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