lbbs/src/io.c

/***************************************************************************
                                                        io.c  -  description
                                                         -------------------
        Copyright            : (C) 2004-2025 by Leaflet
        Email                : leaflet@leafok.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#include "io.h"
#include "log.h"
#include "common.h"
#include "tcplib.h"
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>

int outc(char c)
{
        int retval;

        retval = fprintf(stdout, "%c", c);

        return retval;
}

int prints(const char *format, ...)
{
        va_list args;
        int retval;

        va_start(args, format);
        retval = vfprintf(stdout, format, args);
        va_end(args);

        return retval;
}

int iflush()
{
        int retval;

        retval = fflush(stdout);

        return retval;
}

int igetch(int clear_buf)
{
        // static input buffer
        static unsigned char buf[256];
        static ssize_t len = 0;
        static int pos = 0;

        unsigned char tmp[256];
        int out = KEY_NULL;
        int in_esc = 0;
        int in_ascii = 0;
        int in_control = 0;
        int i = 0;

        if (clear_buf)
        {
                pos = 0;
                len = 0;

                return 0;
        }

        // Stop on system exit
        if (SYS_exit)
                return KEY_NULL;

        if (pos >= len)
        {
                fd_set testfds;
                struct timeval timeout;

                pos = 0;
                len = 0;

                FD_ZERO(&testfds);
                FD_SET(0, &testfds);

                timeout.tv_sec = 1;
                timeout.tv_usec = 0;

                int result = SignalSafeSelect(FD_SETSIZE, &testfds, (fd_set *)NULL,
                                                                  (fd_set *)NULL, &timeout);

                if (result == 0)
                {
                        return KEY_TIMEOUT;
                }
                if (result < 0)
                {
                        log_error("select() error (%d) !\n", result);
                        return KEY_NULL;
                }
                if (result > 0)
                {
                        if (FD_ISSET(0, &testfds))
                        {
                                len = read(0, buf, 255);
                        }
                }

                // For debug
                // for (j = 0; j < len; j++)
                //   log_std ("<--[%u]\n", (buf[j] + 256) % 256);
        }

        while (pos < len)
        {
                unsigned char c = buf[pos++];

                if (c == '\0')
                {
                        out = c;
                        break;
                }

                if (c == KEY_CONTROL)
                {
                        if (in_control == 0)
                        {
                                in_control = 1;
                                i = 0;
                                continue;
                        }
                }

                if (in_control)
                {
                        tmp[i++] = c;
                        if (i >= 2)
                        {
                                out = (int)tmp[0] * 256 + tmp[1];
                                in_control = 0;
                                break;
                        }
                        continue;
                }

                if (c == ESC_KEY)
                {
                        if (in_esc == 0)
                        {
                                in_esc = 1;
                                in_ascii = 1;
                                i = 0;
                                continue;
                        }
                        else
                        {
                                out = ESC_KEY;
                                in_esc = 0;
                                break;
                        }
                }

                in_esc = 0;

                if (in_ascii)
                {
                        tmp[i++] = c;
                        if (c == 'm')
                        {
                                in_ascii = 0;
                                continue;
                        }
                        if (i == 2 && c >= 'A' && c <= 'D')
                        {
                                in_ascii = 0;
                                switch (c)
                                {
                                case 'A':
                                        out = KEY_UP;
                                        break;
                                case 'B':
                                        out = KEY_DOWN;
                                        break;
                                case 'C':
                                        out = KEY_RIGHT;
                                        break;
                                case 'D':
                                        out = KEY_LEFT;
                                        break;
                                }
                                break;
                        }
                        if (i == 3 && tmp[0] == 91 && tmp[2] == 126)
                        {
                                in_ascii = 0;
                                switch (tmp[1])
                                {
                                case 49:
                                        out = KEY_HOME;
                                        break;
                                case 51:
                                        out = KEY_DEL;
                                        break;
                                case 52:
                                        out = KEY_END;
                                        break;
                                case 53:
                                        out = KEY_PGUP;
                                        break;
                                case 54:
                                        out = KEY_PGDN;
                                        break;
                                }
                                break;
                        }
                        continue;
                }

                out = ((int)c + 256) % 256;
                break;
        }

        // for debug
        // log_std ("-->[%u]\n", out);

        return out;
}

int igetch_t(long int sec)
{
        int ch;
        time_t t_begin = time(0);

        do
        {
                ch = igetch(0);
        } while ((ch == KEY_TIMEOUT || ch == 0xa) && (time(0) - t_begin < sec));

        return ch;
}

int ikbhit()
{
        int len;

        ioctl(0, FIONREAD, &len);

        return len;
}
1	sysadm	1.1	/***************************************************************************
2	sysadm	1.14	io.c - description
3			-------------------
4	sysadm	1.20	Copyright : (C) 2004-2025 by Leaflet
5			Email : leaflet@leafok.com
6	sysadm	1.1	***************************************************************************/
7
8			/***************************************************************************
9			* *
10			* This program is free software; you can redistribute it and/or modify *
11			* it under the terms of the GNU General Public License as published by *
12	sysadm	1.20	* the Free Software Foundation; either version 3 of the License, or *
13	sysadm	1.1	* (at your option) any later version. *
14			* *
15			***************************************************************************/
16
17			#include "io.h"
18	sysadm	1.16	#include "log.h"
19	sysadm	1.1	#include "common.h"
20	sysadm	1.11	#include "tcplib.h"
21	sysadm	1.1	#include <stdio.h>
22			#include <stdarg.h>
23	sysadm	1.9	#include <time.h>
24			#include <fcntl.h>
25			#include <unistd.h>
26	sysadm	1.5	#include <sys/ioctl.h>
27	sysadm	1.1
28	sysadm	1.14	int outc(char c)
29	sysadm	1.1	{
30	sysadm	1.14	int retval;
31	sysadm	1.1
32	sysadm	1.14	retval = fprintf(stdout, "%c", c);
33	sysadm	1.1
34	sysadm	1.14	return retval;
35	sysadm	1.1	}
36
37	sysadm	1.14	int prints(const char *format, ...)
38	sysadm	1.1	{
39	sysadm	1.14	va_list args;
40			int retval;
41	sysadm	1.1
42	sysadm	1.14	va_start(args, format);
43			retval = vfprintf(stdout, format, args);
44			va_end(args);
45	sysadm	1.1
46	sysadm	1.14	return retval;
47	sysadm	1.1	}
48
49	sysadm	1.14	int iflush()
50	sysadm	1.1	{
51	sysadm	1.14	int retval;
52	sysadm	1.6
53	sysadm	1.14	retval = fflush(stdout);
54	sysadm	1.6
55	sysadm	1.14	return retval;
56	sysadm	1.1	}
57
58	sysadm	1.17	int igetch(int clear_buf)
59	sysadm	1.1	{
60	sysadm	1.18	// static input buffer
61	sysadm	1.19	static unsigned char buf[256];
62			static ssize_t len = 0;
63	sysadm	1.18	static int pos = 0;
64
65			unsigned char tmp[256];
66			int out = KEY_NULL;
67			int in_esc = 0;
68			int in_ascii = 0;
69			int in_control = 0;
70			int i = 0;
71	sysadm	1.1
72	sysadm	1.17	if (clear_buf)
73			{
74			pos = 0;
75			len = 0;
76
77			return 0;
78			}
79
80	sysadm	1.14	// Stop on system exit
81			if (SYS_exit)
82			return KEY_NULL;
83	sysadm	1.12
84	sysadm	1.14	if (pos >= len)
85			{
86	sysadm	1.18	fd_set testfds;
87			struct timeval timeout;
88
89	sysadm	1.14	pos = 0;
90			len = 0;
91	sysadm	1.2
92	sysadm	1.14	FD_ZERO(&testfds);
93			FD_SET(0, &testfds);
94	sysadm	1.9
95	sysadm	1.14	timeout.tv_sec = 1;
96			timeout.tv_usec = 0;
97	sysadm	1.9
98	sysadm	1.18	int result = SignalSafeSelect(FD_SETSIZE, &testfds, (fd_set *)NULL,
99	sysadm	1.14	(fd_set *)NULL, &timeout);
100	sysadm	1.9
101	sysadm	1.14	if (result == 0)
102			{
103			return KEY_TIMEOUT;
104			}
105			if (result < 0)
106			{
107			log_error("select() error (%d) !\n", result);
108			return KEY_NULL;
109			}
110			if (result > 0)
111			{
112			if (FD_ISSET(0, &testfds))
113			{
114			len = read(0, buf, 255);
115			}
116			}
117
118			// For debug
119			// for (j = 0; j < len; j++)
120			// log_std ("<--[%u]\n", (buf[j] + 256) % 256);
121	sysadm	1.11	}
122	sysadm	1.14
123			while (pos < len)
124	sysadm	1.11	{
125	sysadm	1.18	unsigned char c = buf[pos++];
126	sysadm	1.5
127	sysadm	1.14	if (c == '\0')
128			{
129			out = c;
130			break;
131			}
132	sysadm	1.1
133	sysadm	1.14	if (c == KEY_CONTROL)
134			{
135			if (in_control == 0)
136			{
137			in_control = 1;
138			i = 0;
139			continue;
140			}
141			}
142	sysadm	1.1
143	sysadm	1.14	if (in_control)
144			{
145			tmp[i++] = c;
146			if (i >= 2)
147			{
148			out = (int)tmp[0] * 256 + tmp[1];
149			in_control = 0;
150			break;
151			}
152			continue;
153			}
154	sysadm	1.6
155	sysadm	1.14	if (c == ESC_KEY)
156			{
157			if (in_esc == 0)
158			{
159			in_esc = 1;
160			in_ascii = 1;
161			i = 0;
162			continue;
163			}
164			else
165			{
166			out = ESC_KEY;
167			in_esc = 0;
168			break;
169			}
170			}
171	sysadm	1.3
172	sysadm	1.14	in_esc = 0;
173	sysadm	1.1
174	sysadm	1.14	if (in_ascii)
175			{
176			tmp[i++] = c;
177			if (c == 'm')
178			{
179			in_ascii = 0;
180			continue;
181			}
182			if (i == 2 && c >= 'A' && c <= 'D')
183			{
184			in_ascii = 0;
185			switch (c)
186			{
187			case 'A':
188			out = KEY_UP;
189			break;
190			case 'B':
191			out = KEY_DOWN;
192			break;
193			case 'C':
194			out = KEY_RIGHT;
195			break;
196			case 'D':
197			out = KEY_LEFT;
198			break;
199			}
200			break;
201			}
202			if (i == 3 && tmp[0] == 91 && tmp[2] == 126)
203			{
204			in_ascii = 0;
205			switch (tmp[1])
206			{
207			case 49:
208			out = KEY_HOME;
209			break;
210			case 51:
211			out = KEY_DEL;
212			break;
213			case 52:
214			out = KEY_END;
215			break;
216			case 53:
217			out = KEY_PGUP;
218			break;
219			case 54:
220			out = KEY_PGDN;
221			break;
222			}
223			break;
224			}
225			continue;
226			}
227	sysadm	1.1
228	sysadm	1.14	out = ((int)c + 256) % 256;
229			break;
230	sysadm	1.1	}
231
232	sysadm	1.14	// for debug
233			// log_std ("-->[%u]\n", out);
234	sysadm	1.1
235	sysadm	1.14	return out;
236	sysadm	1.1	}
237	sysadm	1.5
238	sysadm	1.14	int igetch_t(long int sec)
239	sysadm	1.9	{
240	sysadm	1.14	int ch;
241			time_t t_begin = time(0);
242	sysadm	1.10
243	sysadm	1.14	do
244			{
245	sysadm	1.17	ch = igetch(0);
246			} while ((ch == KEY_TIMEOUT \|\| ch == 0xa) && (time(0) - t_begin < sec));
247	sysadm	1.9
248	sysadm	1.14	return ch;
249	sysadm	1.9	}
250
251	sysadm	1.14	int ikbhit()
252	sysadm	1.5	{
253	sysadm	1.14	int len;
254	sysadm	1.6
255	sysadm	1.14	ioctl(0, FIONREAD, &len);
256	sysadm	1.6
257	sysadm	1.14	return len;
258	sysadm	1.5	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1