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