[u/mdw/putty] / plink.c

/*
 * PLink - a command-line (stdin/stdout) variant of PuTTY.
 */

#ifndef AUTO_WINSOCK
#include <winsock2.h>
#endif
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#define PUTTY_DO_GLOBALS	       /* actually _define_ globals */
#include "putty.h"
#include "storage.h"
#include "tree234.h"

void fatalbox(char *p, ...)
{
    va_list ap;
    fprintf(stderr, "FATAL ERROR: ");
    va_start(ap, p);
    vfprintf(stderr, p, ap);
    va_end(ap);
    fputc('\n', stderr);
    WSACleanup();
    exit(1);
}
void connection_fatal(char *p, ...)
{
    va_list ap;
    fprintf(stderr, "FATAL ERROR: ");
    va_start(ap, p);
    vfprintf(stderr, p, ap);
    va_end(ap);
    fputc('\n', stderr);
    WSACleanup();
    exit(1);
}

static char *password = NULL;

void logevent(char *string)
{
}

void verify_ssh_host_key(char *host, int port, char *keytype,
			 char *keystr, char *fingerprint)
{
    int ret;
    HANDLE hin;
    DWORD savemode, i;

    static const char absentmsg[] =
	"The server's host key is not cached in the registry. You\n"
	"have no guarantee that the server is the computer you\n"
	"think it is.\n"
	"The server's key fingerprint is:\n"
	"%s\n"
	"If you trust this host, enter \"y\" to add the key to\n"
	"PuTTY's cache and carry on connecting.\n"
	"If you want to carry on connecting just once, without\n"
	"adding the key to the cache, enter \"n\".\n"
	"If you do not trust this host, press Return to abandon the\n"
	"connection.\n"
	"Store key in cache? (y/n) ";

    static const char wrongmsg[] =
	"WARNING - POTENTIAL SECURITY BREACH!\n"
	"The server's host key does not match the one PuTTY has\n"
	"cached in the registry. This means that either the\n"
	"server administrator has changed the host key, or you\n"
	"have actually connected to another computer pretending\n"
	"to be the server.\n"
	"The new key fingerprint is:\n"
	"%s\n"
	"If you were expecting this change and trust the new key,\n"
	"enter \"y\" to update PuTTY's cache and continue connecting.\n"
	"If you want to carry on connecting but without updating\n"
	"the cache, enter \"n\".\n"
	"If you want to abandon the connection completely, press\n"
	"Return to cancel. Pressing Return is the ONLY guaranteed\n"
	"safe choice.\n"
	"Update cached key? (y/n, Return cancels connection) ";

    static const char abandoned[] = "Connection abandoned.\n";

    char line[32];

    /*
     * Verify the key against the registry.
     */
    ret = verify_host_key(host, port, keytype, keystr);

    if (ret == 0)		       /* success - key matched OK */
	return;

    if (ret == 2) {		       /* key was different */
	fprintf(stderr, wrongmsg, fingerprint);
	fflush(stderr);
    }
    if (ret == 1) {		       /* key was absent */
	fprintf(stderr, absentmsg, fingerprint);
	fflush(stderr);
    }

    hin = GetStdHandle(STD_INPUT_HANDLE);
    GetConsoleMode(hin, &savemode);
    SetConsoleMode(hin, (savemode | ENABLE_ECHO_INPUT |
			 ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT));
    ReadFile(hin, line, sizeof(line) - 1, &i, NULL);
    SetConsoleMode(hin, savemode);

    if (line[0] != '\0' && line[0] != '\r' && line[0] != '\n') {
	if (line[0] == 'y' || line[0] == 'Y')
	    store_host_key(host, port, keytype, keystr);
    } else {
	fprintf(stderr, abandoned);
	exit(0);
    }
}

HANDLE inhandle, outhandle, errhandle;
DWORD orig_console_mode;

WSAEVENT netevent;

void from_backend(int is_stderr, char *data, int len)
{
    int pos;
    DWORD ret;
    HANDLE h = (is_stderr ? errhandle : outhandle);

    pos = 0;
    while (pos < len) {
	if (!WriteFile(h, data + pos, len - pos, &ret, NULL))
	    return;		       /* give up in panic */
	pos += ret;
    }
}

int term_ldisc(int mode)
{
    return FALSE;
}
void ldisc_update(int echo, int edit)
{
    /* Update stdin read mode to reflect changes in line discipline. */
    DWORD mode;

    mode = ENABLE_PROCESSED_INPUT;
    if (echo)
	mode = mode | ENABLE_ECHO_INPUT;
    else
	mode = mode & ~ENABLE_ECHO_INPUT;
    if (edit)
	mode = mode | ENABLE_LINE_INPUT;
    else
	mode = mode & ~ENABLE_LINE_INPUT;
    SetConsoleMode(inhandle, mode);
}

struct input_data {
    DWORD len;
    char buffer[4096];
    HANDLE event, eventback;
};

static int get_line(const char *prompt, char *str, int maxlen, int is_pw)
{
    HANDLE hin, hout;
    DWORD savemode, newmode, i;

    if (is_pw && password) {
	static int tried_once = 0;

	if (tried_once) {
	    return 0;
	} else {
	    strncpy(str, password, maxlen);
	    str[maxlen - 1] = '\0';
	    tried_once = 1;
	    return 1;
	}
    }

    hin = GetStdHandle(STD_INPUT_HANDLE);
    hout = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hin == INVALID_HANDLE_VALUE || hout == INVALID_HANDLE_VALUE) {
	fprintf(stderr, "Cannot get standard input/output handles");
	return 0;
    }

    GetConsoleMode(hin, &savemode);
    newmode = savemode | ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT;
    if (is_pw)
	newmode &= ~ENABLE_ECHO_INPUT;
    else
	newmode |= ENABLE_ECHO_INPUT;
    SetConsoleMode(hin, newmode);

    WriteFile(hout, prompt, strlen(prompt), &i, NULL);
    ReadFile(hin, str, maxlen - 1, &i, NULL);

    SetConsoleMode(hin, savemode);

    if ((int) i > maxlen)
	i = maxlen - 1;
    else
	i = i - 2;
    str[i] = '\0';

    if (is_pw)
	WriteFile(hout, "\r\n", 2, &i, NULL);

    return 1;
}

