--- lbbs/src/screen.c	2025/05/15 14:17:53	1.52
+++ lbbs/src/screen.c	2025/10/14 05:28:15	1.109
@@ -16,25 +16,50 @@
 
 #include "bbs.h"
 #include "common.h"
-#include "str_process.h"
-#include "log.h"
+#include "editor.h"
+#include "file_loader.h"
 #include "io.h"
+#include "log.h"
+#include "login.h"
 #include "screen.h"
+#include "str_process.h"
+#include <ctype.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <string.h>
-#include <ctype.h>
-#include <unistd.h>
 #include <stdlib.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/stat.h>
+#include <unistd.h>
 #include <sys/param.h>
-#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/shm.h>
+#include <sys/types.h>
 
 #define ACTIVE_BOARD_HEIGHT 8
 
-int screen_rows = 24;
-int screen_cols = 80;
+#define STR_TOP_LEFT_MAX_LEN 80
+#define STR_TOP_MIDDLE_MAX_LEN 40
+#define STR_TOP_RIGHT_MAX_LEN 80
+
+static const char *get_time_str(char *s, size_t len)
+{
+	static const char *weekday[] = {
+		"天", "一", "二", "三", "四", "五", "六"};
+	time_t curtime;
+	struct tm local_tm;
+
+	time(&curtime);
+	localtime_r(&curtime, &local_tm);
+	size_t j = strftime(s, len, "%b %d %H:%M 星期", &local_tm);
+
+	if (j == 0 || j + strlen(weekday[local_tm.tm_wday]) + 1 > len)
+	{
+		return NULL;
+	}
+
+	strncat(s, weekday[local_tm.tm_wday], len - 1 - j);
+
+	return s;
+}
 
 void moveto(int row, int col)
 {
@@ -50,7 +75,7 @@ void moveto(int row, int col)
 
 void clrtoeol()
 {
-	prints("\033[K");
+	prints(CTRL_SEQ_CLR_LINE);
 }
 
 void clrline(int line_begin, int line_end)
@@ -60,7 +85,7 @@ void clrline(int line_begin, int line_en
 	for (i = line_begin; i <= line_end; i++)
 	{
 		moveto(i, 0);
-		prints("\033[K");
+		prints(CTRL_SEQ_CLR_LINE);
 	}
 }
 
@@ -79,10 +104,10 @@ void clearscr()
 
 int press_any_key()
 {
-	moveto(screen_rows, 0);
+	moveto(SCREEN_ROWS, 0);
 	clrtoeol();
 
-	prints("                           \033[1;33m�����������...\033[0;37m");
+	prints("                           \033[1;33m按任意键继续...\033[0;37m");
 	iflush();
 
 	return igetch_t(MIN(MAX_DELAY_TIME, 60));
@@ -105,95 +130,146 @@ void set_input_echo(int echo)
 	}
 }
 
