From c1d9da67a261e3898a5922462c3fda09beffe127 Mon Sep 17 00:00:00 2001
From: Simon Tatham <anakin@pobox.com>
Date: Wed, 26 Jun 2024 08:29:39 +0100
Subject: [PATCH] Pass the calling Socket to plug_log.

This enables plug_log to run query methods on the socket in order to
find out useful information to log. I don't expect it's sensible to do
anything else with it.
---
 network.h                   | 15 ++++++++-------
 otherbackends/raw.c         |  9 +++++----
 otherbackends/rlogin.c      |  6 +++---
 otherbackends/supdup.c      |  6 +++---
 otherbackends/telnet.c      |  6 +++---
 proxy/local.c               |  3 ++-
 proxy/proxy.c               | 15 ++++++++-------
 proxy/sshproxy.c            | 13 +++++++------
 proxy/telnet.c              |  3 ++-
 psocks.c                    | 10 ++++++----
 ssh/portfwd.c               |  6 ++++--
 ssh/server.c                |  5 +++--
 ssh/sesschan.c              |  4 ++--
 ssh/ssh.c                   |  7 ++++---
 ssh/userauth2-client.c      |  5 +++--
 ssh/x11fwd.c                |  4 ++--
 stubs/null-plug.c           |  2 +-
 unix/fd-socket.c            |  6 +++---
 unix/network.c              | 10 +++++-----
 unix/pageant.c              |  4 ++--
 unix/psusan.c               |  4 ++--
 unix/uppity.c               |  4 ++--
 utils/backend_socket_log.c  |  2 +-
 utils/log_proxy_stderr.c    |  6 +++---
 windows/handle-socket.c     |  5 +++--
 windows/named-pipe-server.c |  2 +-
 windows/network.c           | 12 ++++++------
 27 files changed, 94 insertions(+), 80 deletions(-)