static DWORD WINAPI stdin_read_thread(void *param)
{
    struct input_data *idata = (struct input_data *) param;
    HANDLE inhandle;

    inhandle = GetStdHandle(STD_INPUT_HANDLE);

    while (ReadFile(inhandle, idata->buffer, sizeof(idata->buffer),
		    &idata->len, NULL) && idata->len > 0) {
	SetEvent(idata->event);
	WaitForSingleObject(idata->eventback, INFINITE);
    }

    idata->len = 0;
    SetEvent(idata->event);

    return 0;
}

/*
 *  Short description of parameters.
 */
static void usage(void)
{
    printf("PuTTY Link: command-line connection utility\n");
    printf("%s\n", ver);
    printf("Usage: plink [options] [user@]host [command]\n");
    printf("Options:\n");
    printf("  -v        show verbose messages\n");
    printf("  -ssh      force use of ssh protocol\n");
    printf("  -P port   connect to specified port\n");
    printf("  -pw passw login with specified password\n");
    printf("  -m file   read remote command(s) from file\n");
    exit(1);
}

char *do_select(SOCKET skt, int startup)
{
    int events;
    if (startup) {
	events = FD_READ | FD_WRITE | FD_OOB | FD_CLOSE;
    } else {
	events = 0;
    }
    if (WSAEventSelect(skt, netevent, events) == SOCKET_ERROR) {
	switch (WSAGetLastError()) {
	  case WSAENETDOWN:
	    return "Network is down";
	  default:
	    return "WSAAsyncSelect(): unknown error";
	}
    }
    return NULL;
}