-static int _str_input(char *buffer, int buf_size, int echo_mode)
+static int _str_input(char *buffer, int buf_size, int max_display_len, int echo_mode)
 {
-	int c;
+	int ch;
 	int offset = 0;
-	int hz = 0;
+	int eol;
+	int display_len;
+	char input_str[4];
+	int str_len = 0;
+	char c;
 
 	buffer[buf_size - 1] = '\0';
-	for (offset = 0; offset < buf_size - 1 && buffer[offset] != '\0'; offset++)
-		;
+	offset = split_line(buffer, max_display_len, &eol, &display_len, 0);
 
 	igetch_reset();
 
 	while (!SYS_server_exit)
 	{
-		c = igetch_t(MIN(MAX_DELAY_TIME, 60));
+		ch = igetch_t(MIN(MAX_DELAY_TIME, 60));
 
-		if (c == CR)
+		if (ch == CR)
 		{
 			igetch_reset();
 			break;
 		}
-		else if (c == KEY_TIMEOUT || c == KEY_NULL) // timeout or broken pipe
+		else if (ch == KEY_TIMEOUT || ch == KEY_NULL) // timeout or broken pipe
 		{
 			return -1;
 		}
-		else if (c == LF || c == '\0')
+		else if (ch == LF || ch == '\0')
 		{
 			continue;
 		}
-		else if (c == BACKSPACE)
+		else if (ch == BACKSPACE)
 		{
 			if (offset > 0)
 			{
 				offset--;
-				if (buffer[offset] < 0 || buffer[offset] > 127)
+				if (buffer[offset] < 0 || buffer[offset] > 127) // UTF8
 				{
-					prints("\033[D \033[D");
-					offset--;
-					if (offset < 0) // should not happen
+					while (offset > 0 && (buffer[offset] & 0b11000000) != 0b11000000)
 					{
-						log_error("Offset of buffer is negative\n");
-						offset = 0;
+						offset--;
 					}
+					display_len--;
+					prints("\033[D \033[D");
 				}
 				buffer[offset] = '\0';
+				display_len--;
 				prints("\033[D \033[D");
 				iflush();
 			}
 			continue;
 		}
-		else if (c > 255 || iscntrl(c))
+		else if (ch > 255 || iscntrl(ch))
 		{
 			continue;
 		}
-		else if (c > 127 && c <= 255)
+		else if ((ch & 0xff80) == 0x80) // head of multi-byte character
 		{
-			if (!hz && offset + 2 > buf_size - 1) // No enough space for Chinese character
+			str_len = 0;
+			c = (char)(ch & 0b11110000);
+			while (c & 0b10000000)
+			{
+				input_str[str_len] = (char)(ch - 256);
+				str_len++;
+				c = (c & 0b01111111) << 1;
+
+				if ((c & 0b10000000) == 0) // Input completed
+				{
+					break;
+				}
+
+				// Expect additional bytes of input
+				ch = igetch(100);						 // 0.1 second
+				if (ch == KEY_NULL || ch == KEY_TIMEOUT) // Ignore received bytes if no futher input
+				{
+#ifdef _DEBUG
+					log_error("Ignore %d bytes of incomplete UTF8 character\n", str_len);
+#endif
+					str_len = 0;
+					break;
+				}
+			}
+
+			if (str_len == 0) // Incomplete input
+			{
+				continue;
+			}
+
+			if (offset + str_len > buf_size - 1 || display_len + 2 > max_display_len) // No enough space for Chinese character
 			{
-				igetch(0); // Ignore 1 character
 				outc('\a');
 				iflush();
 				continue;
 			}
-			hz = (!hz);
-		}
 
-		if (offset + 1 > buf_size - 1)
-		{
-			outc('\a');
-			iflush();
-			continue;
+			memcpy(buffer + offset, input_str, (size_t)str_len);
+			offset += str_len;
+			buffer[offset] = '\0';
+			display_len += 2;
+
+			switch (echo_mode)
+			{
+			case DOECHO:
+				prints(input_str);
+				break;
+			case NOECHO:
+				prints("**");
+				break;
+			}
 		}
+		else if (ch >= 32 && ch < 127) // Printable character
+		{
+			if (offset + 1 > buf_size - 1 || display_len + 1 > max_display_len)
+			{
+				outc('\a');
+				iflush();
+				continue;
+			}
 
-		buffer[offset++] = (char)c;
-		buffer[offset] = '\0';
+			buffer[offset++] = (char)ch;
+			buffer[offset] = '\0';
+			display_len++;
 
-		switch (echo_mode)
-		{
-		case DOECHO:
-			outc((char)c);
-			break;
-		case NOECHO:
-			outc('*');
-			break;
+			switch (echo_mode)
+			{
+			case DOECHO:
+				outc((char)ch);
+				break;
+			case NOECHO:
+				outc('*');
+				break;
+			}
 		}
-		if (!hz)
+		else // Invalid character
 		{
-			iflush();
+			continue;
 		}
+
+		iflush();
 	}
 
 	return offset;
@@ -205,7 +281,7 @@ int str_input(char *buffer, int buf_size
 
 	buffer[0] = '\0';
 
-	len = _str_input(buffer, buf_size, echo_mode);
+	len = _str_input(buffer, buf_size, buf_size, echo_mode);
 
 	prints("\r\n");
 	iflush();
@@ -213,78 +289,319 @@ int str_input(char *buffer, int buf_size
 	return len;
 };
 
-int get_data(int row, int col, char *prompt, char *buffer, int buf_size, int echo_mode)
+int get_data(int row, int col, char *prompt, char *buffer, int buf_size, int max_display_len)
 {
-	int len;
+	int len = 0;
+	int col_cur = 0;
+	int ch;
+	int offset = 0;
+	int eol;
+	int display_len;
+	char input_str[4];
+	int str_len = 0;
+	char c;
+
+	buffer[buf_size - 1] = '\0';
+	offset = split_line(buffer, max_display_len, &eol, &display_len, 0);
+	buffer[offset] = '\0';
+	len = offset;
+	col_cur = col + str_length(prompt, 1) + display_len;
 
 	moveto(row, col);
-	prints(prompt);
-	prints(buffer);
+	prints("%s", prompt);
+	prints("%s", buffer);
+	prints("%*s", max_display_len - display_len, "");
+	moveto(row, col_cur);
 	iflush();
 
-	len = _str_input(buffer, buf_size, echo_mode);
+	igetch_reset();
+
+	while (!SYS_server_exit)
+	{
+		ch = igetch_t(MIN(MAX_DELAY_TIME, 60));
+
+		if (ch == CR)
+		{
+			igetch_reset();
+			break;
+		}
+		else if (ch == KEY_TIMEOUT || ch == KEY_NULL) // timeout or broken pipe
+		{
+			return -1;
+		}
+		else if (ch == LF || ch == '\0')
+		{
+			continue;
+		}
+		else if (ch == BACKSPACE)
+		{
+			if (offset > 0)
+			{
+				str_len = 1;
+				offset--;
+				if (buffer[offset] < 0 || buffer[offset] > 127) // UTF8
+				{
+					while (offset > 0 && (buffer[offset] & 0b11000000) != 0b11000000)
+					{
+						str_len++;
+						offset--;
+					}
+					display_len--;
+					col_cur--;
+				}
+
+				memmove(buffer + offset, buffer + offset + str_len, (size_t)(len - offset - str_len));
+				len -= str_len;
+				buffer[len] = '\0';
+				display_len--;
+				col_cur--;
+
+				moveto(row, col_cur);
+				prints("%s", buffer + offset);
+				prints("%*s", max_display_len - display_len, "");
+				moveto(row, col_cur);
+				iflush();
+			}
+			continue;
+		}
+		else if (ch == KEY_DEL)
+		{
+			if (offset < len)
+			{
+				if ((buffer[offset] & 0x80) == 0x80) // head of multi-byte character
+				{
+					str_len = 0;
+					c = (char)(buffer[offset] & 0b11110000);
+					while (c & 0b10000000)
+					{
+						str_len++;
+						c = (c & 0b01111111) << 1;
+					}
+					display_len--;
+				}
+				else
+				{
+					str_len = 1;
+				}
+
+				memmove(buffer + offset, buffer + offset + str_len, (size_t)(len - offset - str_len));
+				len -= str_len;
+				buffer[len] = '\0';
+				display_len--;
+
+				moveto(row, col_cur);
+				prints("%s", buffer + offset);
+				prints("%*s", max_display_len - display_len, "");
+				moveto(row, col_cur);
+				iflush();
+			}
+			continue;
+		}
+		else if (ch == KEY_LEFT)
+		{
+			if (offset > 0)
+			{
+				str_len = 1;
+				offset--;
+				if (buffer[offset] < 0 || buffer[offset] > 127) // UTF8
+				{
+					while (offset > 0 && (buffer[offset] & 0b11000000) != 0b11000000)
+					{
+						str_len++;
+						offset--;
+					}
+					col_cur--;
+				}
+				col_cur--;
+
+				moveto(row, col_cur);
+				iflush();
+			}
+			continue;
+		}
+		else if (ch == KEY_RIGHT)
+		{
+			if (offset < len)
+			{
+				str_len = 0;
+				if ((buffer[offset] & 0x80) == 0x80) // head of multi-byte character
+				{
+					c = (char)(buffer[offset] & 0b11110000);
+					while (c & 0b10000000)
+					{
+						str_len++;
+						c = (c & 0b01111111) << 1;
+					}
+					col_cur++;
+				}
+				else
+				{
+					str_len = 1;
+				}
+
+				col_cur++;
+				offset += str_len;
+
+				moveto(row, col_cur);
+				iflush();
+			}
+			continue;
+		}
+		else if (ch == KEY_HOME || ch == KEY_UP)
+		{
+			if (offset > 0)
+			{
+				offset = 0;
+				col_cur = col + str_length(prompt, 1);
+
+				moveto(row, col_cur);
+				iflush();
+			}
+			continue;
+		}
+		else if (ch == KEY_END || ch == KEY_DOWN)
+		{
+			if (offset < len)
+			{
+				offset = len;
+				col_cur = col + str_length(prompt, 1) + display_len;
+
+				moveto(row, col_cur);
+				iflush();
+			}
+			continue;
+		}
+		else if (ch > 255 || iscntrl(ch))
+		{
+			continue;
+		}
+		else if ((ch & 0xff80) == 0x80) // head of multi-byte character
+		{
+			str_len = 0;
+			c = (char)(ch & 0b11110000);
+			while (c & 0b10000000)
+			{
+				input_str[str_len] = (char)(ch - 256);
+				str_len++;
+				c = (c & 0b01111111) << 1;
+
+				if ((c & 0b10000000) == 0) // Input completed
+				{
+					break;
+				}
+
+				// Expect additional bytes of input
+				ch = igetch(100);						 // 0.1 second
+				if (ch == KEY_NULL || ch == KEY_TIMEOUT) // Ignore received bytes if no futher input
+				{
+#ifdef _DEBUG
+					log_error("Ignore %d bytes of incomplete UTF8 character\n", str_len);
+#endif
+					str_len = 0;
+					break;
+				}
+			}
+
+			if (str_len == 0) // Incomplete input
+			{
+				continue;
+			}
+
+			if (len + str_len > buf_size - 1 || display_len + 2 > max_display_len) // No enough space for Chinese character
+			{
+				outc('\a');
+				iflush();
+				continue;
+			}
+
+			memmove(buffer + offset + str_len, buffer + offset, (size_t)(len - offset));
+			memcpy(buffer + offset, input_str, (size_t)str_len);
+			len += str_len;
+			buffer[len] = '\0';
+			display_len += 2;
+
+			moveto(row, col_cur);
+			prints("%s", buffer + offset);
+			prints("%*s", max_display_len - display_len, "");
+
+			col_cur += 2;
+
+			moveto(row, col_cur);
+			iflush();
+
+			offset += str_len;
+		}
+		else if (ch >= 32 && ch < 127) // Printable character
+		{
+			if (len + 1 > buf_size - 1 || display_len + 1 > max_display_len)
+			{
+				outc('\a');
+				iflush();
+				continue;
+			}
+
+			memmove(buffer + offset + 1, buffer + offset, (size_t)(len - offset));
+			buffer[offset] = (char)ch;
+			len++;
+			buffer[len] = '\0';
+			display_len++;
+
+			moveto(row, col_cur);
+			prints("%s", buffer + offset);
+			prints("%*s", max_display_len - display_len, "");
+
+			col_cur++;
+
+			moveto(row, col_cur);
+			iflush();
+
+			offset++;
+		}
+		else // Invalid character
+		{
+			continue;
+		}
+	}
 
 	return len;
 }
 
-int display_file_ex(const char *filename, int begin_line, int wait)
+int display_data(const void *p_data, long display_line_total, const long *p_line_offsets, int eof_exit,
+				 display_data_key_handler key_handler, const char *help_filename)
 {
 	static int show_help = 1;
 	char buffer[LINE_BUFFER_LEN];
-	void *p_data;
+	DISPLAY_CTX ctx;
 	int ch = 0;
-	int input_ok, line, max_lines;
-	long int c_line_current = 0;
-	long int c_line_total = 0;
-	int fd;
-	struct stat sb;
-	long *p_line_offsets;
+	int input_ok;
+	const int screen_begin_row = 1;
+	const int screen_row_total = SCREEN_ROWS - screen_begin_row;
+	int output_current_row = screen_begin_row;
+	int output_end_row = SCREEN_ROWS - 1;
+	long int line_current = 0;
 	long int len;
 	long int percentile;
-	int loop = 1;
-
-	if ((fd = open(filename, O_RDONLY)) < 0)
-	{
-		log_error("open(%s) error (%d)\n", filename, errno);
-		return -1;
-	}
-
-	if (fstat(fd, &sb) < 0)
-	{
-		log_error("fstat(fd) error (%d)\n", errno);
-		return -1;
-	}
+	int loop;
+	int eol, display_len;
 
-	p_data = mmap(NULL, (size_t)sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0L);
-	if (p_data == MAP_FAILED)
-	{
-		log_error("mmap() error (%d)\n", errno);
-		return -2;
-	}
+	clrline(output_current_row, SCREEN_ROWS);
 
-	if (close(fd) < 0)
+	// update msg_ext with extended key handler
+	if (key_handler(&ch, &ctx) != 0)
 	{
-		log_error("close(fd) error (%d)\n", errno);
-		return -1;
+		return ch;
 	}
 
-	p_line_offsets = (long *)malloc(sizeof(long) * MAX_FILE_LINES);
-
-	c_line_total = split_data_lines(p_data, screen_cols, p_line_offsets, MAX_FILE_LINES);
-
-	clrline(begin_line, screen_rows);
-	line = begin_line;
-	max_lines = screen_rows - 1;
-
+	loop = 1;
 	while (!SYS_server_exit && loop)
 	{
-		if (c_line_current >= c_line_total && c_line_total <= screen_rows - 2)
+		if (eof_exit > 0 && line_current >= display_line_total && display_line_total <= screen_row_total)
 		{
-			if (wait)
+			if (eof_exit == 1)
 			{
 				ch = press_any_key();
 			}
-			else
+			else // if (eof_exit == 2)
 			{
 				iflush();
 			}
@@ -293,21 +610,41 @@ int display_file_ex(const char *filename
 			break;
 		}
 
-		if (c_line_current >= c_line_total || line >= max_lines)
+		if (line_current >= display_line_total || output_current_row > output_end_row)
 		{
-			if (c_line_current - (line - 1) + (screen_rows - 2) < c_line_total)
+			ctx.reach_begin = (line_current < output_current_row ? 1 : 0);
+
+			if (line_current - (output_current_row - screen_begin_row) + screen_row_total < display_line_total)
 			{
-				percentile = (c_line_current - (line - 1) + (screen_rows - 2)) * 100 / c_line_total;
+				percentile = (line_current - (output_current_row - screen_begin_row) + screen_row_total) * 100 / display_line_total;
+				ctx.reach_end = 0;
 			}
 			else
 			{
 				percentile = 100;
+				ctx.reach_end = 1;
 			}
 
-			moveto(screen_rows, 0);
-			prints("\033[1;44;32m%s (%d%%)%s\033[33m          �� ���� �� <q> �� ��/��/PgUp/PgDn �ƶ� �� ? ����˵�� ��     \033[m",
-				   (percentile < 100 ? "���滹���" : "û�и�����"), percentile,
-				   (percentile < 10 ? "  " : (percentile < 100 ? " " : "")));
+			ctx.line_top = line_current - (output_current_row - screen_begin_row) + 1;
+			ctx.line_bottom = MIN(line_current - (output_current_row - screen_begin_row) + screen_row_total, display_line_total);
+
+			snprintf(buffer, sizeof(buffer),
+					 "\033[1;44;33m第\033[32m%ld\033[33m-\033[32m%ld\033[33m行 (\033[32m%ld%%\033[33m) %s",
+					 ctx.line_top,
+					 ctx.line_bottom,
+					 percentile,
+					 ctx.msg);
+
+			len = split_line(buffer, SCREEN_COLS, &eol, &display_len, 1);
+			for (; display_len < SCREEN_COLS; display_len++)
+			{
+				buffer[len++] = ' ';
+			}
+			buffer[len] = '\0';
+			strncat(buffer, "\033[m", sizeof(buffer) - 1 - strnlen(buffer, sizeof(buffer)));
+
+			moveto(SCREEN_ROWS, 0);
+			prints("%s", buffer);
 			iflush();
 
 			input_ok = 0;
@@ -315,244 +652,342 @@ int display_file_ex(const char *filename
 			{
 				ch = igetch_t(MAX_DELAY_TIME);
 				input_ok = 1;
+
+				// extended key handler
+				if (key_handler(&ch, &ctx) != 0)
+				{
+					goto cleanup;
+				}
+
 				switch (ch)
 				{
 				case KEY_NULL:
 				case KEY_TIMEOUT:
 					goto cleanup;
 				case KEY_HOME:
-					c_line_current = 0;
-					line = begin_line;
-					max_lines = screen_rows - 1;
-					clrline(begin_line, screen_rows);
+					if (line_current - output_current_row < 0) // Reach begin
+					{
+						break;
+					}
+					line_current = 0;
+					output_current_row = screen_begin_row;
+					output_end_row = SCREEN_ROWS - 1;
+					clrline(output_current_row, SCREEN_ROWS);
 					break;
 				case KEY_END:
-					c_line_current = c_line_total - (screen_rows - 2);
-					line = begin_line;
-					max_lines = screen_rows - 1;
-					clrline(begin_line, screen_rows);
+					if (display_line_total < screen_row_total)
+					{
+						break;
+					}
+					line_current = display_line_total - screen_row_total;
+					output_current_row = screen_begin_row;
+					output_end_row = SCREEN_ROWS - 1;
+					clrline(output_current_row, SCREEN_ROWS);
 					break;
 				case KEY_UP:
-					if (c_line_current - line < 0) // Reach top
+					if (line_current - output_current_row < 0) // Reach begin
 					{
 						break;
 					}
-					c_line_current -= line;
-					line = begin_line;
-					// max_lines = begin_line + 1;
+					line_current -= output_current_row;
+					output_current_row = screen_begin_row;
+					// screen_end_line = screen_begin_line;
 					// prints("\033[T"); // Scroll down 1 line
-					max_lines = screen_rows - 1; // Legacy Fterm only works with this line
+					output_end_row = SCREEN_ROWS - 1; // Legacy Fterm only works with this line
 					break;
 				case CR:
 					igetch_reset();
+				case KEY_SPACE:
 				case KEY_DOWN:
-					if (c_line_current + ((screen_rows - 2) - (line - 1)) >= c_line_total) // Reach bottom
+					if (line_current + (screen_row_total - (output_current_row - screen_begin_row)) >= display_line_total) // Reach end
 					{
 						break;
 					}
-					c_line_current += ((screen_rows - 2) - (line - 1));
-					line = screen_rows - 2;
-					max_lines = screen_rows - 1;
-					moveto(screen_rows, 0);
+					line_current += (screen_row_total - (output_current_row - screen_begin_row));
+					output_current_row = screen_row_total;
+					output_end_row = SCREEN_ROWS - 1;
+					moveto(SCREEN_ROWS, 0);
 					clrtoeol();
-					prints("\033[S"); // Scroll up 1 line
+					// prints("\033[S"); // Scroll up 1 line
+					prints("\n"); // Legacy Cterm only works with this line
 					break;
 				case KEY_PGUP:
-				case Ctrl('B'):
-					if (c_line_current - line < 0) // Reach top
+					if (line_current - output_current_row < 0) // Reach begin
 					{
 						break;
 					}
-					c_line_current -= ((screen_rows - 3) + (line - 1));
-					if (c_line_current < 0)
+					line_current -= ((screen_row_total - 1) + (output_current_row - screen_begin_row));
+					if (line_current < 0)
 					{
-						c_line_current = 0;
+						line_current = 0;
 					}
-					line = begin_line;
-					max_lines = screen_rows - 1;
-					clrline(begin_line, screen_rows);
+					output_current_row = screen_begin_row;
+					output_end_row = SCREEN_ROWS - 1;
+					clrline(output_current_row, SCREEN_ROWS);
 					break;
-				case KEY_RIGHT:
 				case KEY_PGDN:
-				case Ctrl('F'):
-				case KEY_SPACE:
-					if (c_line_current + (screen_rows - 2) - (line - 1) >= c_line_total) // Reach bottom
+					if (line_current + screen_row_total - (output_current_row - screen_begin_row) >= display_line_total) // Reach end
 					{
 						break;
 					}
-					c_line_current += (screen_rows - 3) - (line - 1);
-					if (c_line_current + screen_rows - 2 > c_line_total) // No enough lines to display
+					line_current += (screen_row_total - 1) - (output_current_row - screen_begin_row);
+					if (line_current + screen_row_total > display_line_total) // No enough lines to display
 					{
-						c_line_current = c_line_total - (screen_rows - 2);
+						line_current = display_line_total - screen_row_total;
 					}
-					line = begin_line;
-					max_lines = screen_rows - 1;
-					clrline(begin_line, screen_rows);
+					output_current_row = screen_begin_row;
+					output_end_row = SCREEN_ROWS - 1;
+					clrline(output_current_row, SCREEN_ROWS);
 					break;
+				case KEY_ESC:
 				case KEY_LEFT:
-				case 'q':
-				case 'Q':
 					loop = 0;
 					break;
-				case '?':
 				case 'h':
-				case 'H':
-					if (!show_help)
+					if (!show_help) // Not reentrant
 					{
 						break;
 					}
-
 					// Display help information
 					show_help = 0;
-					display_file_ex(DATA_READ_HELP, begin_line, 1);
+					display_file(help_filename, 1);
 					show_help = 1;
-
+				case KEY_F5:
 					// Refresh after display help information
-					c_line_current -= (line - 1);
-					line = begin_line;
-					max_lines = screen_rows - 1;
-					clrline(begin_line, screen_rows);
+					line_current -= (output_current_row - screen_begin_row);
+					output_current_row = screen_begin_row;
+					output_end_row = SCREEN_ROWS - 1;
+					clrline(output_current_row, SCREEN_ROWS);
+					break;
+				case 0: // Refresh bottom line
 					break;
 				default:
-					log_std("Input: %d\n", ch);
 					input_ok = 0;
 					break;
 				}
 
-				BBS_last_access_tm = time(0);
+				BBS_last_access_tm = time(NULL);
 			}
 
 			continue;
 		}
 
-		len = p_line_offsets[c_line_current + 1] - p_line_offsets[c_line_current];
-		if (len >= LINE_BUFFER_LEN)
+		len = p_line_offsets[line_current + 1] - p_line_offsets[line_current];
+		if (len >= sizeof(buffer))
 		{
-			log_error("Error length exceeds buffer size: %d\n", len);
-			len = LINE_BUFFER_LEN - 1;
+			log_error("Buffer overflow: len=%ld(%ld - %ld) line=%ld \n",
+					  len, p_line_offsets[line_current + 1], p_line_offsets[line_current], line_current);
+			len = sizeof(buffer) - 1;
+		}
+		else if (len < 0)
+		{
+			log_error("Incorrect line offsets: len=%ld(%ld - %ld) line=%ld \n",
+					  len, p_line_offsets[line_current + 1], p_line_offsets[line_current], line_current);
+			len = 0;
 		}
 
-		memcpy(buffer, (const char *)p_data + p_line_offsets[c_line_current], (size_t)len);
+		memcpy(buffer, (const char *)p_data + p_line_offsets[line_current], (size_t)len);
 		buffer[len] = '\0';
 
-		moveto(line, 0);
+		moveto(output_current_row, 0);
 		clrtoeol();
 		prints("%s", buffer);
-		c_line_current++;
-		line++;
+		line_current++;
+		output_current_row++;
 	}
 
 cleanup:
-	if (munmap(p_data, (size_t)sb.st_size) < 0)
+	return ch;
+}
+
+static int display_file_key_handler(int *p_key, DISPLAY_CTX *p_ctx)
+{
+	switch (*p_key)
 	{
-		log_error("munmap() error (%d)\n", errno);
+	case 0: // Set msg
+		snprintf(p_ctx->msg, sizeof(p_ctx->msg),
+				 "| 返回[\033[32m←\033[33m,\033[32mESC\033[33m] | "
+				 "移动[\033[32m↑\033[33m/\033[32m↓\033[33m/\033[32mPgUp\033[33m/\033[32mPgDn\033[33m] | "
+				 "帮助[\033[32mh\033[33m] |");
+		break;
 	}
 
-	free(p_line_offsets);
-
-	return ch;
+	return 0;
 }
 
-int show_top(char *status)
+int display_file(const char *filename, int eof_exit)
 {
-	int end_of_line;
-	int display_len;
-	int len;
+	int ret;
+	const void *p_shm;
+	size_t data_len;
+	long line_total;
+	const void *p_data;
+	const long *p_line_offsets;
 
-	char space1[LINE_BUFFER_LEN];
-	char space2[LINE_BUFFER_LEN];
+	if ((p_shm = get_file_shm_readonly(filename, &data_len, &line_total, &p_data, &p_line_offsets)) == NULL)
+	{
+		log_error("get_file_shm(%s) error\n", filename);
+		return KEY_NULL;
+	}
 
-	len = split_line(status, 20, &end_of_line, &display_len);
-	if (end_of_line)
+	if (user_online_update("VIEW_FILE") < 0)
 	{
-		status[len] = '\0';
+		log_error("user_online_update(VIEW_FILE) error\n");
 	}
-	str_space(space1, 31 - display_len);
 
-	len = split_line(BBS_current_section_name, 20, &end_of_line, &display_len);
-	if (end_of_line)
+	ret = display_data(p_data, line_total, p_line_offsets, eof_exit, display_file_key_handler, DATA_READ_HELP);
+
+	if (detach_file_shm(p_shm) < 0)
 	{
-		status[len] = '\0';
+		log_error("detach_file_shm(%s) error\n", filename);
 	}
-	str_space(space2, 30 - display_len);
+
+	return ret;
+}
+
+int show_top(const char *str_left, const char *str_middle, const char *str_right)
+{
+	char str_left_f[STR_TOP_LEFT_MAX_LEN + 1];
+	char str_middle_f[STR_TOP_MIDDLE_MAX_LEN + 1];
+	char str_right_f[STR_TOP_RIGHT_MAX_LEN + 1];
+	int str_left_len;
+	int str_middle_len;
+	int str_right_len;
+	int eol;
+	int len;
+
+	strncpy(str_left_f, str_left, sizeof(str_left_f) - 1);
+	str_left_f[sizeof(str_left_f) - 1] = '\0';
+	len = split_line(str_left_f, STR_TOP_LEFT_MAX_LEN / 2, &eol, &str_left_len, 1);
+	str_left_f[len] = '\0';
+
+	strncpy(str_middle_f, str_middle, sizeof(str_middle_f) - 1);
+	str_middle_f[sizeof(str_middle_f) - 1] = '\0';
+	len = split_line(str_middle, STR_TOP_MIDDLE_MAX_LEN / 2, &eol, &str_middle_len, 1);
+	str_middle_f[len] = '\0';
+
+	strncpy(str_right_f, str_right, sizeof(str_right_f) - 1);
+	str_right_f[sizeof(str_right_f) - 1] = '\0';
+	len = split_line(str_right, STR_TOP_RIGHT_MAX_LEN / 2, &eol, &str_right_len, 1);
+	str_right_f[len] = '\0';
 
 	moveto(1, 0);
 	clrtoeol();
-	prints("\033[1;44;33m%s \033[37m%s%s%s\033[33m ������ [%s]\033[m",
-		   status, space1, BBS_name, space2, BBS_current_section_name);
-	iflush();
+	prints("\033[1;44;33m%s\033[37m%*s%s\033[33m%*s%s\033[m",
+		   str_left_f, 44 - str_left_len - str_middle_len, "",
+		   str_middle_f, 36 - str_right_len, "", str_right_f);
 
 	return 0;
 }
 
-int show_bottom(char *msg)
+int show_bottom(const char *msg)
 {
 	char str_time[LINE_BUFFER_LEN];
-	char space[LINE_BUFFER_LEN];
 	time_t time_online;
 	struct tm *tm_online;
+	char msg_f[LINE_BUFFER_LEN];
+	int eol;
+	int msg_len;
+	int len;
+	int len_username;
+	char str_tm_online[LINE_BUFFER_LEN];
 
 	get_time_str(str_time, sizeof(str_time));
-	str_space(space, 34 - (int)strnlen(BBS_username, sizeof(BBS_username)));
 
-	time_online = time(0) - BBS_login_tm;
+	msg_f[0] = '\0';
+	msg_len = 0;
+	if (msg != NULL)
+	{
+		strncpy(msg_f, msg, sizeof(msg_f) - 1);
+		msg_f[sizeof(msg_f) - 1] = '\0';
+		len = split_line(msg_f, 23, &eol, &msg_len, 1);
+		msg_f[len] = '\0';
+	}
+
+	len_username = (int)strnlen(BBS_username, sizeof(BBS_username));
+
+	time_online = time(NULL) - BBS_login_tm;
 	tm_online = gmtime(&time_online);
+	if (tm_online->tm_mday > 1)
+	{
+		snprintf(str_tm_online, sizeof(str_tm_online),
+				 "\033[36m%2d\033[33m天\033[36m%2d\033[33m时",
+				 tm_online->tm_mday - 1, tm_online->tm_hour);
+	}
+	else
+	{
+		snprintf(str_tm_online, sizeof(str_tm_online),
+				 "\033[36m%2d\033[33m时\033[36m%2d\033[33m分",
+				 tm_online->tm_hour, tm_online->tm_min);
+	}
 
-	moveto(screen_rows, 0);
+	moveto(SCREEN_ROWS, 0);
 	clrtoeol();
-	prints("\033[1;44;33m[\033[36m%s\033[33m]%s�ʺ�[\033[36m%s\033[33m]"
-		   "[\033[36m%1d\033[33m:\033[36m%2d\033[33m:\033[36m%2d\033[33m]\033[m",
-		   str_time, space, BBS_username, tm_online->tm_mday - 1,
-		   tm_online->tm_hour, tm_online->tm_min);
-	iflush();
+	prints("\033[1;44;33m时间[\033[36m%s\033[33m]%s%*s \033[33m帐号[\033[36m%s\033[33m][%s\033[33m]\033[m",
+		   str_time, msg_f, 38 - msg_len - len_username, "", BBS_username, str_tm_online);
 
 	return 0;
 }
 
 int show_active_board()
 {
-	char filename[FILE_PATH_LEN];
-	char buffer[LINE_BUFFER_LEN];
-	FILE *fin;
-	static int line;
-	int len;
-	int end_of_line;
-	int display_len;
+	static int line_current = 0;
+	static const void *p_shm = NULL;
+	static size_t data_len;
+	static long line_total;
+	static const void *p_data;
+	static const long *p_line_offsets;
 
-	clrline(3, 2 + ACTIVE_BOARD_HEIGHT);
+	static time_t t_last_show = 0;
+	static int line_last = 0;
 
-	if ((fin = fopen(DATA_ACTIVE_BOARD, "r")) == NULL)
-	{
-		log_error("Unable to open file %s\n", filename);
-		return -1;
-	}
+	char buffer[LINE_BUFFER_LEN];
+	long int len;
 
-	for (int i = 0; i < line; i++)
+	if (p_shm == NULL)
 	{
-		if (fgets(buffer, sizeof(buffer), fin) == NULL)
+		if ((p_shm = get_file_shm_readonly(DATA_ACTIVE_BOARD, &data_len, &line_total, &p_data, &p_line_offsets)) == NULL)
 		{
-			line = 0;
-			rewind(fin);
-			break;
+			log_error("get_file_shm(%s) error\n", DATA_ACTIVE_BOARD);
+			return KEY_NULL;
 		}
 	}
 
+	if (time(NULL) - t_last_show >= 10)
+	{
+		line_last = line_current;
+		t_last_show = time(NULL);
+	}
+	else
+	{
+		line_current = line_last;
+	}
+
+	clrline(2, 2 + ACTIVE_BOARD_HEIGHT);
+
 	for (int i = 0; i < ACTIVE_BOARD_HEIGHT; i++)
 	{
-		if (fgets(buffer, sizeof(buffer), fin) == NULL)
+		len = p_line_offsets[line_current + 1] - p_line_offsets[line_current];
+		if (len >= LINE_BUFFER_LEN)
 		{
-			line = 0;
-			break;
+			log_error("buffer overflow: len=%ld(%ld - %ld) line=%ld \n",
+					  len, p_line_offsets[line_current + 1], p_line_offsets[line_current], line_current);
+			len = LINE_BUFFER_LEN - 1;
 		}
-		line++;
-		len = split_line(buffer, screen_cols, &end_of_line, &display_len);
-		buffer[len] = '\0'; // Truncate over-length line
+
+		memcpy(buffer, (const char *)p_data + p_line_offsets[line_current], (size_t)len);
+		buffer[len] = '\0';
+
 		moveto(3 + i, 0);
 		prints("%s", buffer);
-	}
-	iflush();
 
-	fclose(fin);
+		line_current++;
+		if (line_current >= line_total)
+		{
+			line_current = 0;
+			break;
+		}
+	}
 
 	return 0;
 }