Code/CryPlugins/CryLobby/Module/DurangoLive/CryDurangoLiveMatchMaking.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "CryDurangoLiveLobby.h"
   5
   6 #if USE_DURANGOLIVE && USE_CRY_MATCHMAKING
   7         #using <windows.winmd>
   8         #using <platform.winmd>
   9         #using <Microsoft.Xbox.Services.winmd>
  10         #using <Microsoft.Xbox.GameChat.winmd>
  11
  12         #include <CryCore/TypeInfo_impl.h>
  13
  14         #include "CryDurangoLiveMatchMaking.h"
  15         #include "CryDurangoLiveLobbyPacket.h"
  16
  17         #include <CryCore/Platform/IPlatformOS.h>
  18
  19         #define TDM_SESSION_CREATE_SESSION_DATA     0
  20         #define TDM_SESSION_CREATE_USERDATA         1
  21         #define TDN_SESSION_CREATE_NUMUSERDATA      1
  22
  23         #define TDM_SESSION_UPDATE_USERDATA         0
  24         #define TDN_SESSION_UPDATE_NUMUSERDATA      0
  25
  26         #define TDM_SESSION_SEARCH_PARAM            0
  27         #define TDM_SESSION_SEARCH_PARAMDATA        1
  28         #define TDN_SESSION_SEARCH_PARAMNUMDATA     1
  29
  30         #define TDN_UPDATE_SLOTS_PUBLIC             0
  31         #define TDN_UPDATE_SLOTS_PRIVATE            1
  32
  33         #define TDM_SESSION_JOIN_CONNECTION_COUNTER 0
  34         #define CONNECTION_JOIN_SEND_INTERVAL       1000
  35         #define CONNECTION_JOIN_MAX_SEND_TIMES      30
  36
  37         #define GET_REMOTE_SDA_TIMEOUT              20000
  38
  39         #define SESSION_ID_ZERO                     0
  40
  41         #pragma warning(push)
  42         #pragma warning(disable:6011 6102 6246)
  43
  44 using namespace ABI::Windows::Foundation;
  45 using namespace ABI::Windows::Storage::Streams;
  46 using namespace Microsoft::WRL;
  47 using namespace ABI::Windows::Xbox::Networking;
  48 using namespace ABI::Windows::Xbox::System;
  49
  50 // XXX - ATG
  51         #include "DurangoChat\ChatIntegrationLayer.h"
  52
  53 static const GUID SERVICECONFIG_GUID =
  54 {
  55         0xe1039253, 0x2550, 0x49c7, { 0xb7, 0x85, 0x49, 0x34, 0xf0, 0x78, 0xc6, 0x85 }
  56 };
  57
  58 CCryDurangoLiveMatchMaking::CCryDurangoLiveMatchMaking(CCryLobby* pLobby, CCryLobbyService* pService, ECryLobbyService serviceType) : CCryMatchMaking(pLobby, pService, serviceType), m_user(nullptr)
  59 {
  60         m_AssociationIncoming.value = 0;
  61
  62         // Make the CCryMatchMaking base pointers point to our data so we can use the common code in CCryMatchMaking
  63         for (uint32 i = 0; i < MAX_MATCHMAKING_SESSIONS; i++)
  64         {
  65                 CCryMatchMaking::m_sessions[i] = &m_sessions[i];
  66                 CCryMatchMaking::m_sessions[i]->localConnection = &m_sessions[i].localConnection;
  67
  68                 for (uint32 j = 0; j < MAX_LOBBY_CONNECTIONS; j++)
  69                 {
  70                         CCryMatchMaking::m_sessions[i]->remoteConnection[j] = &m_sessions[i].remoteConnection[j];
  71                 }
  72         }
  73
  74         for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; i++)
  75         {
  76                 CCryMatchMaking::m_task[i] = &m_task[i];
  77         }
  78
  79 }
  80
  81 CryLobbySessionHandle CCryDurangoLiveMatchMaking::FindSessionFromID(GUID const& sessionID)
  82 {
  83         for (uint32 i = 0; i < MAX_MATCHMAKING_SESSIONS; i++)
  84         {
  85                 if (m_sessions[i].localFlags & CRYSESSION_LOCAL_FLAG_USED)
  86                 {
  87                         if (IsEqualGUID(m_sessions[i].sessionID, sessionID))
  88                         {
  89                                 return i;
  90                         }
  91                 }
  92         }
  93
  94         return CryLobbyInvalidSessionHandle;
  95 }
  96
  97 void CCryDurangoLiveMatchMaking::StartAsyncActionTask(CryMatchMakingTaskID mmTaskID, IAsyncAction* pAsyncAction)
  98 {
  99         STask* pTask = &m_task[mmTaskID];
 100
 101         pTask->asyncTaskState = STask::eATS_Pending;
 102
 103         StartConcurrencyTaskTask(mmTaskID, ABI::Concurrency::task_from_async(pAsyncAction));
 104 }
 105
 106 void CCryDurangoLiveMatchMaking::StartConcurrencyTaskTask(CryMatchMakingTaskID mmTaskID, concurrency::task<HRESULT> pConcTask)
 107 {
 108         STask* pTask = &m_task[mmTaskID];
 109
 110         pTask->asyncTaskState = STask::eATS_Pending;
 111
 112         concurrency::cancellation_token_source src;
 113         pConcTask.then([this, mmTaskID](HRESULT res)
 114         {
 115                 STask* pTask = &m_task[mmTaskID];
 116                 if (SUCCEEDED(res))
 117                 {
 118                   pTask->asyncTaskState = STask::eATS_Success;
 119                   return;
 120                 }
 121
 122                 pTask->asyncTaskState = STask::eATS_Failed;
 123                 UpdateTaskError(mmTaskID, CryDurangoLiveLobbyGetErrorFromDurangoLive(res));
 124         }, src.get_token(), concurrency::task_continuation_context::use_current());
 125 }
 126
 127 ECryLobbyError CCryDurangoLiveMatchMaking::StartTask(ETask etask, bool startRunning, CryMatchMakingTaskID* pMMTaskID, CryLobbyTaskID* pLTaskID, CryLobbySessionHandle h, void* pCB, void* pCBArg)
 128 {
 129         CryMatchMakingTaskID tmpMMTaskID;
 130         CryMatchMakingTaskID* pUseMMTaskID = pMMTaskID ? pMMTaskID : &tmpMMTaskID;
 131         ECryLobbyError error = CCryMatchMaking::StartTask(etask, startRunning, pUseMMTaskID, pLTaskID, h, pCB, pCBArg);
 132
 133         if (error == eCLE_Success)
 134         {
 135                 ResetTask(*pUseMMTaskID);
 136         }
 137
 138         return error;
 139 }
 140
 141 void CCryDurangoLiveMatchMaking::ResetTask(CryMatchMakingTaskID mmTaskID)
 142 {
 143 }
 144
 145 void CCryDurangoLiveMatchMaking::StartSubTask(ETask etask, CryMatchMakingTaskID mmTaskID)
 146 {
 147         CCryMatchMaking::StartSubTask(etask, mmTaskID);
 148 }
 149
 150 void CCryDurangoLiveMatchMaking::StartTaskRunning(CryMatchMakingTaskID mmTaskID)
 151 {
 152         LOBBY_AUTO_LOCK;
 153
 154         STask* pTask = &m_task[mmTaskID];
 155
 156         if (pTask->used)
 157         {
 158         #if ENABLE_CRYLOBBY_DEBUG_TESTS
 159                 ECryLobbyError error;
 160
 161                 if (!m_lobby->DebugOKToStartTaskRunning(pTask->lTaskID))
 162                 {
 163                         return;
 164                 }
 165
 166                 if (m_lobby->DebugGenerateError(pTask->lTaskID, error))
 167                 {
 168                         UpdateTaskError(mmTaskID, error);
 169                         StopTaskRunning(mmTaskID);
 170
 171                         if ((pTask->startedTask == eT_SessionCreate) || (pTask->startedTask == eT_SessionJoin))
 172                         {
 173                                 FreeSessionHandle(pTask->session);
 174                         }
 175
 176                         return;
 177                 }
 178         #endif
 179
 180                 pTask->running = true;
 181
 182                 switch (pTask->startedTask)
 183                 {
 184                 case eT_SessionRegisterUserData:
 185                 case eT_SessionMigrate:
 186                         StopTaskRunning(mmTaskID);
 187                         break;
 188
 189                 case eT_SessionGetUsers:
 190                         StartSessionGetUsers(mmTaskID);
 191                         break;
 192
 193                 case eT_SessionCreate:
 194                         StartSessionCreate(mmTaskID);
 195                         break;
 196
 197                 case eT_SessionUpdate:
 198                         StartSessionUpdate(mmTaskID);
 199                         break;
 200
 201                 case eT_SessionUpdateSlots:
 202                         StartSessionUpdateSlots(mmTaskID);
 203                         break;
 204
 205                 case eT_SessionStart:
 206                         StartSessionStart(mmTaskID);
 207                         break;
 208
 209                 case eT_SessionEnd:
 210                         StartSessionEnd(mmTaskID);
 211                         break;
 212
 213                 case eT_SessionDelete:
 214                         StartSessionDelete(mmTaskID);
 215                         break;
 216
 217                 case eT_SessionSearch:
 218                         StartSessionSearch(mmTaskID);
 219                         break;
 220
 221                 case eT_SessionJoin:
 222                         StartSessionJoin(mmTaskID);
 223                         break;
 224
 225         #if NETWORK_HOST_MIGRATION
 226                 case eT_SessionMigrateHostStart:
 227                         HostMigrationStartNT(mmTaskID);
 228                         break;
 229
 230                 case eT_SessionMigrateHostServer:
 231                         HostMigrationServerNT(mmTaskID);
 232                         break;
 233         #endif
 234
 235                 case eT_SessionSetLocalUserData:
 236                         StartSessionSetLocalUserData(mmTaskID);
 237                         break;
 238
 239                 case eT_SessionQuery:
 240                         StartSessionQuery(mmTaskID);
 241                         break;
 242                 }
 243         }
 244 }
 245
 246 void CCryDurangoLiveMatchMaking::EndTask(CryMatchMakingTaskID mmTaskID)
 247 {
 248         LOBBY_AUTO_LOCK;
 249
 250         STask* pTask = &m_task[mmTaskID];
 251
 252         if (pTask->used)
 253         {
 254         #if NETWORK_HOST_MIGRATION
 255                 if (pTask->startedTask & HOST_MIGRATION_TASK_ID_FLAG)
 256                 {
 257                         m_sessions[pTask->session].hostMigrationInfo.m_taskID = CryLobbyInvalidTaskID;
 258                 }
 259         #endif
 260
 261                 if (pTask->cb)
 262                 {
 263                         switch (pTask->startedTask)
 264                         {
 265                         case eT_SessionRegisterUserData:
 266                         case eT_SessionUpdate:
 267                         case eT_SessionUpdateSlots:
 268                         case eT_SessionStart:
 269                         case eT_SessionEnd:
 270                         case eT_SessionSetLocalUserData:
 271                         case eT_SessionDelete:
 272         #if NETWORK_HOST_MIGRATION
 273                         case eT_SessionMigrateHostStart:
 274         #endif
 275                                 ((CryMatchmakingCallback)pTask->cb)(pTask->lTaskID, pTask->error, pTask->cbArg);
 276                                 break;
 277
 278                         case eT_SessionGetUsers:
 279                                 EndSessionGetUsers(mmTaskID);
 280                                 break;
 281
 282                         case eT_SessionMigrate:                                                           // From the games point of view a migrate is the same as a create
 283                                 ((CryMatchmakingSessionCreateCallback)pTask->cb)(pTask->lTaskID, pTask->error, CreateGameSessionHandle(pTask->session, m_sessions[pTask->session].localConnection.uid), pTask->cbArg);
 284                                 break;
 285
 286                         case eT_SessionCreate:
 287                                 EndSessionCreate(mmTaskID);
 288                                 break;
 289
 290                         case eT_SessionSearch:
 291                                 EndSessionSearch(mmTaskID);
 292                                 break;
 293
 294                         case eT_SessionJoin:
 295                                 EndSessionJoin(mmTaskID);
 296                                 break;
 297
 298                         case eT_SessionQuery:
 299                                 EndSessionQuery(mmTaskID);
 300                                 break;
 301                         }
 302                 }
 303
 304                 if (pTask->error != eCLE_Success)
 305                 {
 306                         NetLog("[Lobby] EndTask %d (%d) error %d", pTask->startedTask, pTask->subTask, pTask->error);
 307                 }
 308
 309                 // Clear LIVE specific task state so that base class tasks can use this slot
 310                 ResetTask(mmTaskID);
 311
 312                 FreeTask(mmTaskID);
 313         }
 314 }
 315
 316 void CCryDurangoLiveMatchMaking::StopTaskRunning(CryMatchMakingTaskID mmTaskID)
 317 {
 318         STask* pTask = &m_task[mmTaskID];
 319
 320         if (pTask->used)
 321         {
 322                 pTask->running = false;
 323                 TO_GAME_FROM_LOBBY(&CCryDurangoLiveMatchMaking::EndTask, this, mmTaskID);
 324         }
 325 }
 326
 327 ECryLobbyError CCryDurangoLiveMatchMaking::CreateSessionHandle(CryLobbySessionHandle* pH, bool host, uint32 createFlags, int numUsers)
 328 {
 329         ECryLobbyError error = CCryMatchMaking::CreateSessionHandle(pH, host, createFlags, numUsers);
 330
 331         if (error == eCLE_Success)
 332         {
 333                 SSession* pSession = &m_sessions[*pH];
 334
 335                 pSession->localConnection.name[0] = 0;
 336                 memset(pSession->localConnection.userData, 0, CRYLOBBY_USER_DATA_SIZE_IN_BYTES);
 337                 memset(&pSession->sessionID, 0, sizeof(pSession->sessionID));
 338
 339                 if (!m_user)
 340                 {
 341                         return eCLE_UserNotSignedIn;
 342                 }
 343
 344                 pSession->localConnection.xuid = m_user->Xuid();
 345                 pSession->localConnection.uid.m_uid = static_cast<uint16>(m_user->Xuid());
 346         }
 347
 348         return error;
 349 }
 350
 351 void CCryDurangoLiveMatchMaking::CreateSecureDeviceAssociationHandler(ISecureDeviceAssociation* pSecureDeviceAssociation, CryLobbySessionHandle h, CryMatchMakingConnectionID id)
 352 {
 353         SSession* pSession = &m_sessions[h];
 354         SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
 355
 356         pConnection->pSecureDeviceAssociation = pSecureDeviceAssociation;
 357         if (!pConnection->pSecureDeviceAssociation)
 358         {
 359                 return;
 360         }
 361
 362         pConnection->state = SSession::SRConnection::eRCS_CreateAssociationSuccess;
 363
 364         SOCKADDR_STORAGE remoteSocketAddress;
 365         pConnection->pSecureDeviceAssociation->GetRemoteSocketAddressBytes(sizeof(remoteSocketAddress), reinterpret_cast<BYTE*>(&remoteSocketAddress));
 366
 367         TNetAddress addr = TNetAddress(SSockAddrStorageAddr(remoteSocketAddress));
 368         NetLog("[Lobby] Create Secure Device Association Handler from: " PRFORMAT_ADDR, PRARG_ADDR(addr));
 369
 370         CryLobbyConnectionID connectionID = m_lobby->FindConnection(addr);
 371
 372         if (connectionID == CryLobbyInvalidConnectionID)
 373         {
 374                 connectionID = m_lobby->CreateConnection(addr);
 375         }
 376
 377         if (connectionID != CryLobbyInvalidConnectionID)
 378         {
 379                 m_lobby->ConnectionAddRef(connectionID);
 380
 381                 pConnection->connectionID = connectionID;
 382         }
 383 }
 384
 385 void CCryDurangoLiveMatchMaking::StartCreateSecureDeviceAssociation(CryLobbySessionHandle h, CryMatchMakingConnectionID id)
 386 {
 387         SSession* pSession = &m_sessions[h];
 388         SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
 389
 390         ComPtr<IAsyncOperation<SecureDeviceAssociation*>> pCreateAssociationOperation;
 391         if (!m_pSecureDeviceAssociationTemplate)
 392         {
 393                 pConnection->state = SSession::SRConnection::eRCS_CreateAssociationFailed;
 394                 return;
 395         }
 396
 397         NetLog("[Lobby] StartCreateSecureDeviceAssociation creating association");
 398         m_pSecureDeviceAssociationTemplate->CreateAssociationAsync(pSession->remoteConnection[id].pSecureDeviceAddress.Get(), CreateSecureDeviceAssociationBehavior_Default, &pCreateAssociationOperation);
 399
 400         pConnection->state = SSession::SRConnection::eRCS_CreatingAssociation;
 401
 402         enum
 403         {
 404                 Result = 0,
 405                 Association
 406         };
 407
 408         ABI::Concurrency::task_from_async(pCreateAssociationOperation.Get()).then(
 409           [this, h, id](std::tuple<HRESULT, ComPtr<ISecureDeviceAssociation>> res)
 410         {
 411                 SSession* pSession = &m_sessions[h];
 412                 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
 413                 NetLog("[Lobby] StartCreateSecureDeviceAssociation create association result 0x%08x", std::get<Result>(res));
 414
 415                 if (FAILED(std::get<Result>(res)))
 416                 {
 417                   pConnection->state = SSession::SRConnection::eRCS_CreateAssociationFailed;
 418                   return;
 419                 }
 420                 CreateSecureDeviceAssociationHandler(std::get<Association>(res).Get(), h, id);
 421         });
 422 }
 423
 424 CryMatchMakingConnectionID CCryDurangoLiveMatchMaking::AddRemoteConnection(CryLobbySessionHandle h, ISecureDeviceAddress* pSecureDeviceAddress, ISecureDeviceAssociation* pSecureDeviceAssociation, Live::Xuid xuid)
 425 {
 426         SSession* pSession = &m_sessions[h];
 427
 428         SCryMatchMakingConnectionUID remoteUID;
 429         {
 430                 remoteUID.m_sid = GetSIDFromSessionHandle(h);
 431                 remoteUID.m_uid = static_cast<uint16>(xuid);
 432         }
 433
 434         CryMatchMakingConnectionID id = CCryMatchMaking::AddRemoteConnection(h, CryLobbyInvalidConnectionID, remoteUID, 1);
 435
 436         if (id != CryMatchMakingInvalidConnectionID)
 437         {
 438                 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
 439
 440                 pConnection->flags |= CMMRC_FLAG_PLATFORM_DATA_VALID;
 441                 pConnection->xuid = xuid;
 442
 443                 if (pSecureDeviceAssociation)
 444                 {
 445                         SOCKADDR_STORAGE remoteSocketAddress;
 446
 447                         pConnection->state = SSession::SRConnection::eRCS_CreateAssociationSuccess;
 448                         pSecureDeviceAssociation->get_RemoteSecureDeviceAddress(&pConnection->pSecureDeviceAddress);
 449                         pConnection->pSecureDeviceAssociation = pSecureDeviceAssociation;
 450                         pConnection->pSecureDeviceAssociation->GetRemoteSocketAddressBytes(sizeof(remoteSocketAddress), reinterpret_cast<BYTE*>(&remoteSocketAddress));
 451
 452                         TNetAddress addr = TNetAddress(SSockAddrStorageAddr(remoteSocketAddress));
 453                         NetLog("[Lobby] Adding Remote connection address: " PRFORMAT_ADDR, PRARG_ADDR(addr));
 454
 455                         CryLobbyConnectionID connectionID = m_lobby->FindConnection(addr);
 456
 457                         if (connectionID == CryLobbyInvalidConnectionID)
 458                         {
 459                                 connectionID = m_lobby->CreateConnection(addr);
 460                         }
 461
 462                         if (connectionID != CryLobbyInvalidConnectionID)
 463                         {
 464                                 m_lobby->ConnectionAddRef(connectionID);
 465
 466                                 pConnection->connectionID = connectionID;
 467
 468                                 return id;
 469                         }
 470                 }
 471                 else
 472                 {
 473                         if (pSecureDeviceAddress)
 474                         {
 475                                 pConnection->pSecureDeviceAddress = pSecureDeviceAddress;
 476
 477                                 return id;
 478                         }
 479                 }
 480         }
 481
 482         if (id != CryMatchMakingInvalidConnectionID)
 483         {
 484                 FreeRemoteConnection(h, id);
 485         }
 486
 487         return CryMatchMakingInvalidConnectionID;
 488 }
 489
 490 void CCryDurangoLiveMatchMaking::FreeRemoteConnection(CryLobbySessionHandle h, CryMatchMakingConnectionID id)
 491 {
 492         if (id != CryMatchMakingInvalidConnectionID)
 493         {
 494                 SSession* pSession = &m_sessions[h];
 495                 SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
 496
 497                 if (pConnection->used)
 498                 {
 499                         SessionUserDataEvent(eCLSE_SessionUserLeave, h, id);
 500
 501                         if (pConnection->pSecureDeviceAssociation)
 502                         {
 503                                 ComPtr<IAsyncAction> action;
 504                                 pConnection->pSecureDeviceAssociation->DestroyAsync(&action);
 505                         }
 506
 507                         pConnection->pSecureDeviceAddress = nullptr;
 508                         pConnection->pSecureDeviceAssociation = nullptr;
 509
 510                         pConnection->xuid = 0;
 511                         pConnection->name[0] = 0;
 512
 513                         CCryMatchMaking::FreeRemoteConnection(h, id);
 514                 }
 515         }
 516 }
 517
 518 concurrency::task<HRESULT> CCryDurangoLiveMatchMaking::FreeRemoteConnectionAsync(CryLobbySessionHandle h, CryMatchMakingConnectionID id)
 519 {
 520         if (id == CryMatchMakingInvalidConnectionID)
 521                 return concurrency::create_task([](){ return S_OK; });
 522
 523         SSession* pSession = &m_sessions[h];
 524         SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
 525
 526         if (!pConnection->used)
 527                 return concurrency::create_task([](){ return S_OK; });
 528
 529         // XXX - ATG
 530         GetChatIntegrationLayer()->RemoveRemoteConnection(h, id, pConnection->uid.m_uid);
 531
 532         SessionUserDataEvent(eCLSE_SessionUserLeave, h, id);
 533
 534         ComPtr<IAsyncAction> action;
 535         if (pConnection->pSecureDeviceAssociation)
 536         {
 537                 pConnection->pSecureDeviceAssociation->DestroyAsync(&action);
 538         }
 539
 540         pConnection->pSecureDeviceAddress = nullptr;
 541         pConnection->pSecureDeviceAssociation = nullptr;
 542
 543         pConnection->xuid = 0;
 544         pConnection->name[0] = 0;
 545
 546         CCryMatchMaking::FreeRemoteConnection(h, id);
 547         if (action.Get())
 548         {
 549                 return ABI::Concurrency::task_from_async(action);
 550         }
 551
 552         return concurrency::create_task([](){ return S_OK; });
 553 }
 554
 555 uint64 CCryDurangoLiveMatchMaking::GetSIDFromSessionHandle(CryLobbySessionHandle h)
 556 {
 557
 558         CRY_ASSERT_MESSAGE((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED), "CCryDurangoLiveMatchMaking::GetSIDFromSessionHandle: invalid session handle");
 559
 560         uint64 temp;
 561
 562         memcpy(&temp, &m_sessions[h].sessionID.Data4, sizeof(temp));
 563
 564         return temp;
 565
 566 }
 567
 568 void CCryDurangoLiveMatchMaking::Tick(CTimeValue tv)
 569 {
 570         CCryMatchMaking::Tick(tv);
 571
 572         for (uint32 i = 0; i < MAX_MATCHMAKING_TASKS; ++i)
 573         {
 574                 STask* pTask = &m_task[i];
 575
 576         #if ENABLE_CRYLOBBY_DEBUG_TESTS
 577                 if (pTask->used)
 578                 {
 579                         if (m_lobby->DebugTickCallStartTaskRunning(pTask->lTaskID))
 580                         {
 581                                 StartTaskRunning(i);
 582                                 continue;
 583                         }
 584                         if (!m_lobby->DebugOKToTickTask(pTask->lTaskID, pTask->running))
 585                         {
 586                                 continue;
 587                         }
 588                 }
 589         #endif
 590
 591                 if (pTask->used)
 592                 {
 593                         if (pTask->running)
 594                         {
 595                                 switch (pTask->subTask)
 596                                 {
 597                                 case eT_SessionCreate:
 598                                         TickSessionCreate(i);
 599                                         break;
 600
 601                                 case eT_SessionUpdate:
 602                                         TickSessionUpdate(i);
 603                                         break;
 604
 605                                 case eT_SessionUpdateSlots:
 606                                         TickSessionUpdateSlots(i);
 607                                         break;
 608
 609                                 case eT_SessionStart:
 610                                         TickSessionStart(i);
 611                                         break;
 612
 613                                 case eT_SessionEnd:
 614                                         TickSessionEnd(i);
 615                                         break;
 616
 617                                 case eT_SessionDelete:
 618                                         TickSessionDelete(i);
 619                                         break;
 620
 621                                 case eT_SessionSearch:
 622                                         TickSessionSearch(i);
 623                                         break;
 624
 625                                 case eT_SessionJoin:
 626                                         TickSessionJoin(i);
 627                                         break;
 628
 629                                 case eT_SessionJoinCreateAssociation:
 630                                         TickSessionJoinCreateAssociation(i);
 631                                         break;
 632
 633                                 case eT_SessionRequestJoin:
 634                                         TickSessionRequestJoin(i);
 635                                         break;
 636
 637         #if NETWORK_HOST_MIGRATION
 638                                 case eT_SessionMigrateHostStart:
 639                                         TickHostMigrationStartNT(i);
 640                                         break;
 641
 642                                 case eT_SessionMigrateHostServer:
 643                                         TickHostMigrationServerNT(i);
 644                                         break;
 645         #endif
 646                                 default:
 647                                         TickBaseTask(i);
 648                                         break;
 649                                 }
 650                         }
 651                 }
 652         }
 653
 654         for (uint32 i = 0; i < MAX_MATCHMAKING_SESSIONS; i++)
 655         {
 656                 SSession* session = &m_sessions[i];
 657
 658                 if (session->localFlags & CRYSESSION_LOCAL_FLAG_USED)
 659                 {
 660                         // Check what Live thinks the status of our connections is
 661                         for (uint32 j = 0; j < MAX_LOBBY_CONNECTIONS; j++)
 662                         {
 663                                 SSession::SRConnection* pConnection = &session->remoteConnection[j];
 664
 665                                 if (pConnection->used)
 666                                 {
 667                                         if (m_lobby->ConnectionGetState(pConnection->connectionID) != eCLCS_NotConnected)
 668                                         {
 669                                                 SecureDeviceAssociationState state = SecureDeviceAssociationState_Invalid;
 670                                                 pConnection->pSecureDeviceAssociation->get_State(&state);
 671                                                 if ((state == SecureDeviceAssociationState_DestroyingLocal) ||
 672                                                     (state == SecureDeviceAssociationState_DestroyingRemote) ||
 673                                                     (state == SecureDeviceAssociationState_Destroyed))
 674                                                 {
 675                                                         m_lobby->ConnectionSetState(pConnection->connectionID, eCLCS_NotConnected);
 676                                                 }
 677                                         }
 678                                 }
 679                         }
 680                 }
 681         }
 682
 683         if (CLobbyCVars::Get().p2pShowConnectionStatus)
 684         {
 685                 LogConnectionStatus();
 686         }
 687 }
 688
 689 void CCryDurangoLiveMatchMaking::LogConnectionStatus()
 690 {
 691         static float white[] = { 1.0f, 1.0f, 1.0f, 1.0f };
 692         float xpos = 50;
 693         CryFixedStringT<128> buffer;
 694
 695         for (uint32 sessionIndex = 0; sessionIndex < MAX_MATCHMAKING_SESSIONS; ++sessionIndex)
 696         {
 697                 SSession* pSession = &m_sessions[sessionIndex];
 698                 float ypos = 50;
 699
 700                 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_USED)
 701                 {
 702                         for (uint32 connectionIndex = 0; connectionIndex < MAX_LOBBY_CONNECTIONS; connectionIndex++)
 703                         {
 704                                 SSession::SRConnection* pConnection = &pSession->remoteConnection[connectionIndex];
 705
 706                                 if (pConnection->used)
 707                                 {
 708                                         SecureDeviceAssociationState state = SecureDeviceAssociationState_Invalid;
 709                                         pConnection->pSecureDeviceAssociation->get_State(&state);
 710                                         switch (state)
 711                                         {
 712                                         case SecureDeviceAssociationState_Invalid:
 713                                                 buffer.Format(PRFORMAT_UID " : Invalid", PRARG_UID(pConnection->uid));
 714                                                 break;
 715
 716                                         case SecureDeviceAssociationState_CreatingOutbound:
 717                                                 buffer.Format(PRFORMAT_UID " : CreatingOutbound", PRARG_UID(pConnection->uid));
 718                                                 break;
 719
 720                                         case SecureDeviceAssociationState_CreatingInbound:
 721                                                 buffer.Format(PRFORMAT_UID " : CreatingInbound", PRARG_UID(pConnection->uid));
 722                                                 break;
 723
 724                                         case SecureDeviceAssociationState_Ready:
 725                                                 buffer.Format(PRFORMAT_UID " : Ready", PRARG_UID(pConnection->uid));
 726                                                 break;
 727
 728                                         case SecureDeviceAssociationState_DestroyingLocal:
 729                                                 buffer.Format(PRFORMAT_UID " : DestroyingLocal", PRARG_UID(pConnection->uid));
 730                                                 break;
 731
 732                                         case SecureDeviceAssociationState_DestroyingRemote:
 733                                                 buffer.Format(PRFORMAT_UID " : DestroyingRemote", PRARG_UID(pConnection->uid));
 734                                                 break;
 735
 736                                         case SecureDeviceAssociationState_Destroyed:
 737                                                 buffer.Format(PRFORMAT_UID " : Destroyed", PRARG_UID(pConnection->uid));
 738                                                 break;
 739                                         }
 740
 741                                         if (gEnv->pRenderer)
 742                                         {
 743                                                 gEnv->pRenderer->Draw2dLabel(xpos, ypos, 1.25f, white, false, buffer.c_str());
 744                                         }
 745
 746                                         ypos += 20.0f;
 747                                 }
 748                         }
 749                 }
 750
 751                 xpos += 250.0f;
 752         }
 753 }
 754
 755 ECryLobbyError CCryDurangoLiveMatchMaking::Initialise()
 756 {
 757         ECryLobbyError error = CCryMatchMaking::Initialise();
 758
 759         if (error == eCLE_Success)
 760         {
 761                 m_registeredUserData.num = 0;
 762
 763                 HRESULT hr = Interface::Statics<ISecureDeviceAssociationTemplate>()->GetTemplateByName(Microsoft::WRL::Wrappers::HStringReference(L"PeerTraffic").Get(), &m_pSecureDeviceAssociationTemplate);
 764
 765                 // XXX - ATG
 766                 error = GetChatIntegrationLayer()->Initialize(true, this);
 767         }
 768
 769         return error;
 770 }
 771
 772 ECryLobbyError CCryDurangoLiveMatchMaking::Terminate()
 773 {
 774         // XXX - ATG
 775         ShutdownChatIntegrationLayer();
 776
 777         ECryLobbyError error = CCryMatchMaking::Terminate();
 778
 779         return error;
 780 }
 781
 782 ECryLobbyError CCryDurangoLiveMatchMaking::SetINetworkingUser(Live::State::INetworkingUser* user)
 783 {
 784         m_user = user;
 785
 786         if (user == nullptr)
 787         {
 788                 return eCLE_InvalidParam;
 789         }
 790
 791         return eCLE_Success;
 792 }
 793
 794 ECryLobbyError CCryDurangoLiveMatchMaking::SessionRegisterUserData(SCrySessionUserData* pData, uint32 numData, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
 795 {
 796         ECryLobbyError error = eCLE_Success;
 797
 798         LOBBY_AUTO_LOCK;
 799
 800         if (numData < MAX_MATCHMAKING_SESSION_USER_DATA)
 801         {
 802                 CryMatchMakingTaskID mmTaskID;
 803
 804                 error = StartTask(eT_SessionRegisterUserData, false, &mmTaskID, pTaskID, CryLobbyInvalidSessionHandle, pCB, pCBArg);
 805
 806                 if (error == eCLE_Success)
 807                 {
 808                         memcpy(m_registeredUserData.data, pData, numData * sizeof(pData[0]));
 809                         m_registeredUserData.num = numData;
 810
 811                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
 812                 }
 813         }
 814         else
 815         {
 816                 error = eCLE_OutOfSessionUserData;
 817         }
 818
 819         NetLog("[Lobby] Start SessionRegisterUserData error %d", error);
 820
 821         return error;
 822 }
 823
 824 ECryLobbyError CCryDurangoLiveMatchMaking::SessionMigrate(CrySessionHandle gh, uint32* pUsers, int numUsers, uint32 flags, SCrySessionData* pData, CryLobbyTaskID* pTaskID, CryMatchmakingSessionCreateCallback pCB, void* pCBArg)
 825 {
 826         ECryLobbyError error = eCLE_Success;
 827
 828         LOBBY_AUTO_LOCK;
 829
 830         // Because we simply want to re-use the session that is already available, we don't need to do much here
 831
 832         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
 833
 834         if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
 835         {
 836                 SSession* pSession = &m_sessions[h];
 837                 CryMatchMakingTaskID mmTaskID;
 838
 839                 error = StartTask(eT_SessionMigrate, false, &mmTaskID, pTaskID, h, (void*)pCB, pCBArg);
 840
 841                 if (error == eCLE_Success)
 842                 {
 843                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
 844                 }
 845         }
 846         else
 847         {
 848                 error = eCLE_InvalidSession;
 849         }
 850
 851         NetLog("[Lobby] Start SessionMigrate error %d", error);
 852
 853         return error;
 854 }
 855
 856 ECryLobbyError CCryDurangoLiveMatchMaking::SessionQuery(CrySessionHandle gh, CryLobbyTaskID* pTaskID, CryMatchmakingSessionQueryCallback pCB, void* pCBArg)
 857 {
 858         LOBBY_AUTO_LOCK;
 859
 860         ECryLobbyError error = eCLE_Success;
 861
 862         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
 863
 864         if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
 865         {
 866                 SSession* pSession = &m_sessions[h];
 867                 CryMatchMakingTaskID mmTaskID;
 868
 869                 error = StartTask(eT_SessionQuery, false, &mmTaskID, pTaskID, h, (void*)pCB, pCBArg);
 870
 871                 if (error == eCLE_Success)
 872                 {
 873                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
 874                 }
 875         }
 876         else
 877         {
 878                 error = eCLE_InvalidSession;
 879         }
 880
 881         NetLog("[Lobby] Start SessionQuery error %d", error);
 882
 883         return error;
 884 }
 885
 886 void CCryDurangoLiveMatchMaking::StartSessionQuery(CryMatchMakingTaskID mmTaskID)
 887 {
 888         StopTaskRunning(mmTaskID);
 889 }
 890
 891 void CCryDurangoLiveMatchMaking::EndSessionQuery(CryMatchMakingTaskID mmTaskID)
 892 {
 893         STask* pTask = &m_task[mmTaskID];
 894
 895         ((CryMatchmakingSessionQueryCallback)pTask->cb)(pTask->lTaskID, pTask->error, NULL, pTask->cbArg);
 896 }
 897
 898 ECryLobbyError CCryDurangoLiveMatchMaking::SessionGetUsers(CrySessionHandle gh, CryLobbyTaskID* pTaskID, CryMatchmakingSessionGetUsersCallback pCB, void* pCBArg)
 899 {
 900         ECryLobbyError error = eCLE_Success;
 901
 902         LOBBY_AUTO_LOCK;
 903
 904         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
 905
 906         if ((h < MAX_MATCHMAKING_SESSIONS) && m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED)
 907         {
 908                 SSession* pSession = &m_sessions[h];
 909                 CryMatchMakingTaskID tid;
 910
 911                 error = StartTask(eT_SessionGetUsers, false, &tid, pTaskID, h, pCB, pCBArg);
 912
 913                 if (error == eCLE_Success)
 914                 {
 915                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, tid);
 916                 }
 917         }
 918         else
 919         {
 920                 error = eCLE_InvalidSession;
 921         }
 922
 923         if (error != eCLE_Success)
 924         {
 925                 NetLog("[Lobby] Start SessionGetUsers error %d", error);
 926         }
 927
 928         return error;
 929 }
 930
 931 void CCryDurangoLiveMatchMaking::StartSessionGetUsers(CryMatchMakingTaskID mmTaskID)
 932 {
 933 }
 934
 935 void CCryDurangoLiveMatchMaking::EndSessionGetUsers(CryMatchMakingTaskID mmTaskID)
 936 {
 937         STask* pTask = &m_task[mmTaskID];
 938
 939         if (pTask->error == eCLE_Success)
 940         {
 941                 SCryUserInfoResult temp;
 942                 int a;
 943
 944                 // Glue in local user
 945                 SCryDurangoLiveUserID* pID = new SCryDurangoLiveUserID(m_sessions[pTask->session].localConnection.xuid);
 946
 947                 if (pID)
 948                 {
 949                         temp.m_userID = pID;
 950                         temp.m_conID = m_sessions[pTask->session].localConnection.uid;
 951                         temp.m_isDedicated = false;           // Live does not support dedicated servers
 952                         cry_strcpy(temp.m_userName, m_sessions[pTask->session].localConnection.name);
 953                         memcpy(temp.m_userData, m_sessions[pTask->session].localConnection.userData, CRYLOBBY_USER_DATA_SIZE_IN_BYTES);
 954                         ((CryMatchmakingSessionGetUsersCallback)pTask->cb)(pTask->lTaskID, eCLE_SuccessContinue, &temp, pTask->cbArg);
 955                 }
 956                 else
 957                 {
 958                         UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
 959                 }
 960
 961                 for (a = 0; (a < MAX_LOBBY_CONNECTIONS) && (pTask->error == eCLE_Success); a++)
 962                 {
 963                         if (m_sessions[pTask->session].remoteConnection[a].used)
 964                         {
 965                                 pID = new SCryDurangoLiveUserID(m_sessions[pTask->session].remoteConnection[a].xuid);
 966
 967                                 if (pID)
 968                                 {
 969                                         temp.m_userID = pID;
 970                                         temp.m_conID = m_sessions[pTask->session].remoteConnection[a].uid;
 971                                         cry_strcpy(temp.m_userName, m_sessions[pTask->session].remoteConnection[a].name);
 972                                         memcpy(temp.m_userData, m_sessions[pTask->session].remoteConnection[a].userData, CRYLOBBY_USER_DATA_SIZE_IN_BYTES);
 973                                         ((CryMatchmakingSessionGetUsersCallback)pTask->cb)(pTask->lTaskID, eCLE_SuccessContinue, &temp, pTask->cbArg);
 974                                 }
 975                                 else
 976                                 {
 977                                         UpdateTaskError(mmTaskID, eCLE_OutOfMemory);
 978                                 }
 979                         }
 980                 }
 981         }
 982
 983         ((CryMatchmakingSessionGetUsersCallback)pTask->cb)(pTask->lTaskID, pTask->error, NULL, pTask->cbArg);
 984 }
 985
 986 ECryLobbyError CCryDurangoLiveMatchMaking::SessionSetLocalUserData(CrySessionHandle gh, CryLobbyTaskID* pTaskID, uint32 user, uint8* pData, uint32 dataSize, CryMatchmakingCallback pCB, void* pCBArg)
 987 {
 988         ECryLobbyError error = eCLE_Success;
 989
 990         LOBBY_AUTO_LOCK;
 991
 992         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
 993
 994         if ((h < MAX_MATCHMAKING_SESSIONS) && m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED)
 995         {
 996                 if (dataSize <= CRYLOBBY_USER_DATA_SIZE_IN_BYTES)
 997                 {
 998                         SSession* pSession = &m_sessions[h];
 999                         SSession::SLConnection* pLConnection = &pSession->localConnection;
1000                         CryMatchMakingTaskID mmTaskID;
1001
1002                         memcpy(pLConnection->userData, pData, dataSize);
1003
1004                         error = StartTask(eT_SessionSetLocalUserData, false, &mmTaskID, pTaskID, h, (void*)pCB, pCBArg);
1005
1006                         if (error == eCLE_Success)
1007                         {
1008                                 FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1009                         }
1010                 }
1011                 else
1012                 {
1013                         error = eCLE_OutOfUserData;
1014                 }
1015         }
1016         else
1017         {
1018                 error = eCLE_InvalidSession;
1019         }
1020
1021         return error;
1022 }
1023
1024 void CCryDurangoLiveMatchMaking::StartSessionSetLocalUserData(CryMatchMakingTaskID mmTaskID)
1025 {
1026         StopTaskRunning(mmTaskID);
1027 }
1028
1029 ECryLobbyError CCryDurangoLiveMatchMaking::SessionCreate(uint32* pUsers, int numUsers, uint32 flags, SCrySessionData* pData, CryLobbyTaskID* pTaskID, CryMatchmakingSessionCreateCallback pCB, void* pCBArg)
1030 {
1031         LOBBY_AUTO_LOCK;
1032
1033         CryLobbySessionHandle h;
1034         ECryLobbyError error = CreateSessionHandle(&h, true, flags, numUsers);
1035
1036         if (error == eCLE_Success)
1037         {
1038                 CryMatchMakingTaskID mmTaskID;
1039
1040                 error = StartTask(eT_SessionCreate, false, &mmTaskID, pTaskID, h, pCB, pCBArg);
1041
1042                 if (error == eCLE_Success)
1043                 {
1044                         STask* pTask = &m_task[mmTaskID];
1045
1046                         error = CreateTaskParamMem(mmTaskID, TDM_SESSION_CREATE_SESSION_DATA, pData, sizeof(SCrySessionData));
1047
1048                         if (error == eCLE_Success)
1049                         {
1050                                 error = CreateTaskParamMem(mmTaskID, TDM_SESSION_CREATE_USERDATA, pData->m_data, pData->m_numData * sizeof(pData->m_data[0]));
1051
1052                                 if (error == eCLE_Success)
1053                                 {
1054                                         pTask->numParams[TDN_SESSION_CREATE_NUMUSERDATA] = pData->m_numData;
1055                                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1056                                 }
1057                         }
1058
1059                         if (error != eCLE_Success)
1060                         {
1061                                 FreeTask(mmTaskID);
1062                                 FreeSessionHandle(h);
1063                         }
1064                 }
1065                 else
1066                 {
1067                         FreeSessionHandle(h);
1068                 }
1069         }
1070
1071         NetLog("[Lobby] Start SessionCreate error %d", error);
1072
1073         return error;
1074 }
1075
1076 // ~^~^~TODO: We should set up the Incoming SDA listener here.
1077 void CCryDurangoLiveMatchMaking::StartSessionCreate(CryMatchMakingTaskID mmTaskID)
1078 {
1079 }
1080
1081 void CCryDurangoLiveMatchMaking::TickSessionCreate(CryMatchMakingTaskID mmTaskID)
1082 {
1083         using namespace ABI::Microsoft::Xbox::Services::Matchmaking;
1084         STask* pTask = &m_task[mmTaskID];
1085
1086         // If we don't have an async running... {
1087         // If we have not looked in 5 seconds:
1088         if (m_user)
1089         {
1090                 Live::Xuid xuids;
1091                 HRESULT hr = m_user->GetRemoteXuids(1, &xuids, nullptr);
1092
1093                 SSession* pSession = &m_sessions[pTask->session];
1094
1095                 pSession->sessionID = m_user->GetSessionName();
1096
1097                 pSession->localConnection.uid.m_sid = GetSIDFromSessionHandle(pTask->session);
1098                 pSession->localConnection.uid.m_uid = static_cast<uint16>(m_user->Xuid());
1099
1100                 if (m_AssociationIncoming.value == 0)
1101                 {
1102                         m_pSecureDeviceAssociationTemplate->add_AssociationIncoming(Callback<ITypedEventHandler<SecureDeviceAssociationTemplate*, SecureDeviceAssociationIncomingEventArgs*>>(
1103                                                                                       [](ISecureDeviceAssociationTemplate* sender, ISecureDeviceAssociationIncomingEventArgs* args) -> HRESULT
1104                         {
1105                                 UNREFERENCED_PARAMETER(sender);
1106
1107                                 ComPtr<ISecureDeviceAssociation> SDAssoc;
1108                                 args->get_Association(&SDAssoc);
1109
1110                                 SOCKADDR_STORAGE remoteSocketAddress;
1111                                 SDAssoc->GetRemoteSocketAddressBytes(sizeof(remoteSocketAddress), reinterpret_cast<BYTE*>(&remoteSocketAddress));
1112                                 TNetAddress addr = TNetAddress(SSockAddrStorageAddr(remoteSocketAddress));
1113
1114                                 NetLog("[Lobby] Incoming Secure Device Association from: " PRFORMAT_ADDR, PRARG_ADDR(addr));
1115
1116                                 return S_OK;
1117                         }).Get(), &m_AssociationIncoming);
1118                 }
1119
1120                 StopTaskRunning(mmTaskID);
1121         }
1122 }
1123
1124 void CCryDurangoLiveMatchMaking::EndSessionCreate(CryMatchMakingTaskID mmTaskID)
1125 {
1126         STask* pTask = &m_task[mmTaskID];
1127
1128         ((CryMatchmakingSessionCreateCallback)pTask->cb)(pTask->lTaskID, pTask->error, CreateGameSessionHandle(pTask->session, m_sessions[pTask->session].localConnection.uid), pTask->cbArg);
1129
1130         if (pTask->error == eCLE_Success)
1131         {
1132                 InitialUserDataEvent(pTask->session);
1133         }
1134 }
1135
1136 ECryLobbyError CCryDurangoLiveMatchMaking::SessionUpdate(CrySessionHandle gh, SCrySessionUserData* pData, uint32 numData, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
1137 {
1138         ECryLobbyError error = eCLE_Success;
1139
1140         LOBBY_AUTO_LOCK;
1141
1142         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
1143
1144         if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
1145         {
1146                 SSession* pSession = &m_sessions[h];
1147
1148                 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_HOST)
1149                 {
1150                         CryMatchMakingTaskID mmTaskID;
1151
1152                         error = StartTask(eT_SessionUpdate, false, &mmTaskID, pTaskID, h, pCB, pCBArg);
1153
1154                         if (error == eCLE_Success)
1155                         {
1156                                 STask* pTask = &m_task[mmTaskID];
1157
1158                                 error = CreateTaskParamMem(mmTaskID, TDM_SESSION_UPDATE_USERDATA, pData, numData * sizeof(pData[0]));
1159
1160                                 if (error == eCLE_Success)
1161                                 {
1162                                         pTask->numParams[TDN_SESSION_UPDATE_NUMUSERDATA] = numData;
1163                                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1164                                 }
1165                                 else
1166                                 {
1167                                         FreeTask(mmTaskID);
1168                                 }
1169                         }
1170                 }
1171                 else
1172                 {
1173                         error = eCLE_InvalidRequest;
1174                 }
1175         }
1176         else
1177         {
1178                 error = eCLE_InvalidSession;
1179         }
1180
1181         NetLog("[Lobby] Start SessionUpdate error %d", error);
1182
1183         return error;
1184 }
1185
1186 void CCryDurangoLiveMatchMaking::StartSessionUpdate(CryMatchMakingTaskID mmTaskID)
1187 {
1188 }
1189
1190 void CCryDurangoLiveMatchMaking::TickSessionUpdate(CryMatchMakingTaskID mmTaskID)
1191 {
1192         StopTaskRunning(mmTaskID);
1193 }
1194
1195 ECryLobbyError CCryDurangoLiveMatchMaking::SessionUpdateSlots(CrySessionHandle gh, uint32 numPublic, uint32 numPrivate, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
1196 {
1197         ECryLobbyError error = eCLE_Success;
1198
1199         LOBBY_AUTO_LOCK;
1200
1201         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
1202
1203         if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
1204         {
1205                 SSession* pSession = &m_sessions[h];
1206                 CryMatchMakingTaskID mmTaskID;
1207
1208                 error = StartTask(eT_SessionUpdateSlots, false, &mmTaskID, pTaskID, h, pCB, pCBArg);
1209
1210                 if (error == eCLE_Success)
1211                 {
1212                         STask* pTask = &m_task[mmTaskID];
1213
1214                         pTask->numParams[TDN_UPDATE_SLOTS_PUBLIC] = numPublic;
1215                         pTask->numParams[TDN_UPDATE_SLOTS_PRIVATE] = numPrivate;
1216
1217                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1218                 }
1219         }
1220         else
1221         {
1222                 error = eCLE_InvalidSession;
1223         }
1224
1225         NetLog("[Lobby] Start SessionUpdateSlots return %d", error);
1226
1227         return error;
1228 }
1229
1230 void CCryDurangoLiveMatchMaking::StartSessionUpdateSlots(CryMatchMakingTaskID mmTaskID)
1231 {
1232 }
1233
1234 void CCryDurangoLiveMatchMaking::TickSessionUpdateSlots(CryMatchMakingTaskID mmTaskID)
1235 {
1236         StopTaskRunning(mmTaskID);
1237 }
1238
1239 ECryLobbyError CCryDurangoLiveMatchMaking::SessionStart(CrySessionHandle gh, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
1240 {
1241         ECryLobbyError error = eCLE_Success;
1242
1243         LOBBY_AUTO_LOCK;
1244
1245         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
1246
1247         if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
1248         {
1249                 SSession* pSession = &m_sessions[h];
1250                 CryMatchMakingTaskID mmTaskID;
1251
1252                 error = StartTask(eT_SessionStart, false, &mmTaskID, pTaskID, h, pCB, pCBArg);
1253
1254                 if (error == eCLE_Success)
1255                 {
1256                         pSession->localFlags |= CRYSESSION_LOCAL_FLAG_STARTED;
1257                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1258                 }
1259         }
1260         else
1261         {
1262                 error = eCLE_InvalidSession;
1263         }
1264
1265         NetLog("[Lobby] Start SessionStart error %d", error);
1266
1267         return error;
1268 }
1269
1270 void CCryDurangoLiveMatchMaking::StartSessionStart(CryMatchMakingTaskID mmTaskID)
1271 {
1272 }
1273
1274 void CCryDurangoLiveMatchMaking::TickSessionStart(CryMatchMakingTaskID mmTaskID)
1275 {
1276         StopTaskRunning(mmTaskID);
1277 }
1278
1279 ECryLobbyError CCryDurangoLiveMatchMaking::SessionEnd(CrySessionHandle gh, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
1280 {
1281         ECryLobbyError error = eCLE_Success;
1282
1283         LOBBY_AUTO_LOCK;
1284
1285         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
1286
1287         if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
1288         {
1289                 SSession* pSession = &m_sessions[h];
1290                 CryMatchMakingTaskID mmTaskID;
1291
1292                 error = StartTask(eT_SessionEnd, false, &mmTaskID, pTaskID, h, pCB, pCBArg);
1293
1294                 if (error == eCLE_Success)
1295                 {
1296                         pSession->localFlags &= ~CRYSESSION_LOCAL_FLAG_STARTED;
1297                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1298                 }
1299         }
1300         else
1301         {
1302                 error = eCLE_SuccessInvalidSession;
1303         }
1304
1305         NetLog("[Lobby] Start SessionEnd error %d", error);
1306
1307         return error;
1308 }
1309
1310 void CCryDurangoLiveMatchMaking::StartSessionEnd(CryMatchMakingTaskID mmTaskID)
1311 {
1312 }
1313
1314 void CCryDurangoLiveMatchMaking::TickSessionEnd(CryMatchMakingTaskID mmTaskID)
1315 {
1316         StopTaskRunning(mmTaskID);
1317 }
1318
1319 ECryLobbyError CCryDurangoLiveMatchMaking::SessionDelete(CrySessionHandle gh, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
1320 {
1321         ECryLobbyError error = eCLE_Success;
1322
1323         LOBBY_AUTO_LOCK;
1324
1325         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
1326
1327         if ((h < MAX_MATCHMAKING_SESSIONS) && (m_sessions[h].localFlags & CRYSESSION_LOCAL_FLAG_USED))
1328         {
1329                 SSession* pSession = &m_sessions[h];
1330                 CryMatchMakingTaskID mmTaskID;
1331
1332                 error = StartTask(eT_SessionDelete, false, &mmTaskID, pTaskID, h, pCB, pCBArg);
1333
1334                 if (error == eCLE_Success)
1335                 {
1336                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1337                 }
1338         }
1339         else
1340         {
1341                 error = eCLE_SuccessInvalidSession;
1342         }
1343
1344         NetLog("[Lobby] Start SessionDelete error %d", error);
1345
1346         return error;
1347 }
1348
1349 void CCryDurangoLiveMatchMaking::StartSessionDelete(CryMatchMakingTaskID mmTaskID)
1350 {
1351         STask* pTask = &m_task[mmTaskID];
1352         SSession* pSession = &m_sessions[pTask->session];
1353
1354         // Disconnect our local connection
1355         SessionDisconnectRemoteConnectionViaNub(pTask->session, CryMatchMakingInvalidConnectionID, eDS_Local, CryMatchMakingInvalidConnectionID, eDC_UserRequested, "Session deleted");
1356         SessionUserDataEvent(eCLSE_SessionUserLeave, pTask->session, CryMatchMakingInvalidConnectionID);
1357
1358         auto tasks = std::make_shared<std::vector<concurrency::task<HRESULT>>>();
1359
1360         // Free any remaining remote connections
1361         for (uint32 i = 0; i < MAX_LOBBY_CONNECTIONS; i++)
1362         {
1363                 SSession::SRConnection* pConnection = &pSession->remoteConnection[i];
1364
1365                 if (pConnection->used)
1366                 {
1367                         tasks->emplace_back(FreeRemoteConnectionAsync(pTask->session, i));
1368                 }
1369         }
1370
1371         FreeSessionHandle(pTask->session);
1372
1373         // XXX - ATG
1374         GetChatIntegrationLayer()->Reset();
1375
1376         if (m_user)
1377         {
1378                 ComPtr<IAsyncAction> sessionDelete;
1379                 HRESULT res = m_user->DeleteSessionAsync(&sessionDelete);
1380                 if (SUCCEEDED(res))
1381                 {
1382                         tasks->emplace_back(ABI::Concurrency::task_from_async(sessionDelete.Get()).then(
1383                                               [sessionDelete](HRESULT res)
1384                         {
1385                                 return res;
1386                         }));
1387                 }
1388         }
1389
1390         m_pSecureDeviceAssociationTemplate->remove_AssociationIncoming(m_AssociationIncoming);
1391         m_AssociationIncoming.value = 0;
1392
1393         StartConcurrencyTaskTask(mmTaskID, concurrency::when_all(tasks->begin(), tasks->end()).then(
1394                                    [tasks](std::vector<HRESULT> results)
1395         {
1396                 for (auto const& result : results)
1397                 {
1398                   if (FAILED(result))
1399                                 return result;
1400                 }
1401
1402                 return S_OK;
1403         }));
1404 }
1405
1406 void CCryDurangoLiveMatchMaking::TickSessionDelete(CryMatchMakingTaskID mmTaskID)
1407 {
1408         STask* pTask = &m_task[mmTaskID];
1409         SSession* pSession = &m_sessions[pTask->session];
1410
1411         if (pTask->asyncTaskState != STask::eATS_Pending)
1412         {
1413                 StopTaskRunning(mmTaskID);
1414         }
1415 }
1416
1417 ECryLobbyError CCryDurangoLiveMatchMaking::SessionSearch(uint32 user, SCrySessionSearchParam* pParam, CryLobbyTaskID* pTaskID, CryMatchmakingSessionSearchCallback pCB, void* pCBArg)
1418 {
1419         LOBBY_AUTO_LOCK;
1420
1421         CryMatchMakingTaskID mmTaskID;
1422
1423         ECryLobbyError error = StartTask(eT_SessionSearch, false, &mmTaskID, pTaskID, CryLobbyInvalidSessionHandle, pCB, pCBArg);
1424
1425         if (error == eCLE_Success)
1426         {
1427                 STask* pTask = &m_task[mmTaskID];
1428
1429                 error = CreateTaskParamMem(mmTaskID, TDM_SESSION_SEARCH_PARAM, pParam, sizeof(SCrySessionSearchParam));
1430
1431                 if (error == eCLE_Success)
1432                 {
1433                         error = CreateTaskParamMem(mmTaskID, TDM_SESSION_SEARCH_PARAMDATA, pParam->m_data, pParam->m_numData * sizeof(pParam->m_data[0]));
1434
1435                         if (error == eCLE_Success)
1436                         {
1437                                 pTask->numParams[TDN_SESSION_SEARCH_PARAMNUMDATA] = pParam->m_numData;
1438                                 FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1439                         }
1440                 }
1441
1442                 if (error != eCLE_Success)
1443                 {
1444                         FreeTask(mmTaskID);
1445                 }
1446         }
1447
1448         NetLog("[Lobby] Start SessionSearch error %d", error);
1449
1450         return error;
1451 }
1452
1453 void CCryDurangoLiveMatchMaking::StartSessionSearch(CryMatchMakingTaskID mmTaskID)
1454 {
1455         StopTaskRunning(mmTaskID);
1456 }
1457
1458 void CCryDurangoLiveMatchMaking::TickSessionSearch(CryMatchMakingTaskID mmTaskID)
1459 {
1460         StopTaskRunning(mmTaskID);
1461 }
1462
1463 void CCryDurangoLiveMatchMaking::EndSessionSearch(CryMatchMakingTaskID mmTaskID)
1464 {
1465         STask* pTask = &m_task[mmTaskID];
1466
1467         SCryDurangoLiveSessionID* id = nullptr;
1468         {
1469                 if (m_user)
1470                 {
1471                         id = new SCryDurangoLiveSessionID(m_user->GetSessionName());
1472                 }
1473         }
1474
1475         if (id)
1476         {
1477                 SCrySessionSearchResult result;
1478                 SCrySessionUserData userData[MAX_MATCHMAKING_SESSION_USER_DATA];
1479
1480                 result.m_id = id;
1481
1482                 result.m_numFilledSlots = 0;
1483                 result.m_data.m_numPublicSlots = 0;
1484                 result.m_data.m_numPrivateSlots = 0;
1485                 cry_strcpy(result.m_data.m_name, "Test");
1486                 result.m_data.m_ranked = false;
1487
1488                 result.m_data.m_data = userData;
1489                 result.m_data.m_numData = m_registeredUserData.num;
1490
1491                 result.m_ping = 0;
1492                 result.m_numFriends = 0;
1493                 result.m_flags = 0;
1494
1495                 for (uint32 i = 0; i < m_registeredUserData.num; i++)
1496                 {
1497                         result.m_data.m_data[i] = m_registeredUserData.data[i];
1498                 }
1499
1500                 if (pTask->cb)
1501                 {
1502                         ((CryMatchmakingSessionSearchCallback)pTask->cb)(pTask->lTaskID, eCLE_SuccessContinue, &result, pTask->cbArg);
1503                 }
1504         }
1505
1506         // Need to check again as task is cancelled if result from previous call is automatically accepted,
1507         // in which case cb will be nulled out by the previous callback.
1508         if (pTask->cb)
1509         {
1510                 ((CryMatchmakingSessionSearchCallback)pTask->cb)(pTask->lTaskID, pTask->error, NULL, pTask->cbArg);
1511         }
1512 }
1513
1514 ECryLobbyError CCryDurangoLiveMatchMaking::SessionJoin(uint32* pUsers, int numUsers, uint32 flags, CrySessionID id, CryLobbyTaskID* pTaskID, CryMatchmakingSessionJoinCallback pCB, void* pCBArg)
1515 {
1516         LOBBY_AUTO_LOCK;
1517
1518         CryLobbySessionHandle h;
1519         ECryLobbyError error = CreateSessionHandle(&h, false, flags, numUsers);
1520
1521         if (error == eCLE_Success)
1522         {
1523                 CryMatchMakingTaskID mmTaskID;
1524
1525                 error = StartTask(eT_SessionJoin, false, &mmTaskID, pTaskID, h, pCB, pCBArg);
1526
1527                 if (error == eCLE_Success)
1528                 {
1529                         SCryDurangoLiveSessionID* pDurangoLiveID = (SCryDurangoLiveSessionID*)id.get();
1530                         SSession* pSession = &m_sessions[h];
1531
1532                         pSession->sessionID = pDurangoLiveID->m_sessionID;
1533                         OLECHAR* bstrGuid;
1534                         StringFromCLSID(pSession->sessionID, &bstrGuid);
1535                         CryLogAlways("SessionJoin: SID: %s", bstrGuid);
1536                         ::CoTaskMemFree(bstrGuid);
1537
1538                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1539                 }
1540                 else
1541                 {
1542                         FreeSessionHandle(h);
1543                 }
1544         }
1545
1546         NetLog("[Lobby] Start SessionJoin error %d", error);
1547
1548         return error;
1549 }
1550
1551 void CCryDurangoLiveMatchMaking::StartSessionJoin(CryMatchMakingTaskID mmTaskID)
1552 {
1553 }
1554
1555 void CCryDurangoLiveMatchMaking::TickSessionJoin(CryMatchMakingTaskID mmTaskID)
1556 {
1557         using namespace ABI::Microsoft::Xbox::Services::Matchmaking;
1558         STask* pTask = &m_task[mmTaskID];
1559
1560         // If we don't have an async running... {
1561         // If we have not looked in 5 seconds:
1562         if (m_user)
1563         {
1564                 Live::Xuid xuids;
1565                 HRESULT hr = m_user->GetHostXuid(xuids);
1566
1567                 unsigned int addresses = 1;
1568                 ComPtr<ISecureDeviceAddress> sdaddr;
1569                 hr = m_user->GetHostSecureDeviceAddress(&sdaddr, &addresses);
1570
1571                 SSession* pSession = &m_sessions[pTask->session];
1572                 pSession->localConnection.uid.m_sid = GetSIDFromSessionHandle(pTask->session);
1573
1574                 CryMatchMakingConnectionID const remoteId =
1575                   [&]()
1576                         {
1577                                 pSession->hostConnectionID = AddRemoteConnection(pTask->session, sdaddr.Get(), nullptr, xuids);
1578                                 return pSession->hostConnectionID;
1579                   } ();
1580
1581                 if (remoteId != CryMatchMakingInvalidConnectionID)
1582                 {
1583                         StartSubTask(eT_SessionJoinCreateAssociation, mmTaskID);
1584                         StartCreateSecureDeviceAssociation(pTask->session, remoteId);
1585                 }
1586                 else
1587                 {
1588                         UpdateTaskError(mmTaskID, eCLE_ConnectionFailed);
1589                         StopTaskRunning(mmTaskID);
1590                 }
1591         }
1592         else
1593         {
1594                 UpdateTaskError(mmTaskID, eCLE_ConnectionFailed);
1595                 StopTaskRunning(mmTaskID);
1596         }
1597 }
1598
1599 void CCryDurangoLiveMatchMaking::TickSessionJoinCreateAssociation(CryMatchMakingTaskID mmTaskID)
1600 {
1601         STask* pTask = &m_task[mmTaskID];
1602         SSession* pSession = &m_sessions[pTask->session];
1603         SSession::SRConnection* pConnection = &pSession->remoteConnection[pSession->hostConnectionID];
1604
1605         if (pConnection->state == SSession::SRConnection::eRCS_CreateAssociationSuccess)
1606         {
1607                 StartSubTask(eT_SessionRequestJoin, mmTaskID);
1608                 pTask->timerStarted = false;
1609                 pTask->numParams[TDM_SESSION_JOIN_CONNECTION_COUNTER] = 0;
1610         }
1611
1612         if (pConnection->state == SSession::SRConnection::eRCS_CreateAssociationFailed)
1613         {
1614                 UpdateTaskError(mmTaskID, eCLE_ConnectionFailed);
1615                 StopTaskRunning(mmTaskID);
1616         }
1617 }
1618
1619 void CCryDurangoLiveMatchMaking::TickSessionRequestJoin(CryMatchMakingTaskID mmTaskID)
1620 {
1621         STask* pTask = &m_task[mmTaskID];
1622
1623         if (!pTask->TimerStarted() || (pTask->GetTimer() > CONNECTION_JOIN_SEND_INTERVAL))
1624         {
1625                 if (pTask->numParams[TDM_SESSION_JOIN_CONNECTION_COUNTER] < CONNECTION_JOIN_MAX_SEND_TIMES)
1626                 {
1627                         SSession* pSession = &m_sessions[pTask->session];
1628                         const uint32 MaxBufferSize = CryLobbyPacketHeaderSize + CryLobbyPacketUINT8Size + CryLobbyPacketUINT64Size;
1629                         uint8 buffer[MaxBufferSize];
1630                         CCryDurangoLiveLobbyPacket packet;
1631
1632                         pTask->StartTimer();
1633                         pTask->numParams[TDM_SESSION_JOIN_CONNECTION_COUNTER]++;
1634
1635                         Live::Xuid xuid = m_user->Xuid();
1636
1637                         packet.SetWriteBuffer(buffer, MaxBufferSize);
1638                         packet.StartWrite(eDurangoLivePT_SessionRequestJoin, false);
1639                         packet.WriteUINT8(mmTaskID);
1640                         packet.WriteUINT64(xuid);
1641
1642                         TNetAddress addr;
1643                         m_lobby->AddressFromConnection(addr, pSession->remoteConnection[pSession->hostConnectionID].connectionID);
1644                         NetLog("[Lobby] TickSessionRequestJoin sending to " PRFORMAT_ADDR, PRARG_ADDR(addr));
1645
1646                         if (Send(mmTaskID, &packet, pTask->session, pSession->hostConnectionID) != eSE_Ok)
1647                         {
1648                                 UpdateTaskError(mmTaskID, eCLE_ConnectionFailed);
1649                         }
1650                 }
1651                 else
1652                 {
1653                         UpdateTaskError(mmTaskID, eCLE_ConnectionFailed);
1654                         StopTaskRunning(mmTaskID);
1655                 }
1656         }
1657 }
1658
1659 void CCryDurangoLiveMatchMaking::EndSessionJoin(CryMatchMakingTaskID mmTaskID)
1660 {
1661         STask* pTask = &m_task[mmTaskID];
1662
1663         if (pTask->error == eCLE_Success)
1664         {
1665                 SSession* pSession = &m_sessions[pTask->session];
1666
1667                 ((CryMatchmakingSessionJoinCallback)pTask->cb)(pTask->lTaskID, pTask->error, CreateGameSessionHandle(pTask->session, pSession->localConnection.uid), 0, 0, pTask->cbArg);
1668                 InitialUserDataEvent(pTask->session);
1669
1670                 return;
1671         }
1672
1673         ((CryMatchmakingSessionJoinCallback)pTask->cb)(pTask->lTaskID, pTask->error, CrySessionInvalidHandle, 0, 0, pTask->cbArg);
1674 }
1675
1676 void CCryDurangoLiveMatchMaking::ProcessSessionRequestJoin(const TNetAddress& addr, CCryDurangoLiveLobbyPacket* pPacket)
1677 {
1678         NetLog("[Lobby] ProcessSessionRequestJoin from " PRFORMAT_ADDR, PRARG_ADDR(addr));
1679
1680         CryMatchMakingTaskID returnTaskID;
1681
1682         returnTaskID = pPacket->ReadUINT8();
1683         Live::Xuid xuid = pPacket->ReadUINT64();
1684
1685         if (!m_user)
1686                 return;
1687
1688         SSockAddrStorageAddr const* pSockAddrStorageAddr = boost::get<SSockAddrStorageAddr>(&addr);
1689         if (!pSockAddrStorageAddr)
1690                 return;
1691
1692         IDatagramSocketPtr pSocket = m_lobby->GetInternalSocket(m_serviceType);
1693         if (!pSocket)
1694                 return;
1695
1696         ComPtr<ISecureDeviceAssociation> pSecureDeviceAssociation;
1697         {
1698                 sockaddr_storage localAddr;
1699                 int localAddrLen = sizeof(localAddr);
1700
1701                 if (getsockname(pSocket->GetSysSocket(), (CRYSOCKADDR*)&localAddr, &localAddrLen) == 0)
1702                 {
1703                         HRESULT hr = Interface::Statics<ISecureDeviceAssociationStatics>()->GetAssociationBySocketAddressBytes(
1704                           sizeof(pSockAddrStorageAddr->addr),
1705                           reinterpret_cast<uint8*>(&const_cast<SSockAddrStorageAddr*>(pSockAddrStorageAddr)->addr),
1706                           localAddrLen,
1707                           reinterpret_cast<uint8*>(&localAddr),
1708                           &pSecureDeviceAssociation);
1709                         CryLogAlways("CCryDurangoLiveMatchMaking::ProcessSessionRequestJoin - GetAssociationBySocketAddressBytes returned 0x%08x", hr);
1710                 }
1711         }
1712
1713         if (!pSecureDeviceAssociation)
1714                 return;
1715
1716         CryLobbySessionHandle h = FindSessionFromID(m_user->GetSessionName());
1717         if (h == CryLobbyInvalidSessionHandle)
1718                 return;
1719
1720         //Live::Xuid xuid;
1721         //m_user->GetRemoteXuids(1, &xuid, nullptr);
1722
1723         SSession* pSession = &m_sessions[h];
1724         CryMatchMakingConnectionID id = AddRemoteConnection(h, nullptr, pSecureDeviceAssociation.Get(), xuid);
1725
1726         if (id == CryMatchMakingInvalidConnectionID)
1727                 return;
1728
1729         SSession::SLConnection* pLocalConnection = &pSession->localConnection;
1730         SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
1731         const uint32 MaxBufferSize = CryLobbyPacketHeaderSize + CryLobbyPacketUINT8Size + CryLobbyPacketErrorSize + CryLobbyPacketConnectionUIDSize + CryLobbyPacketConnectionUIDSize;
1732         uint8 buffer[MaxBufferSize];
1733         CCryDurangoLiveLobbyPacket packet;
1734
1735         packet.SetWriteBuffer(buffer, MaxBufferSize);
1736         packet.StartWrite(eDurangoLivePT_SessionRequestJoinResult, true);
1737         packet.WriteUINT8(returnTaskID);
1738         packet.WriteError(eCLE_Success);
1739
1740         // Add clients connection info.
1741         packet.WriteConnectionUID(pConnection->uid);
1742
1743         // Add servers connection info.
1744         packet.WriteConnectionUID(pLocalConnection->uid);
1745
1746         Send(CryMatchMakingInvalidTaskID, &packet, h, id);
1747
1748         ConnectionEstablishedUserDataEvent(h, id);
1749
1750         return;
1751 }
1752
1753 void CCryDurangoLiveMatchMaking::ProcessSessionRequestJoinResult(const TNetAddress& addr, CCryDurangoLiveLobbyPacket* pPacket)
1754 {
1755         CryMatchMakingTaskID mmTaskID = pPacket->ReadUINT8();
1756
1757         mmTaskID = FindTaskFromTaskTaskID(eT_SessionRequestJoin, mmTaskID);
1758
1759         if (mmTaskID != CryMatchMakingInvalidTaskID)
1760         {
1761                 STask* pTask = &m_task[mmTaskID];
1762                 ECryLobbyError error = pPacket->ReadError();
1763
1764                 UpdateTaskError(mmTaskID, error);
1765                 StopTaskRunning(mmTaskID);
1766         }
1767 }
1768
1769 uint32 CCryDurangoLiveMatchMaking::GetSessionIDSizeInPacket() const
1770 {
1771         return 0;
1772 }
1773
1774 ECryLobbyError CCryDurangoLiveMatchMaking::WriteSessionIDToPacket(CrySessionID sessionId, CCryLobbyPacket* pPacket) const
1775 {
1776         return eCLE_Success;
1777 }
1778
1779 CrySessionID CCryDurangoLiveMatchMaking::ReadSessionIDFromPacket(CCryLobbyPacket* pPacket) const
1780 {
1781         return CrySessionInvalidID;
1782 }
1783
1784 CrySessionID CCryDurangoLiveMatchMaking::SessionGetCrySessionIDFromCrySessionHandle(CrySessionHandle gh)
1785 {
1786         return CrySessionInvalidID;
1787 }
1788
1789 void CCryDurangoLiveMatchMaking::OnPacket(const TNetAddress& addr, CCryLobbyPacket* pPacket)
1790 {
1791         CCryDurangoLiveLobbyPacket* pDLPacket = (CCryDurangoLiveLobbyPacket*)pPacket;
1792
1793         switch (pDLPacket->StartRead())
1794         {
1795         case eDurangoLivePT_SessionRequestJoin:
1796                 ProcessSessionRequestJoin(addr, pDLPacket);
1797                 break;
1798
1799         case eDurangoLivePT_SessionRequestJoinResult:
1800                 ProcessSessionRequestJoinResult(addr, pDLPacket);
1801                 break;
1802
1803         // XXX - ATG
1804         case eDurangoLivePT_Chat:
1805                 GetChatIntegrationLayer()->ReceivePacket(pDLPacket);
1806                 break;
1807
1808         default:
1809                 CCryMatchMaking::OnPacket(addr, pDLPacket);
1810                 break;
1811         }
1812 }
1813
1814         #if NETWORK_HOST_MIGRATION
1815 void CCryDurangoLiveMatchMaking::HostMigrationInitialise(CryLobbySessionHandle h, EDisconnectionCause cause)
1816 {
1817         SSession* pSession = &m_sessions[h];
1818
1819         pSession->hostMigrationInfo.Reset();
1820 }
1821
1822 void CCryDurangoLiveMatchMaking::HostMigrationFinalise(CryLobbySessionHandle h)
1823 {
1824         SSession* pSession = &m_sessions[h];
1825
1826         HostMigrationReset(h);
1827
1828         if ((pSession->localFlags & CRYSESSION_LOCAL_FLAG_HOST) == 0)
1829         {
1830                 MarkHostHintInformationDirty(h);
1831         }
1832 }
1833
1834 ECryLobbyError CCryDurangoLiveMatchMaking::HostMigrationServer(SHostMigrationInfo* pInfo)
1835 {
1836         ECryLobbyError error = eCLE_Success;
1837
1838         LOBBY_AUTO_LOCK;
1839
1840         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(pInfo->m_session);
1841
1842         if (h != CryLobbyInvalidSessionHandle)
1843         {
1844                 SSession* pSession = &m_sessions[h];
1845
1846                 if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_USED)
1847                 {
1848                         CryMatchMakingTaskID mmTaskID;
1849
1850                         pSession->localFlags |= CRYSESSION_LOCAL_FLAG_HOST;
1851                         pSession->hostConnectionID = CryMatchMakingInvalidConnectionID;
1852                         error = StartTask(eT_SessionMigrateHostServer, false, &mmTaskID, NULL, h, NULL, NULL);
1853
1854                         if (error == eCLE_Success)
1855                         {
1856                                 STask* pTask = &m_task[mmTaskID];
1857                 #if HOST_MIGRATION_SOAK_TEST_BREAK_DETECTION
1858                                 DetectHostMigrationTaskBreak(h, "HostMigrationServer()");
1859                 #endif
1860                                 pSession->hostMigrationInfo.m_taskID = pTask->lTaskID;
1861
1862                                 FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1863                         }
1864                 }
1865                 else
1866                 {
1867                         error = eCLE_InvalidSession;
1868                 }
1869         }
1870         else
1871         {
1872                 error = eCLE_InvalidSession;
1873         }
1874
1875         if (error != eCLE_Success)
1876         {
1877                 m_hostMigration.Terminate((SHostMigrationInfo_Private*)pInfo);
1878                 NetLog("[Host Migration]: CCryLiveMatchMaking::HostMigrationServer(): " PRFORMAT_SH ", error %d", PRARG_SH(h), error);
1879         }
1880
1881         return error;
1882 }
1883
1884 void CCryDurangoLiveMatchMaking::HostMigrationServerNT(CryMatchMakingTaskID mmTaskID)
1885 {
1886 }
1887
1888 void CCryDurangoLiveMatchMaking::TickHostMigrationServerNT(CryMatchMakingTaskID mmTaskID)
1889 {
1890         STask* pTask = &m_task[mmTaskID];
1891         SSession* pSession = &m_sessions[pTask->session];
1892
1893         pSession->hostMigrationInfo.m_matchMakingFinished = true;
1894         StopTaskRunning(mmTaskID);
1895 }
1896
1897 bool CCryDurangoLiveMatchMaking::GetNewHostAddress(char* pAddress, SHostMigrationInfo* pInfo)
1898 {
1899         return false;
1900 }
1901
1902 void CCryDurangoLiveMatchMaking::HostMigrationStartNT(CryMatchMakingTaskID mmTaskID)
1903 {
1904 }
1905
1906 void CCryDurangoLiveMatchMaking::TickHostMigrationStartNT(CryMatchMakingTaskID mmTaskID)
1907 {
1908         StopTaskRunning(mmTaskID);
1909 }
1910         #endif
1911
1912 ECryLobbyError CCryDurangoLiveMatchMaking::SessionEnsureBestHost(CrySessionHandle gh, CryLobbyTaskID* pTaskID, CryMatchmakingCallback pCB, void* pCBArg)
1913 {
1914         ECryLobbyError rc = eCLE_Success;
1915
1916         #if NETWORK_HOST_MIGRATION
1917         LOBBY_AUTO_LOCK;
1918
1919         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
1920
1921         if (h != CryLobbyInvalidSessionHandle)
1922         {
1923                 CryMatchMakingTaskID mmTaskID;
1924                 SSession* pSession = &m_sessions[h];
1925                 rc = StartTask(eT_SessionMigrateHostStart, false, &mmTaskID, pTaskID, h, pCB, pCBArg);
1926
1927                 if (rc == eCLE_Success)
1928                 {
1929                         FROM_GAME_TO_LOBBY(&CCryDurangoLiveMatchMaking::StartTaskRunning, this, mmTaskID);
1930                 }
1931         }
1932         #endif
1933
1934         return rc;
1935 }
1936
1937 void CCryDurangoLiveMatchMaking::SessionUserDataEvent(ECryLobbySystemEvent event, CryLobbySessionHandle h, CryMatchMakingConnectionID id)
1938 {
1939         SSession* pSession = &m_sessions[h];
1940
1941         if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_USER_DATA_EVENTS_STARTED)
1942         {
1943                 ComPtr<IUser> pUser;
1944                 ISystem* pSystem = GetISystem();
1945
1946                 if (pSystem)
1947                 {
1948                         int userIndex = pSystem->GetPlatformOS()->GetFirstSignedInUser();
1949                         if (userIndex != IPlatformOS::Unknown_User)
1950                         {
1951                                 int userId = pSystem->GetPlatformOS()->UserGetId(userIndex);
1952                                 Interface::Statics<IUser>()->GetUserById(userId, &pUser);
1953                         }
1954                 }
1955
1956                 if (id == CryMatchMakingInvalidConnectionID)
1957                 {
1958                         SSession::SLConnection* pConnection = &pSession->localConnection;
1959                         SCryDurangoLiveUserID* pID = new SCryDurangoLiveUserID(pConnection->xuid);
1960
1961                         if (pID)
1962                         {
1963                                 SCryUserInfoResult userInfo;
1964
1965                                 userInfo.m_conID = pConnection->uid;
1966                                 userInfo.m_isDedicated = false;           // Live does not support dedicated servers
1967                                 userInfo.m_userID = pID;
1968                                 cry_strcpy(userInfo.m_userName, pConnection->name);
1969                                 memcpy(userInfo.m_userData, pConnection->userData, CRYLOBBY_USER_DATA_SIZE_IN_BYTES);
1970
1971                                 CCryMatchMaking::SessionUserDataEvent(event, h, &userInfo);
1972                         }
1973
1974                         if (event == eCLSE_SessionUserJoin)
1975                         {
1976                                 if (pUser.Get())
1977                                 {
1978                                         // XXX - ATG
1979                                         auto user = reinterpret_cast<Windows::Xbox::System::User^>(pUser.Get());
1980                                         GetChatIntegrationLayer()->AddLocalUserToChatChannel(0, user);
1981                                 }
1982                         }
1983                         else if (event == eCLSE_SessionUserLeave)
1984                         {
1985                                 if (pUser.Get())
1986                                 {
1987                                         // XXX - ATG
1988                                         auto user = reinterpret_cast<Windows::Xbox::System::User^>(pUser.Get());
1989                                         GetChatIntegrationLayer()->RemoveUserFromChatChannel(0, user);
1990                                 }
1991                         }
1992                 }
1993                 else
1994                 {
1995                         SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
1996                         SCryDurangoLiveUserID* pID = new SCryDurangoLiveUserID(pConnection->xuid);
1997
1998                         if (pID)
1999                         {
2000                                 SCryUserInfoResult userInfo;
2001
2002                                 userInfo.m_conID = pConnection->uid;
2003                                 userInfo.m_isDedicated = false;           // Live does not support dedicated servers
2004                                 userInfo.m_userID = pID;
2005                                 cry_strcpy(userInfo.m_userName, pConnection->name);
2006                                 memcpy(userInfo.m_userData, pConnection->userData, CRYLOBBY_USER_DATA_SIZE_IN_BYTES);
2007
2008                                 CCryMatchMaking::SessionUserDataEvent(event, h, &userInfo);
2009                         }
2010
2011                         if (event == eCLSE_SessionUserJoin)
2012                         {
2013                                 // XXX - ATG
2014                                 GetChatIntegrationLayer()->AddRemoteConnection(h, id, pConnection->uid.m_uid);
2015                         }
2016                         else if (event == eCLSE_SessionUserLeave)
2017                         {
2018                                 // XXX - ATG
2019                                 GetChatIntegrationLayer()->RemoveRemoteConnection(h, id, pConnection->uid.m_uid);
2020                         }
2021                 }
2022         }
2023 }
2024
2025 void CCryDurangoLiveMatchMaking::ConnectionEstablishedUserDataEvent(CryLobbySessionHandle h, CryMatchMakingConnectionID id)
2026 {
2027         SSession* pSession = &m_sessions[h];
2028         SSession::SRConnection* pConnection = &pSession->remoteConnection[id];
2029
2030         SessionUserDataEvent(eCLSE_SessionUserJoin, h, id);
2031 }
2032
2033 void CCryDurangoLiveMatchMaking::InitialUserDataEvent(CryLobbySessionHandle h)
2034 {
2035         SSession* pSession = &m_sessions[h];
2036
2037         pSession->localFlags |= CRYSESSION_LOCAL_FLAG_USER_DATA_EVENTS_STARTED;
2038
2039         SessionUserDataEvent(eCLSE_SessionUserJoin, h, CryMatchMakingInvalidConnectionID);
2040
2041         for (uint32 i = 0; i < MAX_LOBBY_CONNECTIONS; ++i)
2042         {
2043                 SSession::SRConnection* pConnection = &pSession->remoteConnection[i];
2044
2045                 if (pConnection->used)
2046                 {
2047                         SessionUserDataEvent(eCLSE_SessionUserJoin, h, i);
2048                 }
2049         }
2050 }
2051
2052 const char* CCryDurangoLiveMatchMaking::SSession::GetLocalUserName(uint32 localUserIndex) const
2053 {
2054         return NULL;
2055 }
2056
2057 void CCryDurangoLiveMatchMaking::SSession::Reset()
2058 {
2059         CCryMatchMaking::SSession::Reset();
2060
2061         sessionID = NULL_GUID;
2062         hostConnectionID = CryMatchMakingInvalidConnectionID;
2063 }
2064
2065 const char* CCryDurangoLiveMatchMaking::GetConnectionName(CCryMatchMaking::SSession::SRConnection* pConnection, uint32 localUserIndex) const
2066 {
2067         SSession::SRConnection* pPlatformConnection = reinterpret_cast<SSession::SRConnection*>(pConnection);
2068
2069         if (pPlatformConnection->uid.m_uid == DEDICATED_SERVER_CONNECTION_UID)
2070         {
2071                 return "DedicatedServer";
2072         }
2073
2074         if (pPlatformConnection->used)
2075         {
2076                 return pPlatformConnection->name;
2077         }
2078
2079         return NULL;
2080 }
2081
2082 uint64 CCryDurangoLiveMatchMaking::GetConnectionUserID(CCryMatchMaking::SSession::SRConnection* pConnection, uint32 localUserIndex) const
2083 {
2084         return INVALID_USER_ID;
2085 }
2086
2087 TNetAddress CCryDurangoLiveMatchMaking::GetHostAddressFromSessionHandle(CrySessionHandle gh)
2088 {
2089         LOBBY_AUTO_LOCK;
2090
2091         CryLobbySessionHandle h = GetSessionHandleFromGameSessionHandle(gh);
2092         SSession* pSession = &m_sessions[h];
2093
2094         if (pSession->serverConnectionID != CryMatchMakingInvalidConnectionID)
2095         {
2096                 const TNetAddress* pDedicatedServerAddr = m_lobby->GetNetAddress(pSession->remoteConnection[pSession->serverConnectionID].connectionID);
2097
2098                 if (pDedicatedServerAddr)
2099                 {
2100                         return *pDedicatedServerAddr;
2101                 }
2102         }
2103
2104         if (pSession->localFlags & CRYSESSION_LOCAL_FLAG_HOST)
2105         {
2106                 return TNetAddress(TLocalNetAddress(m_lobby->GetInternalSocketPort(eCLS_Online)));
2107         }
2108
2109         if (pSession->hostConnectionID != CryMatchMakingInvalidConnectionID)
2110         {
2111                 const TNetAddress* pHostAddr = m_lobby->GetNetAddress(pSession->remoteConnection[pSession->hostConnectionID].connectionID);
2112
2113                 if (pHostAddr)
2114                 {
2115                         return *pHostAddr;
2116                 }
2117         }
2118
2119         return TNetAddress(SNullAddr());
2120 }
2121
2122         #pragma warning(pop)
2123
2124 #endif // USE_DURANGOLIVE && USE_CRY_MATCHMAKING