diff --git a/src/proto_uxst.c b/src/proto_uxst.c
index 33768a1..9b5a28d 100644
--- a/src/proto_uxst.c
+++ b/src/proto_uxst.c
@@ -109,9 +109,8 @@
 	if (listener->state != LI_ASSIGNED)
 		return ERR_NONE; /* already bound */
 		
-	if (listener->fd == -1)
-		listener->fd = sock_find_compatible_fd(listener);
-
+	if (listener->rx.fd == -1)
+		listener->rx.fd = sock_find_compatible_fd(listener);
 	path = ((struct sockaddr_un *)&listener->rx.addr)->sun_path;
 
 	maxpathlen = MIN(MAXPATHLEN, sizeof(addr.sun_path));
@@ -121,7 +120,7 @@
 	 * to create a new socket. However we still want to set a few flags on
 	 * the socket.
 	 */
-	fd = listener->fd;
+	fd = listener->rx.fd;
 	ext = (fd >= 0);
 	if (ext)
 		goto fd_ready;
@@ -259,7 +258,7 @@
 		unlink(backname);
 
 	/* the socket is now listening */
-	listener->fd = fd;
+	listener->rx.fd = fd;
 	listener->state = LI_LISTEN;
 
 	fd_insert(fd, listener, listener->proto->accept,