int main(int argc, char **argv)
{
    WSADATA wsadata;
    WORD winsock_ver;
    WSAEVENT stdinevent;
    HANDLE handles[2];
    DWORD threadid;
    struct input_data idata;
    int sending;
    int portnumber = -1;
    SOCKET *sklist;
    int skcount, sksize;
    int connopen;

    ssh_get_line = get_line;

    sklist = NULL;
    skcount = sksize = 0;

    flags = FLAG_STDERR;
    /*
     * Process the command line.
     */
    do_defaults(NULL, &cfg);
    default_protocol = cfg.protocol;
    default_port = cfg.port;
    {
	/*
	 * Override the default protocol if PLINK_PROTOCOL is set.
	 */
	char *p = getenv("PLINK_PROTOCOL");
	int i;
	if (p) {
	    for (i = 0; backends[i].backend != NULL; i++) {
		if (!strcmp(backends[i].name, p)) {
		    default_protocol = cfg.protocol = backends[i].protocol;
		    default_port = cfg.port =
			backends[i].backend->default_port;
		    break;
		}
	    }
	}
    }
    while (--argc) {
	char *p = *++argv;
	if (*p == '-') {
	    if (!strcmp(p, "-ssh")) {
		default_protocol = cfg.protocol = PROT_SSH;
		default_port = cfg.port = 22;
	    } else if (!strcmp(p, "-telnet")) {
		default_protocol = cfg.protocol = PROT_TELNET;
		default_port = cfg.port = 23;
	    } else if (!strcmp(p, "-raw")) {
		default_protocol = cfg.protocol = PROT_RAW;
	    } else if (!strcmp(p, "-v")) {
		flags |= FLAG_VERBOSE;
	    } else if (!strcmp(p, "-log")) {
		logfile = "putty.log";
	    } else if (!strcmp(p, "-pw") && argc > 1) {
		--argc, password = *++argv;
	    } else if (!strcmp(p, "-l") && argc > 1) {
		char *username;
		--argc, username = *++argv;
		strncpy(cfg.username, username, sizeof(cfg.username));
		cfg.username[sizeof(cfg.username) - 1] = '\0';
	    } else if (!strcmp(p, "-m") && argc > 1) {
		char *filename, *command;
		int cmdlen, cmdsize;
		FILE *fp;
		int c, d;

		--argc, filename = *++argv;

		cmdlen = cmdsize = 0;
		command = NULL;
		fp = fopen(filename, "r");
		if (!fp) {
		    fprintf(stderr, "plink: unable to open command "
			    "file \"%s\"\n", filename);
		    return 1;
		}
		do {
		    c = fgetc(fp);
		    d = c;
		    if (c == EOF)
			d = 0;
		    if (cmdlen >= cmdsize) {
			cmdsize = cmdlen + 512;
			command = srealloc(command, cmdsize);
		    }
		    command[cmdlen++] = d;
		} while (c != EOF);
		cfg.remote_cmd_ptr = command;
		cfg.nopty = TRUE;      /* command => no terminal */
	    } else if (!strcmp(p, "-P") && argc > 1) {
		--argc, portnumber = atoi(*++argv);
	    }
	} else if (*p) {
	    if (!*cfg.host) {
		char *q = p;
		/*
		 * If the hostname starts with "telnet:", set the
		 * protocol to Telnet and process the string as a
		 * Telnet URL.
		 */
		if (!strncmp(q, "telnet:", 7)) {
		    char c;

		    q += 7;
		    if (q[0] == '/' && q[1] == '/')
			q += 2;
		    cfg.protocol = PROT_TELNET;
		    p = q;
		    while (*p && *p != ':' && *p != '/')
			p++;
		    c = *p;
		    if (*p)
			*p++ = '\0';
		    if (c == ':')
			cfg.port = atoi(p);
		    else
			cfg.port = -1;
		    strncpy(cfg.host, q, sizeof(cfg.host) - 1);
		    cfg.host[sizeof(cfg.host) - 1] = '\0';
		} else {
		    char *r;
		    /*
		     * Before we process the [user@]host string, we
		     * first check for the presence of a protocol
		     * prefix (a protocol name followed by ",").
		     */
		    r = strchr(p, ',');
		    if (r) {
			int i, j;
			for (i = 0; backends[i].backend != NULL; i++) {
			    j = strlen(backends[i].name);
			    if (j == r - p &&
				!memcmp(backends[i].name, p, j)) {
				default_protocol = cfg.protocol =
				    backends[i].protocol;
				portnumber =
				    backends[i].backend->default_port;
				p = r + 1;
				break;
			    }
			}
		    }

		    /*
		     * Three cases. Either (a) there's a nonzero
		     * length string followed by an @, in which
		     * case that's user and the remainder is host.
		     * Or (b) there's only one string, not counting
		     * a potential initial @, and it exists in the
		     * saved-sessions database. Or (c) only one
		     * string and it _doesn't_ exist in the
		     * database.
		     */
		    r = strrchr(p, '@');
		    if (r == p)
			p++, r = NULL; /* discount initial @ */
		    if (r == NULL) {
			/*
			 * One string.
			 */
			Config cfg2;
			do_defaults(p, &cfg2);
			if (cfg2.host[0] == '\0') {
			    /* No settings for this host; use defaults */
			    strncpy(cfg.host, p, sizeof(cfg.host) - 1);
			    cfg.host[sizeof(cfg.host) - 1] = '\0';
			    cfg.port = default_port;
			} else {
			    cfg = cfg2;
			    cfg.remote_cmd_ptr = cfg.remote_cmd;
			}
		    } else {
			*r++ = '\0';
			strncpy(cfg.username, p, sizeof(cfg.username) - 1);
			cfg.username[sizeof(cfg.username) - 1] = '\0';
			strncpy(cfg.host, r, sizeof(cfg.host) - 1);
			cfg.host[sizeof(cfg.host) - 1] = '\0';
			cfg.port = default_port;
		    }
		}
	    } else {
		int len = sizeof(cfg.remote_cmd) - 1;
		char *cp = cfg.remote_cmd;
		int len2;

		strncpy(cp, p, len);
		cp[len] = '\0';
		len2 = strlen(cp);
		len -= len2;
		cp += len2;
		while (--argc) {
		    if (len > 0)
			len--, *cp++ = ' ';
		    strncpy(cp, *++argv, len);
		    cp[len] = '\0';
		    len2 = strlen(cp);
		    len -= len2;
		    cp += len2;
		}
		cfg.nopty = TRUE;      /* command => no terminal */
		break;		       /* done with cmdline */
	    }
	}
    }

    if (!*cfg.host) {
	usage();
    }

    if (!*cfg.remote_cmd_ptr)
	flags |= FLAG_INTERACTIVE;

    /*
     * Select protocol. This is farmed out into a table in a
     * separate file to enable an ssh-free variant.
     */
    {
	int i;
	back = NULL;
	for (i = 0; backends[i].backend != NULL; i++)
	    if (backends[i].protocol == cfg.protocol) {
		back = backends[i].backend;
		break;
	    }
	if (back == NULL) {
	    fprintf(stderr,
		    "Internal fault: Unsupported protocol found\n");
	    return 1;
	}
    }

    /*
     * Select port.
     */
    if (portnumber != -1)
	cfg.port = portnumber;

    /*
     * Initialise WinSock.
     */
    winsock_ver = MAKEWORD(2, 0);
    if (WSAStartup(winsock_ver, &wsadata)) {
	MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
		   MB_OK | MB_ICONEXCLAMATION);
	return 1;
    }
    if (LOBYTE(wsadata.wVersion) != 2 || HIBYTE(wsadata.wVersion) != 0) {
	MessageBox(NULL, "WinSock version is incompatible with 2.0",
		   "WinSock Error", MB_OK | MB_ICONEXCLAMATION);
	WSACleanup();
	return 1;
    }
    sk_init();

    /*
     * Start up the connection.
     */
    netevent = CreateEvent(NULL, FALSE, FALSE, NULL);
    {
	char *error;
	char *realhost;

	error = back->init(cfg.host, cfg.port, &realhost);
	if (error) {
	    fprintf(stderr, "Unable to open connection:\n%s", error);
	    return 1;
	}
	sfree(realhost);
    }
    connopen = 1;

    stdinevent = CreateEvent(NULL, FALSE, FALSE, NULL);

    inhandle = GetStdHandle(STD_INPUT_HANDLE);
    outhandle = GetStdHandle(STD_OUTPUT_HANDLE);
    errhandle = GetStdHandle(STD_ERROR_HANDLE);
    GetConsoleMode(inhandle, &orig_console_mode);
    SetConsoleMode(inhandle, ENABLE_PROCESSED_INPUT);

    /*
     * Turn off ECHO and LINE input modes. We don't care if this
     * call fails, because we know we aren't necessarily running in
     * a console.
     */
    handles[0] = netevent;
    handles[1] = stdinevent;
    sending = FALSE;
    while (1) {
	int n;

	if (!sending && back->sendok()) {
	    /*
	     * Create a separate thread to read from stdin. This is
	     * a total pain, but I can't find another way to do it:
	     *
	     *  - an overlapped ReadFile or ReadFileEx just doesn't
	     *    happen; we get failure from ReadFileEx, and
	     *    ReadFile blocks despite being given an OVERLAPPED
	     *    structure. Perhaps we can't do overlapped reads
	     *    on consoles. WHY THE HELL NOT?
	     * 
	     *  - WaitForMultipleObjects(netevent, console) doesn't
	     *    work, because it signals the console when
	     *    _anything_ happens, including mouse motions and
	     *    other things that don't cause data to be readable
	     *    - so we're back to ReadFile blocking.
	     */
	    idata.event = stdinevent;
	    idata.eventback = CreateEvent(NULL, FALSE, FALSE, NULL);
	    if (!CreateThread(NULL, 0, stdin_read_thread,
			      &idata, 0, &threadid)) {
		fprintf(stderr, "Unable to create second thread\n");
		exit(1);
	    }
	    sending = TRUE;
	}

	n = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
	if (n == 0) {
	    WSANETWORKEVENTS things;
	    SOCKET socket;
	    extern SOCKET first_socket(int *), next_socket(int *);
	    extern int select_result(WPARAM, LPARAM);
	    int i, socketstate;

	    /*
	     * We must not call select_result() for any socket
	     * until we have finished enumerating within the tree.
	     * This is because select_result() may close the socket
	     * and modify the tree.
	     */
	    /* Count the active sockets. */
	    i = 0;
	    for (socket = first_socket(&socketstate);
		 socket != INVALID_SOCKET;
		 socket = next_socket(&socketstate)) i++;

	    /* Expand the buffer if necessary. */
	    if (i > sksize) {
		sksize = i + 16;
		sklist = srealloc(sklist, sksize * sizeof(*sklist));
	    }

	    /* Retrieve the sockets into sklist. */
	    skcount = 0;
	    for (socket = first_socket(&socketstate);
		 socket != INVALID_SOCKET;
		 socket = next_socket(&socketstate)) {
		sklist[skcount++] = socket;
	    }

	    /* Now we're done enumerating; go through the list. */
	    for (i = 0; i < skcount; i++) {
		WPARAM wp;
		socket = sklist[i];
		wp = (WPARAM) socket;
		if (!WSAEnumNetworkEvents(socket, NULL, &things)) {
		    noise_ultralight(socket);
		    noise_ultralight(things.lNetworkEvents);
		    if (things.lNetworkEvents & FD_READ)
			connopen &= select_result(wp, (LPARAM) FD_READ);
		    if (things.lNetworkEvents & FD_CLOSE)
			connopen &= select_result(wp, (LPARAM) FD_CLOSE);
		    if (things.lNetworkEvents & FD_OOB)
			connopen &= select_result(wp, (LPARAM) FD_OOB);
		    if (things.lNetworkEvents & FD_WRITE)
			connopen &= select_result(wp, (LPARAM) FD_WRITE);
		}
	    }
	} else if (n == 1) {
	    noise_ultralight(idata.len);
	    if (idata.len > 0) {
		back->send(idata.buffer, idata.len);
	    } else {
		back->special(TS_EOF);
	    }
	    SetEvent(idata.eventback);
	}
	if (!connopen || back->socket() == NULL)
	    break;		       /* we closed the connection */
    }
    WSACleanup();
    return 0;
}
Commit	Line	Data
12dc4ec0	1	/*
	2	* PLink - a command-line (stdin/stdout) variant of PuTTY.
	3	*/
	4