diff --git a/network.h b/network.h
index 28aa2eea..ac0a63d0 100644
--- a/network.h
+++ b/network.h
@@ -91,7 +91,7 @@ struct PlugVtable {
      * all Plugs must implement this method, even if only to ignore
      * the logged events.
      */
-    void (*log)(Plug *p, PlugLogType type, SockAddr *addr, int port,
+    void (*log)(Plug *p, Socket *s, PlugLogType type, SockAddr *addr, int port,
                 const char *error_msg, int error_code);
 
     /*
@@ -245,8 +245,9 @@ static inline void sk_write_eof(Socket *s)
 { s->vt->write_eof(s); }
 
 static inline void plug_log(
-    Plug *p, int type, SockAddr *addr, int port, const char *msg, int code)
-{ p->vt->log(p, type, addr, port, msg, code); }
+    Plug *p, Socket *s, int type, SockAddr *addr, int port,
+    const char *msg, int code)
+{ p->vt->log(p, s, type, addr, port, msg, code); }
 static inline void plug_closing(Plug *p, PlugCloseType type, const char *msg)
 { p->vt->closing(p, type, msg); }
 static inline void plug_closing_normal(Plug *p)
@@ -379,7 +380,7 @@ extern Plug *const nullplug;
  * In particular, nullplug_log is useful to Plugs that don't need to
  * worry about logging.
  */
-void nullplug_log(Plug *plug, PlugLogType type, SockAddr *addr,
+void nullplug_log(Plug *plug, Socket *s, PlugLogType type, SockAddr *addr,
                   int port, const char *err_msg, int err_code);
 void nullplug_closing(Plug *plug, PlugCloseType type, const char *error_msg);
 void nullplug_receive(Plug *plug, int urgent, const char *data, size_t len);
@@ -391,7 +392,7 @@ void nullplug_sent(Plug *plug, size_t bufsize);
  * they use types defined here.
  */
 
-void backend_socket_log(Seat *seat, LogContext *logctx,
+void backend_socket_log(Seat *seat, LogContext *logctx, Socket *sock,
                         PlugLogType type, SockAddr *addr, int port,
                         const char *error_msg, int error_code, Conf *conf,
                         bool session_started);
@@ -403,8 +404,8 @@ typedef struct ProxyStderrBuf {
 } ProxyStderrBuf;
 void psb_init(ProxyStderrBuf *psb);
 void psb_set_prefix(ProxyStderrBuf *psb, const char *prefix);
-void log_proxy_stderr(
-    Plug *plug, ProxyStderrBuf *psb, const void *vdata, size_t len);
+void log_proxy_stderr(Plug *plug, Socket *sock, ProxyStderrBuf *psb,
+                      const void *vdata, size_t len);
 
 /* ----------------------------------------------------------------------
  * The DeferredSocketOpener trait. This is a thing that some Socket
diff --git a/otherbackends/raw.c b/otherbackends/raw.c
index 7f35d206..9fc5e4c8 100644
--- a/otherbackends/raw.c
+++ b/otherbackends/raw.c
@@ -36,12 +36,13 @@ static void c_write(Raw *raw, const void *buf, size_t len)
     sk_set_frozen(raw->s, backlog > RAW_MAX_BACKLOG);
 }
 
-static void raw_log(Plug *plug, PlugLogType type, SockAddr *addr, int port,
-                    const char *error_msg, int error_code)
+static void raw_log(Plug *plug, Socket *s, PlugLogType type, SockAddr *addr,
+                    int port, const char *error_msg, int error_code)
 {
     Raw *raw = container_of(plug, Raw, plug);
-    backend_socket_log(raw->seat, raw->logctx, type, addr, port, error_msg,
-                       error_code, raw->conf, raw->socket_connected);
+    backend_socket_log(raw->seat, raw->logctx, s, type, addr, port,
+                       error_msg, error_code, raw->conf,
+                       raw->socket_connected);
     if (type == PLUGLOG_CONNECT_SUCCESS) {
         raw->socket_connected = true;
         if (raw->ldisc)
diff --git a/otherbackends/rlogin.c b/otherbackends/rlogin.c
index 37087257..6efe036f 100644
--- a/otherbackends/rlogin.c
+++ b/otherbackends/rlogin.c
@@ -45,11 +45,11 @@ static void c_write(Rlogin *rlogin, const void *buf, size_t len)
     sk_set_frozen(rlogin->s, backlog > RLOGIN_MAX_BACKLOG);
 }
 
-static void rlogin_log(Plug *plug, PlugLogType type, SockAddr *addr, int port,
-                       const char *error_msg, int error_code)
+static void rlogin_log(Plug *plug, Socket *s, PlugLogType type, SockAddr *addr,
+                       int port, const char *error_msg, int error_code)
 {
     Rlogin *rlogin = container_of(plug, Rlogin, plug);
-    backend_socket_log(rlogin->seat, rlogin->logctx, type, addr, port,
+    backend_socket_log(rlogin->seat, rlogin->logctx, s, type, addr, port,
                        error_msg, error_code,
                        rlogin->conf, rlogin->socket_connected);
     if (type == PLUGLOG_CONNECT_SUCCESS) {
diff --git a/otherbackends/supdup.c b/otherbackends/supdup.c
index 9aaf1d4f..6f574c9f 100644
--- a/otherbackends/supdup.c
+++ b/otherbackends/supdup.c
@@ -559,11 +559,11 @@ static void do_supdup_read(Supdup *supdup, const char *buf, size_t len)
     strbuf_free(outbuf);
 }
 
-static void supdup_log(Plug *plug, PlugLogType type, SockAddr *addr, int port,
-                       const char *error_msg, int error_code)
+static void supdup_log(Plug *plug, Socket *s, PlugLogType type, SockAddr *addr,
+                       int port, const char *error_msg, int error_code)
 {
     Supdup *supdup = container_of(plug, Supdup, plug);
-    backend_socket_log(supdup->seat, supdup->logctx, type, addr, port,
+    backend_socket_log(supdup->seat, supdup->logctx, s, type, addr, port,
                        error_msg, error_code,
                        supdup->conf, supdup->socket_connected);
     if (type == PLUGLOG_CONNECT_SUCCESS) {
diff --git a/otherbackends/telnet.c b/otherbackends/telnet.c
index f43520a3..2f12722c 100644
--- a/otherbackends/telnet.c
+++ b/otherbackends/telnet.c
@@ -604,11 +604,11 @@ static void do_telnet_read(Telnet *telnet, const char *buf, size_t len)
     strbuf_free(outbuf);
 }
 
-static void telnet_log(Plug *plug, PlugLogType type, SockAddr *addr, int port,
-                       const char *error_msg, int error_code)
+static void telnet_log(Plug *plug, Socket *s, PlugLogType type, SockAddr *addr,
+                       int port, const char *error_msg, int error_code)
 {
     Telnet *telnet = container_of(plug, Telnet, plug);
-    backend_socket_log(telnet->seat, telnet->logctx, type, addr, port,
+    backend_socket_log(telnet->seat, telnet->logctx, s, type, addr, port,
                        error_msg, error_code, telnet->conf,
                        telnet->socket_connected);
     if (type == PLUGLOG_CONNECT_SUCCESS) {
diff --git a/proxy/local.c b/proxy/local.c
index 3b2d130c..ff504cce 100644
--- a/proxy/local.c
+++ b/proxy/local.c
@@ -209,7 +209,8 @@ static void local_proxy_opener_coroutine(void *vctx)
         put_datapl(logmsg, PTRLEN_LITERAL("Starting local proxy command: "));
         put_c_string_literal(logmsg, ptrlen_from_asciz(censored_cmd));
 
-        plug_log(lp->plug, PLUGLOG_PROXY_MSG, NULL, 0, logmsg->s, 0);
+        plug_log(lp->plug, lp->socket, PLUGLOG_PROXY_MSG, NULL, 0,
+                 logmsg->s, 0);
         strbuf_free(logmsg);
         sfree(censored_cmd);
     }
diff --git a/proxy/proxy.c b/proxy/proxy.c
index ab5b9a71..b7428816 100644
--- a/proxy/proxy.c
+++ b/proxy/proxy.c
@@ -41,7 +41,7 @@ static void proxy_activate(ProxySocket *ps)
 
     proxy_negotiator_cleanup(ps);
 
-    plug_log(ps->plug, PLUGLOG_CONNECT_SUCCESS, NULL, 0, NULL, 0);
+    plug_log(ps->plug, &ps->sock, PLUGLOG_CONNECT_SUCCESS, NULL, 0, NULL, 0);
 
     /* we want to ignore new receive events until we have sent
      * all of our buffered receive data.
@@ -189,12 +189,13 @@ static const char *sk_proxy_socket_error (Socket *s)
 
 /* basic proxy plug functions */
 
-static void plug_proxy_log(Plug *plug, PlugLogType type, SockAddr *addr,
-                           int port, const char *error_msg, int error_code)
+static void plug_proxy_log(Plug *plug, Socket *s, PlugLogType type,
+                           SockAddr *addr, int port,
+                           const char *error_msg, int error_code)
 {
     ProxySocket *ps = container_of(plug, ProxySocket, plugimpl);
 
-    plug_log(ps->plug, type, addr, port, error_msg, error_code);
+    plug_log(ps->plug, &ps->sock, type, addr, port, error_msg, error_code);
 }
 
 static void plug_proxy_closing(Plug *p, PlugCloseType type,
@@ -597,7 +598,7 @@ Socket *new_connection(SockAddr *addr, const char *hostname,
                                      conf_get_str(conf, CONF_proxy_host),
                                      conf_get_int(conf, CONF_proxy_port),
                                      hostname, port);
-            plug_log(plug, PLUGLOG_PROXY_MSG, NULL, 0, logmsg, 0);
+            plug_log(plug, &ps->sock, PLUGLOG_PROXY_MSG, NULL, 0, logmsg, 0);
             sfree(logmsg);
         }
 
@@ -605,7 +606,7 @@ Socket *new_connection(SockAddr *addr, const char *hostname,
             char *logmsg = dns_log_msg(conf_get_str(conf, CONF_proxy_host),
                                        conf_get_int(conf, CONF_addressfamily),
                                        "proxy");
-            plug_log(plug, PLUGLOG_PROXY_MSG, NULL, 0, logmsg, 0);
+            plug_log(plug, &ps->sock, PLUGLOG_PROXY_MSG, NULL, 0, logmsg, 0);
             sfree(logmsg);
         }
 
@@ -626,7 +627,7 @@ Socket *new_connection(SockAddr *addr, const char *hostname,
             logmsg = dupprintf("Connecting to %s proxy at %s port %d",
                                vt->type, addrbuf,
                                conf_get_int(conf, CONF_proxy_port));
-            plug_log(plug, PLUGLOG_PROXY_MSG, NULL, 0, logmsg, 0);
+            plug_log(plug, &ps->sock, PLUGLOG_PROXY_MSG, NULL, 0, logmsg, 0);
             sfree(logmsg);
         }
 
diff --git a/proxy/sshproxy.c b/proxy/sshproxy.c
index c04599af..ce422dd5 100644
--- a/proxy/sshproxy.c
+++ b/proxy/sshproxy.c
@@ -142,8 +142,8 @@ static const SocketVtable SshProxy_sock_vt = {
 static void sshproxy_eventlog(LogPolicy *lp, const char *event)
 {
     SshProxy *sp = container_of(lp, SshProxy, logpolicy);
-    log_proxy_stderr(sp->plug, &sp->psb, event, strlen(event));
-    log_proxy_stderr(sp->plug, &sp->psb, "\n", 1);
+    log_proxy_stderr(sp->plug, &sp->sock, &sp->psb, event, strlen(event));
+    log_proxy_stderr(sp->plug, &sp->sock, &sp->psb, "\n", 1);
 }
 
 static int sshproxy_askappend(LogPolicy *lp, Filename *filename,
@@ -248,7 +248,8 @@ static void sshproxy_notify_session_started(Seat *seat)
         interactor_return_seat(sp->clientitr);
     sp->conn_established = true;
 
-    plug_log(sp->plug, PLUGLOG_CONNECT_SUCCESS, sp->addr, sp->port, NULL, 0);
+    plug_log(sp->plug, &sp->sock, PLUGLOG_CONNECT_SUCCESS, sp->addr, sp->port,
+             NULL, 0);
 }
 
 static size_t sshproxy_output(Seat *seat, SeatOutputType type,
@@ -261,7 +262,7 @@ static size_t sshproxy_output(Seat *seat, SeatOutputType type,
         try_send_ssh_to_socket(sp);
         break;
       case SEAT_OUTPUT_STDERR:
-        log_proxy_stderr(sp->plug, &sp->psb, data, len);
+        log_proxy_stderr(sp->plug, &sp->sock, &sp->psb, data, len);
         break;
     }
     return bufchain_size(&sp->ssh_to_socket);
@@ -322,8 +323,8 @@ static void sshproxy_send_close(SshProxy *sp)
         interactor_return_seat(sp->clientitr);
 
     if (!sp->conn_established)
-        plug_log(sp->plug, PLUGLOG_CONNECT_FAILED, sp->addr, sp->port,
-                 sp->errmsg, 0);
+        plug_log(sp->plug, &sp->sock, PLUGLOG_CONNECT_FAILED, sp->addr,
+                 sp->port, sp->errmsg, 0);
 
     if (sp->errmsg)
         plug_closing_error(sp->plug, sp->errmsg);
diff --git a/proxy/telnet.c b/proxy/telnet.c
index a2efb7b4..41cdf8d7 100644
--- a/proxy/telnet.c
+++ b/proxy/telnet.c
@@ -339,7 +339,8 @@ static void proxy_telnet_process_queue(ProxyNegotiator *pn)
         put_datapl(logmsg, PTRLEN_LITERAL("Sending Telnet proxy command: "));
         put_c_string_literal(logmsg, ptrlen_from_asciz(censored_cmd));
 
-        plug_log(pn->ps->plug, PLUGLOG_PROXY_MSG, NULL, 0, logmsg->s, 0);
+        plug_log(pn->ps->plug, &pn->ps->sock, PLUGLOG_PROXY_MSG, NULL, 0,
+                 logmsg->s, 0);
         strbuf_free(logmsg);
         sfree(censored_cmd);
     }
diff --git a/psocks.c b/psocks.c
index 5054a674..e15ef9d7 100644
--- a/psocks.c
+++ b/psocks.c
@@ -93,8 +93,9 @@ static const SshChannelVtable psocks_scvt = {
     /* all the rest are NULL */
 };
 
-static void psocks_plug_log(Plug *p, PlugLogType type, SockAddr *addr,
-                            int port, const char *error_msg, int error_code);
+static void psocks_plug_log(Plug *p, Socket *s, PlugLogType type,
+                            SockAddr *addr, int port,
+                            const char *error_msg, int error_code);
 static void psocks_plug_closing(Plug *p, PlugCloseType, const char *error_msg);
 static void psocks_plug_receive(Plug *p, int urgent,
                                 const char *data, size_t len);
@@ -320,8 +321,9 @@ static void psocks_sc_unthrottle(SshChannel *sc, size_t bufsize)
 	sk_set_frozen(conn->socket, false);
 }
 
-static void psocks_plug_log(Plug *plug, PlugLogType type, SockAddr *addr,
-                            int port, const char *error_msg, int error_code)
+static void psocks_plug_log(Plug *plug, Socket *s, PlugLogType type,
+                            SockAddr *addr, int port,
+                            const char *error_msg, int error_code)
 {
     psocks_connection *conn = container_of(plug, psocks_connection, plug);
     char addrbuf[256];
diff --git a/ssh/portfwd.c b/ssh/portfwd.c
index 5f6c9fb1..470c090d 100644
--- a/ssh/portfwd.c
+++ b/ssh/portfwd.c
@@ -96,13 +96,15 @@ static void free_portlistener_state(struct PortListener *pl)
     sfree(pl);
 }
 
-static void pfd_log(Plug *plug, PlugLogType type, SockAddr *addr, int port,
+static void pfd_log(Plug *plug, Socket *s, PlugLogType type,
+                    SockAddr *addr, int port,
                     const char *error_msg, int error_code)
 {
     /* we have to dump these since we have no interface to logging.c */
 }
 
-static void pfl_log(Plug *plug, PlugLogType type, SockAddr *addr, int port,
+static void pfl_log(Plug *plug, Socket *s, PlugLogType type,
+                    SockAddr *addr, int port,
                     const char *error_msg, int error_code)
 {
     /* we have to dump these since we have no interface to logging.c */
diff --git a/ssh/server.c b/ssh/server.c
index b477392e..bd8b70db 100644
--- a/ssh/server.c
+++ b/ssh/server.c
@@ -138,8 +138,9 @@ static const SeatVtable server_seat_vt = {
     .get_cursor_position = nullseat_get_cursor_position,
 };
 
-static void server_socket_log(Plug *plug, PlugLogType type, SockAddr *addr,
-                              int port, const char *error_msg, int error_code)
+static void server_socket_log(Plug *plug, Socket *s, PlugLogType type,
+                              SockAddr *addr, int port,
+                              const char *error_msg, int error_code)
 {
     /* server *srv = container_of(plug, server, plug); */
     /* FIXME */
diff --git a/ssh/sesschan.c b/ssh/sesschan.c
index 532fcb3b..f4b44069 100644
--- a/ssh/sesschan.c
+++ b/ssh/sesschan.c
@@ -371,8 +371,8 @@ bool sesschan_run_subsystem(Channel *chan, ptrlen subsys)
     return false;
 }
 
-static void fwd_log(Plug *plug, PlugLogType type, SockAddr *addr, int port,
-                    const char *error_msg, int error_code)
+static void fwd_log(Plug *plug, Socket *s, PlugLogType type, SockAddr *addr,
+                    int port, const char *error_msg, int error_code)
 { /* don't expect any weirdnesses from a listening socket */ }
 static void fwd_closing(Plug *plug, PlugCloseType type, const char *error_msg)
 { /* not here, either */ }
diff --git a/ssh/ssh.c b/ssh/ssh.c
index 836661d6..d94145b0 100644
--- a/ssh/ssh.c
+++ b/ssh/ssh.c
@@ -600,8 +600,9 @@ void ssh_sw_abort_deferred(Ssh *ssh, const char *fmt, ...)
     }
 }
 
-static void ssh_socket_log(Plug *plug, PlugLogType type, SockAddr *addr,
-                           int port, const char *error_msg, int error_code)
+static void ssh_socket_log(Plug *plug, Socket *s, PlugLogType type,
+                           SockAddr *addr, int port,
+                           const char *error_msg, int error_code)
 {
     Ssh *ssh = container_of(plug, Ssh, plug);
 
@@ -615,7 +616,7 @@ static void ssh_socket_log(Plug *plug, PlugLogType type, SockAddr *addr,
      */
 
     if (!ssh->attempting_connshare)
-        backend_socket_log(ssh->seat, ssh->logctx, type, addr, port,
+        backend_socket_log(ssh->seat, ssh->logctx, s, type, addr, port,
                            error_msg, error_code, ssh->conf,
                            ssh->session_started);
 }
diff --git a/ssh/userauth2-client.c b/ssh/userauth2-client.c
index 85f61ab6..17317a44 100644
--- a/ssh/userauth2-client.c
+++ b/ssh/userauth2-client.c
@@ -318,8 +318,9 @@ static bool ssh2_userauth_signflags(struct ssh2_userauth_state *s,
     return true;
 }
 
-static void authplugin_plug_log(Plug *plug, PlugLogType type, SockAddr *addr,
-                                int port, const char *err_msg, int err_code)
+static void authplugin_plug_log(Plug *plug, Socket *sock, PlugLogType type,
+                                SockAddr *addr, int port,
+                                const char *err_msg, int err_code)
 {
     struct ssh2_userauth_state *s = container_of(
         plug, struct ssh2_userauth_state, authplugin_plug);
diff --git a/ssh/x11fwd.c b/ssh/x11fwd.c
index c0ae59f1..a9b049ea 100644
--- a/ssh/x11fwd.c
+++ b/ssh/x11fwd.c
@@ -277,8 +277,8 @@ static char *x11_verify(unsigned long peer_ip, int peer_port,
     return NULL;
 }
 
-static void x11_log(Plug *p, PlugLogType type, SockAddr *addr, int port,
-                    const char *error_msg, int error_code)
+static void x11_log(Plug *p, Socket *s, PlugLogType type, SockAddr *addr,
+                    int port, const char *error_msg, int error_code)
 {
     /* We have no interface to the logging module here, so we drop these. */
 }
diff --git a/stubs/null-plug.c b/stubs/null-plug.c
index d583d156..4ce287ac 100644
--- a/stubs/null-plug.c
+++ b/stubs/null-plug.c
@@ -7,7 +7,7 @@
 
 #include "putty.h"
 
-void nullplug_log(Plug *plug, PlugLogType type, SockAddr *addr,
+void nullplug_log(Plug *plug, Socket *s, PlugLogType type, SockAddr *addr,
                   int port, const char *err_msg, int err_code)
 {
 }
diff --git a/unix/fd-socket.c b/unix/fd-socket.c
index f90d26d5..e6f7c1c1 100644
--- a/unix/fd-socket.c
+++ b/unix/fd-socket.c
@@ -306,7 +306,7 @@ static void fdsocket_select_result_input_error(int fd, int event)
 
     retd = read(fd, buf, sizeof(buf));
     if (retd > 0) {
-        log_proxy_stderr(fds->plug, &fds->psb, buf, retd);
+        log_proxy_stderr(fds->plug, &fds->sock, &fds->psb, buf, retd);
     } else {
         del234(fdsocket_by_inerrfd, fds);
         uxsel_del(fds->inerrfd);
@@ -334,8 +334,8 @@ static const SocketVtable FdSocket_sockvt = {
 static void fdsocket_connect_success_callback(void *ctx)
 {
     FdSocket *fds = (FdSocket *)ctx;
-    plug_log(fds->plug, PLUGLOG_CONNECT_SUCCESS, fds->addr, fds->port,
-             NULL, 0);
+    plug_log(fds->plug, &fds->sock, PLUGLOG_CONNECT_SUCCESS,
+             fds->addr, fds->port, NULL, 0);
 }
 
 void setup_fd_socket(Socket *s, int infd, int outfd, int inerrfd)
diff --git a/unix/network.c b/unix/network.c
index 95ce4b93..2ebd76af 100644
--- a/unix/network.c
+++ b/unix/network.c
@@ -566,7 +566,7 @@ static int try_connect(NetSocket *sock)
     {
         SockAddr thisaddr = sk_extractaddr_tmp(
             sock->addr, &sock->step);
-        plug_log(sock->plug, PLUGLOG_CONNECT_TRYING,
+        plug_log(sock->plug, &sock->sock, PLUGLOG_CONNECT_TRYING,
                  &thisaddr, sock->port, NULL, 0);
     }
 
@@ -725,7 +725,7 @@ static int try_connect(NetSocket *sock)
         sock->writable = true;
 
         SockAddr thisaddr = sk_extractaddr_tmp(sock->addr, &sock->step);
-        plug_log(sock->plug, PLUGLOG_CONNECT_SUCCESS,
+        plug_log(sock->plug, &sock->sock, PLUGLOG_CONNECT_SUCCESS,
                  &thisaddr, sock->port, NULL, 0);
     }
 
@@ -741,7 +741,7 @@ static int try_connect(NetSocket *sock)
     if (err) {
         SockAddr thisaddr = sk_extractaddr_tmp(
             sock->addr, &sock->step);
-        plug_log(sock->plug, PLUGLOG_CONNECT_FAILED,
+        plug_log(sock->plug, &sock->sock, PLUGLOG_CONNECT_FAILED,
                  &thisaddr, sock->port, strerror(err), err);
     }
     return err;
@@ -1425,7 +1425,7 @@ static void net_select_result(int fd, int event)
                     assert(s->addr);
 
                     thisaddr = sk_extractaddr_tmp(s->addr, &s->step);
-                    plug_log(s->plug, PLUGLOG_CONNECT_FAILED,
+                    plug_log(s->plug, &s->sock, PLUGLOG_CONNECT_FAILED,
                              &thisaddr, s->port, errmsg, err);
 
                     while (err && s->addr && sk_nextaddr(s->addr, &s->step)) {
@@ -1442,7 +1442,7 @@ static void net_select_result(int fd, int event)
                      * The connection attempt succeeded.
                      */
                     SockAddr thisaddr = sk_extractaddr_tmp(s->addr, &s->step);
-                    plug_log(s->plug, PLUGLOG_CONNECT_SUCCESS,
+                    plug_log(s->plug, &s->sock, PLUGLOG_CONNECT_SUCCESS,
                              &thisaddr, s->port, NULL, 0);
                 }
             }
diff --git a/unix/pageant.c b/unix/pageant.c
index c77abbac..e53cec23 100644
--- a/unix/pageant.c
+++ b/unix/pageant.c
@@ -243,8 +243,8 @@ static bool time_to_die = false;
  * except that x11_closing has to signal back to the main loop that
  * it's time to terminate.
  */
-static void x11_log(Plug *p, PlugLogType type, SockAddr *addr, int port,
-                    const char *error_msg, int error_code) {}
+static void x11_log(Plug *p, Socket *s, PlugLogType type, SockAddr *addr,
+                    int port, const char *error_msg, int error_code) {}
 static void x11_receive(Plug *plug, int urgent, const char *data, size_t len) {}
 static void x11_sent(Plug *plug, size_t bufsize) {}
 static void x11_closing(Plug *plug, PlugCloseType type, const char *error_msg)
diff --git a/unix/psusan.c b/unix/psusan.c
index 9cf7ac41..4e8693af 100644
--- a/unix/psusan.c
+++ b/unix/psusan.c
@@ -265,8 +265,8 @@ static Plug *server_conn_plug(
         &inst->logpolicy, &unix_live_sftpserver_vt);
 }
 
-static void server_log(Plug *plug, PlugLogType type, SockAddr *addr, int port,
-                       const char *error_msg, int error_code)
+static void server_log(Plug *plug, Socket *s, PlugLogType type, SockAddr *addr,
+                       int port, const char *error_msg, int error_code)
 {
     log_to_stderr(-1, error_msg);
 }
diff --git a/unix/uppity.c b/unix/uppity.c
index 8372a88d..30501af7 100644
--- a/unix/uppity.c
+++ b/unix/uppity.c
@@ -478,8 +478,8 @@ static Plug *server_conn_plug(
         &inst->ap, &inst->logpolicy, &unix_live_sftpserver_vt);
 }
 
-static void server_log(Plug *plug, PlugLogType type, SockAddr *addr, int port,
-                       const char *error_msg, int error_code)
+static void server_log(Plug *plug, Socket *s, PlugLogType type, SockAddr *addr,
+                       int port, const char *error_msg, int error_code)
 {
     log_to_stderr((unsigned)-1, error_msg);
 }
diff --git a/utils/backend_socket_log.c b/utils/backend_socket_log.c
index 783cca31..9036065a 100644
--- a/utils/backend_socket_log.c
+++ b/utils/backend_socket_log.c
@@ -4,7 +4,7 @@
 #include "putty.h"
 #include "network.h"
 
-void backend_socket_log(Seat *seat, LogContext *logctx,
+void backend_socket_log(Seat *seat, LogContext *logctx, Socket *sock,
                         PlugLogType type, SockAddr *addr, int port,
                         const char *error_msg, int error_code, Conf *conf,
                         bool session_started)
diff --git a/utils/log_proxy_stderr.c b/utils/log_proxy_stderr.c
index 2a84173a..74d806ee 100644
--- a/utils/log_proxy_stderr.c
+++ b/utils/log_proxy_stderr.c
@@ -15,7 +15,7 @@ void psb_set_prefix(ProxyStderrBuf *psb, const char *prefix)
     psb->prefix = prefix;
 }
 
-void log_proxy_stderr(Plug *plug, ProxyStderrBuf *psb,
+void log_proxy_stderr(Plug *plug, Socket *sock, ProxyStderrBuf *psb,
                       const void *vdata, size_t len)
 {
     const char *data = (const char *)vdata;
@@ -65,7 +65,7 @@ void log_proxy_stderr(Plug *plug, ProxyStderrBuf *psb,
                 endpos--;
             char *msg = dupprintf(
                 "%s: %.*s", psb->prefix, (int)(endpos - pos), psb->buf + pos);
-            plug_log(plug, PLUGLOG_PROXY_MSG, NULL, 0, msg, 0);
+            plug_log(plug, sock, PLUGLOG_PROXY_MSG, NULL, 0, msg, 0);
             sfree(msg);
 
             pos = nlpos - psb->buf + 1;
@@ -81,7 +81,7 @@ void log_proxy_stderr(Plug *plug, ProxyStderrBuf *psb,
             char *msg = dupprintf(
                 "%s (partial line): %.*s", psb->prefix, (int)psb->size,
                 psb->buf);
-            plug_log(plug, PLUGLOG_PROXY_MSG, NULL, 0, msg, 0);
+            plug_log(plug, sock, PLUGLOG_PROXY_MSG, NULL, 0, msg, 0);
             sfree(msg);
 
             pos = psb->size = 0;
diff --git a/windows/handle-socket.c b/windows/handle-socket.c
index 2a5ba166..47fa4e29 100644
--- a/windows/handle-socket.c
+++ b/windows/handle-socket.c
@@ -107,7 +107,7 @@ static size_t handle_stderr(
     HandleSocket *hs = (HandleSocket *)handle_get_privdata(h);
 
     if (!err && len > 0)
-        log_proxy_stderr(hs->plug, &hs->psb, data, len);
+        log_proxy_stderr(hs->plug, &hs->sock, &hs->psb, data, len);
 
     return 0;
 }
@@ -354,7 +354,8 @@ static const SocketVtable HandleSocket_sockvt = {
 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);
+    plug_log(hs->plug, &hs->sock, PLUGLOG_CONNECT_SUCCESS, hs->addr, hs->port,
+             NULL, 0);
 }
 
 Socket *make_handle_socket(HANDLE send_H, HANDLE recv_H, HANDLE stderr_H,
diff --git a/windows/named-pipe-server.c b/windows/named-pipe-server.c
index 4b0be4db..b6a900db 100644
--- a/windows/named-pipe-server.c
+++ b/windows/named-pipe-server.c
@@ -176,7 +176,7 @@ static void named_pipe_accept_loop(NamedPipeServerSocket *ps,
 
         errmsg = dupprintf("Error while listening to named pipe: %s",
                            win_strerror(error));
-        plug_log(ps->plug, 1, sk_namedpipe_addr(ps->pipename), 0,
+        plug_log(ps->plug, &ps->sock, 1, sk_namedpipe_addr(ps->pipename), 0,
                  errmsg, error);
         sfree(errmsg);
         break;
diff --git a/windows/network.c b/windows/network.c
index 94792c85..de32aefd 100644
--- a/windows/network.c
+++ b/windows/network.c
@@ -904,7 +904,7 @@ static DWORD try_connect(NetSocket *sock)
     {
         SockAddr thisaddr = sk_extractaddr_tmp(
             sock->addr, &sock->step);
-        plug_log(sock->plug, PLUGLOG_CONNECT_TRYING,
+        plug_log(sock->plug, &sock->sock, PLUGLOG_CONNECT_TRYING,
                  &thisaddr, sock->port, NULL, 0);
     }
 
@@ -1065,7 +1065,7 @@ static DWORD try_connect(NetSocket *sock)
          */
         sock->writable = true;
         SockAddr thisaddr = sk_extractaddr_tmp(sock->addr, &sock->step);
-        plug_log(sock->plug, PLUGLOG_CONNECT_SUCCESS,
+        plug_log(sock->plug, &sock->sock, PLUGLOG_CONNECT_SUCCESS,
                  &thisaddr, sock->port, NULL, 0);
     }
 
@@ -1081,7 +1081,7 @@ static DWORD try_connect(NetSocket *sock)
     if (err) {
         SockAddr thisaddr = sk_extractaddr_tmp(
             sock->addr, &sock->step);
-        plug_log(sock->plug, PLUGLOG_CONNECT_FAILED,
+        plug_log(sock->plug, &sock->sock, PLUGLOG_CONNECT_FAILED,
                  &thisaddr, sock->port, sock->error, err);
     }
     return err;
@@ -1578,8 +1578,8 @@ void select_result(WPARAM wParam, LPARAM lParam)
         if (s->addr) {
             SockAddr thisaddr = sk_extractaddr_tmp(
                 s->addr, &s->step);
-            plug_log(s->plug, PLUGLOG_CONNECT_FAILED, &thisaddr, s->port,
-                     winsock_error_string(err), err);
+            plug_log(s->plug, &s->sock, PLUGLOG_CONNECT_FAILED, &thisaddr,
+                     s->port, winsock_error_string(err), err);
             while (err && s->addr && sk_nextaddr(s->addr, &s->step)) {
                 err = try_connect(s);
             }
@@ -1604,7 +1604,7 @@ void select_result(WPARAM wParam, LPARAM lParam)
         if (s->addr) {
             SockAddr thisaddr = sk_extractaddr_tmp(
                 s->addr, &s->step);
-            plug_log(s->plug, PLUGLOG_CONNECT_SUCCESS,
+            plug_log(s->plug, &s->sock, PLUGLOG_CONNECT_SUCCESS,
                      &thisaddr, s->port, NULL, 0);
 
             sk_addr_free(s->addr);