X-Git-Url: https://git.sur5r.net/?p=freertos;a=blobdiff_plain;f=FreeRTOS-Plus%2FSource%2FFreeRTOS-Plus-TCP%2FFreeRTOS_DNS.c;fp=FreeRTOS-Plus%2FSource%2FFreeRTOS-Plus-TCP%2FFreeRTOS_DNS.c;h=43b246d26dd9be2d5aba76625fa103621dbed623;hp=465bdd3f149ff1a58ae1199f62e545d0f7064a6f;hb=e9388d7834fdede42a6cf93794dab4f3a302fcde;hpb=d6457d5167afcaf663d7afc0d835e7bd5ab0964f diff --git a/FreeRTOS-Plus/Source/FreeRTOS-Plus-TCP/FreeRTOS_DNS.c b/FreeRTOS-Plus/Source/FreeRTOS-Plus-TCP/FreeRTOS_DNS.c index 465bdd3f1..43b246d26 100644 --- a/FreeRTOS-Plus/Source/FreeRTOS-Plus-TCP/FreeRTOS_DNS.c +++ b/FreeRTOS-Plus/Source/FreeRTOS-Plus-TCP/FreeRTOS_DNS.c @@ -1,5 +1,5 @@ /* - * FreeRTOS+TCP V2.0.11 + * FreeRTOS+TCP V2.2.0 * 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 @@ -47,58 +47,58 @@ #if( ipconfigUSE_DNS != 0 ) #if( ipconfigBYTE_ORDER == pdFREERTOS_LITTLE_ENDIAN ) - #define dnsDNS_PORT 0x3500 - #define dnsONE_QUESTION 0x0100 - #define dnsOUTGOING_FLAGS 0x0001 /* Standard query. */ - #define dnsRX_FLAGS_MASK 0x0f80 /* The bits of interest in the flags field of incoming DNS messages. */ - #define dnsEXPECTED_RX_FLAGS 0x0080 /* Should be a response, without any errors. */ + #define dnsDNS_PORT 0x3500u + #define dnsONE_QUESTION 0x0100u + #define dnsOUTGOING_FLAGS 0x0001u /* Standard query. */ + #define dnsRX_FLAGS_MASK 0x0f80u /* The bits of interest in the flags field of incoming DNS messages. */ + #define dnsEXPECTED_RX_FLAGS 0x0080u /* Should be a response, without any errors. */ #else - #define dnsDNS_PORT 0x0035 - #define dnsONE_QUESTION 0x0001 - #define dnsOUTGOING_FLAGS 0x0100 /* Standard query. */ - #define dnsRX_FLAGS_MASK 0x800f /* The bits of interest in the flags field of incoming DNS messages. */ - #define dnsEXPECTED_RX_FLAGS 0x8000 /* Should be a response, without any errors. */ + #define dnsDNS_PORT 0x0035u + #define dnsONE_QUESTION 0x0001u + #define dnsOUTGOING_FLAGS 0x0100u /* Standard query. */ + #define dnsRX_FLAGS_MASK 0x800fu /* The bits of interest in the flags field of incoming DNS messages. */ + #define dnsEXPECTED_RX_FLAGS 0x8000u /* Should be a response, without any errors. */ #endif /* ipconfigBYTE_ORDER */ /* The maximum number of times a DNS request should be sent out if a response is not received, before giving up. */ #ifndef ipconfigDNS_REQUEST_ATTEMPTS - #define ipconfigDNS_REQUEST_ATTEMPTS 5 + #define ipconfigDNS_REQUEST_ATTEMPTS 5 #endif /* If the top two bits in the first character of a name field are set then the name field is an offset to the string, rather than the string itself. */ -#define dnsNAME_IS_OFFSET ( ( uint8_t ) 0xc0 ) +#define dnsNAME_IS_OFFSET ( ( uint8_t ) 0xc0 ) /* NBNS flags. */ -#define dnsNBNS_FLAGS_RESPONSE 0x8000 -#define dnsNBNS_FLAGS_OPCODE_MASK 0x7800 -#define dnsNBNS_FLAGS_OPCODE_QUERY 0x0000 -#define dnsNBNS_FLAGS_OPCODE_REGISTRATION 0x2800 +#define dnsNBNS_FLAGS_RESPONSE 0x8000u +#define dnsNBNS_FLAGS_OPCODE_MASK 0x7800u +#define dnsNBNS_FLAGS_OPCODE_QUERY 0x0000u +#define dnsNBNS_FLAGS_OPCODE_REGISTRATION 0x2800u /* Host types. */ -#define dnsTYPE_A_HOST 0x01 -#define dnsCLASS_IN 0x01 +#define dnsTYPE_A_HOST 0x01u +#define dnsCLASS_IN 0x01u /* LLMNR constants. */ -#define dnsLLMNR_TTL_VALUE 300000 -#define dnsLLMNR_FLAGS_IS_REPONSE 0x8000 +#define dnsLLMNR_TTL_VALUE 300000uL +#define dnsLLMNR_FLAGS_IS_REPONSE 0x8000u /* NBNS constants. */ -#define dnsNBNS_TTL_VALUE 3600 /* 1 hour valid */ -#define dnsNBNS_TYPE_NET_BIOS 0x0020 -#define dnsNBNS_CLASS_IN 0x01 -#define dnsNBNS_NAME_FLAGS 0x6000 -#define dnsNBNS_ENCODED_NAME_LENGTH 32 +#define dnsNBNS_TTL_VALUE 3600uL /* 1 hour valid */ +#define dnsNBNS_TYPE_NET_BIOS 0x0020u +#define dnsNBNS_CLASS_IN 0x01u +#define dnsNBNS_NAME_FLAGS 0x6000u +#define dnsNBNS_ENCODED_NAME_LENGTH 32 /* If the queried NBNS name matches with the device's name, the query will be responded to with these flags: */ -#define dnsNBNS_QUERY_RESPONSE_FLAGS ( 0x8500 ) +#define dnsNBNS_QUERY_RESPONSE_FLAGS ( 0x8500u ) /* Flag DNS parsing errors in situations where an IPv4 address is the return type. */ -#define dnsPARSE_ERROR 0UL +#define dnsPARSE_ERROR 0uL /* * Create a socket and bind it to the standard DNS port number. Return the @@ -109,44 +109,66 @@ static Socket_t prvCreateDNSSocket( void ); /* * Create the DNS message in the zero copy buffer passed in the first parameter. */ -static size_t prvCreateDNSMessage( uint8_t *pucUDPPayloadBuffer, const char *pcHostName, TickType_t xIdentifier ); +static size_t prvCreateDNSMessage( uint8_t *pucUDPPayloadBuffer, + const char *pcHostName, + TickType_t uxIdentifier ); /* * Simple routine that jumps over the NAME field of a resource record. */ -static uint8_t *prvSkipNameField( uint8_t *pucByte, size_t xSourceLen ); +static uint8_t * prvSkipNameField( uint8_t *pucByte, + size_t uxSourceLen ); /* * Process a response packet from a DNS server. + * The parameter 'xExpected' indicates whether the identifier in the reply + * was expected, and thus if the DNS cache may be updated with the reply. */ -static uint32_t prvParseDNSReply( uint8_t *pucUDPPayloadBuffer, size_t xBufferLength, TickType_t xIdentifier ); +static uint32_t prvParseDNSReply( uint8_t *pucUDPPayloadBuffer, + size_t uxBufferLength, + BaseType_t xExpected ); /* - * Prepare and send a message to a DNS server. 'xReadTimeOut_ms' will be passed as + * Prepare and send a message to a DNS server. 'uxReadTimeOut_ticks' will be passed as * zero, in case the user has supplied a call-back function. */ -static uint32_t prvGetHostByName( const char *pcHostName, TickType_t xIdentifier, TickType_t xReadTimeOut_ms ); +static uint32_t prvGetHostByName( const char *pcHostName, + TickType_t uxIdentifier, + TickType_t uxReadTimeOut_ticks ); /* * The NBNS and the LLMNR protocol share this reply function. */ #if( ( ipconfigUSE_NBNS == 1 ) || ( ipconfigUSE_LLMNR == 1 ) ) - static void prvReplyDNSMessage( NetworkBufferDescriptor_t *pxNetworkBuffer, BaseType_t lNetLength ); + static void prvReplyDNSMessage( NetworkBufferDescriptor_t *pxNetworkBuffer, + BaseType_t lNetLength ); #endif #if( ipconfigUSE_NBNS == 1 ) - static portINLINE void prvTreatNBNS( uint8_t *pucUDPPayloadBuffer, size_t xBufferLength, uint32_t ulIPAddress ); + static portINLINE void prvTreatNBNS( uint8_t *pucUDPPayloadBuffer, + size_t uxBufferLength, + uint32_t ulIPAddress ); #endif /* ipconfigUSE_NBNS */ + +#if( ipconfigUSE_DNS_CACHE == 1 ) || ( ipconfigDNS_USE_CALLBACKS == 1 ) + static uint8_t * prvReadNameField( uint8_t *pucByte, + size_t uxSourceLen, + char *pcName, + size_t uxLen ); +#endif /* ipconfigUSE_DNS_CACHE || ipconfigDNS_USE_CALLBACKS */ + #if( ipconfigUSE_DNS_CACHE == 1 ) - static uint8_t *prvReadNameField( uint8_t *pucByte, size_t xSourceLen, char *pcName, size_t xLen ); - static void prvProcessDNSCache( const char *pcName, uint32_t *pulIP, uint32_t ulTTL, BaseType_t xLookUp ); + static void prvProcessDNSCache( const char *pcName, + uint32_t *pulIP, + uint32_t ulTTL, + BaseType_t xLookUp ); typedef struct xDNS_CACHE_TABLE_ROW { - uint32_t ulIPAddress; /* The IP address of an ARP cache entry. */ - char pcName[ ipconfigDNS_CACHE_NAME_LENGTH ]; /* The name of the host */ - uint32_t ulTTL; /* Time-to-Live (in seconds) from the DNS server. */ + uint32_t ulIPAddress; /* The IP address of an ARP cache entry. */ + char pcName[ ipconfigDNS_CACHE_NAME_LENGTH ]; /* The name of the host */ + uint32_t ulTTL; /* Time-to-Live (in seconds) from the DNS server. */ uint32_t ulTimeWhenAddedInSeconds; } DNSCacheRow_t; @@ -160,7 +182,7 @@ static uint32_t prvGetHostByName( const char *pcHostName, TickType_t xIdentifier #if( ipconfigUSE_LLMNR == 1 ) const MACAddress_t xLLMNR_MacAdress = { { 0x01, 0x00, 0x5e, 0x00, 0x00, 0xfc } }; -#endif /* ipconfigUSE_LLMNR == 1 */ +#endif /* ipconfigUSE_LLMNR == 1 */ /*-----------------------------------------------------------*/ @@ -208,7 +230,7 @@ typedef struct xDNSAnswerRecord DNSAnswerRecord_t; struct xLLMNRAnswer { uint8_t ucNameCode; - uint8_t ucNameOffset; /* The name is not repeated in the answer, only the offset is given with "0xc0 " */ + uint8_t ucNameOffset; /* The name is not repeated in the answer, only the offset is given with "0xc0 " */ uint16_t usType; uint16_t usClass; uint32_t ulTTL; @@ -247,32 +269,34 @@ typedef struct xDNSAnswerRecord DNSAnswerRecord_t; uint16_t usClass; uint32_t ulTTL; uint16_t usDataLength; - uint16_t usNbFlags; /* NetBIOS flags 0x6000 : IP-address, big-endian */ + uint16_t usNbFlags; /* NetBIOS flags 0x6000 : IP-address, big-endian */ uint32_t ulIPAddress; } #include "pack_struct_end.h" typedef struct xNBNSAnswer NBNSAnswer_t; -#endif /* ipconfigUSE_NBNS == 1 */ + #endif /* ipconfigUSE_NBNS == 1 */ /*-----------------------------------------------------------*/ #if( ipconfigUSE_DNS_CACHE == 1 ) uint32_t FreeRTOS_dnslookup( const char *pcHostName ) { - uint32_t ulIPAddress = 0UL; + uint32_t ulIPAddress = 0uL; + prvProcessDNSCache( pcHostName, &ulIPAddress, 0, pdTRUE ); return ulIPAddress; } #endif /* ipconfigUSE_DNS_CACHE == 1 */ /*-----------------------------------------------------------*/ -#if( ipconfigDNS_USE_CALLBACKS != 0 ) +#if( ipconfigDNS_USE_CALLBACKS == 1 ) - typedef struct xDNS_Callback { - TickType_t xRemaningTime; /* Timeout in ms */ + typedef struct xDNS_Callback + { + TickType_t uxRemaningTime; /* Timeout in ms */ FOnDNSEvent pCallbackFunction; /* Function to be called when the address has been found or when a timeout has beeen reached */ - TimeOut_t xTimeoutState; + TimeOut_t uxTimeoutState; void *pvSearchID; struct xLIST_ITEM xListItem; char pcName[ 1 ]; @@ -283,7 +307,7 @@ typedef struct xDNSAnswerRecord DNSAnswerRecord_t; /* Define FreeRTOS_gethostbyname() as a normal blocking call. */ uint32_t FreeRTOS_gethostbyname( const char *pcHostName ) { - return FreeRTOS_gethostbyname_a( pcHostName, ( FOnDNSEvent ) NULL, ( void* )NULL, 0 ); + return FreeRTOS_gethostbyname_a( pcHostName, ( FOnDNSEvent ) NULL, ( void * ) NULL, 0 ); } /*-----------------------------------------------------------*/ @@ -304,23 +328,25 @@ typedef struct xDNSAnswerRecord DNSAnswerRecord_t; void vDNSCheckCallBack( void *pvSearchID ) { const ListItem_t *pxIterator; - const MiniListItem_t* xEnd = ( const MiniListItem_t* )listGET_END_MARKER( &xCallbackList ); + const MiniListItem_t * xEnd = ( const MiniListItem_t * ) listGET_END_MARKER( &xCallbackList ); vTaskSuspendAll(); { for( pxIterator = ( const ListItem_t * ) listGET_NEXT( xEnd ); pxIterator != ( const ListItem_t * ) xEnd; - ) + ) { - DNSCallback_t *pxCallback = ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator ); + DNSCallback_t *pxCallback = ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator ); + /* Move to the next item because we might remove this item */ - pxIterator = ( const ListItem_t * ) listGET_NEXT( pxIterator ); + pxIterator = ( const ListItem_t * ) listGET_NEXT( pxIterator ); + if( ( pvSearchID != NULL ) && ( pvSearchID == pxCallback->pvSearchID ) ) { uxListRemove( &pxCallback->xListItem ); vPortFree( pxCallback ); } - else if( xTaskCheckForTimeOut( &pxCallback->xTimeoutState, &pxCallback->xRemaningTime ) != pdFALSE ) + else if( xTaskCheckForTimeOut( &pxCallback->uxTimeoutState, &pxCallback->uxRemaningTime ) != pdFALSE ) { pxCallback->pCallbackFunction( pxCallback->pcName, pxCallback->pvSearchID, 0 ); uxListRemove( &pxCallback->xListItem ); @@ -346,28 +372,38 @@ typedef struct xDNSAnswerRecord DNSAnswerRecord_t; /* FreeRTOS_gethostbyname_a() was called along with callback parameters. Store them in a list for later reference. */ - static void vDNSSetCallBack( const char *pcHostName, void *pvSearchID, FOnDNSEvent pCallbackFunction, TickType_t xTimeout, TickType_t xIdentifier ); - static void vDNSSetCallBack( const char *pcHostName, void *pvSearchID, FOnDNSEvent pCallbackFunction, TickType_t xTimeout, TickType_t xIdentifier ) + static void vDNSSetCallBack( const char *pcHostName, + void *pvSearchID, + FOnDNSEvent pCallbackFunction, + TickType_t uxTimeout, + TickType_t uxIdentifier ); + static void vDNSSetCallBack( const char *pcHostName, + void *pvSearchID, + FOnDNSEvent pCallbackFunction, + TickType_t uxTimeout, + TickType_t uxIdentifier ) { - size_t lLength = strlen( pcHostName ); - DNSCallback_t *pxCallback = ( DNSCallback_t * )pvPortMalloc( sizeof( *pxCallback ) + lLength ); + size_t lLength = strlen( pcHostName ); + DNSCallback_t *pxCallback = ( DNSCallback_t * ) pvPortMalloc( sizeof( *pxCallback ) + lLength ); /* Translate from ms to number of clock ticks. */ - xTimeout /= portTICK_PERIOD_MS; + uxTimeout /= portTICK_PERIOD_MS; + if( pxCallback != NULL ) { if( listLIST_IS_EMPTY( &xCallbackList ) ) { /* This is the first one, start the DNS timer to check for timeouts */ - vIPReloadDNSTimer( FreeRTOS_min_uint32( 1000U, xTimeout ) ); + vIPReloadDNSTimer( FreeRTOS_min_uint32( 1000U, uxTimeout ) ); } + strcpy( pxCallback->pcName, pcHostName ); pxCallback->pCallbackFunction = pCallbackFunction; pxCallback->pvSearchID = pvSearchID; - pxCallback->xRemaningTime = xTimeout; - vTaskSetTimeOutState( &pxCallback->xTimeoutState ); - listSET_LIST_ITEM_OWNER( &( pxCallback->xListItem ), ( void* ) pxCallback ); - listSET_LIST_ITEM_VALUE( &( pxCallback->xListItem ), xIdentifier ); + pxCallback->uxRemaningTime = uxTimeout; + vTaskSetTimeOutState( &pxCallback->uxTimeoutState ); + listSET_LIST_ITEM_OWNER( &( pxCallback->xListItem ), ( void * ) pxCallback ); + listSET_LIST_ITEM_VALUE( &( pxCallback->xListItem ), uxIdentifier ); vTaskSuspendAll(); { vListInsertEnd( &xCallbackList, &pxCallback->xListItem ); @@ -378,12 +414,17 @@ typedef struct xDNSAnswerRecord DNSAnswerRecord_t; /*-----------------------------------------------------------*/ /* A DNS reply was received, see if there is any matching entry and - call the handler. */ - static void vDNSDoCallback( TickType_t xIdentifier, const char *pcName, uint32_t ulIPAddress ); - static void vDNSDoCallback( TickType_t xIdentifier, const char *pcName, uint32_t ulIPAddress ) + call the handler. Returns pdTRUE if uxIdentifier was recognised. */ + static BaseType_t xDNSDoCallback( TickType_t uxIdentifier, + const char *pcName, + uint32_t ulIPAddress ); + static BaseType_t xDNSDoCallback( TickType_t uxIdentifier, + const char *pcName, + uint32_t ulIPAddress ) { - const ListItem_t *pxIterator; - const MiniListItem_t* xEnd = ( const MiniListItem_t* )listGET_END_MARKER( &xCallbackList ); + BaseType_t xResult = pdFALSE; + const ListItem_t *pxIterator; + const MiniListItem_t * xEnd = ( const MiniListItem_t * ) listGET_END_MARKER( &xCallbackList ); vTaskSuspendAll(); { @@ -391,111 +432,132 @@ typedef struct xDNSAnswerRecord DNSAnswerRecord_t; pxIterator != ( const ListItem_t * ) xEnd; pxIterator = ( const ListItem_t * ) listGET_NEXT( pxIterator ) ) { - if( listGET_LIST_ITEM_VALUE( pxIterator ) == xIdentifier ) + /* The cast will take away the 'configLIST_VOLATILE' */ + if( uxIdentifier == ( TickType_t ) listGET_LIST_ITEM_VALUE( pxIterator ) ) { - DNSCallback_t *pxCallback = ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator ); + DNSCallback_t *pxCallback = ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator ); + pxCallback->pCallbackFunction( pcName, pxCallback->pvSearchID, ulIPAddress ); uxListRemove( &pxCallback->xListItem ); vPortFree( pxCallback ); + if( listLIST_IS_EMPTY( &xCallbackList ) ) { + /* The list of outstanding requests is empty. No need for periodic polling. */ vIPSetDnsTimerEnableState( pdFALSE ); } + + xResult = pdTRUE; break; } } } xTaskResumeAll(); + return xResult; } -#endif /* ipconfigDNS_USE_CALLBACKS != 0 */ +#endif /* ipconfigDNS_USE_CALLBACKS == 1 */ /*-----------------------------------------------------------*/ #if( ipconfigDNS_USE_CALLBACKS == 0 ) -uint32_t FreeRTOS_gethostbyname( const char *pcHostName ) + uint32_t FreeRTOS_gethostbyname( const char *pcHostName ) #else -uint32_t FreeRTOS_gethostbyname_a( const char *pcHostName, FOnDNSEvent pCallback, void *pvSearchID, TickType_t xTimeout ) + uint32_t FreeRTOS_gethostbyname_a( const char *pcHostName, + FOnDNSEvent pCallback, + void *pvSearchID, + TickType_t uxTimeout ) #endif { -uint32_t ulIPAddress = 0UL; -TickType_t xReadTimeOut_ms = ipconfigSOCK_DEFAULT_RECEIVE_BLOCK_TIME; -TickType_t xIdentifier = 0; +uint32_t ulIPAddress = 0uL; +TickType_t uxReadTimeOut_ticks = ipconfigDNS_RECEIVE_BLOCK_TIME_TICKS; +TickType_t uxIdentifier = 0u; +BaseType_t xHasRandom = pdFALSE; - /* If the supplied hostname is IP address, convert it to uint32_t - and return. */ - #if( ipconfigINCLUDE_FULL_INET_ADDR == 1 ) + if( pcHostName != NULL ) { - ulIPAddress = FreeRTOS_inet_addr( pcHostName ); - } - #endif /* ipconfigINCLUDE_FULL_INET_ADDR == 1 */ + /* If the supplied hostname is IP address, convert it to uint32_t + and return. */ + #if( ipconfigINCLUDE_FULL_INET_ADDR == 1 ) + { + ulIPAddress = FreeRTOS_inet_addr( pcHostName ); + } + #endif /* ipconfigINCLUDE_FULL_INET_ADDR == 1 */ - /* If a DNS cache is used then check the cache before issuing another DNS - request. */ - #if( ipconfigUSE_DNS_CACHE == 1 ) - { - if( ulIPAddress == 0UL ) + /* If a DNS cache is used then check the cache before issuing another DNS + request. */ + #if( ipconfigUSE_DNS_CACHE == 1 ) { - ulIPAddress = FreeRTOS_dnslookup( pcHostName ); - if( ulIPAddress != 0 ) + if( ulIPAddress == 0uL ) { - FreeRTOS_debug_printf( ( "FreeRTOS_gethostbyname: found '%s' in cache: %lxip\n", pcHostName, ulIPAddress ) ); - } - else - { - /* prvGetHostByName will be called to start a DNS lookup */ + ulIPAddress = FreeRTOS_dnslookup( pcHostName ); + + if( ulIPAddress != 0 ) + { + FreeRTOS_debug_printf( ( "FreeRTOS_gethostbyname: found '%s' in cache: %lxip\n", pcHostName, ulIPAddress ) ); + } + else + { + /* prvGetHostByName will be called to start a DNS lookup. */ + } } } - } - #endif /* ipconfigUSE_DNS_CACHE == 1 */ + #endif /* ipconfigUSE_DNS_CACHE == 1 */ - /* Generate a unique identifier. */ - if( 0 == ulIPAddress ) - { - xIdentifier = ( TickType_t )ipconfigRAND32( ); - } + /* Generate a unique identifier. */ + if( ulIPAddress == 0uL ) + { + uint32_t ulNumber; - #if( ipconfigDNS_USE_CALLBACKS != 0 ) - { - if( pCallback != NULL ) + xHasRandom = xApplicationGetRandomNumber( &( ulNumber ) ); + /* DNS identifiers are 16-bit. */ + uxIdentifier = ( TickType_t ) ( ulNumber & 0xffffu ); + /* ipconfigRAND32() may not return a non-zero value. */ + } + + #if( ipconfigDNS_USE_CALLBACKS == 1 ) { - if( ulIPAddress == 0UL ) + if( pCallback != NULL ) { - /* The user has provided a callback function, so do not block on recvfrom() */ - if( 0 != xIdentifier ) + if( ulIPAddress == 0uL ) { - xReadTimeOut_ms = 0; - vDNSSetCallBack( pcHostName, pvSearchID, pCallback, xTimeout, ( TickType_t )xIdentifier ); + /* The user has provided a callback function, so do not block on recvfrom() */ + if( xHasRandom != pdFALSE ) + { + uxReadTimeOut_ticks = 0u; + vDNSSetCallBack( pcHostName, pvSearchID, pCallback, uxTimeout, uxIdentifier ); + } + } + else + { + /* The IP address is known, do the call-back now. */ + pCallback( pcHostName, pvSearchID, ulIPAddress ); } - } - else - { - /* The IP address is known, do the call-back now. */ - pCallback( pcHostName, pvSearchID, ulIPAddress ); } } - } - #endif + #endif /* if ( ipconfigDNS_USE_CALLBACKS == 1 ) */ - if( ( ulIPAddress == 0UL ) && ( 0 != xIdentifier ) ) - { - ulIPAddress = prvGetHostByName( pcHostName, xIdentifier, xReadTimeOut_ms ); + if( ( ulIPAddress == 0uL ) && ( xHasRandom != pdFALSE ) ) + { + ulIPAddress = prvGetHostByName( pcHostName, uxIdentifier, uxReadTimeOut_ticks ); + } } - return ulIPAddress; } /*-----------------------------------------------------------*/ -static uint32_t prvGetHostByName( const char *pcHostName, TickType_t xIdentifier, TickType_t xReadTimeOut_ms ) +static uint32_t prvGetHostByName( const char *pcHostName, + TickType_t uxIdentifier, + TickType_t uxReadTimeOut_ticks ) { struct freertos_sockaddr xAddress; Socket_t xDNSSocket; -uint32_t ulIPAddress = 0UL; +uint32_t ulIPAddress = 0uL; uint8_t *pucUDPPayloadBuffer; uint32_t ulAddressLength = sizeof( struct freertos_sockaddr ); BaseType_t xAttempt; int32_t lBytes; -size_t xPayloadLength, xExpectedPayloadLength; -TickType_t xWriteTimeOut_ms = ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME; +size_t uxPayloadLength, uxExpectedPayloadLength; +TickType_t uxWriteTimeOut_ticks = ipconfigDNS_SEND_BLOCK_TIME_TICKS; #if( ipconfigUSE_LLMNR == 1 ) BaseType_t bHasDot = pdFALSE; @@ -505,7 +567,8 @@ TickType_t xWriteTimeOut_ms = ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME; if not then LLMNR can be used as the lookup method. */ #if( ipconfigUSE_LLMNR == 1 ) { - const char *pucPtr; + const char *pucPtr; + for( pucPtr = pcHostName; *pucPtr; pucPtr++ ) { if( *pucPtr == '.' ) @@ -519,26 +582,26 @@ TickType_t xWriteTimeOut_ms = ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME; /* Two is added at the end for the count of characters in the first subdomain part and the string end byte. */ - xExpectedPayloadLength = sizeof( DNSMessage_t ) + strlen( pcHostName ) + sizeof( uint16_t ) + sizeof( uint16_t ) + 2u; + uxExpectedPayloadLength = sizeof( DNSMessage_t ) + strlen( pcHostName ) + sizeof( uint16_t ) + sizeof( uint16_t ) + 2u; xDNSSocket = prvCreateDNSSocket(); if( xDNSSocket != NULL ) { - FreeRTOS_setsockopt( xDNSSocket, 0, FREERTOS_SO_SNDTIMEO, ( void * ) &xWriteTimeOut_ms, sizeof( TickType_t ) ); - FreeRTOS_setsockopt( xDNSSocket, 0, FREERTOS_SO_RCVTIMEO, ( void * ) &xReadTimeOut_ms, sizeof( TickType_t ) ); + FreeRTOS_setsockopt( xDNSSocket, 0, FREERTOS_SO_SNDTIMEO, ( void * ) &uxWriteTimeOut_ticks, sizeof( TickType_t ) ); + FreeRTOS_setsockopt( xDNSSocket, 0, FREERTOS_SO_RCVTIMEO, ( void * ) &uxReadTimeOut_ticks, sizeof( TickType_t ) ); for( xAttempt = 0; xAttempt < ipconfigDNS_REQUEST_ATTEMPTS; xAttempt++ ) { /* 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 tested. */ - pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( xExpectedPayloadLength, portMAX_DELAY ); + pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( uxExpectedPayloadLength, portMAX_DELAY ); if( pucUDPPayloadBuffer != NULL ) { /* Create the message in the obtained buffer. */ - xPayloadLength = prvCreateDNSMessage( pucUDPPayloadBuffer, pcHostName, xIdentifier ); + uxPayloadLength = prvCreateDNSMessage( pucUDPPayloadBuffer, pcHostName, uxIdentifier ); iptraceSENDING_DNS_REQUEST(); @@ -550,8 +613,8 @@ TickType_t xWriteTimeOut_ms = ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME; if( bHasDot == pdFALSE ) { /* Use LLMNR addressing. */ - ( ( DNSMessage_t * ) pucUDPPayloadBuffer) -> usFlags = 0; - xAddress.sin_addr = ipLLMNR_IP_ADDR; /* Is in network byte order. */ + ( ( DNSMessage_t * ) pucUDPPayloadBuffer )->usFlags = 0; + xAddress.sin_addr = ipLLMNR_IP_ADDR; /* Is in network byte order. */ xAddress.sin_port = FreeRTOS_ntohs( ipLLMNR_PORT ); } else @@ -562,24 +625,45 @@ TickType_t xWriteTimeOut_ms = ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME; xAddress.sin_port = dnsDNS_PORT; } - ulIPAddress = 0UL; + ulIPAddress = 0uL; - if( FreeRTOS_sendto( xDNSSocket, pucUDPPayloadBuffer, xPayloadLength, FREERTOS_ZERO_COPY, &xAddress, sizeof( xAddress ) ) != 0 ) + if( FreeRTOS_sendto( xDNSSocket, pucUDPPayloadBuffer, uxPayloadLength, FREERTOS_ZERO_COPY, &xAddress, sizeof( xAddress ) ) != 0 ) { /* Wait for the reply. */ lBytes = FreeRTOS_recvfrom( xDNSSocket, &pucUDPPayloadBuffer, 0, FREERTOS_ZERO_COPY, &xAddress, &ulAddressLength ); if( lBytes > 0 ) { + BaseType_t xExpected; + DNSMessage_t *pxDNSMessageHeader = ( DNSMessage_t * ) pucUDPPayloadBuffer; + + /* See if the identifiers match. */ + if( uxIdentifier == ( TickType_t ) pxDNSMessageHeader->usIdentifier ) + { + xExpected = pdTRUE; + } + else + { + /* The reply was not expected. */ + xExpected = pdFALSE; + } + /* The reply was received. Process it. */ - ulIPAddress = prvParseDNSReply( pucUDPPayloadBuffer, lBytes, xIdentifier ); + #if( ipconfigDNS_USE_CALLBACKS == 0 ) + /* It is useless to analyse the unexpected reply + unless asynchronous look-ups are enabled. */ + if( xExpected != pdFALSE ) + #endif /* ipconfigDNS_USE_CALLBACKS == 0 */ + { + ulIPAddress = prvParseDNSReply( pucUDPPayloadBuffer, ( size_t ) lBytes, xExpected ); + } /* Finished with the buffer. The zero copy interface is being used, so the buffer must be freed by the task. */ FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayloadBuffer ); - if( ulIPAddress != 0UL ) + if( ulIPAddress != 0uL ) { /* All done. */ break; @@ -593,6 +677,13 @@ TickType_t xWriteTimeOut_ms = ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME; FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayloadBuffer ); } } + + if( uxReadTimeOut_ticks == 0u ) + { + /* This DNS lookup is asynchronous, using a call-back: + send the request only once. */ + break; + } } /* Finished with the socket. */ @@ -603,19 +694,21 @@ TickType_t xWriteTimeOut_ms = ipconfigSOCK_DEFAULT_SEND_BLOCK_TIME; } /*-----------------------------------------------------------*/ -static size_t prvCreateDNSMessage( uint8_t *pucUDPPayloadBuffer, const char *pcHostName, TickType_t xIdentifier ) +static size_t prvCreateDNSMessage( uint8_t *pucUDPPayloadBuffer, + const char *pcHostName, + TickType_t uxIdentifier ) { DNSMessage_t *pxDNSMessageHeader; uint8_t *pucStart, *pucByte; DNSTail_t *pxTail; static const DNSMessage_t xDefaultPartDNSHeader = { - 0, /* The identifier will be overwritten. */ - dnsOUTGOING_FLAGS, /* Flags set for standard query. */ - dnsONE_QUESTION, /* One question is being asked. */ - 0, /* No replies are included. */ - 0, /* No authorities. */ - 0 /* No additional authorities. */ + 0, /* The identifier will be overwritten. */ + dnsOUTGOING_FLAGS, /* Flags set for standard query. */ + dnsONE_QUESTION, /* One question is being asked. */ + 0, /* No replies are included. */ + 0, /* No authorities. */ + 0 /* No additional authorities. */ }; /* Copy in the const part of the header. */ @@ -623,7 +716,7 @@ static const DNSMessage_t xDefaultPartDNSHeader = /* Write in a unique identifier. */ pxDNSMessageHeader = ( DNSMessage_t * ) pucUDPPayloadBuffer; - pxDNSMessageHeader->usIdentifier = ( uint16_t ) xIdentifier; + pxDNSMessageHeader->usIdentifier = ( uint16_t ) uxIdentifier; /* Create the resource record at the end of the header. First find the end of the header. */ @@ -659,15 +752,14 @@ static const DNSMessage_t xDefaultPartDNSHeader = ( *pucStart )--; pucStart = pucByte; - } while( *pucByte != 0x00 ); /* Finish off the record. */ - pxTail = (DNSTail_t *)( pucByte + 1 ); + pxTail = ( DNSTail_t * ) ( pucByte + 1 ); - vSetField16( pxTail, DNSTail_t, usType, dnsTYPE_A_HOST ); /* Type A: host */ - vSetField16( pxTail, DNSTail_t, usClass, dnsCLASS_IN ); /* 1: Class IN */ + vSetField16( pxTail, DNSTail_t, usType, dnsTYPE_A_HOST ); /* Type A: host */ + vSetField16( pxTail, DNSTail_t, usClass, dnsCLASS_IN ); /* 1: Class IN */ /* Return the total size of the generated message, which is the space from the last written byte to the beginning of the buffer. */ @@ -675,14 +767,17 @@ static const DNSMessage_t xDefaultPartDNSHeader = } /*-----------------------------------------------------------*/ -#if( ipconfigUSE_DNS_CACHE == 1 ) +#if( ipconfigUSE_DNS_CACHE == 1 ) || ( ipconfigDNS_USE_CALLBACKS == 1 ) - static uint8_t *prvReadNameField( uint8_t *pucByte, size_t xSourceLen, char *pcName, size_t xDestLen ) + static uint8_t * prvReadNameField( uint8_t *pucByte, + size_t uxSourceLen, + char *pcName, + size_t uxDestLen ) { - size_t xNameLen = 0; + size_t uxNameLen = 0; BaseType_t xCount; - if( 0 == xSourceLen ) + if( 0 == uxSourceLen ) { return NULL; } @@ -692,7 +787,7 @@ static const DNSMessage_t xDefaultPartDNSHeader = if( ( *pucByte & dnsNAME_IS_OFFSET ) == dnsNAME_IS_OFFSET ) { /* Jump over the two byte offset. */ - if( xSourceLen > sizeof( uint16_t ) ) + if( uxSourceLen > sizeof( uint16_t ) ) { pucByte += sizeof( uint16_t ); } @@ -704,23 +799,23 @@ static const DNSMessage_t xDefaultPartDNSHeader = else { /* pucByte points to the full name. Walk over the string. */ - while( ( NULL != pucByte ) && ( *pucByte != 0x00 ) && ( xSourceLen > 1 ) ) + while( ( NULL != pucByte ) && ( *pucByte != 0x00u ) && ( uxSourceLen > 1u ) ) { /* If this is not the first time through the loop, then add a separator in the output. */ - if( ( xNameLen > 0 ) && ( xNameLen < ( xDestLen - 1 ) ) ) + if( ( uxNameLen > 0 ) && ( uxNameLen < ( uxDestLen - 1u ) ) ) { - pcName[ xNameLen++ ] = '.'; + pcName[ uxNameLen++ ] = '.'; } /* Process the first/next sub-string. */ - for( xCount = *(pucByte++), xSourceLen--; - xCount-- && xSourceLen > 1; - pucByte++, xSourceLen-- ) + for( xCount = *( pucByte++ ), uxSourceLen--; + xCount-- && uxSourceLen > 1u; + pucByte++, uxSourceLen-- ) { - if( xNameLen < xDestLen - 1 ) + if( uxNameLen < uxDestLen - 1u ) { - pcName[ xNameLen++ ] = *( ( char * )pucByte ); + pcName[ uxNameLen++ ] = *( ( char * ) pucByte ); } else { @@ -737,8 +832,8 @@ static const DNSMessage_t xDefaultPartDNSHeader = if( 0x00 == *pucByte ) { pucByte++; - xSourceLen--; - pcName[ xNameLen++ ] = '\0'; + uxSourceLen--; + pcName[ uxNameLen++ ] = '\0'; } else { @@ -749,14 +844,15 @@ static const DNSMessage_t xDefaultPartDNSHeader = return pucByte; } -#endif /* ipconfigUSE_DNS_CACHE == 1 */ +#endif /* ipconfigUSE_DNS_CACHE || ipconfigDNS_USE_CALLBACKS */ /*-----------------------------------------------------------*/ -static uint8_t *prvSkipNameField( uint8_t *pucByte, size_t xSourceLen ) +static uint8_t * prvSkipNameField( uint8_t *pucByte, + size_t uxSourceLen ) { - size_t xChunkLength; +size_t uxChunkLength; - if( 0 == xSourceLen ) + if( 0u == uxSourceLen ) { return NULL; } @@ -766,7 +862,7 @@ static uint8_t *prvSkipNameField( uint8_t *pucByte, size_t xSourceLen ) if( ( *pucByte & dnsNAME_IS_OFFSET ) == dnsNAME_IS_OFFSET ) { /* Jump over the two byte offset. */ - if( xSourceLen > sizeof( uint16_t ) ) + if( uxSourceLen > sizeof( uint16_t ) ) { pucByte += sizeof( uint16_t ); } @@ -778,14 +874,14 @@ static uint8_t *prvSkipNameField( uint8_t *pucByte, size_t xSourceLen ) else { /* pucByte points to the full name. Walk over the string. */ - while( ( *pucByte != 0x00 ) && ( xSourceLen > 1 ) ) + while( ( *pucByte != 0x00u ) && ( uxSourceLen > 1u ) ) { - xChunkLength = *pucByte + 1; + uxChunkLength = *pucByte + 1u; - if( xSourceLen > xChunkLength ) + if( uxSourceLen > uxChunkLength ) { - xSourceLen -= xChunkLength; - pucByte += xChunkLength; + uxSourceLen -= uxChunkLength; + pucByte += uxChunkLength; } else { @@ -797,7 +893,7 @@ static uint8_t *prvSkipNameField( uint8_t *pucByte, size_t xSourceLen ) /* Confirm that a fully formed name was found. */ if( NULL != pucByte ) { - if( 0x00 == *pucByte ) + if( 0x00u == *pucByte ) { pucByte++; } @@ -812,19 +908,33 @@ static uint8_t *prvSkipNameField( uint8_t *pucByte, size_t xSourceLen ) } /*-----------------------------------------------------------*/ +/* The function below will only be called : +when ipconfigDNS_USE_CALLBACKS == 1 +when ipconfigUSE_LLMNR == 1 +for testing purposes, by the module iot_test_freertos_tcp.c +*/ uint32_t ulDNSHandlePacket( NetworkBufferDescriptor_t *pxNetworkBuffer ) { DNSMessage_t *pxDNSMessageHeader; - - if( pxNetworkBuffer->xDataLength >= sizeof( DNSMessage_t ) ) - { - pxDNSMessageHeader = - ( DNSMessage_t * )( pxNetworkBuffer->pucEthernetBuffer + sizeof( UDPPacket_t ) ); - - prvParseDNSReply( ( uint8_t * )pxDNSMessageHeader, - pxNetworkBuffer->xDataLength, - ( uint32_t )pxDNSMessageHeader->usIdentifier ); - } +size_t uxPayloadSize; + + /* Only proceed if the payload length indicated in the header + appears to be valid. */ + if( pxNetworkBuffer->xDataLength >= sizeof( UDPPacket_t ) ) + { + uxPayloadSize = pxNetworkBuffer->xDataLength - sizeof( UDPPacket_t ); + + if( uxPayloadSize >= sizeof( DNSMessage_t ) ) + { + pxDNSMessageHeader = + ( DNSMessage_t * ) ( pxNetworkBuffer->pucEthernetBuffer + sizeof( UDPPacket_t ) ); + + /* The parameter pdFALSE indicates that the reply was not expected. */ + prvParseDNSReply( ( uint8_t * ) pxDNSMessageHeader, + uxPayloadSize, + pdFALSE ); + } + } /* The packet was not consumed. */ return pdFAIL; @@ -833,15 +943,16 @@ DNSMessage_t *pxDNSMessageHeader; #if( ipconfigUSE_NBNS == 1 ) - uint32_t ulNBNSHandlePacket (NetworkBufferDescriptor_t *pxNetworkBuffer ) + uint32_t ulNBNSHandlePacket( NetworkBufferDescriptor_t * pxNetworkBuffer ) { UDPPacket_t *pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer; uint8_t *pucUDPPayloadBuffer = pxNetworkBuffer->pucEthernetBuffer + sizeof( UDPPacket_t ); + size_t uxPayloadSize = pxNetworkBuffer->xDataLength - sizeof( UDPPacket_t ); - /* The network buffer data length has already been set to the + /* The network buffer data length has already been set to the length of the UDP payload. */ prvTreatNBNS( pucUDPPayloadBuffer, - pxNetworkBuffer->xDataLength, + uxPayloadSize, pxUDPPacket->xIPHeader.ulSourceIPAddress ); /* The packet was not consumed. */ @@ -851,45 +962,48 @@ DNSMessage_t *pxDNSMessageHeader; #endif /* ipconfigUSE_NBNS */ /*-----------------------------------------------------------*/ -static uint32_t prvParseDNSReply( uint8_t *pucUDPPayloadBuffer, size_t xBufferLength, TickType_t xIdentifier ) +static uint32_t prvParseDNSReply( uint8_t *pucUDPPayloadBuffer, + size_t uxBufferLength, + BaseType_t xExpected ) { DNSMessage_t *pxDNSMessageHeader; DNSAnswerRecord_t *pxDNSAnswerRecord; -uint32_t ulIPAddress = 0UL; +uint32_t ulIPAddress = 0uL; #if( ipconfigUSE_LLMNR == 1 ) char *pcRequestedName = NULL; #endif uint8_t *pucByte; -size_t xSourceBytesRemaining; +size_t uxSourceBytesRemaining; uint16_t x, usDataLength, usQuestions; +BaseType_t xDoStore = xExpected; #if( ipconfigUSE_LLMNR == 1 ) uint16_t usType = 0, usClass = 0; #endif -#if( ipconfigUSE_DNS_CACHE == 1 ) +#if( ipconfigUSE_DNS_CACHE == 1 ) || ( ipconfigDNS_USE_CALLBACKS == 1 ) char pcName[ ipconfigDNS_CACHE_NAME_LENGTH ] = ""; #endif /* Ensure that the buffer is of at least minimal DNS message length. */ - if( xBufferLength < sizeof( DNSMessage_t ) ) + if( uxBufferLength < sizeof( DNSMessage_t ) ) { return dnsPARSE_ERROR; } - else - { - xSourceBytesRemaining = xBufferLength; - } + + uxSourceBytesRemaining = uxBufferLength; /* Parse the DNS message header. */ pxDNSMessageHeader = ( DNSMessage_t * ) pucUDPPayloadBuffer; - if( pxDNSMessageHeader->usIdentifier == ( uint16_t ) xIdentifier ) + /* Introduce a do {} while (0) to allow the use of breaks. */ + do { /* Start at the first byte after the header. */ pucByte = pucUDPPayloadBuffer + sizeof( DNSMessage_t ); - xSourceBytesRemaining -= sizeof( DNSMessage_t ); + uxSourceBytesRemaining -= sizeof( DNSMessage_t ); /* Skip any question records. */ usQuestions = FreeRTOS_ntohs( pxDNSMessageHeader->usQuestions ); + for( x = 0; x < usQuestions; x++ ) { #if( ipconfigUSE_LLMNR == 1 ) @@ -901,11 +1015,11 @@ uint16_t x, usDataLength, usQuestions; } #endif -#if( ipconfigUSE_DNS_CACHE == 1 ) +#if( ipconfigUSE_DNS_CACHE == 1 ) || ( ipconfigDNS_USE_CALLBACKS == 1 ) if( x == 0 ) { pucByte = prvReadNameField( pucByte, - xSourceBytesRemaining, + uxSourceBytesRemaining, pcName, sizeof( pcName ) ); @@ -914,35 +1028,32 @@ uint16_t x, usDataLength, usQuestions; { return dnsPARSE_ERROR; } - else - { - xSourceBytesRemaining = ( pucUDPPayloadBuffer + xBufferLength ) - pucByte; - } + + uxSourceBytesRemaining = ( pucUDPPayloadBuffer + uxBufferLength ) - pucByte; } else -#endif /* ipconfigUSE_DNS_CACHE */ +#endif /* ipconfigUSE_DNS_CACHE || ipconfigDNS_USE_CALLBACKS */ { /* Skip the variable length pcName field. */ pucByte = prvSkipNameField( pucByte, - xSourceBytesRemaining ); + uxSourceBytesRemaining ); /* Check for a malformed response. */ if( NULL == pucByte ) { return dnsPARSE_ERROR; } - else - { - xSourceBytesRemaining = pucUDPPayloadBuffer + xBufferLength - pucByte; - } + + uxSourceBytesRemaining = ( size_t ) + ( pucUDPPayloadBuffer + uxBufferLength - pucByte ); } /* Check the remaining buffer size. */ - if( xSourceBytesRemaining >= sizeof( uint32_t ) ) + if( uxSourceBytesRemaining >= sizeof( uint32_t ) ) { #if( ipconfigUSE_LLMNR == 1 ) { - /* usChar2u16 returns value in host endianness */ + /* usChar2u16 returns value in host endianness. */ usType = usChar2u16( pucByte ); usClass = usChar2u16( pucByte + 2 ); } @@ -950,7 +1061,7 @@ uint16_t x, usDataLength, usQuestions; /* Skip the type and class fields. */ pucByte += sizeof( uint32_t ); - xSourceBytesRemaining -= sizeof( uint32_t ); + uxSourceBytesRemaining -= sizeof( uint32_t ); } else { @@ -967,25 +1078,24 @@ uint16_t x, usDataLength, usQuestions; for( x = 0; x < pxDNSMessageHeader->usAnswers; x++ ) { pucByte = prvSkipNameField( pucByte, - xSourceBytesRemaining ); + uxSourceBytesRemaining ); /* Check for a malformed response. */ if( NULL == pucByte ) { return dnsPARSE_ERROR; } - else - { - xSourceBytesRemaining = pucUDPPayloadBuffer + xBufferLength - pucByte; - } + + uxSourceBytesRemaining = ( size_t ) + ( pucUDPPayloadBuffer + uxBufferLength - pucByte ); /* Is there enough data for an IPv4 A record answer and, if so, is this an A record? */ - if( xSourceBytesRemaining >= sizeof( DNSAnswerRecord_t ) + sizeof( uint32_t ) && - usChar2u16( pucByte ) == dnsTYPE_A_HOST ) + if( ( uxSourceBytesRemaining >= ( sizeof( DNSAnswerRecord_t ) + sizeof( uint32_t ) ) ) && + ( usChar2u16( pucByte ) == dnsTYPE_A_HOST ) ) { /* This is the required record type and is of sufficient size. */ - pxDNSAnswerRecord = ( DNSAnswerRecord_t * )pucByte; + pxDNSAnswerRecord = ( DNSAnswerRecord_t * ) pucByte; /* Sanity check the data length of an IPv4 answer. */ if( FreeRTOS_ntohs( pxDNSAnswerRecord->usDataLength ) == sizeof( uint32_t ) ) @@ -995,39 +1105,56 @@ uint16_t x, usDataLength, usQuestions; pucByte + sizeof( DNSAnswerRecord_t ), sizeof( uint32_t ) ); - #if( ipconfigUSE_DNS_CACHE == 1 ) + #if( ipconfigDNS_USE_CALLBACKS == 1 ) { - prvProcessDNSCache( pcName, &ulIPAddress, pxDNSAnswerRecord->ulTTL, pdFALSE ); + /* See if any asynchronous call was made to FreeRTOS_gethostbyname_a() */ + if( xDNSDoCallback( ( TickType_t ) pxDNSMessageHeader->usIdentifier, pcName, ulIPAddress ) != pdFALSE ) + { + /* This device has requested this DNS look-up. + The result may be stored in the DNS cache. */ + xDoStore = pdTRUE; + } } - #endif /* ipconfigUSE_DNS_CACHE */ - #if( ipconfigDNS_USE_CALLBACKS != 0 ) + #endif /* ipconfigDNS_USE_CALLBACKS == 1 */ + #if( ipconfigUSE_DNS_CACHE == 1 ) { - /* See if any asynchronous call was made to FreeRTOS_gethostbyname_a() */ - vDNSDoCallback( ( TickType_t ) pxDNSMessageHeader->usIdentifier, pcName, ulIPAddress ); + /* The reply will only be stored in the DNS cache when the + request was issued by this device. */ + if( xDoStore != pdFALSE ) + { + prvProcessDNSCache( pcName, &ulIPAddress, pxDNSAnswerRecord->ulTTL, pdFALSE ); + } + + /* Show what has happened. */ + FreeRTOS_printf( ( "DNS[0x%04X]: The answer to '%s' (%xip) will%s be stored\n", + ( unsigned ) pxDNSMessageHeader->usIdentifier, + pcName, + ( unsigned ) FreeRTOS_ntohl( ulIPAddress ), + ( xDoStore != 0 ) ? "" : " NOT" ) ); } - #endif /* ipconfigDNS_USE_CALLBACKS != 0 */ + #endif /* ipconfigUSE_DNS_CACHE */ } pucByte += sizeof( DNSAnswerRecord_t ) + sizeof( uint32_t ); - xSourceBytesRemaining -= ( sizeof( DNSAnswerRecord_t ) + sizeof( uint32_t ) ); + uxSourceBytesRemaining -= ( sizeof( DNSAnswerRecord_t ) + sizeof( uint32_t ) ); break; } - else if( xSourceBytesRemaining >= sizeof( DNSAnswerRecord_t ) ) + else if( uxSourceBytesRemaining >= sizeof( DNSAnswerRecord_t ) ) { /* It's not an A record, so skip it. Get the header location and then jump over the header. */ - pxDNSAnswerRecord = ( DNSAnswerRecord_t * )pucByte; + pxDNSAnswerRecord = ( DNSAnswerRecord_t * ) pucByte; pucByte += sizeof( DNSAnswerRecord_t ); - xSourceBytesRemaining -= sizeof( DNSAnswerRecord_t ); + uxSourceBytesRemaining -= sizeof( DNSAnswerRecord_t ); /* Determine the length of the answer data from the header. */ usDataLength = FreeRTOS_ntohs( pxDNSAnswerRecord->usDataLength ); /* Jump over the answer. */ - if( xSourceBytesRemaining >= usDataLength ) + if( uxSourceBytesRemaining >= usDataLength ) { pucByte += usDataLength; - xSourceBytesRemaining -= usDataLength; + uxSourceBytesRemaining -= usDataLength; } else { @@ -1037,12 +1164,13 @@ uint16_t x, usDataLength, usQuestions; } } } + #if( ipconfigUSE_LLMNR == 1 ) else if( usQuestions && ( usType == dnsTYPE_A_HOST ) && ( usClass == dnsCLASS_IN ) ) { /* If this is not a reply to our DNS request, it might an LLMNR request. */ - if( xApplicationDNSQueryHook ( ( pcRequestedName + 1 ) ) ) + if( xApplicationDNSQueryHook( ( pcRequestedName + 1 ) ) ) { int16_t usLength; NetworkBufferDescriptor_t *pxNewBuffer = NULL; @@ -1051,13 +1179,12 @@ uint16_t x, usDataLength, usQuestions; if( ( xBufferAllocFixedSize == pdFALSE ) && ( pxNetworkBuffer != NULL ) ) { - BaseType_t xDataLength = xBufferLength + sizeof( UDPHeader_t ) + sizeof( EthernetHeader_t ) + sizeof( IPHeader_t ); + BaseType_t xDataLength = uxBufferLength + sizeof( UDPHeader_t ) + sizeof( EthernetHeader_t ) + sizeof( IPHeader_t ); - /* The field xDataLength was set to the length of the UDP payload. - The answer (reply) will be longer than the request, so the packet - must be duplicaed into a bigger buffer */ + /* Set the size of the outgoing packet. */ pxNetworkBuffer->xDataLength = xDataLength; - pxNewBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, xDataLength + 16 ); + pxNewBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, xDataLength + sizeof( LLMNRAnswer_t ) ); + if( pxNewBuffer != NULL ) { BaseType_t xOffset1, xOffset2; @@ -1071,7 +1198,6 @@ uint16_t x, usDataLength, usQuestions; pucByte = pucUDPPayloadBuffer + xOffset1; pcRequestedName = ( char * ) ( pucUDPPayloadBuffer + xOffset2 ); pxDNSMessageHeader = ( DNSMessage_t * ) pucUDPPayloadBuffer; - } else { @@ -1079,21 +1205,22 @@ uint16_t x, usDataLength, usQuestions; pxNetworkBuffer = NULL; } } + if( pxNetworkBuffer != NULL ) { - pxAnswer = (LLMNRAnswer_t *)pucByte; + pxAnswer = ( LLMNRAnswer_t * ) pucByte; /* We leave 'usIdentifier' and 'usQuestions' untouched */ - vSetField16( pxDNSMessageHeader, DNSMessage_t, usFlags, dnsLLMNR_FLAGS_IS_REPONSE ); /* Set the response flag */ - vSetField16( pxDNSMessageHeader, DNSMessage_t, usAnswers, 1 ); /* Provide a single answer */ - vSetField16( pxDNSMessageHeader, DNSMessage_t, usAuthorityRRs, 0 ); /* No authority */ - vSetField16( pxDNSMessageHeader, DNSMessage_t, usAdditionalRRs, 0 ); /* No additional info */ + vSetField16( pxDNSMessageHeader, DNSMessage_t, usFlags, dnsLLMNR_FLAGS_IS_REPONSE ); /* Set the response flag */ + vSetField16( pxDNSMessageHeader, DNSMessage_t, usAnswers, 1 ); /* Provide a single answer */ + vSetField16( pxDNSMessageHeader, DNSMessage_t, usAuthorityRRs, 0 ); /* No authority */ + vSetField16( pxDNSMessageHeader, DNSMessage_t, usAdditionalRRs, 0 ); /* No additional info */ pxAnswer->ucNameCode = dnsNAME_IS_OFFSET; - pxAnswer->ucNameOffset = ( uint8_t )( pcRequestedName - ( char * ) pucUDPPayloadBuffer ); + pxAnswer->ucNameOffset = ( uint8_t ) ( pcRequestedName - ( char * ) pucUDPPayloadBuffer ); - vSetField16( pxAnswer, LLMNRAnswer_t, usType, dnsTYPE_A_HOST ); /* Type A: host */ - vSetField16( pxAnswer, LLMNRAnswer_t, usClass, dnsCLASS_IN ); /* 1: Class IN */ + vSetField16( pxAnswer, LLMNRAnswer_t, usType, dnsTYPE_A_HOST ); /* Type A: host */ + vSetField16( pxAnswer, LLMNRAnswer_t, usClass, dnsCLASS_IN ); /* 1: Class IN */ vSetField32( pxAnswer, LLMNRAnswer_t, ulTTL, dnsLLMNR_TTL_VALUE ); vSetField16( pxAnswer, LLMNRAnswer_t, usDataLength, 4 ); vSetField32( pxAnswer, LLMNRAnswer_t, ulIPAddress, FreeRTOS_ntohl( *ipLOCAL_IP_ADDRESS_POINTER ) ); @@ -1110,6 +1237,12 @@ uint16_t x, usDataLength, usQuestions; } } #endif /* ipconfigUSE_LLMNR == 1 */ + } while( 0 ); + + if( xExpected == pdFALSE ) + { + /* Do not return a valid IP-address in case the reply was not expected. */ + ulIPAddress = 0uL; } return ulIPAddress; @@ -1118,15 +1251,17 @@ uint16_t x, usDataLength, usQuestions; #if( ipconfigUSE_NBNS == 1 ) - static void prvTreatNBNS( uint8_t *pucUDPPayloadBuffer, size_t xBufferLength, uint32_t ulIPAddress ) + static void prvTreatNBNS( uint8_t *pucUDPPayloadBuffer, + size_t uxBufferLength, + uint32_t ulIPAddress ) { - uint16_t usFlags, usType, usClass; - uint8_t *pucSource, *pucTarget; - uint8_t ucByte; - uint8_t ucNBNSName[ 17 ]; + uint16_t usFlags, usType, usClass; + uint8_t *pucSource, *pucTarget; + uint8_t ucByte; + uint8_t ucNBNSName[ 17 ]; /* Check for minimum buffer size. */ - if( xBufferLength < sizeof( NBNSRequest_t ) ) + if( uxBufferLength < sizeof( NBNSRequest_t ) ) { return; } @@ -1140,10 +1275,11 @@ uint16_t x, usDataLength, usQuestions; usClass = usChar2u16( pucUDPPayloadBuffer + offsetof( NBNSRequest_t, usClass ) ); /* Not used for now */ - ( void )usClass; + ( void ) usClass; + /* For NBNS a name is 16 bytes long, written with capitals only. Make sure that the copy is terminated with a zero. */ - pucTarget = ucNBNSName + sizeof(ucNBNSName ) - 2; + pucTarget = ucNBNSName + sizeof( ucNBNSName ) - 2; pucTarget[ 1 ] = '\0'; /* Start with decoding the last 2 bytes. */ @@ -1201,14 +1337,11 @@ uint16_t x, usDataLength, usQuestions; if( ( xBufferAllocFixedSize == pdFALSE ) && ( pxNetworkBuffer != NULL ) ) { NetworkBufferDescriptor_t *pxNewBuffer; - BaseType_t xDataLength = pxNetworkBuffer->xDataLength + sizeof( UDPHeader_t ) + - sizeof( EthernetHeader_t ) + sizeof( IPHeader_t ); - /* The field xDataLength was set to the length of the UDP payload. - The answer (reply) will be longer than the request, so the packet - must be duplicated into a bigger buffer */ - pxNetworkBuffer->xDataLength = xDataLength; - pxNewBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, xDataLength + 16 ); + /* The field xDataLength was set to the total length of the UDP packet, + i.e. the payload size plus sizeof( UDPPacket_t ). */ + pxNewBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, pxNetworkBuffer->xDataLength + sizeof( NBNSAnswer_t ) ); + if( pxNewBuffer != NULL ) { pucUDPPayloadBuffer = pxNewBuffer->pucEthernetBuffer + sizeof( UDPPacket_t ); @@ -1224,7 +1357,7 @@ uint16_t x, usDataLength, usQuestions; /* Should not occur: pucUDPPayloadBuffer is part of a xNetworkBufferDescriptor */ if( pxNetworkBuffer != NULL ) { - pxMessage = (DNSMessage_t *)pucUDPPayloadBuffer; + pxMessage = ( DNSMessage_t * ) pucUDPPayloadBuffer; /* As the fields in the structures are not word-aligned, we have to copy the values byte-by-byte using macro's vSetField16() and vSetField32() */ @@ -1234,12 +1367,12 @@ uint16_t x, usDataLength, usQuestions; vSetField16( pxMessage, DNSMessage_t, usAuthorityRRs, 0 ); vSetField16( pxMessage, DNSMessage_t, usAdditionalRRs, 0 ); - pxAnswer = (NBNSAnswer_t *)( pucUDPPayloadBuffer + offsetof( NBNSRequest_t, usType ) ); + pxAnswer = ( NBNSAnswer_t * ) ( pucUDPPayloadBuffer + offsetof( NBNSRequest_t, usType ) ); - vSetField16( pxAnswer, NBNSAnswer_t, usType, usType ); /* Type */ - vSetField16( pxAnswer, NBNSAnswer_t, usClass, dnsNBNS_CLASS_IN ); /* Class */ + vSetField16( pxAnswer, NBNSAnswer_t, usType, usType ); /* Type */ + vSetField16( pxAnswer, NBNSAnswer_t, usClass, dnsNBNS_CLASS_IN ); /* Class */ vSetField32( pxAnswer, NBNSAnswer_t, ulTTL, dnsNBNS_TTL_VALUE ); - vSetField16( pxAnswer, NBNSAnswer_t, usDataLength, 6 ); /* 6 bytes including the length field */ + vSetField16( pxAnswer, NBNSAnswer_t, usDataLength, 6 ); /* 6 bytes including the length field */ vSetField16( pxAnswer, NBNSAnswer_t, usNbFlags, dnsNBNS_NAME_FLAGS ); vSetField32( pxAnswer, NBNSAnswer_t, ulIPAddress, FreeRTOS_ntohl( *ipLOCAL_IP_ADDRESS_POINTER ) ); @@ -1251,7 +1384,7 @@ uint16_t x, usDataLength, usQuestions; } } -#endif /* ipconfigUSE_NBNS */ +#endif /* ipconfigUSE_NBNS */ /*-----------------------------------------------------------*/ static Socket_t prvCreateDNSSocket( void ) @@ -1259,7 +1392,6 @@ static Socket_t prvCreateDNSSocket( void ) Socket_t xSocket = NULL; struct freertos_sockaddr xAddress; BaseType_t xReturn; -TickType_t xTimeoutTime = pdMS_TO_TICKS( 200 ); /* This must be the first time this function has been called. Create the socket. */ @@ -1277,9 +1409,7 @@ TickType_t xTimeoutTime = pdMS_TO_TICKS( 200 ); } else { - /* Set the send and receive timeouts. */ - FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, ( void * ) &xTimeoutTime, sizeof( TickType_t ) ); - FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, ( void * ) &xTimeoutTime, sizeof( TickType_t ) ); + /* The send and receive timeouts will be set later on. */ } return xSocket; @@ -1288,13 +1418,14 @@ TickType_t xTimeoutTime = pdMS_TO_TICKS( 200 ); #if( ( ipconfigUSE_NBNS == 1 ) || ( ipconfigUSE_LLMNR == 1 ) ) - static void prvReplyDNSMessage( NetworkBufferDescriptor_t *pxNetworkBuffer, BaseType_t lNetLength ) + static void prvReplyDNSMessage( NetworkBufferDescriptor_t *pxNetworkBuffer, + BaseType_t lNetLength ) { UDPPacket_t *pxUDPPacket; IPHeader_t *pxIPHeader; UDPHeader_t *pxUDPHeader; - pxUDPPacket = (UDPPacket_t *) pxNetworkBuffer->pucEthernetBuffer; + pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer; pxIPHeader = &pxUDPPacket->xIPHeader; pxUDPHeader = &pxUDPPacket->xUDPHeader; /* HT: started using defines like 'ipSIZE_OF_xxx' */ @@ -1314,9 +1445,9 @@ TickType_t xTimeoutTime = pdMS_TO_TICKS( 200 ); #if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 ) { /* calculate the IP header checksum */ - pxIPHeader->usHeaderChecksum = 0x00; - pxIPHeader->usHeaderChecksum = usGenerateChecksum( 0UL, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ipSIZE_OF_IPv4_HEADER ); - pxIPHeader->usHeaderChecksum = ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum ); + pxIPHeader->usHeaderChecksum = 0x00; + pxIPHeader->usHeaderChecksum = usGenerateChecksum( 0uL, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ipSIZE_OF_IPv4_HEADER ); + pxIPHeader->usHeaderChecksum = ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum ); /* calculate the UDP checksum for outgoing package */ usGenerateProtocolChecksum( ( uint8_t* ) pxUDPPacket, pxNetworkBuffer->xDataLength, pdTRUE ); @@ -1332,14 +1463,16 @@ TickType_t xTimeoutTime = pdMS_TO_TICKS( 200 ); #if( ipconfigUSE_DNS_CACHE == 1 ) - static void prvProcessDNSCache( const char *pcName, uint32_t *pulIP, uint32_t ulTTL, BaseType_t xLookUp ) + static void prvProcessDNSCache( const char *pcName, + uint32_t *pulIP, + uint32_t ulTTL, + BaseType_t xLookUp ) { BaseType_t x; BaseType_t xFound = pdFALSE; uint32_t ulCurrentTimeSeconds = ( xTaskGetTickCount() / portTICK_PERIOD_MS ) / 1000; static BaseType_t xFreeEntry = 0; - configASSERT(pcName); - + configASSERT(pcName); /* For each entry in the DNS cache table. */ for( x = 0; x < ipconfigDNS_CACHE_ENTRIES; x++ ) @@ -1395,6 +1528,7 @@ TickType_t xTimeoutTime = pdMS_TO_TICKS( 200 ); xDNSCache[ xFreeEntry ].ulTimeWhenAddedInSeconds = ulCurrentTimeSeconds; xFreeEntry++; + if( xFreeEntry == ipconfigDNS_CACHE_ENTRIES ) { xFreeEntry = 0;