mirror of
https://github.com/tstack/lnav
synced 2024-11-15 18:13:10 +00:00
1154 lines
39 KiB
C++
1154 lines
39 KiB
C++
/**
|
||
* Copyright (c) 2007-2012, Timothy Stack
|
||
*
|
||
* All rights reserved.
|
||
*
|
||
* Redistribution and use in source and binary forms, with or without
|
||
* modification, are permitted provided that the following conditions are met:
|
||
*
|
||
* * Redistributions of source code must retain the above copyright notice, this
|
||
* list of conditions and the following disclaimer.
|
||
* * 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.
|
||
* * Neither the name of Timothy Stack nor the names of its contributors
|
||
* may be used to endorse or promote products derived from this software
|
||
* without specific prior written permission.
|
||
*
|
||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||
*/
|
||
|
||
#include <assert.h>
|
||
#include <errno.h>
|
||
#include <fcntl.h>
|
||
#include <signal.h>
|
||
#include <stdint.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <sys/ioctl.h>
|
||
#include <sys/time.h>
|
||
#include <sys/types.h>
|
||
#include <sys/wait.h>
|
||
#include <termios.h>
|
||
#include <unistd.h>
|
||
|
||
#include "config.h"
|
||
|
||
#if defined HAVE_NCURSESW_CURSES_H
|
||
# include <ncursesw/curses.h>
|
||
#elif defined HAVE_NCURSESW_H
|
||
# include <ncursesw.h>
|
||
#elif defined HAVE_NCURSES_CURSES_H
|
||
# include <ncurses/curses.h>
|
||
#elif defined HAVE_NCURSES_H
|
||
# include <ncurses.h>
|
||
#elif defined HAVE_CURSES_H
|
||
# include <curses.h>
|
||
#else
|
||
# error "SysV or X/Open-compatible Curses header file required"
|
||
#endif
|
||
|
||
#ifdef HAVE_PTY_H
|
||
# include <pty.h>
|
||
#endif
|
||
|
||
#ifdef HAVE_UTIL_H
|
||
# include <util.h>
|
||
#endif
|
||
|
||
#ifdef HAVE_LIBUTIL_H
|
||
# include <libutil.h>
|
||
#endif
|
||
|
||
#include <algorithm>
|
||
#include <map>
|
||
#include <queue>
|
||
#include <sstream>
|
||
#include <string>
|
||
#include <utility>
|
||
|
||
#include "base/auto_fd.hh"
|
||
#include "base/auto_mem.hh"
|
||
#include "base/string_util.hh"
|
||
#include "fmt/format.h"
|
||
#include "ghc/filesystem.hpp"
|
||
#include "styling.hh"
|
||
#include "termios_guard.hh"
|
||
#include "ww898/cp_utf8.hpp"
|
||
|
||
using namespace std;
|
||
|
||
/**
|
||
* An RAII class for opening a PTY and forking a child process.
|
||
*/
|
||
class child_term {
|
||
public:
|
||
class error : public std::exception {
|
||
public:
|
||
error(int err) : e_err(err){};
|
||
|
||
int e_err;
|
||
};
|
||
|
||
explicit child_term(bool passin)
|
||
{
|
||
struct winsize ws;
|
||
auto_fd slave;
|
||
|
||
memset(&ws, 0, sizeof(ws));
|
||
|
||
if (isatty(STDIN_FILENO)
|
||
&& tcgetattr(STDIN_FILENO, &this->ct_termios) == -1) {
|
||
throw error(errno);
|
||
}
|
||
|
||
if (isatty(STDOUT_FILENO)
|
||
&& ioctl(STDOUT_FILENO, TIOCGWINSZ, &this->ct_winsize) == -1)
|
||
{
|
||
throw error(errno);
|
||
}
|
||
|
||
ws.ws_col = 80;
|
||
ws.ws_row = 24;
|
||
|
||
if (openpty(this->ct_master.out(), slave.out(), nullptr, nullptr, &ws)
|
||
< 0) {
|
||
throw error(errno);
|
||
}
|
||
|
||
if ((this->ct_child = fork()) == -1)
|
||
throw error(errno);
|
||
|
||
if (this->ct_child == 0) {
|
||
this->ct_master.reset();
|
||
|
||
if (!passin) {
|
||
dup2(slave, STDIN_FILENO);
|
||
}
|
||
dup2(slave, STDOUT_FILENO);
|
||
|
||
setenv("TERM", "xterm-color", 1);
|
||
} else {
|
||
slave.reset();
|
||
}
|
||
};
|
||
|
||
virtual ~child_term()
|
||
{
|
||
(void) this->wait_for_child();
|
||
|
||
if (isatty(STDIN_FILENO)
|
||
&& tcsetattr(STDIN_FILENO, TCSANOW, &this->ct_termios) == -1)
|
||
{
|
||
perror("tcsetattr");
|
||
}
|
||
if (isatty(STDOUT_FILENO)
|
||
&& ioctl(STDOUT_FILENO, TIOCSWINSZ, &this->ct_winsize) == -1)
|
||
{
|
||
perror("ioctl");
|
||
}
|
||
};
|
||
|
||
int wait_for_child()
|
||
{
|
||
int retval = -1;
|
||
|
||
if (this->ct_child > 0) {
|
||
kill(this->ct_child, SIGTERM);
|
||
this->ct_child = -1;
|
||
|
||
while (wait(&retval) < 0 && (errno == EINTR))
|
||
;
|
||
}
|
||
|
||
return retval;
|
||
};
|
||
|
||
bool is_child() const
|
||
{
|
||
return this->ct_child == 0;
|
||
};
|
||
|
||
pid_t get_child_pid() const
|
||
{
|
||
return this->ct_child;
|
||
};
|
||
|
||
int get_fd() const
|
||
{
|
||
return this->ct_master;
|
||
};
|
||
|
||
protected:
|
||
pid_t ct_child;
|
||
auto_fd ct_master;
|
||
struct termios ct_termios;
|
||
struct winsize ct_winsize;
|
||
};
|
||
|
||
/**
|
||
* @param fd The file descriptor to switch to raw mode.
|
||
* @return Zero on success, -1 on error.
|
||
*/
|
||
static int
|
||
tty_raw(int fd)
|
||
{
|
||
struct termios attr[1];
|
||
|
||
assert(fd >= 0);
|
||
|
||
if (tcgetattr(fd, attr) == -1)
|
||
return -1;
|
||
|
||
attr->c_lflag &= ~(ECHO | ICANON | IEXTEN);
|
||
attr->c_iflag &= ~(ICRNL | INPCK | ISTRIP | IXON);
|
||
attr->c_cflag &= ~(CSIZE | PARENB);
|
||
attr->c_cflag |= (CS8);
|
||
attr->c_oflag &= ~(OPOST);
|
||
attr->c_cc[VMIN] = 1;
|
||
attr->c_cc[VTIME] = 0;
|
||
|
||
return tcsetattr(fd, TCSANOW, attr);
|
||
}
|
||
|
||
static void
|
||
dump_memory(FILE* dst, const char* src, int len)
|
||
{
|
||
int lpc;
|
||
|
||
for (lpc = 0; lpc < len; lpc++) {
|
||
fprintf(dst, "%02x", src[lpc] & 0xff);
|
||
}
|
||
}
|
||
|
||
static std::vector<char>
|
||
hex2bits(const char* src)
|
||
{
|
||
std::vector<char> retval;
|
||
|
||
for (size_t lpc = 0; src[lpc] && isdigit(src[lpc]); lpc += 2) {
|
||
int val;
|
||
|
||
sscanf(&src[lpc], "%2x", &val);
|
||
retval.push_back((char) val);
|
||
}
|
||
|
||
return retval;
|
||
}
|
||
|
||
static const char*
|
||
tstamp()
|
||
{
|
||
static char buf[64];
|
||
|
||
struct timeval tv;
|
||
gettimeofday(&tv, nullptr);
|
||
strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S.", localtime(&tv.tv_sec));
|
||
auto dlen = strlen(buf);
|
||
snprintf(&buf[dlen], sizeof(buf) - dlen, "%.06d", tv.tv_usec);
|
||
|
||
return buf;
|
||
}
|
||
|
||
typedef enum {
|
||
CT_WRITE,
|
||
} command_type_t;
|
||
|
||
struct command {
|
||
command_type_t c_type;
|
||
vector<char> c_arg;
|
||
};
|
||
|
||
static struct {
|
||
const char* sd_program_name{nullptr};
|
||
sig_atomic_t sd_looping{true};
|
||
|
||
pid_t sd_child_pid{-1};
|
||
|
||
ghc::filesystem::path sd_actual_name;
|
||
auto_mem<FILE> sd_from_child{fclose};
|
||
ghc::filesystem::path sd_expected_name;
|
||
|
||
deque<struct command> sd_replay;
|
||
} scripty_data;
|
||
|
||
static const std::map<std::string, std::string> CSI_TO_DESC = {
|
||
{")0", "Use alt charset"},
|
||
|
||
{"[?1000l", "Don't Send Mouse X & Y"},
|
||
{"[?1002l", "Don’t Use Cell Motion Mouse Tracking"},
|
||
{"[?1006l", "Don't ..."},
|
||
{"[?1h", "Application cursor keys"},
|
||
{"[?1l", "Normal cursor keys"},
|
||
{"[?47h", "Use alternate screen buffer"},
|
||
{"[?47l", "Use normal screen buffer"},
|
||
{"[2h", "Set Keyboard Action mode"},
|
||
{"[4h", "Set Replace mode"},
|
||
{"[12h", "Set Send/Receive mode"},
|
||
{"[20h", "Set Normal Linefeed mode"},
|
||
{"[2l", "Reset Keyboard Action mode"},
|
||
{"[4l", "Reset Replace mode"},
|
||
{"[12l", "Reset Send/Receive mode"},
|
||
{"[20l", "Reset Normal Linefeed mode"},
|
||
{"[2J", "Erase all"},
|
||
};
|
||
|
||
struct term_machine {
|
||
enum class state {
|
||
NORMAL,
|
||
ESCAPE_START,
|
||
ESCAPE_FIXED_LENGTH,
|
||
ESCAPE_VARIABLE_LENGTH,
|
||
ESCAPE_OSC,
|
||
};
|
||
|
||
struct term_attr {
|
||
term_attr(size_t pos, const std::string& desc)
|
||
: ta_pos(pos), ta_end(pos), ta_desc({desc})
|
||
{
|
||
}
|
||
|
||
term_attr(size_t pos, size_t end, const std::string& desc)
|
||
: ta_pos(pos), ta_end(end), ta_desc({desc})
|
||
{
|
||
}
|
||
|
||
size_t ta_pos;
|
||
size_t ta_end;
|
||
std::vector<std::string> ta_desc;
|
||
};
|
||
|
||
term_machine(child_term& ct) : tm_child_term(ct)
|
||
{
|
||
this->clear();
|
||
}
|
||
|
||
~term_machine()
|
||
{
|
||
this->flush_line();
|
||
}
|
||
|
||
void clear()
|
||
{
|
||
std::fill(begin(this->tm_line), end(this->tm_line), ' ');
|
||
this->tm_line_attrs.clear();
|
||
this->tm_new_data = false;
|
||
}
|
||
|
||
void add_line_attr(const std::string& desc)
|
||
{
|
||
if (!this->tm_line_attrs.empty()
|
||
&& this->tm_line_attrs.back().ta_pos == this->tm_cursor_x)
|
||
{
|
||
this->tm_line_attrs.back().ta_desc.emplace_back(desc);
|
||
} else {
|
||
this->tm_line_attrs.emplace_back(this->tm_cursor_x, desc);
|
||
}
|
||
}
|
||
|
||
void write_char(char ch)
|
||
{
|
||
if (isprint(ch)) {
|
||
require(ch);
|
||
|
||
this->tm_new_data = true;
|
||
this->tm_line[this->tm_cursor_x++] = (unsigned char) ch;
|
||
} else {
|
||
switch (ch) {
|
||
case '\a':
|
||
this->flush_line();
|
||
fprintf(scripty_data.sd_from_child, "CTRL bell\n");
|
||
break;
|
||
case '\x08':
|
||
this->add_line_attr("backspace");
|
||
if (this->tm_cursor_x > 0) {
|
||
this->tm_cursor_x -= 1;
|
||
}
|
||
break;
|
||
case '\r':
|
||
this->add_line_attr("carriage-return");
|
||
this->tm_cursor_x = 0;
|
||
break;
|
||
case '\n':
|
||
this->flush_line();
|
||
if (this->tm_cursor_y >= 0) {
|
||
this->tm_cursor_y += 1;
|
||
}
|
||
this->tm_cursor_x = 0;
|
||
break;
|
||
case '\x0e':
|
||
this->tm_shift_start = this->tm_cursor_x;
|
||
break;
|
||
case '\x0f':
|
||
if (this->tm_shift_start != this->tm_cursor_x) {
|
||
this->tm_line_attrs.emplace_back(
|
||
this->tm_shift_start, this->tm_cursor_x, "alt");
|
||
}
|
||
break;
|
||
default:
|
||
require(ch);
|
||
this->tm_new_data = true;
|
||
this->tm_line[this->tm_cursor_x++] = (unsigned char) ch;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void flush_line()
|
||
{
|
||
if (std::exchange(this->tm_waiting_on_input, false)
|
||
&& !this->tm_user_input.empty())
|
||
{
|
||
fprintf(stderr, "%s:flush keys\n", tstamp());
|
||
fprintf(scripty_data.sd_from_child, "K ");
|
||
dump_memory(
|
||
scripty_data.sd_from_child, this->tm_user_input.data(), 1);
|
||
fprintf(scripty_data.sd_from_child, "\n");
|
||
this->tm_user_input.erase(this->tm_user_input.begin());
|
||
}
|
||
if (this->tm_new_data || !this->tm_line_attrs.empty()) {
|
||
// fprintf(scripty_data.sd_from_child, "flush %d\n",
|
||
// this->tm_flush_count);
|
||
fprintf(stderr, "%s:flush %zu\n", tstamp(), this->tm_flush_count++);
|
||
fprintf(
|
||
scripty_data.sd_from_child, "S % 3d \u250B", this->tm_cursor_y);
|
||
for (auto uch : this->tm_line) {
|
||
ww898::utf::utf8::write(uch, [](auto ch) {
|
||
fputc(ch, scripty_data.sd_from_child);
|
||
});
|
||
}
|
||
fprintf(scripty_data.sd_from_child, "\u250B\n");
|
||
for (size_t lpc = 0; lpc < this->tm_line_attrs.size(); lpc++) {
|
||
const auto& ta = this->tm_line_attrs[lpc];
|
||
auto full_desc = fmt::format(
|
||
"{}",
|
||
fmt::join(ta.ta_desc.begin(), ta.ta_desc.end(), ", "));
|
||
int line_len;
|
||
|
||
if (ta.ta_pos == ta.ta_end) {
|
||
line_len = fprintf(
|
||
scripty_data.sd_from_child,
|
||
"A %s%s %s",
|
||
repeat("\u00B7", ta.ta_pos).c_str(),
|
||
((lpc + 1 < this->tm_line_attrs.size())
|
||
&& (ta.ta_pos == this->tm_line_attrs[lpc + 1].ta_pos))
|
||
? "\u251C"
|
||
: "\u2514",
|
||
full_desc.c_str());
|
||
line_len -= 2 + ta.ta_pos;
|
||
} else {
|
||
line_len = fprintf(
|
||
scripty_data.sd_from_child,
|
||
"A %s%s%s\u251b %s",
|
||
std::string(ta.ta_pos, ' ').c_str(),
|
||
((lpc + 1 < this->tm_line_attrs.size())
|
||
&& (ta.ta_pos == this->tm_line_attrs[lpc + 1].ta_pos))
|
||
? "\u2518"
|
||
: "\u2514",
|
||
std::string(ta.ta_end - ta.ta_pos - 1, '-').c_str(),
|
||
full_desc.c_str());
|
||
line_len -= 4;
|
||
}
|
||
for (size_t lpc2 = lpc + 1; lpc2 < this->tm_line_attrs.size();
|
||
lpc2++) {
|
||
auto bar_pos = 7 + this->tm_line_attrs[lpc2].ta_pos;
|
||
|
||
if (bar_pos < line_len) {
|
||
continue;
|
||
}
|
||
line_len += fprintf(
|
||
scripty_data.sd_from_child,
|
||
"%s\u2502",
|
||
std::string(bar_pos - line_len, ' ').c_str());
|
||
line_len -= 2;
|
||
}
|
||
fprintf(scripty_data.sd_from_child, "\n");
|
||
}
|
||
this->clear();
|
||
}
|
||
fflush(scripty_data.sd_from_child);
|
||
}
|
||
|
||
std::vector<int> get_m_params()
|
||
{
|
||
std::vector<int> retval;
|
||
size_t index = 1;
|
||
|
||
while (index < this->tm_escape_buffer.size()) {
|
||
int val, last;
|
||
|
||
if (sscanf(&this->tm_escape_buffer[index], "%d%n", &val, &last)
|
||
== 1) {
|
||
retval.push_back(val);
|
||
index += last;
|
||
if (this->tm_escape_buffer[index] != ';') {
|
||
break;
|
||
}
|
||
index += 1;
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
|
||
return retval;
|
||
}
|
||
|
||
void new_user_input(char ch)
|
||
{
|
||
this->tm_user_input.push_back(ch);
|
||
}
|
||
|
||
void new_input(char ch)
|
||
{
|
||
if (this->tm_unicode_remaining > 0) {
|
||
this->tm_unicode_buffer.push_back(ch);
|
||
this->tm_unicode_remaining -= 1;
|
||
if (this->tm_unicode_remaining == 0) {
|
||
this->tm_new_data = true;
|
||
this->tm_line[this->tm_cursor_x++]
|
||
= ww898::utf::utf8::read([this]() {
|
||
auto retval = this->tm_unicode_buffer.front();
|
||
|
||
this->tm_unicode_buffer.pop_front();
|
||
return retval;
|
||
});
|
||
}
|
||
return;
|
||
} else {
|
||
auto utfsize = ww898::utf::utf8::char_size(
|
||
[ch]() { return std::make_pair(ch, 16); });
|
||
|
||
if (utfsize.unwrap() > 1) {
|
||
this->tm_unicode_remaining = utfsize.unwrap() - 1;
|
||
this->tm_unicode_buffer.push_back(ch);
|
||
return;
|
||
}
|
||
}
|
||
|
||
switch (this->tm_state) {
|
||
case state::NORMAL: {
|
||
switch (ch) {
|
||
case '\x1b': {
|
||
this->tm_escape_buffer.clear();
|
||
this->tm_state = state::ESCAPE_START;
|
||
break;
|
||
}
|
||
default: {
|
||
this->write_char(ch);
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case state::ESCAPE_START: {
|
||
switch (ch) {
|
||
case '[': {
|
||
this->tm_escape_buffer.push_back(ch);
|
||
this->tm_state = state::ESCAPE_VARIABLE_LENGTH;
|
||
break;
|
||
}
|
||
case ']': {
|
||
this->tm_escape_buffer.push_back(ch);
|
||
this->tm_state = state::ESCAPE_OSC;
|
||
break;
|
||
}
|
||
case '(':
|
||
case ')':
|
||
case '*':
|
||
case '+': {
|
||
this->tm_state = state::ESCAPE_FIXED_LENGTH;
|
||
this->tm_escape_buffer.push_back(ch);
|
||
this->tm_escape_expected_size = 2;
|
||
break;
|
||
}
|
||
default: {
|
||
this->flush_line();
|
||
switch (ch) {
|
||
case '7':
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CTRL save cursor\n");
|
||
break;
|
||
case '8':
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CTRL restore cursor\n");
|
||
break;
|
||
case '>':
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CTRL Normal keypad\n");
|
||
break;
|
||
default: {
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CTRL %c\n",
|
||
ch);
|
||
break;
|
||
}
|
||
}
|
||
this->tm_state = state::NORMAL;
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case state::ESCAPE_FIXED_LENGTH: {
|
||
this->tm_escape_buffer.push_back(ch);
|
||
if (this->tm_escape_buffer.size()
|
||
== this->tm_escape_expected_size) {
|
||
auto iter = CSI_TO_DESC.find(
|
||
std::string(this->tm_escape_buffer.data(),
|
||
this->tm_escape_buffer.size()));
|
||
this->flush_line();
|
||
if (iter == CSI_TO_DESC.end()) {
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CTRL %.*s\n",
|
||
(int) this->tm_escape_buffer.size(),
|
||
this->tm_escape_buffer.data());
|
||
} else {
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CTRL %s\n",
|
||
iter->second.c_str());
|
||
}
|
||
this->tm_state = state::NORMAL;
|
||
}
|
||
break;
|
||
}
|
||
case state::ESCAPE_VARIABLE_LENGTH: {
|
||
this->tm_escape_buffer.push_back(ch);
|
||
if (isalpha(ch)) {
|
||
auto iter = CSI_TO_DESC.find(
|
||
std::string(this->tm_escape_buffer.data(),
|
||
this->tm_escape_buffer.size()));
|
||
if (iter == CSI_TO_DESC.end()) {
|
||
this->tm_escape_buffer.push_back('\0');
|
||
switch (ch) {
|
||
case 'A': {
|
||
auto amount = this->get_m_params();
|
||
int count = 1;
|
||
|
||
if (!amount.empty()) {
|
||
count = amount[0];
|
||
}
|
||
this->flush_line();
|
||
this->tm_cursor_y -= count;
|
||
if (this->tm_cursor_y < 0) {
|
||
this->tm_cursor_y = 0;
|
||
}
|
||
break;
|
||
}
|
||
case 'B': {
|
||
auto amount = this->get_m_params();
|
||
int count = 1;
|
||
|
||
if (!amount.empty()) {
|
||
count = amount[0];
|
||
}
|
||
this->flush_line();
|
||
this->tm_cursor_y += count;
|
||
break;
|
||
}
|
||
case 'C': {
|
||
auto amount = this->get_m_params();
|
||
int count = 1;
|
||
|
||
if (!amount.empty()) {
|
||
count = amount[0];
|
||
}
|
||
this->tm_cursor_x += count;
|
||
break;
|
||
}
|
||
case 'J': {
|
||
auto param = this->get_m_params();
|
||
|
||
this->flush_line();
|
||
|
||
auto region = param.empty() ? 0 : param[0];
|
||
switch (region) {
|
||
case 0:
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CSI Erase Below\n");
|
||
break;
|
||
case 1:
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CSI Erase Above\n");
|
||
break;
|
||
case 2:
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CSI Erase All\n");
|
||
break;
|
||
case 3:
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CSI Erase Saved Lines\n");
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
case 'K': {
|
||
auto param = this->get_m_params();
|
||
|
||
this->flush_line();
|
||
|
||
auto region = param.empty() ? 0 : param[0];
|
||
switch (region) {
|
||
case 0:
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CSI Erase to Right\n");
|
||
break;
|
||
case 1:
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CSI Erase to Left\n");
|
||
break;
|
||
case 2:
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CSI Erase All\n");
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
case 'H': {
|
||
auto coords = this->get_m_params();
|
||
|
||
if (coords.empty()) {
|
||
coords = {1, 1};
|
||
}
|
||
this->flush_line();
|
||
this->tm_cursor_y = coords[0];
|
||
this->tm_cursor_x = coords[1] - 1;
|
||
break;
|
||
}
|
||
case 'r': {
|
||
auto region = this->get_m_params();
|
||
|
||
this->flush_line();
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CSI set scrolling region %d-%d\n",
|
||
region[0],
|
||
region[1]);
|
||
break;
|
||
}
|
||
case 'm': {
|
||
auto attrs = this->get_m_params();
|
||
|
||
if (attrs.empty()) {
|
||
this->add_line_attr("normal");
|
||
} else if ((30 <= attrs[0]) && (attrs[0] <= 37))
|
||
{
|
||
auto xt = xterm_colors();
|
||
|
||
this->add_line_attr(fmt::format(
|
||
"fg({})",
|
||
xt->tc_palette[attrs[0] - 30].xc_hex));
|
||
} else if (attrs[0] == 38) {
|
||
auto xt = xterm_colors();
|
||
|
||
require(attrs[1] == 5);
|
||
this->add_line_attr(fmt::format(
|
||
"fg({})",
|
||
xt->tc_palette[attrs[2]].xc_hex));
|
||
} else if ((40 <= attrs[0]) && (attrs[0] <= 47))
|
||
{
|
||
auto xt = xterm_colors();
|
||
|
||
this->add_line_attr(fmt::format(
|
||
"bg({})",
|
||
xt->tc_palette[attrs[0] - 40].xc_hex));
|
||
} else if (attrs[0] == 48) {
|
||
auto xt = xterm_colors();
|
||
|
||
require(attrs[1] == 5);
|
||
this->add_line_attr(fmt::format(
|
||
"bg({})",
|
||
xt->tc_palette[attrs[2]].xc_hex));
|
||
} else {
|
||
switch (attrs[0]) {
|
||
case 1:
|
||
this->add_line_attr("bold");
|
||
break;
|
||
case 4:
|
||
this->add_line_attr("underline");
|
||
break;
|
||
case 5:
|
||
this->add_line_attr("blink");
|
||
break;
|
||
case 7:
|
||
this->add_line_attr("inverse");
|
||
break;
|
||
default:
|
||
this->add_line_attr(
|
||
this->tm_escape_buffer.data());
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
default:
|
||
fprintf(stderr, "%s:missed %c\n", tstamp(), ch);
|
||
this->add_line_attr(
|
||
this->tm_escape_buffer.data());
|
||
break;
|
||
}
|
||
} else {
|
||
this->flush_line();
|
||
fprintf(scripty_data.sd_from_child,
|
||
"CSI %s\n",
|
||
iter->second.c_str());
|
||
}
|
||
this->tm_state = state::NORMAL;
|
||
} else {
|
||
}
|
||
break;
|
||
}
|
||
case state::ESCAPE_OSC: {
|
||
if (ch == '\a') {
|
||
this->tm_escape_buffer.push_back('\0');
|
||
|
||
auto num = this->get_m_params();
|
||
auto semi_index
|
||
= strchr(this->tm_escape_buffer.data(), ';');
|
||
|
||
switch (num[0]) {
|
||
case 0: {
|
||
this->flush_line();
|
||
fprintf(scripty_data.sd_from_child,
|
||
"OSC Set window title: %s\n",
|
||
semi_index + 1);
|
||
break;
|
||
}
|
||
case 999: {
|
||
this->flush_line();
|
||
this->tm_waiting_on_input = true;
|
||
if (!scripty_data.sd_replay.empty()) {
|
||
const auto& cmd
|
||
= scripty_data.sd_replay.front();
|
||
|
||
this->tm_user_input = cmd.c_arg;
|
||
write(this->tm_child_term.get_fd(),
|
||
this->tm_user_input.data(),
|
||
this->tm_user_input.size());
|
||
|
||
scripty_data.sd_replay.pop_front();
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
this->tm_state = state::NORMAL;
|
||
} else {
|
||
this->tm_escape_buffer.push_back(ch);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
child_term& tm_child_term;
|
||
bool tm_waiting_on_input{false};
|
||
state tm_state{state::NORMAL};
|
||
std::vector<char> tm_escape_buffer;
|
||
std::deque<uint8_t> tm_unicode_buffer;
|
||
size_t tm_unicode_remaining{0};
|
||
size_t tm_escape_expected_size{0};
|
||
uint32_t tm_line[80];
|
||
bool tm_new_data{false};
|
||
size_t tm_cursor_x{0};
|
||
int tm_cursor_y{-1};
|
||
size_t tm_shift_start{0};
|
||
std::vector<term_attr> tm_line_attrs;
|
||
|
||
std::vector<char> tm_user_input;
|
||
|
||
size_t tm_flush_count{0};
|
||
};
|
||
|
||
static void
|
||
sigchld(int sig)
|
||
{
|
||
}
|
||
|
||
static void
|
||
sigpass(int sig)
|
||
{
|
||
kill(scripty_data.sd_child_pid, sig);
|
||
}
|
||
|
||
static void
|
||
usage()
|
||
{
|
||
const char* usage_msg
|
||
= "usage: %s [-h] [-t to_child] [-f from_child] -- <cmd>\n"
|
||
"\n"
|
||
"Recorder for TTY I/O from a child process."
|
||
"\n"
|
||
"Options:\n"
|
||
" -h Print this message, then exit.\n"
|
||
" -n Do not pass the output to the console.\n"
|
||
" -i Pass stdin to the child process instead of connecting\n"
|
||
" the child to the tty.\n"
|
||
" -a <file> The file where the actual I/O from/to the child "
|
||
"process\n"
|
||
" should be stored.\n"
|
||
" -e <file> The file containing the expected I/O from/to the "
|
||
"child\n"
|
||
" process.\n"
|
||
"\n"
|
||
"Examples:\n"
|
||
" To record a session for playback later:\n"
|
||
" $ scripty -a output.0 -- myCursesApp\n"
|
||
"\n"
|
||
" To replay the recorded session:\n"
|
||
" $ scripty -e input.0 -- myCursesApp\n";
|
||
|
||
fprintf(stderr, usage_msg, scripty_data.sd_program_name);
|
||
}
|
||
|
||
int
|
||
main(int argc, char* argv[])
|
||
{
|
||
int c, fd, retval = EXIT_SUCCESS;
|
||
bool passout = true, passin = false, prompt = false;
|
||
auto_mem<FILE> file(fclose);
|
||
|
||
scripty_data.sd_program_name = argv[0];
|
||
scripty_data.sd_looping = true;
|
||
|
||
while ((c = getopt(argc, argv, "ha:e:nip")) != -1) {
|
||
switch (c) {
|
||
case 'h':
|
||
usage();
|
||
exit(retval);
|
||
break;
|
||
case 'a':
|
||
scripty_data.sd_actual_name = optarg;
|
||
break;
|
||
case 'e':
|
||
scripty_data.sd_expected_name = optarg;
|
||
if ((file = fopen(optarg, "r")) == nullptr) {
|
||
fprintf(
|
||
stderr, "%s:error: cannot open %s\n", tstamp(), optarg);
|
||
retval = EXIT_FAILURE;
|
||
} else {
|
||
char line[32 * 1024];
|
||
|
||
while (fgets(line, sizeof(line), file)) {
|
||
if (line[0] == 'K') {
|
||
struct command cmd;
|
||
|
||
cmd.c_type = CT_WRITE;
|
||
cmd.c_arg = hex2bits(&line[2]);
|
||
scripty_data.sd_replay.push_back(cmd);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case 'n':
|
||
passout = false;
|
||
break;
|
||
case 'i':
|
||
passin = true;
|
||
break;
|
||
case 'p':
|
||
prompt = true;
|
||
break;
|
||
default:
|
||
fprintf(stderr, "%s:error: unknown flag -- %c\n", tstamp(), c);
|
||
retval = EXIT_FAILURE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
argc -= optind;
|
||
argv += optind;
|
||
|
||
if (!scripty_data.sd_expected_name.empty()
|
||
&& scripty_data.sd_actual_name.empty())
|
||
{
|
||
scripty_data.sd_actual_name = scripty_data.sd_expected_name.filename();
|
||
scripty_data.sd_actual_name += ".tmp";
|
||
}
|
||
|
||
if (!scripty_data.sd_actual_name.empty()) {
|
||
if ((scripty_data.sd_from_child
|
||
= fopen(scripty_data.sd_actual_name.c_str(), "w"))
|
||
== nullptr)
|
||
{
|
||
fprintf(stderr,
|
||
"error: unable to open %s -- %s\n",
|
||
scripty_data.sd_actual_name.c_str(),
|
||
strerror(errno));
|
||
retval = EXIT_FAILURE;
|
||
}
|
||
}
|
||
|
||
if (scripty_data.sd_from_child != nullptr) {
|
||
fcntl(fileno(scripty_data.sd_from_child), F_SETFD, 1);
|
||
}
|
||
|
||
if (retval != EXIT_FAILURE) {
|
||
guard_termios gt(STDOUT_FILENO);
|
||
fd = open("/tmp/scripty.err", O_WRONLY | O_CREAT | O_APPEND, 0666);
|
||
dup2(fd, STDERR_FILENO);
|
||
close(fd);
|
||
fprintf(stderr, "%s:startup\n", tstamp());
|
||
|
||
child_term ct(passin);
|
||
|
||
if (ct.is_child()) {
|
||
execvp(argv[0], argv);
|
||
perror("execvp");
|
||
exit(-1);
|
||
} else {
|
||
int maxfd;
|
||
struct timeval last, now;
|
||
fd_set read_fds;
|
||
term_machine tm(ct);
|
||
size_t last_replay_size = scripty_data.sd_replay.size();
|
||
|
||
scripty_data.sd_child_pid = ct.get_child_pid();
|
||
signal(SIGINT, sigpass);
|
||
signal(SIGTERM, sigpass);
|
||
|
||
signal(SIGCHLD, sigchld);
|
||
|
||
gettimeofday(&now, nullptr);
|
||
last = now;
|
||
|
||
FD_ZERO(&read_fds);
|
||
FD_SET(STDIN_FILENO, &read_fds);
|
||
FD_SET(ct.get_fd(), &read_fds);
|
||
|
||
fprintf(stderr, "%s:goin in the loop\n", tstamp());
|
||
|
||
tty_raw(STDIN_FILENO);
|
||
|
||
maxfd = max(STDIN_FILENO, ct.get_fd());
|
||
while (scripty_data.sd_looping) {
|
||
fd_set ready_rfds = read_fds;
|
||
struct timeval diff, to;
|
||
int rc;
|
||
|
||
to.tv_sec = 0;
|
||
to.tv_usec = 10000;
|
||
rc = select(maxfd + 1, &ready_rfds, nullptr, nullptr, &to);
|
||
gettimeofday(&now, nullptr);
|
||
timersub(&now, &last, &diff);
|
||
if (diff.tv_sec > 10) {
|
||
fprintf(stderr, "%s:replay timed out!\n", tstamp());
|
||
scripty_data.sd_looping = false;
|
||
kill(ct.get_child_pid(), SIGKILL);
|
||
retval = EXIT_FAILURE;
|
||
break;
|
||
}
|
||
if (rc == 0) {
|
||
} else if (rc < 0) {
|
||
switch (errno) {
|
||
case EINTR:
|
||
break;
|
||
default:
|
||
fprintf(stderr,
|
||
"%s:select %s\n",
|
||
tstamp(),
|
||
strerror(errno));
|
||
kill(ct.get_child_pid(), SIGKILL);
|
||
scripty_data.sd_looping = false;
|
||
break;
|
||
}
|
||
} else {
|
||
char buffer[1024];
|
||
|
||
fprintf(stderr, "%s:fds ready %d\n", tstamp(), rc);
|
||
if (FD_ISSET(STDIN_FILENO, &ready_rfds)) {
|
||
rc = read(STDIN_FILENO, buffer, sizeof(buffer));
|
||
if (rc < 0) {
|
||
scripty_data.sd_looping = false;
|
||
} else if (rc == 0) {
|
||
FD_CLR(STDIN_FILENO, &read_fds);
|
||
} else {
|
||
log_perror(write(ct.get_fd(), buffer, rc));
|
||
|
||
for (ssize_t lpc = 0; lpc < rc; lpc++) {
|
||
fprintf(stderr,
|
||
"%s:to-child %02x\n",
|
||
tstamp(),
|
||
buffer[lpc] & 0xff);
|
||
tm.new_user_input(buffer[lpc]);
|
||
}
|
||
}
|
||
last = now;
|
||
}
|
||
if (FD_ISSET(ct.get_fd(), &ready_rfds)) {
|
||
rc = read(ct.get_fd(), buffer, sizeof(buffer));
|
||
fprintf(stderr, "%s:read rc %d\n", tstamp(), rc);
|
||
if (rc <= 0) {
|
||
scripty_data.sd_looping = false;
|
||
} else {
|
||
if (passout) {
|
||
log_perror(write(STDOUT_FILENO, buffer, rc));
|
||
}
|
||
if (scripty_data.sd_from_child != nullptr) {
|
||
for (size_t lpc = 0; lpc < rc; lpc++) {
|
||
#if 0
|
||
fprintf(stderr, "%s:from-child %02x\n",
|
||
tstamp(),
|
||
buffer[lpc] & 0xff);
|
||
#endif
|
||
tm.new_input(buffer[lpc]);
|
||
if (scripty_data.sd_replay.size()
|
||
!= last_replay_size) {
|
||
last = now;
|
||
last_replay_size
|
||
= scripty_data.sd_replay.size();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
retval = ct.wait_for_child() || retval;
|
||
}
|
||
|
||
if (retval == EXIT_SUCCESS && !scripty_data.sd_expected_name.empty()) {
|
||
auto cmd = fmt::format("diff -ua {} {}",
|
||
scripty_data.sd_expected_name.string(),
|
||
scripty_data.sd_actual_name.string());
|
||
auto rc = system(cmd.c_str());
|
||
if (rc != 0) {
|
||
if (prompt) {
|
||
char resp[4];
|
||
|
||
printf("Would you like to update the original file? (y/N) ");
|
||
fflush(stdout);
|
||
log_perror(scanf("%3s", resp));
|
||
if (strcasecmp(resp, "y") == 0) {
|
||
printf("Updating: %s -> %s\n",
|
||
scripty_data.sd_actual_name.c_str(),
|
||
scripty_data.sd_expected_name.c_str());
|
||
|
||
auto options
|
||
= ghc::filesystem::copy_options::overwrite_existing;
|
||
ghc::filesystem::copy_file(scripty_data.sd_actual_name,
|
||
scripty_data.sd_expected_name,
|
||
options);
|
||
} else {
|
||
retval = EXIT_FAILURE;
|
||
}
|
||
} else {
|
||
fprintf(stderr, "%s:error: mismatch\n", tstamp());
|
||
retval = EXIT_FAILURE;
|
||
}
|
||
}
|
||
}
|
||
|
||
return retval;
|
||
}
|