4d331a77	5	#ifndef AUTO_WINSOCK
12dc4ec0	6	#include <winsock2.h>
4d331a77	7	#endif
12dc4ec0	8	#include <windows.h>
12dc4ec0	9	#include <stdio.h>
49bad831	10	#include <stdlib.h>
12dc4ec0	11	#include <stdarg.h>
12dc4ec0	12
32874aea	13	#define PUTTY_DO_GLOBALS /* actually _define_ globals */
12dc4ec0	14	#include "putty.h"
a9422f39	15	#include "storage.h"
8df7a775	16	#include "tree234.h"
12dc4ec0	17
32874aea	18	void fatalbox(char *p, ...)
32874aea	19	{
12dc4ec0	20	va_list ap;
49bad831	21	fprintf(stderr, "FATAL ERROR: ");
12dc4ec0	22	va_start(ap, p);
	23	vfprintf(stderr, p, ap);
	24	va_end(ap);
	25	fputc('\n', stderr);
	26	WSACleanup();
	27	exit(1);
	28	}
32874aea	29	void connection_fatal(char *p, ...)
32874aea	30	{
8d5de777	31	va_list ap;
49bad831	32	fprintf(stderr, "FATAL ERROR: ");
8d5de777	33	va_start(ap, p);
	34	vfprintf(stderr, p, ap);
	35	va_end(ap);
	36	fputc('\n', stderr);
	37	WSACleanup();
	38	exit(1);
	39	}
12dc4ec0	40
d8426c54	41	static char *password = NULL;
d8426c54	42
32874aea	43	void logevent(char *string)
	44	{
	45	}
