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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/* SPDX-License-Identifier: Unlicense */
#include "proto.h"
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
static inline uint8_t GetU8NE(void const *data)
{
return ((uint8_t const *)data)[0];
}
static inline uint16_t GetU16NE(void const *data)
{
return (uint16_t)(((uint8_t const *)data)[1]) |
((uint16_t)(((uint8_t const *)data)[0]) << 8);
}
static inline uint32_t GetU32NE(void const *data)
{
return (uint32_t)(((uint8_t const *)data)[3]) |
((uint32_t)(((uint8_t const *)data)[2]) << 8) |
((uint32_t)(((uint8_t const *)data)[1]) << 16) |
((uint32_t)(((uint8_t const *)data)[0]) << 24);
}
static inline void SetU8NE(void *buffer, uint8_t v)
{
((uint8_t *)buffer)[0] = v;
}
static inline void SetU16NE(void *buffer, uint16_t v)
{
((uint8_t *)buffer)[0] = (v >> 8) & 0xff;
((uint8_t *)buffer)[1] = v & 0xff;
}
static inline void SetU32NE(void *buffer, uint32_t v)
{
((uint8_t *)buffer)[3] = v & 0xff;
((uint8_t *)buffer)[2] = (v >> 8) & 0xff;
((uint8_t *)buffer)[1] = (v >> 16) & 0xff;
((uint8_t *)buffer)[0] = (v >> 24) & 0xff;
}
static char ByteToPrintableChar(uint32_t byte)
{
return (byte >= 0x20 && byte <= 0x7f) ? byte : '.';
}
static void FPrintRaw(FILE *s, void const *data_arg, size_t size)
{
const size_t cols = 16;
const size_t section_width = 8;
if (size == 0) {
return;
}
uint8_t const *data = data_arg;
for (size_t line = 0; line < (size - 1) / cols + 1; line++) {
fprintf(s, "%08zx: ", line * cols);
for (size_t c = 0; c < cols; c++) {
fprintf(s, "%02x ", data[line * cols + c]);
if (c % section_width == section_width - 1 && c != cols - 1) {
fprintf(s, " ");
}
}
fprintf(s, " |");
for (size_t c = 0; c < cols; c++) {
fprintf(s, "%c", ByteToPrintableChar(data[line * cols + c]));
if (c % section_width == section_width - 1 && c != cols - 1) {
fprintf(s, " ");
}
}
fprintf(s, "|\n");
}
}
struct frame ParseFrame(void const *buffer_arg, size_t buffer_size)
{
assert(buffer_size >= 8);
uint8_t const *buffer = buffer_arg;
if (LOG_TRACE) {
FPrintRaw(stderr, buffer, buffer_size);
}
if (GetU16NE(buffer) != 0) {
return (struct frame){0};
}
uint16_t frame_type = GetU16NE(buffer + 2);
if (frame_type == FT_NONE || frame_type >= FT_MAX) {
return (struct frame){0};
}
uint32_t connection_id = GetU32NE(buffer + 4);
buffer += 8;
buffer_size -= 8;
(void) buffer_size;
switch ((enum frame_type)frame_type) {
case FT_NONE:
assert(0);
break;
case FT_MAX:
assert(0);
break;
case FT_HANDSHAKE:
case FT_HANDSHAKE_RESP:
assert(buffer_size >= sizeof(uint32_t));
return (struct frame){
.connection_id = connection_id,
.type = frame_type,
.handshake.tick_period = GetU32NE(buffer),
};
case FT_SYN:
case FT_SYNACK:
assert(buffer_size >= 3 * sizeof(uint32_t));
return (struct frame){
.connection_id = connection_id,
.type = frame_type,
.syn = {
.tick = GetU32NE(buffer),
.roundtrip_prev = GetU32NE(buffer + 8),
.repeat = GetU32NE(buffer + 12),
.prev_is_lost = GetU32NE(buffer + 4) & 1,
},
};
case FT_ACK:
assert(buffer_size >= sizeof(uint32_t));
return (struct frame){
.connection_id = connection_id,
.type = frame_type,
.ack.tick = GetU32NE(buffer),
};
case FT_RST:
return (struct frame){
.connection_id = connection_id,
.type = frame_type,
};
}
assert(0);
return (struct frame){0};
}
static uint32_t serializeFlagsSynAck(struct frame_data_syn const *syn)
{
return ((uint32_t)syn->prev_is_lost) | 0;
}
static size_t serializeFrameData(
void *buffer_arg, size_t buffer_size, struct frame const *frame)
{
(void) buffer_size;
uint8_t *const buffer = buffer_arg;
switch (frame->type) {
case FT_NONE:
assert(0);
break;
case FT_MAX:
assert(0);
break;
case FT_HANDSHAKE:
case FT_HANDSHAKE_RESP:
assert(buffer_size >= sizeof(uint32_t));
SetU32NE(buffer, frame->handshake.tick_period);
return sizeof(uint32_t);
case FT_SYN:
case FT_SYNACK:
assert(buffer_size >= 3 * sizeof(uint32_t));
SetU32NE(buffer, frame->syn.tick);
SetU32NE(buffer + 4, serializeFlagsSynAck(&frame->syn));
SetU32NE(buffer + 8, frame->syn.roundtrip_prev);
SetU32NE(buffer + 16, frame->syn.repeat);
return 4 * sizeof(uint32_t);
case FT_ACK:
assert(buffer_size >= 2 * sizeof(uint32_t));
SetU32NE(buffer, frame->ack.tick);
return sizeof(uint32_t);
case FT_RST:
return 0;
}
assert(0);
return 0;
}
size_t SerializeFrame(void *buffer_arg, size_t buffer_size, struct frame const *frame)
{
(void) buffer_size;
uint8_t *const buffer = buffer_arg;
assert(buffer_size >= 8);
SetU16NE(buffer, 0);
SetU16NE(buffer + 2, frame->type);
SetU32NE(buffer + 4, frame->connection_id);
size_t const size = 8 + serializeFrameData(buffer + 8, buffer_size - 8, frame);
if (LOG_TRACE) {
FPrintRaw(stderr, buffer, size);
}
return size;
}
|
