Fix/Suppress more misra violations

alfred2g · alfred2g · commit 2b59b8aa8518 · 2022-07-29T11:58:14.000-07:00
diff --git a/MISRA.md b/MISRA.md
@@ -135,6 +135,13 @@ _Ref 17.2.1_
         have a secondary child socket thereby limiting the number of recursive
         calls to one.
 
+#### Rule 20.5
+_Ref 20.5.1_
+
+- MISRA C-2012 Rule 20.10 warns against the use of #undef
+        However, in this case, it must be used to make sure some macros are
+        defined to a certain value
+
 #### Rule 20.10
 _Ref 20.10.1_
 
diff --git a/source/FreeRTOS_IP.c b/source/FreeRTOS_IP.c
@@ -1171,7 +1171,7 @@ eFrameProcessingResult_t eConsiderFrameForProcessing( const uint8_t * const pucE
     /* Map the buffer onto Ethernet Header struct for easy access to fields. */
 
     /* MISRA Ref 11.3.1 [Misaligned access] */
-/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
+    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
     /* coverity[misra_c_2012_rule_11_3_violation] */
     pxEthernetHeader = ( ( const EthernetHeader_t * ) pucEthernetBuffer );
 
diff --git a/source/include/FreeRTOSIPConfigDefaults.h b/source/include/FreeRTOSIPConfigDefaults.h
@@ -259,6 +259,9 @@
 
 #ifndef FreeRTOS_debug_printf
     #define FreeRTOS_debug_printf( MSG )    do {} while( ipFALSE_BOOL )
+    /* MISRA Ref 20.5.1 [Misaligned access] */
+    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-2051 */
+    /* coverity[misra_c_2012_rule_20_5_violation] */
     #undef ipconfigHAS_DEBUG_PRINTF
     #define ipconfigHAS_DEBUG_PRINTF    0
 #endif
@@ -282,6 +285,9 @@
 
 #ifndef FreeRTOS_printf
     #define FreeRTOS_printf( MSG )    do {} while( ipFALSE_BOOL )
+    /* MISRA Ref 20.5.1 [Misaligned access] */
+    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-2051 */
+    /* coverity[misra_c_2012_rule_20_5_violation] */
     #undef ipconfigHAS_PRINTF
     #define ipconfigHAS_PRINTF    0
 #endif
@@ -611,6 +617,9 @@
 #else
     /* A sanity check to avoid a possible overflow of size_t. */
     #if ipconfigNETWORK_MTU > ( SIZE_MAX >> 1 )
+        /* MISRA Ref 20.5.1 [Misaligned access] */
+        /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-2051 */
+        /* coverity[misra_c_2012_rule_20_5_violation] */
         #undef ipconfigNETWORK_MTU
         #define ipconfigNETWORK_MTU    ( SIZE_MAX >> 1 )
     #endif
diff --git a/source/portable/BufferManagement/BufferAllocation_2.c b/source/portable/BufferManagement/BufferAllocation_2.c
@@ -215,13 +215,14 @@ uint8_t * pucGetNetworkBuffer( size_t * pxRequestedSizeBytes )
 
 void vReleaseNetworkBuffer( uint8_t * pucEthernetBuffer )
 {
+    uint8_t * pucEthernetBufferCopy = pucEthernetBuffer;
     /* There is space before the Ethernet buffer in which a pointer to the
      * network buffer that references this Ethernet buffer is stored.  Remove the
      * space before freeing the buffer. */
-    if( pucEthernetBuffer != NULL )
+    if( pucEthernetBufferCopy != NULL )
     {
-        pucEthernetBuffer -= ipBUFFER_PADDING;
-        vPortFree( ( void * ) pucEthernetBuffer );
+        pucEthernetBufferCopy -= ipBUFFER_PADDING;
+        vPortFree( ( void * ) pucEthernetBufferCopy );
     }
 }
 /*-----------------------------------------------------------*/
@@ -232,8 +233,9 @@ NetworkBufferDescriptor_t * pxGetNetworkBufferWithDescriptor( size_t xRequestedS
     NetworkBufferDescriptor_t * pxReturn = NULL;
     size_t uxCount;
     size_t uxMaxAllowedBytes = ( SIZE_MAX >> 1 );
+    size_t xRequestedSizeBytesCopy = xRequestedSizeBytes;
 
-    if( ( xRequestedSizeBytes <= uxMaxAllowedBytes ) && ( xNetworkBufferSemaphore != NULL ) )
+    if( ( xRequestedSizeBytesCopy <= uxMaxAllowedBytes ) && ( xNetworkBufferSemaphore != NULL ) )
     {
         /* If there is a semaphore available, there is a network buffer available. */
         if( xSemaphoreTake( xNetworkBufferSemaphore, xBlockTimeTicks ) == pdPASS )
@@ -257,27 +259,27 @@ NetworkBufferDescriptor_t * pxGetNetworkBufferWithDescriptor( size_t xRequestedS
             /* Allocate storage of exactly the requested size to the buffer. */
             configASSERT( pxReturn->pucEthernetBuffer == NULL );
 
-            if( xRequestedSizeBytes > 0U )
+            if( xRequestedSizeBytesCopy > 0U )
             {
-                if( ( xRequestedSizeBytes < ( size_t ) baMINIMAL_BUFFER_SIZE ) )
+                if( ( xRequestedSizeBytesCopy < ( size_t ) baMINIMAL_BUFFER_SIZE ) )
                 {
                     /* ARP packets can replace application packets, so the storage must be
                      * at least large enough to hold an ARP. */
-                    xRequestedSizeBytes = baMINIMAL_BUFFER_SIZE;
+                    xRequestedSizeBytesCopy = baMINIMAL_BUFFER_SIZE;
                 }
 
-                /* Add 2 bytes to xRequestedSizeBytes and round up xRequestedSizeBytes
+                /* Add 2 bytes to xRequestedSizeBytesCopy and round up xRequestedSizeBytesCopy
                  * to the nearest multiple of N bytes, where N equals 'sizeof( size_t )'. */
-                xRequestedSizeBytes += 2U;
+                xRequestedSizeBytesCopy += 2U;
 
-                if( ( xRequestedSizeBytes & ( sizeof( size_t ) - 1U ) ) != 0U )
+                if( ( xRequestedSizeBytesCopy & ( sizeof( size_t ) - 1U ) ) != 0U )
                 {
-                    xRequestedSizeBytes = ( xRequestedSizeBytes | ( sizeof( size_t ) - 1U ) ) + 1U;
+                    xRequestedSizeBytesCopy = ( xRequestedSizeBytesCopy | ( sizeof( size_t ) - 1U ) ) + 1U;
                 }
 
                 /* Extra space is obtained so a pointer to the network buffer can
                  * be stored at the beginning of the buffer. */
-                pxReturn->pucEthernetBuffer = ( uint8_t * ) pvPortMalloc( xRequestedSizeBytes + ipBUFFER_PADDING );
+                pxReturn->pucEthernetBuffer = ( uint8_t * ) pvPortMalloc( xRequestedSizeBytesCopy + ipBUFFER_PADDING );
 
                 if( pxReturn->pucEthernetBuffer == NULL )
                 {
@@ -293,12 +295,15 @@ NetworkBufferDescriptor_t * pxGetNetworkBufferWithDescriptor( size_t xRequestedS
                      * buffer storage area, then move the buffer pointer on past the
                      * stored pointer so the pointer value is not overwritten by the
                      * application when the buffer is used. */
+                    /* MISRA Ref 11.3.1 [Misaligned access] */
+                    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
+                    /* coverity[misra_c_2012_rule_11_3_violation] */
                     *( ( NetworkBufferDescriptor_t ** ) ( pxReturn->pucEthernetBuffer ) ) = pxReturn;
                     pxReturn->pucEthernetBuffer += ipBUFFER_PADDING;
 
                     /* Store the actual size of the allocated buffer, which may be
                      * greater than the original requested size. */
-                    pxReturn->xDataLength = xRequestedSizeBytes;
+                    pxReturn->xDataLength = xRequestedSizeBytesCopy;
 
                     #if ( ipconfigUSE_LINKED_RX_MESSAGES != 0 )
                         {
@@ -393,11 +398,12 @@ NetworkBufferDescriptor_t * pxResizeNetworkBufferWithDescriptor( NetworkBufferDe
 {
     size_t xOriginalLength;
     uint8_t * pucBuffer;
+    size_t xSizeBytes = xNewSizeBytes;
 
     xOriginalLength = pxNetworkBuffer->xDataLength + ipBUFFER_PADDING;
-    xNewSizeBytes = xNewSizeBytes + ipBUFFER_PADDING;
+    xSizeBytes = xSizeBytes + ipBUFFER_PADDING;
 
-    pucBuffer = pucGetNetworkBuffer( &( xNewSizeBytes ) );
+    pucBuffer = pucGetNetworkBuffer( &( xSizeBytes ) );
 
     if( pucBuffer == NULL )
     {
@@ -406,11 +412,11 @@ NetworkBufferDescriptor_t * pxResizeNetworkBufferWithDescriptor( NetworkBufferDe
     }
     else
     {
-        pxNetworkBuffer->xDataLength = xNewSizeBytes;
+        pxNetworkBuffer->xDataLength = xSizeBytes ;
 
-        if( xNewSizeBytes > xOriginalLength )
+        if( xSizeBytes > xOriginalLength )
         {
-            xNewSizeBytes = xOriginalLength;
+            xSizeBytes = xOriginalLength;
         }
 
         ( void ) memcpy( pucBuffer - ipBUFFER_PADDING, pxNetworkBuffer->pucEthernetBuffer - ipBUFFER_PADDING, xNewSizeBytes );
diff --git a/test/Coverity/ConfigFiles/FreeRTOSIPConfig.h b/test/Coverity/ConfigFiles/FreeRTOSIPConfig.h
@@ -105,7 +105,7 @@
  * number generation is performed via this macro to allow applications to use their
  * own random number generation method.  For example, it might be possible to
  * generate a random number by sampling noise on an analogue input. */
-extern uint32_t ulRand();
+extern uint32_t ulRand( void );
 #define ipconfigRAND32()    ulRand()
 
 /* If ipconfigUSE_NETWORK_EVENT_HOOK is set to 1 then FreeRTOS+TCP will call the

Original file line number	Diff line number	Diff line change
`@@ -215,13 +215,14 @@ uint8_t * pucGetNetworkBuffer( size_t * pxRequestedSizeBytes )`
`215`	`215`
`216`	`216`	`void vReleaseNetworkBuffer( uint8_t * pucEthernetBuffer )`
`217`	`217`	`{`
	`218`	`+ uint8_t * pucEthernetBufferCopy = pucEthernetBuffer;`
`218`	`219`	`/* There is space before the Ethernet buffer in which a pointer to the`
`219`	`220`	`* network buffer that references this Ethernet buffer is stored. Remove the`
`220`	`221`	`* space before freeing the buffer. */`
`221`		`- if( pucEthernetBuffer != NULL )`
	`222`	`+ if( pucEthernetBufferCopy != NULL )`
`222`	`223`	`{`
`223`		`- pucEthernetBuffer -= ipBUFFER_PADDING;`
`224`		`- vPortFree( ( void * ) pucEthernetBuffer );`
	`224`	`+ pucEthernetBufferCopy -= ipBUFFER_PADDING;`
	`225`	`+ vPortFree( ( void * ) pucEthernetBufferCopy );`
`225`	`226`	`}`
`226`	`227`	`}`
`227`	`228`	`/-----------------------------------------------------------/`
`@@ -232,8 +233,9 @@ NetworkBufferDescriptor_t * pxGetNetworkBufferWithDescriptor( size_t xRequestedS`
`232`	`233`	`NetworkBufferDescriptor_t * pxReturn = NULL;`
`233`	`234`	`size_t uxCount;`
`234`	`235`	`size_t uxMaxAllowedBytes = ( SIZE_MAX >> 1 );`
	`236`	`+ size_t xRequestedSizeBytesCopy = xRequestedSizeBytes;`
`235`	`237`
`236`		`- if( ( xRequestedSizeBytes <= uxMaxAllowedBytes ) && ( xNetworkBufferSemaphore != NULL ) )`
	`238`	`+ if( ( xRequestedSizeBytesCopy <= uxMaxAllowedBytes ) && ( xNetworkBufferSemaphore != NULL ) )`
`237`	`239`	`{`
`238`	`240`	`/* If there is a semaphore available, there is a network buffer available. */`
`239`	`241`	`if( xSemaphoreTake( xNetworkBufferSemaphore, xBlockTimeTicks ) == pdPASS )`
`@@ -257,27 +259,27 @@ NetworkBufferDescriptor_t * pxGetNetworkBufferWithDescriptor( size_t xRequestedS`
`257`	`259`	`/* Allocate storage of exactly the requested size to the buffer. */`
`258`	`260`	`configASSERT( pxReturn->pucEthernetBuffer == NULL );`
`259`	`261`
`260`		`- if( xRequestedSizeBytes > 0U )`
	`262`	`+ if( xRequestedSizeBytesCopy > 0U )`
`261`	`263`	`{`
`262`		`- if( ( xRequestedSizeBytes < ( size_t ) baMINIMAL_BUFFER_SIZE ) )`
	`264`	`+ if( ( xRequestedSizeBytesCopy < ( size_t ) baMINIMAL_BUFFER_SIZE ) )`
`263`	`265`	`{`
`264`	`266`	`/* ARP packets can replace application packets, so the storage must be`
`265`	`267`	`* at least large enough to hold an ARP. */`
`266`		`- xRequestedSizeBytes = baMINIMAL_BUFFER_SIZE;`
	`268`	`+ xRequestedSizeBytesCopy = baMINIMAL_BUFFER_SIZE;`
`267`	`269`	`}`
`268`	`270`
`269`		`- /* Add 2 bytes to xRequestedSizeBytes and round up xRequestedSizeBytes`
	`271`	`+ /* Add 2 bytes to xRequestedSizeBytesCopy and round up xRequestedSizeBytesCopy`
`270`	`272`	`* to the nearest multiple of N bytes, where N equals 'sizeof( size_t )'. */`
`271`		`- xRequestedSizeBytes += 2U;`
	`273`	`+ xRequestedSizeBytesCopy += 2U;`
`272`	`274`
`273`		`- if( ( xRequestedSizeBytes & ( sizeof( size_t ) - 1U ) ) != 0U )`
	`275`	`+ if( ( xRequestedSizeBytesCopy & ( sizeof( size_t ) - 1U ) ) != 0U )`
`274`	`276`	`{`
`275`		`- xRequestedSizeBytes = ( xRequestedSizeBytes \| ( sizeof( size_t ) - 1U ) ) + 1U;`
	`277`	`+ xRequestedSizeBytesCopy = ( xRequestedSizeBytesCopy \| ( sizeof( size_t ) - 1U ) ) + 1U;`
`276`	`278`	`}`
`277`	`279`
`278`	`280`	`/* Extra space is obtained so a pointer to the network buffer can`
`279`	`281`	`* be stored at the beginning of the buffer. */`
`280`		`- pxReturn->pucEthernetBuffer = ( uint8_t * ) pvPortMalloc( xRequestedSizeBytes + ipBUFFER_PADDING );`
	`282`	`+ pxReturn->pucEthernetBuffer = ( uint8_t * ) pvPortMalloc( xRequestedSizeBytesCopy + ipBUFFER_PADDING );`
`281`	`283`
`282`	`284`	`if( pxReturn->pucEthernetBuffer == NULL )`
`283`	`285`	`{`
`@@ -293,12 +295,15 @@ NetworkBufferDescriptor_t * pxGetNetworkBufferWithDescriptor( size_t xRequestedS`
`293`	`295`	`* buffer storage area, then move the buffer pointer on past the`
`294`	`296`	`* stored pointer so the pointer value is not overwritten by the`
`295`	`297`	`* application when the buffer is used. */`
	`298`	`+ /* MISRA Ref 11.3.1 [Misaligned access] */`
	`299`	`+ /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */`
	`300`	`+ /* coverity[misra_c_2012_rule_11_3_violation] */`
`296`	`301`	`( ( NetworkBufferDescriptor_t * ) ( pxReturn->pucEthernetBuffer ) ) = pxReturn;`
`297`	`302`	`pxReturn->pucEthernetBuffer += ipBUFFER_PADDING;`
`298`	`303`
`299`	`304`	`/* Store the actual size of the allocated buffer, which may be`
`300`	`305`	`* greater than the original requested size. */`
`301`		`- pxReturn->xDataLength = xRequestedSizeBytes;`
	`306`	`+ pxReturn->xDataLength = xRequestedSizeBytesCopy;`
`302`	`307`
`303`	`308`	`#if ( ipconfigUSE_LINKED_RX_MESSAGES != 0 )`
`304`	`309`	`{`
`@@ -393,11 +398,12 @@ NetworkBufferDescriptor_t * pxResizeNetworkBufferWithDescriptor( NetworkBufferDe`
`393`	`398`	`{`
`394`	`399`	`size_t xOriginalLength;`
`395`	`400`	`uint8_t * pucBuffer;`
	`401`	`+ size_t xSizeBytes = xNewSizeBytes;`
`396`	`402`
`397`	`403`	`xOriginalLength = pxNetworkBuffer->xDataLength + ipBUFFER_PADDING;`
`398`		`- xNewSizeBytes = xNewSizeBytes + ipBUFFER_PADDING;`
	`404`	`+ xSizeBytes = xSizeBytes + ipBUFFER_PADDING;`
`399`	`405`
`400`		`- pucBuffer = pucGetNetworkBuffer( &( xNewSizeBytes ) );`
	`406`	`+ pucBuffer = pucGetNetworkBuffer( &( xSizeBytes ) );`
`401`	`407`
`402`	`408`	`if( pucBuffer == NULL )`
`403`	`409`	`{`
`@@ -406,11 +412,11 @@ NetworkBufferDescriptor_t * pxResizeNetworkBufferWithDescriptor( NetworkBufferDe`
`406`	`412`	`}`
`407`	`413`	`else`
`408`	`414`	`{`
`409`		`- pxNetworkBuffer->xDataLength = xNewSizeBytes;`
	`415`	`+ pxNetworkBuffer->xDataLength = xSizeBytes ;`
`410`	`416`
`411`		`- if( xNewSizeBytes > xOriginalLength )`
	`417`	`+ if( xSizeBytes > xOriginalLength )`
`412`	`418`	`{`
`413`		`- xNewSizeBytes = xOriginalLength;`
	`419`	`+ xSizeBytes = xOriginalLength;`
`414`	`420`	`}`
`415`	`421`
`416`	`422`	`( void ) memcpy( pucBuffer - ipBUFFER_PADDING, pxNetworkBuffer->pucEthernetBuffer - ipBUFFER_PADDING, xNewSizeBytes );`