2 * Copyright 2000, International Business Machines Corporation and others.
5 * This software has been released under the terms of the IBM Public
6 * License. For details, see the LICENSE file in the top-level source
7 * directory or online at http://www.openafs.org/dl/license10.html
11 * LWP_WaitForKeystroke - wait indefinitely or for a specified number of
12 * seconds for keyboard input.
14 * If seconds < 0, LWP_WaitForKeystroke will wait indefinitely.
15 * If seconds == 0, LWP_WaitForKeystroke will just determine if data is now
17 * Otherwise, wait "seconds" for data.
19 * Return 1 if data available.
22 #include <afsconfig.h>
23 #include <afs/param.h>
27 #ifdef HAVE_STDIO_EXT_H
28 #include <stdio_ext.h>
30 #include <sys/types.h>
42 #define LWP_KEYSTROKE_DELAY 250 /* 250ms. Must be < 1000 */
43 #define LWP_MAXLINELEN 256
46 /* LWP_WaitForKeystroke : Wait until a key has been struck or time (secconds)
47 * runs out and return to caller. The NT version of this function will return
48 * immediately after a key has been pressed (doesn't wait for cr).
50 * seconds: wait for <seconds> seconds before returning. If seconds < 0,
53 * 1: Keyboard input available
54 * 0: seconds elapsed. Timeout.
57 LWP_WaitForKeystroke(int seconds)
59 time_t startTime, nowTime;
61 #ifndef AFS_PTHREAD_ENV
65 twait.tv_usec = LWP_KEYSTROKE_DELAY;
74 /* check if we have a keystroke */
81 /* sleep for LWP_KEYSTROKE_DELAY ms and let other
83 #ifdef AFS_PTHREAD_ENV
84 Sleep(LWP_KEYSTROKE_DELAY);
86 IOMGR_Select(0, 0, 0, 0, &twait);
88 if (seconds > 0) { /* we only worry about elapsed time if
89 * not looping forever (seconds < 0) */
90 /* now check elapsed time */
92 timeleft = seconds - difftime(nowTime, startTime);
100 /* LWP_GetLine() - Waits indefinitely until a newline has been typed
101 * and then returns the line typed.
103 * This is trivial in unix, but requires some processing on NT.
104 * we basically read all chars into a buffer until we hit a newline and
105 * then return it to the user.
107 * n - a whole line has been read.(has n chars)
108 * 0 - buf not big enough.
109 * -1 - line with only EOF
113 LWP_GetLine(char *linebuf, int len)
119 /* loop until a new line has been entered */
120 while (ch != '\r' && cnt < len - 1) {
121 LWP_WaitForKeystroke(-1);
124 if ((ch == EOF) && (cnt == 0))
127 if (ch == '\b') { /* print and throw away a backspace */
128 if (!cnt) /* if we are at the start of the line don't bspace */
130 /* print a space to delete char and move cursor back */
139 if (ch == '\r') { /* got a cr. translate to nl */
140 linebuf[cnt - 1] = '\n';
144 } else { /* buffer too small */
151 /* LWP_WaitForKeystroke(Unix) :Wait until a key has been struck or time (secconds)
152 * runs out and return to caller. The Unix version will actually wait until
153 * a <cr> has been entered before returning.
155 * seconds: wait for <seconds> seconds before returning. If seconds < 0,
158 * 1: Keyboard input available
159 * 0: seconds elapsed. Timeout.
162 LWP_WaitForKeystroke(int seconds)
166 struct timeval twait;
167 struct timeval *tp = NULL;
169 #if defined(HAVE_STDIO_EXT_H)
170 if (__fbufsize(stdin) > 0)
172 #elif defined(AFS_LINUX20_ENV)
173 if (stdin->_IO_read_ptr < stdin->_IO_read_end)
175 #elif (defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)) && defined(AFS_DFBSD_ENV)
177 unsigned char *_base;
182 struct __FILE_public pub;
183 struct appx_sbuf _bf; /* the buffer (at least 1 byte, if !NULL) */
185 struct APPX_FILE *appx_stdin = (struct APPX_FILE *) stdin;
186 if (appx_stdin->_bf._size > 0)
188 #elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
189 if (stdin->_bf._size > 0)
197 FD_SET(fileno(stdin), &rdfds);
200 twait.tv_sec = seconds;
205 #ifdef AFS_PTHREAD_ENV
206 code = select(1 + fileno(stdin), &rdfds, NULL, NULL, tp);
208 code = IOMGR_Select(1 + fileno(stdin), &rdfds, NULL, NULL, tp);
211 return (code == 1) ? 1 : 0;
214 /* LWP_GetLine() - Waits indefinitely until a newline has been typed
215 * and then returns the line typed.
217 * This is trivial in unix, but requires some processing on NT.
218 * we basically read all chars into a buffer until we hit a newline and
219 * then return it to the user.
221 * n - a whole line has been read.(has n chars)
222 * 0 - buf not big enough.
223 * -1 - line with only EOF
227 LWP_GetLine(char *linebuf, int len)
232 LWP_WaitForKeystroke(-1);
234 s = fgets(linebuf, len, stdin);
238 linelen = strlen(linebuf);
239 if (linebuf[linelen - 1] != '\n') /* buffer too small */
245 #endif /* else NT40 */
247 /* LWP_GetResponseKey() - Waits for a specified period of time and
248 * returns a char when one has been typed by the user.
250 * seconds - how long to wait for a key press.
251 * *key - char entered by user
253 * 0 - Time ran out before the user typed a key.
254 * 1 - Valid char is being returned.
258 LWP_GetResponseKey(int seconds, char *key)
263 return 0; /* need space to store char */
266 fflush(stdin); /* flush all existing data and start anew */
269 rc = LWP_WaitForKeystroke(seconds);
270 if (rc == 0) { /* time ran out */
275 /* now read the char. */
277 *key = getche(); /* get char and echo it to screen */
279 *key = (char)getchar();