a9422f39	46
a9422f39	47	void verify_ssh_host_key(char host, int port, char keytype,
32874aea	48	char keystr, char fingerprint)
32874aea	49	{
a9422f39	50	int ret;
fcbb94d3	51	HANDLE hin;
fcbb94d3	52	DWORD savemode, i;
a9422f39	53
a9422f39	54	static const char absentmsg[] =
32874aea	55	"The server's host key is not cached in the registry. You\n"
	56	"have no guarantee that the server is the computer you\n"
	57	"think it is.\n"
	58	"The server's key fingerprint is:\n"
	59	"%s\n"
	60	"If you trust this host, enter \"y\" to add the key to\n"
	61	"PuTTY's cache and carry on connecting.\n"
d0718310	62	"If you want to carry on connecting just once, without\n"
	63	"adding the key to the cache, enter \"n\".\n"
	64	"If you do not trust this host, press Return to abandon the\n"
	65	"connection.\n"
	66	"Store key in cache? (y/n) ";
a9422f39	67
a9422f39	68	static const char wrongmsg[] =
32874aea	69	"WARNING - POTENTIAL SECURITY BREACH!\n"
	70	"The server's host key does not match the one PuTTY has\n"
	71	"cached in the registry. This means that either the\n"
	72	"server administrator has changed the host key, or you\n"
	73	"have actually connected to another computer pretending\n"
	74	"to be the server.\n"
	75	"The new key fingerprint is:\n"
	76	"%s\n"
	77	"If you were expecting this change and trust the new key,\n"
	78	"enter \"y\" to update PuTTY's cache and continue connecting.\n"
	79	"If you want to carry on connecting but without updating\n"
	80	"the cache, enter \"n\".\n"
	81	"If you want to abandon the connection completely, press\n"
	82	"Return to cancel. Pressing Return is the ONLY guaranteed\n"
	83	"safe choice.\n"
	84	"Update cached key? (y/n, Return cancels connection) ";
a9422f39	85
	86	static const char abandoned[] = "Connection abandoned.\n";
	87
	88	char line[32];
	89
	90	/*
	91	* Verify the key against the registry.
	92	*/
	93	ret = verify_host_key(host, port, keytype, keystr);
	94
32874aea	95	if (ret == 0) /* success - key matched OK */
32874aea	96	return;
fcbb94d3	97
b4453f49	98	if (ret == 2) { /* key was different */
32874aea	99	fprintf(stderr, wrongmsg, fingerprint);
b4453f49	100	fflush(stderr);
	101	}
	102	if (ret == 1) { /* key was absent */
32874aea	103	fprintf(stderr, absentmsg, fingerprint);
b4453f49	104	fflush(stderr);
b4453f49	105	}
fcbb94d3	106
	107	hin = GetStdHandle(STD_INPUT_HANDLE);
	108	GetConsoleMode(hin, &savemode);
	109	SetConsoleMode(hin, (savemode \| ENABLE_ECHO_INPUT \|
32874aea	110	ENABLE_PROCESSED_INPUT \| ENABLE_LINE_INPUT));
32874aea	111	ReadFile(hin, line, sizeof(line) - 1, &i, NULL);
fcbb94d3	112	SetConsoleMode(hin, savemode);
fcbb94d3	113
d0718310	114	if (line[0] != '\0' && line[0] != '\r' && line[0] != '\n') {
32874aea	115	if (line[0] == 'y' \|\| line[0] == 'Y')
32874aea	116	store_host_key(host, port, keytype, keystr);
d0718310	117	} else {
	118	fprintf(stderr, abandoned);
	119	exit(0);
a9422f39	120	}
a9422f39	121	}
989b10e9	122
0965bee0	123	HANDLE inhandle, outhandle, errhandle;
6f34e365	124	DWORD orig_console_mode;
6f34e365	125
8df7a775	126	WSAEVENT netevent;
8df7a775	127
32874aea	128	void from_backend(int is_stderr, char *data, int len)
32874aea	129	{
fe50e814	130	int pos;
12dc4ec0	131	DWORD ret;
fe50e814	132	HANDLE h = (is_stderr ? errhandle : outhandle);
	133
	134	pos = 0;
	135	while (pos < len) {
32874aea	136	if (!WriteFile(h, data + pos, len - pos, &ret, NULL))
	137	return; /* give up in panic */
	138	pos += ret;
12dc4ec0	139	}
12dc4ec0	140	}
12dc4ec0	141
32874aea	142	int term_ldisc(int mode)
	143	{
	144	return FALSE;
	145	}
	146	void ldisc_update(int echo, int edit)
	147	{
0965bee0	148	/* Update stdin read mode to reflect changes in line discipline. */
	149	DWORD mode;
	150
	151	mode = ENABLE_PROCESSED_INPUT;
	152	if (echo)
32874aea	153	mode = mode \| ENABLE_ECHO_INPUT;
0965bee0	154	else
32874aea	155	mode = mode & ~ENABLE_ECHO_INPUT;
0965bee0	156	if (edit)
32874aea	157	mode = mode \| ENABLE_LINE_INPUT;
0965bee0	158	else
32874aea	159	mode = mode & ~ENABLE_LINE_INPUT;
0965bee0	160	SetConsoleMode(inhandle, mode);
	161	}
	162
12dc4ec0	163	struct input_data {
	164	DWORD len;
	165	char buffer[4096];
8df7a775	166	HANDLE event, eventback;
12dc4ec0	167	};
12dc4ec0	168
fa17a66e	169	static int get_line(const char prompt, char str, int maxlen, int is_pw)
67779be7	170	{
67779be7	171	HANDLE hin, hout;
fa17a66e	172	DWORD savemode, newmode, i;
67779be7	173
fa17a66e	174	if (is_pw && password) {
32874aea	175	static int tried_once = 0;
	176
	177	if (tried_once) {
	178	return 0;
	179	} else {
	180	strncpy(str, password, maxlen);
	181	str[maxlen - 1] = '\0';
	182	tried_once = 1;
	183	return 1;
	184	}
67779be7	185	}
67779be7	186
	187	hin = GetStdHandle(STD_INPUT_HANDLE);
	188	hout = GetStdHandle(STD_OUTPUT_HANDLE);
	189	if (hin == INVALID_HANDLE_VALUE \|\| hout == INVALID_HANDLE_VALUE) {
32874aea	190	fprintf(stderr, "Cannot get standard input/output handles");
32874aea	191	return 0;
67779be7	192	}
	193
	194	GetConsoleMode(hin, &savemode);
fa17a66e	195	newmode = savemode \| ENABLE_PROCESSED_INPUT \| ENABLE_LINE_INPUT;
fa17a66e	196	if (is_pw)
32874aea	197	newmode &= ~ENABLE_ECHO_INPUT;
fa17a66e	198	else
32874aea	199	newmode \|= ENABLE_ECHO_INPUT;
fa17a66e	200	SetConsoleMode(hin, newmode);
67779be7	201
67779be7	202	WriteFile(hout, prompt, strlen(prompt), &i, NULL);
32874aea	203	ReadFile(hin, str, maxlen - 1, &i, NULL);
67779be7	204
	205	SetConsoleMode(hin, savemode);
	206
32874aea	207	if ((int) i > maxlen)
	208	i = maxlen - 1;
	209	else
	210	i = i - 2;
67779be7	211	str[i] = '\0';
67779be7	212
fa17a66e	213	if (is_pw)
32874aea	214	WriteFile(hout, "\r\n", 2, &i, NULL);
67779be7	215
	216	return 1;
	217	}
	218
