libvncserver: add listener socket rebinding

Author: bk138

include/rfb/rfb.h

@@ -382,6 +382,10 @@ typedef struct _rfbScreenInfo
 #endif
     /* Timeout value for select() calls, mainly used for multithreaded servers. */
     int select_timeout_usec;
+    /** Set by rfbRequestListenRebind() to ask the listener thread to re-create
+     * its listening sockets from the current listenInterface/listen6Interface/
+     * port/ipv6port values on its next loop iteration. Cleared by the thread. */
+    rfbBool rebindListenSockets;
 } rfbScreenInfo, *rfbScreenInfoPtr;
 
 
@@ -784,6 +788,15 @@ extern int rfbMaxClientWait;
 
 extern void rfbInitSockets(rfbScreenInfoPtr rfbScreen);
 extern void rfbShutdownSockets(rfbScreenInfoPtr rfbScreen);
+/** Close and re-create the TCP/TCP6 listening sockets from the screen's current
+ * listenInterface/listen6Interface/port/ipv6port. Must run on the same thread
+ * that select()s on those sockets; off-thread callers use rfbRequestListenRebind().
+ * Returns TRUE if at least one family is now listening. */
+extern rfbBool rfbRebindListenSockets(rfbScreenInfoPtr rfbScreen);
+/** Thread-safe request to rebind the listening sockets: the actual swap is done
+ * by the background listener thread on its next iteration. Caller must have set
+ * the desired listenInterface/listen6Interface/port/ipv6port beforehand. */
+extern void rfbRequestListenRebind(rfbScreenInfoPtr rfbScreen);
 extern void rfbDisconnectUDPSock(rfbScreenInfoPtr rfbScreen);
 extern void rfbCloseClient(rfbClientPtr cl);
 extern int rfbReadExact(rfbClientPtr cl, char *buf, int len);

src/libvncserver/main.c

@@ -661,6 +661,12 @@ listenerRun(void *data)
 	    /* Reset the pipe */
 	    char buf;
 	    while (read(screen->pipe_notify_listener_thread[0], &buf, sizeof(buf)) == sizeof(buf));
+	    /* A rebind request is serviced here, on the listener thread, so the
+	       close()/socket() swap cannot race the select() above. */
+	    if (screen->rebindListenSockets) {
+		screen->rebindListenSockets = FALSE;
+		rfbRebindListenSockets(screen);
+	    }
 	    /* Go on with loop */
 	    continue;
 	}
@@ -686,7 +692,28 @@ listenerRun(void *data)
 
 #endif
 
-void 
+void
+rfbRequestListenRebind(rfbScreenInfoPtr screen)
+{
+    /* Flag the request; the listener thread picks it up after being woken. */
+    screen->rebindListenSockets = TRUE;
+
+#if defined(LIBVNCSERVER_HAVE_LIBPTHREAD) && !defined(WIN32)
+    if (screen->backgroundLoop && screen->pipe_notify_listener_thread[1] != -1) {
+	const char buf = 'r';
+	if (write(screen->pipe_notify_listener_thread[1], &buf, sizeof(buf)) < 0)
+	    rfbLogPerror("rfbRequestListenRebind: write to notify pipe");
+	return;
+    }
+#endif
+
+    /* No background listener thread: do the swap inline. Safe because the
+       single-threaded event loop is not concurrently in select() here. */
+    screen->rebindListenSockets = FALSE;
+    rfbRebindListenSockets(screen);
+}
+
+void
 rfbStartOnHoldClient(rfbClientPtr cl)
 {
     cl->onHold = FALSE;

src/libvncserver/sockets.c

@@ -336,6 +336,83 @@ void rfbShutdownSockets(rfbScreenInfoPtr rfbScreen)
 #endif
 }
 
