Updating code to PuTTY 65b65bb

Also fixing apparent bug in chan_log_close_msg macro (which got reimplemented and consequently fixed in bit later PuTTY commit)

Source commit: db2b72f5c07836443b49455f7c829f8b0997986f

source/Putty.cbproj

@@ -94,6 +94,9 @@
 		<TASM_Debugging>None</TASM_Debugging>
 	</PropertyGroup>
 	<ItemGroup>
+		<CppCompile Include="putty\agentf.c">
+			<BuildOrder>60</BuildOrder>
+		</CppCompile>
 		<CppCompile Include="putty\be_misc.c">
 			<BuildOrder>47</BuildOrder>
 		</CppCompile>

source/core/PuttyIntf.cpp

@@ -85,13 +85,17 @@ TSecureShell * GetSecureShell(Plug plug, bool & pfwd)
   }
 
   pfwd = is_pfwd(plug);
+  void * frontend;
   if (pfwd)
   {
-    plug = (Plug)get_pfwd_backend(plug);
+    Ssh ssh = get_pfwd_ssh(plug);
+    frontend = ssh_get_frontend(ssh);
   }
-
-  void * frontend = get_ssh_frontend(plug);
-  DebugAssert(frontend);
+  else
+  {
+    frontend = get_ssh_frontend(plug);
+  }
+  DebugAssert(frontend != NULL);
 
   return reinterpret_cast<TSecureShell*>(frontend);
 }
@@ -119,7 +123,7 @@ extern "C" char * do_select(Plug plug, SOCKET skt, int startup)
   return NULL;
 }
 //---------------------------------------------------------------------------
-int from_backend(void * frontend, int is_stderr, const void * data, int datalen)
+int from_backend(Frontend * frontend, int is_stderr, const void * data, int datalen)
 {
   DebugAssert(frontend);
   if (is_stderr >= 0)
@@ -135,14 +139,14 @@ int from_backend(void * frontend, int is_stderr, const void * data, int datalen)
   return 0;
 }
 //---------------------------------------------------------------------------
-int from_backend_untrusted(void * /*frontend*/, const void * /*data*/, int /*len*/)
+int from_backend_untrusted(Frontend * /*frontend*/, const void * /*data*/, int /*len*/)
 {
   // currently used with authentication banner only,
   // for which we have own interface display_banner
   return 0;
 }
 //---------------------------------------------------------------------------
-int from_backend_eof(void * /*frontend*/)
+int from_backend_eof(Frontend * /*frontend*/)
 {
   return FALSE;
 }
@@ -216,14 +220,14 @@ int get_userpass_input(prompts_t * p, bufchain * DebugUsedArg(input))
   return Result;
 }
 //---------------------------------------------------------------------------
-char * get_ttymode(void * /*frontend*/, const char * /*mode*/)
+char * get_ttymode(Frontend * /*frontend*/, const char * /*mode*/)
 {
   // should never happen when Config.nopty == TRUE
   DebugFail();
   return NULL;
 }
 //---------------------------------------------------------------------------
-void logevent(void * frontend, const char * string)
+void logevent(Frontend * frontend, const char * string)
 {
   // Frontend maybe NULL here
   if (frontend != NULL)
@@ -232,7 +236,7 @@ void logevent(void * frontend, const char * string)
   }
 }
 //---------------------------------------------------------------------------
-void connection_fatal(void * frontend, const char * fmt, ...)
+void connection_fatal(Frontend * frontend, const char * fmt, ...)
 {
   va_list Param;
   char Buf[200];
@@ -245,12 +249,12 @@ void connection_fatal(void * frontend, const char * fmt, ...)
   ((TSecureShell *)frontend)->PuttyFatalError(Buf);
 }
 //---------------------------------------------------------------------------
