refactor: make codec layer fully header-only (#23)

* refactor: merge codec cpp files into headers (fully header-only library)

Co-authored-by: petesramek <2333452+petesramek@users.noreply.github.com>
Agent-Logs-Url: https://github.com/petesramek/tiny-link/sessions/822fb91b-cc43-4f24-8888-79646c3eda00

* fix: restore static inline on packet_size per code review

Co-authored-by: petesramek <2333452+petesramek@users.noreply.github.com>
Agent-Logs-Url: https://github.com/petesramek/tiny-link/sessions/822fb91b-cc43-4f24-8888-79646c3eda00

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: petesramek <2333452+petesramek@users.noreply.github.com>

Author: Copilot

src/internal/codec/CobsCodec.cpp

@@ -1,6 +1,6 @@
 /**
  * @file CobsCodec.h
- * @brief COBS (Consistent Overhead Byte Stuffing) encode/decode API.
+ * @brief COBS (Consistent Overhead Byte Stuffing) encode/decode implementation.
  *
  * AVR-friendly – no STL dependencies.
  */
@@ -23,7 +23,44 @@ namespace codec {
  * @param dstCap Capacity of dst in bytes.
  * @return Number of bytes written to dst, or 0 on error (dstCap too small).
  */
-size_t cobs_encode(const uint8_t* src, size_t srcLen, uint8_t* dst, size_t dstCap);
+inline size_t cobs_encode(const uint8_t* src, size_t srcLen, uint8_t* dst, size_t dstCap) {
+    // Worst-case encoded length: srcLen + (srcLen / 254) + 1
+    // A safe upper bound is srcLen + 2 (holds for srcLen <= 253).
+    // For larger inputs the +1 per 254-byte block is handled by the
+    // overflow check inside the loop.
+    if (dstCap == 0) return 0;
+
+    size_t read_idx = 0, write_idx = 1, code_idx = 0;
+    uint8_t code = 1;
+
+    while (read_idx < srcLen) {
+        if (src[read_idx] == 0) {
+            if (code_idx >= dstCap) return 0;
+            dst[code_idx] = code;
+            code = 1;
+            code_idx = write_idx;
+            if (write_idx >= dstCap) return 0;
+            write_idx++;
+        } else {
+            if (write_idx >= dstCap) return 0;
+            dst[write_idx++] = src[read_idx];
+            code++;
+            if (code == 0xFF) {
+                if (code_idx >= dstCap) return 0;
+                dst[code_idx] = code;
+                code = 1;
+                code_idx = write_idx;
+                if (write_idx >= dstCap) return 0;
+                write_idx++;
+            }
+        }
+        read_idx++;
+    }
+
+    if (code_idx >= dstCap) return 0;
+    dst[code_idx] = code;
+    return write_idx;
+}
 
 /**
  * @brief Decode a COBS-encoded byte buffer.
@@ -34,7 +71,28 @@ size_t cobs_encode(const uint8_t* src, size_t srcLen, uint8_t* dst, size_t dstCa
  * @param dstCap Capacity of dst in bytes.
  * @return Number of bytes written to dst, or 0 on invalid frame / buffer overflow.
  */
-size_t cobs_decode(const uint8_t* src, size_t srcLen, uint8_t* dst, size_t dstCap);
+inline size_t cobs_decode(const uint8_t* src, size_t srcLen, uint8_t* dst, size_t dstCap) {
+    size_t read_idx = 0, write_idx = 0;
+
+    while (read_idx < srcLen) {
+        uint8_t code = src[read_idx++];
+
+        if (code == 0 || (read_idx + code - 1) > srcLen)
+            return 0;  // Invalid frame
+
+        for (uint8_t i = 1; i < code; i++) {
+            if (write_idx >= dstCap) return 0;
+            dst[write_idx++] = src[read_idx++];
+        }
+
+        if (code < 0xFF && read_idx < srcLen) {
+            if (write_idx >= dstCap) return 0;
+            dst[write_idx++] = 0;
+        }
+    }
+
+    return write_idx;
+}
 
 } // namespace codec
 } // namespace tinylink