+/*
+ * rfbRebindListenSockets closes the current TCP/TCP6 listening sockets and
+ * re-creates them from the screen's current listenInterface/listen6Interface
+ * and port/ipv6port. This is used to follow an interface whose IP address
+ * changed (e.g. after the bound network interface went down and back up).
+ *
+ * It must be called on the thread that select()s on the listening sockets so
+ * that the close()/socket() swap cannot race a concurrent select(): in the
+ * threaded (background loop) case that is the listener thread, which invokes
+ * this from listenerRun() in response to rfbRequestListenRebind(). Already-
+ * connected clients keep their own sockets and are unaffected. The HTTP
+ * listeners are bound to the same interface address, so they are re-created too.
+ */
+rfbBool
+rfbRebindListenSockets(rfbScreenInfoPtr rfbScreen)
+{
+    in_addr_t iface = rfbScreen->listenInterface;
+
+    /* This deliberately only handles the plain TCP/TCP6 listeners; inetd and
+       autoPort setups have no stable address to rebind to. */
+    if (rfbScreen->inetdSock != RFB_INVALID_SOCKET || rfbScreen->autoPort)
+        return FALSE;
+
+    /* tear down the existing listeners; rfbCloseSocket() also resets the fd to
+       RFB_INVALID_SOCKET, the outer if only skips the FD_CLR when there is none */
+    if (rfbScreen->listenSock != RFB_INVALID_SOCKET) {
+        FD_CLR(rfbScreen->listenSock, &rfbScreen->allFds);
+        rfbCloseSocket(rfbScreen->listenSock);
+    }
+#ifdef LIBVNCSERVER_IPv6
+    if (rfbScreen->listen6Sock != RFB_INVALID_SOCKET) {
+        FD_CLR(rfbScreen->listen6Sock, &rfbScreen->allFds);
+        rfbCloseSocket(rfbScreen->listen6Sock);
+    }
+#endif
+
+    /* re-create from the current interface addresses */
+    if (rfbScreen->port > 0) {
+        if ((rfbScreen->listenSock = rfbListenOnTCPPort(rfbScreen->port, iface)) == RFB_INVALID_SOCKET) {
+            rfbLogPerror("rfbRebindListenSockets: ListenOnTCPPort");
+        } else {
+            rfbLog("rfbRebindListenSockets: listening for VNC connections on TCP port %d\n", rfbScreen->port);
+            FD_SET(rfbScreen->listenSock, &rfbScreen->allFds);
+            rfbScreen->maxFd = rfbMax((int)rfbScreen->listenSock, rfbScreen->maxFd);
+        }
+    }
+
+#ifdef LIBVNCSERVER_IPv6
+    if (rfbScreen->ipv6port > 0) {
+        if ((rfbScreen->listen6Sock = rfbListenOnTCP6Port(rfbScreen->ipv6port, rfbScreen->listen6Interface)) == RFB_INVALID_SOCKET) {
+            /* rfbListenOnTCP6Port has its own detailed error printout */
+        } else {
+            rfbLog("rfbRebindListenSockets: listening for VNC connections on TCP6 port %d\n", rfbScreen->ipv6port);
+            FD_SET(rfbScreen->listen6Sock, &rfbScreen->allFds);
+            rfbScreen->maxFd = rfbMax((int)rfbScreen->listen6Sock, rfbScreen->maxFd);
+        }
+    }
+#endif
+
+    /* The HTTP listeners are bound to the same interface address and go stale the
+       same way, so re-create them too. rfbHttpCheckFds() runs on this same listener
+       thread, so closing/reopening here cannot race it. Only relevant with an httpDir
+       configured; reset httpInitDone so rfbHttpInitSockets() actually runs again. This
+       is best-effort and does not affect the RFB-based return value below. */
+    if (rfbScreen->httpDir) {
+        rfbHttpShutdownSockets(rfbScreen);
+        rfbScreen->httpInitDone = FALSE;
+        rfbHttpInitSockets(rfbScreen);
+    }
+
+    return (rfbScreen->listenSock != RFB_INVALID_SOCKET
+#ifdef LIBVNCSERVER_IPv6
+            || rfbScreen->listen6Sock != RFB_INVALID_SOCKET
+#endif
+           ) ? TRUE : FALSE;
+}
+
 /*
  * rfbCheckFds is called from ProcessInputEvents to check for input on the RFB
  * socket(s).  If there is input to process, the appropriate function in the