Merge pull request #836 from fjtrujy/fix/ps2ip-rpc-select-pkt-abi

fix: [ps2ip_rpc] explicit fixed-layout `select_pkt` across EE/IOP RPC

Author: uyjulian

common/include/ps2ip_rpc.h

@@ -132,21 +132,39 @@ typedef struct
     u8 buffer[128];
 } setsockopt_pkt;
 
+/* On-the-wire fd_set for the select RPC. The struct fd_set seen on EE
+ * (newlib, ~128 bytes) and IOP (lwIP, MEMP_NUM_NETCONN/8 bytes) compile
+ * units differs in size, which used to scramble select_pkt's layout
+ * across the SIF RPC boundary — IOP would only touch the first few
+ * bytes of EE's wider readset and never see writeset/exceptset at the
+ * right offsets. Using a fixed-size struct here keeps select_pkt
+ * byte-identical on both sides regardless of which struct fd_set is
+ * in scope at the include site. */
+typedef struct
+{
+    unsigned char fd_bits[(MEMP_NUM_NETCONN + 7) / 8];
+} ps2ip_rpc_fd_set;
+
+/* struct timeval differs across the boundary too — newlib's tv_sec/tv_usec
+ * are 64-bit on EE while the IOP defines them as 32-bit longs. Carry
+ * explicit 32-bit fields here so the layout is byte-identical on both
+ * sides; each end reconstructs its native struct timeval. */
 typedef struct
 {
     union
     {
         s32 maxfdp1;
         s32 result;
     };
-    struct timeval *timeout_p;
-    struct timeval timeout;
-    struct fd_set *readset_p;
-    struct fd_set *writeset_p;
-    struct fd_set *exceptset_p;
-    struct fd_set readset;
-    struct fd_set writeset;
-    struct fd_set exceptset;
+    void *timeout_p;     /* opaque NULL/non-NULL flag */
+    s32 timeout_sec;
+    s32 timeout_usec;
+    void *readset_p;     /* opaque: only NULL/non-NULL is meaningful across RPC */
+    void *writeset_p;
+    void *exceptset_p;
+    ps2ip_rpc_fd_set readset;
+    ps2ip_rpc_fd_set writeset;
+    ps2ip_rpc_fd_set exceptset;
 } select_pkt;
 
 typedef struct

ee/rpc/tcpips/src/ps2ipc.c

@@ -481,6 +481,38 @@ int ps2ipc_ps2ip_getconfig(char *netif_name, t_ip_info *ip_info)
 	return 1;
 }
 
