358 lines
8.9 KiB
C
358 lines
8.9 KiB
C
/* Copyright (C) 2020 C. McEnroe <june@causal.agency>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
* Additional permission under GNU GPL version 3 section 7:
|
|
*
|
|
* If you modify this Program, or any covered work, by linking or
|
|
* combining it with OpenSSL (or a modified version of that library),
|
|
* containing parts covered by the terms of the OpenSSL License and the
|
|
* original SSLeay license, the licensors of this Program grant you
|
|
* additional permission to convey the resulting work. Corresponding
|
|
* Source for a non-source form of such a combination shall include the
|
|
* source code for the parts of OpenSSL used as well as that of the
|
|
* covered work.
|
|
*/
|
|
|
|
#define _XOPEN_SOURCE_EXTENDED
|
|
|
|
#include <assert.h>
|
|
#include <curses.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <inttypes.h>
|
|
#include <stdarg.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/file.h>
|
|
#include <sysexits.h>
|
|
#include <term.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
|
|
#ifdef __FreeBSD__
|
|
#include <capsicum_helpers.h>
|
|
#endif
|
|
|
|
#include "chat.h"
|
|
|
|
#define BOTTOM (LINES - 1)
|
|
#define RIGHT (COLS - 1)
|
|
#define MAIN_LINES (LINES - StatusLines - InputLines)
|
|
|
|
WINDOW *uiStatus;
|
|
WINDOW *uiMain;
|
|
WINDOW *uiInput;
|
|
|
|
static short colorPairs;
|
|
|
|
static void colorInit(void) {
|
|
start_color();
|
|
use_default_colors();
|
|
if (!COLORS) return;
|
|
for (short pair = 0; pair < 16; ++pair) {
|
|
init_pair(1 + pair, pair % COLORS, -1);
|
|
}
|
|
colorPairs = 17;
|
|
}
|
|
|
|
static attr_t colorAttr(short fg) {
|
|
if (!COLORS) return (fg > 0 ? A_BOLD : A_NORMAL);
|
|
if (fg != COLOR_BLACK && fg % COLORS == COLOR_BLACK) return A_BOLD;
|
|
if (COLORS > 8) return A_NORMAL;
|
|
return (fg / COLORS & 1 ? A_BOLD : A_NORMAL);
|
|
}
|
|
|
|
static short colorPair(short fg, short bg) {
|
|
if (!COLORS) return 0;
|
|
fg %= COLORS;
|
|
bg %= COLORS;
|
|
if (bg == -1 && fg < 16) return 1 + fg;
|
|
for (short pair = 17; pair < colorPairs; ++pair) {
|
|
short f, b;
|
|
pair_content(pair, &f, &b);
|
|
if (f == fg && b == bg) return pair;
|
|
}
|
|
init_pair(colorPairs, fg, bg);
|
|
return colorPairs++;
|
|
}
|
|
|
|
// XXX: Assuming terminals will be fine with these even if they're unsupported,
|
|
// since they're "private" modes.
|
|
static const char *FocusMode[2] = { "\33[?1004l", "\33[?1004h" };
|
|
static const char *PasteMode[2] = { "\33[?2004l", "\33[?2004h" };
|
|
|
|
static void errExit(void) {
|
|
putp(FocusMode[false]);
|
|
putp(PasteMode[false]);
|
|
reset_shell_mode();
|
|
}
|
|
|
|
void uiInit(void) {
|
|
initscr();
|
|
cbreak();
|
|
noecho();
|
|
colorInit();
|
|
atexit(errExit);
|
|
|
|
#ifndef A_ITALIC
|
|
#define A_ITALIC A_BLINK
|
|
// Force ncurses to use individual enter_attr_mode strings:
|
|
set_attributes = NULL;
|
|
enter_blink_mode = enter_italics_mode;
|
|
#endif
|
|
|
|
if (!to_status_line && !strncmp(termname(), "xterm", 5)) {
|
|
to_status_line = "\33]2;";
|
|
from_status_line = "\7";
|
|
}
|
|
|
|
uiStatus = newwin(StatusLines, COLS, 0, 0);
|
|
if (!uiStatus) err(EX_OSERR, "newwin");
|
|
|
|
uiMain = newwin(MAIN_LINES, COLS, StatusLines, 0);
|
|
if (!uiMain) err(EX_OSERR, "newwin");
|
|
|
|
uiInput = newpad(InputLines, InputCols);
|
|
if (!uiInput) err(EX_OSERR, "newpad");
|
|
|
|
windowInit();
|
|
uiShow();
|
|
}
|
|
|
|
static bool hidden = true;
|
|
|
|
char uiTitle[TitleCap];
|
|
static char prevTitle[TitleCap];
|
|
|
|
void uiDraw(void) {
|
|
if (hidden) return;
|
|
wnoutrefresh(uiStatus);
|
|
wnoutrefresh(uiMain);
|
|
int y, x;
|
|
getyx(uiInput, y, x);
|
|
pnoutrefresh(
|
|
uiInput,
|
|
0, (x + 1 > RIGHT ? x + 1 - RIGHT : 0),
|
|
LINES - InputLines, 0,
|
|
BOTTOM, RIGHT
|
|
);
|
|
(void)y;
|
|
doupdate();
|
|
|
|
if (!to_status_line) return;
|
|
if (!strcmp(uiTitle, prevTitle)) return;
|
|
strcpy(prevTitle, uiTitle);
|
|
putp(to_status_line);
|
|
putp(uiTitle);
|
|
putp(from_status_line);
|
|
fflush(stdout);
|
|
}
|
|
|
|
static const short Colors[ColorCap] = {
|
|
[Default] = -1,
|
|
[White] = 8 + COLOR_WHITE,
|
|
[Black] = 0 + COLOR_BLACK,
|
|
[Blue] = 0 + COLOR_BLUE,
|
|
[Green] = 0 + COLOR_GREEN,
|
|
[Red] = 8 + COLOR_RED,
|
|
[Brown] = 0 + COLOR_RED,
|
|
[Magenta] = 0 + COLOR_MAGENTA,
|
|
[Orange] = 0 + COLOR_YELLOW,
|
|
[Yellow] = 8 + COLOR_YELLOW,
|
|
[LightGreen] = 8 + COLOR_GREEN,
|
|
[Cyan] = 0 + COLOR_CYAN,
|
|
[LightCyan] = 8 + COLOR_CYAN,
|
|
[LightBlue] = 8 + COLOR_BLUE,
|
|
[Pink] = 8 + COLOR_MAGENTA,
|
|
[Gray] = 8 + COLOR_BLACK,
|
|
[LightGray] = 0 + COLOR_WHITE,
|
|
52, 94, 100, 58, 22, 29, 23, 24, 17, 54, 53, 89,
|
|
88, 130, 142, 64, 28, 35, 30, 25, 18, 91, 90, 125,
|
|
124, 166, 184, 106, 34, 49, 37, 33, 19, 129, 127, 161,
|
|
196, 208, 226, 154, 46, 86, 51, 75, 21, 171, 201, 198,
|
|
203, 215, 227, 191, 83, 122, 87, 111, 63, 177, 207, 205,
|
|
217, 223, 229, 193, 157, 158, 159, 153, 147, 183, 219, 212,
|
|
16, 233, 235, 237, 239, 241, 244, 247, 250, 254, 231,
|
|
};
|
|
|
|
uint uiAttr(struct Style style) {
|
|
attr_t attr = A_NORMAL;
|
|
if (style.attr & Bold) attr |= A_BOLD;
|
|
if (style.attr & Reverse) attr |= A_REVERSE;
|
|
if (style.attr & Italic) attr |= A_ITALIC;
|
|
if (style.attr & Underline) attr |= A_UNDERLINE;
|
|
return attr | colorAttr(Colors[style.fg]);
|
|
}
|
|
|
|
bool uiSpoilerReveal;
|
|
|
|
short uiPair(struct Style style) {
|
|
if (uiSpoilerReveal && style.fg == style.bg) {
|
|
return colorPair(Colors[Default], Colors[style.bg]);
|
|
}
|
|
return colorPair(Colors[style.fg], Colors[style.bg]);
|
|
}
|
|
|
|
void uiShow(void) {
|
|
if (!hidden) return;
|
|
prevTitle[0] = '\0';
|
|
putp(FocusMode[true]);
|
|
putp(PasteMode[true]);
|
|
fflush(stdout);
|
|
hidden = false;
|
|
windowUnmark();
|
|
}
|
|
|
|
void uiHide(void) {
|
|
if (hidden) return;
|
|
windowMark();
|
|
hidden = true;
|
|
putp(FocusMode[false]);
|
|
putp(PasteMode[false]);
|
|
endwin();
|
|
}
|
|
|
|
struct Util uiNotifyUtil;
|
|
static void notify(uint id, const char *str) {
|
|
if (self.restricted) return;
|
|
if (!uiNotifyUtil.argc) return;
|
|
|
|
char buf[1024];
|
|
styleStrip(buf, sizeof(buf), str);
|
|
|
|
struct Util util = uiNotifyUtil;
|
|
utilPush(&util, idNames[id]);
|
|
utilPush(&util, buf);
|
|
|
|
pid_t pid = fork();
|
|
if (pid < 0) err(EX_OSERR, "fork");
|
|
if (pid) return;
|
|
|
|
setsid();
|
|
close(STDIN_FILENO);
|
|
dup2(utilPipe[1], STDOUT_FILENO);
|
|
dup2(utilPipe[1], STDERR_FILENO);
|
|
execvp(util.argv[0], (char *const *)util.argv);
|
|
warn("%s", util.argv[0]);
|
|
_exit(EX_CONFIG);
|
|
}
|
|
|
|
void uiWrite(uint id, enum Heat heat, const time_t *src, const char *str) {
|
|
bool note = windowWrite(id, heat, src, str);
|
|
if (note) {
|
|
beep();
|
|
notify(id, str);
|
|
}
|
|
}
|
|
|
|
void uiFormat(
|
|
uint id, enum Heat heat, const time_t *time, const char *format, ...
|
|
) {
|
|
char buf[1024];
|
|
va_list ap;
|
|
va_start(ap, format);
|
|
int len = vsnprintf(buf, sizeof(buf), format, ap);
|
|
va_end(ap);
|
|
assert((size_t)len < sizeof(buf));
|
|
uiWrite(id, heat, time, buf);
|
|
}
|
|
|
|
void uiResize(void) {
|
|
wclear(uiMain);
|
|
wresize(uiMain, MAIN_LINES, COLS);
|
|
windowResize();
|
|
}
|
|
|
|
static FILE *saveFile;
|
|
|
|
static const uint64_t Signatures[] = {
|
|
0x6C72696774616301, // no heat, unread, unreadWarm
|
|
0x6C72696774616302, // no self.pos
|
|
0x6C72696774616303, // no buffer line heat
|
|
0x6C72696774616304, // no mute
|
|
0x6C72696774616305, // no URLs
|
|
0x6C72696774616306, // no thresh
|
|
0x6C72696774616307, // no window time
|
|
0x6C72696774616308, // no input
|
|
0x6C72696774616309,
|
|
};
|
|
|
|
static size_t signatureVersion(uint64_t signature) {
|
|
for (size_t i = 0; i < ARRAY_LEN(Signatures); ++i) {
|
|
if (signature == Signatures[i]) return i;
|
|
}
|
|
errx(EX_DATAERR, "unknown file signature %" PRIX64, signature);
|
|
}
|
|
|
|
static int writeUint64(FILE *file, uint64_t u) {
|
|
return (fwrite(&u, sizeof(u), 1, file) ? 0 : -1);
|
|
}
|
|
|
|
int uiSave(void) {
|
|
return 0
|
|
|| ftruncate(fileno(saveFile), 0)
|
|
|| writeUint64(saveFile, Signatures[8])
|
|
|| writeUint64(saveFile, self.pos)
|
|
|| windowSave(saveFile)
|
|
|| inputSave(saveFile)
|
|
|| urlSave(saveFile)
|
|
|| fclose(saveFile);
|
|
}
|
|
|
|
static uint64_t readUint64(FILE *file) {
|
|
uint64_t u;
|
|
fread(&u, sizeof(u), 1, file);
|
|
if (ferror(file)) err(EX_IOERR, "fread");
|
|
if (feof(file)) errx(EX_DATAERR, "unexpected eof");
|
|
return u;
|
|
}
|
|
|
|
void uiLoad(const char *name) {
|
|
int error;
|
|
saveFile = dataOpen(name, "a+e");
|
|
if (!saveFile) exit(EX_CANTCREAT);
|
|
rewind(saveFile);
|
|
|
|
#ifdef __FreeBSD__
|
|
cap_rights_t rights;
|
|
cap_rights_init(&rights, CAP_READ, CAP_WRITE, CAP_FLOCK, CAP_FTRUNCATE);
|
|
error = caph_rights_limit(fileno(saveFile), &rights);
|
|
if (error) err(EX_OSERR, "cap_rights_limit");
|
|
#endif
|
|
|
|
error = flock(fileno(saveFile), LOCK_EX | LOCK_NB);
|
|
if (error && errno == EWOULDBLOCK) {
|
|
errx(EX_CANTCREAT, "%s: save file in use", name);
|
|
}
|
|
|
|
time_t signature;
|
|
fread(&signature, sizeof(signature), 1, saveFile);
|
|
if (ferror(saveFile)) err(EX_IOERR, "fread");
|
|
if (feof(saveFile)) {
|
|
return;
|
|
}
|
|
size_t version = signatureVersion(signature);
|
|
|
|
if (version > 1) {
|
|
self.pos = readUint64(saveFile);
|
|
}
|
|
windowLoad(saveFile, version);
|
|
inputLoad(saveFile, version);
|
|
urlLoad(saveFile, version);
|
|
}
|