mirror of
https://github.com/FreeRTOS/FreeRTOS-Plus-TCP
synced 2025-10-20 22:10:04 +08:00
a4124602cc
This commit brings in the refactoring and restructuring changes from IntegrationTesting1 branch to the main branch. It also includes additional unit tests for 100% coverage. The rationale behind not creating a PR is that the conflicts were too huge to be resolved correctly. Thus, a force push to the main branch is being done.
1254 lines
54 KiB
C
1254 lines
54 KiB
C
/*
|
|
* FreeRTOS+TCP V2.3.4
|
|
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
*
|
|
* SPDX-License-Identifier: MIT
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
* this software and associated documentation files (the "Software"), to deal in
|
|
* the Software without restriction, including without limitation the rights to
|
|
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
|
* the Software, and to permit persons to whom the Software is furnished to do so,
|
|
* subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* http://aws.amazon.com/freertos
|
|
* http://www.FreeRTOS.org
|
|
*/
|
|
|
|
/**
|
|
* @file FreeRTOS_DHCP.c
|
|
* @brief Implements the Dynamic Host Configuration Protocol for the FreeRTOS+TCP network stack.
|
|
*/
|
|
|
|
/* Standard includes. */
|
|
#include <stdint.h>
|
|
|
|
/* FreeRTOS includes. */
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#include "semphr.h"
|
|
|
|
/* FreeRTOS+TCP includes. */
|
|
#include "FreeRTOS_IP.h"
|
|
#include "FreeRTOS_Sockets.h"
|
|
#include "FreeRTOS_IP_Private.h"
|
|
#include "FreeRTOS_UDP_IP.h"
|
|
#include "FreeRTOS_DHCP.h"
|
|
#include "FreeRTOS_ARP.h"
|
|
#include "FreeRTOS_IP_Timers.h"
|
|
|
|
|
|
/* Exclude the entire file if DHCP is not enabled. */
|
|
#if ( ipconfigUSE_DHCP != 0 )
|
|
|
|
#include "NetworkInterface.h"
|
|
#include "NetworkBufferManagement.h"
|
|
|
|
/** @brief The UDP socket used for all incoming and outgoing DHCP traffic. */
|
|
_static Socket_t xDHCPSocket;
|
|
|
|
#if ( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 )
|
|
/* Define the Link Layer IP address: 169.254.x.x */
|
|
#define LINK_LAYER_ADDRESS_0 169
|
|
#define LINK_LAYER_ADDRESS_1 254
|
|
|
|
/* Define the netmask used: 255.255.0.0 */
|
|
#define LINK_LAYER_NETMASK_0 255
|
|
#define LINK_LAYER_NETMASK_1 255
|
|
#define LINK_LAYER_NETMASK_2 0
|
|
#define LINK_LAYER_NETMASK_3 0
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Generate a DHCP discover message and send it on the DHCP socket.
|
|
*/
|
|
static BaseType_t prvSendDHCPDiscover( void );
|
|
|
|
/*
|
|
* Interpret message received on the DHCP socket.
|
|
*/
|
|
_static BaseType_t prvProcessDHCPReplies( BaseType_t xExpectedMessageType );
|
|
|
|
/*
|
|
* Generate a DHCP request packet, and send it on the DHCP socket.
|
|
*/
|
|
static BaseType_t prvSendDHCPRequest( void );
|
|
|
|
/*
|
|
* Prepare to start a DHCP transaction. This initialises some state variables
|
|
* and creates the DHCP socket if necessary.
|
|
*/
|
|
static void prvInitialiseDHCP( void );
|
|
|
|
/*
|
|
* Creates the part of outgoing DHCP messages that are common to all outgoing
|
|
* DHCP messages.
|
|
*/
|
|
static uint8_t * prvCreatePartDHCPMessage( struct freertos_sockaddr * pxAddress,
|
|
BaseType_t xOpcode,
|
|
const uint8_t * const pucOptionsArray,
|
|
size_t * pxOptionsArraySize );
|
|
|
|
/*
|
|
* Create the DHCP socket, if it has not been created already.
|
|
*/
|
|
_static void prvCreateDHCPSocket( void );
|
|
|
|
/*
|
|
* Close the DHCP socket.
|
|
*/
|
|
static void prvCloseDHCPSocket( void );
|
|
|
|
/*
|
|
* After DHCP has failed to answer, prepare everything to start searching
|
|
* for (trying-out) LinkLayer IP-addresses, using the random method: Send
|
|
* a gratuitous ARP request and wait if another device responds to it.
|
|
*/
|
|
#if ( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 )
|
|
static void prvPrepareLinkLayerIPLookUp( void );
|
|
#endif
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/** @brief Hold information in between steps in the DHCP state machine. */
|
|
_static DHCPData_t xDHCPData;
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief Check whether a given socket is the DHCP socket or not.
|
|
*
|
|
* @param[in] xSocket: The socket to be checked.
|
|
*
|
|
* @return If the socket given as parameter is the DHCP socket - return
|
|
* pdTRUE, else pdFALSE.
|
|
*/
|
|
BaseType_t xIsDHCPSocket( Socket_t xSocket )
|
|
{
|
|
BaseType_t xReturn;
|
|
|
|
if( xDHCPSocket == xSocket )
|
|
{
|
|
xReturn = pdTRUE;
|
|
}
|
|
else
|
|
{
|
|
xReturn = pdFALSE;
|
|
}
|
|
|
|
return xReturn;
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief The application can indicate a preferred IP address by calling this function.
|
|
* before starting up the IP-task by calling FreeRTOS_IPInit().
|
|
*
|
|
* @param[in] ulIPAddress: The preferred IP-address.
|
|
*
|
|
* @return The previous value of ulPreferredIPAddress.
|
|
*/
|
|
uint32_t vDHCPSetPreferredIPAddress( uint32_t ulIPAddress )
|
|
{
|
|
uint32_t ulPrevious = xDHCPData.ulPreferredIPAddress;
|
|
|
|
xDHCPData.ulPreferredIPAddress = ulIPAddress;
|
|
|
|
return ulPrevious;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the current state of a DHCP process.
|
|
*
|
|
* @return The current state ( eDHCPState_t ) of the DHCP process.
|
|
*/
|
|
eDHCPState_t eGetDHCPState( void )
|
|
{
|
|
return EP_DHCPData.eDHCPState;
|
|
}
|
|
|
|
/**
|
|
* @brief Process the DHCP state machine based on current state.
|
|
*
|
|
* @param[in] xReset: Is the DHCP state machine starting over? pdTRUE/pdFALSE.
|
|
* @param[in] eExpectedState: The function will only run if the state is expected.
|
|
*/
|
|
void vDHCPProcess( BaseType_t xReset,
|
|
eDHCPState_t eExpectedState )
|
|
{
|
|
BaseType_t xGivingUp = pdFALSE;
|
|
|
|
#if ( ipconfigUSE_DHCP_HOOK != 0 )
|
|
eDHCPCallbackAnswer_t eAnswer;
|
|
#endif /* ipconfigUSE_DHCP_HOOK */
|
|
|
|
/* Is DHCP starting over? */
|
|
if( xReset != pdFALSE )
|
|
{
|
|
EP_DHCPData.eDHCPState = eInitialWait;
|
|
}
|
|
|
|
if( ( EP_DHCPData.eDHCPState != eExpectedState ) && ( xReset == pdFALSE ) )
|
|
{
|
|
/* When the DHCP event was generated, the DHCP client was
|
|
* in a different state. Therefore, ignore this event. */
|
|
FreeRTOS_debug_printf( ( "DHCP wrong state: expect: %d got: %d : ignore\n",
|
|
eExpectedState, EP_DHCPData.eDHCPState ) );
|
|
}
|
|
else
|
|
{
|
|
switch( EP_DHCPData.eDHCPState )
|
|
{
|
|
case eInitialWait:
|
|
|
|
/* Initial state. Create the DHCP socket, timer, etc. if they
|
|
* have not already been created. */
|
|
prvInitialiseDHCP();
|
|
EP_DHCPData.eDHCPState = eWaitingSendFirstDiscover;
|
|
break;
|
|
|
|
case eWaitingSendFirstDiscover:
|
|
/* Ask the user if a DHCP discovery is required. */
|
|
#if ( ipconfigUSE_DHCP_HOOK != 0 )
|
|
eAnswer = xApplicationDHCPHook( eDHCPPhasePreDiscover, xNetworkAddressing.ulDefaultIPAddress );
|
|
|
|
if( eAnswer == eDHCPContinue )
|
|
#endif /* ipconfigUSE_DHCP_HOOK */
|
|
{
|
|
/* See if prvInitialiseDHCP() has creates a socket. */
|
|
if( xDHCPSocket == NULL )
|
|
{
|
|
xGivingUp = pdTRUE;
|
|
}
|
|
else
|
|
{
|
|
*ipLOCAL_IP_ADDRESS_POINTER = 0U;
|
|
|
|
/* Send the first discover request. */
|
|
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
|
|
|
|
if( prvSendDHCPDiscover() == pdPASS )
|
|
{
|
|
EP_DHCPData.eDHCPState = eWaitingOffer;
|
|
}
|
|
else
|
|
{
|
|
/* Either the creation of a message buffer failed, or sendto().
|
|
* Try again in the next cycle. */
|
|
FreeRTOS_debug_printf( ( "Send failed during eWaitingSendFirstDiscover\n" ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
#if ( ipconfigUSE_DHCP_HOOK != 0 )
|
|
else
|
|
{
|
|
if( eAnswer == eDHCPUseDefaults )
|
|
{
|
|
( void ) memcpy( &( xNetworkAddressing ), &( xDefaultAddressing ), sizeof( xNetworkAddressing ) );
|
|
}
|
|
|
|
/* The user indicates that the DHCP process does not continue. */
|
|
xGivingUp = pdTRUE;
|
|
}
|
|
#endif /* ipconfigUSE_DHCP_HOOK */
|
|
break;
|
|
|
|
case eSendDHCPRequest:
|
|
|
|
if( prvSendDHCPRequest() == pdPASS )
|
|
{
|
|
/* Send succeeded, go to state 'eWaitingAcknowledge'. */
|
|
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
|
|
EP_DHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;
|
|
EP_DHCPData.eDHCPState = eWaitingAcknowledge;
|
|
}
|
|
else
|
|
{
|
|
/* Either the creation of a message buffer failed, or sendto().
|
|
* Try again in the next cycle. */
|
|
FreeRTOS_debug_printf( ( "Send failed during eSendDHCPRequest.\n" ) );
|
|
}
|
|
|
|
break;
|
|
|
|
case eWaitingOffer:
|
|
|
|
xGivingUp = pdFALSE;
|
|
|
|
/* Look for offers coming in. */
|
|
if( prvProcessDHCPReplies( dhcpMESSAGE_TYPE_OFFER ) == pdPASS )
|
|
{
|
|
#if ( ipconfigUSE_DHCP_HOOK != 0 )
|
|
/* Ask the user if a DHCP request is required. */
|
|
eAnswer = xApplicationDHCPHook( eDHCPPhasePreRequest, EP_DHCPData.ulOfferedIPAddress );
|
|
|
|
if( eAnswer == eDHCPContinue )
|
|
#endif /* ipconfigUSE_DHCP_HOOK */
|
|
{
|
|
/* An offer has been made, the user wants to continue,
|
|
* generate the request. */
|
|
if( prvSendDHCPRequest() == pdPASS )
|
|
{
|
|
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
|
|
EP_DHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;
|
|
EP_DHCPData.eDHCPState = eWaitingAcknowledge;
|
|
}
|
|
else
|
|
{
|
|
/* Either the creation of a message buffer failed, or sendto().
|
|
* Try again in the next cycle. */
|
|
FreeRTOS_debug_printf( ( "Send failed during eWaitingOffer/1.\n" ) );
|
|
EP_DHCPData.eDHCPState = eSendDHCPRequest;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
#if ( ipconfigUSE_DHCP_HOOK != 0 )
|
|
if( eAnswer == eDHCPUseDefaults )
|
|
{
|
|
( void ) memcpy( &( xNetworkAddressing ), &( xDefaultAddressing ), sizeof( xNetworkAddressing ) );
|
|
}
|
|
|
|
/* The user indicates that the DHCP process does not continue. */
|
|
xGivingUp = pdTRUE;
|
|
#endif /* ipconfigUSE_DHCP_HOOK */
|
|
}
|
|
|
|
/* Is it time to send another Discover? */
|
|
else if( ( xTaskGetTickCount() - EP_DHCPData.xDHCPTxTime ) > EP_DHCPData.xDHCPTxPeriod )
|
|
{
|
|
/* It is time to send another Discover. Increase the time
|
|
* period, and if it has not got to the point of giving up - send
|
|
* another discovery. */
|
|
EP_DHCPData.xDHCPTxPeriod <<= 1;
|
|
|
|
if( EP_DHCPData.xDHCPTxPeriod <= ( TickType_t ) ipconfigMAXIMUM_DISCOVER_TX_PERIOD )
|
|
{
|
|
if( xApplicationGetRandomNumber( &( EP_DHCPData.ulTransactionId ) ) != pdFALSE )
|
|
{
|
|
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
|
|
|
|
if( EP_DHCPData.xUseBroadcast != pdFALSE )
|
|
{
|
|
EP_DHCPData.xUseBroadcast = pdFALSE;
|
|
}
|
|
else
|
|
{
|
|
EP_DHCPData.xUseBroadcast = pdTRUE;
|
|
}
|
|
|
|
if( prvSendDHCPDiscover() == pdPASS )
|
|
{
|
|
FreeRTOS_debug_printf( ( "vDHCPProcess: timeout %lu ticks\n", EP_DHCPData.xDHCPTxPeriod ) );
|
|
}
|
|
else
|
|
{
|
|
/* Either the creation of a message buffer failed, or sendto().
|
|
* Try again in the next cycle. */
|
|
FreeRTOS_debug_printf( ( "Send failed during eWaitingOffer/2.\n" ) );
|
|
EP_DHCPData.eDHCPState = eInitialWait;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FreeRTOS_debug_printf( ( "vDHCPProcess: failed to generate a random Transaction ID\n" ) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FreeRTOS_debug_printf( ( "vDHCPProcess: giving up %lu > %lu ticks\n", EP_DHCPData.xDHCPTxPeriod, ipconfigMAXIMUM_DISCOVER_TX_PERIOD ) );
|
|
|
|
#if ( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 )
|
|
{
|
|
/* Only use a fake Ack if the default IP address == 0x00
|
|
* and the link local addressing is used. Start searching
|
|
* a free LinkLayer IP-address. Next state will be
|
|
* 'eGetLinkLayerAddress'. */
|
|
prvPrepareLinkLayerIPLookUp();
|
|
|
|
/* Setting an IP address manually so set to not using
|
|
* leased address mode. */
|
|
EP_DHCPData.eDHCPState = eGetLinkLayerAddress;
|
|
}
|
|
#else
|
|
{
|
|
xGivingUp = pdTRUE;
|
|
}
|
|
#endif /* ipconfigDHCP_FALL_BACK_AUTO_IP */
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* There was no DHCP reply, there was no time-out, just keep on waiting. */
|
|
}
|
|
|
|
break;
|
|
|
|
case eWaitingAcknowledge:
|
|
|
|
/* Look for acks coming in. */
|
|
if( prvProcessDHCPReplies( dhcpMESSAGE_TYPE_ACK ) == pdPASS )
|
|
{
|
|
FreeRTOS_debug_printf( ( "vDHCPProcess: acked %xip\n", ( unsigned ) FreeRTOS_ntohl( EP_DHCPData.ulOfferedIPAddress ) ) );
|
|
|
|
/* DHCP completed. The IP address can now be used, and the
|
|
* timer set to the lease timeout time. */
|
|
*ipLOCAL_IP_ADDRESS_POINTER = EP_DHCPData.ulOfferedIPAddress;
|
|
|
|
/* Setting the 'local' broadcast address, something like
|
|
* '192.168.1.255'. */
|
|
EP_IPv4_SETTINGS.ulBroadcastAddress = ( EP_DHCPData.ulOfferedIPAddress & xNetworkAddressing.ulNetMask ) | ~xNetworkAddressing.ulNetMask;
|
|
EP_DHCPData.eDHCPState = eLeasedAddress;
|
|
|
|
iptraceDHCP_SUCCEDEED( EP_DHCPData.ulOfferedIPAddress );
|
|
|
|
/* DHCP failed, the default configured IP-address will be used
|
|
* Now call vIPNetworkUpCalls() to send the network-up event and
|
|
* start the ARP timer. */
|
|
vIPNetworkUpCalls();
|
|
|
|
/* Close socket to ensure packets don't queue on it. */
|
|
prvCloseDHCPSocket();
|
|
|
|
if( EP_DHCPData.ulLeaseTime == 0U )
|
|
{
|
|
EP_DHCPData.ulLeaseTime = ( uint32_t ) dhcpDEFAULT_LEASE_TIME;
|
|
}
|
|
else if( EP_DHCPData.ulLeaseTime < dhcpMINIMUM_LEASE_TIME )
|
|
{
|
|
EP_DHCPData.ulLeaseTime = dhcpMINIMUM_LEASE_TIME;
|
|
}
|
|
else
|
|
{
|
|
/* The lease time is already valid. */
|
|
}
|
|
|
|
/* Check for clashes. */
|
|
vARPSendGratuitous();
|
|
vDHCPTimerReload( EP_DHCPData.ulLeaseTime );
|
|
}
|
|
else
|
|
{
|
|
/* Is it time to send another Discover? */
|
|
if( ( xTaskGetTickCount() - EP_DHCPData.xDHCPTxTime ) > EP_DHCPData.xDHCPTxPeriod )
|
|
{
|
|
/* Increase the time period, and if it has not got to the
|
|
* point of giving up - send another request. */
|
|
EP_DHCPData.xDHCPTxPeriod <<= 1;
|
|
|
|
if( EP_DHCPData.xDHCPTxPeriod <= ( TickType_t ) ipconfigMAXIMUM_DISCOVER_TX_PERIOD )
|
|
{
|
|
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
|
|
|
|
if( prvSendDHCPRequest() == pdPASS )
|
|
{
|
|
/* The message is sent. Stay in state 'eWaitingAcknowledge'. */
|
|
}
|
|
else
|
|
{
|
|
/* Either the creation of a message buffer failed, or sendto().
|
|
* Try again in the next cycle. */
|
|
FreeRTOS_debug_printf( ( "Send failed during eWaitingAcknowledge.\n" ) );
|
|
EP_DHCPData.eDHCPState = eSendDHCPRequest;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Give up, start again. */
|
|
EP_DHCPData.eDHCPState = eInitialWait;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
#if ( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 )
|
|
case eGetLinkLayerAddress:
|
|
|
|
if( ( xTaskGetTickCount() - EP_DHCPData.xDHCPTxTime ) > EP_DHCPData.xDHCPTxPeriod )
|
|
{
|
|
if( xARPHadIPClash == pdFALSE )
|
|
{
|
|
/* ARP OK. proceed. */
|
|
iptraceDHCP_SUCCEDEED( EP_DHCPData.ulOfferedIPAddress );
|
|
|
|
/* Auto-IP succeeded, the default configured IP-address will
|
|
* be used. Now call vIPNetworkUpCalls() to send the
|
|
* network-up event and start the ARP timer. */
|
|
vIPNetworkUpCalls();
|
|
EP_DHCPData.eDHCPState = eNotUsingLeasedAddress;
|
|
}
|
|
else
|
|
{
|
|
/* ARP clashed - try another IP address. */
|
|
prvPrepareLinkLayerIPLookUp();
|
|
|
|
/* Setting an IP address manually so set to not using leased
|
|
* address mode. */
|
|
EP_DHCPData.eDHCPState = eGetLinkLayerAddress;
|
|
}
|
|
}
|
|
break;
|
|
#endif /* ipconfigDHCP_FALL_BACK_AUTO_IP */
|
|
|
|
case eLeasedAddress:
|
|
|
|
if( FreeRTOS_IsNetworkUp() != 0 )
|
|
{
|
|
/* Resend the request at the appropriate time to renew the lease. */
|
|
prvCreateDHCPSocket();
|
|
|
|
if( xDHCPSocket != NULL )
|
|
{
|
|
uint32_t ulID = 0U;
|
|
|
|
if( xApplicationGetRandomNumber( &( ulID ) ) != pdFALSE )
|
|
{
|
|
EP_DHCPData.ulTransactionId = ulID;
|
|
}
|
|
|
|
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
|
|
EP_DHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;
|
|
|
|
if( prvSendDHCPRequest() == pdPASS )
|
|
{
|
|
/* The packet was sent successfully, wait for an acknowledgement. */
|
|
EP_DHCPData.eDHCPState = eWaitingAcknowledge;
|
|
}
|
|
else
|
|
{
|
|
/* The packet was not sent, try sending it later. */
|
|
EP_DHCPData.eDHCPState = eSendDHCPRequest;
|
|
FreeRTOS_debug_printf( ( "Send failed eLeasedAddress.\n" ) );
|
|
}
|
|
|
|
/* From now on, we should be called more often */
|
|
vDHCPTimerReload( dhcpINITIAL_TIMER_PERIOD );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* See PR #53 on github/freertos/freertos */
|
|
FreeRTOS_printf( ( "DHCP: lease time finished but network is down\n" ) );
|
|
vDHCPTimerReload( pdMS_TO_TICKS( 5000U ) );
|
|
}
|
|
|
|
break;
|
|
|
|
case eNotUsingLeasedAddress:
|
|
|
|
vIPSetDHCPTimerEnableState( pdFALSE );
|
|
break;
|
|
|
|
default:
|
|
/* Lint: all options are included. */
|
|
break;
|
|
}
|
|
|
|
if( xGivingUp != pdFALSE )
|
|
{
|
|
/* xGivingUp became true either because of a time-out, or because
|
|
* xApplicationDHCPHook() returned another value than 'eDHCPContinue',
|
|
* meaning that the conversion is cancelled from here. */
|
|
|
|
/* Revert to static IP address. */
|
|
taskENTER_CRITICAL();
|
|
{
|
|
*ipLOCAL_IP_ADDRESS_POINTER = xNetworkAddressing.ulDefaultIPAddress;
|
|
iptraceDHCP_REQUESTS_FAILED_USING_DEFAULT_IP_ADDRESS( xNetworkAddressing.ulDefaultIPAddress );
|
|
}
|
|
taskEXIT_CRITICAL();
|
|
|
|
EP_DHCPData.eDHCPState = eNotUsingLeasedAddress;
|
|
vIPSetDHCPTimerEnableState( pdFALSE );
|
|
|
|
/* DHCP failed, the default configured IP-address will be used. Now
|
|
* call vIPNetworkUpCalls() to send the network-up event and start the ARP
|
|
* timer. */
|
|
vIPNetworkUpCalls();
|
|
|
|
/* Close socket to ensure packets don't queue on it. */
|
|
prvCloseDHCPSocket();
|
|
}
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief Close the DHCP socket.
|
|
*/
|
|
static void prvCloseDHCPSocket( void )
|
|
{
|
|
if( xDHCPSocket != NULL )
|
|
{
|
|
/* This modules runs from the IP-task. Use the internal
|
|
* function 'vSocketClose()` to close the socket. */
|
|
( void ) vSocketClose( xDHCPSocket );
|
|
xDHCPSocket = NULL;
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief Create a DHCP socket with the defined timeouts.
|
|
*/
|
|
_static void prvCreateDHCPSocket( void )
|
|
{
|
|
struct freertos_sockaddr xAddress;
|
|
BaseType_t xReturn;
|
|
TickType_t xTimeoutTime = ( TickType_t ) 0;
|
|
|
|
/* Create the socket, if it has not already been created. */
|
|
if( xDHCPSocket == NULL )
|
|
{
|
|
xDHCPSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );
|
|
|
|
if( xDHCPSocket != FREERTOS_INVALID_SOCKET )
|
|
{
|
|
/* Ensure the Rx and Tx timeouts are zero as the DHCP executes in the
|
|
* context of the IP task. */
|
|
( void ) FreeRTOS_setsockopt( xDHCPSocket, 0, FREERTOS_SO_RCVTIMEO, &( xTimeoutTime ), sizeof( TickType_t ) );
|
|
( void ) FreeRTOS_setsockopt( xDHCPSocket, 0, FREERTOS_SO_SNDTIMEO, &( xTimeoutTime ), sizeof( TickType_t ) );
|
|
|
|
/* Bind to the standard DHCP client port. */
|
|
xAddress.sin_port = ( uint16_t ) dhcpCLIENT_PORT_IPv4;
|
|
xReturn = vSocketBind( xDHCPSocket, &xAddress, sizeof( xAddress ), pdFALSE );
|
|
|
|
if( xReturn != 0 )
|
|
{
|
|
/* Binding failed, close the socket again. */
|
|
prvCloseDHCPSocket();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Change to NULL for easier testing. */
|
|
xDHCPSocket = NULL;
|
|
}
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief Initialise the DHCP state machine by creating DHCP socket and
|
|
* begin the transaction.
|
|
*/
|
|
static void prvInitialiseDHCP( void )
|
|
{
|
|
/* Initialise the parameters that will be set by the DHCP process. Per
|
|
* https://www.ietf.org/rfc/rfc2131.txt, Transaction ID should be a random
|
|
* value chosen by the client. */
|
|
|
|
/* Check for random number generator API failure. */
|
|
if( xApplicationGetRandomNumber( &( EP_DHCPData.ulTransactionId ) ) != pdFALSE )
|
|
{
|
|
EP_DHCPData.xUseBroadcast = 0;
|
|
EP_DHCPData.ulOfferedIPAddress = 0U;
|
|
EP_DHCPData.ulDHCPServerAddress = 0U;
|
|
EP_DHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;
|
|
|
|
/* Create the DHCP socket if it has not already been created. */
|
|
prvCreateDHCPSocket();
|
|
FreeRTOS_debug_printf( ( "prvInitialiseDHCP: start after %lu ticks\n", dhcpINITIAL_TIMER_PERIOD ) );
|
|
vDHCPTimerReload( dhcpINITIAL_TIMER_PERIOD );
|
|
}
|
|
else
|
|
{
|
|
/* There was a problem with the randomiser. */
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief Check whether the DHCP response from the server has all valid
|
|
* invariant parameters and valid (non broadcast and non localhost)
|
|
* IP address being assigned to the device.
|
|
*
|
|
* @param[in] pxDHCPMessage: The DHCP message.
|
|
*
|
|
* @return pdPASS if the DHCP response has correct parameters; pdFAIL otherwise.
|
|
*/
|
|
static BaseType_t prvIsValidDHCPResponse( const DHCPMessage_IPv4_t * pxDHCPMessage )
|
|
{
|
|
BaseType_t xReturn = pdPASS;
|
|
|
|
if( ( pxDHCPMessage->ulDHCPCookie != ( uint32_t ) dhcpCOOKIE ) ||
|
|
( pxDHCPMessage->ucOpcode != ( uint8_t ) dhcpREPLY_OPCODE ) ||
|
|
( pxDHCPMessage->ucAddressType != ( uint8_t ) dhcpADDRESS_TYPE_ETHERNET ) ||
|
|
( pxDHCPMessage->ucAddressLength != ( uint8_t ) dhcpETHERNET_ADDRESS_LENGTH ) ||
|
|
( ( FreeRTOS_ntohl( pxDHCPMessage->ulYourIPAddress_yiaddr ) & 0xFF ) == 0xFF ) ||
|
|
( ( ( pxDHCPMessage->ulYourIPAddress_yiaddr & 0x7F ) ^ 0x7F ) == 0x00 ) )
|
|
{
|
|
/* Invalid cookie OR
|
|
* Unexpected opcode OR
|
|
* Incorrect address type OR
|
|
* Incorrect address length OR
|
|
* The DHCP server is trying to assign a broadcast address to the device OR
|
|
* The DHCP server is trying to assign a localhost address to the device. */
|
|
xReturn = pdFAIL;
|
|
}
|
|
|
|
return xReturn;
|
|
}
|
|
|
|
/**
|
|
* @brief Process the DHCP replies.
|
|
*
|
|
* @param[in] xExpectedMessageType: The type of the message the DHCP state machine is expecting.
|
|
* Messages of different type will be dropped.
|
|
*
|
|
* @return pdPASS: if DHCP options are received correctly; pdFAIL: Otherwise.
|
|
*/
|
|
_static BaseType_t prvProcessDHCPReplies( BaseType_t xExpectedMessageType )
|
|
{
|
|
uint8_t * pucUDPPayload;
|
|
int32_t lBytes;
|
|
const DHCPMessage_IPv4_t * pxDHCPMessage;
|
|
const uint8_t * pucByte;
|
|
uint8_t ucOptionCode;
|
|
uint32_t ulProcessed, ulParameter;
|
|
BaseType_t xReturn = pdFALSE;
|
|
const uint32_t ulMandatoryOptions = 2U; /* DHCP server address, and the correct DHCP message type must be present in the options. */
|
|
/* memcpy() helper variables for MISRA Rule 21.15 compliance*/
|
|
const void * pvCopySource;
|
|
void * pvCopyDest;
|
|
|
|
/* Passing the address of a pointer (pucUDPPayload) because FREERTOS_ZERO_COPY is used. */
|
|
lBytes = FreeRTOS_recvfrom( xDHCPSocket, &pucUDPPayload, 0U, FREERTOS_ZERO_COPY, NULL, NULL );
|
|
|
|
if( lBytes > 0 )
|
|
{
|
|
/* Map a DHCP structure onto the received data. */
|
|
pxDHCPMessage = ( ( DHCPMessage_IPv4_t * ) pucUDPPayload );
|
|
|
|
/* Sanity check. */
|
|
if( lBytes < ( int32_t ) sizeof( DHCPMessage_IPv4_t ) )
|
|
{
|
|
/* Not enough bytes. */
|
|
}
|
|
else if( prvIsValidDHCPResponse( pxDHCPMessage ) == pdFAIL )
|
|
{
|
|
/* Invalid values in DHCP response. */
|
|
}
|
|
else if( ( pxDHCPMessage->ulTransactionID != FreeRTOS_htonl( EP_DHCPData.ulTransactionId ) ) )
|
|
{
|
|
/* Transaction ID does not match. */
|
|
}
|
|
else /* Looks like a valid DHCP response, with the same transaction ID. */
|
|
{
|
|
if( memcmp( pxDHCPMessage->ucClientHardwareAddress,
|
|
ipLOCAL_MAC_ADDRESS,
|
|
sizeof( MACAddress_t ) ) != 0 )
|
|
{
|
|
/* Target MAC address doesn't match. */
|
|
}
|
|
else
|
|
{
|
|
size_t uxIndex, uxPayloadDataLength, uxLength;
|
|
|
|
/* None of the essential options have been processed yet. */
|
|
ulProcessed = 0U;
|
|
|
|
/* Walk through the options until the dhcpOPTION_END_BYTE byte
|
|
* is found, taking care not to walk off the end of the options. */
|
|
pucByte = &( pucUDPPayload[ sizeof( DHCPMessage_IPv4_t ) ] );
|
|
uxIndex = 0;
|
|
uxPayloadDataLength = ( ( size_t ) lBytes ) - sizeof( DHCPMessage_IPv4_t );
|
|
|
|
while( uxIndex < uxPayloadDataLength )
|
|
{
|
|
ucOptionCode = pucByte[ uxIndex ];
|
|
|
|
if( ucOptionCode == ( uint8_t ) dhcpOPTION_END_BYTE )
|
|
{
|
|
/* Ready, the last byte has been seen. */
|
|
/* coverity[break_stmt] : Break statement terminating the loop */
|
|
break;
|
|
}
|
|
|
|
if( ucOptionCode == ( uint8_t ) dhcpIPv4_ZERO_PAD_OPTION_CODE )
|
|
{
|
|
/* The value zero is used as a pad byte,
|
|
* it is not followed by a length byte. */
|
|
uxIndex = uxIndex + 1U;
|
|
continue;
|
|
}
|
|
|
|
/* Stop if the response is malformed. */
|
|
if( ( uxIndex + 1U ) < uxPayloadDataLength )
|
|
{
|
|
/* Fetch the length byte. */
|
|
uxLength = ( size_t ) pucByte[ uxIndex + 1U ];
|
|
uxIndex = uxIndex + 2U;
|
|
|
|
if( !( ( ( uxIndex + uxLength ) - 1U ) < uxPayloadDataLength ) )
|
|
{
|
|
/* There are not as many bytes left as there should be. */
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* The length byte is missing. */
|
|
break;
|
|
}
|
|
|
|
/* In most cases, a 4-byte network-endian parameter follows,
|
|
* just get it once here and use later. */
|
|
if( uxLength >= sizeof( ulParameter ) )
|
|
{
|
|
/*
|
|
* Use helper variables for memcpy() to remain
|
|
* compliant with MISRA Rule 21.15. These should be
|
|
* optimized away.
|
|
*/
|
|
pvCopySource = &pucByte[ uxIndex ];
|
|
pvCopyDest = &ulParameter;
|
|
( void ) memcpy( pvCopyDest, pvCopySource, sizeof( ulParameter ) );
|
|
/* 'uxIndex' will be increased at the end of this loop. */
|
|
}
|
|
else
|
|
{
|
|
ulParameter = 0;
|
|
}
|
|
|
|
/* Confirm uxIndex is still a valid index after adjustments to uxIndex above */
|
|
if( !( uxIndex < uxPayloadDataLength ) )
|
|
{
|
|
break;
|
|
}
|
|
|
|
/* Option-specific handling. */
|
|
switch( ucOptionCode )
|
|
{
|
|
case dhcpIPv4_MESSAGE_TYPE_OPTION_CODE:
|
|
|
|
if( pucByte[ uxIndex ] == ( uint8_t ) xExpectedMessageType )
|
|
{
|
|
/* The message type is the message type the
|
|
* state machine is expecting. */
|
|
ulProcessed++;
|
|
}
|
|
else
|
|
{
|
|
if( pucByte[ uxIndex ] == ( uint8_t ) dhcpMESSAGE_TYPE_NACK )
|
|
{
|
|
if( xExpectedMessageType == ( BaseType_t ) dhcpMESSAGE_TYPE_ACK )
|
|
{
|
|
/* Start again. */
|
|
EP_DHCPData.eDHCPState = eInitialWait;
|
|
}
|
|
}
|
|
|
|
/* Stop processing further options. */
|
|
uxLength = 0;
|
|
}
|
|
|
|
break;
|
|
|
|
case dhcpIPv4_SUBNET_MASK_OPTION_CODE:
|
|
|
|
if( uxLength == sizeof( uint32_t ) )
|
|
{
|
|
EP_IPv4_SETTINGS.ulNetMask = ulParameter;
|
|
}
|
|
|
|
break;
|
|
|
|
case dhcpIPv4_GATEWAY_OPTION_CODE:
|
|
|
|
/* The DHCP server may send more than 1 gateway addresses. */
|
|
if( uxLength >= sizeof( uint32_t ) )
|
|
{
|
|
/* ulProcessed is not incremented in this case
|
|
* because the gateway is not essential. */
|
|
EP_IPv4_SETTINGS.ulGatewayAddress = ulParameter;
|
|
}
|
|
|
|
break;
|
|
|
|
case dhcpIPv4_DNS_SERVER_OPTIONS_CODE:
|
|
|
|
/* The DHCP server may send more than 1 DNS server addresses. */
|
|
if( uxLength >= sizeof( uint32_t ) )
|
|
{
|
|
/* ulProcessed is not incremented in this case
|
|
* because the DNS server is not essential. Only the
|
|
* first DNS server address is taken. */
|
|
EP_IPv4_SETTINGS.ulDNSServerAddress = ulParameter;
|
|
}
|
|
|
|
break;
|
|
|
|
case dhcpIPv4_SERVER_IP_ADDRESS_OPTION_CODE:
|
|
|
|
if( uxLength == sizeof( uint32_t ) )
|
|
{
|
|
if( xExpectedMessageType == ( BaseType_t ) dhcpMESSAGE_TYPE_OFFER )
|
|
{
|
|
/* Offers state the replying server. */
|
|
ulProcessed++;
|
|
EP_DHCPData.ulDHCPServerAddress = ulParameter;
|
|
}
|
|
else
|
|
{
|
|
/* The ack must come from the expected server. */
|
|
if( EP_DHCPData.ulDHCPServerAddress == ulParameter )
|
|
{
|
|
ulProcessed++;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case dhcpIPv4_LEASE_TIME_OPTION_CODE:
|
|
|
|
if( uxLength == sizeof( EP_DHCPData.ulLeaseTime ) )
|
|
{
|
|
/* ulProcessed is not incremented in this case
|
|
* because the lease time is not essential. */
|
|
|
|
/* The DHCP parameter is in seconds, convert
|
|
* to host-endian format. */
|
|
EP_DHCPData.ulLeaseTime = FreeRTOS_ntohl( ulParameter );
|
|
|
|
/* Divide the lease time by two to ensure a renew
|
|
* request is sent before the lease actually expires. */
|
|
EP_DHCPData.ulLeaseTime >>= 1;
|
|
|
|
/* Multiply with configTICK_RATE_HZ to get clock ticks. */
|
|
EP_DHCPData.ulLeaseTime = ( uint32_t ) configTICK_RATE_HZ * ( uint32_t ) EP_DHCPData.ulLeaseTime;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Not interested in this field. */
|
|
|
|
break;
|
|
}
|
|
|
|
/* Jump over the data to find the next option code. */
|
|
if( uxLength == 0U )
|
|
{
|
|
break;
|
|
}
|
|
|
|
uxIndex = uxIndex + uxLength;
|
|
}
|
|
|
|
/* Were all the mandatory options received? */
|
|
if( ulProcessed >= ulMandatoryOptions )
|
|
{
|
|
/* HT:endian: used to be network order */
|
|
EP_DHCPData.ulOfferedIPAddress = pxDHCPMessage->ulYourIPAddress_yiaddr;
|
|
FreeRTOS_printf( ( "vDHCPProcess: offer %xip\n", ( unsigned ) FreeRTOS_ntohl( EP_DHCPData.ulOfferedIPAddress ) ) );
|
|
xReturn = pdPASS;
|
|
}
|
|
}
|
|
}
|
|
|
|
FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayload );
|
|
} /* if( lBytes > 0 ) */
|
|
|
|
return xReturn;
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief Create a partial DHCP message by filling in all the 'constant' fields.
|
|
*
|
|
* @param[out] pxAddress: Address to be filled in.
|
|
* @param[out] xOpcode: Opcode to be filled in the packet. Will always be 'dhcpREQUEST_OPCODE'.
|
|
* @param[in] pucOptionsArray: The options to be added to the packet.
|
|
* @param[in,out] pxOptionsArraySize: Byte count of the options. Its value might change.
|
|
*
|
|
* @return Ethernet buffer of the partially created DHCP packet.
|
|
*/
|
|
static uint8_t * prvCreatePartDHCPMessage( struct freertos_sockaddr * pxAddress,
|
|
BaseType_t xOpcode,
|
|
const uint8_t * const pucOptionsArray,
|
|
size_t * pxOptionsArraySize )
|
|
{
|
|
DHCPMessage_IPv4_t * pxDHCPMessage;
|
|
size_t uxRequiredBufferSize = sizeof( DHCPMessage_IPv4_t ) + *pxOptionsArraySize;
|
|
const NetworkBufferDescriptor_t * pxNetworkBuffer;
|
|
uint8_t * pucUDPPayloadBuffer = NULL;
|
|
|
|
#if ( ipconfigDHCP_REGISTER_HOSTNAME == 1 )
|
|
const char * pucHostName = pcApplicationHostnameHook();
|
|
size_t uxNameLength = strlen( pucHostName );
|
|
uint8_t * pucPtr;
|
|
|
|
/* memcpy() helper variables for MISRA Rule 21.15 compliance*/
|
|
const void * pvCopySource;
|
|
void * pvCopyDest;
|
|
|
|
/* Two extra bytes for option code and length. */
|
|
uxRequiredBufferSize += ( 2U + uxNameLength );
|
|
#endif /* if ( ipconfigDHCP_REGISTER_HOSTNAME == 1 ) */
|
|
|
|
/* Obtain a network buffer with the required amount of storage. It doesn't make much sense
|
|
* to use a time-out here, because that would cause the IP-task to wait for itself. */
|
|
pxNetworkBuffer = pxGetNetworkBufferWithDescriptor( sizeof( UDPPacket_t ) + uxRequiredBufferSize, 0U );
|
|
|
|
if( pxNetworkBuffer != NULL )
|
|
{
|
|
/* Leave space for the UDP header. */
|
|
pucUDPPayloadBuffer = &( pxNetworkBuffer->pucEthernetBuffer[ ipUDP_PAYLOAD_OFFSET_IPv4 ] );
|
|
pxDHCPMessage = ( ( DHCPMessage_IPv4_t * ) pucUDPPayloadBuffer );
|
|
|
|
/* Most fields need to be zero. */
|
|
( void ) memset( pxDHCPMessage, 0x00, sizeof( DHCPMessage_IPv4_t ) );
|
|
|
|
/* Create the message. */
|
|
pxDHCPMessage->ucOpcode = ( uint8_t ) xOpcode;
|
|
pxDHCPMessage->ucAddressType = ( uint8_t ) dhcpADDRESS_TYPE_ETHERNET;
|
|
pxDHCPMessage->ucAddressLength = ( uint8_t ) dhcpETHERNET_ADDRESS_LENGTH;
|
|
pxDHCPMessage->ulTransactionID = FreeRTOS_htonl( EP_DHCPData.ulTransactionId );
|
|
pxDHCPMessage->ulDHCPCookie = ( uint32_t ) dhcpCOOKIE;
|
|
|
|
if( EP_DHCPData.xUseBroadcast != pdFALSE )
|
|
{
|
|
pxDHCPMessage->usFlags = ( uint16_t ) dhcpBROADCAST;
|
|
}
|
|
else
|
|
{
|
|
pxDHCPMessage->usFlags = 0U;
|
|
}
|
|
|
|
( void ) memcpy( &( pxDHCPMessage->ucClientHardwareAddress[ 0 ] ), ipLOCAL_MAC_ADDRESS, sizeof( MACAddress_t ) );
|
|
|
|
/* Copy in the const part of the options options. */
|
|
( void ) memcpy( &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET ] ), pucOptionsArray, *pxOptionsArraySize );
|
|
|
|
#if ( ipconfigDHCP_REGISTER_HOSTNAME == 1 )
|
|
{
|
|
/* With this option, the hostname can be registered as well which makes
|
|
* it easier to lookup a device in a router's list of DHCP clients. */
|
|
|
|
/* Point to where the OPTION_END was stored to add data. */
|
|
pucPtr = &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + ( *pxOptionsArraySize - 1U ) ] );
|
|
pucPtr[ 0U ] = dhcpIPv4_DNS_HOSTNAME_OPTIONS_CODE;
|
|
pucPtr[ 1U ] = ( uint8_t ) uxNameLength;
|
|
|
|
/*
|
|
* Use helper variables for memcpy() to remain
|
|
* compliant with MISRA Rule 21.15. These should be
|
|
* optimized away.
|
|
*/
|
|
pvCopySource = pucHostName;
|
|
pvCopyDest = &pucPtr[ 2U ];
|
|
|
|
( void ) memcpy( pvCopyDest, pvCopySource, uxNameLength );
|
|
pucPtr[ 2U + uxNameLength ] = ( uint8_t ) dhcpOPTION_END_BYTE;
|
|
*pxOptionsArraySize += ( size_t ) ( 2U + uxNameLength );
|
|
}
|
|
#endif /* if ( ipconfigDHCP_REGISTER_HOSTNAME == 1 ) */
|
|
|
|
/* Map in the client identifier. */
|
|
( void ) memcpy( &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpCLIENT_IDENTIFIER_OFFSET ] ),
|
|
ipLOCAL_MAC_ADDRESS, sizeof( MACAddress_t ) );
|
|
|
|
/* Set the addressing. */
|
|
pxAddress->sin_addr = ipBROADCAST_IP_ADDRESS;
|
|
pxAddress->sin_port = ( uint16_t ) dhcpSERVER_PORT_IPv4;
|
|
}
|
|
|
|
return pucUDPPayloadBuffer;
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief Create and send a DHCP request message through the DHCP socket.
|
|
* @return Returns pdPASS when the message is successfully created and sent.
|
|
*/
|
|
static BaseType_t prvSendDHCPRequest( void )
|
|
{
|
|
BaseType_t xResult = pdFAIL;
|
|
uint8_t * pucUDPPayloadBuffer;
|
|
struct freertos_sockaddr xAddress;
|
|
static const uint8_t ucDHCPRequestOptions[] =
|
|
{
|
|
/* Do not change the ordering without also changing
|
|
* dhcpCLIENT_IDENTIFIER_OFFSET, dhcpREQUESTED_IP_ADDRESS_OFFSET and
|
|
* dhcpDHCP_SERVER_IP_ADDRESS_OFFSET. */
|
|
dhcpIPv4_MESSAGE_TYPE_OPTION_CODE, 1, dhcpMESSAGE_TYPE_REQUEST, /* Message type option. */
|
|
dhcpIPv4_CLIENT_IDENTIFIER_OPTION_CODE, 7, 1, 0, 0, 0, 0, 0, 0, /* Client identifier. */
|
|
dhcpIPv4_REQUEST_IP_ADDRESS_OPTION_CODE, 4, 0, 0, 0, 0, /* The IP address being requested. */
|
|
dhcpIPv4_SERVER_IP_ADDRESS_OPTION_CODE, 4, 0, 0, 0, 0, /* The IP address of the DHCP server. */
|
|
dhcpOPTION_END_BYTE
|
|
};
|
|
size_t uxOptionsLength = sizeof( ucDHCPRequestOptions );
|
|
/* memcpy() helper variables for MISRA Rule 21.15 compliance*/
|
|
const void * pvCopySource;
|
|
void * pvCopyDest;
|
|
|
|
pucUDPPayloadBuffer = prvCreatePartDHCPMessage( &xAddress,
|
|
( BaseType_t ) dhcpREQUEST_OPCODE,
|
|
ucDHCPRequestOptions,
|
|
&( uxOptionsLength ) );
|
|
|
|
if( pucUDPPayloadBuffer != NULL )
|
|
{
|
|
/* Copy in the IP address being requested. */
|
|
|
|
/*
|
|
* Use helper variables for memcpy() source & dest to remain
|
|
* compliant with MISRA Rule 21.15. These should be
|
|
* optimized away.
|
|
*/
|
|
pvCopySource = &EP_DHCPData.ulOfferedIPAddress;
|
|
pvCopyDest = &pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpREQUESTED_IP_ADDRESS_OFFSET ];
|
|
( void ) memcpy( pvCopyDest, pvCopySource, sizeof( EP_DHCPData.ulOfferedIPAddress ) );
|
|
|
|
/* Copy in the address of the DHCP server being used. */
|
|
pvCopySource = &EP_DHCPData.ulDHCPServerAddress;
|
|
pvCopyDest = &pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpDHCP_SERVER_IP_ADDRESS_OFFSET ];
|
|
( void ) memcpy( pvCopyDest, pvCopySource, sizeof( EP_DHCPData.ulDHCPServerAddress ) );
|
|
|
|
FreeRTOS_debug_printf( ( "vDHCPProcess: reply %xip\n", ( unsigned ) FreeRTOS_ntohl( EP_DHCPData.ulOfferedIPAddress ) ) );
|
|
iptraceSENDING_DHCP_REQUEST();
|
|
|
|
if( FreeRTOS_sendto( xDHCPSocket, pucUDPPayloadBuffer, sizeof( DHCPMessage_IPv4_t ) + uxOptionsLength, FREERTOS_ZERO_COPY, &xAddress, ( socklen_t ) sizeof( xAddress ) ) == 0 )
|
|
{
|
|
/* The packet was not successfully queued for sending and must be
|
|
* returned to the stack. */
|
|
FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayloadBuffer );
|
|
}
|
|
else
|
|
{
|
|
xResult = pdPASS;
|
|
}
|
|
}
|
|
|
|
return xResult;
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/**
|
|
* @brief Create and send a DHCP discover packet through the DHCP socket.
|
|
* @return Returns pdPASS when the message is successfully created and sent.
|
|
*/
|
|
static BaseType_t prvSendDHCPDiscover( void )
|
|
{
|
|
BaseType_t xResult = pdFAIL;
|
|
uint8_t * pucUDPPayloadBuffer;
|
|
struct freertos_sockaddr xAddress;
|
|
static const uint8_t ucDHCPDiscoverOptions[] =
|
|
{
|
|
/* Do not change the ordering without also changing dhcpCLIENT_IDENTIFIER_OFFSET. */
|
|
dhcpIPv4_MESSAGE_TYPE_OPTION_CODE, 1, dhcpMESSAGE_TYPE_DISCOVER, /* Message type option. */
|
|
dhcpIPv4_CLIENT_IDENTIFIER_OPTION_CODE, 7, 1, 0, 0, 0, 0, 0, 0, /* Client identifier. */
|
|
dhcpIPv4_REQUEST_IP_ADDRESS_OPTION_CODE, 4, 0, 0, 0, 0, /* The IP address being requested. */
|
|
dhcpIPv4_PARAMETER_REQUEST_OPTION_CODE, 3, dhcpIPv4_SUBNET_MASK_OPTION_CODE, dhcpIPv4_GATEWAY_OPTION_CODE, dhcpIPv4_DNS_SERVER_OPTIONS_CODE, /* Parameter request option. */
|
|
dhcpOPTION_END_BYTE
|
|
};
|
|
size_t uxOptionsLength = sizeof( ucDHCPDiscoverOptions );
|
|
|
|
pucUDPPayloadBuffer = prvCreatePartDHCPMessage( &xAddress,
|
|
( BaseType_t ) dhcpREQUEST_OPCODE,
|
|
ucDHCPDiscoverOptions,
|
|
&( uxOptionsLength ) );
|
|
|
|
if( pucUDPPayloadBuffer != NULL )
|
|
{
|
|
void * pvCopySource, * pvCopyDest;
|
|
|
|
FreeRTOS_debug_printf( ( "vDHCPProcess: discover\n" ) );
|
|
iptraceSENDING_DHCP_DISCOVER();
|
|
|
|
pvCopySource = &xDHCPData.ulPreferredIPAddress;
|
|
pvCopyDest = &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpREQUESTED_IP_ADDRESS_OFFSET ] );
|
|
( void ) memcpy( pvCopyDest, pvCopySource, sizeof( EP_DHCPData.ulPreferredIPAddress ) );
|
|
|
|
if( FreeRTOS_sendto( xDHCPSocket,
|
|
pucUDPPayloadBuffer,
|
|
sizeof( DHCPMessage_IPv4_t ) + uxOptionsLength,
|
|
FREERTOS_ZERO_COPY,
|
|
&( xAddress ),
|
|
( socklen_t ) sizeof( xAddress ) ) == 0 )
|
|
{
|
|
/* The packet was not successfully queued for sending and must be
|
|
* returned to the stack. */
|
|
FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayloadBuffer );
|
|
}
|
|
else
|
|
{
|
|
xResult = pdTRUE;
|
|
}
|
|
}
|
|
|
|
return xResult;
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
|
|
#if ( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 )
|
|
|
|
/**
|
|
* @brief When DHCP has failed, the code can assign a Link-Layer address, and check if
|
|
* another device already uses the IP-address.
|
|
*/
|
|
static void prvPrepareLinkLayerIPLookUp( void )
|
|
{
|
|
uint8_t ucLinkLayerIPAddress[ 2 ];
|
|
uint32_t ulNumbers[ 2 ];
|
|
|
|
/* After DHCP has failed to answer, prepare everything to start
|
|
* trying-out LinkLayer IP-addresses, using the random method. */
|
|
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
|
|
|
|
xApplicationGetRandomNumber( &( ulNumbers[ 0 ] ) );
|
|
xApplicationGetRandomNumber( &( ulNumbers[ 1 ] ) );
|
|
ucLinkLayerIPAddress[ 0 ] = ( uint8_t ) 1 + ( uint8_t ) ( ulNumbers[ 0 ] % 0xFDU ); /* get value 1..254 for IP-address 3rd byte of IP address to try. */
|
|
ucLinkLayerIPAddress[ 1 ] = ( uint8_t ) 1 + ( uint8_t ) ( ulNumbers[ 1 ] % 0xFDU ); /* get value 1..254 for IP-address 4th byte of IP address to try. */
|
|
|
|
EP_IPv4_SETTINGS.ulGatewayAddress = 0U;
|
|
|
|
/* prepare xDHCPData with data to test. */
|
|
EP_DHCPData.ulOfferedIPAddress =
|
|
FreeRTOS_inet_addr_quick( LINK_LAYER_ADDRESS_0, LINK_LAYER_ADDRESS_1, ucLinkLayerIPAddress[ 0 ], ucLinkLayerIPAddress[ 1 ] );
|
|
|
|
EP_DHCPData.ulLeaseTime = dhcpDEFAULT_LEASE_TIME; /* don't care about lease time. just put anything. */
|
|
|
|
EP_IPv4_SETTINGS.ulNetMask =
|
|
FreeRTOS_inet_addr_quick( LINK_LAYER_NETMASK_0, LINK_LAYER_NETMASK_1, LINK_LAYER_NETMASK_2, LINK_LAYER_NETMASK_3 );
|
|
|
|
/* DHCP completed. The IP address can now be used, and the
|
|
* timer set to the lease timeout time. */
|
|
*( ipLOCAL_IP_ADDRESS_POINTER ) = EP_DHCPData.ulOfferedIPAddress;
|
|
|
|
/* Setting the 'local' broadcast address, something like 192.168.1.255' */
|
|
EP_IPv4_SETTINGS.ulBroadcastAddress = ( EP_DHCPData.ulOfferedIPAddress & EP_IPv4_SETTINGS.ulNetMask ) | ~EP_IPv4_SETTINGS.ulNetMask;
|
|
|
|
/* Close socket to ensure packets don't queue on it. not needed anymore as DHCP failed. but still need timer for ARP testing. */
|
|
prvCloseDHCPSocket();
|
|
|
|
xApplicationGetRandomNumber( &( ulNumbers[ 0 ] ) );
|
|
EP_DHCPData.xDHCPTxPeriod = pdMS_TO_TICKS( 3000U + ( ulNumbers[ 0 ] & 0x3ffU ) ); /* do ARP test every (3 + 0-1024mS) seconds. */
|
|
|
|
xARPHadIPClash = pdFALSE; /* reset flag that shows if have ARP clash. */
|
|
vARPSendGratuitous();
|
|
}
|
|
|
|
#endif /* ipconfigDHCP_FALL_BACK_AUTO_IP */
|
|
/*-----------------------------------------------------------*/
|
|
|
|
#endif /* ipconfigUSE_DHCP != 0 */
|