Embedded SDK
Embedded SDK
Loading...
Searching...
No Matches
buffer.c
Go to the documentation of this file.
1/*****************************************************************************
2 * (c) 2020 Ledger SAS.
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 <stdint.h> // uint*_t
18#include <stddef.h> // size_t
19#include <stdbool.h> // bool
20#include <string.h> // memmove
21
22#include "buffer.h"
23#include "read.h"
24#include "varint.h"
25#include "write.h"
26
31static inline bool buffer_is_consistent(const buffer_t *buffer)
32{
33 return buffer->offset <= buffer->size;
34}
35
36bool buffer_can_read(const buffer_t *buffer, size_t n)
37{
38 if (!buffer_is_consistent(buffer)) {
39 return false;
40 }
41 return buffer->size - buffer->offset >= n;
42}
43
44#define buffer_has_space buffer_can_read
45
46bool buffer_seek_set(buffer_t *buffer, size_t offset)
47{
48 if (offset > buffer->size) {
49 return false;
50 }
51
52 buffer->offset = offset;
53
54 return true;
55}
56
57bool buffer_seek_cur(buffer_t *buffer, size_t offset)
58{
59 if (buffer->offset + offset < buffer->offset || // overflow
60 buffer->offset + offset > buffer->size) { // exceed buffer size
61 return false;
62 }
63
64 buffer->offset += offset;
65
66 return true;
67}
68
69bool buffer_seek_end(buffer_t *buffer, size_t offset)
70{
71 if (offset > buffer->size) {
72 return false;
73 }
74
75 buffer->offset = buffer->size - offset;
76
77 return true;
78}
79
80bool buffer_read_u8(buffer_t *buffer, uint8_t *value)
81{
82 if (!buffer_can_read(buffer, 1)) {
83 *value = 0;
84
85 return false;
86 }
87
88 *value = buffer->ptr[buffer->offset];
89 buffer_seek_cur(buffer, 1);
90
91 return true;
92}
93
94bool buffer_read_u16(buffer_t *buffer, uint16_t *value, endianness_t endianness)
95{
96 if (!buffer_can_read(buffer, 2)) {
97 *value = 0;
98
99 return false;
100 }
101
102 *value = ((endianness == BE) ? read_u16_be(buffer->ptr, buffer->offset)
103 : read_u16_le(buffer->ptr, buffer->offset));
104
105 buffer_seek_cur(buffer, 2);
106
107 return true;
108}
109
110bool buffer_read_u32(buffer_t *buffer, uint32_t *value, endianness_t endianness)
111{
112 if (!buffer_can_read(buffer, 4)) {
113 *value = 0;
114
115 return false;
116 }
117
118 *value = ((endianness == BE) ? read_u32_be(buffer->ptr, buffer->offset)
119 : read_u32_le(buffer->ptr, buffer->offset));
120
121 buffer_seek_cur(buffer, 4);
122
123 return true;
124}
125
126bool buffer_read_u64(buffer_t *buffer, uint64_t *value, endianness_t endianness)
127{
128 if (!buffer_can_read(buffer, 8)) {
129 *value = 0;
130
131 return false;
132 }
133
134 *value = ((endianness == BE) ? read_u64_be(buffer->ptr, buffer->offset)
135 : read_u64_le(buffer->ptr, buffer->offset));
136
137 buffer_seek_cur(buffer, 8);
138
139 return true;
140}
141
142bool buffer_read_varint(buffer_t *buffer, uint64_t *value)
143{
144 if (!buffer_is_consistent(buffer)) {
145 *value = 0;
146
147 return false;
148 }
149
150 int length = varint_read(buffer->ptr + buffer->offset, buffer->size - buffer->offset, value);
151
152 if (length < 0) {
153 *value = 0;
154
155 return false;
156 }
157
158 return buffer_seek_cur(buffer, (size_t) length);
159}
160
161bool buffer_read_bip32_path(buffer_t *buffer, uint32_t *out, size_t out_len)
162{
163 if (!buffer_is_consistent(buffer)) {
164 return false;
165 }
166
167 if (!bip32_path_read(
168 buffer->ptr + buffer->offset, buffer->size - buffer->offset, out, out_len)) {
169 return false;
170 }
171
172 buffer_seek_cur(buffer, sizeof(*out) * out_len);
173
174 return true;
175}
176
178{
179 if ((buffer == NULL) || (bip32 == NULL) || !buffer_can_read(buffer, 1)) {
180 return false;
181 }
182
183 bip32->length = buffer->ptr[buffer->offset];
184 buffer->offset++;
185
186 if (!buffer_can_read(buffer, sizeof(uint32_t) * bip32->length)) {
187 return false;
188 }
189
190 if (!bip32_path_read(buffer->ptr + buffer->offset,
191 buffer->size - buffer->offset,
192 bip32->path,
193 bip32->length)) {
194 return false;
195 }
196
197 buffer_seek_cur(buffer, sizeof(*bip32->path) * bip32->length);
198
199 return true;
200}
201
202bool buffer_copy(const buffer_t *buffer, uint8_t *out, size_t out_len)
203{
204 if (!buffer_is_consistent(buffer) || buffer->size - buffer->offset > out_len) {
205 return false;
206 }
207
208 memmove(out, buffer->ptr + buffer->offset, buffer->size - buffer->offset);
209
210 return true;
211}
212
213bool buffer_move(buffer_t *buffer, uint8_t *out, size_t out_len)
214{
215 if (!buffer_copy(buffer, out, out_len)) {
216 return false;
217 }
218
219 buffer_seek_cur(buffer, out_len);
220
221 return true;
222}
223
224bool buffer_peek(const buffer_t *buffer, uint8_t *value)
225{
226 return buffer_peek_n(buffer, 0, value);
227}
228
229bool buffer_peek_n(const buffer_t *buffer, size_t n, uint8_t *value)
230{
231 if (!buffer_is_consistent(buffer) || n >= buffer->size - buffer->offset) {
232 return false;
233 }
234
235 *value = buffer->ptr[buffer->offset + n];
236
237 return true;
238}
239
240WEAK bool buffer_read_bytes(buffer_t *buffer, uint8_t *out, size_t n)
241{
242 if (!buffer_is_consistent(buffer) || buffer->size - buffer->offset < n) {
243 return false;
244 }
245
246 memmove(out, buffer->ptr + buffer->offset, n);
247 buffer_seek_cur(buffer, n);
248
249 return true;
250}
251
252bool buffer_write_u8(buffer_t *buffer, uint8_t value)
253{
254 if (!buffer_has_space(buffer, 1)) {
255 return false;
256 }
257
258 (buffer->ptr)[buffer->offset] = value;
259 buffer_seek_cur(buffer, 1);
260
261 return true;
262}
263
264bool buffer_write_u16(buffer_t *buffer, uint16_t value, endianness_t endianness)
265{
266 if (!buffer_has_space(buffer, 2)) {
267 return false;
268 }
269
270 if (endianness == BE) {
271 write_u16_be(buffer->ptr, buffer->offset, value);
272 }
273 else {
274 write_u16_le(buffer->ptr, buffer->offset, value);
275 }
276 buffer_seek_cur(buffer, 2);
277
278 return true;
279}
280
281bool buffer_write_u32(buffer_t *buffer, uint32_t value, endianness_t endianness)
282{
283 if (!buffer_has_space(buffer, 4)) {
284 return false;
285 }
286
287 if (endianness == BE) {
288 write_u32_be(buffer->ptr, buffer->offset, value);
289 }
290 else {
291 write_u32_le(buffer->ptr, buffer->offset, value);
292 }
293 buffer_seek_cur(buffer, 4);
294
295 return true;
296}
297
298bool buffer_write_u64(buffer_t *buffer, uint64_t value, endianness_t endianness)
299{
300 if (!buffer_has_space(buffer, 8)) {
301 return false;
302 }
303
304 if (endianness == BE) {
305 write_u64_be(buffer->ptr, buffer->offset, value);
306 }
307 else {
308 write_u64_le(buffer->ptr, buffer->offset, value);
309 }
310
311 buffer_seek_cur(buffer, 8);
312
313 return true;
314}
315
316bool buffer_write_bytes(buffer_t *buffer, const uint8_t *data, size_t n)
317{
318 if (!buffer_has_space(buffer, n)) {
319 return false;
320 }
321
322 memmove(buffer->ptr + buffer->offset, data, n);
323 buffer_seek_cur(buffer, n);
324 return true;
325}
bool bip32_path_read(const uint8_t *in, size_t in_len, uint32_t *out, size_t out_len)
Definition bip32.c:26
bool buffer_read_varint(buffer_t *buffer, uint64_t *value)
Definition buffer.c:142
bool buffer_seek_end(buffer_t *buffer, size_t offset)
Definition buffer.c:69
bool buffer_read_u16(buffer_t *buffer, uint16_t *value, endianness_t endianness)
Definition buffer.c:94
bool buffer_write_u16(buffer_t *buffer, uint16_t value, endianness_t endianness)
Definition buffer.c:264
bool buffer_copy(const buffer_t *buffer, uint8_t *out, size_t out_len)
Definition buffer.c:202
bool buffer_seek_cur(buffer_t *buffer, size_t offset)
Definition buffer.c:57
bool buffer_read_bip32_path(buffer_t *buffer, uint32_t *out, size_t out_len)
Definition buffer.c:161
bool buffer_write_bytes(buffer_t *buffer, const uint8_t *data, size_t n)
Definition buffer.c:316
bool buffer_get_path_bip32(buffer_t *buffer, path_bip32_t *bip32)
Definition buffer.c:177
bool buffer_seek_set(buffer_t *buffer, size_t offset)
Definition buffer.c:46
bool buffer_can_read(const buffer_t *buffer, size_t n)
Definition buffer.c:36
bool buffer_write_u64(buffer_t *buffer, uint64_t value, endianness_t endianness)
Definition buffer.c:298
bool buffer_peek(const buffer_t *buffer, uint8_t *value)
Definition buffer.c:224
bool buffer_write_u32(buffer_t *buffer, uint32_t value, endianness_t endianness)
Definition buffer.c:281
#define buffer_has_space
Definition buffer.c:44
static bool buffer_is_consistent(const buffer_t *buffer)
Definition buffer.c:31
bool buffer_write_u8(buffer_t *buffer, uint8_t value)
Definition buffer.c:252
bool buffer_read_u64(buffer_t *buffer, uint64_t *value, endianness_t endianness)
Definition buffer.c:126
WEAK bool buffer_read_bytes(buffer_t *buffer, uint8_t *out, size_t n)
Definition buffer.c:240
bool buffer_peek_n(const buffer_t *buffer, size_t n, uint8_t *value)
Definition buffer.c:229
bool buffer_move(buffer_t *buffer, uint8_t *out, size_t out_len)
Definition buffer.c:213
bool buffer_read_u32(buffer_t *buffer, uint32_t *value, endianness_t endianness)
Definition buffer.c:110
bool buffer_read_u8(buffer_t *buffer, uint8_t *value)
Definition buffer.c:80
endianness_t
Definition buffer.h:13
@ BE
Definition buffer.h:14
#define WEAK
Definition macros.h:12
uint32_t read_u32_le(const uint8_t *ptr, size_t offset)
Definition read.c:52
uint64_t read_u64_le(const uint8_t *ptr, size_t offset)
Definition read.c:60
uint16_t read_u16_le(const uint8_t *ptr, size_t offset)
Definition read.c:46
uint32_t read_u32_be(const uint8_t *ptr, size_t offset)
Definition read.c:26
uint64_t read_u64_be(const uint8_t *ptr, size_t offset)
Definition read.c:34
uint16_t read_u16_be(const uint8_t *ptr, size_t offset)
Definition read.c:20
uint8_t * ptr
Definition buffer.h:22
size_t size
Pointer to byte buffer.
Definition buffer.h:23
size_t offset
Size of byte buffer.
Definition buffer.h:24
uint32_t path[MAX_BIP32_PATH]
Definition bip32.h:19
uint8_t length
Definition bip32.h:18
int varint_read(const uint8_t *in, size_t in_len, uint64_t *value)
Definition varint.c:42
void write_u16_le(uint8_t *ptr, size_t offset, uint16_t value)
Definition write.c:46
void write_u32_be(uint8_t *ptr, size_t offset, uint32_t value)
Definition write.c:26
void write_u16_be(uint8_t *ptr, size_t offset, uint16_t value)
Definition write.c:20
void write_u64_be(uint8_t *ptr, size_t offset, uint64_t value)
Definition write.c:34
void write_u64_le(uint8_t *ptr, size_t offset, uint64_t value)
Definition write.c:60
void write_u32_le(uint8_t *ptr, size_t offset, uint32_t value)
Definition write.c:52