PageRenderTime 56ms CodeModel.GetById 24ms RepoModel.GetById 0ms app.codeStats 0ms

/platform/FNET/fnet_stack/services/dhcp/fnet_dhcp.c

https://gitlab.com/fuggles/ucos
C | 1331 lines | 795 code | 199 blank | 337 comment | 105 complexity | feefc34b71e028b1806882c461cdac1c MD5 | raw file
Possible License(s): GPL-3.0, LGPL-3.0

Large files files are truncated, but you can click here to view the full file

    

  1. /**************************************************************************

    2. 

  2. * 

    3. 

  3. * Copyright 2011-2015 by Andrey Butok. FNET Community.

    4. 

  4. * Copyright 2008-2010 by Andrey Butok. Freescale Semiconductor, Inc.

    5. 

  5. *

    6. 

  6. ***************************************************************************

    7. 

  7. * This program is free software: you can redistribute it and/or modify

    8. 

  8. * it under the terms of the GNU Lesser General Public License Version 3 

    9. 

  9. * or later (the "LGPL").

    10. 

  10. *

    11. 

  11. * As a special exception, the copyright holders of the FNET project give you

    12. 

  12. * permission to link the FNET sources with independent modules to produce an

    13. 

  13. * executable, regardless of the license terms of these independent modules,

    14. 

  14. * and to copy and distribute the resulting executable under terms of your 

    15. 

  15. * choice, provided that you also meet, for each linked independent module,

    16. 

  16. * the terms and conditions of the license of that module.

    17. 

  17. * An independent module is a module which is not derived from or based 

    18. 

  18. * on this library. 

    19. 

  19. * If you modify the FNET sources, you may extend this exception 

    20. 

  20. * to your version of the FNET sources, but you are not obligated 

    21. 

  21. * to do so. If you do not wish to do so, delete this

    22. 

  22. * exception statement from your version.

    23. 

  23. *

    24. 

  24. * This program is distributed in the hope that it will be useful,

    25. 

  25. * but WITHOUT ANY WARRANTY; without even the implied warranty of

    26. 

  26. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

    27. 

  27. *

    28. 

  28. * You should have received a copy of the GNU General Public License

    29. 

  29. * and the GNU Lesser General Public License along with this program.

    30. 

  30. * If not, see <http://www.gnu.org/licenses/>.

    31. 

  31. *

    32. 

  32. **********************************************************************/ /*!

    33. 

  33. *

    34. 

  34. * @file fnet_dhcp.c

    35. 

  35. *

    36. 

  36. * @author Andrey Butok

    37. 

  37. *

    38. 

  38. * @brief DHCP/BOOTP Client implementation.

    39. 

  39. *  

    40. 

  40. *  BOOTP is based on Peter Baertschi contribution (Siemens Building Technologies).

    41. 

  41. *

    42. 

  42. ***************************************************************************/

    43. 

  43. 

    44. 

  44. 

    45. 

  45. /*

    46. 

  46. * Boot file name (or two-step bootstrap procedure) is not suported.

    47. 

  47. */

    48. 

  48. 

    49. 

  49. #include "fnet.h"

    50. 

  50. 

    51. 

  51. #if FNET_CFG_DHCP && FNET_CFG_IP4

    52. 

  52. 

    53. 

  53. 

    54. 

  54. #if FNET_CFG_DEBUG_DHCP    

    55. 

  55.     #define FNET_DEBUG_DHCP   FNET_DEBUG

    56. 

  56. #else

    57. 

  57.     #define FNET_DEBUG_DHCP(...)

    58. 

  58. #endif

    59. 

  59. 

    60. 

  60. /************************************************************************

    61. 

  61. *     Definitions

    62. 

  62. *************************************************************************/

    63. 

  63. 

    64. 

  64. 

    65. 

  65. #define FNET_DHCP_OP_BOOTREQUEST        (1U)

    66. 

  66. #define FNET_DHCP_FLAGS_BROADCAST       (0x8000U)

    67. 

  67. 

    68. 

  68. #if !FNET_CFG_DHCP_BOOTP /* Not used by BOOTP */

    69. 

  69.     #define FNET_DHCP_OP_BOOTREPLY          (2U)

    70. 

  70. 

    71. 

  71.     #define FNET_DHCP_LEASE_MAX             (0xFFFFFFFFU/(1000U*2U)) /* Maximum lease time value (cause of timer counter is in ms) */

    72. 

  72. 

    73. 

  73.     #define FNET_DHCP_STATE_REBOOTING_SEND_TIMEOUT      (4U*1000U)          /*(ms) timeout for ACK => request retransmission.*/

    74. 

  74.     #define FNET_DHCP_STATE_REBOOTING_TIMEOUT           (2U*FNET_DHCP_STATE_REBOOTING_SEND_TIMEOUT)  /*(ms) timeout to go to INIT state.*/

    75. 

  75.     #define FNET_DHCP_STATE_RENEWING_SEND_TIMEOUT       (60U*1000U)                                   /*(ms) timeout for ACK => request retransmission.*/

    76. 

  76.     #define FNET_DHCP_STATE_REBINDING_SEND_TIMEOUT      (60U*1000U)                                   /*(ms) timeout for ACK => request retransmission.*/

    77. 

  77. #endif /* !FNET_CFG_DHCP_BOOTP */

    78. 

  78. 

    79. 

  79. #define FNET_DHCP_STATE_REQUESTING_SEND_TIMEOUT     (4U*1000U)          /*(ms) timeout for ACK => request retransmission.*/

    80. 

  80. #define FNET_DHCP_STATE_REQUESTING_TIMEOUT          (4U*FNET_DHCP_STATE_REQUESTING_SEND_TIMEOUT) /*(ms) timeout to go to INIT state.*/

    81. 

  81. #define FNET_DHCP_STATE_SELECTING_SEND_TIMEOUT      (FNET_CFG_DHCP_RESPONSE_TIMEOUT*1000U)     /*(ms) timeout for OFFER => INIT.*/

    82. 

  82. 

    83. 

  83. #define FNET_DHCP_ERR_SOCKET_CREATION   "ERROR: Socket creation error."

    84. 

  84. #define FNET_DHCP_ERR_SOCKET_BIND       "ERROR: Socket Error during bind."

    85. 

  85. #define FNET_DHCP_ERR_IS_INITIALIZED    "ERROR: DHCP is already initialized."

    86. 

  86. #define FNET_DHCP_ERR_NONETWORK         "ERROR: Network Interface is not configurated."

    87. 

  87. #define FNET_DHCP_ERR_SERVICE           "ERROR: Service registration is failed."

    88. 

  88. 

    89. 

  89. #define FNET_DHCP_ISTIMEOUT (-1)

    90. 

  90. 

    91. 

  91. 

    92. 

  92. /************************************************************************

    93. 

  93. *     DHCP Options. [RFC 2132] definitions

    94. 

  94. *************************************************************************/

    95. 

  95. #define FNET_DHCP_OPTION_PAD                    (0U)     /* Pad option.*/

    96. 

  96. #define FNET_DHCP_OPTION_SUBNETMASK             (1U)     /* Subnet mask.*/

    97. 

  97. #define FNET_DHCP_OPTION_SUBNETMASK_LENGTH      (4U)

    98. 

  98. 

    99. 

  99. #define FNET_DHCP_OPTION_ROUTER                 (3U)     /* Router option (gateway).*/

    100. 

  100. #define FNET_DHCP_OPTION_ROUTER_MULTIPLE        (4U)

    101. 

  101. #define FNET_DHCP_OPTION_DNS                    (6U)     /* Domain Name Server option. */

    102. 

  102. #define FNET_DHCP_OPTION_DNS_LENGTH_MIN         (4U)     /* The minimum length for this option is 4 octets, 

    103. 

  103.                                                          * and the length MUST always be a multiple of 4. */

    104. 

  104. #define FNET_DHCP_OPTION_HOSTNAME               (12U)    /* Hostname */

    105. 

  105. #define FNET_DHCP_OPTION_HOSTNAME_LENGTH        (32U)  

    106. 

  106. #define FNET_DHCP_OPTION_FILELENGTH             (13U)    /* File Length */

    107. 

  107. #define FNET_DHCP_OPTION_FILELENGTH_LENGTH      (2U)  

    108. 

  108. #define FNET_DHCP_OPTION_ROOTPATH               (17U)    /* Rootpath.*/

    109. 

  109. #define FNET_DHCP_OPTION_ROOTPATH_LENGTH        (32U)                                                

    110. 

  110. #define FNET_DHCP_OPTION_BROADCAST              (28U)    /* Broadcast Address option.  */

    111. 

  111. #define FNET_DHCP_OPTION_BROADCAST_LENGTH       (4U)

    112. 

  112. #define FNET_DHCP_OPTION_REQ_ADDRESS            (50U)    /* Requested IP address.*/

    113. 

  113. #define FNET_DHCP_OPTION_REQ_ADDRESS_LENGTH     (4U)

    114. 

  114. #define FNET_DHCP_OPTION_LEASE                  (51U)    /* IP Address lease time (seconds).*/

    115. 

  115. #define FNET_DHCP_OPTION_LEASE_LENGTH           (4U)

    116. 

  116. #define FNET_DHCP_OPTION_OVERLOAD               (52U)    /* Option overload.*/

    117. 

  117. #define FNET_DHCP_OPTION_OVERLOAD_LENGTH        (1U)

    118. 

  118. #define FNET_DHCP_OPTION_OVERLOAD_NONE          (0U)

    119. 

  119. #define FNET_DHCP_OPTION_OVERLOAD_FILE          (1U)     /* The 'file' field is used to hold options.*/

    120. 

  120. #define FNET_DHCP_OPTION_OVERLOAD_SNAME         (2U)     /* The 'sname' field is used to hold options.*/

    121. 

  121. #define FNET_DHCP_OPTION_OVERLOAD_BOTH          (3U)     /* Both fields are used to hold options.*/

    122. 

  122. #define FNET_DHCP_OPTION_TYPE                   (53U)    /* DHCP Message Type.*/

    123. 

  123. #define FNET_DHCP_OPTION_TYPE_LENGTH            (1U)

    124. 

  124. #define FNET_DHCP_OPTION_TYPE_DISCOVER          (1U)

    125. 

  125. #define FNET_DHCP_OPTION_TYPE_OFFER             (2U)

    126. 

  126. #define FNET_DHCP_OPTION_TYPE_REQUEST           (3U)

    127. 

  127. #define FNET_DHCP_OPTION_TYPE_DECLINE           (4U)

    128. 

  128. #define FNET_DHCP_OPTION_TYPE_ACK               (5U)

    129. 

  129. #define FNET_DHCP_OPTION_TYPE_NAK               (6U)

    130. 

  130. #define FNET_DHCP_OPTION_TYPE_RELEASE           (7U)

    131. 

  131. #define FNET_DHCP_OPTION_TYPE_INFORM            (8U)

    132. 

  132. #define FNET_DHCP_OPTION_SERVER_ID              (54U)    /* Server Identifier (ip address).*/

    133. 

  133. #define FNET_DHCP_OPTION_SERVER_ID_LENGTH       (4U)

    134. 

  134. #define FNET_DHCP_OPTION_PARAMETER_REQ_LIST     (55U)    /* Parameter Request List. */

    135. 

  135. #define FNET_DHCP_OPTION_MESSAGE_SIZE           (57U)    /* Maximum DHCP Message Size. The minimum legal value is 576.*/

    136. 

  136. #define FNET_DHCP_OPTION_MESSAGE_SIZE_LENGTH    (2U)

    137. 

  137. #define FNET_DHCP_OPTION_T1                     (58U)    /* Renewal (T1) Time Value.*/

    138. 

  138. #define FNET_DHCP_OPTION_T1_LENGTH              (4U)

    139. 

  139. #define FNET_DHCP_OPTION_T2                     (59U)    /* Rebinding (T2) Time Value. */

    140. 

  140. #define FNET_DHCP_OPTION_T2_LENGTH              (4U)

    141. 

  141. #define FNET_DHCP_OPTION_CLIENT_ID              (61U)    /* Client-identifier.*/

    142. 

  142. #define FNET_DHCP_OPTION_CLIENT_ID_LENGTH       (sizeof(fnet_mac_addr_t)+1U)

    143. 

  143. #define FNET_DHCP_OPTION_END                    (255U)   /* End option. */

    144. 

  144. 

    145. 

  145. static const unsigned char fnet_dhcp_magic_cookie [] =

    146. 

  146. {

    147. 

  147.   99, 130, 83, 99

    148. 

  148. }; /* The first four octets of the vendor information

    149. 

  149. *   field have been assigned to the "magic cookie".*/

    150. 

  150. 

    151. 

  151. #define FNET_DHCP_OPTIONS_LENGTH (312U) /* [RFC2131, 2] A DHCP client must be prepared to receive DHCP messages 

    152. 

  152.                                         *   with an 'options' field of at least length 312 octets.*/

    153. 

  153. 

    154. 

  154. /**************************************************************************/ /*!

    155. 

  155.  * Private DHCP options.

    156. 

  156.  ******************************************************************************/

    157. 

  157. struct fnet_dhcp_options_prv

    158. 

  158. {

    159. 

  159.    

    160. 

  160.     unsigned char message_type;     /* The DHCP Message Type.

    161. 

  161.                                      * This option is used to convey the type of the 

    162. 

  162.                                      * last DHCP message.	                                     

    163. 

  163.                                      */

    164. 

  164. 

    165. 

  165. #if FNET_CFG_DHCP_OVERLOAD && !FNET_CFG_DHCP_BOOTP

    166. 

  166. 

    167. 

  167.     unsigned char overload;         /* Overload Option.

    168. 

  168.                                      * If this option is present, the DHCP client interprets 

    169. 

  169.                                      * the specified additional fields after it concludes 

    170. 

  170.                                      * interpretation of the standard option fields.

    171. 

  171.                                      */

    172. 

  172. #endif

    173. 

  173. 

    174. 

  174. };

    175. 

  175. 

    176. 

  176. /**************************************************************************/ /*!

    177. 

  177.  * All DHCP options are retrieved from a DHCP server.

    178. 

  178.  ******************************************************************************/ 

    179. 

  179. struct fnet_dhcp_options_in

    180. 

  180. {

    181. 

  181.     struct fnet_dhcp_options public_options;

    182. 

  182.     struct fnet_dhcp_options_prv private_options;

    183. 

  183. };

    184. 

  184. 

    185. 

  185. /************************************************************************

    186. 

  186. *    DHCP header [RFC2131, 2]

    187. 

  187. *************************************************************************

    188. 

  188.    0                   1                   2                   3

    189. 

  189.    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1

    190. 

  190.    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

    191. 

  191.    |     op (1)    |   htype (1)   |   hlen (1)    |   hops (1)    |

    192. 

  192.    +---------------+---------------+---------------+---------------+

    193. 

  193.    |                            xid (4) - Transaction ID                           |

    194. 

  194.    +-------------------------------+-------------------------------+

    195. 

  195.    |           secs (2)            |           flags (2)           |

    196. 

  196.    +-------------------------------+-------------------------------+

    197. 

  197.    |                          ciaddr  (4) - client IP addr         |

    198. 

  198.    +---------------------------------------------------------------+

    199. 

  199.    |                          yiaddr  (4) - your (client) IP addr  |

    200. 

  200.    +---------------------------------------------------------------+

    201. 

  201.    |                          siaddr  (4) - server IP addr         |

    202. 

  202.    +---------------------------------------------------------------+

    203. 

  203.    |                          giaddr  (4) - relay aget IP addr     |

    204. 

  204.    +---------------------------------------------------------------+

    205. 

  205.    |                                                               |

    206. 

  206.    |                          chaddr  (16) - client HW adress.     |

    207. 

  207.    |                                                               |

    208. 

  208.    |                                                               |

    209. 

  209.    +---------------------------------------------------------------+

    210. 

  210.    |                                                               |

    211. 

  211.    |                          sname   (64) - server host name      |

    212. 

  212.    +---------------------------------------------------------------+

    213. 

  213.    |                                                               |

    214. 

  214.    |                          file    (128) - boot file name       |

    215. 

  215.    +---------------------------------------------------------------+

    216. 

  216.    |                          DHCP magic cookie    (4)             |

    217. 

  217.    +---------------------------------------------------------------+   

    218. 

  218.    |                                                               |

    219. 

  219.    |                          options (variable)                   |   

    220. 

  220.    +---------------------------------------------------------------+

    221. 

  221.    | opt end = 0xFF|

    222. 

  222.    +---------------+*/

    223. 

  223. 

    224. 

  224. FNET_COMP_PACKED_BEGIN

    225. 

  225. typedef struct

    226. 

  226. {

    227. 

  227.     unsigned char   op FNET_COMP_PACKED;        /* Message op code / message type:

    228. 

  228.                                                  *   1 = BOOTREQUEST, 2 = BOOTREPLY */

    229. 

  229.     unsigned char   htype FNET_COMP_PACKED;     /* Hardware address type, see ARP section in "Assigned

    230. 

  230.                                                  *   Numbers" RFC; e.g., '1' = 10mb ethernet.*/

    231. 

  231.     unsigned char   hlen FNET_COMP_PACKED;      /* Hardware address length (e.g.  '6' for 10mb ethernet).*/

    232. 

  232.     unsigned char   hops FNET_COMP_PACKED;      /* Client sets to zero, optionally used by relay agents

    233. 

  233.                                                  *   when booting via a relay agent.*/

    234. 

  234.     unsigned long   xid FNET_COMP_PACKED;       /* Transaction ID, a random number chosen by the

    235. 

  235.                                                  *   client, used by the client and server to associate

    236. 

  236.                                                  *   messages and responses between a client and a server.*/

    237. 

  237.     unsigned short  secs FNET_COMP_PACKED;      /* Filled in by client, seconds elapsed since client

    238. 

  238.                                                  *   began address acquisition or renewal process.*/

    239. 

  239.     unsigned short  flags FNET_COMP_PACKED;     /* Flags.*/

    240. 

  240.     fnet_ip4_addr_t ciaddr FNET_COMP_PACKED;    /* Client IP address; only filled in if client is in BOUND,

    241. 

  241.                                                  *   RENEW or REBINDING state and can respond to ARP requests.*/

    242. 

  242.     fnet_ip4_addr_t yiaddr FNET_COMP_PACKED;    /* Your (client) IP address.*/

    243. 

  243.     fnet_ip4_addr_t siaddr FNET_COMP_PACKED;    /* IP address of next server to use in bootstrap;

    244. 

  244.                                                  *   returned in DHCPOFFER, DHCPACK by server.*/

    245. 

  245.     fnet_ip4_addr_t giaddr FNET_COMP_PACKED;    /* Relay agent IP address, used in booting via a relay agent.*/

    246. 

  246.     unsigned char   chaddr[16] FNET_COMP_PACKED;/* Client hardware address.*/

    247. 

  247.     unsigned char   sname[64] FNET_COMP_PACKED; /* Optional server host name, null terminated string.*/

    248. 

  248.     unsigned char   file[128] FNET_COMP_PACKED; /* Boot file name, null terminated string; "generic"

    249. 

  249.                                                  *   name or null in DHCPDISCOVER, fully qualified

    250. 

  250.                                                  *   directory-path name in DHCPOFFER.*/

    251. 

  251.     char            magic_cookie[4] FNET_COMP_PACKED;

    252. 

  252.     unsigned char   options[FNET_DHCP_OPTIONS_LENGTH] FNET_COMP_PACKED; /* Optional parameters field. See [RFC2132].*/

    253. 

  253. } fnet_dhcp_header_t;

    254. 

  254. FNET_COMP_PACKED_END

    255. 

  255. 

    256. 

  256. /************************************************************************

    257. 

  257. *    DHCP message control structure.

    258. 

  258. *************************************************************************/

    259. 

  259. 

    260. 

  260. typedef struct

    261. 

  261. {

    262. 

  262.     unsigned char *next_option_position;

    263. 

  263.     unsigned char *end_position;

    264. 

  264.     fnet_dhcp_header_t header;

    265. 

  265. } fnet_dhcp_message_t;

    266. 

  266. 

    267. 

  267. /************************************************************************

    268. 

  268. *    DHCP interface interface structure

    269. 

  269. *************************************************************************/

    270. 

  270. typedef struct

    271. 

  271. {

    272. 

  272.     SOCKET              socket_client;

    273. 

  273.     fnet_dhcp_state_t   state;                      /* Current state.*/

    274. 

  274. 

    275. 

  275. #if !FNET_CFG_DHCP_BOOTP    

    276. 

  276.     unsigned long       state_timeout;              /* Current State timeout (ticks).*/

    277. 

  277.     fnet_dhcp_state_t   state_timeout_next_state;   /* Next state on state timeout.*/

    278. 

  278.     unsigned long       lease_obtained_time;

    279. 

  279. #endif

    280. 

  280. 

    281. 

  281.     unsigned long       state_send_timeout;         /* Current State send request timeout (ticks).*/

    282. 

  282.     unsigned long       send_request_time;          /* Time at which the client sent the REQUEST message */

    283. 

  283.     fnet_mac_addr_t     macaddr;

    284. 

  284.     unsigned long       xid;

    285. 

  285.     fnet_dhcp_message_t message;

    286. 

  286.     struct fnet_dhcp_params     in_params;          /* Input user parameters.*/

    287. 

  287.     struct fnet_dhcp_options_in current_options;    /* parsed options */

    288. 

  288.     struct fnet_dhcp_options_in offered_options;    /* parsed options */

    289. 

  289.     fnet_netif_desc_t           netif;

    290. 

  290.     fnet_poll_desc_t            service_descriptor;

    291. 

  291.     

    292. 

  292.     fnet_dhcp_handler_updated_t handler_updated;    /* Optional ponter to the handler 

    293. 

  293.                                                      * callback function, that is 

    294. 

  294.                                                      * called when the DHCP client has 

    295. 

  295.                                                      * updated the IP parameters.

    296. 

  296.                                                      */

    297. 

  297.     fnet_dhcp_handler_discover_t handler_discover;  /* Optional pointer to the handler 

    298. 

  298.                                                      * callback function, that is 

    299. 

  299.                                                      * called when the DHCP client send 

    300. 

  300.                                                      * the DHCP discover message.  

    301. 

  301.                                                      */

    302. 

  302.     void                *handler_discover_param;    /* Optional user-application specific parameter. 

    303. 

  303.                                                      * It's passed to @ref fnet_dhcp_handler_discover_t. 

    304. 

  304.                                                      */   

    305. 

  305.     void                *handler_updated_param;     /* Optional user-application specific parameter. 

    306. 

  306.                                                      * It's passed to @ref fnet_dhcp_handler_updated_t 

    307. 

  307.                                                      * event handler. 

    308. 

  308.                                                      */                                              

    309. 

  309. } fnet_dhcp_if_t;

    310. 

  310. 

    311. 

  311. 

    312. 

  312. /* DHCP client interface */

    313. 

  313. static fnet_dhcp_if_t fnet_dhcp_if;

    314. 

  314. 

    315. 

  315. /* List of dhcp parameter/options we request.*/

    316. 

  316. static const char fnet_dhcp_parameter_request_list [] =

    317. 

  317. {

    318. 

  318.   FNET_DHCP_OPTION_SUBNETMASK, 

    319. 

  319.   FNET_DHCP_OPTION_ROUTER, 

    320. 

  320. #if FNET_CFG_DNS  

    321. 

  321.   FNET_DHCP_OPTION_DNS, 

    322. 

  322. #endif

    323. 

  323. #if FNET_CFG_DHCP_BROADCAST 

    324. 

  324.   FNET_DHCP_OPTION_BROADCAST,

    325. 

  325. #endif  

    326. 

  326.   FNET_DHCP_OPTION_LEASE,      

    327. 

  327.   FNET_DHCP_OPTION_T1,     

    328. 

  328.   FNET_DHCP_OPTION_T2

    329. 

  329. };

    330. 

  330. 

    331. 

  331. static int fnet_dhcp_add_option( fnet_dhcp_message_t *message, unsigned char option_code,

    332. 

  332.                                  unsigned char option_length,  void *option_value );

    333. 

  333. static unsigned char *fnet_dhcp_next_option( fnet_dhcp_message_t *message );

    334. 

  334. static void fnet_dhcp_parse_options( fnet_dhcp_message_t *message, struct fnet_dhcp_options_in *options );

    335. 

  335. static int fnet_dhcp_send_message( fnet_dhcp_if_t *dhcp );

    336. 

  336. static int fnet_dhcp_receive_message( fnet_dhcp_if_t *dhcp, struct fnet_dhcp_options_in *options );

    337. 

  337. static void fnet_dhcp_apply_params(fnet_dhcp_if_t *dhcp); 

    338. 

  338. static void fnet_dhcp_change_state( fnet_dhcp_if_t *dhcp, fnet_dhcp_state_t state );

    339. 

  339. static void fnet_dhcp_state_machine( void *fnet_dhcp_if_p );

    340. 

  340. 

    341. 

  341. 

    342. 

  342. #if FNET_CFG_DEBUG_DHCP /* Debug functions */

    343. 

  343. /************************************************************************

    344. 

  344. * NAME: fnet_dhcp_print_header

    345. 

  345. *

    346. 

  346. * DESCRIPTION: Print DHCP header. For debug needs.

    347. 

  347. ************************************************************************/

    348. 

  348. 

    349. 

  349. static void fnet_dhcp_print_header( fnet_dhcp_header_t *header )

    350. 

  350. {

    351. 

  351.     char ip_str[FNET_IP4_ADDR_STR_SIZE];

    352. 

  352.     int i;

    353. 

  353. 

    354. 

  354.     FNET_DEBUG_DHCP("DHCP: Message header:");

    355. 

  355.     FNET_DEBUG_DHCP(" op \t %02X", header->op);

    356. 

  356.     FNET_DEBUG_DHCP(" htype \t %02X", header->htype);

    357. 

  357.     FNET_DEBUG_DHCP(" hlen \t %02X", header->hlen);

    358. 

  358.     FNET_DEBUG_DHCP(" hops \t %02X", header->hops);

    359. 

  359.     FNET_DEBUG_DHCP(" xid \t %08X", fnet_ntohl(header->xid));

    360. 

  360.     FNET_DEBUG_DHCP(" secs \t %04X", fnet_ntohs(header->secs));

    361. 

  361.     FNET_DEBUG_DHCP(" secs \t %04X", fnet_ntohs(header->flags));

    362. 

  362.     fnet_inet_ntoa(*(struct in_addr *)(&header->ciaddr), ip_str);

    363. 

  363.     FNET_DEBUG_DHCP(" ciaddr \t %s", ip_str);

    364. 

  364.     fnet_inet_ntoa(*(struct in_addr *)(&header->yiaddr), ip_str);

    365. 

  365.     FNET_DEBUG_DHCP(" yiaddr \t %s", ip_str);

    366. 

  366.     fnet_inet_ntoa(*(struct in_addr *)(&header->siaddr), ip_str);

    367. 

  367.     FNET_DEBUG_DHCP(" siaddr \t %s", ip_str);

    368. 

  368.     fnet_inet_ntoa(*(struct in_addr *)(&header->giaddr), ip_str);

    369. 

  369.     FNET_DEBUG_DHCP(" giaddr \t %s", ip_str);

    370. 

  370.     FNET_DEBUG_DHCP(" chaddr \t ");

    371. 

  371. 

    372. 

  372.     for (i = 0; i < 16; i++)

    373. 

  373.       FNET_DEBUG_DHCP("%02X", header->chaddr[i]);

    374. 

  374. 

    375. 

  375.     FNET_DEBUG_DHCP("");

    376. 

  376.     FNET_DEBUG_DHCP(" sname \t %s", header->sname);

    377. 

  377.     FNET_DEBUG_DHCP(" file \t %s", header->file);

    378. 

  378. }

    379. 

  379. 

    380. 

  380. /************************************************************************

    381. 

  381. * NAME: fnet_dhcp_print_state

    382. 

  382. *

    383. 

  383. * DESCRIPTION: Print DHCP current state. For debug needs.

    384. 

  384. ************************************************************************/

    385. 

  385. static void fnet_dhcp_print_state( fnet_dhcp_if_t *dhcp )

    386. 

  386. {

    387. 

  387.     FNET_DEBUG_DHCP("\nDHCP: State ");

    388. 

  388.     switch(dhcp->state)

    389. 

  389.     {

    390. 

  390.         case FNET_DHCP_STATE_DISABLED:

    391. 

  391.           FNET_DEBUG_DHCP("DISABLED");

    392. 

  392.           break;

    393. 

  393.         case FNET_DHCP_STATE_INIT:

    394. 

  394.           FNET_DEBUG_DHCP("INIT");

    395. 

  395.           break;

    396. 

  396.         case FNET_DHCP_STATE_SELECTING:

    397. 

  397.           FNET_DEBUG_DHCP("SELECTING");

    398. 

  398.           break;

    399. 

  399.         case FNET_DHCP_STATE_BOUND:

    400. 

  400.           FNET_DEBUG_DHCP("BOUND");

    401. 

  401.           break;

    402. 

  402.           

    403. 

  403.     #if !FNET_CFG_DHCP_BOOTP

    404. 

  404.     

    405. 

  405.         case FNET_DHCP_STATE_REQUESTING:

    406. 

  406.           FNET_DEBUG_DHCP("REQUESTING");

    407. 

  407.           break;

    408. 

  408. 

    409. 

  409.         case FNET_DHCP_STATE_RENEWING:

    410. 

  410.           FNET_DEBUG_DHCP("RENEWING");

    411. 

  411.           break;

    412. 

  412. 

    413. 

  413.         case FNET_DHCP_STATE_REBINDING:

    414. 

  414.           FNET_DEBUG_DHCP("REBINDING");

    415. 

  415.           break;

    416. 

  416. 

    417. 

  417.         case FNET_DHCP_STATE_INIT_REBOOT:

    418. 

  418.           FNET_DEBUG_DHCP("INIT_REBOOT");

    419. 

  419.           break;

    420. 

  420. 

    421. 

  421.         case FNET_DHCP_STATE_REBOOTING:

    422. 

  422.           FNET_DEBUG_DHCP("REBOOTING");

    423. 

  423.           break;

    424. 

  424. 

    425. 

  425.         case FNET_DHCP_STATE_RELEASE:

    426. 

  426.           FNET_DEBUG_DHCP("RELEASE");

    427. 

  427.           break;

    428. 

  428.           

    429. 

  429.     #endif /* !FNET_CFG_DHCP_BOOTP */

    430. 

  430.     }

    431. 

  431. }

    432. 

  432. 

    433. 

  433. /************************************************************************

    434. 

  434. * NAME: fnet_dhcp_print_options

    435. 

  435. *

    436. 

  436. * DESCRIPTION: Print DHCP options. For debug needs.

    437. 

  437. ************************************************************************/

    438. 

  438. static void fnet_dhcp_print_options( struct fnet_dhcp_options_in *options )

    439. 

  439. {

    440. 

  440.     char ip_str[FNET_IP4_ADDR_STR_SIZE];

    441. 

  441. 

    442. 

  442.     FNET_DEBUG_DHCP("DHCP: Options:");

    443. 

  443.     FNET_DEBUG_DHCP(" message_type \t\t %02X", options->private_options.message_type);

    444. 

  444. 

    445. 

  445.     fnet_inet_ntoa(*(struct in_addr *)(&options->public_options.ip_address), ip_str);

    446. 

  446.     FNET_DEBUG_DHCP(" ip_address \t\t %s", ip_str);

    447. 

  447.     fnet_inet_ntoa(*(struct in_addr *)(&options->public_options.dhcp_server), ip_str);

    448. 

  448.     FNET_DEBUG_DHCP(" dhcp_server \t %s", ip_str);

    449. 

  449.     fnet_inet_ntoa(*(struct in_addr *)(&options->public_options.netmask), ip_str);

    450. 

  450.     FNET_DEBUG_DHCP(" netmask \t\t %s", ip_str);

    451. 

  451. #if FNET_CFG_DHCP_BROADCAST     

    452. 

  452.     fnet_inet_ntoa(*(struct in_addr *)(&options->public_options.broadcast), ip_str);

    453. 

  453.     FNET_DEBUG_DHCP(" broadcast \t\t %s", ip_str);

    454. 

  454. #endif    

    455. 

  455.     fnet_inet_ntoa(*(struct in_addr *)(&options->public_options.gateway), ip_str);

    456. 

  456.     FNET_DEBUG_DHCP(" gateway \t\t %s", ip_str);

    457. 

  457. 

    458. 

  458.     FNET_DEBUG_DHCP(" t1 \t\t\t 0x%08X", fnet_ntohl(options->public_options.t1));

    459. 

  459.     FNET_DEBUG_DHCP(" t2 \t\t\t 0x%08X", fnet_ntohl(options->public_options.t2));

    460. 

  460.     FNET_DEBUG_DHCP(" lease_time \t\t 0x%08X", options->public_options.lease_time);

    461. 

  461. 

    462. 

  462. #if FNET_CFG_DHCP_OVERLOAD

    463. 

  463. 

    464. 

  464.     FNET_DEBUG_DHCP(" overload \t\t 0x%02X", options->public_options.overload);

    465. 

  465. 

    466. 

  466. #endif

    467. 

  467. 

    468. 

  468. }

    469. 

  469. 

    470. 

  470. #else

    471. 

  471. 

    472. 

  472.     #define fnet_dhcp_print_header(x) do{}while(0)

    473. 

  473.     #define fnet_dhcp_print_state(x) do{}while(0)

    474. 

  474.     #define fnet_dhcp_print_options(x) do{}while(0)

    475. 

  475. 

    476. 

  476. #endif /* FNET_CFG_DEBUG_DHCP */

    477. 

  477. 

    478. 

  478. 

    479. 

  479. /************************************************************************

    480. 

  480. * NAME: fnet_dhcp_add_option

    481. 

  481. *

    482. 

  482. * DESCRIPTION: Add option to a DHCP options field.

    483. 

  483. ************************************************************************/

    484. 

  484. 

    485. 

  485. static int fnet_dhcp_add_option( fnet_dhcp_message_t *message, unsigned char option_code,

    486. 

  486.                                  unsigned char option_length,  void *option_value )

    487. 

  487. {

    488. 

  488.     if((&message->header.options[FNET_DHCP_OPTIONS_LENGTH] - message->next_option_position)

    489. 

  489.            < (unsigned int)(option_length + 2U))

    490. 

  490.         return 1;

    491. 

  491. 

    492. 

  492.     *message->next_option_position++ = option_code;

    493. 

  493.     *message->next_option_position++ = option_length;

    494. 

  494.     fnet_memcpy(message->next_option_position, option_value, (unsigned int)option_length);

    495. 

  495.     message->next_option_position += option_length;

    496. 

  496. 

    497. 

  497.     return 0;

    498. 

  498. }

    499. 

  499. 

    500. 

  500. /************************************************************************

    501. 

  501. * NAME: fnet_dhcp_next_option

    502. 

  502. *

    503. 

  503. * DESCRIPTION: Go to the next DHCP option.

    504. 

  504. ************************************************************************/

    505. 

  505. static unsigned char *fnet_dhcp_next_option( fnet_dhcp_message_t *message )

    506. 

  506. {

    507. 

  507.     unsigned char *current_position = message->next_option_position;

    508. 

  508.     unsigned char length;

    509. 

  509.     unsigned char *result = FNET_NULL;

    510. 

  510. 

    511. 

  511.     /* Check for the end of DHCP packet.

    512. 

  512.      * as we don't want try to access an unmapped memory.*/

    513. 

  513.     if(current_position + 1 >= message->end_position)

    514. 

  514.         goto EXIT;

    515. 

  515. 

    516. 

  516.     /* Skip pad options.*/

    517. 

  517.     while(*current_position == FNET_DHCP_OPTION_PAD)

    518. 

  518.       if(++current_position >= message->end_position)

    519. 

  519.           goto EXIT;

    520. 

  520. 

    521. 

  521.     /* Check End option.*/

    522. 

  522.     if(*current_position == FNET_DHCP_OPTION_END)

    523. 

  523.         goto EXIT;

    524. 

  524. 

    525. 

  525.     length = *(current_position + 1);

    526. 

  526.     /* Check Option Length overflow.*/

    527. 

  527.     if(current_position + length + 2 > message->end_position)

    528. 

  528.         goto EXIT;

    529. 

  529. 

    530. 

  530.     message->next_option_position = current_position + length + 2;

    531. 

  531.     

    532. 

  532.     result = current_position;

    533. 

  533. 

    534. 

  534. EXIT:

    535. 

  535.     

    536. 

  536.     return result;

    537. 

  537. }

    538. 

  538. 

    539. 

  539. /************************************************************************

    540. 

  540. * NAME: fnet_dhcp_parse_options

    541. 

  541. *

    542. 

  542. * DESCRIPTION: Parse DHCP options from message.

    543. 

  543. ************************************************************************/

    544. 

  544. static void fnet_dhcp_parse_options( fnet_dhcp_message_t *message, struct fnet_dhcp_options_in *options )

    545. 

  545. {

    546. 

  546.     unsigned char *current_option;

    547. 

  547. 

    548. 

  548.     while((current_option = fnet_dhcp_next_option(message)) != 0)

    549. 

  549.     {

    550. 

  550.         unsigned char *option_data = current_option + 2;

    551. 

  551.         unsigned char option_length = *(current_option + 1);

    552. 

  552. 

    553. 

  553.         switch(*current_option)

    554. 

  554.         {

    555. 

  555. 

    556. 

  556.             case FNET_DHCP_OPTION_SERVER_ID:

    557. 

  557.               if(option_length == FNET_DHCP_OPTION_SERVER_ID_LENGTH)

    558. 

  558.                   options->public_options.dhcp_server.s_addr = *(unsigned long *)option_data;

    559. 

  559. 

    560. 

  560.               break;

    561. 

  561. 

    562. 

  562.             case FNET_DHCP_OPTION_SUBNETMASK:

    563. 

  563.               if(option_length == FNET_DHCP_OPTION_SUBNETMASK_LENGTH)

    564. 

  564.                   options->public_options.netmask.s_addr = *(unsigned long *)option_data;

    565. 

  565. 

    566. 

  566.               break;

    567. 

  567. 

    568. 

  568.             case FNET_DHCP_OPTION_ROUTER:

    569. 

  569.               if(option_length >= FNET_DHCP_OPTION_ROUTER_MULTIPLE)

    570. 

  570.                   options->public_options.gateway.s_addr = *(unsigned long *)option_data;

    571. 

  571. 

    572. 

  572.               break;

    573. 

  573.               

    574. 

  574.         #if FNET_CFG_DHCP_BROADCAST   

    575. 

  575.             case FNET_DHCP_OPTION_BROADCAST:

    576. 

  576.               if(option_length == FNET_DHCP_OPTION_BROADCAST_LENGTH)

    577. 

  577.                   options->public_options.broadcast.s_addr = *(unsigned long *)option_data;

    578. 

  578. 

    579. 

  579.               break;

    580. 

  580.         #endif

    581. 

  581.         #if FNET_CFG_DNS              

    582. 

  582.             case FNET_DHCP_OPTION_DNS: 

    583. 

  583.               if(option_length >= FNET_DHCP_OPTION_DNS_LENGTH_MIN)

    584. 

  584.                   options->public_options.dns.s_addr = *(unsigned long *)option_data;

    585. 

  585. 

    586. 

  586.               break;

    587. 

  587.         #endif

    588. 

  588. 

    589. 

  589.         #if !FNET_CFG_DHCP_BOOTP

    590. 

  590. 

    591. 

  591.             case FNET_DHCP_OPTION_TYPE:

    592. 

  592.               if(option_length == FNET_DHCP_OPTION_TYPE_LENGTH)

    593. 

  593.                   options->private_options.message_type = *option_data;

    594. 

  594. 

    595. 

  595.               break;

    596. 

  596. 

    597. 

  597.             case FNET_DHCP_OPTION_LEASE:

    598. 

  598.               if(option_length == FNET_DHCP_OPTION_LEASE_LENGTH)

    599. 

  599.                   options->public_options.lease_time = *(unsigned long *)option_data;

    600. 

  600. 

    601. 

  601.               break;

    602. 

  602. 

    603. 

  603.         #if FNET_CFG_DHCP_OVERLOAD

    604. 

  604.             case FNET_DHCP_OPTION_OVERLOAD:

    605. 

  605.               if(option_length == FNET_DHCP_OPTION_OVERLOAD_LENGTH

    606. 

  606.                      && *option_data <= FNET_DHCP_OPTION_OVERLOAD_BOTH)

    607. 

  607.                   options->private_options.overload = *option_data;

    608. 

  608. 

    609. 

  609.               break;

    610. 

  610.         #endif

    611. 

  611.             case FNET_DHCP_OPTION_T1:

    612. 

  612.               if(option_length == FNET_DHCP_OPTION_T1_LENGTH)

    613. 

  613.                   options->public_options.t1 = *(unsigned long *)option_data;

    614. 

  614. 

    615. 

  615.               break;

    616. 

  616. 

    617. 

  617.             case FNET_DHCP_OPTION_T2:

    618. 

  618.               if(option_length == FNET_DHCP_OPTION_T2_LENGTH)

    619. 

  619.                   options->public_options.t2 = *(unsigned long *)option_data;

    620. 

  620. 

    621. 

  621.               break;

    622. 

  622.               

    623. 

  623.         #endif /* !FNET_CFG_DHCP_BOOTP */

    624. 

  624. 

    625. 

  625.         /* Todo Other Options. */

    626. 

  626.         }

    627. 

  627.     }

    628. 

  628. }

    629. 

  629. 

    630. 

  630. 

    631. 

  631. /************************************************************************

    632. 

  632. * NAME: fnet_dhcp_send_message

    633. 

  633. *

    634. 

  634. * DESCRIPTION: Send DHCP message.

    635. 

  635. ************************************************************************/

    636. 

  636. static int fnet_dhcp_send_message( fnet_dhcp_if_t *dhcp )

    637. 

  637. {

    638. 

  638.     fnet_dhcp_message_t *message = &dhcp->message;

    639. 

  639.     struct sockaddr     addr_send;

    640. 

  640.     unsigned int        length;

    641. 

  641.     struct in_addr      ip_address;

    642. 

  642. #if !FNET_CFG_DHCP_BOOTP    

    643. 

  643.     unsigned short      max_message_size;

    644. 

  644.     unsigned char       client_id[FNET_DHCP_OPTION_CLIENT_ID_LENGTH];    

    645. 

  645.     unsigned char       message_type;    

    646. 

  646. #endif     

    647. 

  647.     

    648. 

  648.     fnet_memset_zero(&message->header, sizeof(message->header));

    649. 

  649.     message->header.op = FNET_DHCP_OP_BOOTREQUEST;

    650. 

  650.     message->header.htype = 1U; /* Ethernet */

    651. 

  651.     message->header.hlen = sizeof(dhcp->macaddr);

    652. 

  652.     message->header.xid = fnet_htonl(dhcp->xid); /* TBD PFI */

    653. 

  653.     message->header.flags = FNET_HTONS(FNET_DHCP_FLAGS_BROADCAST);

    654. 

  654. 

    655. 

  655.     fnet_memcpy(message->header.chaddr, dhcp->macaddr, sizeof(dhcp->macaddr)); /* Client HW address */

    656. 

  656. 

    657. 

  657.     /* Add "magic cookie" */

    658. 

  658.     fnet_memcpy(message->header.magic_cookie, fnet_dhcp_magic_cookie, sizeof(fnet_dhcp_magic_cookie));

    659. 

  659.     message->next_option_position = message->header.options;

    660. 

  660.     

    661. 

  661.     /* Add options */

    662. 

  662.     switch(dhcp->state)

    663. 

  663.     {

    664. 

  664. 

    665. 

  665.     #if FNET_CFG_DHCP_BOOTP

    666. 

  666.         case FNET_DHCP_STATE_SELECTING: /*=>Requesting*/

    667. 

  667.             ip_address.s_addr = INADDR_BROADCAST;

    668. 

  668.             break;

    669. 

  669.     #else /* DHCP */

    670. 

  670.         case FNET_DHCP_STATE_REQUESTING: /*=>Requesting*/

    671. 

  671.             ip_address.s_addr = INADDR_BROADCAST;

    672. 

  672.             fnet_dhcp_add_option(message, FNET_DHCP_OPTION_REQ_ADDRESS,

    673. 

  673.                                FNET_DHCP_OPTION_REQ_ADDRESS_LENGTH, &dhcp->offered_options.public_options.ip_address);

    674. 

  674.             fnet_dhcp_add_option(message, FNET_DHCP_OPTION_SERVER_ID,

    675. 

  675.                                FNET_DHCP_OPTION_SERVER_ID_LENGTH, &dhcp->offered_options.public_options.dhcp_server);

    676. 

  676.             message_type = FNET_DHCP_OPTION_TYPE_REQUEST;

    677. 

  677.             break;

    678. 

  678.        case FNET_DHCP_STATE_SELECTING:

    679. 

  679.             ip_address.s_addr = INADDR_BROADCAST;

    680. 

  680.             message_type = FNET_DHCP_OPTION_TYPE_DISCOVER;

    681. 

  681.             break;

    682. 

  682. 

    683. 

  683.         case FNET_DHCP_STATE_REBOOTING: /*=>Requesting*/

    684. 

  684.             ip_address.s_addr = INADDR_BROADCAST;

    685. 

  685.             fnet_dhcp_add_option(message, FNET_DHCP_OPTION_REQ_ADDRESS,

    686. 

  686.                                    FNET_DHCP_OPTION_REQ_ADDRESS_LENGTH, &dhcp->in_params.requested_ip_address);

    687. 

  687.             message_type = FNET_DHCP_OPTION_TYPE_REQUEST;

    688. 

  688.             break;

    689. 

  689. 

    690. 

  690.         case FNET_DHCP_STATE_RENEWING:

    691. 

  691.             ip_address = dhcp->current_options.public_options.dhcp_server; /* Send REQUEST to leasing server*/

    692. 

  692.             message->header.ciaddr = dhcp->current_options.public_options.ip_address.s_addr;

    693. 

  693.             message_type = FNET_DHCP_OPTION_TYPE_REQUEST;

    694. 

  694.             break;

    695. 

  695. 

    696. 

  696.         case FNET_DHCP_STATE_REBINDING:

    697. 

  697.             ip_address.s_addr = INADDR_BROADCAST;

    698. 

  698.             message_type = FNET_DHCP_OPTION_TYPE_REQUEST;

    699. 

  699.             message->header.ciaddr = dhcp->current_options.public_options.ip_address.s_addr;

    700. 

  700.             break;

    701. 

  701. 

    702. 

  702.         case FNET_DHCP_STATE_RELEASE:

    703. 

  703.             ip_address = dhcp->current_options.public_options.dhcp_server;

    704. 

  704.             message->header.ciaddr = dhcp->current_options.public_options.ip_address.s_addr;

    705. 

  705.             message_type = FNET_DHCP_OPTION_TYPE_RELEASE;

    706. 

  706.             break;

    707. 

  707.           

    708. 

  708.     #endif /* !FNET_CFG_DHCP_BOOTP */

    709. 

  709.               

    710. 

  710.         default:  

    711. 

  711.           return FNET_ERR;

    712. 

  712.     };

    713. 

  713.     

    714. 

  714. #if FNET_CFG_DHCP_BOOTP

    715. 

  715.     

    716. 

  716.     /* Record time when client sent the DHCPREQUEST */

    717. 

  717.     dhcp->send_request_time = fnet_timer_ticks();

    718. 

  718. 

    719. 

  719. #else /* DHCP */

    720. 

  720.     

    721. 

  721.     fnet_dhcp_add_option(message, FNET_DHCP_OPTION_TYPE, FNET_DHCP_OPTION_TYPE_LENGTH, &message_type);

    722. 

  722. 

    723. 

  723.     if((message_type == FNET_DHCP_OPTION_TYPE_REQUEST) || (message_type == FNET_DHCP_OPTION_TYPE_DISCOVER))

    724. 

  724.     {

    725. 

  725.         /* Record time when client sent the DHCPREQUEST */

    726. 

  726.         dhcp->send_request_time = fnet_timer_ticks();

    727. 

  727. 

    728. 

  728.         /* Request a lease time for the IP address */

    729. 

  729.         if(dhcp->in_params.requested_lease_time)

    730. 

  730.             fnet_dhcp_add_option(message,                       FNET_DHCP_OPTION_LEASE,

    731. 

  731.                                  FNET_DHCP_OPTION_LEASE_LENGTH, &dhcp->in_params.requested_lease_time);

    732. 

  732.         /* Add Parameter Request list */

    733. 

  733.         fnet_dhcp_add_option(message,

    734. 

  734.                              FNET_DHCP_OPTION_PARAMETER_REQ_LIST,

    735. 

  735.                              sizeof(fnet_dhcp_parameter_request_list),

    736. 

  736.                              (void *) &fnet_dhcp_parameter_request_list);

    737. 

  737.     }

    738. 

  738. 

    739. 

  739.     /* Add Maximum DHCP message size option. */

    740. 

  740.     max_message_size = fnet_htons(sizeof(fnet_dhcp_header_t));

    741. 

  741.     fnet_dhcp_add_option(message,                              FNET_DHCP_OPTION_MESSAGE_SIZE,

    742. 

  742.                          FNET_DHCP_OPTION_MESSAGE_SIZE_LENGTH, &max_message_size);

    743. 

  743. 

    744. 

  744.     /* Client ID (MAC) option */

    745. 

  745.     client_id[0] = message->header.htype;

    746. 

  746.     fnet_memcpy(&client_id[1], dhcp->macaddr, sizeof(dhcp->macaddr));

    747. 

  747.     fnet_dhcp_add_option(&dhcp->message,                    FNET_DHCP_OPTION_CLIENT_ID,

    748. 

  748.                          FNET_DHCP_OPTION_CLIENT_ID_LENGTH, &client_id);

    749. 

  749. 

    750. 

  750. #endif /* FNET_CFG_DHCP_BOOTP */

    751. 

  751. 

    752. 

  752.     /* End Option */

    753. 

  753.     *message->next_option_position++ = FNET_DHCP_OPTION_END;

    754. 

  754. 

    755. 

  755. 

    756. 

  756.     /* Send message. */

    757. 

  757.     fnet_memset_zero(&addr_send, sizeof(addr_send));

    758. 

  758.     ((struct sockaddr_in *)(&addr_send))->sin_family = AF_INET;

    759. 

  759.     ((struct sockaddr_in *)(&addr_send))->sin_port = FNET_CFG_DHCP_PORT_SERVER;

    760. 

  760.     ((struct sockaddr_in *)(&addr_send))->sin_addr = ip_address;

    761. 

  761. 

    762. 

  762.     length = message->next_option_position - (unsigned char *) &message->header;

    763. 

  763.     return sendto(dhcp->socket_client, (char *) &message->header, length, 0, (struct sockaddr *) &addr_send, sizeof(addr_send));

    764. 

  764. }

    765. 

  765. 

    766. 

  766. /************************************************************************

    767. 

  767. * NAME: dhcp_receive_message

    768. 

  768. *

    769. 

  769. * DESCRIPTION: Receive DHCP message (non blocking).

    770. 

  770. ************************************************************************/

    771. 

  771. static int fnet_dhcp_receive_message( fnet_dhcp_if_t *dhcp, struct fnet_dhcp_options_in *options )

    772. 

  772. {

    773. 

  773.     int                     size;

    774. 

  774.     struct sockaddr         addr_from;

    775. 

  775.     fnet_dhcp_header_t      *dhcp_header = &dhcp->message.header;

    776. 

  776.     unsigned int            addr_len = sizeof(addr_from);

    777. 

  777. 

    778. 

  778.     size = recvfrom(dhcp->socket_client, (char *) dhcp_header, sizeof(fnet_dhcp_header_t),

    779. 

  779.                     0U,                   (struct sockaddr *) &addr_from, &addr_len);

    780. 

  780.  

    781. 

  781.     if(fnet_timer_get_interval(dhcp->send_request_time, fnet_timer_ticks()) < dhcp->state_send_timeout)

    782. 

  782.     {

    783. 

  783.         if((size < (int)(sizeof(fnet_dhcp_header_t) - FNET_DHCP_OPTIONS_LENGTH))

    784. 

  784.                || (dhcp_header->xid != fnet_htonl(dhcp->xid))  /* Is message for us? */

    785. 

  785.                || (dhcp_header->hlen != sizeof(dhcp->macaddr))

    786. 

  786.                || fnet_memcmp(dhcp_header->chaddr, dhcp->macaddr, sizeof(dhcp->macaddr))

    787. 

  787.                || fnet_memcmp(&dhcp_header->magic_cookie[0], fnet_dhcp_magic_cookie,

    788. 

  788.                                   sizeof(fnet_dhcp_magic_cookie)))

    789. 

  789.         {

    790. 

  790.             size = 0;

    791. 

  791.         }

    792. 

  792.         else

    793. 

  793.         {

    794. 

  794.             fnet_memset_zero(options, sizeof(*options));                        /* Clear old options.*/

    795. 

  795.             options->public_options.ip_address.s_addr = dhcp_header->yiaddr;    /* our IP address */

    796. 

  796. 

    797. 

  797.             /* Parse options field */

    798. 

  798.             dhcp->message.next_option_position = &dhcp_header->options[0];

    799. 

  799.             dhcp->message.end_position = (unsigned char *) dhcp_header + size - 1;

    800. 

  800. 

    801. 

  801.             fnet_dhcp_parse_options(&dhcp->message, options);

    802. 

  802. 

    803. 

  803.         #if FNET_CFG_DHCP_OVERLOAD && !FNET_CFG_DHCP_BOOTP

    804. 

  804.             /* Parse overload options in sname/file */

    805. 

  805. 

    806. 

  806.             if(options->public_options.overload)

    807. 

  807.             {

    808. 

  808.                 if(options->public_options.overload & FNET_DHCP_OPTION_OVERLOAD_SNAME)

    809. 

  809.                     dhcp->message->next_option_position = &dhcp_header->sname[0];

    810. 

  810.                 else

    811. 

  811.                     dhcp->message->next_option_position = &dhcp_header->file[0];

    812. 

  812. 

    813. 

  813.                 if(options->public_options.overload & FNET_DHCP_OPTION_OVERLOAD_FILE)

    814. 

  814.                     dhcp->message->end_position = &dhcp_header->file[128];

    815. 

  815.                 else

    816. 

  816.                     dhcp->message->end_position = &dhcp_header->sname[64];

    817. 

  817. 

    818. 

  818.                 fnet_dhcp_parse_options(dhcp->message, options);

    819. 

  819.             }

    820. 

  820.         #endif

    821. 

  821. 

    822. 

  822.         }

    823. 

  823. 

    824. 

  824.     }

    825. 

  825.     else

    826. 

  826.     {

    827. 

  827.         size = FNET_DHCP_ISTIMEOUT;

    828. 

  828.     }

    829. 

  829. 

    830. 

  830.     return size;

    831. 

  831. }

    832. 

  832. 

    833. 

  833. /************************************************************************

    834. 

  834. * NAME: fnet_dhcp_change_state

    835. 

  835. *

    836. 

  836. * DESCRIPTION: Change state of DHCP client.

    837. 

  837. ************************************************************************/

    838. 

  838. static void fnet_dhcp_change_state( fnet_dhcp_if_t *dhcp, fnet_dhcp_state_t state )

    839. 

  839. {

    840. 

  840.     dhcp->state = state;

    841. 

  841. 

    842. 

  842.     fnet_dhcp_print_state(dhcp);

    843. 

  843. 

    844. 

  844.     switch(state)

    845. 

  845.     {

    846. 

  846.     #if !FNET_CFG_DHCP_BOOTP

    847. 

  847.         case FNET_DHCP_STATE_INIT_REBOOT:

    848. 

  848.     #endif    

    849. 

  849.         case FNET_DHCP_STATE_INIT:

    850. 

  850.             fnet_netif_set_ip4_addr(dhcp->netif, 0U);   /* Set zero address. DHCP messages broadcast 

    851. 

  851.                                                         * by a client prior to that client obtaining 

    852. 

  852.                                                         * its IP address must have the source address 

    853. 

  853.                                                         * field in IP header set to 0.*/

    854. 

  854.             dhcp->xid++; /* Todo must be random.*/

    855. 

  855.             break;

    856. 

  856.         case FNET_DHCP_STATE_SELECTING:

    857. 

  857.             fnet_dhcp_send_message(dhcp);                          /* Send DISCOVER */

    858. 

  858.             dhcp->state_send_timeout = FNET_DHCP_STATE_SELECTING_SEND_TIMEOUT

    859. 

  859.                                          / FNET_TIMER_PERIOD_MS; /* Wait OFFER */

    860. 

  860.             break;          

    861. 

  861.         case FNET_DHCP_STATE_BOUND:

    862. 

  862.    

    863. 

  863.     #if !FNET_CFG_DHCP_BOOTP

    864. 

  864.             dhcp->state_timeout_next_state = FNET_DHCP_STATE_RENEWING;

    865. 

  865.             dhcp->lease_obtained_time = dhcp->send_request_time;

    866. 

  866. 

    867. 

  867.             if(dhcp->current_options.public_options.t1 == FNET_HTONL(FNET_DHCP_LEASE_INFINITY))

    868. 

  868.                 dhcp->state_timeout = FNET_DHCP_LEASE_INFINITY;

    869. 

  869.             else

    870. 

  870.                 dhcp->state_timeout = (fnet_ntohl(dhcp->current_options.public_options.t1) * 1000U) / FNET_TIMER_PERIOD_MS;

    871. 

  871.     #endif /* !FNET_CFG_DHCP_BOOTP */

    872. 

  872.           break;

    873. 

  873. 

    874. 

  874.     #if !FNET_CFG_DHCP_BOOTP

    875. 

  875.         case FNET_DHCP_STATE_REQUESTING:

    876. 

  876.           fnet_dhcp_send_message(dhcp); /* Send REQUEST.*/

    877. 

  877.           dhcp->state_timeout_next_state = FNET_DHCP_STATE_INIT;

    878. 

  878.           dhcp->lease_obtained_time = dhcp->send_request_time;

    879. 

  879.           dhcp->state_send_timeout = FNET_DHCP_STATE_REQUESTING_SEND_TIMEOUT

    880. 

  880.                                          / FNET_TIMER_PERIOD_MS; /* Wait ACK */

    881. 

  881.           dhcp->state_timeout = FNET_DHCP_STATE_REQUESTING_TIMEOUT / FNET_TIMER_PERIOD_MS;

    882. 

  882.           break;

    883. 

  883. 

    884. 

  884.         case FNET_DHCP_STATE_REBOOTING:

    885. 

  885.           fnet_dhcp_send_message(dhcp);               /* Send REQUEST.*/

    886. 

  886.           dhcp->state_timeout_next_state = FNET_DHCP_STATE_INIT;

    887. 

  887.           dhcp->lease_obtained_time = dhcp->send_request_time; /* To follow state machine rules.*/

    888. 

  888.           dhcp->state_timeout = FNET_DHCP_STATE_REBOOTING_TIMEOUT / FNET_TIMER_PERIOD_MS;

    889. 

  889.           dhcp->state_send_timeout = FNET_DHCP_STATE_REBOOTING_SEND_TIMEOUT / FNET_TIMER_PERIOD_MS;

    890. 

  890.           break;

    891. 

  891. 

    892. 

  892.         case FNET_DHCP_STATE_RENEWING:

    893. 

  893.           fnet_dhcp_send_message(dhcp); /* Send REQUEST.*/

    894. 

  894.           dhcp->state_timeout_next_state = FNET_DHCP_STATE_REBINDING;

    895. 

  895.           dhcp->state_timeout = (fnet_ntohl(dhcp->current_options.public_options.t2) * 1000U)

    896. 

  896.                                                                 / FNET_TIMER_PERIOD_MS;

    897. 

  897.      

    898. 

  898.           dhcp->state_send_timeout = FNET_DHCP_STATE_RENEWING_SEND_TIMEOUT / FNET_TIMER_PERIOD_MS;

    899. 

  899.           break;

    900. 

  900. 

    901. 

  901.         case FNET_DHCP_STATE_REBINDING:

    902. 

  902.           fnet_dhcp_send_message(dhcp); /* Send REQUEST.*/

    903. 

  903.           dhcp->state_timeout_next_state = FNET_DHCP_STATE_INIT;

    904. 

  904.           dhcp->state_timeout = (fnet_ntohl(dhcp->current_options.public_options.lease_time) * 1000U) / FNET_TIMER_PERIOD_MS;

    905. 

  905.           dhcp->state_send_timeout = FNET_DHCP_STATE_REBINDING_SEND_TIMEOUT / FNET_TIMER_PERIOD_MS;

    906. 

  906.           break;

    907. 

  907. 

    908. 

  908.         case FNET_DHCP_STATE_RELEASE:

    909. 

  909.           break;

    910. 

  910.         default:

    911. 

  911.           break;  /* do nothing, avoid compiler warning "enumeration value not handled in switch" */          

    912. 

  912.     #endif /* !FNET_CFG_DHCP_BOOTP */

    913. 

  913.     };

    914. 

  914. }

    915. 

  915. 

    916. 

  916. /************************************************************************

    917. 

  917. * NAME: fnet_dhcp_apply_params

    918. 

  918. *

    919. 

  919. * DESCRIPTION: Apply DHCP parameters to the interface.

    920. 

  920. ************************************************************************/

    921. 

  921. static void fnet_dhcp_apply_params(fnet_dhcp_if_t *dhcp)

    922. 

  922. {

    923. 

  923.     /* Apply parameters. */

    924. 

  924.     fnet_netif_set_ip4_addr(dhcp->netif, dhcp->current_options.public_options.ip_address.s_addr);

    925. 

  925.     fnet_netif_set_ip4_subnet_mask(dhcp->netif, dhcp->current_options.public_options.netmask.s_addr);

    926. 

  926.     fnet_netif_set_ip4_gateway(dhcp->netif, dhcp->current_options.public_options.gateway.s_addr);

    927. 

  927. #if FNET_CFG_DNS                      

    928. 

  928.     fnet_netif_set_ip4_dns(dhcp->netif, dhcp->current_options.public_options.dns.s_addr);                      

    929. 

  929. #endif                      

    930. 

  930.     fnet_netif_set_ip4_addr_automatic(dhcp->netif);

    931. 

  931. 

    932. 

  932.     fnet_dhcp_change_state(dhcp, FNET_DHCP_STATE_BOUND); /* => BOUND */

    933. 

  933.     /* Rise event. */

    934. 

  934.     if(dhcp->handler_updated)

    935. 

  935.         dhcp->handler_updated(dhcp->netif, dhcp->handler_updated_param);

    936. 

  936. }          

    937. 

  937. 

    938. 

  938. /************************************************************************

    939. 

  939. * NAME: fnet_dhcp_state_machine

    940. 

  940. *

    941. 

  941. * DESCRIPTION: DHCP client state machine.

    942. 

  942. ************************************************************************/

    943. 

  943. /*

    944. 

  944. State-transition diagram for DHCP clients [RFC 2131]:

    945. 

  945. 

    946. 

  946.  --------                               -------

    947. 

  947. |        | +-------------------------->|       |<-------------------+

    948. 

  948. | INIT-  | |     +-------------------->| INIT  |                    |

    949. 

  949. | REBOOT |DHCPNAK/         +---------->|       |<---+               |

    950. 

  950. |        |Restart|         |            -------     |               |

    951. 

  951.  --------  |  DHCPNAK/     |               |                        |

    952. 

  952.     |      Discard offer   |      -/Send DHCPDISCOVER               |

    953. 

  953. -/Send DHCPREQUEST         |               |                        |

    954. 

  954.     |      |     |      DHCPACK            v        |               |

    955. 

  955.  -----------     |   (not accept.)/   -----------   |               |

    956. 

  956. |           |    |  Send DHCPDECLINE |           |                  |

    957. 

  957. | REBOOTING |    |         |         | SELECTING |<----+            |

    958. 

  958. |           |    |        /          |           |     |DHCPOFFER/  |

    959. 

  959.  -----------     |       /            -----------   |  |Collect     |

    960. 

  960.     |            |      /                  |   |       |  replies   |

    961. 

  961. DHCPACK/         |     /  +----------------+   +-------+            |

    962. 

  962. Record lease, set|    |   v   Select offer/                         |

    963. 

  963. timers T1, T2   ------------  send DHCPREQUEST      |               |

    964. 

  964.     |   +----->|            |             DHCPNAK, Lease expired/   |

    965. 

  965.     |   |      | REQUESTING |                  Halt network         |

    966. 

  966.     DHCPOFFER/ |            |                       |               |

    967. 

  967.     Discard     ------------                        |               |

    968. 

  968.     |   |        |        |                   -----------           |

    969. 

  969.     |   +--------+     DHCPACK/              |           |          |

    970. 

  970.     |              Record lease, set    -----| REBINDING |          |

    971. 

  971.     |                timers T1, T2     /     |           |          |

    972. 

  972.     |                     |        DHCPACK/   -----------           |

    973. 

  973.     |                     v     Record lease, set   ^               |

    974. 

  974.     +----------------> -------      /timers T1,T2   |               |

    975. 

  975.                +----->|       |<---+                |               |

    976. 

  976.                |      | BOUND |<---+                |               |

    977. 

  977.   DHCPOFFER, DHCPACK, |       |    |            T2 expires/   DHCPNAK/

    978. 

  978.    DHCPNAK/Discard     -------     |             Broadcast  Halt network

    979. 

  979.                |       | |         |            DHCPREQUEST         |

    980. 

  980.                +-------+ |        DHCPACK/          |               |

    981. 

  981.                     T1 expires/   Record lease, set |               |

    982. 

  982.                  Send DHCPREQUEST timers T1, T2     |               |

    983. 

  983.                  to leasing server |                |               |

    984. 

  984.                          |   ----------             |               |

    985. 

  985.                          |  |          |------------+               |

    986. 

  986.                          +->| RENEWING |                            |

    987. 

  987.                             |          |----------------------------+

    988. 

  988.                              ----------

    989. 

  989. */

    990. 

  990. 

    991. 

  991. /*  BOOTP:

    992. 

  992. 

    993. 

  993. 

    994. 

  994.                                              BOOTREPLY/

    995. 

  995.   -------   -/Send         ---------------   Configure client   -------

    996. 

  996.  |       |  BOOTPREQUEST  |               |  and StopTask      |       |

    997. 

  997.  | INIT  |--------------->| BOOTP_REQUEST |------------------->| BOUND |

    998. 

  998.  |       |                | (SELECTING)   |                    |       |

    999. 

  999.   -------                  ---------------                      -------

    1000. 

  1000.      ^                           |

    1001. 

  1001.      |         Timeout/-         |

    1002. 

  1002.      +---------------------------+

    1003. 

  1003. 

    1004. 

  1004. 

    1005. 

  1005. */

    1006. 

  1006. 

    1007. 

  1007. static void fnet_dhcp_state_machine( void *fnet_dhcp_if_p )

    1008. 

  1008. {

    1009. 

  1009.     fnet_dhcp_if_t                  *dhcp = (fnet_dhcp_if_t *)fnet_dhcp_if_p;

    1010. 

  1010.     struct fnet_dhcp_options_in     options;

    1011. 

  1011.     int                             res;

    1012. 

  1012. 

    1013. 

  1013.     switch(dhcp->state)

    1014. 

  1014.     {

    1015. 

  1015.         /*---- INIT ----------------------------------------------------*/

    1016. 

  1016.         case FNET_DHCP_STATE_INIT:

    1017. 

  1017.             /* Todo: The client SHOULD wait a random time between one and ten seconds to

    1018. 

  1018.             * desynchronize the use of DHCP at startup. */

    1019. 

  1019.             fnet_dhcp_change_state(dhcp, FNET_DHCP_STATE_SELECTING); /* => SELECTING */

    1020. 

  1020.             if(dhcp->handler_discover)

    1021. 

  1021.                 dhcp->handler_discover(dhcp->netif, dhcp->handler_discover_param); 

    1022. 

  1022.           

    1023. 

  1023.             break;

    1024. 

  1024.         /*---- SELECTING --------------------------------------------*/

    1025. 

  1025.         case FNET_DHCP_STATE_SELECTING:

    1026. 

  1026.             /* Waiting for OFFER */

    1027. 

  1027.             res = fnet_dhcp_receive_message(dhcp, &options);

    1028. 

  1028. 

    1029. 

  1029.             if(res == FNET_DHCP_ISTIMEOUT)

    1030. 

  1030.             {

    1031. 

  1031.                 fnet_dhcp_change_state(dhcp, FNET_DHCP_STATE_INIT); /* => INIT */

    1032. 

  1032.             }

    1033. 

  1033.             

    1034. 

  1034.         #if FNET_CFG_DHCP_BOOTP            

    1035. 

  1035.             else if(res>0)

    1036. 

  1036.             {

    1037. 

  1037.                 /* Todo: The client SHOULD perform a check on the suggested address 

    1038. 

  1038.                 * to ensure that the address is not already in use.*/

    1039. 

  1039.                 fnet_dhcp_print_options(&options);

    1040. 

  1040.                 /* Apply parameters. */

    1041. 

  1041.                 dhcp->current_options = options;

    1042. 

  1042. 

    1043. 

  1043.                 fnet_dhcp_apply_params(dhcp); 

    1044. 

  1044.             }

    1045. 

  1045.         #else /* DHCP */

    1046. 

  1046.             else if(res > 0 && options.private_options.message_type == FNET_DHCP_OPTION_TYPE_OFFER)

    1047. 

  1047.             {

    1048. 

  1048.                 dhcp->offered_options = options;                          /* Save offered options */

    1049. 

  1049.                 fnet_dhcp_change_state(dhcp, FNET_DHCP_STATE_REQUESTING); /* => REQUESTING */

    1050. 

  1050.             }

    1051. 

  1051.         #endif          

    1052. 

  1052.             break;

    1053. 

  1053.         /*---- BOUND ------------------------------------------------*/

    1054. 

  1054.         case FNET_DHCP_STATE_BOUND:

    1055. 

  1055.         #if FNET_CFG_DHCP_BOOTP 

    1056. 

  1056.             fnet_dhcp_release(); 

    1057. 

  1057.         #else /* DHCP */

    1058. 

  1058.             if(fnet_netif_get_ip4_addr_automatic(dhcp->netif)) /* If user changed parameters manually.*/

    1059. 

  1059.             {

    1060. 

  1060.                 struct sockaddr     addr_from;

    1061. 

  1061.                 unsigned int        addr_len = sizeof(addr_from);

    1062. 

  1062. 

    1063. 

  1063.                 /* Discard all input data. */

    1064. 

  1064.                 recvfrom(dhcp->socket_client, (char *) &dhcp->message.header, sizeof(fnet_dhcp_header_t),

    1065. 

  1065.                        0U,                   (struct sockaddr *) &addr_from, &addr_len);

    1066. 

  1066. 

    1067. 

  1067.             

    1068. 

  1068.                 /* If T1 expired. */

    1069. 

  1069.                 if(fnet_timer_get_interval(dhcp->lease_obtained_time, fnet_timer_ticks()) > dhcp->state_timeout)

    1070. 

  1070.                 {

    1071. 

  1071.                     fnet_dhcp_change_state(dhcp, dhcp->state_timeout_next_state); /* => INIT *…
    1072.

Large files files are truncated, but you can click here to view the full file