[sgt/putty] / plink.c

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

#include <winsock2.h>
#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);
}

HANDLE outhandle;

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

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

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;

    flags = FLAG_CONNECTION;
    /*
     * Process the command line.
     */
    default_protocol = DEFAULT_PROTOCOL;
    default_port = DEFAULT_PORT;
    do_defaults(NULL);
    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, "-log")) {
                logfile = "putty.log";
	    }
	} 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 {
                    /*
                     * 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.
                     */
                    char *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 */
            }
	}
    }

    /*
     * 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;
        }
    }

    /*
     * 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);

    if (!cfg.ldisc_term)
        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;
        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();
            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;
            }
        } 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
	5	#include <winsock2.h>
	6	#include <windows.h>
	7	#include <stdio.h>
	8	#include <stdarg.h>
	9
	10	#define PUTTY_DO_GLOBALS /* actually _define_ globals */
	11	#include "putty.h"
	12
	13	void fatalbox (char *p, ...) {
	14	va_list ap;
	15	fprintf(stderr, "FATAL ERROR: ", p);
	16	va_start(ap, p);
	17	vfprintf(stderr, p, ap);
	18	va_end(ap);
	19	fputc('\n', stderr);
	20	WSACleanup();
	21	exit(1);
	22	}
	23
	24	HANDLE outhandle;
	25
	26	void term_out(void)
	27	{
	28	int reap;
	29	DWORD ret;
	30
	31	reap = 0;
	32	while (reap < inbuf_head) {
	33	if (!WriteFile(outhandle, inbuf+reap, inbuf_head-reap, &ret, NULL))
	34	return; /* give up in panic */
	35	reap += ret;
	36	}
	37	inbuf_head = 0;
	38	}
	39
	40	struct input_data {
	41	DWORD len;
	42	char buffer[4096];
	43	HANDLE event;
	44	};
	45
	46	int WINAPI stdin_read_thread(void *param) {
	47	struct input_data idata = (struct input_data )param;
	48	HANDLE inhandle;
	49
	50	inhandle = GetStdHandle(STD_INPUT_HANDLE);
	51
	52	while (ReadFile(inhandle, idata->buffer, sizeof(idata->buffer),
	53	&idata->len, NULL)) {
	54	SetEvent(idata->event);
	55	}
	56
	57	idata->len = 0;
	58	SetEvent(idata->event);
	59
	60	return 0;
	61	}
	62
	63	int main(int argc, char **argv) {
	64	WSADATA wsadata;
65	WORD winsock_ver;
66	WSAEVENT netevent, stdinevent;
67	HANDLE handles[2];
68	SOCKET socket;
69	DWORD threadid;
70	struct input_data idata;
71	int sending;
72
73	flags = FLAG_CONNECTION;
74	/*
75	* Process the command line.
76	*/
77	default_protocol = DEFAULT_PROTOCOL;
78	default_port = DEFAULT_PORT;
79	do_defaults(NULL);
80	while (--argc) {
81	char p = ++argv;
82	if (*p == '-') {
83	if (!strcmp(p, "-ssh")) {
84	default_protocol = cfg.protocol = PROT_SSH;
85	default_port = cfg.port = 22;
86	} else if (!strcmp(p, "-log")) {
87	logfile = "putty.log";
88	}
89	} else if (*p) {
90	if (!*cfg.host) {
91	char *q = p;
92	/*
93	* If the hostname starts with "telnet:", set the
94	* protocol to Telnet and process the string as a
95	* Telnet URL.
96	*/
97	if (!strncmp(q, "telnet:", 7)) {
98	char c;
99
100	q += 7;
101	if (q[0] == '/' && q[1] == '/')
102	q += 2;
103	cfg.protocol = PROT_TELNET;
104	p = q;
105	while (p && p != ':' && *p != '/') p++;
106	c = *p;
107	if (*p)
108	*p++ = '\0';
109	if (c == ':')
110	cfg.port = atoi(p);
111	else
112	cfg.port = -1;
113	strncpy (cfg.host, q, sizeof(cfg.host)-1);
114	cfg.host[sizeof(cfg.host)-1] = '\0';
115	} else {
116	/*
117	* Three cases. Either (a) there's a nonzero
118	* length string followed by an @, in which
119	* case that's user and the remainder is host.
120	* Or (b) there's only one string, not counting
121	* a potential initial @, and it exists in the
122	* saved-sessions database. Or (c) only one
123	* string and it _doesn't_ exist in the
124	* database.
125	*/
126	char *r = strrchr(p, '@');
127	if (r == p) p++, r = NULL; /* discount initial @ */
128	if (r == NULL) {
129	/*
130	* One string.
131	*/
132	do_defaults (p);
133	if (cfg.host[0] == '\0') {
134	/* No settings for this host; use defaults */
135	strncpy(cfg.host, p, sizeof(cfg.host)-1);
136	cfg.host[sizeof(cfg.host)-1] = '\0';
137	cfg.port = 22;
138	}
139	} else {
140	*r++ = '\0';
141	strncpy(cfg.username, p, sizeof(cfg.username)-1);
142	cfg.username[sizeof(cfg.username)-1] = '\0';
143	strncpy(cfg.host, r, sizeof(cfg.host)-1);
144	cfg.host[sizeof(cfg.host)-1] = '\0';
145	cfg.port = 22;
146	}
147	}
148	} else {
149	int len = sizeof(cfg.remote_cmd) - 1;
150	char *cp = cfg.remote_cmd;
151	int len2;
152
153	strncpy(cp, p, len); cp[len] = '\0';
154	len2 = strlen(cp); len -= len2; cp += len2;
155	while (--argc) {
156	if (len > 0)
157	len--, *cp++ = ' ';
158	strncpy(cp, *++argv, len); cp[len] = '\0';
159	len2 = strlen(cp); len -= len2; cp += len2;
160	}
161	cfg.nopty = TRUE; /* command => no terminal */
162	cfg.ldisc_term = TRUE; /* use stdin like a line buffer */
163	break; /* done with cmdline */
164	}
165	}
166	}
167
168	/*
169	* Select protocol. This is farmed out into a table in a
170	* separate file to enable an ssh-free variant.
171	*/
172	{
173	int i;
174	back = NULL;
175	for (i = 0; backends[i].backend != NULL; i++)
176	if (backends[i].protocol == cfg.protocol) {
177	back = backends[i].backend;
178	break;
179	}
180	if (back == NULL) {
181	fprintf(stderr, "Internal fault: Unsupported protocol found\n");
182	return 1;
183	}
184	}
185
186	/*
187	* Initialise WinSock.
188	*/
189	winsock_ver = MAKEWORD(2, 0);
190	if (WSAStartup(winsock_ver, &wsadata)) {
191	MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
192	MB_OK \| MB_ICONEXCLAMATION);
193	return 1;
194	}
195	if (LOBYTE(wsadata.wVersion) != 2 \|\| HIBYTE(wsadata.wVersion) != 0) {
196	MessageBox(NULL, "WinSock version is incompatible with 2.0",
197	"WinSock Error", MB_OK \| MB_ICONEXCLAMATION);
198	WSACleanup();
199	return 1;
200	}
201
202	/*
203	* Start up the connection.
204	*/
205	{
206	char *error;
207	char *realhost;
208
209	error = back->init (NULL, cfg.host, cfg.port, &realhost);
210	if (error) {
211	fprintf(stderr, "Unable to open connection:\n%s", error);
212	return 1;
213	}
214	}
215
216	netevent = CreateEvent(NULL, FALSE, FALSE, NULL);
217	stdinevent = CreateEvent(NULL, FALSE, FALSE, NULL);
218
219	if (!cfg.ldisc_term)
220	SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), ENABLE_PROCESSED_INPUT);
221	outhandle = GetStdHandle(STD_OUTPUT_HANDLE);
222
223	/*
224	* Now we must send the back end oodles of stuff.
225	*/
226	socket = back->socket();
227	/*
228	* Turn off ECHO and LINE input modes. We don't care if this
229	* call fails, because we know we aren't necessarily running in
230	* a console.
231	*/
232	WSAEventSelect(socket, netevent, FD_READ \| FD_CLOSE);
233	handles[0] = netevent;
234	handles[1] = stdinevent;
235	sending = FALSE;
236	while (1) {
237	int n;
238	n = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
239	if (n == 0) {
240	WSANETWORKEVENTS things;
241	if (!WSAEnumNetworkEvents(socket, netevent, &things)) {
242	if (things.lNetworkEvents & FD_READ)
243	back->msg(0, FD_READ);
244	if (things.lNetworkEvents & FD_CLOSE) {
245	back->msg(0, FD_CLOSE);
246	break;
247	}
248	}
249	term_out();
250	if (!sending && back->sendok()) {
251	/*
252	* Create a separate thread to read from stdin.
253	* This is a total pain, but I can't find another
254	* way to do it:
255	*
256	* - an overlapped ReadFile or ReadFileEx just
257	* doesn't happen; we get failure from
258	* ReadFileEx, and ReadFile blocks despite being
259	* given an OVERLAPPED structure. Perhaps we
260	* can't do overlapped reads on consoles. WHY
261	* THE HELL NOT?
262	*
263	* - WaitForMultipleObjects(netevent, console)
264	* doesn't work, because it signals the console
265	* when _anything_ happens, including mouse
266	* motions and other things that don't cause
267	* data to be readable - so we're back to
268	* ReadFile blocking.
269	*/
270	idata.event = stdinevent;
271	if (!CreateThread(NULL, 0, stdin_read_thread,
272	&idata, 0, &threadid)) {
273	fprintf(stderr, "Unable to create second thread\n");
274	exit(1);
275	}
276	sending = TRUE;
277	}
278	} else if (n == 1) {
279	if (idata.len > 0) {
280	back->send(idata.buffer, idata.len);
281	} else {
282	back->special(TS_EOF);
283	}
284	}
285	}
286	WSACleanup();
287	return 0;
288	}