[openssh.git] / cli.c

/*	$OpenBSD: cli.c,v 1.13 2001/05/06 21:23:31 markus Exp $	*/

/*
 * Copyright (c) 2000 Markus Friedl.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "includes.h"
RCSID("$OpenBSD: cli.c,v 1.13 2001/05/06 21:23:31 markus Exp $");

#include "xmalloc.h"
#include "log.h"
#include "cli.h"

static int cli_input = -1;
static int cli_output = -1;
static int cli_from_stdin = 0;

sigset_t oset;
sigset_t nset;
struct sigaction nsa;
struct sigaction osa;
struct termios ntio;
struct termios otio;
int echo_modified;

volatile int intr;

static int
cli_open(int from_stdin)
{
	if (cli_input >= 0 && cli_output >= 0 && cli_from_stdin == from_stdin)
		return 1;

	if (from_stdin) {
		if (!cli_from_stdin && cli_input >= 0) {
			(void)close(cli_input);
		}
		cli_input = STDIN_FILENO;
		cli_output = STDERR_FILENO;
	} else {
		cli_input = cli_output = open(_PATH_TTY, O_RDWR);
		if (cli_input < 0)
			fatal("You have no controlling tty.  Cannot read passphrase.");
	}

	cli_from_stdin = from_stdin;

	return cli_input >= 0 && cli_output >= 0 && cli_from_stdin == from_stdin;
}

static void
cli_close(void)
{
	if (!cli_from_stdin && cli_input >= 0)
		close(cli_input);
	cli_input = -1;
	cli_output = -1;
	cli_from_stdin = 0;
	return;
}

void
intrcatch(int sig)
{
	intr = 1;
}

static void
cli_echo_disable(void)
{
	sigemptyset(&nset);
	sigaddset(&nset, SIGTSTP);
	(void) sigprocmask(SIG_BLOCK, &nset, &oset);

	intr = 0;

	memset(&nsa, 0, sizeof(nsa));
	nsa.sa_handler = intrcatch;
	(void) sigaction(SIGINT, &nsa, &osa);

	echo_modified = 0;
	if (tcgetattr(cli_input, &otio) == 0 && (otio.c_lflag & ECHO)) {
		echo_modified = 1;
		ntio = otio;
		ntio.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
		(void) tcsetattr(cli_input, TCSANOW, &ntio);
	}
	return;
}

static void
cli_echo_restore(void)
{
	if (echo_modified != 0) {
		tcsetattr(cli_input, TCSANOW, &otio);
		echo_modified = 0;
	}

	(void) sigprocmask(SIG_SETMASK, &oset, NULL);
	(void) sigaction(SIGINT, &osa, NULL);

	if (intr != 0) {
		kill(getpid(), SIGINT);
		sigemptyset(&nset);
		/* XXX tty has not neccessarily drained by now? */
		sigsuspend(&nset);
		intr = 0;
	}
	return;
}

static int
cli_read(char* buf, int size, int echo)
{
	char ch = 0;
	int i = 0;
	int n;

	if (!echo)
		cli_echo_disable();

	while (ch != '\n') {
		n = read(cli_input, &ch, 1);
		if (intr)
			break;
		if (n == -1 && (errno == EAGAIN || errno == EINTR))
			continue;
		if (n != 1)
			break;
		if (ch == '\n')
			break;
		if (i < size - 1)
			buf[i++] = ch;
	}
	if (intr)
		i = 0;
	buf[i] = '\0';

	if (!echo)
		cli_echo_restore();
	if (!intr && !echo)
		(void) write(cli_output, "\n", 1);
	return i;
}

static int
cli_write(const char* buf, int size)
{
	int i, len, pos, ret = 0;
	char *output, *p;

	output = xmalloc(4*size);
	for (p = output, i = 0; i < size; i++) {
		if (buf[i] == '\n' || buf[i] == '\r')
			*p++ = buf[i];
		else
			p = vis(p, buf[i], 0, 0);
	}
	len = p - output;

	for (pos = 0; pos < len; pos += ret) {
		ret = write(cli_output, output + pos, len - pos);
		if (ret == -1) {
			xfree(output);
			return -1;
		}
	}
	xfree(output);
	return 0;
}

