/* * FreeRTOS+TCP V2.0.11 * Copyright (C) 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved. * * 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 */ /* Standard includes. */ #include /* 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_TCP_IP.h" #include "FreeRTOS_DHCP.h" #include "FreeRTOS_ARP.h" #include "NetworkInterface.h" #include "NetworkBufferManagement.h" /* Exclude the entire file if DHCP is not enabled. */ #if( ipconfigUSE_DHCP != 0 ) #if ( ipconfigUSE_DHCP != 0 ) && ( ipconfigNETWORK_MTU < 586u ) /* DHCP must be able to receive an options field of 312 bytes, the fixed part of the DHCP packet is 240 bytes, and the IP/UDP headers take 28 bytes. */ #error ipconfigNETWORK_MTU needs to be at least 586 to use DHCP #endif /* Parameter widths in the DHCP packet. */ #define dhcpCLIENT_HARDWARE_ADDRESS_LENGTH 16 #define dhcpSERVER_HOST_NAME_LENGTH 64 #define dhcpBOOT_FILE_NAME_LENGTH 128 /* Timer parameters */ #ifndef dhcpINITIAL_DHCP_TX_PERIOD #define dhcpINITIAL_TIMER_PERIOD ( pdMS_TO_TICKS( 250 ) ) #define dhcpINITIAL_DHCP_TX_PERIOD ( pdMS_TO_TICKS( 5000 ) ) #endif /* Codes of interest found in the DHCP options field. */ #define dhcpZERO_PAD_OPTION_CODE ( 0u ) #define dhcpSUBNET_MASK_OPTION_CODE ( 1u ) #define dhcpGATEWAY_OPTION_CODE ( 3u ) #define dhcpDNS_SERVER_OPTIONS_CODE ( 6u ) #define dhcpDNS_HOSTNAME_OPTIONS_CODE ( 12u ) #define dhcpREQUEST_IP_ADDRESS_OPTION_CODE ( 50u ) #define dhcpLEASE_TIME_OPTION_CODE ( 51u ) #define dhcpMESSAGE_TYPE_OPTION_CODE ( 53u ) #define dhcpSERVER_IP_ADDRESS_OPTION_CODE ( 54u ) #define dhcpPARAMETER_REQUEST_OPTION_CODE ( 55u ) #define dhcpCLIENT_IDENTIFIER_OPTION_CODE ( 61u ) /* The four DHCP message types of interest. */ #define dhcpMESSAGE_TYPE_DISCOVER ( 1 ) #define dhcpMESSAGE_TYPE_OFFER ( 2 ) #define dhcpMESSAGE_TYPE_REQUEST ( 3 ) #define dhcpMESSAGE_TYPE_ACK ( 5 ) #define dhcpMESSAGE_TYPE_NACK ( 6 ) /* Offsets into the transmitted DHCP options fields at which various parameters are located. */ #define dhcpCLIENT_IDENTIFIER_OFFSET ( 5 ) #define dhcpREQUESTED_IP_ADDRESS_OFFSET ( 13 ) #define dhcpDHCP_SERVER_IP_ADDRESS_OFFSET ( 19 ) /* Values used in the DHCP packets. */ #define dhcpREQUEST_OPCODE ( 1 ) #define dhcpREPLY_OPCODE ( 2 ) #define dhcpADDRESS_TYPE_ETHERNET ( 1 ) #define dhcpETHERNET_ADDRESS_LENGTH ( 6 ) /* If a lease time is not received, use the default of two days. */ /* 48 hours in ticks. Can not use pdMS_TO_TICKS() as integer overflow can occur. */ #define dhcpDEFAULT_LEASE_TIME ( ( 48UL * 60UL * 60UL ) * configTICK_RATE_HZ ) /* Don't allow the lease time to be too short. */ #define dhcpMINIMUM_LEASE_TIME ( pdMS_TO_TICKS( 60000UL ) ) /* 60 seconds in ticks. */ /* Marks the end of the variable length options field in the DHCP packet. */ #define dhcpOPTION_END_BYTE 0xffu /* Offset into a DHCP message at which the first byte of the options is located. */ #define dhcpFIRST_OPTION_BYTE_OFFSET ( 0xf0 ) /* When walking the variable length options field, the following value is used to ensure the walk has not gone past the end of the valid options. 2 bytes is made up of the length byte, and minimum one byte value. */ #define dhcpMAX_OPTION_LENGTH_OF_INTEREST ( 2L ) /* Standard DHCP port numbers and magic cookie value. */ #if( ipconfigBYTE_ORDER == pdFREERTOS_LITTLE_ENDIAN ) #define dhcpCLIENT_PORT 0x4400u #define dhcpSERVER_PORT 0x4300u #define dhcpCOOKIE 0x63538263ul #define dhcpBROADCAST 0x0080u #else #define dhcpCLIENT_PORT 0x0044u #define dhcpSERVER_PORT 0x0043u #define dhcpCOOKIE 0x63825363ul #define dhcpBROADCAST 0x8000u #endif /* ipconfigBYTE_ORDER */ #include "pack_struct_start.h" struct xDHCPMessage { uint8_t ucOpcode; uint8_t ucAddressType; uint8_t ucAddressLength; uint8_t ucHops; uint32_t ulTransactionID; uint16_t usElapsedTime; uint16_t usFlags; uint32_t ulClientIPAddress_ciaddr; uint32_t ulYourIPAddress_yiaddr; uint32_t ulServerIPAddress_siaddr; uint32_t ulRelayAgentIPAddress_giaddr; uint8_t ucClientHardwareAddress[ dhcpCLIENT_HARDWARE_ADDRESS_LENGTH ]; uint8_t ucServerHostName[ dhcpSERVER_HOST_NAME_LENGTH ]; uint8_t ucBootFileName[ dhcpBOOT_FILE_NAME_LENGTH ]; uint32_t ulDHCPCookie; uint8_t ucFirstOptionByte; } #include "pack_struct_end.h" typedef struct xDHCPMessage DHCPMessage_t; /* DHCP state machine states. */ typedef enum { eWaitingSendFirstDiscover = 0, /* Initial state. Send a discover the first time it is called, and reset all timers. */ eWaitingOffer, /* Either resend the discover, or, if the offer is forthcoming, send a request. */ eWaitingAcknowledge, /* Either resend the request. */ #if( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 ) eGetLinkLayerAddress, /* When DHCP didn't respond, try to obtain a LinkLayer address 168.254.x.x. */ #endif eLeasedAddress, /* Resend the request at the appropriate time to renew the lease. */ eNotUsingLeasedAddress /* DHCP failed, and a default IP address is being used. */ } eDHCPState_t; /* Hold information in between steps in the DHCP state machine. */ struct xDHCP_DATA { uint32_t ulTransactionId; uint32_t ulOfferedIPAddress; uint32_t ulDHCPServerAddress; uint32_t ulLeaseTime; /* Hold information on the current timer state. */ TickType_t xDHCPTxTime; TickType_t xDHCPTxPeriod; /* Try both without and with the broadcast flag */ BaseType_t xUseBroadcast; /* Maintains the DHCP state machine state. */ eDHCPState_t eDHCPState; /* The UDP socket used for all incoming and outgoing DHCP traffic. */ Socket_t xDHCPSocket; }; typedef struct xDHCP_DATA DHCPData_t; #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 void 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 void 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 ); /* * 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 /*-----------------------------------------------------------*/ /* The next DHCP transaction Id to be used. */ static DHCPData_t xDHCPData; /*-----------------------------------------------------------*/ BaseType_t xIsDHCPSocket( Socket_t xSocket ) { BaseType_t xReturn; if( xDHCPData.xDHCPSocket == xSocket ) { xReturn = pdTRUE; } else { xReturn = pdFALSE; } return xReturn; } /*-----------------------------------------------------------*/ void vDHCPProcess( BaseType_t xReset ) { BaseType_t xGivingUp = pdFALSE; #if( ipconfigUSE_DHCP_HOOK != 0 ) eDHCPCallbackAnswer_t eAnswer; #endif /* ipconfigUSE_DHCP_HOOK */ /* Is DHCP starting over? */ if( xReset != pdFALSE ) { xDHCPData.eDHCPState = eWaitingSendFirstDiscover; } switch( xDHCPData.eDHCPState ) { 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 */ { /* Initial state. Create the DHCP socket, timer, etc. if they have not already been created. */ prvInitialiseDHCP(); /* See if prvInitialiseDHCP() has creates a socket. */ if( xDHCPData.xDHCPSocket == NULL ) { xGivingUp = pdTRUE; break; } *ipLOCAL_IP_ADDRESS_POINTER = 0UL; /* Send the first discover request. */ if( xDHCPData.xDHCPSocket != NULL ) { xDHCPData.xDHCPTxTime = xTaskGetTickCount(); prvSendDHCPDiscover( ); xDHCPData.eDHCPState = eWaitingOffer; } } #if( ipconfigUSE_DHCP_HOOK != 0 ) else { if( eAnswer == eDHCPUseDefaults ) { memcpy( &xNetworkAddressing, &xDefaultAddressing, sizeof( xNetworkAddressing ) ); } /* The user indicates that the DHCP process does not continue. */ xGivingUp = pdTRUE; } #endif /* ipconfigUSE_DHCP_HOOK */ 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, xDHCPData.ulOfferedIPAddress ); if( eAnswer == eDHCPContinue ) #endif /* ipconfigUSE_DHCP_HOOK */ { /* An offer has been made, the user wants to continue, generate the request. */ xDHCPData.xDHCPTxTime = xTaskGetTickCount(); xDHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD; prvSendDHCPRequest( ); xDHCPData.eDHCPState = eWaitingAcknowledge; break; } #if( ipconfigUSE_DHCP_HOOK != 0 ) if( eAnswer == eDHCPUseDefaults ) { memcpy( &xNetworkAddressing, &xDefaultAddressing, sizeof( xNetworkAddressing ) ); } /* The user indicates that the DHCP process does not continue. */ xGivingUp = pdTRUE; #endif /* ipconfigUSE_DHCP_HOOK */ } else if( ( xTaskGetTickCount() - xDHCPData.xDHCPTxTime ) > xDHCPData.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. */ xDHCPData.xDHCPTxPeriod <<= 1; if( xDHCPData.xDHCPTxPeriod <= ipconfigMAXIMUM_DISCOVER_TX_PERIOD ) { xDHCPData.ulTransactionId = ipconfigRAND32( ); if( 0 != xDHCPData.ulTransactionId ) { xDHCPData.xDHCPTxTime = xTaskGetTickCount( ); xDHCPData.xUseBroadcast = !xDHCPData.xUseBroadcast; prvSendDHCPDiscover( ); FreeRTOS_debug_printf( ( "vDHCPProcess: timeout %lu ticks\n", xDHCPData.xDHCPTxPeriod ) ); } else { FreeRTOS_debug_printf( ( "vDHCPProcess: failed to generate a random Transaction ID\n" ) ); } } else { FreeRTOS_debug_printf( ( "vDHCPProcess: giving up %lu > %lu ticks\n", xDHCPData.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. */ xDHCPData.eDHCPState = eGetLinkLayerAddress; } #else { xGivingUp = pdTRUE; } #endif /* ipconfigDHCP_FALL_BACK_AUTO_IP */ } } break; case eWaitingAcknowledge : /* Look for acks coming in. */ if( prvProcessDHCPReplies( dhcpMESSAGE_TYPE_ACK ) == pdPASS ) { FreeRTOS_debug_printf( ( "vDHCPProcess: acked %lxip\n", FreeRTOS_ntohl( xDHCPData.ulOfferedIPAddress ) ) ); /* DHCP completed. The IP address can now be used, and the timer set to the lease timeout time. */ *ipLOCAL_IP_ADDRESS_POINTER = xDHCPData.ulOfferedIPAddress; /* Setting the 'local' broadcast address, something like '192.168.1.255'. */ xNetworkAddressing.ulBroadcastAddress = ( xDHCPData.ulOfferedIPAddress & xNetworkAddressing.ulNetMask ) | ~xNetworkAddressing.ulNetMask; xDHCPData.eDHCPState = eLeasedAddress; iptraceDHCP_SUCCEDEED( xDHCPData.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. */ vSocketClose( xDHCPData.xDHCPSocket ); xDHCPData.xDHCPSocket = NULL; if( xDHCPData.ulLeaseTime == 0UL ) { xDHCPData.ulLeaseTime = dhcpDEFAULT_LEASE_TIME; } else if( xDHCPData.ulLeaseTime < dhcpMINIMUM_LEASE_TIME ) { xDHCPData.ulLeaseTime = dhcpMINIMUM_LEASE_TIME; } else { /* The lease time is already valid. */ } /* Check for clashes. */ vARPSendGratuitous(); vIPReloadDHCPTimer( xDHCPData.ulLeaseTime ); } else { /* Is it time to send another Discover? */ if( ( xTaskGetTickCount() - xDHCPData.xDHCPTxTime ) > xDHCPData.xDHCPTxPeriod ) { /* Increase the time period, and if it has not got to the point of giving up - send another request. */ xDHCPData.xDHCPTxPeriod <<= 1; if( xDHCPData.xDHCPTxPeriod <= ipconfigMAXIMUM_DISCOVER_TX_PERIOD ) { xDHCPData.xDHCPTxTime = xTaskGetTickCount(); prvSendDHCPRequest( ); } else { /* Give up, start again. */ xDHCPData.eDHCPState = eWaitingSendFirstDiscover; } } } break; #if( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 ) case eGetLinkLayerAddress: if( ( xTaskGetTickCount() - xDHCPData.xDHCPTxTime ) > xDHCPData.xDHCPTxPeriod ) { if( xARPHadIPClash == pdFALSE ) { /* ARP OK. proceed. */ iptraceDHCP_SUCCEDEED( xDHCPData.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( ); xDHCPData.eDHCPState = eNotUsingLeasedAddress; } else { /* ARP clashed - try another IP address. */ prvPrepareLinkLayerIPLookUp(); /* Setting an IP address manually so set to not using leased address mode. */ xDHCPData.eDHCPState = eGetLinkLayerAddress; } } break; #endif /* ipconfigDHCP_FALL_BACK_AUTO_IP */ case eLeasedAddress : /* Resend the request at the appropriate time to renew the lease. */ prvCreateDHCPSocket(); if( xDHCPData.xDHCPSocket != NULL ) { xDHCPData.xDHCPTxTime = xTaskGetTickCount(); xDHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD; prvSendDHCPRequest( ); xDHCPData.eDHCPState = eWaitingAcknowledge; /* From now on, we should be called more often */ vIPReloadDHCPTimer( dhcpINITIAL_TIMER_PERIOD ); } break; case eNotUsingLeasedAddress: vIPSetDHCPTimerEnableState( pdFALSE ); break; default: 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 canceled 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(); xDHCPData.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( ); /* Test if socket was indeed created. */ if( xDHCPData.xDHCPSocket != NULL ) { /* Close socket to ensure packets don't queue on it. */ vSocketClose( xDHCPData.xDHCPSocket ); xDHCPData.xDHCPSocket = NULL; } } } /*-----------------------------------------------------------*/ 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( xDHCPData.xDHCPSocket == NULL ) { xDHCPData.xDHCPSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP ); if( xDHCPData.xDHCPSocket != FREERTOS_INVALID_SOCKET ) { /* Ensure the Rx and Tx timeouts are zero as the DHCP executes in the context of the IP task. */ FreeRTOS_setsockopt( xDHCPData.xDHCPSocket, 0, FREERTOS_SO_RCVTIMEO, ( void * ) &xTimeoutTime, sizeof( TickType_t ) ); FreeRTOS_setsockopt( xDHCPData.xDHCPSocket, 0, FREERTOS_SO_SNDTIMEO, ( void * ) &xTimeoutTime, sizeof( TickType_t ) ); /* Bind to the standard DHCP client port. */ xAddress.sin_port = ( uint16_t ) dhcpCLIENT_PORT; xReturn = vSocketBind( xDHCPData.xDHCPSocket, &xAddress, sizeof( xAddress ), pdFALSE ); if( xReturn != 0 ) { /* Binding failed, close the socket again. */ vSocketClose( xDHCPData.xDHCPSocket ); xDHCPData.xDHCPSocket = NULL; } } else { /* Change to NULL for easier testing. */ xDHCPData.xDHCPSocket = NULL; } } } /*-----------------------------------------------------------*/ 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. */ xDHCPData.ulTransactionId = ipconfigRAND32(); /* Check for random number generator API failure. */ if( 0 != xDHCPData.ulTransactionId ) { xDHCPData.xUseBroadcast = 0; xDHCPData.ulOfferedIPAddress = 0UL; xDHCPData.ulDHCPServerAddress = 0UL; xDHCPData.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 ) ); vIPReloadDHCPTimer( dhcpINITIAL_TIMER_PERIOD ); } } /*-----------------------------------------------------------*/ static BaseType_t prvProcessDHCPReplies( BaseType_t xExpectedMessageType ) { uint8_t *pucUDPPayload, *pucLastByte; struct freertos_sockaddr xClient; uint32_t xClientLength = sizeof( xClient ); int32_t lBytes; DHCPMessage_t *pxDHCPMessage; uint8_t *pucByte, ucOptionCode, ucLength; uint32_t ulProcessed, ulParameter; BaseType_t xReturn = pdFALSE; const uint32_t ulMandatoryOptions = 2ul; /* DHCP server address, and the correct DHCP message type must be present in the options. */ lBytes = FreeRTOS_recvfrom( xDHCPData.xDHCPSocket, ( void * ) &pucUDPPayload, 0ul, FREERTOS_ZERO_COPY, &xClient, &xClientLength ); if( lBytes > 0 ) { /* Map a DHCP structure onto the received data. */ pxDHCPMessage = ( DHCPMessage_t * ) ( pucUDPPayload ); /* Sanity check. */ if( ( lBytes >= sizeof( DHCPMessage_t ) ) && ( pxDHCPMessage->ulDHCPCookie == ( uint32_t ) dhcpCOOKIE ) && ( pxDHCPMessage->ucOpcode == ( uint8_t ) dhcpREPLY_OPCODE ) && ( pxDHCPMessage->ulTransactionID == FreeRTOS_htonl( xDHCPData.ulTransactionId ) ) ) { if( memcmp( ( void * ) &( pxDHCPMessage->ucClientHardwareAddress ), ( void * ) ipLOCAL_MAC_ADDRESS, sizeof( MACAddress_t ) ) == 0 ) { /* None of the essential options have been processed yet. */ ulProcessed = 0ul; /* Walk through the options until the dhcpOPTION_END_BYTE byte is found, taking care not to walk off the end of the options. */ pucByte = &( pxDHCPMessage->ucFirstOptionByte ); pucLastByte = &( pucUDPPayload[ lBytes - dhcpMAX_OPTION_LENGTH_OF_INTEREST ] ); while( pucByte < pucLastByte ) { ucOptionCode = pucByte[ 0 ]; if( ucOptionCode == dhcpOPTION_END_BYTE ) { /* Ready, the last byte has been seen. */ break; } if( ucOptionCode == dhcpZERO_PAD_OPTION_CODE ) { /* The value zero is used as a pad byte, it is not followed by a length byte. */ pucByte += 1; continue; } /* Stop if the response is malformed. */ if( pucByte < pucLastByte - 1 ) { ucLength = pucByte[ 1 ]; pucByte += 2; if( pucByte >= pucLastByte - ucLength ) { break; } } else { break; } /* In most cases, a 4-byte network-endian parameter follows, just get it once here and use later. */ if( ucLength >= sizeof( ulParameter ) ) { memcpy( ( void * ) &( ulParameter ), ( void * ) pucByte, ( size_t ) sizeof( ulParameter ) ); } else { ulParameter = 0; } /* Option-specific handling. */ switch( ucOptionCode ) { case dhcpMESSAGE_TYPE_OPTION_CODE : if( *pucByte == ( uint8_t ) xExpectedMessageType ) { /* The message type is the message type the state machine is expecting. */ ulProcessed++; } else if( *pucByte == ( uint8_t ) dhcpMESSAGE_TYPE_NACK ) { if( xExpectedMessageType == ( BaseType_t ) dhcpMESSAGE_TYPE_ACK ) { /* Start again. */ xDHCPData.eDHCPState = eWaitingSendFirstDiscover; } } else { /* Don't process other message types. */ } break; case dhcpSUBNET_MASK_OPTION_CODE : if( ucLength == sizeof( uint32_t ) ) { xNetworkAddressing.ulNetMask = ulParameter; } break; case dhcpGATEWAY_OPTION_CODE : if( ucLength == sizeof( uint32_t ) ) { /* ulProcessed is not incremented in this case because the gateway is not essential. */ xNetworkAddressing.ulGatewayAddress = ulParameter; } break; case dhcpDNS_SERVER_OPTIONS_CODE : /* ulProcessed is not incremented in this case because the DNS server is not essential. Only the first DNS server address is taken. */ xNetworkAddressing.ulDNSServerAddress = ulParameter; break; case dhcpSERVER_IP_ADDRESS_OPTION_CODE : if( ucLength == sizeof( uint32_t ) ) { if( xExpectedMessageType == ( BaseType_t ) dhcpMESSAGE_TYPE_OFFER ) { /* Offers state the replying server. */ ulProcessed++; xDHCPData.ulDHCPServerAddress = ulParameter; } else { /* The ack must come from the expected server. */ if( xDHCPData.ulDHCPServerAddress == ulParameter ) { ulProcessed++; } } } break; case dhcpLEASE_TIME_OPTION_CODE : if( ucLength == sizeof( xDHCPData.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. */ xDHCPData.ulLeaseTime = FreeRTOS_ntohl( ulParameter ); /* Divide the lease time by two to ensure a renew request is sent before the lease actually expires. */ xDHCPData.ulLeaseTime >>= 1UL; /* Multiply with configTICK_RATE_HZ to get clock ticks. */ xDHCPData.ulLeaseTime = configTICK_RATE_HZ * xDHCPData.ulLeaseTime; } break; default : /* Not interested in this field. */ break; } /* Jump over the data to find the next option code. */ if( ucLength == 0u ) { break; } else { pucByte += ucLength; } } /* Were all the mandatory options received? */ if( ulProcessed >= ulMandatoryOptions ) { /* HT:endian: used to be network order */ xDHCPData.ulOfferedIPAddress = pxDHCPMessage->ulYourIPAddress_yiaddr; FreeRTOS_printf( ( "vDHCPProcess: offer %lxip\n", FreeRTOS_ntohl( xDHCPData.ulOfferedIPAddress ) ) ); xReturn = pdPASS; } } } FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayload ); } return xReturn; } /*-----------------------------------------------------------*/ static uint8_t *prvCreatePartDHCPMessage( struct freertos_sockaddr *pxAddress, BaseType_t xOpcode, const uint8_t * const pucOptionsArray, size_t *pxOptionsArraySize ) { DHCPMessage_t *pxDHCPMessage; size_t xRequiredBufferSize = sizeof( DHCPMessage_t ) + *pxOptionsArraySize; uint8_t *pucUDPPayloadBuffer; #if( ipconfigDHCP_REGISTER_HOSTNAME == 1 ) const char *pucHostName = pcApplicationHostnameHook (); size_t xNameLength = strlen( pucHostName ); uint8_t *pucPtr; xRequiredBufferSize += ( 2 + xNameLength ); #endif /* Get a buffer. This uses a maximum delay, but the delay will be capped to ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS so the return value still needs to be test. */ do { } while( ( pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( xRequiredBufferSize, portMAX_DELAY ) ) == NULL ); pxDHCPMessage = ( DHCPMessage_t * ) pucUDPPayloadBuffer; /* Most fields need to be zero. */ memset( ( void * ) pxDHCPMessage, 0x00, sizeof( DHCPMessage_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( xDHCPData.ulTransactionId ); pxDHCPMessage->ulDHCPCookie = ( uint32_t ) dhcpCOOKIE; if( xDHCPData.xUseBroadcast != pdFALSE ) { pxDHCPMessage->usFlags = ( uint16_t ) dhcpBROADCAST; } else { pxDHCPMessage->usFlags = 0u; } memcpy( ( void * ) &( pxDHCPMessage->ucClientHardwareAddress[ 0 ] ), ( void * ) ipLOCAL_MAC_ADDRESS, sizeof( MACAddress_t ) ); /* Copy in the const part of the options options. */ memcpy( ( void * ) &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET ] ), ( void * ) 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 - 1 ) ] ); pucPtr[ 0 ] = dhcpDNS_HOSTNAME_OPTIONS_CODE; pucPtr[ 1 ] = ( uint8_t ) xNameLength; memcpy( ( void *) ( pucPtr + 2 ), pucHostName, xNameLength ); pucPtr[ 2 + xNameLength ] = dhcpOPTION_END_BYTE; *pxOptionsArraySize += ( 2 + xNameLength ); } #endif /* Map in the client identifier. */ memcpy( ( void * ) &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpCLIENT_IDENTIFIER_OFFSET ] ), ( void * ) ipLOCAL_MAC_ADDRESS, sizeof( MACAddress_t ) ); /* Set the addressing. */ pxAddress->sin_addr = ipBROADCAST_IP_ADDRESS; pxAddress->sin_port = ( uint16_t ) dhcpSERVER_PORT; return pucUDPPayloadBuffer; } /*-----------------------------------------------------------*/ static void prvSendDHCPRequest( void ) { 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. */ dhcpMESSAGE_TYPE_OPTION_CODE, 1, dhcpMESSAGE_TYPE_REQUEST, /* Message type option. */ dhcpCLIENT_IDENTIFIER_OPTION_CODE, 6, 0, 0, 0, 0, 0, 0, /* Client identifier. */ dhcpREQUEST_IP_ADDRESS_OPTION_CODE, 4, 0, 0, 0, 0, /* The IP address being requested. */ dhcpSERVER_IP_ADDRESS_OPTION_CODE, 4, 0, 0, 0, 0, /* The IP address of the DHCP server. */ dhcpOPTION_END_BYTE }; size_t xOptionsLength = sizeof( ucDHCPRequestOptions ); pucUDPPayloadBuffer = prvCreatePartDHCPMessage( &xAddress, dhcpREQUEST_OPCODE, ucDHCPRequestOptions, &xOptionsLength ); /* Copy in the IP address being requested. */ memcpy( ( void * ) &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpREQUESTED_IP_ADDRESS_OFFSET ] ), ( void * ) &( xDHCPData.ulOfferedIPAddress ), sizeof( xDHCPData.ulOfferedIPAddress ) ); /* Copy in the address of the DHCP server being used. */ memcpy( ( void * ) &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpDHCP_SERVER_IP_ADDRESS_OFFSET ] ), ( void * ) &( xDHCPData.ulDHCPServerAddress ), sizeof( xDHCPData.ulDHCPServerAddress ) ); FreeRTOS_debug_printf( ( "vDHCPProcess: reply %lxip\n", FreeRTOS_ntohl( xDHCPData.ulOfferedIPAddress ) ) ); iptraceSENDING_DHCP_REQUEST(); if( FreeRTOS_sendto( xDHCPData.xDHCPSocket, pucUDPPayloadBuffer, ( sizeof( DHCPMessage_t ) + xOptionsLength ), FREERTOS_ZERO_COPY, &xAddress, sizeof( xAddress ) ) == 0 ) { /* The packet was not successfully queued for sending and must be returned to the stack. */ FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayloadBuffer ); } } /*-----------------------------------------------------------*/ static void prvSendDHCPDiscover( void ) { uint8_t *pucUDPPayloadBuffer; struct freertos_sockaddr xAddress; static const uint8_t ucDHCPDiscoverOptions[] = { /* Do not change the ordering without also changing dhcpCLIENT_IDENTIFIER_OFFSET. */ dhcpMESSAGE_TYPE_OPTION_CODE, 1, dhcpMESSAGE_TYPE_DISCOVER, /* Message type option. */ dhcpCLIENT_IDENTIFIER_OPTION_CODE, 6, 0, 0, 0, 0, 0, 0, /* Client identifier. */ dhcpPARAMETER_REQUEST_OPTION_CODE, 3, dhcpSUBNET_MASK_OPTION_CODE, dhcpGATEWAY_OPTION_CODE, dhcpDNS_SERVER_OPTIONS_CODE, /* Parameter request option. */ dhcpOPTION_END_BYTE }; size_t xOptionsLength = sizeof( ucDHCPDiscoverOptions ); pucUDPPayloadBuffer = prvCreatePartDHCPMessage( &xAddress, dhcpREQUEST_OPCODE, ucDHCPDiscoverOptions, &xOptionsLength ); FreeRTOS_debug_printf( ( "vDHCPProcess: discover\n" ) ); iptraceSENDING_DHCP_DISCOVER(); if( FreeRTOS_sendto( xDHCPData.xDHCPSocket, pucUDPPayloadBuffer, ( sizeof( DHCPMessage_t ) + xOptionsLength ), FREERTOS_ZERO_COPY, &xAddress, sizeof( xAddress ) ) == 0 ) { /* The packet was not successfully queued for sending and must be returned to the stack. */ FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayloadBuffer ); } } /*-----------------------------------------------------------*/ #if( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 ) static void prvPrepareLinkLayerIPLookUp( void ) { uint8_t ucLinkLayerIPAddress[ 2 ]; /* After DHCP has failed to answer, prepare everything to start trying-out LinkLayer IP-addresses, using the random method. */ xDHCPData.xDHCPTxTime = xTaskGetTickCount(); ucLinkLayerIPAddress[ 0 ] = ( uint8_t )1 + ( uint8_t )( ipconfigRAND32() % 0xFDu ); /* get value 1..254 for IP-address 3rd byte of IP address to try. */ ucLinkLayerIPAddress[ 1 ] = ( uint8_t )1 + ( uint8_t )( ipconfigRAND32() % 0xFDu ); /* get value 1..254 for IP-address 4th byte of IP address to try. */ xNetworkAddressing.ulGatewayAddress = FreeRTOS_htonl( 0xA9FE0203 ); /* prepare xDHCPData with data to test. */ xDHCPData.ulOfferedIPAddress = FreeRTOS_inet_addr_quick( LINK_LAYER_ADDRESS_0, LINK_LAYER_ADDRESS_1, ucLinkLayerIPAddress[ 0 ], ucLinkLayerIPAddress[ 1 ] ); xDHCPData.ulLeaseTime = dhcpDEFAULT_LEASE_TIME; /* don't care about lease time. just put anything. */ xNetworkAddressing.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 = xDHCPData.ulOfferedIPAddress; /* Setting the 'local' broadcast address, something like 192.168.1.255' */ xNetworkAddressing.ulBroadcastAddress = ( xDHCPData.ulOfferedIPAddress & xNetworkAddressing.ulNetMask ) | ~xNetworkAddressing.ulNetMask; /* Close socket to ensure packets don't queue on it. not needed anymore as DHCP failed. but still need timer for ARP testing. */ vSocketClose( xDHCPData.xDHCPSocket ); xDHCPData.xDHCPSocket = NULL; xDHCPData.xDHCPTxPeriod = pdMS_TO_TICKS( 3000ul + ( ipconfigRAND32() & 0x3fful ) ); /* 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 */