cli.c

   1 /*      $OpenBSD: cli.c,v 1.13 2001/05/06 21:23:31 markus Exp $ */
   2
   3 /*
   4  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include "includes.h"
  28 RCSID("$OpenBSD: cli.c,v 1.13 2001/05/06 21:23:31 markus Exp $");
  29
  30 #include "xmalloc.h"
  31 #include "log.h"
  32 #include "cli.h"
  33
  34 static int cli_input = -1;
  35 static int cli_output = -1;
  36 static int cli_from_stdin = 0;
  37
  38 sigset_t oset;
  39 sigset_t nset;
  40 struct sigaction nsa;
  41 struct sigaction osa;
  42 struct termios ntio;
  43 struct termios otio;
  44 int echo_modified;
  45
  46 volatile int intr;
  47
  48 static int
  49 cli_open(int from_stdin)
  50 {
  51         if (cli_input >= 0 && cli_output >= 0 && cli_from_stdin == from_stdin)
  52                 return 1;
  53
  54         if (from_stdin) {
  55                 if (!cli_from_stdin && cli_input >= 0) {
  56                         (void)close(cli_input);
  57                 }
  58                 cli_input = STDIN_FILENO;
  59                 cli_output = STDERR_FILENO;
  60         } else {
  61                 cli_input = cli_output = open(_PATH_TTY, O_RDWR);
  62                 if (cli_input < 0)
  63                         fatal("You have no controlling tty.  Cannot read passphrase.");
  64         }
  65
  66         cli_from_stdin = from_stdin;
  67
  68         return cli_input >= 0 && cli_output >= 0 && cli_from_stdin == from_stdin;
  69 }
  70
  71 static void
  72 cli_close(void)
  73 {
  74         if (!cli_from_stdin && cli_input >= 0)
  75                 close(cli_input);
  76         cli_input = -1;
  77         cli_output = -1;
  78         cli_from_stdin = 0;
  79         return;
  80 }
  81
  82 void
  83 intrcatch(int sig)
  84 {
  85         intr = 1;
  86 }
  87
  88 static void
  89 cli_echo_disable(void)
  90 {
  91         sigemptyset(&nset);
  92         sigaddset(&nset, SIGTSTP);
  93         (void) sigprocmask(SIG_BLOCK, &nset, &oset);
  94
  95         intr = 0;
  96
  97         memset(&nsa, 0, sizeof(nsa));
  98         nsa.sa_handler = intrcatch;
  99         (void) sigaction(SIGINT, &nsa, &osa);
 100
 101         echo_modified = 0;
 102         if (tcgetattr(cli_input, &otio) == 0 && (otio.c_lflag & ECHO)) {
 103                 echo_modified = 1;
 104                 ntio = otio;
 105                 ntio.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
 106                 (void) tcsetattr(cli_input, TCSANOW, &ntio);
 107         }
 108         return;
 109 }
 110
 111 static void
 112 cli_echo_restore(void)
 113 {
 114         if (echo_modified != 0) {
 115                 tcsetattr(cli_input, TCSANOW, &otio);
 116                 echo_modified = 0;
 117         }
 118
 119         (void) sigprocmask(SIG_SETMASK, &oset, NULL);
 120         (void) sigaction(SIGINT, &osa, NULL);
 121
 122         if (intr != 0) {
 123                 kill(getpid(), SIGINT);
 124                 sigemptyset(&nset);
 125                 /* XXX tty has not neccessarily drained by now? */
 126                 sigsuspend(&nset);
 127                 intr = 0;
 128         }
 129         return;
 130 }
 131
 132 static int
 133 cli_read(char* buf, int size, int echo)
 134 {
 135         char ch = 0;
 136         int i = 0;
 137         int n;
 138
 139         if (!echo)
 140                 cli_echo_disable();
 141
 142         while (ch != '\n') {
 143                 n = read(cli_input, &ch, 1);
 144                 if (intr)
 145                         break;
 146                 if (n == -1 && (errno == EAGAIN || errno == EINTR))
 147                         continue;
 148                 if (n != 1)
 149                         break;
 150                 if (ch == '\n')
 151                         break;
 152                 if (i < size - 1)
 153                         buf[i++] = ch;
 154         }
 155         if (intr)
 156                 i = 0;
 157         buf[i] = '\0';
 158
 159         if (!echo)
 160                 cli_echo_restore();
 161         if (!intr && !echo)
 162                 (void) write(cli_output, "\n", 1);
 163         return i;
 164 }
 165
 166 static int
 167 cli_write(const char* buf, int size)
 168 {
 169         int i, len, pos, ret = 0;
 170         char *output, *p;
 171
 172         output = xmalloc(4*size);
 173         for (p = output, i = 0; i < size; i++) {
 174                 if (buf[i] == '\n' || buf[i] == '\r')
 175                         *p++ = buf[i];
 176                 else
 177                         p = vis(p, buf[i], 0, 0);
 178         }
 179         len = p - output;
 180
 181         for (pos = 0; pos < len; pos += ret) {
 182                 ret = write(cli_output, output + pos, len - pos);
 183                 if (ret == -1) {
 184                         xfree(output);
 185                         return -1;
 186                 }
 187         }
 188         xfree(output);
 189         return 0;
 190 }
 191
 192 /*
 193  * Presents a prompt and returns the response allocated with xmalloc().
 194  * Uses /dev/tty or stdin/out depending on arg.  Optionally disables echo
 195  * of response depending on arg.  Tries to ensure that no other userland
 196  * buffer is storing the response.
 197  */
 198 char*
 199 cli_read_passphrase(const char* prompt, int from_stdin, int echo_enable)
 200 {
 201         char    buf[BUFSIZ];
 202         char*   p;
 203
 204         if (!cli_open(from_stdin))
 205                 fatal("Cannot read passphrase.");
 206
 207         fflush(stdout);
 208
 209         cli_write(prompt, strlen(prompt));
 210         cli_read(buf, sizeof buf, echo_enable);
 211
 212         cli_close();
 213
 214         p = xstrdup(buf);
 215         memset(buf, 0, sizeof(buf));
 216         return (p);
 217 }
 218
 219 char*
 220 cli_prompt(char* prompt, int echo_enable)
 221 {
 222         return cli_read_passphrase(prompt, 0, echo_enable);
 223 }
 224
 225 void
 226 cli_mesg(char* mesg)
 227 {
 228         cli_open(0);
 229         cli_write(mesg, strlen(mesg));
 230         cli_write("\n", strlen("\n"));
 231         cli_close();
 232         return;
 233 }