[sgt/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 <stdarg.h>

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

void fatalbox (char *p, ...) {
    va_list ap;
    fprintf(stderr, "FATAL ERROR: ", p);
    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: ", p);
    va_start(ap, p);
    vfprintf(stderr, p, ap);
    va_end(ap);
    fputc('\n', stderr);
    WSACleanup();
    exit(1);
}

static char *password = NULL;

/*
 * Stubs for linking with other modules.
 */
void write_clip (void *data, int len, int must_deselect) { }
void term_deselect(void) { }

HANDLE outhandle;
DWORD orig_console_mode;

void begin_session(void) {
    if (!cfg.ldisc_term)
        SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), ENABLE_PROCESSED_INPUT);
    else
        SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), orig_console_mode);
}

void term_out(void)
{
    int reap;
    DWORD ret;
    reap = 0;
    while (reap < inbuf_head) {
        if (!WriteFile(outhandle, inbuf+reap, inbuf_head-reap, &ret, NULL))
            return;                    /* give up in panic */
        reap += ret;
    }
    inbuf_head = 0;
}

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

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

    if (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);
    SetConsoleMode(hin, (savemode & (~ENABLE_ECHO_INPUT)) |
                   ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT);

    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';

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

    return 1;
}

static int 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)) {
        SetEvent(idata->event);
    }

    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");
    exit(1);
}

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

    ssh_get_password = get_password;

    flags = FLAG_STDERR;
    /*
     * Process the command line.
     */
    do_defaults(NULL);
    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, "-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.
                         */
                        do_defaults (p);
                        if (cfg.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 = 22;
                        }
                    } 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 = 22;
                    }
                }
            } 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 */
                cfg.ldisc_term = TRUE; /* use stdin like a line buffer */
                break;                 /* done with cmdline */
            }
	}
    }

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

    if (!*cfg.remote_cmd)
        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;
    }

    /*
     * Start up the connection.
     */
    {
	char *error;
	char *realhost;

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

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

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

    /*
     * Now we must send the back end oodles of stuff.
     */
    socket = back->socket();
    /*
     * 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.
     */
    WSAEventSelect(socket, netevent, FD_READ | FD_CLOSE);
    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;
            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;
            if (!WSAEnumNetworkEvents(socket, netevent, &things)) {
                if (things.lNetworkEvents & FD_READ)
                    back->msg(0, FD_READ);
                if (things.lNetworkEvents & FD_CLOSE) {
                    back->msg(0, FD_CLOSE);
                    break;
                }
            }
            term_out();
        } else if (n == 1) {
            if (idata.len > 0) {
                back->send(idata.buffer, idata.len);
            } else {
                back->special(TS_EOF);
            }
        }
    }
    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>
	9	#include <stdio.h>
	10	#include <stdarg.h>
	11
	12	#define PUTTY_DO_GLOBALS /* actually _define_ globals */
	13	#include "putty.h"
	14
	15	void fatalbox (char *p, ...) {
	16	va_list ap;
	17	fprintf(stderr, "FATAL ERROR: ", p);
	18	va_start(ap, p);
	19	vfprintf(stderr, p, ap);
	20	va_end(ap);
	21	fputc('\n', stderr);
	22	WSACleanup();
	23	exit(1);
	24	}
8d5de777	25	void connection_fatal (char *p, ...) {
	26	va_list ap;
	27	fprintf(stderr, "FATAL ERROR: ", p);
	28	va_start(ap, p);
	29	vfprintf(stderr, p, ap);
	30	va_end(ap);
	31	fputc('\n', stderr);
	32	WSACleanup();
	33	exit(1);
	34	}
12dc4ec0	35
d8426c54	36	static char *password = NULL;
d8426c54	37
989b10e9	38	/*
	39	* Stubs for linking with other modules.
	40	*/
f0df44da	41	void write_clip (void *data, int len, int must_deselect) { }
989b10e9	42	void term_deselect(void) { }
989b10e9	43
12dc4ec0	44	HANDLE outhandle;
6f34e365	45	DWORD orig_console_mode;
	46
	47	void begin_session(void) {
	48	if (!cfg.ldisc_term)
	49	SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), ENABLE_PROCESSED_INPUT);
	50	else
	51	SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), orig_console_mode);
	52	}
12dc4ec0	53
	54	void term_out(void)
	55	{
	56	int reap;
	57	DWORD ret;
12dc4ec0	58	reap = 0;
	59	while (reap < inbuf_head) {
	60	if (!WriteFile(outhandle, inbuf+reap, inbuf_head-reap, &ret, NULL))
	61	return; /* give up in panic */
	62	reap += ret;
	63	}
	64	inbuf_head = 0;
	65	}
	66
	67	struct input_data {
	68	DWORD len;
	69	char buffer[4096];
	70	HANDLE event;
	71	};
	72
