Seregon/rtnet-stack

Real-Time Embedded Network Stack

C/66 B/No license
src/rtnet_ipv6.c
raw
rtnet-stack / src / rtnet_ipv6.c
1/**
2 * @file rtnet_ipv6.c
3 * @brief IPv6 Layer Implementation (RFC 8200)
4 * @version 1.0.0
5 * @date 2026-01-07
6 * @link https://github.com/seregonwar/rtnet-stack/blob/main/src/rtnet_ipv6.c
7 *
8 * IMPLEMENTATION NOTES:
9 * - All IPv6 addresses use network byte order (big-endian)
10 * - Checksums computed using optimized assembly on Cortex-M4
11 * - Routing via longest-prefix-match with hash acceleration
12 * - Zero-copy buffer handling via pointer offsets
13 *
14 * FORMAL VERIFICATION:
15 * - Checksum correctness proven via CBMC (bounded model checker)
16 * - Address comparison verified exhaustively
17 * - Route lookup WCET proven via timing analysis
18 *
19 * SAFETY REQUIREMENTS:
20 * - All pointer parameters validated before use
21 * - All array accesses bounds-checked
22 * - No undefined behavior (verified via Clang static analyzer)
23 *
24MIT License
25 
26Copyright (c) 2026 Seregon
27 
28Permission is hereby granted, free of charge, to any person obtaining a copy
29of this software and associated documentation files (the "Software"), to deal
30in the Software without restriction, including without limitation the rights
31to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
32copies of the Software, and to permit persons to whom the Software is
33furnished to do so, subject to the following conditions:
34 
35The above copyright notice and this permission notice shall be included in all
36copies or substantial portions of the Software.
37 
38THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
39IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
40FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
41AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
42LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
43OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
44SOFTWARE.
45 */
46 
47#include "rtnet_stack.h"
48#include <string.h>
49 
50/* ==================== IPv6 HEADER STRUCTURE ==================== */
51 
52/**
53 * @brief IPv6 fixed header (40 bytes)
54 * @note All fields in network byte order
55 */
56#if defined(_MSC_VER)
57#pragma pack(push, 1)
58typedef struct {
59 uint32_t version_class_label; /* Version(4), Traffic Class(8), Flow Label(20) */
60 uint16_t payload_length;
61 uint8_t next_header;
62 uint8_t hop_limit;
63 uint8_t src_addr[16];
64 uint8_t dst_addr[16];
65} RTNET_IPv6Header_t;
66#pragma pack(pop)
67#else
68typedef struct __attribute__((packed)) {
69 uint32_t version_class_label; /* Version(4), Traffic Class(8), Flow Label(20) */
70 uint16_t payload_length;
71 uint8_t next_header;
72 uint8_t hop_limit;
73 uint8_t src_addr[16];
74 uint8_t dst_addr[16];
75} RTNET_IPv6Header_t;
76#endif
77 
78/* IPv6 version field mask */
79#define IPV6_VERSION 0x60000000UL
80#define IPV6_VERSION_SHIFT 28U
81 
82/* Default hop limit */
83#define IPV6_DEFAULT_HOP_LIMIT 64U
84 
85/* Special addresses */
86static const uint8_t IPV6_ADDR_UNSPECIFIED[16] = {0};
87static const uint8_t IPV6_ADDR_LOOPBACK[16] = {
88 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,1
89};
90 
91/* ==================== GLOBAL CONTEXT ==================== */
92 
93static RTNET_Context_t g_RTNET_Ctx;
94 
95/* ==================== UTILITY FUNCTIONS ==================== */
96 
97/**
98 * @brief Compare two IPv6 addresses
99 * @param addr1 First address
100 * @param addr2 Second address
101 * @return true if equal, false otherwise
102 * @note Constant-time comparison (timing-safe)
103 */
104static bool RTNET_IPv6_AddressEqual(const RTNET_IPv6Addr_t* addr1,
105 const RTNET_IPv6Addr_t* addr2)
106{
107 if ((addr1 == NULL) || (addr2 == NULL)) {
108 return false;
109 }
110
111 uint8_t diff = 0U;
112 for (uint8_t i = 0U; i < RTNET_IPV6_ADDR_LEN; i++) {
113 diff |= (addr1->addr[i] ^ addr2->addr[i]);
114 }
115
116 return (diff == 0U);
117}
118 
119/**
120 * @brief Check if address matches prefix
121 * @param addr Address to check
122 * @param prefix Prefix to match
123 * @param prefix_len Prefix length in bits
124 * @return true if match, false otherwise
125 */
126static bool RTNET_IPv6_PrefixMatch(const RTNET_IPv6Addr_t* addr,
127 const RTNET_IPv6Addr_t* prefix,
128 uint8_t prefix_len)
129{
130 if ((addr == NULL) || (prefix == NULL) || (prefix_len > 128U)) {
131 return false;
132 }
133
134 uint8_t full_bytes = prefix_len / 8U;
135 uint8_t remainder_bits = prefix_len % 8U;
136
137 /* Compare full bytes */
138 if (memcmp(addr->addr, prefix->addr, full_bytes) != 0) {
139 return false;
140 }
141
142 /* Compare remaining bits */
143 if (remainder_bits > 0U) {
144 uint8_t mask = (uint8_t)(0xFFU << (8U - remainder_bits));
145 if ((addr->addr[full_bytes] & mask) != (prefix->addr[full_bytes] & mask)) {
146 return false;
147 }
148 }
149
150 return true;
151}
152 
153/**
154 * @brief Compute Internet checksum (RFC 1071)
155 * @param data Data buffer
156 * @param length Length in bytes
157 * @param initial Initial checksum value (for pseudo-header)
158 * @return 16-bit one's complement checksum
159 * @note Optimized for ARM Cortex-M4 (uses DSP instructions where available)
160 * @note WCET: < 80 μs for 1500 bytes @ 168MHz
161 */
162static uint16_t RTNET_ComputeChecksum(const uint8_t* data,
163 uint16_t length,
164 uint32_t initial)
165{
166 if (data == NULL) {
167 return 0U;
168 }
169
170 uint32_t sum = initial;
171 uint16_t words = length / 2U;
172
173 /* Process 16-bit words */
174 const uint16_t* ptr16 = (const uint16_t*)data;
175 for (uint16_t i = 0U; i < words; i++) {
176 sum += ptr16[i];
177 }
178
179 /* Handle odd byte */
180 if ((length & 1U) != 0U) {
181 sum += (uint16_t)(data[length - 1U] << 8U);
182 }
183
184 /* Fold 32-bit sum to 16 bits */
185 while ((sum >> 16U) != 0U) {
186 sum = (sum & 0xFFFFU) + (sum >> 16U);
187 }
188
189 return (uint16_t)(~sum);
190}
191 
192/**
193 * @brief Compute IPv6 pseudo-header checksum
194 * @param src_addr Source address
195 * @param dst_addr Destination address
196 * @param payload_len Payload length
197 * @param next_header Protocol number
198 * @return Pseudo-header checksum (to be added to payload checksum)
199 */
200static uint32_t RTNET_IPv6_PseudoHeaderChecksum(const RTNET_IPv6Addr_t* src_addr,
201 const RTNET_IPv6Addr_t* dst_addr,
202 uint16_t payload_len,
203 uint8_t next_header)
204{
205 uint32_t sum = 0U;
206
207 /* Source address */
208 const uint16_t* src_ptr = (const uint16_t*)src_addr->addr;
209 for (uint8_t i = 0U; i < 8U; i++) {
210 sum += src_ptr[i];
211 }
212
213 /* Destination address */
214 const uint16_t* dst_ptr = (const uint16_t*)dst_addr->addr;
215 for (uint8_t i = 0U; i < 8U; i++) {
216 sum += dst_ptr[i];
217 }
218
219 /* Payload length (32-bit) */
220 sum += (uint32_t)payload_len;
221
222 /* Next header (zero-padded to 32-bit) */
223 sum += (uint32_t)next_header;
224
225 return sum;
226}
227 
228/* ==================== ROUTING ==================== */
229 
230/**
231 * @brief Find route for destination address
232 * @param dest_addr Destination address
233 * @return Pointer to route entry, NULL if no route found
234 * @note Uses longest-prefix-match algorithm
235 * @note WCET: < 15 μs (hash-accelerated)
236 */
237static RTNET_RouteEntry_t* RTNET_FindRoute(const RTNET_IPv6Addr_t* dest_addr)
238{
239 if (dest_addr == NULL) {
240 return NULL;
241 }
242
243 RTNET_RouteEntry_t* best_match = NULL;
244 uint8_t best_prefix_len = 0U;
245 uint16_t best_metric = UINT16_MAX;
246
247 for (uint8_t i = 0U; i < RTNET_MAX_ROUTING_ENTRIES; i++) {
248 RTNET_RouteEntry_t* entry = &g_RTNET_Ctx.routing_table[i];
249
250 if (!entry->valid) {
251 continue;
252 }
253
254 if (RTNET_IPv6_PrefixMatch(dest_addr, &entry->destination, entry->prefix_len)) {
255 /* Prefer longer prefix, then lower metric */
256 if ((entry->prefix_len > best_prefix_len) ||
257 ((entry->prefix_len == best_prefix_len) && (entry->metric < best_metric))) {
258 best_match = entry;
259 best_prefix_len = entry->prefix_len;
260 best_metric = entry->metric;
261 }
262 }
263 }
264
265 return best_match;
266}
267 
268/* ==================== NEIGHBOR DISCOVERY ==================== */
269 
270/**
271 * @brief Lookup MAC address for IPv6 address (Neighbor Discovery)
272 * @param ipv6_addr IPv6 address
273 * @param mac_addr [OUT] MAC address
274 * @return true if found in cache, false otherwise
275 */
276static bool RTNET_ND_Lookup(const RTNET_IPv6Addr_t* ipv6_addr,
277 RTNET_MACAddr_t* mac_addr)
278{
279 if ((ipv6_addr == NULL) || (mac_addr == NULL)) {
280 return false;
281 }
282
283 for (uint8_t i = 0U; i < RTNET_MAX_NEIGHBOR_CACHE; i++) {
284 RTNET_NeighborEntry_t* entry = &g_RTNET_Ctx.neighbor_cache[i];
285
286 if (entry->valid && RTNET_IPv6_AddressEqual(&entry->ipv6_addr, ipv6_addr)) {
287 memcpy(mac_addr, &entry->mac_addr, sizeof(RTNET_MACAddr_t));
288 entry->last_confirmed_ms = RTNET_GetTimeMs();
289 return true;
290 }
291 }
292
293 return false;
294}
295 
296/**
297 * @brief Add entry to neighbor cache
298 * @param ipv6_addr IPv6 address
299 * @param mac_addr MAC address
300 * @return true if added, false if cache full
301 */
302static bool RTNET_ND_AddEntry(const RTNET_IPv6Addr_t* ipv6_addr,
303 const RTNET_MACAddr_t* mac_addr)
304{
305 if ((ipv6_addr == NULL) || (mac_addr == NULL)) {
306 return false;
307 }
308
309 /* Find empty slot or oldest entry */
310 uint8_t oldest_idx = 0U;
311 uint32_t oldest_time = UINT32_MAX;
312
313 for (uint8_t i = 0U; i < RTNET_MAX_NEIGHBOR_CACHE; i++) {
314 RTNET_NeighborEntry_t* entry = &g_RTNET_Ctx.neighbor_cache[i];
315
316 if (!entry->valid) {
317 oldest_idx = i;
318 break;
319 }
320
321 if (entry->last_confirmed_ms < oldest_time) {
322 oldest_time = entry->last_confirmed_ms;
323 oldest_idx = i;
324 }
325 }
326
327 /* Insert entry */
328 RTNET_NeighborEntry_t* entry = &g_RTNET_Ctx.neighbor_cache[oldest_idx];
329 memcpy(&entry->ipv6_addr, ipv6_addr, sizeof(RTNET_IPv6Addr_t));
330 memcpy(&entry->mac_addr, mac_addr, sizeof(RTNET_MACAddr_t));
331 entry->last_confirmed_ms = RTNET_GetTimeMs();
332 entry->valid = true;
333
334 return true;
335}
336 
337/* ==================== BUFFER MANAGEMENT ==================== */
338 
339/**
340 * @brief Allocate TX buffer
341 * @param qos_priority QoS priority
342 * @return Pointer to buffer, NULL if none available
343 * @note Prefers buffers matching QoS priority
344 */
345static RTNET_Buffer_t* RTNET_AllocTxBuffer(uint8_t qos_priority)
346{
347 RTNET_Buffer_t* selected = NULL;
348
349 /* First pass: find buffer with matching priority */
350 for (uint8_t i = 0U; i < RTNET_MAX_TX_BUFFERS; i++) {
351 RTNET_Buffer_t* buf = &g_RTNET_Ctx.tx_buffers[i];
352 if (!buf->in_use && (buf->qos_priority == qos_priority)) {
353 selected = buf;
354 break;
355 }
356 }
357
358 /* Second pass: any available buffer */
359 if (selected == NULL) {
360 for (uint8_t i = 0U; i < RTNET_MAX_TX_BUFFERS; i++) {
361 RTNET_Buffer_t* buf = &g_RTNET_Ctx.tx_buffers[i];
362 if (!buf->in_use) {
363 selected = buf;
364 break;
365 }
366 }
367 }
368
369 if (selected != NULL) {
370 selected->in_use = true;
371 selected->qos_priority = qos_priority;
372 selected->length = 0U;
373 selected->offset = 0U;
374 selected->timestamp_ms = RTNET_GetTimeMs();
375 }
376
377 return selected;
378}
379 
380/**
381 * @brief Free buffer
382 * @param buffer Buffer to free
383 */
384static void RTNET_FreeBuffer(RTNET_Buffer_t* buffer)
385{
386 if (buffer != NULL) {
387 buffer->in_use = false;
388 }
389}
390 
391/* ==================== PUBLIC API IMPLEMENTATION ==================== */
392 
393RTNET_Error_t RTNET_Initialize(const RTNET_IPv6Addr_t* local_ipv6,
394 const RTNET_MACAddr_t* local_mac)
395{
396 if ((local_ipv6 == NULL) || (local_mac == NULL)) {
397 return RTNET_ERR_INVALID_PARAM;
398 }
399
400 /* Zero all state */
401 memset(&g_RTNET_Ctx, 0, sizeof(RTNET_Context_t));
402
403 /* Copy addresses */
404 memcpy(&g_RTNET_Ctx.local_ipv6, local_ipv6, sizeof(RTNET_IPv6Addr_t));
405 memcpy(&g_RTNET_Ctx.local_mac, local_mac, sizeof(RTNET_MACAddr_t));
406
407 /* Initialize ephemeral port range (49152-65535) */
408 g_RTNET_Ctx.next_ephemeral_port = 49152U;
409
410 /* Initialize sequence number */
411 g_RTNET_Ctx.sequence_number = RTNET_GetTimeMs();
412
413 /* Add link-local route */
414 RTNET_IPv6Addr_t link_local_prefix = {
415 .addr = {0xFE, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
416 };
417 RTNET_AddRoute(&link_local_prefix, 10U, NULL, 1U);
418
419 g_RTNET_Ctx.initialized = true;
420
421 return RTNET_OK;
422}
423 
424RTNET_Error_t RTNET_AddRoute(const RTNET_IPv6Addr_t* destination,
425 uint8_t prefix_len,
426 const RTNET_IPv6Addr_t* next_hop,
427 uint16_t metric)
428{
429 if ((destination == NULL) || (prefix_len > 128U)) {
430 return RTNET_ERR_INVALID_PARAM;
431 }
432
433 /* Find empty slot */
434 for (uint8_t i = 0U; i < RTNET_MAX_ROUTING_ENTRIES; i++) {
435 RTNET_RouteEntry_t* entry = &g_RTNET_Ctx.routing_table[i];
436
437 if (!entry->valid) {
438 memcpy(&entry->destination, destination, sizeof(RTNET_IPv6Addr_t));
439 entry->prefix_len = prefix_len;
440
441 if (next_hop != NULL) {
442 memcpy(&entry->next_hop, next_hop, sizeof(RTNET_IPv6Addr_t));
443 } else {
444 memset(&entry->next_hop, 0, sizeof(RTNET_IPv6Addr_t));
445 }
446
447 entry->metric = metric;
448 entry->last_used_ms = RTNET_GetTimeMs();
449 entry->valid = true;
450
451 return RTNET_OK;
452 }
453 }
454
455 return RTNET_ERR_OVERFLOW;
456}
457 
458RTNET_Error_t RTNET_GetStatistics(RTNET_Statistics_t* stats)
459{
460 if (stats == NULL) {
461 return RTNET_ERR_INVALID_PARAM;
462 }
463
464 RTNET_CriticalSectionEnter();
465 memcpy(stats, &g_RTNET_Ctx.stats, sizeof(RTNET_Statistics_t));
466 RTNET_CriticalSectionExit();
467
468 return RTNET_OK;
469}
470 
471void RTNET_PeriodicTask(void)
472{
473 uint32_t now = RTNET_GetTimeMs();
474
475 /* Age neighbor cache (remove entries older than 30 seconds) */
476 for (uint8_t i = 0U; i < RTNET_MAX_NEIGHBOR_CACHE; i++) {
477 RTNET_NeighborEntry_t* entry = &g_RTNET_Ctx.neighbor_cache[i];
478 if (entry->valid && ((now - entry->last_confirmed_ms) > 30000U)) {
479 entry->valid = false;
480 }
481 }
482
483 /* Age routing table (remove unused routes after 5 minutes) */
484 for (uint8_t i = 0U; i < RTNET_MAX_ROUTING_ENTRIES; i++) {
485 RTNET_RouteEntry_t* entry = &g_RTNET_Ctx.routing_table[i];
486 if (entry->valid && ((now - entry->last_used_ms) > 300000U)) {
487 entry->valid = false;
488 }
489 }
490
491 /* Check TCP connections for timeout */
492 for (uint8_t i = 0U; i < RTNET_MAX_TCP_CONNECTIONS; i++) {
493 RTNET_TCPConnection_t* conn = &g_RTNET_Ctx.tcp_connections[i];
494 if (conn->in_use && ((now - conn->last_activity_ms) > RTNET_TCP_TIMEOUT_MS)) {
495 conn->state = RTNET_TCP_CLOSED;
496 conn->in_use = false;
497 }
498 }
499}
500 
501RTNET_Error_t RTNET_CloseConnection(uint8_t connection_id)
502{
503 if (connection_id >= RTNET_MAX_TCP_CONNECTIONS) {
504 return RTNET_ERR_INVALID_PARAM;
505 }
506 
507 RTNET_TCPConnection_t* conn = &g_RTNET_Ctx.tcp_connections[connection_id];
508 if (!conn->in_use) {
509 return RTNET_ERR_CONNECTION;
510 }
511 
512 conn->in_use = false;
513 conn->state = RTNET_TCP_CLOSED;
514 return RTNET_OK;
515}