+/* Marshal between the caller's struct fd_set (newlib, ~128 bytes on EE)
+ * and the on-the-wire ps2ip_rpc_fd_set (MEMP_NUM_NETCONN/8 bytes, fixed
+ * size on both sides). Bit-by-bit copy avoids any reliance on
+ * sizeof(struct fd_set) matching across the RPC boundary. */
+static void ps2ipc_pack_fdset(ps2ip_rpc_fd_set *dst, struct fd_set *src, int maxfdp1)
+{
+	int i;
+	memset(dst, 0, sizeof(*dst));
+	if (src == NULL) return;
+	if (maxfdp1 > (int)(sizeof(dst->fd_bits) * 8))
+		maxfdp1 = (int)(sizeof(dst->fd_bits) * 8);
+	for (i = 0; i < maxfdp1; i++) {
+		if (FD_ISSET(i, src)) {
+			dst->fd_bits[i >> 3] |= (unsigned char)(1U << (i & 7));
+		}
+	}
+}
+
+static void ps2ipc_unpack_fdset(struct fd_set *dst, const ps2ip_rpc_fd_set *src, int maxfdp1)
+{
+	int i;
+	if (dst == NULL) return;
+	FD_ZERO(dst);
+	if (maxfdp1 > (int)(sizeof(src->fd_bits) * 8))
+		maxfdp1 = (int)(sizeof(src->fd_bits) * 8);
+	for (i = 0; i < maxfdp1; i++) {
+		if (src->fd_bits[i >> 3] & (1U << (i & 7))) {
+			FD_SET(i, dst);
+		}
+	}
+}
+
 int ps2ipc_select(int maxfdp1, struct fd_set *readset, struct fd_set *writeset, struct fd_set *exceptset, struct timeval *timeout)
 {
 	int result;
@@ -491,21 +523,19 @@ int ps2ipc_select(int maxfdp1, struct fd_set *readset, struct fd_set *writeset,
 	WaitSema(lock_sema);
 
 	pkt->maxfdp1 = maxfdp1;
-	pkt->readset_p = readset;
-	pkt->writeset_p = writeset;
-	pkt->exceptset_p = exceptset;
+	pkt->readset_p = (void *)readset;
+	pkt->writeset_p = (void *)writeset;
+	pkt->exceptset_p = (void *)exceptset;
 	pkt->timeout_p = timeout;
 	if( timeout )
-		pkt->timeout = *timeout;
-
-	if( readset )
-		pkt->readset = *readset;
-
-	if( writeset )
-		pkt->writeset = *writeset;
+	{
+		pkt->timeout_sec  = (s32)timeout->tv_sec;
+		pkt->timeout_usec = (s32)timeout->tv_usec;
+	}
 
-	if( exceptset )
-		pkt->exceptset = *exceptset;
+	ps2ipc_pack_fdset(&pkt->readset,   readset,   maxfdp1);
+	ps2ipc_pack_fdset(&pkt->writeset,  writeset,  maxfdp1);
+	ps2ipc_pack_fdset(&pkt->exceptset, exceptset, maxfdp1);
 
 	if (sceSifCallRpc(&_ps2ip, PS2IPS_ID_SELECT, 0, (void*)pkt, sizeof(select_pkt), (void*)pkt, sizeof(select_pkt), NULL, NULL) < 0)
 	{
@@ -514,16 +544,14 @@ int ps2ipc_select(int maxfdp1, struct fd_set *readset, struct fd_set *writeset,
 	}
 
 	if( timeout )
-		*timeout = pkt->timeout;
-
-	if( readset )
-		*readset = pkt->readset;
-
-	if( writeset )
-		*writeset = pkt->writeset;
+	{
+		timeout->tv_sec  = pkt->timeout_sec;
+		timeout->tv_usec = pkt->timeout_usec;
+	}
 
-	if( exceptset )
-		*exceptset = pkt->exceptset;
+	ps2ipc_unpack_fdset(readset,   &pkt->readset,   maxfdp1);
+	ps2ipc_unpack_fdset(writeset,  &pkt->writeset,  maxfdp1);
+	ps2ipc_unpack_fdset(exceptset, &pkt->exceptset, maxfdp1);
 
 	result = pkt->result;
 

iop/tcpip/tcpips/src/ps2ips.c

@@ -402,15 +402,34 @@ static void do_setconfig(void *rpcBuffer, int size)
 static void do_select( void * rpcBuffer, int size )
 {
 	select_pkt *pkt = (select_pkt*)_rpc_buffer;
+	struct timeval tv;
+	int result;
 
 	(void)rpcBuffer;
 	(void)size;
 
-	pkt->result = select(	pkt->maxfdp1,
-				pkt->readset_p != NULL ? &pkt->readset : NULL,
-				pkt->writeset_p != NULL ? &pkt->writeset : NULL,
-				pkt->exceptset_p != NULL ? &pkt->exceptset : NULL,
-				pkt->timeout_p != NULL ? &pkt->timeout : NULL );
+	/* Reconstruct an IOP-native struct timeval from the wire fields. */
+	if (pkt->timeout_p != NULL)
+	{
+		tv.tv_sec  = pkt->timeout_sec;
+		tv.tv_usec = pkt->timeout_usec;
+	}
+
+	/* ps2ip_rpc_fd_set is { unsigned char fd_bits[(MEMP_NUM_NETCONN+7)/8] },
+	 * which is byte-identical to lwIP's struct fd_set. The cast is safe and
+	 * keeps lwip_select free to mutate the bits in place. */
+	result = select(	pkt->maxfdp1,
+				pkt->readset_p   != NULL ? (struct fd_set *)&pkt->readset   : NULL,
+				pkt->writeset_p  != NULL ? (struct fd_set *)&pkt->writeset  : NULL,
+				pkt->exceptset_p != NULL ? (struct fd_set *)&pkt->exceptset : NULL,
+				pkt->timeout_p   != NULL ? &tv : NULL );
+
+	if (pkt->timeout_p != NULL)
+	{
+		pkt->timeout_sec  = (s32)tv.tv_sec;
+		pkt->timeout_usec = (s32)tv.tv_usec;
+	}
+	pkt->result = result;
 }
 
 static void do_ioctlsocket( void *rpcBuffer, int size )