?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
!I integrate from //ce/main...
[CRYENGINE.git] / Code / CryPlugins / CryLobby / Module / CryLobby.cpp
blobdb2491ecd361137eaf4c232bc2cf3fbfc132768d
1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
2
3 #include "StdAfx.h"
4
5 #include "CryLobby.h"
6 #include "CrySharedLobbyPacket.h"
7 #include "LAN/CryLANLobby.h"
8 #if USE_LIVE
9 #include "Live/CryLiveLobby.h"
10 #endif
11 #if USE_PSN
12 #if CRY_PLATFORM_ORBIS
13 #include "PSNOrbis/CryPSN2Lobby.h"
14 #endif
15 #endif
16 #if USE_STEAM
17 #include "Steam/CrySteamLobby.h"
18 #endif
19 #if USE_DURANGOLIVE
20 #include "DurangoLive/CryDurangoLiveLobby.h"
21 #endif
22
23 #include <CryGame/IGameFramework.h>
24 #include "INetworkPrivate.h"
25 #include "Protocol/FrameTypes.h"
26 #include <CryMemory/BucketAllocatorImpl.h>
27
28 #include <CryMath/Random.h>
29 #include <CryCore/Platform/platform_impl.inl>
30
31 const int LOBBY_KEEP_ALIVE_INTERVAL = (CryLobbySendInterval + 100);
32 const int LOBBY_FORCE_DISCONNECT_TIMER = 99999999;
33
34 static const uint8 CONNECTION_COUNTER_MAX = 255;
35
36 #if ENCRYPT_LOBBY_PACKETS
37 const char* g_lobbyEncryptionKey = "gSPyI9\"£$h83H8Uasd73nn()u12gh[[&";
38 #endif
39
40 #define INVALID_CONNECTION_COOKIE 0
41
42 #if !defined(_LIB)
43 CTimeValue g_time;
44 SObjectCounters* g_pObjcnt = NULL;
45 #endif
46
47 #ifdef USE_GLOBAL_BUCKET_ALLOCATOR
48 CCryLobby::CMemAllocator::LobbyBuckets CCryLobby::CMemAllocator::m_bucketAllocator(NULL, false);
49 #else
50 CCryLobby::CMemAllocator::LobbyBuckets CCryLobby::CMemAllocator::m_bucketAllocator;
51 #endif
52 ICryLobby* CCryLobby::m_pLobby = NULL;
53
54 #if defined(_RELEASE) && !defined(DEDICATED_SERVER)
55 #define NO_NETWORK_SECURITY_LOGS
56 #endif
57
58 #if defined(NO_NETWORK_SECURITY_LOGS)
59 #define SECURE_NET_LOG(...)
60 #else
61 #define SECURE_NET_LOG NetLog
62 #endif
63
64 CRYREGISTER_SINGLETON_CLASS(CCryLobby)
65
66 CCryLobby::CCryLobby()
67 {
68 gEnv->pLobby = this;
69 }
70
71 CCryLobby::~CCryLobby()
72 {
73 int a;
74
75 #if NETWORK_HOST_MIGRATION
76 RemoveHostMigrationEventListener(this);
77 #endif
78
79 for (a = 0; a < eCLS_NumServices; a++)
80 {
81 InternalSocketDie(ECryLobbyService(a));
82 }
83
84 #if ENCRYPT_LOBBY_PACKETS
85 if (gEnv->pNetwork)
86 {
87 gEnv->pNetwork->EndCipher(m_cipher);
88 }
89 #endif
90
91 m_pLobby = NULL;
92 }
93
94 bool CCryLobby::Initialize(SSystemGlobalEnvironment& env, const SSystemInitParams& initParams)
95 {
96 if (m_pLobby)
97 {
98 CryFatalError("Trying to create a lobby when we already have one, this does not end well");
99 }
100
101 m_pLobby = this;
102 g_time = gEnv->pTimer->GetAsyncTime();
103
104 for (uint32 i = 0; i < eCLS_NumServices; i++)
105 {
106 m_services[i] = NULL;
107 m_task[i].cb = NULL;
108 m_task[i].cbArg = NULL;
109
110 m_socketServices[i].m_socket = NULL;
111 m_socketServices[i].m_socketListenPort = 0;
112 m_socketServices[i].m_socketConnectPort = 0;
113
114 memset(&m_serviceParams[i], 0, sizeof(SCryLobbyParameters));
115
116 m_servicePacketEnd[i] = 0xffff;
117 }
118
119 for (uint32 i = 0; i < MAX_LOBBY_TASKS; i++)
120 {
121 m_serviceTask[i].used = false;
122 }
123
124 for (uint32 i = 0; i < MAX_LOBBY_CONNECTIONS; i++)
125 {
126 m_connection[i].used = false;
127 }
128
129 m_userPacketEnd = 0xffff;
130
131 m_lvlName[0] = 0;
132 m_rulName[0] = 0;
133
134 m_callbacks.reserve(10); // pre-reserve space for callback event data
135 m_service = eCLS_LAN;
136 m_natType = eNT_Unknown;
137
138 #if USE_GFWL
139 m_gfwlExtras = new CCryLobbyGFWLExtras;
140 #else
141 m_gfwlExtras = NULL;
142 #endif
143
144 #if NETWORK_HOST_MIGRATION
145 //m_hostMigrationListeners.reserve(10);
146 AddHostMigrationEventListener(this, "CryLobby", ELPT_Engine);
147 #endif
148
149 #if ENCRYPT_LOBBY_PACKETS
150 if (gEnv->pNetwork)
151 {
152 m_cipher = gEnv->pNetwork->BeginCipher((const uint8*)g_lobbyEncryptionKey, 32);
153 }
154 #endif
155
156 return true;
157 }
158
159 ECryLobbyService CCryLobby::SetLobbyService(ECryLobbyService service)
160 {
161 LOBBY_AUTO_LOCK;
162
163 ECryLobbyService ret = m_service;
164
165 assert(service < eCLS_NumServices);
166 #if CRY_PLATFORM_DURANGO || CRY_PLATFORM_ORBIS
167 m_service = eCLS_Online;
168 #else
169 m_service = service;
170 #endif
171
172 return ret;
173 }
174
175 #if NETWORK_HOST_MIGRATION
176 IHostMigrationEventListener::EHostMigrationReturn CCryLobby::OnInitiate(SHostMigrationInfo& hostMigrationInfo, HMStateType& state)
177 {
178 NetLog("[Host Migration]: CCryLobby::OnInitiate() started");
179
180 SHostMigrationInfo_Private& privateInfo = static_cast<SHostMigrationInfo_Private&>(hostMigrationInfo);
181 privateInfo.m_lobbyHMStatus = eLHMS_InitiateMigrate;
182
183 NetLog("[Host Migration]: CCryLobby::OnInitiate() finished");
184 return IHostMigrationEventListener::Listener_Done;
185 }
186
187 IHostMigrationEventListener::EHostMigrationReturn CCryLobby::OnDisconnectClient(SHostMigrationInfo& hostMigrationInfo, HMStateType& state)
188 {
189 return IHostMigrationEventListener::Listener_Done;
190 }
191
192 IHostMigrationEventListener::EHostMigrationReturn CCryLobby::OnDemoteToClient(SHostMigrationInfo& hostMigrationInfo, HMStateType& state)
193 {
194 return IHostMigrationEventListener::Listener_Done;
195 }
196
197 IHostMigrationEventListener::EHostMigrationReturn CCryLobby::OnPromoteToServer(SHostMigrationInfo& hostMigrationInfo, HMStateType& state)
198 {
199 bool done = false;
200 CCryMatchMaking* pMatchMaking = (CCryMatchMaking*)GetMatchMaking();
201
202 if (pMatchMaking)
203 {
204 SHostMigrationInfo_Private& privateInfo = static_cast<SHostMigrationInfo_Private&>(hostMigrationInfo);
205 switch (privateInfo.m_lobbyHMStatus)
206 {
207 case eLHMS_InitiateMigrate:
208 NetLog("[Host Migration]: CCryLobby::OnPromoteToServer() started");
209 pMatchMaking->HostMigrationServer(&hostMigrationInfo);
210 ++privateInfo.m_lobbyHMStatus;
211 break;
212 case eLHMS_Migrating:
213 default:
214 done = pMatchMaking->IsSessionMigrated(&hostMigrationInfo);
215 if (done)
216 {
217 privateInfo.m_lobbyHMStatus = eLHMS_InitiateMigrate;
218 }
219 break;
220 }
221
222 if (hostMigrationInfo.m_logProgress || (done == true))
223 {
224 NetLog("[Host Migration]: CCryLobby::OnPromoteToServer() %s for " PRFORMAT_SH, ((done == true) ? "finished" : "waiting"), PRARG_SH(pMatchMaking->GetSessionHandleFromGameSessionHandle(hostMigrationInfo.m_session)));
225 }
226 }
227
228 if (done)
229 {
230 return IHostMigrationEventListener::Listener_Done;
231 }
232
233 return IHostMigrationEventListener::Listener_Wait;
234 }
235
236 IHostMigrationEventListener::EHostMigrationReturn CCryLobby::OnReconnectClient(SHostMigrationInfo& hostMigrationInfo, HMStateType& state)
237 {
238 bool done = false;
239 CCryMatchMaking* pMatchMaking = (CCryMatchMaking*)GetMatchMaking();
240 if (pMatchMaking)
241 {
242 SHostMigrationInfo_Private& privateInfo = static_cast<SHostMigrationInfo_Private&>(hostMigrationInfo);
243 switch (privateInfo.m_lobbyHMStatus)
244 {
245 case eLHMS_InitiateMigrate:
246 NetLog("[Host Migration]: CCryLobby::OnReconnectClient() started");
247 ++privateInfo.m_lobbyHMStatus;
248 break;
249 case eLHMS_Migrating:
250 done = pMatchMaking->IsSessionMigrated(&hostMigrationInfo);
251 default:
252 break;
253 }
254
255 if (hostMigrationInfo.m_logProgress || (done == true))
256 {
257 NetLog("[Host Migration]: CCryLobby::OnReconnectClient() %s for " PRFORMAT_SH, ((done == true) ? "finished" : "waiting"), PRARG_SH(pMatchMaking->GetSessionHandleFromGameSessionHandle(hostMigrationInfo.m_session)));
258 }
259
260 if (done)
261 {
262 pMatchMaking->OnReconnectClient(hostMigrationInfo);
263 }
264 }
265
266 if (done)
267 {
268 return IHostMigrationEventListener::Listener_Done;
269 }
270
271 return IHostMigrationEventListener::Listener_Wait;
272 }
273
274 IHostMigrationEventListener::EHostMigrationReturn CCryLobby::OnFinalise(SHostMigrationInfo& hostMigrationInfo, HMStateType& state)
275 {
276 return IHostMigrationEventListener::Listener_Done;
277 }
278
279 IHostMigrationEventListener::EHostMigrationReturn CCryLobby::OnTerminate(SHostMigrationInfo& hostMigrationInfo, HMStateType& state)
280 {
281 return IHostMigrationEventListener::Listener_Done;
282 }
283
284 IHostMigrationEventListener::EHostMigrationReturn CCryLobby::OnReset(SHostMigrationInfo& hostMigrationInfo, HMStateType& state)
285 {
286 return IHostMigrationEventListener::Listener_Done;
287 }
288 #endif
289
290 void CCryLobby::InviteAccepted(ECryLobbyService service, uint32 user, CrySessionID sessionID, ECryLobbyError error)
291 {
292 UCryLobbyEventData eventData;
293 SCryLobbyInviteAcceptedData inviteData;
294
295 eventData.pInviteAcceptedData = &inviteData;
296 inviteData.m_service = service;
297 inviteData.m_user = user;
298 inviteData.m_id = sessionID;
299 inviteData.m_error = error;
300 DispatchEvent(eCLSE_InviteAccepted, eventData);
301 }
302
303 void CCryLobby::InviteAccepted(ECryLobbyService service, uint32 user, CryUserID userID, ECryLobbyError error, ECryLobbyInviteType inviteType)
304 {
305 UCryLobbyEventData eventData;
306 SCryLobbyUserInviteAcceptedData inviteData;
307
308 eventData.pUserInviteAcceptedData = &inviteData;
309 inviteData.m_service = service;
310 inviteData.m_user = user;
311 inviteData.m_inviterId = userID;
312 inviteData.m_error = error;
313 inviteData.m_type = inviteType;
314 DispatchEvent(eCLSE_UserInviteAccepted, eventData);
315 }
316
317 uint32 CCryLobby::GetDisconnectTimeOut()
318 {
319 const CNetCVars* pNetCVars = GetNetCVars();
320
321 if (pNetCVars)
322 {
323 if (gEnv->pSystem->IsDevMode())
324 {
325 if (pNetCVars->InactivityTimeoutDevmode > 0.0f)
326 {
327 return (uint32)(1000.0f * pNetCVars->InactivityTimeoutDevmode);
328 }
329 }
330 else
331 {
332 if (pNetCVars->InactivityTimeout > 0.0f)
333 {
334 return (uint32)(1000.0f * pNetCVars->InactivityTimeout);
335 }
336 }
337 }
338
339 return CryLobbyTimeOut;
340 }
341
342 void CCryLobby::LogPacketsInBuffer(const uint8* pBuffer, uint32 size)
343 {
344 #if !defined(_RELEASE) || defined(RELEASE_LOGGING)
345 CCrySharedLobbyPacket packet;
346 SCryLobbyPacketHeader* pPacketHeader = packet.GetLobbyPacketHeader();
347 SCryLobbyPacketDataHeader* pDataHeader = packet.GetLobbyPacketDataHeader();
348
349 packet.SetReadBuffer(pBuffer, size);
350 pPacketHeader->reliable = true; // No point reading whole header for this log
351 packet.SetReadBufferPos(CryLobbyPacketReliablePacketHeaderSize);
352
353 while (packet.GetReadBufferPos() < size)
354 {
355 packet.ReadDataHeader();
356 uint32 encodedPacketType = pDataHeader->lobbyPacketType;
357 DecodePacketDataHeader(&packet);
358 NetLog(" packet %d (%d) size %d", pDataHeader->lobbyPacketType, encodedPacketType, pDataHeader->dataSize);
359 packet.SetReadBufferPos(packet.GetReadBufferPos() + pDataHeader->dataSize);
360 }
361 #endif // #if !defined(_RELEASE) || defined(RELEASE_LOGGING)
362 }
363
364 void CCryLobby::Tick(bool flush)
365 {
366 if (gEnv->IsEditor() || (gEnv->pSystem && gEnv->pSystem->IsQuitting()))
367 {
368 return;
369 }
370
371 ProcessCachedPacketBuffer();
372
373 uint32 lastFrameTime = 0;
374 uint32 disconnectTimeOut = GetDisconnectTimeOut();
375 uint32 CryLobbyKeepAliveInterval = LOBBY_KEEP_ALIVE_INTERVAL;
376
377 g_time = gEnv->pTimer->GetAsyncTime();
378
379 if (!flush)
380 {
381 lastFrameTime = (uint32)(g_time.GetMilliSecondsAsInt64() - m_lastTickTime.GetMilliSecondsAsInt64());
382 if (lastFrameTime > CryLobbySendInterval)
383 {
384 NetLog("CCryLobby::TimerCallback() long frame detected, lastFrameTime=%u", lastFrameTime);
385 // Guard against very long frames that can cause sends to time out even before they have started.
386 lastFrameTime = CryLobbySendInterval;
387 }
388 }
389
390 #if USE_LOBBY_REMOTE_CONNECTIONS
391 for (uint32 i = 0; i < MAX_LOBBY_CONNECTIONS; i++)
392 {
393 SConnection* pConnection = &m_connection[i];
394
395 if (pConnection->used)
396 {
397 bool doneSend = false;
398
399 pConnection->timeSinceSend += lastFrameTime;
400 pConnection->timeSinceRecv += lastFrameTime;
401
402 switch (pConnection->state)
403 {
404 case eCLCS_NotConnected:
405 if (pConnection->refCount == 0)
406 {
407 SECURE_NET_LOG("[lobby] Release connection " PRFORMAT_LCINFO, PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr));
408
409 FreeConnection(i);
410 }
411
412 break;
413
414 case eCLCS_Pending:
415 {
416 if (pConnection->timeSinceSend >= CryLobbySendInterval)
417 {
418 const uint32 MaxBufferSize = CryLobbyPacketHeaderSize
419 #if RESET_CONNECTED_CONNECTION
420 + CryLobbyPacketUINT64Size;
421 #endif
422 ;
423 uint8 buffer[MaxBufferSize];
424 CCrySharedLobbyPacket packet;
425
426 packet.SetWriteBuffer(buffer, MaxBufferSize);
427 doneSend = true;
428 packet.StartWrite(eLobbyPT_ConnectionRequest, false);
429
430 #if RESET_CONNECTED_CONNECTION
431 SECURE_NET_LOG("[Lobby] Sending connection request with cookie %llx connection " PRFORMAT_LCINFO, pConnection->sendCookie, PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr));
432 packet.WriteUINT64(pConnection->sendCookie);
433 #endif
434
435 if (Send(&packet, pConnection->addr, i, NULL) != eSE_Ok)
436 {
437 SECURE_NET_LOG("[Lobby] Failed to send setting pending connection " PRFORMAT_LCINFO " to eCLCS_NotConnected", PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr));
438 pConnection->state = eCLCS_NotConnected;
439 }
440 }
441 }
442
443 break;
444
445 case eCLCS_Connected:
446 if (((pConnection->timeSinceRecv > CryLobbyKeepAliveInterval) && (pConnection->timeSinceSend > CryLobbyKeepAliveInterval)) ||
447 ((pConnection->timeSinceSend >= CryLobbySendInterval) && (pConnection->ping.times[NUM_LOBBY_PINGS - 1] == CRYLOBBY_INVALID_PING)) ||
448 (pConnection->timeSinceSend >= CryLobbyInGameSendInterval))
449 {
450 const uint32 MaxBufferSize = CryLobbyPacketHeaderSize + CryLobbyPacketUINT64Size;
451 uint8 buffer[MaxBufferSize];
452 CCrySharedLobbyPacket packet;
453
454 packet.SetWriteBuffer(buffer, MaxBufferSize);
455 doneSend = true;
456 packet.StartWrite(eLobbyPT_Ping, false);
457 packet.WriteUINT64(gEnv->pTimer->GetAsyncTime().GetMilliSecondsAsInt64());
458
459 if (Send(&packet, pConnection->addr, i, NULL) != eSE_Ok)
460 {
461 SECURE_NET_LOG("[Lobby] Failed to send setting connected connection " PRFORMAT_LCINFO " to eCLCS_NotConnected", PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr));
462 pConnection->state = eCLCS_NotConnected;
463 }
464 }
465
466 if (pConnection->refCount == 0)
467 {
468 // There are no references to this connection.
469 if (pConnection->dataQueue.Empty())
470 {
471 pConnection->disconnectTimer += lastFrameTime;
472
473 if (pConnection->disconnectTimer > disconnectTimeOut)
474 {
475 // It hasn't been in use for a while
476 SECURE_NET_LOG("[Lobby] No references to connection setting connected connection " PRFORMAT_LCINFO " to eCLCS_NotConnected", PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr));
477 pConnection->state = eCLCS_NotConnected;
478 }
479 }
480 else
481 {
482 // It's still in use so reset counter.
483 pConnection->disconnectTimer = 0;
484 }
485 }
486 else
487 {
488 pConnection->disconnectTimer = 0;
489 }
490
491 break;
492 }
493
494 if (pConnection->timeSinceRecv > disconnectTimeOut)
495 {
496 // It hasn't been in use for a while
497 if (pConnection->state != eCLCS_NotConnected)
498 {
499 SECURE_NET_LOG("[Lobby] Connection to " PRFORMAT_LCINFO " has timed out (timeSinceRecv %u disconnectTimeOut %u) setting to eCLCS_NotConnected", PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr), pConnection->timeSinceRecv, disconnectTimeOut);
500 pConnection->state = eCLCS_NotConnected;
501 }
502 }
503
504 if (pConnection->dataQueue.Empty() && (pConnection->reliableBuildPacket.GetWriteBufferPos() > 0))
505 {
506 AddReliablePacketToSendQueue(i, &pConnection->reliableBuildPacket);
507 }
508
509 if (!pConnection->dataQueue.Empty())
510 {
511 if ((pConnection->timeSinceSend >= CryLobbySendInterval) || flush)
512 {
513 SConnection::SData& data = pConnection->dataQueue.Front();
514
515 #if !defined(_RELEASE) || defined(RELEASE_LOGGING)
516 CCrySharedLobbyPacket packetInfo;
517
518 packetInfo.SetReadBuffer((const uint8*)MemGetPtr(data.data), data.dataSize);
519
520 packetInfo.ReadPacketHeader();
521
522 SECURE_NET_LOG("[lobby] Send reliable connection " PRFORMAT_LCINFO " from " PRFORMAT_UID " counter %d size %d",
523 PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr), PRARG_UID(packetInfo.GetLobbyPacketHeader()->fromUID), data.counter, data.dataSize);
524
525 LogPacketsInBuffer((uint8*)MemGetPtr(data.data), data.dataSize);
526 #endif // #if !defined(_RELEASE) || defined(RELEASE_LOGGING)
527
528 doneSend = true;
529
530 // Data hasn't been acknowledged so try sending again
531 SSocketService* pSocketService = GetCorrectSocketServiceForAddr(pConnection->addr);
532 if (pSocketService->m_socket)
533 {
534 if (pSocketService->m_socket->Send(EncryptPacket((uint8*)MemGetPtr(data.data), data.dataSize), data.dataSize, pConnection->addr) != eSE_Ok)
535 {
536 SECURE_NET_LOG("[Lobby] Failed to send setting connection " PRFORMAT_LCINFO " to eCLCS_NotConnected", PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr));
537 pConnection->state = eCLCS_NotConnected;
538 }
539 }
540 }
541
542 if ((pConnection->timeSinceRecv > disconnectTimeOut) || (pConnection->state == eCLCS_NotConnected))
543 {
544 // Timeout on send
545 OnError(pConnection->addr, eSE_UnreachableAddress);
546 }
547 }
548 else
549 {
550 if (pConnection->state == eCLCS_Freeing)
551 {
552 SECURE_NET_LOG("[Lobby] Setting freeing connection " PRFORMAT_LCINFO " to eCLCS_NotConnected", PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr));
553 pConnection->state = eCLCS_NotConnected;
554 }
555 }
556
557 if (doneSend)
558 {
559 pConnection->timeSinceSend = 0;
560 }
561 }
562 }
563 #endif // USE_LOBBY_REMOTE_CONNECTIONS
564
565 if (m_mutex.TryLock())
566 {
567 m_fromGameQueue.Flush(false);
568 m_mutex.Unlock();
569 }
570
571 if (flush)
572 {
573 // We're flushing, so no need to tick services or reset the timer
574 return;
575 }
576
577 // Tick all lobby services.
578 // Things like invite notifications for a service still need to be processed even if currently using a different service
579 for (uint32 i = 0; i < eCLS_NumServices; i++)
580 {
581 if (m_services[i])
582 {
583 m_services[i]->Tick(g_time);
584 }
585 }
586
587 m_lastTickTime = g_time;
588 }
589
590 void CCryLobby::InitialiseServiceCB(ECryLobbyError error, CCryLobby* lobby, ECryLobbyService service)
591 {
592 if (error != eCLE_Success)
593 {
594 lobby->m_services[service] = NULL;
595 }
596
597 if (lobby->m_task[service].cb)
598 {
599 lobby->m_task[service].cb(service, error, lobby->m_task[service].cbArg);
600 }
601 }
602
603 void CCryLobby::TerminateServiceCB(ECryLobbyError error, CCryLobby* lobby, ECryLobbyService service)
604 {
605 // Remove our reference to the service. It will be deleted when all references are gone.
606 lobby->m_services[service] = NULL;
607
608 lobby->CheckFreeGlobalResources();
609
610 if (lobby->m_task[service].cb)
611 {
612 lobby->m_task[service].cb(service, error, lobby->m_task[service].cbArg);
613 }
614 }
615
616 #define MAX_IP_EXPECTED (16)
617 #define MAX_ADDRESS_SIZE (MAX_IP_EXPECTED + 6 + 1)
618
619 void FixPortBinding(TNetAddress& defaultBind, int port)
620 {
621 #if CRY_PLATFORM_WINDOWS // On windows we should check the sv_bind variable and attempt to play nice and bind to the address requested
622 CNetAddressResolver* pResolver = CCryLobby::GetResolver();
623
624 if (pResolver)
625 {
626 char address[MAX_ADDRESS_SIZE];
627
628 cry_sprintf(address, "0.0.0.0:%d", port);
629
630 ICVar* pCVar = gEnv->pConsole->GetCVar("sv_bind");
631 if (pCVar && pCVar->GetString())
632 {
633 if (strlen(pCVar->GetString()) <= MAX_IP_EXPECTED)
634 {
635 cry_sprintf(address, "%s:%d", pCVar->GetString(), port);
636 }
637 else
638 {
639 NetLog("Address to bind '%s' does not appear to be an IP address", pCVar->GetString());
640 }
641 }
642
643 CNameRequestPtr pReq = pResolver->RequestNameLookup(address);
644 pReq->Wait();
645 if (pReq->GetResult() != eNRR_Succeeded)
646 {
647 NetLog("Name resolution for '%s' failed - binding to 0.0.0.0", address);
648 }
649 else
650 {
651 defaultBind = pReq->GetAddrs()[0];
652 }
653
654 }
655 #endif // CRY_PLATFORM_WINDOWS
656 }
657
658 void CCryLobby::InternalSocketCreate(ECryLobbyService service)
659 {
660 SSocketService* pSocketService = GetCorrectSocketService(service);
661
662 CRY_ASSERT_MESSAGE(service < eCLS_NumServices, "Illegal service specified");
663 CRY_ASSERT_MESSAGE(m_services[service] != NULL, "Tried to create a socket for a non existant service.");
664
665 pSocketService->m_socketConnectPort = 0;
666 pSocketService->m_socketListenPort = 0;
667
668 if (m_services[service] != NULL)
669 {
670 m_services[service]->GetSocketPorts(pSocketService->m_socketConnectPort, pSocketService->m_socketListenPort);
671 }
672
673 uint16 port = pSocketService->m_socketListenPort;
674 TNetAddress defaultBind = TNetAddress(SIPv4Addr(0, port));
675 FixPortBinding(defaultBind, port);
676
677 ISocketIOManager* pSocketIOManager = GetExternalSocketIOManager();
678 uint32 flags = eSF_Online;
679
680 if (service == eCLS_LAN)
681 {
682 pSocketIOManager = GetInternalSocketIOManager();
683 flags = (eSF_BroadcastSend | eSF_BroadcastReceive);
684 }
685
686 if (pSocketIOManager && !pSocketService->m_socket)
687 {
688 InternalSocketFree(service);
689
690 NetLog("[Lobby] Creating socket on port %u (service [%s], socket manager [%s])", port, (service == eCLS_LAN) ? "LAN" : "Online", pSocketIOManager->GetName());
691 pSocketService->m_socket = pSocketIOManager->CreateDatagramSocket(defaultBind, flags);
692
693 if (!pSocketService->m_socket)
694 {
695 NetLog("[Lobby] Failed to create socket on port %u", port);
696 if ((gEnv->IsDedicated() == false) || ((gEnv->IsClient() == true) && (gEnv->bServer == false)))
697 {
698 // If we are not a dedicated server (Which should always use the port specified in the cfg file) and we fail to create the socket
699 // try to create on some different ports.
700
701 for (uint32 i = 1; i < MAX_SOCKET_PORTS_TRY; i++)
702 {
703 port++;
704 defaultBind = TNetAddress(SIPv4Addr(0, port));
705 FixPortBinding(defaultBind, port);
706 NetLog("[Lobby] Creating socket on port %u", port);
707 pSocketService->m_socket = pSocketIOManager->CreateDatagramSocket(defaultBind, flags);
708
709 if (pSocketService->m_socket)
710 {
711 break;
712 }
713 else
714 {
715 NetLog("[Lobby] Failed to create socket on port %u", port);
716 }
717 }
718 }
719 }
720
721 if (pSocketService->m_socket)
722 {
723 NetLog("[Lobby] Created socket on port %u", port);
724 pSocketService->m_socket->RegisterListener(this);
725 pSocketService->m_socketListenPort = port;
726 m_serviceParams[service].m_listenPort = port;
727 if (m_services[service] != NULL)
728 {
729 m_services[service]->OnInternalSocketChanged(pSocketService->m_socket);
730 }
731 }
732 else
733 {
734 CryWarning(VALIDATOR_MODULE_ONLINE, VALIDATOR_ERROR,
735 "[Lobby] Socket could not be created, check firewall or try a different port. Connecting to network games may fail if not fixed.");
736 }
737 }
738 }
739
740 void CCryLobby::InternalSocketDie(ECryLobbyService service)
741 {
742 CRY_ASSERT_MESSAGE(service < eCLS_NumServices, "Illegal service specified");
743 SSocketService* pSocketService = GetCorrectSocketService(service);
744 ISocketIOManager* pSocketIOManager = GetExternalSocketIOManager();
745 if (service == eCLS_LAN)
746 {
747 pSocketIOManager = GetInternalSocketIOManager();
748 }
749
750 if (pSocketIOManager && pSocketService->m_socket)
751 {
752 pSocketService->m_socket->UnregisterListener(this);
753 pSocketIOManager->FreeDatagramSocket(pSocketService->m_socket);
754 pSocketService->m_socket = NULL;
755 }
756
757 if (m_services[service])
758 {
759 m_services[service]->OnInternalSocketChanged(pSocketService->m_socket);
760 }
761 }
762
763 void CCryLobby::InternalSocketFree(ECryLobbyService service)
764 {
765 SSocketService* pSocketService = GetCorrectSocketService(service);
766 if (pSocketService->m_socket)
767 {
768 InternalSocketDie(service);
769 }
770 }
771
772 ECryLobbyError CCryLobby::CheckAllocGlobalResources()
773 {
774 g_pObjcnt = &((INetworkPrivate*)gEnv->pNetwork)->GetObjectCounters();
775 return eCLE_Success;
776 }
777
778 void CCryLobby::CheckFreeGlobalResources()
779 {
780 uint32 i;
781
782 for (i = 0; i < eCLS_NumServices; i++)
783 {
784 if (m_services[i])
785 {
786 break;
787 }
788 }
789
790 if (i == eCLS_NumServices)
791 {
792 int a;
793
794 for (i = 0; i < MAX_LOBBY_TASKS; i++)
795 {
796 m_serviceTask[i].used = false;
797 }
798
799 for (i = 0; i < MAX_LOBBY_CONNECTIONS; i++)
800 {
801 FreeConnection(i);
802 }
803
804 for (a = 0; a < eCLS_NumServices; a++)
805 {
806 InternalSocketDie(ECryLobbyService(a));
807 }
808 }
809 }
810
811 CryLobbyTaskID CCryLobby::CreateTask()
812 {
813 for (uint32 i = 0; i < MAX_LOBBY_TASKS; i++)
814 {
815 if (!m_serviceTask[i].used)
816 {
817 m_serviceTask[i].used = true;
818 #if ENABLE_CRYLOBBY_DEBUG_TESTS
819 m_serviceTask[i].startTaskTime = 0LL;
820 m_serviceTask[i].tickTaskTime = 0LL;
821 m_serviceTask[i].generateErrorDone = false;
822 m_serviceTask[i].startTaskTimerStarted = false;
823 m_serviceTask[i].startTaskDone = false;
824 m_serviceTask[i].tickTaskTimerStarted = false;
825 m_serviceTask[i].tickTaskDone = false;
826 #endif
827 return i;
828 }
829 }
830
831 return CryLobbyInvalidTaskID;
832 }
833
834 void CCryLobby::ReleaseTask(CryLobbyTaskID id)
835 {
836 m_serviceTask[id].used = false;
837 }
838
839 #if ENABLE_CRYLOBBY_DEBUG_TESTS
840 bool CCryLobby::DebugGenerateError(CryLobbyTaskID id, ECryLobbyError& error)
841 {
842 if (CLobbyCVars::Get().cldEnable)
843 {
844 SServiceTask* pTask = &m_serviceTask[id];
845
846 if (!pTask->generateErrorDone)
847 {
848 pTask->generateErrorDone = true;
849
850 if (cry_random(0, 99) < CLobbyCVars::Get().cldErrorPercentage)
851 {
852 NetLog("[Lobby] Generating random eCLE_TimeOut on task %u", id);
853 error = eCLE_TimeOut;
854 return true;
855 }
856 }
857 }
858
859 return false;
860 }
861
862 bool CCryLobby::DebugOKToStartTaskRunning(CryLobbyTaskID id)
863 {
864 int minDelay = CLobbyCVars::Get().cldMinDelayTime;
865 int maxDelay = CLobbyCVars::Get().cldMaxDelayTime;
866
867 if (CLobbyCVars::Get().cldEnable && (minDelay >= 0) && (maxDelay > minDelay))
868 {
869 SServiceTask* pTask = &m_serviceTask[id];
870
871 if (!pTask->startTaskTimerStarted)
872 {
873 CTimeValue addTime;
874 int64 addMilliSeconds;
875
876 addMilliSeconds = cry_random(minDelay, maxDelay);
877
878 addTime.SetMilliSeconds(addMilliSeconds);
879
880 pTask->startTaskTimerStarted = true;
881 pTask->startTaskDone = false;
882 pTask->startTaskTime = g_time + addTime;
883
884 NetLog("[Lobby] Delay start task %u for %" PRIi64 " milliseconds", id, addMilliSeconds);
885
886 return false;
887 }
888
889 NetLog("[Lobby] Delayed task %u started", id);
890 }
891
892 return true;
893 }
894
895 bool CCryLobby::DebugTickCallStartTaskRunning(CryLobbyTaskID id)
896 {
897 if (CLobbyCVars::Get().cldEnable)
898 {
899 SServiceTask* pTask = &m_serviceTask[id];
900
901 if (pTask->startTaskTimerStarted && !pTask->startTaskDone)
902 {
903 if (g_time > pTask->startTaskTime)
904 {
905 pTask->startTaskDone = true;
906 return true;
907 }
908 }
909 }
910
911 return false;
912 }
913
914 bool CCryLobby::DebugOKToTickTask(CryLobbyTaskID id, bool running)
915 {
916 int minDelay = CLobbyCVars::Get().cldMinDelayTime;
917 int maxDelay = CLobbyCVars::Get().cldMaxDelayTime;
918
919 if (CLobbyCVars::Get().cldEnable && (minDelay >= 0) && (maxDelay > minDelay))
920 {
921 SServiceTask* pTask = &m_serviceTask[id];
922
923 if (running && !pTask->startTaskDone)
924 {
925 if (!pTask->tickTaskTimerStarted)
926 {
927 CTimeValue addTime;
928 int64 addMilliSeconds;
929
930 addMilliSeconds = cry_random(minDelay, maxDelay);
931
932 addTime.SetMilliSeconds(addMilliSeconds);
933
934 pTask->tickTaskTimerStarted = true;
935 pTask->tickTaskTime = g_time + addTime;
936
937 NetLog("[Lobby] Delay start ticking task %u for %" PRIi64 " milliseconds", id, addMilliSeconds);
938
939 return false;
940 }
941 else
942 {
943 if (g_time > pTask->tickTaskTime)
944 {
945 if (!pTask->tickTaskDone)
946 {
947 NetLog("[Lobby] Delayed task %u ticking", id);
948
949 pTask->tickTaskDone = true;
950 }
951
952 return true;
953 }
954 else
955 {
956 return false;
957 }
958 }
959 }
960 }
961
962 return true;
963 }
964 #endif
965
966 ECryLobbyError CCryLobby::Initialise(ECryLobbyService service, ECryLobbyServiceFeatures features, CryLobbyConfigurationCallback cfgCb, CryLobbyCallback cb, void* cbArg)
967 {
968 LOBBY_AUTO_LOCK;
969
970 ECryLobbyError error = eCLE_Success;
971 if (features & eCLSO_Base)
972 {
973 error = CheckAllocGlobalResources();
974 }
975
976 assert(service >= 0 && service < eCLS_NumServices);
977
978 if (error == eCLE_Success)
979 {
980 switch (service)
981 {
982 case eCLS_LAN:
983 //#if !defined(_RELEASE) && !defined(DEDICATED_SERVER) && !defined(PURE_CLIENT)
984 #if USE_LAN
985 if (m_services[eCLS_LAN] == NULL)
986 {
987 m_services[eCLS_LAN] = new CCryLANLobbyService(this, service);
988
989 if (!m_services[eCLS_LAN])
990 {
991 error = eCLE_OutOfMemory;
992 }
993 }
994 #else
995 error = eCLE_ServiceNotSupported;
996 #endif // USE_LAN
997
998 break;
999
1000 case eCLS_Online:
1001 if (m_services[eCLS_Online] == NULL)
1002 {
1003 #if USE_STEAM
1004 if (CLobbyCVars::Get().useSteamAsOnlineLobby)
1005 {
1006 m_services[eCLS_Online] = new CCrySteamLobbyService(this, service);
1007
1008 if (!m_services[eCLS_Online])
1009 {
1010 error = eCLE_OutOfMemory;
1011 }
1012 }
1013 else
1014 {
1015 error = eCLE_ServiceNotSupported;
1016 }
1017 #else
1018 #if USE_LIVE
1019 m_services[eCLS_Online] = new CCryLiveLobbyService(this, service);
1020
1021 if (!m_services[eCLS_Online])
1022 {
1023 error = eCLE_OutOfMemory;
1024 }
1025 #elif USE_PSN
1026 m_services[eCLS_Online] = new CCryPSNLobbyService(this, service);
1027
1028 if (!m_services[eCLS_Online])
1029 {
1030 error = eCLE_OutOfMemory;
1031 }
1032 #elif USE_DURANGOLIVE
1033 m_services[eCLS_Online] = new CCryDurangoLiveLobbyService(this, service);
1034
1035 if (!m_services[eCLS_Online])
1036 {
1037 error = eCLE_OutOfMemory;
1038 }
1039 #else
1040 m_services[eCLS_Online] = NULL;
1041 error = eCLE_ServiceNotSupported;
1042 #endif
1043 #endif
1044 break;
1045 }
1046 }
1047
1048 if (error == eCLE_Success)
1049 {
1050 m_task[service].cb = cb;
1051 m_task[service].cbArg = cbArg;
1052 this->m_configCB = cfgCb;
1053
1054 error = m_services[service]->Initialise(features, (features & eCLSO_Base) ? InitialiseServiceCB : NULL);
1055
1056 if (error == eCLE_Success)
1057 {
1058 if (features & eCLSO_Base)
1059 {
1060 FROM_GAME_TO_LOBBY(&CCryLobbyService::CreateSocketNT, m_services[service].get());
1061 }
1062 }
1063 else
1064 {
1065 // Task didn't start so remove our reference to the service
1066 m_services[service] = NULL;
1067 }
1068 }
1069 }
1070
1071 if ((error == eCLE_Success) && (features & eCLSO_Base))
1072 {
1073 // Final step, initialise lobby parameters
1074 m_services[service]->GetSocketPorts(m_serviceParams[service].m_connectPort, m_serviceParams[service].m_listenPort);
1075 }
1076
1077 CryLog("[Lobby] Initialise service %d error %d\n", service, error);
1078
1079 return error;
1080 }
1081
1082 ECryLobbyError CCryLobby::Terminate(ECryLobbyService service, ECryLobbyServiceFeatures features, CryLobbyCallback cb, void* cbArg)
1083 {
1084 LOBBY_AUTO_LOCK;
1085 ECryLobbyError error;
1086
1087 if (m_services[service])
1088 {
1089 m_task[service].cb = cb;
1090 m_task[service].cbArg = cbArg;
1091
1092 error = m_services[service]->Terminate(features, (features & eCLSO_Base) ? TerminateServiceCB : NULL);
1093
1094 if (features & eCLSO_Base)
1095 {
1096 m_services[service] = NULL;
1097 }
1098 }
1099 else
1100 {
1101 error = eCLE_NotInitialised;
1102 }
1103
1104 {
1105 if (features & eCLSO_Base)
1106 {
1107 CheckFreeGlobalResources();
1108 }
1109 }
1110 CryLog("[Lobby] Terminate service %d error %d\n", service, error);
1111
1112 return error;
1113 }
1114
1115 ECryLobbyError CCryLobby::ProcessEvents()
1116 {
1117 if (m_safetyToGameMutex.TryLock())
1118 {
1119 m_toGameQueue.Flush(false);
1120 m_safetyToGameMutex.Unlock();
1121 return eCLE_Success;
1122 }
1123
1124 return eCLE_SuccessContinue;
1125 }
1126
1127 CryLobbyConnectionID CCryLobby::CreateConnection(const TNetAddress& address)
1128 {
1129 #if USE_LOBBY_REMOTE_CONNECTIONS
1130 for (uint32 i = 0; i < MAX_LOBBY_CONNECTIONS; i++)
1131 {
1132 if (!m_connection[i].used)
1133 {
1134 SConnection* pConnection = &m_connection[i];
1135
1136 #if RESET_CONNECTED_CONNECTION
1137 pConnection->sendCookie = gEnv->pTimer->GetAsyncTime().GetValue();
1138 pConnection->recvCookie = INVALID_CONNECTION_COOKIE;
1139 #endif
1140
1141 pConnection->timeSinceSend = 0;
1142 pConnection->timeSinceRecv = 0;
1143 pConnection->disconnectTimer = 0;
1144 pConnection->addr = address;
1145 pConnection->state = eCLCS_Pending;
1146 pConnection->refCount = 0;
1147 pConnection->counterIn = 0;
1148 pConnection->counterOut = 0;
1149 pConnection->used = true;
1150 pConnection->reliableBuildPacket.SetWriteBuffer(pConnection->reliableBuildPacketBuffer, MAX_LOBBY_PACKET_SIZE);
1151
1152 pConnection->ping.aveTime = CRYLOBBY_INVALID_PING;
1153 pConnection->ping.currentTime = 0;
1154
1155 for (uint32 j = 0; j < NUM_LOBBY_PINGS; j++)
1156 {
1157 pConnection->ping.times[j] = CRYLOBBY_INVALID_PING;
1158 }
1159
1160 ECryLobbyService service = GetCorrectSocketServiceTypeForAddr(address);
1161 if (!GetInternalSocket(service))
1162 {
1163 NetLog("[Lobby] Socket was not previously ready, trying again");
1164 InternalSocketCreate(service);
1165 }
1166
1167 SECURE_NET_LOG("[lobby] Create reliable connection " PRFORMAT_LCINFO, PRARG_LCINFO(CryLobbyConnectionID(i), pConnection->addr));
1168
1169 return i;
1170 }
1171 }
1172 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1173
1174 return CryLobbyInvalidConnectionID;
1175 }
1176
1177 CryLobbyConnectionID CCryLobby::FindConnection(const TNetAddress& address)
1178 {
1179 #if USE_LOBBY_REMOTE_CONNECTIONS
1180 for (uint32 i = 0; i < MAX_LOBBY_CONNECTIONS; i++)
1181 {
1182 if (m_connection[i].used && (m_connection[i].addr == address))
1183 {
1184 return i;
1185 }
1186 }
1187 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1188
1189 return CryLobbyInvalidConnectionID;
1190 }
1191
1192 void CCryLobby::ConnectionAddRef(CryLobbyConnectionID c)
1193 {
1194 #if USE_LOBBY_REMOTE_CONNECTIONS
1195 if (c != CryLobbyInvalidConnectionID)
1196 {
1197 SConnection* pConnection = &m_connection[c];
1198
1199 if (pConnection->used)
1200 {
1201 SECURE_NET_LOG("RefCount of connection " PRFORMAT_LCINFO " is incrementing, %u->%u. Thread #%" PRI_THREADID, PRARG_LCINFO(c, pConnection->addr), pConnection->refCount, pConnection->refCount + 1u, CryGetCurrentThreadId());
1202
1203 pConnection->refCount++;
1204 }
1205 }
1206 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1207 }
1208
1209 bool CCryLobby::KeepPacketAfterDisconnect(uint32 packetType)
1210 {
1211 return ((packetType == eLobbyPT_SessionDeleteRemoteConnection) ||
1212 (packetType == eLobbyPT_SessionRequestJoinResult));
1213 }
1214
1215 void CCryLobby::ConnectionRemoveRef(CryLobbyConnectionID c)
1216 {
1217 #if USE_LOBBY_REMOTE_CONNECTIONS
1218 if (c != CryLobbyInvalidConnectionID)
1219 {
1220 SConnection* pConnection = &m_connection[c];
1221
1222 if (pConnection->used)
1223 {
1224 if (pConnection->refCount > 0)
1225 {
1226 SECURE_NET_LOG("RefCount of connection " PRFORMAT_LCINFO " is decrementing, %u->%d. Thread #%" PRI_THREADID, PRARG_LCINFO(c, pConnection->addr), pConnection->refCount, pConnection->refCount - 1u, CryGetCurrentThreadId());
1227
1228 pConnection->refCount--;
1229
1230 if (pConnection->refCount == 0)
1231 {
1232 if (pConnection->reliableBuildPacket.GetWriteBufferPos() > 0)
1233 {
1234 AddReliablePacketToSendQueue(c, &pConnection->reliableBuildPacket);
1235 }
1236
1237 // We only need to keep eLobbyPT_SessionDeleteRemoteConnection in the send queue so the other end knows we are leaving.
1238 // All other packets should be removed as they are not important now.
1239 NetLog("[Lobby] %u packets in send queue", pConnection->dataQueue.Size());
1240 pConnection->counterOut -= (uint8) pConnection->dataQueue.Size();
1241
1242 if (!pConnection->dataQueue.Empty())
1243 {
1244 uint32 numCheck = pConnection->dataQueue.Size();
1245
1246 for (uint32 i = 0; i < numCheck; i++)
1247 {
1248 SConnection::SData& data = pConnection->dataQueue.Front();
1249 uint8* pData = (uint8*)MemGetPtr(data.data);
1250 CCrySharedLobbyPacket packet;
1251 uint32 dataPos = 0;
1252 SCryLobbyPacketDataHeader* pDataHeader = packet.GetLobbyPacketDataHeader();
1253
1254 pConnection->dataQueue.Pop();
1255
1256 while (GetNextPacketFromBuffer(pData, data.dataSize, dataPos, &packet))
1257 {
1258 #if !defined(EXCLUDE_NORMAL_LOG)
1259 uint32 encodedPacketType = pDataHeader->lobbyPacketType;
1260 #endif
1261 DecodePacketDataHeader(&packet);
1262
1263 if (KeepPacketAfterDisconnect(pDataHeader->lobbyPacketType))
1264 {
1265 NetLog("[Lobby] Keep packet %u (%u) Size %u", pDataHeader->lobbyPacketType, encodedPacketType, pDataHeader->dataSize);
1266 EncodePacketDataHeader(&packet);
1267 AddPacketToReliableBuildPacket(c, &packet);
1268 }
1269 else
1270 {
1271 NetLog("[Lobby] Remove packet %u Size %u", pDataHeader->lobbyPacketType, pDataHeader->dataSize);
1272 }
1273 }
1274
1275 MemFree(data.data);
1276 }
1277 }
1278
1279 if (pConnection->reliableBuildPacket.GetWriteBufferPos() > 0)
1280 {
1281 AddReliablePacketToSendQueue(c, &pConnection->reliableBuildPacket);
1282
1283 // Put connection into freeing state
1284 // Any sends in queue will still try and send and no new sends will be accepted
1285 pConnection->state = eCLCS_Freeing;
1286 }
1287 else
1288 {
1289 SECURE_NET_LOG("[lobby] Release connection " PRFORMAT_LCINFO, PRARG_LCINFO(c, pConnection->addr));
1290
1291 FreeConnection(c);
1292 }
1293 }
1294 }
1295 else
1296 {
1297 #if !defined(_RELEASE)
1298 CryFatalError("RefCount of connection " PRFORMAT_LCINFO " is trying to drop below 0! Thread #%" PRI_THREADID ".", PRARG_LCINFO(c, pConnection->addr), CryGetCurrentThreadId());
1299 #else
1300 SECURE_NET_LOG("RefCount of connection " PRFORMAT_LCINFO " is trying to drop below 0! Thread #%" PRI_THREADID ".", PRARG_LCINFO(c, pConnection->addr), CryGetCurrentThreadId());
1301 #endif
1302 }
1303 }
1304 }
1305 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1306 }
1307
1308 bool CCryLobby::ConnectionHasReference(CryLobbyConnectionID c)
1309 {
1310 #if USE_LOBBY_REMOTE_CONNECTIONS
1311 if (c != CryLobbyInvalidConnectionID)
1312 {
1313 SConnection* pConnection = &m_connection[c];
1314
1315 if (pConnection->used)
1316 {
1317 return pConnection->refCount > 0;
1318 }
1319 }
1320 #endif
1321
1322 return false;
1323 }
1324
1325 void CCryLobby::ConnectionSetState(CryLobbyConnectionID c, ECryLobbyConnectionState state)
1326 {
1327 #if USE_LOBBY_REMOTE_CONNECTIONS
1328 if (c != CryLobbyInvalidConnectionID)
1329 {
1330 SConnection* pConnection = &m_connection[c];
1331
1332 if (pConnection->used)
1333 {
1334 pConnection->state = state;
1335 }
1336 }
1337 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1338 }
1339
1340 ECryLobbyConnectionState CCryLobby::ConnectionGetState(CryLobbyConnectionID c)
1341 {
1342 #if USE_LOBBY_REMOTE_CONNECTIONS
1343 if (c != CryLobbyInvalidConnectionID)
1344 {
1345 SConnection* pConnection = &m_connection[c];
1346
1347 if (pConnection->used)
1348 {
1349 return pConnection->state;
1350 }
1351 }
1352 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1353
1354 return eCLCS_NotConnected;
1355 }
1356
1357 void CCryLobby::FreeConnection(CryLobbyConnectionID c)
1358 {
1359 #if USE_LOBBY_REMOTE_CONNECTIONS
1360 if (c != CryLobbyInvalidConnectionID)
1361 {
1362 SConnection* connection = &m_connection[c];
1363
1364 if (connection->used)
1365 {
1366 connection->used = false;
1367
1368 while (!connection->dataQueue.Empty())
1369 {
1370 SConnection::SData& data = connection->dataQueue.Front();
1371
1372 MemFree(data.data);
1373 connection->dataQueue.Pop();
1374 }
1375 }
1376 }
1377 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1378 }
1379
1380 bool CCryLobby::ConnectionFromAddress(CryLobbyConnectionID* connection, const TNetAddress& address)
1381 {
1382 *connection = FindConnection(address);
1383
1384 return *connection != CryLobbyInvalidConnectionID;
1385 }
1386
1387 bool CCryLobby::AddressFromConnection(TNetAddress& address, CryLobbyConnectionID c)
1388 {
1389 #if USE_LOBBY_REMOTE_CONNECTIONS
1390 assert(c == CryLobbyInvalidConnectionID || c < MAX_LOBBY_CONNECTIONS);
1391
1392 if (c < MAX_LOBBY_CONNECTIONS)
1393 {
1394 SConnection* connection = &m_connection[c];
1395
1396 if (connection->used)
1397 {
1398 address = connection->addr;
1399 return true;
1400 }
1401 }
1402 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1403
1404 return false;
1405 }
1406
1407 bool CCryLobby::SetConnectionAddress(CryLobbyConnectionID c, TNetAddress& address)
1408 {
1409 #if USE_LOBBY_REMOTE_CONNECTIONS
1410 if (c != CryLobbyInvalidConnectionID)
1411 {
1412 SConnection* connection = &m_connection[c];
1413
1414 if (connection->used)
1415 {
1416 connection->addr = address;
1417 return true;
1418 }
1419 }
1420 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1421
1422 return false;
1423 }
1424
1425 void CCryLobby::FlushMessageQueue()
1426 {
1427 Tick(true);
1428 }
1429
1430 bool CCryLobby::AddReliablePacketToSendQueue(CryLobbyConnectionID connectionID, CCryLobbyPacket* pPacket)
1431 {
1432 #if USE_LOBBY_REMOTE_CONNECTIONS
1433 SConnection* pConnection = &m_connection[connectionID];
1434
1435 if (!pConnection->dataQueue.Full())
1436 {
1437 SConnection::SData sdata;
1438
1439 sdata.data = MemAlloc(pPacket->GetWriteBufferPos());
1440
1441 if (sdata.data != TMemInvalidHdl)
1442 {
1443 uint8* pData = (uint8*)MemGetPtr(sdata.data);
1444
1445 memcpy(pData, pPacket->GetWriteBuffer(), pPacket->GetWriteBufferPos());
1446
1447 sdata.dataSize = pPacket->GetWriteBufferPos();
1448 sdata.counter = pConnection->counterOut;
1449 pConnection->dataQueue.Push(sdata);
1450
1451 pPacket->SetWriteBufferPos(0);
1452
1453 return true;
1454 }
1455 }
1456 else
1457 {
1458 SECURE_NET_LOG("[Lobby] Trying to send to connection " PRFORMAT_LCINFO " but the send queue is full", PRARG_LCINFO(connectionID, pConnection->addr));
1459 const int numPacketsInQueue = pConnection->dataQueue.Size();
1460 for (int i = 0; i < numPacketsInQueue; ++i)
1461 {
1462 SConnection::SData& data = pConnection->dataQueue[i];
1463 NetLog("counter %d size %d", data.counter, data.dataSize);
1464 LogPacketsInBuffer((uint8*)MemGetPtr(data.data), data.dataSize);
1465 }
1466 }
1467 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1468
1469 return false;
1470 }
1471
1472 bool CCryLobby::AddPacketToReliableBuildPacket(CryLobbyConnectionID connectionID, CCryLobbyPacket* pPacket)
1473 {
1474 #if USE_LOBBY_REMOTE_CONNECTIONS
1475 SConnection* pConnection = &m_connection[connectionID];
1476 CCrySharedLobbyPacket* pSBuildPacket = (CCrySharedLobbyPacket*)&pConnection->reliableBuildPacket;
1477 SCryLobbyPacketHeader* pBuildPacketHeader = pSBuildPacket->GetLobbyPacketHeader();
1478 SCryLobbyPacketDataHeader* pBuildDataHeader = pSBuildPacket->GetLobbyPacketDataHeader();
1479 CCrySharedLobbyPacket* pSPacket = (CCrySharedLobbyPacket*)pPacket;
1480 SCryLobbyPacketHeader* pPacketHeader = pSPacket->GetLobbyPacketHeader();
1481 SCryLobbyPacketDataHeader* pDataHeader = pSPacket->GetLobbyPacketDataHeader();
1482 uint8* pDataBuffer = pSPacket->GetWriteBuffer() + CryLobbyPacketReliableHeaderSize;
1483 uint32 dataSize = pSPacket->GetWriteBufferPos() - CryLobbyPacketReliableHeaderSize;
1484
1485 if (pSPacket->GetWriteBufferPos() > MAX_LOBBY_PACKET_SIZE)
1486 {
1487 if (pSBuildPacket->GetWriteBufferPos() > 0)
1488 {
1489 if (!AddReliablePacketToSendQueue(connectionID, pSBuildPacket))
1490 {
1491 return false;
1492 }
1493 }
1494
1495 pConnection->counterOut++;
1496
1497 *pBuildPacketHeader = *pPacketHeader;
1498 *pBuildDataHeader = *pDataHeader;
1499
1500 pPacketHeader->counterOut = pConnection->counterOut;
1501 pPacketHeader->counterIn = pConnection->counterIn;
1502 pDataHeader->dataSize = dataSize;
1503
1504 uint32 bufferPos = pSPacket->GetWriteBufferPos();
1505 pSPacket->SetWriteBufferPos(0);
1506 pSPacket->WritePacketHeader();
1507 pSPacket->WriteDataHeader();
1508 pSPacket->SetWriteBufferPos(bufferPos);
1509
1510 if (AddReliablePacketToSendQueue(connectionID, pSPacket))
1511 {
1512 return true;
1513 }
1514
1515 return false;
1516 }
1517
1518 if (pSBuildPacket->GetWriteBufferPos() > 0)
1519 {
1520 // Send and start new if
1521 if (((pSBuildPacket->GetWriteBufferPos() + CryLobbyPacketReliableDataHeaderSize + dataSize) > pSBuildPacket->GetReadBufferSize()) || // Data will not fit in current packet
1522 (pBuildPacketHeader->fromUID.m_sid != pPacketHeader->fromUID.m_sid)) // sid has changed due to host migration
1523 {
1524 if (!AddReliablePacketToSendQueue(connectionID, pSBuildPacket))
1525 {
1526 return false;
1527 }
1528 }
1529 }
1530
1531 if (pSBuildPacket->GetWriteBufferPos() == 0)
1532 {
1533 // Build packet is empty so start with this packet
1534 pConnection->counterOut++;
1535
1536 *pBuildPacketHeader = *pPacketHeader;
1537 *pBuildDataHeader = *pDataHeader;
1538
1539 pBuildPacketHeader->counterOut = pConnection->counterOut;
1540 pBuildPacketHeader->counterIn = pConnection->counterIn;
1541 pBuildDataHeader->dataSize = dataSize;
1542
1543 pSBuildPacket->WritePacketHeader();
1544 pSBuildPacket->WriteDataHeader();
1545 pSBuildPacket->WriteData(pDataBuffer, dataSize);
1546 }
1547 else
1548 {
1549 // Add data to end of current packet.
1550 *pBuildDataHeader = *pDataHeader;
1551 pBuildDataHeader->dataSize = dataSize;
1552 pSBuildPacket->WriteDataHeader();
1553 pSBuildPacket->WriteData(pDataBuffer, dataSize);
1554 }
1555
1556 return true;
1557 #else // USE_LOBBY_REMOTE_CONNECTIONS
1558 return false;
1559 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1560 }
1561
1562 void CCryLobby::CalculatePacketTypeEncoding()
1563 {
1564 CMTRand_int32 r(CRYLOBBY_PACKET_TYPE_ENCODE_SEED);
1565 uint32 i;
1566
1567 for (i = 0; i < 256; i++)
1568 {
1569 m_encodePacketType[i] = i;
1570 }
1571
1572 for (i = 0; i < 1024; i++)
1573 {
1574 uint32 lhs = r.GenerateUint32() & 0xff;
1575 uint32 rhs = r.GenerateUint32() & 0xff;
1576
1577 std::swap(m_encodePacketType[lhs], m_encodePacketType[rhs]);
1578 }
1579
1580 for (i = 0; i < 256; i++)
1581 {
1582 m_decodePacketType[m_encodePacketType[i]] = i;
1583 }
1584
1585 for (i = m_servicePacketEnd[eCLS_LAN]; i <= CRYLANLOBBY_PACKET_MAX; i++)
1586 {
1587 m_decodePacketType[m_encodePacketType[i]] = eLobbyPT_InvalidPackeType;
1588 }
1589
1590 for (i = m_servicePacketEnd[eCLS_Online]; i <= CRYONLINELOBBY_PACKET_MAX; i++)
1591 {
1592 m_decodePacketType[m_encodePacketType[i]] = eLobbyPT_InvalidPackeType;
1593 }
1594
1595 for (i = m_userPacketEnd; i <= CRYLOBBY_USER_PACKET_MAX; i++)
1596 {
1597 m_decodePacketType[m_encodePacketType[i]] = eLobbyPT_InvalidPackeType;
1598 }
1599 }
1600
1601 void CCryLobby::EncodePacketDataHeader(CCryLobbyPacket* pPacket)
1602 {
1603 CCrySharedLobbyPacket* pSPacket = (CCrySharedLobbyPacket*)pPacket;
1604 SCryLobbyPacketDataHeader* pDataHeader = pSPacket->GetLobbyPacketDataHeader();
1605
1606 pDataHeader->lobbyPacketType = m_encodePacketType[pDataHeader->lobbyPacketType];
1607 }
1608
1609 void CCryLobby::DecodePacketDataHeader(CCryLobbyPacket* pPacket)
1610 {
1611 CCrySharedLobbyPacket* pSPacket = (CCrySharedLobbyPacket*)pPacket;
1612 SCryLobbyPacketDataHeader* pDataHeader = pSPacket->GetLobbyPacketDataHeader();
1613
1614 pDataHeader->lobbyPacketType = m_decodePacketType[pDataHeader->lobbyPacketType];
1615 }
1616
1617 ESocketError CCryLobby::Send(CCryLobbyPacket* pPacket, const TNetAddress& to, CryLobbyConnectionID connectionID, CryLobbySendID* pSendID)
1618 {
1619 #if USE_LOBBY_REMOTE_CONNECTIONS
1620 CCrySharedLobbyPacket* pSPacket = (CCrySharedLobbyPacket*)pPacket;
1621 ESocketError ret = eSE_Ok;
1622
1623 EncodePacketDataHeader(pSPacket);
1624
1625 if (pSPacket->GetReliable())
1626 {
1627 if (connectionID == CryLobbyInvalidConnectionID)
1628 {
1629 connectionID = FindConnection(to);
1630
1631 if (connectionID == CryLobbyInvalidConnectionID)
1632 {
1633 connectionID = CreateConnection(to);
1634 }
1635 }
1636
1637 if (connectionID != CryLobbyInvalidConnectionID)
1638 {
1639 SConnection* pConnection = &m_connection[connectionID];
1640
1641 if ((pConnection->state == eCLCS_Connected) || (pConnection->state == eCLCS_Pending))
1642 {
1643 if (AddPacketToReliableBuildPacket(connectionID, pSPacket))
1644 {
1645 if (pConnection->dataQueue.Empty())
1646 {
1647 AddReliablePacketToSendQueue(connectionID, &pConnection->reliableBuildPacket);
1648
1649 SConnection::SData& data = pConnection->dataQueue.Front();
1650
1651 SECURE_NET_LOG("[lobby] Send reliable connection " PRFORMAT_LCINFO " counter %d size %d", PRARG_LCINFO(connectionID, pConnection->addr), data.counter, data.dataSize);
1652
1653 LogPacketsInBuffer((uint8*)MemGetPtr(data.data), data.dataSize);
1654
1655 // Data hasn't been acknowledged so try sending again
1656 SSocketService* pSocketService = GetCorrectSocketServiceForAddr(pConnection->addr);
1657 if (pSocketService->m_socket)
1658 {
1659 if (pSocketService->m_socket->Send(EncryptPacket((uint8*)MemGetPtr(data.data), data.dataSize), data.dataSize, pConnection->addr) != eSE_Ok)
1660 {
1661 SECURE_NET_LOG("[Lobby] Failed to send setting connection " PRFORMAT_LCINFO " to eCLCS_NotConnected", PRARG_LCINFO(connectionID, pConnection->addr));
1662 pConnection->state = eCLCS_NotConnected;
1663 }
1664 }
1665 }
1666
1667 if (pSendID)
1668 {
1669 *pSendID = CryLobbyCreateSendID(connectionID, pConnection->counterOut);
1670 }
1671 }
1672 else
1673 {
1674 ret = eSE_MiscFatalError;
1675 }
1676 }
1677 }
1678 else
1679 {
1680 ret = eSE_MiscFatalError;
1681 }
1682 }
1683 else
1684 {
1685 SSocketService* pSocketService = GetCorrectSocketServiceForAddr(to);
1686
1687 if (pSocketService->m_socket)
1688 {
1689 uint8* pBuffer = pSPacket->GetWriteBuffer();
1690 uint32 bufferSize = pSPacket->GetWriteBufferPos();
1691
1692 pSPacket->SetWriteBufferPos(0);
1693 pSPacket->WritePacketHeader();
1694 pSPacket->WriteDataHeader();
1695 pSPacket->SetWriteBufferPos(bufferSize);
1696
1697 if (pSendID)
1698 {
1699 *pSendID = CryLobbyInvalidSendID;
1700 }
1701
1702 ret = pSocketService->m_socket->Send(EncryptPacket(pBuffer, bufferSize), bufferSize, to);
1703 }
1704 else
1705 {
1706 ret = eSE_MiscFatalError;
1707 }
1708 }
1709
1710 DecodePacketDataHeader(pSPacket);
1711
1712 return ret;
1713 #else // USE_LOBBY_REMOTE_CONNECTIONS
1714 return eSE_MiscFatalError;
1715 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1716 }
1717
1718 ESocketError CCryLobby::SendVoice(CCryLobbyPacket* pPacket, const TNetAddress& to)
1719 {
1720 #if USE_LOBBY_REMOTE_CONNECTIONS
1721 SSocketService* pSocketService = GetCorrectSocketService(m_service);
1722
1723 if (pSocketService->m_socket)
1724 {
1725 CCrySharedLobbyPacket* pSPacket = (CCrySharedLobbyPacket*)pPacket;
1726 uint8* pBuffer = pSPacket->GetWriteBuffer();
1727 uint32 bufferSize = pSPacket->GetWriteBufferPos();
1728
1729 EncodePacketDataHeader(pSPacket);
1730
1731 pSPacket->SetWriteBufferPos(0);
1732 pSPacket->WritePacketHeader();
1733 pSPacket->WriteDataHeader();
1734 pSPacket->SetWriteBufferPos(bufferSize);
1735
1736 DecodePacketDataHeader(pSPacket);
1737
1738 return pSocketService->m_socket->SendVoice(EncryptPacket(pBuffer, bufferSize), bufferSize, to);
1739 }
1740 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1741
1742 return eSE_MiscFatalError;
1743 }
1744
1745 void CCryLobby::UpdateConnectionPing(CryLobbyConnectionID connectionID, CryPing ping)
1746 {
1747 #if USE_LOBBY_REMOTE_CONNECTIONS
1748 SConnection* pConnection = &m_connection[connectionID];
1749
1750 pConnection->ping.times[pConnection->ping.currentTime] = ping;
1751 pConnection->ping.currentTime = (pConnection->ping.currentTime + 1) % NUM_LOBBY_PINGS;
1752
1753 uint32 numValidPings = 0;
1754 CryPingAccumulator totalTime = 0;
1755
1756 for (uint32 i = 0; i < NUM_LOBBY_PINGS; ++i)
1757 {
1758 if (pConnection->ping.times[i] != CRYLOBBY_INVALID_PING)
1759 {
1760 totalTime += pConnection->ping.times[i];
1761 ++numValidPings;
1762 }
1763 }
1764
1765 if (numValidPings)
1766 {
1767 pConnection->ping.aveTime = (CryPing)(totalTime / numValidPings);
1768 }
1769 else
1770 {
1771 pConnection->ping.aveTime = CRYLOBBY_INVALID_PING;
1772 }
1773 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1774 }
1775
1776 CryPing CCryLobby::GetConnectionPing(CryLobbyConnectionID connectionID)
1777 {
1778 #if USE_LOBBY_REMOTE_CONNECTIONS
1779 if ((connectionID != CryLobbyInvalidConnectionID) && (connectionID < MAX_LOBBY_CONNECTIONS))
1780 {
1781 return m_connection[connectionID].ping.aveTime;
1782 }
1783 #endif // USE_LOBBY_REMOTE_CONNECTIONS
1784
1785 return CRYLOBBY_INVALID_PING;
1786 }
1787
1788 bool CCryLobby::GetNextPacketFromBuffer(const uint8* pData, uint32 dataSize, uint32& dataPos, CCryLobbyPacket* pPacket)
1789 {
1790 CCrySharedLobbyPacket* pSPacket = (CCrySharedLobbyPacket*)pPacket;
1791
1792 if (dataPos == 0)
1793 {
1794 pSPacket->SetReadBuffer(pData, dataSize);
1795 pSPacket->SetReadBufferPos(0);
1796 pSPacket->ReadPacketHeader();
1797 dataPos = CryLobbyPacketReliablePacketHeaderSize;
1798 }
1799
1800 if (dataPos < dataSize)
1801 {
1802 SCryLobbyPacketDataHeader* pDataHeader = pSPacket->GetLobbyPacketDataHeader();
1803
1804 pSPacket->SetReadBuffer(pData + dataPos - CryLobbyPacketReliablePacketHeaderSize, dataSize - (dataPos - CryLobbyPacketReliablePacketHeaderSize));
1805 pSPacket->SetReadBufferPos(CryLobbyPacketReliablePacketHeaderSize);
1806 pSPacket->ReadDataHeader();
1807 pSPacket->SetReadBuffer(pData + dataPos - CryLobbyPacketReliablePacketHeaderSize, pDataHeader->dataSize + CryLobbyPacketReliableHeaderSize);
1808 pSPacket->SetReadBufferPos(CryLobbyPacketReliableHeaderSize + pDataHeader->dataSize);
1809 dataPos += CryLobbyPacketReliableDataHeaderSize + pDataHeader->dataSize;
1810 return true;
1811 }
1812
1813 return false;
1814 }
1815
1816 void CCryLobby::ProcessPacket(const TNetAddress& addr, CryLobbyConnectionID connectionID, CCryLobbyPacket* pPacket)
1817 {
1818 #if USE_LOBBY_REMOTE_CONNECTIONS
1819 SConnection* pConnection = (connectionID != CryLobbyInvalidConnectionID) ? &m_connection[connectionID] : NULL;
1820
1821 switch (pPacket->StartRead())
1822 {
1823 case eLobbyPT_Ack:
1824 if (pConnection)
1825 {
1826 uint8 counterIn = pPacket->ReadUINT8();
1827
1828 if (!pConnection->dataQueue.Empty())
1829 {
1830 SConnection::SData& qdata = pConnection->dataQueue.Front();
1831
1832 if (counterIn == qdata.counter)
1833 {
1834 #if !defined(NO_NETWORK_SECURITY_LOGS)
1835 const uint8 qDataCounter = qdata.counter;
1836 #endif
1837 // Other end has received the packet we are trying to send
1838 OnSendComplete(addr);
1839 SECURE_NET_LOG("[lobby] Got ack on connection " PRFORMAT_LCINFO " counterIn=%u, qDataCounter=%u", PRARG_LCINFO(connectionID, pConnection->addr), counterIn, qDataCounter);
1840 }
1841 }
1842 }
1843
1844 break;
1845
1846 case eLobbyPT_ConnectionRequest:
1847 {
1848 #if RESET_CONNECTED_CONNECTION
1849 uint64 cookie = pPacket->ReadUINT64();
1850 #endif
1851
1852 if (connectionID == CryLobbyInvalidConnectionID)
1853 {
1854 connectionID = CreateConnection(addr);
1855 }
1856 else
1857 {
1858 pConnection = &m_connection[connectionID];
1859
1860 if (pConnection->state == eCLCS_Freeing)
1861 {
1862 SECURE_NET_LOG("[Lobby] Connection Request on existing Freeing connection " PRFORMAT_LCINFO, PRARG_LCINFO(connectionID, pConnection->addr));
1863 uint8 refCount = pConnection->refCount;
1864 FreeConnection(connectionID);
1865 connectionID = CreateConnection(addr);
1866 NetLog("[Lobby] setting refCount back to %u for resetted connection", refCount);
1867 pConnection = &m_connection[connectionID];
1868 pConnection->refCount = refCount;
1869 }
1870 #if RESET_CONNECTED_CONNECTION
1871 else
1872 {
1873 if ((pConnection->recvCookie != cookie) && (pConnection->recvCookie != INVALID_CONNECTION_COOKIE))
1874 {
1875 SECURE_NET_LOG("[Lobby] Connection Request on existing connected connection, current cookie %llx new cookie %llx Freeing connection " PRFORMAT_LCINFO, pConnection->recvCookie, cookie, PRARG_LCINFO(connectionID, pConnection->addr));
1876 CCryMatchMaking* pMatchMaking = (CCryMatchMaking*)GetMatchMaking();
1877 if (pMatchMaking)
1878 {
1879 pMatchMaking->ResetConnection(connectionID);
1880 }
1881
1882 uint8 refCount = pConnection->refCount;
1883
1884 FreeConnection(connectionID);
1885 connectionID = CreateConnection(addr);
1886
1887 if (connectionID != CryLobbyInvalidConnectionID)
1888 {
1889 NetLog("[Lobby] setting refCount back to %u for resetted connection", refCount);
1890
1891 pConnection = &m_connection[connectionID];
1892 pConnection->refCount = refCount;
1893 }
1894 }
1895 }
1896 #endif
1897 }
1898
1899 if (connectionID != CryLobbyInvalidConnectionID)
1900 {
1901 pConnection = &m_connection[connectionID];
1902
1903 const uint32 MaxBufferSize = CryLobbyPacketHeaderSize
1904 #if RESET_CONNECTED_CONNECTION
1905 + CryLobbyPacketUINT64Size;
1906 #endif // RESET_CONNECTED_CONNECTION
1907 ;
1908 uint8 buffer[MaxBufferSize];
1909 CCrySharedLobbyPacket resultPacket;
1910
1911 #if RESET_CONNECTED_CONNECTION
1912 pConnection->recvCookie = cookie;
1913 #endif
1914
1915 pConnection->state = eCLCS_Connected;
1916
1917 resultPacket.SetWriteBuffer(buffer, MaxBufferSize);
1918 resultPacket.StartWrite(eLobbyPT_ConnectionRequestResult, false);
1919 #if RESET_CONNECTED_CONNECTION
1920 SECURE_NET_LOG("[Lobby] Sending cookie %llx with connection " PRFORMAT_LCINFO, pConnection->sendCookie, PRARG_LCINFO(connectionID, pConnection->addr));
1921 resultPacket.WriteUINT64(pConnection->sendCookie);
1922 #endif
1923
1924 if (Send(&resultPacket, pConnection->addr, connectionID, NULL) != eSE_Ok)
1925 {
1926 SECURE_NET_LOG("[Lobby] Failed to send setting connection " PRFORMAT_LCINFO " to eCLCS_NotConnected", PRARG_LCINFO(connectionID, pConnection->addr));
1927 pConnection->state = eCLCS_NotConnected;
1928 }
1929 }
1930
1931 break;
1932 }
1933
1934 case eLobbyPT_ConnectionRequestResult:
1935 if (pConnection)
1936 {
1937 pConnection->state = eCLCS_Connected;
1938 #if RESET_CONNECTED_CONNECTION
1939 pConnection->recvCookie = pPacket->ReadUINT64();
1940 SECURE_NET_LOG("[Lobby] Setting recvCookie %llx for connection " PRFORMAT_LCINFO, pConnection->recvCookie, PRARG_LCINFO(connectionID, pConnection->addr));
1941 #endif
1942 }
1943
1944 break;
1945
1946 case eLobbyPT_Ping:
1947 if (pConnection)
1948 {
1949 CTimeValue currentTime = gEnv->pTimer->GetAsyncTime();
1950 CTimeValue recvTime = pPacket->GetRecvTime();
1951 uint64 timeDelayed = (currentTime - recvTime).GetMilliSecondsAsInt64();
1952 const uint32 MaxBufferSize = CryLobbyPacketHeaderSize + CryLobbyPacketUINT64Size;
1953 uint8 buffer[MaxBufferSize];
1954 CCrySharedLobbyPacket pongPacket;
1955
1956 pongPacket.SetWriteBuffer(buffer, MaxBufferSize);
1957 uint64 time = pPacket->ReadUINT64() + timeDelayed;
1958
1959 pongPacket.StartWrite(eLobbyPT_Pong, false);
1960 pongPacket.WriteUINT64(time);
1961
1962 if (Send(&pongPacket, pConnection->addr, connectionID, NULL) != eSE_Ok)
1963 {
1964 SECURE_NET_LOG("[Lobby] Failed to send setting connection " PRFORMAT_LCINFO " to eCLCS_NotConnected", PRARG_LCINFO(connectionID, pConnection->addr));
1965 pConnection->state = eCLCS_NotConnected;
1966 }
1967 }
1968
1969 break;
1970
1971 case eLobbyPT_Pong:
1972 if (pConnection)
1973 {
1974 CTimeValue recvTime = pPacket->GetRecvTime();
1975 uint64 sendTime = pPacket->ReadUINT64();
1976 uint64 pingTime = recvTime.GetMilliSecondsAsInt64() - sendTime;
1977 if (pingTime > CRYLOBBY_INVALID_PING)
1978 {
1979 pingTime = CRYLOBBY_INVALID_PING;
1980 }
1981
1982 UpdateConnectionPing(connectionID, (CryPing)pingTime);
1983 }
1984
1985 break;
1986
1987 case eLobbyPT_InvalidPackeType:
1988 if (pConnection)
1989 {
1990 pConnection->state = eCLCS_NotConnected;
1991 }
1992
1993 break;
1994
1995 default:
1996 if (m_services[m_service])
1997 {
1998 // Give packet to the current service
1999 m_services[m_service]->OnPacket(addr, pPacket);
2000 }
2001
2002 break;
2003 }
2004 #endif // USE_LOBBY_REMOTE_CONNECTIONS
2005 }
2006
2007 void CCryLobby::OnPacket(const TNetAddress& addr, const uint8* pData, uint32 length)
2008 {
2009 #if USE_LOBBY_REMOTE_CONNECTIONS
2010 CryLobbyConnectionID connectionID = FindConnection(addr);
2011 SConnection* pConnection = (connectionID != CryLobbyInvalidConnectionID) ? &m_connection[connectionID] : NULL;
2012
2013 if (pData[0] == GetLobbyPacketID())
2014 {
2015 m_cachedPacketBuffer.WritePacket(addr, pData, length);
2016 }
2017
2018 if (pConnection)
2019 {
2020 pConnection->timeSinceRecv = 0;
2021 }
2022 #endif // USE_LOBBY_REMOTE_CONNECTIONS
2023 }
2024
2025 void CCryLobby::ProcessCachedPacketBuffer(void)
2026 {
2027 #if USE_LOBBY_REMOTE_CONNECTIONS
2028 while (m_cachedPacketBuffer.PacketsAvailable())
2029 {
2030 CTimeValue recvTime;
2031 TNetAddress addr;
2032 const uint8* pData;
2033 uint32 length;
2034 m_cachedPacketBuffer.ReadPacket(recvTime, addr, pData, length);
2035
2036 CryLobbyConnectionID connectionID = FindConnection(addr);
2037 SConnection* pConnection = (connectionID != CryLobbyInvalidConnectionID) ? &m_connection[connectionID] : NULL;
2038
2039 const uint8* pDecodedData;
2040 CCrySharedLobbyPacket packet;
2041 SCryLobbyPacketHeader* pPacketHeader = packet.GetLobbyPacketHeader();
2042 SCryLobbyPacketDataHeader* pDataHeader = packet.GetLobbyPacketDataHeader();
2043 bool processPacket = true;
2044
2045 pDecodedData = DecryptPacket(pData, length);
2046
2047 packet.SetReadBuffer(pDecodedData, length);
2048 packet.SetReadBufferPos(0);
2049 packet.ReadPacketHeader();
2050 pPacketHeader->recvTime = recvTime;
2051
2052 if (packet.GetReliable())
2053 {
2054 if (pConnection && ((pConnection->state == eCLCS_Pending) || (pConnection->state == eCLCS_Connected)))
2055 {
2056 SECURE_NET_LOG("[lobby] OnPacket reliable connection " PRFORMAT_LCINFO " size %u", PRARG_LCINFO(connectionID, pConnection->addr), length);
2057
2058 if (((uint8)(pConnection->counterIn - pPacketHeader->counterOut)) == CONNECTION_COUNTER_MAX)
2059 {
2060 // This is a new packet
2061 NetLog("[lobby] New packet counter %d", pPacketHeader->counterOut);
2062
2063 pConnection->counterIn = pPacketHeader->counterOut;
2064
2065 if (!pConnection->dataQueue.Empty())
2066 {
2067 SConnection::SData& qdata = pConnection->dataQueue.Front();
2068
2069 if (pPacketHeader->counterIn == qdata.counter)
2070 {
2071 #if !defined(NO_NETWORK_SECURITY_LOGS)
2072 const uint8 qDataCounter = qdata.counter;
2073 #endif
2074 // Other end has received the packet we are trying to send
2075 OnSendComplete(addr);
2076 SECURE_NET_LOG("[lobby] Got ack(first) on connection " PRFORMAT_LCINFO " counterIn=%u, qDataCounter=%u", PRARG_LCINFO(connectionID, pConnection->addr), pPacketHeader->counterIn, qDataCounter);
2077 }
2078 }
2079 }
2080 else
2081 {
2082 processPacket = false;
2083 NetLog("[lobby] Repeat packet counter %d", pPacketHeader->counterOut);
2084 }
2085
2086 const uint32 MaxBufferSize = CryLobbyPacketUnReliableHeaderSize + CryLobbyPacketUINT8Size;
2087 uint8 buffer[MaxBufferSize];
2088 CCryLobbyPacket ackPacket;
2089
2090 ackPacket.SetWriteBuffer(buffer, MaxBufferSize);
2091 ackPacket.StartWrite(eLobbyPT_Ack, false);
2092 ackPacket.WriteUINT8(pPacketHeader->counterOut);
2093
2094 Send(&ackPacket, addr, connectionID, NULL);
2095
2096 NetLog("[lobby] Send ack (counter=%u)", pPacketHeader->counterOut);
2097 }
2098 else
2099 {
2100 NetLog("[lobby] OnPacket reliable packet for non connected connection " PRFORMAT_LCINFO " size %u ignoring", PRARG_LCINFO(connectionID, addr), length);
2101
2102 processPacket = false;
2103
2104 // We don't have a valid connection for this reliable packet.
2105 // This will most likely happen if we have disconnected but the other end doesn't know and is trying to disconnect from us.
2106 // If this is one of the packet types that is kept and still sent after a disconnect send back an ack to stop the other end sending.
2107 uint32 dataPos = 0;
2108 bool sendAck = false;
2109
2110 while (GetNextPacketFromBuffer(pDecodedData, length, dataPos, &packet))
2111 {
2112 #if !defined(EXCLUDE_NORMAL_LOG)
2113 uint32 encodedPacketType = pDataHeader->lobbyPacketType;
2114 #endif
2115 DecodePacketDataHeader(&packet);
2116
2117 if (KeepPacketAfterDisconnect(pDataHeader->lobbyPacketType))
2118 {
2119 sendAck = true;
2120 NetLog(" Ignoring packet %u (%u) size %u Still needs ack", pDataHeader->lobbyPacketType, encodedPacketType, pDataHeader->dataSize);
2121 }
2122 else
2123 {
2124 NetLog(" Ignoring packet %u (%u) size %u Doesn't need ack", pDataHeader->lobbyPacketType, encodedPacketType, pDataHeader->dataSize);
2125 }
2126 }
2127
2128 if (sendAck)
2129 {
2130 const uint32 MaxBufferSize = CryLobbyPacketUnReliableHeaderSize + CryLobbyPacketUINT8Size;
2131 uint8 buffer[MaxBufferSize];
2132 CCryLobbyPacket ackPacket;
2133
2134 ackPacket.SetWriteBuffer(buffer, MaxBufferSize);
2135 ackPacket.StartWrite(eLobbyPT_Ack, false);
2136 ackPacket.WriteUINT8(pPacketHeader->counterOut);
2137
2138 Send(&ackPacket, addr, connectionID, NULL);
2139
2140 NetLog("[lobby] Send ack for non connected connection (counter=%u)", pPacketHeader->counterOut);
2141 }
2142 }
2143 }
2144
2145 if (processPacket)
2146 {
2147 if (packet.GetReliable())
2148 {
2149 uint32 dataPos = 0;
2150
2151 while (GetNextPacketFromBuffer(pDecodedData, length, dataPos, &packet))
2152 {
2153 #if !defined(EXCLUDE_NORMAL_LOG)
2154 uint32 encodedPacketType = pDataHeader->lobbyPacketType;
2155 #endif
2156 DecodePacketDataHeader(&packet);
2157 NetLog(" Process packet %d (%d) size %d", pDataHeader->lobbyPacketType, encodedPacketType, pDataHeader->dataSize);
2158 ProcessPacket(addr, connectionID, &packet);
2159 }
2160 }
2161 else
2162 {
2163 packet.ReadDataHeader();
2164 DecodePacketDataHeader(&packet);
2165 ProcessPacket(addr, connectionID, &packet);
2166 }
2167 }
2168 }
2169
2170 m_cachedPacketBuffer.Reset();
2171 #endif // USE_LOBBY_REMOTE_CONNECTIONS
2172 }
2173
2174 void CCryLobby::OnError(const TNetAddress& addr, ESocketError error)
2175 {
2176 #if USE_LOBBY_REMOTE_CONNECTIONS
2177 CryLobbyConnectionID c;
2178 CryLobbySendID sendID = CryLobbyInvalidSendID;
2179
2180 if (ConnectionFromAddress(&c, addr))
2181 {
2182 SConnection* connection = &m_connection[c];
2183
2184 while (!connection->dataQueue.Empty())
2185 {
2186 SConnection::SData& data = connection->dataQueue.Front();
2187
2188 sendID = CryLobbyCreateSendID(c, data.counter);
2189
2190 MemFree(data.data);
2191
2192 if (m_services[m_service])
2193 {
2194 m_services[m_service]->OnError(addr, error, sendID);
2195 }
2196
2197 SECURE_NET_LOG("[lobby] Socket error %d on connection " PRFORMAT_LCINFO " free send data counter %u", error, PRARG_LCINFO(c, connection->addr), data.counter);
2198
2199 connection->dataQueue.Pop();
2200 }
2201
2202 connection->state = eCLCS_NotConnected;
2203 }
2204 else
2205 {
2206 if (m_services[m_service])
2207 {
2208 m_services[m_service]->OnError(addr, error, sendID);
2209 }
2210 }
2211 #endif // USE_LOBBY_REMOTE_CONNECTIONS
2212 }
2213
2214 void CCryLobby::OnSendComplete(const TNetAddress& addr)
2215 {
2216 #if USE_LOBBY_REMOTE_CONNECTIONS
2217 CryLobbyConnectionID c;
2218 CryLobbySendID sendID = CryLobbyInvalidSendID;
2219
2220 if (ConnectionFromAddress(&c, addr))
2221 {
2222 SConnection* connection = &m_connection[c];
2223
2224 if (!connection->dataQueue.Empty())
2225 {
2226 SConnection::SData& data = connection->dataQueue.Front();
2227
2228 sendID = CryLobbyCreateSendID(c, data.counter);
2229
2230 SECURE_NET_LOG("[lobby] Send complete on connection " PRFORMAT_LCINFO " free send data counter %d", PRARG_LCINFO(c, connection->addr), data.counter);
2231 LogPacketsInBuffer((uint8*)MemGetPtr(data.data), data.dataSize);
2232
2233 MemFree(data.data);
2234
2235 connection->dataQueue.Pop();
2236 }
2237 }
2238
2239 if (m_services[m_service])
2240 {
2241 m_services[m_service]->OnSendComplete(addr, sendID);
2242 }
2243 #endif // USE_LOBBY_REMOTE_CONNECTIONS
2244 }
2245
2246 #if NETWORK_HOST_MIGRATION
2247 uint8 CCryLobby::GetActiveConnections(void)
2248 {
2249 uint8 count = 0;
2250
2251 for (uint32 index = 0; index < MAX_LOBBY_CONNECTIONS; ++index)
2252 {
2253 if (m_connection[index].used && (m_connection[index].state == eCLCS_Connected))
2254 {
2255 ++count;
2256 }
2257 }
2258
2259 return count;
2260 }
2261 #endif
2262
2263 void CCryLobby::RegisterEventInterest(ECryLobbySystemEvent eventOfInterest, CryLobbyEventCallback cb, void* pUserData)
2264 {
2265 SEventCBData newEvent;
2266
2267 newEvent.cb = cb;
2268 newEvent.pUserData = pUserData;
2269 newEvent.event = eventOfInterest;
2270
2271 m_callbacks.push_back(newEvent);
2272 }
2273
2274 void CCryLobby::UnregisterEventInterest(ECryLobbySystemEvent eventOfInterest, CryLobbyEventCallback cb, void* pUserData)
2275 {
2276 SEventCBData newEvent;
2277
2278 newEvent.cb = cb;
2279 newEvent.pUserData = pUserData;
2280 newEvent.event = eventOfInterest;
2281
2282 stl::find_and_erase(m_callbacks, newEvent);
2283 }
2284
2285 void CCryLobby::DispatchEvent(ECryLobbySystemEvent evnt, UCryLobbyEventData data)
2286 {
2287 EventCBList::iterator callbackItem;
2288
2289 for (callbackItem = m_callbacks.begin(); callbackItem != m_callbacks.end(); ++callbackItem)
2290 {
2291 if (callbackItem->event == evnt)
2292 {
2293 callbackItem->cb(data, callbackItem->pUserData);
2294 }
2295 }
2296 }
2297
2298 void CCryLobby::GetConfigurationInformation(SConfigurationParams* infos, uint32 infoCnt)
2299 {
2300 if (m_configCB)
2301 {
2302 m_configCB(GetLobbyServiceType(), infos, infoCnt);
2303 }
2304 }
2305
2306 ICryTCPServicePtr CCryLobbyService::GetTCPService(const char* pService)
2307 {
2308 #if USE_CRY_TCPSERVICE
2309 if (m_pTCPServiceFactory)
2310 {
2311 return m_pTCPServiceFactory->GetTCPService(pService);
2312 }
2313 #endif // USE_CRY_TCPSERVICE
2314 return NULL;
2315 }
2316
2317 ICryTCPServicePtr CCryLobbyService::GetTCPService(const char* pServer, uint16 port, const char* pUrlPrefix)
2318 {
2319 #if USE_CRY_TCPSERVICE
2320 if (m_pTCPServiceFactory)
2321 {
2322 return m_pTCPServiceFactory->GetTCPService(pServer, port, pUrlPrefix);
2323 }
2324 #endif // USE_CRY_TCPSERVICE
2325 return NULL;
2326 }
2327
2328 bool CCryLobbyService::GetFlag(ECryLobbyServiceFlag flag)
2329 {
2330 return (m_lobbyServiceFlags & flag) == flag;
2331 }
2332
2333 // Description:
2334 // Is the given flag true for the lobby service of the given type?
2335 // Arguments:
2336 // service - lobby service to be queried
2337 // flag - flag to be queried
2338 // Return:
2339 // True if the flag is true.
2340 bool CCryLobby::GetLobbyServiceFlag(ECryLobbyService service, ECryLobbyServiceFlag flag)
2341 {
2342 bool result = false;
2343
2344 if (m_services[service])
2345 {
2346 result = m_services[service]->GetFlag(flag);
2347 }
2348
2349 return result;
2350 }
2351
2352 CCryLobbyService::CCryLobbyService(CCryLobby* pLobby, ECryLobbyService service)
2353 : m_pLobby(pLobby)
2354 , m_service(service)
2355 #if USE_CRY_TCPSERVICE
2356 , m_pTCPServiceFactory(NULL)
2357 #endif // USE_CRY_TCPSERVICE
2358 {
2359 m_lobbyServiceFlags = eCLSF_AllowMultipleSessions | eCLSF_SupportHostMigration;
2360 ZeroMemory(&m_tasks, sizeof(m_tasks));
2361 }
2362
2363 CCryLobbyService::~CCryLobbyService()
2364 {
2365
2366 }
2367
2368 ECryLobbyError CCryLobbyService::Initialise(ECryLobbyServiceFeatures features, CryLobbyServiceCallback pCB)
2369 {
2370 if (features & eCLSO_Base)
2371 {
2372 LOBBY_AUTO_LOCK;
2373
2374 for (uint32 i = 0; i < MAX_LOBBY_TASKS; i++)
2375 {
2376 m_tasks[i].used = false;
2377 }
2378 }
2379
2380 return eCLE_Success;
2381 }
2382
2383 ECryLobbyError CCryLobbyService::Terminate(ECryLobbyServiceFeatures features, CryLobbyServiceCallback pCB)
2384 {
2385 if (features & eCLSO_Base)
2386 {
2387 LOBBY_AUTO_LOCK;
2388
2389 FROM_GAME_TO_LOBBY(&CCryLobbyService::FreeSocketNT, this);
2390 }
2391
2392 return eCLE_Success;
2393 }
2394
2395 void CCryLobbyService::CreateSocketNT(void)
2396 {
2397 m_pLobby->InternalSocketCreate(m_service);
2398 }
2399
2400 void CCryLobbyService::FreeSocketNT(void)
2401 {
2402 m_pLobby->InternalSocketFree(m_service);
2403 }
2404
2405 ECryLobbyError CCryLobbyService::StartTask(uint32 eTask, uint32 user, bool startRunning, CryLobbyServiceTaskID* pLSTaskID, CryLobbyTaskID* pLTaskID, void* pCb, void* pCbArg)
2406 {
2407 CryLobbyTaskID lobbyTaskID = m_pLobby->CreateTask();
2408
2409 if (lobbyTaskID != CryLobbyInvalidTaskID)
2410 {
2411 for (uint32 i = 0; i < MAX_LOBBY_TASKS; i++)
2412 {
2413 STask* pTask = GetTask(i);
2414
2415 if (!pTask->used)
2416 {
2417 pTask->user = user;
2418 pTask->lTaskID = lobbyTaskID;
2419 pTask->error = eCLE_Success;
2420 pTask->startedTask = eTask;
2421 pTask->pCB = pCb;
2422 pTask->pCBArg = pCbArg;
2423 pTask->used = true;
2424 pTask->running = startRunning;
2425
2426 if (pLSTaskID)
2427 {
2428 *pLSTaskID = i;
2429 }
2430
2431 if (pLTaskID)
2432 {
2433 *pLTaskID = lobbyTaskID;
2434 }
2435
2436 for (uint32 j = 0; j < MAX_LOBBY_TASK_DATAS; j++)
2437 {
2438 pTask->dataMem[j] = TMemInvalidHdl;
2439 pTask->dataNum[j] = 0;
2440 }
2441
2442 return eCLE_Success;
2443 }
2444 }
2445
2446 m_pLobby->ReleaseTask(lobbyTaskID);
2447 }
2448
2449 return eCLE_TooManyTasks;
2450 }
2451
2452 void CCryLobbyService::FreeTask(CryLobbyServiceTaskID lsTaskID)
2453 {
2454 STask* pTask = GetTask(lsTaskID);
2455
2456 m_pLobby->ReleaseTask(pTask->lTaskID);
2457
2458 for (uint32 i = 0; i < MAX_LOBBY_TASK_DATAS; i++)
2459 {
2460 if (pTask->dataMem[i] != TMemInvalidHdl)
2461 {
2462 m_pLobby->MemFree(pTask->dataMem[i]);
2463 pTask->dataMem[i] = TMemInvalidHdl;
2464 }
2465 }
2466
2467 pTask->used = false;
2468 }
2469
2470 void CCryLobbyService::CancelTask(CryLobbyTaskID lTaskID)
2471 {
2472 LOBBY_AUTO_LOCK;
2473
2474 CryLogAlways("[Lobby]Try cancel task %u", lTaskID);
2475
2476 if (lTaskID != CryLobbyInvalidTaskID)
2477 {
2478 for (uint32 i = 0; i < MAX_LOBBY_TASKS; i++)
2479 {
2480 STask* pTask = GetTask(i);
2481
2482 CRY_ASSERT_MESSAGE(pTask, "CCryLobby: Task base pointers not setup");
2483
2484 if (pTask->used && (pTask->lTaskID == lTaskID))
2485 {
2486 CryLogAlways("[Lobby] Task %u canceled", lTaskID);
2487 pTask->pCB = NULL;
2488 break;
2489 }
2490 }
2491 }
2492 }
2493
2494 void CCryLobbyService::UpdateTaskError(CryLobbyServiceTaskID lsTaskID, ECryLobbyError error)
2495 {
2496 STask* pTask = GetTask(lsTaskID);
2497
2498 if (pTask->error == eCLE_Success)
2499 {
2500 pTask->error = error;
2501 }
2502 }
2503
2504 void CCryLobbyService::StartTaskRunning(CryLobbyServiceTaskID lsTaskID)
2505 {
2506 LOBBY_AUTO_LOCK;
2507
2508 STask* pTask = GetTask(lsTaskID);
2509
2510 if (pTask->used)
2511 {
2512 pTask->running = true;
2513
2514 switch (pTask->startedTask)
2515 {
2516 case eT_GetUserPrivileges:
2517 StopTaskRunning(lsTaskID);
2518 break;
2519 }
2520 }
2521 }
2522
2523 void CCryLobbyService::StopTaskRunning(CryLobbyServiceTaskID lsTaskID)
2524 {
2525 STask* pTask = GetTask(lsTaskID);
2526
2527 if (pTask->used)
2528 {
2529 pTask->running = false;
2530
2531 TO_GAME_FROM_LOBBY(&CCryLobbyService::EndTask, this, lsTaskID);
2532 }
2533 }
2534
2535 void CCryLobbyService::EndTask(CryLobbyServiceTaskID lsTaskID)
2536 {
2537 LOBBY_AUTO_LOCK;
2538
2539 STask* pTask = GetTask(lsTaskID);
2540
2541 if (pTask->used)
2542 {
2543 if (pTask->pCB)
2544 {
2545 switch (pTask->startedTask)
2546 {
2547 case eT_GetUserPrivileges:
2548 if (!m_pLobby->GetInternalSocket(m_service))
2549 {
2550 UpdateTaskError(lsTaskID, eCLE_InternalError);
2551 }
2552
2553 ((CryLobbyPrivilegeCallback)pTask->pCB)(pTask->lTaskID, pTask->error, 0, pTask->pCBArg);
2554 break;
2555 }
2556 }
2557
2558 if (pTask->error != eCLE_Success)
2559 {
2560 NetLog("[Lobby] Lobby Service EndTask %u Result %d", pTask->startedTask, pTask->error);
2561 }
2562
2563 FreeTask(lsTaskID);
2564 }
2565 }
2566
2567 ECryLobbyError CCryLobbyService::GetUserPrivileges(uint32 user, CryLobbyTaskID* pTaskID, CryLobbyPrivilegeCallback pCB, void* pCBArg)
2568 {
2569 ECryLobbyError error;
2570 CryLobbyServiceTaskID tid;
2571
2572 LOBBY_AUTO_LOCK;
2573
2574 error = StartTask(eT_GetUserPrivileges, user, false, &tid, pTaskID, (void*)pCB, pCBArg);
2575
2576 if (error == eCLE_Success)
2577 {
2578 FROM_GAME_TO_LOBBY(&CCryLobbyService::StartTaskRunning, this, tid);
2579 }
2580
2581 return error;
2582 }
2583
2584 void CCryLobbyService::GetSocketPorts(uint16& connectPort, uint16& listenPort)
2585 {
2586 listenPort = CLobbyCVars::Get().lobbyDefaultPort;
2587 connectPort = CLobbyCVars::Get().lobbyDefaultPort;
2588 }
2589
2590 void CCryLobbyService::MakeAddrPCCompatible(TNetAddress& addr)
2591 {
2592 }
2593
2594 void CCryLobby::MakeAddrPCCompatible(TNetAddress& addr)
2595 {
2596 m_services[m_service]->MakeAddrPCCompatible(addr);
2597 }
2598
2599 void CCryLobby::MakeConnectionPCCompatible(CryLobbyConnectionID connectionID)
2600 {
2601 if (connectionID != CryLobbyInvalidConnectionID)
2602 {
2603 m_services[m_service]->MakeAddrPCCompatible(m_connection[connectionID].addr);
2604 }
2605 }
2606
2607 CCryLobby::SSocketService* CCryLobby::GetCorrectSocketServiceForAddr(const TNetAddress& addr)
2608 {
2609 return &m_socketServices[GetCorrectSocketServiceTypeForAddr(addr)];
2610 }
2611
2612 ECryLobbyService CCryLobby::GetCorrectSocketServiceTypeForAddr(const TNetAddress& addr)
2613 {
2614 const SIPv4Addr* pIPv4Addr = stl::get_if<SIPv4Addr>(&addr);
2615
2616 if (pIPv4Addr && (pIPv4Addr->lobbyService != eCLS_NumServices))
2617 {
2618 return ECryLobbyService(pIPv4Addr->lobbyService);
2619 }
2620
2621 return m_service;
2622 }
2623
2624 CCryLobby::SSocketService* CCryLobby::GetCorrectSocketService(ECryLobbyService serviceType)
2625 {
2626 //Note that there will always be a 2 sockets no matter which services are initialised
2627 return &m_socketServices[serviceType];
2628 }
2629
2630 uint16 CCryLobby::GetInternalSocketPort(ECryLobbyService service)
2631 {
2632 SSocketService* pSocketService = GetCorrectSocketService(service);
2633
2634 return pSocketService->m_socketListenPort;
2635 }
2636
2637 IDatagramSocketPtr CCryLobby::GetInternalSocket(ECryLobbyService service)
2638 {
2639 SSocketService* pSocketService = GetCorrectSocketService(service);
2640
2641 return pSocketService->m_socket;
2642 }
2643
2644 const SCryLobbyParameters& CCryLobby::GetLobbyParameters() const
2645 {
2646 return m_serviceParams[m_service];
2647 }
2648
2649 uint32 CCryLobby::TimeSincePacketInMS(CryLobbyConnectionID c) const
2650 {
2651 #if USE_LOBBY_REMOTE_CONNECTIONS
2652 if (c != CryLobbyInvalidConnectionID)
2653 {
2654 if (m_connection[c].used)
2655 {
2656 return m_connection[c].timeSinceRecv;
2657 }
2658 }
2659 #endif // USE_LOBBY_REMOTE_CONNECTIONS
2660
2661 return 0;
2662 }
2663
2664 void CCryLobby::ForceTimeoutConnection(CryLobbyConnectionID c)
2665 {
2666 #if USE_LOBBY_REMOTE_CONNECTIONS
2667 if (c != CryLobbyInvalidConnectionID)
2668 {
2669 if (m_connection[c].used)
2670 {
2671 m_connection[c].timeSinceRecv = LOBBY_FORCE_DISCONNECT_TIMER;
2672 }
2673 }
2674 #endif // USE_LOBBY_REMOTE_CONNECTIONS
2675 }
2676
2677 const TNetAddress* CCryLobby::GetNetAddress(CryLobbyConnectionID c) const
2678 {
2679 const TNetAddress* pAddress = NULL;
2680
2681 if ((c != CryLobbyInvalidConnectionID) && (c < MAX_LOBBY_CONNECTIONS))
2682 {
2683 if (m_connection[c].used)
2684 {
2685 pAddress = &(m_connection[c].addr);
2686 }
2687 }
2688
2689 return pAddress;
2690 }
2691
2692 ECryLobbyError CCryLobbyService::CreateTaskParamMem(CryLobbyServiceTaskID lsTaskID, uint32 param, const void* pParamData, size_t paramDataSize)
2693 {
2694 STask* pTask = &m_tasks[lsTaskID];
2695
2696 CRY_ASSERT_MESSAGE(pTask, "CCryLobbyService: Task base pointers not setup");
2697
2698 if (paramDataSize > 0)
2699 {
2700 pTask->dataMem[param] = m_pLobby->MemAlloc(paramDataSize);
2701 void* p = m_pLobby->MemGetPtr(pTask->dataMem[param]);
2702
2703 if (p)
2704 {
2705 if (pParamData)
2706 {
2707 memcpy(p, pParamData, paramDataSize);
2708 }
2709 }
2710 else
2711 {
2712 return eCLE_OutOfMemory;
2713 }
2714 }
2715
2716 return eCLE_Success;
2717 }
2718
2719 const uint8* CCryLobby::EncryptPacket(const uint8* buffer, uint32 length)
2720 {
2721 #if ENCRYPT_LOBBY_PACKETS
2722 if (gEnv->pNetwork)
2723 {
2724 m_tempEncryptionBuffer[0] = buffer[0];
2725
2726 gEnv->pNetwork->EncryptBuffer(m_cipher, m_tempEncryptionBuffer + 1, buffer + 1, length - 1);
2727
2728 return m_tempEncryptionBuffer;
2729 }
2730 else
2731 #endif
2732 {
2733 return buffer;
2734 }
2735 }
2736
2737 const uint8* CCryLobby::DecryptPacket(const uint8* buffer, uint32 length)
2738 {
2739 #if ENCRYPT_LOBBY_PACKETS
2740 if (gEnv->pNetwork)
2741 {
2742 m_tempDecryptionBuffer[0] = buffer[0];
2743
2744 gEnv->pNetwork->DecryptBuffer(m_cipher, m_tempDecryptionBuffer + 1, buffer + 1, length - 1);
2745
2746 return m_tempDecryptionBuffer;
2747 }
2748 else
2749 #endif
2750 {
2751 return buffer;
2752 }
2753 }
2754
2755 bool CCryLobby::DecodeAddress(const TNetAddress& address, uint32* pIP, uint16* pPort)
2756 {
2757 bool decoded = true;
2758
2759 const SIPv4Addr* pIPv4Addr = stl::get_if<SIPv4Addr>(&address);
2760 if (pIPv4Addr != NULL)
2761 {
2762 *pIP = pIPv4Addr->addr;
2763 *pPort = pIPv4Addr->port;
2764 }
2765 else
2766 {
2767 const TLocalNetAddress* pLocalAddr = stl::get_if<TLocalNetAddress>(&address);
2768 if (pLocalAddr != NULL)
2769 {
2770 *pIP = LOOPBACK_ADDRESS;
2771 *pPort = *pLocalAddr;
2772 }
2773 else
2774 {
2775 *pIP = *pPort = 0;
2776 decoded = false;
2777 }
2778 }
2779
2780 return decoded;
2781 }
2782
2783 void CCryLobby::DecodeAddress(uint32 ip, uint16 port, char* ipstring, bool ignorePort)
2784 {
2785 if (ignorePort)
2786 {
2787 sprintf(ipstring, "%u.%u.%u.%u", ((ip >> 24) & 0xff), ((ip >> 16) & 0xff), ((ip >> 8) & 0xff), (ip & 0xff));
2788 }
2789 else
2790 {
2791 sprintf(ipstring, "%u.%u.%u.%u:%u", ((ip >> 24) & 0xff), ((ip >> 16) & 0xff), ((ip >> 8) & 0xff), (ip & 0xff), port);
2792 }
2793 }
2794
2795 void CCryLobby::DecodeAddress(const TNetAddress& address, char* ipstring, bool ignorePort)
2796 {
2797 uint32 ip;
2798 uint16 port;
2799
2800 if (DecodeAddress(address, &ip, &port))
2801 {
2802 DecodeAddress(ip, port, ipstring, ignorePort);
2803 }
2804 else
2805 {
2806 sprintf(ipstring, "<UNKNOWN>");
2807 }
2808 }
2809
2810 bool CCryLobby::ConvertAddr(const TNetAddress& addrIn, CRYSOCKADDR_IN* pSockAddr)
2811 {
2812 if (gEnv->pNetwork)
2813 {
2814 return ((INetworkPrivate*)gEnv->pNetwork)->ConvertAddr(addrIn, pSockAddr);
2815 }
2816
2817 return false;
2818 }
2819
2820 bool CCryLobby::ConvertAddr(const TNetAddress& addrIn, CRYSOCKADDR* pSockAddr, int* addrLen)
2821 {
2822 if (gEnv->pNetwork)
2823 {
2824 return ((INetworkPrivate*)gEnv->pNetwork)->ConvertAddr(addrIn, pSockAddr, addrLen);
2825 }
2826
2827 return false;
2828 }
2829
2830 ISocketIOManager* CCryLobby::GetExternalSocketIOManager()
2831 {
2832 if (gEnv->pNetwork)
2833 {
2834 return &((INetworkPrivate*)gEnv->pNetwork)->GetExternalSocketIOManager();
2835 }
2836
2837 return NULL;
2838 }
2839
2840 ISocketIOManager* CCryLobby::GetInternalSocketIOManager()
2841 {
2842 if (gEnv->pNetwork)
2843 {
2844 return &((INetworkPrivate*)gEnv->pNetwork)->GetInternalSocketIOManager();
2845 }
2846
2847 return NULL;
2848 }
2849
2850 CNetAddressResolver* CCryLobby::GetResolver()
2851 {
2852 if (gEnv->pNetwork)
2853 {
2854 return ((INetworkPrivate*)gEnv->pNetwork)->GetResolver();
2855 }
2856
2857 return NULL;
2858 }
2859
2860 const CNetCVars* CCryLobby::GetNetCVars()
2861 {
2862 if (gEnv->pNetwork)
2863 {
2864 return &((INetworkPrivate*)gEnv->pNetwork)->GetCVars();
2865 }
2866
2867 return NULL;
2868 }
2869
2870 uint8 CCryLobby::GetLobbyPacketID()
2871 {
2872 if (gEnv->pNetwork)
2873 {
2874 return ((INetworkPrivate*)gEnv->pNetwork)->FrameIDToHeader(eH_CryLobby);
2875 }
2876
2877 return 0;
2878 }
2879
2880 #if NETWORK_HOST_MIGRATION
2881 THostMigrationEventListenerContainer* CCryLobby::GetHostMigrationListeners()
2882 {
2883 return &m_hostMigrationListeners;
2884 }
2885 #endif
2886
2887 void CCryLobby::AddHostMigrationEventListener(IHostMigrationEventListener* pListener, const char* pWho, uint32 priority)
2888 {
2889 #if NETWORK_HOST_MIGRATION
2890 for (THostMigrationEventListenerContainer::iterator it = m_hostMigrationListeners.begin(); it != m_hostMigrationListeners.end(); ++it)
2891 {
2892 if (it->second.m_pListener == pListener)
2893 {
2894 // The listener is already registered
2895 return;
2896 }
2897 }
2898
2899 SHostMigrationEventListenerInfo info(pListener, pWho);
2900 m_hostMigrationListeners.insert(std::pair<EListenerPriorityType, SHostMigrationEventListenerInfo>((EListenerPriorityType)priority, info));
2901 #endif
2902 }
2903
2904 void CCryLobby::RemoveHostMigrationEventListener(IHostMigrationEventListener* pListener)
2905 {
2906 #if NETWORK_HOST_MIGRATION
2907 for (THostMigrationEventListenerContainer::iterator it = m_hostMigrationListeners.begin(); it != m_hostMigrationListeners.end(); ++it)
2908 {
2909 if (it->second.m_pListener == pListener)
2910 {
2911 m_hostMigrationListeners.erase(it);
2912 return;
2913 }
2914 }
2915 #endif
2916 }
2917
2918 CCryLobby::CMemAllocator::CMemAllocator()
2919 {
2920 #ifdef USE_GLOBAL_BUCKET_ALLOCATOR
2921 m_bucketAllocator.EnableExpandCleanups(false);
2922 #endif
2923 m_pGeneralHeap = CryGetIMemoryManager()->CreateGeneralExpandingMemoryHeap(LOBBY_GENERAL_HEAP_SIZE, LOBBY_GENERAL_HEAP_SIZE, "CryLobby General");
2924 m_totalBucketAllocated = 0;
2925 m_totalGeneralHeapAllocated = 0;
2926 m_MaxBucketAllocated = 0;
2927 m_MaxGeneralHeapAllocated = 0;
2928 }
2929
2930 CCryLobby::CMemAllocator::~CMemAllocator()
2931 {
2932 PrintStats();
2933
2934 if (m_pGeneralHeap)
2935 {
2936 m_pGeneralHeap->Release();
2937 }
2938 }
2939
2940 TMemHdl CCryLobby::CMemAllocator::MemAlloc(size_t sz)
2941 {
2942 void* p = NULL;
2943
2944 if (sz <= m_bucketAllocator.MaxSize)
2945 {
2946 p = m_bucketAllocator.allocate(sz);
2947
2948 if (p == NULL)
2949 {
2950 CryFatalError("Lobby Allocation For %" PRISIZE_T " Failed - Suggest increasing the bucket allocator size!!!!", sz);
2951 }
2952
2953 m_totalBucketAllocated += m_bucketAllocator.getSize(p);
2954
2955 if (m_totalBucketAllocated > m_MaxBucketAllocated)
2956 {
2957 m_MaxBucketAllocated = m_totalBucketAllocated;
2958 }
2959 }
2960 else
2961 {
2962 p = m_pGeneralHeap->Malloc(sz, "Lobby");
2963
2964 if (p == NULL)
2965 {
2966 CryFatalError("Lobby Allocation For %" PRISIZE_T " Failed - Suggest increasing the general heap size!!!!", sz);
2967 }
2968
2969 m_totalGeneralHeapAllocated += m_pGeneralHeap->UsableSize(p);
2970
2971 if (m_totalGeneralHeapAllocated > m_MaxGeneralHeapAllocated)
2972 {
2973 m_MaxGeneralHeapAllocated = m_totalGeneralHeapAllocated;
2974 }
2975 }
2976
2977 return p;
2978 }
2979
2980 void CCryLobby::CMemAllocator::MemFree(TMemHdl h)
2981 {
2982 void* p = MemGetPtr(h);
2983
2984 if (m_bucketAllocator.IsInAddressRange(p))
2985 {
2986 m_totalBucketAllocated -= m_bucketAllocator.getSize(p);
2987 m_bucketAllocator.deallocate(p);
2988 }
2989 else
2990 {
2991 m_totalGeneralHeapAllocated -= m_pGeneralHeap->UsableSize(p);
2992 m_pGeneralHeap->Free(p);
2993 }
2994 }
2995
2996 void* CCryLobby::CMemAllocator::MemGetPtr(TMemHdl h)
2997 {
2998 return h;
2999 }
3000
3001 TMemHdl CCryLobby::CMemAllocator::MemGetHdl(void* ptr)
3002 {
3003 return ptr;
3004 }
3005
3006 void CCryLobby::CMemAllocator::PrintStats()
3007 {
3008 NetLog("CryLobby Memory Stats");
3009 NetLog("Current Bucket Allocated %" PRISIZE_T " Maximum Bucket Allocated %" PRISIZE_T, m_totalBucketAllocated, m_MaxBucketAllocated);
3010 NetLog("Current General Heap Allocated %" PRISIZE_T " Maximum General Heap Allocated %" PRISIZE_T, m_totalGeneralHeapAllocated, m_MaxGeneralHeapAllocated);
3011 }
CRYENGINE is a powerful real-time game development platform created by Crytek.