32874aea	219	static DWORD WINAPI stdin_read_thread(void *param)
	220	{
	221	struct input_data idata = (struct input_data ) param;
12dc4ec0	222	HANDLE inhandle;
	223
	224	inhandle = GetStdHandle(STD_INPUT_HANDLE);
	225
	226	while (ReadFile(inhandle, idata->buffer, sizeof(idata->buffer),
32874aea	227	&idata->len, NULL) && idata->len > 0) {
	228	SetEvent(idata->event);
	229	WaitForSingleObject(idata->eventback, INFINITE);
12dc4ec0	230	}
	231
	232	idata->len = 0;
	233	SetEvent(idata->event);
	234
	235	return 0;
	236	}
	237
d8426c54	238	/*
	239	* Short description of parameters.
	240	*/
	241	static void usage(void)
	242	{
	243	printf("PuTTY Link: command-line connection utility\n");
	244	printf("%s\n", ver);
	245	printf("Usage: plink [options] [user@]host [command]\n");
	246	printf("Options:\n");
	247	printf(" -v show verbose messages\n");
	248	printf(" -ssh force use of ssh protocol\n");
	249	printf(" -P port connect to specified port\n");
	250	printf(" -pw passw login with specified password\n");
96621a84	251	printf(" -m file read remote command(s) from file\n");
d8426c54	252	exit(1);
	253	}
	254
32874aea	255	char *do_select(SOCKET skt, int startup)
32874aea	256	{
8df7a775	257	int events;
	258	if (startup) {
	259	events = FD_READ \| FD_WRITE \| FD_OOB \| FD_CLOSE;
	260	} else {
	261	events = 0;
	262	}
32874aea	263	if (WSAEventSelect(skt, netevent, events) == SOCKET_ERROR) {
	264	switch (WSAGetLastError()) {
	265	case WSAENETDOWN:
	266	return "Network is down";
	267	default:
	268	return "WSAAsyncSelect(): unknown error";
	269	}
8df7a775	270	}
	271	return NULL;
	272	}
	273
