/*\r
- * FreeRTOS+TCP V2.0.3\r
+ * FreeRTOS+TCP V2.2.0\r
* Copyright (C) 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.\r
*\r
* Permission is hereby granted, free of charge, to any person obtaining a copy of\r
#if( ipconfigUSE_DNS != 0 )\r
\r
#if( ipconfigBYTE_ORDER == pdFREERTOS_LITTLE_ENDIAN )\r
- #define dnsDNS_PORT 0x3500u\r
- #define dnsONE_QUESTION 0x0100u\r
- #define dnsOUTGOING_FLAGS 0x0001u /* Standard query. */\r
- #define dnsRX_FLAGS_MASK 0x0f80u /* The bits of interest in the flags field of incoming DNS messages. */\r
- #define dnsEXPECTED_RX_FLAGS 0x0080u /* Should be a response, without any errors. */\r
+ #define dnsDNS_PORT 0x3500u\r
+ #define dnsONE_QUESTION 0x0100u\r
+ #define dnsOUTGOING_FLAGS 0x0001u /* Standard query. */\r
+ #define dnsRX_FLAGS_MASK 0x0f80u /* The bits of interest in the flags field of incoming DNS messages. */\r
+ #define dnsEXPECTED_RX_FLAGS 0x0080u /* Should be a response, without any errors. */\r
#else\r
- #define dnsDNS_PORT 0x0035u\r
- #define dnsONE_QUESTION 0x0001u\r
- #define dnsOUTGOING_FLAGS 0x0100u /* Standard query. */\r
- #define dnsRX_FLAGS_MASK 0x800fu /* The bits of interest in the flags field of incoming DNS messages. */\r
- #define dnsEXPECTED_RX_FLAGS 0x8000u /* Should be a response, without any errors. */\r
+ #define dnsDNS_PORT 0x0035u\r
+ #define dnsONE_QUESTION 0x0001u\r
+ #define dnsOUTGOING_FLAGS 0x0100u /* Standard query. */\r
+ #define dnsRX_FLAGS_MASK 0x800fu /* The bits of interest in the flags field of incoming DNS messages. */\r
+ #define dnsEXPECTED_RX_FLAGS 0x8000u /* Should be a response, without any errors. */\r
\r
#endif /* ipconfigBYTE_ORDER */\r
\r
/* The maximum number of times a DNS request should be sent out if a response\r
is not received, before giving up. */\r
#ifndef ipconfigDNS_REQUEST_ATTEMPTS\r
- #define ipconfigDNS_REQUEST_ATTEMPTS 5\r
+ #define ipconfigDNS_REQUEST_ATTEMPTS 5\r
#endif\r
\r
/* If the top two bits in the first character of a name field are set then the\r
name field is an offset to the string, rather than the string itself. */\r
-#define dnsNAME_IS_OFFSET ( ( uint8_t ) 0xc0 )\r
+#define dnsNAME_IS_OFFSET ( ( uint8_t ) 0xc0 )\r
\r
/* NBNS flags. */\r
-#define dnsNBNS_FLAGS_RESPONSE 0x8000u\r
-#define dnsNBNS_FLAGS_OPCODE_MASK 0x7800u\r
-#define dnsNBNS_FLAGS_OPCODE_QUERY 0x0000u\r
-#define dnsNBNS_FLAGS_OPCODE_REGISTRATION 0x2800u\r
+#define dnsNBNS_FLAGS_RESPONSE 0x8000u\r
+#define dnsNBNS_FLAGS_OPCODE_MASK 0x7800u\r
+#define dnsNBNS_FLAGS_OPCODE_QUERY 0x0000u\r
+#define dnsNBNS_FLAGS_OPCODE_REGISTRATION 0x2800u\r
\r
/* Host types. */\r
-#define dnsTYPE_A_HOST 0x0001u\r
-#define dnsCLASS_IN 0x0001u\r
+#define dnsTYPE_A_HOST 0x01u\r
+#define dnsCLASS_IN 0x01u\r
\r
/* LLMNR constants. */\r
-#define dnsLLMNR_TTL_VALUE 300000u\r
-#define dnsLLMNR_FLAGS_IS_REPONSE 0x8000u\r
+#define dnsLLMNR_TTL_VALUE 300000uL\r
+#define dnsLLMNR_FLAGS_IS_REPONSE 0x8000u\r
\r
/* NBNS constants. */\r
-#define dnsNBNS_TTL_VALUE 3600u /* 1 hour valid */\r
-#define dnsNBNS_TYPE_NET_BIOS 0x0020u\r
-#define dnsNBNS_CLASS_IN 0x0001u\r
-#define dnsNBNS_NAME_FLAGS 0x6000u\r
-#define dnsNBNS_ENCODED_NAME_LENGTH 32\r
+#define dnsNBNS_TTL_VALUE 3600uL /* 1 hour valid */\r
+#define dnsNBNS_TYPE_NET_BIOS 0x0020u\r
+#define dnsNBNS_CLASS_IN 0x01u\r
+#define dnsNBNS_NAME_FLAGS 0x6000u\r
+#define dnsNBNS_ENCODED_NAME_LENGTH 32\r
\r
/* If the queried NBNS name matches with the device's name,\r
the query will be responded to with these flags: */\r
-#define dnsNBNS_QUERY_RESPONSE_FLAGS 0x8500u\r
+#define dnsNBNS_QUERY_RESPONSE_FLAGS ( 0x8500u )\r
+\r
+/* Flag DNS parsing errors in situations where an IPv4 address is the return\r
+type. */\r
+#define dnsPARSE_ERROR 0uL\r
\r
/*\r
* Create a socket and bind it to the standard DNS port number. Return the\r
/*\r
* Create the DNS message in the zero copy buffer passed in the first parameter.\r
*/\r
-static size_t prvCreateDNSMessage( uint8_t *pucUDPPayloadBuffer, const char *pcHostName, TickType_t xIdentifier );\r
+static size_t prvCreateDNSMessage( uint8_t *pucUDPPayloadBuffer,\r
+ const char *pcHostName,\r
+ TickType_t uxIdentifier );\r
\r
/*\r
* Simple routine that jumps over the NAME field of a resource record.\r
*/\r
-static uint8_t *prvSkipNameField( uint8_t *pucByte );\r
+static uint8_t * prvSkipNameField( uint8_t *pucByte,\r
+ size_t uxSourceLen );\r
\r
/*\r
* Process a response packet from a DNS server.\r
+ * The parameter 'xExpected' indicates whether the identifier in the reply\r
+ * was expected, and thus if the DNS cache may be updated with the reply.\r
*/\r
-static uint32_t prvParseDNSReply( uint8_t *pucUDPPayloadBuffer, TickType_t xIdentifier );\r
+static uint32_t prvParseDNSReply( uint8_t *pucUDPPayloadBuffer,\r
+ size_t uxBufferLength,\r
+ BaseType_t xExpected );\r
\r
/*\r
- * Prepare and send a message to a DNS server. 'xReadTimeOut_ms' will be passed as\r
+ * Prepare and send a message to a DNS server. 'uxReadTimeOut_ticks' will be passed as\r
* zero, in case the user has supplied a call-back function.\r
*/\r
-static uint32_t prvGetHostByName( const char *pcHostName, TickType_t xIdentifier, TickType_t xReadTimeOut_ms );\r
+static uint32_t prvGetHostByName( const char *pcHostName,\r
+ TickType_t uxIdentifier,\r
+ TickType_t uxReadTimeOut_ticks );\r
\r
/*\r
* The NBNS and the LLMNR protocol share this reply function.\r
*/\r
#if( ( ipconfigUSE_NBNS == 1 ) || ( ipconfigUSE_LLMNR == 1 ) )\r
- static void prvReplyDNSMessage( NetworkBufferDescriptor_t *pxNetworkBuffer, BaseType_t lNetLength );\r
+ static void prvReplyDNSMessage( NetworkBufferDescriptor_t *pxNetworkBuffer,\r
+ BaseType_t lNetLength );\r
#endif\r
\r
#if( ipconfigUSE_NBNS == 1 )\r
- static portINLINE void prvTreatNBNS( uint8_t *pucUDPPayloadBuffer, uint32_t ulIPAddress );\r
+ static portINLINE void prvTreatNBNS( uint8_t *pucUDPPayloadBuffer,\r
+ size_t uxBufferLength,\r
+ uint32_t ulIPAddress );\r
#endif /* ipconfigUSE_NBNS */\r
\r
+\r
+#if( ipconfigUSE_DNS_CACHE == 1 ) || ( ipconfigDNS_USE_CALLBACKS == 1 )\r
+ static uint8_t * prvReadNameField( uint8_t *pucByte,\r
+ size_t uxSourceLen,\r
+ char *pcName,\r
+ size_t uxLen );\r
+#endif /* ipconfigUSE_DNS_CACHE || ipconfigDNS_USE_CALLBACKS */\r
+\r
#if( ipconfigUSE_DNS_CACHE == 1 )\r
- static uint8_t *prvReadNameField( uint8_t *pucByte, char *pcName, BaseType_t xLen );\r
- static void prvProcessDNSCache( const char *pcName, uint32_t *pulIP, BaseType_t xLookUp );\r
+ static void prvProcessDNSCache( const char *pcName,\r
+ uint32_t *pulIP,\r
+ uint32_t ulTTL,\r
+ BaseType_t xLookUp );\r
\r
typedef struct xDNS_CACHE_TABLE_ROW\r
{\r
- uint32_t ulIPAddress; /* The IP address of an ARP cache entry. */\r
- char pcName[ipconfigDNS_CACHE_NAME_LENGTH]; /* The name of the host */\r
- uint8_t ucAge; /* A value that is periodically decremented but can also be refreshed by active communication. The ARP cache entry is removed if the value reaches zero. */\r
+ uint32_t ulIPAddress; /* The IP address of an ARP cache entry. */\r
+ char pcName[ ipconfigDNS_CACHE_NAME_LENGTH ]; /* The name of the host */\r
+ uint32_t ulTTL; /* Time-to-Live (in seconds) from the DNS server. */\r
+ uint32_t ulTimeWhenAddedInSeconds;\r
} DNSCacheRow_t;\r
\r
static DNSCacheRow_t xDNSCache[ ipconfigDNS_CACHE_ENTRIES ];\r
+\r
+ void FreeRTOS_dnsclear()\r
+ {\r
+ memset( xDNSCache, 0x0, sizeof( xDNSCache ) );\r
+ }\r
#endif /* ipconfigUSE_DNS_CACHE == 1 */\r
\r
#if( ipconfigUSE_LLMNR == 1 )\r
const MACAddress_t xLLMNR_MacAdress = { { 0x01, 0x00, 0x5e, 0x00, 0x00, 0xfc } };\r
-#endif /* ipconfigUSE_LLMNR == 1 */\r
+#endif /* ipconfigUSE_LLMNR == 1 */\r
\r
/*-----------------------------------------------------------*/\r
\r
#include "pack_struct_end.h"\r
typedef struct xDNSTail DNSTail_t;\r
\r
+/* DNS answer record header. */\r
+#include "pack_struct_start.h"\r
+struct xDNSAnswerRecord\r
+{\r
+ uint16_t usType;\r
+ uint16_t usClass;\r
+ uint32_t ulTTL;\r
+ uint16_t usDataLength;\r
+}\r
+#include "pack_struct_end.h"\r
+typedef struct xDNSAnswerRecord DNSAnswerRecord_t;\r
+\r
#if( ipconfigUSE_LLMNR == 1 )\r
\r
#include "pack_struct_start.h"\r
struct xLLMNRAnswer\r
{\r
uint8_t ucNameCode;\r
- uint8_t ucNameOffset; /* The name is not repeated in the answer, only the offset is given with "0xc0 <offs>" */\r
+ uint8_t ucNameOffset; /* The name is not repeated in the answer, only the offset is given with "0xc0 <offs>" */\r
uint16_t usType;\r
uint16_t usClass;\r
uint32_t ulTTL;\r
uint16_t usClass;\r
uint32_t ulTTL;\r
uint16_t usDataLength;\r
- uint16_t usNbFlags; /* NetBIOS flags 0x6000 : IP-address, big-endian */\r
+ uint16_t usNbFlags; /* NetBIOS flags 0x6000 : IP-address, big-endian */\r
uint32_t ulIPAddress;\r
}\r
#include "pack_struct_end.h"\r
typedef struct xNBNSAnswer NBNSAnswer_t;\r
\r
-#endif /* ipconfigUSE_NBNS == 1 */\r
+ #endif /* ipconfigUSE_NBNS == 1 */\r
\r
/*-----------------------------------------------------------*/\r
\r
#if( ipconfigUSE_DNS_CACHE == 1 )\r
uint32_t FreeRTOS_dnslookup( const char *pcHostName )\r
{\r
- uint32_t ulIPAddress = 0UL;\r
- prvProcessDNSCache( pcHostName, &ulIPAddress, pdTRUE );\r
+ uint32_t ulIPAddress = 0uL;\r
+\r
+ prvProcessDNSCache( pcHostName, &ulIPAddress, 0, pdTRUE );\r
return ulIPAddress;\r
}\r
#endif /* ipconfigUSE_DNS_CACHE == 1 */\r
/*-----------------------------------------------------------*/\r
\r
-#if( ipconfigDNS_USE_CALLBACKS != 0 )\r
+#if( ipconfigDNS_USE_CALLBACKS == 1 )\r
\r
- typedef struct xDNS_Callback {\r
- TickType_t xRemaningTime; /* Timeout in ms */\r
+ typedef struct xDNS_Callback\r
+ {\r
+ TickType_t uxRemaningTime; /* Timeout in ms */\r
FOnDNSEvent pCallbackFunction; /* Function to be called when the address has been found or when a timeout has beeen reached */\r
- TimeOut_t xTimeoutState;\r
+ TimeOut_t uxTimeoutState;\r
void *pvSearchID;\r
struct xLIST_ITEM xListItem;\r
char pcName[ 1 ];\r
/* Define FreeRTOS_gethostbyname() as a normal blocking call. */\r
uint32_t FreeRTOS_gethostbyname( const char *pcHostName )\r
{\r
- return FreeRTOS_gethostbyname_a( pcHostName, ( FOnDNSEvent ) NULL, ( void* )NULL, 0 );\r
+ return FreeRTOS_gethostbyname_a( pcHostName, ( FOnDNSEvent ) NULL, ( void * ) NULL, 0 );\r
}\r
/*-----------------------------------------------------------*/\r
\r
void vDNSCheckCallBack( void *pvSearchID )\r
{\r
const ListItem_t *pxIterator;\r
- const MiniListItem_t* xEnd = ( const MiniListItem_t* )listGET_END_MARKER( &xCallbackList );\r
+ const MiniListItem_t * xEnd = ( const MiniListItem_t * ) listGET_END_MARKER( &xCallbackList );\r
\r
vTaskSuspendAll();\r
{\r
for( pxIterator = ( const ListItem_t * ) listGET_NEXT( xEnd );\r
pxIterator != ( const ListItem_t * ) xEnd;\r
- )\r
+ )\r
{\r
- DNSCallback_t *pxCallback = ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator );\r
+ DNSCallback_t *pxCallback = ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator );\r
+\r
/* Move to the next item because we might remove this item */\r
- pxIterator = ( const ListItem_t * ) listGET_NEXT( pxIterator );\r
+ pxIterator = ( const ListItem_t * ) listGET_NEXT( pxIterator );\r
+\r
if( ( pvSearchID != NULL ) && ( pvSearchID == pxCallback->pvSearchID ) )\r
{\r
uxListRemove( &pxCallback->xListItem );\r
vPortFree( pxCallback );\r
}\r
- else if( xTaskCheckForTimeOut( &pxCallback->xTimeoutState, &pxCallback->xRemaningTime ) != pdFALSE )\r
+ else if( xTaskCheckForTimeOut( &pxCallback->uxTimeoutState, &pxCallback->uxRemaningTime ) != pdFALSE )\r
{\r
pxCallback->pCallbackFunction( pxCallback->pcName, pxCallback->pvSearchID, 0 );\r
uxListRemove( &pxCallback->xListItem );\r
\r
/* FreeRTOS_gethostbyname_a() was called along with callback parameters.\r
Store them in a list for later reference. */\r
- static void vDNSSetCallBack( const char *pcHostName, void *pvSearchID, FOnDNSEvent pCallbackFunction, TickType_t xTimeout, TickType_t xIdentifier );\r
- static void vDNSSetCallBack( const char *pcHostName, void *pvSearchID, FOnDNSEvent pCallbackFunction, TickType_t xTimeout, TickType_t xIdentifier )\r
+ static void vDNSSetCallBack( const char *pcHostName,\r
+ void *pvSearchID,\r
+ FOnDNSEvent pCallbackFunction,\r
+ TickType_t uxTimeout,\r
+ TickType_t uxIdentifier );\r
+ static void vDNSSetCallBack( const char *pcHostName,\r
+ void *pvSearchID,\r
+ FOnDNSEvent pCallbackFunction,\r
+ TickType_t uxTimeout,\r
+ TickType_t uxIdentifier )\r
{\r
- size_t lLength = strlen( pcHostName );\r
- DNSCallback_t *pxCallback = ( DNSCallback_t * )pvPortMalloc( sizeof( *pxCallback ) + lLength );\r
+ size_t lLength = strlen( pcHostName );\r
+ DNSCallback_t *pxCallback = ( DNSCallback_t * ) pvPortMalloc( sizeof( *pxCallback ) + lLength );\r
\r
/* Translate from ms to number of clock ticks. */\r
- xTimeout /= portTICK_PERIOD_MS;\r
+ uxTimeout /= portTICK_PERIOD_MS;\r
+\r
if( pxCallback != NULL )\r
{\r
if( listLIST_IS_EMPTY( &xCallbackList ) )\r
{\r
/* This is the first one, start the DNS timer to check for timeouts */\r
- vIPReloadDNSTimer( FreeRTOS_min_uint32( 1000U, xTimeout ) );\r
+ vIPReloadDNSTimer( FreeRTOS_min_uint32( 1000U, uxTimeout ) );\r
}\r
+\r
strcpy( pxCallback->pcName, pcHostName );\r
pxCallback->pCallbackFunction = pCallbackFunction;\r
pxCallback->pvSearchID = pvSearchID;\r
- pxCallback->xRemaningTime = xTimeout;\r
- vTaskSetTimeOutState( &pxCallback->xTimeoutState );\r
- listSET_LIST_ITEM_OWNER( &( pxCallback->xListItem ), ( void* ) pxCallback );\r
- listSET_LIST_ITEM_VALUE( &( pxCallback->xListItem ), xIdentifier );\r
+ pxCallback->uxRemaningTime = uxTimeout;\r
+ vTaskSetTimeOutState( &pxCallback->uxTimeoutState );\r
+ listSET_LIST_ITEM_OWNER( &( pxCallback->xListItem ), ( void * ) pxCallback );\r
+ listSET_LIST_ITEM_VALUE( &( pxCallback->xListItem ), uxIdentifier );\r
vTaskSuspendAll();\r
{\r
vListInsertEnd( &xCallbackList, &pxCallback->xListItem );\r
/*-----------------------------------------------------------*/\r
\r
/* A DNS reply was received, see if there is any matching entry and\r
- call the handler. */\r
- static void vDNSDoCallback( TickType_t xIdentifier, const char *pcName, uint32_t ulIPAddress );\r
- static void vDNSDoCallback( TickType_t xIdentifier, const char *pcName, uint32_t ulIPAddress )\r
+ call the handler. Returns pdTRUE if uxIdentifier was recognised. */\r
+ static BaseType_t xDNSDoCallback( TickType_t uxIdentifier,\r
+ const char *pcName,\r
+ uint32_t ulIPAddress );\r
+ static BaseType_t xDNSDoCallback( TickType_t uxIdentifier,\r
+ const char *pcName,\r
+ uint32_t ulIPAddress )\r
{\r
- const ListItem_t *pxIterator;\r
- const MiniListItem_t* xEnd = ( const MiniListItem_t* )listGET_END_MARKER( &xCallbackList );\r
+ BaseType_t xResult = pdFALSE;\r
+ const ListItem_t *pxIterator;\r
+ const MiniListItem_t * xEnd = ( const MiniListItem_t * ) listGET_END_MARKER( &xCallbackList );\r
\r
vTaskSuspendAll();\r
{\r
pxIterator != ( const ListItem_t * ) xEnd;\r
pxIterator = ( const ListItem_t * ) listGET_NEXT( pxIterator ) )\r
{\r
- if( listGET_LIST_ITEM_VALUE( pxIterator ) == xIdentifier )\r
+ /* The cast will take away the 'configLIST_VOLATILE' */\r
+ if( uxIdentifier == ( TickType_t ) listGET_LIST_ITEM_VALUE( pxIterator ) )\r
{\r
- DNSCallback_t *pxCallback = ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator );\r
+ DNSCallback_t *pxCallback = ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator );\r
+\r
pxCallback->pCallbackFunction( pcName, pxCallback->pvSearchID, ulIPAddress );\r
uxListRemove( &pxCallback->xListItem );\r
vPortFree( pxCallback );\r
+\r
if( listLIST_IS_EMPTY( &xCallbackList ) )\r
{\r
+ /* The list of outstanding requests is empty. No need for periodic polling. */\r
vIPSetDnsTimerEnableState( pdFALSE );\r
}\r
+\r
+ xResult = pdTRUE;\r
break;\r
}\r
}\r
}\r
xTaskResumeAll();\r
+ return xResult;\r
}\r
\r
-#endif /* ipconfigDNS_USE_CALLBACKS != 0 */\r
+#endif /* ipconfigDNS_USE_CALLBACKS == 1 */\r
/*-----------------------------------------------------------*/\r
\r
#if( ipconfigDNS_USE_CALLBACKS == 0 )\r
-uint32_t FreeRTOS_gethostbyname( const char *pcHostName )\r
+ uint32_t FreeRTOS_gethostbyname( const char *pcHostName )\r
#else\r
-uint32_t FreeRTOS_gethostbyname_a( const char *pcHostName, FOnDNSEvent pCallback, void *pvSearchID, TickType_t xTimeout )\r
+ uint32_t FreeRTOS_gethostbyname_a( const char *pcHostName,\r
+ FOnDNSEvent pCallback,\r
+ void *pvSearchID,\r
+ TickType_t uxTimeout )\r
#endif\r
{\r
-uint32_t ulIPAddress = 0UL;\r
-static uint16_t usIdentifier = 0u;\r
-TickType_t xReadTimeOut_ms = 1200U;\r
-/* Generate a unique identifier for this query. Keep it in a local variable\r
- as gethostbyname() may be called from different threads */\r
-TickType_t xIdentifier = ( TickType_t )usIdentifier++;\r
-\r
- /* If the supplied hostname is IP address, convert it to uint32_t\r
- and return. */\r
- #if( ipconfigINCLUDE_FULL_INET_ADDR == 1 )\r
- {\r
- ulIPAddress = FreeRTOS_inet_addr( pcHostName );\r
- }\r
- #endif /* ipconfigINCLUDE_FULL_INET_ADDR == 1 */\r
+uint32_t ulIPAddress = 0uL;\r
+TickType_t uxReadTimeOut_ticks = ipconfigDNS_RECEIVE_BLOCK_TIME_TICKS;\r
+TickType_t uxIdentifier = 0u;\r
+BaseType_t xHasRandom = pdFALSE;\r
\r
- /* If a DNS cache is used then check the cache before issuing another DNS\r
- request. */\r
- #if( ipconfigUSE_DNS_CACHE == 1 )\r
+ if( pcHostName != NULL )\r
{\r
- if( ulIPAddress == 0UL )\r
+ /* If the supplied hostname is IP address, convert it to uint32_t\r
+ and return. */\r
+ #if( ipconfigINCLUDE_FULL_INET_ADDR == 1 )\r
{\r
- ulIPAddress = FreeRTOS_dnslookup( pcHostName );\r
- if( ulIPAddress != 0 )\r
- {\r
- FreeRTOS_debug_printf( ( "FreeRTOS_gethostbyname: found '%s' in cache: %lxip\n", pcHostName, ulIPAddress ) );\r
- }\r
- else\r
- {\r
- /* prvGetHostByName will be called to start a DNS lookup */\r
- }\r
+ ulIPAddress = FreeRTOS_inet_addr( pcHostName );\r
}\r
- }\r
- #endif /* ipconfigUSE_DNS_CACHE == 1 */\r
+ #endif /* ipconfigINCLUDE_FULL_INET_ADDR == 1 */\r
\r
- #if( ipconfigDNS_USE_CALLBACKS != 0 )\r
- {\r
- if( pCallback != NULL )\r
+ /* If a DNS cache is used then check the cache before issuing another DNS\r
+ request. */\r
+ #if( ipconfigUSE_DNS_CACHE == 1 )\r
{\r
- if( ulIPAddress == 0UL )\r
+ if( ulIPAddress == 0uL )\r
{\r
- /* The user has provided a callback function, so do not block on recvfrom() */\r
- xReadTimeOut_ms = 0;\r
- vDNSSetCallBack( pcHostName, pvSearchID, pCallback, xTimeout, ( TickType_t ) xIdentifier );\r
+ ulIPAddress = FreeRTOS_dnslookup( pcHostName );\r
+\r
+ if( ulIPAddress != 0 )\r
+ {\r
+ FreeRTOS_debug_printf( ( "FreeRTOS_gethostbyname: found '%s' in cache: %lxip\n", pcHostName, ulIPAddress ) );\r
+ }\r
+ else\r
+ {\r
+ /* prvGetHostByName will be called to start a DNS lookup. */\r
+ }\r
}\r
- else\r
+ }\r
+ #endif /* ipconfigUSE_DNS_CACHE == 1 */\r
+\r
+ /* Generate a unique identifier. */\r
+ if( ulIPAddress == 0uL )\r
+ {\r
+ uint32_t ulNumber;\r
+\r
+ xHasRandom = xApplicationGetRandomNumber( &( ulNumber ) );\r
+ /* DNS identifiers are 16-bit. */\r
+ uxIdentifier = ( TickType_t ) ( ulNumber & 0xffffu );\r
+ /* ipconfigRAND32() may not return a non-zero value. */\r
+ }\r
+\r
+ #if( ipconfigDNS_USE_CALLBACKS == 1 )\r
+ {\r
+ if( pCallback != NULL )\r
{\r
- /* The IP address is known, do the call-back now. */\r
- pCallback( pcHostName, pvSearchID, ulIPAddress );\r
+ if( ulIPAddress == 0uL )\r
+ {\r
+ /* The user has provided a callback function, so do not block on recvfrom() */\r
+ if( xHasRandom != pdFALSE )\r
+ {\r
+ uxReadTimeOut_ticks = 0u;\r
+ vDNSSetCallBack( pcHostName, pvSearchID, pCallback, uxTimeout, uxIdentifier );\r
+ }\r
+ }\r
+ else\r
+ {\r
+ /* The IP address is known, do the call-back now. */\r
+ pCallback( pcHostName, pvSearchID, ulIPAddress );\r
+ }\r
}\r
}\r
- }\r
- #endif\r
+ #endif /* if ( ipconfigDNS_USE_CALLBACKS == 1 ) */\r
\r
- if( ulIPAddress == 0UL)\r
- {\r
- ulIPAddress = prvGetHostByName( pcHostName, xIdentifier, xReadTimeOut_ms );\r
+ if( ( ulIPAddress == 0uL ) && ( xHasRandom != pdFALSE ) )\r
+ {\r
+ ulIPAddress = prvGetHostByName( pcHostName, uxIdentifier, uxReadTimeOut_ticks );\r
+ }\r
}\r
-\r
return ulIPAddress;\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static uint32_t prvGetHostByName( const char *pcHostName, TickType_t xIdentifier, TickType_t xReadTimeOut_ms )\r
+static uint32_t prvGetHostByName( const char *pcHostName,\r
+ TickType_t uxIdentifier,\r
+ TickType_t uxReadTimeOut_ticks )\r
{\r
struct freertos_sockaddr xAddress;\r
Socket_t xDNSSocket;\r
-uint32_t ulIPAddress = 0UL;\r
+uint32_t ulIPAddress = 0uL;\r
uint8_t *pucUDPPayloadBuffer;\r
uint32_t ulAddressLength = sizeof( struct freertos_sockaddr );\r
BaseType_t xAttempt;\r
int32_t lBytes;\r
-size_t xPayloadLength, xExpectedPayloadLength;\r
-TickType_t xWriteTimeOut_ms = 100U;\r
+size_t uxPayloadLength, uxExpectedPayloadLength;\r
+TickType_t uxWriteTimeOut_ticks = ipconfigDNS_SEND_BLOCK_TIME_TICKS;\r
\r
#if( ipconfigUSE_LLMNR == 1 )\r
BaseType_t bHasDot = pdFALSE;\r
if not then LLMNR can be used as the lookup method. */\r
#if( ipconfigUSE_LLMNR == 1 )\r
{\r
- const char *pucPtr;\r
+ const char *pucPtr;\r
+\r
for( pucPtr = pcHostName; *pucPtr; pucPtr++ )\r
{\r
if( *pucPtr == '.' )\r
\r
/* Two is added at the end for the count of characters in the first\r
subdomain part and the string end byte. */\r
- xExpectedPayloadLength = sizeof( DNSMessage_t ) + strlen( pcHostName ) + sizeof( uint16_t ) + sizeof( uint16_t ) + 2u;\r
+ uxExpectedPayloadLength = sizeof( DNSMessage_t ) + strlen( pcHostName ) + sizeof( uint16_t ) + sizeof( uint16_t ) + 2u;\r
\r
xDNSSocket = prvCreateDNSSocket();\r
\r
if( xDNSSocket != NULL )\r
{\r
- FreeRTOS_setsockopt( xDNSSocket, 0, FREERTOS_SO_SNDTIMEO, ( void * ) &xWriteTimeOut_ms, sizeof( TickType_t ) );\r
- FreeRTOS_setsockopt( xDNSSocket, 0, FREERTOS_SO_RCVTIMEO, ( void * ) &xReadTimeOut_ms, sizeof( TickType_t ) );\r
+ FreeRTOS_setsockopt( xDNSSocket, 0, FREERTOS_SO_SNDTIMEO, ( void * ) &uxWriteTimeOut_ticks, sizeof( TickType_t ) );\r
+ FreeRTOS_setsockopt( xDNSSocket, 0, FREERTOS_SO_RCVTIMEO, ( void * ) &uxReadTimeOut_ticks, sizeof( TickType_t ) );\r
\r
for( xAttempt = 0; xAttempt < ipconfigDNS_REQUEST_ATTEMPTS; xAttempt++ )\r
{\r
/* Get a buffer. This uses a maximum delay, but the delay will be\r
capped to ipconfigUDP_MAX_SEND_BLOCK_TIME_TICKS so the return value\r
still needs to be tested. */\r
- pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( xExpectedPayloadLength, portMAX_DELAY );\r
+ pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( uxExpectedPayloadLength, portMAX_DELAY );\r
\r
if( pucUDPPayloadBuffer != NULL )\r
{\r
/* Create the message in the obtained buffer. */\r
- xPayloadLength = prvCreateDNSMessage( pucUDPPayloadBuffer, pcHostName, xIdentifier );\r
+ uxPayloadLength = prvCreateDNSMessage( pucUDPPayloadBuffer, pcHostName, uxIdentifier );\r
\r
iptraceSENDING_DNS_REQUEST();\r
\r
if( bHasDot == pdFALSE )\r
{\r
/* Use LLMNR addressing. */\r
- ( ( DNSMessage_t * ) pucUDPPayloadBuffer) -> usFlags = 0;\r
- xAddress.sin_addr = ipLLMNR_IP_ADDR; /* Is in network byte order. */\r
+ ( ( DNSMessage_t * ) pucUDPPayloadBuffer )->usFlags = 0;\r
+ xAddress.sin_addr = ipLLMNR_IP_ADDR; /* Is in network byte order. */\r
xAddress.sin_port = FreeRTOS_ntohs( ipLLMNR_PORT );\r
}\r
else\r
xAddress.sin_port = dnsDNS_PORT;\r
}\r
\r
- ulIPAddress = 0UL;\r
+ ulIPAddress = 0uL;\r
\r
- if( FreeRTOS_sendto( xDNSSocket, pucUDPPayloadBuffer, xPayloadLength, FREERTOS_ZERO_COPY, &xAddress, sizeof( xAddress ) ) != 0 )\r
+ if( FreeRTOS_sendto( xDNSSocket, pucUDPPayloadBuffer, uxPayloadLength, FREERTOS_ZERO_COPY, &xAddress, sizeof( xAddress ) ) != 0 )\r
{\r
/* Wait for the reply. */\r
lBytes = FreeRTOS_recvfrom( xDNSSocket, &pucUDPPayloadBuffer, 0, FREERTOS_ZERO_COPY, &xAddress, &ulAddressLength );\r
\r
if( lBytes > 0 )\r
{\r
+ BaseType_t xExpected;\r
+ DNSMessage_t *pxDNSMessageHeader = ( DNSMessage_t * ) pucUDPPayloadBuffer;\r
+\r
+ /* See if the identifiers match. */\r
+ if( uxIdentifier == ( TickType_t ) pxDNSMessageHeader->usIdentifier )\r
+ {\r
+ xExpected = pdTRUE;\r
+ }\r
+ else\r
+ {\r
+ /* The reply was not expected. */\r
+ xExpected = pdFALSE;\r
+ }\r
+\r
/* The reply was received. Process it. */\r
- ulIPAddress = prvParseDNSReply( pucUDPPayloadBuffer, xIdentifier );\r
+ #if( ipconfigDNS_USE_CALLBACKS == 0 )\r
+ /* It is useless to analyse the unexpected reply\r
+ unless asynchronous look-ups are enabled. */\r
+ if( xExpected != pdFALSE )\r
+ #endif /* ipconfigDNS_USE_CALLBACKS == 0 */\r
+ {\r
+ ulIPAddress = prvParseDNSReply( pucUDPPayloadBuffer, ( size_t ) lBytes, xExpected );\r
+ }\r
\r
/* Finished with the buffer. The zero copy interface\r
is being used, so the buffer must be freed by the\r
task. */\r
FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayloadBuffer );\r
\r
- if( ulIPAddress != 0UL )\r
+ if( ulIPAddress != 0uL )\r
{\r
/* All done. */\r
break;\r
FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayloadBuffer );\r
}\r
}\r
+\r
+ if( uxReadTimeOut_ticks == 0u )\r
+ {\r
+ /* This DNS lookup is asynchronous, using a call-back:\r
+ send the request only once. */\r
+ break;\r
+ }\r
}\r
\r
/* Finished with the socket. */\r
}\r
/*-----------------------------------------------------------*/\r
\r
-static size_t prvCreateDNSMessage( uint8_t *pucUDPPayloadBuffer, const char *pcHostName, TickType_t xIdentifier )\r
+static size_t prvCreateDNSMessage( uint8_t *pucUDPPayloadBuffer,\r
+ const char *pcHostName,\r
+ TickType_t uxIdentifier )\r
{\r
DNSMessage_t *pxDNSMessageHeader;\r
uint8_t *pucStart, *pucByte;\r
DNSTail_t *pxTail;\r
static const DNSMessage_t xDefaultPartDNSHeader =\r
{\r
- 0, /* The identifier will be overwritten. */\r
- dnsOUTGOING_FLAGS, /* Flags set for standard query. */\r
- dnsONE_QUESTION, /* One question is being asked. */\r
- 0, /* No replies are included. */\r
- 0, /* No authorities. */\r
- 0 /* No additional authorities. */\r
+ 0, /* The identifier will be overwritten. */\r
+ dnsOUTGOING_FLAGS, /* Flags set for standard query. */\r
+ dnsONE_QUESTION, /* One question is being asked. */\r
+ 0, /* No replies are included. */\r
+ 0, /* No authorities. */\r
+ 0 /* No additional authorities. */\r
};\r
\r
/* Copy in the const part of the header. */\r
\r
/* Write in a unique identifier. */\r
pxDNSMessageHeader = ( DNSMessage_t * ) pucUDPPayloadBuffer;\r
- pxDNSMessageHeader->usIdentifier = ( uint16_t ) xIdentifier;\r
+ pxDNSMessageHeader->usIdentifier = ( uint16_t ) uxIdentifier;\r
\r
/* Create the resource record at the end of the header. First\r
find the end of the header. */\r
( *pucStart )--;\r
\r
pucStart = pucByte;\r
-\r
} while( *pucByte != 0x00 );\r
\r
/* Finish off the record. */\r
\r
- pxTail = (DNSTail_t *)( pucByte + 1 );\r
+ pxTail = ( DNSTail_t * ) ( pucByte + 1 );\r
\r
- vSetField16( pxTail, DNSTail_t, usType, dnsTYPE_A_HOST ); /* Type A: host */\r
- vSetField16( pxTail, DNSTail_t, usClass, dnsCLASS_IN ); /* 1: Class IN */\r
+ vSetField16( pxTail, DNSTail_t, usType, dnsTYPE_A_HOST ); /* Type A: host */\r
+ vSetField16( pxTail, DNSTail_t, usClass, dnsCLASS_IN ); /* 1: Class IN */\r
\r
/* Return the total size of the generated message, which is the space from\r
the last written byte to the beginning of the buffer. */\r
}\r
/*-----------------------------------------------------------*/\r
\r
-#if( ipconfigUSE_DNS_CACHE == 1 )\r
+#if( ipconfigUSE_DNS_CACHE == 1 ) || ( ipconfigDNS_USE_CALLBACKS == 1 )\r
\r
- static uint8_t *prvReadNameField( uint8_t *pucByte, char *pcName, BaseType_t xLen )\r
+ static uint8_t * prvReadNameField( uint8_t *pucByte,\r
+ size_t uxSourceLen,\r
+ char *pcName,\r
+ size_t uxDestLen )\r
{\r
- BaseType_t xNameLen = 0;\r
+ size_t uxNameLen = 0;\r
+ BaseType_t xCount;\r
+\r
+ if( 0 == uxSourceLen )\r
+ {\r
+ return NULL;\r
+ }\r
+\r
/* Determine if the name is the fully coded name, or an offset to the name\r
elsewhere in the message. */\r
if( ( *pucByte & dnsNAME_IS_OFFSET ) == dnsNAME_IS_OFFSET )\r
{\r
/* Jump over the two byte offset. */\r
- pucByte += sizeof( uint16_t );\r
-\r
+ if( uxSourceLen > sizeof( uint16_t ) )\r
+ {\r
+ pucByte += sizeof( uint16_t );\r
+ }\r
+ else\r
+ {\r
+ pucByte = NULL;\r
+ }\r
}\r
else\r
{\r
- /* pucByte points to the full name. Walk over the string. */\r
- while( *pucByte != 0x00 )\r
+ /* pucByte points to the full name. Walk over the string. */\r
+ while( ( NULL != pucByte ) && ( *pucByte != 0x00u ) && ( uxSourceLen > 1u ) )\r
{\r
- BaseType_t xCount;\r
- if( xNameLen && xNameLen < xLen - 1 )\r
- pcName[xNameLen++] = '.';\r
- for( xCount = *(pucByte++); xCount--; pucByte++ )\r
+ /* If this is not the first time through the loop, then add a\r
+ separator in the output. */\r
+ if( ( uxNameLen > 0 ) && ( uxNameLen < ( uxDestLen - 1u ) ) )\r
+ {\r
+ pcName[ uxNameLen++ ] = '.';\r
+ }\r
+\r
+ /* Process the first/next sub-string. */\r
+ for( xCount = *( pucByte++ ), uxSourceLen--;\r
+ xCount-- && uxSourceLen > 1u;\r
+ pucByte++, uxSourceLen-- )\r
{\r
- if( xNameLen < xLen - 1 )\r
- pcName[xNameLen++] = *( ( char * ) pucByte );\r
+ if( uxNameLen < uxDestLen - 1u )\r
+ {\r
+ pcName[ uxNameLen++ ] = *( ( char * ) pucByte );\r
+ }\r
+ else\r
+ {\r
+ /* DNS name is too big for the provided buffer. */\r
+ pucByte = NULL;\r
+ break;\r
+ }\r
}\r
}\r
\r
- pucByte++;\r
+ /* Confirm that a fully formed name was found. */\r
+ if( NULL != pucByte )\r
+ {\r
+ if( 0x00 == *pucByte )\r
+ {\r
+ pucByte++;\r
+ uxSourceLen--;\r
+ pcName[ uxNameLen++ ] = '\0';\r
+ }\r
+ else\r
+ {\r
+ pucByte = NULL;\r
+ }\r
+ }\r
}\r
\r
return pucByte;\r
}\r
-#endif /* ipconfigUSE_DNS_CACHE == 1 */\r
+#endif /* ipconfigUSE_DNS_CACHE || ipconfigDNS_USE_CALLBACKS */\r
/*-----------------------------------------------------------*/\r
\r
-static uint8_t *prvSkipNameField( uint8_t *pucByte )\r
+static uint8_t * prvSkipNameField( uint8_t *pucByte,\r
+ size_t uxSourceLen )\r
{\r
+size_t uxChunkLength;\r
+\r
+ if( 0u == uxSourceLen )\r
+ {\r
+ return NULL;\r
+ }\r
+\r
/* Determine if the name is the fully coded name, or an offset to the name\r
elsewhere in the message. */\r
if( ( *pucByte & dnsNAME_IS_OFFSET ) == dnsNAME_IS_OFFSET )\r
{\r
/* Jump over the two byte offset. */\r
- pucByte += sizeof( uint16_t );\r
-\r
+ if( uxSourceLen > sizeof( uint16_t ) )\r
+ {\r
+ pucByte += sizeof( uint16_t );\r
+ }\r
+ else\r
+ {\r
+ pucByte = NULL;\r
+ }\r
}\r
else\r
{\r
- /* pucByte points to the full name. Walk over the string. */\r
- while( *pucByte != 0x00 )\r
+ /* pucByte points to the full name. Walk over the string. */\r
+ while( ( *pucByte != 0x00u ) && ( uxSourceLen > 1u ) )\r
{\r
- /* The number of bytes to jump for each name section is stored in the byte\r
- before the name section. */\r
- pucByte += ( *pucByte + 1 );\r
+ uxChunkLength = *pucByte + 1u;\r
+\r
+ if( uxSourceLen > uxChunkLength )\r
+ {\r
+ uxSourceLen -= uxChunkLength;\r
+ pucByte += uxChunkLength;\r
+ }\r
+ else\r
+ {\r
+ pucByte = NULL;\r
+ break;\r
+ }\r
}\r
\r
- pucByte++;\r
+ /* Confirm that a fully formed name was found. */\r
+ if( NULL != pucByte )\r
+ {\r
+ if( 0x00u == *pucByte )\r
+ {\r
+ pucByte++;\r
+ }\r
+ else\r
+ {\r
+ pucByte = NULL;\r
+ }\r
+ }\r
}\r
\r
return pucByte;\r
}\r
/*-----------------------------------------------------------*/\r
\r
+/* The function below will only be called :\r
+when ipconfigDNS_USE_CALLBACKS == 1\r
+when ipconfigUSE_LLMNR == 1\r
+for testing purposes, by the module iot_test_freertos_tcp.c\r
+*/\r
uint32_t ulDNSHandlePacket( NetworkBufferDescriptor_t *pxNetworkBuffer )\r
{\r
-uint8_t *pucUDPPayloadBuffer = pxNetworkBuffer->pucEthernetBuffer + sizeof( UDPPacket_t );\r
-DNSMessage_t *pxDNSMessageHeader = ( DNSMessage_t * ) pucUDPPayloadBuffer;\r
-\r
- prvParseDNSReply( pucUDPPayloadBuffer, ( uint32_t ) pxDNSMessageHeader->usIdentifier );\r
+DNSMessage_t *pxDNSMessageHeader;\r
+size_t uxPayloadSize;\r
+\r
+ /* Only proceed if the payload length indicated in the header\r
+ appears to be valid. */\r
+ if( pxNetworkBuffer->xDataLength >= sizeof( UDPPacket_t ) )\r
+ {\r
+ uxPayloadSize = pxNetworkBuffer->xDataLength - sizeof( UDPPacket_t );\r
+\r
+ if( uxPayloadSize >= sizeof( DNSMessage_t ) )\r
+ {\r
+ pxDNSMessageHeader =\r
+ ( DNSMessage_t * ) ( pxNetworkBuffer->pucEthernetBuffer + sizeof( UDPPacket_t ) );\r
+\r
+ /* The parameter pdFALSE indicates that the reply was not expected. */\r
+ prvParseDNSReply( ( uint8_t * ) pxDNSMessageHeader,\r
+ uxPayloadSize,\r
+ pdFALSE );\r
+ }\r
+ }\r
\r
/* The packet was not consumed. */\r
return pdFAIL;\r
\r
#if( ipconfigUSE_NBNS == 1 )\r
\r
- uint32_t ulNBNSHandlePacket (NetworkBufferDescriptor_t *pxNetworkBuffer )\r
+ uint32_t ulNBNSHandlePacket( NetworkBufferDescriptor_t * pxNetworkBuffer )\r
{\r
UDPPacket_t *pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;\r
- uint8_t *pucUDPPayloadBuffer = pxNetworkBuffer->pucEthernetBuffer + sizeof( *pxUDPPacket );\r
+ uint8_t *pucUDPPayloadBuffer = pxNetworkBuffer->pucEthernetBuffer + sizeof( UDPPacket_t );\r
+ size_t uxPayloadSize = pxNetworkBuffer->xDataLength - sizeof( UDPPacket_t );\r
\r
- prvTreatNBNS( pucUDPPayloadBuffer, pxUDPPacket->xIPHeader.ulSourceIPAddress );\r
+ /* The network buffer data length has already been set to the\r
+ length of the UDP payload. */\r
+ prvTreatNBNS( pucUDPPayloadBuffer,\r
+ uxPayloadSize,\r
+ pxUDPPacket->xIPHeader.ulSourceIPAddress );\r
\r
/* The packet was not consumed. */\r
return pdFAIL;\r
#endif /* ipconfigUSE_NBNS */\r
/*-----------------------------------------------------------*/\r
\r
-static uint32_t prvParseDNSReply( uint8_t *pucUDPPayloadBuffer, TickType_t xIdentifier )\r
+static uint32_t prvParseDNSReply( uint8_t *pucUDPPayloadBuffer,\r
+ size_t uxBufferLength,\r
+ BaseType_t xExpected )\r
{\r
DNSMessage_t *pxDNSMessageHeader;\r
-uint32_t ulIPAddress = 0UL;\r
+DNSAnswerRecord_t *pxDNSAnswerRecord;\r
+uint32_t ulIPAddress = 0uL;\r
#if( ipconfigUSE_LLMNR == 1 )\r
char *pcRequestedName = NULL;\r
#endif\r
uint8_t *pucByte;\r
+size_t uxSourceBytesRemaining;\r
uint16_t x, usDataLength, usQuestions;\r
+BaseType_t xDoStore = xExpected;\r
#if( ipconfigUSE_LLMNR == 1 )\r
uint16_t usType = 0, usClass = 0;\r
#endif\r
-#if( ipconfigUSE_DNS_CACHE == 1 )\r
- char pcName[128] = ""; /*_RB_ What is the significance of 128? Probably too big to go on the stack for a small MCU but don't know how else it could be made re-entrant. Might be necessary. */\r
+#if( ipconfigUSE_DNS_CACHE == 1 ) || ( ipconfigDNS_USE_CALLBACKS == 1 )\r
+ char pcName[ ipconfigDNS_CACHE_NAME_LENGTH ] = "";\r
#endif\r
\r
+ /* Ensure that the buffer is of at least minimal DNS message length. */\r
+ if( uxBufferLength < sizeof( DNSMessage_t ) )\r
+ {\r
+ return dnsPARSE_ERROR;\r
+ }\r
+\r
+ uxSourceBytesRemaining = uxBufferLength;\r
+\r
+ /* Parse the DNS message header. */\r
pxDNSMessageHeader = ( DNSMessage_t * ) pucUDPPayloadBuffer;\r
\r
- if( pxDNSMessageHeader->usIdentifier == ( uint16_t ) xIdentifier )\r
+ /* Introduce a do {} while (0) to allow the use of breaks. */\r
+ do\r
{\r
/* Start at the first byte after the header. */\r
pucByte = pucUDPPayloadBuffer + sizeof( DNSMessage_t );\r
+ uxSourceBytesRemaining -= sizeof( DNSMessage_t );\r
\r
/* Skip any question records. */\r
usQuestions = FreeRTOS_ntohs( pxDNSMessageHeader->usQuestions );\r
+\r
for( x = 0; x < usQuestions; x++ )\r
{\r
#if( ipconfigUSE_LLMNR == 1 )\r
}\r
#endif\r
\r
-#if( ipconfigUSE_DNS_CACHE == 1 )\r
+#if( ipconfigUSE_DNS_CACHE == 1 ) || ( ipconfigDNS_USE_CALLBACKS == 1 )\r
if( x == 0 )\r
{\r
- pucByte = prvReadNameField( pucByte, pcName, sizeof( pcName ) );\r
+ pucByte = prvReadNameField( pucByte,\r
+ uxSourceBytesRemaining,\r
+ pcName,\r
+ sizeof( pcName ) );\r
+\r
+ /* Check for a malformed response. */\r
+ if( NULL == pucByte )\r
+ {\r
+ return dnsPARSE_ERROR;\r
+ }\r
+\r
+ uxSourceBytesRemaining = ( pucUDPPayloadBuffer + uxBufferLength ) - pucByte;\r
}\r
else\r
-#endif /* ipconfigUSE_DNS_CACHE */\r
+#endif /* ipconfigUSE_DNS_CACHE || ipconfigDNS_USE_CALLBACKS */\r
{\r
/* Skip the variable length pcName field. */\r
- pucByte = prvSkipNameField( pucByte );\r
+ pucByte = prvSkipNameField( pucByte,\r
+ uxSourceBytesRemaining );\r
+\r
+ /* Check for a malformed response. */\r
+ if( NULL == pucByte )\r
+ {\r
+ return dnsPARSE_ERROR;\r
+ }\r
+\r
+ uxSourceBytesRemaining = ( size_t )\r
+ ( pucUDPPayloadBuffer + uxBufferLength - pucByte );\r
}\r
\r
- #if( ipconfigUSE_LLMNR == 1 )\r
+ /* Check the remaining buffer size. */\r
+ if( uxSourceBytesRemaining >= sizeof( uint32_t ) )\r
{\r
- /* usChar2u16 returns value in host endianness. */\r
- usType = usChar2u16( pucByte );\r
- usClass = usChar2u16( pucByte + 2 );\r
- }\r
- #endif /* ipconfigUSE_LLMNR */\r
+ #if( ipconfigUSE_LLMNR == 1 )\r
+ {\r
+ /* usChar2u16 returns value in host endianness. */\r
+ usType = usChar2u16( pucByte );\r
+ usClass = usChar2u16( pucByte + 2 );\r
+ }\r
+ #endif /* ipconfigUSE_LLMNR */\r
\r
- /* Skip the type and class fields. */\r
- pucByte += sizeof( uint32_t );\r
+ /* Skip the type and class fields. */\r
+ pucByte += sizeof( uint32_t );\r
+ uxSourceBytesRemaining -= sizeof( uint32_t );\r
+ }\r
+ else\r
+ {\r
+ /* Malformed response. */\r
+ return dnsPARSE_ERROR;\r
+ }\r
}\r
\r
- /* Search through the answers records. */\r
+ /* Search through the answer records. */\r
pxDNSMessageHeader->usAnswers = FreeRTOS_ntohs( pxDNSMessageHeader->usAnswers );\r
\r
if( ( pxDNSMessageHeader->usFlags & dnsRX_FLAGS_MASK ) == dnsEXPECTED_RX_FLAGS )\r
{\r
for( x = 0; x < pxDNSMessageHeader->usAnswers; x++ )\r
{\r
- pucByte = prvSkipNameField( pucByte );\r
+ pucByte = prvSkipNameField( pucByte,\r
+ uxSourceBytesRemaining );\r
\r
- /* Is the type field that of an A record? */\r
- if( usChar2u16( pucByte ) == dnsTYPE_A_HOST )\r
+ /* Check for a malformed response. */\r
+ if( NULL == pucByte )\r
{\r
- /* This is the required record. Skip the type, class, and\r
- time to live fields, plus the first byte of the data\r
- length. */\r
- pucByte += ( sizeof( uint32_t ) + sizeof( uint32_t ) + sizeof( uint8_t ) );\r
+ return dnsPARSE_ERROR;\r
+ }\r
\r
- /* Sanity check the data length. */\r
- if( ( size_t ) *pucByte == sizeof( uint32_t ) )\r
- {\r
- /* Skip the second byte of the length. */\r
- pucByte++;\r
+ uxSourceBytesRemaining = ( size_t )\r
+ ( pucUDPPayloadBuffer + uxBufferLength - pucByte );\r
\r
+ /* Is there enough data for an IPv4 A record answer and, if so,\r
+ is this an A record? */\r
+ if( ( uxSourceBytesRemaining >= ( sizeof( DNSAnswerRecord_t ) + sizeof( uint32_t ) ) ) &&\r
+ ( usChar2u16( pucByte ) == dnsTYPE_A_HOST ) )\r
+ {\r
+ /* This is the required record type and is of sufficient size. */\r
+ pxDNSAnswerRecord = ( DNSAnswerRecord_t * ) pucByte;\r
+\r
+ /* Sanity check the data length of an IPv4 answer. */\r
+ if( FreeRTOS_ntohs( pxDNSAnswerRecord->usDataLength ) == sizeof( uint32_t ) )\r
+ {\r
/* Copy the IP address out of the record. */\r
- memcpy( ( void * ) &ulIPAddress, ( void * ) pucByte, sizeof( uint32_t ) );\r
+ memcpy( &ulIPAddress,\r
+ pucByte + sizeof( DNSAnswerRecord_t ),\r
+ sizeof( uint32_t ) );\r
\r
- #if( ipconfigUSE_DNS_CACHE == 1 )\r
+ #if( ipconfigDNS_USE_CALLBACKS == 1 )\r
{\r
- prvProcessDNSCache( pcName, &ulIPAddress, pdFALSE );\r
+ /* See if any asynchronous call was made to FreeRTOS_gethostbyname_a() */\r
+ if( xDNSDoCallback( ( TickType_t ) pxDNSMessageHeader->usIdentifier, pcName, ulIPAddress ) != pdFALSE )\r
+ {\r
+ /* This device has requested this DNS look-up.\r
+ The result may be stored in the DNS cache. */\r
+ xDoStore = pdTRUE;\r
+ }\r
}\r
- #endif /* ipconfigUSE_DNS_CACHE */\r
- #if( ipconfigDNS_USE_CALLBACKS != 0 )\r
+ #endif /* ipconfigDNS_USE_CALLBACKS == 1 */\r
+ #if( ipconfigUSE_DNS_CACHE == 1 )\r
{\r
- /* See if any asynchronous call was made to FreeRTOS_gethostbyname_a() */\r
- vDNSDoCallback( ( TickType_t ) pxDNSMessageHeader->usIdentifier, pcName, ulIPAddress );\r
+ /* The reply will only be stored in the DNS cache when the\r
+ request was issued by this device. */\r
+ if( xDoStore != pdFALSE )\r
+ {\r
+ prvProcessDNSCache( pcName, &ulIPAddress, pxDNSAnswerRecord->ulTTL, pdFALSE );\r
+ }\r
+\r
+ /* Show what has happened. */\r
+ FreeRTOS_printf( ( "DNS[0x%04X]: The answer to '%s' (%xip) will%s be stored\n",\r
+ ( unsigned ) pxDNSMessageHeader->usIdentifier,\r
+ pcName,\r
+ ( unsigned ) FreeRTOS_ntohl( ulIPAddress ),\r
+ ( xDoStore != 0 ) ? "" : " NOT" ) );\r
}\r
- #endif /* ipconfigDNS_USE_CALLBACKS != 0 */\r
+ #endif /* ipconfigUSE_DNS_CACHE */\r
}\r
\r
+ pucByte += sizeof( DNSAnswerRecord_t ) + sizeof( uint32_t );\r
+ uxSourceBytesRemaining -= ( sizeof( DNSAnswerRecord_t ) + sizeof( uint32_t ) );\r
break;\r
}\r
- else\r
+ else if( uxSourceBytesRemaining >= sizeof( DNSAnswerRecord_t ) )\r
{\r
- /* Skip the type, class and time to live fields. */\r
- pucByte += ( sizeof( uint32_t ) + sizeof( uint32_t ) );\r
+ /* It's not an A record, so skip it. Get the header location\r
+ and then jump over the header. */\r
+ pxDNSAnswerRecord = ( DNSAnswerRecord_t * ) pucByte;\r
+ pucByte += sizeof( DNSAnswerRecord_t );\r
+ uxSourceBytesRemaining -= sizeof( DNSAnswerRecord_t );\r
\r
- /* Determine the length of the data in the field. */\r
- memcpy( ( void * ) &usDataLength, ( void * ) pucByte, sizeof( uint16_t ) );\r
- usDataLength = FreeRTOS_ntohs( usDataLength );\r
+ /* Determine the length of the answer data from the header. */\r
+ usDataLength = FreeRTOS_ntohs( pxDNSAnswerRecord->usDataLength );\r
\r
- /* Jump over the data length bytes, and the data itself. */\r
- pucByte += usDataLength + sizeof( uint16_t );\r
+ /* Jump over the answer. */\r
+ if( uxSourceBytesRemaining >= usDataLength )\r
+ {\r
+ pucByte += usDataLength;\r
+ uxSourceBytesRemaining -= usDataLength;\r
+ }\r
+ else\r
+ {\r
+ /* Malformed response. */\r
+ return dnsPARSE_ERROR;\r
+ }\r
}\r
}\r
}\r
+\r
#if( ipconfigUSE_LLMNR == 1 )\r
- else if( ( usQuestions != ( uint16_t )0u ) && ( usType == ( uint16_t )dnsTYPE_A_HOST ) && ( usClass == ( uint16_t )dnsCLASS_IN ) )\r
+ else if( usQuestions && ( usType == dnsTYPE_A_HOST ) && ( usClass == dnsCLASS_IN ) )\r
{\r
/* If this is not a reply to our DNS request, it might an LLMNR\r
request. */\r
- if( xApplicationDNSQueryHook ( ( pcRequestedName + 1 ) ) )\r
+ if( xApplicationDNSQueryHook( ( pcRequestedName + 1 ) ) )\r
{\r
int16_t usLength;\r
NetworkBufferDescriptor_t *pxNewBuffer = NULL;\r
\r
if( ( xBufferAllocFixedSize == pdFALSE ) && ( pxNetworkBuffer != NULL ) )\r
{\r
- BaseType_t xDataLength = pxNetworkBuffer->xDataLength + sizeof( UDPHeader_t ) +\r
- sizeof( EthernetHeader_t ) + sizeof( IPHeader_t );\r
+ BaseType_t xDataLength = uxBufferLength + sizeof( UDPHeader_t ) + sizeof( EthernetHeader_t ) + sizeof( IPHeader_t );\r
\r
- /* The field xDataLength was set to the length of the UDP payload.\r
- The answer (reply) will be longer than the request, so the packet\r
- must be duplicaed into a bigger buffer */\r
+ /* Set the size of the outgoing packet. */\r
pxNetworkBuffer->xDataLength = xDataLength;\r
- pxNewBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, xDataLength + 16 );\r
+ pxNewBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, xDataLength + sizeof( LLMNRAnswer_t ) );\r
+\r
if( pxNewBuffer != NULL )\r
{\r
BaseType_t xOffset1, xOffset2;\r
pucByte = pucUDPPayloadBuffer + xOffset1;\r
pcRequestedName = ( char * ) ( pucUDPPayloadBuffer + xOffset2 );\r
pxDNSMessageHeader = ( DNSMessage_t * ) pucUDPPayloadBuffer;\r
-\r
}\r
else\r
{\r
pxNetworkBuffer = NULL;\r
}\r
}\r
+\r
if( pxNetworkBuffer != NULL )\r
{\r
- pxAnswer = (LLMNRAnswer_t *)pucByte;\r
+ pxAnswer = ( LLMNRAnswer_t * ) pucByte;\r
\r
- /* Leave 'usIdentifier' and 'usQuestions' untouched. */\r
- vSetField16( pxDNSMessageHeader, DNSMessage_t, usFlags, dnsLLMNR_FLAGS_IS_REPONSE ); /* Set the response flag */\r
- vSetField16( pxDNSMessageHeader, DNSMessage_t, usAnswers, 1 ); /* Provide a single answer */\r
- vSetField16( pxDNSMessageHeader, DNSMessage_t, usAuthorityRRs, 0 ); /* No authority */\r
- vSetField16( pxDNSMessageHeader, DNSMessage_t, usAdditionalRRs, 0 ); /* No additional info */\r
+ /* We leave 'usIdentifier' and 'usQuestions' untouched */\r
+ vSetField16( pxDNSMessageHeader, DNSMessage_t, usFlags, dnsLLMNR_FLAGS_IS_REPONSE ); /* Set the response flag */\r
+ vSetField16( pxDNSMessageHeader, DNSMessage_t, usAnswers, 1 ); /* Provide a single answer */\r
+ vSetField16( pxDNSMessageHeader, DNSMessage_t, usAuthorityRRs, 0 ); /* No authority */\r
+ vSetField16( pxDNSMessageHeader, DNSMessage_t, usAdditionalRRs, 0 ); /* No additional info */\r
\r
pxAnswer->ucNameCode = dnsNAME_IS_OFFSET;\r
- pxAnswer->ucNameOffset = ( uint8_t )( pcRequestedName - ( char * ) pucUDPPayloadBuffer );\r
+ pxAnswer->ucNameOffset = ( uint8_t ) ( pcRequestedName - ( char * ) pucUDPPayloadBuffer );\r
\r
- vSetField16( pxAnswer, LLMNRAnswer_t, usType, dnsTYPE_A_HOST ); /* Type A: host */\r
- vSetField16( pxAnswer, LLMNRAnswer_t, usClass, dnsCLASS_IN ); /* 1: Class IN */\r
+ vSetField16( pxAnswer, LLMNRAnswer_t, usType, dnsTYPE_A_HOST ); /* Type A: host */\r
+ vSetField16( pxAnswer, LLMNRAnswer_t, usClass, dnsCLASS_IN ); /* 1: Class IN */\r
vSetField32( pxAnswer, LLMNRAnswer_t, ulTTL, dnsLLMNR_TTL_VALUE );\r
vSetField16( pxAnswer, LLMNRAnswer_t, usDataLength, 4 );\r
vSetField32( pxAnswer, LLMNRAnswer_t, ulIPAddress, FreeRTOS_ntohl( *ipLOCAL_IP_ADDRESS_POINTER ) );\r
}\r
}\r
#endif /* ipconfigUSE_LLMNR == 1 */\r
+ } while( 0 );\r
+\r
+ if( xExpected == pdFALSE )\r
+ {\r
+ /* Do not return a valid IP-address in case the reply was not expected. */\r
+ ulIPAddress = 0uL;\r
}\r
\r
return ulIPAddress;\r
\r
#if( ipconfigUSE_NBNS == 1 )\r
\r
- static void prvTreatNBNS( uint8_t *pucUDPPayloadBuffer, uint32_t ulIPAddress )\r
+ static void prvTreatNBNS( uint8_t *pucUDPPayloadBuffer,\r
+ size_t uxBufferLength,\r
+ uint32_t ulIPAddress )\r
{\r
- uint16_t usFlags, usType, usClass;\r
- uint8_t *pucSource, *pucTarget;\r
- uint8_t ucByte;\r
- uint8_t ucNBNSName[ 17 ];\r
+ uint16_t usFlags, usType, usClass;\r
+ uint8_t *pucSource, *pucTarget;\r
+ uint8_t ucByte;\r
+ uint8_t ucNBNSName[ 17 ];\r
+\r
+ /* Check for minimum buffer size. */\r
+ if( uxBufferLength < sizeof( NBNSRequest_t ) )\r
+ {\r
+ return;\r
+ }\r
\r
+ /* Read the request flags in host endianness. */\r
usFlags = usChar2u16( pucUDPPayloadBuffer + offsetof( NBNSRequest_t, usFlags ) );\r
\r
if( ( usFlags & dnsNBNS_FLAGS_OPCODE_MASK ) == dnsNBNS_FLAGS_OPCODE_QUERY )\r
usClass = usChar2u16( pucUDPPayloadBuffer + offsetof( NBNSRequest_t, usClass ) );\r
\r
/* Not used for now */\r
- ( void )usClass;\r
+ ( void ) usClass;\r
+\r
/* For NBNS a name is 16 bytes long, written with capitals only.\r
Make sure that the copy is terminated with a zero. */\r
- pucTarget = ucNBNSName + sizeof(ucNBNSName ) - 2;\r
+ pucTarget = ucNBNSName + sizeof( ucNBNSName ) - 2;\r
pucTarget[ 1 ] = '\0';\r
\r
/* Start with decoding the last 2 bytes. */\r
{\r
/* If this is a response from another device,\r
add the name to the DNS cache */\r
- prvProcessDNSCache( ( char * ) ucNBNSName, &ulIPAddress, pdFALSE );\r
+ prvProcessDNSCache( ( char * ) ucNBNSName, &ulIPAddress, 0, pdFALSE );\r
}\r
}\r
#else\r
if( ( xBufferAllocFixedSize == pdFALSE ) && ( pxNetworkBuffer != NULL ) )\r
{\r
NetworkBufferDescriptor_t *pxNewBuffer;\r
- BaseType_t xDataLength = pxNetworkBuffer->xDataLength + sizeof( UDPHeader_t ) +\r
\r
- sizeof( EthernetHeader_t ) + sizeof( IPHeader_t );\r
+ /* The field xDataLength was set to the total length of the UDP packet,\r
+ i.e. the payload size plus sizeof( UDPPacket_t ). */\r
+ pxNewBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, pxNetworkBuffer->xDataLength + sizeof( NBNSAnswer_t ) );\r
\r
- /* The field xDataLength was set to the length of the UDP payload.\r
- The answer (reply) will be longer than the request, so the packet\r
- must be duplicated into a bigger buffer */\r
- pxNetworkBuffer->xDataLength = xDataLength;\r
- pxNewBuffer = pxDuplicateNetworkBufferWithDescriptor( pxNetworkBuffer, xDataLength + 16 );\r
if( pxNewBuffer != NULL )\r
{\r
pucUDPPayloadBuffer = pxNewBuffer->pucEthernetBuffer + sizeof( UDPPacket_t );\r
/* Should not occur: pucUDPPayloadBuffer is part of a xNetworkBufferDescriptor */\r
if( pxNetworkBuffer != NULL )\r
{\r
- pxMessage = (DNSMessage_t *)pucUDPPayloadBuffer;\r
+ pxMessage = ( DNSMessage_t * ) pucUDPPayloadBuffer;\r
\r
/* As the fields in the structures are not word-aligned, we have to\r
copy the values byte-by-byte using macro's vSetField16() and vSetField32() */\r
vSetField16( pxMessage, DNSMessage_t, usAuthorityRRs, 0 );\r
vSetField16( pxMessage, DNSMessage_t, usAdditionalRRs, 0 );\r
\r
- pxAnswer = (NBNSAnswer_t *)( pucUDPPayloadBuffer + offsetof( NBNSRequest_t, usType ) );\r
+ pxAnswer = ( NBNSAnswer_t * ) ( pucUDPPayloadBuffer + offsetof( NBNSRequest_t, usType ) );\r
\r
- vSetField16( pxAnswer, NBNSAnswer_t, usType, usType ); /* Type */\r
- vSetField16( pxAnswer, NBNSAnswer_t, usClass, dnsNBNS_CLASS_IN ); /* Class */\r
+ vSetField16( pxAnswer, NBNSAnswer_t, usType, usType ); /* Type */\r
+ vSetField16( pxAnswer, NBNSAnswer_t, usClass, dnsNBNS_CLASS_IN ); /* Class */\r
vSetField32( pxAnswer, NBNSAnswer_t, ulTTL, dnsNBNS_TTL_VALUE );\r
- vSetField16( pxAnswer, NBNSAnswer_t, usDataLength, 6 ); /* 6 bytes including the length field */\r
+ vSetField16( pxAnswer, NBNSAnswer_t, usDataLength, 6 ); /* 6 bytes including the length field */\r
vSetField16( pxAnswer, NBNSAnswer_t, usNbFlags, dnsNBNS_NAME_FLAGS );\r
vSetField32( pxAnswer, NBNSAnswer_t, ulIPAddress, FreeRTOS_ntohl( *ipLOCAL_IP_ADDRESS_POINTER ) );\r
\r
}\r
}\r
\r
-#endif /* ipconfigUSE_NBNS */\r
+#endif /* ipconfigUSE_NBNS */\r
/*-----------------------------------------------------------*/\r
\r
static Socket_t prvCreateDNSSocket( void )\r
Socket_t xSocket = NULL;\r
struct freertos_sockaddr xAddress;\r
BaseType_t xReturn;\r
-TickType_t xTimeoutTime = pdMS_TO_TICKS( 200 );\r
\r
/* This must be the first time this function has been called. Create\r
the socket. */\r
}\r
else\r
{\r
- /* Set the send and receive timeouts. */\r
- FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, ( void * ) &xTimeoutTime, sizeof( TickType_t ) );\r
- FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, ( void * ) &xTimeoutTime, sizeof( TickType_t ) );\r
+ /* The send and receive timeouts will be set later on. */\r
}\r
\r
return xSocket;\r
\r
#if( ( ipconfigUSE_NBNS == 1 ) || ( ipconfigUSE_LLMNR == 1 ) )\r
\r
- static void prvReplyDNSMessage( NetworkBufferDescriptor_t *pxNetworkBuffer, BaseType_t lNetLength )\r
+ static void prvReplyDNSMessage( NetworkBufferDescriptor_t *pxNetworkBuffer,\r
+ BaseType_t lNetLength )\r
{\r
UDPPacket_t *pxUDPPacket;\r
IPHeader_t *pxIPHeader;\r
UDPHeader_t *pxUDPHeader;\r
\r
- pxUDPPacket = (UDPPacket_t *) pxNetworkBuffer->pucEthernetBuffer;\r
+ pxUDPPacket = ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;\r
pxIPHeader = &pxUDPPacket->xIPHeader;\r
pxUDPHeader = &pxUDPPacket->xUDPHeader;\r
/* HT: started using defines like 'ipSIZE_OF_xxx' */\r
- pxIPHeader->usLength = FreeRTOS_htons( lNetLength + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_UDP_HEADER );\r
+ pxIPHeader->usLength = FreeRTOS_htons( lNetLength + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_UDP_HEADER );\r
/* HT:endian: should not be translated, copying from packet to packet */\r
pxIPHeader->ulDestinationIPAddress = pxIPHeader->ulSourceIPAddress;\r
- pxIPHeader->ulSourceIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;\r
- pxIPHeader->ucTimeToLive = ipconfigUDP_TIME_TO_LIVE;\r
- pxIPHeader->usIdentification = FreeRTOS_htons( usPacketIdentifier );\r
+ pxIPHeader->ulSourceIPAddress = *ipLOCAL_IP_ADDRESS_POINTER;\r
+ pxIPHeader->ucTimeToLive = ipconfigUDP_TIME_TO_LIVE;\r
+ pxIPHeader->usIdentification = FreeRTOS_htons( usPacketIdentifier );\r
usPacketIdentifier++;\r
- pxUDPHeader->usLength = FreeRTOS_htons( lNetLength + ipSIZE_OF_UDP_HEADER );\r
+ pxUDPHeader->usLength = FreeRTOS_htons( lNetLength + ipSIZE_OF_UDP_HEADER );\r
vFlip_16( pxUDPPacket->xUDPHeader.usSourcePort, pxUDPPacket->xUDPHeader.usDestinationPort );\r
\r
+ /* Important: tell NIC driver how many bytes must be sent */\r
+ pxNetworkBuffer->xDataLength = ( size_t ) ( lNetLength + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_UDP_HEADER + ipSIZE_OF_ETH_HEADER );\r
+\r
#if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )\r
{\r
/* calculate the IP header checksum */\r
- pxIPHeader->usHeaderChecksum = 0x00;\r
- pxIPHeader->usHeaderChecksum = usGenerateChecksum( 0UL, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ipSIZE_OF_IPv4_HEADER );\r
- pxIPHeader->usHeaderChecksum = ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum );\r
+ pxIPHeader->usHeaderChecksum = 0x00;\r
+ pxIPHeader->usHeaderChecksum = usGenerateChecksum( 0uL, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ipSIZE_OF_IPv4_HEADER );\r
+ pxIPHeader->usHeaderChecksum = ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum );\r
\r
/* calculate the UDP checksum for outgoing package */\r
- usGenerateProtocolChecksum( ( uint8_t* ) pxUDPPacket, pdTRUE );\r
+ usGenerateProtocolChecksum( ( uint8_t* ) pxUDPPacket, pxNetworkBuffer->xDataLength, pdTRUE );\r
}\r
#endif\r
\r
- /* Important: tell NIC driver how many bytes must be sent */\r
- pxNetworkBuffer->xDataLength = ( size_t ) ( lNetLength + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_UDP_HEADER + ipSIZE_OF_ETH_HEADER );\r
-\r
/* This function will fill in the eth addresses and send the packet */\r
vReturnEthernetFrame( pxNetworkBuffer, pdFALSE );\r
}\r
\r
#if( ipconfigUSE_DNS_CACHE == 1 )\r
\r
- static void prvProcessDNSCache( const char *pcName, uint32_t *pulIP, BaseType_t xLookUp )\r
+ static void prvProcessDNSCache( const char *pcName,\r
+ uint32_t *pulIP,\r
+ uint32_t ulTTL,\r
+ BaseType_t xLookUp )\r
{\r
BaseType_t x;\r
BaseType_t xFound = pdFALSE;\r
+ uint32_t ulCurrentTimeSeconds = ( xTaskGetTickCount() / portTICK_PERIOD_MS ) / 1000;\r
static BaseType_t xFreeEntry = 0;\r
+ configASSERT(pcName);\r
\r
/* For each entry in the DNS cache table. */\r
for( x = 0; x < ipconfigDNS_CACHE_ENTRIES; x++ )\r
{\r
if( xDNSCache[ x ].pcName[ 0 ] == 0 )\r
{\r
- break;\r
+ continue;\r
}\r
\r
- if( strncmp( xDNSCache[ x ].pcName, pcName, sizeof( xDNSCache[ x ].pcName ) ) == 0 )\r
+ if( 0 == strcmp( xDNSCache[ x ].pcName, pcName ) )\r
{\r
/* Is this function called for a lookup or to add/update an IP address? */\r
if( xLookUp != pdFALSE )\r
{\r
- *pulIP = xDNSCache[ x ].ulIPAddress;\r
+ /* Confirm that the record is still fresh. */\r
+ if( ulCurrentTimeSeconds < ( xDNSCache[ x ].ulTimeWhenAddedInSeconds + FreeRTOS_ntohl( xDNSCache[ x ].ulTTL ) ) )\r
+ {\r
+ *pulIP = xDNSCache[ x ].ulIPAddress;\r
+ }\r
+ else\r
+ {\r
+ /* Age out the old cached record. */\r
+ xDNSCache[ x ].pcName[ 0 ] = 0;\r
+ }\r
}\r
else\r
{\r
xDNSCache[ x ].ulIPAddress = *pulIP;\r
+ xDNSCache[ x ].ulTTL = ulTTL;\r
+ xDNSCache[ x ].ulTimeWhenAddedInSeconds = ulCurrentTimeSeconds;\r
}\r
\r
xFound = pdTRUE;\r
}\r
else\r
{\r
- /* Called to add or update an item */\r
- strncpy( xDNSCache[ xFreeEntry ].pcName, pcName, sizeof( xDNSCache[ xFreeEntry ].pcName ) );\r
- xDNSCache[ xFreeEntry ].ulIPAddress = *pulIP;\r
-\r
- xFreeEntry++;\r
- if( xFreeEntry == ipconfigDNS_CACHE_ENTRIES )\r
+ /* Add or update the item. */\r
+ if( strlen( pcName ) < ipconfigDNS_CACHE_NAME_LENGTH )\r
{\r
- xFreeEntry = 0;\r
+ strcpy( xDNSCache[ xFreeEntry ].pcName, pcName );\r
+\r
+ xDNSCache[ xFreeEntry ].ulIPAddress = *pulIP;\r
+ xDNSCache[ xFreeEntry ].ulTTL = ulTTL;\r
+ xDNSCache[ xFreeEntry ].ulTimeWhenAddedInSeconds = ulCurrentTimeSeconds;\r
+\r
+ xFreeEntry++;\r
+\r
+ if( xFreeEntry == ipconfigDNS_CACHE_ENTRIES )\r
+ {\r
+ xFreeEntry = 0;\r
+ }\r
}\r
}\r
}\r
\r
#endif /* ipconfigUSE_DNS != 0 */\r
\r
+/*-----------------------------------------------------------*/\r
+\r
+/* Provide access to private members for testing. */\r
+#ifdef AMAZON_FREERTOS_ENABLE_UNIT_TESTS\r
+ #include "iot_freertos_tcp_test_access_dns_define.h"\r
+#endif\r
\r
projects / freertos / blobdiff