Code/CryPlugins/CryLobby/Module/CryStats.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4
   5 #include "Cryptography/rijndael.h"
   6
   7 #include "CryStats.h"
   8
   9 #if USE_CRY_STATS
  10
  11 CCryStats::CCryStats(CCryLobby* pLobby, CCryLobbyService* pService)
  12 {
  13         CRY_ASSERT_MESSAGE(pLobby, "CCryStats::CCryStats: Lobby not specified");
  14         CRY_ASSERT_MESSAGE(pService, "CCryStats::CCryStats: Service not specified");
  15
  16         m_pLobby = pLobby;
  17         m_pService = pService;
  18
  19         for (uint32 i = 0; i < MAX_STATS_TASKS; i++)
  20         {
  21                 m_pTask[i] = NULL;
  22         }
  23 }
  24
  25 ECryLobbyError CCryStats::Initialise()
  26 {
  27         for (uint32 i = 0; i < MAX_STATS_TASKS; i++)
  28         {
  29                 CRY_ASSERT_MESSAGE(m_pTask[i], "CCryStats: Task base pointers not setup");
  30                 m_pTask[i]->used = false;
  31         }
  32
  33         return eCLE_Success;
  34 }
  35
  36 ECryLobbyError CCryStats::Terminate()
  37 {
  38         for (uint32 i = 0; i < MAX_STATS_TASKS; i++)
  39         {
  40                 CRY_ASSERT_MESSAGE(m_pTask[i], "CCryStats: Task base pointers not setup");
  41
  42                 if (m_pTask[i]->used)
  43                 {
  44                         FreeTask(i);
  45                 }
  46         }
  47
  48         return eCLE_Success;
  49 }
  50
  51 ECryLobbyError CCryStats::StartTask(uint32 eTask, bool startRunning, CryStatsTaskID* pSTaskID, CryLobbyTaskID* pLTaskID, CryLobbySessionHandle h, void* pCb, void* pCbArg)
  52 {
  53         CryLobbyTaskID lobbyTaskID = m_pLobby->CreateTask();
  54
  55         if (lobbyTaskID != CryLobbyInvalidTaskID)
  56         {
  57                 for (uint32 i = 0; i < MAX_STATS_TASKS; i++)
  58                 {
  59                         STask* pTask = m_pTask[i];
  60
  61                         CRY_ASSERT_MESSAGE(pTask, "CCryStats: Task base pointers not setup");
  62
  63                         if (!pTask->used)
  64                         {
  65                                 pTask->lTaskID = lobbyTaskID;
  66                                 pTask->error = eCLE_Success;
  67                                 pTask->startedTask = eTask;
  68                                 pTask->subTask = eTask;
  69                                 pTask->session = h;
  70                                 pTask->pCb = pCb;
  71                                 pTask->pCbArg = pCbArg;
  72                                 pTask->used = true;
  73                                 pTask->running = startRunning;
  74                                 pTask->canceled = false;
  75
  76                                 for (uint32 j = 0; j < MAX_STATS_PARAMS; j++)
  77                                 {
  78                                         pTask->paramsMem[j] = TMemInvalidHdl;
  79                                         pTask->paramsNum[j] = 0;
  80                                 }
  81
  82                                 if (pSTaskID)
  83                                 {
  84                                         *pSTaskID = i;
  85                                 }
  86
  87                                 if (pLTaskID)
  88                                 {
  89                                         *pLTaskID = lobbyTaskID;
  90                                 }
  91
  92                                 return eCLE_Success;
  93                         }
  94                 }
  95
  96                 m_pLobby->ReleaseTask(lobbyTaskID);
  97         }
  98
  99         return eCLE_TooManyTasks;
 100 }
 101
 102 void CCryStats::FreeTask(CryStatsTaskID sTaskID)
 103 {
 104         STask* pTask = m_pTask[sTaskID];
 105
 106         CRY_ASSERT_MESSAGE(pTask, "CCryStats: Task base pointers not setup");
 107
 108         for (uint32 i = 0; i < MAX_STATS_PARAMS; i++)
 109         {
 110                 if (pTask->paramsMem[i] != TMemInvalidHdl)
 111                 {
 112                         m_pLobby->MemFree(pTask->paramsMem[i]);
 113                         pTask->paramsMem[i] = TMemInvalidHdl;
 114                 }
 115                 pTask->paramsNum[i] = 0;
 116         }
 117
 118         m_pLobby->ReleaseTask(pTask->lTaskID);
 119
 120         pTask->used = false;
 121 }
 122
 123 void CCryStats::CancelTask(CryLobbyTaskID lTaskID)
 124 {
 125         LOBBY_AUTO_LOCK;
 126
 127         NetLog("[Lobby]Try cancel task %u", lTaskID);
 128
 129         if (lTaskID != CryLobbyInvalidTaskID)
 130         {
 131                 for (uint32 i = 0; i < MAX_STATS_TASKS; i++)
 132                 {
 133                         STask* pTask = m_pTask[i];
 134
 135                         CRY_ASSERT_MESSAGE(pTask, "CCryStats: Task base pointers not setup");
 136
 137                         if (pTask->used && (pTask->lTaskID == lTaskID))
 138                         {
 139                                 NetLog("[Lobby] Task %u canceled", lTaskID);
 140                                 pTask->pCb = NULL;
 141                                 pTask->canceled = true;
 142
 143                                 break;
 144                         }
 145                 }
 146         }
 147 }
 148
 149 ECryLobbyError CCryStats::CreateTaskParamMem(CryStatsTaskID sTaskID, uint32 param, const void* pParamData, size_t paramDataSize)
 150 {
 151         STask* pTask = m_pTask[sTaskID];
 152
 153         CRY_ASSERT_MESSAGE(pTask, "CCryStats: Task base pointers not setup");
 154
 155         if (paramDataSize > 0)
 156         {
 157                 pTask->paramsMem[param] = m_pLobby->MemAlloc(paramDataSize);
 158                 void* p = m_pLobby->MemGetPtr(pTask->paramsMem[param]);
 159
 160                 if (p)
 161                 {
 162                         if (pParamData)
 163                         {
 164                                 memcpy(p, pParamData, paramDataSize);
 165                         }
 166                 }
 167                 else
 168                 {
 169                         return eCLE_OutOfMemory;
 170                 }
 171         }
 172
 173         return eCLE_Success;
 174 }
 175
 176 void CCryStats::UpdateTaskError(CryStatsTaskID sTaskID, ECryLobbyError error)
 177 {
 178         STask* pTask = m_pTask[sTaskID];
 179
 180         CRY_ASSERT_MESSAGE(pTask, "CCryStats: Task base pointers not setup");
 181
 182         if (pTask->error == eCLE_Success)
 183         {
 184                 pTask->error = error;
 185         }
 186 }
 187
 188 ECryLobbyError CCryStats::EncryptUserData(uint32 nBufferSize, const uint8* pUnencrypted, uint8* pEncrypted)
 189 {
 190         if (gEnv->pNetwork)
 191         {
 192                 //-- get key
 193                 SConfigurationParams param = {
 194                         CLCC_CRYSTATS_ENCRYPTION_KEY, { 0 }
 195                 };
 196                 m_pLobby->GetConfigurationInformation(&param, 1);
 197
 198                 uint32 sizeEncrypted = gEnv->pNetwork->RijndaelEncryptBuffer(pEncrypted, pUnencrypted, nBufferSize, (uint8*)param.m_pData, 32);
 199
 200                 NetLog("[Stats] Unencrypted userdata: First few bytes:%02x%02x%02x%02x - %u bytes total",
 201                        pUnencrypted[0],
 202                        pUnencrypted[1],
 203                        pUnencrypted[2],
 204                        pUnencrypted[3],
 205                        nBufferSize
 206                        );
 207                 NetLog("[Stats] Encrypted userdata: First few bytes:%02x%02x%02x%02x - %u bytes total",
 208                        pEncrypted[0],
 209                        pEncrypted[1],
 210                        pEncrypted[2],
 211                        pEncrypted[3],
 212                        sizeEncrypted
 213                        );
 214
 215                 if (sizeEncrypted == nBufferSize)
 216                 {
 217                         return eCLE_Success;
 218                 }
 219                 else
 220                 {
 221                         NetLog("[Stats] Encryption size mismatch; expected %u, got %u bytes.", nBufferSize, sizeEncrypted);
 222                         return eCLE_InternalError;
 223                 }
 224         }
 225         else
 226         {
 227                 return eCLE_InternalError;
 228         }
 229 }
 230
 231 ECryLobbyError CCryStats::DecryptUserData(uint32 nBufferSize, const uint8* pEncrypted, uint8* pDecrypted)
 232 {
 233         //-- get key
 234         SConfigurationParams param = {
 235                 CLCC_CRYSTATS_ENCRYPTION_KEY, { 0 }
 236         };
 237         m_pLobby->GetConfigurationInformation(&param, 1);
 238
 239         uint32 sizeDecrypted = gEnv->pNetwork->RijndaelDecryptBuffer(pDecrypted, pEncrypted, nBufferSize, (uint8*)param.m_pData, 32);
 240
 241         NetLog("[Stats] Encrypted userdata: First few bytes:%02x%02x%02x%02x - %u bytes total",
 242                pEncrypted[0],
 243                pEncrypted[1],
 244                pEncrypted[2],
 245                pEncrypted[3],
 246                nBufferSize
 247                );
 248         NetLog("[Stats] Decrypted userdata: First few bytes:%02x%02x%02x%02x - %u bytes total",
 249                pDecrypted[0],
 250                pDecrypted[1],
 251                pDecrypted[2],
 252                pDecrypted[3],
 253                sizeDecrypted
 254                );
 255
 256         if (sizeDecrypted == nBufferSize)
 257         {
 258                 return eCLE_Success;
 259         }
 260         else
 261         {
 262                 NetLog("[Stats] Decryption size mismatch; expected %u, got %u bytes.", nBufferSize, sizeDecrypted);
 263                 return eCLE_InternalError;
 264         }
 265 }
 266
 267 #endif // USE_CRY_STATS