1 : /* -*- c++ -*- */
2 : /*
3 : * Copyright (c) 2013 The Native Client Authors. All rights reserved.
4 : * Use of this source code is governed by a BSD-style license that can be
5 : * found in the LICENSE file.
6 : */
7 :
8 : #include "native_client/src/shared/serialization/serialization.h"
9 :
10 : #include <stdio.h>
11 : #include <string.h>
12 :
13 : #include "native_client/src/shared/platform/nacl_check.h"
14 :
15 : namespace nacl {
16 :
17 : int const kInitialBufferSize = 256;
18 :
19 17 : SerializationBuffer::SerializationBuffer()
20 : : nbytes_(0)
21 : , in_use_(0)
22 17 : , read_ix_(0) {}
23 :
24 :
25 1 : SerializationBuffer::SerializationBuffer(uint8_t const *data_buffer,
26 : size_t nbytes)
27 : : nbytes_(0) // EnsureTotalSize will update
28 : , in_use_(nbytes)
29 1 : , read_ix_(0) {
30 1 : EnsureTotalSize(nbytes);
31 1 : memcpy(&buffer_[0], data_buffer, nbytes);
32 1 : }
33 :
34 2 : bool SerializationBuffer::Serialize(char const *cstr, size_t char_count) {
35 2 : if (char_count > ~(uint32_t) 0) {
36 0 : return false;
37 : }
38 2 : AddTag<char *>();
39 2 : AddVal(static_cast<uint32_t>(char_count));
40 421 : for (size_t ix = 0; ix < char_count; ++ix) {
41 419 : AddVal<uint8_t>(cstr[ix]);
42 : }
43 2 : return true;
44 : }
45 :
46 2 : bool SerializationBuffer::Serialize(char const *cstr) {
47 2 : size_t len = strlen(cstr) + 1; // The ASCII character NUL is included
48 2 : return Serialize(cstr, len);
49 : }
50 :
51 15 : bool SerializationBuffer::Serialize(std::string str) {
52 15 : size_t bytes = str.size();
53 15 : if (bytes > ~(uint32_t) 0) {
54 0 : return false;
55 : }
56 15 : AddTag<std::string>();
57 15 : AddVal(static_cast<uint32_t>(bytes));
58 846 : for (size_t ix = 0; ix < bytes; ++ix) {
59 831 : AddVal<uint8_t>(str[ix]);
60 : }
61 15 : return true;
62 : }
63 :
64 3 : bool SerializationBuffer::Deserialize(char *cstr, size_t *buffer_size) {
65 3 : size_t orig = cur_read_pos();
66 3 : if (bytes_unread() < kTagBytes + SerializationTraits<uint32_t>::kBytes) {
67 0 : return false;
68 : }
69 3 : if (ReadTag() != SerializationTraits<char *>::kTag) {
70 0 : reset_read_pos(orig);
71 0 : return false;
72 : }
73 : uint32_t char_count;
74 3 : if (!GetUint32(&char_count)) {
75 0 : reset_read_pos(orig);
76 0 : return false;
77 : }
78 3 : if (char_count > *buffer_size) {
79 1 : *buffer_size = char_count;
80 1 : reset_read_pos(orig);
81 1 : return true; // true means check buffer_size!
82 : }
83 421 : for (size_t ix = 0; ix < char_count; ++ix) {
84 : uint8_t byte;
85 419 : if (!GetVal(&byte)) {
86 0 : reset_read_pos(orig);
87 0 : return false; // encoded data is garbled!
88 : }
89 419 : cstr[ix] = byte;
90 : }
91 2 : *buffer_size = char_count;
92 2 : return true;
93 : }
94 :
95 1 : bool SerializationBuffer::Deserialize(char **cstr_out) {
96 1 : size_t nbytes = 256;
97 1 : char *buffer = new char[nbytes];
98 :
99 1 : size_t used = nbytes;
100 1 : if (!Deserialize(buffer, &used)) {
101 0 : delete[] buffer;
102 0 : return false;
103 : }
104 1 : if (used > nbytes) {
105 1 : delete[] buffer;
106 1 : buffer = new char[used];
107 1 : CHECK(Deserialize(buffer, &used));
108 : }
109 1 : *cstr_out = buffer;
110 1 : return true;
111 : }
112 :
113 15 : bool SerializationBuffer::Deserialize(std::string *str) {
114 15 : size_t orig = cur_read_pos();
115 15 : if (bytes_unread() < kTagBytes + SerializationTraits<uint32_t>::kBytes) {
116 0 : return false;
117 : }
118 15 : if (ReadTag() != SerializationTraits<std::string>::kTag) {
119 0 : reset_read_pos(orig);
120 0 : return false;
121 : }
122 : uint32_t bytes;
123 15 : if (!GetUint32(&bytes)) {
124 0 : reset_read_pos(orig);
125 0 : return false;
126 : }
127 846 : for (size_t ix = 0; ix < bytes; ++ix) {
128 : uint8_t b;
129 831 : if (!GetUint8(&b)) {
130 0 : reset_read_pos(orig);
131 0 : return false;
132 : }
133 831 : str->push_back(b);
134 : }
135 15 : return true;
136 : }
137 :
138 1348 : void SerializationBuffer::AddUint8(uint8_t value) {
139 1348 : EnsureAvailableSpace(sizeof value);
140 1348 : buffer_[in_use_] = value;
141 1348 : in_use_ += sizeof value;
142 1348 : }
143 :
144 5 : void SerializationBuffer::AddUint16(uint16_t value) {
145 5 : EnsureAvailableSpace(sizeof value);
146 5 : buffer_[in_use_ + 0] = static_cast<uint8_t>(value >> 0);
147 5 : buffer_[in_use_ + 1] = static_cast<uint8_t>(value >> 8);
148 5 : in_use_ += sizeof value;
149 5 : }
150 :
151 132 : void SerializationBuffer::AddUint32(uint32_t value) {
152 132 : EnsureAvailableSpace(sizeof value);
153 132 : buffer_[in_use_ + 0] = static_cast<uint8_t>(value >> 0);
154 132 : buffer_[in_use_ + 1] = static_cast<uint8_t>(value >> 8);
155 132 : buffer_[in_use_ + 2] = static_cast<uint8_t>(value >> 16);
156 132 : buffer_[in_use_ + 3] = static_cast<uint8_t>(value >> 24);
157 132 : in_use_ += sizeof value;
158 132 : }
159 :
160 4 : void SerializationBuffer::AddUint64(uint64_t value) {
161 4 : EnsureAvailableSpace(sizeof value);
162 4 : buffer_[in_use_ + 0] = static_cast<uint8_t>(value >> 0);
163 4 : buffer_[in_use_ + 1] = static_cast<uint8_t>(value >> 8);
164 4 : buffer_[in_use_ + 2] = static_cast<uint8_t>(value >> 16);
165 4 : buffer_[in_use_ + 3] = static_cast<uint8_t>(value >> 24);
166 4 : buffer_[in_use_ + 4] = static_cast<uint8_t>(value >> 32);
167 4 : buffer_[in_use_ + 5] = static_cast<uint8_t>(value >> 40);
168 4 : buffer_[in_use_ + 6] = static_cast<uint8_t>(value >> 48);
169 4 : buffer_[in_use_ + 7] = static_cast<uint8_t>(value >> 56);
170 4 : in_use_ += sizeof value;
171 4 : }
172 :
173 1256 : bool SerializationBuffer::GetUint8(uint8_t *value) {
174 1256 : if (bytes_unread() < sizeof *value) {
175 0 : return false;
176 : }
177 1256 : *value = static_cast<uint8_t>(buffer_[read_ix_]);
178 1256 : read_ix_ += sizeof *value;
179 1256 : return true;
180 : }
181 :
182 8 : bool SerializationBuffer::GetUint16(uint16_t *value) {
183 8 : if (bytes_unread() < sizeof *value) {
184 0 : return false;
185 : }
186 8 : *value = ((static_cast<uint16_t>(buffer_[read_ix_ + 0]) << 0) |
187 8 : (static_cast<uint16_t>(buffer_[read_ix_ + 1]) << 8));
188 8 : read_ix_ += sizeof *value;
189 8 : return true;
190 : }
191 :
192 34 : bool SerializationBuffer::GetUint32(uint32_t *value) {
193 34 : if (bytes_unread() < sizeof *value) {
194 0 : return false;
195 : }
196 34 : *value = ((static_cast<uint32_t>(buffer_[read_ix_ + 0]) << 0) |
197 34 : (static_cast<uint32_t>(buffer_[read_ix_ + 1]) << 8) |
198 34 : (static_cast<uint32_t>(buffer_[read_ix_ + 2]) << 16) |
199 102 : (static_cast<uint32_t>(buffer_[read_ix_ + 3]) << 24));
200 34 : read_ix_ += sizeof *value;
201 34 : return true;
202 : }
203 :
204 6 : bool SerializationBuffer::GetUint64(uint64_t *value) {
205 6 : if (bytes_unread() < sizeof *value) {
206 0 : return false;
207 : }
208 6 : *value = ((static_cast<uint64_t>(buffer_[read_ix_ + 0]) << 0) |
209 6 : (static_cast<uint64_t>(buffer_[read_ix_ + 1]) << 8) |
210 6 : (static_cast<uint64_t>(buffer_[read_ix_ + 2]) << 16) |
211 6 : (static_cast<uint64_t>(buffer_[read_ix_ + 3]) << 24) |
212 6 : (static_cast<uint64_t>(buffer_[read_ix_ + 4]) << 32) |
213 6 : (static_cast<uint64_t>(buffer_[read_ix_ + 5]) << 40) |
214 6 : (static_cast<uint64_t>(buffer_[read_ix_ + 6]) << 48) |
215 42 : (static_cast<uint64_t>(buffer_[read_ix_ + 7]) << 56));
216 6 : read_ix_ += sizeof *value;
217 6 : return true;
218 : }
219 :
220 : #if defined(NACL_HAS_IEEE_754)
221 : bool SerializationBuffer::GetFloat(float *value) {
222 : union ieee754_float v;
223 : uint32_t encoded = 0;
224 : if (!GetUint32(&encoded)) {
225 : return false;
226 : }
227 : v.ieee.negative = encoded >> 31;
228 : v.ieee.exponent = encoded >> 23;
229 : v.ieee.mantissa = encoded;
230 : *value = v.f;
231 : return true;
232 : }
233 :
234 : bool SerializationBuffer::GetDouble(double *value) {
235 : union ieee754_double v;
236 : uint64_t encoded;
237 : if (!GetUint64(&encoded)) {
238 : return false;
239 : }
240 : v.ieee.negative = encoded >> 63;
241 : v.ieee.exponent = encoded >> 52;
242 : v.ieee.mantissa0 = encoded >> 32;
243 : v.ieee.mantissa1 = encoded;
244 : *value = v.d;
245 : return true;
246 : }
247 :
248 : bool SerializationBuffer::GetLongDouble(long double *value) {
249 : union ieee854_long_double v;
250 : uint16_t encoded1;
251 : uint64_t encoded2;
252 : if (in_use_ < read_ix_ + 10) {
253 : return false;
254 : }
255 : if (!GetUint16(&encoded1) || !GetUint64(&encoded2)) {
256 : return false;
257 : }
258 : v.ieee.negative = (encoded1 >> 15) & 1;
259 : v.ieee.exponent = encoded1;
260 : v.ieee.mantissa0 = encoded2 >> 32;
261 : v.ieee.mantissa1 = encoded2;
262 : *value = v.d;
263 : return true;
264 : }
265 : #endif
266 :
267 1490 : void SerializationBuffer::EnsureTotalSize(size_t req_size) {
268 1490 : if (nbytes_ >= req_size) {
269 2954 : return;
270 : }
271 26 : size_t new_size = (0 == nbytes_) ? kInitialBufferSize : 2 * nbytes_;
272 26 : CHECK(new_size > nbytes_); // no arithmetic overflow
273 26 : if (new_size < req_size) {
274 1 : new_size = req_size;
275 : }
276 26 : buffer_.resize(new_size);
277 26 : nbytes_ = new_size;
278 : }
279 :
280 1489 : void SerializationBuffer::EnsureAvailableSpace(size_t req_space) {
281 1489 : CHECK(nbytes_ >= in_use_);
282 1489 : CHECK((~(size_t) 0) - in_use_ >= req_space);
283 1489 : size_t new_size = in_use_ + req_space;
284 1489 : EnsureTotalSize(new_size);
285 1489 : }
286 :
287 : } // namespace nacl
|
