night0721/zsm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
zsm/src/zen/ui.c

697 lines
20 KiB
C
Raw Blame History

#include "config.h"
#include "packet.h"
#include "util.h"
#include "client/ui.h"
#include "client/db.h"
#include "client/user.h"
WINDOW *panel;
WINDOW *users_border;
WINDOW *chat_border;
WINDOW *users_content;
WINDOW *textbox;
WINDOW *chat_content;
ArrayList *users;
ArrayList *marked;
message_t messages[100];
int num_messages = 0;
long current_user = 0;
int current_window = 0;
int sockfd;
/* For tracking cursor position in content */
static int curs_pos = 0;
static char content[MAX_MESSAGE_LENGTH];
void send_message();
/*
* Free and close everything
*/
void deinit()
{
shutdown(sockfd, SHUT_WR);
close(sockfd);
arraylist_free(users);
arraylist_free(marked);
endwin();
}
void signal_handler(int signal)
{
switch (signal) {
case SIGPIPE:
error(0, "SIGPIPE received");
break;
case SIGABRT:
case SIGINT:
case SIGTERM:
deinit();
error(1, "Shutdown signal received");
break;
}
}
/*
* Start ncurses
*/
void ncurses_init()
{
/* check if it is interactive shell */
if (!isatty(STDIN_FILENO)) {
error(1, "No tty detected. zen requires an interactive shell to run");
}
/* initialize screen, don't print special chars,
* make ctrl + c work, don't show cursor
* enable arrow keys */
initscr();
noecho();
cbreak();
keypad(stdscr, TRUE);
/* check terminal has colors */
if (!has_colors()) {
endwin();
error(1, "Color is not supported in your terminal");
} else {
use_default_colors();
start_color();
}
/* colors */
init_pair(1, COLOR_BLACK, -1); /* */
init_pair(2, COLOR_RED, -1); /* */
init_pair(3, COLOR_GREEN, -1); /* active window */
init_pair(4, COLOR_YELLOW, -1); /* */
init_pair(5, COLOR_BLUE, -1); /* inactive window */
init_pair(6, COLOR_MAGENTA, -1); /* */
init_pair(7, COLOR_CYAN, -1); /* Selected user */
init_pair(8, COLOR_WHITE, -1); /* */
}
/*
* Draw windows
*/
void windows_init()
{
int users_width = MAX_NAME / 2;
int chat_width = COLS - (MAX_NAME / 2);
/*------------------------------+
|-----border----||---border----||
|| || ||
|| content || content ||
|| (users) || (chat) ||
|| ||-------------||
|---------------||-textbox-----||
+==========panel===============*/
/* lines, cols, y, x */
panel = newwin(PANEL_HEIGHT, COLS, LINES - PANEL_HEIGHT, 0 );
users_border = newwin(LINES - PANEL_HEIGHT, users_width + 2, 0, 0 );
chat_border = newwin(LINES - PANEL_HEIGHT - TEXTBOX_HEIGHT, chat_width - 2, 0, users_width + 2);
textbox = newwin(TEXTBOX_HEIGHT, chat_width - 2, LINES - PANEL_HEIGHT - TEXTBOX_HEIGHT, users_width + 3);
/* lines, cols, y, x */
users_content = subwin(users_border, LINES - PANEL_HEIGHT - 2, users_width, 1, 1 );
chat_content = subwin(chat_border, LINES - PANEL_HEIGHT - 2 - TEXTBOX_HEIGHT, chat_width - 4, 1, users_width + 3);
/* draw border around windows */
refresh();
draw_border(users_border, true);
draw_border(chat_border, false);
scrollok(textbox, true);
scrollok(users_content, true);
scrollok(chat_content, true);
refresh();
}
/*
* Draw the border of the window depending if it's active or not
*/
void draw_border(WINDOW *window, bool active)
{
/* turn on color depends on active */
if (active) {
wattron(window, COLOR_PAIR(3));
} else {
wattron(window, COLOR_PAIR(5));
}
box(window, 0, 0);
/* turn color off after turning it on */
if (active) {
wattroff(window, COLOR_PAIR(3));
} else {
wattroff(window, COLOR_PAIR(5));
}
wrefresh(window); /* Refresh the window to see the colored border and title */
}
/*
* Print line to the panel
*/
void wpprintw(const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
wclear(panel);
vw_printw(panel, fmt, args);
va_end(args);
wrefresh(panel);
}
/*
* Highlight current line by reversing the color
*/
void draw_users()
{
long overflow = 0;
/* Check if the current selected user is not shown in rendered text */
if (current_user > LINES - 3) {
/* overflown */
overflow = current_user - (LINES - 3);
}
/* Calculate number of users to show */
long range = users->length;
/* Stop drawing if there is no users */
if (range == 0) {
wprintw(chat_content, "No users. Start a converstation.");
wrefresh(chat_content);
return;
}
if (range > LINES - 3) {
/* if there are more users than lines available to display
* shrink range to avaiable lines to display with
* overflow to keep the number of iterations to be constant */
range = LINES - 3 + overflow;
}
/* Clears content before printing */
wclear(users_content);
/* To keep track the line to print after overflow */
long line_count = 0;
for (long i = overflow; i < range; i++) {
/* Check for currently selected user */
if ((overflow == 0 && i == current_user) || (overflow != 0 && i == current_user)) {
/* current selected user should have color reversed */
wattron(users_content, A_REVERSE);
/* check for marked users */
long num_marked = marked->length;
if (num_marked > 0) {
/* Determine length of formatted string */
int m_len = snprintf(NULL, 0, "[%ld] selected", num_marked);
char *selected = memalloc(m_len + 1);
snprintf(selected, m_len + 1, "[%ld] selected", num_marked);
wpprintw("(%ld/%ld) %s", current_user + 1, users->length, selected);
} else {
wpprintw("(%ld/%ld)", current_user + 1, users->length);
}
}
/* print the actual filename and stats */
user seluser = users->items[i];
size_t name_len = strlen(seluser.name);
/* If length of name is longer than half of allowed size in window,
* trim it to end with .. to show the it is too long to be displayed
*/
int too_long = 0;
if (name_len > MAX_NAME / 2) {
name_len = MAX_NAME / 2;
too_long = 1;
}
char line[name_len];
if (too_long) {
strncpy(line, seluser.name, name_len - 2);
strncat(line, "..", 2);
} else {
strcpy(line, seluser.name);
}
int color = users->items[i].color;
/* check is user marked for action */
bool is_marked = arraylist_search(marked, users->items[i].name) != -1;
if (is_marked) {
/* show user is selected */
wattron(users_content, COLOR_PAIR(7));
} else {
/* print username with default color */
wattron(users_content, COLOR_PAIR(color));
}
if (overflow > 0) {
mvwprintw(users_content, line_count, 0, "%s", line);
} else {
mvwprintw(users_content, i, 0, "%s", line);
}
/* turn off color after printing */
if (is_marked) {
wattroff(users_content, COLOR_PAIR(7));
} else {
wattroff(users_content, COLOR_PAIR(color));
}
wattroff(users_content, A_REVERSE);
line_count++;
}
wrefresh(users_content);
wrefresh(panel);
/* show chat conversation every time cursor changes */
show_chat(users->items[current_user].name);
wrefresh(chat_content);
}
void add_message(uint8_t *author, uint8_t *recipient, uint8_t *content, uint32_t length, time_t creation)
{
message_t *msg = &messages[num_messages];
strcpy(msg->author, author);
strcpy(msg->recipient, recipient);
msg->content = memalloc(length);
strcpy(msg->content, content);
msg->creation = creation;
num_messages++;
}
/*
* Add message to chat window
* if flag is 1, print date as well
* user_color is the color defined above at ncurses_init
*/
void print_message(int flag, message_t *msg)
{
struct tm *timeinfo = localtime(&msg->creation);
char timestr[21];
if (flag) {
strftime(timestr, sizeof(timestr), "%b %d %Y %H:%M:%S", timeinfo);
} else {
strftime(timestr, sizeof(timestr), "%H:%M:%S", timeinfo);
}
wprintw(chat_content, "%s ", timestr);
wattron(chat_content, A_BOLD);
int user_color = get_user_color(users, msg->author);
wattron(chat_content, COLOR_PAIR(user_color));
wprintw(chat_content, "<%s> ", msg->author);
wattroff(chat_content, A_BOLD);
wattroff(chat_content, COLOR_PAIR(user_color));
int i = 0;
int n = strlen(msg->content);
int in_bold = 0, in_italic = 0, in_underline = 0, in_block = 0;
int last_active_color = -1;
while (i < n) {
/* Bold */
if (msg->content[i] == '*' && msg->content[i + 1] == '*') {
if (!in_bold) {
/* Look ahead for the matching closing delimiter */
int closing_pos = i + 2;
while (closing_pos < n && !(msg->content[closing_pos] == '*' && msg->content[closing_pos + 1] == '*')) {
closing_pos++;
}
if (closing_pos < n) {
wattron(chat_content, A_BOLD);
in_bold = 1;
} else {
/* Treat as regular text if closing delimiter */
waddch(chat_content, msg->content[i++]);
}
} else {
wattroff(chat_content, A_BOLD);
in_bold = 0;
}
/* Skip */
i += 2;
/* Italic */
} else if (msg->content[i] == '*') {
if (!in_italic) {
/* Look ahead for the matching closing delimiter */
int closing_pos = i + 1;
while (closing_pos < n && msg->content[closing_pos] != '*') {
closing_pos++;
}
if (closing_pos < n) {
wattron(chat_content, A_ITALIC);
in_italic = 1;
} else {
/* Treat as regular text if closing delimiter */
waddch(chat_content, msg->content[i++]);
}
} else {
wattroff(chat_content, A_ITALIC);
in_italic = 0;
}
/* Skip */
i += 1;
/* Underline */
} else if (msg->content[i] == '_') {
if (!in_underline) {
/* Look ahead for the matching closing delimiter */
int closing_pos = i + 1;
while (closing_pos < n && msg->content[closing_pos] != '_') {
closing_pos++;
}
if (closing_pos < n) {
wattron(chat_content, A_UNDERLINE);
in_underline = 1;
} else {
/* Treat as regular text if closing delimiter */
waddch(chat_content, msg->content[i++]);
}
} else {
wattroff(chat_content, A_UNDERLINE);
in_underline = 0;
}
/* Skip */
i += 1;
/* Block */
} else if (msg->content[i] == '`') {
if (!in_block) {
/* Look ahead for the matching closing delimiter */
int closing_pos = i + 1;
while (closing_pos < n && msg->content[closing_pos] != '`') {
closing_pos++;
}
if (closing_pos < n) {
wattron(chat_content, A_STANDOUT);
in_block = 1;
} else {
/* Treat as regular text if closing delimiter */
waddch(chat_content, msg->content[i++]);
}
} else {
wattroff(chat_content, A_STANDOUT);
in_block = 0;
}
/* Skip */
i += 1;
/* Allow escape sequence for genuine backslash */
} else if (msg->content[i] == '\\' && msg->content[i + 1] == '\\') {
/* Print a literal backslash */
waddch(chat_content, '\\');
/* Skip both backslashes */
i += 2;
/* Color, new line and tab */
} else if (msg->content[i] == '\\') {
/* Skip the backslash and check the next character */
i++;
/* Handle color codes \1 to \8 */
if (msg->content[i] >= '1' && msg->content[i] <= '8') {
/* Convert char to int */
int new_color = msg->content[i] - '0';
if (new_color == last_active_color) {
/* Turn off current color */
wattroff(chat_content, COLOR_PAIR(last_active_color));
/* Reset last active color */
last_active_color = -1;
} else {
if (last_active_color != -1) {
/* Turn off previous color */
wattroff(chat_content, COLOR_PAIR(last_active_color));
}
last_active_color = new_color;
/* Turn on new color */
wattron(chat_content, COLOR_PAIR(new_color));
}
i++;
/* Handle new line */
} else if (msg->content[i] == 'n') {
waddch(chat_content, '\n');
/* Skip the 'n' */
i++;
} else {
/* Invalid sequence, just print the backslash and character */
waddch(chat_content, '\\');
waddch(chat_content, msg->content[i]);
i++;
}
} else {
/* Print regular character */
waddch(chat_content, msg->content[i]);
i++;
}
}
/* Ensure attributes are turned off after printing */
wattroff(chat_content, A_BOLD);
wattroff(chat_content, A_ITALIC);
wattroff(chat_content, A_UNDERLINE);
wattroff(chat_content, A_STANDOUT);
for (int i = 1; i < 8; i++) {
wattroff(chat_content, COLOR_PAIR(i));
}
}
/*
* Get chat conversation into buffer and show it to chat window
*/
void show_chat(uint8_t *recipient)
{
wclear(chat_content);
for (int i = 0; i < 100; i++) {
message_t message = messages[i];
if (message.content == NULL) continue;
/* Find messages from recipient to client or vice versa */
/* outgoing = 1, incoming = 2 */
/* if message to print is older than previous message by a day,
* enable flag in print_message to include date */
int print_date = 0;
if (i > 0 && messages[i - 1].content != NULL && message.creation >= messages[i - 1].creation + 86400) {
print_date = 1;
}
if (strncmp(message.author, USERNAME, MAX_NAME) == 0 &&
strncmp(message.recipient, recipient, MAX_NAME) == 0) {
print_message(print_date, &message);
continue;
}
if (strncmp(message.author, recipient, MAX_NAME) == 0 &&
strncmp(message.recipient, USERNAME, MAX_NAME) == 0) {
print_message(print_date, &message);
continue;
}
}
wrefresh(chat_content);
/* after printing move cursor back to textbox */
wmove(textbox, 0, curs_pos + 2);
wrefresh(textbox);
}
/*
* Require heap allocated username
*/
void add_username(char *username)
{
int randomco = rand() % 8;
arraylist_add(users, username, randomco, false, false);
}
void get_chatbox_content(int ch)
{
if (ch == KEY_BACKSPACE || ch == 127) {
if (curs_pos > 0) {
curs_pos--;
content[curs_pos] = '\0';
}
}
/* Append it to the content if it is normal character */
else if (curs_pos < MAX_MESSAGE_LENGTH - 1) {
/* Filter readable ASCII */
if (ch > 31 && ch < 127) {
content[curs_pos++] = ch;
content[curs_pos] = '\0';
}
}
/* Display the current content */
mvwprintw(textbox, 0, 0, "> %s", content);
wrefresh(textbox);
}
void send_message()
{
uint8_t *recipient = users->items[current_user].name;
keypair_t *kp_from = get_keypair(USERNAME);
uint8_t *pk_to = get_pk_from_ks(recipient); /* ed25519 */
int status = ZSM_STA_SUCCESS;
uint8_t *shared_key = get_sharedkey(recipient);
if (shared_key == NULL) {
uint8_t shared_key[SHARED_KEY_SIZE];
/* Key exchange need to be done with x25519 public and secret keys */
uint8_t from_pk[PK_X25519_SIZE];
uint8_t to_pk[PK_X25519_SIZE];
uint8_t from_sk[SK_X25519_SIZE];
crypto_sign_ed25519_pk_to_curve25519(from_pk, kp_from->pk.raw);
crypto_sign_ed25519_pk_to_curve25519(to_pk, pk_to);
crypto_sign_ed25519_sk_to_curve25519(from_sk, kp_from->sk);
if (crypto_kx_client_session_keys(shared_key, NULL, from_pk, from_sk,
to_pk) != 0) {
deinit();
/* Recipient public key is suspicious */
error(1, "Error performing key exchange with %s", recipient);
}
save_sharedkey(recipient, shared_key);
}
size_t content_len = strlen(content);
uint32_t cipher_len = content_len + ADDITIONAL_SIZE;
uint8_t nonce[NONCE_SIZE], encrypted[cipher_len];
/* Generate random nonce(number used once) */
randombytes_buf(nonce, sizeof(nonce));
/* Encrypt the content and store it to encrypted, should be cipher_len */
crypto_aead_xchacha20poly1305_ietf_encrypt(encrypted, NULL, content,
content_len, NULL, 0, NULL, nonce, shared_key);
size_t data_len = MAX_NAME * 2 + NONCE_SIZE + cipher_len;
uint8_t *data = memalloc(data_len);
uint8_t recipient_padded[MAX_NAME];
strcpy(recipient_padded, recipient);
size_t length = strlen(recipient);
if (length < MAX_NAME) {
/* Pad with null characters up to max length */
memset(recipient_padded + length, 0, MAX_NAME - length);
} else {
deinit();
error(1, "Recipient username must be shorter than MAX_NAME");
}
/* Construct data */
memcpy(data, kp_from->pk.username, MAX_NAME);
memcpy(data + MAX_NAME, recipient, MAX_NAME);
memcpy(data + MAX_NAME * 2, nonce, NONCE_SIZE);
memcpy(data + MAX_NAME * 2 + NONCE_SIZE, encrypted, cipher_len);
uint8_t *signature = create_signature(data, data_len, kp_from->sk);
packet_t *pkt = create_packet(1, ZSM_TYP_MESSAGE, data_len, data, signature);
if (send_packet(pkt, sockfd) != ZSM_STA_SUCCESS) {
close(sockfd);
write_log(LOG_ERROR, "Failed to send message");
}
add_message(USERNAME, recipient, content, content_len, time(NULL));
free_packet(pkt);
show_chat(recipient);
}
/*
* Main loop of user interface
*/
void ui(int *fd)
{
signal(SIGPIPE, signal_handler);
signal(SIGABRT, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
ncurses_init();
windows_init();
sockfd = *fd;
users = arraylist_init(LINES);
marked = arraylist_init(100);
sqlite_init();
get_users();
draw_users();
refresh();
while (1) {
if (current_window == CHAT_WINDOW) {
wclear(textbox);
mvwprintw(textbox, 0, 0, "> %s", content);
wrefresh(textbox);
wmove(textbox, 0, curs_pos + 2);
/* Set cursor to visible */
curs_set(2);
} else {
/* Set cursor to invisible */
curs_set(0);
}
int ch = getch();
switch (ch) {
/* go up by k or up arrow */
case UP:
if (current_window == USERS_WINDOW) {
if (current_user > 0)
current_user--;
draw_users();
}
break;
/* go down by j or down arrow */
case DOWN:
if (current_window == USERS_WINDOW) {
if (current_user < (users->length - 1))
current_user++;
draw_users();
}
break;
/* A is normally for left and E for right */
case CTRLA:
case CTRLE:
current_window ^= 1;
if (current_window == USERS_WINDOW) {
draw_border(users_border, true);
draw_border(chat_border, false);
} else {
draw_border(chat_border, true);
draw_border(users_border, false);
}
break;
case CLEAR_INPUT:
if (current_window == CHAT_WINDOW) {
curs_pos = 0;
content[0] = '\0';
}
case ENTER:
if (current_window == CHAT_WINDOW) {
content[curs_pos++] = ch;
content[curs_pos++] = '\0';
send_message();
/* Reset for new input */
curs_pos = 0;
/* Set content[0] for printing purposes */
content[0] = '\0';
}
break;
default:
if (current_window == CHAT_WINDOW)
get_chatbox_content(ch);
}
}
deinit();
return;
}
Reference in a new issue View git blame Copy permalink