RPCN v0.6

rpcs3/Emu/Cell/Modules/sceNp.h

@@ -1393,14 +1393,14 @@ struct SceNpMatchingReqRange
 
 struct SceNpScoreVariableSizeGameInfo
 {
-	be_t<u64> infoSize;
+	be_t<u32> infoSize;
 	u8 data[SCE_NP_SCORE_VARIABLE_SIZE_GAMEINFO_MAXSIZE];
 	u8 pad[3];
 };
 
 struct SceNpScoreRecordOptParam
 {
-	be_t<u64> size;
+	be_t<u32> size;
 	vm::bptr<SceNpScoreVariableSizeGameInfo> vsInfo;
 	vm::bptr<CellRtcTick> reserved;
 };

rpcs3/Emu/Cell/Modules/sceNp2.cpp

@@ -611,6 +611,11 @@ error_code sceNpMatching2SignalingGetConnectionInfo(
 		return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED;
 	}
 
+	if (!connInfo || code < 1 || code > 6)
+	{
+		return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT;	
+	}
+
 	switch (code)
 	{
 		case SCE_NP_SIGNALING_CONN_INFO_RTT:
@@ -625,8 +630,9 @@ error_code sceNpMatching2SignalingGetConnectionInfo(
 		}
 		case SCE_NP_SIGNALING_CONN_INFO_PEER_NPID:
 		{
-			// TODO: need an update to whole signaling as matching2 signaling ignores npids atm
-			sceNp2.fatal("sceNpMatching2SignalingGetConnectionInfo Unimplemented SCE_NP_SIGNALING_CONN_INFO_PEER_NPID");
+			auto& sigh = g_fxo->get<named_thread<signaling_handler>>();
+			const auto si = sigh.get_sig2_infos(roomId, memberId);
+			connInfo->npId = si.npid;
 			break;
 		}
 		case SCE_NP_SIGNALING_CONN_INFO_PEER_ADDRESS:

rpcs3/Emu/Cell/lv2/sys_net/lv2_socket_raw.cpp

@@ -1,5 +1,6 @@
 #include "stdafx.h"
 #include "lv2_socket_raw.h"
+#include "Emu/NP/vport0.h"
 
 LOG_CHANNEL(sys_net);
 
@@ -10,31 +11,37 @@ lv2_socket_raw::lv2_socket_raw(lv2_socket_family family, lv2_socket_type type, l
 
 std::tuple<bool, s32, std::shared_ptr<lv2_socket>, sys_net_sockaddr> lv2_socket_raw::accept([[maybe_unused]] bool is_lock)
 {
-	sys_net.todo("lv2_socket_raw::accept");
-	return {};
-}
-
-s32 lv2_socket_raw::bind([[maybe_unused]] const sys_net_sockaddr& addr, [[maybe_unused]] s32 ps3_id)
-{
-	sys_net.todo("lv2_socket_raw::bind");
+	sys_net.fatal("[RAW] accept() called on a RAW socket");
 	return {};
 }
 
 std::optional<s32> lv2_socket_raw::connect([[maybe_unused]] const sys_net_sockaddr& addr)
 {
-	sys_net.todo("lv2_socket_raw::connect");
+	sys_net.fatal("[RAW] connect() called on a RAW socket");
 	return CELL_OK;
 }
 
 s32 lv2_socket_raw::connect_followup()
 {
-	sys_net.todo("lv2_socket_raw::connect_followup");
+	sys_net.fatal("[RAW] connect_followup() called on a RAW socket");
 	return CELL_OK;
 }
 
 std::pair<s32, sys_net_sockaddr> lv2_socket_raw::getpeername()
 {
-	sys_net.todo("lv2_socket_raw::getpeername");
+	sys_net.todo("[RAW] getpeername() called on a RAW socket");
+	return {};
+}
+
+s32 lv2_socket_raw::listen([[maybe_unused]] s32 backlog)
+{
+	sys_net.todo("[RAW] listen() called on a RAW socket");
+	return {};
+}
+
+s32 lv2_socket_raw::bind([[maybe_unused]] const sys_net_sockaddr& addr, [[maybe_unused]] s32 ps3_id)
+{
+	sys_net.todo("lv2_socket_raw::bind");
 	return {};
 }
 
@@ -56,16 +63,10 @@ s32 lv2_socket_raw::setsockopt([[maybe_unused]] s32 level, [[maybe_unused]] s32
 	return {};
 }
 
-s32 lv2_socket_raw::listen([[maybe_unused]] s32 backlog)
-{
-	sys_net.todo("lv2_socket_raw::listen");
-	return {};
-}
-
 std::optional<std::tuple<s32, std::vector<u8>, sys_net_sockaddr>> lv2_socket_raw::recvfrom([[maybe_unused]] s32 flags, [[maybe_unused]] u32 len, [[maybe_unused]] bool is_lock)
 {
 	sys_net.todo("lv2_socket_raw::recvfrom");
-	return {{{}, {}, {}}};
+	return {};
 }
 
 std::optional<s32> lv2_socket_raw::sendto([[maybe_unused]] s32 flags, [[maybe_unused]] const std::vector<u8>& buf, [[maybe_unused]] std::optional<sys_net_sockaddr> opt_sn_addr, [[maybe_unused]] bool is_lock)

rpcs3/Emu/Cell/lv2/sys_net/nt_p2p_port.cpp

@@ -9,6 +9,7 @@
 #include "sys_net_helpers.h"
 #include "Emu/NP/signaling_handler.h"
 #include "sys_net_helpers.h"
+#include "Emu/NP/vport0.h"
 
 LOG_CHANNEL(sys_net);
 
@@ -119,35 +120,48 @@ bool nt_p2p_port::recv_data()
 
 	u16 dst_vport = reinterpret_cast<le_t<u16>&>(p2p_recv_data[0]);
 
-	if (dst_vport == 0) // Reserved for messages from RPCN server
+	if (dst_vport == 0)
 	{
-		std::vector<u8> rpcn_msg(recv_res - sizeof(u16));
-		memcpy(rpcn_msg.data(), p2p_recv_data.data() + sizeof(u16), recv_res - sizeof(u16));
-
-		std::lock_guard lock(s_rpcn_mutex);
-		rpcn_msgs.push_back(std::move(rpcn_msg));
-		return true;
-	}
-
-	if (dst_vport == 65535) // Reserved for signaling
-	{
-		std::vector<u8> sign_msg(recv_res - sizeof(u16));
-		memcpy(sign_msg.data(), p2p_recv_data.data() + sizeof(u16), recv_res - sizeof(u16));
-
-		std::pair<std::pair<u32, u16>, std::vector<u8>> msg;
-		msg.first.first  = reinterpret_cast<struct sockaddr_in*>(&native_addr)->sin_addr.s_addr;
-		msg.first.second = std::bit_cast<u16, be_t<u16>>(reinterpret_cast<struct sockaddr_in*>(&native_addr)->sin_port);
-		msg.second       = std::move(sign_msg);
-
+		if (recv_res < VPORT_0_HEADER_SIZE)
 		{
-			std::lock_guard lock(s_sign_mutex);
-			sign_msgs.push_back(std::move(msg));
+			sys_net.error("Bad vport 0 packet(no subset)!");
+			return true;
 		}
 
-		auto& sigh = g_fxo->get<named_thread<signaling_handler>>();
-		sigh.wake_up();
+		const u8 subset      = p2p_recv_data[2];
+		const auto data_size = recv_res - VPORT_0_HEADER_SIZE;
+		std::vector<u8> vport_0_data(p2p_recv_data.data() + VPORT_0_HEADER_SIZE, p2p_recv_data.data() + VPORT_0_HEADER_SIZE + data_size);
 
-		return true;
+		switch (subset)
+		{
+		case SUBSET_RPCN:
+		{
+			std::lock_guard lock(s_rpcn_mutex);
+			rpcn_msgs.push_back(std::move(vport_0_data));
+			return true;
+		}
+		case SUBSET_SIGNALING:
+		{
+			std::pair<std::pair<u32, u16>, std::vector<u8>> msg;
+			msg.first.first  = reinterpret_cast<struct sockaddr_in*>(&native_addr)->sin_addr.s_addr;
+			msg.first.second = std::bit_cast<u16, be_t<u16>>(reinterpret_cast<struct sockaddr_in*>(&native_addr)->sin_port);
+			msg.second       = std::move(vport_0_data);
+
+			{
+				std::lock_guard lock(s_sign_mutex);
+				sign_msgs.push_back(std::move(msg));
+			}
+
+			auto& sigh = g_fxo->get<named_thread<signaling_handler>>();
+			sigh.wake_up();
+			return true;
+		}
+		default:
+		{
+			sys_net.error("Invalid vport 0 subset!");
+			return true;
+		}
+		}
 	}
 
 	{

rpcs3/Emu/NP/generated/np2_structs.fbs

@@ -270,3 +270,11 @@ table SendMessageRequest {
     message:[uint8] (nested_flatbuffer: "MessageDetails");
     npids:[string];
 }
+
+table BoardInfo {
+    rankLimit:uint32;
+    updateMode:uint32;
+    sortMode:uint32;
+    uploadNumLimit:uint32;
+    uploadSizeLimit:uint32;
+}

rpcs3/Emu/NP/generated/np2_structs_generated.h

@@ -111,6 +111,9 @@ struct MessageDetailsBuilder;
 struct SendMessageRequest;
 struct SendMessageRequestBuilder;
 
+struct BoardInfo;
+struct BoardInfoBuilder;
+
 struct BinAttr FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef BinAttrBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -3460,4 +3463,85 @@ inline flatbuffers::Offset<SendMessageRequest> CreateSendMessageRequestDirect(
       npids__);
 }
 
+struct BoardInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef BoardInfoBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_RANKLIMIT = 4,
+    VT_UPDATEMODE = 6,
+    VT_SORTMODE = 8,
+    VT_UPLOADNUMLIMIT = 10,
+    VT_UPLOADSIZELIMIT = 12
+  };
+  uint32_t rankLimit() const {
+    return GetField<uint32_t>(VT_RANKLIMIT, 0);
+  }
+  uint32_t updateMode() const {
+    return GetField<uint32_t>(VT_UPDATEMODE, 0);
+  }
+  uint32_t sortMode() const {
+    return GetField<uint32_t>(VT_SORTMODE, 0);
+  }
+  uint32_t uploadNumLimit() const {
+    return GetField<uint32_t>(VT_UPLOADNUMLIMIT, 0);
+  }
+  uint32_t uploadSizeLimit() const {
+    return GetField<uint32_t>(VT_UPLOADSIZELIMIT, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint32_t>(verifier, VT_RANKLIMIT, 4) &&
+           VerifyField<uint32_t>(verifier, VT_UPDATEMODE, 4) &&
+           VerifyField<uint32_t>(verifier, VT_SORTMODE, 4) &&
+           VerifyField<uint32_t>(verifier, VT_UPLOADNUMLIMIT, 4) &&
+           VerifyField<uint32_t>(verifier, VT_UPLOADSIZELIMIT, 4) &&
+           verifier.EndTable();
+  }
+};
+
+struct BoardInfoBuilder {
+  typedef BoardInfo Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_rankLimit(uint32_t rankLimit) {
+    fbb_.AddElement<uint32_t>(BoardInfo::VT_RANKLIMIT, rankLimit, 0);
+  }
+  void add_updateMode(uint32_t updateMode) {
+    fbb_.AddElement<uint32_t>(BoardInfo::VT_UPDATEMODE, updateMode, 0);
+  }
+  void add_sortMode(uint32_t sortMode) {
+    fbb_.AddElement<uint32_t>(BoardInfo::VT_SORTMODE, sortMode, 0);
+  }
+  void add_uploadNumLimit(uint32_t uploadNumLimit) {
+    fbb_.AddElement<uint32_t>(BoardInfo::VT_UPLOADNUMLIMIT, uploadNumLimit, 0);
+  }
+  void add_uploadSizeLimit(uint32_t uploadSizeLimit) {
+    fbb_.AddElement<uint32_t>(BoardInfo::VT_UPLOADSIZELIMIT, uploadSizeLimit, 0);
+  }
+  explicit BoardInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<BoardInfo> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<BoardInfo>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<BoardInfo> CreateBoardInfo(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    uint32_t rankLimit = 0,
+    uint32_t updateMode = 0,
+    uint32_t sortMode = 0,
+    uint32_t uploadNumLimit = 0,
+    uint32_t uploadSizeLimit = 0) {
+  BoardInfoBuilder builder_(_fbb);
+  builder_.add_uploadSizeLimit(uploadSizeLimit);
+  builder_.add_uploadNumLimit(uploadNumLimit);
+  builder_.add_sortMode(sortMode);
+  builder_.add_updateMode(updateMode);
+  builder_.add_rankLimit(rankLimit);
+  return builder_.Finish();
+}
+
 #endif  // FLATBUFFERS_GENERATED_NP2STRUCTS_H_

rpcs3/Emu/NP/np_cache.cpp

@@ -218,7 +218,7 @@ namespace np
 			return SCE_NP_MATCHING2_ERROR_ROOM_MEMBER_NOT_FOUND;
 		}
 
-		const auto& room = rooms.at(room_id);
+		const auto& room   = rooms.at(room_id);
 		const auto& member = room.members.at(member_id);
 
 		if (ptr_member)
@@ -278,18 +278,18 @@ namespace np
 		if (num_binattrs)
 		{
 			ptr_member->roomMemberBinAttrInternal.set(mem.allocate(sizeof(SceNpMatching2RoomMemberBinAttrInternal) * num_binattrs));
-			ptr_member->roomMemberBinAttrInternalNum = num_binattrs;
+			ptr_member->roomMemberBinAttrInternalNum         = num_binattrs;
 			SceNpMatching2RoomMemberBinAttrInternal* bin_ptr = ptr_member->roomMemberBinAttrInternal.get_ptr();
 
 			u32 actual_cnt = 0;
 			for (u32 i = 0; i < binattrs_list.size(); i++)
 			{
 				if (member.bins.contains(binattrs_list[i]))
 				{
-					const auto& bin = member.bins.at(binattrs_list[i]);
+					const auto& bin                     = member.bins.at(binattrs_list[i]);
 					bin_ptr[actual_cnt].updateDate.tick = bin.updateDate.tick;
-					bin_ptr[actual_cnt].data.id = bin.id;
-					bin_ptr[actual_cnt].data.size = bin.data.size();
+					bin_ptr[actual_cnt].data.id         = bin.id;
+					bin_ptr[actual_cnt].data.size       = bin.data.size();
 					bin_ptr[actual_cnt].data.ptr.set(mem.allocate(bin.data.size()));
 					memcpy(bin_ptr[actual_cnt].data.ptr.get_ptr(), bin.data.data(), bin.data.size());
 					actual_cnt++;
@@ -299,4 +299,15 @@ namespace np
 
 		return needed_data_size;
 	}
+
+	SceNpId cache_manager::get_npid(u64 room_id, u16 member_id)
+	{
+		std::lock_guard lock(mutex);
+
+		ensure(rooms.contains(room_id), "cache_manager::get_npid: Room not cached!");
+		ensure(rooms.at(room_id).members.contains(member_id), "cache_manager::get_npid: Member not cached!");
+
+		return rooms.at(room_id).members.at(member_id).userInfo.npId;
+	}
+
 } // namespace np

rpcs3/Emu/NP/np_cache.h

@@ -75,6 +75,7 @@ namespace np
 		std::pair<error_code, std::vector<SceNpMatching2RoomMemberId>> get_memberids(u64 room_id, s32 sort_method);
 		std::pair<error_code, std::optional<SceNpMatching2SessionPassword>> get_password(SceNpMatching2RoomId room_id);
 		error_code get_member_and_attrs(SceNpMatching2RoomId room_id, SceNpMatching2RoomMemberId member_id, const std::vector<SceNpMatching2AttributeId>& binattrs_list, SceNpMatching2RoomMemberDataInternal* ptr_member, u32 addr_data, u32 size_data);
+		SceNpId get_npid(u64 room_id, u16 member_id);
 
 	private:
 		shared_mutex mutex;