Skip to content

Commit de7bdb6

Browse files
tony-josi-awstony-josi-aws
committed
Fix unit test coverage for DHCP v4 and v6
1 parent 396aa90 commit de7bdb6

File tree

5 files changed

+227
-9
lines changed

5 files changed

+227
-9
lines changed

‎source/FreeRTOS_DHCP.c‎

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -210,7 +210,8 @@
210210
const DHCPMessage_IPv4_t * pxDHCPMessage;
211211
int32_t lBytes;
212212
struct freertos_sockaddr xSourceAddress;
213-
213+
BaseType_t xFristIter = pdTRUE;
214+
214215
memset(&xSourceAddress, 0, sizeof(xSourceAddress));
215216

216217
while( EP_DHCPData.xDHCPSocket != NULL )
@@ -219,6 +220,7 @@
219220
NetworkEndPoint_t * pxIterator = NULL;
220221
struct freertos_sockaddr xSourceAddressCurrent;
221222
socklen_t xSourceAddressCurrentLength = 0;
223+
pucUDPPayload = NULL;
222224

223225
/* Peek the next UDP message. */
224226
lBytes = FreeRTOS_recvfrom( EP_DHCPData.xDHCPSocket, &( pucUDPPayload ), 0, xRecvFlags, &xSourceAddressCurrent, &xSourceAddressCurrentLength );
@@ -230,12 +232,18 @@
230232
FreeRTOS_printf( ( "vDHCPProcess: FreeRTOS_recvfrom returns %d\n", ( int ) lBytes ) );
231233
}
232234

235+
if( ( lBytes >= 0 ) && ( pucUDPPayload != NULL ) )
236+
{
237+
FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayload );
238+
}
239+
233240
break;
234241
}
235242

236-
if( xSourceAddress.sin_address.ulIP_IPv4 == 0U )
243+
if( xFristIter == pdTRUE )
237244
{
238245
memcpy(&xSourceAddress, &xSourceAddressCurrent, xSourceAddressCurrentLength);
246+
xFristIter = pdFALSE;
239247
}
240248

241249
/* Map a DHCP structure onto the received data. */

‎source/FreeRTOS_DHCPv6.c‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -422,7 +422,7 @@ void vDHCPv6Process( BaseType_t xReset,
422422
BaseType_t lBytes;
423423
size_t uxLength;
424424
struct freertos_sockaddr xSourceAddress;
425-
uint8_t ucFirstIter = 1U;
425+
BaseType_t xFristIter = pdTRUE;
426426

427427
memset(&xSourceAddress, 0, sizeof(xSourceAddress));
428428

@@ -444,18 +444,18 @@ void vDHCPv6Process( BaseType_t xReset,
444444
FreeRTOS_printf( ( "vDHCPProcess: FreeRTOS_recvfrom returns %d\n", ( int ) lBytes ) );
445445
}
446446

447-
if(pucUDPPayload != NULL)
447+
if((lBytes == 0) && (pucUDPPayload != NULL))
448448
{
449449
FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayload );
450450
}
451451

452452
break;
453453
}
454454

455-
if( ucFirstIter != 0U )
455+
if( xFristIter == pdTRUE )
456456
{
457-
memcpy(&xSourceAddress, &xSourceAddressCurrent, xSourceAddressCurrentLength);
458-
ucFirstIter = 0U;
457+
memcpy(&xSourceAddress, &xSourceAddressCurrent, sizeof(xSourceAddress));
458+
xFristIter = pdFALSE;
459459
}
460460

461461
/* Verify DHCPv6 server address. */

‎test/unit-test/FreeRTOS_DHCP/FreeRTOS_DHCP_utest.c‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -921,6 +921,38 @@ void test_vDHCPProcess_eSendDHCPRequestCorrectStateGNWFails( void )
921921
TEST_ASSERT_EQUAL( eSendDHCPRequest, pxEndPoint->xDHCPData.eDHCPState );
922922
}
923923

