diff options
Diffstat (limited to 'tools/plink/winnps.c')
| -rw-r--r-- | tools/plink/winnps.c | 248 |
1 files changed, 248 insertions, 0 deletions
diff --git a/tools/plink/winnps.c b/tools/plink/winnps.c new file mode 100644 index 000000000..a172628f8 --- /dev/null +++ b/tools/plink/winnps.c @@ -0,0 +1,248 @@ +/* + * Windows support module which deals with being a named-pipe server. + */ + +#include <stdio.h> +#include <assert.h> + +#define DEFINE_PLUG_METHOD_MACROS +#include "tree234.h" +#include "putty.h" +#include "network.h" +#include "proxy.h" +#include "ssh.h" + +#if !defined NO_SECURITY + +#include "winsecur.h" + +Socket make_handle_socket(HANDLE send_H, HANDLE recv_H, Plug plug, + int overlapped); + +typedef struct Socket_named_pipe_server_tag *Named_Pipe_Server_Socket; +struct Socket_named_pipe_server_tag { + const struct socket_function_table *fn; + /* the above variable absolutely *must* be the first in this structure */ + + /* Parameters for (repeated) creation of named pipe objects */ + PSECURITY_DESCRIPTOR psd; + PACL acl; + char *pipename; + + /* The current named pipe object + attempt to connect to it */ + HANDLE pipehandle; + OVERLAPPED connect_ovl; + + /* PuTTY Socket machinery */ + Plug plug; + char *error; +}; + +static Plug sk_namedpipeserver_plug(Socket s, Plug p) +{ + Named_Pipe_Server_Socket ps = (Named_Pipe_Server_Socket) s; + Plug ret = ps->plug; + if (p) + ps->plug = p; + return ret; +} + +static void sk_namedpipeserver_close(Socket s) +{ + Named_Pipe_Server_Socket ps = (Named_Pipe_Server_Socket) s; + + CloseHandle(ps->pipehandle); + CloseHandle(ps->connect_ovl.hEvent); + sfree(ps->error); + sfree(ps->pipename); + if (ps->acl) + LocalFree(ps->acl); + if (ps->psd) + LocalFree(ps->psd); + sfree(ps); +} + +static const char *sk_namedpipeserver_socket_error(Socket s) +{ + Named_Pipe_Server_Socket ps = (Named_Pipe_Server_Socket) s; + return ps->error; +} + +static int create_named_pipe(Named_Pipe_Server_Socket ps, int first_instance) +{ + SECURITY_ATTRIBUTES sa; + + memset(&sa, 0, sizeof(sa)); + sa.nLength = sizeof(sa); + sa.lpSecurityDescriptor = ps->psd; + sa.bInheritHandle = FALSE; + + ps->pipehandle = CreateNamedPipe + (/* lpName */ + ps->pipename, + + /* dwOpenMode */ + PIPE_ACCESS_DUPLEX | + FILE_FLAG_OVERLAPPED | + (first_instance ? FILE_FLAG_FIRST_PIPE_INSTANCE : 0), + + /* dwPipeMode */ + PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT +#ifdef PIPE_REJECT_REMOTE_CLIENTS + | PIPE_REJECT_REMOTE_CLIENTS +#endif + , + + /* nMaxInstances */ + PIPE_UNLIMITED_INSTANCES, + + /* nOutBufferSize, nInBufferSize */ + 4096, 4096, /* FIXME: think harder about buffer sizes? */ + + /* nDefaultTimeOut */ + 0 /* default timeout */, + + /* lpSecurityAttributes */ + &sa); + + return ps->pipehandle != INVALID_HANDLE_VALUE; +} + +static Socket named_pipe_accept(accept_ctx_t ctx, Plug plug) +{ + HANDLE conn = (HANDLE)ctx.p; + + return make_handle_socket(conn, conn, plug, TRUE); +} + +/* + * Dummy SockAddr type which just holds a named pipe address. Only + * used for calling plug_log from named_pipe_accept_loop() here. + */ +SockAddr sk_namedpipe_addr(const char *pipename); + +static void named_pipe_accept_loop(Named_Pipe_Server_Socket ps, + int got_one_already) +{ + while (1) { + int error; + char *errmsg; + + if (got_one_already) { + /* If we were called with a connection already waiting, + * skip this step. */ + got_one_already = FALSE; + error = 0; + } else { + /* + * Call ConnectNamedPipe, which might succeed or might + * tell us that an overlapped operation is in progress and + * we should wait for our event object. + */ + if (ConnectNamedPipe(ps->pipehandle, &ps->connect_ovl)) + error = 0; + else + error = GetLastError(); + + if (error == ERROR_IO_PENDING) + return; + } + + if (error == 0 || error == ERROR_PIPE_CONNECTED) { + /* + * We've successfully retrieved an incoming connection, so + * ps->pipehandle now refers to that connection. So + * convert that handle into a separate connection-type + * Socket, and create a fresh one to be the new listening + * pipe. + */ + HANDLE conn = ps->pipehandle; + accept_ctx_t actx; + + actx.p = (void *)conn; + if (plug_accepting(ps->plug, named_pipe_accept, actx)) { + /* + * If the plug didn't want the connection, might as + * well close this handle. + */ + CloseHandle(conn); + } + + if (!create_named_pipe(ps, FALSE)) { + error = GetLastError(); + } else { + /* + * Go round again to see if more connections can be + * got, or to begin waiting on the event object. + */ + continue; + } + } + + errmsg = dupprintf("Error while listening to named pipe: %s", + win_strerror(error)); + plug_log(ps->plug, 1, sk_namedpipe_addr(ps->pipename), 0, + errmsg, error); + sfree(errmsg); + break; + } +} + +static void named_pipe_connect_callback(void *vps) +{ + Named_Pipe_Server_Socket ps = (Named_Pipe_Server_Socket)vps; + named_pipe_accept_loop(ps, TRUE); +} + +Socket new_named_pipe_listener(const char *pipename, Plug plug) +{ + /* + * This socket type is only used for listening, so it should never + * be asked to write or flush or set_frozen. + */ + static const struct socket_function_table socket_fn_table = { + sk_namedpipeserver_plug, + sk_namedpipeserver_close, + NULL /* write */, + NULL /* write_oob */, + NULL /* write_eof */, + NULL /* flush */, + NULL /* set_frozen */, + sk_namedpipeserver_socket_error + }; + + Named_Pipe_Server_Socket ret; + + ret = snew(struct Socket_named_pipe_server_tag); + ret->fn = &socket_fn_table; + ret->plug = plug; + ret->error = NULL; + ret->psd = NULL; + ret->pipename = dupstr(pipename); + ret->acl = NULL; + + assert(strncmp(pipename, "\\\\.\\pipe\\", 9) == 0); + assert(strchr(pipename + 9, '\\') == NULL); + + if (!make_private_security_descriptor(GENERIC_READ | GENERIC_WRITE, + &ret->psd, &ret->acl, &ret->error)) { + goto cleanup; + } + + if (!create_named_pipe(ret, TRUE)) { + ret->error = dupprintf("unable to create named pipe '%s': %s", + pipename, win_strerror(GetLastError())); + goto cleanup; + } + + memset(&ret->connect_ovl, 0, sizeof(ret->connect_ovl)); + ret->connect_ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + handle_add_foreign_event(ret->connect_ovl.hEvent, + named_pipe_connect_callback, ret); + named_pipe_accept_loop(ret, FALSE); + + cleanup: + return (Socket) ret; +} + +#endif /* !defined NO_SECURITY */ |