* card-util.c (card_status): Use isotimestamp and not the
[gnupg.git] / util / ttyio.c
1 /* ttyio.c -  tty i/O functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
3  *               2004 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stdarg.h>
27 #include <unistd.h>
28 #ifdef HAVE_TCGETATTR
29 #include <termios.h>
30 #else
31 #ifdef HAVE_TERMIO_H
32 /* simulate termios with termio */
33 #include <termio.h>
34 #define termios termio
35 #define tcsetattr ioctl
36 #define TCSAFLUSH TCSETAF
37 #define tcgetattr(A,B) ioctl(A,TCGETA,B)
38 #define HAVE_TCGETATTR
39 #endif
40 #endif
41 #ifdef _WIN32 /* use the odd Win32 functions */
42 #include <windows.h>
43 #ifdef HAVE_TCGETATTR
44 #error windows and termios
45 #endif
46 #endif
47 #include <errno.h>
48 #include <ctype.h>
49 #ifdef HAVE_LIBREADLINE
50 #include <readline/readline.h>
51 #include <readline/history.h>
52 #endif
53
54 #include "util.h"
55 #include "memory.h"
56 #include "ttyio.h"
57
58 #define CONTROL_D ('D' - 'A' + 1)
59
60 #ifdef _WIN32 /* use the odd Win32 functions */
61 static struct {
62     HANDLE in, out;
63 } con;
64 #define DEF_INPMODE  (ENABLE_LINE_INPUT|ENABLE_ECHO_INPUT    \
65                                         |ENABLE_PROCESSED_INPUT )
66 #define HID_INPMODE  (ENABLE_LINE_INPUT|ENABLE_PROCESSED_INPUT )
67 #define DEF_OUTMODE  (ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT)
68
69 #else /* yeah, we have a real OS */
70 static FILE *ttyfp = NULL;
71 #endif
72
73 static int initialized;
74 static int last_prompt_len;
75 static int batchmode;
76 static int no_terminal;
77
78 #ifdef HAVE_TCGETATTR
79     static struct termios termsave;
80     static int restore_termios;
81 #endif
82
83
84
85 /* This is a wrapper around ttyname so that we can use it even when
86    the standard streams are redirected.  It figures the name out the
87    first time and returns it in a statically allocated buffer. */
88 const char *
89 tty_get_ttyname (void)
90 {
91   static char *name;
92
93   /* On a GNU system ctermid() always return /dev/tty, so this does
94      not make much sense - however if it is ever changed we do the
95      Right Thing now. */
96 #ifdef HAVE_CTERMID
97   static int got_name;
98
99   if (!got_name)
100     {
101       const char *s;
102       s = ctermid (NULL);
103       if (s)
104         name = strdup (s);
105       got_name = 1;
106     }
107 #endif
108   /* Assume the standard tty on memory error or when there is no
109      ctermid. */
110   return name? name : "/dev/tty";
111 }
112
113
114 #ifdef HAVE_TCGETATTR
115 static void
116 cleanup(void)
117 {
118     if( restore_termios ) {
119         restore_termios = 0; /* do it prios in case it is interrupted again */
120         if( tcsetattr(fileno(ttyfp), TCSAFLUSH, &termsave) )
121             log_error("tcsetattr() failed: %s\n", strerror(errno) );
122     }
123 }
124 #endif
125
126 static void
127 init_ttyfp(void)
128 {
129     if( initialized )
130         return;
131
132 #if defined(_WIN32)
133     {
134         SECURITY_ATTRIBUTES sa;
135
136         memset(&sa, 0, sizeof(sa));
137         sa.nLength = sizeof(sa);
138         sa.bInheritHandle = TRUE;
139         con.out = CreateFileA( "CONOUT$", GENERIC_READ|GENERIC_WRITE,
140                                FILE_SHARE_READ|FILE_SHARE_WRITE,
141                                &sa, OPEN_EXISTING, 0, 0 );
142         if( con.out == INVALID_HANDLE_VALUE )
143             log_fatal ("open(CONOUT$) failed: %s", w32_strerror (0));
144         memset(&sa, 0, sizeof(sa));
145         sa.nLength = sizeof(sa);
146         sa.bInheritHandle = TRUE;
147         con.in = CreateFileA( "CONIN$", GENERIC_READ|GENERIC_WRITE,
148                                FILE_SHARE_READ|FILE_SHARE_WRITE,
149                                &sa, OPEN_EXISTING, 0, 0 );
150         if (con.in == INVALID_HANDLE_VALUE)
151             log_fatal ("open(CONIN$) failed: %s", w32_strerror (0));
152     }
153     SetConsoleMode(con.in, DEF_INPMODE );
154     SetConsoleMode(con.out, DEF_OUTMODE );
155
156 #elif defined(__EMX__)
157     ttyfp = stdout; /* Fixme: replace by the real functions: see wklib */
158 #else
159     ttyfp = batchmode? stderr : fopen( tty_get_ttyname (), "r+");
160     if( !ttyfp ) {
161         log_error("cannot open `%s': %s\n",
162                   tty_get_ttyname (), strerror(errno) );
163         exit(2);
164     }
165 #ifdef HAVE_LIBREADLINE
166     rl_catch_signals = 0;
167     rl_instream = rl_outstream = ttyfp;
168 #endif
169 #endif
170 #ifdef HAVE_TCGETATTR
171     atexit( cleanup );
172 #endif
173     initialized = 1;
174 }
175
176 int
177 tty_batchmode( int onoff )
178 {
179     int old = batchmode;
180     if( onoff != -1 )
181         batchmode = onoff;
182     return old;
183 }
184
185 int
186 tty_no_terminal(int onoff)
187 {
188     int old = no_terminal;
189     no_terminal = onoff ? 1 : 0;
190     return old;
191 }
192
193 void
194 tty_printf( const char *fmt, ... )
195 {
196     va_list arg_ptr;
197
198     if (no_terminal)
199         return;
200
201     if( !initialized )
202         init_ttyfp();
203
204     va_start( arg_ptr, fmt ) ;
205 #ifdef _WIN32
206     {   
207         char *buf = NULL;
208         int n;
209         DWORD nwritten;
210
211         n = vasprintf(&buf, fmt, arg_ptr);
212         if( !buf )
213             log_bug("vasprintf() failed\n");
214         
215         if (!WriteConsoleA (con.out, buf, n, &nwritten, NULL))
216             log_fatal ("WriteConsole failed: %s", w32_strerror (0));
217         if( n != nwritten )
218             log_fatal ("WriteConsole failed: %d != %d\n", n, (int)nwritten );
219         last_prompt_len += n;
220         m_free (buf);
221     }
222 #else
223     last_prompt_len += vfprintf(ttyfp,fmt,arg_ptr) ;
224     fflush(ttyfp);
225 #endif
226     va_end(arg_ptr);
227 }
228
229
230 /* Same as tty_printf but if FP is not NULL, behave like the standard
231    fprintf. */
232 void
233 tty_fprintf (FILE *fp, const char *fmt, ... )
234 {
235   va_list arg_ptr;
236
237   if (fp)
238     {
239       va_start (arg_ptr, fmt) ;
240       vfprintf (fp, fmt, arg_ptr );
241       va_end (arg_ptr);
242       return;
243     }
244
245   if (no_terminal)
246     return;
247
248   if( !initialized )
249     init_ttyfp();
250
251     va_start( arg_ptr, fmt ) ;
252 #ifdef _WIN32
253     {   
254         char *buf = NULL;
255         int n;
256         DWORD nwritten;
257
258         n = vasprintf(&buf, fmt, arg_ptr);
259         if( !buf )
260             log_bug("vasprintf() failed\n");
261         
262         if (!WriteConsoleA (con.out, buf, n, &nwritten, NULL))
263             log_fatal ("WriteConsole failed: %s", w32_strerror (0));
264         if (n != nwritten)
265             log_fatal ("WriteConsole failed: %d != %d\n", n, (int)nwritten);
266         last_prompt_len += n;
267         xfree (buf);
268     }
269 #else
270     last_prompt_len += vfprintf(ttyfp,fmt,arg_ptr) ;
271     fflush(ttyfp);
272 #endif
273     va_end(arg_ptr);
274 }
275
276
277 /****************
278  * Print a string, but filter all control characters out.
279  */
280 void
281 tty_print_string( const byte *p, size_t n )
282 {
283     if (no_terminal)
284         return;
285
286     if( !initialized )
287         init_ttyfp();
288
289 #ifdef _WIN32
290     /* not so effective, change it if you want */
291     for( ; n; n--, p++ )
292         if( iscntrl( *p ) ) {
293             if( *p == '\n' )
294                 tty_printf("\\n");
295             else if( !*p )
296                 tty_printf("\\0");
297             else
298                 tty_printf("\\x%02x", *p);
299         }
300         else
301             tty_printf("%c", *p);
302 #else
303     for( ; n; n--, p++ )
304         if( iscntrl( *p ) ) {
305             putc('\\', ttyfp);
306             if( *p == '\n' )
307                 putc('n', ttyfp);
308             else if( !*p )
309                 putc('0', ttyfp);
310             else
311                 fprintf(ttyfp, "x%02x", *p );
312         }
313         else
314             putc(*p, ttyfp);
315 #endif
316 }
317
318 void
319 tty_print_utf8_string2 (const byte *p, size_t n, size_t max_n )
320 {
321     size_t i;
322     char *buf;
323
324     if (no_terminal)
325         return;
326
327     /* we can handle plain ascii simpler, so check for it first */
328     for(i=0; i < n; i++ ) {
329         if( p[i] & 0x80 )
330             break;
331     }
332     if( i < n ) {
333         buf = utf8_to_native( p, n, 0 );
334         if( max_n && (strlen( buf ) > max_n )) {
335             buf[max_n] = 0;
336         }
337         /*(utf8 conversion already does the control character quoting)*/
338         tty_printf("%s", buf );
339         m_free( buf );
340     }
341     else {
342         if( max_n && (n > max_n) ) {
343             n = max_n;
344         }
345         tty_print_string( p, n );
346     }
347 }
348
349 void
350 tty_print_utf8_string( const byte *p, size_t n )
351 {
352     tty_print_utf8_string2( p, n, 0 );
353 }
354
355
356 static char *
357 do_get( const char *prompt, int hidden )
358 {
359     char *buf;
360 #ifndef __riscos__
361     byte cbuf[1];
362 #endif
363     int c, n, i;
364
365     if( batchmode ) {
366         log_error("Sorry, we are in batchmode - can't get input\n");
367         exit(2);
368     }
369
370     if (no_terminal) {
371         log_error("Sorry, no terminal at all requested - can't get input\n");
372         exit(2);
373     }
374
375     if( !initialized )
376         init_ttyfp();
377
378     last_prompt_len = 0;
379     tty_printf( "%s", prompt );
380     buf = m_alloc(n=50);
381     i = 0;
382
383 #ifdef _WIN32 /* windoze version */
384     if( hidden )
385         SetConsoleMode(con.in, HID_INPMODE );
386
387     for(;;) {
388         DWORD nread;
389
390         if (!ReadConsoleA (con.in, cbuf, 1, &nread, NULL))
391             log_fatal ("ReadConsole failed: %s", w32_strerror (0));
392         if( !nread )
393             continue;
394         if( *cbuf == '\n' )
395             break;
396
397         if( !hidden )
398             last_prompt_len++;
399         c = *cbuf;
400         if( c == '\t' )
401             c = ' ';
402         else if( c > 0xa0 )
403             ; /* we don't allow 0xa0, as this is a protected blank which may
404                * confuse the user */
405         else if( iscntrl(c) )
406             continue;
407         if( !(i < n-1) ) {
408             n += 50;
409             buf = m_realloc( buf, n );
410         }
411         buf[i++] = c;
412     }
413
414     if( hidden )
415         SetConsoleMode(con.in, DEF_INPMODE );
416
417 #elif defined(__riscos__)
418     do {
419         c = riscos_getchar();
420         if (c == 0xa || c == 0xd) { /* Return || Enter */
421             c = (int) '\n';
422         } else if (c == 0x8 || c == 0x7f) { /* Backspace || Delete */
423             if (i>0) {
424                 i--;
425                 if (!hidden) {
426                     last_prompt_len--;
427                     fputc(8, ttyfp);
428                     fputc(32, ttyfp);
429                     fputc(8, ttyfp);
430                     fflush(ttyfp);
431                 }
432             } else {
433                 fputc(7, ttyfp);
434                 fflush(ttyfp);
435             }
436             continue;
437         } else if (c == (int) '\t') { /* Tab */
438             c = ' ';
439         } else if (c > 0xa0) {
440             ; /* we don't allow 0xa0, as this is a protected blank which may
441                * confuse the user */
442         } else if (iscntrl(c)) {
443             continue;
444         }
445         if(!(i < n-1)) {
446             n += 50;
447             buf = m_realloc(buf, n);
448         }
449         buf[i++] = c;
450         if (!hidden) {
451             last_prompt_len++;
452             fputc(c, ttyfp);
453             fflush(ttyfp);
454         }
455     } while (c != '\n');
456     i = (i>0) ? i-1 : 0;
457 #else /* unix version */
458     if( hidden ) {
459 #ifdef HAVE_TCGETATTR
460         struct termios term;
461
462         if( tcgetattr(fileno(ttyfp), &termsave) )
463             log_fatal("tcgetattr() failed: %s\n", strerror(errno) );
464         restore_termios = 1;
465         term = termsave;
466         term.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
467         if( tcsetattr( fileno(ttyfp), TCSAFLUSH, &term ) )
468             log_fatal("tcsetattr() failed: %s\n", strerror(errno) );
469 #endif
470     }
471
472     /* fixme: How can we avoid that the \n is echoed w/o disabling
473      * canonical mode - w/o this kill_prompt can't work */
474     while( read(fileno(ttyfp), cbuf, 1) == 1 && *cbuf != '\n' ) {
475         if( !hidden )
476             last_prompt_len++;
477         c = *cbuf;
478         if( c == CONTROL_D )
479             log_info("control d found\n");
480         if( c == '\t' )
481             c = ' ';
482         else if( c > 0xa0 )
483             ; /* we don't allow 0xa0, as this is a protected blank which may
484                * confuse the user */
485         else if( iscntrl(c) )
486             continue;
487         if( !(i < n-1) ) {
488             n += 50;
489             buf = m_realloc( buf, n );
490         }
491         buf[i++] = c;
492     }
493     if( *cbuf != '\n' ) {
494         buf[0] = CONTROL_D;
495         i = 1;
496     }
497
498
499     if( hidden ) {
500 #ifdef HAVE_TCGETATTR
501         if( tcsetattr(fileno(ttyfp), TCSAFLUSH, &termsave) )
502             log_error("tcsetattr() failed: %s\n", strerror(errno) );
503         restore_termios = 0;
504 #endif
505     }
506 #endif /* end unix version */
507     buf[i] = 0;
508     return buf;
509 }
510
511
512 char *
513 tty_get( const char *prompt )
514 {
515 #ifdef HAVE_LIBREADLINE
516     if (!batchmode && !no_terminal) {
517       char *line;
518       char *buf;
519
520       if( !initialized )
521         init_ttyfp();
522
523       last_prompt_len = 0;
524
525       line = readline (prompt?prompt:"");
526
527       /* We need to copy it to memory controlled by our malloc
528          implementations; further we need to convert an EOF to our
529          convention. */
530       buf = m_alloc(line? strlen(line)+1:2);
531       if (line)
532         {
533           strcpy (buf, line);
534           trim_spaces (buf);
535           if (strlen (buf) > 2 )
536             add_history (line); /* Note that we test BUF but add LINE. */
537           free (line);
538         }
539       else
540         {
541           buf[0] = CONTROL_D;
542           buf[1] = 0;
543         }
544       return buf;
545     }
546     else
547 #endif /* HAVE_LIBREADLINE */
548       return do_get( prompt, 0 );
549 }
550
551 char *
552 tty_get_hidden( const char *prompt )
553 {
554     return do_get( prompt, 1 );
555 }
556
557
558 void
559 tty_kill_prompt()
560 {
561     if ( no_terminal )
562         return;
563
564     if( !initialized )
565         init_ttyfp();
566
567     if( batchmode )
568         last_prompt_len = 0;
569     if( !last_prompt_len )
570         return;
571 #ifdef _WIN32
572     tty_printf("\r%*s\r", last_prompt_len, "");
573 #else
574     {
575         int i;
576         putc('\r', ttyfp);
577         for(i=0; i < last_prompt_len; i ++ )
578             putc(' ', ttyfp);
579         putc('\r', ttyfp);
580         fflush(ttyfp);
581     }
582 #endif
583     last_prompt_len = 0;
584 }
585
586
587 int
588 tty_get_answer_is_yes( const char *prompt )
589 {
590     int yes;
591     char *p = tty_get( prompt );
592     tty_kill_prompt();
593     yes = answer_is_yes(p);
594     m_free(p);
595     return yes;
596 }