Move frame counters management to LoRaMacCrypto.

Previously the frame counters were managed at 2 different places which could lead to have them to not be anymore in sync.

LoRaMacFCntHandler.c/h module is completely suppressed.

#606, #573

Author: mluis1

src/apps/LoRaMac/common/NvmCtxMgmt.c

@@ -112,7 +112,6 @@ LoRaMacCtxUpdateStatus_t CtxUpdateStatus = { .Value = 0 };
 /*
  * Nvmm handles
  */
-static NvmmDataBlock_t FCntHandlerNvmCtxDataBlock;
 static NvmmDataBlock_t SecureElementNvmCtxDataBlock;
 static NvmmDataBlock_t CryptoNvmCtxDataBlock;
 #if ( MAX_PERSISTENT_CTX_MGMT_ENABLED == 1 )
@@ -164,11 +163,6 @@ void NvmCtxMgmtEvent( LoRaMacNvmCtxModule_t module )
             CtxUpdateStatus.Elements.ConfirmQueue = 1;
             break;
         }
-        case LORAMAC_NVMCTXMODULE_FCNT_HANDLER:
-        {
-            CtxUpdateStatus.Elements.FCntHandlerNvmCtx = 1;
-            break;
-        }
         default:
         {
             break;
@@ -213,14 +207,6 @@ NvmCtxMgmtStatus_t NvmCtxMgmtStore( void )
         }
     }
 
-    if( CtxUpdateStatus.Elements.FCntHandlerNvmCtx == 1 )
-    {
-        if( NvmmWrite( &FCntHandlerNvmCtxDataBlock, MacContexts->FCntHandlerNvmCtx, MacContexts->FCntHandlerNvmCtxSize ) != NVMM_SUCCESS )
-        {
-            return NVMCTXMGMT_STATUS_FAIL;
-        }
-    }
-
 #if ( MAX_PERSISTENT_CTX_MGMT_ENABLED == 1 )
     if( CtxUpdateStatus.Elements.Mac == 1 )
     {
@@ -288,7 +274,6 @@ NvmCtxMgmtStatus_t NvmCtxMgmtRestore( void )
 
     uint8_t NvmCryptoCtxRestore[mibReq.Param.Contexts->CryptoNvmCtxSize];
     uint8_t NvmSecureElementCtxRestore[mibReq.Param.Contexts->SecureElementNvmCtxSize];
-    uint8_t NvmFCntHandlerCtxRestore[mibReq.Param.Contexts->FCntHandlerNvmCtxSize];
 #if ( MAX_PERSISTENT_CTX_MGMT_ENABLED == 1 )
     uint8_t NvmMacCtxRestore[mibReq.Param.Contexts->MacNvmCtxSize];
     uint8_t NvmRegionCtxRestore[mibReq.Param.Contexts->RegionNvmCtxSize];
@@ -319,17 +304,6 @@ NvmCtxMgmtStatus_t NvmCtxMgmtRestore( void )
         status = NVMCTXMGMT_STATUS_FAIL;
     }
 
