Merge pull request #460 from nasa/385-operational-sas-for-testing-in-nos3

Donnie-Ice · web-flow · commit 952a1e9f902f · 2025-07-02T17:00:00.000-04:00
WIP [#385] Operational sas for testing in nos3
diff --git a/src/core/crypto_config.c b/src/core/crypto_config.c
@@ -88,13 +88,36 @@ int32_t Crypto_SC_Init(void)
 
     // TM
     GvcidManagedParameters_t TM_UT_Managed_Parameters = {
-        0, 0x0003, 1, TM_HAS_FECF, AOS_FHEC_NA, AOS_IZ_NA, 0, TM_SEGMENT_HDRS_NA, 1786, TM_NO_OCF, 1};
+        0, 0x0003, 1, TM_NO_FECF, AOS_FHEC_NA, AOS_IZ_NA, 0, TM_SEGMENT_HDRS_NA, 1786, TM_NO_OCF, 1};
     Crypto_Config_Add_Gvcid_Managed_Parameters(TM_UT_Managed_Parameters);
     TM_UT_Managed_Parameters.vcid = 4;
     Crypto_Config_Add_Gvcid_Managed_Parameters(TM_UT_Managed_Parameters);
     TM_UT_Managed_Parameters.vcid = 5;
     Crypto_Config_Add_Gvcid_Managed_Parameters(TM_UT_Managed_Parameters);
     status = Crypto_Init();
+
+    SecurityAssociation_t *sa_ptr = NULL;
+    sa_if->sa_get_from_spi(1, &sa_ptr);
+    sa_ptr->gvcid_blk.vcid = 0;
+    sa_if->sa_get_from_spi(2, &sa_ptr);
+    sa_ptr->gvcid_blk.vcid = 2;
+    sa_if->sa_get_from_spi(3, &sa_ptr);
+    sa_ptr->sa_state       = SA_OPERATIONAL;
+    sa_ptr->gvcid_blk.vcid = 3;
+    sa_ptr->abm_len        = ABM_SIZE;
+    sa_if->sa_get_from_spi(5, &sa_ptr);
+    sa_ptr->sa_state       = SA_OPERATIONAL;
+    sa_ptr->shsnf_len      = 0;
+    sa_ptr->arsn_len       = 0;
+    sa_ptr->gvcid_blk.vcid = 1;
+    sa_if->sa_get_from_spi(6, &sa_ptr);
+    sa_ptr->sa_state       = SA_OPERATIONAL;
+    sa_ptr->gvcid_blk.vcid = 4;
+    sa_if->sa_get_from_spi(7, &sa_ptr);
+    sa_ptr->sa_state       = SA_OPERATIONAL;
+    sa_ptr->abm_len        = ABM_SIZE;
+    sa_ptr->gvcid_blk.vcid = 5;
+
     return status;
 }
 
diff --git a/src/core/crypto_tm.c b/src/core/crypto_tm.c
@@ -927,7 +927,8 @@ int32_t Crypto_TM_ApplySecurity(uint8_t *pTfBuffer, uint16_t len_ingest)
     printf("Actual secondary header length: %d\n", secondary_hdr_len);
 #endif
     // Only validate SHVN if secondary header is present