/*
 * Presents a prompt and returns the response allocated with xmalloc().
 * Uses /dev/tty or stdin/out depending on arg.  Optionally disables echo
 * of response depending on arg.  Tries to ensure that no other userland
 * buffer is storing the response.
 */
char*
cli_read_passphrase(const char* prompt, int from_stdin, int echo_enable)
{
	char	buf[BUFSIZ];
	char*	p;

	if (!cli_open(from_stdin))
		fatal("Cannot read passphrase.");

	fflush(stdout);

	cli_write(prompt, strlen(prompt));
	cli_read(buf, sizeof buf, echo_enable);

	cli_close();

	p = xstrdup(buf);
	memset(buf, 0, sizeof(buf));
	return (p);
}

char*
cli_prompt(char* prompt, int echo_enable)
{
	return cli_read_passphrase(prompt, 0, echo_enable);
}

void
cli_mesg(char* mesg)
{
	cli_open(0);
	cli_write(mesg, strlen(mesg));
	cli_write("\n", strlen("\n"));
	cli_close();
	return;
}
Commit	Line	Data
588f4ed0	1	/* $OpenBSD: cli.c,v 1.13 2001/05/06 21:23:31 markus Exp $ */
4371658c	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
94ec8c6b	27	#include "includes.h"
588f4ed0	28	RCSID("$OpenBSD: cli.c,v 1.13 2001/05/06 21:23:31 markus Exp $");
94ec8c6b	29
94ec8c6b	30	#include "xmalloc.h"
42f11eb2	31	#include "log.h"
5ca51e19	32	#include "cli.h"
94ec8c6b	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 {
5ca51e19	61	cli_input = cli_output = open(_PATH_TTY, O_RDWR);
94ec8c6b	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
5ca51e19	72	cli_close(void)
94ec8c6b	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
5ca51e19	83	intrcatch(int sig)
94ec8c6b	84	{
	85	intr = 1;
	86	}
	87
	88	static void
5ca51e19	89	cli_echo_disable(void)
94ec8c6b	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
5ca51e19	112	cli_echo_restore(void)
94ec8c6b	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;
bbc62e59	137	int n;
94ec8c6b	138
	139	if (!echo)
	140	cli_echo_disable();
	141
	142	while (ch != '\n') {
bbc62e59	143	n = read(cli_input, &ch, 1);
588f4ed0	144	if (intr)
588f4ed0	145	break;
bbc62e59	146	if (n == -1 && (errno == EAGAIN \|\| errno == EINTR))
	147	continue;
	148	if (n != 1)
94ec8c6b	149	break;
588f4ed0	150	if (ch == '\n')
94ec8c6b	151	break;
588f4ed0	152	if (i < size - 1)
94ec8c6b	153	buf[i++] = ch;
94ec8c6b	154	}
588f4ed0	155	if (intr)
588f4ed0	156	i = 0;
94ec8c6b	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
8694a1ce	167	cli_write(const char* buf, int size)
94ec8c6b	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++) {
7f8ea238	174	if (buf[i] == '\n' \|\| buf[i] == '\r')
2b87da3b	175	*p++ = buf[i];
	176	else
	177	p = vis(p, buf[i], 0, 0);
	178	}
94ec8c6b	179	len = p - output;
	180
	181	for (pos = 0; pos < len; pos += ret) {
	182	ret = write(cli_output, output + pos, len - pos);
bbcf899f	183	if (ret == -1) {
bbcf899f	184	xfree(output);
94ec8c6b	185	return -1;
bbcf899f	186	}
94ec8c6b	187	}
bbcf899f	188	xfree(output);
94ec8c6b	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*
8694a1ce	199	cli_read_passphrase(const char* prompt, int from_stdin, int echo_enable)
94ec8c6b	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	}