-    if ( NvmmDeclare( &FCntHandlerNvmCtxDataBlock, mibReq.Param.Contexts->FCntHandlerNvmCtxSize ) == NVMM_SUCCESS )
-    {
-        NvmmRead( &FCntHandlerNvmCtxDataBlock, NvmFCntHandlerCtxRestore, mibReq.Param.Contexts->FCntHandlerNvmCtxSize );
-        contexts.FCntHandlerNvmCtx = &NvmFCntHandlerCtxRestore;
-        contexts.FCntHandlerNvmCtxSize = mibReq.Param.Contexts->FCntHandlerNvmCtxSize;
-    }
-    else
-    {
-        status = NVMCTXMGMT_STATUS_FAIL;
-    }
-
 #if ( MAX_PERSISTENT_CTX_MGMT_ENABLED == 1 )
     if( NvmmDeclare( &MacNvmCtxDataBlock, mibReq.Param.Contexts->MacNvmCtxSize ) == NVMM_SUCCESS )
     {

src/mac/LoRaMac.c

@@ -41,7 +41,6 @@
 #include "LoRaMacHeaderTypes.h"
 #include "LoRaMacMessageTypes.h"
 #include "LoRaMacParser.h"
-#include "LoRaMacFCntHandler.h"
 #include "LoRaMacCommands.h"
 #include "LoRaMacAdr.h"
 
@@ -444,6 +443,22 @@ static void OnAckTimeoutTimerEvent( void* context );
  */
 static void SetMlmeScheduleUplinkIndication( void );
 
+/*!
+ * Computes next 32 bit downlink counter value and determines the frame counter ID.
+ *
+ * \param[IN]     addrID                - Address identifier
+ * \param[IN]     fType                 - Frame type
+ * \param[IN]     macMsg                - Data message object, holding the current 16 bit transmitted frame counter
+ * \param[IN]     lrWanVersion          - LoRaWAN version
+ * \param[IN]     maxFCntGap            - Maximum allowed frame counter difference (only for 1.0.X necessary)
+ * \param[OUT]    fCntID                - Frame counter identifier
+ * \param[OUT]    currentDown           - Current downlink counter value
+ *
+ * \retval                              - Status of the operation
+ */
+static LoRaMacCryptoStatus_t GetFCntDown( AddressIdentifier_t addrID, FType_t fType, LoRaMacMessageData_t* macMsg, Version_t lrWanVersion,
+                                          uint16_t maxFCntGap, FCntIdentifier_t* fCntID, uint32_t* currentDown );
+
 /*!
  * \brief Switches the device class
  *
@@ -716,11 +731,6 @@ static void EventClassBNvmCtxChanged( void );
  */
 static void EventConfirmQueueNvmCtxChanged( void );
 
-/*!
- * \brief FCnt Handler module nvm context has been changed
- */
-static void EventFCntHandlerNvmCtxChanged( void );
-
 /*!
  * \brief Verifies if a request is pending currently
  *
@@ -942,7 +952,6 @@ static void ProcessRadioRxDone( void )
     uint32_t address = MacCtx.NvmCtx->DevAddr;
     uint8_t multicast = 0;
     AddressIdentifier_t addrID = UNICAST_DEV_ADDR;
-    LoRaMacFCntHandlerStatus_t fCntHandlerStatus;
     FCntIdentifier_t fCntID;
 
     MacCtx.McpsConfirm.AckReceived = false;
@@ -1124,10 +1133,10 @@ static void ProcessRadioRxDone( void )
             phyParam = RegionGetPhyParam( MacCtx.NvmCtx->Region, &getPhy );
 
             // Get downlink frame counter value
-            fCntHandlerStatus = LoRaMacGetFCntDown( addrID, fType, &macMsgData, MacCtx.NvmCtx->Version, phyParam.Value, &fCntID, &downLinkCounter );
-            if( fCntHandlerStatus != LORAMAC_FCNT_HANDLER_SUCCESS )
+            macCryptoStatus = GetFCntDown( addrID, fType, &macMsgData, MacCtx.NvmCtx->Version, phyParam.Value, &fCntID, &downLinkCounter );
+            if( macCryptoStatus != LORAMAC_CRYPTO_SUCCESS )
             {
-                if( fCntHandlerStatus == LORAMAC_FCNT_HANDLER_CHECK_FAIL )
+                if( macCryptoStatus == LORAMAC_CRYPTO_FAIL_FCNT_DUPLICATED )
                 {
                     // Catch the case of repeated downlink frame counter
                     MacCtx.McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_DOWNLINK_REPEATED;
@@ -1136,7 +1145,7 @@ static void ProcessRadioRxDone( void )
                         MacCtx.NvmCtx->SrvAckRequested = true;
                     }
                 }
-                else if( fCntHandlerStatus == LORAMAC_FCNT_HANDLER_MAX_GAP_FAIL )
+                else if( macCryptoStatus == LORAMAC_CRYPTO_FAIL_MAX_GAP_FCNT )
                 {
                     // Lost too many frames
                     MacCtx.McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_DOWNLINK_TOO_MANY_FRAMES_LOSS;
@@ -1205,14 +1214,6 @@ static void ProcessRadioRxDone( void )
                 }
             }
 
-            // Update downlink counter in mac context / multicast context.
-            if( LORAMAC_FCNT_HANDLER_SUCCESS != LoRaMacSetFCntDown( fCntID, downLinkCounter ) )
-            {
-                MacCtx.McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_ERROR;
-                PrepareRxDoneAbort( );
-                return;
-            }
-
             RemoveMacCommands( MacCtx.McpsIndication.RxSlot, macMsgData.FHDR.FCtrl, MacCtx.McpsConfirm.McpsRequest );
 
             switch( fType )
@@ -1752,6 +1753,54 @@ static void OnAckTimeoutTimerEvent( void* context )
     }
 }
 
+static LoRaMacCryptoStatus_t GetFCntDown( AddressIdentifier_t addrID, FType_t fType, LoRaMacMessageData_t* macMsg, Version_t lrWanVersion,
+                                          uint16_t maxFCntGap, FCntIdentifier_t* fCntID, uint32_t* currentDown )
+{
+    if( ( macMsg == NULL ) || ( fCntID == NULL ) ||
+        ( currentDown == NULL ) )
+    {
+        return LORAMAC_CRYPTO_ERROR_NPE;
+    }
+
+    // Determine the frame counter identifier and choose counter from FCntList
+    switch( addrID )
+    {
+        case UNICAST_DEV_ADDR:
+            if( lrWanVersion.Fields.Minor == 1 )
+            {
+                if( ( fType == FRAME_TYPE_A ) || ( fType == FRAME_TYPE_D ) )
+                {
+                    *fCntID = A_FCNT_DOWN;
+                }
+                else
+                {
+                    *fCntID = N_FCNT_DOWN;
+                }
+            }
+            else
+            { // For LoRaWAN 1.0.X
+                *fCntID = FCNT_DOWN;
+            }
+            break;
+        case MULTICAST_0_ADDR:
+            *fCntID = MC_FCNT_DOWN_0;
+            break;
+        case MULTICAST_1_ADDR:
+            *fCntID = MC_FCNT_DOWN_1;
+            break;
+        case MULTICAST_2_ADDR:
+            *fCntID = MC_FCNT_DOWN_2;
+            break;
+        case MULTICAST_3_ADDR:
+            *fCntID = MC_FCNT_DOWN_3;
+            break;
+        default:
+            return LORAMAC_CRYPTO_FAIL_FCNT_ID;
+    }
+
+    return LoRaMacCryptoGetFCntDown( *fCntID, maxFCntGap, macMsg->FHDR.FCnt, currentDown );
+}
+
 static LoRaMacStatus_t SwitchClass( DeviceClass_t deviceClass )
 {
     LoRaMacStatus_t status = LORAMAC_STATUS_PARAMETER_INVALID;
@@ -2419,11 +2468,16 @@ static LoRaMacStatus_t SecureFrame( uint8_t txDr, uint8_t txCh )
             break;
         case LORAMAC_MSG_TYPE_DATA:
 
-            if( LORAMAC_FCNT_HANDLER_SUCCESS != LoRaMacGetFCntUp( &fCntUp ) )
+            if( LORAMAC_CRYPTO_SUCCESS != LoRaMacCryptoGetFCntUp( &fCntUp ) )
             {
                 return LORAMAC_STATUS_FCNT_HANDLER_ERROR;
             }
 
+            if( ( MacCtx.ChannelsNbTransCounter >= 1 ) || ( MacCtx.AckTimeoutRetriesCounter > 1 ) )
+            {
+                fCntUp -= 1;
+            }
+
             macCryptoStatus = LoRaMacCryptoSecureMessage( fCntUp, txDr, txCh, &MacCtx.TxMsg.Message.Data );
             if( LORAMAC_CRYPTO_SUCCESS != macCryptoStatus )
             {
@@ -2497,9 +2551,6 @@ static void ResetMacParameters( void )
     // ADR counter
     MacCtx.NvmCtx->AdrAckCounter = 0;
 
-    // Initialize the uplink and downlink counters default value
-    LoRaMacResetFCnts( );
-
     MacCtx.ChannelsNbTransCounter = 0;
     MacCtx.AckTimeoutRetries = 1;
     MacCtx.AckTimeoutRetriesCounter = 1;
@@ -2600,11 +2651,11 @@ LoRaMacStatus_t PrepareFrame( LoRaMacHeader_t* macHdr, LoRaMacFrameCtrl_t* fCtrl
             MacCtx.TxMsg.Message.Data.FRMPayloadSize = MacCtx.AppDataSize;
             MacCtx.TxMsg.Message.Data.FRMPayload = MacCtx.AppData;
 
-            if( LORAMAC_FCNT_HANDLER_SUCCESS != LoRaMacGetFCntUp( &fCntUp ) )
+            if( LORAMAC_CRYPTO_SUCCESS != LoRaMacCryptoGetFCntUp( &fCntUp ) )
             {
                 return LORAMAC_STATUS_FCNT_HANDLER_ERROR;
             }
-            MacCtx.TxMsg.Message.Data.FHDR.FCnt = ( uint16_t ) fCntUp;
+            MacCtx.TxMsg.Message.Data.FHDR.FCnt = ( uint16_t )fCntUp;
 
             // Reset confirm parameters
             MacCtx.McpsConfirm.NbRetries = 0;
@@ -2781,7 +2832,6 @@ LoRaMacCtxs_t* GetCtxs( void )
     Contexts.CommandsNvmCtx = LoRaMacCommandsGetNvmCtx( &Contexts.CommandsNvmCtxSize );
     Contexts.ClassBNvmCtx = LoRaMacClassBGetNvmCtx( &Contexts.ClassBNvmCtxSize );
     Contexts.ConfirmQueueNvmCtx = LoRaMacConfirmQueueGetNvmCtx( &Contexts.ConfirmQueueNvmCtxSize );
-    Contexts.FCntHandlerNvmCtx = LoRaMacFCntHandlerGetNvmCtx( &Contexts.FCntHandlerNvmCtxSize );
     return &Contexts;
 }
 
@@ -2816,11 +2866,6 @@ LoRaMacStatus_t RestoreCtxs( LoRaMacCtxs_t* contexts )
         return LORAMAC_STATUS_CRYPTO_ERROR;
     }
 
-    if( LoRaMacFCntHandlerRestoreNvmCtx( contexts->FCntHandlerNvmCtx ) != LORAMAC_FCNT_HANDLER_SUCCESS )
-    {
-        return LORAMAC_STATUS_FCNT_HANDLER_ERROR;
-    }
-
     if( LoRaMacCommandsRestoreNvmCtx( contexts->CommandsNvmCtx ) != LORAMAC_COMMANDS_SUCCESS )
     {
         return LORAMAC_STATUS_MAC_COMMAD_ERROR;
@@ -2938,17 +2983,6 @@ static bool CheckRetransConfirmedUplink( void )
 
 static bool StopRetransmission( void )
 {
-    // Increase the current value by 1
-    uint32_t fCntUp = 0;
-    if( LORAMAC_FCNT_HANDLER_SUCCESS != LoRaMacGetFCntUp( &fCntUp ) )
-    {
-        return false;
-    }
-    if( LORAMAC_FCNT_HANDLER_SUCCESS != LoRaMacSetFCntUp( ( fCntUp ) ) )
-    {
-        return false;
-    }
-
     if( MacCtx.MacFlags.Bits.McpsInd == 0 )
     {   // Maximum repetitions without downlink. Increase ADR Ack counter.
         // Only process the case when the MAC did not receive a downlink.
@@ -3043,11 +3077,6 @@ static void EventConfirmQueueNvmCtxChanged( void )
     CallNvmCtxCallback( LORAMAC_NVMCTXMODULE_CONFIRM_QUEUE );
 }
 
-static void EventFCntHandlerNvmCtxChanged( void )
-{
-    CallNvmCtxCallback( LORAMAC_NVMCTXMODULE_FCNT_HANDLER );
-}
-
 static uint8_t IsRequestPending( void )
 {
     if( ( MacCtx.MacFlags.Bits.MlmeReq == 1 ) ||
@@ -3245,15 +3274,12 @@ LoRaMacStatus_t LoRaMacInitialization( LoRaMacPrimitives_t* primitives, LoRaMacC
         return LORAMAC_STATUS_MAC_COMMAD_ERROR;
     }
 
-    // Initialize FCnt Handler module
-    if( LoRaMacFCntHandlerInit( EventFCntHandlerNvmCtxChanged ) != LORAMAC_FCNT_HANDLER_SUCCESS )
+    // Set multicast downlink counter reference
+    if( LoRaMacCryptoSetMulticastReference( MacCtx.NvmCtx->MulticastChannelList ) != LORAMAC_CRYPTO_SUCCESS )
     {
-        return LORAMAC_STATUS_FCNT_HANDLER_ERROR;
+        return LORAMAC_STATUS_CRYPTO_ERROR;
     }
 
-    // Set multicast downlink counter reference
-    LoRaMacFCntHandlerSetMulticastReference( MacCtx.NvmCtx->MulticastChannelList );
-
     // Random seed initialization
     srand1( Radio.Random( ) );
 

src/mac/LoRaMac.h

@@ -308,14 +308,6 @@ typedef struct sLoRaMacCtxs
      * \brief   Size of MLME Confirm queue module context
      */
     size_t ConfirmQueueNvmCtxSize;
-    /*!
-     * \brief   Pointer to FCnt handler module context
-     */
-    void* FCntHandlerNvmCtx;
-    /*!
-     * \brief   Size of FCnt handler module context
-     */
-    size_t FCntHandlerNvmCtxSize;
 }LoRaMacCtxs_t;
 
 /*!
@@ -2264,10 +2256,6 @@ typedef enum LoRaMacNvmCtxModule_e
      * Context for the confirm queue
      */
     LORAMAC_NVMCTXMODULE_CONFIRM_QUEUE,
-    /*!
-     * Context for the frame count handler
-     */
-    LORAMAC_NVMCTXMODULE_FCNT_HANDLER
 }LoRaMacNvmCtxModule_t;