-    if (idx > secondary_hdr_start && shvn > 0) // SHVN is 2 bits, 0b00 is the only allowed value
+
+    if (idx > secondary_hdr_start && shvn != 0) // SHVN is 2 bits, so max value is 3
     {
         status = CRYPTO_LIB_ERR_TM_SECONDARY_HDR_VN;
         mc_if->mc_log(status);
diff --git a/src/sa/internal/sa_interface_inmemory.template.c b/src/sa/internal/sa_interface_inmemory.template.c
@@ -346,7 +346,7 @@ void sa_populate(void)
     sa[5].gvcid_blk.tfvn  = 0;
     sa[5].gvcid_blk.scid  = SCID & 0x3FF;
     sa[5].gvcid_blk.vcid  = 1;
-    sa[5].gvcid_blk.mapid = TYPE_TM;
+    sa[5].gvcid_blk.mapid = TYPE_TC;
 
     // TM - Encryption Only - AES-CBC-256 (Keyed)
     // IV = 0...0, IV-Len = 16, TFVN = 0, VCID = 0; MAC-Len = 0, ARSNW = 5
@@ -368,7 +368,7 @@ void sa_populate(void)
     sa[6].gvcid_blk.tfvn  = 0;
     sa[6].gvcid_blk.scid  = SCID & 0x3FF;
     sa[6].gvcid_blk.vcid  = 0;
-    sa[6].gvcid_blk.mapid = TYPE_TM;
+    sa[6].gvcid_blk.mapid = TYPE_TC;
 
     // TM - Authentication Only HMAC_SHA512 (Keyed)
     // IV = 0...0, IV-Len = 12, MAC-Len = 16, TFVN = 0, VCID = 0, ARSNW = 5
@@ -390,7 +390,7 @@ void sa_populate(void)
     sa[7].gvcid_blk.tfvn  = 0;
     sa[7].gvcid_blk.scid  = SCID & 0x3FF;
     sa[7].gvcid_blk.vcid  = 0;
-    sa[7].gvcid_blk.mapid = TYPE_TM;
+    sa[7].gvcid_blk.mapid = TYPE_TC;
 
     // TM - Authenticated Encryption AES-CBC-256 (Keyed)
     // IV = 0...0, IV-Len = 16, MAC-Len = 16, TFVN = 0, VCID = 0, ARSNW = 5
@@ -413,7 +413,7 @@ void sa_populate(void)
     sa[8].gvcid_blk.tfvn  = 0;
     sa[8].gvcid_blk.scid  = SCID & 0x3FF;
     sa[8].gvcid_blk.vcid  = 0;
-    sa[8].gvcid_blk.mapid = TYPE_TM;
+    sa[8].gvcid_blk.mapid = TYPE_TC;
 
     // AOS - Clear Mode
     // IV = 0...0, IV-Len = 12, MAC-Len = 0, TFVN = 1, VCID = 0, ARSNW = 5
@@ -546,7 +546,7 @@ void sa_populate(void)
     sa[15].arsn_len        = 2;
     sa[15].gvcid_blk.tfvn  = 2;
     sa[15].gvcid_blk.scid  = SCID & 0x3FF;
-    sa[15].gvcid_blk.vcid  = 3;
+    sa[15].gvcid_blk.vcid  = 7;
     sa[15].gvcid_blk.mapid = TYPE_TC;
 
     sa_perform_save(&sa[0]);
diff --git a/support/standalone/standalone.c b/support/standalone/standalone.c
@@ -163,7 +163,7 @@ int32_t crypto_standalone_process_command(int32_t cc, int32_t num_tokens, char *
                     {
                         Crypto_saPrint(test_association);
                     }
-
+                    printf("Get_SA_Status: %d\n", status);
                     if ((status == CRYPTO_LIB_SUCCESS) && (test_association->sa_state == SA_OPERATIONAL) &&
                         (test_association->gvcid_blk.mapid == TYPE_TC) && (test_association->gvcid_blk.scid == SCID))
                     {
@@ -372,14 +372,10 @@ void crypto_standalone_tc_frame(uint8_t *in_data, uint16_t in_length, uint8_t *o
     /* TC Length */
     if (DYNAMIC_LENGTHS)
     {
-        uint8_t segment_hdr_len = tc_current_managed_parameters_struct.has_segmentation_hdr ? 1 : 0;
+        uint8_t segment_hdr_len = 1;
         uint8_t fecf_len        = tc_current_managed_parameters_struct.has_fecf ? 2 : 0;
 
-        SecurityAssociation_t *sa_ptr;
-        sa_if->sa_get_from_spi(tc_vcid, &sa_ptr);
-
-        *out_length = TC_FRAME_HEADER_SIZE + segment_hdr_len + sa_ptr->arsn_len + sa_ptr->shivf_len +
-                      sa_ptr->shplf_len + sa_ptr->shsnf_len + in_length + sa_ptr->stmacf_len + fecf_len;
+        *out_length = TC_FRAME_HEADER_SIZE + segment_hdr_len + in_length + fecf_len;
     }
     else
     {
@@ -525,8 +521,9 @@ void crypto_standalone_tm_frame(uint8_t *in_data, uint16_t in_length, uint8_t *o
     }
 
     // Calculate security headers and trailers
-    uint8_t header_length = TM_PRI_HDR_LENGTH + SDLS_SPI_LENGTH + sa_ptr->shivf_len + sa_ptr->shplf_len +
-                            sa_ptr->shsnf_len; // TODO: Why +40?
+    uint8_t header_length =
+        TM_PRI_HDR_LENGTH + SDLS_SPI_LENGTH + sa_ptr->shivf_len + sa_ptr->shplf_len + sa_ptr->shsnf_len;
+
     uint8_t trailer_length = sa_ptr->stmacf_len;
     if (tm_current_managed_parameters_struct.has_fecf == TM_HAS_FECF)
     {
@@ -571,85 +568,76 @@ void crypto_standalone_tm_debug_process(uint8_t *tm_process_in)
     }
 }
 
-void crypto_standalone_spp_telem_or_idle(int32_t *status_p, uint8_t *tm_ptr, uint16_t *spp_len_p,
-                                         udp_interface_t *tm_socks, int *tm_process_len_p)
+void crypto_standalone_spp_telem_or_idle(int32_t *status, uint8_t *tm_ptr, uint16_t *spp_len, udp_interface_t *tm_socks,
+                                         int *tm_process_len)
 {
-    int32_t  status         = *status_p;
-    uint16_t spp_len        = *spp_len_p;
-    int      tm_process_len = *tm_process_len_p;
-
     udp_info_t *tm_write_sock = &tm_socks->write;
 
     if ((tm_ptr[0] == 0x08) || (tm_ptr[0] == 0x09) || ((tm_ptr[0] == 0x07) && (tm_ptr[1] == 0xff)) ||
-        (tm_ptr[0] == 0x0F && tm_ptr[1] == 0xFD) || (tm_ptr[0] == 0x1F && tm_ptr[1] == 0xFD))
+        (tm_ptr[0] == 0x0F && tm_ptr[1] == 0xFD))
     {
-        spp_len = (((0xFFFF & tm_ptr[4]) << 8) | tm_ptr[5]) + 7;
+        *spp_len = (((0xFFFF & tm_ptr[4]) << 8) | tm_ptr[5]) + 7;
 #ifdef CRYPTO_STANDALONE_TM_PROCESS_DEBUG
-        printf("crypto_standalone_tm_process - SPP[%d]: 0x", spp_len);
-        for (int i = 0; i < spp_len; i++)
+        printf("crypto_standalone_tm_process - SPP[%d]: 0x", *spp_len);
+        for (int i = 0; i < *spp_len; i++)
         {
             printf("%02x", tm_ptr[i]);
         }
         printf("\n");
 #endif
-
         // Send all SPP telemetry packets
         // 0x09 for HK/Device TLM Packets (Generic Components)
+        // 0x0FFD = CFDP
         if (tm_ptr[0] == 0x08 || tm_ptr[0] == 0x09 || (tm_ptr[0] == 0x0f && tm_ptr[1] == 0xfd))
         {
-            status = sendto(tm_write_sock->sockfd, tm_ptr, spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,
-                            sizeof(tm_write_sock->saddr));
+            *status = sendto(tm_write_sock->sockfd, tm_ptr, *spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,
+                             sizeof(tm_write_sock->saddr));
         }
         // Only send idle packets if configured to do so
         else
         {
 #ifdef CRYPTO_STANDALONE_DISCARD_IDLE_PACKETS
             // Don't forward idle packets
-            status = spp_len;
+            *status = *spp_len;
 #else
-            status = sendto(tm_write_sock->sockfd, tm_ptr, spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,
+            status = sendto(tm_write_sock->sockfd, tm_ptr, *spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,
                             sizeof(tm_write_sock->saddr));
 #endif
         }
 
         // Check status
-        if ((status == -1) || (status != spp_len))
+        if ((*status == -1) || (*status != *spp_len))
         {
-            printf("crypto_standalone_tm_process - Reply error %d \n", status);
+            printf("crypto_standalone_tm_process - Reply error %d \n", *status);
         }
-        tm_ptr         = &tm_ptr[spp_len];
-        tm_process_len = tm_process_len - spp_len;
+
+        *tm_process_len -= *spp_len;
     }
     else if ((tm_ptr[0] == 0xFF && tm_ptr[1] == 0x48) || (tm_ptr[0] == 0x00 && tm_ptr[1] == 0x00) ||
-             (tm_ptr[0] == 0x02 && tm_ptr[1] == 0x00) || (tm_ptr[0] == 0xFF && tm_ptr[1] == 0xFF) ||
-             (tm_ptr[0] == 0x1F && tm_ptr[1] == 0xFE))
+             (tm_ptr[0] == 0x02 && tm_ptr[1] == 0x00) || (tm_ptr[0] == 0xFF && tm_ptr[1] == 0xFF))
     {
         // TODO: Why 0x0200?
         // Idle Frame
         // Idle Frame is entire length of remaining data
 #ifdef CRYPTO_STANDALONE_DISCARD_IDLE_FRAMES
         // Don't forward idle frame
-        status = spp_len;
+        *status = *spp_len;
 #else
-        status = sendto(tm_write_sock->sockfd, tm_ptr, spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,
+        status = sendto(tm_write_sock->sockfd, tm_ptr, *spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,
                         sizeof(tm_write_sock->saddr));
-        if ((status == -1) || (status != spp_len))
+        if ((status == -1) || (status != *spp_len))
         {
-            printf("crypto_standalone_tm_process - Reply error %d \n", status);
+            printf("crypto_standalone_tm_process - Reply error %d \n", *status);
         }
-        tm_ptr = &tm_ptr[spp_len];
 #endif
-        tm_process_len = 0;
+        *tm_process_len = 0;
     }
     else
     {
         printf("crypto_standalone_tm_process - SPP loop error, expected idle packet or frame! tm_ptr = 0x%02x%02x \n",
                tm_ptr[0], tm_ptr[1]);
-        tm_process_len = 0;
+        *tm_process_len = 0;
     }
-    *status_p         = status;
-    *spp_len_p        = spp_len;
-    *tm_process_len_p = tm_process_len;
 }
 
 void *crypto_standalone_tm_process(void *socks)
@@ -747,6 +735,7 @@ void *crypto_standalone_tm_process(void *socks)
                 {
                     // SPP Telemetry OR SPP Idle Packet
                     crypto_standalone_spp_telem_or_idle(&status, tm_ptr, &spp_len, tm_socks, &tm_process_len);
+                    tm_ptr = &tm_ptr[spp_len];
                 }
             }
             else
@@ -757,13 +746,14 @@ void *crypto_standalone_tm_process(void *socks)
             /* Reset */
             memset(tm_process_in, 0x00, sizeof(tm_process_in));
             tm_process_len = 0;
+            memset(tm_ptr, 0x00, sizeof(tm_process_in));
 #ifdef CRYPTO_STANDALONE_TM_PROCESS_DEBUG
             printf("\n");
 #endif
         }
 
         /* Delay */
-        usleep(100);
+        usleep(10);
     }
     close(tm_read_sock->port);
     close(tm_write_sock->port);
diff --git a/test/unit/ut_sa_save.c b/test/unit/ut_sa_save.c
@@ -622,7 +622,7 @@ UTEST(SA_SAVE, VERIFY_SAVE_ADJACENT)
     ASSERT_EQ(test_association->gvcid_blk.tfvn, 0);
     ASSERT_EQ(test_association->gvcid_blk.scid, 3);
     ASSERT_EQ(test_association->gvcid_blk.vcid, 1);
-    ASSERT_EQ(test_association->gvcid_blk.mapid, 2);
+    ASSERT_EQ(test_association->gvcid_blk.mapid, 0);
     ASSERT_EQ(test_association->est, 0);
     ASSERT_EQ(test_association->ast, 0);
     ASSERT_EQ(test_association->shivf_len, 12);
diff --git a/test/unit/ut_tm_apply.c b/test/unit/ut_tm_apply.c
@@ -2087,7 +2087,8 @@ UTEST(TM_APPLY_ENC_VAL, AEAD_AES_GCM_BITMASK_1)
     hex_conversion(next_iv_h, &next_iv_b, &next_iv_len);
     ASSERT_EQ(next_iv_len, iv_len);
 
-    Crypto_TM_ApplySecurity((uint8_t *)framed_tm_b, framed_tm_len);
+    status = Crypto_TM_ApplySecurity((uint8_t *)framed_tm_b, framed_tm_len);
+    ASSERT_EQ(status, CRYPTO_LIB_SUCCESS);
 
     printf("Static frame contents:\n\t");
     for (int i = 0; i < 1786; i++)

Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ int32_t crypto_standalone_process_command(int32_t cc, int32_t num_tokens, char *`
`163`	`163`	`{`
`164`	`164`	`Crypto_saPrint(test_association);`
`165`	`165`	`}`
`166`		`-`
	`166`	`+ printf("Get_SA_Status: %d\n", status);`
`167`	`167`	`if ((status == CRYPTO_LIB_SUCCESS) && (test_association->sa_state == SA_OPERATIONAL) &&`
`168`	`168`	`(test_association->gvcid_blk.mapid == TYPE_TC) && (test_association->gvcid_blk.scid == SCID))`
`169`	`169`	`{`
`@@ -372,14 +372,10 @@ void crypto_standalone_tc_frame(uint8_t in_data, uint16_t in_length, uint8_t o`
`372`	`372`	`/* TC Length */`
`373`	`373`	`if (DYNAMIC_LENGTHS)`
`374`	`374`	`{`
`375`		`- uint8_t segment_hdr_len = tc_current_managed_parameters_struct.has_segmentation_hdr ? 1 : 0;`
	`375`	`+ uint8_t segment_hdr_len = 1;`
`376`	`376`	`uint8_t fecf_len = tc_current_managed_parameters_struct.has_fecf ? 2 : 0;`
`377`	`377`
`378`		`- SecurityAssociation_t *sa_ptr;`
`379`		`- sa_if->sa_get_from_spi(tc_vcid, &sa_ptr);`
`380`		`-`
`381`		`- *out_length = TC_FRAME_HEADER_SIZE + segment_hdr_len + sa_ptr->arsn_len + sa_ptr->shivf_len +`
`382`		`- sa_ptr->shplf_len + sa_ptr->shsnf_len + in_length + sa_ptr->stmacf_len + fecf_len;`
	`378`	`+ *out_length = TC_FRAME_HEADER_SIZE + segment_hdr_len + in_length + fecf_len;`
`383`	`379`	`}`
`384`	`380`	`else`
`385`	`381`	`{`
`@@ -525,8 +521,9 @@ void crypto_standalone_tm_frame(uint8_t in_data, uint16_t in_length, uint8_t o`
`525`	`521`	`}`
`526`	`522`
`527`	`523`	`// Calculate security headers and trailers`
`528`		`- uint8_t header_length = TM_PRI_HDR_LENGTH + SDLS_SPI_LENGTH + sa_ptr->shivf_len + sa_ptr->shplf_len +`
`529`		`- sa_ptr->shsnf_len; // TODO: Why +40?`
	`524`	`+ uint8_t header_length =`
	`525`	`+ TM_PRI_HDR_LENGTH + SDLS_SPI_LENGTH + sa_ptr->shivf_len + sa_ptr->shplf_len + sa_ptr->shsnf_len;`
	`526`	`+`
`530`	`527`	`uint8_t trailer_length = sa_ptr->stmacf_len;`
`531`	`528`	`if (tm_current_managed_parameters_struct.has_fecf == TM_HAS_FECF)`
`532`	`529`	`{`
`@@ -571,85 +568,76 @@ void crypto_standalone_tm_debug_process(uint8_t *tm_process_in)`
`571`	`568`	`}`
`572`	`569`	`}`
`573`	`570`
`574`		`-void crypto_standalone_spp_telem_or_idle(int32_t status_p, uint8_t tm_ptr, uint16_t *spp_len_p,`
`575`		`- udp_interface_t tm_socks, int tm_process_len_p)`
	`571`	`+void crypto_standalone_spp_telem_or_idle(int32_t status, uint8_t tm_ptr, uint16_t spp_len, udp_interface_t tm_socks,`
	`572`	`+ int *tm_process_len)`
`576`	`573`	`{`
`577`		`- int32_t status = *status_p;`
`578`		`- uint16_t spp_len = *spp_len_p;`
`579`		`- int tm_process_len = *tm_process_len_p;`
`580`		`-`
`581`	`574`	`udp_info_t *tm_write_sock = &tm_socks->write;`
`582`	`575`
`583`	`576`	`if ((tm_ptr[0] == 0x08) \|\| (tm_ptr[0] == 0x09) \|\| ((tm_ptr[0] == 0x07) && (tm_ptr[1] == 0xff)) \|\|`
`584`		`- (tm_ptr[0] == 0x0F && tm_ptr[1] == 0xFD) \|\| (tm_ptr[0] == 0x1F && tm_ptr[1] == 0xFD))`
	`577`	`+ (tm_ptr[0] == 0x0F && tm_ptr[1] == 0xFD))`
`585`	`578`	`{`
`586`		`- spp_len = (((0xFFFF & tm_ptr[4]) << 8) \| tm_ptr[5]) + 7;`
	`579`	`+ *spp_len = (((0xFFFF & tm_ptr[4]) << 8) \| tm_ptr[5]) + 7;`
`587`	`580`	`#ifdef CRYPTO_STANDALONE_TM_PROCESS_DEBUG`
`588`		`- printf("crypto_standalone_tm_process - SPP[%d]: 0x", spp_len);`
`589`		`- for (int i = 0; i < spp_len; i++)`
	`581`	`+ printf("crypto_standalone_tm_process - SPP[%d]: 0x", *spp_len);`
	`582`	`+ for (int i = 0; i < *spp_len; i++)`
`590`	`583`	`{`
`591`	`584`	`printf("%02x", tm_ptr[i]);`
`592`	`585`	`}`
`593`	`586`	`printf("\n");`
`594`	`587`	`#endif`
`595`		`-`
`596`	`588`	`// Send all SPP telemetry packets`
`597`	`589`	`// 0x09 for HK/Device TLM Packets (Generic Components)`
	`590`	`+ // 0x0FFD = CFDP`
`598`	`591`	`if (tm_ptr[0] == 0x08 \|\| tm_ptr[0] == 0x09 \|\| (tm_ptr[0] == 0x0f && tm_ptr[1] == 0xfd))`
`599`	`592`	`{`
`600`		`- status = sendto(tm_write_sock->sockfd, tm_ptr, spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,`
`601`		`- sizeof(tm_write_sock->saddr));`
	`593`	`+ status = sendto(tm_write_sock->sockfd, tm_ptr, spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,`
	`594`	`+ sizeof(tm_write_sock->saddr));`
`602`	`595`	`}`
`603`	`596`	`// Only send idle packets if configured to do so`
`604`	`597`	`else`
`605`	`598`	`{`
`606`	`599`	`#ifdef CRYPTO_STANDALONE_DISCARD_IDLE_PACKETS`
`607`	`600`	`// Don't forward idle packets`
`608`		`- status = spp_len;`
	`601`	`+ status = spp_len;`
`609`	`602`	`#else`
`610`		`- status = sendto(tm_write_sock->sockfd, tm_ptr, spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,`
	`603`	`+ status = sendto(tm_write_sock->sockfd, tm_ptr, spp_len, 0, (struct sockaddr )&tm_write_sock->saddr,`
`611`	`604`	`sizeof(tm_write_sock->saddr));`
`612`	`605`	`#endif`
`613`	`606`	`}`
`614`	`607`
`615`	`608`	`// Check status`
`616`		`- if ((status == -1) \|\| (status != spp_len))`
	`609`	`+ if ((status == -1) \|\| (status != *spp_len))`
`617`	`610`	`{`
`618`		`- printf("crypto_standalone_tm_process - Reply error %d \n", status);`
	`611`	`+ printf("crypto_standalone_tm_process - Reply error %d \n", *status);`
`619`	`612`	`}`
`620`		`- tm_ptr = &tm_ptr[spp_len];`
`621`		`- tm_process_len = tm_process_len - spp_len;`
	`613`	`+`
	`614`	`+ tm_process_len -= spp_len;`
`622`	`615`	`}`
`623`	`616`	`else if ((tm_ptr[0] == 0xFF && tm_ptr[1] == 0x48) \|\| (tm_ptr[0] == 0x00 && tm_ptr[1] == 0x00) \|\|`
`624`		`- (tm_ptr[0] == 0x02 && tm_ptr[1] == 0x00) \|\| (tm_ptr[0] == 0xFF && tm_ptr[1] == 0xFF) \|\|`
`625`		`- (tm_ptr[0] == 0x1F && tm_ptr[1] == 0xFE))`
	`617`	`+ (tm_ptr[0] == 0x02 && tm_ptr[1] == 0x00) \|\| (tm_ptr[0] == 0xFF && tm_ptr[1] == 0xFF))`
`626`	`618`	`{`
`627`	`619`	`// TODO: Why 0x0200?`
`628`	`620`	`// Idle Frame`
`629`	`621`	`// Idle Frame is entire length of remaining data`
`630`	`622`	`#ifdef CRYPTO_STANDALONE_DISCARD_IDLE_FRAMES`
`631`	`623`	`// Don't forward idle frame`
`632`		`- status = spp_len;`
	`624`	`+ status = spp_len;`
`633`	`625`	`#else`
`634`		`- status = sendto(tm_write_sock->sockfd, tm_ptr, spp_len, 0, (struct sockaddr *)&tm_write_sock->saddr,`
	`626`	`+ status = sendto(tm_write_sock->sockfd, tm_ptr, spp_len, 0, (struct sockaddr )&tm_write_sock->saddr,`
`635`	`627`	`sizeof(tm_write_sock->saddr));`
`636`		`- if ((status == -1) \|\| (status != spp_len))`
	`628`	`+ if ((status == -1) \|\| (status != *spp_len))`
`637`	`629`	`{`
`638`		`- printf("crypto_standalone_tm_process - Reply error %d \n", status);`
	`630`	`+ printf("crypto_standalone_tm_process - Reply error %d \n", *status);`
`639`	`631`	`}`
`640`		`- tm_ptr = &tm_ptr[spp_len];`
`641`	`632`	`#endif`
`642`		`- tm_process_len = 0;`
	`633`	`+ *tm_process_len = 0;`
`643`	`634`	`}`
`644`	`635`	`else`
`645`	`636`	`{`
`646`	`637`	`printf("crypto_standalone_tm_process - SPP loop error, expected idle packet or frame! tm_ptr = 0x%02x%02x \n",`
`647`	`638`	`tm_ptr[0], tm_ptr[1]);`
`648`		`- tm_process_len = 0;`
	`639`	`+ *tm_process_len = 0;`
`649`	`640`	`}`
`650`		`- *status_p = status;`
`651`		`- *spp_len_p = spp_len;`
`652`		`- *tm_process_len_p = tm_process_len;`
`653`	`641`	`}`
`654`	`642`
`655`	`643`	`void crypto_standalone_tm_process(void socks)`
`@@ -747,6 +735,7 @@ void crypto_standalone_tm_process(void socks)`
`747`	`735`	`{`
`748`	`736`	`// SPP Telemetry OR SPP Idle Packet`
`749`	`737`	`crypto_standalone_spp_telem_or_idle(&status, tm_ptr, &spp_len, tm_socks, &tm_process_len);`
	`738`	`+ tm_ptr = &tm_ptr[spp_len];`
`750`	`739`	`}`
`751`	`740`	`}`
`752`	`741`	`else`
`@@ -757,13 +746,14 @@ void crypto_standalone_tm_process(void socks)`
`757`	`746`	`/* Reset */`
`758`	`747`	`memset(tm_process_in, 0x00, sizeof(tm_process_in));`
`759`	`748`	`tm_process_len = 0;`
	`749`	`+ memset(tm_ptr, 0x00, sizeof(tm_process_in));`
`760`	`750`	`#ifdef CRYPTO_STANDALONE_TM_PROCESS_DEBUG`
`761`	`751`	`printf("\n");`
`762`	`752`	`#endif`
`763`	`753`	`}`
`764`	`754`
`765`	`755`	`/* Delay */`
`766`		`- usleep(100);`
	`756`	`+ usleep(10);`
`767`	`757`	`}`
`768`	`758`	`close(tm_read_sock->port);`
`769`	`759`	`close(tm_write_sock->port);`