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