diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b3c042e556..921aaf30bd 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -443,7 +443,7 @@ jobs:
 
   proof_ci:
     if: ${{ github.event.pull_request }}
-    runs-on: cbmc_ubuntu-latest_16-core
+    runs-on: cbmc_ubuntu-latest_64-core
     steps:
       - name: Set up CBMC runner
         uses: FreeRTOS/CI-CD-Github-Actions/set_up_cbmc_runner@main
diff --git a/MISRA.md b/MISRA.md
index c48104eda8..79f78d0a86 100644
--- a/MISRA.md
+++ b/MISRA.md
@@ -97,7 +97,17 @@ _Ref 10.5.1_
 
 - MISRA C-2012 Rule 10.5 Converting from an unsigned to an enum type. The
   operation is safe to perform in that case, as we are using a generic API to
-  send and receive data, in that case the exact data sent it is received
+  send and receive data, in that case the exact data sent it is received.
+
+#### Rule 10.8
+
+_Ref 10.8.1_
+
+- MISRA C-2012 Rule 10.8 Casting a composite expression from a signed to an
+  unsigned type. The operation is safe to perform in this case as we have verified
+  that the pointer being subtracted from is greater than or equal to the pointer
+  being subtracted thereby making the result positive. This result can be safely
+  casted to an unsigned type like size_t.
 
 #### Rule 11.1
 
diff --git a/source/FreeRTOS_DNS.c b/source/FreeRTOS_DNS.c
index 020e9b5149..82ce02fd56 100644
--- a/source/FreeRTOS_DNS.c
+++ b/source/FreeRTOS_DNS.c
@@ -1573,7 +1573,7 @@ const MACAddress_t xMDNS_MacAddressIPv6 = { { 0x33, 0x33, 0x00, 0x00, 0x00, 0xFB
  * @return Always pdFAIL to indicate that the packet was not consumed and must
  *         be released by the caller.
  */
-    uint32_t ulDNSHandlePacket( const NetworkBufferDescriptor_t * pxNetworkBuffer )
+    BaseType_t xDNSHandlePacket( const NetworkBufferDescriptor_t * pxNetworkBuffer )
     {
         uint8_t * pucPayLoadBuffer;
         size_t uxPayloadSize;
diff --git a/source/FreeRTOS_DNS_Parser.c b/source/FreeRTOS_DNS_Parser.c
index 1666a3e8ed..525556d3e2 100644
--- a/source/FreeRTOS_DNS_Parser.c
+++ b/source/FreeRTOS_DNS_Parser.c
@@ -262,7 +262,7 @@
         uint16_t x;
         BaseType_t xReturn = pdTRUE;
         uint32_t ulIPAddress = 0U;
-        BaseType_t xDNSHookReturn = 0U;
+        BaseType_t xDNSHookReturn = 0;
         NetworkBufferDescriptor_t * pxNewBuffer = NULL;
 
         ( void ) memset( &( xSet ), 0, sizeof( xSet ) );
@@ -388,6 +388,9 @@
                     {
                         /* Note that the Questions section turns into the Answers section.
                          * uxSkipCount points to the first byte after e.g. 'name.local' */
+                        /* MISRA Ref 10.8.1 [Misaligned access] */
+                        /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-108 */
+                        /* coverity[misra_c_2012_rule_10_8_violation] */
                         xSet.uxSkipCount = ( size_t ) ( xSet.pucByte - pucUDPPayloadBuffer );
                     }
 
diff --git a/source/FreeRTOS_IP.c b/source/FreeRTOS_IP.c
index 903ed5b813..3ad1019aa9 100644
--- a/source/FreeRTOS_IP.c
+++ b/source/FreeRTOS_IP.c
@@ -343,7 +343,7 @@ static void prvProcessIPEventsAndTimers( void )
             switch( pxSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE */
             {
                 #if ( ipconfigUSE_IPv4 != 0 )
-                    case pdFALSE_UNSIGNED:
+                    case ipFALSE_BOOL:
                         xAddress.sin_family = FREERTOS_AF_INET;
                         xAddress.sin_address.ulIP_IPv4 = FreeRTOS_htonl( pxSocket->xLocalAddress.ulIP_IPv4 );
                         /* 'ulLocalAddress' will be set again by vSocketBind(). */
@@ -352,7 +352,7 @@ static void prvProcessIPEventsAndTimers( void )
                 #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
                 #if ( ipconfigUSE_IPv6 != 0 )
-                    case pdTRUE_UNSIGNED:
+                    case ipTRUE_BOOL:
                         xAddress.sin_family = FREERTOS_AF_INET6;
                         ( void ) memcpy( xAddress.sin_address.xIP_IPv6.ucBytes, pxSocket->xLocalAddress.xIP_IPv6.ucBytes, sizeof( xAddress.sin_address.xIP_IPv6.ucBytes ) );
                         /* 'ulLocalAddress' will be set again by vSocketBind(). */
@@ -568,10 +568,10 @@ static void prvIPTask_CheckPendingEvents( void )
              pxInterface != NULL;
              pxInterface = FreeRTOS_NextNetworkInterface( pxInterface ) )
         {
-            if( pxInterface->bits.bCallDownEvent != pdFALSE_UNSIGNED )
+            if( pxInterface->bits.bCallDownEvent != ipFALSE_BOOL )
             {
                 prvProcessNetworkDownEvent( pxInterface );
-                pxInterface->bits.bCallDownEvent = pdFALSE_UNSIGNED;
+                pxInterface->bits.bCallDownEvent = ipFALSE_BOOL;
             }
         }
     }
@@ -656,7 +656,7 @@ void vIPNetworkUpCalls( struct xNetworkEndPoint * pxEndPoint )
         #endif
     }
 
-    pxEndPoint->bits.bEndPointUp = pdTRUE_UNSIGNED;
+    pxEndPoint->bits.bEndPointUp = ipTRUE_BOOL;
 
     #if ( ipconfigUSE_NETWORK_EVENT_HOOK == 1 )
     #if ( ipconfigIPv4_BACKWARD_COMPATIBLE == 1 )
@@ -762,7 +762,7 @@ void FreeRTOS_NetworkDown( struct xNetworkInterface * pxNetworkInterface )
     IPStackEvent_t xNetworkDownEvent;
     const TickType_t xDontBlock = ( TickType_t ) 0;
 
-    pxNetworkInterface->bits.bInterfaceUp = pdFALSE_UNSIGNED;
+    pxNetworkInterface->bits.bInterfaceUp = ipFALSE_BOOL;
     xNetworkDownEvent.eEventType = eNetworkDownEvent;
     xNetworkDownEvent.pvData = pxNetworkInterface;
 
@@ -770,13 +770,13 @@ void FreeRTOS_NetworkDown( struct xNetworkInterface * pxNetworkInterface )
     if( xSendEventStructToIPTask( &xNetworkDownEvent, xDontBlock ) != pdPASS )
     {
         /* Could not send the message, so it is still pending. */
-        pxNetworkInterface->bits.bCallDownEvent = pdTRUE;
+        pxNetworkInterface->bits.bCallDownEvent = ipTRUE_BOOL;
         xNetworkDownEventPending = pdTRUE;
     }
     else
     {
         /* Message was sent so it is not pending. */
-        pxNetworkInterface->bits.bCallDownEvent = pdFALSE;
+        pxNetworkInterface->bits.bCallDownEvent = ipFALSE_BOOL;
     }
 
     iptraceNETWORK_DOWN();
@@ -805,13 +805,13 @@ BaseType_t FreeRTOS_NetworkDownFromISR( struct xNetworkInterface * pxNetworkInte
     if( xQueueSendToBackFromISR( xNetworkEventQueue, &xNetworkDownEvent, &xHigherPriorityTaskWoken ) != pdPASS )
     {
         /* Could not send the message, so it is still pending. */
-        pxNetworkInterface->bits.bCallDownEvent = pdTRUE;
+        pxNetworkInterface->bits.bCallDownEvent = ipTRUE_BOOL;
         xNetworkDownEventPending = pdTRUE;
     }
     else
     {
         /* Message was sent so it is not pending. */
-        pxNetworkInterface->bits.bCallDownEvent = pdFALSE;
+        pxNetworkInterface->bits.bCallDownEvent = ipFALSE_BOOL;
         xNetworkDownEventPending = pdFALSE;
     }
 
@@ -1773,7 +1773,7 @@ static void prvProcessEthernetPacket( NetworkBufferDescriptor_t * const pxNetwor
                     break;
             } /* switch( pxEthernetHeader->usFrameType ) */
         }
-    } while( pdFALSE );
+    } while( ipFALSE_BOOL );
 
     /* Perform any actions that resulted from processing the Ethernet frame. */
     switch( eReturned )
diff --git a/source/FreeRTOS_IP_Timers.c b/source/FreeRTOS_IP_Timers.c
index d2746c2ee6..35891aba20 100644
--- a/source/FreeRTOS_IP_Timers.c
+++ b/source/FreeRTOS_IP_Timers.c
@@ -401,14 +401,14 @@ static void prvIPTimerStart( IPTimer_t * pxTimer,
 
     if( xTime == ( TickType_t ) 0 )
     {
-        pxTimer->bExpired = pdTRUE_UNSIGNED;
+        pxTimer->bExpired = ipTRUE_BOOL;
     }
     else
     {
-        pxTimer->bExpired = pdFALSE_UNSIGNED;
+        pxTimer->bExpired = ipFALSE_BOOL;
     }
 
-    pxTimer->bActive = pdTRUE_UNSIGNED;
+    pxTimer->bActive = ipTRUE_BOOL;
 }
 /*-----------------------------------------------------------*/
 
@@ -559,15 +559,15 @@ static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer )
     {
         /* The timer might have set the bExpired flag already, if not, check the
          * value of xTimeOut against ulRemainingTime. */
-        if( pxTimer->bExpired == pdFALSE_UNSIGNED )
+        if( pxTimer->bExpired == ipFALSE_BOOL )
         {
             if( xTaskCheckForTimeOut( &( pxTimer->xTimeOut ), &( pxTimer->ulRemainingTime ) ) != pdFALSE )
             {
-                pxTimer->bExpired = pdTRUE_UNSIGNED;
+                pxTimer->bExpired = ipTRUE_BOOL;
             }
         }
 
-        if( pxTimer->bExpired != pdFALSE_UNSIGNED )
+        if( pxTimer->bExpired != ipFALSE_BOOL )
         {
             prvIPTimerStart( pxTimer, pxTimer->ulReloadTime );
             xReturn = pdTRUE;
@@ -591,15 +591,15 @@ static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer )
  */
     void vIPSetTCPTimerExpiredState( BaseType_t xExpiredState )
     {
-        xTCPTimer.bActive = pdTRUE_UNSIGNED;
+        xTCPTimer.bActive = ipTRUE_BOOL;
 
         if( xExpiredState != pdFALSE )
         {
-            xTCPTimer.bExpired = pdTRUE_UNSIGNED;
+            xTCPTimer.bExpired = ipTRUE_BOOL;
         }
         else
         {
-            xTCPTimer.bExpired = pdFALSE_UNSIGNED;
+            xTCPTimer.bExpired = ipFALSE_BOOL;
         }
     }
 #endif /* if ( ipconfigUSE_TCP == 1 ) */
@@ -616,11 +616,11 @@ static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer )
     {
         if( xEnableState != pdFALSE )
         {
-            xARPTimer.bActive = pdTRUE_UNSIGNED;
+            xARPTimer.bActive = ipTRUE_BOOL;
         }
         else
         {
-            xARPTimer.bActive = pdFALSE_UNSIGNED;
+            xARPTimer.bActive = ipFALSE_BOOL;
         }
     }
     /*-----------------------------------------------------------*/
@@ -634,11 +634,11 @@ static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer )
     {
         if( xEnableState != pdFALSE )
         {
-            xARPResolutionTimer.bActive = pdTRUE_UNSIGNED;
+            xARPResolutionTimer.bActive = ipTRUE_BOOL;
         }
         else
         {
-            xARPResolutionTimer.bActive = pdFALSE_UNSIGNED;
+            xARPResolutionTimer.bActive = ipFALSE_BOOL;
         }
     }
 #endif /* if ipconfigIS_ENABLED( ipconfigUSE_IPv4 ) */
@@ -655,11 +655,11 @@ static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer )
     {
         if( xEnableState != pdFALSE )
         {
-            xNDTimer.bActive = pdTRUE_UNSIGNED;
+            xNDTimer.bActive = ipTRUE_BOOL;
         }
         else
         {
-            xNDTimer.bActive = pdFALSE_UNSIGNED;
+            xNDTimer.bActive = ipFALSE_BOOL;
         }
     }
     /*-----------------------------------------------------------*/
@@ -673,11 +673,11 @@ static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer )
     {
         if( xEnableState != pdFALSE )
         {
-            xNDResolutionTimer.bActive = pdTRUE_UNSIGNED;
+            xNDResolutionTimer.bActive = ipTRUE_BOOL;
         }
         else
         {
-            xNDResolutionTimer.bActive = pdFALSE_UNSIGNED;
+            xNDResolutionTimer.bActive = ipFALSE_BOOL;
         }
     }
 #endif /* if ipconfigIS_ENABLED( ipconfigUSE_IPv6 ) */
@@ -699,11 +699,11 @@ static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer )
         /* 'xDHCP_RATimer' is shared between DHCP (IPv4) and RA/SLAAC (IPv6). */
         if( xEnableState != 0 )
         {
-            pxEndPoint->xDHCP_RATimer.bActive = pdTRUE_UNSIGNED;
+            pxEndPoint->xDHCP_RATimer.bActive = ipTRUE_BOOL;
         }
         else
         {
-            pxEndPoint->xDHCP_RATimer.bActive = pdFALSE_UNSIGNED;
+            pxEndPoint->xDHCP_RATimer.bActive = ipFALSE_BOOL;
         }
     }
 #endif /* if ( ipconfigUSE_DHCP == 1 ) || ( ipconfigUSE_RA == 1 ) || ( ipconfigUSE_DHCPv6 == 1 ) */
@@ -720,11 +720,11 @@ static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer )
     {
         if( xEnableState != 0 )
         {
-            xDNSTimer.bActive = pdTRUE_UNSIGNED;
+            xDNSTimer.bActive = ipTRUE_BOOL;
         }
         else
         {
-            xDNSTimer.bActive = pdFALSE_UNSIGNED;
+            xDNSTimer.bActive = ipFALSE_BOOL;
         }
     }
 
