feature: IL2P+CRC

Co-Authored-By: Claude <noreply@anthropic.com>

Author: doismellburning

src/audio.go

@@ -208,6 +208,8 @@ type achan_param_s struct {
 
 	il2p_invert_polarity int // 1 means invert on transmit.  Receive handles either automatically.
 
+	il2p_crc int // 1 to append trailing CRC after IL2P frame, 0 to disable.  Default 1.
+
 	v26_alternative v26_e
 
 	// Original implementation used alternative A for 2400 bbps PSK.

src/config.go

@@ -874,6 +874,7 @@ func config_init(fname string, p_audio_config *audio_s,
 		p_audio_config.achan[channel].layer2_xmit = LAYER2_AX25
 		p_audio_config.achan[channel].il2p_max_fec = 1
 		p_audio_config.achan[channel].il2p_invert_polarity = 0
+		p_audio_config.achan[channel].il2p_crc = 1
 
 		p_audio_config.achan[channel].fix_bits = DEFAULT_FIX_BITS
 		p_audio_config.achan[channel].sanity_test = SANITY_APRS
@@ -2643,6 +2644,7 @@ func config_init(fname string, p_audio_config *audio_s,
 			p_audio_config.achan[channel].layer2_xmit = LAYER2_IL2P
 			p_audio_config.achan[channel].il2p_max_fec = 1
 			p_audio_config.achan[channel].il2p_invert_polarity = 0
+			p_audio_config.achan[channel].il2p_crc = 1
 
 			for {
 				t = split("", false)
@@ -2660,6 +2662,10 @@ func config_init(fname string, p_audio_config *audio_s,
 						p_audio_config.achan[channel].il2p_max_fec = 0
 					case '1':
 						p_audio_config.achan[channel].il2p_max_fec = 1
+					case 'C':
+						p_audio_config.achan[channel].il2p_crc = 1
+					case 'c':
+						p_audio_config.achan[channel].il2p_crc = 0
 					default:
 						text_color_set(DW_COLOR_ERROR)
 						dw_printf("Line %d: Invalid parameter '%c' for IL2PTX command.\n", line, c)

src/il2p.go

@@ -13,4 +13,6 @@ const IL2P_MAX_PAYLOAD_BLOCKS = 5
 const IL2P_MAX_PARITY_SYMBOLS = 16 // For payload only.
 const IL2P_MAX_ENCODED_PAYLOAD_SIZE = (IL2P_MAX_PAYLOAD_SIZE + IL2P_MAX_PAYLOAD_BLOCKS*IL2P_MAX_PARITY_SYMBOLS)
 
-const IL2P_MAX_PACKET_SIZE = (IL2P_SYNC_WORD_SIZE + IL2P_HEADER_SIZE + IL2P_HEADER_PARITY + IL2P_MAX_ENCODED_PAYLOAD_SIZE)
+const IL2P_CRC_ENCODED_SIZE = 4 // 16-bit CRC → 4 Hamming-encoded bytes
+
+const IL2P_MAX_PACKET_SIZE = (IL2P_SYNC_WORD_SIZE + IL2P_HEADER_SIZE + IL2P_HEADER_PARITY + IL2P_MAX_ENCODED_PAYLOAD_SIZE + IL2P_CRC_ENCODED_SIZE)

src/il2p_codec.go

@@ -41,7 +41,10 @@ import (
  *
  *--------------------------------------------------------------*/
 
-func il2p_encode_frame(pp *packet_t, max_fec int) ([]byte, int) {
+func il2p_encode_frame(pp *packet_t, max_fec int, crc ...bool) ([]byte, int) {
+
+	var appendCRC = len(crc) > 0 && crc[0]
+
 	// Can a type 1 header be used?
 	var hdr, e = il2p_type_1_header(pp, max_fec)
 
@@ -56,6 +59,10 @@ func il2p_encode_frame(pp *packet_t, max_fec int) ([]byte, int) {
 
 		if e == 0 {
 			// Success. No info part.
+			if appendCRC {
+				var crcBytes = il2p_crc_encode(il2p_crc_calc(ax25_get_frame_data(pp)))
+				outbuf.Write(crcBytes[:])
+			}
 			return outbuf.Bytes(), outbuf.Len()
 		}
 
@@ -66,6 +73,11 @@ func il2p_encode_frame(pp *packet_t, max_fec int) ([]byte, int) {
 		if k > 0 {
 			outbuf.Write(encodedPayload)
 
+			if appendCRC {
+				var crcBytes = il2p_crc_encode(il2p_crc_calc(ax25_get_frame_data(pp)))
+				outbuf.Write(crcBytes[:])
+			}
+
 			// Success. Info part was <= 1023 bytes.
 			return outbuf.Bytes(), outbuf.Len()
 		}
@@ -93,6 +105,11 @@ func il2p_encode_frame(pp *packet_t, max_fec int) ([]byte, int) {
 			if k > 0 {
 				outbuf.Write(encodedPayload)
 
+				if appendCRC {
+					var crcBytes = il2p_crc_encode(il2p_crc_calc(frame_data))
+					outbuf.Write(crcBytes[:])
+				}
+
 				// Success. Entire AX.25 frame <= 1023 bytes.
 				return outbuf.Bytes(), outbuf.Len()
 			}
@@ -129,11 +146,39 @@ func il2p_encode_frame(pp *packet_t, max_fec int) ([]byte, int) {
  *--------------------------------------------------------------*/
 
 func il2p_decode_frame(irec []byte) *packet_t {
-	var uhdr, e = il2p_clarify_header(irec)
+	var uhdr, e = il2p_clarify_header(irec[:IL2P_HEADER_SIZE+IL2P_HEADER_PARITY])
 
 	// TODO?: for symmetry we might want to clarify the payload before combining.
 
-	return il2p_decode_header_payload(uhdr, irec[IL2P_HEADER_SIZE+IL2P_HEADER_PARITY:], &e)
+	var payload = irec[IL2P_HEADER_SIZE+IL2P_HEADER_PARITY:]
+
+	// Determine if trailing CRC is present by computing the encoded payload size
+	// and checking if there are extra bytes beyond it.
+	var _, max_fec, payload_len = il2p_get_header_attributes(uhdr)
+	var _, encoded_payload_size = il2p_payload_compute(payload_len, max_fec)
+
+	var crc_bytes []byte
+	if len(payload) >= encoded_payload_size+IL2P_CRC_ENCODED_SIZE {
+		crc_bytes = payload[encoded_payload_size : encoded_payload_size+IL2P_CRC_ENCODED_SIZE]
+		payload = payload[:encoded_payload_size]
+	}
+
+	var pp = il2p_decode_header_payload(uhdr, payload, &e)
+
+	// Validate CRC if present.
+	if pp != nil && crc_bytes != nil {
+		var frame_data = ax25_get_frame_data(pp)
+		if !il2p_crc_check(frame_data, crc_bytes) {
+			if il2p_get_debug() >= 1 {
+				text_color_set(DW_COLOR_ERROR)
+				dw_printf("IL2P trailing CRC mismatch.\n")
+			}
+			ax25_delete(pp)
+			return nil
+		}
+	}
+
+	return pp
 }
 
 /*-------------------------------------------------------------

src/il2p_crc.go

@@ -0,0 +1,138 @@
+package direwolf
+
+/*-------------------------------------------------------------
+ *
+ * Purpose:	IL2P Trailing CRC-16-CCITT protected by (7,4) Hamming encoding.
+ *
+ * 		The CRC provides a final validity check after RS FEC decoding,
+ *		catching rare cases where RS decoding silently produces
+ *		incorrect data under extreme error conditions.
+ *
+ * Reference:	IL2P specification v0.6
+ *
+ *--------------------------------------------------------------*/
+
+// Hamming (7,4) encode table from the IL2P spec.
+// Maps 4-bit data nibble to 7-bit Hamming codeword.
+var il2p_hamming_encode = [16]byte{
+	0x00, 0x71, 0x62, 0x13, 0x54, 0x25, 0x36, 0x47,
+	0x38, 0x49, 0x5a, 0x2b, 0x6c, 0x1d, 0x0e, 0x7f,
+}
+
+// Hamming (7,4) decode table from the IL2P spec.
+// Maps 7-bit received codeword to 4-bit data nibble.
+// Provides single-bit error correction.
+var il2p_hamming_decode = [128]byte{
+	0x00, 0x00, 0x00, 0x03, 0x00, 0x05, 0x0e, 0x07,
+	0x00, 0x09, 0x0e, 0x0b, 0x0e, 0x0d, 0x0e, 0x0e,
+	0x00, 0x03, 0x03, 0x03, 0x04, 0x0d, 0x06, 0x03,
+	0x08, 0x0d, 0x0a, 0x03, 0x0d, 0x0d, 0x0e, 0x0d,
+	0x00, 0x05, 0x02, 0x0b, 0x05, 0x05, 0x06, 0x05,
+	0x08, 0x0b, 0x0b, 0x0b, 0x0c, 0x05, 0x0e, 0x0b,
+	0x08, 0x01, 0x06, 0x03, 0x06, 0x05, 0x06, 0x06,
+	0x08, 0x08, 0x08, 0x0b, 0x08, 0x0d, 0x06, 0x0f,
+	0x00, 0x09, 0x02, 0x07, 0x04, 0x07, 0x07, 0x07,
+	0x09, 0x09, 0x0a, 0x09, 0x0c, 0x09, 0x0e, 0x07,
+	0x04, 0x01, 0x0a, 0x03, 0x04, 0x04, 0x04, 0x07,
+	0x0a, 0x09, 0x0a, 0x0a, 0x04, 0x0d, 0x0a, 0x0f,
+	0x02, 0x01, 0x02, 0x02, 0x0c, 0x05, 0x02, 0x07,
+	0x0c, 0x09, 0x02, 0x0b, 0x0c, 0x0c, 0x0c, 0x0f,
+	0x01, 0x01, 0x02, 0x01, 0x04, 0x01, 0x06, 0x0f,
+	0x08, 0x01, 0x0a, 0x0f, 0x0c, 0x0f, 0x0f, 0x0f,
+}
+
+/*-------------------------------------------------------------
+ *
+ * Name:	il2p_crc_calc
+ *
+ * Purpose:	Compute CRC-16-CCITT over AX.25 frame data.
+ *
+ * Inputs:	data	- AX.25 frame bytes (without AX.25 FCS).
+ *
+ * Returns:	16-bit CRC value.
+ *
+ *--------------------------------------------------------------*/
+
+func il2p_crc_calc(data []byte) uint16 {
+	return fcs_calc(data)
+}
+
+/*-------------------------------------------------------------
+ *
+ * Name:	il2p_crc_encode
+ *
+ * Purpose:	Hamming-encode a 16-bit CRC into 4 bytes.
+ *
+ * Inputs:	crc	- 16-bit CRC value.
+ *
+ * Returns:	4 bytes, each containing a Hamming (7,4) encoded nibble.
+ *		High nibble of CRC is encoded first.
+ *
+ *--------------------------------------------------------------*/
+
+func il2p_crc_encode(crc uint16) [IL2P_CRC_ENCODED_SIZE]byte {
+	var encoded [IL2P_CRC_ENCODED_SIZE]byte
+	encoded[0] = il2p_hamming_encode[(crc>>12)&0x0f]
+	encoded[1] = il2p_hamming_encode[(crc>>8)&0x0f]
+	encoded[2] = il2p_hamming_encode[(crc>>4)&0x0f]
+	encoded[3] = il2p_hamming_encode[crc&0x0f]
+	return encoded
+}
+
+/*-------------------------------------------------------------
+ *
+ * Name:	il2p_crc_decode
+ *
+ * Purpose:	Decode 4 Hamming-encoded bytes back to a 16-bit CRC.
+ *
+ * Inputs:	encoded	- 4 bytes of Hamming (7,4) encoded CRC.
+ *
+ * Returns:	16-bit CRC value.
+ *
+ *--------------------------------------------------------------*/
+
+func il2p_crc_decode(encoded []byte) uint16 {
+	var n0 = uint16(il2p_hamming_decode[encoded[0]&0x7f])
+	var n1 = uint16(il2p_hamming_decode[encoded[1]&0x7f])
+	var n2 = uint16(il2p_hamming_decode[encoded[2]&0x7f])
+	var n3 = uint16(il2p_hamming_decode[encoded[3]&0x7f])
+	return (n0 << 12) | (n1 << 8) | (n2 << 4) | n3
+}
+
+/*-------------------------------------------------------------
+ *
+ * Name:	il2p_crc_check
+ *
+ * Purpose:	Validate received Hamming-encoded CRC against AX.25 frame data.
+ *
+ * Inputs:	frame_data   - Decoded AX.25 frame bytes.
+ *		encoded_crc  - 4 bytes of received Hamming-encoded CRC.
+ *
+ * Returns:	true if CRC matches, false otherwise.
+ *
+ *--------------------------------------------------------------*/
+
+func il2p_crc_check(frame_data []byte, encoded_crc []byte) bool {
+	var expected = il2p_crc_calc(frame_data)
+	var received = il2p_crc_decode(encoded_crc)
+	return expected == received
+}
+
+/*-------------------------------------------------------------
+ *
+ * Name:	il2p_crc_enabled
+ *
+ * Purpose:	Check if IL2P trailing CRC is enabled for a channel.
+ *
+ * Inputs:	channel	- Radio channel number.
+ *
+ * Returns:	true if CRC is enabled, false otherwise.
+ *
+ *--------------------------------------------------------------*/
+
+func il2p_crc_enabled(channel int) bool {
+	if save_audio_config_p == nil {
+		return true // Default to enabled if no config available.
+	}
+	return save_audio_config_p.achan[channel].il2p_crc != 0
+}