32874aea	274	int main(int argc, char **argv)
32874aea	275	{
12dc4ec0	276	WSADATA wsadata;
12dc4ec0	277	WORD winsock_ver;
8df7a775	278	WSAEVENT stdinevent;
12dc4ec0	279	HANDLE handles[2];
12dc4ec0	280	DWORD threadid;
	281	struct input_data idata;
	282	int sending;
d8426c54	283	int portnumber = -1;
8df7a775	284	SOCKET *sklist;
	285	int skcount, sksize;
	286	int connopen;
12dc4ec0	287
fa17a66e	288	ssh_get_line = get_line;
67779be7	289
32874aea	290	sklist = NULL;
32874aea	291	skcount = sksize = 0;
8df7a775	292
67779be7	293	flags = FLAG_STDERR;
12dc4ec0	294	/*
	295	* Process the command line.
	296	*/
a9422f39	297	do_defaults(NULL, &cfg);
e7a7383f	298	default_protocol = cfg.protocol;
e7a7383f	299	default_port = cfg.port;
8cb9c947	300	{
32874aea	301	/*
	302	* Override the default protocol if PLINK_PROTOCOL is set.
	303	*/
	304	char *p = getenv("PLINK_PROTOCOL");
	305	int i;
	306	if (p) {
	307	for (i = 0; backends[i].backend != NULL; i++) {
	308	if (!strcmp(backends[i].name, p)) {
	309	default_protocol = cfg.protocol = backends[i].protocol;
	310	default_port = cfg.port =
	311	backends[i].backend->default_port;
	312	break;
	313	}
	314	}
	315	}
8cb9c947	316	}
12dc4ec0	317	while (--argc) {
32874aea	318	char p = ++argv;
	319	if (*p == '-') {
	320	if (!strcmp(p, "-ssh")) {
12dc4ec0	321	default_protocol = cfg.protocol = PROT_SSH;
12dc4ec0	322	default_port = cfg.port = 22;
32874aea	323	} else if (!strcmp(p, "-telnet")) {
9d33ebdd	324	default_protocol = cfg.protocol = PROT_TELNET;
9d33ebdd	325	default_port = cfg.port = 23;
32874aea	326	} else if (!strcmp(p, "-raw")) {
9d33ebdd	327	default_protocol = cfg.protocol = PROT_RAW;
67779be7	328	} else if (!strcmp(p, "-v")) {
32874aea	329	flags \|= FLAG_VERBOSE;
12dc4ec0	330	} else if (!strcmp(p, "-log")) {
32874aea	331	logfile = "putty.log";
	332	} else if (!strcmp(p, "-pw") && argc > 1) {
	333	--argc, password = *++argv;
	334	} else if (!strcmp(p, "-l") && argc > 1) {
	335	char *username;
	336	--argc, username = *++argv;
	337	strncpy(cfg.username, username, sizeof(cfg.username));
	338	cfg.username[sizeof(cfg.username) - 1] = '\0';
	339	} else if (!strcmp(p, "-m") && argc > 1) {
	340	char filename, command;
	341	int cmdlen, cmdsize;
	342	FILE *fp;
	343	int c, d;
	344
	345	--argc, filename = *++argv;
	346
	347	cmdlen = cmdsize = 0;
	348	command = NULL;
	349	fp = fopen(filename, "r");
	350	if (!fp) {
	351	fprintf(stderr, "plink: unable to open command "
	352	"file \"%s\"\n", filename);
	353	return 1;
	354	}
	355	do {
	356	c = fgetc(fp);
	357	d = c;
	358	if (c == EOF)
	359	d = 0;
	360	if (cmdlen >= cmdsize) {
	361	cmdsize = cmdlen + 512;
	362	command = srealloc(command, cmdsize);
	363	}
	364	command[cmdlen++] = d;
	365	} while (c != EOF);
	366	cfg.remote_cmd_ptr = command;
	367	cfg.nopty = TRUE; /* command => no terminal */
	368	} else if (!strcmp(p, "-P") && argc > 1) {
	369	--argc, portnumber = atoi(*++argv);
	370	}
12dc4ec0	371	} else if (*p) {
32874aea	372	if (!*cfg.host) {
	373	char *q = p;
	374	/*
	375	* If the hostname starts with "telnet:", set the
	376	* protocol to Telnet and process the string as a
	377	* Telnet URL.
	378	*/
	379	if (!strncmp(q, "telnet:", 7)) {
	380	char c;
	381
	382	q += 7;
	383	if (q[0] == '/' && q[1] == '/')
	384	q += 2;
	385	cfg.protocol = PROT_TELNET;
	386	p = q;
	387	while (p && p != ':' && *p != '/')
	388	p++;
	389	c = *p;
	390	if (*p)
	391	*p++ = '\0';
	392	if (c == ':')
	393	cfg.port = atoi(p);
	394	else
	395	cfg.port = -1;
	396	strncpy(cfg.host, q, sizeof(cfg.host) - 1);
	397	cfg.host[sizeof(cfg.host) - 1] = '\0';
	398	} else {
	399	char *r;
	400	/*
	401	* Before we process the [user@]host string, we
	402	* first check for the presence of a protocol
	403	* prefix (a protocol name followed by ",").
	404	*/
	405	r = strchr(p, ',');
	406	if (r) {
	407	int i, j;
	408	for (i = 0; backends[i].backend != NULL; i++) {
	409	j = strlen(backends[i].name);
	410	if (j == r - p &&
	411	!memcmp(backends[i].name, p, j)) {
	412	default_protocol = cfg.protocol =
	413	backends[i].protocol;
	414	portnumber =
	415	backends[i].backend->default_port;
	416	p = r + 1;
	417	break;
	418	}
	419	}
	420	}
	421
	422	/*
	423	* Three cases. Either (a) there's a nonzero
	424	* length string followed by an @, in which
	425	* case that's user and the remainder is host.
	426	* Or (b) there's only one string, not counting
	427	* a potential initial @, and it exists in the
	428	* saved-sessions database. Or (c) only one
	429	* string and it _doesn't_ exist in the
	430	* database.
	431	*/
	432	r = strrchr(p, '@');
	433	if (r == p)
	434	p++, r = NULL; /* discount initial @ */
	435	if (r == NULL) {
436	/*
437	* One string.
438	*/
439	Config cfg2;
440	do_defaults(p, &cfg2);
441	if (cfg2.host[0] == '\0') {
442	/* No settings for this host; use defaults */
443	strncpy(cfg.host, p, sizeof(cfg.host) - 1);
444	cfg.host[sizeof(cfg.host) - 1] = '\0';
445	cfg.port = default_port;
446	} else {
447	cfg = cfg2;
448	cfg.remote_cmd_ptr = cfg.remote_cmd;
449	}
450	} else {
451	*r++ = '\0';
452	strncpy(cfg.username, p, sizeof(cfg.username) - 1);
453	cfg.username[sizeof(cfg.username) - 1] = '\0';
454	strncpy(cfg.host, r, sizeof(cfg.host) - 1);
455	cfg.host[sizeof(cfg.host) - 1] = '\0';
456	cfg.port = default_port;
457	}
458	}
459	} else {
460	int len = sizeof(cfg.remote_cmd) - 1;
461	char *cp = cfg.remote_cmd;
462	int len2;
463
464	strncpy(cp, p, len);
465	cp[len] = '\0';
466	len2 = strlen(cp);
467	len -= len2;
468	cp += len2;
469	while (--argc) {
470	if (len > 0)
471	len--, *cp++ = ' ';
472	strncpy(cp, *++argv, len);
473	cp[len] = '\0';
474	len2 = strlen(cp);
475	len -= len2;
476	cp += len2;
477	}
478	cfg.nopty = TRUE; /* command => no terminal */
479	break; /* done with cmdline */
480	}
12dc4ec0	481	}
	482	}
	483
d8426c54	484	if (!*cfg.host) {
32874aea	485	usage();
d8426c54	486	}
d8426c54	487
96621a84	488	if (!*cfg.remote_cmd_ptr)
32874aea	489	flags \|= FLAG_INTERACTIVE;
67779be7	490
12dc4ec0	491	/*
	492	* Select protocol. This is farmed out into a table in a
	493	* separate file to enable an ssh-free variant.
	494	*/
	495	{
32874aea	496	int i;
	497	back = NULL;
	498	for (i = 0; backends[i].backend != NULL; i++)
	499	if (backends[i].protocol == cfg.protocol) {
	500	back = backends[i].backend;
	501	break;
	502	}
	503	if (back == NULL) {
	504	fprintf(stderr,
	505	"Internal fault: Unsupported protocol found\n");
	506	return 1;
	507	}
12dc4ec0	508	}
	509
	510	/*
8cb9c947	511	* Select port.
	512	*/
	513	if (portnumber != -1)
32874aea	514	cfg.port = portnumber;
8cb9c947	515
8cb9c947	516	/*
12dc4ec0	517	* Initialise WinSock.
	518	*/
	519	winsock_ver = MAKEWORD(2, 0);
	520	if (WSAStartup(winsock_ver, &wsadata)) {
	521	MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
	522	MB_OK \| MB_ICONEXCLAMATION);
	523	return 1;
	524	}
	525	if (LOBYTE(wsadata.wVersion) != 2 \|\| HIBYTE(wsadata.wVersion) != 0) {
	526	MessageBox(NULL, "WinSock version is incompatible with 2.0",
	527	"WinSock Error", MB_OK \| MB_ICONEXCLAMATION);
	528	WSACleanup();
	529	return 1;
	530	}