67779be7	73	static int get_password(const char prompt, char str, int maxlen)
	74	{
	75	HANDLE hin, hout;
	76	DWORD savemode, i;
	77
67779be7	78	if (password) {
	79	static int tried_once = 0;
	80
	81	if (tried_once) {
	82	return 0;
	83	} else {
	84	strncpy(str, password, maxlen);
	85	str[maxlen-1] = '\0';
	86	tried_once = 1;
	87	return 1;
	88	}
	89	}
67779be7	90
	91	hin = GetStdHandle(STD_INPUT_HANDLE);
	92	hout = GetStdHandle(STD_OUTPUT_HANDLE);
	93	if (hin == INVALID_HANDLE_VALUE \|\| hout == INVALID_HANDLE_VALUE) {
	94	fprintf(stderr, "Cannot get standard input/output handles");
	95	return 0;
	96	}
	97
	98	GetConsoleMode(hin, &savemode);
	99	SetConsoleMode(hin, (savemode & (~ENABLE_ECHO_INPUT)) \|
	100	ENABLE_PROCESSED_INPUT \| ENABLE_LINE_INPUT);
	101
	102	WriteFile(hout, prompt, strlen(prompt), &i, NULL);
	103	ReadFile(hin, str, maxlen-1, &i, NULL);
	104
	105	SetConsoleMode(hin, savemode);
	106
	107	if ((int)i > maxlen) i = maxlen-1; else i = i - 2;
	108	str[i] = '\0';
	109
	110	WriteFile(hout, "\r\n", 2, &i, NULL);
	111
	112	return 1;
	113	}
	114
f0df44da	115	static int WINAPI stdin_read_thread(void *param) {
12dc4ec0	116	struct input_data idata = (struct input_data )param;
	117	HANDLE inhandle;
	118
	119	inhandle = GetStdHandle(STD_INPUT_HANDLE);
	120
	121	while (ReadFile(inhandle, idata->buffer, sizeof(idata->buffer),
	122	&idata->len, NULL)) {
	123	SetEvent(idata->event);
	124	}
	125
	126	idata->len = 0;
	127	SetEvent(idata->event);
	128
	129	return 0;
	130	}
	131
d8426c54	132	/*
	133	* Short description of parameters.
	134	*/
	135	static void usage(void)
	136	{
	137	printf("PuTTY Link: command-line connection utility\n");
	138	printf("%s\n", ver);
	139	printf("Usage: plink [options] [user@]host [command]\n");
	140	printf("Options:\n");
	141	printf(" -v show verbose messages\n");
	142	printf(" -ssh force use of ssh protocol\n");
	143	printf(" -P port connect to specified port\n");
	144	printf(" -pw passw login with specified password\n");
	145	exit(1);
	146	}
	147
