* http.c (connect_server): [_WIN32] actually fill in the sin_addr so we
[gnupg.git] / util / ttyio.c
index 0f0f144..add7467 100644 (file)
@@ -1,5 +1,6 @@
 /* ttyio.c -  tty i/O functions
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002,
+ *               2004 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <stdarg.h>
 #include <unistd.h>
 #ifdef HAVE_TCGETATTR
-  #include <termios.h>
+#include <termios.h>
+#else
+#ifdef HAVE_TERMIO_H
+/* simulate termios with termio */
+#include <termio.h>
+#define termios termio
+#define tcsetattr ioctl
+#define TCSAFLUSH TCSETAF
+#define tcgetattr(A,B) ioctl(A,TCGETA,B)
+#define HAVE_TCGETATTR
+#endif
+#endif
+#ifdef _WIN32 /* use the odd Win32 functions */
+#include <windows.h>
+#ifdef HAVE_TCGETATTR
+#error windows and termios
 #endif
-#ifdef __MINGW32__ /* use the odd Win32 functions */
-  #include <windows.h>
-  #ifdef HAVE_TCGETATTR
-     #error mingw32 and termios
-  #endif
 #endif
 #include <errno.h>
 #include <ctype.h>
+#ifdef HAVE_READLINE_READLINE_H
+#include <readline/readline.h>
+#include <readline/history.h>
+#endif
+
 #include "util.h"
 #include "memory.h"
 #include "ttyio.h"
 
 #define CONTROL_D ('D' - 'A' + 1)
 
-
-#ifdef __MINGW32__ /* use the odd Win32 functions */
+#ifdef _WIN32 /* use the odd Win32 functions */
 static struct {
     HANDLE in, out;
 } con;
@@ -58,11 +73,43 @@ static FILE *ttyfp = NULL;
 static int initialized;
 static int last_prompt_len;
 static int batchmode;
+static int no_terminal;
 
 #ifdef HAVE_TCGETATTR
-static struct termios termsave;
-static int restore_termios;
+    static struct termios termsave;
+    static int restore_termios;
+#endif
+
+
+
+/* This is a wrapper around ttyname so that we can use it even when
+   the standard streams are redirected.  It figures the name out the
+   first time and returns it in a statically allocated buffer. */
+const char *
+tty_get_ttyname (void)
+{
+  static char *name;
+
+  /* On a GNU system ctermid() always return /dev/tty, so this does
+     not make much sense - however if it is ever changed we do the
+     Right Thing now. */
+#ifdef HAVE_CTERMID
+  static int got_name;
+
+  if (!got_name)
+    {
+      const char *s;
+      s = ctermid (NULL);
+      if (s)
+        name = strdup (s);
+      got_name = 1;
+    }
 #endif
+  /* Assume the standard tty on memory error or when there is no
+     ctermid. */
+  return name? name : "/dev/tty";
+}
+
 
 #ifdef HAVE_TCGETATTR
 static void
@@ -82,7 +129,7 @@ init_ttyfp(void)
     if( initialized )
        return;
 
-  #if defined(__MINGW32__)
+#if defined(_WIN32)
     {
        SECURITY_ATTRIBUTES sa;
 
@@ -106,18 +153,23 @@ init_ttyfp(void)
     SetConsoleMode(con.in, DEF_INPMODE );
     SetConsoleMode(con.out, DEF_OUTMODE );
 
-  #elif defined(__EMX__)
+#elif defined(__EMX__)
     ttyfp = stdout; /* Fixme: replace by the real functions: see wklib */
-  #else
-    ttyfp = batchmode? stderr : fopen("/dev/tty", "r+");
+#else
+    ttyfp = batchmode? stderr : fopen( tty_get_ttyname (), "r+");
     if( !ttyfp ) {
-       log_error("cannot open /dev/tty: %s\n", strerror(errno) );
+       log_error("cannot open `%s': %s\n",
+                  tty_get_ttyname (), strerror(errno) );
        exit(2);
     }
-  #endif
-  #ifdef HAVE_TCGETATTR
+#if defined(HAVE_READLINE_READLINE_H) && defined(HAVE_LIBREADLINE)
+    rl_catch_signals = 0;
+    rl_instream = rl_outstream = ttyfp;
+#endif
+#endif
+#ifdef HAVE_TCGETATTR
     atexit( cleanup );
-  #endif
+#endif
     initialized = 1;
 }
 
