mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-10 01:48:00 +00:00
364e1aa3f3
Having a single plug_closing() function covering various kinds of closure is reasonably convenient from the point of view of Plug implementations, but it's annoying for callers, who all have to fill in pointless NULL and 0 parameters in the cases where they're not used. Added some inline helper functions in network.h alongside the main plug_closing() dispatch wrappers, so that each kind of connection closure can present a separate API for the Socket side of the interface, without complicating the vtable for the Plug side. Also, added OS-specific extra helpers in the Unix and Windows directories, which centralise the job of taking an OS error code (of whatever kind) and translating it into its error message. In passing, this removes the horrible ad-hoc made-up error codes in proxy.h, which is OK, because nothing checked for them anyway, and also I'm about to do an API change to plug_closing proper that removes the need for them.
370 lines
10 KiB
C
370 lines
10 KiB
C
/*
|
|
* General mechanism for wrapping up reading/writing of Windows
|
|
* HANDLEs into a PuTTY Socket abstraction.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <assert.h>
|
|
#include <limits.h>
|
|
|
|
#include "tree234.h"
|
|
#include "putty.h"
|
|
#include "network.h"
|
|
|
|
typedef struct HandleSocket {
|
|
HANDLE send_H, recv_H, stderr_H;
|
|
struct handle *send_h, *recv_h, *stderr_h;
|
|
|
|
/*
|
|
* Freezing one of these sockets is a slightly fiddly business,
|
|
* because the reads from the handle are happening in a separate
|
|
* thread as blocking system calls and so once one is in progress
|
|
* it can't sensibly be interrupted. Hence, after the user tries
|
|
* to freeze one of these sockets, it's unavoidable that we may
|
|
* receive one more load of data before we manage to get
|
|
* winhandl.c to stop reading.
|
|
*/
|
|
enum {
|
|
UNFROZEN, /* reading as normal */
|
|
FREEZING, /* have been set to frozen but winhandl is still reading */
|
|
FROZEN, /* really frozen - winhandl has been throttled */
|
|
THAWING /* we're gradually releasing our remaining data */
|
|
} frozen;
|
|
/* We buffer data here if we receive it from winhandl while frozen. */
|
|
bufchain inputdata;
|
|
|
|
/* Handle logging proxy error messages from stderr_H, if we have one. */
|
|
ProxyStderrBuf psb;
|
|
|
|
bool defer_close, deferred_close; /* in case of re-entrance */
|
|
|
|
char *error;
|
|
|
|
SockAddr *addr;
|
|
int port;
|
|
Plug *plug;
|
|
|
|
Socket sock;
|
|
} HandleSocket;
|
|
|
|
static size_t handle_gotdata(
|
|
struct handle *h, const void *data, size_t len, int err)
|
|
{
|
|
HandleSocket *hs = (HandleSocket *)handle_get_privdata(h);
|
|
|
|
if (err) {
|
|
plug_closing_error(hs->plug, "Read error from handle");
|
|
return 0;
|
|
} else if (len == 0) {
|
|
plug_closing_normal(hs->plug);
|
|
return 0;
|
|
} else {
|
|
assert(hs->frozen != FROZEN && hs->frozen != THAWING);
|
|
if (hs->frozen == FREEZING) {
|
|
/*
|
|
* If we've received data while this socket is supposed to
|
|
* be frozen (because the read winhandl.c started before
|
|
* sk_set_frozen was called has now returned) then buffer
|
|
* the data for when we unfreeze.
|
|
*/
|
|
bufchain_add(&hs->inputdata, data, len);
|
|
hs->frozen = FROZEN;
|
|
|
|
/*
|
|
* And return a very large backlog, to prevent further
|
|
* data arriving from winhandl until we unfreeze.
|
|
*/
|
|
return INT_MAX;
|
|
} else {
|
|
plug_receive(hs->plug, 0, data, len);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static size_t handle_stderr(
|
|
struct handle *h, const void *data, size_t len, int err)
|
|
{
|
|
HandleSocket *hs = (HandleSocket *)handle_get_privdata(h);
|
|
|
|
if (!err && len > 0)
|
|
log_proxy_stderr(hs->plug, &hs->psb, data, len);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void handle_sentdata(struct handle *h, size_t new_backlog, int err,
|
|
bool close)
|
|
{
|
|
HandleSocket *hs = (HandleSocket *)handle_get_privdata(h);
|
|
|
|
if (close) {
|
|
if (hs->send_H != INVALID_HANDLE_VALUE)
|
|
CloseHandle(hs->send_H);
|
|
if (hs->recv_H != INVALID_HANDLE_VALUE && hs->recv_H != hs->send_H)
|
|
CloseHandle(hs->recv_H);
|
|
hs->send_H = hs->recv_H = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
if (err) {
|
|
plug_closing_system_error(hs->plug, err);
|
|
return;
|
|
}
|
|
|
|
plug_sent(hs->plug, new_backlog);
|
|
}
|
|
|
|
static Plug *sk_handle_plug(Socket *s, Plug *p)
|
|
{
|
|
HandleSocket *hs = container_of(s, HandleSocket, sock);
|
|
Plug *ret = hs->plug;
|
|
if (p)
|
|
hs->plug = p;
|
|
return ret;
|
|
}
|
|
|
|
static void sk_handle_close(Socket *s)
|
|
{
|
|
HandleSocket *hs = container_of(s, HandleSocket, sock);
|
|
|
|
if (hs->defer_close) {
|
|
hs->deferred_close = true;
|
|
return;
|
|
}
|
|
|
|
handle_free(hs->send_h);
|
|
handle_free(hs->recv_h);
|
|
if (hs->send_H != INVALID_HANDLE_VALUE)
|
|
CloseHandle(hs->send_H);
|
|
if (hs->recv_H != INVALID_HANDLE_VALUE && hs->recv_H != hs->send_H)
|
|
CloseHandle(hs->recv_H);
|
|
bufchain_clear(&hs->inputdata);
|
|
|
|
if (hs->addr)
|
|
sk_addr_free(hs->addr);
|
|
|
|
delete_callbacks_for_context(hs);
|
|
|
|
sfree(hs);
|
|
}
|
|
|
|
static size_t sk_handle_write(Socket *s, const void *data, size_t len)
|
|
{
|
|
HandleSocket *hs = container_of(s, HandleSocket, sock);
|
|
|
|
return handle_write(hs->send_h, data, len);
|
|
}
|
|
|
|
static size_t sk_handle_write_oob(Socket *s, const void *data, size_t len)
|
|
{
|
|
/*
|
|
* oob data is treated as inband; nasty, but nothing really
|
|
* better we can do
|
|
*/
|
|
return sk_handle_write(s, data, len);
|
|
}
|
|
|
|
static void sk_handle_write_eof(Socket *s)
|
|
{
|
|
HandleSocket *hs = container_of(s, HandleSocket, sock);
|
|
|
|
handle_write_eof(hs->send_h);
|
|
}
|
|
|
|
static void handle_socket_unfreeze(void *hsv)
|
|
{
|
|
HandleSocket *hs = (HandleSocket *)hsv;
|
|
|
|
/*
|
|
* If we've been put into a state other than THAWING since the
|
|
* last callback, then we're done.
|
|
*/
|
|
if (hs->frozen != THAWING)
|
|
return;
|
|
|
|
/*
|
|
* Get some of the data we've buffered.
|
|
*/
|
|
ptrlen data = bufchain_prefix(&hs->inputdata);
|
|
assert(data.len > 0);
|
|
|
|
/*
|
|
* Hand it off to the plug. Be careful of re-entrance - that might
|
|
* have the effect of trying to close this socket.
|
|
*/
|
|
hs->defer_close = true;
|
|
plug_receive(hs->plug, 0, data.ptr, data.len);
|
|
bufchain_consume(&hs->inputdata, data.len);
|
|
hs->defer_close = false;
|
|
if (hs->deferred_close) {
|
|
sk_handle_close(&hs->sock);
|
|
return;
|
|
}
|
|
|
|
if (bufchain_size(&hs->inputdata) > 0) {
|
|
/*
|
|
* If there's still data in our buffer, stay in THAWING state,
|
|
* and reschedule ourself.
|
|
*/
|
|
queue_toplevel_callback(handle_socket_unfreeze, hs);
|
|
} else {
|
|
/*
|
|
* Otherwise, we've successfully thawed!
|
|
*/
|
|
hs->frozen = UNFROZEN;
|
|
handle_unthrottle(hs->recv_h, 0);
|
|
}
|
|
}
|
|
|
|
static void sk_handle_set_frozen(Socket *s, bool is_frozen)
|
|
{
|
|
HandleSocket *hs = container_of(s, HandleSocket, sock);
|
|
|
|
if (is_frozen) {
|
|
switch (hs->frozen) {
|
|
case FREEZING:
|
|
case FROZEN:
|
|
return; /* nothing to do */
|
|
|
|
case THAWING:
|
|
/*
|
|
* We were in the middle of emptying our bufchain, and got
|
|
* frozen again. In that case, winhandl.c is already
|
|
* throttled, so just return to FROZEN state. The toplevel
|
|
* callback will notice and disable itself.
|
|
*/
|
|
hs->frozen = FROZEN;
|
|
break;
|
|
|
|
case UNFROZEN:
|
|
/*
|
|
* The normal case. Go to FREEZING, and expect one more
|
|
* load of data from winhandl if we're unlucky.
|
|
*/
|
|
hs->frozen = FREEZING;
|
|
break;
|
|
}
|
|
} else {
|
|
switch (hs->frozen) {
|
|
case UNFROZEN:
|
|
case THAWING:
|
|
return; /* nothing to do */
|
|
|
|
case FREEZING:
|
|
/*
|
|
* If winhandl didn't send us any data throughout the time
|
|
* we were frozen, then we'll still be in this state and
|
|
* can just unfreeze in the trivial way.
|
|
*/
|
|
assert(bufchain_size(&hs->inputdata) == 0);
|
|
hs->frozen = UNFROZEN;
|
|
break;
|
|
|
|
case FROZEN:
|
|
/*
|
|
* If we have buffered data, go to THAWING and start
|
|
* releasing it in top-level callbacks.
|
|
*/
|
|
hs->frozen = THAWING;
|
|
queue_toplevel_callback(handle_socket_unfreeze, hs);
|
|
}
|
|
}
|
|
}
|
|
|
|
static const char *sk_handle_socket_error(Socket *s)
|
|
{
|
|
HandleSocket *hs = container_of(s, HandleSocket, sock);
|
|
return hs->error;
|
|
}
|
|
|
|
static SocketPeerInfo *sk_handle_peer_info(Socket *s)
|
|
{
|
|
HandleSocket *hs = container_of(s, HandleSocket, sock);
|
|
ULONG pid;
|
|
static HMODULE kernel32_module;
|
|
DECL_WINDOWS_FUNCTION(static, BOOL, GetNamedPipeClientProcessId,
|
|
(HANDLE, PULONG));
|
|
|
|
if (!kernel32_module) {
|
|
kernel32_module = load_system32_dll("kernel32.dll");
|
|
#if !HAVE_GETNAMEDPIPECLIENTPROCESSID
|
|
/* For older Visual Studio, and MinGW too (at least as of
|
|
* Ubuntu 16.04), this function isn't available in the header
|
|
* files to type-check. Ditto the toolchain I use for
|
|
* Coveritying the Windows code. */
|
|
GET_WINDOWS_FUNCTION_NO_TYPECHECK(
|
|
kernel32_module, GetNamedPipeClientProcessId);
|
|
#else
|
|
GET_WINDOWS_FUNCTION(
|
|
kernel32_module, GetNamedPipeClientProcessId);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Of course, not all handles managed by this module will be
|
|
* server ends of named pipes, but if they are, then it's useful
|
|
* to log what we can find out about the client end.
|
|
*/
|
|
if (p_GetNamedPipeClientProcessId &&
|
|
p_GetNamedPipeClientProcessId(hs->send_H, &pid)) {
|
|
SocketPeerInfo *pi = snew(SocketPeerInfo);
|
|
pi->addressfamily = ADDRTYPE_LOCAL;
|
|
pi->addr_text = NULL;
|
|
pi->port = -1;
|
|
pi->log_text = dupprintf("process id %lu", (unsigned long)pid);
|
|
return pi;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static const SocketVtable HandleSocket_sockvt = {
|
|
.plug = sk_handle_plug,
|
|
.close = sk_handle_close,
|
|
.write = sk_handle_write,
|
|
.write_oob = sk_handle_write_oob,
|
|
.write_eof = sk_handle_write_eof,
|
|
.set_frozen = sk_handle_set_frozen,
|
|
.socket_error = sk_handle_socket_error,
|
|
.peer_info = sk_handle_peer_info,
|
|
};
|
|
|
|
static void sk_handle_connect_success_callback(void *ctx)
|
|
{
|
|
HandleSocket *hs = (HandleSocket *)ctx;
|
|
plug_log(hs->plug, PLUGLOG_CONNECT_SUCCESS, hs->addr, hs->port, NULL, 0);
|
|
}
|
|
|
|
Socket *make_handle_socket(HANDLE send_H, HANDLE recv_H, HANDLE stderr_H,
|
|
SockAddr *addr, int port, Plug *plug,
|
|
bool overlapped)
|
|
{
|
|
HandleSocket *hs;
|
|
int flags = (overlapped ? HANDLE_FLAG_OVERLAPPED : 0);
|
|
|
|
hs = snew(HandleSocket);
|
|
hs->sock.vt = &HandleSocket_sockvt;
|
|
hs->addr = addr;
|
|
hs->port = port;
|
|
hs->plug = plug;
|
|
hs->error = NULL;
|
|
hs->frozen = UNFROZEN;
|
|
bufchain_init(&hs->inputdata);
|
|
psb_init(&hs->psb);
|
|
|
|
hs->recv_H = recv_H;
|
|
hs->recv_h = handle_input_new(hs->recv_H, handle_gotdata, hs, flags);
|
|
hs->send_H = send_H;
|
|
hs->send_h = handle_output_new(hs->send_H, handle_sentdata, hs, flags);
|
|
hs->stderr_H = stderr_H;
|
|
if (hs->stderr_H)
|
|
hs->stderr_h = handle_input_new(hs->stderr_H, handle_stderr,
|
|
hs, flags);
|
|
|
|
hs->defer_close = hs->deferred_close = false;
|
|
|
|
queue_toplevel_callback(sk_handle_connect_success_callback, hs);
|
|
|
|
return &hs->sock;
|
|
}
|