src/internal/codec/CobsCodec.h

@@ -1,6 +1,6 @@
 /**
  * @file Fletcher16.h
- * @brief Fletcher-16 checksum declaration.
+ * @brief Fletcher-16 checksum implementation.
  *
  * AVR-friendly – no STL dependencies.
  */
@@ -24,7 +24,23 @@ namespace codec {
  * @param len  Number of bytes to process.
  * @return (sum2 << 8) | sum1
  */
-uint16_t fletcher16(const uint8_t* data, size_t len);
+inline uint16_t fletcher16(const uint8_t* data, size_t len) {
+    uint16_t sum1 = 0xff, sum2 = 0xff;
+
+    while (len) {
+        size_t tlen = len > 20 ? 20 : len;
+        len -= tlen;
+        do {
+            sum1 += *data++;
+            sum2 += sum1;
+        } while (--tlen);
+
+        sum1 = (sum1 & 0xff) + (sum1 >> 8);
+        sum2 = (sum2 & 0xff) + (sum2 >> 8);
+    }
+
+    return (sum2 << 8) | sum1;
+}
 
 } // namespace codec
 } // namespace tinylink

src/internal/codec/Fletcher16.cpp

@@ -3,6 +3,8 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include <string.h>
+#include "Fletcher16.h"
 
 namespace tinylink {
 namespace packet {
@@ -13,15 +15,51 @@ static inline size_t packet_size(size_t payloadLen) {
 }
 
 // Pack a packet into out (outCap >= packet_size(payloadLen)). Returns bytes written or 0 on error.
-size_t pack(uint8_t type, uint8_t seq,
-            const uint8_t* payload, size_t payloadLen,
-            uint8_t* out, size_t outCap);
+inline size_t pack(uint8_t type, uint8_t seq,
+                   const uint8_t* payload, size_t payloadLen,
+                   uint8_t* out, size_t outCap)
+{
+    size_t need = packet_size(payloadLen);
+    if (!out || outCap < need) return 0;
+
+    out[0] = type;
+    out[1] = seq;
+    out[2] = (uint8_t)payloadLen;
+    if (payloadLen && payload) memcpy(&out[3], payload, payloadLen);
+
+    // compute checksum over header+payload
+    uint16_t chk = tinylink::codec::fletcher16(out, 3 + payloadLen);
+    out[3 + payloadLen + 0] = (uint8_t)(chk & 0xFF);
+    out[3 + payloadLen + 1] = (uint8_t)((chk >> 8) & 0xFF);
+    return need;
+}
 
 // Unpack a packet. On success returns payload length (>0) and fills outType/outSeq/outPayload (if non-null).
 // Returns 0 on error (malformed, length mismatch, checksum failure, or insufficient outPayloadCap).
-size_t unpack(const uint8_t* src, size_t srcLen,
-              uint8_t* outType, uint8_t* outSeq,
-              uint8_t* outPayload, size_t outPayloadCap);
+inline size_t unpack(const uint8_t* src, size_t srcLen,
+                     uint8_t* outType, uint8_t* outSeq,
+                     uint8_t* outPayload, size_t outPayloadCap)
+{
+    if (!src || srcLen < 5) return 0; // min header + checksum
+
+    uint8_t payloadLen = src[2];
+    size_t expected = packet_size(payloadLen);
+    if (srcLen != expected) return 0;
+
+    uint16_t recv = (uint16_t)src[3 + payloadLen + 0] | (uint16_t(src[3 + payloadLen + 1]) << 8);
+    uint16_t calc = tinylink::codec::fletcher16(src, 3 + payloadLen);
+    if (calc != recv) return 0;
+
+    if (outType) *outType = src[0];
+    if (outSeq) *outSeq = src[1];
+
+    if (outPayload) {
+        if (outPayloadCap < payloadLen) return 0;
+        if (payloadLen) memcpy(outPayload, &src[3], payloadLen);
+    }
+
+    return payloadLen;
+}
 
 } // namespace packet
 } // namespace tinylink