lbbs/src/io.c

/***************************************************************************
                                                        io.c  -  description
                                                         -------------------
        begin                : Mon Oct 18 2004
        copyright            : (C) 2004 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 2 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 char buf[256];
        unsigned char c, tmp[256];
        int out = KEY_NULL, loop = 1, in_esc = 0, in_ascii = 0, in_control = 0, i = 0, j, result;
        static int len = 0, pos = 0;
        fd_set testfds;
        struct timeval timeout;

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

                return 0;
        }

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

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

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

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

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