forked from FreeRTOS/FreeRTOS-Plus-TCP
-
Notifications
You must be signed in to change notification settings - Fork 0
/
FreeRTOS_DHCP.c
1322 lines (1117 loc) · 60.2 KB
/
FreeRTOS_DHCP.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* FreeRTOS+TCP V2.3.2
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* http://aws.amazon.com/freertos
* http://www.FreeRTOS.org
*/
/**
* @file FreeRTOS_DHCP.c
* @brief Implements the Dynamic Host Configuration Protocol for the FreeRTOS+TCP network stack.
*/
/* Standard includes. */
#include <stdint.h>
/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
/* FreeRTOS+TCP includes. */
#include "FreeRTOS_IP.h"
#include "FreeRTOS_Sockets.h"
#include "FreeRTOS_IP_Private.h"
#include "FreeRTOS_UDP_IP.h"
#include "FreeRTOS_DHCP.h"
#include "FreeRTOS_ARP.h"
/* Exclude the entire file if DHCP is not enabled. */
#if ( ipconfigUSE_DHCP != 0 )
#include "NetworkInterface.h"
#include "NetworkBufferManagement.h"
#if ( ipconfigUSE_DHCP != 0 ) && ( ipconfigNETWORK_MTU < 586U )
/* DHCP must be able to receive an options field of 312 bytes, the fixed
* part of the DHCP packet is 240 bytes, and the IP/UDP headers take 28 bytes. */
#error ipconfigNETWORK_MTU needs to be at least 586 to use DHCP
#endif
/* Parameter widths in the DHCP packet. */
#define dhcpCLIENT_HARDWARE_ADDRESS_LENGTH 16 /**< Client hardware address length.*/
#define dhcpSERVER_HOST_NAME_LENGTH 64 /**< Server host name length. */
#define dhcpBOOT_FILE_NAME_LENGTH 128 /**< Boot file name length. */
/* Timer parameters */
#ifndef dhcpINITIAL_TIMER_PERIOD
/** @brief The interval at which the DHCP state handler is called. */
#define dhcpINITIAL_TIMER_PERIOD ( pdMS_TO_TICKS( 250U ) )
#endif
#ifndef dhcpINITIAL_DHCP_TX_PERIOD
/** @brief The initial amount of time to wait for a DHCP reply. When repeating an
* unanswered request, this time-out shall be multiplied by 2. */
#define dhcpINITIAL_DHCP_TX_PERIOD ( pdMS_TO_TICKS( 5000U ) )
#endif
/* Codes of interest found in the DHCP options field. */
#define dhcpIPv4_ZERO_PAD_OPTION_CODE ( 0U ) /**< Used to pad other options to make them aligned. See RFC 2132. */
#define dhcpIPv4_SUBNET_MASK_OPTION_CODE ( 1U ) /**< Subnet mask. See RFC 2132. */
#define dhcpIPv4_GATEWAY_OPTION_CODE ( 3U ) /**< Available routers. See RFC 2132. */
#define dhcpIPv4_DNS_SERVER_OPTIONS_CODE ( 6U ) /**< Domain name server. See RFC 2132. */
#define dhcpIPv4_DNS_HOSTNAME_OPTIONS_CODE ( 12U ) /**< Host name. See RFC 2132. */
#define dhcpIPv4_REQUEST_IP_ADDRESS_OPTION_CODE ( 50U ) /**< Requested IP-address. See RFC 2132. */
#define dhcpIPv4_LEASE_TIME_OPTION_CODE ( 51U ) /**< IP-address lease time. See RFC 2132. */
#define dhcpIPv4_MESSAGE_TYPE_OPTION_CODE ( 53U ) /**< DHCP message type. See RFC 2132. */
#define dhcpIPv4_SERVER_IP_ADDRESS_OPTION_CODE ( 54U ) /**< Server Identifier. See RFC 2132. */
#define dhcpIPv4_PARAMETER_REQUEST_OPTION_CODE ( 55U ) /**< Parameter Request list. See RFC 2132. */
#define dhcpIPv4_CLIENT_IDENTIFIER_OPTION_CODE ( 61U ) /**< Client Identifier. See RFC 2132. */
/* The four DHCP message types of interest. */
#define dhcpMESSAGE_TYPE_DISCOVER ( 1 ) /**< DHCP discover message. */
#define dhcpMESSAGE_TYPE_OFFER ( 2 ) /**< DHCP offer message. */
#define dhcpMESSAGE_TYPE_REQUEST ( 3 ) /**< DHCP request message. */
#define dhcpMESSAGE_TYPE_ACK ( 5 ) /**< DHCP acknowledgement. */
#define dhcpMESSAGE_TYPE_NACK ( 6 ) /**< DHCP NACK. (Negative acknowledgement) */
/* Offsets into the transmitted DHCP options fields at which various parameters
* are located. */
#define dhcpCLIENT_IDENTIFIER_OFFSET ( 6U ) /**< Offset for the client ID option. */
#define dhcpREQUESTED_IP_ADDRESS_OFFSET ( 14U ) /**< Offset for the requested IP-address option. */
#define dhcpDHCP_SERVER_IP_ADDRESS_OFFSET ( 20U ) /**< Offset for the server IP-address option. */
/* Values used in the DHCP packets. */
#define dhcpREQUEST_OPCODE ( 1U ) /**< DHCP request opcode. */
#define dhcpREPLY_OPCODE ( 2U ) /**< DHCP reply opcode. */
#define dhcpADDRESS_TYPE_ETHERNET ( 1U ) /**< Address type: ethernet opcode. */
#define dhcpETHERNET_ADDRESS_LENGTH ( 6U ) /**< Ethernet address length opcode. */
/* The following define is temporary and serves to make the /single source
* code more similar to the /multi version. */
#define EP_DHCPData xDHCPData /**< Temporary define to make /single source similar to /multi version. */
#define EP_IPv4_SETTINGS xNetworkAddressing /**< Temporary define to make /single source similar to /multi version. */
/** @brief If a lease time is not received, use the default of two days (48 hours in ticks).
* Can not use pdMS_TO_TICKS() as integer overflow can occur. */
#define dhcpDEFAULT_LEASE_TIME ( ( 48UL * 60UL * 60UL ) * configTICK_RATE_HZ )
/** @brief Don't allow the lease time to be too short. */
#define dhcpMINIMUM_LEASE_TIME ( pdMS_TO_TICKS( 60000UL ) ) /* 60 seconds in ticks. */
/** @brief Marks the end of the variable length options field in the DHCP packet. */
#define dhcpOPTION_END_BYTE 0xffu
/** @brief Offset into a DHCP message at which the first byte of the options is
* located. */
#define dhcpFIRST_OPTION_BYTE_OFFSET ( 0xf0U )
/* Standard DHCP port numbers and magic cookie value.
* DHCPv4 uses UDP port number 68 for clients and port number 67 for servers.
*/
#if ( ipconfigBYTE_ORDER == pdFREERTOS_LITTLE_ENDIAN )
#define dhcpCLIENT_PORT_IPv4 0x4400U /**< Little endian representation of port 68. */
#define dhcpSERVER_PORT_IPv4 0x4300U /**< Little endian representation of port 67. */
#define dhcpCOOKIE 0x63538263UL /**< Little endian representation of magic cookie. */
#define dhcpBROADCAST 0x0080U /**< Little endian representation of broadcast flag. */
#else
#define dhcpCLIENT_PORT_IPv4 0x0044U /**< Big endian representation of port 68. */
#define dhcpSERVER_PORT_IPv4 0x0043U /**< Big endian representation of port 68. */
#define dhcpCOOKIE 0x63825363UL /**< Big endian representation of magic cookie. */
#define dhcpBROADCAST 0x8000U /**< Big endian representation of broadcast flag. */
#endif /* ( ipconfigBYTE_ORDER == pdFREERTOS_LITTLE_ENDIAN ) */
#include "pack_struct_start.h"
struct xDHCPMessage_IPv4
{
uint8_t ucOpcode; /**< Operation Code: Specifies the general type of message. */
uint8_t ucAddressType; /**< Hardware type used on the local network. */
uint8_t ucAddressLength; /**< Hardware Address Length: Specifies how long hardware
* addresses are in this message. */
uint8_t ucHops; /**< Hops. */
uint32_t ulTransactionID; /**< A 32-bit identification field generated by the client,
* to allow it to match up the request with replies received
* from DHCP servers. */
uint16_t usElapsedTime; /**< Number of seconds elapsed since a client began an attempt to acquire or renew a lease. */
uint16_t usFlags; /**< Just one bit used to indicate broadcast. */
uint32_t ulClientIPAddress_ciaddr; /**< Client's IP address if it has one or 0 is put in this field. */
uint32_t ulYourIPAddress_yiaddr; /**< The IP address that the server is assigning to the client. */
uint32_t ulServerIPAddress_siaddr; /**< The DHCP server address that the client should use. */
uint32_t ulRelayAgentIPAddress_giaddr; /**< Gateway IP address in case the server client are on different subnets. */
uint8_t ucClientHardwareAddress[ dhcpCLIENT_HARDWARE_ADDRESS_LENGTH ]; /**< The client hardware address. */
uint8_t ucServerHostName[ dhcpSERVER_HOST_NAME_LENGTH ]; /**< Server's hostname. */
uint8_t ucBootFileName[ dhcpBOOT_FILE_NAME_LENGTH ]; /**< Boot file full directory path. */
uint32_t ulDHCPCookie; /**< Magic cookie option. */
/* Option bytes from here on. */
}
#include "pack_struct_end.h"
typedef struct xDHCPMessage_IPv4 DHCPMessage_IPv4_t;
/**
* @brief Function to cast pointers to DHCPMessage_IPv4_t.
*/
static portINLINE ipDECL_CAST_PTR_FUNC_FOR_TYPE( DHCPMessage_IPv4_t )
{
return ( DHCPMessage_IPv4_t * ) pvArgument;
}
/**
* @brief Function to cast const pointers to DHCPMessage_IPv4_t.
*/
static portINLINE ipDECL_CAST_CONST_PTR_FUNC_FOR_TYPE( DHCPMessage_IPv4_t )
{
return ( const DHCPMessage_IPv4_t * ) pvArgument;
}
/** @brief The UDP socket used for all incoming and outgoing DHCP traffic. */
_static Socket_t xDHCPSocket;
#if ( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 )
/* Define the Link Layer IP address: 169.254.x.x */
#define LINK_LAYER_ADDRESS_0 169
#define LINK_LAYER_ADDRESS_1 254
/* Define the netmask used: 255.255.0.0 */
#define LINK_LAYER_NETMASK_0 255
#define LINK_LAYER_NETMASK_1 255
#define LINK_LAYER_NETMASK_2 0
#define LINK_LAYER_NETMASK_3 0
#endif
/*
* Generate a DHCP discover message and send it on the DHCP socket.
*/
static BaseType_t prvSendDHCPDiscover( void );
/*
* Interpret message received on the DHCP socket.
*/
_static BaseType_t prvProcessDHCPReplies( BaseType_t xExpectedMessageType );
/*
* Generate a DHCP request packet, and send it on the DHCP socket.
*/
static BaseType_t prvSendDHCPRequest( void );
/*
* Prepare to start a DHCP transaction. This initialises some state variables
* and creates the DHCP socket if necessary.
*/
static void prvInitialiseDHCP( void );
/*
* Creates the part of outgoing DHCP messages that are common to all outgoing
* DHCP messages.
*/
static uint8_t * prvCreatePartDHCPMessage( struct freertos_sockaddr * pxAddress,
BaseType_t xOpcode,
const uint8_t * const pucOptionsArray,
size_t * pxOptionsArraySize );
/*
* Create the DHCP socket, if it has not been created already.
*/
_static void prvCreateDHCPSocket( void );
/*
* Close the DHCP socket.
*/
static void prvCloseDHCPSocket( void );
/*
* After DHCP has failed to answer, prepare everything to start searching
* for (trying-out) LinkLayer IP-addresses, using the random method: Send
* a gratuitous ARP request and wait if another device responds to it.
*/
#if ( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 )
static void prvPrepareLinkLayerIPLookUp( void );
#endif
/*-----------------------------------------------------------*/
/** @brief Hold information in between steps in the DHCP state machine. */
_static DHCPData_t xDHCPData;
/*-----------------------------------------------------------*/
/**
* @brief Check whether a given socket is the DHCP socket or not.
*
* @param[in] xSocket: The socket to be checked.
*
* @return If the socket given as parameter is the DHCP socket - return
* pdTRUE, else pdFALSE.
*/
BaseType_t xIsDHCPSocket( Socket_t xSocket )
{
BaseType_t xReturn;
if( xDHCPSocket == xSocket )
{
xReturn = pdTRUE;
}
else
{
xReturn = pdFALSE;
}
return xReturn;
}
/*-----------------------------------------------------------*/
/**
* @brief Returns the current state of a DHCP process.
*
* @return The current state ( eDHCPState_t ) of the DHCP process.
*/
eDHCPState_t eGetDHCPState( void )
{
return EP_DHCPData.eDHCPState;
}
/**
* @brief Process the DHCP state machine based on current state.
*
* @param[in] xReset: Is the DHCP state machine starting over? pdTRUE/pdFALSE.
* @param[in] eExpectedState: The function will only run if the state is expected.
*/
void vDHCPProcess( BaseType_t xReset,
eDHCPState_t eExpectedState )
{
BaseType_t xGivingUp = pdFALSE;
#if ( ipconfigUSE_DHCP_HOOK != 0 )
eDHCPCallbackAnswer_t eAnswer;
#endif /* ipconfigUSE_DHCP_HOOK */
/* Is DHCP starting over? */
if( xReset != pdFALSE )
{
EP_DHCPData.eDHCPState = eInitialWait;
}
if( ( EP_DHCPData.eDHCPState != eExpectedState ) && ( xReset == pdFALSE ) )
{
/* When the DHCP event was generated, the DHCP client was
* in a different state. Therefore, ignore this event. */
FreeRTOS_debug_printf( ( "DHCP wrong state: expect: %d got: %d : ignore\n",
eExpectedState, EP_DHCPData.eDHCPState ) );
}
else
{
switch( EP_DHCPData.eDHCPState )
{
case eInitialWait:
/* Initial state. Create the DHCP socket, timer, etc. if they
* have not already been created. */
prvInitialiseDHCP();
EP_DHCPData.eDHCPState = eWaitingSendFirstDiscover;
break;
case eWaitingSendFirstDiscover:
/* Ask the user if a DHCP discovery is required. */
#if ( ipconfigUSE_DHCP_HOOK != 0 )
eAnswer = xApplicationDHCPHook( eDHCPPhasePreDiscover, xNetworkAddressing.ulDefaultIPAddress );
if( eAnswer == eDHCPContinue )
#endif /* ipconfigUSE_DHCP_HOOK */
{
/* See if prvInitialiseDHCP() has creates a socket. */
if( xDHCPSocket == NULL )
{
xGivingUp = pdTRUE;
}
else
{
*ipLOCAL_IP_ADDRESS_POINTER = 0UL;
/* Send the first discover request. */
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
if( prvSendDHCPDiscover() == pdPASS )
{
EP_DHCPData.eDHCPState = eWaitingOffer;
}
else
{
/* Either the creation of a message buffer failed, or sendto().
* Try again in the next cycle. */
FreeRTOS_debug_printf( ( "Send failed during eWaitingSendFirstDiscover\n" ) );
}
}
}
#if ( ipconfigUSE_DHCP_HOOK != 0 )
else
{
if( eAnswer == eDHCPUseDefaults )
{
( void ) memcpy( &( xNetworkAddressing ), &( xDefaultAddressing ), sizeof( xNetworkAddressing ) );
}
/* The user indicates that the DHCP process does not continue. */
xGivingUp = pdTRUE;
}
#endif /* ipconfigUSE_DHCP_HOOK */
break;
case eSendDHCPRequest:
if( prvSendDHCPRequest() == pdPASS )
{
/* Send succeeded, go to state 'eWaitingAcknowledge'. */
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
EP_DHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;
EP_DHCPData.eDHCPState = eWaitingAcknowledge;
}
else
{
/* Either the creation of a message buffer failed, or sendto().
* Try again in the next cycle. */
FreeRTOS_debug_printf( ( "Send failed during eSendDHCPRequest.\n" ) );
}
break;
case eWaitingOffer:
xGivingUp = pdFALSE;
/* Look for offers coming in. */
if( prvProcessDHCPReplies( dhcpMESSAGE_TYPE_OFFER ) == pdPASS )
{
#if ( ipconfigUSE_DHCP_HOOK != 0 )
/* Ask the user if a DHCP request is required. */
eAnswer = xApplicationDHCPHook( eDHCPPhasePreRequest, EP_DHCPData.ulOfferedIPAddress );
if( eAnswer == eDHCPContinue )
#endif /* ipconfigUSE_DHCP_HOOK */
{
/* An offer has been made, the user wants to continue,
* generate the request. */
if( prvSendDHCPRequest() == pdPASS )
{
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
EP_DHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;
EP_DHCPData.eDHCPState = eWaitingAcknowledge;
}
else
{
/* Either the creation of a message buffer failed, or sendto().
* Try again in the next cycle. */
FreeRTOS_debug_printf( ( "Send failed during eWaitingOffer/1.\n" ) );
EP_DHCPData.eDHCPState = eSendDHCPRequest;
}
break;
}
#if ( ipconfigUSE_DHCP_HOOK != 0 )
if( eAnswer == eDHCPUseDefaults )
{
( void ) memcpy( &( xNetworkAddressing ), &( xDefaultAddressing ), sizeof( xNetworkAddressing ) );
}
/* The user indicates that the DHCP process does not continue. */
xGivingUp = pdTRUE;
#endif /* ipconfigUSE_DHCP_HOOK */
}
/* Is it time to send another Discover? */
else if( ( xTaskGetTickCount() - EP_DHCPData.xDHCPTxTime ) > EP_DHCPData.xDHCPTxPeriod )
{
/* It is time to send another Discover. Increase the time
* period, and if it has not got to the point of giving up - send
* another discovery. */
EP_DHCPData.xDHCPTxPeriod <<= 1;
if( EP_DHCPData.xDHCPTxPeriod <= ( TickType_t ) ipconfigMAXIMUM_DISCOVER_TX_PERIOD )
{
if( xApplicationGetRandomNumber( &( EP_DHCPData.ulTransactionId ) ) != pdFALSE )
{
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
if( EP_DHCPData.xUseBroadcast != pdFALSE )
{
EP_DHCPData.xUseBroadcast = pdFALSE;
}
else
{
EP_DHCPData.xUseBroadcast = pdTRUE;
}
if( prvSendDHCPDiscover() == pdPASS )
{
FreeRTOS_debug_printf( ( "vDHCPProcess: timeout %lu ticks\n", EP_DHCPData.xDHCPTxPeriod ) );
}
else
{
/* Either the creation of a message buffer failed, or sendto().
* Try again in the next cycle. */
FreeRTOS_debug_printf( ( "Send failed during eWaitingOffer/2.\n" ) );
EP_DHCPData.eDHCPState = eInitialWait;
}
}
else
{
FreeRTOS_debug_printf( ( "vDHCPProcess: failed to generate a random Transaction ID\n" ) );
}
}
else
{
FreeRTOS_debug_printf( ( "vDHCPProcess: giving up %lu > %lu ticks\n", EP_DHCPData.xDHCPTxPeriod, ipconfigMAXIMUM_DISCOVER_TX_PERIOD ) );
#if ( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 )
{
/* Only use a fake Ack if the default IP address == 0x00
* and the link local addressing is used. Start searching
* a free LinkLayer IP-address. Next state will be
* 'eGetLinkLayerAddress'. */
prvPrepareLinkLayerIPLookUp();
/* Setting an IP address manually so set to not using
* leased address mode. */
EP_DHCPData.eDHCPState = eGetLinkLayerAddress;
}
#else
{
xGivingUp = pdTRUE;
}
#endif /* ipconfigDHCP_FALL_BACK_AUTO_IP */
}
}
else
{
/* There was no DHCP reply, there was no time-out, just keep on waiting. */
}
break;
case eWaitingAcknowledge:
/* Look for acks coming in. */
if( prvProcessDHCPReplies( dhcpMESSAGE_TYPE_ACK ) == pdPASS )
{
FreeRTOS_debug_printf( ( "vDHCPProcess: acked %lxip\n", FreeRTOS_ntohl( EP_DHCPData.ulOfferedIPAddress ) ) );
/* DHCP completed. The IP address can now be used, and the
* timer set to the lease timeout time. */
*ipLOCAL_IP_ADDRESS_POINTER = EP_DHCPData.ulOfferedIPAddress;
/* Setting the 'local' broadcast address, something like
* '192.168.1.255'. */
EP_IPv4_SETTINGS.ulBroadcastAddress = ( EP_DHCPData.ulOfferedIPAddress & xNetworkAddressing.ulNetMask ) | ~xNetworkAddressing.ulNetMask;
EP_DHCPData.eDHCPState = eLeasedAddress;
iptraceDHCP_SUCCEDEED( EP_DHCPData.ulOfferedIPAddress );
/* DHCP failed, the default configured IP-address will be used
* Now call vIPNetworkUpCalls() to send the network-up event and
* start the ARP timer. */
vIPNetworkUpCalls();
/* Close socket to ensure packets don't queue on it. */
prvCloseDHCPSocket();
if( EP_DHCPData.ulLeaseTime == 0UL )
{
EP_DHCPData.ulLeaseTime = ( uint32_t ) dhcpDEFAULT_LEASE_TIME;
}
else if( EP_DHCPData.ulLeaseTime < dhcpMINIMUM_LEASE_TIME )
{
EP_DHCPData.ulLeaseTime = dhcpMINIMUM_LEASE_TIME;
}
else
{
/* The lease time is already valid. */
}
/* Check for clashes. */
vARPSendGratuitous();
vIPReloadDHCPTimer( EP_DHCPData.ulLeaseTime );
}
else
{
/* Is it time to send another Discover? */
if( ( xTaskGetTickCount() - EP_DHCPData.xDHCPTxTime ) > EP_DHCPData.xDHCPTxPeriod )
{
/* Increase the time period, and if it has not got to the
* point of giving up - send another request. */
EP_DHCPData.xDHCPTxPeriod <<= 1;
if( EP_DHCPData.xDHCPTxPeriod <= ( TickType_t ) ipconfigMAXIMUM_DISCOVER_TX_PERIOD )
{
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
if( prvSendDHCPRequest() == pdPASS )
{
/* The message is sent. Stay in state 'eWaitingAcknowledge'. */
}
else
{
/* Either the creation of a message buffer failed, or sendto().
* Try again in the next cycle. */
FreeRTOS_debug_printf( ( "Send failed during eWaitingAcknowledge.\n" ) );
EP_DHCPData.eDHCPState = eSendDHCPRequest;
}
}
else
{
/* Give up, start again. */
EP_DHCPData.eDHCPState = eInitialWait;
}
}
}
break;
#if ( ipconfigDHCP_FALL_BACK_AUTO_IP != 0 )
case eGetLinkLayerAddress:
if( ( xTaskGetTickCount() - EP_DHCPData.xDHCPTxTime ) > EP_DHCPData.xDHCPTxPeriod )
{
if( xARPHadIPClash == pdFALSE )
{
/* ARP OK. proceed. */
iptraceDHCP_SUCCEDEED( EP_DHCPData.ulOfferedIPAddress );
/* Auto-IP succeeded, the default configured IP-address will
* be used. Now call vIPNetworkUpCalls() to send the
* network-up event and start the ARP timer. */
vIPNetworkUpCalls();
EP_DHCPData.eDHCPState = eNotUsingLeasedAddress;
}
else
{
/* ARP clashed - try another IP address. */
prvPrepareLinkLayerIPLookUp();
/* Setting an IP address manually so set to not using leased
* address mode. */
EP_DHCPData.eDHCPState = eGetLinkLayerAddress;
}
}
break;
#endif /* ipconfigDHCP_FALL_BACK_AUTO_IP */
case eLeasedAddress:
if( FreeRTOS_IsNetworkUp() != 0 )
{
/* Resend the request at the appropriate time to renew the lease. */
prvCreateDHCPSocket();
if( xDHCPSocket != NULL )
{
uint32_t ulID;
if( xApplicationGetRandomNumber( &( ulID ) ) != pdFALSE )
{
EP_DHCPData.ulTransactionId = ulID;
}
EP_DHCPData.xDHCPTxTime = xTaskGetTickCount();
EP_DHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;
if( prvSendDHCPRequest() == pdPASS )
{
/* The packet was sent successfully, wait for an acknowledgement. */
EP_DHCPData.eDHCPState = eWaitingAcknowledge;
}
else
{
/* The packet was not sent, try sending it later. */
EP_DHCPData.eDHCPState = eSendDHCPRequest;
FreeRTOS_debug_printf( ( "Send failed eLeasedAddress.\n" ) );
}
/* From now on, we should be called more often */
vIPReloadDHCPTimer( dhcpINITIAL_TIMER_PERIOD );
}
}
else
{
/* See PR #53 on github/freertos/freertos */
FreeRTOS_printf( ( "DHCP: lease time finished but network is down\n" ) );
vIPReloadDHCPTimer( pdMS_TO_TICKS( 5000U ) );
}
break;
case eNotUsingLeasedAddress:
vIPSetDHCPTimerEnableState( pdFALSE );
break;
default:
/* Lint: all options are included. */
break;
}
if( xGivingUp != pdFALSE )
{
/* xGivingUp became true either because of a time-out, or because
* xApplicationDHCPHook() returned another value than 'eDHCPContinue',
* meaning that the conversion is cancelled from here. */
/* Revert to static IP address. */
taskENTER_CRITICAL();
{
*ipLOCAL_IP_ADDRESS_POINTER = xNetworkAddressing.ulDefaultIPAddress;
iptraceDHCP_REQUESTS_FAILED_USING_DEFAULT_IP_ADDRESS( xNetworkAddressing.ulDefaultIPAddress );
}
taskEXIT_CRITICAL();
EP_DHCPData.eDHCPState = eNotUsingLeasedAddress;
vIPSetDHCPTimerEnableState( pdFALSE );
/* DHCP failed, the default configured IP-address will be used. Now
* call vIPNetworkUpCalls() to send the network-up event and start the ARP
* timer. */
vIPNetworkUpCalls();
/* Close socket to ensure packets don't queue on it. */
prvCloseDHCPSocket();
}
}
}
/*-----------------------------------------------------------*/
/**
* @brief Close the DHCP socket.
*/
static void prvCloseDHCPSocket( void )
{
if( xDHCPSocket != NULL )
{
/* This modules runs from the IP-task. Use the internal
* function 'vSocketClose()` to close the socket. */
( void ) vSocketClose( xDHCPSocket );
xDHCPSocket = NULL;
}
}
/*-----------------------------------------------------------*/
/**
* @brief Create a DHCP socket with the defined timeouts.
*/
_static void prvCreateDHCPSocket( void )
{
struct freertos_sockaddr xAddress;
BaseType_t xReturn;
TickType_t xTimeoutTime = ( TickType_t ) 0;
/* Create the socket, if it has not already been created. */
if( xDHCPSocket == NULL )
{
xDHCPSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );
if( xDHCPSocket != FREERTOS_INVALID_SOCKET )
{
/* Ensure the Rx and Tx timeouts are zero as the DHCP executes in the
* context of the IP task. */
( void ) FreeRTOS_setsockopt( xDHCPSocket, 0, FREERTOS_SO_RCVTIMEO, &( xTimeoutTime ), sizeof( TickType_t ) );
( void ) FreeRTOS_setsockopt( xDHCPSocket, 0, FREERTOS_SO_SNDTIMEO, &( xTimeoutTime ), sizeof( TickType_t ) );
/* Bind to the standard DHCP client port. */
xAddress.sin_port = ( uint16_t ) dhcpCLIENT_PORT_IPv4;
xReturn = vSocketBind( xDHCPSocket, &xAddress, sizeof( xAddress ), pdFALSE );
if( xReturn != 0 )
{
/* Binding failed, close the socket again. */
prvCloseDHCPSocket();
}
}
else
{
/* Change to NULL for easier testing. */
xDHCPSocket = NULL;
}
}
}
/*-----------------------------------------------------------*/
/**
* @brief Initialise the DHCP state machine by creating DHCP socket and
* begin the transaction.
*/
static void prvInitialiseDHCP( void )
{
/* Initialise the parameters that will be set by the DHCP process. Per
* https://www.ietf.org/rfc/rfc2131.txt, Transaction ID should be a random
* value chosen by the client. */
/* Check for random number generator API failure. */
if( xApplicationGetRandomNumber( &( EP_DHCPData.ulTransactionId ) ) != pdFALSE )
{
EP_DHCPData.xUseBroadcast = 0;
EP_DHCPData.ulOfferedIPAddress = 0UL;
EP_DHCPData.ulDHCPServerAddress = 0UL;
EP_DHCPData.xDHCPTxPeriod = dhcpINITIAL_DHCP_TX_PERIOD;
/* Create the DHCP socket if it has not already been created. */
prvCreateDHCPSocket();
FreeRTOS_debug_printf( ( "prvInitialiseDHCP: start after %lu ticks\n", dhcpINITIAL_TIMER_PERIOD ) );
vIPReloadDHCPTimer( dhcpINITIAL_TIMER_PERIOD );
}
else
{
/* There was a problem with the randomiser. */
}
}
/*-----------------------------------------------------------*/
/**
* @brief Process the DHCP replies.
*
* @param[in] xExpectedMessageType: The type of the message the DHCP state machine is expecting.
* Messages of different type will be dropped.
*
* @return pdPASS: if DHCP options are received correctly; pdFAIL: Otherwise.
*/
_static BaseType_t prvProcessDHCPReplies( BaseType_t xExpectedMessageType )
{
uint8_t * pucUDPPayload;
int32_t lBytes;
const DHCPMessage_IPv4_t * pxDHCPMessage;
const uint8_t * pucByte;
uint8_t ucOptionCode;
uint32_t ulProcessed, ulParameter;
BaseType_t xReturn = pdFALSE;
const uint32_t ulMandatoryOptions = 2UL; /* DHCP server address, and the correct DHCP message type must be present in the options. */
/* memcpy() helper variables for MISRA Rule 21.15 compliance*/
const void * pvCopySource;
void * pvCopyDest;
/* Passing the address of a pointer (pucUDPPayload) because FREERTOS_ZERO_COPY is used. */
lBytes = FreeRTOS_recvfrom( xDHCPSocket, &pucUDPPayload, 0UL, FREERTOS_ZERO_COPY, NULL, NULL );
if( lBytes > 0 )
{
/* Map a DHCP structure onto the received data. */
pxDHCPMessage = ipCAST_CONST_PTR_TO_CONST_TYPE_PTR( DHCPMessage_IPv4_t, pucUDPPayload );
/* Sanity check. */
if( lBytes < ( int32_t ) sizeof( DHCPMessage_IPv4_t ) )
{
/* Not enough bytes. */
}
else if( ( pxDHCPMessage->ulDHCPCookie != ( uint32_t ) dhcpCOOKIE ) ||
( pxDHCPMessage->ucOpcode != ( uint8_t ) dhcpREPLY_OPCODE ) )
{
/* Invalid cookie or unexpected opcode. */
}
else if( ( pxDHCPMessage->ulTransactionID != FreeRTOS_htonl( EP_DHCPData.ulTransactionId ) ) )
{
/* Transaction ID does not match. */
}
else /* Looks like a valid DHCP response, with the same transaction ID. */
{
if( memcmp( pxDHCPMessage->ucClientHardwareAddress,
ipLOCAL_MAC_ADDRESS,
sizeof( MACAddress_t ) ) != 0 )
{
/* Target MAC address doesn't match. */
}
else
{
size_t uxIndex, uxPayloadDataLength, uxLength;
/* None of the essential options have been processed yet. */
ulProcessed = 0UL;
/* Walk through the options until the dhcpOPTION_END_BYTE byte
* is found, taking care not to walk off the end of the options. */
pucByte = &( pucUDPPayload[ sizeof( DHCPMessage_IPv4_t ) ] );
uxIndex = 0;
uxPayloadDataLength = ( ( size_t ) lBytes ) - sizeof( DHCPMessage_IPv4_t );
while( uxIndex < uxPayloadDataLength )
{
ucOptionCode = pucByte[ uxIndex ];
if( ucOptionCode == ( uint8_t ) dhcpOPTION_END_BYTE )
{
/* Ready, the last byte has been seen. */
/* coverity[break_stmt] : Break statement terminating the loop */
break;
}
if( ucOptionCode == ( uint8_t ) dhcpIPv4_ZERO_PAD_OPTION_CODE )
{
/* The value zero is used as a pad byte,
* it is not followed by a length byte. */
uxIndex = uxIndex + 1U;
continue;
}
/* Stop if the response is malformed. */
if( ( uxIndex + 1U ) < uxPayloadDataLength )
{
/* Fetch the length byte. */
uxLength = ( size_t ) pucByte[ uxIndex + 1U ];
uxIndex = uxIndex + 2U;
if( !( ( ( uxIndex + uxLength ) - 1U ) < uxPayloadDataLength ) )
{
/* There are not as many bytes left as there should be. */
break;
}
}
else
{
/* The length byte is missing. */
break;
}
/* In most cases, a 4-byte network-endian parameter follows,
* just get it once here and use later. */
if( uxLength >= sizeof( ulParameter ) )
{
/*
* Use helper variables for memcpy() to remain
* compliant with MISRA Rule 21.15. These should be
* optimized away.
*/
pvCopySource = &pucByte[ uxIndex ];
pvCopyDest = &ulParameter;
( void ) memcpy( pvCopyDest, pvCopySource, sizeof( ulParameter ) );
/* 'uxIndex' will be increased at the end of this loop. */
}
else
{
ulParameter = 0;
}
/* Confirm uxIndex is still a valid index after adjustments to uxIndex above */
if( !( uxIndex < uxPayloadDataLength ) )
{
break;
}
/* Option-specific handling. */
switch( ucOptionCode )
{
case dhcpIPv4_MESSAGE_TYPE_OPTION_CODE:
if( pucByte[ uxIndex ] == ( uint8_t ) xExpectedMessageType )
{
/* The message type is the message type the
* state machine is expecting. */
ulProcessed++;
}
else
{
if( pucByte[ uxIndex ] == ( uint8_t ) dhcpMESSAGE_TYPE_NACK )
{
if( xExpectedMessageType == ( BaseType_t ) dhcpMESSAGE_TYPE_ACK )
{
/* Start again. */
EP_DHCPData.eDHCPState = eInitialWait;
}
}
/* Stop processing further options. */
uxLength = 0;
}
break;
case dhcpIPv4_SUBNET_MASK_OPTION_CODE:
if( uxLength == sizeof( uint32_t ) )
{
EP_IPv4_SETTINGS.ulNetMask = ulParameter;
}
break;
case dhcpIPv4_GATEWAY_OPTION_CODE:
/* The DHCP server may send more than 1 gateway addresses. */
if( uxLength >= sizeof( uint32_t ) )
{
/* ulProcessed is not incremented in this case
* because the gateway is not essential. */
EP_IPv4_SETTINGS.ulGatewayAddress = ulParameter;
}
break;
case dhcpIPv4_DNS_SERVER_OPTIONS_CODE:
/* ulProcessed is not incremented in this case
* because the DNS server is not essential. Only the
* first DNS server address is taken. */
EP_IPv4_SETTINGS.ulDNSServerAddress = ulParameter;
break;
case dhcpIPv4_SERVER_IP_ADDRESS_OPTION_CODE:
if( uxLength == sizeof( uint32_t ) )
{
if( xExpectedMessageType == ( BaseType_t ) dhcpMESSAGE_TYPE_OFFER )
{
/* Offers state the replying server. */
ulProcessed++;
EP_DHCPData.ulDHCPServerAddress = ulParameter;
}
else
{
/* The ack must come from the expected server. */
if( EP_DHCPData.ulDHCPServerAddress == ulParameter )
{
ulProcessed++;
}
}
}
break;
case dhcpIPv4_LEASE_TIME_OPTION_CODE:
if( uxLength == sizeof( EP_DHCPData.ulLeaseTime ) )
{
/* ulProcessed is not incremented in this case