nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-10 09:58:01 +00:00
Code Issues Projects Releases Wiki Activity
650404f32c
putty-source/unix/uxproxy.c

103 lines
2.5 KiB
C
Raw Normal View History

Support, on Unix only (so far), for OpenSSH-style generic proxying (running a local command in a pair of pipes and proxying through that, for example `ssh proxyhost nc -q0 %host %port'). [originally from svn r3164]
2003-05-06 19:52:31 +00:00
/*
* uxproxy.c: Unix implementation of platform_new_connection(),
* supporting an OpenSSH-like proxy command.
*/
#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include "tree234.h"
#include "putty.h"
#include "network.h"
#include "proxy.h"
Get rid of lots of implicit pointer types. All the main backend structures - Ssh, Telnet, Pty, Serial etc - now describe structure types themselves rather than pointers to them. The same goes for the codebase-wide trait types Socket and Plug, and the supporting types SockAddr and Pinger. All those things that were typedefed as pointers are older types; the newer ones have the explicit * at the point of use, because that's what I now seem to be preferring. But whichever one of those is better, inconsistently using a mixture of the two styles is worse, so let's make everything consistent. A few types are still implicitly pointers, such as Bignum and some of the GSSAPI types; generally this is either because they have to be void *, or because they're typedefed differently on different platforms and aren't always pointers at all. Can't be helped. But I've got rid of the main ones, at least.
2018-10-04 18:10:23 +00:00
Socket *platform_new_connection(SockAddr *addr, const char *hostname,
int port, int privport,
int oobinline, int nodelay, int keepalive,
Plug *plug, Conf *conf)
Support, on Unix only (so far), for OpenSSH-style generic proxying (running a local command in a pair of pipes and proxying through that, for example `ssh proxyhost nc -q0 %host %port'). [originally from svn r3164]
2003-05-06 19:52:31 +00:00
{
char *cmd;
In GUI PuTTY, log standard error from local proxy commands. On both Unix and Windows, we now redirect the local proxy command's standard error into a third pipe; data received from that pipe is broken up at newlines and logged in the Event Log. So if the proxy command emits any error messages in the course of failing to connect to something, you now have a fighting chance of finding out what went wrong. This feature is disabled in command-line tools like PSFTP and Plink, on the basis that in that situation it seems more likely that the user would expect standard-error output to go to the ordinary standard error in the ordinary way. Only GUI PuTTY catches it and logs it like this, because it either doesn't have a standard error at all (on Windows) or is likely to be pointing it at some completely unhelpful session log file (under X).
2015-11-22 11:50:37 +00:00
int to_cmd_pipe[2], from_cmd_pipe[2], cmd_err_pipe[2], pid, proxytype;
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
int infd, outfd, inerrfd;
Support, on Unix only (so far), for OpenSSH-style generic proxying (running a local command in a pair of pipes and proxying through that, for example `ssh proxyhost nc -q0 %host %port'). [originally from svn r3164]
2003-05-06 19:52:31 +00:00
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
proxytype = conf_get_int(conf, CONF_proxy_type);
if (proxytype != PROXY_CMD && proxytype != PROXY_FUZZ)
Support, on Unix only (so far), for OpenSSH-style generic proxying (running a local command in a pair of pipes and proxying through that, for example `ssh proxyhost nc -q0 %host %port'). [originally from svn r3164]
2003-05-06 19:52:31 +00:00
return NULL;
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
if (proxytype == PROXY_CMD) {
cmd = format_telnet_command(addr, port, conf);
Log the setup of proxied network connections. I've defined a new value for the 'int type' parameter passed to plug_log(), which proxy sockets will use to pass their backend information on how the setup of their proxied connections are going. I've implemented support for the new type code in all _nontrivial_ plug log functions (which, conveniently, are precisely the ones I just refactored into backend_socket_log); the ones which just throw all their log data away anyway will do that to the new code as well. We use the new type code to log the DNS lookup and connection setup for connecting to a networked proxy, and also to log the exact command string sent down Telnet proxy connections (so the user can easily debug mistakes in the configured format string) and the exact command executed when spawning a local proxy process. (The latter was already supported on Windows by a bodgy logging call taking advantage of Windows in particular having no front end pointer; I've converted that into a sensible use of the new plug_log facility, and done the same thing on Unix.)
2015-11-22 12:15:52 +00:00
{
char *logmsg = dupprintf("Starting local proxy command: %s", cmd);
plug_log(plug, 2, NULL, 0, logmsg, 0);
sfree(logmsg);
}
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
/*
* Create the pipes to the proxy command, and spawn the proxy
* command process.
*/
if (pipe(to_cmd_pipe) < 0 ||
In GUI PuTTY, log standard error from local proxy commands. On both Unix and Windows, we now redirect the local proxy command's standard error into a third pipe; data received from that pipe is broken up at newlines and logged in the Event Log. So if the proxy command emits any error messages in the course of failing to connect to something, you now have a fighting chance of finding out what went wrong. This feature is disabled in command-line tools like PSFTP and Plink, on the basis that in that situation it seems more likely that the user would expect standard-error output to go to the ordinary standard error in the ordinary way. Only GUI PuTTY catches it and logs it like this, because it either doesn't have a standard error at all (on Windows) or is likely to be pointing it at some completely unhelpful session log file (under X).
2015-11-22 11:50:37 +00:00
pipe(from_cmd_pipe) < 0 ||
Remove FLAG_STDERR completely. Originally, it controlled whether ssh.c should send terminal messages (such as login and password prompts) to terminal.c or to stderr. But we've had the from_backend() abstraction for ages now, which even has an existing flag to indicate that the data is stderr rather than stdout data; applications which set FLAG_STDERR are precisely those that link against uxcons or wincons, so from_backend will do the expected thing anyway with data sent to it with that flag set. So there's no reason ssh.c can't just unconditionally pass everything through that, and remove the special case. FLAG_STDERR was also used by winproxy and uxproxy to decide whether to capture standard error from a local proxy command, or whether to let the proxy command send its diagnostics directly to the usual standard error. On reflection, I think it's better to unconditionally capture the proxy's stderr, for three reasons. Firstly, it means proxy diagnostics are prefixed with 'proxy:' so that you can tell them apart from any other stderr spew (which used to be particularly confusing if both the main application and the proxy command were instances of Plink); secondly, proxy diagnostics are now reliably copied to packet log files along with all the other Event Log entries, even by command-line tools; and thirdly, this means the option to suppress proxy command diagnostics after the main session starts will actually _work_ in the command-line tools, which it previously couldn't. A more minor structure change is that copying of Event Log messages to stderr in verbose mode is now done by wincons/uxcons, instead of centrally in logging.c (since logging.c can now no longer check FLAG_STDERR to decide whether to do it). The total amount of code to do this is considerably smaller than the defensive-sounding comment in logevent.c explaining why I did it the other way instead :-)
2018-09-21 15:15:49 +00:00
pipe(cmd_err_pipe) < 0) {
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
sfree(cmd);
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
return new_error_socket_fmt(plug, "pipe: %s", strerror(errno));
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
}
cloexec(to_cmd_pipe[1]);
cloexec(from_cmd_pipe[0]);
Remove FLAG_STDERR completely. Originally, it controlled whether ssh.c should send terminal messages (such as login and password prompts) to terminal.c or to stderr. But we've had the from_backend() abstraction for ages now, which even has an existing flag to indicate that the data is stderr rather than stdout data; applications which set FLAG_STDERR are precisely those that link against uxcons or wincons, so from_backend will do the expected thing anyway with data sent to it with that flag set. So there's no reason ssh.c can't just unconditionally pass everything through that, and remove the special case. FLAG_STDERR was also used by winproxy and uxproxy to decide whether to capture standard error from a local proxy command, or whether to let the proxy command send its diagnostics directly to the usual standard error. On reflection, I think it's better to unconditionally capture the proxy's stderr, for three reasons. Firstly, it means proxy diagnostics are prefixed with 'proxy:' so that you can tell them apart from any other stderr spew (which used to be particularly confusing if both the main application and the proxy command were instances of Plink); secondly, proxy diagnostics are now reliably copied to packet log files along with all the other Event Log entries, even by command-line tools; and thirdly, this means the option to suppress proxy command diagnostics after the main session starts will actually _work_ in the command-line tools, which it previously couldn't. A more minor structure change is that copying of Event Log messages to stderr in verbose mode is now done by wincons/uxcons, instead of centrally in logging.c (since logging.c can now no longer check FLAG_STDERR to decide whether to do it). The total amount of code to do this is considerably smaller than the defensive-sounding comment in logevent.c explaining why I did it the other way instead :-)
2018-09-21 15:15:49 +00:00
cloexec(cmd_err_pipe[0]);
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
pid = fork();
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
if (pid == 0) {
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
close(0);
close(1);
dup2(to_cmd_pipe[0], 0);
dup2(from_cmd_pipe[1], 1);
close(to_cmd_pipe[0]);
close(from_cmd_pipe[1]);
Remove FLAG_STDERR completely. Originally, it controlled whether ssh.c should send terminal messages (such as login and password prompts) to terminal.c or to stderr. But we've had the from_backend() abstraction for ages now, which even has an existing flag to indicate that the data is stderr rather than stdout data; applications which set FLAG_STDERR are precisely those that link against uxcons or wincons, so from_backend will do the expected thing anyway with data sent to it with that flag set. So there's no reason ssh.c can't just unconditionally pass everything through that, and remove the special case. FLAG_STDERR was also used by winproxy and uxproxy to decide whether to capture standard error from a local proxy command, or whether to let the proxy command send its diagnostics directly to the usual standard error. On reflection, I think it's better to unconditionally capture the proxy's stderr, for three reasons. Firstly, it means proxy diagnostics are prefixed with 'proxy:' so that you can tell them apart from any other stderr spew (which used to be particularly confusing if both the main application and the proxy command were instances of Plink); secondly, proxy diagnostics are now reliably copied to packet log files along with all the other Event Log entries, even by command-line tools; and thirdly, this means the option to suppress proxy command diagnostics after the main session starts will actually _work_ in the command-line tools, which it previously couldn't. A more minor structure change is that copying of Event Log messages to stderr in verbose mode is now done by wincons/uxcons, instead of centrally in logging.c (since logging.c can now no longer check FLAG_STDERR to decide whether to do it). The total amount of code to do this is considerably smaller than the defensive-sounding comment in logevent.c explaining why I did it the other way instead :-)
2018-09-21 15:15:49 +00:00
dup2(cmd_err_pipe[1], 2);
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
noncloexec(0);
noncloexec(1);
execl("/bin/sh", "sh", "-c", cmd, (void *)NULL);
_exit(255);
}
Support, on Unix only (so far), for OpenSSH-style generic proxying (running a local command in a pair of pipes and proxying through that, for example `ssh proxyhost nc -q0 %host %port'). [originally from svn r3164]
2003-05-06 19:52:31 +00:00
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
sfree(cmd);
Corey Stup points out a memory leak in the local-proxy implementations. [originally from svn r8626]
2009-08-21 21:16:22 +00:00
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
if (pid < 0)
return new_error_socket_fmt(plug, "fork: %s", strerror(errno));
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
close(to_cmd_pipe[0]);
close(from_cmd_pipe[1]);
Remove FLAG_STDERR completely. Originally, it controlled whether ssh.c should send terminal messages (such as login and password prompts) to terminal.c or to stderr. But we've had the from_backend() abstraction for ages now, which even has an existing flag to indicate that the data is stderr rather than stdout data; applications which set FLAG_STDERR are precisely those that link against uxcons or wincons, so from_backend will do the expected thing anyway with data sent to it with that flag set. So there's no reason ssh.c can't just unconditionally pass everything through that, and remove the special case. FLAG_STDERR was also used by winproxy and uxproxy to decide whether to capture standard error from a local proxy command, or whether to let the proxy command send its diagnostics directly to the usual standard error. On reflection, I think it's better to unconditionally capture the proxy's stderr, for three reasons. Firstly, it means proxy diagnostics are prefixed with 'proxy:' so that you can tell them apart from any other stderr spew (which used to be particularly confusing if both the main application and the proxy command were instances of Plink); secondly, proxy diagnostics are now reliably copied to packet log files along with all the other Event Log entries, even by command-line tools; and thirdly, this means the option to suppress proxy command diagnostics after the main session starts will actually _work_ in the command-line tools, which it previously couldn't. A more minor structure change is that copying of Event Log messages to stderr in verbose mode is now done by wincons/uxcons, instead of centrally in logging.c (since logging.c can now no longer check FLAG_STDERR to decide whether to do it). The total amount of code to do this is considerably smaller than the defensive-sounding comment in logevent.c explaining why I did it the other way instead :-)
2018-09-21 15:15:49 +00:00
close(cmd_err_pipe[1]);
Support, on Unix only (so far), for OpenSSH-style generic proxying (running a local command in a pair of pipes and proxying through that, for example `ssh proxyhost nc -q0 %host %port'). [originally from svn r3164]
2003-05-06 19:52:31 +00:00
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
outfd = to_cmd_pipe[1];
infd = from_cmd_pipe[0];
inerrfd = cmd_err_pipe[0];
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
} else {
cmd = format_telnet_command(addr, port, conf);
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
outfd = open("/dev/null", O_WRONLY);
if (outfd == -1) {
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
sfree(cmd);
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
return new_error_socket_fmt(
plug, "/dev/null: %s", strerror(errno));
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
}
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
infd = open(cmd, O_RDONLY);
if (infd == -1) {
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
sfree(cmd);
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
return new_error_socket_fmt(plug, "%s: %s", cmd, strerror(errno));
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
}
sfree(cmd);
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
inerrfd = -1;
Add an explicit PROXY_FUZZ that just feeds a file into the backend. This saves the need to fork and exec "cat", which should speed things up. It also ensures that the network output goes to /dev/null, which should avoid problems with blocking when writing to a full pipe.
2015-10-17 13:06:06 +00:00
}
Support, on Unix only (so far), for OpenSSH-style generic proxying (running a local command in a pair of pipes and proxying through that, for example `ssh proxyhost nc -q0 %host %port'). [originally from svn r3164]
2003-05-06 19:52:31 +00:00
Control of 'addr' is now handed over to {platform_,}new_connection() and sk_new() on invocation; these functions become responsible for (eventually) freeing it. The caller must not do anything with 'addr' after it's been passed in. (Ick.) Why: A SOCKS5 crash appears to have been caused by overzealous freeing of a SockAddr (ssh.c:1.257 [r2492]), which for proxied connections is squirreled away long-term (and this can't easily be avoided). It would have been nice to make a copy of the SockAddr, in case the caller has a use for it, but one of the implementations (uxnet.c) hides a "struct addrinfo" in there, and we have no defined way to duplicate those. (None of the current callers _do_ have a further use for the SockAddr.) As far as I can tell, everything _except_ proxying only needs addr for the duration of the call, so sk_addr_free()s immediately. If I'm mistaken, it should at least be easier to find the offending free()... [originally from svn r3383] [r2492 == bdd6633970d9c53ce0ad97b460c8c684285bb15e]
2003-08-07 16:04:33 +00:00
/* We are responsible for this and don't need it any more */
sk_addr_free(addr);
Unix: turn LocalProxySocket into a general FdSocket. The new FdSocket just takes an arbitrary pair of file descriptors to read and write, optionally with an extra input fd providing the standard error output from a command. uxproxy.c now just does the forking and pipe setup, and once it's got all its fds, it hands off to FdSocket to actually do the reading and writing. This is very like the reorganisation I did on the Windows side in commit 98a6a3553 (back in 2013, in preparation for named-pipe sockets and connection sharing). The idea is that it should enable me to make a thing that the PuTTY code base sees as a Socket, but which actually connects to the standard I/O handles of the process it lives in.
2018-10-07 13:55:32 +00:00
return make_fd_socket(infd, outfd, inerrfd, plug);
Support, on Unix only (so far), for OpenSSH-style generic proxying (running a local command in a pair of pipes and proxying through that, for example `ssh proxyhost nc -q0 %host %port'). [originally from svn r3164]
2003-05-06 19:52:31 +00:00
}
Reference in New Issue Copy Permalink