src/type3_AndroidCloud/anbox-master/android/opengl/shared/OpenglCodecCommon/ChecksumCalculator.cpp

   1 /*
   2 * Copyright (C) 2016 The Android Open Source Project
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include "ChecksumCalculator.h"
  18
  19 #include <string>
  20 #include <vector>
  21 #include <string.h>
  22
  23 // Checklist when implementing new protocol:
  24 // 1. update CHECKSUMHELPER_MAX_VERSION
  25 // 2. update maxChecksumSize()
  26 // 3. update checksumByteSize()
  27 // 4. update addBuffer, writeChecksum, resetChecksum, validate
  28
  29 // change CHECKSUMHELPER_MAX_VERSION when you want to update the protocol version
  30 #define CHECKSUMHELPER_MAX_VERSION 1
  31
  32 // checksum buffer size
  33 // Please add a new checksum buffer size when implementing a new protocol,
  34 // as well as modifying the maxChecksumSize function.
  35 static const size_t kV1ChecksumSize = 8;
  36
  37 static constexpr size_t maxChecksumSize() {
  38     return 0 > kV1ChecksumSize ? 0 : kV1ChecksumSize;
  39 }
  40
  41 static const size_t kMaxChecksumSize = maxChecksumSize();
  42
  43 // utility macros to create checksum string at compilation time
  44 #define CHECKSUMHELPER_VERSION_STR_PREFIX "ANDROID_EMU_CHECKSUM_HELPER_v"
  45 #define CHECKSUMHELPER_MACRO_TO_STR(x) #x
  46 #define CHECKSUMHELPER_MACRO_VAL_TO_STR(x) CHECKSUMHELPER_MACRO_TO_STR(x)
  47
  48 static const uint32_t kMaxVersion = CHECKSUMHELPER_MAX_VERSION;
  49 static const char* kMaxVersionStrPrefix = CHECKSUMHELPER_VERSION_STR_PREFIX;
  50 static const char* kMaxVersionStr = CHECKSUMHELPER_VERSION_STR_PREFIX CHECKSUMHELPER_MACRO_VAL_TO_STR(CHECKSUMHELPER_MAX_VERSION);
  51
  52 #undef CHECKSUMHELPER_MAX_VERSION
  53 #undef CHECKSUMHELPER_VERSION_STR_PREFIX
  54 #undef CHECKSUMHELPER_MACRO_TO_STR
  55 #undef CHECKSUMHELPER_MACRO_VAL_TO_STR
  56
  57 uint32_t ChecksumCalculator::getMaxVersion() {return kMaxVersion;}
  58 const char* ChecksumCalculator::getMaxVersionStr() {return kMaxVersionStr;}
  59 const char* ChecksumCalculator::getMaxVersionStrPrefix() {return kMaxVersionStrPrefix;}
  60
  61 bool ChecksumCalculator::setVersion(uint32_t version) {
  62     if (version > kMaxVersion) {  // unsupported version
  63         LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Unsupported version Version %d\n",
  64                 __FUNCTION__, m_version);
  65         return false;
  66     }
  67     if (m_isEncodingChecksum) { // setVersion is called in the middle of encoding checksums
  68         LOG_CHECKSUMHELPER("%s: called between addBuffer and writeChecksum\n",
  69                 __FUNCTION__);
  70         return false;
  71     }
  72     m_version = version;
  73     LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Version %d\n", __FUNCTION__,
  74                 m_version);
  75     return true;
  76 }
  77
  78 size_t ChecksumCalculator::checksumByteSize() const {
  79     switch (m_version) {
  80         case 0:
  81             return 0;
  82         case 1:
  83             return sizeof(uint32_t) + sizeof(m_numWrite);
  84         default:
  85             return 0;
  86     }
  87 }
  88
  89 void ChecksumCalculator::addBuffer(const void* buf, size_t packetLen) {
  90     m_isEncodingChecksum = true;
  91     switch (m_version) {
  92         case 1:
  93             m_v1BufferTotalLength += packetLen;
  94             break;
  95     }
  96 }
  97
  98 bool ChecksumCalculator::writeChecksum(void* outputChecksum, size_t outputChecksumLen) {
  99     if (outputChecksumLen < checksumByteSize()) return false;
 100     char *checksumPtr = (char *)outputChecksum;
 101     switch (m_version) {
 102         case 1: { // protocol v1 is to reverse the packetLen and write it at the end
 103             uint32_t val = computeV1Checksum();
 104             memcpy(checksumPtr, &val, sizeof(val));
 105             memcpy(checksumPtr+sizeof(val), &m_numWrite, sizeof(m_numWrite));
 106             break;
 107         }
 108     }
 109     resetChecksum();
 110     m_numWrite++;
 111     return true;
 112 }
 113
 114 void ChecksumCalculator::resetChecksum() {
 115     switch (m_version) {
 116         case 1:
 117             m_v1BufferTotalLength = 0;
 118             break;
 119     }
 120     m_isEncodingChecksum = false;
 121 }
 122
 123 bool ChecksumCalculator::validate(const void* expectedChecksum, size_t expectedChecksumLen) {
 124     size_t checksumSize = checksumByteSize();
 125     if (expectedChecksumLen != checksumSize) {
 126         m_numRead++;
 127         resetChecksum();
 128         return false;
 129     }
 130     // buffers for computing the checksum
 131     unsigned char sChecksumBuffer[kMaxChecksumSize];
 132     switch (m_version) {
 133         case 1: {
 134             uint32_t val = computeV1Checksum();
 135             memcpy(sChecksumBuffer, &val, sizeof(val));
 136             memcpy(sChecksumBuffer+sizeof(val), &m_numRead, sizeof(m_numRead));
 137             break;
 138         }
 139     }
 140     bool isValid = !memcmp(sChecksumBuffer, expectedChecksum, checksumSize);
 141     m_numRead++;
 142     resetChecksum();
 143     return isValid;
 144 }
 145
 146 uint32_t ChecksumCalculator::computeV1Checksum() {
 147     uint32_t revLen = m_v1BufferTotalLength;
 148     revLen = (revLen & 0xffff0000) >> 16 | (revLen & 0x0000ffff) << 16;
 149     revLen = (revLen & 0xff00ff00) >> 8 | (revLen & 0x00ff00ff) << 8;
 150     revLen = (revLen & 0xf0f0f0f0) >> 4 | (revLen & 0x0f0f0f0f) << 4;
 151     revLen = (revLen & 0xcccccccc) >> 2 | (revLen & 0x33333333) << 2;
 152     revLen = (revLen & 0xaaaaaaaa) >> 1 | (revLen & 0x55555555) << 1;
 153     return revLen;
 154 }