ui_openssl.c@ 91772

Last change on this file since 91772 was 91772, checked in by vboxsync, 3 years ago
openssl-1.1.1l: Applied and adjusted our OpenSSL changes to 1.1.1l. bugref:10126
File size: 19.2 KB

Line
1	/*
2	* Copyright 2001-2020 The OpenSSL Project Authors. All Rights Reserved.
3	*
4	* Licensed under the OpenSSL license (the "License"). You may not use
5	* this file except in compliance with the License. You can obtain a copy
6	* in the file LICENSE in the source distribution or at
7	* https://www.openssl.org/source/license.html
8	*/
9
10	#include "e_os.h"
11	#include <openssl/e_os2.h>
12	#include <openssl/err.h>
13	#include <openssl/ui.h>
14
15	#ifndef OPENSSL_NO_UI_CONSOLE
16	/*
17	* need for #define _POSIX_C_SOURCE arises whenever you pass -ansi to gcc
18	* [maybe others?], because it masks interfaces not discussed in standard,
19	* sigaction and fileno included. -pedantic would be more appropriate for the
20	* intended purposes, but we can't prevent users from adding -ansi.
21	*/
22	# if defined(OPENSSL_SYS_VXWORKS)
23	# include <sys/types.h>
24	# endif
25
26	# if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS)
27	# ifndef _POSIX_C_SOURCE
28	# define _POSIX_C_SOURCE 2
29	# endif
30	# endif
31	# include <signal.h>
32	# include <stdio.h>
33	# include <string.h>
34	# include <errno.h>
35
36	# if !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_VMS)
37	# ifdef OPENSSL_UNISTD
38	# include OPENSSL_UNISTD
39	# else
40	# include <unistd.h>
41	# endif
42	/*
43	* If unistd.h defines _POSIX_VERSION, we conclude that we are on a POSIX
44	* system and have sigaction and termios.
45	*/
46	# if defined(_POSIX_VERSION) && _POSIX_VERSION>=199309L
47
48	# define SIGACTION
49	# if !defined(TERMIOS) && !defined(TERMIO) && !defined(SGTTY)
50	# define TERMIOS
51	# endif
52
53	# endif
54	# endif
55
56	# include "ui_local.h"
57	# include "internal/cryptlib.h"
58
59	# ifdef OPENSSL_SYS_VMS /* prototypes for sys$whatever */
60	# include <starlet.h>
61	# ifdef __DECC
62	# pragma message disable DOLLARID
63	# endif
64	# endif
65
66	# ifdef WIN_CONSOLE_BUG
67	# include <windows.h>
68	# ifndef OPENSSL_SYS_WINCE
69	# include <wincon.h>
70	# endif
71	# endif
72
73	/*
74	* There are 6 types of terminal interface supported, TERMIO, TERMIOS, VMS,
75	* MSDOS, WIN32 Console and SGTTY.
76	*
77	* If someone defines one of the macros TERMIO, TERMIOS or SGTTY, it will
78	* remain respected. Otherwise, we default to TERMIOS except for a few
79	* systems that require something different.
80	*
81	* Note: we do not use SGTTY unless it's defined by the configuration. We
82	* may eventually opt to remove its use entirely.
83	*/
84
85	# if !defined(TERMIOS) && !defined(TERMIO) && !defined(SGTTY)
86
87	# if defined(_LIBC)
88	# undef TERMIOS
89	# define TERMIO
90	# undef SGTTY
91	/*
92	* We know that VMS, MSDOS, VXWORKS, use entirely other mechanisms.
93	*/
94	# elif !defined(OPENSSL_SYS_VMS) \
95	&& !defined(OPENSSL_SYS_MSDOS) \
96	&& !defined(OPENSSL_SYS_VXWORKS)
97	# define TERMIOS
98	# undef TERMIO
99	# undef SGTTY
100	# endif
101
102	# endif
103
104	# if defined(OPENSSL_SYS_VXWORKS)
105	# undef TERMIOS
106	# undef TERMIO
107	# undef SGTTY
108	# endif
109
110	# ifdef TERMIOS
111	# include <termios.h>
112	# define TTY_STRUCT struct termios
113	# define TTY_FLAGS c_lflag
114	# define TTY_get(tty,data) tcgetattr(tty,data)
115	# define TTY_set(tty,data) tcsetattr(tty,TCSANOW,data)
116	# endif
117
118	# ifdef TERMIO
119	# include <termio.h>
120	# define TTY_STRUCT struct termio
121	# define TTY_FLAGS c_lflag
122	# define TTY_get(tty,data) ioctl(tty,TCGETA,data)
123	# define TTY_set(tty,data) ioctl(tty,TCSETA,data)
124	# endif
125
126	# ifdef SGTTY
127	# include <sgtty.h>
128	# define TTY_STRUCT struct sgttyb
129	# define TTY_FLAGS sg_flags
130	# define TTY_get(tty,data) ioctl(tty,TIOCGETP,data)
131	# define TTY_set(tty,data) ioctl(tty,TIOCSETP,data)
132	# endif
133
134	# if !defined(_LIBC) && !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_VMS)
135	# include <sys/ioctl.h>
136	# endif
137
138	# ifdef OPENSSL_SYS_MSDOS
139	# include <conio.h>
140	# endif
141
142	# ifdef OPENSSL_SYS_VMS
143	# include <ssdef.h>
144	# include <iodef.h>
145	# include <ttdef.h>
146	# include <descrip.h>
147	struct IOSB {
148	short iosb$w_value;
149	short iosb$w_count;
150	long iosb$l_info;
151	};
152	# endif
153
154	# ifndef NX509_SIG
155	# define NX509_SIG 32
156	# endif
157
158	/* Define globals. They are protected by a lock */
159	# ifdef SIGACTION
160	static struct sigaction savsig[NX509_SIG];
161	# else
162	static void (*savsig[NX509_SIG]) (int);
163	# endif
164
165	# ifdef OPENSSL_SYS_VMS
166	static struct IOSB iosb;
167	static $DESCRIPTOR(terminal, "TT");
168	static long tty_orig[3], tty_new[3]; /* XXX Is there any guarantee that this
169	* will always suffice for the actual
170	* structures? */
171	static long status;
172	static unsigned short channel = 0;
173	# elif defined(_WIN32) && !defined(_WIN32_WCE)
174	static DWORD tty_orig, tty_new;
175	# else
176	# if !defined(OPENSSL_SYS_MSDOS) \|\| defined(__DJGPP__)
177	static TTY_STRUCT tty_orig, tty_new;
178	# endif
179	# endif
180	static FILE tty_in, tty_out;
181	static int is_a_tty;
182
183	/* Declare static functions */
184	# if !defined(OPENSSL_SYS_WINCE)
185	static int read_till_nl(FILE *);
186	static void recsig(int);
187	static void pushsig(void);
188	static void popsig(void);
189	# endif
190	# if defined(OPENSSL_SYS_MSDOS) && !defined(_WIN32)
191	static int noecho_fgets(char buf, int size, FILE tty);
192	# endif
193	static int read_string_inner(UI ui, UI_STRING uis, int echo, int strip_nl);
194
195	static int read_string(UI ui, UI_STRING uis);
196	static int write_string(UI ui, UI_STRING uis);
197
198	static int open_console(UI *ui);
199	static int echo_console(UI *ui);
200	static int noecho_console(UI *ui);
201	static int close_console(UI *ui);
202
203	/*
204	* The following function makes sure that info and error strings are printed
205	* before any prompt.
206	*/
207	static int write_string(UI ui, UI_STRING uis)
208	{
209	switch (UI_get_string_type(uis)) {
210	case UIT_ERROR:
211	case UIT_INFO:
212	fputs(UI_get0_output_string(uis), tty_out);
213	fflush(tty_out);
214	break;
215	case UIT_NONE:
216	case UIT_PROMPT:
217	case UIT_VERIFY:
218	case UIT_BOOLEAN:
219	break;
220	}
221	return 1;
222	}
223
224	static int read_string(UI ui, UI_STRING uis)
225	{
226	int ok = 0;
227
228	switch (UI_get_string_type(uis)) {
229	case UIT_BOOLEAN:
230	fputs(UI_get0_output_string(uis), tty_out);
231	fputs(UI_get0_action_string(uis), tty_out);
232	fflush(tty_out);
233	return read_string_inner(ui, uis,
234	UI_get_input_flags(uis) & UI_INPUT_FLAG_ECHO,
235	0);
236	case UIT_PROMPT:
237	fputs(UI_get0_output_string(uis), tty_out);
238	fflush(tty_out);
239	return read_string_inner(ui, uis,
240	UI_get_input_flags(uis) & UI_INPUT_FLAG_ECHO,
241	1);
242	case UIT_VERIFY:
243	fprintf(tty_out, "Verifying - %s", UI_get0_output_string(uis));
244	fflush(tty_out);
245	if ((ok = read_string_inner(ui, uis,
246	UI_get_input_flags(uis) &
247	UI_INPUT_FLAG_ECHO, 1)) <= 0)
248	return ok;
249	if (strcmp(UI_get0_result_string(uis), UI_get0_test_string(uis)) != 0) {
250	fprintf(tty_out, "Verify failure\n");
251	fflush(tty_out);
252	return 0;
253	}
254	break;
255	case UIT_NONE:
256	case UIT_INFO:
257	case UIT_ERROR:
258	break;
259	}
260	return 1;
261	}
262
263	# if !defined(OPENSSL_SYS_WINCE)
264	/* Internal functions to read a string without echoing */
265	static int read_till_nl(FILE *in)
266	{
267	# define SIZE 4
268	char buf[SIZE + 1];
269
270	do {
271	if (!fgets(buf, SIZE, in))
272	return 0;
273	} while (strchr(buf, '\n') == NULL);
274	return 1;
275	}
276
277	static volatile sig_atomic_t intr_signal;
278	# endif
279
280	static int read_string_inner(UI ui, UI_STRING uis, int echo, int strip_nl)
281	{
282	static int ps;
283	int ok;
284	char result[BUFSIZ];
285	int maxsize = BUFSIZ - 1;
286	# if !defined(OPENSSL_SYS_WINCE)
287	char *p = NULL;
288	int echo_eol = !echo;
289
290	intr_signal = 0;
291	ok = 0;
292	ps = 0;
293
294	pushsig();
295	ps = 1;
296
297	if (!echo && !noecho_console(ui))
298	goto error;
299	ps = 2;
300
301	result[0] = '\0';
302	# if defined(_WIN32)
303	if (is_a_tty) {
304	DWORD numread;
305	# if defined(CP_UTF8)
306	if (GetEnvironmentVariableW(L"OPENSSL_WIN32_UTF8", NULL, 0) != 0) {
307	WCHAR wresult[BUFSIZ];
308
309	if (ReadConsoleW(GetStdHandle(STD_INPUT_HANDLE),
310	wresult, maxsize, &numread, NULL)) {
311	if (numread >= 2 &&
312	wresult[numread-2] == L'\r' &&
313	wresult[numread-1] == L'\n') {
314	wresult[numread-2] = L'\n';
315	numread--;
316	}
317	wresult[numread] = '\0';
318	if (WideCharToMultiByte(CP_UTF8, 0, wresult, -1,
319	result, sizeof(result), NULL, 0) > 0)
320	p = result;
321
322	OPENSSL_cleanse(wresult, sizeof(wresult));
323	}
324	} else
325	# endif
326	if (ReadConsoleA(GetStdHandle(STD_INPUT_HANDLE),
327	result, maxsize, &numread, NULL)) {
328	if (numread >= 2 &&
329	result[numread-2] == '\r' && result[numread-1] == '\n') {
330	result[numread-2] = '\n';
331	numread--;
332	}
333	result[numread] = '\0';
334	p = result;
335	}
336	} else
337	# elif defined(OPENSSL_SYS_MSDOS)
338	if (!echo) {
339	noecho_fgets(result, maxsize, tty_in);
340	p = result; /* FIXME: noecho_fgets doesn't return errors */
341	} else
342	# endif
343	p = fgets(result, maxsize, tty_in);
344	if (p == NULL)
345	goto error;
346	if (feof(tty_in))
347	goto error;
348	if (ferror(tty_in))
349	goto error;
350	if ((p = (char *)strchr(result, '\n')) != NULL) {
351	if (strip_nl)
352	*p = '\0';
353	} else if (!read_till_nl(tty_in))
354	goto error;
355	if (UI_set_result(ui, uis, result) >= 0)
356	ok = 1;
357
358	error:
359	if (intr_signal == SIGINT)
360	ok = -1;
361	if (echo_eol)
362	fprintf(tty_out, "\n");
363	if (ps >= 2 && !echo && !echo_console(ui))
364	ok = 0;
365
366	if (ps >= 1)
367	popsig();
368	# else
369	ok = 1;
370	# endif
371
372	OPENSSL_cleanse(result, BUFSIZ);
373	return ok;
374	}
375
376	/* Internal functions to open, handle and close a channel to the console. */
377	static int open_console(UI *ui)
378	{
379	CRYPTO_THREAD_write_lock(ui->lock);
380	is_a_tty = 1;
381
382	# if defined(OPENSSL_SYS_VXWORKS)
383	tty_in = stdin;
384	tty_out = stderr;
385	# elif defined(_WIN32) && !defined(_WIN32_WCE)
386	if ((tty_out = fopen("conout$", "w")) == NULL)
387	tty_out = stderr;
388
389	if (GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &tty_orig)) {
390	tty_in = stdin;
391	} else {
392	is_a_tty = 0;
393	if ((tty_in = fopen("conin$", "r")) == NULL)
394	tty_in = stdin;
395	}
396	# else
397	# ifdef OPENSSL_SYS_MSDOS
398	# define DEV_TTY "con"
399	# else
400	# define DEV_TTY "/dev/tty"
401	# endif
402	if ((tty_in = fopen(DEV_TTY, "r")) == NULL)
403	tty_in = stdin;
404	if ((tty_out = fopen(DEV_TTY, "w")) == NULL)
405	tty_out = stderr;
406	# endif
407
408	# if defined(TTY_get) && !defined(OPENSSL_SYS_VMS)
409	if (TTY_get(fileno(tty_in), &tty_orig) == -1) {
410	# ifdef ENOTTY
411	if (errno == ENOTTY)
412	is_a_tty = 0;
413	else
414	# endif
415	# ifdef EINVAL
416	/*
417	* Ariel Glenn reports that solaris can return EINVAL instead.
418	* This should be ok
419	*/
420	if (errno == EINVAL)
421	is_a_tty = 0;
422	else
423	# endif
424	# ifdef ENXIO
425	/*
426	* Solaris can return ENXIO.
427	* This should be ok
428	*/
429	if (errno == ENXIO)
430	is_a_tty = 0;
431	else
432	# endif
433	# ifdef EIO
434	/*
435	* Linux can return EIO.
436	* This should be ok
437	*/
438	if (errno == EIO)
439	is_a_tty = 0;
440	else
441	# endif
442	# ifdef EPERM
443	/*
444	* Linux can return EPERM (Operation not permitted),
445	* e.g. if a daemon executes openssl via fork()+execve()
446	* This should be ok
447	*/
448	if (errno == EPERM)
449	is_a_tty = 0;
450	else
451	# endif
452	# ifdef ENODEV
453	/*
454	* MacOS X returns ENODEV (Operation not supported by device),
455	* which seems appropriate.
456	*/
457	if (errno == ENODEV)
458	is_a_tty = 0;
459	else
460	# endif
461	{
462	char tmp_num[10];
463	BIO_snprintf(tmp_num, sizeof(tmp_num) - 1, "%d", errno);
464	UIerr(UI_F_OPEN_CONSOLE, UI_R_UNKNOWN_TTYGET_ERRNO_VALUE);
465	ERR_add_error_data(2, "errno=", tmp_num);
466
467	return 0;
468	}
469	}
470	# endif
471	# ifdef OPENSSL_SYS_VMS
472	status = sys$assign(&terminal, &channel, 0, 0);
473
474	/* if there isn't a TT device, something is very wrong */
475	if (status != SS$_NORMAL) {
476	char tmp_num[12];
477
478	BIO_snprintf(tmp_num, sizeof(tmp_num) - 1, "%%X%08X", status);
479	UIerr(UI_F_OPEN_CONSOLE, UI_R_SYSASSIGN_ERROR);
480	ERR_add_error_data(2, "status=", tmp_num);
481	return 0;
482	}
483
484	status = sys$qiow(0, channel, IO$_SENSEMODE, &iosb, 0, 0, tty_orig, 12,
485	0, 0, 0, 0);
486
487	/* If IO$_SENSEMODE doesn't work, this is not a terminal device */
488	if ((status != SS$_NORMAL) \|\| (iosb.iosb$w_value != SS$_NORMAL))
489	is_a_tty = 0;
490	# endif
491	return 1;
492	}
493
494	static int noecho_console(UI *ui)
495	{
496	# ifdef TTY_FLAGS
497	memcpy(&(tty_new), &(tty_orig), sizeof(tty_orig));
498	tty_new.TTY_FLAGS &= ~ECHO;
499	# endif
500
501	# if defined(TTY_set) && !defined(OPENSSL_SYS_VMS)
502	if (is_a_tty && (TTY_set(fileno(tty_in), &tty_new) == -1))
503	return 0;
504	# endif
505	# ifdef OPENSSL_SYS_VMS
506	if (is_a_tty) {
507	tty_new[0] = tty_orig[0];
508	tty_new[1] = tty_orig[1] \| TT$M_NOECHO;
509	tty_new[2] = tty_orig[2];
510	status = sys$qiow(0, channel, IO$_SETMODE, &iosb, 0, 0, tty_new, 12,
511	0, 0, 0, 0);
512	if ((status != SS$_NORMAL) \|\| (iosb.iosb$w_value != SS$_NORMAL)) {
513	char tmp_num[2][12];
514
515	BIO_snprintf(tmp_num[0], sizeof(tmp_num[0]) - 1, "%%X%08X",
516	status);
517	BIO_snprintf(tmp_num[1], sizeof(tmp_num[1]) - 1, "%%X%08X",
518	iosb.iosb$w_value);
519	UIerr(UI_F_NOECHO_CONSOLE, UI_R_SYSQIOW_ERROR);
520	ERR_add_error_data(5, "status=", tmp_num[0],
521	",", "iosb.iosb$w_value=", tmp_num[1]);
522	return 0;
523	}
524	}
525	# endif
526	# if defined(_WIN32) && !defined(_WIN32_WCE)
527	if (is_a_tty) {
528	tty_new = tty_orig;
529	tty_new &= ~ENABLE_ECHO_INPUT;
530	SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), tty_new);
531	}
532	# endif
533	return 1;
534	}
535
536	static int echo_console(UI *ui)
537	{
538	# if defined(TTY_set) && !defined(OPENSSL_SYS_VMS)
539	memcpy(&(tty_new), &(tty_orig), sizeof(tty_orig));
540	if (is_a_tty && (TTY_set(fileno(tty_in), &tty_new) == -1))
541	return 0;
542	# endif
543	# ifdef OPENSSL_SYS_VMS
544	if (is_a_tty) {
545	tty_new[0] = tty_orig[0];
546	tty_new[1] = tty_orig[1];
547	tty_new[2] = tty_orig[2];
548	status = sys$qiow(0, channel, IO$_SETMODE, &iosb, 0, 0, tty_new, 12,
549	0, 0, 0, 0);
550	if ((status != SS$_NORMAL) \|\| (iosb.iosb$w_value != SS$_NORMAL)) {
551	char tmp_num[2][12];
552
553	BIO_snprintf(tmp_num[0], sizeof(tmp_num[0]) - 1, "%%X%08X",
554	status);
555	BIO_snprintf(tmp_num[1], sizeof(tmp_num[1]) - 1, "%%X%08X",
556	iosb.iosb$w_value);
557	UIerr(UI_F_ECHO_CONSOLE, UI_R_SYSQIOW_ERROR);
558	ERR_add_error_data(5, "status=", tmp_num[0],
559	",", "iosb.iosb$w_value=", tmp_num[1]);
560	return 0;
561	}
562	}
563	# endif
564	# if defined(_WIN32) && !defined(_WIN32_WCE)
565	if (is_a_tty) {
566	tty_new = tty_orig;
567	SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), tty_new);
568	}
569	# endif
570	return 1;
571	}
572
573	static int close_console(UI *ui)
574	{
575	if (tty_in != stdin)
576	fclose(tty_in);
577	if (tty_out != stderr)
578	fclose(tty_out);
579	# ifdef OPENSSL_SYS_VMS
580	status = sys$dassgn(channel);
581	if (status != SS$_NORMAL) {
582	char tmp_num[12];
583
584	BIO_snprintf(tmp_num, sizeof(tmp_num) - 1, "%%X%08X", status);
585	UIerr(UI_F_CLOSE_CONSOLE, UI_R_SYSDASSGN_ERROR);
586	ERR_add_error_data(2, "status=", tmp_num);
587	return 0;
588	}
589	# endif
590	CRYPTO_THREAD_unlock(ui->lock);
591
592	return 1;
593	}
594
595	# if !defined(OPENSSL_SYS_WINCE)
596	/* Internal functions to handle signals and act on them */
597	static void pushsig(void)
598	{
599	# ifndef OPENSSL_SYS_WIN32
600	int i;
601	# endif
602	# ifdef SIGACTION
603	struct sigaction sa;
604
605	memset(&sa, 0, sizeof(sa));
606	sa.sa_handler = recsig;
607	# endif
608
609	# ifdef OPENSSL_SYS_WIN32
610	savsig[SIGABRT] = signal(SIGABRT, recsig);
611	savsig[SIGFPE] = signal(SIGFPE, recsig);
612	savsig[SIGILL] = signal(SIGILL, recsig);
613	savsig[SIGINT] = signal(SIGINT, recsig);
614	savsig[SIGSEGV] = signal(SIGSEGV, recsig);
615	savsig[SIGTERM] = signal(SIGTERM, recsig);
616	# else
617	for (i = 1; i < NX509_SIG; i++) {
618	# ifdef SIGUSR1
619	if (i == SIGUSR1)
620	continue;
621	# endif
622	# ifdef SIGUSR2
623	if (i == SIGUSR2)
624	continue;
625	# endif
626	# ifdef SIGKILL
627	if (i == SIGKILL) /* We can't make any action on that. */
628	continue;
629	# endif
630	# ifdef SIGACTION
631	sigaction(i, &sa, &savsig[i]);
632	# else
633	savsig[i] = signal(i, recsig);
634	# endif
635	}
636	# endif
637
638	# ifdef SIGWINCH
639	signal(SIGWINCH, SIG_DFL);
640	# endif
641	}
642
643	static void popsig(void)
644	{
645	# ifdef OPENSSL_SYS_WIN32
646	signal(SIGABRT, savsig[SIGABRT]);
647	signal(SIGFPE, savsig[SIGFPE]);
648	signal(SIGILL, savsig[SIGILL]);
649	signal(SIGINT, savsig[SIGINT]);
650	signal(SIGSEGV, savsig[SIGSEGV]);
651	signal(SIGTERM, savsig[SIGTERM]);
652	# else
653	int i;
654	for (i = 1; i < NX509_SIG; i++) {
655	# ifdef SIGUSR1
656	if (i == SIGUSR1)
657	continue;
658	# endif
659	# ifdef SIGUSR2
660	if (i == SIGUSR2)
661	continue;
662	# endif
663	# ifdef SIGACTION
664	sigaction(i, &savsig[i], NULL);
665	# else
666	signal(i, savsig[i]);
667	# endif
668	}
669	# endif
670	}
671
672	static void recsig(int i)
673	{
674	intr_signal = i;
675	}
676	# endif
677
678	/* Internal functions specific for Windows */
679	# if defined(OPENSSL_SYS_MSDOS) && !defined(_WIN32)
680	static int noecho_fgets(char buf, int size, FILE tty)
681	{
682	int i;
683	char *p;
684
685	p = buf;
686	for (;;) {
687	if (size == 0) {
688	*p = '\0';
689	break;
690	}
691	size--;
692	# if defined(_WIN32)
693	i = _getch();
694	# else
695	i = getch();
696	# endif
697	if (i == '\r')
698	i = '\n';
699	*(p++) = i;
700	if (i == '\n') {
701	*p = '\0';
702	break;
703	}
704	}
705	# ifdef WIN_CONSOLE_BUG
706	/*
707	* Win95 has several evil console bugs: one of these is that the last
708	* character read using getch() is passed to the next read: this is
709	* usually a CR so this can be trouble. No STDIO fix seems to work but
710	* flushing the console appears to do the trick.
711	*/
712	{
713	HANDLE inh;
714	inh = GetStdHandle(STD_INPUT_HANDLE);
715	FlushConsoleInputBuffer(inh);
716	}
717	# endif
718	return strlen(buf);
719	}
720	# endif
721
722	static UI_METHOD ui_openssl = {
723	"OpenSSL default user interface",
724	open_console,
725	write_string,
726	NULL, /* No flusher is needed for command lines */
727	read_string,
728	close_console,
729	NULL
730	};
731
732	/* The method with all the built-in console thingies */
733	UI_METHOD *UI_OpenSSL(void)
734	{
735	return &ui_openssl;
736	}
737
738	static const UI_METHOD *default_UI_meth = &ui_openssl;
739
740	#else
741
742	static const UI_METHOD *default_UI_meth = NULL;
743
744	#endif
745
746	void UI_set_default_method(const UI_METHOD *meth)
747	{
748	default_UI_meth = meth;
749	}
750
751	const UI_METHOD *UI_get_default_method(void)
752	{
753	return default_UI_meth;
754	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-1.1.1l/crypto/ui/ui_openssl.c@ 91772

Download in other formats: