mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-09 09:27:59 +00:00
b4c8fd9d86
This is a new vtable-based abstraction which is passed to a backend in place of Frontend, and it implements only the subset of the Frontend functions needed by a backend. (Many other Frontend functions still exist, notably the wide range of things called by terminal.c providing platform-independent operations on the GUI terminal window.) The purpose of making it a vtable is that this opens up the possibility of creating a backend as an internal implementation detail of some other activity, by providing just that one backend with a custom Seat that implements the methods differently. For example, this refactoring should make it feasible to directly implement an SSH proxy type, aka the 'jump host' feature supported by OpenSSH, aka 'open a secondary SSH session in MAINCHAN_DIRECT_TCP mode, and then expose the main channel of that as the Socket for the primary connection'. (Which of course you can already do by spawning 'plink -nc' as a separate proxy process, but this would permit it in the _same_ process without anything getting confused.) I've centralised a full set of stub methods in misc.c for the new abstraction, which allows me to get rid of several annoying stubs in the previous code. Also, while I'm here, I've moved a lot of duplicated modalfatalbox() type functions from application main program files into wincons.c / uxcons.c, which I think saves duplication overall. (A minor visible effect is that the prefixes on those console-based fatal error messages will now be more consistent between applications.)
115 lines
3.4 KiB
C
115 lines
3.4 KiB
C
/*
|
|
* be_misc.c: helper functions shared between main network backends.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
|
|
#include "putty.h"
|
|
#include "network.h"
|
|
|
|
void backend_socket_log(Seat *seat, LogContext *logctx,
|
|
int type, SockAddr *addr, int port,
|
|
const char *error_msg, int error_code, Conf *conf,
|
|
int session_started)
|
|
{
|
|
char addrbuf[256], *msg;
|
|
|
|
switch (type) {
|
|
case 0:
|
|
sk_getaddr(addr, addrbuf, lenof(addrbuf));
|
|
if (sk_addr_needs_port(addr)) {
|
|
msg = dupprintf("Connecting to %s port %d", addrbuf, port);
|
|
} else {
|
|
msg = dupprintf("Connecting to %s", addrbuf);
|
|
}
|
|
break;
|
|
case 1:
|
|
sk_getaddr(addr, addrbuf, lenof(addrbuf));
|
|
msg = dupprintf("Failed to connect to %s: %s", addrbuf, error_msg);
|
|
break;
|
|
case 2:
|
|
/* Proxy-related log messages have their own identifying
|
|
* prefix already, put on by our caller. */
|
|
{
|
|
int len, log_to_term;
|
|
|
|
/* Suffix \r\n temporarily, so we can log to the terminal. */
|
|
msg = dupprintf("%s\r\n", error_msg);
|
|
len = strlen(msg);
|
|
assert(len >= 2);
|
|
|
|
log_to_term = conf_get_int(conf, CONF_proxy_log_to_term);
|
|
if (log_to_term == AUTO)
|
|
log_to_term = session_started ? FORCE_OFF : FORCE_ON;
|
|
if (log_to_term == FORCE_ON)
|
|
seat_stderr(seat, msg, len);
|
|
|
|
msg[len-2] = '\0'; /* remove the \r\n again */
|
|
}
|
|
break;
|
|
default:
|
|
msg = NULL; /* shouldn't happen, but placate optimiser */
|
|
break;
|
|
}
|
|
|
|
if (msg) {
|
|
logevent(logctx, msg);
|
|
sfree(msg);
|
|
}
|
|
}
|
|
|
|
void log_proxy_stderr(Plug *plug, bufchain *buf, const void *vdata, int len)
|
|
{
|
|
const char *data = (const char *)vdata;
|
|
int pos = 0;
|
|
int msglen;
|
|
const char *nlpos;
|
|
char *msg, *fullmsg;
|
|
|
|
/*
|
|
* This helper function allows us to collect the data written to a
|
|
* local proxy command's standard error in whatever size chunks we
|
|
* happen to get from its pipe, and whenever we have a complete
|
|
* line, we pass it to plug_log.
|
|
*
|
|
* Prerequisites: a plug to log to, and a bufchain stored
|
|
* somewhere to collect the data in.
|
|
*/
|
|
|
|
while (pos < len && (nlpos = memchr(data+pos, '\n', len-pos)) != NULL) {
|
|
/*
|
|
* Found a newline in the current input buffer. Append it to
|
|
* the bufchain (which may contain a partial line from last
|
|
* time).
|
|
*/
|
|
bufchain_add(buf, data + pos, nlpos - (data + pos));
|
|
|
|
/*
|
|
* Collect the resulting line of data and pass it to plug_log.
|
|
*/
|
|
msglen = bufchain_size(buf);
|
|
msg = snewn(msglen+1, char);
|
|
bufchain_fetch(buf, msg, msglen);
|
|
bufchain_consume(buf, msglen);
|
|
while (msglen > 0 && (msg[msglen-1] == '\n' || msg[msglen-1] == '\r'))
|
|
msglen--;
|
|
msg[msglen] = '\0';
|
|
fullmsg = dupprintf("proxy: %s", msg);
|
|
plug_log(plug, 2, NULL, 0, fullmsg, 0);
|
|
sfree(fullmsg);
|
|
sfree(msg);
|
|
|
|
/*
|
|
* Advance past the newline.
|
|
*/
|
|
pos += nlpos+1 - (data + pos);
|
|
}
|
|
|
|
/*
|
|
* Now any remaining data is a partial line, which we save for
|
|
* next time.
|
|
*/
|
|
bufchain_add(buf, data + pos, len - pos);
|
|
}
|