git.sur5r.net Git - freertos/blob - FreeRTOS-Plus/Source/FreeRTOS-Plus-UDP/FreeRTOS_DHCP.c

   1 /*\r
   2  * FreeRTOS+UDP V1.0.0 (C) 2013 Real Time Engineers ltd.\r
   3  *\r
   4  * This file is part of the FreeRTOS+UDP distribution.  The FreeRTOS+UDP license\r
   5  * terms are different to the FreeRTOS license terms.\r
   6  *\r
   7  * FreeRTOS+UDP uses a dual license model that allows the software to be used\r
   8  * under a pure GPL open source license (as opposed to the modified GPL license\r
   9  * under which FreeRTOS is distributed) or a commercial license.  Details of\r
  10  * both license options follow:\r
  11  *\r
  12  * - Open source licensing -\r
  13  * FreeRTOS+UDP is a free download and may be used, modified, evaluated and\r
  14  * distributed without charge provided the user adheres to version two of the\r
  15  * GNU General Public License (GPL) and does not remove the copyright notice or\r
  16  * this text.  The GPL V2 text is available on the gnu.org web site, and on the\r
  17  * following URL: http://www.FreeRTOS.org/gpl-2.0.txt.\r
  18  *\r
  19  * - Commercial licensing -\r
  20  * Businesses and individuals that for commercial or other reasons cannot comply\r
  21  * with the terms of the GPL V2 license must obtain a commercial license before\r
  22  * incorporating FreeRTOS+UDP into proprietary software for distribution in any\r
  23  * form.  Commercial licenses can be purchased from http://shop.freertos.org/udp\r
  24  * and do not require any source files to be changed.\r
  25  *\r
  26  * FreeRTOS+UDP is distributed in the hope that it will be useful.  You cannot\r
  27  * use FreeRTOS+UDP unless you agree that you use the software 'as is'.\r
  28  * FreeRTOS+UDP is provided WITHOUT ANY WARRANTY; without even the implied\r
  29  * warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR\r
  30  * PURPOSE. Real Time Engineers Ltd. disclaims all conditions and terms, be they\r
  31  * implied, expressed, or statutory.\r
  32  *\r
  33  * 1 tab == 4 spaces!\r
  34  *\r
  35  * http://www.FreeRTOS.org\r
  36  * http://www.FreeRTOS.org/udp\r
  37  *\r
  38  */\r
  39 \r
  40 /* Standard includes. */\r
  41 #include <stdint.h>\r
  42 \r
  43 /* FreeRTOS includes. */\r
  44 #include "FreeRTOS.h"\r
  45 #include "task.h"\r
  46 #include "queue.h"\r
  47 #include "timers.h"\r
  48 \r
  49 /* FreeRTOS+UDP includes. */\r
  50 #include "FreeRTOS_UDP_IP.h"\r
  51 #include "FreeRTOS_IP_Private.h"\r
  52 #include "FreeRTOS_DHCP.h"\r
  53 #include "FreeRTOS_Sockets.h"\r
  54 #include "NetworkInterface.h"\r
  55 #include "IPTraceMacroDefaults.h"\r
  56 \r
  57 /* Exclude the entire file if DHCP is not enabled. */\r
  58 #if ipconfigUSE_DHCP != 0\r
  59 \r
  60 #if ( ipconfigUSE_DHCP != 0 ) && ( ipconfigNETWORK_MTU < 586 )\r
  61         /* DHCP must be able to receive an options field of 312 bytes, the fixed\r
  62         part of the DHCP packet is 240 bytes, and the IP/UDP headers take 28 bytes. */\r
  63         #error ipconfigNETWORK_MTU needs to be at least 586 to use DHCP (588 if ipconfigCAN_FRAGMENT_OUTGOING_PACKETS is set to 1)\r
  64 #endif\r
  65 \r
  66 /* Parameter widths in the DHCP packet. */\r
  67 #define dhcpCLIENT_HARDWARE_ADDRESS_LENGTH              16\r
  68 #define dhcpSERVER_HOST_NAME_LENGTH                             64\r
  69 #define dhcpBOOT_FILE_NAME_LENGTH                               128\r
  70 \r
  71 /* Timer parameters.  Windows simulator times are much shorter because simulated\r
  72 time is not real time. */\r
  73 #ifdef _WINDOWS_\r
  74         #define dhcpINITIAL_DHCP_TX_PERIOD                      ( 100 / portTICK_RATE_MS )\r
  75         #define dhcpINITIAL_TIMER_PERIOD                        ( 10 / portTICK_RATE_MS )\r
  76         #define dhcpMAX_TIME_TO_WAIT_FOR_ACK            ( 200 / portTICK_RATE_MS )\r
  77 #else\r
  78         #define dhcpINITIAL_DHCP_TX_PERIOD                      ( 5000 / portTICK_RATE_MS )\r
  79         #define dhcpINITIAL_TIMER_PERIOD                        ( 250 / portTICK_RATE_MS )\r
  80         #define dhcpMAX_TIME_TO_WAIT_FOR_ACK            ( 5000 / portTICK_RATE_MS )\r
  81 #endif /* _WINDOWS_ */\r
  82 \r
  83 /* Codes of interest found in the DHCP options field. */\r
  84 #define dhcpSUBNET_MASK_OPTION_CODE                             ( 1 )\r
  85 #define dhcpGATEWAY_OPTION_CODE                                 ( 3 )\r
  86 #define hdcpDNS_SERVER_OPTIONS_CODE                             ( 6 )\r
  87 #define dhcpMESSAGE_TYPE_OPTION_CODE                    ( 53 )\r
  88 #define dhcpLEASE_TIME_OPTION_CODE                              ( 51 )\r
  89 #define dhcpCLIENT_IDENTIFIER_OPTION_CODE               ( 61 )\r
  90 #define dhcpPARAMETER_REQUEST_OPTION_CODE               ( 55 )\r
  91 #define dhcpREQUEST_IP_ADDRESS_OPTION_CODE              ( 50 )\r
  92 #define dhcpSERVER_IP_ADDRESS_OPTION_CODE               ( 54 )\r
  93 \r
  94 /* The four DHCP message types of interest. */\r
  95 #define dhcpMESSAGE_TYPE_DISCOVER                               ( 1 )\r
  96 #define dhcpMESSAGE_TYPE_OFFER                                  ( 2 )\r
  97 #define dhcpMESSAGE_TYPE_REQUEST                                ( 3 )\r
  98 #define dhcpMESSAGE_TYPE_ACK                                    ( 5 )\r
  99 #define dhcpMESSAGE_TYPE_NACK                                   ( 6 )\r
 100 \r
 101 /* Offsets into the transmitted DHCP options fields at which various parameters\r
 102 are located. */\r
 103 #define dhcpCLIENT_IDENTIFIER_OFFSET                    ( 5 )\r
 104 #define dhcpREQUESTED_IP_ADDRESS_OFFSET                 ( 13 )\r
 105 #define dhcpDHCP_SERVER_IP_ADDRESS_OFFSET               ( 19 )\r
 106 \r
 107 /* Values used in the DHCP packets. */\r
 108 #define dhcpREQUEST_OPCODE                                              ( 1 )\r
 109 #define dhcpREPLY_OPCODE                                                ( 2 )\r
 110 #define dhcpADDRESS_TYPE_ETHERNET                               ( 1 )\r
 111 #define dhcpETHERNET_ADDRESS_LENGTH                             ( 6 )\r
 112 \r
 113 /* If a lease time is not received, use the default of two days. */\r
 114 #define dhcpDEFAULT_LEASE_TIME                                  ( ( 48UL * 60UL * 60UL * 1000UL ) / portTICK_RATE_MS ) /* 48 hours in ticks. */\r
 115 \r
 116 /* Don't allow the lease time to be too short. */\r
 117 #define dhcpMINIMUM_LEASE_TIME                                  ( 60000UL / portTICK_RATE_MS )  /* 60 seconds in ticks. */\r
 118 \r
 119 /* Marks the end of the variable length options field in the DHCP packet. */\r
 120 #define dhcpOPTION_END_BYTE 0xff\r
 121 \r
 122 /* Offset into a DHCP message at which the first byte of the options is\r
 123 located. */\r
 124 #define dhcpFIRST_OPTION_BYTE_OFFSET                    ( 0xf0 )\r
 125 \r
 126 /* When walking the variable length options field, the following value is used\r
 127 to ensure the walk has not gone past the end of the valid options.  2 bytes is\r
 128 made up of the length byte, and minimum one byte value. */\r
 129 #define dhcpMAX_OPTION_LENGTH_OF_INTEREST               ( 2L )\r
 130 \r
 131 /* Standard DHCP port numbers and magic cookie value. */\r
 132 #if( ipconfigBYTE_ORDER == FREERTOS_LITTLE_ENDIAN )\r
 133         #define dhcpCLIENT_PORT 0x4400\r
 134         #define dhcpSERVER_PORT 0x4300\r
 135         #define dhcpCOOKIE              0x63538263\r
 136 #else\r
 137         #define dhcpCLIENT_PORT 0x0044\r
 138         #define dhcpSERVER_PORT 0x0043\r
 139         #define dhcpCOOKIE              0x63825363\r
 140 #endif /* ipconfigBYTE_ORDER */\r
 141 \r
 142 #include "pack_struct_start.h"\r
 143 struct xDHCPMessage\r
 144 {\r
 145         uint8_t ucOpcode;\r
 146         uint8_t ucAddressType;\r
 147         uint8_t ucAddressLength;\r
 148         uint8_t ucHops;\r
 149         uint32_t ulTransactionID;\r
 150         uint16_t usElapsedTime;\r
 151         uint16_t usFlags;\r
 152         uint32_t ulClientIPAddress_ciaddr;\r
 153         uint32_t ulYourIPAddress_yiaddr;\r
 154         uint32_t ulServerIPAddress_siaddr;\r
 155         uint32_t ulRelayAgentIPAddress_giaddr;\r
 156         uint8_t ucClientHardwareAddress[ dhcpCLIENT_HARDWARE_ADDRESS_LENGTH ];\r
 157         uint8_t ucServerHostName[ dhcpSERVER_HOST_NAME_LENGTH ];\r
 158         uint8_t ucBootFileName[ dhcpBOOT_FILE_NAME_LENGTH ];\r
 159         uint32_t ulDHCPCookie;\r
 160         uint8_t ucFirstOptionByte;\r
 161 }\r
 162 #include "pack_struct_end.h"\r
 163 typedef struct xDHCPMessage xDHCPMessage_t;\r
 164 \r
 165 /* DHCP state machine states. */\r
 166 typedef enum\r
 167 {\r
 168         eWaitingSendFirstDiscover = 0,  /* Initial state.  Send a discover the first time it is called, and reset all timers. */\r
 169         eWaitingOffer,                                  /* Either resend the discover, or, if the offer is forthcoming, send a request. */\r
 170         eWaitingAcknowledge,                    /* Either resend the request. */\r
 171         eLeasedAddress,                                 /* Resend the request at the appropriate time to renew the lease. */\r
 172         eNotUsingLeasedAddress                  /* DHCP failed, and a default IP address is being used. */\r
 173 } eDHCPState_t;\r
 174 \r
 175 /*\r
 176  * Generate a DHCP discover message and send it on the DHCP socket.\r
 177  */\r
 178 static void prvSendDHCPDiscover( xMACAddress_t *pxMACAddress );\r
 179 \r
 180 /*\r
 181  * Interpret message received on the DHCP socket.\r
 182  */\r
 183 static portBASE_TYPE prvProcessDHCPReplies( uint8_t ucExpectedMessageType, xMACAddress_t *pxMACAddress, xNetworkAddressingParameters_t *pxNetworkAddressing );\r
 184 \r
 185 /*\r
 186  * Generate a DHCP request packet, and send it on the DHCP socket.\r
 187  */\r
 188 static void prvSendDHCPRequest( xMACAddress_t *pxMACAddress );\r
 189 \r
 190 /*\r
 191  * Prepare to start a DHCP transaction.  This initialises some state variables\r
 192  * and creates the DHCP socket if necessary.\r
 193  */\r
 194 static void prvInitialiseDHCP( void );\r
 195 \r
 196 /*\r
 197  * Creates the part of outgoing DHCP messages that are common to all outgoing\r
 198  * DHCP messages.\r
 199  */\r
 200 static uint8_t *prvCreatePartDHCPMessage( struct freertos_sockaddr *pxAddress, xMACAddress_t *pxMACAddress, uint8_t ucOpcode, const uint8_t * const pucOptionsArray, size_t xOptionsArraySize );\r
 201 \r
 202 /*\r
 203  * Create the DHCP socket, if it has not been created already.\r
 204  */\r
 205 static void prvCreateDHCPSocket( void );\r
 206 \r
 207 /*-----------------------------------------------------------*/\r
 208 \r
 209 /* The timer used to drive the DHCP state machine. */\r
 210 static xTimerHandle xDHCPTimer = NULL;\r
 211 \r
 212 /* The UDP socket used for all incoming and outgoing DHCP traffic. */\r
 213 static xSocket_t xDHCPSocket = NULL;\r
 214 \r
 215 /* Hold information in between steps in the DHCP state machine. */\r
 216 static uint32_t ulTransactionId = 0UL, ulOfferedIPAddress = 0UL, ulDHCPServerAddress = 0UL, ulLeaseTime = 0;\r
 217 \r
 218 /* Hold information on the current timer state. */\r
 219 static portTickType xDHCPTxTime = 0x00, xDHCPTxPeriod = 0x00;\r
 220 \r
 221 /* Maintains the DHCP state machine state. */\r
 222 static eDHCPState_t eDHCPState = eWaitingSendFirstDiscover;\r
 223 \r
 224 /*-----------------------------------------------------------*/\r
 225 \r
 226 void vDHCPProcess( portBASE_TYPE xReset, xMACAddress_t *pxMACAddress, uint32_t *pulIPAddress, xNetworkAddressingParameters_t *pxNetworkAddressing )\r
 227 {\r
 228         if( xReset != pdFALSE )\r
 229         {\r
 230                 eDHCPState = eWaitingSendFirstDiscover;\r
 231         }\r
 232 \r
 233         switch( eDHCPState )\r
 234         {\r
 235                 case eWaitingSendFirstDiscover :\r
 236 \r
 237                         /* Initial state.  Create the DHCP socket, timer, etc. if they\r
 238                         have not already been created. */\r
 239                         prvInitialiseDHCP();\r
 240                         *pulIPAddress = 0UL;\r
 241 \r
 242                         /* Send the first discover request. */\r
 243                         if( xDHCPSocket != NULL )\r
 244                         {\r
 245                                 xDHCPTxTime = xTaskGetTickCount();\r
 246                                 prvSendDHCPDiscover( pxMACAddress );\r
 247                                 eDHCPState = eWaitingOffer;\r
 248                         }\r
 249                         break;\r
 250 \r
 251                 case eWaitingOffer :\r
 252 \r
 253                         /* Look for offers coming in. */\r
 254                         if( prvProcessDHCPReplies( dhcpMESSAGE_TYPE_OFFER, pxMACAddress, pxNetworkAddressing ) == pdPASS )\r
 255                         {\r
 256                                 /* An offer has been made, generate the request. */\r
 257                                 xDHCPTxTime = xTaskGetTickCount();\r
 258                                 xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;\r
 259                                 prvSendDHCPRequest( pxMACAddress );\r
 260                                 eDHCPState = eWaitingAcknowledge;\r
 261                         }\r
 262                         else\r
 263                         {\r
 264                                 /* Is it time to send another Discover? */\r
 265                                 if( ( xTaskGetTickCount() - xDHCPTxTime ) > xDHCPTxPeriod )\r
 266                                 {\r
 267                                         /* Increase the time period, and if it has not got to the\r
 268                                         point of giving up - send another discovery. */\r
 269                                         xDHCPTxPeriod <<= 1;\r
 270                                         if( xDHCPTxPeriod <= ipconfigMAXIMUM_DISCOVER_TX_PERIOD )\r
 271                                         {\r
 272                                                 ulTransactionId++;\r
 273                                                 xDHCPTxTime = xTaskGetTickCount();\r
 274                                                 prvSendDHCPDiscover( pxMACAddress );\r
 275                                         }\r
 276                                         else\r
 277                                         {\r
 278                                                 /* Revert to static IP address. */\r
 279                                                 taskENTER_CRITICAL();\r
 280                                                 {\r
 281                                                         *pulIPAddress = pxNetworkAddressing->ulDefaultIPAddress;\r
 282                                                         iptraceDHCP_REQUESTS_FAILED_USING_DEFAULT_IP_ADDRESS( pxNetworkAddressing->ulDefaultIPAddress );\r
 283                                                 }\r
 284                                                 taskEXIT_CRITICAL();\r
 285                                                 eDHCPState = eNotUsingLeasedAddress;\r
 286                                                 xTimerStop( xDHCPTimer, ( portTickType ) 0 );\r
 287 \r
 288                                                 #if ipconfigFREERTOS_PLUS_NABTO == 1\r
 289                                                 {\r
 290                                                         vStartNabtoTask();\r
 291                                                 }\r
 292                                                 #endif /* ipconfigFREERTOS_PLUS_NABTO */\r
 293 \r
 294                                                 #if ipconfigUSE_NETWORK_EVENT_HOOK == 1\r
 295                                                 {\r
 296                                                         vApplicationIPNetworkEventHook( eNetworkUp );\r
 297                                                 }\r
 298                                                 #endif\r
 299 \r
 300                                                 /* Close socket to ensure packets don't queue on it. */\r
 301                                                 FreeRTOS_closesocket( xDHCPSocket );\r
 302                                                 xDHCPSocket = NULL;\r
 303                                         }\r
 304                                 }\r
 305                         }\r
 306                         break;\r
 307 \r
 308                 case eWaitingAcknowledge :\r
 309 \r
 310                         /* Look for acks coming in. */\r
 311                         if( prvProcessDHCPReplies( dhcpMESSAGE_TYPE_ACK, pxMACAddress, pxNetworkAddressing ) == pdPASS )\r
 312                         {\r
 313                                 /* DHCP completed.  The IP address can now be used, and the\r
 314                                 timer set to the lease timeout time. */\r
 315                                 *pulIPAddress = ulOfferedIPAddress;\r
 316                                 eDHCPState = eLeasedAddress;\r
 317 \r
 318                                 #if ipconfigFREERTOS_PLUS_NABTO == 1\r
 319                                 {\r
 320                                         vStartNabtoTask();\r
 321                                 }\r
 322                                 #endif /* ipconfigFREERTOS_PLUS_NABTO */\r
 323 \r
 324                                 #if ipconfigUSE_NETWORK_EVENT_HOOK == 1\r
 325                                 {\r
 326                                         vApplicationIPNetworkEventHook( eNetworkUp );\r
 327                                 }\r
 328                                 #endif\r
 329 \r
 330                                 /* Close socket to ensure packets don't queue on it. */\r
 331                                 FreeRTOS_closesocket( xDHCPSocket );\r
 332                                 xDHCPSocket = NULL;\r
 333 \r
 334                                 if( ulLeaseTime == 0UL )\r
 335                                 {\r
 336                                         ulLeaseTime = dhcpDEFAULT_LEASE_TIME;\r
 337                                 }\r
 338                                 else if( ulLeaseTime < dhcpMINIMUM_LEASE_TIME )\r
 339                                 {\r
 340                                         ulLeaseTime = dhcpMINIMUM_LEASE_TIME;\r
 341                                 }\r
 342                                 else\r
 343                                 {\r
 344                                         /* The lease time is already valid. */\r
 345                                 }\r
 346 \r
 347                                 xTimerChangePeriod( xDHCPTimer, ulLeaseTime, portMAX_DELAY );\r
 348                         }\r
 349                         else\r
 350                         {\r
 351                                 /* Is it time to send another Discover? */\r
 352                                 if( ( xTaskGetTickCount() - xDHCPTxTime ) > xDHCPTxPeriod )\r
 353                                 {\r
 354                                         /* Increase the time period, and if it has not got to the\r
 355                                         point of giving up - send another request. */\r
 356                                         xDHCPTxPeriod <<= 1;\r
 357                                         if( xDHCPTxPeriod <= ipconfigMAXIMUM_DISCOVER_TX_PERIOD )\r
 358                                         {\r
 359                                                 xDHCPTxTime = xTaskGetTickCount();\r
 360                                                 prvSendDHCPRequest( pxMACAddress );\r
 361                                         }\r
 362                                         else\r
 363                                         {\r
 364                                                 /* Give up, start again. */\r
 365                                                 eDHCPState = eWaitingSendFirstDiscover;\r
 366                                         }\r
 367                                 }\r
 368                         }\r
 369                         break;\r
 370 \r
 371                 case eLeasedAddress :\r
 372 \r
 373                         /* Resend the request at the appropriate time to renew the lease. */\r
 374                         prvCreateDHCPSocket();\r
 375                         if( xDHCPSocket != NULL )\r
 376                         {\r
 377                                 xDHCPTxTime = xTaskGetTickCount();\r
 378                                 xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;\r
 379                                 prvSendDHCPRequest( pxMACAddress );\r
 380                                 eDHCPState = eWaitingAcknowledge;\r
 381                         }\r
 382                         xTimerChangePeriod( xDHCPTimer, dhcpINITIAL_TIMER_PERIOD, portMAX_DELAY );\r
 383                         break;\r
 384 \r
 385                 case eNotUsingLeasedAddress:\r
 386                         xTimerStop( xDHCPTimer, ( portTickType ) 0 );\r
 387                         break;\r
 388         }\r
 389 }\r
 390 /*-----------------------------------------------------------*/\r
 391 \r
 392 static void prvCreateDHCPSocket( void )\r
 393 {\r
 394 struct freertos_sockaddr xAddress;\r
 395 portBASE_TYPE xReturn;\r
 396 portTickType xTimeoutTime = 0;\r
 397 \r
 398         /* Create the socket, if it has not already been created. */\r
 399         if( xDHCPSocket == NULL )\r
 400         {\r
 401                 xDHCPSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );\r
 402                 configASSERT( ( xDHCPSocket != FREERTOS_INVALID_SOCKET ) );\r
 403 \r
 404                 /* Ensure the Rx and Tx timeouts are zero as the DHCP executes in the\r
 405                 context of the IP task. */\r
 406                 FreeRTOS_setsockopt( xDHCPSocket, 0, FREERTOS_SO_RCVTIMEO, ( void * ) &xTimeoutTime, sizeof( portTickType ) );\r
 407                 FreeRTOS_setsockopt( xDHCPSocket, 0, FREERTOS_SO_SNDTIMEO, ( void * ) &xTimeoutTime, sizeof( portTickType ) );\r
 408 \r
 409                 /* Bind to the standard DHCP client port. */\r
 410                 xAddress.sin_port = dhcpCLIENT_PORT;\r
 411                 xReturn = FreeRTOS_bind( xDHCPSocket, &xAddress, sizeof( xAddress ) );\r
 412                 configASSERT( xReturn == 0 );\r
 413 \r
 414                 /* Remove compiler warnings if configASSERT() is not defined. */\r
 415                 ( void ) xReturn;\r
 416         }\r
 417 }\r
 418 /*-----------------------------------------------------------*/\r
 419 \r
 420 static void prvInitialiseDHCP( void )\r
 421 {\r
 422 extern void vIPFunctionsTimerCallback( xTimerHandle xTimer );\r
 423 \r
 424         /* Initialise the parameters that will be set by the DHCP process. */\r
 425         if( ulTransactionId == 0 )\r
 426         {\r
 427                 ulTransactionId = ipconfigRAND32();\r
 428         }\r
 429         else\r
 430         {\r
 431                 ulTransactionId++;\r
 432         }\r
 433         ulOfferedIPAddress = 0UL;\r
 434         ulDHCPServerAddress = 0UL;\r
 435         xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;\r
 436 \r
 437         /* Create the DHCP socket if it has not already been created. */\r
 438         prvCreateDHCPSocket();\r
 439 \r
 440         if( xDHCPTimer == NULL )\r
 441         {\r
 442                 xDHCPTimer = xTimerCreate( ( const signed char * const ) "DHCP", dhcpINITIAL_TIMER_PERIOD, pdTRUE, ( void * ) eDHCPEvent, vIPFunctionsTimerCallback );\r
 443                 configASSERT( xDHCPTimer );\r
 444                 xTimerStart( xDHCPTimer, portMAX_DELAY );\r
 445         }\r
 446         else\r
 447         {\r
 448                 xTimerChangePeriod( xDHCPTimer, dhcpINITIAL_TIMER_PERIOD, portMAX_DELAY );\r
 449         }\r
 450 }\r
 451 /*-----------------------------------------------------------*/\r
 452 \r
 453 static portBASE_TYPE prvProcessDHCPReplies( uint8_t ucExpectedMessageType, xMACAddress_t *pxMACAddress, xNetworkAddressingParameters_t *pxNetworkAddressing )\r
 454 {\r
 455 uint8_t *pucUDPPayload, *pucLastByte;\r
 456 struct freertos_sockaddr xClient;\r
 457 uint32_t xClientLength = sizeof( xClient );\r
 458 int32_t lBytes;\r
 459 xDHCPMessage_t *pxDHCPMessage;\r
 460 uint8_t *pucByte, ucOptionCode, ucLength;\r
 461 uint32_t ulProcessed;\r
 462 portBASE_TYPE xReturn = pdFALSE;\r
 463 const uint32_t ulMandatoryOptions = 2; /* DHCP server address, and the correct DHCP message type must be present in the options. */\r
 464 \r
 465         lBytes = FreeRTOS_recvfrom( xDHCPSocket, ( void * ) &pucUDPPayload, 0, FREERTOS_ZERO_COPY, &xClient, &xClientLength );\r
 466 \r
 467         if( lBytes > 0 )\r
 468         {\r
 469                 /* Map a DHCP structure onto the received data. */\r
 470                 pxDHCPMessage = ( xDHCPMessage_t * ) ( pucUDPPayload );\r
 471 \r
 472                 /* Sanity check. */\r
 473                 if( ( pxDHCPMessage->ulDHCPCookie == dhcpCOOKIE ) && ( pxDHCPMessage->ucOpcode == dhcpREPLY_OPCODE ) && ( pxDHCPMessage->ulTransactionID == ulTransactionId ) )\r
 474                 {\r
 475                         if( memcmp( ( void * ) &( pxDHCPMessage->ucClientHardwareAddress ), ( void * ) pxMACAddress, sizeof( xMACAddress_t ) ) == 0 )\r
 476                         {\r
 477                                 /* None of the essential options have been processed yet. */\r
 478                                 ulProcessed = 0;\r
 479 \r
 480                                 /* Walk through the options until the dhcpOPTION_END_BYTE byte\r
 481                                 is found, taking care not to walk off the end of the options. */\r
 482                                 pucByte = &( pxDHCPMessage->ucFirstOptionByte );\r
 483                                 pucLastByte = &( pucUDPPayload[ lBytes - dhcpMAX_OPTION_LENGTH_OF_INTEREST ] );\r
 484                                 while( ( *pucByte != dhcpOPTION_END_BYTE ) && ( pucByte < pucLastByte ) )\r
 485                                 {\r
 486                                         ucOptionCode = *pucByte;\r
 487                                         pucByte++;\r
 488                                         ucLength = *pucByte;\r
 489                                         pucByte++;\r
 490 \r
 491                                         switch( ucOptionCode )\r
 492                                         {\r
 493                                                 case dhcpMESSAGE_TYPE_OPTION_CODE       :\r
 494 \r
 495                                                         if( *pucByte == ucExpectedMessageType )\r
 496                                                         {\r
 497                                                                 /* The message type is the message type the\r
 498                                                                 state machine is expecting. */\r
 499                                                                 ulProcessed++;\r
 500                                                         }\r
 501                                                         else if( *pucByte == dhcpMESSAGE_TYPE_NACK )\r
 502                                                         {\r
 503                                                                 if( ucExpectedMessageType == dhcpMESSAGE_TYPE_ACK )\r
 504                                                                 {\r
 505                                                                         /* Start again. */\r
 506                                                                         eDHCPState = eWaitingSendFirstDiscover;\r
 507                                                                 }\r
 508                                                         }\r
 509                                                         else\r
 510                                                         {\r
 511                                                                 /* Don't process other message types. */\r
 512                                                         }\r
 513                                                         break;\r
 514 \r
 515                                                 case dhcpSUBNET_MASK_OPTION_CODE :\r
 516 \r
 517                                                         if( ucLength == sizeof( uint32_t ) )\r
 518                                                         {\r
 519                                                                 memcpy( ( void * ) &( pxNetworkAddressing->ulNetMask ), ( void * ) pucByte, ( size_t ) ucLength );\r
 520                                                         }\r
 521                                                         break;\r
 522 \r
 523                                                 case dhcpGATEWAY_OPTION_CODE :\r
 524 \r
 525                                                         if( ucLength == sizeof( uint32_t ) )\r
 526                                                         {\r
 527                                                                 /* ulProcessed is not incremented in this case\r
 528                                                                 because the gateway is not essential. */\r
 529                                                                 memcpy( ( void * ) &( pxNetworkAddressing->ulGatewayAddress ), ( void * ) pucByte, ( size_t ) ucLength );\r
 530                                                         }\r
 531                                                         break;\r
 532 \r
 533                                                 case hdcpDNS_SERVER_OPTIONS_CODE :\r
 534 \r
 535                                                         /* ulProcessed is not incremented in this case\r
 536                                                         because the DNS server is not essential.  Only the\r
 537                                                         first DNS server address is taken. */\r
 538                                                         memcpy( ( void * ) &( pxNetworkAddressing->ulDNSServerAddress ), ( void * ) pucByte, sizeof( uint32_t ) );\r
 539                                                         break;\r
 540 \r
 541                                                 case dhcpSERVER_IP_ADDRESS_OPTION_CODE :\r
 542 \r
 543                                                         if( ucLength == sizeof( uint32_t ) )\r
 544                                                         {\r
 545                                                                 if( ucExpectedMessageType == dhcpMESSAGE_TYPE_OFFER )\r
 546                                                                 {\r
 547                                                                         /* Offers state the replying server. */\r
 548                                                                         ulProcessed++;\r
 549                                                                         memcpy( ( void * ) &ulDHCPServerAddress, ( void * ) pucByte, ( size_t ) ucLength );\r
 550                                                                 }\r
 551                                                                 else\r
 552                                                                 {\r
 553                                                                         /* The ack must come from the expected server. */\r
 554                                                                         if( memcmp( ( void * ) &ulDHCPServerAddress, ( void * ) pucByte, ( size_t ) ucLength ) == 0 )\r
 555                                                                         {\r
 556                                                                                 ulProcessed++;\r
 557                                                                         }\r
 558                                                                 }\r
 559                                                         }\r
 560                                                         break;\r
 561 \r
 562                                                 case dhcpLEASE_TIME_OPTION_CODE :\r
 563 \r
 564                                                         if( ucLength == sizeof( &ulLeaseTime ) )\r
 565                                                         {\r
 566                                                                 /* ulProcessed is not incremented in this case\r
 567                                                                 because the lease time is not essential. */\r
 568                                                                 memcpy( ( void * ) &ulLeaseTime, ( void * ) pucByte, ( size_t ) ucLength );\r
 569                                                                 ulLeaseTime = FreeRTOS_ntohl( ulLeaseTime );\r
 570 \r
 571                                                                 /* Convert the lease time to milliseconds\r
 572                                                                 (*1000) then ticks (/portTICK_RATE_MS). */\r
 573                                                                 ulLeaseTime *= ( 1000UL / portTICK_RATE_MS );\r
 574 \r
 575                                                                 /* Divide the lease time to ensure a renew\r
 576                                                                 request is sent before the lease actually\r
 577                                                                 expires. */\r
 578                                                                 ulLeaseTime >>= 1UL;\r
 579                                                         }\r
 580                                                         break;\r
 581 \r
 582                                                 default :\r
 583 \r
 584                                                         /* Not interested in this field. */\r
 585 \r
 586                                                         break;\r
 587                                         }\r
 588 \r
 589                                         /* Jump over the data to find the next option code. */\r
 590                                         if( ucLength == 0 )\r
 591                                         {\r
 592                                                 break;\r
 593                                         }\r
 594                                         else\r
 595                                         {\r
 596                                                 pucByte += ucLength;\r
 597                                         }\r
 598                                 }\r
 599 \r
 600                                 /* Were all the mandatory options received? */\r
 601                                 if( ulProcessed == ulMandatoryOptions )\r
 602                                 {\r
 603                                         ulOfferedIPAddress = pxDHCPMessage->ulYourIPAddress_yiaddr;\r
 604                                         xReturn = pdPASS;\r
 605                                 }\r
 606                         }\r
 607                 }\r
 608 \r
 609                 FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayload );\r
 610         }\r
 611 \r
 612         return xReturn;\r
 613 }\r
 614 /*-----------------------------------------------------------*/\r
 615 \r
 616 static uint8_t *prvCreatePartDHCPMessage( struct freertos_sockaddr *pxAddress, xMACAddress_t *pxMACAddress, uint8_t ucOpcode, const uint8_t * const pucOptionsArray, size_t xOptionsArraySize )\r
 617 {\r
 618 xDHCPMessage_t *pxDHCPMessage;\r
 619 const size_t xRequiredBufferSize = sizeof( xDHCPMessage_t ) + xOptionsArraySize;\r
 620 uint8_t *pucUDPPayloadBuffer;\r
 621 \r
 622         /* Get a buffer.  This uses a maximum delay, but the delay will be capped\r
 623         to ipconfigMAX_SEND_BLOCK_TIME_TICKS so the return value still needs to be\r
 624         test. */\r
 625         do\r
 626         {\r
 627         }while( ( pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( xRequiredBufferSize, portMAX_DELAY ) ) == NULL );\r
 628 \r
 629         pxDHCPMessage = ( xDHCPMessage_t * ) pucUDPPayloadBuffer;\r
 630 \r
 631         /* Most fields need to be zero. */\r
 632         memset( ( void * ) pxDHCPMessage, 0x00, sizeof( xDHCPMessage_t ) );\r
 633 \r
 634         /* Create the message. */\r
 635         pxDHCPMessage->ucOpcode = ucOpcode;\r
 636         pxDHCPMessage->ucAddressType = dhcpADDRESS_TYPE_ETHERNET;\r
 637         pxDHCPMessage->ucAddressLength = dhcpETHERNET_ADDRESS_LENGTH;\r
 638         pxDHCPMessage->ulTransactionID = ulTransactionId;\r
 639         pxDHCPMessage->ulYourIPAddress_yiaddr = ulOfferedIPAddress;\r
 640         pxDHCPMessage->ulDHCPCookie = dhcpCOOKIE;\r
 641         memcpy( ( void * ) &( pxDHCPMessage->ucClientHardwareAddress[ 0 ] ), ( void * ) pxMACAddress, sizeof( xMACAddress_t ) );\r
 642 \r
 643         /* Copy in the const part of the options options. */\r
 644         memcpy( ( void * ) &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET ] ), ( void * ) pucOptionsArray, xOptionsArraySize );\r
 645 \r
 646         /* Map in the client identifier. */\r
 647         memcpy( ( void * ) &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpCLIENT_IDENTIFIER_OFFSET ] ), ( void * ) pxMACAddress, sizeof( xMACAddress_t ) );\r
 648 \r
 649         /* Set the addressing. */\r
 650         pxAddress->sin_addr = ipBROADCAST_IP_ADDRESS;\r
 651         pxAddress->sin_port = ( uint16_t ) dhcpSERVER_PORT;\r
 652 \r
 653         return pucUDPPayloadBuffer;\r
 654 }\r
 655 /*-----------------------------------------------------------*/\r
 656 \r
 657 static void prvSendDHCPRequest( xMACAddress_t *pxMACAddress )\r
 658 {\r
 659 uint8_t *pucUDPPayloadBuffer;\r
 660 struct freertos_sockaddr xAddress;\r
 661 static const uint8_t ucDHCPRequestOptions[] =\r
 662 {\r
 663         /* Do not change the ordering without also changing\r
 664         dhcpCLIENT_IDENTIFIER_OFFSET, dhcpREQUESTED_IP_ADDRESS_OFFSET and\r
 665         dhcpDHCP_SERVER_IP_ADDRESS_OFFSET. */\r
 666         dhcpMESSAGE_TYPE_OPTION_CODE, 1, dhcpMESSAGE_TYPE_REQUEST,              /* Message type option. */\r
 667         dhcpCLIENT_IDENTIFIER_OPTION_CODE, 6, 0, 0, 0, 0, 0, 0,                 /* Client identifier. */\r
 668         dhcpREQUEST_IP_ADDRESS_OPTION_CODE, 4, 0, 0, 0, 0,                              /* The IP address being requested. */\r
 669         dhcpSERVER_IP_ADDRESS_OPTION_CODE, 4, 0, 0, 0, 0,                               /* The IP address of the DHCP server. */\r
 670         dhcpOPTION_END_BYTE\r
 671 };\r
 672 \r
 673         pucUDPPayloadBuffer = prvCreatePartDHCPMessage( &xAddress, pxMACAddress, dhcpREQUEST_OPCODE, ucDHCPRequestOptions, sizeof( ucDHCPRequestOptions ) );\r
 674 \r
 675         /* Copy in the IP address being requested. */\r
 676         memcpy( ( void * ) &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpREQUESTED_IP_ADDRESS_OFFSET ] ), ( void * ) &ulOfferedIPAddress, sizeof( ulOfferedIPAddress ) );\r
 677 \r
 678         /* Copy in the address of the DHCP server being used. */\r
 679         memcpy( ( void * ) &( pucUDPPayloadBuffer[ dhcpFIRST_OPTION_BYTE_OFFSET + dhcpDHCP_SERVER_IP_ADDRESS_OFFSET ] ), ( void * ) &ulDHCPServerAddress, sizeof( ulDHCPServerAddress ) );\r
 680 \r
 681         iptraceSENDING_DHCP_REQUEST();\r
 682         if( FreeRTOS_sendto( xDHCPSocket, pucUDPPayloadBuffer, ( sizeof( xDHCPMessage_t ) + sizeof( ucDHCPRequestOptions ) ), FREERTOS_ZERO_COPY, &xAddress, sizeof( xAddress ) ) == 0 )\r
 683         {\r
 684                 /* The packet was not successfully queued for sending and must be\r
 685                 returned to the stack. */\r
 686                 FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayloadBuffer );\r
 687         }\r
 688 }\r
 689 /*-----------------------------------------------------------*/\r
 690 \r
 691 static void prvSendDHCPDiscover( xMACAddress_t *pxMACAddress )\r
 692 {\r
 693 uint8_t *pucUDPPayloadBuffer;\r
 694 struct freertos_sockaddr xAddress;\r
 695 static const uint8_t ucDHCPDiscoverOptions[] =\r
 696 {\r
 697         /* Do not change the ordering without also changing dhcpCLIENT_IDENTIFIER_OFFSET. */\r
 698         dhcpMESSAGE_TYPE_OPTION_CODE, 1, dhcpMESSAGE_TYPE_DISCOVER,                                     /* Message type option. */\r
 699         dhcpCLIENT_IDENTIFIER_OPTION_CODE, 6, 0, 0, 0, 0, 0, 0,                                         /* Client identifier. */\r
 700         dhcpPARAMETER_REQUEST_OPTION_CODE, 3, dhcpSUBNET_MASK_OPTION_CODE, dhcpGATEWAY_OPTION_CODE, hdcpDNS_SERVER_OPTIONS_CODE,        /* Parameter request option. */\r
 701         dhcpOPTION_END_BYTE\r
 702 };\r
 703 \r
 704         pucUDPPayloadBuffer = prvCreatePartDHCPMessage( &xAddress, pxMACAddress, dhcpREQUEST_OPCODE, ucDHCPDiscoverOptions, sizeof( ucDHCPDiscoverOptions ) );\r
 705 \r
 706         iptraceSENDING_DHCP_DISCOVER();\r
 707         if( FreeRTOS_sendto( xDHCPSocket, pucUDPPayloadBuffer, ( sizeof( xDHCPMessage_t ) + sizeof( ucDHCPDiscoverOptions ) ), FREERTOS_ZERO_COPY, &xAddress, sizeof( xAddress ) ) == 0 )\r
 708         {\r
 709                 /* The packet was not successfully queued for sending and must be\r
 710                 returned to the stack. */\r
 711                 FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayloadBuffer );\r
 712         }\r
 713 }\r
 714 /*-----------------------------------------------------------*/\r
 715 \r
 716 #endif /* ipconfigUSE_DHCP != 0 */\r
 717 \r
 718 \r