12dc4ec0	148	int main(int argc, char **argv) {
	149	WSADATA wsadata;
	150	WORD winsock_ver;
	151	WSAEVENT netevent, stdinevent;
	152	HANDLE handles[2];
	153	SOCKET socket;
	154	DWORD threadid;
	155	struct input_data idata;
	156	int sending;
d8426c54	157	int portnumber = -1;
12dc4ec0	158
67779be7	159	ssh_get_password = get_password;
	160
	161	flags = FLAG_STDERR;
12dc4ec0	162	/*
	163	* Process the command line.
	164	*/
12dc4ec0	165	do_defaults(NULL);
e7a7383f	166	default_protocol = cfg.protocol;
e7a7383f	167	default_port = cfg.port;
8cb9c947	168	{
	169	/*
	170	* Override the default protocol if PLINK_PROTOCOL is set.
	171	*/
	172	char *p = getenv("PLINK_PROTOCOL");
	173	int i;
	174	if (p) {
	175	for (i = 0; backends[i].backend != NULL; i++) {
	176	if (!strcmp(backends[i].name, p)) {
	177	default_protocol = cfg.protocol = backends[i].protocol;
	178	default_port = cfg.port = backends[i].backend->default_port;
	179	break;
	180	}
	181	}
	182	}
	183	}
12dc4ec0	184	while (--argc) {
	185	char p = ++argv;
	186	if (*p == '-') {
	187	if (!strcmp(p, "-ssh")) {
	188	default_protocol = cfg.protocol = PROT_SSH;
	189	default_port = cfg.port = 22;
9d33ebdd	190	} else if (!strcmp(p, "-telnet")) {
	191	default_protocol = cfg.protocol = PROT_TELNET;
	192	default_port = cfg.port = 23;
	193	} else if (!strcmp(p, "-raw")) {
	194	default_protocol = cfg.protocol = PROT_RAW;
67779be7	195	} else if (!strcmp(p, "-v")) {
67779be7	196	flags \|= FLAG_VERBOSE;
12dc4ec0	197	} else if (!strcmp(p, "-log")) {
12dc4ec0	198	logfile = "putty.log";
d8426c54	199	} else if (!strcmp(p, "-pw") && argc > 1) {
d8426c54	200	--argc, password = *++argv;
e7a7383f	201	} else if (!strcmp(p, "-l") && argc > 1) {
	202	char *username;
	203	--argc, username = *++argv;
	204	strncpy(cfg.username, username, sizeof(cfg.username));
	205	cfg.username[sizeof(cfg.username)-1] = '\0';
d8426c54	206	} else if (!strcmp(p, "-P") && argc > 1) {
	207	--argc, portnumber = atoi(*++argv);
	208	}
12dc4ec0	209	} else if (*p) {
	210	if (!*cfg.host) {
	211	char *q = p;
	212	/*
	213	* If the hostname starts with "telnet:", set the
	214	* protocol to Telnet and process the string as a
	215	* Telnet URL.
	216	*/
	217	if (!strncmp(q, "telnet:", 7)) {
	218	char c;
	219
	220	q += 7;
	221	if (q[0] == '/' && q[1] == '/')
	222	q += 2;
	223	cfg.protocol = PROT_TELNET;
	224	p = q;
	225	while (p && p != ':' && *p != '/') p++;
	226	c = *p;
	227	if (*p)
	228	*p++ = '\0';
	229	if (c == ':')
	230	cfg.port = atoi(p);
	231	else
	232	cfg.port = -1;
	233	strncpy (cfg.host, q, sizeof(cfg.host)-1);
	234	cfg.host[sizeof(cfg.host)-1] = '\0';
	235	} else {
9d33ebdd	236	char *r;
	237	/*
	238	* Before we process the [user@]host string, we
	239	* first check for the presence of a protocol
	240	* prefix (a protocol name followed by ",").
	241	*/
	242	r = strchr(p, ',');
	243	if (r) {
	244	int i, j;
	245	for (i = 0; backends[i].backend != NULL; i++) {
	246	j = strlen(backends[i].name);
	247	if (j == r-p &&
	248	!memcmp(backends[i].name, p, j)) {
	249	default_protocol = cfg.protocol = backends[i].protocol;
	250	portnumber = backends[i].backend->default_port;
	251	p = r+1;
	252	break;
	253	}
	254	}
	255	}
	256
12dc4ec0	257	/*
	258	* Three cases. Either (a) there's a nonzero
	259	* length string followed by an @, in which
	260	* case that's user and the remainder is host.
	261	* Or (b) there's only one string, not counting
	262	* a potential initial @, and it exists in the
	263	* saved-sessions database. Or (c) only one
	264	* string and it _doesn't_ exist in the
	265	* database.
	266	*/
9d33ebdd	267	r = strrchr(p, '@');
12dc4ec0	268	if (r == p) p++, r = NULL; /* discount initial @ */
	269	if (r == NULL) {
	270	/*
	271	* One string.
	272	*/
	273	do_defaults (p);
	274	if (cfg.host[0] == '\0') {
	275	/* No settings for this host; use defaults */
	276	strncpy(cfg.host, p, sizeof(cfg.host)-1);
	277	cfg.host[sizeof(cfg.host)-1] = '\0';
	278	cfg.port = 22;
	279	}
	280	} else {
	281	*r++ = '\0';
	282	strncpy(cfg.username, p, sizeof(cfg.username)-1);
	283	cfg.username[sizeof(cfg.username)-1] = '\0';
	284	strncpy(cfg.host, r, sizeof(cfg.host)-1);
	285	cfg.host[sizeof(cfg.host)-1] = '\0';
	286	cfg.port = 22;
	287	}
	288	}
	289	} else {
	290	int len = sizeof(cfg.remote_cmd) - 1;
	291	char *cp = cfg.remote_cmd;
	292	int len2;
	293
	294	strncpy(cp, p, len); cp[len] = '\0';
	295	len2 = strlen(cp); len -= len2; cp += len2;
	296	while (--argc) {
	297	if (len > 0)
	298	len--, *cp++ = ' ';
	299	strncpy(cp, *++argv, len); cp[len] = '\0';
	300	len2 = strlen(cp); len -= len2; cp += len2;
	301	}
	302	cfg.nopty = TRUE; /* command => no terminal */
	303	cfg.ldisc_term = TRUE; /* use stdin like a line buffer */
	304	break; /* done with cmdline */
	305	}
	306	}
	307	}
	308
d8426c54	309	if (!*cfg.host) {
	310	usage();
	311	}
d8426c54	312
67779be7	313	if (!*cfg.remote_cmd)
	314	flags \|= FLAG_INTERACTIVE;
	315
12dc4ec0	316	/*
	317	* Select protocol. This is farmed out into a table in a
	318	* separate file to enable an ssh-free variant.
	319	*/
	320	{
	321	int i;
	322	back = NULL;
	323	for (i = 0; backends[i].backend != NULL; i++)
	324	if (backends[i].protocol == cfg.protocol) {
	325	back = backends[i].backend;
	326	break;
	327	}
	328	if (back == NULL) {
	329	fprintf(stderr, "Internal fault: Unsupported protocol found\n");
	330	return 1;
	331	}
	332	}
	333
	334	/*
8cb9c947	335	* Select port.
	336	*/
	337	if (portnumber != -1)
	338	cfg.port = portnumber;
	339
	340	/*
12dc4ec0	341	* Initialise WinSock.
	342	*/
	343	winsock_ver = MAKEWORD(2, 0);
	344	if (WSAStartup(winsock_ver, &wsadata)) {
	345	MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
	346	MB_OK \| MB_ICONEXCLAMATION);
	347	return 1;
	348	}
	349	if (LOBYTE(wsadata.wVersion) != 2 \|\| HIBYTE(wsadata.wVersion) != 0) {
	350	MessageBox(NULL, "WinSock version is incompatible with 2.0",
	351	"WinSock Error", MB_OK \| MB_ICONEXCLAMATION);
	352	WSACleanup();
	353	return 1;
	354	}
	355
	356	/*
	357	* Start up the connection.
	358	*/
	359	{
	360	char *error;
	361	char *realhost;
	362
	363	error = back->init (NULL, cfg.host, cfg.port, &realhost);
	364	if (error) {
	365	fprintf(stderr, "Unable to open connection:\n%s", error);
	366	return 1;
	367	}
	368	}
	369
	370	netevent = CreateEvent(NULL, FALSE, FALSE, NULL);
	371	stdinevent = CreateEvent(NULL, FALSE, FALSE, NULL);
	372