8df7a775	531	sk_init();
12dc4ec0	532
	533	/*
	534	* Start up the connection.
	535	*/
8df7a775	536	netevent = CreateEvent(NULL, FALSE, FALSE, NULL);
12dc4ec0	537	{
	538	char *error;
	539	char *realhost;
	540
32874aea	541	error = back->init(cfg.host, cfg.port, &realhost);
12dc4ec0	542	if (error) {
	543	fprintf(stderr, "Unable to open connection:\n%s", error);
	544	return 1;
	545	}
6e1ebb76	546	sfree(realhost);
12dc4ec0	547	}
8df7a775	548	connopen = 1;
12dc4ec0	549
12dc4ec0	550	stdinevent = CreateEvent(NULL, FALSE, FALSE, NULL);
12dc4ec0	551
0965bee0	552	inhandle = GetStdHandle(STD_INPUT_HANDLE);
12dc4ec0	553	outhandle = GetStdHandle(STD_OUTPUT_HANDLE);
fe50e814	554	errhandle = GetStdHandle(STD_ERROR_HANDLE);
0965bee0	555	GetConsoleMode(inhandle, &orig_console_mode);
0965bee0	556	SetConsoleMode(inhandle, ENABLE_PROCESSED_INPUT);
12dc4ec0	557
12dc4ec0	558	/*
12dc4ec0	559	* Turn off ECHO and LINE input modes. We don't care if this
	560	* call fails, because we know we aren't necessarily running in
	561	* a console.
	562	*/
12dc4ec0	563	handles[0] = netevent;
	564	handles[1] = stdinevent;
	565	sending = FALSE;
	566	while (1) {
32874aea	567	int n;
	568
	569	if (!sending && back->sendok()) {
	570	/*
	571	* Create a separate thread to read from stdin. This is
	572	* a total pain, but I can't find another way to do it:
	573	*
	574	* - an overlapped ReadFile or ReadFileEx just doesn't
	575	* happen; we get failure from ReadFileEx, and
	576	* ReadFile blocks despite being given an OVERLAPPED
	577	* structure. Perhaps we can't do overlapped reads
	578	* on consoles. WHY THE HELL NOT?
	579	*
	580	* - WaitForMultipleObjects(netevent, console) doesn't
	581	* work, because it signals the console when
	582	* _anything_ happens, including mouse motions and
	583	* other things that don't cause data to be readable
	584	* - so we're back to ReadFile blocking.
	585	*/
	586	idata.event = stdinevent;
	587	idata.eventback = CreateEvent(NULL, FALSE, FALSE, NULL);
	588	if (!CreateThread(NULL, 0, stdin_read_thread,
	589	&idata, 0, &threadid)) {
	590	fprintf(stderr, "Unable to create second thread\n");
	591	exit(1);
	592	}
	593	sending = TRUE;
	594	}
	595
	596	n = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
	597	if (n == 0) {
	598	WSANETWORKEVENTS things;
8df7a775	599	SOCKET socket;
d2371c81	600	extern SOCKET first_socket(int ), next_socket(int );
8df7a775	601	extern int select_result(WPARAM, LPARAM);
32874aea	602	int i, socketstate;
	603
	604	/*
	605	* We must not call select_result() for any socket
	606	* until we have finished enumerating within the tree.
	607	* This is because select_result() may close the socket
	608	* and modify the tree.
	609	*/
	610	/* Count the active sockets. */
	611	i = 0;
	612	for (socket = first_socket(&socketstate);
	613	socket != INVALID_SOCKET;
	614	socket = next_socket(&socketstate)) i++;
	615
	616	/* Expand the buffer if necessary. */
	617	if (i > sksize) {
	618	sksize = i + 16;
	619	sklist = srealloc(sklist, sksize * sizeof(*sklist));
	620	}
	621
	622	/* Retrieve the sockets into sklist. */
	623	skcount = 0;
	624	for (socket = first_socket(&socketstate);
	625	socket != INVALID_SOCKET;
d2371c81	626	socket = next_socket(&socketstate)) {
32874aea	627	sklist[skcount++] = socket;
	628	}
	629
	630	/* Now we're done enumerating; go through the list. */
	631	for (i = 0; i < skcount; i++) {
	632	WPARAM wp;
	633	socket = sklist[i];
	634	wp = (WPARAM) socket;
ffb959c7	635	if (!WSAEnumNetworkEvents(socket, NULL, &things)) {
32874aea	636	noise_ultralight(socket);
32874aea	637	noise_ultralight(things.lNetworkEvents);
8df7a775	638	if (things.lNetworkEvents & FD_READ)
32874aea	639	connopen &= select_result(wp, (LPARAM) FD_READ);
8df7a775	640	if (things.lNetworkEvents & FD_CLOSE)
32874aea	641	connopen &= select_result(wp, (LPARAM) FD_CLOSE);
8df7a775	642	if (things.lNetworkEvents & FD_OOB)
32874aea	643	connopen &= select_result(wp, (LPARAM) FD_OOB);
8df7a775	644	if (things.lNetworkEvents & FD_WRITE)
32874aea	645	connopen &= select_result(wp, (LPARAM) FD_WRITE);
8df7a775	646	}
8df7a775	647	}
32874aea	648	} else if (n == 1) {
	649	noise_ultralight(idata.len);
	650	if (idata.len > 0) {
	651	back->send(idata.buffer, idata.len);
	652	} else {
	653	back->special(TS_EOF);
	654	}
	655	SetEvent(idata.eventback);
	656	}
	657	if (!connopen \|\| back->socket() == NULL)
	658	break; /* we closed the connection */
12dc4ec0	659	}
	660	WSACleanup();
	661	return 0;
	662	}