Code/CryPlugins/CryLobby/Module/PSNOrbis/CryPSN2Lobby.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4
   5 #if CRY_PLATFORM_ORBIS
   6
   7         #include "CryPSN2Lobby.h"
   8
   9         #if USE_PSN
  10                 #include <net.h>
  11                 #include <libnetctl.h>
  12
  13 void CCryPSNLobbyService::SupportCallback(ECryPSNSupportCallbackEvent ecb, SCryPSNSupportCallbackEventData& data, void* pArg)
  14 {
  15         CCryPSNLobbyService* _this = static_cast<CCryPSNLobbyService*>(pArg);
  16
  17         if (ecb == eCE_ErrorEvent)
  18         {
  19                 for (uint32 i = 0; i < MAX_LOBBY_TASKS; i++)
  20                 {
  21                         STask* pTask = _this->GetTask(i);
  22
  23                         if (pTask->used && pTask->running)
  24                         {
  25                                 _this->UpdateTaskError(i, MapSupportErrorToLobbyError(data.m_errorEvent.m_error));
  26                                 _this->StopTaskRunning(i);
  27                         }
  28                 }
  29         }
  30 }
  31
  32 CCryPSNLobbyService::CCryPSNLobbyService(CCryLobby* pLobby, ECryLobbyService service) : CCryLobbyService(pLobby, service)
  33 {
  34                 #if USE_PSN_VOICE
  35         m_pVoice = NULL;
  36                 #endif//USE_PSN_VOICE
  37         m_pLobbySupport = NULL;
  38                 #if USE_CRY_MATCHMAKING
  39         m_pMatchmaking = NULL;
  40                 #endif // USE_CRY_MATCHMAKING
  41         m_NPInited = false;
  42                 #if USE_CRY_TCPSERVICE
  43         m_pTCPServiceFactory = NULL;
  44                 #endif // USE_CRY_TCPSERVICE
  45                 #if USE_CRY_STATS
  46         m_pStats = NULL;
  47                 #endif // USE_CRY_STATS
  48         m_pLobbyUI = NULL;
  49                 #if USE_CRY_FRIENDS
  50         m_pFriends = NULL;
  51                 #endif // USE_CRY_FRIENDS
  52         m_pReward = NULL;
  53 }
  54
  55 ECryLobbyError CCryPSNLobbyService::Initialise(ECryLobbyServiceFeatures features, CryLobbyServiceCallback pCB)
  56 {
  57         ECryLobbyError error = CCryLobbyService::Initialise(features, pCB);
  58
  59         if (!m_NPInited)
  60         {
  61                 int ret;
  62
  63                 ret = sceNetCtlInit();
  64                 if ((ret < PSN_OK) && (ret != SCE_NET_CTL_ERROR_NOT_INITIALIZED))
  65                 {
  66                         NetLog("sceNetCtlInit() failed. ret = 0x%x\n", ret);
  67                         return eCLE_InternalError;
  68                 }
  69
  70                 SConfigurationParams titleInfo[3] = {
  71                         { CLCC_PSN_TITLE_ID,     { NULL }
  72                         },{ CLCC_PSN_TITLE_SECRET, { NULL }
  73                         },{ CLCC_PSN_AGE_LIMIT,    { NULL }
  74                         }
  75                 };
  76                 GetConfigurationInformation(titleInfo, 3);
  77
  78                 #if !USE_NPTITLE_DAT
  79                 ret = sceNpSetNpTitleId((const SceNpTitleId*)titleInfo[0].m_pData, (const SceNpTitleSecret*)titleInfo[1].m_pData);
  80                 if (ret < PSN_OK)
  81                 {
  82                         NetLog("sceNpSetNpTitleId() failed. ret = 0x%x\n", ret);
  83                         return eCLE_InternalError;
  84                 }
  85                 #endif // !USE_NPTITLE_DAT
  86
  87                 SCryLobbyAgeRestrictionSetup* pAgeSetup = (SCryLobbyAgeRestrictionSetup*)titleInfo[2].m_pData;
  88                 SceNpAgeRestriction* pAges = NULL;
  89
  90                 SceNpContentRestriction contentRestriction;
  91                 memset(&contentRestriction, 0, sizeof(contentRestriction));
  92                 contentRestriction.size = sizeof(contentRestriction);
  93                 contentRestriction.defaultAgeRestriction = SCE_NP_NO_AGE_RESTRICTION;
  94
  95                 if (pAgeSetup && pAgeSetup->m_numCountries && pAgeSetup->m_pCountries)
  96                 {
  97                         pAges = new SceNpAgeRestriction[pAgeSetup->m_numCountries];
  98                         if (pAges)
  99                         {
 100                                 memset(pAges, 0, pAgeSetup->m_numCountries * sizeof(SceNpAgeRestriction));
 101
 102                                 for (int i = 0; i < pAgeSetup->m_numCountries; ++i)
 103                                 {
 104                                         strncpy(pAges[i].countryCode.data, pAgeSetup->m_pCountries[i].id, 2);
 105                                         pAges[i].age = pAgeSetup->m_pCountries[i].age;
 106                                 }
 107
 108                                 contentRestriction.ageRestrictionCount = pAgeSetup->m_numCountries;
 109                                 contentRestriction.ageRestriction = pAges;
 110                         }
 111                 }
 112
 113                 ret = sceNpSetContentRestriction(&contentRestriction);
 114                 if (ret < PSN_OK)
 115                 {
 116                         NetLog("sceNpSetContentRestriction() failed. ret = 0x%x\n", ret);
 117                         SAFE_DELETE_ARRAY(pAges);
 118                         return eCLE_InternalError;
 119                 }
 120
 121                 SAFE_DELETE_ARRAY(pAges);
 122
 123                 m_NPInited = true;
 124         }
 125
 126                 #if USE_CRY_TCPSERVICE
 127         if ((m_pTCPServiceFactory == NULL) && (features & eCLSO_TCPService))
 128         {
 129                 m_pTCPServiceFactory = new CCryTCPServiceFactory();
 130
 131                 if (m_pTCPServiceFactory)
 132                 {
 133                         error = m_pTCPServiceFactory->Initialise("Scripts/Network/TCPServices.xml", CCryTCPServiceFactory::k_defaultMaxSockets);
 134                 }
 135                 else
 136                 {
 137                         return eCLE_OutOfMemory;
 138                 }
 139         }
 140                 #endif // USE_CRY_TCPSERVICE
 141
 142         if ((error == eCLE_Success) && (m_pLobbySupport == NULL) && (features & eCLSO_Base))
 143         {
 144                 m_pLobbySupport = new CCryPSNSupport(m_pLobby, this, features);
 145                 if (m_pLobbySupport)
 146                 {
 147                         error = m_pLobbySupport->Initialise();
 148                         if (!m_pLobbySupport->RegisterEventHandler(eCE_ErrorEvent, CCryPSNLobbyService::SupportCallback, this))
 149                         {
 150                                 return eCLE_InternalError;
 151                         }
 152                 }
 153                 else
 154                 {
 155                         return eCLE_OutOfMemory;
 156                 }
 157         }
 158
 159                 #if USE_PSN_VOICE
 160         if ((error == eCLE_Success) && (m_pVoice == NULL) && (features & eCLSO_Voice))
 161         {
 162                 m_pVoice = new CCryPSNVoice(m_pLobby, this);
 163
 164                 if (m_pVoice)
 165                 {
 166                         error = m_pVoice->Initialise();
 167                 }
 168                 else
 169                 {
 170                         return eCLE_OutOfMemory;
 171                 }
 172         }
 173                 #endif
 174
 175                 #if USE_CRY_MATCHMAKING
 176         if ((error == eCLE_Success) && (m_pMatchmaking == NULL) && (features & eCLSO_Matchmaking))
 177         {
 178                 m_pMatchmaking = new CCryPSNMatchMaking(m_pLobby, this, m_pLobbySupport, m_service);
 179
 180                 if (m_pMatchmaking)
 181                 {
 182                         error = m_pMatchmaking->Initialise();
 183                         if (!m_pLobbySupport->RegisterEventHandler(eCE_ErrorEvent | eCE_RequestEvent | eCE_RoomEvent | eCE_SignalEvent | eCE_WebApiEvent, CCryPSNMatchMaking::SupportCallback, m_pMatchmaking))
 184                         {
 185                                 return eCLE_InternalError;
 186                         }
 187                 }
 188                 else
 189                 {
 190                         return eCLE_OutOfMemory;
 191                 }
 192         }
 193                 #endif // USE_CRY_MATCHMAKING
 194
 195                 #if USE_CRY_STATS
 196         if ((error == eCLE_Success) && (m_pStats == NULL) && (features & eCLSO_Stats))
 197         {
 198                 m_pStats = new CCryPSNStats(m_pLobby, this, m_pLobbySupport);
 199
 200                 if (m_pStats)
 201                 {
 202                         error = m_pStats->Initialise();
 203                         if (!m_pLobbySupport->RegisterEventHandler(eCE_ErrorEvent, CCryPSNStats::SupportCallback, m_pStats))
 204                         {
 205                                 return eCLE_InternalError;
 206                         }
 207                 }
 208                 else
 209                 {
 210                         return eCLE_OutOfMemory;
 211                 }
 212         }
 213                 #endif // USE_CRY_STATS
 214
 215         if ((error == eCLE_Success) && (m_pLobbyUI == NULL) && (features & eCLSO_LobbyUI))
 216         {
 217                 m_pLobbyUI = new CCryPSNLobbyUI(m_pLobby, this, m_pLobbySupport);
 218
 219                 if (m_pLobbyUI)
 220                 {
 221                         error = m_pLobbyUI->Initialise();
 222                         if (!m_pLobbySupport->RegisterEventHandler(eCE_ErrorEvent | eCE_WebApiEvent, CCryPSNLobbyUI::SupportCallback, m_pLobbyUI))
 223                         {
 224                                 return eCLE_InternalError;
 225                         }
 226                 }
 227                 else
 228                 {
 229                         return eCLE_OutOfMemory;
 230                 }
 231         }
 232
 233                 #if USE_CRY_FRIENDS
 234         if ((error == eCLE_Success) && (m_pFriends == NULL) && (features & eCLSO_Friends))
 235         {
 236                 m_pFriends = new CCryPSNFriends(m_pLobby, this, m_pLobbySupport);
 237
 238                 if (m_pFriends)
 239                 {
 240                         error = m_pFriends->Initialise();
 241                         if (!m_pLobbySupport->RegisterEventHandler(eCE_ErrorEvent | eCE_WebApiEvent, CCryPSNFriends::SupportCallback, m_pFriends))
 242                         {
 243                                 return eCLE_InternalError;
 244                         }
 245                 }
 246                 else
 247                 {
 248                         return eCLE_OutOfMemory;
 249                 }
 250         }
 251                 #endif // USE_CRY_FRIENDS
 252
 253         if ((error == eCLE_Success) && (m_pReward == NULL) && (features & eCLSO_Reward))
 254         {
 255                 m_pReward = new CCryPSNReward(m_pLobby);
 256                 if (m_pReward)
 257                 {
 258                         error = m_pReward->Initialise();
 259                 }
 260                 else
 261                 {
 262                         return eCLE_OutOfMemory;
 263                 }
 264         }
 265
 266         if (error == eCLE_Success)
 267         {
 268                 if (features & eCLSO_Base)
 269                 {
 270                         m_pLobby->SetServicePacketEnd(m_service, ePSNPT_EndType);
 271                 }
 272         }
 273         else
 274         {
 275                 Terminate(features, NULL);
 276         }
 277
 278         if (pCB)
 279         {
 280                 pCB(error, m_pLobby, m_service);
 281         }
 282
 283         return error;
 284 }
 285
 286 ECryLobbyError CCryPSNLobbyService::Terminate(ECryLobbyServiceFeatures features, CryLobbyServiceCallback pCB)
 287 {
 288         if (
 289                 #if USE_CRY_MATCHMAKING
 290           m_pMatchmaking ||
 291                 #endif // USE_CRY_MATCHMAKING
 292                 #if USE_CRY_TCPSERVICE
 293           m_pTCPServiceFactory ||
 294                 #endif // USE_CRY_TCPSERVICE
 295           m_pLobbySupport ||
 296                 #if USE_CRY_STATS
 297           m_pStats ||
 298                 #endif // USE_CRY_STATS
 299           m_pLobbyUI ||
 300                 #if USE_CRY_FRIENDS
 301           m_pFriends ||
 302                 #endif // USE_CRY_FRIENDS
 303           m_pReward ||
 304                 #if USE_PSN_VOICE
 305           m_pVoice ||
 306                 #endif
 307           0
 308           )
 309         {
 310                 ECryLobbyError ret = CCryLobbyService::Terminate(features, pCB);
 311
 312                 #if USE_CRY_FRIENDS
 313                 if (m_pFriends && (features & eCLSO_Friends))
 314                 {
 315                         ECryLobbyError error = m_pFriends->Terminate();
 316                         m_pFriends = NULL;
 317
 318                         if (ret == eCLE_Success)
 319                         {
 320                                 ret = error;
 321                         }
 322                 }
 323                 #endif // USE_CRY_FRIENDS
 324
 325                 if (m_pLobbyUI && (features & eCLSO_LobbyUI))
 326                 {
 327                         ECryLobbyError error = m_pLobbyUI->Terminate();
 328                         m_pLobbyUI = NULL;
 329
 330                         if (ret == eCLE_Success)
 331                         {
 332                                 ret = error;
 333                         }
 334                 }
 335
 336                 #if USE_CRY_STATS
 337                 if (m_pStats && (features & eCLSO_Stats))
 338                 {
 339                         ECryLobbyError error = m_pStats->Terminate();
 340                         m_pStats = NULL;
 341
 342                         if (ret == eCLE_Success)
 343                         {
 344                                 ret = error;
 345                         }
 346                 }
 347                 #endif // USE_CRY_STATS
 348
 349                 #if USE_CRY_TCPSERVICE
 350                 if (m_pTCPServiceFactory && (features & eCLSO_TCPService))
 351                 {
 352                         ECryLobbyError error = m_pTCPServiceFactory->Terminate(false);
 353                         m_pTCPServiceFactory = NULL;
 354
 355                         if (ret == eCLE_Success)
 356                         {
 357                                 ret = error;
 358                         }
 359                 }
 360                 #endif // USE_CRY_TCPSERVICE
 361
 362                 #if USE_PSN_VOICE
 363                 if (m_pVoice && (features & eCLSO_Voice))
 364                 {
 365                         ECryLobbyError error = m_pVoice->Terminate();
 366                         m_pVoice = NULL;
 367
 368                         if (ret == eCLE_Success)
 369                         {
 370                                 ret = error;
 371                         }
 372                 }
 373                 #endif
 374
 375                 #if USE_CRY_MATCHMAKING
 376                 if (m_pMatchmaking && (features & eCLSO_Matchmaking))
 377                 {
 378                         ECryLobbyError error = m_pMatchmaking->Terminate();
 379                         m_pMatchmaking = NULL;
 380
 381                         if (ret == eCLE_Success)
 382                         {
 383                                 ret = error;
 384                         }
 385                 }
 386                 #endif // USE_CRY_MATCHMAKING
 387
 388                 if (m_pReward && (features & eCLSO_Reward))
 389                 {
 390                         ECryLobbyError error = m_pReward->Terminate();
 391                         m_pReward = NULL;
 392
 393                         if (ret == eCLE_Success)
 394                         {
 395                                 ret = error;
 396                         }
 397                 }
 398
 399                 if (m_pLobbySupport && (features & eCLSO_Base))
 400                 {
 401                         ECryLobbyError error = m_pLobbySupport->Terminate();
 402                         m_pLobbySupport = NULL;
 403
 404                         if (ret == eCLE_Success)
 405                         {
 406                                 ret = error;
 407                         }
 408                 }
 409
 410                 if (pCB)
 411                 {
 412                         pCB(ret, m_pLobby, m_service);
 413                 }
 414
 415                 return ret;
 416         }
 417         else
 418         {
 419                 return eCLE_NotInitialised;
 420         }
 421 }
 422
 423 void CCryPSNLobbyService::Tick(CTimeValue tv)
 424 {
 425         if (m_pLobby->MutexTryLock())
 426         {
 427                 if (m_pLobbySupport)
 428                 {
 429                         m_pLobbySupport->Tick();
 430                 }
 431
 432                 for (uint32 i = 0; i < MAX_LOBBY_TASKS; i++)
 433                 {
 434                         STask* pTask = GetTask(i);
 435
 436                         if (pTask->used && pTask->running)
 437                         {
 438                                 if (pTask->error == eCLE_Success)
 439                                 {
 440                                         switch (pTask->startedTask)
 441                                         {
 442                                         case eT_GetUserPrivileges:
 443                                                 TickGetUserPrivileges(i);
 444                                                 break;
 445                                         }
 446                                 }
 447                         }
 448                 }
 449
 450                 #if USE_CRY_MATCHMAKING
 451                 if (m_pMatchmaking)
 452                 {
 453                         m_pMatchmaking->Tick(tv);
 454                 }
 455                 #endif // USE_CRY_MATCHMAKING
 456
 457                 #if USE_PSN_VOICE
 458                 if (m_pVoice)
 459                 {
 460                         m_pVoice->Tick(tv);
 461                 }
 462                 #endif
 463
 464                 #if USE_CRY_STATS
 465                 if (m_pStats)
 466                 {
 467                         m_pStats->Tick(tv);
 468                 }
 469                 #endif // USE_CRY_STATS
 470
 471                 if (m_pReward)
 472                 {
 473                         m_pReward->Tick(tv);
 474                 }
 475
 476                 if (m_pLobbyUI)
 477                 {
 478                         m_pLobbyUI->Tick(tv);
 479                 }
 480
 481                 m_pLobby->MutexUnlock();
 482         }
 483
 484                 #if USE_CRY_TCPSERVICE
 485         if (m_pTCPServiceFactory)
 486         {
 487                 m_pTCPServiceFactory->Tick(tv);
 488         }
 489                 #endif // USE_CRY_TCPSERVICE
 490 }
 491
 492 void CCryPSNLobbyService::OnPacket(const TNetAddress& addr, CCryLobbyPacket* pPacket)
 493 {
 494                 #if USE_CRY_MATCHMAKING
 495         if (m_pMatchmaking)
 496         {
 497                 m_pMatchmaking->OnPacket(addr, pPacket);
 498         }
 499                 #endif // USE_CRY_MATCHMAKING
 500
 501                 #if USE_PSN_VOICE
 502         if (m_pVoice)
 503         {
 504                 m_pVoice->OnPacket(addr, pPacket);
 505         }
 506                 #endif // USE_PSN_VOICE
 507 }
 508
 509 void CCryPSNLobbyService::OnError(const TNetAddress& addr, ESocketError error, CryLobbySendID sendID)
 510 {
 511                 #if USE_CRY_MATCHMAKING
 512         if (m_pMatchmaking)
 513         {
 514                 m_pMatchmaking->OnError(addr, error, sendID);
 515         }
 516                 #endif // USE_CRY_MATCHMAKING
 517 }
 518
 519 void CCryPSNLobbyService::OnSendComplete(const TNetAddress& addr, CryLobbySendID sendID)
 520 {
 521                 #if USE_CRY_MATCHMAKING
 522         if (m_pMatchmaking)
 523         {
 524                 m_pMatchmaking->OnSendComplete(addr, sendID);
 525         }
 526                 #endif // USE_CRY_MATCHMAKING
 527 }
 528
 529 void CCryPSNLobbyService::GetConfigurationInformation(SConfigurationParams* infos, uint32 cnt)
 530 {
 531         m_pLobby->GetConfigurationInformation(infos, cnt);
 532 }
 533
 534 CryUserID CCryPSNLobbyService::GetUserID(uint32 user)
 535 {
 536         if (m_pLobbySupport && (m_pLobbySupport->GetOnlineState() >= ePSNOS_Online))
 537         {
 538                 //-- the npId should be valid
 539                 SCryPSNUserID* pID = new SCryPSNUserID;
 540                 if (pID)
 541                 {
 542                         pID->npId = *(m_pLobbySupport->GetLocalNpId());
 543                         return pID;
 544                 }
 545         }
 546
 547         return CryUserInvalidID;
 548 }
 549
 550 void CCryPSNLobbyService::StartTaskRunning(CryLobbyServiceTaskID lsTaskID)
 551 {
 552         LOBBY_AUTO_LOCK;
 553
 554         STask* pTask = GetTask(lsTaskID);
 555
 556         if (pTask->used)
 557         {
 558                 pTask->running = true;
 559
 560                 switch (pTask->startedTask)
 561                 {
 562                 case eT_GetUserPrivileges:
 563                         StartGetUserPrivileges(lsTaskID);
 564                         break;
 565                 }
 566         }
 567 }
 568
 569 void CCryPSNLobbyService::StopTaskRunning(CryLobbyServiceTaskID lsTaskID)
 570 {
 571         STask* pTask = GetTask(lsTaskID);
 572
 573         if (pTask->used)
 574         {
 575                 pTask->running = false;
 576
 577                 TO_GAME_FROM_LOBBY(&CCryPSNLobbyService::EndTask, this, lsTaskID);
 578         }
 579 }
 580
 581 void CCryPSNLobbyService::EndTask(CryLobbyServiceTaskID lsTaskID)
 582 {
 583         LOBBY_AUTO_LOCK;
 584
 585         STask* pTask = GetTask(lsTaskID);
 586
 587         if (pTask->used)
 588         {
 589                 if (pTask->pCB)
 590                 {
 591                         switch (pTask->startedTask)
 592                         {
 593                         case eT_GetUserPrivileges:
 594                                 {
 595                                         uint32 result = 0;
 596                                         if (!m_pLobbySupport || (m_pLobbySupport->GetOnlineState() < ePSNOS_Online) || (pTask->error == eCLE_InsufficientPrivileges) || (pTask->error == eCLE_AgeRestricted))
 597                                         {
 598                                                 result |= CLPF_BlockMultiplayerSessons;
 599                                         }
 600
 601                                         ((CryLobbyPrivilegeCallback)pTask->pCB)(pTask->lTaskID, pTask->error, result, pTask->pCBArg);
 602                                 }
 603                                 break;
 604                         }
 605                 }
 606
 607                 if (pTask->error != eCLE_Success)
 608                 {
 609                         NetLog("[Lobby] Lobby Service EndTask %d Result %d", pTask->startedTask, pTask->error);
 610                 }
 611
 612                 FreeTask(lsTaskID);
 613         }
 614 }
 615
 616 ECryLobbyError CCryPSNLobbyService::GetUserPrivileges(uint32 user, CryLobbyTaskID* pTaskID, CryLobbyPrivilegeCallback pCB, void* pCBArg)
 617 {
 618         ECryLobbyError error;
 619         CryLobbyServiceTaskID tid;
 620
 621         LOBBY_AUTO_LOCK;
 622
 623         error = StartTask(eT_GetUserPrivileges, user, false, &tid, pTaskID, (void*)pCB, pCBArg);
 624
 625         if (error == eCLE_Success)
 626         {
 627                 FROM_GAME_TO_LOBBY(&CCryPSNLobbyService::StartTaskRunning, this, tid);
 628         }
 629
 630         return error;
 631 }
 632
 633 ECryLobbyError CCryPSNLobbyService::GetSystemTime(uint32 user, SCrySystemTime* pSystemTime)
 634 {
 635         SceRtcTick tick;
 636         ECryLobbyError error = eCLE_Success;
 637
 638         memset(pSystemTime, 0, sizeof(SCrySystemTime));
 639
 640         // There's no Network Clock as far as I can see. We'll have to use the system clock for now, which isn't as accurate.
 641         int rc = sceRtcGetCurrentTick(&tick);
 642         switch (rc)
 643         {
 644         case 0:
 645                 // success
 646                 break;
 647         case SCE_NP_ERROR_NOT_INITIALIZED:
 648                 error = eCLE_NotInitialised;
 649                 break;
 650         case SCE_NP_ERROR_INVALID_ARGUMENT:
 651                 error = eCLE_InvalidParam;
 652                 break;
 653         default:
 654                 error = eCLE_InternalError;
 655                 break;
 656         }
 657
 658         if (error == eCLE_Success)
 659         {
 660                 SceRtcDateTime time;
 661                 if (sceRtcSetTick(&time, &tick) == SCE_OK)
 662                 {
 663                         pSystemTime->m_Year = time.year;
 664                         pSystemTime->m_Month = static_cast<uint8>(time.month);
 665                         pSystemTime->m_Day = static_cast<uint8>(time.day);
 666                         pSystemTime->m_Hour = static_cast<uint8>(time.hour);
 667                         pSystemTime->m_Minute = static_cast<uint8>(time.minute);
 668                         pSystemTime->m_Second = static_cast<uint8>(time.second);
 669                 }
 670                 else
 671                 {
 672                         error = eCLE_InternalError;
 673                 }
 674         }
 675
 676         return error;
 677 }
 678
 679 void CCryPSNLobbyService::StartGetUserPrivileges(CryLobbyServiceTaskID lsTaskID)
 680 {
 681         if (m_pLobbySupport && m_pLobby->GetInternalSocket(m_service))
 682         {
 683                 // change this to ePSNOS_Matchmaking_Available if you want GetUserPrivileges to include PS+ test, otherwise it will test user age/PSN account privileges only
 684                 m_pLobbySupport->ResumeTransitioning(ePSNOS_Online);
 685         }
 686         else
 687         {
 688                 UpdateTaskError(lsTaskID, eCLE_InternalError);
 689                 StopTaskRunning(lsTaskID);
 690         }
 691 }
 692
 693 void CCryPSNLobbyService::TickGetUserPrivileges(CryLobbyServiceTaskID lsTaskID)
 694 {
 695         // change this to ePSNOS_Matchmaking_Available if you want GetUserPrivileges to include PS+ test, otherwise it will test user age/PSN account privileges only
 696         m_pLobbySupport->ResumeTransitioning(ePSNOS_Online);
 697         if (m_pLobbySupport->HasTransitioningReachedState(ePSNOS_Online))
 698         {
 699                 StopTaskRunning(lsTaskID);
 700         }
 701 }
 702
 703 void CCryPSNLobbyService::GetSocketPorts(uint16& connectPort, uint16& listenPort)
 704 {
 705         connectPort = SCE_NP_PORT;
 706         listenPort = SCE_NP_PORT;
 707 }
 708
 709                 #if defined(WARFACE_CONSOLE_VERSION)
 710                         #if defined(GUID_STYLE_DB)
 711
 712 CryUserID CCryPSNLobbyService::GetUserIDFromGUID(PlatformGUID64 xuid)
 713 {
 714         SCryPSNUserID* pID = new SCryPSNUserID;
 715
 716         if (pID)
 717         {
 718                 pID->guid = xuid;
 719                 return pID;
 720         }
 721
 722         return CryUserInvalidID;
 723 }
 724
 725 PlatformGUID64 CCryPSNLobbyService::GetGUIDFromUserID(CryUserID id)
 726 {
 727         return ((SCryPSNUserID*)id.get())->guid;
 728 }
 729
 730                         #endif
 731                 #endif
 732
 733 void CCryPSNLobbyService::MakeAddrPCCompatible(TNetAddress& addr)
 734 {
 735         //SIPv4Addr* pIPv4Addr = addr.GetPtr<SIPv4Addr>();
 736
 737         //if (pIPv4Addr)
 738         //{
 739         //      pIPv4Addr->lobbyService = eCLS_LAN;
 740         //}
 741 }
 742
 743         #endif // USE_PSN
 744 #endif   // CRY_PLATFORM_ORBIS