6f34e365	373	GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &orig_console_mode);
6f34e365	374	SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), ENABLE_PROCESSED_INPUT);
12dc4ec0	375	outhandle = GetStdHandle(STD_OUTPUT_HANDLE);
	376
	377	/*
	378	* Now we must send the back end oodles of stuff.
	379	*/
	380	socket = back->socket();
	381	/*
	382	* Turn off ECHO and LINE input modes. We don't care if this
	383	* call fails, because we know we aren't necessarily running in
	384	* a console.
	385	*/
	386	WSAEventSelect(socket, netevent, FD_READ \| FD_CLOSE);
	387	handles[0] = netevent;
	388	handles[1] = stdinevent;
	389	sending = FALSE;
	390	while (1) {
	391	int n;
8cb9c947	392
	393	if (!sending && back->sendok()) {
	394	/*
	395	* Create a separate thread to read from stdin. This is
	396	* a total pain, but I can't find another way to do it:
	397	*
	398	* - an overlapped ReadFile or ReadFileEx just doesn't
	399	* happen; we get failure from ReadFileEx, and
	400	* ReadFile blocks despite being given an OVERLAPPED
	401	* structure. Perhaps we can't do overlapped reads
	402	* on consoles. WHY THE HELL NOT?
	403	*
	404	* - WaitForMultipleObjects(netevent, console) doesn't
	405	* work, because it signals the console when
	406	* _anything_ happens, including mouse motions and
	407	* other things that don't cause data to be readable
	408	* - so we're back to ReadFile blocking.
	409	*/
	410	idata.event = stdinevent;
	411	if (!CreateThread(NULL, 0, stdin_read_thread,
	412	&idata, 0, &threadid)) {
	413	fprintf(stderr, "Unable to create second thread\n");
	414	exit(1);
	415	}
	416	sending = TRUE;
	417	}
	418
12dc4ec0	419	n = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
	420	if (n == 0) {
	421	WSANETWORKEVENTS things;
	422	if (!WSAEnumNetworkEvents(socket, netevent, &things)) {
	423	if (things.lNetworkEvents & FD_READ)
	424	back->msg(0, FD_READ);
	425	if (things.lNetworkEvents & FD_CLOSE) {
	426	back->msg(0, FD_CLOSE);
	427	break;
	428	}
	429	}
	430	term_out();
12dc4ec0	431	} else if (n == 1) {
	432	if (idata.len > 0) {
	433	back->send(idata.buffer, idata.len);
	434	} else {
	435	back->special(TS_EOF);
	436	}
	437	}
	438	}
	439	WSACleanup();
	440	return 0;
	441	}