?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
!I 1937152 from //dev_game_hunt/consoles_candidate: !B Remove allocations of unnecess...
[CRYENGINE.git] / Code / CryPlugins / CryLobby / Module / PSNOrbis / CryPSN2MatchMaking.cpp
blob37fa6f1247b78facb92775e443d819fc8c77d292
1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
2
3 #include "StdAfx.h"
4
5 #include "CrySharedLobbyPacket.h"
6
7 #if CRY_PLATFORM_ORBIS
8
9 #include "CryPSN2Lobby.h"
10 #include "CryPSN2Response.h"
11 #include "CryPSN2MatchMaking.h"
12
13 #if USE_PSN
14 #if USE_CRY_MATCHMAKING
15
16 #include <CryCore/CryEndian.h>
17 #include <CryGame/IGameFramework.h>
18
19 #include <libsysmodule.h>
20 #include "CryPSN2WebApi.h"
21 #include "CryPSN2WebApi_Session.h"
22
23 #define SIGNALING_TIMEOUT (15 * 1000) // 15 seconds using our own timeout code
24 #define PSN_MATCHMAKING_DEFAULT_UNKNOWN_PING (3000)
25
26 #define MAX_ROOMS_PER_WORLD (5000) //-- Max 5000 rooms available for one world
27
28 #define PSN_MATCHMAKING_PSNSUPPORT_LEAVE_REQUEST_SLOT (0)
29 #define PSN_MATCHMAKING_WEBAPI_LEAVE_REQUEST_SLOT (1)
30
31 #define PSN_MATCHMAKING_SEARCH_PARAMS_SLOT (0)
32 #define PSN_MATCHMAKING_SEARCH_DATA_SLOT (1)
33 #define PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT (2)
34 #define PSN_MATCHMAKING_PSNSUPPORT_SEARCH_QOS_SLOT (3)
35
36 #define PSN_MATCHMAKING_PSNSUPPORT_JOIN_REQUEST_SLOT (0)
37 #define PSN_MATCHMAKING_PSNSUPPORT_JOIN_RESPONSE_SLOT (1)
38 #define PSN_MATCHMAKING_WEBAPI_JOIN_SLOT (2)
39
40 #define PSN_MATCHMAKING_CREATE_PARAMS_SLOT (0)
41 #define PSN_MATCHMAKING_CREATE_DATA_SLOT (1)
42 #define PSN_MATCHMAKING_PSNSUPPORT_CREATE_REQUEST_SLOT (2)
43 #define PSN_MATCHMAKING_WEBAPI_CREATE_SLOT (3)
44
45 #define PSN_MATCHMAKING_UPDATE_DATA_SLOT (0)
46 #define PSN_MATCHMAKING_PSNSUPPORT_UPDATE_REQUEST_SLOT (1)
47
48 #define PSN_MATCHMAKING_USERDATA_DATA_SLOT (0)
49 #define PSN_MATCHMAKING_PSNSUPPORT_USERDATA_REQUEST_SLOT (1)
50
51 #define PSN_MATCHMAKING_PSNSUPPORT_QUERY_REQUEST_SLOT (0)
52 #define PSN_MATCHMAKING_PSNSUPPORT_QUERY_RESPONSE_SLOT (1)
53
54 #define PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_REQUEST_SLOT (0)
55 #define PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_RESTART (1)
56
57 #define PSN_MATCHMAKING_PSNSUPPORT_GRANTROOM_REQUEST_SLOT (0)
58
59 #define PSN_MATCHMAKING_PSNSUPPORT_UPDATEADVERT_REQUEST_SLOT (0)
60 #define PSN_MATCHMAKING_WEBAPI_UPDATEADVERT_REQUEST_SLOT (1)
61
62 #define PSN_MATCHMAKING_PSNSUPPORT_GETADVERT_REQUEST_SLOT (0)
63 #define PSN_MATCHMAKING_WEBAPI_GETADVERT_REQUEST_SLOT (1)
64 #define PSN_MATCHMAKING_WEBAPI_GETADVERT_RESPONSE_SLOT (2)
65
66 CryMatchMakingConnectionID CCryPSNMatchMaking::FindConnectionIDFromRoomMemberID(CryLobbySessionHandle sessionHandle, SceNpMatching2RoomMemberId memberId)
67 {
68 if ((sessionHandle != CryLobbyInvalidSessionHandle) && (memberId != INVALID_PSN_ROOM_MEMBER_ID))
69 {
70 SSession* pSession = &m_sessions[sessionHandle];
71 if (pSession->IsUsed())
72 {
73 for (uint32 a = 0; a < MAX_LOBBY_CONNECTIONS; a++)
74 {
75 SSession::SRConnection* pConnection = &pSession->remoteConnection[a];
76 if (pConnection->used && pConnection->registered && (pConnection->memberId == memberId))
77 {
78 return a;
79 }
80 }
81 }
82 }
83
84 return CryMatchMakingInvalidConnectionID;
85 }
86
87 CCryPSNMatchMaking::SSession::SRoomMember* CCryPSNMatchMaking::FindRoomMemberFromRoomMemberID(CryLobbySessionHandle sessionHandle, SceNpMatching2RoomMemberId memberId)
88 {
89 if ((sessionHandle != CryLobbyInvalidSessionHandle) && (memberId != INVALID_PSN_ROOM_MEMBER_ID))
90 {
91 SSession* pSession = &m_sessions[sessionHandle];
92 if (pSession->IsUsed())
93 {
94 for (uint32 a = 0; a < MAX_PSN_ROOM_MEMBERS; a++)
95 {
96 if (pSession->m_members[a].IsUsed() && (pSession->m_members[a].m_memberId == memberId))
97 {
98 return &pSession->m_members[a];
99 }
100 }
101 }
102 }
103
104 return NULL;
105 }
106
107 uint64 CCryPSNMatchMaking::GetSIDFromSessionHandle(CryLobbySessionHandle h)
108 {
109 CRY_ASSERT_MESSAGE((h < MAX_MATCHMAKING_SESSIONS) && m_sessions[h].IsUsed(), "CCryPSNMatchMaking::GetSIDFromSessionHandle: invalid session handle");
110
111 return m_sessions[h].m_roomId;
112 }
113
114 CrySessionID CCryPSNMatchMaking::SessionGetCrySessionIDFromCrySessionHandle(CrySessionHandle gh)
115 {
116 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
117
118 if ((h < MAX_MATCHMAKING_SESSIONS) && m_sessions[h].IsUsed())
119 {
120 SCryPSNSessionID* pID = new SCryPSNSessionID;
121
122 if (pID)
123 {
124 pID->m_sessionInfo.m_roomId = m_sessions[h].m_roomId;
125 pID->m_sessionInfo.m_worldId = m_sessions[h].m_worldId;
126 pID->m_sessionInfo.m_serverId = m_sessions[h].m_serverId;
127 pID->m_sessionInfo.m_gameType = m_sessions[h].m_gameType;
128 memcpy(&pID->m_sessionId, &m_sessions[h].m_sessionId, sizeof(pID->m_sessionId));
129 pID->m_fromInvite = false;
130
131 memcpy(&pID->m_sessionId, &m_sessions[h].m_sessionId, sizeof(SceNpSessionId));
132
133 return pID;
134 }
135 }
136
137 return NULL;
138 }
139
140 TNetAddress CCryPSNMatchMaking::GetHostAddressFromSessionHandle(CrySessionHandle gh)
141 {
142 LOBBY_AUTO_LOCK;
143
144 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
145 SSession* pSession = &m_sessions[h];
146
147 if (pSession->serverConnectionID != CryMatchMakingInvalidConnectionID)
148 {
149 const TNetAddress* pDedicatedServerAddr = m_lobby->GetNetAddress(pSession->remoteConnection[pSession->serverConnectionID].connectionID);
150
151 if (pDedicatedServerAddr)
152 {
153 return *pDedicatedServerAddr;
154 }
155 }
156
157 SSession::SRoomMember* pMember = FindRoomMemberFromRoomMemberID(h, pSession->m_ownerMemberId);
158 if (pSession->m_ownerMemberId == pSession->m_myMemberId)
159 {
160 return TNetAddress(TLocalNetAddress(m_lobby->GetInternalSocketPort(eCLS_Online)));
161 }
162
163 SIPv4Addr addr4;
164 addr4.addr = ntohl(pMember->m_peerAddr.s_addr);
165 addr4.port = ntohs(pMember->m_peerPort);
166
167 #if !ENABLE_PLATFORM_PROTOCOL
168 if (m_pService)
169 {
170 uint16 connectPort, listenPort;
171 m_pService->GetSocketPorts(connectPort, listenPort);
172 addr4.port = ntohs(connectPort);
173 }
174 #endif
175
176 return TNetAddress(addr4);
177 }
178
179 void CCryPSNMatchMaking::SessionDisconnectRemoteConnection(CrySessionHandle gh, const TNetAddress& addr)
180 {
181 // At present i don't need to worry about this
182 }
183
184 void CCryPSNMatchMaking::FreeRemoteConnection(CryLobbySessionHandle h, CryMatchMakingConnectionID id)
185 {
186 if (id != CryMatchMakingInvalidConnectionID)
187 {
188 SSession* pSession = &m_sessions[h];
189 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
190
191 if (pConnection->used)
192 {
193 SessionUserDataEvent(eCLSE_SessionUserLeave, h, id);
194
195 CCryMatchMaking::FreeRemoteConnection(h, id);
196
197 pConnection->registered = false;
198 pConnection->memberId = INVALID_PSN_ROOM_MEMBER_ID;
199 }
200 }
201 }
202
203 uint32 CCryPSNMatchMaking::GetSessionIDSizeInPacket() const
204 {
205 return sizeof(SSynchronisedSessionID);
206 }
207
208 ECryLobbyError CCryPSNMatchMaking::WriteSessionIDToPacket(CrySessionID sessionId, CCryLobbyPacket* pPacket) const
209 {
210 if (pPacket)
211 {
212 SCryPSNSessionID blank;
213
214 if (sessionId != CrySessionInvalidID)
215 {
216 SCryPSNSessionID* psnID = (SCryPSNSessionID*)sessionId.get();
217 if (psnID)
218 {
219 pPacket->WriteData(&psnID->m_sessionInfo, sizeof(psnID->m_sessionInfo));
220 }
221 else
222 {
223 pPacket->WriteData(&blank.m_sessionInfo, sizeof(blank.m_sessionInfo));
224 }
225 }
226 else
227 {
228 pPacket->WriteData(&blank.m_sessionInfo, sizeof(blank.m_sessionInfo));
229 }
230
231 return eCLE_Success;
232 }
233
234 return eCLE_InternalError;
235 }
236
237 CrySessionID CCryPSNMatchMaking::ReadSessionIDFromPacket(CCryLobbyPacket* pPacket) const
238 {
239 if (pPacket)
240 {
241 CrySessionID returnId = new SCryPSNSessionID;
242 SCryPSNSessionID* psnID = (SCryPSNSessionID*)returnId.get();
243 if (psnID)
244 {
245 SCryPSNSessionID blank;
246
247 pPacket->ReadData(&psnID->m_sessionInfo, sizeof(psnID->m_sessionInfo));
248
249 //-- Cannot use the SCryPSNSessionID equals operator because we write more than just the roomId to the packet
250 //-- to signify a null session ID.
251 if ((psnID->m_sessionInfo.m_roomId != blank.m_sessionInfo.m_roomId) ||
252 (psnID->m_sessionInfo.m_worldId != blank.m_sessionInfo.m_worldId) ||
253 (psnID->m_sessionInfo.m_serverId != blank.m_sessionInfo.m_serverId) ||
254 (psnID->m_sessionInfo.m_gameType != blank.m_sessionInfo.m_gameType))
255 {
256 //-- assume it's a valid session id if any field does not match the blank
257 return returnId;
258 }
259 }
260 }
261
262 return CrySessionInvalidID;
263 }
264
265 void CCryPSNMatchMaking::DumpMemberInfo(SSession::SRoomMember* pMember)
266 {
267 #if !defined(_RELEASE) || defined(RELEASE_LOGGING)
268 NetLog("%s , uid %d , %d.%d.%d.%d:%d",
269 pMember->m_npId.handle.data,
270 pMember->m_memberId,
271 (pMember->m_peerAddr.s_addr >> 24) & 0xFF, (pMember->m_peerAddr.s_addr >> 16) & 0xFF, (pMember->m_peerAddr.s_addr >> 8) & 0xFF, (pMember->m_peerAddr.s_addr) & 0xFF,
272 pMember->m_peerPort);
273 #endif // #if !defined(_RELEASE) || defined(RELEASE_LOGGING)
274 }
275
276 void CCryPSNMatchMaking::ClearRoomMember(CryLobbySessionHandle sessionHandle, uint32 nMember)
277 {
278 if (sessionHandle != CryLobbyInvalidSessionHandle)
279 {
280 SSession* pSession = &m_sessions[sessionHandle];
281 SSession::SRoomMember* pMember = &pSession->m_members[nMember];
282
283 if (pMember->IsUsed())
284 {
285 if (pMember->IsValid(ePSNMI_Other))
286 {
287 // Remove the player (if we have connection information we will need to drop that here too)
288 CryMatchMakingConnectionID id = FindConnectionIDFromRoomMemberID(sessionHandle, pMember->m_memberId);
289 if (id != CryMatchMakingInvalidConnectionID)
290 {
291 // This disconnect should be treated as if it came from the host.
292 SessionDisconnectRemoteConnectionViaNub(sessionHandle, id, eDS_FromID, pSession->hostConnectionID, eDC_Unknown, "Clear Room Member");
293 }
294 }
295
296 pMember->m_signalingState = ePSNCS_None;
297 pMember->m_memberId = INVALID_PSN_ROOM_MEMBER_ID;
298 pMember->m_valid = ePSNMI_None;
299 pMember->m_bHostJoinAck = false;
300 memset(pMember->m_userData, 0, sizeof(pMember->m_userData));
301 }
302 }
303 }
304
305 void CCryPSNMatchMaking::AddRoomMember(CryLobbySessionHandle sessionHandle, const SCryPSNRoomMemberDataInternal& memberInfo, ECryPSNMemberInfo info)
306 {
307 if (sessionHandle != CryLobbyInvalidSessionHandle)
308 {
309 SSession* pSession = &m_sessions[sessionHandle];
310 if (pSession->IsUsed())
311 {
312 SSession::SRoomMember* pMember = NULL;
313
314 for (uint32 a = 0; a < MAX_PSN_ROOM_MEMBERS; a++)
315 {
316 if (pSession->m_members[a].IsUsed())
317 {
318 if (pSession->m_members[a].m_memberId == memberInfo.m_memberId)
319 {
320 //-- already exists!
321 CRY_ASSERT_MESSAGE(pSession->m_members[a].m_memberId != memberInfo.m_memberId, "Adding a room member who already exists!");
322 return;
323 }
324 }
325 else
326 {
327 if (pMember == NULL)
328 {
329 pMember = &pSession->m_members[a];
330 }
331 }
332 }
333
334 if (pMember)
335 {
336 pMember->m_npId = memberInfo.m_npId;
337 pMember->m_memberId = memberInfo.m_memberId;
338 pMember->m_valid = info;
339 pMember->m_signalingState = ePSNCS_None;
340 pMember->m_bHostJoinAck = false;
341
342 if (memberInfo.m_numBinAttributes > 0)
343 {
344 memcpy(pMember->m_userData, memberInfo.m_binAttributes[0].m_data, CRYLOBBY_USER_DATA_SIZE_IN_BYTES);
345 }
346
347 if (pMember->IsValid(ePSNMI_Me))
348 {
349 pSession->m_myMemberId = pMember->m_memberId;
350
351 pSession->localConnection.uid.m_uid = pMember->m_memberId;
352 pSession->localConnection.uid.m_sid = pSession->m_roomId;
353 }
354
355 if (pMember->IsValid(ePSNMI_Owner))
356 {
357 pSession->m_ownerMemberId = pMember->m_memberId;
358 }
359
360 if (pMember->IsValid(ePSNMI_Other))
361 {
362 // We don't have connection information yet (ip / port etc)
363 SCryMatchMakingConnectionUID matchingUID;
364
365 matchingUID.m_uid = pMember->m_memberId;
366 matchingUID.m_sid = pSession->m_roomId;
367
368 CryMatchMakingConnectionID id = CCryMatchMaking::AddRemoteConnection(sessionHandle, CryLobbyInvalidConnectionID, matchingUID, 1);
369 if (id != CryMatchMakingInvalidConnectionID)
370 {
371 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
372
373 // pConnection->flags |= CMMRC_FLAG_PLATFORM_DATA_VALID;
374 pConnection->registered = true;
375 pConnection->connectionID = CryLobbyInvalidConnectionID;
376 pConnection->memberId = pMember->m_memberId;
377
378 if ((pSession->localFlags & CRYSESSION_LOCAL_FLAG_HOST) != CRYSESSION_LOCAL_FLAG_HOST)
379 {
380 if (!pMember->IsValid(ePSNMI_Owner))
381 {
382 //-- If person being added is not the owner, and I am not the owner, send a user joined event to the game immediately -
383 //-- there is no need to wait for signaling to establish.
384 //-- This should allow peers behind strict firewalls to see each other joining
385 //-- but still ensure clients are only added to the server when the signaling establishes.
386 DumpMemberInfo(pMember);
387 AddVoiceUser(pMember);
388 SessionUserDataEvent(eCLSE_SessionUserJoin, sessionHandle, id);
389 }
390 }
391 }
392
393 //-- Not me, and no peer state defined yet, so lets kick off a peer connection test for this member
394 pMember->m_signalingState = ePSNCS_Pending;
395 pMember->m_signalingTimer = g_time;
396 }
397 }
398 }
399 }
400 }
401
402 void CCryPSNMatchMaking::RemoveRoomMember(CryLobbySessionHandle sessionHandle, const SCryPSNRoomMemberDataInternal& memberInfo)
403 {
404 if (sessionHandle != CryLobbyInvalidSessionHandle)
405 {
406 SSession* pSession = &m_sessions[sessionHandle];
407 if (pSession->IsUsed())
408 {
409 for (uint32 a = 0; a < MAX_PSN_ROOM_MEMBERS; a++)
410 {
411 SSession::SRoomMember* pMember = &pSession->m_members[a];
412
413 if (pMember->IsUsed() && (sceNpCmpNpId(&pMember->m_npId, &memberInfo.m_npId) == 0))
414 {
415 ClearRoomMember(sessionHandle, a);
416 return;
417 }
418 }
419 }
420 }
421 }
422
423 void CCryPSNMatchMaking::UpdateRoomMember(CryLobbySessionHandle sessionHandle, const SCryPSNRoomMemberDataInternal& updatedMemberInfo)
424 {
425 if (sessionHandle != CryLobbyInvalidSessionHandle)
426 {
427 SSession* pSession = &m_sessions[sessionHandle];
428 if (pSession->IsUsed())
429 {
430 for (uint32 a = 0; a < MAX_PSN_ROOM_MEMBERS; a++)
431 {
432 SSession::SRoomMember* pMember = &pSession->m_members[a];
433
434 if (pMember->m_valid && (pMember->m_memberId == updatedMemberInfo.m_memberId))
435 {
436 if (updatedMemberInfo.m_numBinAttributes > 0)
437 {
438 memcpy(pMember->m_userData, updatedMemberInfo.m_binAttributes[0].m_data, CRYLOBBY_USER_DATA_SIZE_IN_BYTES);
439 }
440
441 CryMatchMakingConnectionID id = FindConnectionIDFromRoomMemberID(sessionHandle, pMember->m_memberId);
442 SessionUserDataEvent(eCLSE_SessionUserUpdate, sessionHandle, id);
443
444 return;
445 }
446 }
447 }
448 }
449 }
450
451 void CCryPSNMatchMaking::ClearSessionInfo(CryLobbySessionHandle sessionHandle)
452 {
453 assert(sessionHandle != CryLobbyInvalidSessionHandle);
454
455 if (sessionHandle != CryLobbyInvalidSessionHandle)
456 {
457 SSession* pSession = &m_sessions[sessionHandle];
458
459 if (pSession->IsUsed() && (pSession->m_roomId != INVALID_PSN_ROOM_ID))
460 {
461 SceNpMatching2RequestId IDontCareReqId;
462 SceNpMatching2LeaveRoomRequest IDontCareLeaveParam;
463
464 memset(&IDontCareLeaveParam, 0, sizeof(SceNpMatching2LeaveRoomRequest));
465 IDontCareLeaveParam.roomId = pSession->m_roomId;
466
467 sceNpMatching2LeaveRoom(m_pPSNSupport->GetMatchmakingContextId(), &IDontCareLeaveParam, NULL, &IDontCareReqId);
468 if (pSession->m_sessionId.data[0] != 0)
469 {
470 // TODO: the only trouble here is that leaveSessionParamsHdl needs to be allocated, but when do we free it? There's no task to complete!
471 // m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::LeaveSession, leaveSessionParamsHdl);
472 }
473 }
474
475 for (uint32 a = 0; a < MAX_PSN_ROOM_MEMBERS; a++)
476 {
477 ClearRoomMember(sessionHandle, a);
478 }
479 }
480 }
481
482 void CCryPSNMatchMaking::AddInitialRoomMembers(CryLobbySessionHandle sessionHandle, const SCryPSNRoomMemberDataInternalList& memberList)
483 {
484 if (sessionHandle != CryLobbyInvalidSessionHandle)
485 {
486 SSession* pSession = &m_sessions[sessionHandle];
487 if (pSession->IsUsed())
488 {
489 for (uint32 a = 0; a < memberList.m_numRoomMembers; a++)
490 {
491 SCryPSNRoomMemberDataInternal& memberInfo = memberList.m_pRoomMembers[a];
492 uint32 info = ePSNMI_None;
493
494 if (a == memberList.m_owner)
495 {
496 info |= ePSNMI_Owner;
497 }
498
499 if (a == memberList.m_me)
500 {
501 info |= ePSNMI_Me;
502 }
503 else
504 {
505 info |= ePSNMI_Other;
506 }
507
508 AddRoomMember(sessionHandle, memberInfo, (ECryPSNMemberInfo)info);
509 }
510 }
511 }
512 }
513
514 void CCryPSNMatchMaking::DispatchRoomOwnerChangedEvent(TMemHdl mh)
515 {
516 UCryLobbyEventData eventData;
517 eventData.pRoomOwnerChanged = (SCryLobbyRoomOwnerChanged*)m_lobby->MemGetPtr(mh);
518
519 m_lobby->DispatchEvent(eCLSE_RoomOwnerChanged, eventData);
520
521 m_lobby->MemFree(mh);
522 }
523
524 void CCryPSNMatchMaking::ChangeRoomOwner(CryLobbySessionHandle sessionHandle, SceNpMatching2RoomMemberId prevOwner, SceNpMatching2RoomMemberId newOwner)
525 {
526 if (sessionHandle != CryLobbyInvalidSessionHandle)
527 {
528 SSession* pSession = &m_sessions[sessionHandle];
529 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_USED)
530 {
531 SSession::SRoomMember* pMember = NULL;
532
533 pSession->m_ownerMemberId = newOwner;
534
535 //-- remove the old room owner
536 for (uint32 a = 0; a < MAX_PSN_ROOM_MEMBERS; a++)
537 {
538 pMember = &pSession->m_members[a];
539 if (pMember->m_valid)
540 {
541 if (pMember->m_memberId == prevOwner)
542 {
543 assert(pMember->m_valid & ePSNMI_Owner);
544
545 if (pMember->m_valid & ePSNMI_Me)
546 {
547 pMember->m_valid = ePSNMI_Me;
548 }
549 else
550 {
551 pMember->m_valid = ePSNMI_Other;
552 }
553 }
554
555 if (pMember->m_memberId == newOwner)
556 {
557 if (pMember->m_valid & ePSNMI_Me)
558 {
559 pMember->m_valid = ePSNMI_MeOwner;
560 }
561 else
562 {
563 pMember->m_valid = ePSNMI_OtherOwner;
564 }
565 }
566 }
567 }
568
569 #if NETWORK_HOST_MIGRATION
570 CryLobbySessionHandle h;
571
572 SCryMatchMakingConnectionUID matchingUID;
573
574 matchingUID.m_uid = newOwner;
575 matchingUID.m_sid = pSession->m_roomId;
576
577 FindConnectionFromUID(matchingUID, &h, &pSession->hostConnectionID); // It is valid for the h to be invalid (basically if hostConnectionID comes back with 0 we don't have any remotes - thats allowed!)
578
579 // Ensure we're migrating the session (covers catastrophic migration, and migration within migration)
580 HostMigrationInitiate(sessionHandle, eDC_Unknown);
581 pSession->hostMigrationInfo.m_newHostAddressValid = true;
582 pSession->newHostUID = matchingUID;
583
584 SSession::SRoomMember* pRoomMember = FindRoomMemberFromRoomMemberID(sessionHandle, newOwner);
585
586 if (pRoomMember)
587 {
588 if (pRoomMember->IsValid(ePSNMI_Other) && (pRoomMember->m_signalingState == ePSNCS_Active))
589 {
590 if (m_lobby)
591 {
592 TMemHdl mh = m_lobby->MemAlloc(sizeof(SCryLobbyRoomOwnerChanged));
593 if (mh != TMemInvalidHdl)
594 {
595 SCryLobbyRoomOwnerChanged* pOwnerData = (SCryLobbyRoomOwnerChanged*)m_lobby->MemGetPtr(mh);
596
597 pOwnerData->m_session = CreateGameSessionHandle(sessionHandle, pSession->localConnection.uid);
598 pOwnerData->m_port = pRoomMember->m_peerPort;
599 pOwnerData->m_ip = pRoomMember->m_peerAddr.s_addr;
600
601 TO_GAME_FROM_LOBBY(&CCryPSNMatchMaking::DispatchRoomOwnerChangedEvent, this, mh);
602 }
603 }
604 }
605 }
606 #endif
607 }
608 }
609 }
610
611 void CCryPSNMatchMaking::UpdateSignaling(CryMatchMakingTaskID mmTaskID)
612 {
613 STask* pTask = &m_task[mmTaskID];
614
615 if (pTask->used && pTask->running && (pTask->session != CryLobbyInvalidSessionHandle))
616 {
617 SSession* pSession = &m_sessions[pTask->session];
618 if (pSession->IsUsed())
619 {
620 for (uint32 a = 0; a < MAX_PSN_ROOM_MEMBERS; a++)
621 {
622 SSession::SRoomMember* pMember = &pSession->m_members[a];
623
624 if (pMember->IsUsed())
625 {
626 //-- Timed out?
627 bool bTestTimeout = false;
628
629 if (pMember->m_signalingState == ePSNCS_Pending)
630 {
631 bTestTimeout = true;
632 }
633 else
634 {
635 if ((pTask->startedTask == eT_SessionJoin) && pMember->IsValid(ePSNMI_Owner) && (pMember->m_signalingState == ePSNCS_Active) && (pMember->m_bHostJoinAck == false))
636 {
637 bTestTimeout = true;
638 }
639 }
640
641 if (bTestTimeout)
642 {
643 if ((g_time.GetMilliSecondsAsInt64() - pMember->m_signalingTimer.GetMilliSecondsAsInt64()) > SIGNALING_TIMEOUT)
644 {
645 pMember->m_signalingState = ePSNCS_Dead;
646
647 CryMatchMakingConnectionID id = FindConnectionIDFromRoomMemberID(pTask->session, pMember->m_memberId);
648 if (id != CryMatchMakingInvalidConnectionID)
649 {
650 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
651 NetLog("[Lobby] CCryPSNMatchMaking::UpdateSignaling() : Signaling dead event setting connection " PRFORMAT_LCID " to eCLCS_NotConnected", PRARG_LCID(pConnection->connectionID));
652 m_lobby->ConnectionSetState(pConnection->connectionID, eCLCS_NotConnected);
653 }
654 }
655 }
656 }
657 }
658 }
659 }
660 }
661
662 CCryPSNMatchMaking::ECryPSNConnectionState CCryPSNMatchMaking::CheckSignaling(CryMatchMakingTaskID mmTaskID)
663 {
664 STask* pTask = &m_task[mmTaskID];
665
666 if (pTask->used && pTask->running && (pTask->session != CryLobbyInvalidSessionHandle))
667 {
668 SSession* pSession = &m_sessions[pTask->session];
669 if (pSession->IsUsed())
670 {
671 //-- If we can talk to the room owner, we'll allow the session state machine to run
672 for (uint32 a = 0; a < MAX_PSN_ROOM_MEMBERS; a++)
673 {
674 SSession::SRoomMember* pMember = &pSession->m_members[a];
675
676 if (pMember->IsValid(ePSNMI_Owner))
677 {
678 //-- Are we the owner?
679 if (pMember->IsValid(ePSNMI_Me))
680 {
681 //-- technically, 'me' always has a signaling state of ePSNMI_None, so we'll fake it just for this return.
682 return ePSNCS_Active;
683 }
684
685 //-- Is peer connection to remote owner active?
686 if (pMember->m_signalingState == ePSNCS_Active)
687 {
688 if (pMember->m_bHostJoinAck)
689 {
690 return ePSNCS_Active;
691 }
692 else
693 {
694 return ePSNCS_Pending;
695 }
696 }
697
698 return pMember->m_signalingState;
699 }
700 }
701 }
702 }
703
704 //-- No owner at all! This is wrong!
705 return ePSNCS_None;
706 }
707
708 bool CCryPSNMatchMaking::ProcessCorrectTaskForRequest(SCryPSNSupportCallbackEventData& data, ETask subTaskCheck, const char* pRequestString, EventRequestResponseCallback pCB)
709 {
710 for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; i++)
711 {
712 STask* pTask = &m_task[i];
713 if (pTask->used && pTask->running)
714 {
715 if (pTask->m_reqId == data.m_requestEvent.m_reqId)
716 {
717 bool bHandled = false;
718
719 if (pTask->subTask == subTaskCheck)
720 {
721 bHandled = pCB(this, pTask, i, data);
722
723 if (bHandled)
724 {
725 data.m_requestEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRequestEvent::REQUEST_EVENT_HANDLED;
726 }
727 else
728 {
729 data.m_requestEvent.m_returnFlags = SCryPSNSupportCallbackEventData::SRequestEvent::REQUEST_EVENT_NOT_HANDLED;
730
731 // a task was found, but not handled. mark the task with an error so it stops itself
732
733 // Some generic behaviours for non-critical errors
734 switch (data.m_requestEvent.m_error)
735 {
736 case SCE_NP_MATCHING2_ERROR_ROOM_NOT_FOUND:
737 case SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_ROOM:
738 case SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_ROOM_INSTANCE:
739 {
740 UpdateTaskError(i, eCLE_RoomDoesNotExist);
741 data.m_requestEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRequestEvent::REQUEST_EVENT_HANDLED;
742 }
743 break;
744 case SCE_NP_MATCHING2_SERVER_ERROR_ROOM_FULL:
745 {
746 UpdateTaskError(i, eCLE_SessionFull);
747 data.m_requestEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRequestEvent::REQUEST_EVENT_HANDLED;
748 }
749 break;
750 default:
751 {
752 UpdateTaskError(i, eCLE_InternalError);
753 // If we leave it unhandled, PSNSupport will attempt to handle any critical errors for us
754 }
755 break;
756 }
757 }
758
759 pTask->m_reqId = INVALID_PSN_REQUEST_ID;
760
761 if (pTask->error != eCLE_Success)
762 {
763 StopTaskRunning(i);
764 }
765
766 return bHandled;
767 }
768 }
769 }
770 }
771
772 NetLog("%s event received, but no tasks in correct state to process it!", pRequestString);
773 return false;
774 }
775
776 bool CCryPSNMatchMaking::ProcessCorrectTaskForSearch(SCryPSNSupportCallbackEventData& data, ETask subTaskCheck, const char* pRequestString, EventRequestResponseCallback pCB)
777 {
778 for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; i++)
779 {
780 STask* pTask = &m_task[i];
781 if (pTask->used && pTask->running)
782 {
783 if (pTask->subTask == subTaskCheck)
784 {
785 assert(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT] != TMemInvalidHdl);
786
787 SSearchInfoData* pSearchInfo = (SSearchInfoData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT]);
788 if (pSearchInfo)
789 {
790 for (int a = 0; a < pSearchInfo->m_numResults; a++)
791 {
792 if (data.m_requestEvent.m_reqId == pSearchInfo->m_reqId[a])
793 {
794 pTask->m_reqId = data.m_requestEvent.m_reqId;
795
796 bool bHandled = pCB(this, pTask, i, data);
797
798 if (bHandled)
799 {
800 data.m_requestEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRequestEvent::REQUEST_EVENT_HANDLED;
801 }
802 else
803 {
804 data.m_requestEvent.m_returnFlags = SCryPSNSupportCallbackEventData::SRequestEvent::REQUEST_EVENT_NOT_HANDLED;
805
806 // a task was found, but not handled, stop the task.
807 // If we leave it unhandled, the PSNSupport will attempt to handle any critical errors for us
808 UpdateTaskError(i, eCLE_InternalError);
809 }
810
811 pTask->m_reqId = INVALID_PSN_REQUEST_ID;
812
813 if (pTask->error != eCLE_Success)
814 {
815 StopTaskRunning(i);
816 }
817
818 return bHandled;
819 }
820 }
821 }
822 else
823 {
824 // no search info
825 NetLog("%s event received, task %d found with correct subtask %d, but no pSearchInfo!", pRequestString, i, subTaskCheck);
826 UpdateTaskError(i, eCLE_OutOfMemory);
827 StopTaskRunning(i);
828 return false;
829 }
830 }
831 }
832 }
833
834 NetLog("%s event received, but no tasks in correct state to process it!", pRequestString);
835 return false;
836 }
837
838 void CCryPSNMatchMaking::ProcessRequestEvent(SCryPSNSupportCallbackEventData& data)
839 {
840 switch (data.m_requestEvent.m_event)
841 {
842 case REQUEST_EVENT_GET_WORLD_INFO_LIST:
843 {
844 if (!ProcessCorrectTaskForRequest(data, eST_WaitingForCreateRoomWorldInfo, "REQUEST_EVENT_GET_WORLD_INFO_LIST", EventRequestResponse_GetWorldInfoListForCreate))
845 {
846 NetLog("Not a create, so trying search instead...");
847 if (!ProcessCorrectTaskForRequest(data, eST_WaitingForSearchRoomWorldInfo, "REQUEST_EVENT_GET_WORLD_INFO_LIST", EventRequestResponse_GetWorldInfoListForSearch))
848 {
849 NetLog("Not a search either! Time to trigger unhandled REQUEST_EVENT_GET_WORLD_INFO_LIST!");
850 }
851 }
852 }
853 break;
854 case REQUEST_EVENT_LEAVE_ROOM:
855 {
856 ProcessCorrectTaskForRequest(data, eST_WaitingForLeaveRoomRequestCallback, "REQUEST_EVENT_LEAVE_ROOM", EventRequestResponse_LeaveRoom);
857 }
858 break;
859 case REQUEST_EVENT_SET_ROOM_MEMBER_DATA_INTERNAL:
860 {
861 ProcessCorrectTaskForRequest(data, eST_WaitingForUserDataRequestCallback, "REQUEST_EVENT_SET_ROOM_MEMBER_DATA_INTERNAL", EventRequestResponse_SetRoomMemberDataInternal);
862 }
863 break;
864 case REQUEST_EVENT_SET_ROOM_DATA_EXTERNAL:
865 {
866 ProcessCorrectTaskForRequest(data, eST_WaitingForUpdateRoomRequestCallback, "REQUEST_EVENT_SET_ROOM_DATA_EXTERNAL", EventRequestResponse_SetRoomDataExternal);
867 }
868 break;
869 case REQUEST_EVENT_SET_ROOM_DATA_INTERNAL:
870 {
871 #if NETWORK_HOST_MIGRATION
872 ProcessCorrectTaskForRequest(data, eST_WaitingForNewHostHintCallback, "REQUEST_EVENT_SET_ROOM_DATA_INTERNAL", EventRequestResponse_SetRoomDataInternal);
873 #endif
874 }
875 break;
876 case REQUEST_EVENT_GET_ROOM_DATA_EXTERNAL_LIST:
877 {
878 ProcessCorrectTaskForRequest(data, eST_WaitingForQueryRoomRequestCallback, "REQUEST_EVENT_GET_ROOM_DATA_EXTERNAL_LIST", EventRequestResponse_GetRoomDataExternalList);
879 }
880 break;
881 case REQUEST_EVENT_SEARCH_ROOM:
882 {
883 ProcessCorrectTaskForRequest(data, eST_WaitingForSearchRoomRequestCallback, "REQUEST_EVENT_SEARCH_ROOM", EventRequestResponse_SearchRoom);
884 }
885 break;
886 case REQUEST_EVENT_SIGNALING_GET_PING_INFO:
887 {
888 ProcessCorrectTaskForSearch(data, eST_WaitingForSearchQOSRequestCallback, "REQUEST_EVENT_SIGNALING_GET_PING_INFO", EventRequestResponse_SearchQOS);
889 }
890 break;
891 case REQUEST_EVENT_JOIN_ROOM:
892 {
893 ProcessCorrectTaskForRequest(data, eST_WaitingForJoinRoomRequestCallback, "REQUEST_EVENT_JOIN_ROOM", EventRequestResponse_JoinRoom);
894 }
895 break;
896 case REQUEST_EVENT_CREATE_JOIN_ROOM:
897 {
898 ProcessCorrectTaskForRequest(data, eST_WaitingForCreateRoomRequestCallback, "REQUEST_EVENT_CREATE_JOIN_ROOM", EventRequestResponse_CreateRoom);
899 }
900 break;
901 case REQUEST_EVENT_GRANT_ROOM_OWNER:
902 {
903 #if NETWORK_HOST_MIGRATION
904 ProcessCorrectTaskForRequest(data, eST_WaitingForGrantRoomOwnerRequestCallback, "REQUEST_EVENT_GRANT_ROOM_OWNER", EventRequestResponse_GrantRoomOwner);
905 #endif
906 }
907 break;
908 default:
909 break;
910 } //-- switch
911 }
912
913 void CCryPSNMatchMaking::ProcessSignalingEvent(SCryPSNSupportCallbackEventData& data)
914 {
915 for (uint32 i = 0; i < MAX_MATCHMAKING_SESSIONS; i++)
916 {
917 SSession* pSession = &m_sessions[i];
918
919 if (pSession->IsUsed())
920 {
921 SSession::SRoomMember* pMember = FindRoomMemberFromRoomMemberID(i, data.m_signalEvent.m_subject);
922 if (pMember && pMember->IsValid(ePSNMI_Other) && (pMember->m_signalingState != ePSNCS_None))
923 {
924 switch (data.m_signalEvent.m_event)
925 {
926 case SIGNALING_EVENT_DEAD:
927 {
928 pMember->m_signalingState = ePSNCS_Dead;
929
930 DumpMemberInfo(pMember);
931 CryMatchMakingConnectionID id = FindConnectionIDFromRoomMemberID(i, pMember->m_memberId);
932 if (id != CryMatchMakingInvalidConnectionID)
933 {
934 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
935 NetLog("[Lobby] CCryPSNMatchMaking::ProcessSignalingEvent() : SCE_NP_SIGNALING_EVENT_DEAD : Signaling dead event setting connection " PRFORMAT_LCID " to eCLCS_NotConnected", PRARG_LCID(pConnection->connectionID));
936 NetLog("[Lobby] Signaling ID %d: SIGNALING_EVENT_DEAD not handled: error %08X", data.m_signalEvent.m_subject, data.m_signalEvent.m_error);
937 m_lobby->ConnectionSetState(pConnection->connectionID, eCLCS_NotConnected);
938 }
939
940 data.m_signalEvent.m_bHandled = true;
941 }
942 break;
943
944 case SIGNALING_EVENT_CONNECTED:
945 {
946 int conStatus;
947 int ret = sceNpMatching2SignalingGetConnectionStatus(m_pPSNSupport->GetMatchmakingContextId(), data.m_signalEvent.m_roomId, data.m_signalEvent.m_subject, &conStatus, (SceNetInAddr*)&pMember->m_peerAddr, &pMember->m_peerPort);
948 if ((ret == PSN_OK) && (conStatus == SCE_NP_MATCHING2_SIGNALING_CONN_STATUS_ACTIVE))
949 {
950 pMember->m_signalingState = ePSNCS_Active;
951
952 CryMatchMakingConnectionID id = FindConnectionIDFromRoomMemberID(i, pMember->m_memberId);
953 if (id != CryMatchMakingInvalidConnectionID)
954 {
955 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
956
957 if (pConnection->connectionID == CryLobbyInvalidConnectionID)
958 {
959 TNetAddress netAddr = TNetAddress(SIPv4Addr(ntohl(pMember->m_peerAddr.s_addr), ntohs(pMember->m_peerPort)));
960
961 #if !ENABLE_PLATFORM_PROTOCOL
962 if (m_pService)
963 {
964 uint16 connectPort, listenPort;
965
966 m_pService->GetSocketPorts(connectPort, listenPort);
967 netAddr = TNetAddress(SIPv4Addr(ntohl(pMember->m_peerAddr.s_addr), connectPort));
968 }
969 #endif
970 // Add connection - if not found
971 CryLobbyConnectionID lID = m_lobby->FindConnection(netAddr);
972 if (lID == CryLobbyInvalidConnectionID)
973 {
974 lID = m_lobby->CreateConnection(netAddr);
975 }
976 else
977 {
978 if (m_lobby->ConnectionGetState(lID) == eCLCS_Freeing)
979 {
980 NetLog("[Lobby] Signaling active on existing Freeing connection " PRFORMAT_LCID, PRARG_LCID(lID));
981 m_lobby->FreeConnection(lID);
982 lID = m_lobby->CreateConnection(netAddr);
983 }
984 }
985
986 m_lobby->ConnectionAddRef(lID);
987 pConnection->connectionID = lID;
988
989 DumpMemberInfo(pMember);
990 NetLog("[Lobby] CCryPSNMatchMaking::ProcessSignalingEvent() : SIGNALING_EVENT_CONNECTED : Signaling established for " PRFORMAT_SHMMCINFO, PRARG_SHMMCINFO(CryLobbySessionHandle(i), id, pConnection->connectionID, pConnection->uid));
991
992 AddVoiceUser(pMember);
993 SessionUserDataEvent(eCLSE_SessionUserJoin, i, id);
994
995 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_HOST)
996 {
997 // Include the SceNpSessionId the host got from registering the session on PSN when room was created.
998 // Pass this over to all connecting clients so they can join the same session
999 const uint32 maxBufferSize = CryLobbyPacketHeaderSize + sizeof(SceNpSessionId);
1000 uint8 buffer[maxBufferSize];
1001 CCryLobbyPacket packet;
1002
1003 packet.SetWriteBuffer(buffer, maxBufferSize);
1004 packet.StartWrite(ePSNPT_JoinSessionAck, true);
1005 packet.WriteString((const char*)&pSession->m_sessionId, sizeof(SceNpSessionId));
1006
1007 Send(CryMatchMakingInvalidTaskID, &packet, i, id);
1008 }
1009 }
1010 }
1011 }
1012 else if (ret < PSN_OK)
1013 {
1014 NetLog("sceNpMatching2SignalingGetConnectionStatus : %08X", ret);
1015
1016 pMember->m_signalingState = ePSNCS_Dead;
1017
1018 CryMatchMakingConnectionID id = FindConnectionIDFromRoomMemberID(i, pMember->m_memberId);
1019 if (id != CryMatchMakingInvalidConnectionID)
1020 {
1021 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
1022 NetLog("[Lobby] CCryPSNMatchMaking::ProcessSignalingEvent() : SIGNALING_EVENT_CONNECTED(1) : Signaling connected failure event, setting " PRFORMAT_SHMMCINFO " to eCLCS_NotConnected", PRARG_SHMMCINFO(CryLobbySessionHandle(i), id, pConnection->connectionID, pConnection->uid));
1023 m_lobby->ConnectionSetState(pConnection->connectionID, eCLCS_NotConnected);
1024 }
1025
1026 m_pPSNSupport->HandlePSNError(ret);
1027 }
1028 else
1029 {
1030 pMember->m_signalingState = ePSNCS_Dead;
1031
1032 CryMatchMakingConnectionID id = FindConnectionIDFromRoomMemberID(i, pMember->m_memberId);
1033 if (id != CryMatchMakingInvalidConnectionID)
1034 {
1035 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
1036 NetLog("[Lobby] CCryPSNMatchMaking::ProcessSignalingEvent() : SIGNALING_EVENT_CONNECTED(2) : Signaling connected failure event, setting " PRFORMAT_SHMMCINFO " to eCLCS_NotConnected", PRARG_SHMMCINFO(CryLobbySessionHandle(i), id, pConnection->connectionID, pConnection->uid));
1037 m_lobby->ConnectionSetState(pConnection->connectionID, eCLCS_NotConnected);
1038 }
1039 }
1040 data.m_signalEvent.m_bHandled = true;
1041 }
1042 break;
1043
1044 case SIGNALING_EVENT_NETINFO_RESULT:
1045 {
1046 NetLog("[SIGNALING] Ignored Event : %08X", data.m_signalEvent.m_event);
1047 data.m_signalEvent.m_bHandled = true;
1048 }
1049 break;
1050
1051 default:
1052 // handle unknown responses - future sdks
1053 break;
1054 }
1055 }
1056 }
1057 }
1058 }
1059
1060 void CCryPSNMatchMaking::DispatchForcedFromRoomEvent(CrySessionHandle gh, SceNpMatching2Event how, SceNpMatching2EventCause why)
1061 {
1062 if (m_lobby)
1063 {
1064 UCryLobbyEventData eventData;
1065 SCryLobbyForcedFromRoomData eventRoomData;
1066 eventData.pForcedFromRoomData = &eventRoomData;
1067
1068 eventRoomData.m_session = gh;
1069
1070 switch (why)
1071 {
1072 case SCE_NP_MATCHING2_EVENT_CAUSE_SERVER_OPERATION:
1073 case SCE_NP_MATCHING2_EVENT_CAUSE_CONTEXT_ACTION:
1074 {
1075 NetLog("DispatchForcedFromRoomEvent(eFFRR_ServerForced)");
1076 eventRoomData.m_why = eFFRR_ServerForced;
1077 }
1078 break;
1079 case SCE_NP_MATCHING2_EVENT_CAUSE_LEAVE_ACTION:
1080 case SCE_NP_MATCHING2_EVENT_CAUSE_MEMBER_DISAPPEARED:
1081 {
1082 NetLog("DispatchForcedFromRoomEvent(eFFRR_Left)");
1083 eventRoomData.m_why = eFFRR_Left;
1084 }
1085 break;
1086 case SCE_NP_MATCHING2_EVENT_CAUSE_KICKOUT_ACTION:
1087 {
1088 NetLog("DispatchForcedFromRoomEvent(eFFRR_Kicked)");
1089 eventRoomData.m_why = eFFRR_Kicked;
1090 }
1091 break;
1092 case SCE_NP_MATCHING2_EVENT_CAUSE_SERVER_INTERNAL:
1093 case SCE_NP_MATCHING2_EVENT_CAUSE_SYSTEM_ERROR:
1094 case SCE_NP_MATCHING2_EVENT_CAUSE_CONTEXT_ERROR:
1095 {
1096 NetLog("DispatchForcedFromRoomEvent(eFFRR_ServerInternalError)");
1097 eventRoomData.m_why = eFFRR_ServerInternalError;
1098 }
1099 break;
1100 case SCE_NP_MATCHING2_EVENT_CAUSE_CONNECTION_ERROR:
1101 {
1102 NetLog("DispatchForcedFromRoomEvent(eFFRR_ConnectionError)");
1103 eventRoomData.m_why = eFFRR_ConnectionError;
1104 }
1105 break;
1106 case SCE_NP_MATCHING2_EVENT_CAUSE_NP_SIGNED_OUT:
1107 {
1108 NetLog("DispatchForcedFromRoomEvent(eFFRR_SignedOut)");
1109 eventRoomData.m_why = eFFRR_SignedOut;
1110 }
1111 break;
1112 default:
1113 {
1114 NetLog("DispatchForcedFromRoomEvent(eFFRR_Unknown)");
1115 eventRoomData.m_why = eFFRR_Unknown;
1116 }
1117 break;
1118 }
1119
1120 m_lobby->DispatchEvent(eCLSE_ForcedFromRoom, eventData);
1121 }
1122 }
1123
1124 void CCryPSNMatchMaking::ProcessRoomEvent(SCryPSNSupportCallbackEventData& data)
1125 {
1126 for (uint32 i = 0; i < MAX_MATCHMAKING_SESSIONS; i++)
1127 {
1128 SSession* pSession = &m_sessions[i];
1129
1130 if (pSession->IsUsed() && (pSession->m_roomId == data.m_roomEvent.m_roomId))
1131 {
1132 switch (data.m_roomEvent.m_event)
1133 {
1134 case ROOM_EVENT_MEMBER_JOINED:
1135 {
1136 if ((data.m_roomEvent.m_error == 0) &&
1137 (data.m_roomEvent.m_dataHdl != TMemInvalidHdl) &&
1138 (data.m_roomEvent.m_dataSize == sizeof(SCryPSNRoomMemberUpdateInfoResponse)))
1139 {
1140 SCryPSNRoomMemberUpdateInfoResponse* pMemberUpdateInfo = (SCryPSNRoomMemberUpdateInfoResponse*)m_pPSNSupport->GetLobby()->MemGetPtr(data.m_roomEvent.m_dataHdl);
1141
1142 if (pMemberUpdateInfo->m_member.m_flagAttr & SCE_NP_MATCHING2_ROOMMEMBER_FLAG_ATTR_OWNER)
1143 {
1144 AddRoomMember(i, pMemberUpdateInfo->m_member, ePSNMI_OtherOwner);
1145 }
1146 else
1147 {
1148 AddRoomMember(i, pMemberUpdateInfo->m_member, ePSNMI_Other);
1149 }
1150
1151 data.m_roomEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRoomEvent::ROOM_EVENT_HANDLED;
1152 }
1153 else
1154 {
1155 //-- error occurred on room member join event
1156 //-- leave data.m_roomEvent.m_returnFlags as 0 to let the default error handler take care of any serious errors.
1157 }
1158 }
1159 break;
1160 case ROOM_EVENT_MEMBER_LEFT:
1161 {
1162 if ((data.m_roomEvent.m_error == 0) &&
1163 (data.m_roomEvent.m_dataHdl != TMemInvalidHdl) &&
1164 (data.m_roomEvent.m_dataSize == sizeof(SCryPSNRoomMemberUpdateInfoResponse)))
1165 {
1166 SCryPSNRoomMemberUpdateInfoResponse* pMemberUpdateInfo = (SCryPSNRoomMemberUpdateInfoResponse*)m_pPSNSupport->GetLobby()->MemGetPtr(data.m_roomEvent.m_dataHdl);
1167 RemoveRoomMember(i, pMemberUpdateInfo->m_member);
1168
1169 data.m_roomEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRoomEvent::ROOM_EVENT_HANDLED;
1170 }
1171 else
1172 {
1173 //-- error occurred on room member left event
1174 //-- leave data.m_roomEvent.m_returnFlags as 0 to let the default error handler take care of any serious errors.
1175 }
1176 }
1177 break;
1178 case ROOM_EVENT_ROOM_OWNER_CHANGED:
1179 {
1180 if ((data.m_roomEvent.m_error == 0) &&
1181 (data.m_roomEvent.m_dataHdl != TMemInvalidHdl) &&
1182 (data.m_roomEvent.m_dataSize == sizeof(SCryPSNRoomOwnerUpdateInfoResponse)))
1183 {
1184 SCryPSNRoomOwnerUpdateInfoResponse* pOwnerInfo = (SCryPSNRoomOwnerUpdateInfoResponse*)m_pPSNSupport->GetLobby()->MemGetPtr(data.m_roomEvent.m_dataHdl);
1185 NetLog("[LEE] Got Request for room owner change : Old Owner %d, New Owner %d", pOwnerInfo->m_prevOwner, pOwnerInfo->m_newOwner);
1186 ChangeRoomOwner(i, pOwnerInfo->m_prevOwner, pOwnerInfo->m_newOwner);
1187
1188 data.m_roomEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRoomEvent::ROOM_EVENT_HANDLED;
1189 }
1190 else
1191 {
1192 //-- error occurred on room owner changed event
1193 //-- leave data.m_roomEvent.m_returnFlags as 0 to let the default error handler take care of any serious errors.
1194 }
1195 }
1196 break;
1197 case ROOM_EVENT_KICKED_OUT:
1198 {
1199 NetLog("ROOM_EVENT_KICKED_OUT i:%d", i);
1200
1201 if ((data.m_roomEvent.m_error == 0) &&
1202 (data.m_roomEvent.m_dataHdl != TMemInvalidHdl) &&
1203 (data.m_roomEvent.m_dataSize == sizeof(SCryPSNRoomUpdateInfoResponse)))
1204 {
1205 ClearSessionInfo(i);
1206 FreeSessionHandle(i);
1207
1208 SCryPSNRoomUpdateInfoResponse* pUpdateInfo = (SCryPSNRoomUpdateInfoResponse*)m_pPSNSupport->GetLobby()->MemGetPtr(data.m_roomEvent.m_dataHdl);
1209
1210 TO_GAME_FROM_LOBBY(&CCryPSNMatchMaking::DispatchForcedFromRoomEvent, this, CreateGameSessionHandle(i, pSession->localConnection.uid), data.m_roomEvent.m_event, pUpdateInfo->m_eventCause);
1211
1212 data.m_roomEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRoomEvent::ROOM_EVENT_HANDLED;
1213 }
1214 else
1215 {
1216 //-- error occurred on kicked out of room event
1217 //-- leave data.m_roomEvent.m_returnFlags as 0 to let the default error handler take care of any serious errors.
1218 }
1219 }
1220 break;
1221 case ROOM_EVENT_ROOM_DESTROYED:
1222 {
1223 if ((data.m_roomEvent.m_error == 0) &&
1224 (data.m_roomEvent.m_dataHdl != TMemInvalidHdl) &&
1225 (data.m_roomEvent.m_dataSize == sizeof(SCryPSNRoomUpdateInfoResponse)))
1226 {
1227 ClearSessionInfo(i);
1228 FreeSessionHandle(i);
1229
1230 SCryPSNRoomUpdateInfoResponse* pUpdateInfo = (SCryPSNRoomUpdateInfoResponse*)m_pPSNSupport->GetLobby()->MemGetPtr(data.m_roomEvent.m_dataHdl);
1231
1232 TO_GAME_FROM_LOBBY(&CCryPSNMatchMaking::DispatchForcedFromRoomEvent, this, CreateGameSessionHandle(i, pSession->localConnection.uid), data.m_roomEvent.m_event, pUpdateInfo->m_eventCause);
1233
1234 data.m_roomEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRoomEvent::ROOM_EVENT_HANDLED;
1235 }
1236 else
1237 {
1238 //-- error occurred on room destroyed event
1239 //-- leave data.m_roomEvent.m_returnFlags as 0 to let the default error handler take care of any serious errors.
1240 }
1241 }
1242 break;
1243 case ROOM_EVENT_UPDATED_ROOM_DATA_INTERNAL:
1244 {
1245 //-- Don't actually care about this event:- we just trap it so it doesn't get flagged as unhandled.
1246 if (data.m_roomEvent.m_error == 0)
1247 {
1248 data.m_roomEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRoomEvent::ROOM_EVENT_HANDLED;
1249 }
1250 else
1251 {
1252 //-- error occurred on internal room data updated event
1253 //-- leave data.m_roomEvent.m_returnFlags as 0 to let the default error handler take care of any serious errors.
1254 }
1255 }
1256 break;
1257 case ROOM_EVENT_UPDATED_ROOM_MEMBER_DATA_INTERNAL:
1258 {
1259 if ((data.m_roomEvent.m_error == 0) &&
1260 (data.m_roomEvent.m_dataHdl != TMemInvalidHdl) &&
1261 (data.m_roomEvent.m_dataSize == sizeof(SCryPSNRoomMemberUpdateInfoResponse)))
1262 {
1263
1264 const SCryPSNRoomMemberUpdateInfoResponse* const pUpdateInfo = (SCryPSNRoomMemberUpdateInfoResponse*)m_pPSNSupport->GetLobby()->MemGetPtr(data.m_requestEvent.m_dataHdl);
1265 UpdateRoomMember(i, pUpdateInfo->m_member);
1266
1267 data.m_roomEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRoomEvent::ROOM_EVENT_HANDLED;
1268 }
1269 else
1270 {
1271 //-- error occurred on internal room member data updated event
1272 //-- leave data.m_roomEvent.m_returnFlags as 0 to let the default error handler take care of any serious errors.
1273 }
1274 }
1275 break;
1276 case ROOM_EVENT_UPDATED_SIGNALING_OPT_PARAM:
1277 {
1278 //-- Don't actually care about this event:- we just trap it so it doesn't get flagged as unhandled.
1279 if (data.m_roomEvent.m_error == 0)
1280 {
1281 data.m_roomEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRoomEvent::ROOM_EVENT_HANDLED;
1282 }
1283 else
1284 {
1285 //-- error occurred on signaling opt param updated event
1286 //-- leave data.m_roomEvent.m_returnFlags as 0 to let the default error handler take care of any serious errors.
1287 }
1288 }
1289 break;
1290 }
1291
1292 return;
1293 }
1294 }
1295 }
1296
1297 void CCryPSNMatchMaking::ProcessErrorEvent(SCryPSNSupportCallbackEventData& data)
1298 {
1299 for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; i++)
1300 {
1301 STask* pTask = &m_task[i];
1302 if (pTask->used && pTask->running)
1303 {
1304 UpdateTaskError(i, MapSupportErrorToLobbyError(data.m_errorEvent.m_error));
1305 StopTaskRunning(i);
1306 }
1307 }
1308
1309 for (uint32 j = 0; j < MAX_MATCHMAKING_SESSIONS; j++)
1310 {
1311 SSession* pSession = &m_sessions[j];
1312 if (pSession->IsUsed())
1313 {
1314 ClearSessionInfo(j);
1315 FreeSessionHandle(j);
1316 }
1317 }
1318 }
1319
1320 void CCryPSNMatchMaking::ProcessWebApiEvent(SCryPSNSupportCallbackEventData& data)
1321 {
1322 for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; i++)
1323 {
1324 STask* pTask = &m_task[i];
1325 if (pTask->used && pTask->running)
1326 {
1327 switch (pTask->subTask)
1328 {
1329 case eST_WaitingForCreateRoomWebApiCallback:
1330 {
1331 SCreateParamData* pCreateParams = (SCreateParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_CREATE_REQUEST_SLOT]);
1332 if (pCreateParams && (pCreateParams->m_createJobId == data.m_webApiEvent.m_id))
1333 {
1334 EventWebApiCreateSession(i, data);
1335 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
1336 }
1337 }
1338 break;
1339 case eST_WaitingForJoinRoomWebApiCallback:
1340 {
1341 SJoinParamData* pJoinParams = (SJoinParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_JOIN_REQUEST_SLOT]);
1342 if (pJoinParams && (pJoinParams->m_joinJobId == data.m_webApiEvent.m_id))
1343 {
1344 EventWebApiJoinSession(i, data);
1345 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
1346 }
1347 }
1348 break;
1349 case eST_WaitingForLeaveRoomWebApiCallback:
1350 {
1351 SLeaveParamData* pLeaveParams = (SLeaveParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_LEAVE_REQUEST_SLOT]);
1352 if (pLeaveParams && (pLeaveParams->m_leaveJobId == data.m_webApiEvent.m_id))
1353 {
1354 EventWebApiLeaveSession(i, data);
1355 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
1356 }
1357 }
1358 break;
1359 case eST_WaitingForUpdateAdvertisementDataWebApiCallback:
1360 {
1361 SUpdateAdvertisementDataParamData* pAdParams = (SUpdateAdvertisementDataParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_UPDATEADVERT_REQUEST_SLOT]);
1362 if (pAdParams && (pAdParams->m_jobId == data.m_webApiEvent.m_id))
1363 {
1364 EventWebApiUpdateSessionAdvertisement(i, data);
1365 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
1366 }
1367 }
1368 break;
1369 case eST_WaitingForGetAdvertisementDataWebApiCallback:
1370 {
1371 SGetAdvertisementDataParamData* pAdParams = (SGetAdvertisementDataParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_GETADVERT_REQUEST_SLOT]);
1372 if (pAdParams && (pAdParams->m_jobId == data.m_webApiEvent.m_id))
1373 {
1374 EventWebApiGetSessionLinkData(i, data);
1375 data.m_webApiEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SWebApiEvent::WEBAPI_EVENT_HANDLED;
1376 }
1377 }
1378 break;
1379 }
1380 }
1381 }
1382 }
1383
1384 void CCryPSNMatchMaking::SupportCallback(ECryPSNSupportCallbackEvent ecb, SCryPSNSupportCallbackEventData& data, void* pArg)
1385 {
1386 CCryPSNMatchMaking* _this = static_cast<CCryPSNMatchMaking*>(pArg);
1387
1388 switch (ecb)
1389 {
1390 case eCE_RequestEvent:
1391 {
1392 _this->ProcessRequestEvent(data);
1393 }
1394 break;
1395 case eCE_SignalEvent:
1396 {
1397 _this->ProcessSignalingEvent(data);
1398 }
1399 break;
1400 case eCE_RoomEvent:
1401 {
1402 _this->ProcessRoomEvent(data);
1403 }
1404 break;
1405 case eCE_ErrorEvent:
1406 {
1407 _this->ProcessErrorEvent(data);
1408 }
1409 break;
1410 case eCE_WebApiEvent:
1411 {
1412 _this->ProcessWebApiEvent(data);
1413 }
1414 break;
1415 }
1416 }
1417
1418 ECryLobbyError CCryPSNMatchMaking::Initialise()
1419 {
1420 ECryLobbyError error = CCryMatchMaking::Initialise();
1421
1422 if (error == eCLE_Success)
1423 {
1424 int ret;
1425
1426 ret = sceSysmoduleLoadModule(SCE_SYSMODULE_NP_MATCHING2);
1427 if (ret < PSN_OK)
1428 {
1429 NetLog("sceSysmoduleLoadModule(SCE_SYSMODULE_NP_MATCHING2) failed. ret = 0x%x\n", ret);
1430 return eCLE_InternalError;
1431 }
1432
1433 SceNpMatching2InitializeParameter configurationMatching2;
1434 memset(&configurationMatching2, 0, sizeof(configurationMatching2));
1435 configurationMatching2.size = sizeof(configurationMatching2);
1436 configurationMatching2.poolSize = SCE_NP_MATCHING2_POOLSIZE_DEFAULT;
1437 configurationMatching2.cpuAffinityMask = SCE_KERNEL_CPUMASK_USER_ALL;
1438 configurationMatching2.threadPriority = SCE_KERNEL_PRIO_FIFO_DEFAULT; //CLobbyCVars::Get().psnMatching2ThreadPriority;
1439 configurationMatching2.threadStackSize = SCE_NP_MATCHING2_THREAD_STACK_SIZE_DEFAULT;
1440
1441 ret = sceNpMatching2Initialize(&configurationMatching2);
1442 if (ret < PSN_OK)
1443 {
1444 NetLog("sceNpMatching2Initialize() failed. ret = 0x%x\n", ret);
1445 return eCLE_InternalError;
1446 }
1447
1448 m_registeredUserData.num = 0;
1449
1450 for (uint32 i = 0; i < MAX_MATCHMAKING_SESSIONS; i++)
1451 {
1452 m_sessions[i].localFlags &= ~CRYSESSION_LOCAL_FLAG_USED;
1453
1454 for (uint32 j = 0; j < MAX_LOBBY_CONNECTIONS; j++)
1455 {
1456 m_sessions[i].remoteConnection[j].connectionID = CryLobbyInvalidConnectionID;
1457 m_sessions[i].remoteConnection[j].used = false;
1458 m_sessions[i].remoteConnection[j].registered = false;
1459 m_sessions[i].remoteConnection[j].memberId = INVALID_PSN_ROOM_MEMBER_ID;
1460 }
1461
1462 ClearSessionInfo(i);
1463 }
1464
1465 for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; i++)
1466 {
1467 m_task[i].m_reqId = INVALID_PSN_REQUEST_ID;
1468 }
1469 }
1470
1471 return error;
1472 }
1473
1474 ECryLobbyError CCryPSNMatchMaking::Terminate()
1475 {
1476 for (uint32 i = 0; i < MAX_MATCHMAKING_SESSIONS; i++)
1477 {
1478 SSession* pSession = &m_sessions[i];
1479 if (pSession->IsUsed())
1480 {
1481 ClearSessionInfo(i);
1482 FreeSessionHandle(i);
1483 }
1484 }
1485
1486 int ret;
1487 ret = sceNpMatching2Terminate();
1488 if (ret < PSN_OK)
1489 {
1490 NetLog("sceNpMatching2Termimate() failed. ret = 0x%x\n", ret);
1491 }
1492
1493 ret = sceSysmoduleUnloadModule(SCE_SYSMODULE_NP_MATCHING2);
1494 if (ret < PSN_OK)
1495 {
1496 NetLog("sceSysmoduleUnloadModule(SCE_SYSMODULE_NP_MATCHING2) failed. ret = 0x%x\n", ret);
1497 }
1498
1499 return eCLE_Success;
1500 }
1501
1502 CCryPSNMatchMaking::CCryPSNMatchMaking(CCryLobby* lobby, CCryLobbyService* service, CCryPSNSupport* pSupport, ECryLobbyService serviceType) : CCryMatchMaking(lobby, service, serviceType)
1503 {
1504 m_pPSNSupport = pSupport;
1505
1506 m_oldNatType = SCE_NP_MATCHING2_SIGNALING_NETINFO_NAT_STATUS_UNKNOWN;
1507
1508 // Make the CCryMatchMaking base pointers point to our data so we can use the common code in CCryMatchMaking
1509 for (uint32 i = 0; i < MAX_MATCHMAKING_SESSIONS; i++)
1510 {
1511 CCryMatchMaking::m_sessions[i] = &m_sessions[i];
1512 CCryMatchMaking::m_sessions[i]->localConnection = &m_sessions[i].localConnection;
1513
1514 for (uint32 j = 0; j < MAX_LOBBY_CONNECTIONS; j++)
1515 {
1516 CCryMatchMaking::m_sessions[i]->remoteConnection[j] = &m_sessions[i].remoteConnection[j];
1517 }
1518 }
1519
1520 for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; i++)
1521 {
1522 CCryMatchMaking::m_task[i] = &m_task[i];
1523 }
1524
1525 REGISTER_CVAR2("net_enable_psn_hinting", &net_enable_psn_hinting, 1, VF_DUMPTODISK, "Toggles whether PSN hinting enabled or not");
1526 }
1527
1528 CCryPSNMatchMaking::~CCryPSNMatchMaking()
1529 {
1530 }
1531
1532 ECryLobbyError CCryPSNMatchMaking::StartTask(ETask etask, bool startRunning, uint32 user, CryMatchMakingTaskID* mmTaskID, CryLobbyTaskID* lTaskID, CryLobbySessionHandle h, void* cb, void* cbArg)
1533 {
1534 CryMatchMakingTaskID tmpMMTaskID;
1535 CryMatchMakingTaskID* useMMTaskID = mmTaskID ? mmTaskID : &tmpMMTaskID;
1536 ECryLobbyError error = CCryMatchMaking::StartTask(etask, startRunning, useMMTaskID, lTaskID, h, cb, cbArg);
1537
1538 if (error == eCLE_Success)
1539 {
1540 ResetTask(*useMMTaskID);
1541 }
1542
1543 return error;
1544 }
1545
1546 void CCryPSNMatchMaking::ResetTask(CryMatchMakingTaskID mmTaskID)
1547 {
1548 STask* pTask = &m_task[mmTaskID];
1549 pTask->returnTaskID = CryMatchMakingInvalidTaskID;
1550 pTask->m_reqId = INVALID_PSN_REQUEST_ID;
1551 }
1552
1553 const char* CCryPSNMatchMaking::SSession::GetLocalUserName(uint32 localUserIndex) const
1554 {
1555 if (localFlags & CRYSESSION_LOCAL_FLAG_USED)
1556 {
1557 for (uint32 memberIndex = 0; memberIndex < MAX_PSN_ROOM_MEMBERS; ++memberIndex)
1558 {
1559 const SRoomMember* pRoomMember = &m_members[memberIndex];
1560 if ((pRoomMember->m_valid != ePSNMI_None) && (pRoomMember->m_memberId == m_myMemberId))
1561 {
1562 return pRoomMember->m_npId.handle.data;
1563 }
1564 }
1565 }
1566
1567 return NULL;
1568 }
1569
1570 void CCryPSNMatchMaking::SSession::Reset()
1571 {
1572 PARENT::Reset();
1573
1574 started = false;
1575 remoteConnectionProcessingToDo = false;
1576 remoteConnectionTaskID = CryMatchMakingInvalidTaskID;
1577 hostConnectionID = CryMatchMakingInvalidConnectionID;
1578 unregisteredConnectionsKicked = false;
1579
1580 m_serverId = INVALID_PSN_SERVER_ID;
1581 m_worldId = INVALID_PSN_WORLD_ID;
1582 m_roomId = INVALID_PSN_ROOM_ID;
1583 memset(&m_sessionId, 0, sizeof(SceNpSessionId));
1584
1585 m_myMemberId = INVALID_PSN_ROOM_MEMBER_ID;
1586 m_ownerMemberId = INVALID_PSN_ROOM_MEMBER_ID;
1587 }
1588
1589 const char* CCryPSNMatchMaking::GetConnectionName(CCryMatchMaking::SSession::SRConnection* pConnection, uint32 localUserIndex) const
1590 {
1591 SSession::SRConnection* pPlatformConnection = reinterpret_cast<SSession::SRConnection*>(pConnection);
1592
1593 if (pPlatformConnection->uid.m_uid == DEDICATED_SERVER_CONNECTION_UID)
1594 {
1595 return "DedicatedServer";
1596 }
1597
1598 for (uint32 sessionIndex = 0; sessionIndex < MAX_MATCHMAKING_SESSIONS; ++sessionIndex)
1599 {
1600 const SSession* pSession = &m_sessions[sessionIndex];
1601
1602 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_USED)
1603 {
1604 for (uint32 memberIndex = 0; memberIndex < MAX_PSN_ROOM_MEMBERS; ++memberIndex)
1605 {
1606 const SSession::SRoomMember* pRoomMember = &pSession->m_members[memberIndex];
1607 if ((pRoomMember->m_valid != ePSNMI_None) && (pRoomMember->m_memberId == pPlatformConnection->memberId))
1608 {
1609 return pRoomMember->m_npId.handle.data;
1610 }
1611 }
1612 }
1613 }
1614
1615 return NULL;
1616 }
1617
1618 void CCryPSNMatchMaking::StartTaskRunning(CryMatchMakingTaskID mmTaskID)
1619 {
1620 LOBBY_AUTO_LOCK;
1621
1622 STask* task = &m_task[mmTaskID];
1623
1624 if (task->used)
1625 {
1626 #if ENABLE_CRYLOBBY_DEBUG_TESTS
1627 ECryLobbyError error;
1628
1629 if (!m_lobby->DebugOKToStartTaskRunning(task->lTaskID))
1630 {
1631 return;
1632 }
1633
1634 if (m_lobby->DebugGenerateError(task->lTaskID, error))
1635 {
1636 UpdateTaskError(mmTaskID, error);
1637 StopTaskRunning(mmTaskID);
1638
1639 if ((task->startedTask == eT_SessionCreate) || (task->startedTask == eT_SessionJoin))
1640 {
1641 FreeSessionHandle(task->session);
1642 }
1643
1644 return;
1645 }
1646 #endif
1647
1648 task->running = true;
1649
1650 switch (task->startedTask)
1651 {
1652 case eT_SessionDelete:
1653 StartSessionDelete(mmTaskID);
1654 break;
1655
1656 case eT_SessionUpdateSlots:
1657 case eT_SessionStart:
1658 case eT_SessionEnd:
1659 case eT_SessionRegisterUserData:
1660 StopTaskRunning(mmTaskID);
1661 break;
1662
1663 case eT_SessionSearch:
1664 StartSessionSearch(mmTaskID);
1665 break;
1666
1667 #if NETWORK_HOST_MIGRATION
1668 case eT_SessionMigrateHostStart:
1669 HostMigrationStartNT(mmTaskID);
1670 break;
1671 case eT_SessionMigrateHostServer:
1672 HostMigrationServerNT(mmTaskID);
1673 break;
1674 case eT_SessionSendHostHintExternal:
1675 StartSessionSendHostHintExternal(mmTaskID);
1676 break;
1677 #endif
1678 }
1679 }
1680 }
1681
1682 void CCryPSNMatchMaking::EndTask(CryMatchMakingTaskID mmTaskID)
1683 {
1684 LOBBY_AUTO_LOCK;
1685
1686 STask* pTask = &m_task[mmTaskID];
1687
1688 if (pTask->used)
1689 {
1690 if (m_pPSNSupport->GetNetInfo().natStatus != m_oldNatType)
1691 {
1692 m_oldNatType = m_pPSNSupport->GetNetInfo().natStatus;
1693
1694 UCryLobbyEventData eventData;
1695 SCryLobbyNatTypeData natTypeData;
1696
1697 eventData.pNatTypeData = &natTypeData;
1698
1699 switch (m_oldNatType)
1700 {
1701 default:
1702 case SCE_NP_MATCHING2_SIGNALING_NETINFO_NAT_STATUS_UNKNOWN:
1703 natTypeData.m_curState = eNT_Unknown;
1704 break;
1705 case SCE_NP_MATCHING2_SIGNALING_NETINFO_NAT_STATUS_TYPE:
1706 natTypeData.m_curState = eNT_Open;
1707 break;
1708 case SCE_NP_MATCHING2_SIGNALING_NETINFO_NAT_STATUS_TYPE2:
1709 natTypeData.m_curState = eNT_Moderate;
1710 break;
1711 case SCE_NP_MATCHING2_SIGNALING_NETINFO_NAT_STATUS_TYPE3:
1712 natTypeData.m_curState = eNT_Strict;
1713 break;
1714 }
1715
1716 if (m_lobby)
1717 {
1718 m_lobby->DispatchEvent(eCLSE_NatType, eventData);
1719 m_lobby->SetNATType(natTypeData.m_curState);
1720 }
1721 }
1722
1723 #if NETWORK_HOST_MIGRATION
1724 if (pTask->startedTask & HOST_MIGRATION_TASK_ID_FLAG)
1725 {
1726 m_sessions[pTask->session].hostMigrationInfo.m_taskID = CryLobbyInvalidTaskID;
1727 }
1728 #endif
1729
1730 if (pTask->cb)
1731 {
1732 switch (pTask->startedTask)
1733 {
1734 case eT_SessionRegisterUserData:
1735 ((CryMatchmakingCallback)pTask->cb)(pTask->lTaskID, pTask->error, pTask->cbArg);
1736 break;
1737
1738 case eT_SessionSearch:
1739 EndSessionSearch(mmTaskID);
1740 break;
1741
1742 case eT_SessionMigrate:
1743 ((CryMatchmakingSessionCreateCallback)pTask->cb)(pTask->lTaskID, pTask->error, CreateGameSessionHandle(pTask->session, m_sessions[pTask->session].localConnection.uid), pTask->cbArg);
1744 break;
1745
1746 case eT_SessionCreate:
1747 EndSessionCreate(mmTaskID);
1748 break;
1749
1750 case eT_SessionQuery:
1751 EndSessionQuery(mmTaskID);
1752 break;
1753
1754 case eT_SessionGetUsers:
1755 ((CryMatchmakingSessionGetUsersCallback)pTask->cb)(pTask->lTaskID, pTask->error, NULL, pTask->cbArg);
1756 break;
1757
1758 case eT_SessionJoin:
1759 EndSessionJoin(mmTaskID);
1760 break;
1761
1762 case eT_SessionSetAdvertisementData:
1763 EndSessionSetAdvertisementData(mmTaskID);
1764 break;
1765
1766 case eT_SessionGetAdvertisementData:
1767 EndSessionGetAdvertisementData(mmTaskID);
1768 break;
1769
1770 #if NETWORK_HOST_MIGRATION
1771 case eT_SessionSendHostHintExternal:
1772 EndSessionSendHostHintExternal(mmTaskID);
1773 break;
1774 #endif
1775
1776 case eT_SessionUserData:
1777 case eT_SessionUpdate:
1778 case eT_SessionUpdateSlots:
1779 case eT_SessionStart:
1780 case eT_SessionEnd:
1781 case eT_SessionDelete:
1782 #if NETWORK_HOST_MIGRATION
1783 case eT_SessionMigrateHostStart:
1784 #endif
1785 ((CryMatchmakingCallback)pTask->cb)(pTask->lTaskID, pTask->error, pTask->cbArg);
1786 break;
1787 }
1788 }
1789
1790 if (pTask->canceled)
1791 {
1792 UpdateTaskError(mmTaskID, eCLE_InternalError);
1793 }
1794
1795 if (pTask->error != eCLE_Success)
1796 {
1797 if ((pTask->startedTask == eT_SessionCreate) || (pTask->startedTask == eT_SessionJoin))
1798 {
1799 if (pTask->session != CryLobbyInvalidSessionHandle)
1800 {
1801 ClearSessionInfo(pTask->session);
1802 FreeSessionHandle(pTask->session);
1803 pTask->session = CryLobbyInvalidSessionHandle;
1804 }
1805 }
1806
1807 NetLog("[Lobby] EndTask %d (%d) error %d", pTask->startedTask, pTask->subTask, pTask->error);
1808 }
1809
1810 // Clear PSN specific task state so that base class tasks can use this slot
1811 ResetTask(mmTaskID);
1812
1813 FreeTask(mmTaskID);
1814 }
1815 }
1816
1817 void CCryPSNMatchMaking::StopTaskRunning(CryMatchMakingTaskID mmTaskID)
1818 {
1819 STask* pTask = &m_task[mmTaskID];
1820
1821 if (pTask->used)
1822 {
1823 pTask->running = false;
1824 TO_GAME_FROM_LOBBY(&CCryPSNMatchMaking::EndTask, this, mmTaskID);
1825 }
1826 }
1827
1828 ECryLobbyError CCryPSNMatchMaking::CreateSessionHandle(CryLobbySessionHandle* h, bool host, uint32* users, int numUsers, uint32 flags)
1829 {
1830 ECryLobbyError error = CCryMatchMaking::CreateSessionHandle(h, host, flags, numUsers);
1831
1832 if (error == eCLE_Success)
1833 {
1834 SSession* pSession = &m_sessions[*h];
1835
1836 for (uint32 j = 0; j < numUsers; j++)
1837 {
1838 pSession->localConnection.users[j] = users[j];
1839 }
1840
1841 ClearSessionInfo(*h);
1842 }
1843
1844 return error;
1845 }
1846
1847 void CCryPSNMatchMaking::Tick(CTimeValue tv)
1848 {
1849 CCryMatchMaking::Tick(tv);
1850
1851 for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; i++)
1852 {
1853 STask* pTask = &m_task[i];
1854
1855 #if ENABLE_CRYLOBBY_DEBUG_TESTS
1856 if (pTask->used)
1857 {
1858 if (m_lobby->DebugTickCallStartTaskRunning(pTask->lTaskID))
1859 {
1860 StartTaskRunning(i);
1861 continue;
1862 }
1863 if (!m_lobby->DebugOKToTickTask(pTask->lTaskID, pTask->running))
1864 {
1865 continue;
1866 }
1867 }
1868 #endif
1869
1870 if (pTask->used && pTask->running)
1871 {
1872 if (pTask->error == eCLE_Success)
1873 {
1874 switch (pTask->subTask)
1875 {
1876 case eT_SessionQuery:
1877 TickSessionQuery(i);
1878 break;
1879
1880 case eT_SessionUpdate:
1881 TickSessionUpdate(i);
1882 break;
1883
1884 case eT_SessionUserData:
1885 TickSessionUserData(i);
1886 break;
1887
1888 case eT_SessionRegisterUserData:
1889 case eT_SessionStart:
1890 case eT_SessionEnd:
1891 break;
1892
1893 case eST_WaitingForJoinRoomSignalingCallback:
1894 {
1895 TickSessionJoinSignaling(i);
1896 }
1897 break;
1898
1899 case eST_WaitingForCreateRoomSignalingCallback:
1900 {
1901 TickSessionCreateSignaling(i);
1902 }
1903 break;
1904
1905 case eT_SessionSearch:
1906 TickSessionSearch(i);
1907 break;
1908 case eST_SessionSearchRequest:
1909 TickSessionSearchRequest(i);
1910 break;
1911 case eST_SessionSearchKickQOS:
1912 TickSessionQOSSearch(i);
1913 break;
1914 case eST_WaitingForSearchQOSRequestCallback:
1915 TickSessionWaitForQOS(i);
1916 break;
1917
1918 case eT_SessionCreate:
1919 TickSessionCreate(i);
1920 break;
1921 case eST_SessionCreateRequest:
1922 TickSessionCreateRequest(i);
1923 break;
1924
1925 case eT_SessionMigrate:
1926 TickSessionMigrate(i);
1927 break;
1928
1929 case eT_SessionJoin:
1930 TickSessionJoin(i);
1931 break;
1932
1933 case eT_SessionGetUsers:
1934 TickSessionGetUsers(i);
1935 break;
1936
1937 case eT_SessionDelete:
1938 TickSessionDelete(i);
1939 break;
1940
1941 case eT_SessionSetAdvertisementData:
1942 TickSessionSetAdvertisementData(i);
1943 break;
1944
1945 case eT_SessionGetAdvertisementData:
1946 TickSessionGetAdvertisementData(i);
1947 break;
1948
1949 #if NETWORK_HOST_MIGRATION
1950 case eT_SessionMigrateHostStart:
1951 TickHostMigrationStartNT(i);
1952 break;
1953
1954 case eT_SessionMigrateHostServer:
1955 TickHostMigrationServerNT(i);
1956 break;
1957
1958 case eT_SessionSendHostHintExternal:
1959 TickSessionSendHostHintExternal(i);
1960 break;
1961 #endif
1962 default:
1963 TickBaseTask(i);
1964 break;
1965 }
1966 }
1967
1968 if (pTask->error != eCLE_Success)
1969 {
1970 StopTaskRunning(i);
1971 }
1972 }
1973 }
1974
1975 UpdateVoiceUsers();
1976
1977 const int psnShowRooms = CLobbyCVars::Get().psnShowRooms;
1978 if ((psnShowRooms != 0) && gEnv->pRenderer)
1979 {
1980 static float yellow[] = { 1.0f, 1.0f, 0.4f, 1.0f };
1981 f32 ypos = 35.0f;
1982
1983 for (uint32 i = 0; i < MAX_MATCHMAKING_SESSIONS; i++)
1984 {
1985 SSession* pSession = &m_sessions[i];
1986 if (pSession->IsUsed())
1987 {
1988 f32 xpos = 50.0f + (250.0f * i);
1989
1990 // gEnv->pRenderer->Draw2dLabel(xpos, ypos, 1.5f, yellow, false, "S%d-W%d-R%lld",
1991 // pSession->m_serverId, pSession->m_worldId, pSession->m_roomId);
1992 }
1993 }
1994 }
1995 }
1996
1997 ECryLobbyError CCryPSNMatchMaking::SessionRegisterUserData(SCrySessionUserData* data, uint32 numData, CryLobbyTaskID* taskID, CryMatchmakingCallback cb, void* cbArg)
1998 {
1999 ECryLobbyError error = eCLE_Success;
2000
2001 LOBBY_AUTO_LOCK;
2002
2003 if (numData < MAX_MATCHMAKING_SESSION_USER_DATA)
2004 {
2005 CryMatchMakingTaskID mmTaskID;
2006
2007 error = StartTask(eT_SessionRegisterUserData, false, 0, &mmTaskID, taskID, 0, (void*)cb, cbArg);
2008
2009 if (error == eCLE_Success)
2010 {
2011 memcpy(m_registeredUserData.data, data, numData * sizeof(data[0]));
2012 m_registeredUserData.num = numData;
2013
2014 uint32 searchableCount = 0;
2015 uint32 binBucketOffset = 0;
2016 for (uint32 a = 0; a < numData; a++)
2017 {
2018 if ((m_registeredUserData.data[a].m_type == eCSUDT_Int32) && (searchableCount < SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_NUM))
2019 {
2020 m_registeredUserData.mapping[a].integerField = 1;
2021 m_registeredUserData.mapping[a].fieldOffset = searchableCount;
2022
2023 searchableCount++;
2024 }
2025 else
2026 {
2027 // Either we have run out of searchable integers or the data type is not 32bit
2028 m_registeredUserData.mapping[a].integerField = 0;
2029 m_registeredUserData.mapping[a].fieldOffset = binBucketOffset;
2030 switch (m_registeredUserData.data[a].m_type)
2031 {
2032 case eCSUDT_Int64:
2033 case eCSUDT_Int64NoEndianSwap:
2034 case eCSUDT_Float64:
2035 binBucketOffset += 8;
2036 break;
2037 case eCSUDT_Int32:
2038 case eCSUDT_Float32:
2039 binBucketOffset += 4;
2040 break;
2041 case eCSUDT_Int16:
2042 binBucketOffset += 2;
2043 break;
2044 case eCSUDT_Int8:
2045 binBucketOffset += 1;
2046 break;
2047 default:
2048 error = eCLE_UserDataTypeMissMatch;
2049 return error;
2050 }
2051 if (binBucketOffset > (SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_MAX_SIZE * SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_NUM))
2052 {
2053 error = eCLE_OutOfSessionUserData;
2054 return error;
2055 }
2056 }
2057 }
2058
2059 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
2060 }
2061 }
2062 else
2063 {
2064 error = eCLE_OutOfSessionUserData;
2065 }
2066
2067 NetLog("[Lobby] Start SessionRegisterUserData error %d", error);
2068
2069 return error;
2070 }
2071
2072 uint32 CCryPSNMatchMaking::SortWorlds(const SCryPSNGetWorldInfoListResponse* pWorldList, SceNpMatching2WorldId* pReturnIdList, uint32 nMaxListSize, bool bIsForSearch)
2073 {
2074 uint32 numWorldsSorted = 0;
2075
2076 if (pReturnIdList && (nMaxListSize > 0))
2077 {
2078 for (uint32 w = 0; w < nMaxListSize; w++)
2079 {
2080 pReturnIdList[w] = INVALID_PSN_ROOM_ID;
2081 }
2082
2083 uint32 numTotalWorlds = pWorldList ? pWorldList->m_numWorlds : 0;
2084 if (pWorldList && numTotalWorlds)
2085 {
2086 int forceWorld = CLobbyCVars::Get().psnForceWorld;
2087 if (forceWorld == 0)
2088 {
2089 //-- For worlds metrics, we have access to two values:
2090 //-- ~ number of rooms on a world. The more rooms on a world, the better list of search results we'll get back
2091 //-- ~ players-per-room ratio. The higher the ratio, the more likely it is that the world is hosting game sessions.
2092
2093 uint32 mostRooms = 1;
2094 f32 mostPPRRatio = 1.0f;
2095 for (uint32 i = 0; i < numTotalWorlds; i++)
2096 {
2097 SCryPSNWorld& world = pWorldList->m_pWorlds[i];
2098
2099 world.m_score = 0;
2100 world.m_sortState = SCryPSNWorld::SORT_WORLD_NONE;
2101
2102 if (world.m_numRooms > 0)
2103 {
2104 if (world.m_numRooms > mostRooms)
2105 {
2106 mostRooms = world.m_numRooms;
2107 }
2108
2109 f32 fRatio = (f32)world.m_numTotalRoomMembers / (f32)world.m_numRooms;
2110 if (fRatio > mostPPRRatio)
2111 {
2112 mostPPRRatio = fRatio;
2113 }
2114 }
2115 }
2116
2117 f32 roomsBonus = (f32)CLobbyCVars::Get().psnBestWorldNumRoomsBonus;
2118 f32 roomsPCth = (f32)mostRooms * CLobbyCVars::Get().psnBestWorldNumRoomsPivot;
2119 f32 roomsRampUp = roomsBonus / roomsPCth;
2120 f32 roomsRampDown = 0.0f;
2121 if (CLobbyCVars::Get().psnBestWorldNumRoomsPivot < 1.0f)
2122 {
2123 roomsRampDown = (roomsBonus * 0.33f) / (mostRooms - roomsPCth);
2124 }
2125
2126 f32 ratioBonus = (f32)CLobbyCVars::Get().psnBestWorldPlayersPerRoomBonus;
2127 f32 ratioPCth = mostPPRRatio * CLobbyCVars::Get().psnBestWorldPlayersPerRoomPivot;
2128 f32 ratioRampUp = ratioBonus / ratioPCth;
2129 f32 ratioRampDown = 0.0f;
2130 if (CLobbyCVars::Get().psnBestWorldPlayersPerRoomPivot < 1.0f)
2131 {
2132 ratioRampDown = (ratioBonus * 0.33f) / (mostPPRRatio - ratioPCth);
2133 }
2134
2135 NetLog("SortWorlds: Room Setup: %d maximum, optimal is %.02f at position %.02f", mostRooms, roomsPCth, CLobbyCVars::Get().psnBestWorldNumRoomsPivot);
2136 NetLog("SortWorlds: PPR Setup: %.04f maximum, optimal is %.04f at position %.02f", mostPPRRatio, ratioPCth, CLobbyCVars::Get().psnBestWorldPlayersPerRoomPivot);
2137
2138 uint32 maxRooms = max(0, min(CLobbyCVars::Get().psnBestWorldMaxRooms, MAX_ROOMS_PER_WORLD));
2139 uint32 maxBonus = CLobbyCVars::Get().psnBestWorldNumRoomsBonus
2140 + CLobbyCVars::Get().psnBestWorldPlayersPerRoomBonus
2141 + CLobbyCVars::Get().psnBestWorldRandomBonus
2142 + 1;
2143
2144 for (uint32 i = 0; i < numTotalWorlds; i++)
2145 {
2146 uint32 scoreA = 0;
2147 uint32 scoreB = 0;
2148 uint32 scoreC = 0;
2149 f32 playersPerRoomRatio = 0.0f;
2150
2151 SCryPSNWorld& world = pWorldList->m_pWorlds[i];
2152
2153 if (world.m_numRooms > 0)
2154 {
2155 //-- This could probably do with some statistical study to provide a good world score,
2156 //-- but using only the number of rooms (as we have in the past) isn't necessarily going to
2157 //-- provide a good world (it might be full of squads).
2158
2159 f32 curNumOfRoom = (f32)world.m_numRooms;
2160 if (curNumOfRoom <= roomsPCth)
2161 {
2162 scoreA = (uint32)(curNumOfRoom * roomsRampUp);
2163 }
2164 else
2165 {
2166 scoreA = (uint32)(roomsBonus - ((curNumOfRoom - roomsPCth) * roomsRampDown));
2167 }
2168
2169 //-- And maybe some points for players per room density, which should skew the results towards
2170 //-- worlds with bigger rooms and hopefully those are more likely to contain game sessions and not squads.
2171
2172 playersPerRoomRatio = (f32)world.m_numTotalRoomMembers / (f32)world.m_numRooms;
2173 if (playersPerRoomRatio <= ratioPCth)
2174 {
2175 scoreB = (uint32)(playersPerRoomRatio * ratioRampUp);
2176 }
2177 else
2178 {
2179 scoreB = (uint32)(ratioBonus - ((playersPerRoomRatio - ratioPCth) * ratioRampDown));
2180 }
2181
2182 world.m_score = scoreA + scoreB;
2183 }
2184
2185 if (bIsForSearch)
2186 {
2187 //-- if sorting is for a room search, only include worlds with a score > 0
2188 if (world.m_score > 0)
2189 {
2190 world.m_sortState = SCryPSNWorld::SORT_WORLD_NEEDS_SORTING;
2191 }
2192 //-- We also have to make sure that at least 1 world is returned, so lets use world[0].
2193 if (i == 0)
2194 {
2195 world.m_sortState = SCryPSNWorld::SORT_WORLD_NEEDS_SORTING;
2196 }
2197
2198 //-- also add a slightly random element so there's a chance that the sorted world list can change
2199 //-- (only useful if we return a subset of the sorted worlds (eg: top 3) and want some variation, otherwise it's pointless.)
2200 //-- Since we return all worlds for a search this is no longer necessary. But might be in the future.
2201 //scoreC = (cry_rand() % CNetCVars::Get().psnBestWorldRandomBonus);
2202 //world.m_score += scoreC;
2203 }
2204 else
2205 {
2206 //-- if sorting is for a room create, only include worlds that are not full.
2207 if (world.m_numRooms < maxRooms)
2208 {
2209 world.m_sortState = SCryPSNWorld::SORT_WORLD_NEEDS_SORTING;
2210 }
2211 }
2212
2213 NetLog("SortWorlds: World %02d : ID %d: Score = %d + %d + %d = %d (%d rooms ~ %.2f PPR)", i + 1, world.m_worldId,
2214 scoreA, scoreB, scoreC, world.m_score, world.m_numRooms, playersPerRoomRatio);
2215 }
2216
2217 //-- We have a set of valid worlds to sort now, so we just have to add them to the return list in the correct order.
2218 //-- It's a pretty bad selection sort algorithm, but it doesn't need to be hugely performance critical.
2219 bool bSorting = true;
2220 while (bSorting)
2221 {
2222 SCryPSNWorld* pBestWorld = NULL;
2223 uint32 highestWorldScore = 0;
2224 uint32 lowestWorldScore = maxBonus;
2225
2226 for (uint32 l = 0; l < numTotalWorlds; l++)
2227 {
2228 SCryPSNWorld* pWorld = &pWorldList->m_pWorlds[l];
2229
2230 if (pWorld->m_sortState == SCryPSNWorld::SORT_WORLD_NEEDS_SORTING)
2231 {
2232 if (bIsForSearch)
2233 {
2234 // search returns the highest scoring worlds first
2235 if (pWorld->m_score >= highestWorldScore)
2236 {
2237 highestWorldScore = pWorld->m_score;
2238 pBestWorld = pWorld;
2239 }
2240 }
2241 else
2242 {
2243 // create returns the lowest scoring worlds first.
2244 // I'm not sure this is really what we want...
2245 if (pWorld->m_score < lowestWorldScore)
2246 {
2247 lowestWorldScore = pWorld->m_score;
2248 pBestWorld = pWorld;
2249 }
2250 }
2251 }
2252 }
2253
2254 if (pBestWorld)
2255 {
2256 pReturnIdList[numWorldsSorted] = pBestWorld->m_worldId;
2257 pBestWorld->m_sortState = SCryPSNWorld::SORT_WORLD_SORTED;
2258
2259 numWorldsSorted++;
2260 if (numWorldsSorted >= nMaxListSize)
2261 {
2262 bSorting = false;
2263 }
2264
2265 NetLog("SortWorlds: Sorted %02d : ID %d: Score = %d", numWorldsSorted, pBestWorld->m_worldId, pBestWorld->m_score);
2266 }
2267 else
2268 {
2269 //-- No more worlds to add to sorted list
2270 bSorting = false;
2271 }
2272 }
2273 }
2274 else
2275 {
2276 if ((forceWorld >= 1) && (forceWorld <= numTotalWorlds))
2277 {
2278 pReturnIdList[0] = pWorldList->m_pWorlds[forceWorld - 1].m_worldId;
2279 }
2280 else
2281 {
2282 pReturnIdList[0] = pWorldList->m_pWorlds[0].m_worldId;
2283 }
2284 numWorldsSorted = 1;
2285 }
2286 }
2287 }
2288
2289 return numWorldsSorted;
2290 }
2291
2292 void CCryPSNMatchMaking::ProcessExternalRoomData(const SCryPSNRoomDataExternal& curRoom, SCrySessionSearchResult& result, SCrySessionUserData userData[MAX_MATCHMAKING_SESSION_USER_DATA])
2293 {
2294 SCryPSNSessionID* pRoomInfo = new SCryPSNSessionID;
2295
2296 pRoomInfo->m_sessionInfo.m_roomId = curRoom.m_roomId;
2297 pRoomInfo->m_sessionInfo.m_worldId = curRoom.m_worldId;
2298 pRoomInfo->m_sessionInfo.m_serverId = curRoom.m_serverId;
2299 pRoomInfo->m_sessionInfo.m_gameType = 0;
2300 memset(&pRoomInfo->m_sessionId, 0, sizeof(pRoomInfo->m_sessionId));
2301 pRoomInfo->m_fromInvite = false;
2302
2303 result.m_id = pRoomInfo;
2304
2305 result.m_numFilledSlots = curRoom.m_numPublicSlots - curRoom.m_numOpenPublicSlots;
2306 result.m_numFriends = 0;
2307 result.m_flags = 0;
2308
2309 result.m_data.m_ranked = false;
2310 result.m_data.m_name[0] = 0;
2311 result.m_data.m_data = userData;
2312 result.m_data.m_numData = 0;
2313
2314 result.m_data.m_numPublicSlots = curRoom.m_numPublicSlots;
2315 result.m_data.m_numPrivateSlots = curRoom.m_numPrivateSlots;
2316
2317 for (uint32 k = 0; k < SCE_NP_ONLINEID_MAX_LENGTH; k++)
2318 {
2319 result.m_data.m_name[k] = (char)curRoom.m_owner.handle.data[k];
2320 }
2321 result.m_data.m_name[SCE_NP_ONLINEID_MAX_LENGTH] = 0;
2322
2323 for (int a = 0; a < curRoom.m_numSearchableUIntAttributes; a++)
2324 {
2325 for (int b = 0; b < m_registeredUserData.num; b++)
2326 {
2327 if (m_registeredUserData.mapping[b].integerField)
2328 {
2329 if (curRoom.m_searchableUIntAttributes[a].m_id == m_registeredUserData.mapping[b].fieldOffset + SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_1_ID)
2330 {
2331 result.m_data.m_data[result.m_data.m_numData].m_id = m_registeredUserData.data[b].m_id;
2332 result.m_data.m_data[result.m_data.m_numData].m_type = m_registeredUserData.data[b].m_type;
2333 result.m_data.m_data[result.m_data.m_numData].m_int32 = curRoom.m_searchableUIntAttributes[a].m_num;
2334
2335 result.m_data.m_numData++;
2336 break;
2337 }
2338 }
2339 }
2340 }
2341
2342 char binAttrExternalData[SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_MAX_SIZE * SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_NUM];
2343
2344 for (int a = 0; a < curRoom.m_numBinAttributes; a++)
2345 {
2346 memcpy(&binAttrExternalData[SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_MAX_SIZE * a], curRoom.m_binAttributes[a].m_data, curRoom.m_binAttributes[a].m_dataSize);
2347 }
2348
2349 for (int b = 0; b < m_registeredUserData.num; b++)
2350 {
2351 if (!m_registeredUserData.mapping[b].integerField)
2352 {
2353 result.m_data.m_data[result.m_data.m_numData].m_id = m_registeredUserData.data[b].m_id;
2354 result.m_data.m_data[result.m_data.m_numData].m_type = m_registeredUserData.data[b].m_type;
2355
2356 void* dPtr;
2357 switch (result.m_data.m_data[result.m_data.m_numData].m_type)
2358 {
2359 case eCSUDT_Int64:
2360 case eCSUDT_Int64NoEndianSwap:
2361 case eCSUDT_Float64:
2362 dPtr = (void*)&result.m_data.m_data[result.m_data.m_numData].m_int64;
2363 memcpy(dPtr, &binAttrExternalData[m_registeredUserData.mapping[b].fieldOffset], sizeof(result.m_data.m_data[result.m_data.m_numData].m_int64));
2364 break;
2365 case eCSUDT_Int32:
2366 case eCSUDT_Float32:
2367 dPtr = (void*)&result.m_data.m_data[result.m_data.m_numData].m_int32;
2368 memcpy(dPtr, &binAttrExternalData[m_registeredUserData.mapping[b].fieldOffset], sizeof(result.m_data.m_data[result.m_data.m_numData].m_int32));
2369 break;
2370 case eCSUDT_Int16:
2371 dPtr = (void*)&result.m_data.m_data[result.m_data.m_numData].m_int16;
2372 memcpy(dPtr, &binAttrExternalData[m_registeredUserData.mapping[b].fieldOffset], sizeof(result.m_data.m_data[result.m_data.m_numData].m_int16));
2373 break;
2374 case eCSUDT_Int8:
2375 dPtr = (void*)&result.m_data.m_data[result.m_data.m_numData].m_int8;
2376 memcpy(dPtr, &binAttrExternalData[m_registeredUserData.mapping[b].fieldOffset], sizeof(result.m_data.m_data[result.m_data.m_numData].m_int8));
2377 break;
2378 }
2379 result.m_data.m_numData++;
2380 }
2381 }
2382 }
2383
2384 void CCryPSNMatchMaking::BuildUserSessionParams(SSession* pSession, SCrySessionUserData* pData, uint32 numData,
2385 SceNpMatching2BinAttr binAttrExternal[SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_NUM],
2386 SceNpMatching2IntAttr intAttrExternal[SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_NUM],
2387 char binAttrExternalData[SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_MAX_SIZE * SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_NUM])
2388 {
2389 // Setup our advertiser data
2390 for (int a = 0; a < SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_NUM; a++)
2391 {
2392 binAttrExternal[a].id = SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_1_ID + a;
2393 binAttrExternal[a].ptr = &binAttrExternalData[SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_MAX_SIZE * a];
2394 binAttrExternal[a].size = SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_MAX_SIZE; // should really shrink these to avoid sending unused data
2395 }
2396
2397 for (int a = 0; a < SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_NUM; a++)
2398 {
2399 intAttrExternal[a].id = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_1_ID + a;
2400 }
2401
2402 // Build user data into psn format
2403 if (pSession->IsUsed())
2404 {
2405 for (uint32 i = 0; i < numData; i++)
2406 {
2407 uint32 j;
2408
2409 for (j = 0; j < m_registeredUserData.num; j++)
2410 {
2411 if (pData[i].m_id == m_registeredUserData.data[j].m_id)
2412 {
2413 if (pData[i].m_type == m_registeredUserData.data[j].m_type)
2414 {
2415 if (m_registeredUserData.mapping[j].integerField)
2416 {
2417 intAttrExternal[m_registeredUserData.mapping[j].fieldOffset].num = pData[i].m_int32;
2418 }
2419 else
2420 {
2421 void* dPtr;
2422 switch (pData[i].m_type)
2423 {
2424 case eCSUDT_Int64:
2425 case eCSUDT_Int64NoEndianSwap:
2426 case eCSUDT_Float64:
2427 dPtr = (void*)&pData[i].m_int64;
2428 memcpy(&binAttrExternalData[m_registeredUserData.mapping[j].fieldOffset], dPtr, sizeof(pData[i].m_int64));
2429 break;
2430 case eCSUDT_Int32:
2431 case eCSUDT_Float32:
2432 dPtr = (void*)&pData[i].m_int32;
2433 memcpy(&binAttrExternalData[m_registeredUserData.mapping[j].fieldOffset], dPtr, sizeof(pData[i].m_int32));
2434 break;
2435 case eCSUDT_Int16:
2436 dPtr = (void*)&pData[i].m_int16;
2437 memcpy(&binAttrExternalData[m_registeredUserData.mapping[j].fieldOffset], dPtr, sizeof(pData[i].m_int16));
2438 break;
2439 case eCSUDT_Int8:
2440 dPtr = (void*)&pData[i].m_int8;
2441 memcpy(&binAttrExternalData[m_registeredUserData.mapping[j].fieldOffset], dPtr, sizeof(pData[i].m_int8));
2442 break;
2443 }
2444 }
2445 }
2446 }
2447 }
2448 }
2449 }
2450 }
2451
2452 // SESSION CREATE -----------------------------------------------------------------------------------------
2453
2454 ECryLobbyError CCryPSNMatchMaking::SessionCreate(uint32* users, int numUsers, uint32 flags, SCrySessionData* data, CryLobbyTaskID* taskID, CryMatchmakingSessionCreateCallback cb, void* cbArg)
2455 {
2456 LOBBY_AUTO_LOCK;
2457
2458 CryLobbySessionHandle h;
2459 ECryLobbyError error = CreateSessionHandle(&h, true, users, numUsers, flags);
2460
2461 if (error == eCLE_Success)
2462 {
2463 CryMatchMakingTaskID mmTaskID;
2464
2465 error = StartTask(eT_SessionCreate, false, users[0], &mmTaskID, taskID, h, (void*)cb, cbArg);
2466
2467 if (error == eCLE_Success)
2468 {
2469 SSession* pSession = &m_sessions[h];
2470
2471 pSession->m_flags = SCE_NP_MATCHING2_ROOM_FLAG_ATTR_OWNER_AUTO_GRANT; // Auto migrate
2472
2473 if ((flags & CRYSESSION_CREATE_FLAG_SEARCHABLE) == 0)
2474 {
2475 pSession->m_flags |= SCE_NP_MATCHING2_ROOM_FLAG_ATTR_HIDDEN;
2476 }
2477
2478 if (data->m_ranked)
2479 {
2480 pSession->m_flags |= 0; // TODO.. implement ranked rooms
2481 pSession->m_gameType = 0;
2482 }
2483 else
2484 {
2485 pSession->m_gameType = 0;
2486 }
2487
2488 pSession->m_gameMode = 0;
2489 pSession->m_numPublicSlots = data->m_numPublicSlots;
2490 pSession->m_numPrivateSlots = data->m_numPrivateSlots;
2491
2492 NetLog("[Lobby] Created local connection " PRFORMAT_SH " " PRFORMAT_UID, PRARG_SH(h), PRARG_UID(pSession->localConnection.uid));
2493
2494 for (uint32 i = 0; i < numUsers; i++)
2495 {
2496 pSession->localConnection.privateSlot[i] = TRUE;
2497 }
2498
2499 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_CREATE_PARAMS_SLOT, data, 1, sizeof(SCrySessionData));
2500
2501 if (error == eCLE_Success)
2502 {
2503 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_CREATE_DATA_SLOT, data->m_data, data->m_numData, data->m_numData * sizeof(data->m_data[0]));
2504
2505 if (error == eCLE_Success)
2506 {
2507 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_CREATE_REQUEST_SLOT, NULL, 1, sizeof(SCreateParamData));
2508
2509 if (error == eCLE_Success)
2510 {
2511 // This next alloc is a doozy - 165KB-ish
2512 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_WEBAPI_CREATE_SLOT, NULL, 1, sizeof(SCryPSNOrbisWebApiCreateSessionInput));
2513 if (error == eCLE_Success)
2514 {
2515 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
2516
2517 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
2518 }
2519 }
2520 }
2521 }
2522
2523 if (error != eCLE_Success)
2524 {
2525 FreeTask(mmTaskID);
2526 FreeSessionHandle(h);
2527 }
2528 }
2529 else
2530 {
2531 FreeSessionHandle(h);
2532 }
2533 }
2534
2535 NetLog("[Lobby] Start SessionCreate error %d", error);
2536
2537 return error;
2538 }
2539
2540 void CCryPSNMatchMaking::TickSessionCreate(CryMatchMakingTaskID mmTaskID)
2541 {
2542 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
2543 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
2544 {
2545 STask* pTask = &m_task[mmTaskID];
2546
2547 //-- get the world list
2548 StartSubTask(eST_WaitingForCreateRoomWorldInfo, mmTaskID);
2549
2550 SceNpMatching2GetWorldInfoListRequest reqParam;
2551 memset(&reqParam, 0, sizeof(reqParam));
2552 reqParam.serverId = m_pPSNSupport->GetServerInfo()->server.serverId;
2553
2554 int ret = sceNpMatching2GetWorldInfoList(m_pPSNSupport->GetMatchmakingContextId(), &reqParam, NULL, &pTask->m_reqId);
2555 if (ret == PSN_OK)
2556 {
2557 //-- Waiting for callback
2558 }
2559 else
2560 {
2561 NetLog("sceNpMatching2GetWorldInfoList : error %08X", ret);
2562 if (!m_pPSNSupport->HandlePSNError(ret))
2563 {
2564 UpdateTaskError(mmTaskID, eCLE_WorldNotDefined);
2565 }
2566 }
2567 }
2568 }
2569
2570 bool CCryPSNMatchMaking::EventRequestResponse_GetWorldInfoListForCreate(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
2571 {
2572 assert(pTask->subTask == eST_WaitingForCreateRoomWorldInfo);
2573 assert(data.m_requestEvent.m_event == REQUEST_EVENT_GET_WORLD_INFO_LIST);
2574 assert(data.m_requestEvent.m_dataSize == sizeof(SCryPSNGetWorldInfoListResponse));
2575
2576 if ((data.m_requestEvent.m_error == 0) &&
2577 (data.m_requestEvent.m_dataHdl != TMemInvalidHdl) &&
2578 (data.m_requestEvent.m_dataSize == sizeof(SCryPSNGetWorldInfoListResponse)))
2579 {
2580 SCreateParamData* pCreateParams = (SCreateParamData*)_this->m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_CREATE_REQUEST_SLOT]);
2581 if (pCreateParams)
2582 {
2583 memset(pCreateParams, 0, sizeof(SCreateParamData));
2584
2585 const SCryPSNGetWorldInfoListResponse* pWorldList = (SCryPSNGetWorldInfoListResponse*)_this->m_lobby->MemGetPtr(data.m_requestEvent.m_dataHdl);
2586
2587 uint32 listSize = SortWorlds(pWorldList, &pCreateParams->m_createRequest.worldId, 1, false);
2588 if ((listSize > 0) && (pCreateParams->m_createRequest.worldId != INVALID_PSN_WORLD_ID))
2589 {
2590 _this->StartSubTask(eST_SessionCreateRequest, taskId);
2591 }
2592 else
2593 {
2594 _this->UpdateTaskError(taskId, eCLE_WorldNotDefined);
2595 }
2596 }
2597 else
2598 {
2599 _this->UpdateTaskError(taskId, eCLE_OutOfMemory);
2600 }
2601
2602 return true;
2603 }
2604 else
2605 {
2606 return false;
2607 }
2608 }
2609
2610 // At present there are only 8 possible searchable integer values (so we need to be careful with which attributes use them.
2611 // For now I have chucked all the data into the 2 binary attributes (256 bytes each). If I run out, i`ll panic later.
2612 void CCryPSNMatchMaking::TickSessionCreateRequest(CryMatchMakingTaskID mmTaskID)
2613 {
2614 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
2615 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
2616 {
2617 STask* pTask = &m_task[mmTaskID];
2618
2619 if (pTask->params[PSN_MATCHMAKING_CREATE_PARAMS_SLOT] != TMemInvalidHdl)
2620 {
2621 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_CREATE_REQUEST_SLOT] != TMemInvalidHdl)
2622 {
2623 SCrySessionData* pData = (SCrySessionData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_CREATE_PARAMS_SLOT]);
2624 if (pTask->params[PSN_MATCHMAKING_CREATE_DATA_SLOT] != TMemInvalidHdl)
2625 {
2626 pData->m_data = (SCrySessionUserData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_CREATE_DATA_SLOT]);
2627 }
2628 else
2629 {
2630 pData->m_data = NULL;
2631 }
2632
2633 SCreateParamData* pCreateParams = (SCreateParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_CREATE_REQUEST_SLOT]);
2634 SSession* pSession = &m_sessions[pTask->session];
2635
2636 BuildUserSessionParams(pSession, pData->m_data, pData->m_numData, pCreateParams->m_binAttrExternal, pCreateParams->m_intAttrExternal, pCreateParams->m_binAttrExternalData);
2637
2638 // Internal data defaults
2639 for (int32 index = 0; index < SCE_NP_MATCHING2_ROOM_BIN_ATTR_INTERNAL_NUM; ++index)
2640 {
2641 pCreateParams->m_binAttrInternal[index].id = SCE_NP_MATCHING2_ROOM_BIN_ATTR_INTERNAL_1_ID + index;
2642 pCreateParams->m_binAttrInternal[index].ptr = &pCreateParams->m_binAttrInternalData[SCE_NP_MATCHING2_ROOM_BIN_ATTR_INTERNAL_MAX_SIZE * index];
2643 pCreateParams->m_binAttrInternal[index].size = SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_MAX_SIZE; // should really shrink these to avoid sending unused data
2644 }
2645
2646 // Build internal data
2647 const int numInternalData = 1;
2648 uint16 sessionCreateGameFlags = (pSession->createFlags & CRYSESSION_CREATE_FLAG_GAME_MASK) >> CRYSESSION_CREATE_FLAG_GAME_FLAGS_SHIFT;
2649 memcpy((void*)pCreateParams->m_binAttrInternal[0].ptr, &sessionCreateGameFlags, sizeof(sessionCreateGameFlags));
2650 pCreateParams->m_binAttrInternal[0].size = sizeof(sessionCreateGameFlags);
2651
2652 SceNpMatching2SignalingOptParam sigParams;
2653 sigParams.type = SCE_NP_MATCHING2_SIGNALING_TYPE_MESH;
2654 sigParams.flag = 0;
2655 sigParams.hubMemberId = 0;
2656
2657 pCreateParams->m_createRequest.maxSlot = pSession->m_numPrivateSlots + pSession->m_numPublicSlots;
2658 pCreateParams->m_createRequest.flagAttr = pSession->m_flags;
2659 pCreateParams->m_createRequest.roomPassword = NULL;
2660 pCreateParams->m_createRequest.groupConfig = NULL;
2661 pCreateParams->m_createRequest.groupConfigNum = 0;
2662 pCreateParams->m_createRequest.passwordSlotMask = NULL;
2663 pCreateParams->m_createRequest.allowedUser = NULL;
2664 pCreateParams->m_createRequest.allowedUserNum = 0;
2665 pCreateParams->m_createRequest.blockedUser = NULL;
2666 pCreateParams->m_createRequest.blockedUserNum = 0;
2667 pCreateParams->m_createRequest.sigOptParam = &sigParams;
2668 pCreateParams->m_createRequest.roomBinAttrInternal = pCreateParams->m_binAttrInternal;
2669 pCreateParams->m_createRequest.roomBinAttrInternalNum = numInternalData;
2670 pCreateParams->m_createRequest.roomBinAttrExternal = pCreateParams->m_binAttrExternal;
2671 pCreateParams->m_createRequest.roomBinAttrExternalNum = SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_NUM;
2672 pCreateParams->m_createRequest.roomSearchableBinAttrExternal = NULL;
2673 pCreateParams->m_createRequest.roomSearchableBinAttrExternalNum = 0;
2674 pCreateParams->m_createRequest.roomSearchableIntAttrExternal = pCreateParams->m_intAttrExternal;
2675 pCreateParams->m_createRequest.roomSearchableIntAttrExternalNum = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_NUM;
2676 pCreateParams->m_createRequest.joinRoomGroupLabel = NULL;
2677 pCreateParams->m_createRequest.roomMemberBinAttrInternal = NULL;
2678 pCreateParams->m_createRequest.roomMemberBinAttrInternalNum = 0;
2679 pCreateParams->m_createRequest.teamId = 0;
2680
2681 StartSubTask(eST_WaitingForCreateRoomRequestCallback, mmTaskID);
2682
2683 int ret = sceNpMatching2CreateJoinRoom(m_pPSNSupport->GetMatchmakingContextId(), &pCreateParams->m_createRequest, NULL, &pTask->m_reqId);
2684 if (ret == PSN_OK)
2685 {
2686 //-- waiting for callback
2687 }
2688 else
2689 {
2690 NetLog("sceNpMatching2CreateJoinRoom : error %08X", ret);
2691 //-- triggering a PSN error will cause an error event into SupportCallback() and set a task error if it needs to clean up.
2692 //-- otherwise, we have to update the task error ourself.
2693 if (!m_pPSNSupport->HandlePSNError(ret))
2694 {
2695 UpdateTaskError(mmTaskID, eCLE_InternalError);
2696 }
2697 }
2698 }
2699 else
2700 {
2701 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
2702 }
2703 }
2704 else
2705 {
2706 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
2707 }
2708 }
2709 }
2710
2711 bool CCryPSNMatchMaking::EventRequestResponse_CreateRoom(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
2712 {
2713 // sanity
2714 assert(pTask->subTask == eST_WaitingForCreateRoomRequestCallback);
2715 assert(data.m_requestEvent.m_event == REQUEST_EVENT_CREATE_JOIN_ROOM);
2716 assert(data.m_requestEvent.m_dataHdl != TMemInvalidHdl);
2717 assert(data.m_requestEvent.m_dataSize == sizeof(SCryPSNCreateJoinRoomResponse));
2718
2719 if ((data.m_requestEvent.m_error == 0) &&
2720 (data.m_requestEvent.m_dataHdl != TMemInvalidHdl) &&
2721 (data.m_requestEvent.m_dataSize == sizeof(SCryPSNCreateJoinRoomResponse)))
2722 {
2723 const SCryPSNCreateJoinRoomResponse* pCreateResponse = (SCryPSNCreateJoinRoomResponse*)_this->m_pPSNSupport->GetLobby()->MemGetPtr(data.m_requestEvent.m_dataHdl);
2724
2725 if (pTask->session != CryLobbyInvalidSessionHandle)
2726 {
2727 SSession* pSession = &_this->m_sessions[pTask->session];
2728 if (pSession->IsUsed())
2729 {
2730 pSession->m_roomId = pCreateResponse->m_roomInfo.m_roomId;
2731 pSession->m_worldId = pCreateResponse->m_roomInfo.m_worldId;
2732 pSession->m_serverId = pCreateResponse->m_roomInfo.m_serverId;
2733
2734 if (!pTask->canceled)
2735 {
2736 _this->AddInitialRoomMembers(pTask->session, pCreateResponse->m_roomMembers);
2737 _this->StartSubTask(eST_WaitingForCreateRoomSignalingCallback, taskId);
2738 }
2739 else
2740 {
2741 _this->UpdateTaskError(taskId, eCLE_IllegalSessionJoin);
2742 }
2743 }
2744 else
2745 {
2746 _this->UpdateTaskError(taskId, eCLE_InternalError);
2747 }
2748 }
2749 else
2750 {
2751 _this->UpdateTaskError(taskId, eCLE_InternalError);
2752 }
2753
2754 return true;
2755 }
2756 else
2757 {
2758 return false;
2759 }
2760 }
2761
2762 void CCryPSNMatchMaking::TickSessionCreateSignaling(CryMatchMakingTaskID mmTaskID)
2763 {
2764 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
2765 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
2766 {
2767 STask* pTask = &m_task[mmTaskID];
2768
2769 UpdateSignaling(mmTaskID);
2770
2771 switch (CheckSignaling(mmTaskID))
2772 {
2773 case ePSNCS_None:
2774 {
2775 //-- This is bad, means there is no room owner!
2776 UpdateTaskError(mmTaskID, eCLE_InvalidParam);
2777 }
2778 break;
2779
2780 case ePSNCS_Active:
2781 {
2782 assert(pTask->subTask == eST_WaitingForCreateRoomSignalingCallback);
2783
2784 if (pTask->session != CryLobbyInvalidSessionHandle)
2785 {
2786 SSession* pSession = &m_sessions[pTask->session];
2787 if (pSession->IsUsed())
2788 {
2789 if (!pTask->canceled)
2790 {
2791 if (pSession->createFlags & CRYSESSION_CREATE_FLAG_INVITABLE)
2792 {
2793 SCrySessionData* pSessionData = (SCrySessionData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_CREATE_PARAMS_SLOT]);
2794 SCreateParamData* pCreateParams = (SCreateParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_CREATE_REQUEST_SLOT]);
2795 SCryPSNOrbisWebApiCreateSessionInput* pWebApiCreateParams = (SCryPSNOrbisWebApiCreateSessionInput*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_WEBAPI_CREATE_SLOT]);
2796 if (pSessionData && pCreateParams && pWebApiCreateParams)
2797 {
2798 StartSubTask(eST_WaitingForCreateRoomWebApiCallback, mmTaskID);
2799
2800 memset(pWebApiCreateParams, 0, sizeof(SCryPSNOrbisWebApiCreateSessionInput));
2801
2802 // Some of the SCryLobbySessionAdvertisement we can fill in now.
2803 SCryLobbySessionAdvertisement& advertisement = pWebApiCreateParams->advertisement;
2804
2805 advertisement.m_numSlots = pSessionData->m_numPublicSlots + pSessionData->m_numPrivateSlots;
2806 advertisement.m_bIsPrivate = false;
2807 advertisement.m_bIsEditableByAll = true;
2808 advertisement.m_pData = pWebApiCreateParams->data;
2809
2810 if (pTask->session != CryLobbyInvalidSessionHandle)
2811 {
2812 // default session advertisement data should be set to the matching2 room info if available
2813 SSession* pSession = &m_sessions[pTask->session];
2814 SSynchronisedSessionID* pSessionInfo = (SSynchronisedSessionID*)advertisement.m_pData;
2815
2816 pSessionInfo->m_serverId = pSession->m_serverId;
2817 pSessionInfo->m_worldId = pSession->m_worldId;
2818 pSessionInfo->m_roomId = pSession->m_roomId;
2819 pSessionInfo->m_gameType = pSession->m_gameType;
2820 advertisement.m_sizeofData = sizeof(SSynchronisedSessionID);
2821 }
2822 else
2823 {
2824 // otherwise just set the session advertisement data to an empty chunk of maximum size
2825 advertisement.m_sizeofData = CRY_WEBAPI_CREATESESSION_LINKDATA_MAX_SIZE;
2826 }
2827
2828 // The rest needs filling in and/or modifying via configuration callback to the game.
2829 SConfigurationParams neededInfo = {
2830 CLCC_PSN_CREATE_SESSION_ADVERTISEMENT, { NULL }
2831 };
2832 neededInfo.m_pData = (void*)&pWebApiCreateParams->advertisement;
2833 m_lobby->GetConfigurationInformation(&neededInfo, 1);
2834
2835 // And now we should have a completed SCryLobbySessionAdvertisement structure available to us. We'll be using this in CCryPSNOrbisWebApiThread::CreateSession later on.
2836 pCreateParams->m_createJobId = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::CreateSession, pTask->params[PSN_MATCHMAKING_WEBAPI_CREATE_SLOT]);
2837 if (pCreateParams->m_createJobId == INVALID_WEBAPI_JOB_ID)
2838 {
2839 // failed
2840 UpdateTaskError(mmTaskID, eCLE_InternalError);
2841 }
2842 }
2843 else
2844 {
2845 UpdateTaskError(mmTaskID, eCLE_InternalError);
2846 }
2847 }
2848 else
2849 {
2850 // Session is not invitable, so we don't need the session Id.
2851 UpdateTaskError(mmTaskID, eCLE_Success);
2852 StopTaskRunning(mmTaskID);
2853 }
2854 }
2855 else
2856 {
2857 // cancelled
2858 UpdateTaskError(mmTaskID, eCLE_IllegalSessionJoin);
2859 }
2860 }
2861 else
2862 {
2863 UpdateTaskError(mmTaskID, eCLE_InternalError);
2864 }
2865 }
2866 else
2867 {
2868 UpdateTaskError(mmTaskID, eCLE_InternalError);
2869 }
2870 }
2871 break;
2872
2873 case ePSNCS_Dead:
2874 {
2875 assert(pTask->subTask == eST_WaitingForCreateRoomSignalingCallback);
2876
2877 UpdateTaskError(mmTaskID, eCLE_ConnectionFailed);
2878 }
2879 break;
2880 }
2881 }
2882 }
2883
2884 void CCryPSNMatchMaking::EventWebApiCreateSession(CryMatchMakingTaskID mmTaskID, SCryPSNSupportCallbackEventData& data)
2885 {
2886 STask* pTask = &m_task[mmTaskID];
2887
2888 if (pTask->session != CryLobbyInvalidSessionHandle)
2889 {
2890 SSession* pSession = &m_sessions[pTask->session];
2891
2892 memset(&pSession->m_sessionId, 0, sizeof(SceNpSessionId));
2893
2894 if (data.m_webApiEvent.m_error == PSN_OK)
2895 {
2896 if (data.m_webApiEvent.m_pResponseBody)
2897 {
2898 if (data.m_webApiEvent.m_pResponseBody->eType == SCryPSNWebApiResponseBody::E_JSON)
2899 {
2900 // parse json to get session ID
2901 // CCryPSNWebApiJobController::PrintResponseJSONTree(data.m_webApiEvent.m_pResponseBody);
2902 const sce::Json::Value& val = data.m_webApiEvent.m_pResponseBody->jsonTreeRoot["sessionId"];
2903 if (val.getType() == sce::Json::kValueTypeString)
2904 {
2905 strncpy((char*)&pSession->m_sessionId, val.toString().c_str(), sizeof(pSession->m_sessionId.data));
2906 pSession->m_sessionId.term = 0;
2907
2908 // Completed successfully
2909 UpdateTaskError(mmTaskID, eCLE_Success);
2910 StopTaskRunning(mmTaskID);
2911
2912 return;
2913 }
2914 }
2915 }
2916 }
2917
2918 // something went wrong
2919 UpdateTaskError(mmTaskID, eCLE_InternalError);
2920 StopTaskRunning(mmTaskID);
2921 }
2922
2923 // otherwise something went wrong!
2924 UpdateTaskError(mmTaskID, eCLE_InternalError);
2925 StopTaskRunning(mmTaskID);
2926 }
2927
2928 void CCryPSNMatchMaking::EndSessionCreate(CryMatchMakingTaskID mmTaskID)
2929 {
2930 STask* pTask = &m_task[mmTaskID];
2931 SSession* pSession = &m_sessions[pTask->session];
2932
2933 if (pTask->error == eCLE_Success)
2934 {
2935 SCryMatchMakingConnectionUID matchingUID;
2936 matchingUID.m_uid = pSession->m_myMemberId;
2937 matchingUID.m_sid = pSession->m_roomId;
2938
2939 pSession->localConnection.uid = matchingUID;
2940 pSession->localConnection.pingToServer = CRYLOBBY_INVALID_PING;
2941 pSession->localConnection.used = true;
2942 pSession->hostConnectionID = CryMatchMakingInvalidConnectionID;
2943 }
2944 else
2945 {
2946 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
2947 }
2948
2949 ((CryMatchmakingSessionCreateCallback)pTask->cb)(pTask->lTaskID, pTask->error, CreateGameSessionHandle(pTask->session, pSession->localConnection.uid), pTask->cbArg);
2950
2951 if (pTask->error == eCLE_Success)
2952 {
2953 InitialUserDataEvent(pTask->session);
2954 }
2955 }
2956
2957 // END SESSON CREATE ---------------------------------------------------------------------------------------
2958
2959 ECryLobbyError CCryPSNMatchMaking::SessionMigrate(CrySessionHandle gh, uint32* pUsers, int numUsers, uint32 flags, SCrySessionData* pData, CryLobbyTaskID* pTaskID, CryMatchmakingSessionCreateCallback pCB, void* pCBArg)
2960 {
2961 ECryLobbyError error = eCLE_Success;
2962
2963 LOBBY_AUTO_LOCK;
2964
2965 // Because we simply want to re-use the session that is already available, we don't need to do much here
2966
2967 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
2968
2969 if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
2970 {
2971 SSession* pSession = &m_sessions[h];
2972 CryMatchMakingTaskID mmTaskID;
2973
2974 error = StartTask(eT_SessionMigrate, false, pSession->localConnection.users[0], &mmTaskID, pTaskID, h, (void*)pCB, pCBArg);
2975
2976 if (error == eCLE_Success)
2977 {
2978 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
2979 }
2980 }
2981 else
2982 {
2983 error = eCLE_InvalidSession;
2984 }
2985
2986 NetLog("[Lobby] Start SessionMigrate error %d", error);
2987
2988 return error;
2989 }
2990
2991 void CCryPSNMatchMaking::TickSessionMigrate(CryMatchMakingTaskID mmTaskID)
2992 {
2993 UpdateTaskError(mmTaskID, eCLE_Success);
2994 StopTaskRunning(mmTaskID);
2995 }
2996
2997 ECryLobbyError CCryPSNMatchMaking::SessionUpdate(CrySessionHandle gh, SCrySessionUserData* pData, uint32 numData, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
2998 {
2999 ECryLobbyError error = eCLE_Success;
3000
3001 LOBBY_AUTO_LOCK;
3002
3003 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
3004
3005 if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
3006 {
3007 SSession* session = &m_sessions[h];
3008
3009 if (session->localFlags & CRYSESSION_LOCAL_FLAG_HOST)
3010 {
3011 CryMatchMakingTaskID mmTaskID;
3012
3013 error = StartTask(eT_SessionUpdate, false, session->localConnection.users[0], &mmTaskID, pTaskID, h, (void*)pCB, pCBArg);
3014
3015 if (error == eCLE_Success)
3016 {
3017 STask* task = &m_task[mmTaskID];
3018
3019 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_UPDATE_DATA_SLOT, pData, numData, numData * sizeof(pData[0]));
3020
3021 if (error == eCLE_Success)
3022 {
3023 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_UPDATE_REQUEST_SLOT, NULL, 1, sizeof(SUpdateParamData));
3024 if (error == eCLE_Success)
3025 {
3026 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3027
3028 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
3029 }
3030 else
3031 {
3032 FreeTask(mmTaskID);
3033 }
3034 }
3035 else
3036 {
3037 FreeTask(mmTaskID);
3038 }
3039 }
3040 }
3041 else
3042 {
3043 error = eCLE_InvalidRequest;
3044 }
3045 }
3046 else
3047 {
3048 error = eCLE_InvalidSession;
3049 }
3050
3051 NetLog("[Lobby] Start SessionUpdate error %d", error);
3052
3053 return error;
3054 }
3055
3056 void CCryPSNMatchMaking::TickSessionUpdate(CryMatchMakingTaskID mmTaskID)
3057 {
3058 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3059 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
3060 {
3061 STask* pTask = &m_task[mmTaskID];
3062
3063 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_UPDATE_REQUEST_SLOT] != TMemInvalidHdl)
3064 {
3065 SUpdateParamData* pUpdateParams = (SUpdateParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_UPDATE_REQUEST_SLOT]);
3066 SCrySessionUserData* pData = (SCrySessionUserData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_UPDATE_DATA_SLOT]);
3067 SSession* pSession = &m_sessions[pTask->session];
3068
3069 memset(pUpdateParams, 0, sizeof(SUpdateParamData));
3070
3071 BuildUserSessionParams(pSession, pData, pTask->numParams[0], pUpdateParams->m_binAttrExternal, pUpdateParams->m_intAttrExternal, pUpdateParams->m_binAttrExternalData);
3072
3073 pUpdateParams->m_updateRequest.roomId = pSession->m_roomId;
3074
3075 pUpdateParams->m_updateRequest.roomSearchableIntAttrExternal = pUpdateParams->m_intAttrExternal;
3076 pUpdateParams->m_updateRequest.roomSearchableBinAttrExternal = NULL;
3077 pUpdateParams->m_updateRequest.roomBinAttrExternal = pUpdateParams->m_binAttrExternal;
3078
3079 pUpdateParams->m_updateRequest.roomSearchableBinAttrExternalNum = 0;
3080 pUpdateParams->m_updateRequest.roomSearchableIntAttrExternalNum = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_NUM;
3081 pUpdateParams->m_updateRequest.roomBinAttrExternalNum = SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_NUM;
3082
3083 StartSubTask(eST_WaitingForUpdateRoomRequestCallback, mmTaskID);
3084
3085 int ret = sceNpMatching2SetRoomDataExternal(m_pPSNSupport->GetMatchmakingContextId(), &pUpdateParams->m_updateRequest, NULL, &pTask->m_reqId);
3086 if (ret == PSN_OK)
3087 {
3088 //-- Waiting for callback
3089 }
3090 else
3091 {
3092 NetLog("sceNpMatching2SetRoomDataExternal : error %08X", ret);
3093 if (!m_pPSNSupport->HandlePSNError(ret))
3094 {
3095 UpdateTaskError(mmTaskID, eCLE_InternalError);
3096 }
3097 }
3098 }
3099 else
3100 {
3101 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
3102 }
3103 }
3104 }
3105
3106 bool CCryPSNMatchMaking::EventRequestResponse_SetRoomDataExternal(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
3107 {
3108 // sanity
3109 assert(pTask->subTask == eST_WaitingForUpdateRoomRequestCallback);
3110 assert(data.m_requestEvent.m_event == REQUEST_EVENT_SET_ROOM_DATA_EXTERNAL);
3111 assert(data.m_requestEvent.m_dataSize == 0);
3112
3113 if (data.m_requestEvent.m_error == 0)
3114 {
3115 _this->UpdateTaskError(taskId, eCLE_Success);
3116 _this->StopTaskRunning(taskId);
3117
3118 return true;
3119 }
3120 else
3121 {
3122 // return false to let the default error handler work
3123 return false;
3124 }
3125 }
3126
3127 // END SESSION UPDATE ------------------------------------------------------------------------
3128
3129 ECryLobbyError CCryPSNMatchMaking::SessionUpdateSlots(CrySessionHandle gh, uint32 numPublic, uint32 numPrivate, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
3130 {
3131 ECryLobbyError error = eCLE_Success;
3132
3133 LOBBY_AUTO_LOCK;
3134
3135 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
3136
3137 if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
3138 {
3139 CryMatchMakingTaskID tid;
3140
3141 error = StartTask(eT_SessionUpdateSlots, false, m_sessions[h].localConnection.users[0], &tid, pTaskID, h, (void*)pCB, pCBArg);
3142
3143 if (error == eCLE_Success)
3144 {
3145 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, tid);
3146 }
3147 }
3148 else
3149 {
3150 error = eCLE_InvalidSession;
3151 }
3152
3153 NetLog("[Lobby] Start SessionUpdateSlots return %d", error);
3154
3155 return error;
3156 }
3157
3158 #if NETWORK_HOST_MIGRATION
3159 ECryLobbyError CCryPSNMatchMaking::SendHostHintExternal(CryLobbySessionHandle h)
3160 {
3161 ECryLobbyError error = eCLE_Success;
3162 LOBBY_AUTO_LOCK;
3163
3164 if (net_enable_psn_hinting)
3165 {
3166 if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
3167 {
3168 SSession* pSession = &m_sessions[h];
3169
3170 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_HOST)
3171 {
3172 CryMatchMakingTaskID mmTaskID;
3173
3174 bool taskRunning = false;
3175 for (uint32 taskID = 0; taskID < MAX_MATCHMAKING_TASKS; ++taskID)
3176 {
3177 STask* pTask = &m_task[taskID];
3178
3179 if (pTask->used && pTask->running && (pTask->startedTask == eT_SessionSendHostHintExternal) && (pTask->session == h))
3180 {
3181 #if NET_HOST_HINT_DEBUG
3182 NetLog("[Host Hints]: hints already in flight to PSN, will resend when done");
3183 #endif // #if NET_HOST_HINT_DEBUG
3184 pTask->numParams[PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_RESTART] = eHHTB_REQUIRES_RESTART;
3185 taskRunning = true;
3186 break;
3187 }
3188 }
3189
3190 if (!taskRunning)
3191 {
3192 error = StartTask(eT_SessionSendHostHintExternal, false, pSession->localConnection.users[0], &mmTaskID, NULL, h, NULL, NULL);
3193 if (error == eCLE_Success)
3194 {
3195 STask* pTask = &m_task[mmTaskID];
3196 pTask->numParams[PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_RESTART] = eHHTB_NORMAL;
3197
3198 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_REQUEST_SLOT, NULL, 1, sizeof(SHostHintParamData));
3199
3200 if (error == eCLE_Success)
3201 {
3202 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3203
3204 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
3205 }
3206 }
3207 else
3208 {
3209 error = eCLE_InternalError;
3210 }
3211 }
3212 }
3213 else
3214 {
3215 error = eCLE_InvalidRequest;
3216 }
3217 }
3218 else
3219 {
3220 error = eCLE_InvalidSession;
3221 }
3222 }
3223
3224 NetLog("[Host Hints] Start SendHostHintExternal error %d", error);
3225
3226 return error;
3227 }
3228
3229 void CCryPSNMatchMaking::StartSessionSendHostHintExternal(CryMatchMakingTaskID mmTaskID)
3230 {
3231 STask* pTask = &m_task[mmTaskID];
3232
3233 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_REQUEST_SLOT] != TMemInvalidHdl)
3234 {
3235 SHostHintParamData* pHostHintParams = (SHostHintParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_REQUEST_SLOT]);
3236 memset(pHostHintParams, 0, sizeof(SHostHintParamData));
3237 SSession* pSession = &m_sessions[pTask->session];
3238
3239 for (uint32 index = 0; index < pSession->newHostPriorityCount; ++index)
3240 {
3241 pHostHintParams->m_memberId[index] = ((CCryPSNMatchMaking::SSession::SRConnection*)(pSession->newHostPriority[index]))->memberId;
3242 }
3243
3244 pHostHintParams->m_reqParam.roomId = pSession->m_roomId;
3245 pHostHintParams->m_reqParam.ownerPrivilegeRank = pHostHintParams->m_memberId;
3246 pHostHintParams->m_reqParam.ownerPrivilegeRankNum = pSession->newHostPriorityCount;
3247
3248 NetLog("[Host Hints]: PSN SendHostHintExternal " PRFORMAT_SH " roomId 0x%llX Rank[0] %d RankNum %d",
3249 PRARG_SH(pTask->session), (uint64)pHostHintParams->m_reqParam.roomId, pHostHintParams->m_reqParam.ownerPrivilegeRank[0], pHostHintParams->m_reqParam.ownerPrivilegeRankNum);
3250
3251 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3252 }
3253 else
3254 {
3255 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
3256 }
3257
3258 if (pTask->error != eCLE_Success)
3259 {
3260 StopTaskRunning(mmTaskID);
3261 }
3262 }
3263
3264 void CCryPSNMatchMaking::TickSessionSendHostHintExternal(CryMatchMakingTaskID mmTaskID)
3265 {
3266 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3267 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
3268 {
3269 STask* pTask = &m_task[mmTaskID];
3270
3271 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_REQUEST_SLOT] != TMemInvalidHdl)
3272 {
3273 SHostHintParamData* pHostHintParams = (SHostHintParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_REQUEST_SLOT]);
3274
3275 StartSubTask(eST_WaitingForNewHostHintCallback, mmTaskID);
3276
3277 int ret = sceNpMatching2SetRoomDataInternal(m_pPSNSupport->GetMatchmakingContextId(), &pHostHintParams->m_reqParam, NULL, &pTask->m_reqId);
3278 if (ret == PSN_OK)
3279 {
3280 //-- waiting for callback
3281 }
3282 else
3283 {
3284 NetLog("sceNpMatching2SetRoomDataInternal : error %08X", ret);
3285 //-- triggering a PSN error will cause an error event into SupportCallback() and set a task error if it needs to clean up.
3286 //-- otherwise, we have to update the task error ourself.
3287 if (!m_pPSNSupport->HandlePSNError(ret))
3288 {
3289 UpdateTaskError(mmTaskID, eCLE_InternalError);
3290 }
3291 }
3292 }
3293 else
3294 {
3295 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
3296 }
3297 }
3298 }
3299
3300 bool CCryPSNMatchMaking::EventRequestResponse_SetRoomDataInternal(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
3301 {
3302 // sanity
3303 assert(pTask->subTask == eST_WaitingForNewHostHintCallback);
3304 assert(data.m_requestEvent.m_event == REQUEST_EVENT_SET_ROOM_DATA_INTERNAL);
3305 assert(data.m_requestEvent.m_dataSize == 0);
3306
3307 if (data.m_requestEvent.m_error == 0)
3308 {
3309 _this->UpdateTaskError(taskId, eCLE_Success);
3310 _this->StopTaskRunning(taskId);
3311
3312 return true;
3313 }
3314 else
3315 {
3316 // return false to let the default error handler work
3317 return false;
3318 }
3319 }
3320
3321 void CCryPSNMatchMaking::EndSessionSendHostHintExternal(CryMatchMakingTaskID mmTaskID)
3322 {
3323 STask* pTask = &m_task[mmTaskID];
3324 if (pTask->numParams[PSN_MATCHMAKING_PSNSUPPORT_HOSTHINT_RESTART] == eHHTB_REQUIRES_RESTART)
3325 {
3326 #if NET_HOST_HINT_DEBUG
3327 NetLog("[Host Hints]: hints changed whilst informing PSN, resending hints to PSN");
3328 #endif // #if NET_HOST_HINT_DEBUG
3329 SendHostHintExternal(pTask->session);
3330 }
3331 }
3332 #endif
3333
3334 ECryLobbyError CCryPSNMatchMaking::SessionQuery(CrySessionHandle gh, CryLobbyTaskID* pTaskID, CryMatchmakingSessionQueryCallback pCB, void* pCBArg)
3335 {
3336 ECryLobbyError error = eCLE_Success;
3337
3338 LOBBY_AUTO_LOCK;
3339
3340 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
3341
3342 if ((h < MAX_MATCHMAKING_SESSIONS) && m_sessions[h].IsUsed())
3343 {
3344 SSession* pSession = &m_sessions[h];
3345 CryMatchMakingTaskID mmTaskID;
3346
3347 error = StartTask(eT_SessionQuery, false, pSession->localConnection.users[0], &mmTaskID, pTaskID, h, (void*)pCB, pCBArg);
3348 if (error == eCLE_Success)
3349 {
3350 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_QUERY_REQUEST_SLOT, NULL, 1, sizeof(SQueryParamData));
3351 if (error == eCLE_Success)
3352 {
3353 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3354
3355 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
3356 }
3357 else
3358 {
3359 FreeTask(mmTaskID);
3360 }
3361 }
3362 }
3363 else
3364 {
3365 error = eCLE_InvalidSession;
3366 }
3367
3368 NetLog("[Lobby] Session Query Error %d", error);
3369
3370 return error;
3371 }
3372
3373 void CCryPSNMatchMaking::TickSessionQuery(CryMatchMakingTaskID mmTaskID)
3374 {
3375 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3376 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
3377 {
3378 STask* pTask = &m_task[mmTaskID];
3379
3380 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_QUERY_REQUEST_SLOT] != TMemInvalidHdl)
3381 {
3382 SQueryParamData* pQueryParams = (SQueryParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_QUERY_REQUEST_SLOT]);
3383
3384 memset(pQueryParams, 0, sizeof(SQueryParamData));
3385
3386 SSession* pSession = &m_sessions[pTask->session];
3387
3388 pQueryParams->m_queryRequest.roomId = pQueryParams->m_roomIds;
3389 pQueryParams->m_queryRequest.attrId = pQueryParams->m_attrTable;
3390 pQueryParams->m_roomIds[0] = pSession->m_roomId;
3391 pQueryParams->m_queryRequest.roomIdNum = 1;
3392 pQueryParams->m_attrTable[0] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_1_ID;
3393 pQueryParams->m_attrTable[1] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_2_ID;
3394 pQueryParams->m_attrTable[2] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_3_ID;
3395 pQueryParams->m_attrTable[3] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_4_ID;
3396 pQueryParams->m_attrTable[4] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_5_ID;
3397 pQueryParams->m_attrTable[5] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_6_ID;
3398 pQueryParams->m_attrTable[6] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_7_ID;
3399 pQueryParams->m_attrTable[7] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_8_ID;
3400 pQueryParams->m_attrTable[8] = SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_1_ID;
3401 pQueryParams->m_attrTable[9] = SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_2_ID;
3402 pQueryParams->m_queryRequest.attrIdNum = 10;
3403
3404 StartSubTask(eST_WaitingForQueryRoomRequestCallback, mmTaskID);
3405
3406 int ret = sceNpMatching2GetRoomDataExternalList(m_pPSNSupport->GetMatchmakingContextId(), &pQueryParams->m_queryRequest, NULL, &pTask->m_reqId);
3407 if (ret == PSN_OK)
3408 {
3409 //-- waiting for callback
3410 }
3411 else
3412 {
3413 NetLog("sceNpMatching2GetRoomDataExternalList : error %08X", ret);
3414 //-- triggering a PSN error will cause an error event into SupportCallback() and set a task error if it needs to clean up.
3415 //-- otherwise, we have to update the task error ourself.
3416 if (!m_pPSNSupport->HandlePSNError(ret))
3417 {
3418 UpdateTaskError(mmTaskID, eCLE_InternalError);
3419 }
3420 }
3421 }
3422 else
3423 {
3424 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
3425 }
3426 }
3427 }
3428
3429 bool CCryPSNMatchMaking::EventRequestResponse_GetRoomDataExternalList(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
3430 {
3431 // sanity
3432 assert(pTask->subTask == eST_WaitingForQueryRoomRequestCallback);
3433 assert(data.m_requestEvent.m_event == REQUEST_EVENT_GET_ROOM_DATA_EXTERNAL_LIST);
3434 assert(data.m_requestEvent.m_dataHdl != TMemInvalidHdl);
3435 assert(data.m_requestEvent.m_dataSize == sizeof(SCryPSNSearchRoomResponse));
3436
3437 if ((data.m_requestEvent.m_error == 0) &&
3438 (data.m_requestEvent.m_dataHdl != TMemInvalidHdl) &&
3439 (data.m_requestEvent.m_dataSize == sizeof(SCryPSNSearchRoomResponse)))
3440 {
3441 // take ownership of the memory returned by the callback so it is not automatically discarded on return
3442 pTask->params[PSN_MATCHMAKING_PSNSUPPORT_QUERY_RESPONSE_SLOT] = data.m_requestEvent.m_dataHdl;
3443 data.m_requestEvent.m_dataHdl = TMemInvalidHdl;
3444 data.m_requestEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRequestEvent::REQUEST_EVENT_OWNS_MEMORY;
3445
3446 _this->UpdateTaskError(taskId, eCLE_Success);
3447 _this->StopTaskRunning(taskId);
3448
3449 return true;
3450 }
3451 else
3452 {
3453 // return false to let the default error handler work
3454 return false;
3455 }
3456 }
3457
3458 void CCryPSNMatchMaking::EndSessionQuery(CryMatchMakingTaskID mmTaskID)
3459 {
3460 STask* pTask = &m_task[mmTaskID];
3461 SCryPSNSearchRoomResponse* pResponse = NULL;
3462
3463 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_QUERY_RESPONSE_SLOT] != TMemInvalidHdl)
3464 {
3465 pResponse = (SCryPSNSearchRoomResponse*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_QUERY_RESPONSE_SLOT]);
3466 }
3467
3468 if (pTask->error == eCLE_Success)
3469 {
3470 if (pResponse)
3471 {
3472 for (uint16 i = 0; i < pResponse->m_numRooms; i++)
3473 {
3474 SCrySessionSearchResult result;
3475 SCrySessionUserData userData[MAX_MATCHMAKING_SESSION_USER_DATA];
3476
3477 ProcessExternalRoomData(pResponse->m_pRooms[i], result, userData);
3478
3479 ((CryMatchmakingSessionQueryCallback)pTask->cb)(pTask->lTaskID, eCLE_SuccessContinue, &result, pTask->cbArg);
3480 }
3481 }
3482 else
3483 {
3484 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
3485 }
3486 }
3487
3488 // free the memory allocated to the response
3489 if (pResponse)
3490 {
3491 pResponse->Release(m_lobby);
3492 }
3493
3494 ((CryMatchmakingSessionQueryCallback)pTask->cb)(pTask->lTaskID, pTask->error, NULL, pTask->cbArg);
3495 }
3496
3497 ECryLobbyError CCryPSNMatchMaking::SessionGetUsers(CrySessionHandle gh, CryLobbyTaskID* pTaskID, CryMatchmakingSessionGetUsersCallback pCB, void* pCBArg)
3498 {
3499 ECryLobbyError error = eCLE_Success;
3500
3501 LOBBY_AUTO_LOCK;
3502
3503 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
3504
3505 if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
3506 {
3507 SSession* session = &m_sessions[h];
3508 CryMatchMakingTaskID mmTaskID;
3509
3510 error = StartTask(eT_SessionGetUsers, false, session->localConnection.users[0], &mmTaskID, pTaskID, h, (void*)pCB, pCBArg);
3511
3512 if (error == eCLE_Success)
3513 {
3514 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
3515 }
3516 }
3517 else
3518 {
3519 error = eCLE_InvalidSession;
3520 }
3521
3522 if (error != eCLE_Success)
3523 {
3524 NetLog("[Lobby] Session Get Users Is Error %d", error);
3525 }
3526
3527 return error;
3528 }
3529
3530 void CCryPSNMatchMaking::GetRoomMemberData(CryLobbySessionHandle sessionHandle, SCryUserInfoResult& result, SCryMatchMakingConnectionUID& uid)
3531 {
3532 SSession::SRoomMember* pRoomMember = FindRoomMemberFromRoomMemberID(sessionHandle, uid.m_uid);
3533
3534 result.m_conID = uid;
3535 result.m_isDedicated = false; // PSN does not support dedicated servers
3536
3537 if (pRoomMember)
3538 {
3539 cry_strcpy(result.m_userName, pRoomMember->m_npId.handle.data);
3540 memcpy(result.m_userData, pRoomMember->m_userData, CRYLOBBY_USER_DATA_SIZE_IN_BYTES);
3541
3542 ((SCryPSNUserID*)result.m_userID.get())->npId = pRoomMember->m_npId;
3543 }
3544 else
3545 {
3546 result.m_userName[0] = 0;
3547 }
3548 }
3549
3550 void CCryPSNMatchMaking::TickSessionGetUsers(CryMatchMakingTaskID mmTaskID)
3551 {
3552 STask* pTask = &m_task[mmTaskID];
3553
3554 SCryUserInfoResult temp;
3555 temp.m_userID = new SCryPSNUserID;
3556
3557 int a;
3558
3559 // Glue in local user - arguably, this could all just iterate over the room members list (ho hum)
3560 GetRoomMemberData(pTask->session, temp, m_sessions[pTask->session].localConnection.uid);
3561 ((CryMatchmakingSessionGetUsersCallback)pTask->cb)(pTask->lTaskID, pTask->error, &temp, pTask->cbArg);
3562
3563 for (a = 0; a < MAX_LOBBY_CONNECTIONS; a++)
3564 {
3565 if (m_sessions[pTask->session].remoteConnection[a].used)
3566 {
3567 GetRoomMemberData(pTask->session, temp, m_sessions[pTask->session].remoteConnection[a].uid);
3568 ((CryMatchmakingSessionGetUsersCallback)pTask->cb)(pTask->lTaskID, pTask->error, &temp, pTask->cbArg);
3569 }
3570 }
3571
3572 StopTaskRunning(mmTaskID);
3573 }
3574
3575 ECryLobbyError CCryPSNMatchMaking::SessionStart(CrySessionHandle gh, CryLobbyTaskID* taskID, CryMatchmakingCallback cb, void* cbArg)
3576 {
3577 ECryLobbyError error = eCLE_Success;
3578
3579 LOBBY_AUTO_LOCK;
3580
3581 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
3582
3583 if ((h < MAX_MATCHMAKING_SESSIONS) && m_sessions[h].IsUsed())
3584 {
3585 SSession* pSession = &m_sessions[h];
3586 CryMatchMakingTaskID mmTaskID;
3587
3588 error = StartTask(eT_SessionStart, false, pSession->localConnection.users[0], &mmTaskID, taskID, h, (void*)cb, cbArg);
3589
3590 if (error == eCLE_Success)
3591 {
3592 pSession->localFlags |= CRYSESSION_LOCAL_FLAG_STARTED;
3593 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
3594 }
3595 }
3596 else
3597 {
3598 error = eCLE_InvalidSession;
3599 }
3600
3601 NetLog("[Lobby] Start SessionStart error %d", error);
3602
3603 return error;
3604 }
3605
3606 ECryLobbyError CCryPSNMatchMaking::SessionEnd(CrySessionHandle gh, CryLobbyTaskID* taskID, CryMatchmakingCallback cb, void* cbArg)
3607 {
3608 ECryLobbyError error = eCLE_Success;
3609
3610 LOBBY_AUTO_LOCK;
3611
3612 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
3613
3614 if ((h < MAX_MATCHMAKING_SESSIONS) && m_sessions[h].IsUsed())
3615 {
3616 SSession* pSession = &m_sessions[h];
3617 CryMatchMakingTaskID mmTaskID;
3618
3619 error = StartTask(eT_SessionEnd, false, pSession->localConnection.users[0], &mmTaskID, taskID, h, (void*)cb, cbArg);
3620
3621 if (error == eCLE_Success)
3622 {
3623 pSession->localFlags &= ~CRYSESSION_LOCAL_FLAG_STARTED;
3624 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
3625 }
3626 }
3627 else
3628 {
3629 error = eCLE_SuccessInvalidSession;
3630 }
3631
3632 NetLog("[Lobby] Start SessionEnd error %d", error);
3633
3634 return error;
3635 }
3636
3637 // SESSION DELETE ------------------------------------------------------------------------------------------
3638
3639 ECryLobbyError CCryPSNMatchMaking::SessionDelete(CrySessionHandle gh, CryLobbyTaskID* taskID, CryMatchmakingCallback cb, void* cbArg)
3640 {
3641 ECryLobbyError error = eCLE_Success;
3642
3643 LOBBY_AUTO_LOCK;
3644
3645 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
3646
3647 if ((h < MAX_MATCHMAKING_SESSIONS) && m_sessions[h].IsUsed())
3648 {
3649 SSession* pSession = &m_sessions[h];
3650 CryMatchMakingTaskID mmTaskID;
3651
3652 // Disconnect our local connection
3653 SessionDisconnectRemoteConnectionViaNub(h, CryMatchMakingInvalidConnectionID, eDS_Local, CryMatchMakingInvalidConnectionID, eDC_UserRequested, "Session deleted");
3654
3655 error = StartTask(eT_SessionDelete, false, pSession->localConnection.users[0], &mmTaskID, taskID, h, (void*)cb, cbArg);
3656
3657 if (error == eCLE_Success)
3658 {
3659 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_LEAVE_REQUEST_SLOT, NULL, 1, sizeof(SLeaveParamData));
3660 if (error == eCLE_Success)
3661 {
3662 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_WEBAPI_LEAVE_REQUEST_SLOT, NULL, 1, sizeof(SCryPSNOrbisWebApiLeaveSessionInput));
3663 if (error == eCLE_Success)
3664 {
3665 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3666
3667 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
3668
3669 #if NETWORK_HOST_MIGRATION
3670 // Since we're deleting this session, terminate any host migration
3671 if (pSession->hostMigrationInfo.m_state != eHMS_Idle)
3672 {
3673 m_hostMigration.Terminate(&pSession->hostMigrationInfo);
3674 }
3675 #endif
3676 pSession->createFlags &= ~CRYSESSION_CREATE_FLAG_MIGRATABLE;
3677 }
3678 }
3679 if (error != eCLE_Success)
3680 {
3681 FreeTask(mmTaskID);
3682 }
3683 }
3684 }
3685 else
3686 {
3687 error = eCLE_SuccessInvalidSession;
3688 }
3689
3690 NetLog("[Lobby] Start SessionDelete error %d", error);
3691
3692 return error;
3693 }
3694
3695 void CCryPSNMatchMaking::StartSessionDelete(CryMatchMakingTaskID mmTaskID)
3696 {
3697 STask* pTask = &m_task[mmTaskID];
3698 SSession* pSession = &m_sessions[pTask->session];
3699
3700 #if NETWORK_HOST_MIGRATION
3701 // Since we're deleting this session, terminate any host migration
3702 if (pSession->hostMigrationInfo.m_state != eHMS_Idle)
3703 {
3704 m_hostMigration.Terminate(&pSession->hostMigrationInfo);
3705 }
3706 #endif
3707
3708 pSession->createFlags &= ~CRYSESSION_CREATE_FLAG_MIGRATABLE;
3709 for (uint32 i = 0; i < MAX_LOBBY_CONNECTIONS; i++)
3710 {
3711 SSession::SRConnection* connection = &pSession->remoteConnection[i];
3712
3713 if (connection->used)
3714 {
3715 FreeRemoteConnection(pTask->session, i);
3716 }
3717 }
3718
3719 if (pTask->error != eCLE_Success)
3720 {
3721 StopTaskRunning(mmTaskID);
3722 }
3723 }
3724
3725 void CCryPSNMatchMaking::TickSessionDelete(CryMatchMakingTaskID mmTaskID)
3726 {
3727 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3728 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
3729 {
3730 STask* pTask = &m_task[mmTaskID];
3731
3732 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_LEAVE_REQUEST_SLOT] != TMemInvalidHdl)
3733 {
3734 SLeaveParamData* pLeaveParams = (SLeaveParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_LEAVE_REQUEST_SLOT]);
3735 SSession* pSession = &m_sessions[pTask->session];
3736
3737 memset(pLeaveParams, 0, sizeof(SLeaveParamData));
3738 pLeaveParams->m_leaveRequest.roomId = pSession->m_roomId;
3739 pLeaveParams->m_leaveRequest.optData.len = 0;
3740
3741 StartSubTask(eST_WaitingForLeaveRoomRequestCallback, mmTaskID);
3742
3743 int ret = sceNpMatching2LeaveRoom(m_pPSNSupport->GetMatchmakingContextId(), &pLeaveParams->m_leaveRequest, NULL, &pTask->m_reqId);
3744 if (ret == PSN_OK)
3745 {
3746 //-- wait for callback
3747 }
3748 else
3749 {
3750 NetLog("sceNpMatching2LeaveRoom : error %08X", ret);
3751
3752 if ((ret == SCE_NP_MATCHING2_ERROR_ROOM_NOT_FOUND) || (ret == SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_ROOM) || (ret == SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_ROOM_INSTANCE))
3753 {
3754 //-- To fix a bug in trying to delete a room that doesn't exist.
3755 //-- If we attempt to leave a room, and the room doesn't exist, we'll treat it the same as if we left
3756 //-- the room successfully, so call the event handler than deals with the cleanup of the room leaving.
3757 SCryPSNSupportCallbackEventData data;
3758 memset(&data, 0, sizeof(SCryPSNSupportCallbackEventData));
3759 data.m_requestEvent.m_event = REQUEST_EVENT_LEAVE_ROOM;
3760 data.m_requestEvent.m_reqId = pTask->m_reqId;
3761
3762 EventRequestResponse_LeaveRoom(this, pTask, mmTaskID, data);
3763 }
3764 else
3765 {
3766 //-- triggering a PSN error will cause an error event into SupportCallback() and set a task error if it needs to clean up.
3767 //-- otherwise, we have to update the task error ourself.
3768 if (!m_pPSNSupport->HandlePSNError(ret))
3769 {
3770 UpdateTaskError(mmTaskID, eCLE_RoomDoesNotExist);
3771 }
3772 }
3773 }
3774 }
3775 else
3776 {
3777 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
3778 }
3779 }
3780 }
3781
3782 bool CCryPSNMatchMaking::EventRequestResponse_LeaveRoom(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
3783 {
3784 // sanity
3785 assert(pTask->subTask == eST_WaitingForLeaveRoomRequestCallback);
3786 assert(data.m_requestEvent.m_event == REQUEST_EVENT_LEAVE_ROOM);
3787
3788 if (data.m_requestEvent.m_error == 0)
3789 {
3790 if (pTask->session != CryLobbyInvalidSessionHandle)
3791 {
3792 SSession* pSession = &_this->m_sessions[pTask->session];
3793 if (pSession->IsUsed())
3794 {
3795 if (pSession->m_sessionId.data[0] != 0)
3796 {
3797 _this->StartSubTask(eST_WaitingForLeaveRoomWebApiCallback, taskId);
3798
3799 SCryPSNOrbisWebApiLeaveSessionInput* pLeaveWebApiParams = (SCryPSNOrbisWebApiLeaveSessionInput*)_this->m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_WEBAPI_LEAVE_REQUEST_SLOT]);
3800 if (pLeaveWebApiParams)
3801 {
3802 memcpy(&pLeaveWebApiParams->sessionId, &pSession->m_sessionId, sizeof(SceNpSessionId));
3803 memcpy(&pLeaveWebApiParams->playerId, &_this->m_pPSNSupport->GetLocalNpId()->handle, sizeof(SceNpOnlineId));
3804
3805 SLeaveParamData* pLeaveParams = (SLeaveParamData*)_this->m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_LEAVE_REQUEST_SLOT]);
3806 pLeaveParams->m_leaveJobId = _this->m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::LeaveSession, pTask->params[PSN_MATCHMAKING_WEBAPI_LEAVE_REQUEST_SLOT]);
3807 }
3808 else
3809 {
3810 // failed!
3811 _this->UpdateTaskError(taskId, eCLE_OutOfMemory);
3812 }
3813 }
3814 else
3815 {
3816 // no session advert to leave, so we're finished!
3817 _this->ClearSessionInfo(pTask->session);
3818 _this->FreeSessionHandle(pTask->session);
3819
3820 _this->UpdateTaskError(taskId, eCLE_Success);
3821 _this->StopTaskRunning(taskId);
3822 }
3823 }
3824 else
3825 {
3826 _this->UpdateTaskError(taskId, eCLE_InternalError);
3827 }
3828 }
3829 else
3830 {
3831 _this->UpdateTaskError(taskId, eCLE_InternalError);
3832 }
3833
3834 return true;
3835 }
3836 else
3837 {
3838 return false;
3839 }
3840 }
3841
3842 void CCryPSNMatchMaking::EventWebApiLeaveSession(CryMatchMakingTaskID mmTaskID, SCryPSNSupportCallbackEventData& data)
3843 {
3844 STask* pTask = &m_task[mmTaskID];
3845
3846 if (pTask->session != CryLobbyInvalidSessionHandle)
3847 {
3848 SSession* pSession = &m_sessions[pTask->session];
3849
3850 if (data.m_webApiEvent.m_error == PSN_OK)
3851 {
3852 // Completed successfully
3853 // no session advert to leave, so we're finished!
3854 ClearSessionInfo(pTask->session);
3855 FreeSessionHandle(pTask->session);
3856
3857 UpdateTaskError(mmTaskID, eCLE_Success);
3858 StopTaskRunning(mmTaskID);
3859 return;
3860 }
3861 }
3862
3863 // otherwise something went wrong!
3864 ClearSessionInfo(pTask->session);
3865 FreeSessionHandle(pTask->session);
3866
3867 UpdateTaskError(mmTaskID, eCLE_InternalError);
3868 StopTaskRunning(mmTaskID);
3869 }
3870
3871 // END SESSION DELETE -----------------------------------------------------------------------------------------------------
3872
3873 // SESSION SEARCH ---------------------------------------------------------------------------------------------------------
3874
3875 ECryLobbyError CCryPSNMatchMaking::SessionSearch(uint32 user, SCrySessionSearchParam* pParam, CryLobbyTaskID* pTaskID, CryMatchmakingSessionSearchCallback cb, void* cbArg)
3876 {
3877 LOBBY_AUTO_LOCK;
3878
3879 CryMatchMakingTaskID mmTaskID;
3880
3881 ECryLobbyError error = StartTask(eT_SessionSearch, false, user, &mmTaskID, pTaskID, 0, (void*)cb, cbArg);
3882 if (error == eCLE_Success)
3883 {
3884 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_SEARCH_PARAMS_SLOT, pParam, 1, sizeof(SCrySessionSearchParam));
3885 if (error == eCLE_Success)
3886 {
3887 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_SEARCH_DATA_SLOT, pParam->m_data, pParam->m_numData, pParam->m_numData * sizeof(pParam->m_data[0]));
3888 if (error == eCLE_Success)
3889 {
3890 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT, NULL, 1, sizeof(SSearchInfoData));
3891 if (error == eCLE_Success)
3892 {
3893 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
3894
3895 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
3896 }
3897 }
3898 }
3899
3900 if (error != eCLE_Success)
3901 {
3902 FreeTask(mmTaskID);
3903 }
3904 }
3905
3906 NetLog("[Lobby] Start SessionSearch error %d", error);
3907
3908 return error;
3909 }
3910
3911 uint32 CCryPSNMatchMaking::BuildSearchFilterParams(SCrySessionSearchData* pData, uint32 numData,
3912 SceNpMatching2IntSearchFilter intFilterExternal[SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_NUM])
3913 {
3914 uint32 nCount = 0;
3915
3916 if (pData)
3917 {
3918 for (uint32 i = 0; (i < numData) && (nCount < SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_NUM); i++)
3919 {
3920 SCrySessionSearchData* pCurData = &pData[i];
3921
3922 for (uint32 j = 0; (j < m_registeredUserData.num) && (nCount < SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_NUM); j++)
3923 {
3924 SCrySessionUserData* pRegUserData = &m_registeredUserData.data[j];
3925 SMappingToPSNLobbyData* pRegMappingData = &m_registeredUserData.mapping[j];
3926
3927 if (pCurData->m_data.m_id == pRegUserData->m_id)
3928 {
3929 if (pCurData->m_data.m_type == pRegUserData->m_type)
3930 {
3931 assert(pRegMappingData->integerField && "Can only search using integer fields on PSN!");
3932
3933 if (pRegMappingData->integerField)
3934 {
3935 intFilterExternal[nCount].attr.id = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_1_ID + pRegMappingData->fieldOffset;
3936 intFilterExternal[nCount].attr.num = pCurData->m_data.m_int32;
3937
3938 switch (pCurData->m_operator)
3939 {
3940 default:
3941 {
3942 NetLog("[PSN Search] No valid Search filter operator defined: using default EQUALS");
3943 intFilterExternal[nCount].searchOperator = SCE_NP_MATCHING2_OPERATOR_EQ;
3944 }
3945 break;
3946 case eCSSO_Equal:
3947 {
3948 intFilterExternal[nCount].searchOperator = SCE_NP_MATCHING2_OPERATOR_EQ;
3949 }
3950 break;
3951 case eCSSO_NotEqual:
3952 {
3953 intFilterExternal[nCount].searchOperator = SCE_NP_MATCHING2_OPERATOR_NE;
3954 }
3955 break;
3956 case eCSSO_LessThan:
3957 {
3958 intFilterExternal[nCount].searchOperator = SCE_NP_MATCHING2_OPERATOR_LT;
3959 }
3960 break;
3961 case eCSSO_LessThanEqual:
3962 {
3963 intFilterExternal[nCount].searchOperator = SCE_NP_MATCHING2_OPERATOR_LE;
3964 }
3965 break;
3966 case eCSSO_GreaterThan:
3967 {
3968 intFilterExternal[nCount].searchOperator = SCE_NP_MATCHING2_OPERATOR_GT;
3969 }
3970 break;
3971 case eCSSO_GreaterThanEqual:
3972 {
3973 intFilterExternal[nCount].searchOperator = SCE_NP_MATCHING2_OPERATOR_GE;
3974 }
3975 break;
3976 }
3977
3978 nCount++;
3979 }
3980 else
3981 {
3982 NetLog("[PSN Search] Can only search using integer fields on PSN!");
3983 }
3984 }
3985 }
3986 }
3987 }
3988 }
3989
3990 return nCount;
3991 }
3992
3993 void CCryPSNMatchMaking::StartSessionSearch(CryMatchMakingTaskID mmTaskID)
3994 {
3995 STask* pTask = &m_task[mmTaskID];
3996
3997 if (pTask->params[PSN_MATCHMAKING_SEARCH_PARAMS_SLOT] != TMemInvalidHdl)
3998 {
3999 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT] != TMemInvalidHdl)
4000 {
4001 SCrySessionSearchParam* pData = (SCrySessionSearchParam*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_SEARCH_PARAMS_SLOT]);
4002 if (pTask->params[PSN_MATCHMAKING_SEARCH_DATA_SLOT] != TMemInvalidHdl)
4003 {
4004 pData->m_data = (SCrySessionSearchData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_SEARCH_DATA_SLOT]);
4005 }
4006 else
4007 {
4008 pData->m_data = NULL;
4009 }
4010
4011 SSearchInfoData* pSearchInfo = (SSearchInfoData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT]);
4012 memset(pSearchInfo, 0, sizeof(SSearchInfoData));
4013
4014 uint32 nFields = BuildSearchFilterParams(pData->m_data, pData->m_numData, pSearchInfo->m_intFilterExternal);
4015
4016 pSearchInfo->m_searchRequest.worldId = 0;
4017 pSearchInfo->m_searchRequest.lobbyId = 0;
4018 pSearchInfo->m_searchRequest.flagFilter = SCE_NP_MATCHING2_ROOM_FLAG_ATTR_CLOSED | SCE_NP_MATCHING2_ROOM_FLAG_ATTR_FULL;
4019 pSearchInfo->m_searchRequest.flagAttr = 0;
4020 pSearchInfo->m_searchRequest.intFilter = (nFields > 0) ? (pSearchInfo->m_intFilterExternal) : (NULL);
4021 pSearchInfo->m_searchRequest.intFilterNum = nFields;
4022 pSearchInfo->m_searchRequest.binFilter = NULL;
4023 pSearchInfo->m_searchRequest.binFilterNum = 0;
4024 pSearchInfo->m_searchRequest.rangeFilter.startIndex = SCE_NP_MATCHING2_RANGE_FILTER_START_INDEX_MIN;
4025 pSearchInfo->m_searchRequest.rangeFilter.max = SCE_NP_MATCHING2_RANGE_FILTER_MAX;
4026 pSearchInfo->m_searchRequest.option = SCE_NP_MATCHING2_SEARCH_ROOM_OPTION_RANDOM;
4027
4028 pSearchInfo->m_attrId[0] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_1_ID;
4029 pSearchInfo->m_attrId[1] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_2_ID;
4030 pSearchInfo->m_attrId[2] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_3_ID;
4031 pSearchInfo->m_attrId[3] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_4_ID;
4032 pSearchInfo->m_attrId[4] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_5_ID;
4033 pSearchInfo->m_attrId[5] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_6_ID;
4034 pSearchInfo->m_attrId[6] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_7_ID;
4035 pSearchInfo->m_attrId[7] = SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_8_ID;
4036 pSearchInfo->m_attrId[8] = SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_1_ID;
4037 pSearchInfo->m_attrId[9] = SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_2_ID;
4038
4039 pSearchInfo->m_searchRequest.attrId = pSearchInfo->m_attrId;
4040 pSearchInfo->m_searchRequest.attrIdNum = 10;
4041
4042 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
4043 }
4044 else
4045 {
4046 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
4047 StopTaskRunning(mmTaskID);
4048 }
4049 }
4050 else
4051 {
4052 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
4053 StopTaskRunning(mmTaskID);
4054 }
4055 }
4056
4057 void CCryPSNMatchMaking::TickSessionSearch(CryMatchMakingTaskID mmTaskID)
4058 {
4059 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
4060 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
4061 {
4062 STask* pTask = &m_task[mmTaskID];
4063
4064 //-- get a list of worlds
4065 StartSubTask(eST_WaitingForSearchRoomWorldInfo, mmTaskID);
4066
4067 SceNpMatching2GetWorldInfoListRequest reqParam;
4068 memset(&reqParam, 0, sizeof(reqParam));
4069 reqParam.serverId = m_pPSNSupport->GetServerInfo()->server.serverId;
4070
4071 int ret = sceNpMatching2GetWorldInfoList(m_pPSNSupport->GetMatchmakingContextId(), &reqParam, NULL, &pTask->m_reqId);
4072 if (ret == PSN_OK)
4073 {
4074 //-- Waiting for callback
4075 }
4076 else
4077 {
4078 NetLog("sceNpMatching2GetWorldInfoList : error %08X", ret);
4079 if (!m_pPSNSupport->HandlePSNError(ret))
4080 {
4081 UpdateTaskError(mmTaskID, eCLE_WorldNotDefined);
4082 }
4083 }
4084 }
4085 }
4086
4087 bool CCryPSNMatchMaking::EventRequestResponse_GetWorldInfoListForSearch(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
4088 {
4089 assert(pTask->subTask == eST_WaitingForSearchRoomWorldInfo);
4090 assert(data.m_requestEvent.m_event == REQUEST_EVENT_GET_WORLD_INFO_LIST);
4091 assert(data.m_requestEvent.m_dataSize == sizeof(SCryPSNGetWorldInfoListResponse));
4092
4093 if ((data.m_requestEvent.m_error == 0) &&
4094 (data.m_requestEvent.m_dataHdl != TMemInvalidHdl) &&
4095 (data.m_requestEvent.m_dataSize == sizeof(SCryPSNGetWorldInfoListResponse)))
4096 {
4097 SSearchInfoData* pSearchInfo = (SSearchInfoData*)_this->m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT]);
4098 if (pSearchInfo)
4099 {
4100 const SCryPSNGetWorldInfoListResponse* pWorldList = (SCryPSNGetWorldInfoListResponse*)_this->m_lobby->MemGetPtr(data.m_requestEvent.m_dataHdl);
4101
4102 pSearchInfo->m_numWorlds = SortWorlds(pWorldList, pSearchInfo->m_worldIds, MAX_WORLDS_TO_SEARCH, true);
4103 if (pSearchInfo->m_numWorlds > 0)
4104 {
4105 pSearchInfo->m_nIndex = 0;
4106 pSearchInfo->m_searchRequest.worldId = pSearchInfo->m_worldIds[pSearchInfo->m_nIndex];
4107
4108 _this->StartSubTask(eST_SessionSearchRequest, taskId);
4109 }
4110 else
4111 {
4112 _this->UpdateTaskError(taskId, eCLE_WorldNotDefined);
4113 }
4114 }
4115 else
4116 {
4117 _this->UpdateTaskError(taskId, eCLE_OutOfMemory);
4118 }
4119
4120 return true;
4121 }
4122 else
4123 {
4124 return false;
4125 }
4126 }
4127
4128 void CCryPSNMatchMaking::TickSessionSearchRequest(CryMatchMakingTaskID mmTaskID)
4129 {
4130 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
4131 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
4132 {
4133 STask* pTask = &m_task[mmTaskID];
4134
4135 SSearchInfoData* pSearchInfo = (SSearchInfoData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT]);
4136
4137 StartSubTask(eST_WaitingForSearchRoomRequestCallback, mmTaskID);
4138
4139 int ret = sceNpMatching2SearchRoom(m_pPSNSupport->GetMatchmakingContextId(), &pSearchInfo->m_searchRequest, NULL, &pTask->m_reqId);
4140 if (ret == PSN_OK)
4141 {
4142 //-- waiting for callback
4143 }
4144 else
4145 {
4146 NetLog("sceNpMatching2SearchRoom : error %08X", ret);
4147 //-- triggering a PSN error will cause an error event into SupportCallback() and set a task error if it needs to clean up.
4148 //-- otherwise, we have to update the task error ourself.
4149 if (!m_pPSNSupport->HandlePSNError(ret))
4150 {
4151 UpdateTaskError(mmTaskID, eCLE_InternalError);
4152 }
4153 }
4154 }
4155 else
4156 {
4157 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
4158 }
4159 }
4160
4161 bool CCryPSNMatchMaking::EventRequestResponse_SearchRoom(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
4162 {
4163 // sanity
4164 assert(pTask->subTask == eST_WaitingForSearchRoomRequestCallback);
4165 assert(data.m_requestEvent.m_event == REQUEST_EVENT_SEARCH_ROOM);
4166 assert(data.m_requestEvent.m_dataHdl != TMemInvalidHdl);
4167 assert(data.m_requestEvent.m_dataSize == sizeof(SCryPSNSearchRoomResponse));
4168
4169 if ((data.m_requestEvent.m_error == 0) &&
4170 (data.m_requestEvent.m_dataHdl != TMemInvalidHdl) &&
4171 (data.m_requestEvent.m_dataSize == sizeof(SCryPSNSearchRoomResponse)))
4172 {
4173 const SCryPSNSearchRoomResponse* const pResponse = (SCryPSNSearchRoomResponse*)_this->m_lobby->MemGetPtr(data.m_requestEvent.m_dataHdl);
4174 SSearchInfoData* pSearchInfo = (SSearchInfoData*)_this->m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT]);
4175 SCrySessionSearchParam* pSearchParams = (SCrySessionSearchParam*)_this->m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_SEARCH_PARAMS_SLOT]);
4176
4177 uint16 c = 0;
4178 while ((pSearchInfo->m_numResults < MAX_ROOMS_TO_STORE) && (pSearchInfo->m_numResults < pSearchParams->m_maxNumReturn) && (c < pResponse->m_numRooms))
4179 {
4180 _this->ProcessExternalRoomData(pResponse->m_pRooms[c], pSearchInfo->m_results[pSearchInfo->m_numResults], pSearchInfo->m_resultUserData[pSearchInfo->m_numResults]);
4181 pSearchInfo->m_numResults++;
4182 c++;
4183 }
4184
4185 pSearchInfo->m_nIndex++;
4186 if ((pSearchInfo->m_numResults < MAX_ROOMS_TO_STORE) && (pSearchInfo->m_numResults < pSearchParams->m_maxNumReturn) && (pSearchInfo->m_nIndex < pSearchInfo->m_numWorlds))
4187 {
4188 //-- Chain start a new search on the next world in the list.
4189 assert(pSearchInfo->m_worldIds[pSearchInfo->m_nIndex] != 0);
4190 pSearchInfo->m_searchRequest.worldId = pSearchInfo->m_worldIds[pSearchInfo->m_nIndex];
4191 _this->StartSubTask(eST_SessionSearchRequest, taskId);
4192 }
4193 else
4194 {
4195 if (pSearchInfo->m_numResults > 0)
4196 {
4197 //-- We've filled the results buffer, or run out of worlds, so move onto QOS!
4198 pSearchInfo->m_nIndex = 0;
4199 _this->StartSubTask(eST_SessionSearchKickQOS, taskId);
4200 }
4201 else
4202 {
4203 //-- No results after searching all the worlds, so just give up on search task.
4204 _this->UpdateTaskError(taskId, eCLE_Success);
4205 _this->StopTaskRunning(taskId);
4206 }
4207 }
4208
4209 return true;
4210 }
4211 else
4212 {
4213 // an error was returned in the response. If we return false, the default error handler will deal with it
4214 return false;
4215 }
4216 }
4217
4218 void CCryPSNMatchMaking::TickSessionWaitForQOS(CryMatchMakingTaskID mmTaskID)
4219 {
4220 STask* pTask = &m_task[mmTaskID];
4221
4222 if (pTask->GetTimer() >= MAX_WAITTIME_FOR_QOS)
4223 {
4224 NetLog("Timeout Getting QOS Data - Returning what we have");
4225 UpdateTaskError(mmTaskID, eCLE_Success); // Don't return timeout, that way game gets some results
4226 StopTaskRunning(mmTaskID);
4227 }
4228 }
4229
4230 void CCryPSNMatchMaking::TickSessionQOSSearch(CryMatchMakingTaskID mmTaskID)
4231 {
4232 int qosIndex = 0;
4233
4234 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
4235 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
4236 {
4237 STask* pTask = &m_task[mmTaskID];
4238
4239 SSearchInfoData* pSearchInfo = (SSearchInfoData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT]);
4240 pSearchInfo->m_nIndex = 0;
4241 while (qosIndex < pSearchInfo->m_numResults)
4242 {
4243 SCryPSNSessionID* pId = (SCryPSNSessionID*)pSearchInfo->m_results[qosIndex].m_id.get();
4244 if (pId)
4245 {
4246 memset(&pSearchInfo->m_QOSRequest[qosIndex], 0, sizeof(SceNpMatching2SignalingGetPingInfoRequest));
4247 pSearchInfo->m_QOSRequest[qosIndex].roomId = pId->m_sessionInfo.m_roomId;
4248 pSearchInfo->m_results[qosIndex].m_ping = PSN_MATCHMAKING_DEFAULT_UNKNOWN_PING;
4249
4250 pTask->m_reqId = INVALID_PSN_REQUEST_ID; // We cant use the global task id, because we have many qos subtasks potentially on one task
4251
4252 StartSubTask(eST_WaitingForSearchQOSRequestCallback, mmTaskID);
4253
4254 int ret = sceNpMatching2SignalingGetPingInfo(m_pPSNSupport->GetMatchmakingContextId(), &pSearchInfo->m_QOSRequest[qosIndex], NULL, &pSearchInfo->m_reqId[qosIndex]);
4255
4256 NetLog("Task ID : %d Idx : %d Request id : %d Room Id : %d", mmTaskID, qosIndex, (int32)pSearchInfo->m_reqId[qosIndex], (int32)pId->m_sessionInfo.m_roomId);
4257 qosIndex++;
4258
4259 if (ret == PSN_OK)
4260 {
4261 //-- waiting for callback
4262 }
4263 else
4264 {
4265 NetLog("sceNpMatching2SignalingGetPingInfo : error %08X", ret);
4266 //-- triggering a PSN error will cause an error event into SupportCallback() and set a task error if it needs to clean up.
4267 //-- otherwise, we have to update the task error ourself.
4268 if (!m_pPSNSupport->HandlePSNError(ret))
4269 {
4270 UpdateTaskError(mmTaskID, eCLE_InternalError);
4271 }
4272 }
4273 }
4274 else
4275 {
4276 UpdateTaskError(mmTaskID, eCLE_InternalError);
4277 }
4278
4279 pSearchInfo->m_nIndex = qosIndex;
4280 }
4281
4282 if (pSearchInfo->m_nIndex == 0)
4283 {
4284 //-- SUCCESS End of search results, we can end the task now.
4285 UpdateTaskError(mmTaskID, eCLE_Success);
4286 StopTaskRunning(mmTaskID);
4287 }
4288 else
4289 {
4290 pTask->StartTimer();
4291 }
4292 }
4293 }
4294
4295 bool CCryPSNMatchMaking::EventRequestResponse_SearchQOS(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
4296 {
4297 assert(pTask->subTask == eST_WaitingForSearchQOSRequestCallback);
4298 assert(data.m_requestEvent.m_event == REQUEST_EVENT_SIGNALING_GET_PING_INFO);
4299 assert(data.m_requestEvent.m_dataHdl != TMemInvalidHdl);
4300 assert(data.m_requestEvent.m_dataSize == sizeof(SCryPSNSignalingGetPingInfoResponse));
4301
4302 SSearchInfoData* pSearchInfo = (SSearchInfoData*)_this->m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT]);
4303 SCrySessionSearchResult* pSearchResult = NULL;
4304
4305 for (int a = 0; a < pSearchInfo->m_numResults; a++)
4306 {
4307 if (data.m_requestEvent.m_reqId == pSearchInfo->m_reqId[a])
4308 {
4309 pSearchResult = &pSearchInfo->m_results[a];
4310 pSearchInfo->m_nIndex--;
4311 break;
4312 }
4313 }
4314
4315 if ((data.m_requestEvent.m_error == 0) &&
4316 (data.m_requestEvent.m_dataHdl != TMemInvalidHdl) &&
4317 (data.m_requestEvent.m_dataSize == sizeof(SCryPSNSignalingGetPingInfoResponse)) &&
4318 pSearchResult)
4319 {
4320 const SCryPSNSignalingGetPingInfoResponse* const pQOSResponse = (SCryPSNSignalingGetPingInfoResponse*)_this->m_lobby->MemGetPtr(data.m_requestEvent.m_dataHdl);
4321 pSearchResult->m_ping = pQOSResponse->m_rtt / 1000;
4322 NetLog("Request Id: %d QoS Done: ping %d roomId %d", data.m_requestEvent.m_reqId, (int32)pSearchResult->m_ping, (int32)pQOSResponse->m_roomId);
4323 }
4324 else
4325 {
4326 // QoS can return socket errors, or a timeout as an error. In this rare case, we'll have to assume the error is not fatal and trap it
4327 // by marking it as handled with no ping value.
4328 NetLog("Request Id: %d QoS Done ERROR: ping %d, error %08X", data.m_requestEvent.m_reqId, (int32)pSearchResult->m_ping, data.m_requestEvent.m_error);
4329 }
4330
4331 if (pSearchInfo->m_nIndex == 0)
4332 {
4333 //-- SUCCESS End of search results, we can end the task now.
4334 _this->UpdateTaskError(taskId, eCLE_Success);
4335 _this->StopTaskRunning(taskId);
4336 }
4337
4338 return true;
4339 }
4340
4341 void CCryPSNMatchMaking::EndSessionSearch(CryMatchMakingTaskID mmTaskID)
4342 {
4343 STask* pTask = &m_task[mmTaskID];
4344
4345 if (pTask->error == eCLE_Success)
4346 {
4347 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT] != TMemInvalidHdl)
4348 {
4349 SSearchInfoData* pSearchInfo = (SSearchInfoData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_SEARCH_INFO_SLOT]);
4350
4351 NetLog("[Lobby] Found %d sessions in %d worlds.", pSearchInfo->m_numResults, pSearchInfo->m_numWorlds);
4352
4353 for (uint32 i = 0; i < pSearchInfo->m_numResults; i++)
4354 {
4355 SCrySessionSearchResult* pResult = &pSearchInfo->m_results[i];
4356 ((CryMatchmakingSessionSearchCallback)pTask->cb)(pTask->lTaskID, eCLE_SuccessContinue, pResult, pTask->cbArg);
4357
4358 //-- remove reference to CrySessionID, since it's a smart pointer inside a larger alloc that wouldn't be cleaned up otherwise.
4359 pResult->m_id = NULL;
4360 }
4361 }
4362 else
4363 {
4364 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
4365 }
4366 }
4367
4368 ((CryMatchmakingSessionSearchCallback)pTask->cb)(pTask->lTaskID, pTask->error, NULL, pTask->cbArg);
4369 }
4370
4371 // END OF SEARCH -------------------------------------------------------------------------
4372
4373 // SESSION JOIN --------------------------------------------------------------------------
4374
4375 ECryLobbyError CCryPSNMatchMaking::SessionJoin(uint32* users, int numUsers, uint32 flags, CrySessionID id, CryLobbyTaskID* taskID, CryMatchmakingSessionJoinCallback cb, void* cbArg)
4376 {
4377 LOBBY_AUTO_LOCK;
4378
4379 CryLobbySessionHandle h;
4380 ECryLobbyError error = CreateSessionHandle(&h, false, users, numUsers, flags);
4381 if (error == eCLE_Success)
4382 {
4383 CryMatchMakingTaskID mmTaskID;
4384
4385 error = StartTask(eT_SessionJoin, false, users[0], &mmTaskID, taskID, h, (void*)cb, cbArg);
4386 if (error == eCLE_Success)
4387 {
4388 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_JOIN_REQUEST_SLOT, NULL, 1, sizeof(SJoinParamData));
4389 if (error == eCLE_Success)
4390 {
4391 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_WEBAPI_JOIN_SLOT, NULL, 1, sizeof(SCryPSNOrbisWebApiJoinSessionInput));
4392 if (error == eCLE_Success)
4393 {
4394 SCryPSNSessionID* psnID = (SCryPSNSessionID*)id.get();
4395 SSession* pSession = &m_sessions[h];
4396
4397 pSession->m_roomId = psnID->m_sessionInfo.m_roomId;
4398 pSession->m_worldId = psnID->m_sessionInfo.m_worldId;
4399 pSession->m_serverId = psnID->m_sessionInfo.m_serverId;
4400 pSession->m_gameType = psnID->m_sessionInfo.m_gameType;
4401 pSession->m_flags = 0;
4402
4403 for (uint32 i = 0; i < numUsers; i++)
4404 {
4405 pSession->localConnection.privateSlot[i] = psnID->m_fromInvite;
4406 }
4407
4408 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
4409
4410 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
4411 }
4412 }
4413
4414 if (error != eCLE_Success)
4415 {
4416 FreeTask(mmTaskID);
4417 FreeSessionHandle(h);
4418 }
4419 }
4420 else
4421 {
4422 FreeSessionHandle(h);
4423 }
4424 }
4425
4426 NetLog("[Lobby] Start SessionJoin error %d", error);
4427
4428 return error;
4429 }
4430
4431 void CCryPSNMatchMaking::TickSessionJoin(CryMatchMakingTaskID mmTaskID)
4432 {
4433 STask* pTask = &m_task[mmTaskID];
4434
4435 if (pTask->error == eCLE_Success)
4436 {
4437 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
4438 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
4439 {
4440 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_JOIN_REQUEST_SLOT] != TMemInvalidHdl)
4441 {
4442 SJoinParamData* pJoinParams = (SJoinParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_JOIN_REQUEST_SLOT]);
4443 SSession* pSession = &m_sessions[pTask->session];
4444
4445 memset(pJoinParams, 0, sizeof(SJoinParamData));
4446
4447 pJoinParams->m_joinRequest.roomId = pSession->m_roomId;
4448 pJoinParams->m_joinRequest.roomPassword = NULL;
4449 pJoinParams->m_joinRequest.joinRoomGroupLabel = NULL;
4450 pJoinParams->m_joinRequest.roomMemberBinAttrInternal = NULL;
4451 pJoinParams->m_joinRequest.roomMemberBinAttrInternalNum = 0;
4452 pJoinParams->m_joinRequest.optData.len = 0;
4453
4454 StartSubTask(eST_WaitingForJoinRoomRequestCallback, mmTaskID);
4455
4456 int ret = sceNpMatching2JoinRoom(m_pPSNSupport->GetMatchmakingContextId(), &pJoinParams->m_joinRequest, NULL, &pTask->m_reqId);
4457 if (ret == PSN_OK)
4458 {
4459 //-- waiting for callback
4460 }
4461 else
4462 {
4463 NetLog("sceNpMatching2JoinRoom : error %08X", ret);
4464 //-- triggering a PSN error will cause an error event into SupportCallback() and set a task error if it needs to clean up.
4465 //-- otherwise, we have to update the task error ourself.
4466 if (!m_pPSNSupport->HandlePSNError(ret))
4467 {
4468 UpdateTaskError(mmTaskID, eCLE_InternalError);
4469 }
4470 }
4471 }
4472 else
4473 {
4474 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
4475 }
4476 }
4477 }
4478 }
4479
4480 bool CCryPSNMatchMaking::EventRequestResponse_JoinRoom(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
4481 {
4482 // sanity
4483 assert(pTask->subTask == eST_WaitingForJoinRoomRequestCallback);
4484 assert(data.m_requestEvent.m_event == REQUEST_EVENT_JOIN_ROOM);
4485 assert(data.m_requestEvent.m_dataHdl != TMemInvalidHdl);
4486 assert(data.m_requestEvent.m_dataSize == sizeof(SCryPSNJoinRoomResponse));
4487
4488 if ((data.m_requestEvent.m_error == 0) &&
4489 (data.m_requestEvent.m_dataHdl != TMemInvalidHdl) &&
4490 (data.m_requestEvent.m_dataSize == sizeof(SCryPSNJoinRoomResponse)))
4491 {
4492 if (pTask->session != CryLobbyInvalidSessionHandle)
4493 {
4494 SSession* pSession = &_this->m_sessions[pTask->session];
4495 if (pSession->IsUsed())
4496 {
4497 const SCryPSNJoinRoomResponse* const pJoinResponse = (SCryPSNJoinRoomResponse*)_this->m_lobby->MemGetPtr(data.m_requestEvent.m_dataHdl);
4498 pSession->m_roomId = pJoinResponse->m_roomInfo.m_roomId;
4499
4500 if (!pTask->canceled)
4501 {
4502 _this->AddInitialRoomMembers(pTask->session, pJoinResponse->m_roomMembers);
4503
4504 // take ownership of the memory returned by the callback so it is not automatically discarded on return
4505 pTask->params[PSN_MATCHMAKING_PSNSUPPORT_JOIN_RESPONSE_SLOT] = data.m_requestEvent.m_dataHdl;
4506 data.m_requestEvent.m_dataHdl = TMemInvalidHdl;
4507 data.m_requestEvent.m_returnFlags |= SCryPSNSupportCallbackEventData::SRequestEvent::REQUEST_EVENT_OWNS_MEMORY;
4508
4509 _this->StartSubTask(eST_WaitingForJoinRoomSignalingCallback, taskId);
4510 }
4511 else
4512 {
4513 _this->UpdateTaskError(taskId, eCLE_IllegalSessionJoin);
4514 }
4515 }
4516 else
4517 {
4518 _this->UpdateTaskError(taskId, eCLE_InternalError);
4519 }
4520 }
4521 else
4522 {
4523 _this->UpdateTaskError(taskId, eCLE_InternalError);
4524 }
4525
4526 return true;
4527 }
4528 else
4529 {
4530 return false;
4531 }
4532 }
4533
4534 void CCryPSNMatchMaking::ProcessSessionJoinHostAck(const TNetAddress& addr, CCrySharedLobbyPacket* pPacket)
4535 {
4536 CryLobbySessionHandle h = CryLobbyInvalidSessionHandle;
4537 SCryMatchMakingConnectionUID hostUID = pPacket->GetFromConnectionUID();
4538 CryMatchMakingConnectionID mmCxID = CryMatchMakingInvalidConnectionID;
4539
4540 if (FindConnectionFromUID(hostUID, &h, &mmCxID))
4541 {
4542 SSession* pSession = &m_sessions[h];
4543
4544 NetLog("[join session]: received join session server acknowledgment " PRFORMAT_SHMMCINFO, PRARG_SHMMCINFO(h, mmCxID, pSession->remoteConnection[mmCxID].connectionID, hostUID));
4545
4546 // part of the join session ack packet is the host's session id, which we want to copy.
4547 pPacket->ReadString((char*)&pSession->m_sessionId, sizeof(SceNpSessionId));
4548
4549 for (uint32 a = 0; a < MAX_PSN_ROOM_MEMBERS; a++)
4550 {
4551 SSession::SRoomMember* pMember = &pSession->m_members[a];
4552 if (pMember->IsValid(ePSNMI_Owner))
4553 {
4554 if ((pMember->m_signalingState == ePSNCS_Active) || (pMember->m_signalingState == ePSNCS_Pending))
4555 {
4556 pMember->m_bHostJoinAck = true;
4557
4558 for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; i++)
4559 {
4560 STask* pTask = &m_task[i];
4561
4562 if (pTask->used && pTask->running && (pTask->subTask == eST_WaitingForJoinRoomSignalingCallback))
4563 {
4564 TickSessionJoinSignaling(i);
4565 }
4566 }
4567 }
4568 break;
4569 }
4570 }
4571 }
4572 else
4573 {
4574 NetLog("[join session]: received join session server acknowledgement from unknown host " PRFORMAT_UID, PRARG_UID(hostUID));
4575 }
4576 }
4577
4578 void CCryPSNMatchMaking::TickSessionJoinSignaling(CryMatchMakingTaskID mmTaskID)
4579 {
4580 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
4581 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
4582 {
4583 STask* pTask = &m_task[mmTaskID];
4584
4585 UpdateSignaling(mmTaskID);
4586
4587 switch (CheckSignaling(mmTaskID))
4588 {
4589 case ePSNCS_None:
4590 {
4591 //-- This is bad, means there is no room owner!
4592 UpdateTaskError(mmTaskID, eCLE_InvalidParam);
4593 }
4594 break;
4595 case ePSNCS_Active:
4596 {
4597 assert(pTask->subTask == eST_WaitingForJoinRoomSignalingCallback);
4598
4599 //-- Success! We can talk to the server p2p, and we also have the hosts session Id
4600 // Next step is to join the same session via webapi.
4601 if (!pTask->canceled)
4602 {
4603 if (pTask->session != CryLobbyInvalidSessionHandle)
4604 {
4605 SSession* pSession = &m_sessions[pTask->session];
4606 if (pSession->IsUsed())
4607 {
4608 if (pSession->createFlags & CRYSESSION_CREATE_FLAG_INVITABLE)
4609 {
4610 if (pSession->m_sessionId.data[0] != 0)
4611 {
4612 SJoinParamData* pJoinParams = (SJoinParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_JOIN_REQUEST_SLOT]);
4613 SCryPSNOrbisWebApiJoinSessionInput* pWebApiJoinParams = (SCryPSNOrbisWebApiJoinSessionInput*)m_pPSNSupport->GetLobby()->MemGetPtr(pTask->params[PSN_MATCHMAKING_WEBAPI_JOIN_SLOT]);
4614 if (pJoinParams && pWebApiJoinParams)
4615 {
4616 StartSubTask(eST_WaitingForJoinRoomWebApiCallback, mmTaskID);
4617
4618 memcpy(&pWebApiJoinParams->sessionId, &pSession->m_sessionId, sizeof(SceNpSessionId));
4619
4620 pJoinParams->m_joinJobId = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::JoinSession, pTask->params[PSN_MATCHMAKING_WEBAPI_JOIN_SLOT]);
4621 if (pJoinParams->m_joinJobId == INVALID_WEBAPI_JOB_ID)
4622 {
4623 // failed
4624 UpdateTaskError(mmTaskID, eCLE_InternalError);
4625 }
4626 }
4627 else
4628 {
4629 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
4630 }
4631 }
4632 else
4633 {
4634 // missing session Id
4635 UpdateTaskError(mmTaskID, eCLE_InvalidParam);
4636 }
4637 }
4638 else
4639 {
4640 // Session is not invitable, so we don't need to join a webapi session
4641 // This is the end of Join! Success!
4642 UpdateTaskError(mmTaskID, eCLE_Success);
4643 StopTaskRunning(mmTaskID);
4644 }
4645 }
4646 else
4647 {
4648 // session not in use
4649 UpdateTaskError(mmTaskID, eCLE_InternalError);
4650 }
4651 }
4652 else
4653 {
4654 // invalid session handle
4655 UpdateTaskError(mmTaskID, eCLE_InternalError);
4656 }
4657 }
4658 else
4659 {
4660 // cancelled
4661 UpdateTaskError(mmTaskID, eCLE_IllegalSessionJoin);
4662 }
4663 }
4664 break;
4665 case ePSNCS_Dead:
4666 {
4667 assert(pTask->subTask == eST_WaitingForJoinRoomSignalingCallback);
4668
4669 //-- Failed! We cannot talk to the server via p2p, so we've failed at the last hurdle! Join task completed(failed)
4670 UpdateTaskError(mmTaskID, eCLE_ConnectionFailed);
4671 }
4672 break;
4673 }
4674 }
4675 }
4676
4677 void CCryPSNMatchMaking::EventWebApiJoinSession(CryMatchMakingTaskID mmTaskID, SCryPSNSupportCallbackEventData& data)
4678 {
4679 STask* pTask = &m_task[mmTaskID];
4680
4681 if (pTask->session != CryLobbyInvalidSessionHandle)
4682 {
4683 SSession* pSession = &m_sessions[pTask->session];
4684
4685 if (data.m_webApiEvent.m_error == PSN_OK)
4686 {
4687 // Completed successfully
4688 UpdateTaskError(mmTaskID, eCLE_Success);
4689 StopTaskRunning(mmTaskID);
4690 return;
4691 }
4692 }
4693
4694 // otherwise something went wrong!
4695 UpdateTaskError(mmTaskID, eCLE_InternalError);
4696 StopTaskRunning(mmTaskID);
4697 }
4698
4699 void CCryPSNMatchMaking::EndSessionJoin(CryMatchMakingTaskID mmTaskID)
4700 {
4701 uint32 myIP = 0, myPort = 0;
4702 STask* pTask = &m_task[mmTaskID];
4703 SSession* pSession = &m_sessions[pTask->session];
4704
4705 SCryPSNJoinRoomResponse* pResponse = NULL;
4706
4707 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_JOIN_RESPONSE_SLOT] != TMemInvalidHdl)
4708 {
4709 pResponse = (SCryPSNJoinRoomResponse*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_JOIN_RESPONSE_SLOT]);
4710 }
4711
4712 if (pTask->error == eCLE_Success)
4713 {
4714 if (pResponse)
4715 {
4716 SSession::SRoomMember* pMember = FindRoomMemberFromRoomMemberID(pTask->session, pSession->m_ownerMemberId);
4717
4718 if (pSession->m_ownerMemberId != pSession->m_myMemberId)
4719 {
4720 if (pMember && (pMember->m_signalingState == ePSNCS_Active))
4721 {
4722 SCryMatchMakingConnectionUID matchingUID;
4723 myIP = pMember->m_peerAddr.s_addr;
4724 myPort = pMember->m_peerPort;
4725
4726 matchingUID.m_uid = pSession->m_myMemberId;
4727 matchingUID.m_sid = pSession->m_roomId;
4728
4729 pSession->localConnection.uid = matchingUID;
4730 pSession->localConnection.pingToServer = CRYLOBBY_INVALID_PING;
4731 pSession->localConnection.used = true;
4732
4733 uint16 sessionCreateGameFlags = 0;
4734 memcpy(&sessionCreateGameFlags, pResponse->m_roomInfo.m_binAttributes[0].m_data, sizeof(sessionCreateGameFlags));
4735 pSession->createFlags = (pSession->createFlags & CRYSESSION_CREATE_FLAG_SYSTEM_MASK) | (sessionCreateGameFlags << CRYSESSION_CREATE_FLAG_GAME_FLAGS_SHIFT);
4736
4737 bool hostMigrationSupported = m_lobby->GetLobbyServiceFlag(m_serviceType, eCLSF_SupportHostMigration);
4738 if ((pSession->createFlags & CRYSESSION_CREATE_FLAG_MIGRATABLE) && hostMigrationSupported)
4739 {
4740 pSession->localFlags |= CRYSESSION_LOCAL_FLAG_CAN_SEND_HOST_HINTS;
4741 }
4742
4743 matchingUID.m_uid = pSession->m_ownerMemberId;
4744 CryLobbySessionHandle h;
4745 FindConnectionFromUID(matchingUID, &h, &pSession->hostConnectionID);
4746 assert(h == pTask->session);
4747
4748 // if (pSession->createFlags & CRYSESSION_CREATE_FLAG_INVITABLE)
4749 // {
4750 // if (m_pService->GetLobbyUI())
4751 // {
4752 // ((CCryPSNLobbyUI*)m_pService->GetLobbyUI())->SetStoredInviteSessionHandle(CreateGameSessionHandle(pTask->session, CryMatchMakingInvalidConnectionUID));
4753 // }
4754 // }
4755 }
4756 else
4757 {
4758 UpdateTaskError(mmTaskID, eCLE_InternalError);
4759 }
4760 }
4761 else
4762 {
4763 // we've become the owner in the middle of joining, that won't end well,
4764 // so terminate here
4765 UpdateTaskError(mmTaskID, eCLE_ConnectionFailed);
4766 }
4767 }
4768 else
4769 {
4770 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
4771 }
4772 }
4773
4774 // free the memory allocated to the response
4775 if (pResponse)
4776 {
4777 pResponse->Release(m_lobby);
4778 }
4779
4780 ((CryMatchmakingSessionJoinCallback)pTask->cb)(pTask->lTaskID, pTask->error, CreateGameSessionHandle(pTask->session, pSession->localConnection.uid), myIP, myPort, pTask->cbArg);
4781
4782 if (pTask->error == eCLE_Success)
4783 {
4784 InitialUserDataEvent(pTask->session);
4785 }
4786 }
4787
4788 // END SESSION JOIN -------------------------------------------------------------
4789
4790 // SESSION UPDATE USER ---------------------------------------------------------------
4791
4792 ECryLobbyError CCryPSNMatchMaking::SessionSetLocalUserData(CrySessionHandle gh, CryLobbyTaskID* pTaskID, uint32 user, uint8* pData, uint32 dataSize, CryMatchmakingCallback pCB, void* pCBArg)
4793 {
4794 ECryLobbyError error = eCLE_Success;
4795
4796 LOBBY_AUTO_LOCK;
4797
4798 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
4799
4800 if ((h < MAX_MATCHMAKING_SESSIONS) && m_sessions[h].IsUsed())
4801 {
4802 SSession* session = &m_sessions[h];
4803
4804 if (dataSize <= CRYLOBBY_USER_DATA_SIZE_IN_BYTES)
4805 {
4806 CryMatchMakingTaskID mmTaskID;
4807
4808 error = StartTask(eT_SessionUserData, false, session->localConnection.users[0], &mmTaskID, pTaskID, h, (void*)pCB, pCBArg);
4809 if (error == eCLE_Success)
4810 {
4811 STask* task = &m_task[mmTaskID];
4812
4813 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_USERDATA_DATA_SLOT, pData, dataSize, dataSize);
4814 if (error == eCLE_Success)
4815 {
4816 error = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_USERDATA_REQUEST_SLOT, NULL, 1, sizeof(SUserDataParamData));
4817 if (error == eCLE_Success)
4818 {
4819 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
4820
4821 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
4822 }
4823 else
4824 {
4825 FreeTask(mmTaskID);
4826 }
4827 }
4828 else
4829 {
4830 FreeTask(mmTaskID);
4831 }
4832 }
4833 }
4834 else
4835 {
4836 error = eCLE_OutOfUserData;
4837 }
4838 }
4839 else
4840 {
4841 error = eCLE_InvalidSession;
4842 }
4843
4844 NetLog("[Lobby] Start SessionUpdate error %d", error);
4845
4846 return error;
4847 }
4848
4849 void CCryPSNMatchMaking::TickSessionUserData(CryMatchMakingTaskID mmTaskID)
4850 {
4851 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
4852 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
4853 {
4854 STask* pTask = &m_task[mmTaskID];
4855
4856 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_USERDATA_REQUEST_SLOT] != TMemInvalidHdl)
4857 {
4858 SUserDataParamData* pUserDataParams = (SUserDataParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_USERDATA_REQUEST_SLOT]);
4859
4860 if (pTask->params[PSN_MATCHMAKING_USERDATA_DATA_SLOT] != TMemInvalidHdl)
4861 {
4862 uint8* pData = (uint8*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_USERDATA_DATA_SLOT]);
4863 SSession* pSession = &m_sessions[pTask->session];
4864
4865 memset((void*)pUserDataParams, 0, sizeof(SUserDataParamData));
4866
4867 memcpy(pUserDataParams->m_binAttrInternalData, pData, pTask->numParams[PSN_MATCHMAKING_USERDATA_DATA_SLOT]);
4868 pUserDataParams->m_userDataRequest.roomMemberBinAttrInternal = pUserDataParams->m_binAttrInternal;
4869
4870 pUserDataParams->m_userDataRequest.roomId = pSession->m_roomId;
4871 pUserDataParams->m_userDataRequest.memberId = 0; // This is allowed, and means update my own data
4872 pUserDataParams->m_userDataRequest.teamId = 0;
4873
4874 for (int a = 0; a < SCE_NP_MATCHING2_ROOMMEMBER_BIN_ATTR_INTERNAL_NUM; a++)
4875 {
4876 pUserDataParams->m_binAttrInternal[a].id = SCE_NP_MATCHING2_ROOMMEMBER_BIN_ATTR_INTERNAL_1_ID + a;
4877 pUserDataParams->m_binAttrInternal[a].ptr = &pUserDataParams->m_binAttrInternalData[a * SCE_NP_MATCHING2_ROOMMEMBER_BIN_ATTR_INTERNAL_MAX_SIZE];
4878 pUserDataParams->m_binAttrInternal[a].size = SCE_NP_MATCHING2_ROOMMEMBER_BIN_ATTR_INTERNAL_MAX_SIZE;
4879 }
4880 pUserDataParams->m_userDataRequest.roomMemberBinAttrInternalNum = SCE_NP_MATCHING2_ROOMMEMBER_BIN_ATTR_INTERNAL_NUM;
4881
4882 StartSubTask(eST_WaitingForUserDataRequestCallback, mmTaskID);
4883
4884 int ret = sceNpMatching2SetRoomMemberDataInternal(m_pPSNSupport->GetMatchmakingContextId(), &pUserDataParams->m_userDataRequest, NULL, &pTask->m_reqId);
4885 if (ret == PSN_OK)
4886 {
4887 //-- Waiting for callback
4888 }
4889 else
4890 {
4891 NetLog("sceNpMatching2SetRoomMemberDataInternal : error %08X", ret);
4892 if (!m_pPSNSupport->HandlePSNError(ret))
4893 {
4894 UpdateTaskError(mmTaskID, eCLE_InternalError);
4895 }
4896 }
4897 }
4898 else
4899 {
4900 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
4901 }
4902 }
4903 else
4904 {
4905 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
4906 }
4907 }
4908 }
4909
4910 bool CCryPSNMatchMaking::EventRequestResponse_SetRoomMemberDataInternal(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
4911 {
4912 // sanity tests
4913 assert(pTask->subTask == eST_WaitingForUserDataRequestCallback);
4914 assert(data.m_requestEvent.m_event == REQUEST_EVENT_SET_ROOM_MEMBER_DATA_INTERNAL);
4915 assert(data.m_requestEvent.m_dataSize == 0);
4916
4917 if (data.m_requestEvent.m_error == 0)
4918 {
4919 // We don't really care if this SetRoomMemberDataInternal succeeds for fails, so we'll just mark the task as complete
4920 _this->UpdateTaskError(taskId, eCLE_Success);
4921 _this->StopTaskRunning(taskId);
4922
4923 // this event is handled
4924 return true;
4925 }
4926 else
4927 {
4928 // return false to let the default error handler work
4929 return false;
4930 }
4931 }
4932
4933 // END SESSION UPDATE USER ------------------------------------------------------------------------
4934
4935 void CCryPSNMatchMaking::OnPacket(const TNetAddress& addr, CCryLobbyPacket* pPacket)
4936 {
4937 CCrySharedLobbyPacket* pSPacket = (CCrySharedLobbyPacket*)pPacket;
4938
4939 switch (pSPacket->StartRead())
4940 {
4941 #if NETWORK_HOST_MIGRATION
4942 case ePSNPT_HostMigrationStart:
4943 ProcessHostMigrationStart(addr, pSPacket);
4944 break;
4945
4946 case ePSNPT_HostMigrationServer:
4947 ProcessHostMigrationFromServer(addr, pSPacket);
4948 break;
4949 #endif
4950
4951 case ePSNPT_JoinSessionAck:
4952 ProcessSessionJoinHostAck(addr, pSPacket);
4953 break;
4954
4955 default:
4956 CCryMatchMaking::OnPacket(addr, pSPacket);
4957 break;
4958 }
4959 }
4960
4961 void CCryPSNMatchMaking::SessionUserDataEvent(ECryLobbySystemEvent event, CryLobbySessionHandle h, CryMatchMakingConnectionID id)
4962 {
4963 SSession* pSession = &m_sessions[h];
4964
4965 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_USER_DATA_EVENTS_STARTED)
4966 {
4967 SCryUserInfoResult userInfo;
4968 userInfo.m_userID = new SCryPSNUserID;
4969
4970 if (id == CryMatchMakingInvalidConnectionID)
4971 {
4972 SSession::SLConnection* pConnection = &pSession->localConnection;
4973 GetRoomMemberData(h, userInfo, pConnection->uid);
4974 }
4975 else
4976 {
4977 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
4978 GetRoomMemberData(h, userInfo, pConnection->uid);
4979 }
4980
4981 CCryMatchMaking::SessionUserDataEvent(event, h, &userInfo);
4982 }
4983 }
4984
4985 void CCryPSNMatchMaking::InitialUserDataEvent(CryLobbySessionHandle h)
4986 {
4987 SSession* pSession = &m_sessions[h];
4988
4989 pSession->localFlags |= CRYSESSION_LOCAL_FLAG_USER_DATA_EVENTS_STARTED;
4990
4991 SessionUserDataEvent(eCLSE_SessionUserJoin, h, CryMatchMakingInvalidConnectionID);
4992
4993 for (uint32 i = 0; i < MAX_LOBBY_CONNECTIONS; i++)
4994 {
4995 SSession::SRConnection* pConnection = &pSession->remoteConnection[i];
4996
4997 if (pConnection->used)
4998 {
4999 SessionUserDataEvent(eCLSE_SessionUserJoin, h, i);
5000 }
5001 }
5002 }
5003
5004 #if NETWORK_HOST_MIGRATION
5005 void CCryPSNMatchMaking::HostMigrationInitialise(CryLobbySessionHandle h, EDisconnectionCause cause)
5006 {
5007 SSession* pSession = &m_sessions[h];
5008
5009 pSession->hostMigrationInfo.Reset();
5010 }
5011
5012 ECryLobbyError CCryPSNMatchMaking::HostMigrationServer(SHostMigrationInfo* pInfo)
5013 {
5014 ECryLobbyError error = eCLE_Success;
5015
5016 LOBBY_AUTO_LOCK;
5017
5018 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(pInfo->m_session);
5019 if (h != CryLobbyInvalidSessionHandle)
5020 {
5021 SSession* pSession = &m_sessions[h];
5022 CryMatchMakingTaskID mmTaskID;
5023
5024 pSession->localFlags |= CRYSESSION_LOCAL_FLAG_HOST;
5025 pSession->hostConnectionID = CryMatchMakingInvalidConnectionID;
5026 error = StartTask(eT_SessionMigrateHostServer, false, pSession->localConnection.users[0], &mmTaskID, NULL, h, NULL, NULL);
5027
5028 if (error == eCLE_Success)
5029 {
5030 STask* pTask = &m_task[mmTaskID];
5031 #if HOST_MIGRATION_SOAK_TEST_BREAK_DETECTION
5032 DetectHostMigrationTaskBreak(h, "HostMigrationServer()");
5033 #endif
5034 pSession->hostMigrationInfo.m_taskID = pTask->lTaskID;
5035
5036 NetLog("[Host Migration]: matchmaking migrating " PRFORMAT_SH " on the SERVER", PRARG_SH(h));
5037 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
5038 }
5039 }
5040 else
5041 {
5042 error = eCLE_InvalidSession;
5043 }
5044
5045 if (error != eCLE_Success)
5046 {
5047 NetLog("[Host Migration]: CCryPSNMatchMaking::HostMigrationServer(): " PRFORMAT_SH ", error %d", PRARG_SH(h), error);
5048 }
5049
5050 return error;
5051 }
5052
5053 void CCryPSNMatchMaking::HostMigrationServerNT(CryMatchMakingTaskID mmTaskID)
5054 {
5055 STask* task = &m_task[mmTaskID];
5056 task->StartTimer();
5057 }
5058
5059 void CCryPSNMatchMaking::TickHostMigrationServerNT(CryMatchMakingTaskID mmTaskID)
5060 {
5061 STask* pTask = &m_task[mmTaskID];
5062 SSession* pSession = &m_sessions[pTask->session];
5063
5064 if (pTask->canceled)
5065 {
5066 NetLog("[Host Migration]: TickHostMigrationServerNT() cancelled for " PRFORMAT_SH " - bailing", PRARG_SH(pTask->session));
5067 StopTaskRunning(mmTaskID);
5068 return;
5069 }
5070
5071 float timeout = CLobbyCVars::Get().hostMigrationTimeout * 1000.0f;
5072 if (pTask->GetTimer() > timeout)
5073 {
5074 StopTaskRunning(mmTaskID);
5075 return;
5076 }
5077
5078 NetLog("[Host Migration]: matchmaking SERVER migrated " PRFORMAT_SH " successfully - informing CLIENTS", PRARG_SH(pTask->session));
5079
5080 const uint32 MaxBufferSize = CryLobbyPacketHeaderSize;
5081 uint8 buffer[MaxBufferSize];
5082 CCrySharedLobbyPacket packet;
5083
5084 packet.SetWriteBuffer(buffer, MaxBufferSize);
5085 packet.StartWrite(ePSNPT_HostMigrationServer, true);
5086
5087 #if !defined(CRYNETWORK_RELEASEBUILD)
5088 int count = 0;
5089 CCryMatchMaking::SSession* pSession = CCryMatchMaking::m_sessions[pTask->session];
5090 for (uint32 i = 0; i < MAX_LOBBY_CONNECTIONS; i++)
5091 {
5092 CCryMatchMaking::SSession::SRConnection* pConnection = pSession->remoteConnection[i];
5093
5094 if (pConnection->used)
5095 {
5096 TNetAddress ip;
5097 if (m_lobby->AddressFromConnection(ip, pConnection->connectionID))
5098 {
5099 NetLog(" sending to " PRFORMAT_ADDR " client, " PRFORMAT_MMCINFO, PRARG_ADDR(ip), PRARG_MMCINFO(CryMatchMakingConnectionID(i), pConnection->connectionID, pConnection->uid));
5100 }
5101
5102 ++count;
5103 }
5104 }
5105 NetLog(" sending to %i clients", count);
5106 #endif
5107
5108 SendToAll(mmTaskID, &packet, pTask->session, CryMatchMakingInvalidConnectionID);
5109 m_lobby->FlushMessageQueue();
5110
5111 pSession->hostMigrationInfo.m_sessionMigrated = true;
5112 pSession->hostMigrationInfo.m_matchMakingFinished = true;
5113 StopTaskRunning(mmTaskID);
5114 }
5115
5116 void CCryPSNMatchMaking::ProcessHostMigrationFromServer(const TNetAddress& addr, CCrySharedLobbyPacket* pPacket)
5117 {
5118 CryLobbySessionHandle h = CryLobbyInvalidSessionHandle;
5119 SCryMatchMakingConnectionUID hostUID = pPacket->GetFromConnectionUID();
5120 CryMatchMakingConnectionID mmCxID = CryMatchMakingInvalidConnectionID;
5121
5122 if (FindConnectionFromUID(hostUID, &h, &mmCxID))
5123 {
5124 SSession* pSession = &m_sessions[h];
5125 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_HOST)
5126 {
5127 NetLog("[Host Migration]: ignoring session details from " PRFORMAT_SHMMCINFO " as I am already the server " PRFORMAT_UID,
5128 PRARG_SHMMCINFO(h, mmCxID, pSession->remoteConnection[mmCxID].connectionID, hostUID), PRARG_UID(pSession->localConnection.uid));
5129 }
5130 else
5131 {
5132 NetLog("[Host Migration]: matchmaking CLIENT received session details from " PRFORMAT_SHMMCINFO " - migrating to new PSN session",
5133 PRARG_SHMMCINFO(h, mmCxID, pSession->remoteConnection[mmCxID].connectionID, hostUID));
5134 NetLog("[Host Migration]: matchmaking CLIENT received server confirmation for " PRFORMAT_SH " - migrating to new session", PRARG_SH(h));
5135
5136 SSession* pSession = &m_sessions[h];
5137 if (pSession->hostMigrationInfo.m_state == eHMS_Idle)
5138 {
5139 NetLog("[Host Migration]: received server confirmation before host migration initiated - initiating now");
5140 HostMigrationInitiate(h, eDC_Unknown);
5141 }
5142
5143 pSession->localFlags &= ~CRYSESSION_LOCAL_FLAG_HOST;
5144 pSession->hostMigrationInfo.m_sessionMigrated = true;
5145 pSession->hostMigrationInfo.m_matchMakingFinished = true;
5146
5147 if (pSession->m_ownerMemberId == hostUID.m_uid)
5148 {
5149 pSession->hostMigrationInfo.m_newHostAddressValid = true;
5150 }
5151 }
5152 }
5153 else
5154 {
5155 NetLog("[Host Migration]: received server notification from unknown host " PRFORMAT_UID, PRARG_UID(hostUID));
5156 }
5157 }
5158
5159 bool CCryPSNMatchMaking::GetNewHostAddress(char* address, SHostMigrationInfo* pInfo)
5160 {
5161 bool success = false;
5162
5163 CryLobbySessionHandle sessionIndex = GetSessionHandleFromGameSessionHandle(pInfo->m_session);
5164 SSession* pSession = &m_sessions[sessionIndex];
5165 SHostMigrationInfo_Private* pPrivateInfo = &pSession->hostMigrationInfo;
5166
5167 if ((pSession->localFlags & CRYSESSION_LOCAL_FLAG_USED) && pPrivateInfo->m_newHostAddressValid)
5168 {
5169 uint32 myIP = 0;
5170 uint16 myPort = 0;
5171
5172 const SSession::SRoomMember* const pMember = FindRoomMemberFromRoomMemberID(sessionIndex, pSession->m_ownerMemberId);
5173
5174 if (pMember)
5175 {
5176 if (pSession->serverConnectionID != CryMatchMakingInvalidConnectionID)
5177 {
5178 if (pSession->desiredHostUID != CryMatchMakingInvalidConnectionUID)
5179 {
5180 if ((pMember->m_valid & ePSNMI_Me) == 0) // Make sure we are not the new host before updating the connection information
5181 {
5182 if (!pSession->hostMigrationInfo.m_matchMakingFinished)
5183 {
5184 CryMatchMakingConnectionID remoteConnectionID = FindConnectionIDFromRoomMemberID(sessionIndex, pSession->m_ownerMemberId);
5185 if (remoteConnectionID != CryMatchMakingInvalidConnectionID)
5186 {
5187 pInfo->SetIsNewHost(false);
5188 success = (pSession->remoteConnection[remoteConnectionID].uid == pSession->desiredHostUID);
5189
5190 NetLog("[Host Migration]: new host for session " PRFORMAT_SH " host uid " PRFORMAT_UID " desired uid " PRFORMAT_UID, PRARG_SH(sessionIndex), PRARG_UID(pSession->remoteConnection[remoteConnectionID].uid), PRARG_UID(pSession->desiredHostUID));
5191 }
5192 else
5193 {
5194 NetLog("[Host Migration]: failed to find connection for new host " PRFORMAT_UID " of session " PRFORMAT_SH, PRARG_UID(pSession->desiredHostUID), PRARG_SH(sessionIndex));
5195 }
5196 }
5197 else
5198 {
5199 NetLog("[Host Migration]: matchmaking not finished desiredHostUID " PRFORMAT_UID " newHostUID " PRFORMAT_UID, PRARG_UID(pSession->desiredHostUID), PRARG_UID(pSession->newHostUID));
5200 }
5201
5202 }
5203 else
5204 {
5205 pInfo->SetIsNewHost(true);
5206 success = (pSession->localConnection.uid == pSession->desiredHostUID);
5207
5208 NetLog("[Host Migration]: becoming the new host for session " PRFORMAT_SH " host uid " PRFORMAT_UID " desired uid " PRFORMAT_UID, PRARG_SH(sessionIndex), PRARG_UID(pSession->localConnection.uid), PRARG_UID(pSession->desiredHostUID));
5209 }
5210 }
5211
5212 return success;
5213 }
5214
5215 if (pMember->m_signalingState == ePSNCS_Active)
5216 {
5217 myIP = pMember->m_peerAddr.s_addr;
5218 myPort = pMember->m_peerPort;
5219 }
5220 if ((pMember->m_valid & ePSNMI_Me) == 0) // Make sure we are not the new host before updating the connection information
5221 {
5222 if (!pSession->hostMigrationInfo.m_matchMakingFinished)
5223 {
5224 pInfo->SetIsNewHost(false);
5225 // Wait until the server has notified us that migration has completed
5226 return false;
5227 }
5228
5229 NetLog("[Host Migration]: new host is uid %i " PRFORMAT_SH, pSession->m_ownerMemberId, PRARG_SH(sessionIndex));
5230 m_lobby->DecodeAddress(myIP, myPort, address, false);
5231 }
5232 else
5233 {
5234 // We are the new host, we should return quickly
5235 pInfo->SetIsNewHost(true);
5236 NetLog("[Host Migration]: becoming the new host for " PRFORMAT_SH "...", PRARG_SH(sessionIndex));
5237
5238 const SCryLobbyParameters& lobbyParams = m_lobby->GetLobbyParameters();
5239 uint16 port = lobbyParams.m_listenPort;
5240 cry_sprintf(address, HOST_MIGRATION_MAX_SERVER_NAME_SIZE, "%s:%d", LOCAL_CONNECTION_STRING, port);
5241 }
5242 }
5243
5244 NetLog("[Host Migration]: Using %s as connection address", address);
5245 success = true;
5246 }
5247
5248 return success;
5249 }
5250
5251 void CCryPSNMatchMaking::HostMigrationStartNT(CryMatchMakingTaskID mmTaskID)
5252 {
5253 STask* pTask = &m_task[mmTaskID];
5254 SSession* pSession = &m_sessions[pTask->session];
5255
5256 // Ensure we're the host and we've not started the session
5257 if ((pSession->localFlags & (CRYSESSION_LOCAL_FLAG_HOST | CRYSESSION_LOCAL_FLAG_STARTED)) == CRYSESSION_LOCAL_FLAG_HOST)
5258 {
5259 // Determine if host hinting has a better host
5260 SHostHintInformation newHost;
5261 CryMatchMakingConnectionID newHostID;
5262 if (FindConnectionFromSessionUID(pTask->session, pSession->newHostUID, &newHostID))
5263 {
5264 SSession::SRConnection* pConnection = &pSession->remoteConnection[newHostID];
5265 newHost = pConnection->hostHintInfo;
5266 }
5267
5268 bool isBetterHost = false;
5269 if (SortNewHostPriorities_ComparatorHelper(newHost, pSession->hostHintInfo) < 0)
5270 {
5271 isBetterHost = true;
5272 }
5273
5274 if (isBetterHost)
5275 {
5276 pTask->params[PSN_MATCHMAKING_PSNSUPPORT_GRANTROOM_REQUEST_SLOT] = m_lobby->MemAlloc(sizeof(SGrantRoomOwnerParamData));
5277 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_GRANTROOM_REQUEST_SLOT] != TMemInvalidHdl)
5278 {
5279 if (HostMigrationInitiate(pTask->session, eDC_Unknown))
5280 {
5281 const uint32 maxBufferSize = CryLobbyPacketHeaderSize;
5282 uint8 buffer[maxBufferSize];
5283 CCryLobbyPacket packet;
5284
5285 NetLog("[Host Migration]: local server is not best host for " PRFORMAT_SH "- instructing clients to choose new host (sent from " PRFORMAT_UID ")", PRARG_SH(pTask->session), PRARG_UID(pSession->localConnection.uid));
5286 packet.SetWriteBuffer(buffer, maxBufferSize);
5287 packet.StartWrite(ePSNPT_HostMigrationStart, true);
5288
5289 SendToAll(mmTaskID, &packet, pTask->session, CryMatchMakingInvalidConnectionID);
5290 pSession->localFlags &= ~CRYSESSION_LOCAL_FLAG_HOST;
5291
5292 SGrantRoomOwnerParamData* pGrantRoomOwnerData = (SGrantRoomOwnerParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_GRANTROOM_REQUEST_SLOT]);
5293 memset(pGrantRoomOwnerData, 0, sizeof(SGrantRoomOwnerParamData));
5294
5295 pGrantRoomOwnerData->m_reqParam.roomId = pSession->m_roomId;
5296 pGrantRoomOwnerData->m_reqParam.newOwner = (SceNpMatching2RoomMemberId)(pSession->newHostUID.m_uid);
5297
5298 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
5299 }
5300 else
5301 {
5302 NetLog("[Host Migration]: local server is not best host for " PRFORMAT_SH ", but session is not migratable", PRARG_SH(pTask->session));
5303 UpdateTaskError(mmTaskID, eCLE_SessionNotMigratable);
5304 StopTaskRunning(mmTaskID);
5305 }
5306 }
5307 else
5308 {
5309 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
5310 }
5311
5312 if (pTask->error != eCLE_Success)
5313 {
5314 StopTaskRunning(mmTaskID);
5315 }
5316 }
5317 else
5318 {
5319 NetLog("[Host Migration]: local server is best host for " PRFORMAT_SH, PRARG_SH(pTask->session));
5320 StopTaskRunning(mmTaskID);
5321 }
5322 }
5323 else
5324 {
5325 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_STARTED)
5326 {
5327 NetLog("[Host Migration]: SessionEnsureBestHost() called after the session had started");
5328 }
5329
5330 StopTaskRunning(mmTaskID);
5331 }
5332 }
5333
5334 void CCryPSNMatchMaking::TickHostMigrationStartNT(CryMatchMakingTaskID mmTaskID)
5335 {
5336 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
5337 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
5338 {
5339 STask* pTask = &m_task[mmTaskID];
5340
5341 if (pTask->params[PSN_MATCHMAKING_PSNSUPPORT_GRANTROOM_REQUEST_SLOT] != TMemInvalidHdl)
5342 {
5343 SGrantRoomOwnerParamData* pGrantRoomOwnerData = (SGrantRoomOwnerParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_GRANTROOM_REQUEST_SLOT]);
5344
5345 StartSubTask(eST_WaitingForGrantRoomOwnerRequestCallback, mmTaskID);
5346
5347 int ret = sceNpMatching2GrantRoomOwner(m_pPSNSupport->GetMatchmakingContextId(), &pGrantRoomOwnerData->m_reqParam, NULL, &pTask->m_reqId);
5348 if (ret == PSN_OK)
5349 {
5350 //-- waiting for callback
5351 }
5352 else
5353 {
5354 NetLog("sceNpMatching2GrantRoomOwnerRequest : error %08X", ret);
5355 //-- triggering a PSN error will cause an error event into SupportCallback() and set a task error if it needs to clean up.
5356 //-- otherwise, we have to update the task error ourself.
5357 if (!m_pPSNSupport->HandlePSNError(ret))
5358 {
5359 UpdateTaskError(mmTaskID, eCLE_InternalError);
5360 }
5361 }
5362 }
5363 else
5364 {
5365 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
5366 }
5367 }
5368 }
5369
5370 bool CCryPSNMatchMaking::EventRequestResponse_GrantRoomOwner(CCryPSNMatchMaking* _this, STask* pTask, CryMatchMakingTaskID taskId, SCryPSNSupportCallbackEventData& data)
5371 {
5372 // sanity
5373 assert(pTask->subTask == eST_WaitingForGrantRoomOwnerRequestCallback);
5374 assert(data.m_requestEvent.m_event == REQUEST_EVENT_GRANT_ROOM_OWNER);
5375 assert(data.m_requestEvent.m_dataSize == 0);
5376
5377 // We don't really care if this GrantRoomOwnerRequest succeeds for fails, so we'll just mark the task as complete
5378 _this->UpdateTaskError(taskId, eCLE_Success);
5379 _this->StopTaskRunning(taskId);
5380
5381 // this event is handled
5382 return true;
5383 }
5384
5385 void CCryPSNMatchMaking::ProcessHostMigrationStart(const TNetAddress& addr, CCrySharedLobbyPacket* pPacket)
5386 {
5387 CryLobbySessionHandle h = CryLobbyInvalidSessionHandle;
5388 SCryMatchMakingConnectionUID hostUID = pPacket->GetFromConnectionUID();
5389 CryMatchMakingConnectionID mmCxID = CryMatchMakingInvalidConnectionID;
5390
5391 if (FindConnectionFromUID(hostUID, &h, &mmCxID))
5392 {
5393 SSession* pSession = &m_sessions[h];
5394
5395 NetLog("[Host Migration]: received host migration push event for " PRFORMAT_SHMMCINFO, PRARG_SHMMCINFO(h, mmCxID, pSession->remoteConnection[mmCxID].connectionID, hostUID));
5396
5397 if (pSession->IsUsed() && !(pSession->localFlags & CRYSESSION_LOCAL_FLAG_HOST))
5398 {
5399 if (pSession->hostMigrationInfo.m_state == eHMS_Idle)
5400 {
5401 NetLog("[Host Migration]: remote server is not best host for " PRFORMAT_SH " - instructed to choose new host", PRARG_SH(h));
5402 HostMigrationInitiate(h, eDC_Unknown);
5403 }
5404 else
5405 {
5406 NetLog("[Host Migration]: ignoring pushed migration event - already migrating " PRFORMAT_SH, PRARG_SH(h));
5407 }
5408 }
5409 }
5410 else
5411 {
5412 NetLog("[Host Migration]: received push migration event from unknown host " PRFORMAT_UID, PRARG_UID(hostUID));
5413 }
5414 }
5415 #endif // NETWORK_HOST_MIGRATION
5416
5417 ECryLobbyError CCryPSNMatchMaking::SessionEnsureBestHost(CrySessionHandle gh, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
5418 {
5419 ECryLobbyError rc = eCLE_Success;
5420
5421 #if NETWORK_HOST_MIGRATION
5422 LOBBY_AUTO_LOCK;
5423
5424 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
5425
5426 if (h != CryLobbyInvalidSessionHandle)
5427 {
5428 CryMatchMakingTaskID mmTaskID;
5429 SSession* pSession = &m_sessions[h];
5430 rc = StartTask(eT_SessionMigrateHostStart, false, pSession->localConnection.users[0], &mmTaskID, pTaskID, h, (void*)pCB, pCBArg);
5431
5432 if (rc == eCLE_Success)
5433 {
5434 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
5435 }
5436 }
5437 #endif
5438
5439 return rc;
5440 }
5441
5442 void CCryPSNMatchMaking::AddVoiceUser(SSession::SRoomMember* pMember)
5443 {
5444 #if USE_PSN_VOICE
5445 CCryPSNVoice* pVoice = (CCryPSNVoice*)m_pService->GetVoice();
5446 if (pVoice)
5447 {
5448 assert(pMember->IsValid(ePSNMI_Other));
5449 pVoice->AddRemoteTalker(pMember->m_npId, pMember->m_peerAddr, pMember->m_peerPort, (pMember->m_signalingState == ePSNCS_Active) ? true : false);
5450 }
5451 #endif // USE_PSN_VOICE
5452 }
5453
5454 void CCryPSNMatchMaking::ClearVoiceUser(SSession::SRoomMember* pMember)
5455 {
5456 #if USE_PSN_VOICE
5457 CCryPSNVoice* pVoice = (CCryPSNVoice*)m_pService->GetVoice();
5458 if (pVoice)
5459 {
5460 assert(pMember->m_valid & ePSNMI_Other);
5461 pVoice->ClearRemoteTalker(pMember->m_npId);
5462 }
5463 #endif // USE_PSN_VOICE
5464 }
5465
5466 void CCryPSNMatchMaking::UpdateVoiceUsers()
5467 {
5468 #if USE_PSN_VOICE
5469 CCryPSNVoice* pVoice = (CCryPSNVoice*)m_pService->GetVoice();
5470 if (pVoice)
5471 {
5472 bool bNeedsVoice = false;
5473
5474 for (uint32 i = 0; ((i < MAX_MATCHMAKING_SESSIONS) && (bNeedsVoice == false)); i++)
5475 {
5476 SSession* pSession = &m_sessions[i];
5477 if (pSession->IsUsed())
5478 {
5479 for (uint32 j = 0; j < MAX_PSN_ROOM_MEMBERS; j++)
5480 {
5481 SSession::SRoomMember* pMember = &pSession->m_members[j];
5482 if (pMember->IsValid(ePSNMI_Other))
5483 {
5484 bNeedsVoice = true;
5485 break;
5486 }
5487 }
5488 }
5489 }
5490
5491 if (bNeedsVoice && !m_pPSNSupport->IsChatRestricted())
5492 {
5493 pVoice->Activate();
5494 }
5495 else
5496 {
5497 pVoice->Deactivate();
5498 }
5499 }
5500 #endif //USE_PSN_VOICE
5501 }
5502
5503 ECryLobbyError CCryPSNMatchMaking::CopySessionIDToBuffer(CrySessionID sessionId, void* pBuffer, size_t& bufferSize)
5504 {
5505 if (SCryPSNSessionID* pData = (SCryPSNSessionID*)sessionId.get())
5506 {
5507 size_t requiredSize = sizeof(SCryPSNSessionID);
5508 if (bufferSize >= requiredSize)
5509 {
5510 memcpy(pBuffer, pData, requiredSize);
5511 bufferSize = requiredSize;
5512 return eCLE_Success;
5513 }
5514 else
5515 {
5516 return eCLE_OutOfMemory;
5517 }
5518 }
5519 return eCLE_InvalidSession;
5520 }
5521
5522 ECryLobbyError CCryPSNMatchMaking::CopySessionIDFromBuffer(const void* pBuffer, size_t bufferSize, CrySessionID& sessionId)
5523 {
5524 size_t requiredSize = sizeof(SCryPSNSessionID);
5525 if (bufferSize == requiredSize)
5526 {
5527 SCryPSNSessionID* pData = new SCryPSNSessionID();
5528 // cppcheck-suppress memsetClass (if used in conjunction with CopySessionIDToBuffer(), this is ok)
5529 memcpy(pData, pBuffer, requiredSize);
5530 sessionId = pData;
5531 return eCLE_Success;
5532 }
5533 return eCLE_InvalidParam;
5534 }
5535
5536 void CCryPSNMatchMaking::ForceFromInvite(CrySessionID sessionId)
5537 {
5538 if (SCryPSNSessionID* pData = (SCryPSNSessionID*)sessionId.get())
5539 {
5540 pData->m_fromInvite = true;
5541 }
5542 }
5543
5544 ECryLobbyError CCryPSNMatchMaking::SessionSetAdvertisementData(CrySessionHandle gh, uint8* pData, uint32 dataSize, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCb, void* pCbArg)
5545 {
5546 LOBBY_AUTO_LOCK;
5547
5548 ECryLobbyError rc = eCLE_InvalidSession;
5549 CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
5550 if (h != CryLobbyInvalidSessionHandle)
5551 {
5552 CryMatchMakingTaskID mmTaskID;
5553 SSession* pSession = &m_sessions[h];
5554 rc = StartTask(eT_SessionSetAdvertisementData, false, 0, &mmTaskID, pTaskID, h, (void*)pCb, pCbArg);
5555 if (rc == eCLE_Success)
5556 {
5557 rc = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_UPDATEADVERT_REQUEST_SLOT, NULL, 1, sizeof(SUpdateAdvertisementDataParamData));
5558 if (rc == eCLE_Success)
5559 {
5560 rc = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_WEBAPI_UPDATEADVERT_REQUEST_SLOT, NULL, 1, sizeof(SCryPSNOrbisWebApiUpdateSessionInput));
5561 if (rc == eCLE_Success)
5562 {
5563 SCryPSNOrbisWebApiUpdateSessionInput* pAdvertInput = (SCryPSNOrbisWebApiUpdateSessionInput*)m_lobby->MemGetPtr(m_task[mmTaskID].params[PSN_MATCHMAKING_WEBAPI_UPDATEADVERT_REQUEST_SLOT]);
5564 memset(pAdvertInput, 0, sizeof(SCryPSNOrbisWebApiUpdateSessionInput));
5565
5566 memcpy(&pAdvertInput->sessionId, &pSession->m_sessionId, sizeof(SceNpSessionId));
5567
5568 pAdvertInput->advertisement.m_pData = pAdvertInput->data;
5569 pAdvertInput->advertisement.m_sizeofData = MIN(dataSize, CRY_WEBAPI_UPDATESESSION_LINKDATA_MAX_SIZE);
5570 memcpy(pAdvertInput->data, pData, pAdvertInput->advertisement.m_sizeofData);
5571
5572 SConfigurationParams neededInfo = {
5573 CLCC_PSN_UPDATE_SESSION_ADVERTISEMENT, { NULL }
5574 };
5575 neededInfo.m_pData = (void*)&pAdvertInput->advertisement;
5576 m_lobby->GetConfigurationInformation(&neededInfo, 1);
5577
5578 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
5579
5580 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
5581 }
5582 }
5583
5584 if (rc != eCLE_Success)
5585 {
5586 FreeTask(mmTaskID);
5587 }
5588 }
5589 }
5590
5591 return rc;
5592 }
5593
5594 void CCryPSNMatchMaking::TickSessionSetAdvertisementData(CryMatchMakingTaskID mmTaskID)
5595 {
5596 STask* pTask = &m_task[mmTaskID];
5597
5598 if (pTask->error == eCLE_Success)
5599 {
5600 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
5601 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
5602 {
5603 if ((pTask->params[PSN_MATCHMAKING_PSNSUPPORT_UPDATEADVERT_REQUEST_SLOT] != TMemInvalidHdl) &&
5604 (pTask->params[PSN_MATCHMAKING_WEBAPI_UPDATEADVERT_REQUEST_SLOT] != TMemInvalidHdl))
5605 {
5606 SUpdateAdvertisementDataParamData* pParam = (SUpdateAdvertisementDataParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_UPDATEADVERT_REQUEST_SLOT]);
5607
5608 StartSubTask(eST_WaitingForUpdateAdvertisementDataWebApiCallback, mmTaskID);
5609
5610 pParam->m_jobId = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::UpdateSession, pTask->params[PSN_MATCHMAKING_WEBAPI_UPDATEADVERT_REQUEST_SLOT]);
5611 if (pParam->m_jobId != INVALID_WEBAPI_JOB_ID)
5612 {
5613 //-- waiting for callback
5614 }
5615 else
5616 {
5617 // error - didn't add webapi job
5618 UpdateTaskError(mmTaskID, eCLE_InternalError);
5619 }
5620 }
5621 else
5622 {
5623 // error - bad param slots
5624 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
5625 }
5626 }
5627 }
5628
5629 if ((pTask->error != eCLE_Success) || pTask->canceled)
5630 {
5631 StopTaskRunning(mmTaskID);
5632 }
5633 }
5634
5635 void CCryPSNMatchMaking::EventWebApiUpdateSessionAdvertisement(CryMatchMakingTaskID mmTaskID, SCryPSNSupportCallbackEventData& data)
5636 {
5637 STask* pTask = &m_task[mmTaskID];
5638
5639 if (pTask->session != CryLobbyInvalidSessionHandle)
5640 {
5641 if (data.m_webApiEvent.m_error == PSN_OK)
5642 {
5643 // not expecting a response body, just mark task successful and stop
5644 UpdateTaskError(mmTaskID, eCLE_Success);
5645 StopTaskRunning(mmTaskID);
5646 return;
5647 }
5648 }
5649
5650 // something went wrong
5651 UpdateTaskError(mmTaskID, eCLE_InternalError);
5652 StopTaskRunning(mmTaskID);
5653 }
5654
5655 void CCryPSNMatchMaking::EndSessionSetAdvertisementData(CryMatchMakingTaskID mmTaskID)
5656 {
5657 STask* pTask = &m_task[mmTaskID];
5658 ((CryMatchmakingCallback)pTask->cb)(pTask->lTaskID, pTask->error, pTask->cbArg);
5659 }
5660
5661 ECryLobbyError CCryPSNMatchMaking::SessionGetAdvertisementData(CrySessionID sessionId, CryLobbyTaskID* pTaskID, CryMatchmakingSessionGetAdvertisementDataCallback pCb, void* pCbArg)
5662 {
5663 LOBBY_AUTO_LOCK;
5664
5665 ECryLobbyError rc = eCLE_InvalidSession;
5666 if (sessionId != CrySessionInvalidID)
5667 {
5668 CryMatchMakingTaskID mmTaskID;
5669 rc = StartTask(eT_SessionGetAdvertisementData, false, 0, &mmTaskID, pTaskID, CryLobbyInvalidSessionHandle, (void*)pCb, pCbArg);
5670 if (rc == eCLE_Success)
5671 {
5672 rc = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_PSNSUPPORT_GETADVERT_REQUEST_SLOT, NULL, 1, sizeof(SGetAdvertisementDataParamData));
5673 if (rc == eCLE_Success)
5674 {
5675 rc = CreateTaskParam(mmTaskID, PSN_MATCHMAKING_WEBAPI_GETADVERT_REQUEST_SLOT, NULL, 1, sizeof(SCryPSNOrbisWebApiGetSessionLinkDataInput));
5676 if (rc == eCLE_Success)
5677 {
5678 SCryPSNSessionID* pPSNSessionId = (SCryPSNSessionID*)sessionId.get();
5679 SCryPSNOrbisWebApiGetSessionLinkDataInput* pAdvertInput = (SCryPSNOrbisWebApiGetSessionLinkDataInput*)m_lobby->MemGetPtr(m_task[mmTaskID].params[PSN_MATCHMAKING_WEBAPI_GETADVERT_REQUEST_SLOT]);
5680 memcpy(&pAdvertInput->sessionId, &pPSNSessionId->m_sessionId, sizeof(SceNpSessionId));
5681
5682 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
5683
5684 FROM_GAME_TO_LOBBY(&CCryPSNMatchMaking::StartTaskRunning, this, mmTaskID);
5685 }
5686 }
5687
5688 if (rc != eCLE_Success)
5689 {
5690 FreeTask(mmTaskID);
5691 }
5692 }
5693 }
5694
5695 NetLog("[Lobby] Start SessionGetAdvertisementData error %d", rc);
5696 return rc;
5697 }
5698
5699 void CCryPSNMatchMaking::TickSessionGetAdvertisementData(CryMatchMakingTaskID mmTaskID)
5700 {
5701 STask* pTask = &m_task[mmTaskID];
5702
5703 if (pTask->error == eCLE_Success)
5704 {
5705 m_pPSNSupport->ResumeTransitioning(ePSNOS_Matchmaking_Available);
5706 if (m_pPSNSupport->HasTransitioningReachedState(ePSNOS_Matchmaking_Available))
5707 {
5708 if ((pTask->params[PSN_MATCHMAKING_PSNSUPPORT_GETADVERT_REQUEST_SLOT] != TMemInvalidHdl) &&
5709 (pTask->params[PSN_MATCHMAKING_WEBAPI_GETADVERT_REQUEST_SLOT] != TMemInvalidHdl))
5710 {
5711 SGetAdvertisementDataParamData* pParam = (SGetAdvertisementDataParamData*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_PSNSUPPORT_GETADVERT_REQUEST_SLOT]);
5712
5713 StartSubTask(eST_WaitingForGetAdvertisementDataWebApiCallback, mmTaskID);
5714
5715 pParam->m_jobId = m_pPSNSupport->GetWebApiInterface().AddJob(CCryPSNOrbisWebApiThread::GetSessionLinkData, pTask->params[PSN_MATCHMAKING_WEBAPI_GETADVERT_REQUEST_SLOT]);
5716 if (pParam->m_jobId != INVALID_WEBAPI_JOB_ID)
5717 {
5718 //-- waiting for callback
5719 }
5720 else
5721 {
5722 // error - didnt queue webapi job
5723 UpdateTaskError(mmTaskID, eCLE_InternalError);
5724 }
5725 }
5726 else
5727 {
5728 // error - no slots allocated
5729 UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
5730 }
5731 }
5732 }
5733
5734 if ((pTask->error != eCLE_Success) || pTask->canceled)
5735 {
5736 StopTaskRunning(mmTaskID);
5737 }
5738 }
5739
5740 void CCryPSNMatchMaking::EventWebApiGetSessionLinkData(CryMatchMakingTaskID mmTaskID, SCryPSNSupportCallbackEventData& data)
5741 {
5742 STask* pTask = &m_task[mmTaskID];
5743
5744 if (data.m_webApiEvent.m_error == PSN_OK)
5745 {
5746 if (data.m_webApiEvent.m_pResponseBody)
5747 {
5748 if ((data.m_webApiEvent.m_pResponseBody->eType == SCryPSNWebApiResponseBody::E_RAW) &&
5749 (data.m_webApiEvent.m_pResponseBody->rawResponseBodyHdl != TMemInvalidHdl) &&
5750 (data.m_webApiEvent.m_pResponseBody->rawResponseBodySize > 0))
5751 {
5752 // success.
5753 pTask->params[PSN_MATCHMAKING_WEBAPI_GETADVERT_RESPONSE_SLOT] = data.m_webApiEvent.m_pResponseBody->rawResponseBodyHdl;
5754 pTask->numParams[PSN_MATCHMAKING_WEBAPI_GETADVERT_RESPONSE_SLOT] = (uint32)data.m_webApiEvent.m_pResponseBody->rawResponseBodySize;
5755
5756 // We don't want the data to be deleted when this function returns since we copied the handle.
5757 // If we invalidate the handle, it won't be deleted when the event is cleared up.
5758 data.m_webApiEvent.m_pResponseBody->rawResponseBodyHdl = TMemInvalidHdl;
5759 data.m_webApiEvent.m_pResponseBody->rawResponseBodySize = 0;
5760
5761 UpdateTaskError(mmTaskID, eCLE_Success);
5762 StopTaskRunning(mmTaskID);
5763 return;
5764 }
5765 }
5766 }
5767
5768 // something went wrong
5769 UpdateTaskError(mmTaskID, eCLE_InternalError);
5770 StopTaskRunning(mmTaskID);
5771 }
5772
5773 void CCryPSNMatchMaking::EndSessionGetAdvertisementData(CryMatchMakingTaskID mmTaskID)
5774 {
5775 uint8* pData = NULL;
5776 uint32 dataSize = 0;
5777
5778 STask* pTask = &m_task[mmTaskID];
5779 if (pTask->error == eCLE_Success)
5780 {
5781 pData = (uint8*)m_lobby->MemGetPtr(pTask->params[PSN_MATCHMAKING_WEBAPI_GETADVERT_RESPONSE_SLOT]);
5782 dataSize = pTask->numParams[PSN_MATCHMAKING_WEBAPI_GETADVERT_RESPONSE_SLOT];
5783 }
5784
5785 ((CryMatchmakingSessionGetAdvertisementDataCallback)pTask->cb)(pTask->lTaskID, pTask->error, pData, dataSize, pTask->cbArg);
5786 }
5787
5788 #endif // USE_CRY_MATCHMAKING
5789 #endif // USE_PSN
5790 #endif // CRY_PLATFORM_ORBIS
CRYENGINE is a powerful real-time game development platform created by Crytek.