--- /dev/null
+/*
+* Copyright (C) 2016 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "ChecksumCalculator.h"
+
+#include <string>
+#include <vector>
+#include <string.h>
+
+// Checklist when implementing new protocol:
+// 1. update CHECKSUMHELPER_MAX_VERSION
+// 2. update maxChecksumSize()
+// 3. update checksumByteSize()
+// 4. update addBuffer, writeChecksum, resetChecksum, validate
+
+// change CHECKSUMHELPER_MAX_VERSION when you want to update the protocol version
+#define CHECKSUMHELPER_MAX_VERSION 1
+
+// checksum buffer size
+// Please add a new checksum buffer size when implementing a new protocol,
+// as well as modifying the maxChecksumSize function.
+static const size_t kV1ChecksumSize = 8;
+
+static constexpr size_t maxChecksumSize() {
+ return 0 > kV1ChecksumSize ? 0 : kV1ChecksumSize;
+}
+
+static const size_t kMaxChecksumSize = maxChecksumSize();
+
+// utility macros to create checksum string at compilation time
+#define CHECKSUMHELPER_VERSION_STR_PREFIX "ANDROID_EMU_CHECKSUM_HELPER_v"
+#define CHECKSUMHELPER_MACRO_TO_STR(x) #x
+#define CHECKSUMHELPER_MACRO_VAL_TO_STR(x) CHECKSUMHELPER_MACRO_TO_STR(x)
+
+static const uint32_t kMaxVersion = CHECKSUMHELPER_MAX_VERSION;
+static const char* kMaxVersionStrPrefix = CHECKSUMHELPER_VERSION_STR_PREFIX;
+static const char* kMaxVersionStr = CHECKSUMHELPER_VERSION_STR_PREFIX CHECKSUMHELPER_MACRO_VAL_TO_STR(CHECKSUMHELPER_MAX_VERSION);
+
+#undef CHECKSUMHELPER_MAX_VERSION
+#undef CHECKSUMHELPER_VERSION_STR_PREFIX
+#undef CHECKSUMHELPER_MACRO_TO_STR
+#undef CHECKSUMHELPER_MACRO_VAL_TO_STR
+
+uint32_t ChecksumCalculator::getMaxVersion() {return kMaxVersion;}
+const char* ChecksumCalculator::getMaxVersionStr() {return kMaxVersionStr;}
+const char* ChecksumCalculator::getMaxVersionStrPrefix() {return kMaxVersionStrPrefix;}
+
+bool ChecksumCalculator::setVersion(uint32_t version) {
+ if (version > kMaxVersion) { // unsupported version
+ LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Unsupported version Version %d\n",
+ __FUNCTION__, m_version);
+ return false;
+ }
+ if (m_isEncodingChecksum) { // setVersion is called in the middle of encoding checksums
+ LOG_CHECKSUMHELPER("%s: called between addBuffer and writeChecksum\n",
+ __FUNCTION__);
+ return false;
+ }
+ m_version = version;
+ LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Version %d\n", __FUNCTION__,
+ m_version);
+ return true;
+}
+
+size_t ChecksumCalculator::checksumByteSize() const {
+ switch (m_version) {
+ case 0:
+ return 0;
+ case 1:
+ return sizeof(uint32_t) + sizeof(m_numWrite);
+ default:
+ return 0;
+ }
+}
+
+void ChecksumCalculator::addBuffer(const void* buf, size_t packetLen) {
+ m_isEncodingChecksum = true;
+ switch (m_version) {
+ case 1:
+ m_v1BufferTotalLength += packetLen;
+ break;
+ }
+}
+
+bool ChecksumCalculator::writeChecksum(void* outputChecksum, size_t outputChecksumLen) {
+ if (outputChecksumLen < checksumByteSize()) return false;
+ char *checksumPtr = (char *)outputChecksum;
+ switch (m_version) {
+ case 1: { // protocol v1 is to reverse the packetLen and write it at the end
+ uint32_t val = computeV1Checksum();
+ memcpy(checksumPtr, &val, sizeof(val));
+ memcpy(checksumPtr+sizeof(val), &m_numWrite, sizeof(m_numWrite));
+ break;
+ }
+ }
+ resetChecksum();
+ m_numWrite++;
+ return true;
+}
+
+void ChecksumCalculator::resetChecksum() {
+ switch (m_version) {
+ case 1:
+ m_v1BufferTotalLength = 0;
+ break;
+ }
+ m_isEncodingChecksum = false;
+}
+
+bool ChecksumCalculator::validate(const void* expectedChecksum, size_t expectedChecksumLen) {
+ size_t checksumSize = checksumByteSize();
+ if (expectedChecksumLen != checksumSize) {
+ m_numRead++;
+ resetChecksum();
+ return false;
+ }
+ // buffers for computing the checksum
+ unsigned char sChecksumBuffer[kMaxChecksumSize];
+ switch (m_version) {
+ case 1: {
+ uint32_t val = computeV1Checksum();
+ memcpy(sChecksumBuffer, &val, sizeof(val));
+ memcpy(sChecksumBuffer+sizeof(val), &m_numRead, sizeof(m_numRead));
+ break;
+ }
+ }
+ bool isValid = !memcmp(sChecksumBuffer, expectedChecksum, checksumSize);
+ m_numRead++;
+ resetChecksum();
+ return isValid;
+}
+
+uint32_t ChecksumCalculator::computeV1Checksum() {
+ uint32_t revLen = m_v1BufferTotalLength;
+ revLen = (revLen & 0xffff0000) >> 16 | (revLen & 0x0000ffff) << 16;
+ revLen = (revLen & 0xff00ff00) >> 8 | (revLen & 0x00ff00ff) << 8;
+ revLen = (revLen & 0xf0f0f0f0) >> 4 | (revLen & 0x0f0f0f0f) << 4;
+ revLen = (revLen & 0xcccccccc) >> 2 | (revLen & 0x33333333) << 2;
+ revLen = (revLen & 0xaaaaaaaa) >> 1 | (revLen & 0x55555555) << 1;
+ return revLen;
+}