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.h>
20
21 // Checklist when implementing new protocol:
22 // 1. update CHECKSUMHELPER_MAX_VERSION
23 // 2. update maxChecksumSize()
24 // 3. update checksumByteSize()
25 // 4. update addBuffer, writeChecksum, resetChecksum, validate
26
27 // change CHECKSUMHELPER_MAX_VERSION when you want to update the protocol version
28 #define CHECKSUMHELPER_MAX_VERSION 1
29
30 // checksum buffer size
31 // Please add a new checksum buffer size when implementing a new protocol,
32 // as well as modifying the maxChecksumSize function.
33 static const size_t kV1ChecksumSize = 8;
34
maxChecksumSize()35 static size_t maxChecksumSize() {
36 return 0 > kV1ChecksumSize ? 0 : kV1ChecksumSize;
37 }
38
39 static const size_t kMaxChecksumSize = maxChecksumSize();
40
41 // utility macros to create checksum string at compilation time
42 #define CHECKSUMHELPER_VERSION_STR_PREFIX "ANDROID_EMU_CHECKSUM_HELPER_v"
43 #define CHECKSUMHELPER_MACRO_TO_STR(x) #x
44 #define CHECKSUMHELPER_MACRO_VAL_TO_STR(x) CHECKSUMHELPER_MACRO_TO_STR(x)
45
46 static const uint32_t kMaxVersion = CHECKSUMHELPER_MAX_VERSION;
47 static const char* kMaxVersionStrPrefix = CHECKSUMHELPER_VERSION_STR_PREFIX;
48 static const char* kMaxVersionStr = CHECKSUMHELPER_VERSION_STR_PREFIX CHECKSUMHELPER_MACRO_VAL_TO_STR(CHECKSUMHELPER_MAX_VERSION);
49
50 #undef CHECKSUMHELPER_MAX_VERSION
51 #undef CHECKSUMHELPER_VERSION_STR_PREFIX
52 #undef CHECKSUMHELPER_MACRO_TO_STR
53 #undef CHECKSUMHELPER_MACRO_VAL_TO_STR
54
getMaxVersion()55 uint32_t ChecksumCalculator::getMaxVersion() {return kMaxVersion;}
getMaxVersionStr()56 const char* ChecksumCalculator::getMaxVersionStr() {return kMaxVersionStr;}
getMaxVersionStrPrefix()57 const char* ChecksumCalculator::getMaxVersionStrPrefix() {return kMaxVersionStrPrefix;}
58
setVersion(uint32_t version)59 bool ChecksumCalculator::setVersion(uint32_t version) {
60 if (version > kMaxVersion) { // unsupported version
61 LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Unsupported version Version %d\n",
62 __FUNCTION__, m_version);
63 return false;
64 }
65 if (m_isEncodingChecksum) { // setVersion is called in the middle of encoding checksums
66 LOG_CHECKSUMHELPER("%s: called between addBuffer and writeChecksum\n",
67 __FUNCTION__);
68 return false;
69 }
70 m_version = version;
71 LOG_CHECKSUMHELPER("%s: ChecksumCalculator Set Version %d\n", __FUNCTION__,
72 m_version);
73 return true;
74 }
75
checksumByteSize() const76 size_t ChecksumCalculator::checksumByteSize() const {
77 switch (m_version) {
78 case 0:
79 return 0;
80 case 1:
81 return sizeof(uint32_t) + sizeof(m_numWrite);
82 default:
83 return 0;
84 }
85 }
86
ChecksumCalculator()87 ChecksumCalculator::ChecksumCalculator()
88 : m_version(0)
89 , m_numRead(0)
90 , m_numWrite(0)
91 , m_isEncodingChecksum(false)
92 , m_v1BufferTotalLength(0)
93 {
94 }
95
addBuffer(const void * buf,size_t packetLen)96 void ChecksumCalculator::addBuffer(const void* buf, size_t packetLen) {
97 m_isEncodingChecksum = true;
98 switch (m_version) {
99 case 1:
100 m_v1BufferTotalLength += packetLen;
101 break;
102 }
103 }
104
writeChecksum(void * outputChecksum,size_t outputChecksumLen)105 bool ChecksumCalculator::writeChecksum(void* outputChecksum, size_t outputChecksumLen) {
106 if (outputChecksumLen < checksumByteSize()) return false;
107 char *checksumPtr = (char *)outputChecksum;
108 switch (m_version) {
109 case 1: { // protocol v1 is to reverse the packetLen and write it at the end
110 uint32_t val = computeV1Checksum();
111 memcpy(checksumPtr, &val, sizeof(val));
112 memcpy(checksumPtr+sizeof(val), &m_numWrite, sizeof(m_numWrite));
113 break;
114 }
115 }
116 resetChecksum();
117 m_numWrite++;
118 return true;
119 }
120
resetChecksum()121 void ChecksumCalculator::resetChecksum() {
122 switch (m_version) {
123 case 1:
124 m_v1BufferTotalLength = 0;
125 break;
126 }
127 m_isEncodingChecksum = false;
128 }
129
validate(const void * expectedChecksum,size_t expectedChecksumLen)130 bool ChecksumCalculator::validate(const void* expectedChecksum, size_t expectedChecksumLen) {
131 size_t checksumSize = checksumByteSize();
132 if (expectedChecksumLen != checksumSize) {
133 m_numRead++;
134 resetChecksum();
135 return false;
136 }
137 // buffers for computing the checksum
138 unsigned char sChecksumBuffer[kMaxChecksumSize];
139 switch (m_version) {
140 case 1: {
141 uint32_t val = computeV1Checksum();
142 memcpy(sChecksumBuffer, &val, sizeof(val));
143 memcpy(sChecksumBuffer+sizeof(val), &m_numRead, sizeof(m_numRead));
144 break;
145 }
146 }
147 bool isValid = !memcmp(sChecksumBuffer, expectedChecksum, checksumSize);
148 m_numRead++;
149 resetChecksum();
150 return isValid;
151 }
152
computeV1Checksum()153 uint32_t ChecksumCalculator::computeV1Checksum() {
154 uint32_t revLen = m_v1BufferTotalLength;
155 revLen = (revLen & 0xffff0000) >> 16 | (revLen & 0x0000ffff) << 16;
156 revLen = (revLen & 0xff00ff00) >> 8 | (revLen & 0x00ff00ff) << 8;
157 revLen = (revLen & 0xf0f0f0f0) >> 4 | (revLen & 0x0f0f0f0f) << 4;
158 revLen = (revLen & 0xcccccccc) >> 2 | (revLen & 0x33333333) << 2;
159 revLen = (revLen & 0xaaaaaaaa) >> 1 | (revLen & 0x55555555) << 1;
160 return revLen;
161 }
162