924+
void test_vDHCPProcess_RecvFromReturnsTimeout( void )
925+
{
926+
struct xSOCKET xTestSocket;
927+
NetworkEndPoint_t xEndPoint = { 0 }, * pxEndPoint = &xEndPoint;
928+
929+
/* This should remain unchanged. */
930+
xDHCPv4Socket = &xTestSocket;
931+
xDHCPSocketUserCount = 1;
932+
pxEndPoint->xDHCPData.xDHCPSocket = &xTestSocket;
933+
/* Put the required state. */
934+
pxEndPoint->xDHCPData.eDHCPState = eSendDHCPRequest;
935+
pxEndPoint->xDHCPData.eExpectedState = eSendDHCPRequest;
936+
937+
/* Expect these arguments. */
938+
FreeRTOS_recvfrom_ExpectAndReturn( xDHCPv4Socket, NULL, 0UL, FREERTOS_ZERO_COPY + FREERTOS_MSG_PEEK, NULL, NULL, -pdFREERTOS_ERRNO_EAGAIN );
939+
/* Ignore the buffer, source address and source address
940+
length argument though. */
941+
FreeRTOS_recvfrom_IgnoreArg_pvBuffer();
942+
FreeRTOS_recvfrom_IgnoreArg_pxSourceAddress();
943+
FreeRTOS_recvfrom_IgnoreArg_pxSourceAddressLength();
944+
945+
/* Get the hostname. */
946+
pcApplicationHostnameHook_ExpectAndReturn( pcHostName );
947+
/* Return NULL network buffer. */
948+
pxGetNetworkBufferWithDescriptor_ExpectAnyArgsAndReturn( NULL );
949+
xSocketValid_ExpectAnyArgsAndReturn( pdFALSE );
950+
951+
vDHCPProcess( pdFALSE, pxEndPoint );
952+
953+
}
954+
955+
924956
void test_vDHCPProcess_eSendDHCPRequestCorrectStateGNWSucceedsSendFails( void )
925957
{
926958
struct xSOCKET xTestSocket;

‎test/unit-test/FreeRTOS_DHCPv6/FreeRTOS_DHCPv6_stubs.c‎

Lines changed: 95 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -506,7 +506,7 @@ void vPortExitCritical( void )
506506
{
507507
}
508508

509-
int32_t FreeRTOS_recvfrom__DHCPv6_LoopedCall( const ConstSocket_t xSocket,
509+
int32_t FreeRTOS_recvfrom_DHCPv6_LoopedCall( const ConstSocket_t xSocket,
510510
void * pvBuffer,
511511
size_t uxBufferLength,
512512
BaseType_t xFlags,
@@ -533,6 +533,11 @@ int32_t FreeRTOS_recvfrom__DHCPv6_LoopedCall( const ConstSocket_t xSocket,
533533

534534
if(pxSourceAddress != NULL)
535535
{
536+
if(callbacks == 0)
537+
{
538+
memset(&xSourceAddress.sin_address.xIP_IPv6.ucBytes, 0xAB, sizeof(xSourceAddress.sin_address.xIP_IPv6.ucBytes));
539+
xSourceAddress.sin_port = 6060;
540+
}
536541
if(callbacks == 1)
537542
{
538543
memset(&xSourceAddress.sin_address.xIP_IPv6.ucBytes, 0xAD, sizeof(xSourceAddress.sin_address.xIP_IPv6.ucBytes));
@@ -554,3 +559,92 @@ int32_t FreeRTOS_recvfrom__DHCPv6_LoopedCall( const ConstSocket_t xSocket,
554559

555560
return xSizeRetBufferSize;
556561
}
562+
563+
int32_t FreeRTOS_recvfrom_DHCPv6_LoopedCall_DifferentPort( const ConstSocket_t xSocket,
564+
void * pvBuffer,
565+
size_t uxBufferLength,
566+
BaseType_t xFlags,
567+
struct freertos_sockaddr * pxSourceAddress,
568+
socklen_t * pxSourceAddressLength,
569+
int callbacks )
570+
{
571+
NetworkEndPoint_t * pxIterator = pxNetworkEndPoints;
572+
size_t xSizeRetBufferSize = xSizeofUDPBuffer;
573+
574+
if(callbacks == 1)
575+
{
576+
pxNetworkEndPoints->xDHCPData.eDHCPState = eInitialWait;
577+
}
578+
else if(callbacks == 2)
579+
{
580+
xSizeRetBufferSize = -pdFREERTOS_ERRNO_EAGAIN;
581+
}
582+
583+
if( ( xFlags & FREERTOS_ZERO_COPY ) != 0 )
584+
{
585+
*( ( uint8_t ** ) pvBuffer ) = pucUDPBuffer;
586+
}
587+
588+
if(pxSourceAddress != NULL)
589+
{
590+
if(callbacks == 0)
591+
{
592+
memset(&xSourceAddress.sin_address.xIP_IPv6.ucBytes, 0xAD, sizeof(xSourceAddress.sin_address.xIP_IPv6.ucBytes));
593+
xSourceAddress.sin_port = 6060;
594+
}
595+
else if(callbacks == 1)
596+
{
597+
memset(&xSourceAddress.sin_address.xIP_IPv6.ucBytes, 0xAD, sizeof(xSourceAddress.sin_address.xIP_IPv6.ucBytes));
598+
xSourceAddress.sin_port = 5050;
599+
}
600+
memcpy(pxSourceAddress, &xSourceAddress, sizeof(xSourceAddress));
601+
}
602+
603+
if(pxSourceAddressLength != NULL)
604+
{
605+
*pxSourceAddressLength = sizeof(xSourceAddress);
606+
}
607+
608+
memset( pucUDPBuffer, 0, xSizeofUDPBuffer );
609+
/* Put in correct DHCP cookie. */
610+
( ( struct xDHCPMessage_IPv4 * ) pucUDPBuffer )->ulDHCPCookie = dhcpCOOKIE;
611+
( ( struct xDHCPMessage_IPv4 * ) pucUDPBuffer )->ucOpcode = dhcpREPLY_OPCODE;
612+
( ( struct xDHCPMessage_IPv4 * ) pucUDPBuffer )->ulTransactionID = FreeRTOS_htonl( 0x01ABCDEF );
613+
614+
return xSizeRetBufferSize;
615+
}
616+
617+
618+
int32_t FreeRTOS_recvfrom_DHCPv6_ReturnZero( const ConstSocket_t xSocket,
619+
void * pvBuffer,
620+
size_t uxBufferLength,
621+
BaseType_t xFlags,
622+
struct freertos_sockaddr * pxSourceAddress,
623+
socklen_t * pxSourceAddressLength,
624+
int callbacks )
625+
{
626+
NetworkEndPoint_t * pxIterator = pxNetworkEndPoints;
627+
size_t xSizeRetBufferSize = 0;
628+
629+
if( ( xFlags & FREERTOS_ZERO_COPY ) != 0 )
630+
{
631+
*( ( uint8_t ** ) pvBuffer ) = pucUDPBuffer;
632+
}
633+
634+
if(pxSourceAddress != NULL)
635+
{
636+
memcpy(pxSourceAddress, &xSourceAddress, sizeof(xSourceAddress));
637+
}
638+
639+
if(pxSourceAddressLength != NULL)
640+
{
641+
*pxSourceAddressLength = sizeof(xSourceAddress);
642+
}
643+
644+
/* Put in correct DHCP cookie. */
645+
( ( struct xDHCPMessage_IPv4 * ) pucUDPBuffer )->ulDHCPCookie = dhcpCOOKIE;
646+
( ( struct xDHCPMessage_IPv4 * ) pucUDPBuffer )->ucOpcode = dhcpREPLY_OPCODE;
647+
( ( struct xDHCPMessage_IPv4 * ) pucUDPBuffer )->ulTransactionID = FreeRTOS_htonl( 0x01ABCDEF );
648+
649+
return xSizeRetBufferSize;
650+
}

‎test/unit-test/FreeRTOS_DHCPv6/FreeRTOS_DHCPv6_utest.c‎

Lines changed: 85 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2325,7 +2325,7 @@ void test_vDHCPv6Process_DifferentDHCPServerRespondedWhileInProcess()
23252325

23262326
xEndPoint.pxDHCPMessage = &xDHCPMessage;
23272327

2328-
FreeRTOS_recvfrom_Stub( FreeRTOS_recvfrom__DHCPv6_LoopedCall );
2328+
FreeRTOS_recvfrom_Stub( FreeRTOS_recvfrom_DHCPv6_LoopedCall );
23292329
xTaskGetTickCount_IgnoreAndReturn( 0 );
23302330
FreeRTOS_ReleaseUDPPayloadBuffer_ExpectAnyArgs();
23312331
FreeRTOS_ReleaseUDPPayloadBuffer_ExpectAnyArgs();
@@ -2337,6 +2337,90 @@ void test_vDHCPv6Process_DifferentDHCPServerRespondedWhileInProcess()
23372337
TEST_ASSERT_EQUAL( eInitialWait, xEndPoint.xDHCPData.eDHCPState );
23382338
}
23392339

2340+
/**
2341+
* @brief Check if vDHCPv6Process can handle packets from a different
2342+
* DHCP server while vDHCPv6Process is already processing responses from
2343+
* server running on different port on the same server.
2344+
*/
2345+
void test_vDHCPv6Process_DifferentPortWhileInProcess()
2346+
{
2347+
NetworkEndPoint_t xEndPoint;
2348+
DHCPMessage_IPv6_t xDHCPMessage;
2349+
struct xSOCKET xLocalDHCPv6Socket;
2350+
2351+
memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
2352+
memset( &xLocalDHCPv6Socket, 0, sizeof( struct xSOCKET ) );
2353+
memset( &xDHCPMessage, 0, sizeof( DHCPMessage_IPv6_t ) );
2354+
2355+
pxNetworkEndPoints = &xEndPoint;
2356+
2357+
memcpy( xEndPoint.xMACAddress.ucBytes, ucDefaultMACAddress, sizeof( ucDefaultMACAddress ) );
2358+
memcpy( xEndPoint.ipv6_settings.xPrefix.ucBytes, &xDefaultNetPrefix.ucBytes, sizeof( IPv6_Address_t ) );
2359+
xEndPoint.ipv6_settings.uxPrefixLength = 64;
2360+
xEndPoint.bits.bIPv6 = pdTRUE;
2361+
xEndPoint.bits.bWantDHCP = pdTRUE;
2362+
2363+
xEndPoint.xDHCPData.eDHCPState = eWaitingOffer;
2364+
xEndPoint.xDHCPData.eExpectedState = eWaitingOffer;
2365+
xEndPoint.xDHCPData.ulTransactionId = TEST_DHCPV6_TRANSACTION_ID;
2366+
xEndPoint.xDHCPData.xDHCPSocket = &xLocalDHCPv6Socket;
2367+
memcpy( xEndPoint.xDHCPData.ucClientDUID, ucTestDHCPv6OptionClientID, sizeof( ucTestDHCPv6OptionClientID ) );
2368+
2369+
xEndPoint.pxDHCPMessage = &xDHCPMessage;
2370+
2371+
FreeRTOS_recvfrom_Stub( FreeRTOS_recvfrom_DHCPv6_LoopedCall_DifferentPort );
2372+
xTaskGetTickCount_IgnoreAndReturn( 0 );
2373+
FreeRTOS_ReleaseUDPPayloadBuffer_ExpectAnyArgs();
2374+
FreeRTOS_ReleaseUDPPayloadBuffer_ExpectAnyArgs();
2375+
2376+
prvPrepareAdvertiseStatusCodeLongMessage();
2377+
2378+
vDHCPv6Process( pdFALSE, &xEndPoint );
2379+
2380+
TEST_ASSERT_EQUAL( eInitialWait, xEndPoint.xDHCPData.eDHCPState );
2381+
}
2382+
2383+
2384+
/**
2385+
* @brief Check if vDHCPv6Process FreeRTOS_recvfrom returns 0
2386+
*/
2387+
void test_vDHCPv6Process_RecvFromReturnsZero()
2388+
{
2389+
NetworkEndPoint_t xEndPoint;
2390+
DHCPMessage_IPv6_t xDHCPMessage;
2391+
struct xSOCKET xLocalDHCPv6Socket;
2392+
2393+
memset( &xEndPoint, 0, sizeof( NetworkEndPoint_t ) );
2394+
memset( &xLocalDHCPv6Socket, 0, sizeof( struct xSOCKET ) );
2395+
memset( &xDHCPMessage, 0, sizeof( DHCPMessage_IPv6_t ) );
2396+
2397+
pxNetworkEndPoints = &xEndPoint;
2398+
2399+
memcpy( xEndPoint.xMACAddress.ucBytes, ucDefaultMACAddress, sizeof( ucDefaultMACAddress ) );
2400+
memcpy( xEndPoint.ipv6_settings.xPrefix.ucBytes, &xDefaultNetPrefix.ucBytes, sizeof( IPv6_Address_t ) );
2401+
xEndPoint.ipv6_settings.uxPrefixLength = 64;
2402+
xEndPoint.bits.bIPv6 = pdTRUE;
2403+
xEndPoint.bits.bWantDHCP = pdTRUE;
2404+
2405+
xEndPoint.xDHCPData.eDHCPState = eWaitingOffer;
2406+
xEndPoint.xDHCPData.eExpectedState = eWaitingOffer;
2407+
xEndPoint.xDHCPData.ulTransactionId = TEST_DHCPV6_TRANSACTION_ID;
2408+
xEndPoint.xDHCPData.xDHCPSocket = &xLocalDHCPv6Socket;
2409+
memcpy( xEndPoint.xDHCPData.ucClientDUID, ucTestDHCPv6OptionClientID, sizeof( ucTestDHCPv6OptionClientID ) );
2410+
2411+
xEndPoint.pxDHCPMessage = &xDHCPMessage;
2412+
2413+
FreeRTOS_recvfrom_Stub( FreeRTOS_recvfrom_DHCPv6_ReturnZero );
2414+
xTaskGetTickCount_IgnoreAndReturn( 0 );
2415+
FreeRTOS_ReleaseUDPPayloadBuffer_ExpectAnyArgs();
2416+
2417+
prvPrepareAdvertiseStatusCodeLongMessage();
2418+
2419+
vDHCPv6Process( pdFALSE, &xEndPoint );
2420+
2421+
TEST_ASSERT_EQUAL( eWaitingOffer, xEndPoint.xDHCPData.eDHCPState );
2422+
}
2423+
23402424
/**
23412425
* @brief Receive the message when global endpoint list is empty.
23422426
*/

0 commit comments

Comments
 (0)