-int verify_ssh_host_key(void * frontend, char * host, int port, const char * keytype,
+int verify_ssh_host_key(Frontend * frontend, char * host, int port, const char * keytype,
   char * keystr, char * fingerprint, void (*/*callback*/)(void * ctx, int result),
   void * /*ctx*/)
 {
   DebugAssert(frontend != NULL);
-  static_cast<TSecureShell *>(frontend)->VerifyHostKey(host, port, keytype, keystr, fingerprint);
+  reinterpret_cast<TSecureShell *>(frontend)->VerifyHostKey(host, port, keytype, keystr, fingerprint);
 
   // We should return 0 when key was not confirmed, we throw exception instead.
   return 1;
@@ -263,7 +267,7 @@ int have_ssh_host_key(void * frontend, const char * hostname, int port,
   return static_cast<TSecureShell *>(frontend)->HaveHostKey(hostname, port, keytype) ? 1 : 0;
 }
 //---------------------------------------------------------------------------
-int askalg(void * frontend, const char * algtype, const char * algname,
+int askalg(Frontend * frontend, const char * algtype, const char * algname,
   void (*/*callback*/)(void * ctx, int result), void * /*ctx*/)
 {
   DebugAssert(frontend != NULL);
@@ -273,7 +277,7 @@ int askalg(void * frontend, const char * algtype, const char * algname,
   return 1;
 }
 //---------------------------------------------------------------------------
-int askhk(void * /*frontend*/, const char * /*algname*/, const char * /*betteralgs*/,
+int askhk(Frontend * /*frontend*/, const char * /*algname*/, const char * /*betteralgs*/,
   void (*/*callback*/)(void *ctx, int result), void * /*ctx*/)
 {
   return 1;
@@ -332,7 +336,7 @@ void cleanup_exit(int /*code*/)
   throw ESshFatal(NULL, "");
 }
 //---------------------------------------------------------------------------
-int askappend(void * /*frontend*/, Filename * /*filename*/,
+int askappend(Frontend * /*frontend*/, Filename * /*filename*/,
   void (*/*callback*/)(void * ctx, int result), void * /*ctx*/)
 {
   // this is called from logging.c of putty, which is never used with WinSCP
@@ -340,7 +344,7 @@ int askappend(void * /*frontend*/, Filename * /*filename*/,
   return 0;
 }
 //---------------------------------------------------------------------------
-void ldisc_echoedit_update(void * /*handle*/)
+void ldisc_echoedit_update(Ldisc * /*handle*/)
 {
   DebugFail();
 }
@@ -351,12 +355,12 @@ void agent_schedule_callback(void (* /*callback*/)(void *, void *, int),
   DebugFail();
 }
 //---------------------------------------------------------------------------
-void notify_remote_exit(void * /*frontend*/)
+void notify_remote_exit(Frontend * /*frontend*/)
 {
   // nothing
 }
 //---------------------------------------------------------------------------
-void update_specials_menu(void * /*frontend*/)
+void update_specials_menu(Frontend * /*frontend*/)
 {
   // nothing
 }
@@ -371,7 +375,7 @@ void expire_timer_context(void * /*ctx*/)
   // nothing
 }
 //---------------------------------------------------------------------------
-Pinger pinger_new(Conf * /*conf*/, Backend * /*back*/, void * /*backhandle*/)
+Pinger pinger_new(Conf * /*conf*/, Backend * /*back*/)
 {
   return NULL;
 }
@@ -386,7 +390,7 @@ void pinger_free(Pinger /*pinger*/)
   // nothing
 }
 //---------------------------------------------------------------------------
-void set_busy_status(void * /*frontend*/, int /*status*/)
+void set_busy_status(Frontend * /*frontend*/, int /*status*/)
 {
   // nothing
 }

source/core/SecureShell.cpp

@@ -410,7 +410,7 @@ void __fastcall TSecureShell::Open()
     FSendBuf = FSessionData->SendBuf;
     try
     {
-      InitError = FBackend->init(this, &FBackendHandle, conf,
+      InitError = FBackend->init(reinterpret_cast<Frontend *>(this), &FBackendHandle, conf,
         AnsiString(FSessionData->HostNameExpanded).c_str(), FSessionData->PortNumber, &RealHost,
         (FSessionData->TcpNoDelay ? 1 : 0),
         conf_get_int(conf, CONF_tcp_keepalives));
@@ -1677,7 +1677,7 @@ void inline __fastcall TSecureShell::CheckConnection(int Message)
 
     Str = MainInstructions(Str);
 
-    int ExitCode = get_ssh_exitcode(FBackendHandle);
+    int ExitCode = FBackend->exitcode(FBackendHandle);
     if (ExitCode >= 0)
     {
       Str += L" " + FMTLOAD(SSH_EXITCODE, (ExitCode));

source/core/SecureShell.h

@@ -8,6 +8,7 @@
 #include "SessionInfo.h"
 //---------------------------------------------------------------------------
 #ifndef PuttyIntfH
+struct Backend_vtable;
 struct Backend;
 struct Conf;
 #endif
@@ -34,8 +35,8 @@ private:
   TSessionInfo FSessionInfo;
   bool FSessionInfoValid;
   TDateTime FLastDataSent;
-  Backend * FBackend;
-  void * FBackendHandle;
+  const Backend_vtable * FBackend;
+  Backend * FBackendHandle;
   const unsigned int * FMaxPacketSize;
   TNotifyEvent FOnReceive;
   bool FFrozen;

source/putty/agentf.c

@@ -173,7 +173,7 @@ Channel *agentf_new(struct ssh_channel *c)
 
 static void agentf_free(Channel *chan)
 {
-    assert(chan->vt == &agentf_channelvt);
+    pinitassert(chan->vt == &agentf_channelvt);
     agentf *af = FROMFIELD(chan, agentf, chan);
 
     if (af->pending)
@@ -185,7 +185,7 @@ static void agentf_free(Channel *chan)
 static int agentf_send(Channel *chan, int is_stderr,
                        const void *data, int length)
 {
-    assert(chan->vt == &agentf_channelvt);
+    pinitassert(chan->vt == &agentf_channelvt);
     agentf *af = FROMFIELD(chan, agentf, chan);
     bufchain_add(&af->inbuffer, data, length);
     agentf_try_forward(af);
@@ -203,7 +203,7 @@ static int agentf_send(Channel *chan, int is_stderr,
 
 static void agentf_send_eof(Channel *chan)
 {
-    assert(chan->vt == &agentf_channelvt);
+    pinitassert(chan->vt == &agentf_channelvt);
     agentf *af = FROMFIELD(chan, agentf, chan);
 
     af->rcvd_eof = TRUE;
@@ -221,7 +221,7 @@ static char *agentf_log_close_msg(Channel *chan)
 
 static void agentf_set_input_wanted(Channel *chan, int wanted)
 {
-    assert(chan->vt == &agentf_channelvt);
+    pinitassert(chan->vt == &agentf_channelvt);
     agentf *af = FROMFIELD(chan, agentf, chan);
 
     af->input_wanted = wanted;

source/putty/portfwd.c

@@ -625,7 +625,7 @@ void pfl_terminate(struct PortListener *pl)
 
 static void pfd_set_input_wanted(Channel *chan, int wanted)
 {
-    assert(chan->vt == &PortForwarding_channelvt);
+    pinitassert(chan->vt == &PortForwarding_channelvt);
     PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
     pf->input_wanted = wanted;
     sk_set_frozen(pf->s, !pf->input_wanted);
@@ -633,7 +633,7 @@ static void pfd_set_input_wanted(Channel *chan, int wanted)
 
 static void pfd_chan_free(Channel *chan)
 {
-    assert(chan->vt == &PortForwarding_channelvt);
+    pinitassert(chan->vt == &PortForwarding_channelvt);
     PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
     pfd_close(pf);
 }
@@ -643,21 +643,21 @@ static void pfd_chan_free(Channel *chan)
  */
 static int pfd_send(Channel *chan, int is_stderr, const void *data, int len)
 {
-    assert(chan->vt == &PortForwarding_channelvt);
+    pinitassert(chan->vt == &PortForwarding_channelvt);
     PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
     return sk_write(pf->s, data, len);
 }
 
 static void pfd_send_eof(Channel *chan)
 {
-    assert(chan->vt == &PortForwarding_channelvt);
+    pinitassert(chan->vt == &PortForwarding_channelvt);
     PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
     sk_write_eof(pf->s);
 }
 
 static void pfd_open_confirmation(Channel *chan)
 {
-    assert(chan->vt == &PortForwarding_channelvt);
+    pinitassert(chan->vt == &PortForwarding_channelvt);
     PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
 
     pf->ready = 1;
@@ -673,7 +673,7 @@ static void pfd_open_confirmation(Channel *chan)
 
 static void pfd_open_failure(Channel *chan, const char *errtext)
 {
-    assert(chan->vt == &PortForwarding_channelvt);
+    pinitassert(chan->vt == &PortForwarding_channelvt);
     PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
 
     char *msg = dupprintf(
@@ -687,27 +687,27 @@ static void pfd_open_failure(Channel *chan, const char *errtext)
 
 #include "puttyexp.h"
 
-int is_pfwd(void * handle)
+int is_pfwd(Plug plug)
 {
-  Plug fn = (Plug)handle;
   return
-    ((*fn)->closing == pfd_closing) ||
-    ((*fn)->closing == pfl_closing);
+    ((*plug)->closing == pfd_closing) ||
+    ((*plug)->closing == pfl_closing);
 }
 
-void * get_pfwd_backend(void * handle)
+Ssh get_pfwd_ssh(Plug plug)
 {
-  void * backend = NULL;
-  Plug fn = (Plug)handle;
-  if ((*fn)->closing == pfl_closing)
+  Ssh ssh = NULL;
+  if ((*plug)->closing == pfl_closing)
   {
-    backend = ((struct PortListener *)handle)->backhandle;
+    struct PortListener *pl = FROMFIELD(plug, struct PortListener, plugvt);
+    ssh = pl->ssh;
   }
-  else if ((*fn)->closing == pfd_closing)
+  else if ((*plug)->closing == pfd_closing)
   {
-    backend = ((struct PortForwarding *)handle)->backhandle;
+    struct PortForwarding *pf = FROMFIELD(plug, struct PortForwarding, plugvt);
+    ssh = pf->ssh;
   }
-  return backend;
+  return ssh;
 }
 
 #endif

source/putty/putty.h

@@ -1720,4 +1720,10 @@ void putty_finalize();
 #define MPEXT_BOM "\xEF\xBB\xBF"
 #endif
 
+#ifdef MPEXT
+// Recent PuTTY code uses C99 standard that allows code before initialization.
+// Mostly that code are assertions. This assert implementation allows being used before code.
+#define pinitassert(P) const int __assert_dummy = 1/(P)
+#endif
+
 #endif

source/putty/puttyexp.h

@@ -5,21 +5,20 @@
 
 // from ssh.c
 
-int is_ssh(void * handle);
-void call_ssh_timer(void * handle);
-int get_ssh_version(void * handle);
+int is_ssh(Plug plug);
+void call_ssh_timer(Backend * be);
+int get_ssh_version(Backend * be);
 void * get_ssh_frontend(Plug plug);
-int get_ssh1_compressing(void * handle);
-const struct ssh_cipher * get_cipher(void * handle);
-const struct ssh2_cipher * get_cscipher(void * handle);
-const struct ssh2_cipher * get_sccipher(void * handle);
-const struct ssh_compress * get_cscomp(void * handle);
-const struct ssh_compress * get_sccomp(void * handle);
-int get_ssh_state_closed(void * handle);
-int get_ssh_state_session(void * handle);
-int get_ssh_exitcode(void * handle);
-const unsigned int * ssh2_remmaxpkt(void * handle);
-const unsigned int * ssh2_remwindow(void * handle);
+int get_ssh1_compressing(Backend * be);
+const struct ssh_cipher * get_cipher(Backend * be);
+const struct ssh2_cipher * get_cscipher(Backend * be);
+const struct ssh2_cipher * get_sccipher(Backend * be);
+const struct ssh_compress * get_cscomp(Backend * be);
+const struct ssh_compress * get_sccomp(Backend * be);
+int get_ssh_state_closed(Backend * be);
+int get_ssh_state_session(Backend * be);
+const unsigned int * ssh2_remmaxpkt(Backend * be);
+const unsigned int * ssh2_remwindow(Backend * be);
 void md5checksum(const char * buffer, int len, unsigned char output[16]);
 typedef const struct ssh_keyalg * cp_ssh_keyalg;
 void get_hostkey_algs(int * count, cp_ssh_keyalg * SignKeys);
@@ -33,8 +32,8 @@ void get_macs(int * count, const struct ssh_mac *** amacs);
 
 // from portfwd.c
 
-int is_pfwd(void * handle);
-void * get_pfwd_backend(void * handle);
+int is_pfwd(Plug plug);
+Ssh get_pfwd_ssh(Plug plug);
 
 // for winstore.c
 

source/putty/ssh.c

@@ -9779,7 +9779,7 @@ static mainchan *mainchan_new(Ssh ssh)
 
 static void mainchan_free(Channel *chan)
 {
-    assert(chan->vt == &mainchan_channelvt);
+    pinitassert(chan->vt == &mainchan_channelvt);
     mainchan *mc = FROMFIELD(chan, mainchan, chan);
     mc->ssh->mainchan = NULL;
     sfree(mc);
@@ -9800,14 +9800,14 @@ static void mainchan_open_failure(Channel *chan, const char *errtext)
 static int mainchan_send(Channel *chan, int is_stderr,
                          const void *data, int length)
 {
-    assert(chan->vt == &mainchan_channelvt);
+    pinitassert(chan->vt == &mainchan_channelvt);
     mainchan *mc = FROMFIELD(chan, mainchan, chan);
     return from_backend(mc->ssh->frontend, is_stderr, data, length);
 }
 
 static void mainchan_send_eof(Channel *chan)
 {
-    assert(chan->vt == &mainchan_channelvt);
+    pinitassert(chan->vt == &mainchan_channelvt);
     mainchan *mc = FROMFIELD(chan, mainchan, chan);
 
     if (!mc->ssh->sent_console_eof &&
@@ -9826,7 +9826,7 @@ static void mainchan_send_eof(Channel *chan)
 
 static void mainchan_set_input_wanted(Channel *chan, int wanted)
 {
-    assert(chan->vt == &mainchan_channelvt);
+    pinitassert(chan->vt == &mainchan_channelvt);
     mainchan *mc = FROMFIELD(chan, mainchan, chan);
 
     /*
@@ -11473,23 +11473,24 @@ const struct Backend_vtable ssh_backend = {
 
 #include "puttyexp.h"
 
-int is_ssh(void * handle)
+int is_ssh(Plug plug)
 {
-  Plug fn = (Plug)handle;
-  return (*fn)->closing == ssh_closing;
+  return (*plug)->closing == ssh_closing;
 }
 
-void call_ssh_timer(void * handle)
+void call_ssh_timer(Backend * be)
 {
-  if (((Ssh)handle)->version == 2)
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  if (ssh->version == 2)
   {
-    ssh2_timer(handle, GETTICKCOUNT());
+    ssh2_timer(ssh, GETTICKCOUNT());
   }
 }
 
-int get_ssh_version(void * handle)
+int get_ssh_version(Backend * be)
 {
-  return ((Ssh)handle)->version;
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return ssh->version;
 }
 
 void * get_ssh_frontend(Plug plug)
@@ -11497,59 +11498,64 @@ void * get_ssh_frontend(Plug plug)
   return FROMFIELD(plug, struct ssh_tag, plugvt)->frontend;
 }
 
-int get_ssh1_compressing(void * handle)
+int get_ssh1_compressing(Backend * be)
 {
-  return ssh1_bpp_get_compressing(((Ssh)handle)->bpp);
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return ssh1_bpp_get_compressing(ssh->bpp);
 }
 
-const struct ssh_cipher * get_cipher(void * handle)
+const struct ssh_cipher * get_cipher(Backend * be)
 {
-  return ssh1_bpp_get_cipher(((Ssh)handle)->bpp);
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return ssh1_bpp_get_cipher(ssh->bpp);
 }
 
-const struct ssh2_cipher * get_cscipher(void * handle)
+const struct ssh2_cipher * get_cscipher(Backend * be)
 {
-  return ssh2_bpp_get_cscipher(((Ssh)handle)->bpp);
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return ssh2_bpp_get_cscipher(ssh->bpp);
 }
 
-const struct ssh2_cipher * get_sccipher(void * handle)
+const struct ssh2_cipher * get_sccipher(Backend * be)
 {
-  return ssh2_bpp_get_sccipher(((Ssh)handle)->bpp);
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return ssh2_bpp_get_sccipher(ssh->bpp);
 }
 
-const struct ssh_compress * get_cscomp(void * handle)
+const struct ssh_compress * get_cscomp(Backend * be)
 {
-  return ssh2_bpp_get_cscomp(((Ssh)handle)->bpp);
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return ssh2_bpp_get_cscomp(ssh->bpp);
 }
 
-const struct ssh_compress * get_sccomp(void * handle)
+const struct ssh_compress * get_sccomp(Backend * be)
 {
-  return ssh2_bpp_get_sccomp(((Ssh)handle)->bpp);
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return ssh2_bpp_get_sccomp(ssh->bpp);
 }
 
-int get_ssh_state_closed(void * handle)
+int get_ssh_state_closed(Backend * be)
 {
-  return ((Ssh)handle)->state == SSH_STATE_CLOSED;
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return ssh->state == SSH_STATE_CLOSED;
 }
 
-int get_ssh_state_session(void * handle)
+int get_ssh_state_session(Backend * be)
 {
-  return ((Ssh)handle)->state == SSH_STATE_SESSION;
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return ssh->state == SSH_STATE_SESSION;
 }
 
-int get_ssh_exitcode(void * handle)
+const unsigned int * ssh2_remmaxpkt(Backend * be)
 {
-  return ssh_return_exitcode(handle);
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return &ssh->mainchan->v.v2.remmaxpkt;
 }
 
-const unsigned int * ssh2_remmaxpkt(void * handle)
+const unsigned int * ssh2_remwindow(Backend * be)
 {
-  return &((Ssh)handle)->mainchan->v.v2.remmaxpkt;
-}
-
-const unsigned int * ssh2_remwindow(void * handle)
-{
-  return &((Ssh)handle)->mainchan->v.v2.remwindow;
+  Ssh ssh = FROMFIELD(be, struct ssh_tag, backend);
+  return &ssh->mainchan->v.v2.remwindow;
 }
 
 void md5checksum(const char * buffer, int len, unsigned char output[16])

source/putty/sshchan.h

@@ -40,7 +40,7 @@ struct Channel {
 #define chan_send_eof(ch) ((ch)->vt->send_eof(ch))
 #define chan_set_input_wanted(ch, wanted) \
     ((ch)->vt->set_input_wanted(ch, wanted))
-#define chan_log_close_msg(ch) ((ch)->vt->send_eof(ch))
+#define chan_log_close_msg(ch) ((ch)->vt->log_close_msg(ch))
 #define chan_want_close(ch, leof, reof) ((ch)->vt->want_close(ch, leof, reof))
 
 /*

source/putty/x11fwd.c

@@ -776,7 +776,7 @@ Channel *x11_new_channel(tree234 *authtree, struct ssh_channel *c,
 
 static void x11_chan_free(Channel *chan)
 {
-    assert(chan->vt == &X11Connection_channelvt);
+    pinitassert(chan->vt == &X11Connection_channelvt);
     X11Connection *xconn = FROMFIELD(chan, X11Connection, chan);
 
     if (xconn->auth_protocol) {
@@ -793,7 +793,7 @@ static void x11_chan_free(Channel *chan)
 
 static void x11_set_input_wanted(Channel *chan, int wanted)
 {
-    assert(chan->vt == &X11Connection_channelvt);
+    pinitassert(chan->vt == &X11Connection_channelvt);
     X11Connection *xconn = FROMFIELD(chan, X11Connection, chan);
 
     xconn->input_wanted = wanted;
@@ -848,7 +848,7 @@ static int x11_parse_ip(const char *addr_string, unsigned long *ip)
  */
 static int x11_send(Channel *chan, int is_stderr, const void *vdata, int len)
 {
-    assert(chan->vt == &X11Connection_channelvt);
+    pinitassert(chan->vt == &X11Connection_channelvt);
     X11Connection *xconn = FROMFIELD(chan, X11Connection, chan);
     const char *data = (const char *)vdata;
 
@@ -1006,7 +1006,7 @@ static int x11_send(Channel *chan, int is_stderr, const void *vdata, int len)
 
 static void x11_send_eof(Channel *chan)
 {
-    assert(chan->vt == &X11Connection_channelvt);
+    pinitassert(chan->vt == &X11Connection_channelvt);
     X11Connection *xconn = FROMFIELD(chan, X11Connection, chan);
 
     if (xconn->s) {