1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
#include "state.h"
#include <string.h>
/* state load/save */
int state_load(const Logger *log, state_load_cb *state_load_callback, void *outer,
const uint8_t *data, uint32_t length, uint16_t cookie_inner)
{
if (state_load_callback == nullptr || data == nullptr) {
LOGGER_ERROR(log, "state_load() called with invalid args.\n");
return -1;
}
const uint32_t size_head = sizeof(uint32_t) * 2;
while (length >= size_head) {
uint32_t length_sub;
lendian_bytes_to_host32(&length_sub, data);
uint32_t cookie_type;
lendian_bytes_to_host32(&cookie_type, data + sizeof(uint32_t));
data += size_head;
length -= size_head;
if (length < length_sub) {
/* file truncated */
LOGGER_ERROR(log, "state file too short: %u < %u\n", length, length_sub);
return -1;
}
if (lendian_to_host16((cookie_type >> 16)) != cookie_inner) {
/* something is not matching up in a bad way, give up */
LOGGER_ERROR(log, "state file garbled: %04x != %04x\n", cookie_type >> 16, cookie_inner);
return -1;
}
const uint16_t type = lendian_to_host16(cookie_type & 0xFFFF);
switch (state_load_callback(outer, data, length_sub, type)) {
case STATE_LOAD_STATUS_CONTINUE:
data += length_sub;
length -= length_sub;
break;
case STATE_LOAD_STATUS_ERROR:
LOGGER_ERROR(log, "Error occcured in state file (type: %u).", type);
return -1;
case STATE_LOAD_STATUS_END:
return 0;
}
}
if (length != 0) {
LOGGER_ERROR(log, "unparsed data in state file of length %u\n", length);
return -1;
}
return 0;
}
uint8_t *state_write_section_header(uint8_t *data, uint16_t cookie_type, uint32_t len, uint32_t section_type)
{
host_to_lendian_bytes32(data, len);
data += sizeof(uint32_t);
host_to_lendian_bytes32(data, (host_to_lendian16(cookie_type) << 16) | host_to_lendian16(section_type));
data += sizeof(uint32_t);
return data;
}
uint16_t lendian_to_host16(uint16_t lendian)
{
#ifdef WORDS_BIGENDIAN
return (lendian << 8) | (lendian >> 8);
#else
return lendian;
#endif
}
uint16_t host_to_lendian16(uint16_t host)
{
return lendian_to_host16(host);
}
void host_to_lendian_bytes32(uint8_t *dest, uint32_t num)
{
#ifdef WORDS_BIGENDIAN
num = ((num << 8) & 0xFF00FF00) | ((num >> 8) & 0xFF00FF);
num = (num << 16) | (num >> 16);
#endif
memcpy(dest, &num, sizeof(uint32_t));
}
void lendian_bytes_to_host32(uint32_t *dest, const uint8_t *lendian)
{
uint32_t d;
memcpy(&d, lendian, sizeof(uint32_t));
#ifdef WORDS_BIGENDIAN
d = ((d << 8) & 0xFF00FF00) | ((d >> 8) & 0xFF00FF);
d = (d << 16) | (d >> 16);
#endif
*dest = d;
}
void host_to_lendian_bytes16(uint8_t *dest, uint16_t num)
{
#ifdef WORDS_BIGENDIAN
num = (num << 8) | (num >> 8);
#endif
memcpy(dest, &num, sizeof(uint16_t));
}
void lendian_bytes_to_host16(uint16_t *dest, const uint8_t *lendian)
{
uint16_t d;
memcpy(&d, lendian, sizeof(uint16_t));
#ifdef WORDS_BIGENDIAN
d = (d << 8) | (d >> 8);
#endif
*dest = d;
}
|