@@ -130,54 +182,94 @@ tty_batchmode( int onoff )
     return old;
 }
 
+int
+tty_no_terminal(int onoff)
+{
+    int old = no_terminal;
+    no_terminal = onoff ? 1 : 0;
+    return old;
+}
+
 void
 tty_printf( const char *fmt, ... )
 {
     va_list arg_ptr;
 
+    if (no_terminal)
+       return;
+
     if( !initialized )
        init_ttyfp();
 
     va_start( arg_ptr, fmt ) ;
-  #ifdef __MINGW32__
-    { static char *buf;
-      static size_t bufsize;
-       int n;
+#ifdef _WIN32
+    {   
+        char *buf = NULL;
+        int n;
        DWORD nwritten;
 
-      #if 0 /* the dox say, that there is a snprintf, but I didn't found
-            * it, so we use a static buffer for now */
-       do {
-           if( n == -1 || !buf ) {
-               m_free(buf);
-               bufsize += 200;
-               /* better check the new size; (we use M$ functions) */
-               if( bufsize > 50000 )
-                   log_bug("vsnprintf probably failed\n");
-               buf = m_alloc( bufsize );
-           }
-           n = _vsnprintf(buf, bufsize-1, fmt, arg_ptr);
-       } while( n == -1 );
-      #else
-       if( !buf ) {
-           bufsize += 1000;
-           buf = m_alloc( bufsize );
-       }
-       n = vsprintf(buf, fmt, arg_ptr);
-       if( n == -1 )
-           log_bug("vsprintf() failed\n");
-      #endif
+       n = vasprintf(&buf, fmt, arg_ptr);
+       if( !buf )
+           log_bug("vasprintf() failed\n");
+        
+       if( !WriteConsoleA( con.out, buf, n, &nwritten, NULL ) )
+           log_fatal("WriteConsole failed: rc=%d", (int)GetLastError() );
+       if( n != nwritten )
+           log_fatal("WriteConsole failed: %d != %d\n", n, (int)nwritten );
+       last_prompt_len += n;
+        m_free (buf);
+    }
+#else
+    last_prompt_len += vfprintf(ttyfp,fmt,arg_ptr) ;
+    fflush(ttyfp);
+#endif
+    va_end(arg_ptr);
+}
 
+
+/* Same as tty_printf but if FP is not NULL, behave like the standard
+   fprintf. */
+void
+tty_fprintf (FILE *fp, const char *fmt, ... )
+{
+  va_list arg_ptr;
+
+  if (fp)
+    {
+      va_start (arg_ptr, fmt) ;
+      vfprintf (fp, fmt, arg_ptr );
+      va_end (arg_ptr);
+      return;
+    }
+
+  if (no_terminal)
+    return;
+
+  if( !initialized )
+    init_ttyfp();
+
+    va_start( arg_ptr, fmt ) ;
+#ifdef _WIN32
+    {   
+        char *buf = NULL;
+        int n;
+       DWORD nwritten;
+
+       n = vasprintf(&buf, fmt, arg_ptr);
+       if( !buf )
+           log_bug("vasprintf() failed\n");
+        
        if( !WriteConsoleA( con.out, buf, n, &nwritten, NULL ) )
            log_fatal("WriteConsole failed: rc=%d", (int)GetLastError() );
        if( n != nwritten )
-           log_fatal("WriteConsole failed: %d != %ld\n", n, nwritten );
+           log_fatal("WriteConsole failed: %d != %d\n", n, (int)nwritten );
        last_prompt_len += n;
+        xfree (buf);
     }
-  #else
+#else
     last_prompt_len += vfprintf(ttyfp,fmt,arg_ptr) ;
     fflush(ttyfp);
-  #endif
+#endif
     va_end(arg_ptr);
 }
 
@@ -186,12 +278,15 @@ tty_printf( const char *fmt, ... )
  * Print a string, but filter all control characters out.
  */
 void
-tty_print_string( byte *p, size_t n )
+tty_print_string( const byte *p, size_t n )
 {
+    if (no_terminal)
+       return;
+
     if( !initialized )
        init_ttyfp();
 
-  #ifdef __MINGW32__
+#ifdef _WIN32
     /* not so effective, change it if you want */
     for( ; n; n--, p++ )
        if( iscntrl( *p ) ) {
@@ -204,7 +299,7 @@ tty_print_string( byte *p, size_t n )
        }
        else
            tty_printf("%c", *p);
-  #else
+#else
     for( ; n; n--, p++ )
        if( iscntrl( *p ) ) {
            putc('\\', ttyfp);
@@ -217,18 +312,54 @@ tty_print_string( byte *p, size_t n )
        }
        else
            putc(*p, ttyfp);
-  #endif
+#endif
 }
 
+void
+tty_print_utf8_string2 (const byte *p, size_t n, size_t max_n )
+{
+    size_t i;
+    char *buf;
 
+    if (no_terminal)
+       return;
 
+    /* we can handle plain ascii simpler, so check for it first */
+    for(i=0; i < n; i++ ) {
+       if( p[i] & 0x80 )
+           break;
+    }
+    if( i < n ) {
+       buf = utf8_to_native( p, n, 0 );
+       if( max_n && (strlen( buf ) > max_n )) {
+           buf[max_n] = 0;
+       }
+       /*(utf8 conversion already does the control character quoting)*/
+       tty_printf("%s", buf );
+       m_free( buf );
+    }
+    else {
+       if( max_n && (n > max_n) ) {
+           n = max_n;
+       }
+       tty_print_string( p, n );
+    }
+}
+
+void
+tty_print_utf8_string( const byte *p, size_t n )
+{
+    tty_print_utf8_string2( p, n, 0 );
+}
 
 
 static char *
 do_get( const char *prompt, int hidden )
 {
     char *buf;
+#ifndef __riscos__
     byte cbuf[1];
+#endif
     int c, n, i;
 
     if( batchmode ) {
@@ -236,15 +367,20 @@ do_get( const char *prompt, int hidden )
        exit(2);
     }
 
+    if (no_terminal) {
+       log_error("Sorry, no terminal at all requested - can't get input\n");
+       exit(2);
+    }
+
     if( !initialized )
        init_ttyfp();
 
     last_prompt_len = 0;
-    tty_printf( prompt );
+    tty_printf( "%s", prompt );
     buf = m_alloc(n=50);
     i = 0;
 
-  #if __MINGW32__ /* windoze version */
+#ifdef _WIN32 /* windoze version */
     if( hidden )
        SetConsoleMode(con.in, HID_INPMODE );
 
@@ -278,9 +414,49 @@ do_get( const char *prompt, int hidden )
     if( hidden )
        SetConsoleMode(con.in, DEF_INPMODE );
 
-  #else /* unix version */
+#elif defined(__riscos__)
+    do {
+        c = riscos_getchar();
+        if (c == 0xa || c == 0xd) { /* Return || Enter */
+            c = (int) '\n';
+        } else if (c == 0x8 || c == 0x7f) { /* Backspace || Delete */
+            if (i>0) {
+                i--;
+                if (!hidden) {
+                    last_prompt_len--;
+                    fputc(8, ttyfp);
+                    fputc(32, ttyfp);
+                    fputc(8, ttyfp);
+                    fflush(ttyfp);
+                }
+            } else {
+                fputc(7, ttyfp);
+                fflush(ttyfp);
+            }
+            continue;
+        } else if (c == (int) '\t') { /* Tab */
+            c = ' ';
+        } else if (c > 0xa0) {
+            ; /* we don't allow 0xa0, as this is a protected blank which may
+               * confuse the user */
+        } else if (iscntrl(c)) {
+            continue;
+        }
+        if(!(i < n-1)) {
+            n += 50;
+            buf = m_realloc(buf, n);
+        }
+        buf[i++] = c;
+        if (!hidden) {
+           last_prompt_len++;
+            fputc(c, ttyfp);
+            fflush(ttyfp);
+        }
+    } while (c != '\n');
+    i = (i>0) ? i-1 : 0;
+#else /* unix version */
     if( hidden ) {
-      #ifdef HAVE_TCGETATTR
+#ifdef HAVE_TCGETATTR
        struct termios term;
 
        if( tcgetattr(fileno(ttyfp), &termsave) )
@@ -290,7 +466,7 @@ do_get( const char *prompt, int hidden )
        term.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
        if( tcsetattr( fileno(ttyfp), TCSAFLUSH, &term ) )
            log_fatal("tcsetattr() failed: %s\n", strerror(errno) );
-      #endif
+#endif
     }
 
     /* fixme: How can we avoid that the \n is echoed w/o disabling
@@ -321,13 +497,13 @@ do_get( const char *prompt, int hidden )
 
 
     if( hidden ) {
-      #ifdef HAVE_TCGETATTR
+#ifdef HAVE_TCGETATTR
        if( tcsetattr(fileno(ttyfp), TCSAFLUSH, &termsave) )
            log_error("tcsetattr() failed: %s\n", strerror(errno) );
        restore_termios = 0;
-      #endif
+#endif
     }
-  #endif /* end unix version */
+#endif /* end unix version */
     buf[i] = 0;
     return buf;
 }
@@ -336,7 +512,40 @@ do_get( const char *prompt, int hidden )
 char *
 tty_get( const char *prompt )
 {
-    return do_get( prompt, 0 );
+#if defined(HAVE_READLINE_READLINE_H) && defined(HAVE_LIBREADLINE)
+    if (!batchmode && !no_terminal) {
+      char *line;
+      char *buf;
+
+      if( !initialized )
+       init_ttyfp();
+
+      last_prompt_len = 0;
+
+      line = readline (prompt?prompt:"");
+
+      /* We need to copy it to memory controlled by our malloc
+         implementations; further we need to convert an EOF to our
+         convention. */
+      buf = m_alloc(line? strlen(line)+1:2);
+      if (line)
+        {
+          strcpy (buf, line);
+          trim_spaces (buf);
+          if (strlen (buf) > 2 )
+            add_history (line); /* Note that we test BUF but add LINE. */
+          free (line);
+        }
+      else
+        {
+          buf[0] = CONTROL_D;
+          buf[1] = 0;
+        }
+      return buf;
+    }
+    else
+#endif /* HAVE_READLINE_READLINE_H && HAVE_LIBREADLINE */
+      return do_get( prompt, 0 );
 }
 
 char *
@@ -349,16 +558,19 @@ tty_get_hidden( const char *prompt )
 void
 tty_kill_prompt()
 {
+    if ( no_terminal )
+       return;
 
     if( !initialized )
        init_ttyfp();
+
     if( batchmode )
        last_prompt_len = 0;
     if( !last_prompt_len )
        return;
-  #if __MINGW32__
+#ifdef _WIN32
     tty_printf("\r%*s\r", last_prompt_len, "");
-  #else
+#else
     {
        int i;
        putc('\r', ttyfp);
@@ -367,7 +579,7 @@ tty_kill_prompt()
        putc('\r', ttyfp);
        fflush(ttyfp);
     }
-  #endif
+#endif
     last_prompt_len = 0;
 }
 
@@ -382,4 +594,3 @@ tty_get_answer_is_yes( const char *prompt )
     m_free(p);
     return yes;
 }
-