| /* |
| * OpenVPN -- An application to securely tunnel IP networks |
| * over a single UDP port, with support for SSL/TLS-based |
| * session authentication and key exchange, |
| * packet encryption, packet authentication, and |
| * packet compression. |
| * |
| * Copyright (C) 2002-2018 OpenVPN Inc <sales@openvpn.net> |
| * Copyright (C) 2014-2015 David Sommerseth <davids@redhat.com> |
| * Copyright (C) 2016-2018 David Sommerseth <davids@openvpn.net> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 |
| * as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write to the Free Software Foundation, Inc., |
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
| */ |
| |
| /* |
| * These functions covers handing user input/output using the default consoles |
| * |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #elif defined(_MSC_VER) |
| #include "config-msvc.h" |
| #endif |
| |
| #include "syshead.h" |
| #include "console.h" |
| #include "error.h" |
| #include "buffer.h" |
| #include "misc.h" |
| |
| #ifdef _WIN32 |
| |
| #include "win32.h" |
| |
| /** |
| * Get input from a Windows console. |
| * |
| * @param prompt Prompt to display to the user |
| * @param echo Should the user input be displayed in the console |
| * @param input Pointer to the buffer the user input will be saved |
| * @param capacity Size of the buffer for the user input |
| * |
| * @return Return false on input error, or if service |
| * exit event is signaled. |
| */ |
| static bool |
| get_console_input_win32(const char *prompt, const bool echo, char *input, const int capacity) |
| { |
| HANDLE in = INVALID_HANDLE_VALUE; |
| HANDLE err = INVALID_HANDLE_VALUE; |
| DWORD len = 0; |
| |
| ASSERT(prompt); |
| ASSERT(input); |
| ASSERT(capacity > 0); |
| |
| input[0] = '\0'; |
| |
| in = GetStdHandle(STD_INPUT_HANDLE); |
| err = get_orig_stderr(); |
| |
| if (in != INVALID_HANDLE_VALUE |
| && err != INVALID_HANDLE_VALUE |
| && !win32_service_interrupt(&win32_signal) |
| && WriteFile(err, prompt, strlen(prompt), &len, NULL)) |
| { |
| bool is_console = (GetFileType(in) == FILE_TYPE_CHAR); |
| DWORD flags_save = 0; |
| int status = 0; |
| WCHAR *winput; |
| |
| if (is_console) |
| { |
| if (GetConsoleMode(in, &flags_save)) |
| { |
| DWORD flags = ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT; |
| if (echo) |
| { |
| flags |= ENABLE_ECHO_INPUT; |
| } |
| SetConsoleMode(in, flags); |
| } |
| else |
| { |
| is_console = 0; |
| } |
| } |
| |
| if (is_console) |
| { |
| winput = malloc(capacity * sizeof(WCHAR)); |
| if (winput == NULL) |
| { |
| return false; |
| } |
| |
| status = ReadConsoleW(in, winput, capacity, &len, NULL); |
| WideCharToMultiByte(CP_UTF8, 0, winput, len, input, capacity, NULL, NULL); |
| free(winput); |
| } |
| else |
| { |
| status = ReadFile(in, input, capacity, &len, NULL); |
| } |
| |
| string_null_terminate(input, (int)len, capacity); |
| chomp(input); |
| |
| if (!echo) |
| { |
| WriteFile(err, "\r\n", 2, &len, NULL); |
| } |
| if (is_console) |
| { |
| SetConsoleMode(in, flags_save); |
| } |
| if (status && !win32_service_interrupt(&win32_signal)) |
| { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| #endif /* _WIN32 */ |
| |
| |
| #ifdef HAVE_GETPASS |
| |
| /** |
| * Open the current console TTY for read/write operations |
| * |
| * @params write If true, the user wants to write to the console |
| * otherwise read from the console |
| * |
| * @returns Returns a FILE pointer to either the TTY in read or write mode |
| * or stdin/stderr, depending on the write flag |
| * |
| */ |
| static FILE * |
| open_tty(const bool write) |
| { |
| FILE *ret; |
| ret = fopen("/dev/tty", write ? "w" : "r"); |
| if (!ret) |
| { |
| ret = write ? stderr : stdin; |
| } |
| return ret; |
| } |
| |
| /** |
| * Closes the TTY FILE pointer, but only if it is not a stdin/stderr FILE object. |
| * |
| * @params fp FILE pointer to close |
| * |
| */ |
| static void |
| close_tty(FILE *fp) |
| { |
| if (fp != stderr && fp != stdin) |
| { |
| fclose(fp); |
| } |
| } |
| |
| #endif /* HAVE_GETPASS */ |
| |
| |
| /** |
| * Core function for getting input from console |
| * |
| * @params prompt The prompt to present to the user |
| * @params echo Should the user see what is being typed |
| * @params input Pointer to the buffer used to save the user input |
| * @params capacity Size of the input buffer |
| * |
| * @returns Returns True if user input was gathered |
| */ |
| static bool |
| get_console_input(const char *prompt, const bool echo, char *input, const int capacity) |
| { |
| bool ret = false; |
| ASSERT(prompt); |
| ASSERT(input); |
| ASSERT(capacity > 0); |
| input[0] = '\0'; |
| |
| #if defined(_WIN32) |
| return get_console_input_win32(prompt, echo, input, capacity); |
| #elif defined(HAVE_GETPASS) |
| |
| /* did we --daemon'ize before asking for passwords? |
| * (in which case neither stdin or stderr are connected to a tty and |
| * /dev/tty can not be open()ed anymore) |
| */ |
| if (!isatty(0) && !isatty(2) ) |
| { |
| int fd = open( "/dev/tty", O_RDWR ); |
| if (fd < 0) |
| { |
| msg(M_FATAL, "neither stdin nor stderr are a tty device and you have neither a " |
| "controlling tty nor systemd - can't ask for '%s'. If you used --daemon, " |
| "you need to use --askpass to make passphrase-protected keys work, and you " |
| "can not use --auth-nocache.", prompt ); |
| } |
| close(fd); |
| } |
| |
| if (echo) |
| { |
| FILE *fp; |
| |
| fp = open_tty(true); |
| fprintf(fp, "%s", prompt); |
| fflush(fp); |
| close_tty(fp); |
| |
| fp = open_tty(false); |
| if (fgets(input, capacity, fp) != NULL) |
| { |
| chomp(input); |
| ret = true; |
| } |
| close_tty(fp); |
| } |
| else |
| { |
| char *gp = getpass(prompt); |
| if (gp) |
| { |
| strncpynt(input, gp, capacity); |
| secure_memzero(gp, strlen(gp)); |
| ret = true; |
| } |
| } |
| #else /* if defined(_WIN32) */ |
| msg(M_FATAL, "Sorry, but I can't get console input on this OS (%s)", prompt); |
| #endif /* if defined(_WIN32) */ |
| return ret; |
| } |
| |
| |
| /** |
| * @copydoc query_user_exec() |
| * |
| * Default method for querying user using default stdin/stdout on a console. |
| * This needs to be available as a backup interface for the alternative |
| * implementations in case they cannot query through their implementation |
| * specific methods. |
| * |
| * If no alternative implementation is declared, a wrapper in console.h will ensure |
| * query_user_exec() will call this function instead. |
| * |
| */ |
| bool |
| query_user_exec_builtin(void) |
| { |
| bool ret = true; /* Presume everything goes okay */ |
| int i; |
| |
| /* Loop through configured query_user slots */ |
| for (i = 0; i < QUERY_USER_NUMSLOTS && query_user[i].response != NULL; i++) |
| { |
| if (!get_console_input(query_user[i].prompt, query_user[i].echo, |
| query_user[i].response, query_user[i].response_len) ) |
| { |
| /* Force the final result state to failed on failure */ |
| ret = false; |
| } |
| } |
| |
| return ret; |
| } |