diff --git a/source/FreeRTOS_IP_Utils.c b/source/FreeRTOS_IP_Utils.c
index c39449211c..5065552b69 100644
--- a/source/FreeRTOS_IP_Utils.c
+++ b/source/FreeRTOS_IP_Utils.c
@@ -839,9 +839,9 @@ void prvProcessNetworkDownEvent( struct xNetworkInterface * pxInterface )
          pxEndPoint = FreeRTOS_NextEndPoint( pxInterface, pxEndPoint ) )
     {
         /* The bit 'bEndPointUp' stays low until vIPNetworkUpCalls() is called. */
-        pxEndPoint->bits.bEndPointUp = pdFALSE_UNSIGNED;
+        pxEndPoint->bits.bEndPointUp = ipFALSE_BOOL;
 
-        if( pxEndPoint->bits.bIPv6 == pdTRUE_UNSIGNED )
+        if( pxEndPoint->bits.bIPv6 == ipTRUE_BOOL )
         {
             /* IPv6 end-points have a solicited-node address that needs extra housekeeping. */
             #if ( ipconfigIS_ENABLED( ipconfigUSE_IPv6 ) )
@@ -851,7 +851,7 @@ void prvProcessNetworkDownEvent( struct xNetworkInterface * pxInterface )
 
         #if ( ipconfigUSE_NETWORK_EVENT_HOOK == 1 )
         {
-            if( pxEndPoint->bits.bCallDownHook != pdFALSE_UNSIGNED )
+            if( pxEndPoint->bits.bCallDownHook != ipFALSE_BOOL )
             {
                 #if ( ipconfigIPv4_BACKWARD_COMPATIBLE == 1 )
                 {
@@ -866,7 +866,7 @@ void prvProcessNetworkDownEvent( struct xNetworkInterface * pxInterface )
             else
             {
                 /* The next time NetworkEventHook will be called for this end-point. */
-                pxEndPoint->bits.bCallDownHook = pdTRUE_UNSIGNED;
+                pxEndPoint->bits.bCallDownHook = ipTRUE_BOOL;
             }
         }
         #endif /* ipconfigUSE_NETWORK_EVENT_HOOK */
@@ -887,7 +887,7 @@ void prvProcessNetworkDownEvent( struct xNetworkInterface * pxInterface )
             if( END_POINT_USES_DHCP( pxEndPoint ) )
             {
                 #if ( ( ipconfigUSE_DHCPv6 != 0 ) && ( ipconfigUSE_IPv6 != 0 ) )
-                    if( pxEndPoint->bits.bIPv6 != pdFALSE_UNSIGNED )
+                    if( pxEndPoint->bits.bIPv6 != ipFALSE_BOOL )
                     {
                         vDHCPv6Stop( pxEndPoint );
                     }
@@ -915,7 +915,7 @@ void prvProcessNetworkDownEvent( struct xNetworkInterface * pxInterface )
 
     if( pxInterface->pfInitialise( pxInterface ) == pdPASS )
     {
-        pxInterface->bits.bInterfaceUp = pdTRUE_UNSIGNED;
+        pxInterface->bits.bInterfaceUp = ipTRUE_BOOL;
         /* Set remaining time to 0 so it will become active immediately. */
 
         /* The network is not up until DHCP has completed.
@@ -929,7 +929,7 @@ void prvProcessNetworkDownEvent( struct xNetworkInterface * pxInterface )
                 if( END_POINT_USES_DHCP( pxEndPoint ) )
                 {
                     #if ( ( ipconfigUSE_DHCPv6 != 0 ) && ( ipconfigUSE_IPv6 != 0 ) )
-                        if( pxEndPoint->bits.bIPv6 != pdFALSE_UNSIGNED )
+                        if( pxEndPoint->bits.bIPv6 != ipFALSE_BOOL )
                         {
                             vDHCPv6Process( pdTRUE, pxEndPoint );
                         }
@@ -956,13 +956,13 @@ void prvProcessNetworkDownEvent( struct xNetworkInterface * pxInterface )
                 switch( pxEndPoint->bits.bIPv6 ) /* LCOV_EXCL_BR_LINE */
                 {
                     #if ( ipconfigUSE_IPv4 != 0 )
-                        case pdFALSE_UNSIGNED:
+                        case ipFALSE_BOOL:
                             ( void ) memcpy( &( pxEndPoint->ipv4_settings ), &( pxEndPoint->ipv4_defaults ), sizeof( pxEndPoint->ipv4_settings ) );
                             break;
                     #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
                     #if ( ipconfigUSE_IPv6 != 0 )
-                        case pdTRUE_UNSIGNED:
+                        case ipTRUE_BOOL:
                             ( void ) memcpy( &( pxEndPoint->ipv6_settings ), &( pxEndPoint->ipv6_defaults ), sizeof( pxEndPoint->ipv6_settings ) );
                             break;
                     #endif /* ( ipconfigUSE_IPv6 != 0 ) */
diff --git a/source/FreeRTOS_IPv4.c b/source/FreeRTOS_IPv4.c
index 32c31d756a..a1d689b342 100644
--- a/source/FreeRTOS_IPv4.c
+++ b/source/FreeRTOS_IPv4.c
@@ -236,7 +236,7 @@ BaseType_t xIsIPv4Broadcast( uint32_t ulIPAddress,
     {
         #if ( ipconfigUSE_IPv6 == ipconfigENABLE )
             /* Skip over any IPv6 endpoints. */
-            if( pxEndPoint->bits.bIPv6 == pdTRUE )
+            if( pxEndPoint->bits.bIPv6 == ipTRUE_BOOL )
             {
                 continue;
             }
diff --git a/source/FreeRTOS_IPv6_Utils.c b/source/FreeRTOS_IPv6_Utils.c
index 9e9f2abd6d..eec02fb589 100644
--- a/source/FreeRTOS_IPv6_Utils.c
+++ b/source/FreeRTOS_IPv6_Utils.c
@@ -348,7 +348,7 @@ void vManageSolicitedNodeAddress( const struct xNetworkEndPoint * pxEndPoint,
                 pxEndPoint->pxNetworkInterface->pfRemoveAllowedMAC( pxEndPoint->pxNetworkInterface, xMACAddress.ucBytes );
             }
         }
-    } while( pdFALSE );
+    } while( ipFALSE_BOOL );
 }
 /*-----------------------------------------------------------*/
 
diff --git a/source/FreeRTOS_RA.c b/source/FreeRTOS_RA.c
index 9b0afc73fd..6d1be79c1f 100644
--- a/source/FreeRTOS_RA.c
+++ b/source/FreeRTOS_RA.c
@@ -140,7 +140,7 @@
         NetworkBufferDescriptor_t * pxNewDescriptor = NULL;
 
         configASSERT( pxEndPoint != NULL );
-        configASSERT( pxEndPoint->bits.bIPv6 != pdFALSE_UNSIGNED );
+        configASSERT( pxEndPoint->bits.bIPv6 != ipFALSE_BOOL );
 
         xHasLocal = xGetLinkLocalAddress( pxEndPoint->pxNetworkInterface, &( xSourceAddress ) );
 
@@ -247,11 +247,11 @@
              pxPoint != NULL;
              pxPoint = FreeRTOS_NextEndPoint( pxInterface, pxPoint ) )
         {
-            if( ( pxPoint->bits.bWantRA != pdFALSE_UNSIGNED ) && ( pxPoint->xRAData.eRAState == eRAStateIPWait ) )
+            if( ( pxPoint->bits.bWantRA != ipFALSE_BOOL ) && ( pxPoint->xRAData.eRAState == eRAStateIPWait ) )
             {
                 if( memcmp( pxPoint->ipv6_settings.xIPAddress.ucBytes, pxICMPHeader_IPv6->xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS ) == 0 )
                 {
-                    pxPoint->xRAData.bits.bIPAddressInUse = pdTRUE_UNSIGNED;
+                    pxPoint->xRAData.bits.bIPAddressInUse = ipTRUE_BOOL;
                     vDHCP_RATimerReload( pxPoint, 100U );
                 }
             }
@@ -403,17 +403,17 @@
                          pxEndPoint != NULL;
                          pxEndPoint = FreeRTOS_NextEndPoint( pxNetworkBuffer->pxInterface, pxEndPoint ) )
                     {
-                        if( ( pxEndPoint->bits.bWantRA != pdFALSE_UNSIGNED ) && ( pxEndPoint->xRAData.eRAState == eRAStateWait ) )
+                        if( ( pxEndPoint->bits.bWantRA != ipFALSE_BOOL ) && ( pxEndPoint->xRAData.eRAState == eRAStateWait ) )
                         {
                             pxEndPoint->ipv6_settings.uxPrefixLength = pxPrefixOption->ucPrefixLength;
                             ( void ) memcpy( pxEndPoint->ipv6_settings.xPrefix.ucBytes, pxPrefixOption->ucPrefix, ipSIZE_OF_IPv6_ADDRESS );
                             ( void ) memcpy( pxEndPoint->ipv6_settings.xGatewayAddress.ucBytes, pxICMPPacket->xIPHeader.xSourceAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
 
-                            pxEndPoint->xRAData.bits.bRouterReplied = pdTRUE_UNSIGNED;
+                            pxEndPoint->xRAData.bits.bRouterReplied = ipTRUE_BOOL;
                             pxEndPoint->xRAData.uxRetryCount = 0U;
                             pxEndPoint->xRAData.ulPreferredLifeTime = FreeRTOS_ntohl( pxPrefixOption->ulPreferredLifeTime );
                             /* Force taking a new random IP-address. */
-                            pxEndPoint->xRAData.bits.bIPAddressInUse = pdTRUE_UNSIGNED;
+                            pxEndPoint->xRAData.bits.bIPAddressInUse = ipTRUE_BOOL;
                             pxEndPoint->xRAData.eRAState = eRAStateIPTest;
                             vRAProcess( pdFALSE, pxEndPoint );
                         }
@@ -459,10 +459,10 @@
                 FreeRTOS_printf( ( "RA: Giving up waiting for a Router.\n" ) );
                 ( void ) memcpy( &( pxEndPoint->ipv6_settings ), &( pxEndPoint->ipv6_defaults ), sizeof( pxEndPoint->ipv6_settings ) );
 
-                pxEndPoint->xRAData.bits.bRouterReplied = pdFALSE_UNSIGNED;
+                pxEndPoint->xRAData.bits.bRouterReplied = ipFALSE_BOOL;
                 pxEndPoint->xRAData.uxRetryCount = 0U;
                 /* Force taking a new random IP-address. */
-                pxEndPoint->xRAData.bits.bIPAddressInUse = pdTRUE_UNSIGNED;
+                pxEndPoint->xRAData.bits.bIPAddressInUse = ipTRUE_BOOL;
                 pxEndPoint->xRAData.eRAState = eRAStateIPTest;
             }
         }
@@ -470,7 +470,7 @@
         {
             /* A Neighbour Solicitation has been sent, waited for a reply.
              * Repeat this 'ipconfigRA_IP_TEST_COUNT' times to be sure. */
-            if( pxEndPoint->xRAData.bits.bIPAddressInUse != pdFALSE_UNSIGNED )
+            if( pxEndPoint->xRAData.bits.bIPAddressInUse != ipFALSE_BOOL )
             {
                 /* Another device has responded with the same IPv4 address. */
                 pxEndPoint->xRAData.uxRetryCount = 0U;
@@ -487,7 +487,7 @@
             else
             {
                 /* Now it is assumed that there is no other device using the same IP-address. */
-                if( pxEndPoint->xRAData.bits.bRouterReplied != pdFALSE_UNSIGNED )
+                if( pxEndPoint->xRAData.bits.bRouterReplied != ipFALSE_BOOL )
                 {
                     /* Obtained configuration from a router. */
                     uxNewReloadTime = pdMS_TO_TICKS( ( 1000U * ( uint64_t ) pxEndPoint->xRAData.ulPreferredLifeTime ) );
@@ -573,9 +573,9 @@
                    NetworkBufferDescriptor_t * pxNetworkBuffer;
 
                    /* Get an IP-address, using the network prefix and a random host address. */
-                   if( pxEndPoint->xRAData.bits.bIPAddressInUse != 0U )
+                   if( pxEndPoint->xRAData.bits.bIPAddressInUse != ipFALSE_BOOL )
                    {
-                       pxEndPoint->xRAData.bits.bIPAddressInUse = pdFALSE_UNSIGNED;
+                       pxEndPoint->xRAData.bits.bIPAddressInUse = ipFALSE_BOOL;
 
                        ( void ) FreeRTOS_CreateIPv6Address( &pxEndPoint->ipv6_settings.xIPAddress, &pxEndPoint->ipv6_settings.xPrefix, pxEndPoint->ipv6_settings.uxPrefixLength, pdTRUE );
 
diff --git a/source/FreeRTOS_Routing.c b/source/FreeRTOS_Routing.c
index 9ca8e69799..09a8d7d362 100644
--- a/source/FreeRTOS_Routing.c
+++ b/source/FreeRTOS_Routing.c
@@ -282,7 +282,7 @@ struct xIPv6_Couple
         }
 
         #if ( ipconfigUSE_IPv6 != 0 )
-            if( pxEndPoint->bits.bIPv6 == pdTRUE_UNSIGNED )
+            if( pxEndPoint->bits.bIPv6 == ipTRUE_BOOL )
             {
                 FreeRTOS_printf( ( "FreeRTOS_AddEndPoint: MAC: %02x-%02x IPv6: %pip\n",
                                    pxEndPoint->xMACAddress.ucBytes[ 4 ],
@@ -291,7 +291,7 @@ struct xIPv6_Couple
             }
         #endif /* ( ipconfigUSE_IPv6 != 0 ) */
         #if ( ipconfigUSE_IPv4 != 0 )
-            if( pxEndPoint->bits.bIPv6 == pdFALSE_UNSIGNED )
+            if( pxEndPoint->bits.bIPv6 == ipFALSE_BOOL )
             {
                 FreeRTOS_printf( ( "FreeRTOS_AddEndPoint: MAC: %02x-%02x IPv4: %xip\n",
                                    pxEndPoint->xMACAddress.ucBytes[ 4 ],
@@ -385,7 +385,7 @@ struct xIPv6_Couple
         {
             #if ( ipconfigUSE_IPv4 != 0 )
                 #if ( ipconfigUSE_IPv6 != 0 )
-                    if( pxEndPoint->bits.bIPv6 == 0U )
+                    if( pxEndPoint->bits.bIPv6 == ipFALSE_BOOL )
                 #endif
                 {
                     if( ( ulIPAddress == 0U ) ||
@@ -502,7 +502,7 @@ struct xIPv6_Couple
             {
                 #if ( ipconfigUSE_IPv4 != 0 )
                     #if ( ipconfigUSE_IPv6 != 0 )
-                        if( pxEndPoint->bits.bIPv6 == pdFALSE_UNSIGNED )
+                        if( pxEndPoint->bits.bIPv6 == ipFALSE_BOOL )
                     #endif
                     {
                         if( ( ulIPAddress == ~0U ) ||
@@ -552,7 +552,7 @@ struct xIPv6_Couple
             {
                 if( ( pxInterface == NULL ) || ( pxEndPoint->pxNetworkInterface == pxInterface ) )
                 {
-                    if( pxEndPoint->bits.bIPv6 != pdFALSE_UNSIGNED )
+                    if( pxEndPoint->bits.bIPv6 != ipFALSE_BOOL )
                     {
                         if( xCompareIPv6_Address( &( pxEndPoint->ipv6_settings.xIPAddress ), pxIPAddress, pxEndPoint->ipv6_settings.uxPrefixLength ) == 0 )
                         {
@@ -607,7 +607,7 @@ struct xIPv6_Couple
             {
                 ( void ) memset( pxEndPoint, 0, sizeof( *pxEndPoint ) );
 
-                pxEndPoint->bits.bIPv6 = pdTRUE_UNSIGNED;
+                pxEndPoint->bits.bIPv6 = ipTRUE_BOOL;
 
                 pxEndPoint->ipv6_settings.uxPrefixLength = uxPrefixLength;
 
@@ -989,7 +989,7 @@ struct xIPv6_Couple
                     break;
                 }
             #else
-                if( ( xIPType == ( BaseType_t ) ipTYPE_IPv6 ) && ( pxEndPoint->bits.bIPv6 != pdFALSE_UNSIGNED ) )
+                if( ( xIPType == ( BaseType_t ) ipTYPE_IPv6 ) && ( pxEndPoint->bits.bIPv6 != ipFALSE_BOOL ) )
                 {
                     /* Check if the IP-address is non-zero. */
                     if( memcmp( FreeRTOS_in6addr_any.ucBytes, pxEndPoint->ipv6_settings.xGatewayAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS ) != 0 )
@@ -1000,7 +1000,7 @@ struct xIPv6_Couple
 
                 #if ( ipconfigUSE_IPv4 != 0 )
                     else
-                    if( ( xIPType == ( BaseType_t ) ipTYPE_IPv4 ) && ( pxEndPoint->bits.bIPv6 == pdFALSE_UNSIGNED ) )
+                    if( ( xIPType == ( BaseType_t ) ipTYPE_IPv4 ) && ( pxEndPoint->bits.bIPv6 == ipFALSE_BOOL ) )
                     {
                         if( pxEndPoint->ipv4_settings.ulGatewayAddress != 0U )
                         {
@@ -1038,7 +1038,7 @@ struct xIPv6_Couple
 
             while( pxEndPoint != NULL )
             {
-                if( ( ( pxInterface == NULL ) || ( pxEndPoint->pxNetworkInterface == pxInterface ) ) && ( pxEndPoint->bits.bIPv6 != pdFALSE_UNSIGNED ) )
+                if( ( ( pxInterface == NULL ) || ( pxEndPoint->pxNetworkInterface == pxInterface ) ) && ( pxEndPoint->bits.bIPv6 != ipFALSE_BOOL ) )
                 {
                     break;
                 }
@@ -1481,7 +1481,7 @@ struct xIPv6_Couple
             switch( pxEndPoint->bits.bIPv6 ) /* LCOV_EXCL_BR_LINE */
             {
                 #if ( ipconfigUSE_IPv4 != 0 )
-                    case pdFALSE_UNSIGNED:
+                    case ipFALSE_BOOL:
                         ( void ) FreeRTOS_inet_ntop( FREERTOS_AF_INET4,
                                                      ( const void * ) &( pxEndPoint->ipv4_settings.ulIPAddress ),
                                                      pcBuffer,
@@ -1490,7 +1490,7 @@ struct xIPv6_Couple
                 #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
                 #if ( ipconfigUSE_IPv6 != 0 )
-                    case pdTRUE_UNSIGNED:
+                    case ipTRUE_BOOL:
                         ( void ) FreeRTOS_inet_ntop( FREERTOS_AF_INET6,
                                                      pxEndPoint->ipv6_settings.xIPAddress.ucBytes,
                                                      pcBuffer,
diff --git a/source/FreeRTOS_Sockets.c b/source/FreeRTOS_Sockets.c
index cefbe93b6f..ff4cde14c0 100644
--- a/source/FreeRTOS_Sockets.c
+++ b/source/FreeRTOS_Sockets.c
@@ -706,13 +706,13 @@ Socket_t FreeRTOS_socket( BaseType_t xDomain,
             {
                 #if ( ipconfigUSE_IPv6 != 0 )
                     case FREERTOS_AF_INET6:
-                        pxSocket->bits.bIsIPv6 = pdTRUE_UNSIGNED;
+                        pxSocket->bits.bIsIPv6 = ipTRUE_BOOL;
                         break;
                 #endif /* ( ipconfigUSE_IPv6 != 0 ) */
 
                 #if ( ipconfigUSE_IPv4 != 0 )
                     case FREERTOS_AF_INET:
-                        pxSocket->bits.bIsIPv6 = pdFALSE_UNSIGNED;
+                        pxSocket->bits.bIsIPv6 = ipFALSE_BOOL;
                         break;
                 #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
@@ -1049,7 +1049,7 @@ Socket_t FreeRTOS_socket( BaseType_t xDomain,
 
             /* while the IP-task works on the request, the API will block on
              * 'eSELECT_CALL_IP'.  So clear it first. */
-            ( void ) xEventGroupClearBits( pxSocketSet->xSelectGroup, ( BaseType_t ) eSELECT_CALL_IP );
+            ( void ) xEventGroupClearBits( pxSocketSet->xSelectGroup, ( EventBits_t ) eSELECT_CALL_IP );
         }
         #endif /* if ( ipconfigSELECT_USES_NOTIFY != 0 ) */
 
@@ -1069,7 +1069,7 @@ Socket_t FreeRTOS_socket( BaseType_t xDomain,
             }
             #else
             {
-                ( void ) xEventGroupWaitBits( pxSocketSet->xSelectGroup, ( BaseType_t ) eSELECT_CALL_IP, pdTRUE, pdFALSE, portMAX_DELAY );
+                ( void ) xEventGroupWaitBits( pxSocketSet->xSelectGroup, ( EventBits_t ) eSELECT_CALL_IP, pdTRUE, pdFALSE, portMAX_DELAY );
             }
             #endif
         }
@@ -1723,14 +1723,14 @@ BaseType_t FreeRTOS_bind( Socket_t xSocket,
                 #if ( ipconfigUSE_IPv6 != 0 )
                     case FREERTOS_AF_INET6:
                         ( void ) memcpy( pxSocket->xLocalAddress.xIP_IPv6.ucBytes, pxAddress->sin_address.xIP_IPv6.ucBytes, sizeof( pxSocket->xLocalAddress.xIP_IPv6.ucBytes ) );
-                        pxSocket->bits.bIsIPv6 = pdTRUE_UNSIGNED;
+                        pxSocket->bits.bIsIPv6 = ipTRUE_BOOL;
                         break;
                 #endif /* ( ipconfigUSE_IPv6 != 0 ) */
 
                 #if ( ipconfigUSE_IPv4 != 0 )
                     case FREERTOS_AF_INET4:
                         pxSocket->xLocalAddress.ulIP_IPv4 = FreeRTOS_ntohl( pxAddress->sin_address.ulIP_IPv4 );
-                        pxSocket->bits.bIsIPv6 = pdFALSE_UNSIGNED;
+                        pxSocket->bits.bIsIPv6 = ipFALSE_BOOL;
                         break;
                 #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
@@ -1930,7 +1930,7 @@ BaseType_t vSocketBind( FreeRTOS_Socket_t * pxSocket,
             /* Clear the address: */
             ( void ) memset( pxAddress, 0, sizeof( struct freertos_sockaddr ) );
 
-            if( pxSocket->bits.bIsIPv6 != pdFALSE_UNSIGNED )
+            if( pxSocket->bits.bIsIPv6 != ipFALSE_BOOL )
             {
                 pxAddress->sin_family = FREERTOS_AF_INET6;
             }
@@ -2195,7 +2195,7 @@ void * vSocketClose( FreeRTOS_Socket_t * pxSocket )
                      * See printf-stdarg.c */
 
                     #if ( ipconfigUSE_IPv4 != 0 )
-                        case pdFALSE_UNSIGNED:
+                        case ipFALSE_BOOL:
                             ( void ) snprintf( pucSocketProps, sizeof( pucSocketProps ), "%xip port %u to %xip port %u",
                                                ( unsigned ) pxSocket->xLocalAddress.ulIP_IPv4,
                                                pxSocket->usLocalPort,
@@ -2205,7 +2205,7 @@ void * vSocketClose( FreeRTOS_Socket_t * pxSocket )
                     #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
                     #if ( ipconfigUSE_IPv6 != 0 )
-                        case pdTRUE_UNSIGNED:
+                        case ipTRUE_BOOL:
                             ( void ) snprintf( pucSocketProps, sizeof( pucSocketProps ), "%pip port %u to %pip port %u",
                                                ( void * ) pxSocket->xLocalAddress.xIP_IPv6.ucBytes,
                                                pxSocket->usLocalPort,
@@ -2227,7 +2227,7 @@ void * vSocketClose( FreeRTOS_Socket_t * pxSocket )
             switch( pxSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE Exclude this line because default case is not counted. */
             {
                 #if ( ipconfigUSE_IPv4 != 0 )
-                    case pdFALSE_UNSIGNED:
+                    case ipFALSE_BOOL:
                         ( void ) snprintf( pucSocketProps, sizeof( pucSocketProps ),
                                            "%xip port %u",
                                            ( unsigned ) pxSocket->xLocalAddress.ulIP_IPv4,
@@ -2236,7 +2236,7 @@ void * vSocketClose( FreeRTOS_Socket_t * pxSocket )
                 #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
                 #if ( ipconfigUSE_IPv6 != 0 )
-                    case pdTRUE_UNSIGNED:
+                    case ipTRUE_BOOL:
                         ( void ) snprintf( pucSocketProps, sizeof( pucSocketProps ),
                                            "%pip port %u",
                                            ( void * ) pxSocket->xLocalAddress.xIP_IPv6.ucBytes,
@@ -2296,8 +2296,8 @@ void * vSocketClose( FreeRTOS_Socket_t * pxSocket )
 
                 if( ( pxOtherSocket->u.xTCP.eTCPState != eTCP_LISTEN ) &&
                     ( pxOtherSocket->usLocalPort == usLocalPort ) &&
-                    ( ( pxOtherSocket->u.xTCP.bits.bPassQueued != pdFALSE_UNSIGNED ) ||
-                      ( pxOtherSocket->u.xTCP.bits.bPassAccept != pdFALSE_UNSIGNED ) ) )
+                    ( ( pxOtherSocket->u.xTCP.bits.bPassQueued != ipFALSE_BOOL ) ||
+                      ( pxOtherSocket->u.xTCP.bits.bPassAccept != ipFALSE_BOOL ) ) )
                 {
                     /* MISRA Ref 17.2.1 [Sockets and limited recursion] */
                     /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-172 */
@@ -2540,7 +2540,7 @@ void * vSocketClose( FreeRTOS_Socket_t * pxSocket )
 
             /* In case the socket has already initialised its tcpWin,
              * adapt the window size parameters */
-            if( pxTCP->xTCPWindow.u.bits.bHasInit != pdFALSE_UNSIGNED )
+            if( pxTCP->xTCPWindow.u.bits.bHasInit != ipFALSE_BOOL )
             {
                 pxTCP->xTCPWindow.xSize.ulRxWindowLength = ( uint32_t ) ( pxTCP->uxRxWinSize * pxTCP->usMSS );
                 pxTCP->xTCPWindow.xSize.ulTxWindowLength = ( uint32_t ) ( pxTCP->uxTxWinSize * pxTCP->usMSS );
@@ -2613,11 +2613,11 @@ void * vSocketClose( FreeRTOS_Socket_t * pxSocket )
         {
             if( *( ( const BaseType_t * ) pvOptionValue ) != 0 )
             {
-                pxSocket->u.xTCP.xTCPWindow.u.bits.bSendFullSize = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.xTCPWindow.u.bits.bSendFullSize = ipTRUE_BOOL;
             }
             else
             {
-                pxSocket->u.xTCP.xTCPWindow.u.bits.bSendFullSize = pdFALSE_UNSIGNED;
+                pxSocket->u.xTCP.xTCPWindow.u.bits.bSendFullSize = ipFALSE_BOOL;
             }
 
             if( ( pxSocket->u.xTCP.eTCPState >= eESTABLISHED ) &&
@@ -2656,14 +2656,14 @@ void * vSocketClose( FreeRTOS_Socket_t * pxSocket )
         {
             if( *( ( const BaseType_t * ) pvOptionValue ) != 0 )
             {
-                pxSocket->u.xTCP.bits.bRxStopped = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bRxStopped = ipTRUE_BOOL;
             }
             else
             {
-                pxSocket->u.xTCP.bits.bRxStopped = pdFALSE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bRxStopped = ipFALSE_BOOL;
             }
 
-            pxSocket->u.xTCP.bits.bWinChange = pdTRUE_UNSIGNED;
+            pxSocket->u.xTCP.bits.bWinChange = ipTRUE_BOOL;
             pxSocket->u.xTCP.usTimeout = 1U; /* to set/clear bRxStopped */
             ( void ) xSendEventToIPTask( eTCPTimerEvent );
             xReturn = 0;
@@ -2740,11 +2740,11 @@ static void prvSetOptionTimeout( FreeRTOS_Socket_t * pxSocket,
         {
             if( *( ( const BaseType_t * ) pvOptionValue ) != 0 )
             {
-                pxSocket->u.xTCP.bits.bReuseSocket = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bReuseSocket = ipTRUE_BOOL;
             }
             else
             {
-                pxSocket->u.xTCP.bits.bReuseSocket = pdFALSE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bReuseSocket = ipFALSE_BOOL;
             }
 
             xReturn = 0;
@@ -2775,11 +2775,11 @@ static void prvSetOptionTimeout( FreeRTOS_Socket_t * pxSocket,
         {
             if( *( ( const BaseType_t * ) pvOptionValue ) != 0 )
             {
-                pxSocket->u.xTCP.bits.bCloseAfterSend = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bCloseAfterSend = ipTRUE_BOOL;
             }
             else
             {
-                pxSocket->u.xTCP.bits.bCloseAfterSend = pdFALSE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bCloseAfterSend = ipFALSE_BOOL;
             }
 
             xReturn = 0;
@@ -3497,7 +3497,7 @@ size_t FreeRTOS_GetLocalAddress( ConstSocket_t xSocket,
     switch( pxSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE Exclude this line because default case is not counted. */
     {
         #if ( ipconfigUSE_IPv4 != 0 )
-            case pdFALSE_UNSIGNED:
+            case ipFALSE_BOOL:
                 pxAddress->sin_family = FREERTOS_AF_INET;
                 pxAddress->sin_len = ( uint8_t ) sizeof( *pxAddress );
                 /* IP address of local machine. */
@@ -3509,7 +3509,7 @@ size_t FreeRTOS_GetLocalAddress( ConstSocket_t xSocket,
         #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
         #if ( ipconfigUSE_IPv6 != 0 )
-            case pdTRUE_UNSIGNED:
+            case ipTRUE_BOOL:
                 pxAddress->sin_family = FREERTOS_AF_INET6;
                 /* IP address of local machine. */
                 ( void ) memcpy( pxAddress->sin_address.xIP_IPv6.ucBytes, pxSocket->xLocalAddress.xIP_IPv6.ucBytes, sizeof( pxAddress->sin_address.xIP_IPv6.ucBytes ) );
@@ -3712,14 +3712,14 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
             /* Start the connect procedure, kernel will start working on it */
             if( xResult == 0 )
             {
-                pxSocket->u.xTCP.bits.bConnPrepared = pdFALSE;
+                pxSocket->u.xTCP.bits.bConnPrepared = ipFALSE_BOOL;
                 pxSocket->u.xTCP.ucRepCount = 0U;
 
                 switch( pxAddress->sin_family )
                 {
                     #if ( ipconfigUSE_IPv6 != 0 )
                         case FREERTOS_AF_INET6:
-                            pxSocket->bits.bIsIPv6 = pdTRUE_UNSIGNED;
+                            pxSocket->bits.bIsIPv6 = ipTRUE_BOOL;
                             FreeRTOS_printf( ( "FreeRTOS_connect: %u to %pip port %u\n",
                                                pxSocket->usLocalPort, ( void * ) pxAddress->sin_address.xIP_IPv6.ucBytes,
                                                FreeRTOS_ntohs( pxAddress->sin_port ) ) );
@@ -3729,7 +3729,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
 
                     #if ( ipconfigUSE_IPv4 != 0 )
                         case FREERTOS_AF_INET4:
-                            pxSocket->bits.bIsIPv6 = pdFALSE_UNSIGNED;
+                            pxSocket->bits.bIsIPv6 = ipFALSE_BOOL;
                             FreeRTOS_printf( ( "FreeRTOS_connect: %u to %xip:%u\n",
                                                pxSocket->usLocalPort, ( unsigned int ) FreeRTOS_ntohl( pxAddress->sin_address.ulIP_IPv4 ), FreeRTOS_ntohs( pxAddress->sin_port ) ) );
                             pxSocket->u.xTCP.xRemoteIP.ulIP_IPv4 = FreeRTOS_ntohl( pxAddress->sin_address.ulIP_IPv4 );
@@ -3897,7 +3897,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
         /* Is there a new client? */
         vTaskSuspendAll();
         {
-            if( pxParentSocket->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED )
+            if( pxParentSocket->u.xTCP.bits.bReuseSocket == ipFALSE_BOOL )
             {
                 pxClientSocket = pxParentSocket->u.xTCP.pxPeerSocket;
             }
@@ -3909,14 +3909,14 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
             if( pxClientSocket != NULL )
             {
                 /* Is it still not taken ? */
-                if( pxClientSocket->u.xTCP.bits.bPassAccept != pdFALSE_UNSIGNED )
+                if( pxClientSocket->u.xTCP.bits.bPassAccept != ipFALSE_BOOL )
                 {
                     if( pxParentSocket->u.xTCP.pxPeerSocket != NULL )
                     {
                         pxParentSocket->u.xTCP.pxPeerSocket = NULL;
                     }
 
-                    pxClientSocket->u.xTCP.bits.bPassAccept = pdFALSE_UNSIGNED;
+                    pxClientSocket->u.xTCP.bits.bPassAccept = ipFALSE_BOOL;
                 }
                 else
                 {
@@ -3926,7 +3926,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
         }
         ( void ) xTaskResumeAll();
 
-        if( ( pxClientSocket != NULL ) && ( pxParentSocket->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED ) )
+        if( ( pxClientSocket != NULL ) && ( pxParentSocket->u.xTCP.bits.bReuseSocket == ipFALSE_BOOL ) )
         {
             FreeRTOS_printf( ( "prvAcceptWaitClient: client %p parent %p\n",
                                ( void * ) pxClientSocket, ( void * ) pxParentSocket ) );
@@ -3942,7 +3942,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
             switch( pxClientSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE Exclude this line because default case is not counted. */
             {
                 #if ( ipconfigUSE_IPv4 != 0 )
-                    case pdFALSE_UNSIGNED:
+                    case ipFALSE_BOOL:
 
                         if( pxAddress != NULL )
                         {
@@ -3955,7 +3955,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
                 #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
                 #if ( ipconfigUSE_IPv6 != 0 )
-                    case pdTRUE_UNSIGNED:
+                    case ipTRUE_BOOL:
 
                         if( pxAddress != NULL )
                         {
@@ -4012,7 +4012,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
             /* coverity[misra_c_2012_rule_11_4_violation] */
             pxClientSocket = FREERTOS_INVALID_SOCKET;
         }
-        else if( ( pxSocket->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED ) &&
+        else if( ( pxSocket->u.xTCP.bits.bReuseSocket == ipFALSE_BOOL ) &&
                  ( pxSocket->u.xTCP.eTCPState != eTCP_LISTEN ) )
         {
             /* Parent socket is not in listening mode */
@@ -4031,7 +4031,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
 
                 if( pxClientSocket != NULL )
                 {
-                    if( pxSocket->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED )
+                    if( pxSocket->u.xTCP.bits.bReuseSocket == ipFALSE_BOOL )
                     {
                         /* Ask to set an event in 'xEventGroup' as soon as a new
                          * client gets connected for this listening socket. */
@@ -4114,7 +4114,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
                                             ( size_t ) uxBufferLength,
                                             xIsPeek );
 
-            if( pxSocket->u.xTCP.bits.bLowWater != pdFALSE_UNSIGNED )
+            if( pxSocket->u.xTCP.bits.bLowWater != ipFALSE_BOOL )
             {
                 /* We had reached the low-water mark, now see if the flag
                  * can be cleared */
@@ -4122,8 +4122,8 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
 
                 if( uxFrontSpace >= pxSocket->u.xTCP.uxEnoughSpace )
                 {
-                    pxSocket->u.xTCP.bits.bLowWater = pdFALSE_UNSIGNED;
-                    pxSocket->u.xTCP.bits.bWinChange = pdTRUE_UNSIGNED;
+                    pxSocket->u.xTCP.bits.bLowWater = ipFALSE_BOOL;
+                    pxSocket->u.xTCP.bits.bWinChange = ipTRUE_BOOL;
                     pxSocket->u.xTCP.usTimeout = 1U; /* because bLowWater is cleared. */
                     ( void ) xSendEventToIPTask( eTCPTimerEvent );
                 }
@@ -4178,7 +4178,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
                 /* Return -ENOTCONN, unless there was a malloc failure. */
                 xByteCount = -pdFREERTOS_ERRNO_ENOTCONN;
 
-                if( pxSocket->u.xTCP.bits.bMallocError != pdFALSE_UNSIGNED )
+                if( pxSocket->u.xTCP.bits.bMallocError != ipFALSE_BOOL )
                 {
                     /* The no-memory error has priority above the non-connected error.
                      * Both are fatal and will lead to closing the socket. */
@@ -4346,7 +4346,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
         {
             xResult = -pdFREERTOS_ERRNO_EINVAL;
         }
-        else if( pxSocket->u.xTCP.bits.bMallocError != pdFALSE_UNSIGNED )
+        else if( pxSocket->u.xTCP.bits.bMallocError != ipFALSE_BOOL )
         {
             xResult = -pdFREERTOS_ERRNO_ENOMEM;
         }
@@ -4356,7 +4356,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
         {
             xResult = -pdFREERTOS_ERRNO_ENOTCONN;
         }
-        else if( pxSocket->u.xTCP.bits.bFinSent != pdFALSE_UNSIGNED )
+        else if( pxSocket->u.xTCP.bits.bFinSent != ipFALSE_BOOL )
         {
             /* This TCP connection is closing already, the FIN flag has been sent.
              * Maybe it is still delivering or receiving data.
@@ -4413,7 +4413,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
             /* If the TX buffer hasn't been created yet,
              * and if no malloc error has occurred on this socket yet. */
             if( ( pxBuffer == NULL ) &&
-                ( pxSocket->u.xTCP.bits.bMallocError == pdFALSE_UNSIGNED ) )
+                ( pxSocket->u.xTCP.bits.bMallocError == ipFALSE_BOOL ) )
             {
                 /* Create the outgoing stream only when it is needed */
                 ( void ) prvTCPCreateStream( pxSocket, pdFALSE );
@@ -4460,7 +4460,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
             /* If the TX buffer hasn't been created yet,
              * and if no malloc error has occurred on this socket yet. */
             if( ( pxBuffer == NULL ) &&
-                ( pxSocket->u.xTCP.bits.bMallocError == pdFALSE_UNSIGNED ) )
+                ( pxSocket->u.xTCP.bits.bMallocError == ipFALSE_BOOL ) )
             {
                 /* Create the outgoing stream only when it is needed */
                 ( void ) prvTCPCreateStream( pxSocket, pdFALSE );
@@ -4532,7 +4532,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
                     xByteCount = xBytesLeft;
                 }
 
-                if( ( pxSocket->u.xTCP.bits.bCloseAfterSend != pdFALSE_UNSIGNED ) &&
+                if( ( pxSocket->u.xTCP.bits.bCloseAfterSend != ipFALSE_BOOL ) &&
                     ( xByteCount == xBytesLeft ) )
                 {
                     xCloseAfterSend = pdTRUE;
@@ -4540,7 +4540,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
                     /* Now suspend the scheduler: sending the last data and
                      * setting bCloseRequested must be done together */
                     vTaskSuspendAll();
-                    pxSocket->u.xTCP.bits.bCloseRequested = pdTRUE_UNSIGNED;
+                    pxSocket->u.xTCP.bits.bCloseRequested = ipTRUE_BOOL;
 
                     /* The flag 'bCloseAfterSend' can be set before sending data
                      * using setsockopt()
@@ -4748,7 +4748,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
 
             /* This cleaning is necessary only if a listening socket is being
              * reused as it might have had a previous connection. */
-            if( pxSocket->u.xTCP.bits.bReuseSocket != pdFALSE_UNSIGNED )
+            if( pxSocket->u.xTCP.bits.bReuseSocket != ipFALSE_BOOL )
             {
                 if( pxSocket->u.xTCP.rxStream != NULL )
                 {
@@ -4766,7 +4766,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
 
                 /* Now set the bReuseSocket flag again, because the bits have
                  * just been cleared. */
-                pxSocket->u.xTCP.bits.bReuseSocket = pdTRUE;
+                pxSocket->u.xTCP.bits.bReuseSocket = ipTRUE_BOOL;
             }
 
             vTCPStateChange( pxSocket, eTCP_LISTEN );
@@ -4811,7 +4811,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
         }
         else
         {
-            pxSocket->u.xTCP.bits.bUserShutdown = pdTRUE_UNSIGNED;
+            pxSocket->u.xTCP.bits.bUserShutdown = ipTRUE_BOOL;
 
             /* Let the IP-task perform the shutdown of the connection. */
             pxSocket->u.xTCP.usTimeout = 1U;
@@ -5123,7 +5123,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
         if( pxBuffer == NULL )
         {
             FreeRTOS_debug_printf( ( "prvTCPCreateStream: malloc failed\n" ) );
-            pxSocket->u.xTCP.bits.bMallocError = pdTRUE_UNSIGNED;
+            pxSocket->u.xTCP.bits.bMallocError = ipTRUE_BOOL;
             vTCPStateChange( pxSocket, eCLOSE_WAIT );
         }
         else
@@ -5214,14 +5214,14 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
     static void vTCPAddRxdata_Stored( FreeRTOS_Socket_t * pxSocket )
     {
         /* See if running out of space. */
-        if( pxSocket->u.xTCP.bits.bLowWater == pdFALSE_UNSIGNED )
+        if( pxSocket->u.xTCP.bits.bLowWater == ipFALSE_BOOL )
         {
             size_t uxFrontSpace = uxStreamBufferFrontSpace( pxSocket->u.xTCP.rxStream );
 
             if( uxFrontSpace <= pxSocket->u.xTCP.uxLittleSpace )
             {
-                pxSocket->u.xTCP.bits.bLowWater = pdTRUE_UNSIGNED;
-                pxSocket->u.xTCP.bits.bWinChange = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bLowWater = ipTRUE_BOOL;
+                pxSocket->u.xTCP.bits.bWinChange = ipTRUE_BOOL;
 
                 /* bLowWater was reached, send the changed window size. */
                 pxSocket->u.xTCP.usTimeout = 1U;
@@ -5378,7 +5378,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
             switch( pxSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE Exclude this line because default case is not counted. */
             {
                 #if ( ipconfigUSE_IPv4 != 0 )
-                    case pdFALSE_UNSIGNED:
+                    case ipFALSE_BOOL:
                         pxAddress->sin_len = ( uint8_t ) sizeof( *pxAddress );
                         pxAddress->sin_family = FREERTOS_AF_INET;
 
@@ -5391,7 +5391,7 @@ void vSocketWakeUpUser( FreeRTOS_Socket_t * pxSocket )
                 #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
                 #if ( ipconfigUSE_IPv6 != 0 )
-                    case pdTRUE_UNSIGNED:
+                    case ipTRUE_BOOL:
                         pxAddress->sin_family = FREERTOS_AF_INET6;
 
                         /* IP address of remote machine. */
@@ -5812,13 +5812,13 @@ BaseType_t FreeRTOS_GetIPType( ConstSocket_t xSocket )
     switch( pxSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE Exclude this line because default case is not counted. */
     {
         #if ( ipconfigUSE_IPv4 != 0 )
-            case pdFALSE_UNSIGNED:
+            case ipFALSE_BOOL:
                 xResult = ( BaseType_t ) ipTYPE_IPv4;
                 break;
         #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
         #if ( ipconfigUSE_IPv6 != 0 )
-            case pdTRUE_UNSIGNED:
+            case ipTRUE_BOOL:
                 xResult = ( BaseType_t ) ipTYPE_IPv6;
                 break;
         #endif /* ( ipconfigUSE_IPv6 != 0 ) */
@@ -5872,13 +5872,13 @@ BaseType_t FreeRTOS_GetIPType( ConstSocket_t xSocket )
         switch( pxSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE Exclude this line because default case is not counted. */
         {
             #if ( ipconfigUSE_IPv4 != 0 )
-                case pdFALSE_UNSIGNED:
+                case ipFALSE_BOOL:
                     ( void ) snprintf( pcRemoteIp, sizeof( pcRemoteIp ), "%xip", ( unsigned ) pxSocket->u.xTCP.xRemoteIP.ulIP_IPv4 );
                     break;
             #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
             #if ( ipconfigUSE_IPv6 != 0 )
-                case pdTRUE_UNSIGNED:
+                case ipTRUE_BOOL:
                     ( void ) snprintf( pcRemoteIp,
                                        sizeof( pcRemoteIp ),
                                        "%pip", ( void * ) pxSocket->u.xTCP.xRemoteIP.xIP_IPv6.ucBytes );
@@ -5981,9 +5981,9 @@ BaseType_t FreeRTOS_GetIPType( ConstSocket_t xSocket )
             BaseType_t bAccepted = pdFALSE;
             EventBits_t xSocketBits = 0U;
 
-            if( pxSocket->u.xTCP.bits.bPassQueued == pdFALSE_UNSIGNED )
+            if( pxSocket->u.xTCP.bits.bPassQueued == ipFALSE_BOOL )
             {
-                if( pxSocket->u.xTCP.bits.bPassAccept == pdFALSE_UNSIGNED )
+                if( pxSocket->u.xTCP.bits.bPassAccept == ipFALSE_BOOL )
                 {
                     bAccepted = pdTRUE;
                 }
@@ -5994,12 +5994,12 @@ BaseType_t FreeRTOS_GetIPType( ConstSocket_t xSocket )
             {
                 if( pxSocket->u.xTCP.eTCPState == eTCP_LISTEN )
                 {
-                    if( ( pxSocket->u.xTCP.pxPeerSocket != NULL ) && ( pxSocket->u.xTCP.pxPeerSocket->u.xTCP.bits.bPassAccept != pdFALSE_UNSIGNED ) )
+                    if( ( pxSocket->u.xTCP.pxPeerSocket != NULL ) && ( pxSocket->u.xTCP.pxPeerSocket->u.xTCP.bits.bPassAccept != ipFALSE_BOOL ) )
                     {
                         xSocketBits |= ( EventBits_t ) eSELECT_READ;
                     }
                 }
-                else if( ( pxSocket->u.xTCP.bits.bReuseSocket != pdFALSE_UNSIGNED ) && ( pxSocket->u.xTCP.bits.bPassAccept != pdFALSE_UNSIGNED ) )
+                else if( ( pxSocket->u.xTCP.bits.bReuseSocket != ipFALSE_BOOL ) && ( pxSocket->u.xTCP.bits.bPassAccept != ipFALSE_BOOL ) )
                 {
                     /* This socket has the re-use flag. After connecting it turns into
                      * a connected socket. Set the READ event, so that accept() will be called. */
@@ -6039,11 +6039,11 @@ BaseType_t FreeRTOS_GetIPType( ConstSocket_t xSocket )
 
                 if( bMatch == pdFALSE )
                 {
-                    if( ( pxSocket->u.xTCP.bits.bConnPrepared != pdFALSE_UNSIGNED ) &&
+                    if( ( pxSocket->u.xTCP.bits.bConnPrepared != ipFALSE_BOOL ) &&
                         ( pxSocket->u.xTCP.eTCPState >= eESTABLISHED ) &&
-                        ( pxSocket->u.xTCP.bits.bConnPassed == pdFALSE_UNSIGNED ) )
+                        ( pxSocket->u.xTCP.bits.bConnPassed == ipFALSE_BOOL ) )
                     {
-                        pxSocket->u.xTCP.bits.bConnPassed = pdTRUE_UNSIGNED;
+                        pxSocket->u.xTCP.bits.bConnPassed = ipTRUE_BOOL;
                         bMatch = pdTRUE;
                     }
                 }
diff --git a/source/FreeRTOS_TCP_IP.c b/source/FreeRTOS_TCP_IP.c
index 9d9156882e..ef3462548b 100644
--- a/source/FreeRTOS_TCP_IP.c
+++ b/source/FreeRTOS_TCP_IP.c
@@ -160,7 +160,7 @@
             {
                 /* The first task of this regular socket check is to send-out delayed
                  * ACK's. */
-                if( pxSocket->u.xTCP.bits.bUserShutdown == pdFALSE_UNSIGNED )
+                if( pxSocket->u.xTCP.bits.bUserShutdown == ipFALSE_BOOL )
                 {
                     /* Earlier data was received but not yet acknowledged.  This
                      * function is called when the TCP timer for the socket expires, the
@@ -254,8 +254,8 @@
 
         #if ( ipconfigTCP_KEEP_ALIVE == 1 )
         {
-            pxSocket->u.xTCP.bits.bWaitKeepAlive = pdFALSE_UNSIGNED;
-            pxSocket->u.xTCP.bits.bSendKeepAlive = pdFALSE_UNSIGNED;
+            pxSocket->u.xTCP.bits.bWaitKeepAlive = ipFALSE_BOOL;
+            pxSocket->u.xTCP.bits.bSendKeepAlive = ipFALSE_BOOL;
             pxSocket->u.xTCP.ucKeepRepCount = 0U;
             pxSocket->u.xTCP.xLastAliveTime = xTaskGetTickCount();
         }
@@ -344,10 +344,10 @@
         if( bBefore != bAfter )
         {
             /* if bPassQueued is true, this socket is an orphan until it gets connected. */
-            if( pxSocket->u.xTCP.bits.bPassQueued != pdFALSE_UNSIGNED )
+            if( pxSocket->u.xTCP.bits.bPassQueued != ipFALSE_BOOL )
             {
                 /* Find it's parent if the reuse bit is not set. */
-                if( pxSocket->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED )
+                if( pxSocket->u.xTCP.bits.bReuseSocket == ipFALSE_BOOL )
                 {
                     xParent = pxSocket->u.xTCP.pxPeerSocket;
                     configASSERT( xParent != NULL );
@@ -358,7 +358,7 @@
             if( bAfter != pdFALSE )
             {
                 /* if bPassQueued is true, this socket is an orphan until it gets connected. */
-                if( pxSocket->u.xTCP.bits.bPassQueued != pdFALSE_UNSIGNED )
+                if( pxSocket->u.xTCP.bits.bPassQueued != ipFALSE_BOOL )
                 {
                     if( xParent != NULL )
                     {
@@ -388,7 +388,7 @@
                         #if ( ipconfigUSE_CALLBACKS == 1 )
                         {
                             if( ( ipconfigIS_VALID_PROG_ADDRESS( xParent->u.xTCP.pxHandleConnected ) ) &&
-                                ( xParent->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED ) )
+                                ( xParent->u.xTCP.bits.bReuseSocket == ipFALSE_BOOL ) )
                             {
                                 /* The listening socket does not become connected itself, in stead
                                  * a child socket is created.
@@ -402,10 +402,10 @@
                     /* Don't need to access the parent socket anymore, so the
                      * reference 'pxPeerSocket' may be cleared. */
                     pxSocket->u.xTCP.pxPeerSocket = NULL;
-                    pxSocket->u.xTCP.bits.bPassQueued = pdFALSE_UNSIGNED;
+                    pxSocket->u.xTCP.bits.bPassQueued = ipFALSE_BOOL;
 
                     /* When true, this socket may be returned in a call to accept(). */
-                    pxSocket->u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
+                    pxSocket->u.xTCP.bits.bPassAccept = ipTRUE_BOOL;
                 }
                 else
                 {
@@ -473,6 +473,10 @@
                 xParent = pxSocket->u.xTCP.pxPeerSocket;
             }
 
+            /* Parent is not NULL in a socket which is in listening mode. If reuse socket
+             * flag is set to false, a new socket is created on a 'listen' even and added
+             * to the peer socket field. */
+            /* coverity[NULL_FIELD] */
             if( ( xParent->u.xTCP.pxPeerSocket != NULL ) &&
                 ( xParent->u.xTCP.pxPeerSocket == pxSocket ) )
             {
@@ -494,16 +498,16 @@
 
             vTaskSuspendAll();
             {
-                if( ( pxSocket->u.xTCP.bits.bPassQueued != pdFALSE_UNSIGNED ) ||
-                    ( pxSocket->u.xTCP.bits.bPassAccept != pdFALSE_UNSIGNED ) )
+                if( ( pxSocket->u.xTCP.bits.bPassQueued != ipFALSE_BOOL ) ||
+                    ( pxSocket->u.xTCP.bits.bPassAccept != ipFALSE_BOOL ) )
                 {
-                    if( pxSocket->u.xTCP.bits.bReuseSocket == pdFALSE_UNSIGNED )
+                    if( pxSocket->u.xTCP.bits.bReuseSocket == ipFALSE_BOOL )
                     {
                         xHasCleared = vTCPRemoveTCPChild( pxSocket );
                         ( void ) xHasCleared;
 
-                        pxSocket->u.xTCP.bits.bPassQueued = pdFALSE_UNSIGNED;
-                        pxSocket->u.xTCP.bits.bPassAccept = pdFALSE_UNSIGNED;
+                        pxSocket->u.xTCP.bits.bPassQueued = ipFALSE_BOOL;
+                        pxSocket->u.xTCP.bits.bPassAccept = ipFALSE_BOOL;
                         configASSERT( xIsCallingFromIPTask() != pdFALSE );
                         vSocketCloseNextTime( pxSocket );
                     }
@@ -514,7 +518,7 @@
                                ( int ) xHasCleared ) );
         }
 
-        if( ( eTCPState == eCLOSE_WAIT ) && ( pxSocket->u.xTCP.bits.bReuseSocket == pdTRUE_UNSIGNED ) )
+        if( ( eTCPState == eCLOSE_WAIT ) && ( pxSocket->u.xTCP.bits.bReuseSocket == ipTRUE_BOOL ) )
         {
             switch( xPreviousState )
             {
@@ -549,7 +553,7 @@
                 switch( pxSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE */
                 {
                     #if ( ipconfigUSE_IPv4 != 0 )
-                        case pdFALSE_UNSIGNED:
+                        case ipFALSE_BOOL:
                            {
                                uint32_t ulIPAddress = FreeRTOS_ntohl( pxSocket->u.xTCP.xRemoteIP.ulIP_IPv4 );
                                FreeRTOS_inet_ntop( FREERTOS_AF_INET4,
@@ -561,7 +565,7 @@
                     #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
                     #if ( ipconfigUSE_IPv6 != 0 )
-                        case pdTRUE_UNSIGNED:
+                        case ipTRUE_BOOL:
                             FreeRTOS_inet_ntop( FREERTOS_AF_INET6,
                                                 pxSocket->u.xTCP.xRemoteIP.xIP_IPv6.ucBytes,
                                                 pcBuffer,
@@ -616,7 +620,7 @@
         if( pxSocket->u.xTCP.eTCPState == eCONNECT_SYN )
         {
             /* The socket is actively connecting to a peer. */
-            if( pxSocket->u.xTCP.bits.bConnPrepared != pdFALSE_UNSIGNED )
+            if( pxSocket->u.xTCP.bits.bConnPrepared != ipFALSE_BOOL )
             {
                 /* Ethernet address has been found, use progressive timeout for
                  * active connect(). */
@@ -1016,7 +1020,7 @@
             {
                 pxFound = ( ( FreeRTOS_Socket_t * ) listGET_LIST_ITEM_OWNER( pxIterator ) );
 
-                if( ( pxFound->ucProtocol == ( uint8_t ) FREERTOS_IPPROTO_TCP ) && ( pxFound->u.xTCP.bits.bPassAccept != pdFALSE_UNSIGNED ) )
+                if( ( pxFound->ucProtocol == ( uint8_t ) FREERTOS_IPPROTO_TCP ) && ( pxFound->u.xTCP.bits.bPassAccept != ipFALSE_BOOL ) )
                 {
                     pxSocket->u.xTCP.pxPeerSocket = pxFound;
                     FreeRTOS_debug_printf( ( "xTCPCheckNewClient[0]: client on port %u\n", pxSocket->usLocalPort ) );
diff --git a/source/FreeRTOS_TCP_Reception.c b/source/FreeRTOS_TCP_Reception.c
index 4f1003a67c..632e6b1a4c 100644
--- a/source/FreeRTOS_TCP_Reception.c
+++ b/source/FreeRTOS_TCP_Reception.c
@@ -247,7 +247,7 @@
                             pxSocket->u.xTCP.ucPeerWinScaleFactor = pucPtr[ 2 ];
                         }
 
-                        pxSocket->u.xTCP.bits.bWinScaling = pdTRUE_UNSIGNED;
+                        pxSocket->u.xTCP.bits.bWinScaling = ipTRUE_BOOL;
                     }
 
                     lIndex = ( int32_t ) tcpTCP_OPT_WSOPT_LEN;
@@ -297,7 +297,7 @@
                     if( pxSocket->u.xTCP.usMSS > uxNewMSS )
                     {
                         /* our MSS was bigger than the MSS of the other party: adapt it. */
-                        pxSocket->u.xTCP.bits.bMssChange = pdTRUE_UNSIGNED;
+                        pxSocket->u.xTCP.bits.bMssChange = ipTRUE_BOOL;
 
                         if( pxSocket->u.xTCP.usMSS > uxNewMSS )
                         {
diff --git a/source/FreeRTOS_TCP_State_Handling.c b/source/FreeRTOS_TCP_State_Handling.c
index 6376af4367..5631d2d7d4 100644
--- a/source/FreeRTOS_TCP_State_Handling.c
+++ b/source/FreeRTOS_TCP_State_Handling.c
@@ -199,7 +199,7 @@
 
                     /* When 'bPassQueued' true, this socket is an orphan until it
                      * gets connected. */
-                    if( pxSocket->u.xTCP.bits.bPassQueued != pdFALSE_UNSIGNED )
+                    if( pxSocket->u.xTCP.bits.bPassQueued != ipFALSE_BOOL )
                     {
                         /* vTCPStateChange() has called vSocketCloseNextTime()
                          * in case the socket is not yet owned by the application.
@@ -249,22 +249,22 @@
             pxTCPWindow->rx.ulCurrentSequenceNumber = pxTCPWindow->rx.ulFINSequenceNumber + 1U;
         }
 
-        if( pxSocket->u.xTCP.bits.bFinSent == pdFALSE_UNSIGNED )
+        if( pxSocket->u.xTCP.bits.bFinSent == ipFALSE_BOOL )
         {
             /* We haven't yet replied with a FIN, do so now. */
             pxTCPWindow->tx.ulFINSequenceNumber = pxTCPWindow->tx.ulCurrentSequenceNumber;
-            pxSocket->u.xTCP.bits.bFinSent = pdTRUE_UNSIGNED;
+            pxSocket->u.xTCP.bits.bFinSent = ipTRUE_BOOL;
         }
         else
         {
             /* We did send a FIN already, see if it's ACK'd. */
             if( ulAckNr == ( pxTCPWindow->tx.ulFINSequenceNumber + 1U ) )
             {
-                pxSocket->u.xTCP.bits.bFinAcked = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bFinAcked = ipTRUE_BOOL;
             }
         }
 
-        if( pxSocket->u.xTCP.bits.bFinAcked == pdFALSE_UNSIGNED )
+        if( pxSocket->u.xTCP.bits.bFinAcked == ipFALSE_BOOL )
         {
             pxTCPWindow->tx.ulCurrentSequenceNumber = pxTCPWindow->tx.ulFINSequenceNumber;
             pxTCPHeader->ucTCPFlags = ( uint8_t ) tcpTCP_FLAG_ACK | ( uint8_t ) tcpTCP_FLAG_FIN;
@@ -277,7 +277,7 @@
             /* Our FIN has been ACK'd, the outgoing sequence number is now fixed. */
             pxTCPWindow->tx.ulCurrentSequenceNumber = pxTCPWindow->tx.ulFINSequenceNumber + 1U;
 
-            if( pxSocket->u.xTCP.bits.bFinRecv == pdFALSE_UNSIGNED )
+            if( pxSocket->u.xTCP.bits.bFinRecv == ipFALSE_BOOL )
             {
                 /* We have sent out a FIN but the peer hasn't replied with a FIN
                  * yet. Do nothing for the moment. */
@@ -285,7 +285,7 @@
             }
             else
             {
-                if( pxSocket->u.xTCP.bits.bFinLast == pdFALSE_UNSIGNED )
+                if( pxSocket->u.xTCP.bits.bFinLast == ipFALSE_BOOL )
                 {
                     /* This is the third of the three-way hand shake: the last
                      * ACK. */
@@ -437,7 +437,7 @@
             #if ( ipconfigUSE_TCP_WIN == 1 )
             {
                 char pcBuffer[ 40 ]; /* Space to print an IP-address. */
-                ( void ) FreeRTOS_inet_ntop( ( pxSocket->bits.bIsIPv6 != 0U ) ? FREERTOS_AF_INET6 : FREERTOS_AF_INET,
+                ( void ) FreeRTOS_inet_ntop( ( pxSocket->bits.bIsIPv6 != ipFALSE_BOOL ) ? FREERTOS_AF_INET6 : FREERTOS_AF_INET,
                                              ( void * ) pxSocket->u.xTCP.xRemoteIP.xIP_IPv6.ucBytes,
                                              pcBuffer,
                                              sizeof( pcBuffer ) );
@@ -461,7 +461,7 @@
 
             #if ( ipconfigUSE_TCP_WIN != 0 )
             {
-                if( pxSocket->u.xTCP.bits.bWinScaling == pdFALSE_UNSIGNED )
+                if( pxSocket->u.xTCP.bits.bWinScaling == ipFALSE_BOOL )
                 {
                     /* The other party did not send a scaling factor.
                      * A shifting factor in this side must be canceled. */
@@ -579,7 +579,7 @@
 
             pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber = pxTCPWindow->tx.ulCurrentSequenceNumber;
 
-            if( ( pxSocket->u.xTCP.bits.bFinAccepted != pdFALSE_UNSIGNED ) || ( ( ucTCPFlags & ( uint8_t ) tcpTCP_FLAG_FIN ) != 0U ) )
+            if( ( pxSocket->u.xTCP.bits.bFinAccepted != ipFALSE_BOOL ) || ( ( ucTCPFlags & ( uint8_t ) tcpTCP_FLAG_FIN ) != 0U ) )
             {
                 /* Peer is requesting to stop, see if we're really finished. */
                 xMayClose = pdTRUE;
@@ -587,7 +587,7 @@
                 lDistance = ( int32_t ) ulIntermediateResult;
 
                 /* Checks are only necessary if we haven't sent a FIN yet. */
-                if( pxSocket->u.xTCP.bits.bFinSent == pdFALSE_UNSIGNED )
+                if( pxSocket->u.xTCP.bits.bFinSent == ipFALSE_BOOL )
                 {
                     /* xTCPWindowTxDone returns true when all Tx queues are empty. */
                     bRxComplete = xTCPWindowRxEmpty( pxTCPWindow );
@@ -637,7 +637,7 @@
 
                 if( xMayClose != pdFALSE )
                 {
-                    pxSocket->u.xTCP.bits.bFinAccepted = pdTRUE_UNSIGNED;
+                    pxSocket->u.xTCP.bits.bFinAccepted = ipTRUE_BOOL;
                     xSendLength = prvTCPHandleFin( pxSocket, *ppxNetworkBuffer );
                 }
             }
@@ -653,7 +653,7 @@
                     /* TCP-offset equals '( ( length / 4 ) << 4 )', resulting in a shift-left 2 */
                     pxTCPHeader->ucTCPOffset = ( uint8_t ) ( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 );
 
-                    if( pxSocket->u.xTCP.bits.bFinSent != pdFALSE_UNSIGNED )
+                    if( pxSocket->u.xTCP.bits.bFinSent != ipFALSE_BOOL )
                     {
                         pxTCPWindow->tx.ulCurrentSequenceNumber = pxTCPWindow->tx.ulFINSequenceNumber;
                     }
@@ -748,7 +748,7 @@
                 /* This is most probably a keep-alive message from peer.  Setting
                  * 'bWinChange' doesn't cause a window-size-change, the flag is used
                  * here to force sending an immediate ACK. */
-                pxSocket->u.xTCP.bits.bWinChange = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bWinChange = ipTRUE_BOOL;
             }
         }
 
@@ -783,18 +783,18 @@
                 vTCPStateChange( pxSocket, eSYN_FIRST );
             }
 
-            if( ( ( ucTCPFlags & tcpTCP_FLAG_FIN ) != 0U ) && ( pxSocket->u.xTCP.bits.bFinRecv == pdFALSE_UNSIGNED ) )
+            if( ( ( ucTCPFlags & tcpTCP_FLAG_FIN ) != 0U ) && ( pxSocket->u.xTCP.bits.bFinRecv == ipFALSE_BOOL ) )
             {
                 /* It's the first time a FIN has been received, remember its
                  * sequence number. */
                 pxTCPWindow->rx.ulFINSequenceNumber = ulSequenceNumber + ulReceiveLength;
-                pxSocket->u.xTCP.bits.bFinRecv = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bFinRecv = ipTRUE_BOOL;
 
                 /* Was peer the first one to send a FIN? */
-                if( pxSocket->u.xTCP.bits.bFinSent == pdFALSE_UNSIGNED )
+                if( pxSocket->u.xTCP.bits.bFinSent == ipFALSE_BOOL )
                 {
                     /* If so, don't send the-last-ACK. */
-                    pxSocket->u.xTCP.bits.bFinLast = pdTRUE_UNSIGNED;
+                    pxSocket->u.xTCP.bits.bFinLast = ipTRUE_BOOL;
                 }
             }
 
@@ -1007,7 +1007,7 @@
 
             /* When bPassQueued is true, the socket is an orphan until it gets
              * connected. */
-            pxNewSocket->u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
+            pxNewSocket->u.xTCP.bits.bPassQueued = ipTRUE_BOOL;
             pxNewSocket->u.xTCP.pxPeerSocket = pxSocket;
         }
         #else
@@ -1017,7 +1017,7 @@
 
             /* When bPassAccept is true, this socket may be returned in a call to
              * accept(). */
-            pxNewSocket->u.xTCP.bits.bPassAccept = pdTRUE_UNSIGNED;
+            pxNewSocket->u.xTCP.bits.bPassAccept = ipTRUE_BOOL;
 
             if( pxSocket->u.xTCP.pxPeerSocket == NULL )
             {
diff --git a/source/FreeRTOS_TCP_State_Handling_IPv4.c b/source/FreeRTOS_TCP_State_Handling_IPv4.c
index 8ccae1883a..a7e8dd75a7 100644
--- a/source/FreeRTOS_TCP_State_Handling_IPv4.c
+++ b/source/FreeRTOS_TCP_State_Handling_IPv4.c
@@ -112,12 +112,12 @@ FreeRTOS_Socket_t * prvHandleListen_IPV4( FreeRTOS_Socket_t * pxSocket,
      * it. */
     if( ulInitialSequenceNumber != 0U )
     {
-        if( pxSocket->u.xTCP.bits.bReuseSocket != pdFALSE_UNSIGNED )
+        if( pxSocket->u.xTCP.bits.bReuseSocket != ipFALSE_BOOL )
         {
             /* The flag bReuseSocket indicates that the same instance of the
              * listening socket should be used for the connection. */
             pxReturn = pxSocket;
-            pxSocket->u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
+            pxSocket->u.xTCP.bits.bPassQueued = ipTRUE_BOOL;
             pxSocket->u.xTCP.pxPeerSocket = pxSocket;
         }
         else
@@ -182,7 +182,7 @@ FreeRTOS_Socket_t * prvHandleListen_IPV4( FreeRTOS_Socket_t * pxSocket,
 
             /* The endpoint in network buffer must be valid in this condition. */
             pxReturn->pxEndPoint = pxNetworkBuffer->pxEndPoint;
-            pxReturn->bits.bIsIPv6 = pdFALSE_UNSIGNED;
+            pxReturn->bits.bIsIPv6 = ipFALSE_BOOL;
             pxReturn->u.xTCP.usRemotePort = FreeRTOS_htons( pxTCPPacket->xTCPHeader.usSourcePort );
             pxReturn->u.xTCP.xRemoteIP.ulIP_IPv4 = FreeRTOS_htonl( pxTCPPacket->xIPHeader.ulSourceIPAddress );
             pxReturn->u.xTCP.xTCPWindow.ulOurSequenceNumber = ulInitialSequenceNumber;
diff --git a/source/FreeRTOS_TCP_State_Handling_IPv6.c b/source/FreeRTOS_TCP_State_Handling_IPv6.c
index 40ed8ca8aa..e09edd6632 100644
--- a/source/FreeRTOS_TCP_State_Handling_IPv6.c
+++ b/source/FreeRTOS_TCP_State_Handling_IPv6.c
@@ -107,12 +107,12 @@ FreeRTOS_Socket_t * prvHandleListen_IPV6( FreeRTOS_Socket_t * pxSocket,
      * it. */
     if( xHasSequence != pdFALSE )
     {
-        if( pxSocket->u.xTCP.bits.bReuseSocket != pdFALSE_UNSIGNED )
+        if( pxSocket->u.xTCP.bits.bReuseSocket != ipFALSE_BOOL )
         {
             /* The flag bReuseSocket indicates that the same instance of the
              * listening socket should be used for the connection. */
             pxReturn = pxSocket;
-            pxSocket->u.xTCP.bits.bPassQueued = pdTRUE_UNSIGNED;
+            pxSocket->u.xTCP.bits.bPassQueued = ipTRUE_BOOL;
             pxSocket->u.xTCP.pxPeerSocket = pxSocket;
         }
         else
@@ -177,7 +177,7 @@ FreeRTOS_Socket_t * prvHandleListen_IPV6( FreeRTOS_Socket_t * pxSocket,
                                                             &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + uxIPHeaderSizePacket( pxNetworkBuffer ) ] ) );
 
             pxReturn->pxEndPoint = pxNetworkBuffer->pxEndPoint;
-            pxReturn->bits.bIsIPv6 = pdTRUE_UNSIGNED;
+            pxReturn->bits.bIsIPv6 = ipTRUE_BOOL;
 
             /* MISRA Ref 11.3.1 [Misaligned access] */
             /* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
diff --git a/source/FreeRTOS_TCP_Transmission.c b/source/FreeRTOS_TCP_Transmission.c
index 36eb39c5f0..b61e85dad9 100644
--- a/source/FreeRTOS_TCP_Transmission.c
+++ b/source/FreeRTOS_TCP_Transmission.c
@@ -84,7 +84,7 @@
     {
         BaseType_t xReturn = pdTRUE;
 
-        if( pxSocket->u.xTCP.bits.bConnPrepared == pdFALSE_UNSIGNED )
+        if( pxSocket->u.xTCP.bits.bConnPrepared == ipFALSE_BOOL )
         {
             if( prvTCPPrepareConnect( pxSocket ) != pdTRUE )
             {
@@ -332,7 +332,7 @@
         /* Take the minimum of the RX buffer space and the RX window size. */
         ulSpace = FreeRTOS_min_uint32( pxTCPWindow->xSize.ulRxWindowLength, ulFrontSpace );
 
-        if( ( pxSocket->u.xTCP.bits.bLowWater != pdFALSE_UNSIGNED ) || ( pxSocket->u.xTCP.bits.bRxStopped != pdFALSE_UNSIGNED ) )
+        if( ( pxSocket->u.xTCP.bits.bLowWater != ipFALSE_BOOL ) || ( pxSocket->u.xTCP.bits.bRxStopped != ipFALSE_BOOL ) )
         {
             /* The low-water mark was reached, meaning there was little
              * space left.  The socket will wait until the application has read
@@ -368,7 +368,7 @@
         pxProtocolHeaders->xTCPHeader.usWindow = FreeRTOS_htons( ( uint16_t ) ulWinSize );
 
         /* The new window size has been advertised, switch off the flag. */
-        pxSocket->u.xTCP.bits.bWinChange = pdFALSE_UNSIGNED;
+        pxSocket->u.xTCP.bits.bWinChange = ipFALSE_BOOL;
 
         /* Later on, when deciding to delay an ACK, a precise estimate is needed
          * of the free RX space.  At this moment, 'ulHighestRxAllowed' would be the
@@ -400,13 +400,13 @@
         pxProtocolHeaders = ( ( ProtocolHeaders_t * )
                               &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + uxIPHeaderSize ] ) );
         #if ( ipconfigTCP_KEEP_ALIVE == 1 )
-            if( pxSocket->u.xTCP.bits.bSendKeepAlive != pdFALSE_UNSIGNED )
+            if( pxSocket->u.xTCP.bits.bSendKeepAlive != ipFALSE_BOOL )
             {
                 /* Sending a keep-alive packet, send the current sequence number
                  * minus 1, which will be recognised as a keep-alive packet and
                  * responded to by acknowledging the last byte. */
-                pxSocket->u.xTCP.bits.bSendKeepAlive = pdFALSE_UNSIGNED;
-                pxSocket->u.xTCP.bits.bWaitKeepAlive = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bSendKeepAlive = ipFALSE_BOOL;
+                pxSocket->u.xTCP.bits.bWaitKeepAlive = ipTRUE_BOOL;
 
                 pxProtocolHeaders->xTCPHeader.ulSequenceNumber = pxSocket->u.xTCP.xTCPWindow.ulOurSequenceNumber - 1U;
                 pxProtocolHeaders->xTCPHeader.ulSequenceNumber = FreeRTOS_htonl( pxProtocolHeaders->xTCPHeader.ulSequenceNumber );
@@ -496,13 +496,13 @@
         switch( pxSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE */
         {
             #if ( ipconfigUSE_IPv4 != 0 )
-                case pdFALSE_UNSIGNED:
+                case ipFALSE_BOOL:
                     xReturn = prvTCPPrepareConnect_IPV4( pxSocket );
                     break;
             #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
             #if ( ipconfigUSE_IPv6 != 0 )
-                case pdTRUE_UNSIGNED:
+                case ipTRUE_BOOL:
                     xReturn = prvTCPPrepareConnect_IPV6( pxSocket );
                     break;
             #endif /* ( ipconfigUSE_IPv6 != 0 ) */
@@ -896,7 +896,7 @@
 
                     /* If the owner of the socket requests a closure, add the FIN
                      * flag to the last packet. */
-                    if( pxSocket->u.xTCP.bits.bCloseRequested != pdFALSE_UNSIGNED )
+                    if( pxSocket->u.xTCP.bits.bCloseRequested != ipFALSE_BOOL )
                     {
                         ulDistance = ( uint32_t ) uxStreamBufferDistance( pxSocket->u.xTCP.txStream, ( size_t ) lStreamPos, pxSocket->u.xTCP.txStream->uxHead );
 
@@ -921,7 +921,7 @@
                              * delivered. */
                             pxProtocolHeaders->xTCPHeader.ucTCPFlags |= tcpTCP_FLAG_FIN;
                             pxTCPWindow->tx.ulFINSequenceNumber = pxTCPWindow->ulOurSequenceNumber + ( uint32_t ) lDataLen;
-                            pxSocket->u.xTCP.bits.bFinSent = pdTRUE_UNSIGNED;
+                            pxSocket->u.xTCP.bits.bFinSent = ipTRUE_BOOL;
                         }
                     }
                 }
@@ -935,13 +935,13 @@
         if( ( lDataLen >= 0 ) && ( pxSocket->u.xTCP.eTCPState == eESTABLISHED ) )
         {
             /* See if the socket owner wants to shutdown this connection. */
-            if( ( pxSocket->u.xTCP.bits.bUserShutdown != pdFALSE_UNSIGNED ) &&
+            if( ( pxSocket->u.xTCP.bits.bUserShutdown != ipFALSE_BOOL ) &&
                 ( xTCPWindowTxDone( pxTCPWindow ) != pdFALSE ) )
             {
-                pxSocket->u.xTCP.bits.bUserShutdown = pdFALSE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bUserShutdown = ipFALSE_BOOL;
                 pxProtocolHeaders->xTCPHeader.ucTCPFlags |= tcpTCP_FLAG_FIN;
-                pxSocket->u.xTCP.bits.bFinSent = pdTRUE_UNSIGNED;
-                pxSocket->u.xTCP.bits.bWinChange = pdTRUE_UNSIGNED;
+                pxSocket->u.xTCP.bits.bFinSent = ipTRUE_BOOL;
+                pxSocket->u.xTCP.bits.bWinChange = ipTRUE_BOOL;
                 pxTCPWindow->tx.ulFINSequenceNumber = pxTCPWindow->tx.ulCurrentSequenceNumber;
                 vTCPStateChange( pxSocket, eFIN_WAIT_1 );
             }
@@ -957,7 +957,7 @@
                     lDataLen = -1;
                 }
 
-                if( ( lDataLen == 0 ) && ( pxSocket->u.xTCP.bits.bWinChange == pdFALSE_UNSIGNED ) )
+                if( ( lDataLen == 0 ) && ( pxSocket->u.xTCP.bits.bWinChange == ipFALSE_BOOL ) )
                 {
                     /* If there is no data to be sent, and no window-update message,
                      * we might want to send a keep-alive message. */
@@ -982,7 +982,7 @@
                                                      pxSocket->u.xTCP.ucKeepRepCount ) );
                         }
 
-                        pxSocket->u.xTCP.bits.bSendKeepAlive = pdTRUE_UNSIGNED;
+                        pxSocket->u.xTCP.bits.bSendKeepAlive = ipTRUE_BOOL;
                         pxSocket->u.xTCP.usTimeout = ( ( uint16_t ) pdMS_TO_TICKS( 2500U ) );
                         pxSocket->u.xTCP.ucKeepRepCount++;
                     }
@@ -996,8 +996,8 @@
             /* Anything to send, a change of the advertised window size, or maybe send a
              * keep-alive message? */
             if( ( lDataLen > 0 ) ||
-                ( pxSocket->u.xTCP.bits.bWinChange != pdFALSE_UNSIGNED ) ||
-                ( pxSocket->u.xTCP.bits.bSendKeepAlive != pdFALSE_UNSIGNED ) )
+                ( pxSocket->u.xTCP.bits.bWinChange != ipFALSE_BOOL ) ||
+                ( pxSocket->u.xTCP.bits.bSendKeepAlive != ipFALSE_BOOL ) )
             {
                 pxProtocolHeaders->xTCPHeader.ucTCPFlags &= ( ( uint8_t ) ~tcpTCP_FLAG_PSH );
                 pxProtocolHeaders->xTCPHeader.ucTCPOffset = ( uint8_t ) ( ( ipSIZE_OF_TCP_HEADER + uxOptionsLength ) << 2 ); /*_RB_ "2" needs comment. */
@@ -1117,10 +1117,10 @@
             else
         #endif /* ipconfigUSE_TCP_WIN */
 
-        if( ( pxSocket->u.xTCP.eTCPState >= eESTABLISHED ) && ( pxSocket->u.xTCP.bits.bMssChange != pdFALSE_UNSIGNED ) )
+        if( ( pxSocket->u.xTCP.eTCPState >= eESTABLISHED ) && ( pxSocket->u.xTCP.bits.bMssChange != ipFALSE_BOOL ) )
         {
             /* TCP options must be sent because the MSS has changed. */
-            pxSocket->u.xTCP.bits.bMssChange = pdFALSE_UNSIGNED;
+            pxSocket->u.xTCP.bits.bMssChange = ipFALSE_BOOL;
 
             if( xTCPWindowLoggingLevel >= 0 )
             {
@@ -1196,12 +1196,12 @@
             /* In case we're receiving data continuously, we might postpone sending
              * an ACK to gain performance. */
             /* lint e9007 is OK because 'uxIPHeaderSizeSocket()' has no side-effects. */
-            if( ( ulReceiveLength > 0U ) &&                               /* Data was sent to this socket. */
-                ( lRxSpace >= lMinLength ) &&                             /* There is Rx space for more data. */
-                ( pxSocket->u.xTCP.bits.bFinSent == pdFALSE_UNSIGNED ) && /* Not in a closure phase. */
-                ( xSendLength == xSizeWithoutData ) &&                    /* No Tx data or options to be sent. */
-                ( pxSocket->u.xTCP.eTCPState == eESTABLISHED ) &&         /* Connection established. */
-                ( pxTCPHeader->ucTCPFlags == tcpTCP_FLAG_ACK ) )          /* There are no other flags than an ACK. */
+            if( ( ulReceiveLength > 0U ) &&                           /* Data was sent to this socket. */
+                ( lRxSpace >= lMinLength ) &&                         /* There is Rx space for more data. */
+                ( pxSocket->u.xTCP.bits.bFinSent == ipFALSE_BOOL ) && /* Not in a closure phase. */
+                ( xSendLength == xSizeWithoutData ) &&                /* No Tx data or options to be sent. */
+                ( pxSocket->u.xTCP.eTCPState == eESTABLISHED ) &&     /* Connection established. */
+                ( pxTCPHeader->ucTCPFlags == tcpTCP_FLAG_ACK ) )      /* There are no other flags than an ACK. */
             {
                 uint32_t ulCurMSS = ( uint32_t ) pxSocket->u.xTCP.usMSS;
 
diff --git a/source/FreeRTOS_TCP_Transmission_IPv4.c b/source/FreeRTOS_TCP_Transmission_IPv4.c
index f341b09ac1..cca11d57a9 100644
--- a/source/FreeRTOS_TCP_Transmission_IPv4.c
+++ b/source/FreeRTOS_TCP_Transmission_IPv4.c
@@ -401,7 +401,7 @@ BaseType_t prvTCPPrepareConnect_IPV4( FreeRTOS_Socket_t * pxSocket )
          * the buffer onto the TCPPacket_t struct to easily access it's field. */
 
         /* 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] */
         pxTCPPacket = ( ( TCPPacket_t * ) pxSocket->u.xTCP.xPacket.u.ucLastPacket );
         pxIPHeader = &pxTCPPacket->xIPHeader;
@@ -410,7 +410,7 @@ BaseType_t prvTCPPrepareConnect_IPV4( FreeRTOS_Socket_t * pxSocket )
         pxSocket->u.xTCP.ucRepCount = 0U;
 
         /* And remember that the connect/SYN data are prepared. */
-        pxSocket->u.xTCP.bits.bConnPrepared = pdTRUE_UNSIGNED;
+        pxSocket->u.xTCP.bits.bConnPrepared = ipTRUE_BOOL;
 
         /* Now that the Ethernet address is known, the initial packet can be
          * prepared. */
diff --git a/source/FreeRTOS_TCP_Transmission_IPv6.c b/source/FreeRTOS_TCP_Transmission_IPv6.c
index 1a3cc36209..6668338e4d 100644
--- a/source/FreeRTOS_TCP_Transmission_IPv6.c
+++ b/source/FreeRTOS_TCP_Transmission_IPv6.c
@@ -412,7 +412,7 @@ BaseType_t prvTCPPrepareConnect_IPV6( FreeRTOS_Socket_t * pxSocket )
         pxSocket->u.xTCP.ucRepCount = 0U;
 
         /* And remember that the connect/SYN data are prepared. */
-        pxSocket->u.xTCP.bits.bConnPrepared = pdTRUE_UNSIGNED;
+        pxSocket->u.xTCP.bits.bConnPrepared = ipTRUE_BOOL;
 
         /* Now that the Ethernet address is known, the initial packet can be
          * prepared. */
diff --git a/source/FreeRTOS_TCP_Utils.c b/source/FreeRTOS_TCP_Utils.c
index 425906e219..bc24856034 100644
--- a/source/FreeRTOS_TCP_Utils.c
+++ b/source/FreeRTOS_TCP_Utils.c
@@ -94,13 +94,13 @@
         switch( pxSocket->bits.bIsIPv6 ) /* LCOV_EXCL_BR_LINE */
         {
             #if ( ipconfigUSE_IPv4 != 0 )
-                case pdFALSE_UNSIGNED:
+                case ipFALSE_BOOL:
                     prvSocketSetMSS_IPV4( pxSocket );
                     break;
             #endif /* ( ipconfigUSE_IPv4 != 0 ) */
 
             #if ( ipconfigUSE_IPv6 != 0 )
-                case pdTRUE_UNSIGNED:
+                case ipTRUE_BOOL:
                     prvSocketSetMSS_IPV6( pxSocket );
                     break;
             #endif /* ( ipconfigUSE_IPv6 != 0 ) */
diff --git a/source/FreeRTOS_TCP_WIN.c b/source/FreeRTOS_TCP_WIN.c
index 23182baf00..69e9718241 100644
--- a/source/FreeRTOS_TCP_WIN.c
+++ b/source/FreeRTOS_TCP_WIN.c
@@ -835,7 +835,7 @@
         const int32_t l500ms = 500;
 
         pxWindow->u.ulFlags = 0U;
-        pxWindow->u.bits.bHasInit = pdTRUE_UNSIGNED;
+        pxWindow->u.bits.bHasInit = ipTRUE_BOOL;
 
         if( ulMSS != 0U )
         {
@@ -1429,7 +1429,7 @@
              * verified). */
             if( ( pxSegment != NULL ) &&
                 ( pxSegment->lDataLength < pxSegment->lMaxLength ) &&
-                ( pxSegment->u.bits.bOutstanding == pdFALSE_UNSIGNED ) &&
+                ( pxSegment->u.bits.bOutstanding == ipFALSE_BOOL ) &&
                 ( pxSegment->lDataLength != 0 ) )
             {
                 lToWrite = prvTCPWindowTxAdd_FrontSegment( pxWindow, pxSegment, lBytesLeft );
@@ -1649,7 +1649,7 @@
                         /* Too many outstanding messages. */
                         xReturn = pdFALSE;
                     }
-                    else if( ( pxWindow->u.bits.bSendFullSize != pdFALSE_UNSIGNED ) &&
+                    else if( ( pxWindow->u.bits.bSendFullSize != ipFALSE_BOOL ) &&
                              ( pxSegment->lDataLength < pxSegment->lMaxLength ) )
                     {
                         /* 'bSendFullSize' is a special optimisation.  If true, the
@@ -1694,7 +1694,7 @@
                     /* A normal (non-fast) retransmission.  Move it from the
                      * head of the waiting queue. */
                     pxSegment = xTCPWindowGetHead( &( pxWindow->xWaitQueue ) );
-                    pxSegment->u.bits.ucDupAckCount = ( uint8_t ) pdFALSE_UNSIGNED;
+                    pxSegment->u.bits.ucDupAckCount = ( uint8_t ) 0U;
 
                     /* Some detailed logging. */
                     if( ( xTCPWindowLoggingLevel != 0 ) && ( ipconfigTCP_MAY_LOG_PORT( pxWindow->usOurPortNumber ) ) )
@@ -1739,7 +1739,7 @@
             {
                 /* No segments queued. */
             }
-            else if( ( pxWindow->u.bits.bSendFullSize != pdFALSE_UNSIGNED ) &&
+            else if( ( pxWindow->u.bits.bSendFullSize != ipFALSE_BOOL ) &&
                      ( pxSegment->lDataLength < pxSegment->lMaxLength ) )
             {
                 /* A segment has been queued but the driver waits until it
@@ -1850,7 +1850,7 @@
                 vListInsertFifo( &pxWindow->xWaitQueue, &pxSegment->xQueueItem );
 
                 /* And mark it as outstanding. */
-                pxSegment->u.bits.bOutstanding = pdTRUE_UNSIGNED;
+                pxSegment->u.bits.bOutstanding = ipTRUE_BOOL;
 
                 /* Administer the transmit count, needed for fast
                  * retransmissions. */
@@ -2014,7 +2014,7 @@
 
                 ulDataLength = ( uint32_t ) pxSegment->lDataLength;
 
-                if( pxSegment->u.bits.bAcked == pdFALSE_UNSIGNED )
+                if( pxSegment->u.bits.bAcked == ipFALSE_BOOL )
                 {
                     if( xSequenceGreaterThan( pxSegment->ulSequenceNumber + ( uint32_t ) ulDataLength, ulLast ) != pdFALSE )
                     {
@@ -2040,7 +2040,7 @@
                     }
 
                     /* This segment is fully ACK'd, set the flag. */
-                    pxSegment->u.bits.bAcked = pdTRUE;
+                    pxSegment->u.bits.bAcked = ipTRUE_BOOL;
 
                     /* Calculate the RTT only if the segment was sent-out for the
                      * first time and if this is the last ACK'd segment in a range. */
@@ -2134,7 +2134,7 @@
                  * When 3 packets with a higher sequence number have been acknowledged
                  * by the peer, it is very unlikely a current packet will ever arrive.
                  * It will be retransmitted far before the RTO. */
-                if( pxSegment->u.bits.bAcked == pdFALSE_UNSIGNED )
+                if( pxSegment->u.bits.bAcked == ipFALSE_BOOL )
                 {
                     if( xSequenceLessThan( pxSegment->ulSequenceNumber, ulFirst ) != pdFALSE )
                     {
diff --git a/source/FreeRTOS_UDP_IPv4.c b/source/FreeRTOS_UDP_IPv4.c
index d5fde02476..8d20f4f32e 100644
--- a/source/FreeRTOS_UDP_IPv4.c
+++ b/source/FreeRTOS_UDP_IPv4.c
@@ -80,9 +80,6 @@ void vProcessGeneratedUDPPacket_IPv4( NetworkBufferDescriptor_t * const pxNetwor
     uint32_t ulIPAddress = pxNetworkBuffer->xIPAddress.ulIP_IPv4;
     NetworkEndPoint_t * pxEndPoint = pxNetworkBuffer->pxEndPoint;
     size_t uxPayloadSize;
-    /* memcpy() helper variables for MISRA Rule 21.15 compliance*/
-    const void * pvCopySource;
-    void * pvCopyDest;
 
     /* Map the UDP packet onto the start of the frame. */
 
@@ -131,6 +128,9 @@ void vProcessGeneratedUDPPacket_IPv4( NetworkBufferDescriptor_t * const pxNetwor
                 0x00, 0x00,                         /* usHeaderChecksum. */
                 0x00, 0x00, 0x00, 0x00              /* Source IP address. */
             };
+            /* memcpy() helper variables for MISRA Rule 21.15 compliance*/
+            const void * pvCopySource;
+            void * pvCopyDest;
 
             #if ( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )
                 uint8_t ucSocketOptions;
@@ -515,7 +515,7 @@ BaseType_t xProcessReceivedUDPPacket_IPv4( NetworkBufferDescriptor_t * pxNetwork
                 {
                     vARPRefreshCacheEntry( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress,
                                            pxNetworkBuffer->pxEndPoint );
-                    xReturn = ( BaseType_t ) ulDNSHandlePacket( pxNetworkBuffer );
+                    xReturn = xDNSHandlePacket( pxNetworkBuffer );
                 }
                 else
             #endif
@@ -527,7 +527,7 @@ BaseType_t xProcessReceivedUDPPacket_IPv4( NetworkBufferDescriptor_t * pxNetwork
                 {
                     vARPRefreshCacheEntry( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress,
                                            pxNetworkBuffer->pxEndPoint );
-                    xReturn = ( BaseType_t ) ulDNSHandlePacket( pxNetworkBuffer );
+                    xReturn = xDNSHandlePacket( pxNetworkBuffer );
                 }
                 else
             #endif /* ipconfigUSE_LLMNR */
@@ -548,7 +548,7 @@ BaseType_t xProcessReceivedUDPPacket_IPv4( NetworkBufferDescriptor_t * pxNetwork
                                                pxNetworkBuffer->pxEndPoint );
                     }
 
-                    xReturn = ( BaseType_t ) ulDNSHandlePacket( pxNetworkBuffer );
+                    xReturn = xDNSHandlePacket( pxNetworkBuffer );
                 }
                 else
             #endif /* ipconfigUSE_MDNS */
diff --git a/source/FreeRTOS_UDP_IPv6.c b/source/FreeRTOS_UDP_IPv6.c
index 1efd1927a1..3db8b97c96 100644
--- a/source/FreeRTOS_UDP_IPv6.c
+++ b/source/FreeRTOS_UDP_IPv6.c
@@ -544,7 +544,7 @@ BaseType_t xProcessReceivedUDPPacket_IPv6( NetworkBufferDescriptor_t * pxNetwork
                  * socket is closed) will be treated here. */
                 if( FreeRTOS_ntohs( pxUDPPacket_IPv6->xUDPHeader.usSourcePort ) == ( uint16_t ) ipDNS_PORT )
                 {
-                    xReturn = ( BaseType_t ) ulDNSHandlePacket( pxNetworkBuffer );
+                    xReturn = xDNSHandlePacket( pxNetworkBuffer );
                 }
                 else
             #endif
@@ -554,7 +554,7 @@ BaseType_t xProcessReceivedUDPPacket_IPv6( NetworkBufferDescriptor_t * pxNetwork
                 if( ( usPort == FreeRTOS_htons( ipLLMNR_PORT ) ) ||
                     ( pxUDPPacket_IPv6->xUDPHeader.usSourcePort == FreeRTOS_htons( ipLLMNR_PORT ) ) )
                 {
-                    xReturn = ( BaseType_t ) ulDNSHandlePacket( pxNetworkBuffer );
+                    xReturn = xDNSHandlePacket( pxNetworkBuffer );
                 }
                 else
             #endif /* ipconfigUSE_LLMNR */
@@ -564,7 +564,7 @@ BaseType_t xProcessReceivedUDPPacket_IPv6( NetworkBufferDescriptor_t * pxNetwork
                 if( ( usPort == FreeRTOS_ntohs( ipMDNS_PORT ) ) ||
                     ( pxUDPPacket_IPv6->xUDPHeader.usSourcePort == FreeRTOS_ntohs( ipMDNS_PORT ) ) )
                 {
-                    xReturn = ( BaseType_t ) ulDNSHandlePacket( pxNetworkBuffer );
+                    xReturn = xDNSHandlePacket( pxNetworkBuffer );
                 }
                 else
             #endif /* ipconfigUSE_MDNS */
diff --git a/source/include/FreeRTOSIPConfigDefaults.h b/source/include/FreeRTOSIPConfigDefaults.h
index 59af724eb7..65682d0864 100644
--- a/source/include/FreeRTOSIPConfigDefaults.h
+++ b/source/include/FreeRTOSIPConfigDefaults.h
@@ -1173,7 +1173,7 @@ STATIC_ASSERT( pdMS_TO_TICKS( ipconfigPHY_LS_LOW_CHECK_TIME_MS ) <= portMAX_DELA
     #error ipconfigIP_TASK_AFFINITY must be at least 0
 #endif
 
-#if ( ipconfigIP_TASK_AFFINITY > 0 && configUSE_CORE_AFFINITY == 0 )
+#if ( ( ipconfigIP_TASK_AFFINITY > 0 ) && ( configUSE_CORE_AFFINITY == 0 ) )
     #error configUSE_CORE_AFFINITY must be 1 in order to use ipconfigIP_TASK_AFFINITY
 #endif
 
diff --git a/source/include/FreeRTOS_DNS.h b/source/include/FreeRTOS_DNS.h
index b9ab2e6954..147de4f097 100644
--- a/source/include/FreeRTOS_DNS.h
+++ b/source/include/FreeRTOS_DNS.h
@@ -87,7 +87,7 @@ extern IPPreference_t xDNS_IP_Preference;
 /*
  * LLMNR is very similar to DNS, so is handled by the DNS routines.
  */
-uint32_t ulDNSHandlePacket( const NetworkBufferDescriptor_t * pxNetworkBuffer );
+BaseType_t xDNSHandlePacket( const NetworkBufferDescriptor_t * pxNetworkBuffer );
 
 #if ( ipconfigUSE_NBNS != 0 )
 
diff --git a/source/portable/NetworkInterface/DriverSAM/NetworkInterface.c b/source/portable/NetworkInterface/DriverSAM/NetworkInterface.c
index 0e37bdd6f3..60a6c8d3a4 100644
--- a/source/portable/NetworkInterface/DriverSAM/NetworkInterface.c
+++ b/source/portable/NetworkInterface/DriverSAM/NetworkInterface.c
@@ -875,14 +875,14 @@ static void prvAddAllowedMACAddress( struct xNetworkInterface * pxInterface,
      * unicast frames that are destined to MAC addresses that we send from. Because of this,
      * the EMAC doesn't need to do heavy filtering for unicasts.
      * On the other hand, most networking hardware ( both wired and wireless ) will happily
-     * send us all traffic that has a multicast destination MAC. It is therefor much more
+     * send us all traffic that has a multicast destination MAC. It is therefore much more
      * important to filter out unnecessary multicast traffic. Ideally, we could explicitly
      * allow all multicast MAC addresses that the TCP stack requests, however, this EMAC controller
      * only has 4 specific MAC match registers. Beyond that, we can use the hash match register to
      * match unicast and/or multicast addresses. Every bit in the hash match register corresponds
      * to millions of MAC addresses, so the usage of the hash register should be kept to a minimum.
      * As a side note, setting all bits in the hash register is somewhat equivalent to
-     * promiscuous mode and is therefor not very useful.
+     * promiscuous mode and is therefore not very useful.
      * Due to the filtering nature of network infrastructure, It would make sense to use the
      * specific match registers for matching multicasts and use the hash match register for unicasts
      * because they are already well filtered. Due to the EMAC hardware limitations, such approach
diff --git a/test/cbmc/proofs/DNS/DNSHandlePacket/DNShandlePacket_harness.c b/test/cbmc/proofs/DNS/DNSHandlePacket/DNShandlePacket_harness.c
index 85bb0b8fac..c7f14bb997 100644
--- a/test/cbmc/proofs/DNS/DNSHandlePacket/DNShandlePacket_harness.c
+++ b/test/cbmc/proofs/DNS/DNSHandlePacket/DNShandlePacket_harness.c
@@ -28,5 +28,5 @@ void harness()
     xNetworkBuffer.pucEthernetBuffer = malloc( sizeof( UDPPacket_t ) + sizeof( DNSMessage_t ) );
     __CPROVER_assume( xNetworkBuffer.pucEthernetBuffer != NULL );
 
-    ulDNSHandlePacket( &xNetworkBuffer );
+    xDNSHandlePacket( &xNetworkBuffer );
 }
diff --git a/test/cbmc/proofs/parsing/ProcessIPPacket_IPv6/prvAllowIPPacketIPv6/Configurations.json b/test/cbmc/proofs/parsing/ProcessIPPacket_IPv6/prvAllowIPPacketIPv6/Configurations.json
index 150e6879aa..1a1a1c4a8a 100644
--- a/test/cbmc/proofs/parsing/ProcessIPPacket_IPv6/prvAllowIPPacketIPv6/Configurations.json
+++ b/test/cbmc/proofs/parsing/ProcessIPPacket_IPv6/prvAllowIPPacketIPv6/Configurations.json
@@ -27,7 +27,7 @@
       [
         "ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM=1",
         "ipconfigETHERNET_DRIVER_FILTERS_PACKE,TS=1",
-        "FREERTOS_TCP_ENABLE_VERIFICATION",
+        "FREERTOS_TCP_ENABLE_VERIFICATION=1",
         "ipconfigNETWORK_MTU=200",
         "ipconfigTCP_MSS=586",
         "ipconfigUSE_DHCP=0"
@@ -38,7 +38,7 @@
       [
         "ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM=0",
         "ipconfigETHERNET_DRIVER_FILTERS_PACKETS=0",
-        "FREERTOS_TCP_ENABLE_VERIFICATION",
+        "FREERTOS_TCP_ENABLE_VERIFICATION=1",
         "ipconfigNETWORK_MTU=200",
         "ipconfigTCP_MSS=586",
         "ipconfigUSE_DHCP=0"
diff --git a/test/cbmc/proofs/parsing/ProcessReceivedUDPPacket/ProcessReceivedUDPPacket_harness.c b/test/cbmc/proofs/parsing/ProcessReceivedUDPPacket/ProcessReceivedUDPPacket_harness.c
index 0b2b8c14c5..14e95f5b46 100644
--- a/test/cbmc/proofs/parsing/ProcessReceivedUDPPacket/ProcessReceivedUDPPacket_harness.c
+++ b/test/cbmc/proofs/parsing/ProcessReceivedUDPPacket/ProcessReceivedUDPPacket_harness.c
@@ -32,9 +32,9 @@ BaseType_t xIsDHCPSocket( Socket_t xSocket )
 }
 
 /* This proof was done before. Hence we assume it to be correct here. */
-uint32_t ulDNSHandlePacket( NetworkBufferDescriptor_t * pxNetworkBuffer )
+BaseType_t xDNSHandlePacket( NetworkBufferDescriptor_t * pxNetworkBuffer )
 {
-    /* ulDNSHandlePacket always returns pdFAIL. */
+    /* xDNSHandlePacket always returns pdFAIL. */
     return pdFAIL;
 }
 
diff --git a/test/cbmc/proofs/parsing/ProcessReceivedUDPPacket_IPv6/ProcessReceivedUDPPacket_IPv6_harness.c b/test/cbmc/proofs/parsing/ProcessReceivedUDPPacket_IPv6/ProcessReceivedUDPPacket_IPv6_harness.c
index aef236b617..c10a90d30c 100644
--- a/test/cbmc/proofs/parsing/ProcessReceivedUDPPacket_IPv6/ProcessReceivedUDPPacket_IPv6_harness.c
+++ b/test/cbmc/proofs/parsing/ProcessReceivedUDPPacket_IPv6/ProcessReceivedUDPPacket_IPv6_harness.c
@@ -23,9 +23,9 @@ BaseType_t xIsDHCPSocket( Socket_t xSocket )
 }
 
 /* This proof was done before. Hence we assume it to be correct here. */
-uint32_t ulDNSHandlePacket( NetworkBufferDescriptor_t * pxNetworkBuffer )
+BaseType_t xDNSHandlePacket( NetworkBufferDescriptor_t * pxNetworkBuffer )
 {
-    /* ulDNSHandlePacket always returns pdFAIL. */
+    /* xDNSHandlePacket always returns pdFAIL. */
     return pdFAIL;
 }
 
diff --git a/test/unit-test/FreeRTOS_DNS/FreeRTOS_DNS_utest.c b/test/unit-test/FreeRTOS_DNS/FreeRTOS_DNS_utest.c
index c8a32c868a..54c88107b1 100644
--- a/test/unit-test/FreeRTOS_DNS/FreeRTOS_DNS_utest.c
+++ b/test/unit-test/FreeRTOS_DNS/FreeRTOS_DNS_utest.c
@@ -455,7 +455,7 @@ void test_FreeRTOS_gethostbyname_Success( void )
  *        pdFAIL
  * @warning Function not really tested besides code coverage
  */
-void test_ulDNSHandlePacket_Success( void )
+void test_xDNSHandlePacket_Success( void )
 {
     uint32_t ret;
     NetworkBufferDescriptor_t xNetworkBuffer;
@@ -467,7 +467,7 @@ void test_ulDNSHandlePacket_Success( void )
     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
     DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 0 );
 
-    ret = ulDNSHandlePacket( &xNetworkBuffer );
+    ret = xDNSHandlePacket( &xNetworkBuffer );
     TEST_ASSERT_EQUAL( pdFAIL, ret );
     free( xNetworkBuffer.pucEthernetBuffer );
 }
@@ -476,7 +476,7 @@ void test_ulDNSHandlePacket_Success( void )
  * @brief This function always returns pdFAIL
  * @warning Function not really tested besides code coverage
  */
-void test_ulDNSHandlePacket_FailSmallBuffer( void )
+void test_xDNSHandlePacket_FailSmallBuffer( void )
 {
     uint32_t ret;
     NetworkBufferDescriptor_t xNetworkBuffer;
@@ -486,7 +486,7 @@ void test_ulDNSHandlePacket_FailSmallBuffer( void )
 
     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
 
-    ret = ulDNSHandlePacket( &xNetworkBuffer );
+    ret = xDNSHandlePacket( &xNetworkBuffer );
     TEST_ASSERT_EQUAL( pdFAIL, ret );
     free( xNetworkBuffer.pucEthernetBuffer );
 }
@@ -496,7 +496,7 @@ void test_ulDNSHandlePacket_FailSmallBuffer( void )
  *        coverage
  * @warning Function not really tested besides code coverage
  */
-void test_ulDNSHandlePacket_FailSmallBuffer2( void )
+void test_xDNSHandlePacket_FailSmallBuffer2( void )
 {
     uint32_t ret;
     NetworkBufferDescriptor_t xNetworkBuffer;
@@ -506,7 +506,7 @@ void test_ulDNSHandlePacket_FailSmallBuffer2( void )
 
     uxIPHeaderSizePacket_IgnoreAndReturn( ipSIZE_OF_IPv4_HEADER );
 
-    ret = ulDNSHandlePacket( &xNetworkBuffer );
+    ret = xDNSHandlePacket( &xNetworkBuffer );
     TEST_ASSERT_EQUAL( pdFAIL, ret );
     free( xNetworkBuffer.pucEthernetBuffer );
 }
@@ -514,7 +514,7 @@ void test_ulDNSHandlePacket_FailSmallBuffer2( void )
 /**
  * @brief Make sure function release the allocated buffer from DNS_ParseDNSReply
  */
-void test_ulDNSHandlePacket_FreeBuffer( void )
+void test_xDNSHandlePacket_FreeBuffer( void )
 {
     uint32_t ret;
     NetworkBufferDescriptor_t xNetworkBuffer;
@@ -536,7 +536,7 @@ void test_ulDNSHandlePacket_FreeBuffer( void )
     DNS_ParseDNSReply_ExpectAnyArgsAndReturn( 0 );
     DNS_ParseDNSReply_ReturnThruPtr_ppxAddressInfo( &pxAddress );
 
-    ret = ulDNSHandlePacket( &xNetworkBuffer );
+    ret = xDNSHandlePacket( &xNetworkBuffer );
     TEST_ASSERT_EQUAL( pdFAIL, ret );
 }
 
diff --git a/test/unit-test/FreeRTOS_UDP_IPv4/FreeRTOS_UDP_IPv4_utest.c b/test/unit-test/FreeRTOS_UDP_IPv4/FreeRTOS_UDP_IPv4_utest.c
index 69639f27f1..9541e95694 100644
--- a/test/unit-test/FreeRTOS_UDP_IPv4/FreeRTOS_UDP_IPv4_utest.c
+++ b/test/unit-test/FreeRTOS_UDP_IPv4/FreeRTOS_UDP_IPv4_utest.c
@@ -119,7 +119,7 @@ void test_xProcessReceivedUDPPacket_IPv4_DNSReplyPass()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -152,7 +152,7 @@ void test_xProcessReceivedUDPPacket_IPv4_DNSReplyFail()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -185,7 +185,7 @@ void test_xProcessReceivedUDPPacket_IPv4_LLMNRRequestPass()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -218,7 +218,7 @@ void test_xProcessReceivedUDPPacket_IPv4_LLMNRRequestFail()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -251,7 +251,7 @@ void test_xProcessReceivedUDPPacket_IPv4_LLMNRReplyPass()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -284,7 +284,7 @@ void test_xProcessReceivedUDPPacket_IPv4_LLMNRReplyFail()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -319,7 +319,7 @@ void test_xProcessReceivedUDPPacket_IPv4_MDNSRequestPass()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -354,7 +354,7 @@ void test_xProcessReceivedUDPPacket_IPv4_MDNSRequestFail()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -389,7 +389,7 @@ void test_xProcessReceivedUDPPacket_IPv4_MDNSReplyPass()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -424,7 +424,7 @@ void test_xProcessReceivedUDPPacket_IPv4_MDNSReplyFail()
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
     vARPRefreshCacheEntry_Expect( &( pxUDPPacket->xEthernetHeader.xSourceAddress ), pxUDPPacket->xIPHeader.ulSourceIPAddress, xNetworkBuffer.pxEndPoint );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -459,7 +459,7 @@ void test_xProcessReceivedUDPPacket_IPv4_MDNSRequestPassWithIPv6FrameType()
     pxUDPPacket->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
 
     xReturn = xProcessReceivedUDPPacket_IPv4( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
diff --git a/test/unit-test/FreeRTOS_UDP_IPv6/FreeRTOS_UDP_IPv6_utest.c b/test/unit-test/FreeRTOS_UDP_IPv6/FreeRTOS_UDP_IPv6_utest.c
index dc7a26c6d3..f8fa34cacd 100644
--- a/test/unit-test/FreeRTOS_UDP_IPv6/FreeRTOS_UDP_IPv6_utest.c
+++ b/test/unit-test/FreeRTOS_UDP_IPv6/FreeRTOS_UDP_IPv6_utest.c
@@ -151,7 +151,7 @@ void test_xProcessReceivedUDPPacket_IPv6_DNSReplyPass()
     pxUDPv6Packet->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
 
     xReturn = xProcessReceivedUDPPacket_IPv6( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -183,7 +183,7 @@ void test_xProcessReceivedUDPPacket_IPv6_DNSReplyFail()
     pxUDPv6Packet->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
 
     xReturn = xProcessReceivedUDPPacket_IPv6( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -215,7 +215,7 @@ void test_xProcessReceivedUDPPacket_IPv6_LLMNRRequestPass()
     pxUDPv6Packet->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
 
     xReturn = xProcessReceivedUDPPacket_IPv6( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -247,7 +247,7 @@ void test_xProcessReceivedUDPPacket_IPv6_LLMNRRequestFail()
     pxUDPv6Packet->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
 
     xReturn = xProcessReceivedUDPPacket_IPv6( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -279,7 +279,7 @@ void test_xProcessReceivedUDPPacket_IPv6_LLMNRReplyPass()
     pxUDPv6Packet->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdTRUE );
 
     xReturn = xProcessReceivedUDPPacket_IPv6( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );
 
@@ -311,7 +311,7 @@ void test_xProcessReceivedUDPPacket_IPv6_LLMNRReplyFail()
     pxUDPv6Packet->xUDPHeader.usDestinationPort = usDestPortNetworkEndian;
 
     pxUDPSocketLookup_ExpectAndReturn( usDestPortNetworkEndian, NULL );
-    ulDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
+    xDNSHandlePacket_ExpectAndReturn( &xNetworkBuffer, pdFAIL );
 
     xReturn = xProcessReceivedUDPPacket_IPv6( &xNetworkBuffer, usDestPortNetworkEndian, &xIsWaitingForARPResolution );