My fork of the HTTPServer (working)
Core/lwIP/core/dhcp.c@1:284f2df30cf9, 2012-11-20 (annotated)
- Committer:
- screamer
- Date:
- Tue Nov 20 12:18:53 2012 +0000
- Revision:
- 1:284f2df30cf9
- Parent:
- 0:7a64fbb4069d
local changes
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
screamer | 0:7a64fbb4069d | 1 | /** |
screamer | 0:7a64fbb4069d | 2 | * @file |
screamer | 0:7a64fbb4069d | 3 | * Dynamic Host Configuration Protocol client |
screamer | 0:7a64fbb4069d | 4 | * |
screamer | 0:7a64fbb4069d | 5 | */ |
screamer | 0:7a64fbb4069d | 6 | |
screamer | 0:7a64fbb4069d | 7 | /* |
screamer | 0:7a64fbb4069d | 8 | * |
screamer | 0:7a64fbb4069d | 9 | * Copyright (c) 2001-2004 Leon Woestenberg <leon.woestenberg@gmx.net> |
screamer | 0:7a64fbb4069d | 10 | * Copyright (c) 2001-2004 Axon Digital Design B.V., The Netherlands. |
screamer | 0:7a64fbb4069d | 11 | * All rights reserved. |
screamer | 0:7a64fbb4069d | 12 | * |
screamer | 0:7a64fbb4069d | 13 | * Redistribution and use in source and binary forms, with or without modification, |
screamer | 0:7a64fbb4069d | 14 | * are permitted provided that the following conditions are met: |
screamer | 0:7a64fbb4069d | 15 | * |
screamer | 0:7a64fbb4069d | 16 | * 1. Redistributions of source code must retain the above copyright notice, |
screamer | 0:7a64fbb4069d | 17 | * this list of conditions and the following disclaimer. |
screamer | 0:7a64fbb4069d | 18 | * 2. Redistributions in binary form must reproduce the above copyright notice, |
screamer | 0:7a64fbb4069d | 19 | * this list of conditions and the following disclaimer in the documentation |
screamer | 0:7a64fbb4069d | 20 | * and/or other materials provided with the distribution. |
screamer | 0:7a64fbb4069d | 21 | * 3. The name of the author may not be used to endorse or promote products |
screamer | 0:7a64fbb4069d | 22 | * derived from this software without specific prior written permission. |
screamer | 0:7a64fbb4069d | 23 | * |
screamer | 0:7a64fbb4069d | 24 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED |
screamer | 0:7a64fbb4069d | 25 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
screamer | 0:7a64fbb4069d | 26 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT |
screamer | 0:7a64fbb4069d | 27 | * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
screamer | 0:7a64fbb4069d | 28 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT |
screamer | 0:7a64fbb4069d | 29 | * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
screamer | 0:7a64fbb4069d | 30 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
screamer | 0:7a64fbb4069d | 31 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING |
screamer | 0:7a64fbb4069d | 32 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY |
screamer | 0:7a64fbb4069d | 33 | * OF SUCH DAMAGE. |
screamer | 0:7a64fbb4069d | 34 | * |
screamer | 0:7a64fbb4069d | 35 | * This file is a contribution to the lwIP TCP/IP stack. |
screamer | 0:7a64fbb4069d | 36 | * The Swedish Institute of Computer Science and Adam Dunkels |
screamer | 0:7a64fbb4069d | 37 | * are specifically granted permission to redistribute this |
screamer | 0:7a64fbb4069d | 38 | * source code. |
screamer | 0:7a64fbb4069d | 39 | * |
screamer | 0:7a64fbb4069d | 40 | * Author: Leon Woestenberg <leon.woestenberg@gmx.net> |
screamer | 0:7a64fbb4069d | 41 | * |
screamer | 0:7a64fbb4069d | 42 | * This is a DHCP client for the lwIP TCP/IP stack. It aims to conform |
screamer | 0:7a64fbb4069d | 43 | * with RFC 2131 and RFC 2132. |
screamer | 0:7a64fbb4069d | 44 | * |
screamer | 0:7a64fbb4069d | 45 | * TODO: |
screamer | 0:7a64fbb4069d | 46 | * - Proper parsing of DHCP messages exploiting file/sname field overloading. |
screamer | 0:7a64fbb4069d | 47 | * - Add JavaDoc style documentation (API, internals). |
screamer | 0:7a64fbb4069d | 48 | * - Support for interfaces other than Ethernet (SLIP, PPP, ...) |
screamer | 0:7a64fbb4069d | 49 | * |
screamer | 0:7a64fbb4069d | 50 | * Please coordinate changes and requests with Leon Woestenberg |
screamer | 0:7a64fbb4069d | 51 | * <leon.woestenberg@gmx.net> |
screamer | 0:7a64fbb4069d | 52 | * |
screamer | 0:7a64fbb4069d | 53 | * Integration with your code: |
screamer | 0:7a64fbb4069d | 54 | * |
screamer | 0:7a64fbb4069d | 55 | * In lwip/dhcp.h |
screamer | 0:7a64fbb4069d | 56 | * #define DHCP_COARSE_TIMER_SECS (recommended 60 which is a minute) |
screamer | 0:7a64fbb4069d | 57 | * #define DHCP_FINE_TIMER_MSECS (recommended 500 which equals TCP coarse timer) |
screamer | 0:7a64fbb4069d | 58 | * |
screamer | 0:7a64fbb4069d | 59 | * Then have your application call dhcp_coarse_tmr() and |
screamer | 0:7a64fbb4069d | 60 | * dhcp_fine_tmr() on the defined intervals. |
screamer | 0:7a64fbb4069d | 61 | * |
screamer | 0:7a64fbb4069d | 62 | * dhcp_start(struct netif *netif); |
screamer | 0:7a64fbb4069d | 63 | * starts a DHCP client instance which configures the interface by |
screamer | 0:7a64fbb4069d | 64 | * obtaining an IP address lease and maintaining it. |
screamer | 0:7a64fbb4069d | 65 | * |
screamer | 0:7a64fbb4069d | 66 | * Use dhcp_release(netif) to end the lease and use dhcp_stop(netif) |
screamer | 0:7a64fbb4069d | 67 | * to remove the DHCP client. |
screamer | 0:7a64fbb4069d | 68 | * |
screamer | 0:7a64fbb4069d | 69 | */ |
screamer | 0:7a64fbb4069d | 70 | |
screamer | 0:7a64fbb4069d | 71 | #include "lwip/opt.h" |
screamer | 0:7a64fbb4069d | 72 | |
screamer | 0:7a64fbb4069d | 73 | #if LWIP_DHCP /* don't build if not configured for use in lwipopts.h */ |
screamer | 0:7a64fbb4069d | 74 | |
screamer | 0:7a64fbb4069d | 75 | #include "lwip/stats.h" |
screamer | 0:7a64fbb4069d | 76 | #include "lwip/mem.h" |
screamer | 0:7a64fbb4069d | 77 | #include "lwip/udp.h" |
screamer | 0:7a64fbb4069d | 78 | #include "lwip/ip_addr.h" |
screamer | 0:7a64fbb4069d | 79 | #include "lwip/netif.h" |
screamer | 0:7a64fbb4069d | 80 | #include "lwip/inet.h" |
screamer | 0:7a64fbb4069d | 81 | #include "lwip/sys.h" |
screamer | 0:7a64fbb4069d | 82 | #include "lwip/dhcp.h" |
screamer | 0:7a64fbb4069d | 83 | #include "lwip/autoip.h" |
screamer | 0:7a64fbb4069d | 84 | #include "lwip/dns.h" |
screamer | 0:7a64fbb4069d | 85 | #include "netif/etharp.h" |
screamer | 0:7a64fbb4069d | 86 | |
screamer | 0:7a64fbb4069d | 87 | #include <string.h> |
screamer | 0:7a64fbb4069d | 88 | |
screamer | 0:7a64fbb4069d | 89 | /** Default for DHCP_GLOBAL_XID is 0xABCD0000 |
screamer | 0:7a64fbb4069d | 90 | * This can be changed by defining DHCP_GLOBAL_XID and DHCP_GLOBAL_XID_HEADER, e.g. |
screamer | 0:7a64fbb4069d | 91 | * #define DHCP_GLOBAL_XID_HEADER "stdlib.h" |
screamer | 0:7a64fbb4069d | 92 | * #define DHCP_GLOBAL_XID rand() |
screamer | 0:7a64fbb4069d | 93 | */ |
screamer | 0:7a64fbb4069d | 94 | #ifdef DHCP_GLOBAL_XID_HEADER |
screamer | 0:7a64fbb4069d | 95 | #include DHCP_GLOBAL_XID_HEADER /* include optional starting XID generation prototypes */ |
screamer | 0:7a64fbb4069d | 96 | #endif |
screamer | 0:7a64fbb4069d | 97 | |
screamer | 0:7a64fbb4069d | 98 | /** DHCP_OPTION_MAX_MSG_SIZE is set to the MTU |
screamer | 0:7a64fbb4069d | 99 | * MTU is checked to be big enough in dhcp_start */ |
screamer | 0:7a64fbb4069d | 100 | #define DHCP_MAX_MSG_LEN(netif) (netif->mtu) |
screamer | 0:7a64fbb4069d | 101 | #define DHCP_MAX_MSG_LEN_MIN_REQUIRED 576 |
screamer | 0:7a64fbb4069d | 102 | |
screamer | 0:7a64fbb4069d | 103 | /* DHCP client state machine functions */ |
screamer | 0:7a64fbb4069d | 104 | static void dhcp_handle_ack(struct netif *netif); |
screamer | 0:7a64fbb4069d | 105 | static void dhcp_handle_nak(struct netif *netif); |
screamer | 0:7a64fbb4069d | 106 | static void dhcp_handle_offer(struct netif *netif); |
screamer | 0:7a64fbb4069d | 107 | |
screamer | 0:7a64fbb4069d | 108 | static err_t dhcp_discover(struct netif *netif); |
screamer | 0:7a64fbb4069d | 109 | static err_t dhcp_select(struct netif *netif); |
screamer | 0:7a64fbb4069d | 110 | static void dhcp_check(struct netif *netif); |
screamer | 0:7a64fbb4069d | 111 | static void dhcp_bind(struct netif *netif); |
screamer | 0:7a64fbb4069d | 112 | #if DHCP_DOES_ARP_CHECK |
screamer | 0:7a64fbb4069d | 113 | static err_t dhcp_decline(struct netif *netif); |
screamer | 0:7a64fbb4069d | 114 | #endif /* DHCP_DOES_ARP_CHECK */ |
screamer | 0:7a64fbb4069d | 115 | static err_t dhcp_rebind(struct netif *netif); |
screamer | 0:7a64fbb4069d | 116 | static void dhcp_set_state(struct dhcp *dhcp, u8_t new_state); |
screamer | 0:7a64fbb4069d | 117 | |
screamer | 0:7a64fbb4069d | 118 | /* receive, unfold, parse and free incoming messages */ |
screamer | 0:7a64fbb4069d | 119 | static void dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct ip_addr *addr, u16_t port); |
screamer | 0:7a64fbb4069d | 120 | static err_t dhcp_unfold_reply(struct dhcp *dhcp); |
screamer | 0:7a64fbb4069d | 121 | static u8_t *dhcp_get_option_ptr(struct dhcp *dhcp, u8_t option_type); |
screamer | 0:7a64fbb4069d | 122 | static u8_t dhcp_get_option_byte(u8_t *ptr); |
screamer | 0:7a64fbb4069d | 123 | #if 0 |
screamer | 0:7a64fbb4069d | 124 | static u16_t dhcp_get_option_short(u8_t *ptr); |
screamer | 0:7a64fbb4069d | 125 | #endif |
screamer | 0:7a64fbb4069d | 126 | static u32_t dhcp_get_option_long(u8_t *ptr); |
screamer | 0:7a64fbb4069d | 127 | static void dhcp_free_reply(struct dhcp *dhcp); |
screamer | 0:7a64fbb4069d | 128 | |
screamer | 0:7a64fbb4069d | 129 | /* set the DHCP timers */ |
screamer | 0:7a64fbb4069d | 130 | static void dhcp_timeout(struct netif *netif); |
screamer | 0:7a64fbb4069d | 131 | static void dhcp_t1_timeout(struct netif *netif); |
screamer | 0:7a64fbb4069d | 132 | static void dhcp_t2_timeout(struct netif *netif); |
screamer | 0:7a64fbb4069d | 133 | |
screamer | 0:7a64fbb4069d | 134 | /* build outgoing messages */ |
screamer | 0:7a64fbb4069d | 135 | /* create a DHCP request, fill in common headers */ |
screamer | 0:7a64fbb4069d | 136 | static err_t dhcp_create_request(struct netif *netif); |
screamer | 0:7a64fbb4069d | 137 | /* free a DHCP request */ |
screamer | 0:7a64fbb4069d | 138 | static void dhcp_delete_request(struct netif *netif); |
screamer | 0:7a64fbb4069d | 139 | /* add a DHCP option (type, then length in bytes) */ |
screamer | 0:7a64fbb4069d | 140 | static void dhcp_option(struct dhcp *dhcp, u8_t option_type, u8_t option_len); |
screamer | 0:7a64fbb4069d | 141 | /* add option values */ |
screamer | 0:7a64fbb4069d | 142 | static void dhcp_option_byte(struct dhcp *dhcp, u8_t value); |
screamer | 0:7a64fbb4069d | 143 | static void dhcp_option_short(struct dhcp *dhcp, u16_t value); |
screamer | 0:7a64fbb4069d | 144 | static void dhcp_option_long(struct dhcp *dhcp, u32_t value); |
screamer | 0:7a64fbb4069d | 145 | /* always add the DHCP options trailer to end and pad */ |
screamer | 0:7a64fbb4069d | 146 | static void dhcp_option_trailer(struct dhcp *dhcp); |
screamer | 0:7a64fbb4069d | 147 | |
screamer | 0:7a64fbb4069d | 148 | /** |
screamer | 0:7a64fbb4069d | 149 | * Back-off the DHCP client (because of a received NAK response). |
screamer | 0:7a64fbb4069d | 150 | * |
screamer | 0:7a64fbb4069d | 151 | * Back-off the DHCP client because of a received NAK. Receiving a |
screamer | 0:7a64fbb4069d | 152 | * NAK means the client asked for something non-sensible, for |
screamer | 0:7a64fbb4069d | 153 | * example when it tries to renew a lease obtained on another network. |
screamer | 0:7a64fbb4069d | 154 | * |
screamer | 0:7a64fbb4069d | 155 | * We clear any existing set IP address and restart DHCP negotiation |
screamer | 0:7a64fbb4069d | 156 | * afresh (as per RFC2131 3.2.3). |
screamer | 0:7a64fbb4069d | 157 | * |
screamer | 0:7a64fbb4069d | 158 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 159 | */ |
screamer | 0:7a64fbb4069d | 160 | static void |
screamer | 0:7a64fbb4069d | 161 | dhcp_handle_nak(struct netif *netif) |
screamer | 0:7a64fbb4069d | 162 | { |
screamer | 0:7a64fbb4069d | 163 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 164 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_handle_nak(netif=%p) %c%c%"U16_F"\n", |
screamer | 0:7a64fbb4069d | 165 | (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); |
screamer | 0:7a64fbb4069d | 166 | /* Set the interface down since the address must no longer be used, as per RFC2131 */ |
screamer | 0:7a64fbb4069d | 167 | netif_set_down(netif); |
screamer | 0:7a64fbb4069d | 168 | /* remove IP address from interface */ |
screamer | 0:7a64fbb4069d | 169 | netif_set_ipaddr(netif, IP_ADDR_ANY); |
screamer | 0:7a64fbb4069d | 170 | netif_set_gw(netif, IP_ADDR_ANY); |
screamer | 0:7a64fbb4069d | 171 | netif_set_netmask(netif, IP_ADDR_ANY); |
screamer | 0:7a64fbb4069d | 172 | /* Change to a defined state */ |
screamer | 0:7a64fbb4069d | 173 | dhcp_set_state(dhcp, DHCP_BACKING_OFF); |
screamer | 0:7a64fbb4069d | 174 | /* We can immediately restart discovery */ |
screamer | 0:7a64fbb4069d | 175 | dhcp_discover(netif); |
screamer | 0:7a64fbb4069d | 176 | } |
screamer | 0:7a64fbb4069d | 177 | |
screamer | 0:7a64fbb4069d | 178 | /** |
screamer | 0:7a64fbb4069d | 179 | * Checks if the offered IP address is already in use. |
screamer | 0:7a64fbb4069d | 180 | * |
screamer | 0:7a64fbb4069d | 181 | * It does so by sending an ARP request for the offered address and |
screamer | 0:7a64fbb4069d | 182 | * entering CHECKING state. If no ARP reply is received within a small |
screamer | 0:7a64fbb4069d | 183 | * interval, the address is assumed to be free for use by us. |
screamer | 0:7a64fbb4069d | 184 | * |
screamer | 0:7a64fbb4069d | 185 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 186 | */ |
screamer | 0:7a64fbb4069d | 187 | static void |
screamer | 0:7a64fbb4069d | 188 | dhcp_check(struct netif *netif) |
screamer | 0:7a64fbb4069d | 189 | { |
screamer | 0:7a64fbb4069d | 190 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 191 | err_t result; |
screamer | 0:7a64fbb4069d | 192 | u16_t msecs; |
screamer | 0:7a64fbb4069d | 193 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_check(netif=%p) %c%c\n", (void *)netif, (s16_t)netif->name[0], |
screamer | 0:7a64fbb4069d | 194 | (s16_t)netif->name[1])); |
screamer | 0:7a64fbb4069d | 195 | /* create an ARP query for the offered IP address, expecting that no host |
screamer | 0:7a64fbb4069d | 196 | responds, as the IP address should not be in use. */ |
screamer | 0:7a64fbb4069d | 197 | result = etharp_query(netif, &dhcp->offered_ip_addr, NULL); |
screamer | 0:7a64fbb4069d | 198 | if (result != ERR_OK) { |
screamer | 0:7a64fbb4069d | 199 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_check: could not perform ARP query\n")); |
screamer | 0:7a64fbb4069d | 200 | } |
screamer | 0:7a64fbb4069d | 201 | dhcp->tries++; |
screamer | 0:7a64fbb4069d | 202 | msecs = 500; |
screamer | 0:7a64fbb4069d | 203 | dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS; |
screamer | 0:7a64fbb4069d | 204 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_check(): set request timeout %"U16_F" msecs\n", msecs)); |
screamer | 0:7a64fbb4069d | 205 | dhcp_set_state(dhcp, DHCP_CHECKING); |
screamer | 0:7a64fbb4069d | 206 | } |
screamer | 0:7a64fbb4069d | 207 | |
screamer | 0:7a64fbb4069d | 208 | /** |
screamer | 0:7a64fbb4069d | 209 | * Remember the configuration offered by a DHCP server. |
screamer | 0:7a64fbb4069d | 210 | * |
screamer | 0:7a64fbb4069d | 211 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 212 | */ |
screamer | 0:7a64fbb4069d | 213 | static void |
screamer | 0:7a64fbb4069d | 214 | dhcp_handle_offer(struct netif *netif) |
screamer | 0:7a64fbb4069d | 215 | { |
screamer | 0:7a64fbb4069d | 216 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 217 | /* obtain the server address */ |
screamer | 0:7a64fbb4069d | 218 | u8_t *option_ptr = dhcp_get_option_ptr(dhcp, DHCP_OPTION_SERVER_ID); |
screamer | 0:7a64fbb4069d | 219 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_handle_offer(netif=%p) %c%c%"U16_F"\n", |
screamer | 0:7a64fbb4069d | 220 | (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); |
screamer | 0:7a64fbb4069d | 221 | if (option_ptr != NULL) { |
screamer | 0:7a64fbb4069d | 222 | dhcp->server_ip_addr.addr = htonl(dhcp_get_option_long(&option_ptr[2])); |
screamer | 0:7a64fbb4069d | 223 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): server 0x%08"X32_F"\n", dhcp->server_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 224 | /* remember offered address */ |
screamer | 0:7a64fbb4069d | 225 | ip_addr_set(&dhcp->offered_ip_addr, (struct ip_addr *)&dhcp->msg_in->yiaddr); |
screamer | 0:7a64fbb4069d | 226 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): offer for 0x%08"X32_F"\n", dhcp->offered_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 227 | |
screamer | 0:7a64fbb4069d | 228 | dhcp_select(netif); |
screamer | 0:7a64fbb4069d | 229 | } |
screamer | 0:7a64fbb4069d | 230 | } |
screamer | 0:7a64fbb4069d | 231 | |
screamer | 0:7a64fbb4069d | 232 | /** |
screamer | 0:7a64fbb4069d | 233 | * Select a DHCP server offer out of all offers. |
screamer | 0:7a64fbb4069d | 234 | * |
screamer | 0:7a64fbb4069d | 235 | * Simply select the first offer received. |
screamer | 0:7a64fbb4069d | 236 | * |
screamer | 0:7a64fbb4069d | 237 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 238 | * @return lwIP specific error (see error.h) |
screamer | 0:7a64fbb4069d | 239 | */ |
screamer | 0:7a64fbb4069d | 240 | static err_t |
screamer | 0:7a64fbb4069d | 241 | dhcp_select(struct netif *netif) |
screamer | 0:7a64fbb4069d | 242 | { |
screamer | 0:7a64fbb4069d | 243 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 244 | err_t result; |
screamer | 0:7a64fbb4069d | 245 | u16_t msecs; |
screamer | 0:7a64fbb4069d | 246 | #if LWIP_NETIF_HOSTNAME |
screamer | 0:7a64fbb4069d | 247 | const char *p; |
screamer | 0:7a64fbb4069d | 248 | #endif /* LWIP_NETIF_HOSTNAME */ |
screamer | 0:7a64fbb4069d | 249 | |
screamer | 0:7a64fbb4069d | 250 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_select(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); |
screamer | 0:7a64fbb4069d | 251 | |
screamer | 0:7a64fbb4069d | 252 | /* create and initialize the DHCP message header */ |
screamer | 0:7a64fbb4069d | 253 | result = dhcp_create_request(netif); |
screamer | 0:7a64fbb4069d | 254 | if (result == ERR_OK) { |
screamer | 0:7a64fbb4069d | 255 | dhcp_option(dhcp, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN); |
screamer | 0:7a64fbb4069d | 256 | dhcp_option_byte(dhcp, DHCP_REQUEST); |
screamer | 0:7a64fbb4069d | 257 | |
screamer | 0:7a64fbb4069d | 258 | dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); |
screamer | 0:7a64fbb4069d | 259 | dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif)); |
screamer | 0:7a64fbb4069d | 260 | |
screamer | 0:7a64fbb4069d | 261 | /* MUST request the offered IP address */ |
screamer | 0:7a64fbb4069d | 262 | dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4); |
screamer | 0:7a64fbb4069d | 263 | dhcp_option_long(dhcp, ntohl(dhcp->offered_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 264 | |
screamer | 0:7a64fbb4069d | 265 | dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4); |
screamer | 0:7a64fbb4069d | 266 | dhcp_option_long(dhcp, ntohl(dhcp->server_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 267 | |
screamer | 0:7a64fbb4069d | 268 | dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, 4/*num options*/); |
screamer | 0:7a64fbb4069d | 269 | dhcp_option_byte(dhcp, DHCP_OPTION_SUBNET_MASK); |
screamer | 0:7a64fbb4069d | 270 | dhcp_option_byte(dhcp, DHCP_OPTION_ROUTER); |
screamer | 0:7a64fbb4069d | 271 | dhcp_option_byte(dhcp, DHCP_OPTION_BROADCAST); |
screamer | 0:7a64fbb4069d | 272 | dhcp_option_byte(dhcp, DHCP_OPTION_DNS_SERVER); |
screamer | 0:7a64fbb4069d | 273 | |
screamer | 0:7a64fbb4069d | 274 | #if LWIP_NETIF_HOSTNAME |
screamer | 0:7a64fbb4069d | 275 | p = (const char*)netif->hostname; |
screamer | 0:7a64fbb4069d | 276 | if (p != NULL) { |
screamer | 0:7a64fbb4069d | 277 | dhcp_option(dhcp, DHCP_OPTION_HOSTNAME, strlen(p)); |
screamer | 0:7a64fbb4069d | 278 | while (*p) { |
screamer | 0:7a64fbb4069d | 279 | dhcp_option_byte(dhcp, *p++); |
screamer | 0:7a64fbb4069d | 280 | } |
screamer | 0:7a64fbb4069d | 281 | } |
screamer | 0:7a64fbb4069d | 282 | #endif /* LWIP_NETIF_HOSTNAME */ |
screamer | 0:7a64fbb4069d | 283 | |
screamer | 0:7a64fbb4069d | 284 | dhcp_option_trailer(dhcp); |
screamer | 0:7a64fbb4069d | 285 | /* shrink the pbuf to the actual content length */ |
screamer | 0:7a64fbb4069d | 286 | pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len); |
screamer | 0:7a64fbb4069d | 287 | |
screamer | 0:7a64fbb4069d | 288 | /* TODO: we really should bind to a specific local interface here |
screamer | 0:7a64fbb4069d | 289 | but we cannot specify an unconfigured netif as it is addressless */ |
screamer | 0:7a64fbb4069d | 290 | /* send broadcast to any DHCP server */ |
screamer | 0:7a64fbb4069d | 291 | udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif); |
screamer | 0:7a64fbb4069d | 292 | /* reconnect to any (or to server here?!) */ |
screamer | 0:7a64fbb4069d | 293 | udp_connect(dhcp->pcb, IP_ADDR_ANY, DHCP_SERVER_PORT); |
screamer | 0:7a64fbb4069d | 294 | dhcp_delete_request(netif); |
screamer | 0:7a64fbb4069d | 295 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_select: REQUESTING\n")); |
screamer | 0:7a64fbb4069d | 296 | dhcp_set_state(dhcp, DHCP_REQUESTING); |
screamer | 0:7a64fbb4069d | 297 | } else { |
screamer | 0:7a64fbb4069d | 298 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_select: could not allocate DHCP request\n")); |
screamer | 0:7a64fbb4069d | 299 | } |
screamer | 0:7a64fbb4069d | 300 | dhcp->tries++; |
screamer | 0:7a64fbb4069d | 301 | msecs = dhcp->tries < 4 ? dhcp->tries * 1000 : 4 * 1000; |
screamer | 0:7a64fbb4069d | 302 | dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS; |
screamer | 0:7a64fbb4069d | 303 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_select(): set request timeout %"U16_F" msecs\n", msecs)); |
screamer | 0:7a64fbb4069d | 304 | return result; |
screamer | 0:7a64fbb4069d | 305 | } |
screamer | 0:7a64fbb4069d | 306 | |
screamer | 0:7a64fbb4069d | 307 | /** |
screamer | 0:7a64fbb4069d | 308 | * The DHCP timer that checks for lease renewal/rebind timeouts. |
screamer | 0:7a64fbb4069d | 309 | * |
screamer | 0:7a64fbb4069d | 310 | */ |
screamer | 0:7a64fbb4069d | 311 | void |
screamer | 0:7a64fbb4069d | 312 | dhcp_coarse_tmr() |
screamer | 0:7a64fbb4069d | 313 | { |
screamer | 0:7a64fbb4069d | 314 | struct netif *netif = netif_list; |
screamer | 0:7a64fbb4069d | 315 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_coarse_tmr()\n")); |
screamer | 0:7a64fbb4069d | 316 | /* iterate through all network interfaces */ |
screamer | 0:7a64fbb4069d | 317 | while (netif != NULL) { |
screamer | 0:7a64fbb4069d | 318 | /* only act on DHCP configured interfaces */ |
screamer | 0:7a64fbb4069d | 319 | if (netif->dhcp != NULL) { |
screamer | 0:7a64fbb4069d | 320 | /* timer is active (non zero), and triggers (zeroes) now? */ |
screamer | 0:7a64fbb4069d | 321 | if (netif->dhcp->t2_timeout-- == 1) { |
screamer | 0:7a64fbb4069d | 322 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t2 timeout\n")); |
screamer | 0:7a64fbb4069d | 323 | /* this clients' rebind timeout triggered */ |
screamer | 0:7a64fbb4069d | 324 | dhcp_t2_timeout(netif); |
screamer | 0:7a64fbb4069d | 325 | /* timer is active (non zero), and triggers (zeroes) now */ |
screamer | 0:7a64fbb4069d | 326 | } else if (netif->dhcp->t1_timeout-- == 1) { |
screamer | 0:7a64fbb4069d | 327 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t1 timeout\n")); |
screamer | 0:7a64fbb4069d | 328 | /* this clients' renewal timeout triggered */ |
screamer | 0:7a64fbb4069d | 329 | dhcp_t1_timeout(netif); |
screamer | 0:7a64fbb4069d | 330 | } |
screamer | 0:7a64fbb4069d | 331 | } |
screamer | 0:7a64fbb4069d | 332 | /* proceed to next netif */ |
screamer | 0:7a64fbb4069d | 333 | netif = netif->next; |
screamer | 0:7a64fbb4069d | 334 | } |
screamer | 0:7a64fbb4069d | 335 | } |
screamer | 0:7a64fbb4069d | 336 | |
screamer | 0:7a64fbb4069d | 337 | /** |
screamer | 0:7a64fbb4069d | 338 | * DHCP transaction timeout handling |
screamer | 0:7a64fbb4069d | 339 | * |
screamer | 0:7a64fbb4069d | 340 | * A DHCP server is expected to respond within a short period of time. |
screamer | 0:7a64fbb4069d | 341 | * This timer checks whether an outstanding DHCP request is timed out. |
screamer | 0:7a64fbb4069d | 342 | * |
screamer | 0:7a64fbb4069d | 343 | */ |
screamer | 0:7a64fbb4069d | 344 | void |
screamer | 0:7a64fbb4069d | 345 | dhcp_fine_tmr() |
screamer | 0:7a64fbb4069d | 346 | { |
screamer | 0:7a64fbb4069d | 347 | struct netif *netif = netif_list; |
screamer | 0:7a64fbb4069d | 348 | /* loop through netif's */ |
screamer | 0:7a64fbb4069d | 349 | while (netif != NULL) { |
screamer | 0:7a64fbb4069d | 350 | /* only act on DHCP configured interfaces */ |
screamer | 0:7a64fbb4069d | 351 | if (netif->dhcp != NULL) { |
screamer | 0:7a64fbb4069d | 352 | /* timer is active (non zero), and is about to trigger now */ |
screamer | 0:7a64fbb4069d | 353 | if (netif->dhcp->request_timeout > 1) { |
screamer | 0:7a64fbb4069d | 354 | netif->dhcp->request_timeout--; |
screamer | 0:7a64fbb4069d | 355 | } |
screamer | 0:7a64fbb4069d | 356 | else if (netif->dhcp->request_timeout == 1) { |
screamer | 0:7a64fbb4069d | 357 | netif->dhcp->request_timeout--; |
screamer | 0:7a64fbb4069d | 358 | /* { netif->dhcp->request_timeout == 0 } */ |
screamer | 0:7a64fbb4069d | 359 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_fine_tmr(): request timeout\n")); |
screamer | 0:7a64fbb4069d | 360 | /* this clients' request timeout triggered */ |
screamer | 0:7a64fbb4069d | 361 | dhcp_timeout(netif); |
screamer | 0:7a64fbb4069d | 362 | } |
screamer | 0:7a64fbb4069d | 363 | } |
screamer | 0:7a64fbb4069d | 364 | /* proceed to next network interface */ |
screamer | 0:7a64fbb4069d | 365 | netif = netif->next; |
screamer | 0:7a64fbb4069d | 366 | } |
screamer | 0:7a64fbb4069d | 367 | } |
screamer | 0:7a64fbb4069d | 368 | |
screamer | 0:7a64fbb4069d | 369 | /** |
screamer | 0:7a64fbb4069d | 370 | * A DHCP negotiation transaction, or ARP request, has timed out. |
screamer | 0:7a64fbb4069d | 371 | * |
screamer | 0:7a64fbb4069d | 372 | * The timer that was started with the DHCP or ARP request has |
screamer | 0:7a64fbb4069d | 373 | * timed out, indicating no response was received in time. |
screamer | 0:7a64fbb4069d | 374 | * |
screamer | 0:7a64fbb4069d | 375 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 376 | */ |
screamer | 0:7a64fbb4069d | 377 | static void |
screamer | 0:7a64fbb4069d | 378 | dhcp_timeout(struct netif *netif) |
screamer | 0:7a64fbb4069d | 379 | { |
screamer | 0:7a64fbb4069d | 380 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 381 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_timeout()\n")); |
screamer | 0:7a64fbb4069d | 382 | /* back-off period has passed, or server selection timed out */ |
screamer | 0:7a64fbb4069d | 383 | if ((dhcp->state == DHCP_BACKING_OFF) || (dhcp->state == DHCP_SELECTING)) { |
screamer | 0:7a64fbb4069d | 384 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_timeout(): restarting discovery\n")); |
screamer | 0:7a64fbb4069d | 385 | dhcp_discover(netif); |
screamer | 0:7a64fbb4069d | 386 | /* receiving the requested lease timed out */ |
screamer | 0:7a64fbb4069d | 387 | } else if (dhcp->state == DHCP_REQUESTING) { |
screamer | 0:7a64fbb4069d | 388 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): REQUESTING, DHCP request timed out\n")); |
screamer | 0:7a64fbb4069d | 389 | if (dhcp->tries <= 5) { |
screamer | 0:7a64fbb4069d | 390 | dhcp_select(netif); |
screamer | 0:7a64fbb4069d | 391 | } else { |
screamer | 0:7a64fbb4069d | 392 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): REQUESTING, releasing, restarting\n")); |
screamer | 0:7a64fbb4069d | 393 | dhcp_release(netif); |
screamer | 0:7a64fbb4069d | 394 | dhcp_discover(netif); |
screamer | 0:7a64fbb4069d | 395 | } |
screamer | 0:7a64fbb4069d | 396 | /* received no ARP reply for the offered address (which is good) */ |
screamer | 0:7a64fbb4069d | 397 | } else if (dhcp->state == DHCP_CHECKING) { |
screamer | 0:7a64fbb4069d | 398 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): CHECKING, ARP request timed out\n")); |
screamer | 0:7a64fbb4069d | 399 | if (dhcp->tries <= 1) { |
screamer | 0:7a64fbb4069d | 400 | dhcp_check(netif); |
screamer | 0:7a64fbb4069d | 401 | /* no ARP replies on the offered address, |
screamer | 0:7a64fbb4069d | 402 | looks like the IP address is indeed free */ |
screamer | 0:7a64fbb4069d | 403 | } else { |
screamer | 0:7a64fbb4069d | 404 | /* bind the interface to the offered address */ |
screamer | 0:7a64fbb4069d | 405 | dhcp_bind(netif); |
screamer | 0:7a64fbb4069d | 406 | } |
screamer | 0:7a64fbb4069d | 407 | } |
screamer | 0:7a64fbb4069d | 408 | /* did not get response to renew request? */ |
screamer | 0:7a64fbb4069d | 409 | else if (dhcp->state == DHCP_RENEWING) { |
screamer | 0:7a64fbb4069d | 410 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): RENEWING, DHCP request timed out\n")); |
screamer | 0:7a64fbb4069d | 411 | /* just retry renewal */ |
screamer | 0:7a64fbb4069d | 412 | /* note that the rebind timer will eventually time-out if renew does not work */ |
screamer | 0:7a64fbb4069d | 413 | dhcp_renew(netif); |
screamer | 0:7a64fbb4069d | 414 | /* did not get response to rebind request? */ |
screamer | 0:7a64fbb4069d | 415 | } else if (dhcp->state == DHCP_REBINDING) { |
screamer | 0:7a64fbb4069d | 416 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): REBINDING, DHCP request timed out\n")); |
screamer | 0:7a64fbb4069d | 417 | if (dhcp->tries <= 8) { |
screamer | 0:7a64fbb4069d | 418 | dhcp_rebind(netif); |
screamer | 0:7a64fbb4069d | 419 | } else { |
screamer | 0:7a64fbb4069d | 420 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): RELEASING, DISCOVERING\n")); |
screamer | 0:7a64fbb4069d | 421 | dhcp_release(netif); |
screamer | 0:7a64fbb4069d | 422 | dhcp_discover(netif); |
screamer | 0:7a64fbb4069d | 423 | } |
screamer | 0:7a64fbb4069d | 424 | } |
screamer | 0:7a64fbb4069d | 425 | } |
screamer | 0:7a64fbb4069d | 426 | |
screamer | 0:7a64fbb4069d | 427 | /** |
screamer | 0:7a64fbb4069d | 428 | * The renewal period has timed out. |
screamer | 0:7a64fbb4069d | 429 | * |
screamer | 0:7a64fbb4069d | 430 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 431 | */ |
screamer | 0:7a64fbb4069d | 432 | static void |
screamer | 0:7a64fbb4069d | 433 | dhcp_t1_timeout(struct netif *netif) |
screamer | 0:7a64fbb4069d | 434 | { |
screamer | 0:7a64fbb4069d | 435 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 436 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_t1_timeout()\n")); |
screamer | 0:7a64fbb4069d | 437 | if ((dhcp->state == DHCP_REQUESTING) || (dhcp->state == DHCP_BOUND) || (dhcp->state == DHCP_RENEWING)) { |
screamer | 0:7a64fbb4069d | 438 | /* just retry to renew - note that the rebind timer (t2) will |
screamer | 0:7a64fbb4069d | 439 | * eventually time-out if renew tries fail. */ |
screamer | 0:7a64fbb4069d | 440 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_t1_timeout(): must renew\n")); |
screamer | 0:7a64fbb4069d | 441 | dhcp_renew(netif); |
screamer | 0:7a64fbb4069d | 442 | } |
screamer | 0:7a64fbb4069d | 443 | } |
screamer | 0:7a64fbb4069d | 444 | |
screamer | 0:7a64fbb4069d | 445 | /** |
screamer | 0:7a64fbb4069d | 446 | * The rebind period has timed out. |
screamer | 0:7a64fbb4069d | 447 | * |
screamer | 0:7a64fbb4069d | 448 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 449 | */ |
screamer | 0:7a64fbb4069d | 450 | static void |
screamer | 0:7a64fbb4069d | 451 | dhcp_t2_timeout(struct netif *netif) |
screamer | 0:7a64fbb4069d | 452 | { |
screamer | 0:7a64fbb4069d | 453 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 454 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_t2_timeout()\n")); |
screamer | 0:7a64fbb4069d | 455 | if ((dhcp->state == DHCP_REQUESTING) || (dhcp->state == DHCP_BOUND) || (dhcp->state == DHCP_RENEWING)) { |
screamer | 0:7a64fbb4069d | 456 | /* just retry to rebind */ |
screamer | 0:7a64fbb4069d | 457 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_t2_timeout(): must rebind\n")); |
screamer | 0:7a64fbb4069d | 458 | dhcp_rebind(netif); |
screamer | 0:7a64fbb4069d | 459 | } |
screamer | 0:7a64fbb4069d | 460 | } |
screamer | 0:7a64fbb4069d | 461 | |
screamer | 0:7a64fbb4069d | 462 | /** |
screamer | 0:7a64fbb4069d | 463 | * Handle a DHCP ACK packet |
screamer | 0:7a64fbb4069d | 464 | * |
screamer | 0:7a64fbb4069d | 465 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 466 | */ |
screamer | 0:7a64fbb4069d | 467 | static void |
screamer | 0:7a64fbb4069d | 468 | dhcp_handle_ack(struct netif *netif) |
screamer | 0:7a64fbb4069d | 469 | { |
screamer | 0:7a64fbb4069d | 470 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 471 | u8_t *option_ptr; |
screamer | 0:7a64fbb4069d | 472 | /* clear options we might not get from the ACK */ |
screamer | 0:7a64fbb4069d | 473 | dhcp->offered_sn_mask.addr = 0; |
screamer | 0:7a64fbb4069d | 474 | dhcp->offered_gw_addr.addr = 0; |
screamer | 0:7a64fbb4069d | 475 | dhcp->offered_bc_addr.addr = 0; |
screamer | 0:7a64fbb4069d | 476 | |
screamer | 0:7a64fbb4069d | 477 | /* lease time given? */ |
screamer | 0:7a64fbb4069d | 478 | option_ptr = dhcp_get_option_ptr(dhcp, DHCP_OPTION_LEASE_TIME); |
screamer | 0:7a64fbb4069d | 479 | if (option_ptr != NULL) { |
screamer | 0:7a64fbb4069d | 480 | /* remember offered lease time */ |
screamer | 0:7a64fbb4069d | 481 | dhcp->offered_t0_lease = dhcp_get_option_long(option_ptr + 2); |
screamer | 0:7a64fbb4069d | 482 | } |
screamer | 0:7a64fbb4069d | 483 | /* renewal period given? */ |
screamer | 0:7a64fbb4069d | 484 | option_ptr = dhcp_get_option_ptr(dhcp, DHCP_OPTION_T1); |
screamer | 0:7a64fbb4069d | 485 | if (option_ptr != NULL) { |
screamer | 0:7a64fbb4069d | 486 | /* remember given renewal period */ |
screamer | 0:7a64fbb4069d | 487 | dhcp->offered_t1_renew = dhcp_get_option_long(option_ptr + 2); |
screamer | 0:7a64fbb4069d | 488 | } else { |
screamer | 0:7a64fbb4069d | 489 | /* calculate safe periods for renewal */ |
screamer | 0:7a64fbb4069d | 490 | dhcp->offered_t1_renew = dhcp->offered_t0_lease / 2; |
screamer | 0:7a64fbb4069d | 491 | } |
screamer | 0:7a64fbb4069d | 492 | |
screamer | 0:7a64fbb4069d | 493 | /* renewal period given? */ |
screamer | 0:7a64fbb4069d | 494 | option_ptr = dhcp_get_option_ptr(dhcp, DHCP_OPTION_T2); |
screamer | 0:7a64fbb4069d | 495 | if (option_ptr != NULL) { |
screamer | 0:7a64fbb4069d | 496 | /* remember given rebind period */ |
screamer | 0:7a64fbb4069d | 497 | dhcp->offered_t2_rebind = dhcp_get_option_long(option_ptr + 2); |
screamer | 0:7a64fbb4069d | 498 | } else { |
screamer | 0:7a64fbb4069d | 499 | /* calculate safe periods for rebinding */ |
screamer | 0:7a64fbb4069d | 500 | dhcp->offered_t2_rebind = dhcp->offered_t0_lease; |
screamer | 0:7a64fbb4069d | 501 | } |
screamer | 0:7a64fbb4069d | 502 | |
screamer | 0:7a64fbb4069d | 503 | /* (y)our internet address */ |
screamer | 0:7a64fbb4069d | 504 | ip_addr_set(&dhcp->offered_ip_addr, &dhcp->msg_in->yiaddr); |
screamer | 0:7a64fbb4069d | 505 | |
screamer | 0:7a64fbb4069d | 506 | /** |
screamer | 0:7a64fbb4069d | 507 | * Patch #1308 |
screamer | 0:7a64fbb4069d | 508 | * TODO: we must check if the file field is not overloaded by DHCP options! |
screamer | 0:7a64fbb4069d | 509 | */ |
screamer | 0:7a64fbb4069d | 510 | #if 0 |
screamer | 0:7a64fbb4069d | 511 | /* boot server address */ |
screamer | 0:7a64fbb4069d | 512 | ip_addr_set(&dhcp->offered_si_addr, &dhcp->msg_in->siaddr); |
screamer | 0:7a64fbb4069d | 513 | /* boot file name */ |
screamer | 0:7a64fbb4069d | 514 | if (dhcp->msg_in->file[0]) { |
screamer | 0:7a64fbb4069d | 515 | dhcp->boot_file_name = mem_malloc(strlen(dhcp->msg_in->file) + 1); |
screamer | 0:7a64fbb4069d | 516 | strcpy(dhcp->boot_file_name, dhcp->msg_in->file); |
screamer | 0:7a64fbb4069d | 517 | } |
screamer | 0:7a64fbb4069d | 518 | #endif |
screamer | 0:7a64fbb4069d | 519 | |
screamer | 0:7a64fbb4069d | 520 | /* subnet mask */ |
screamer | 0:7a64fbb4069d | 521 | option_ptr = dhcp_get_option_ptr(dhcp, DHCP_OPTION_SUBNET_MASK); |
screamer | 0:7a64fbb4069d | 522 | /* subnet mask given? */ |
screamer | 0:7a64fbb4069d | 523 | if (option_ptr != NULL) { |
screamer | 0:7a64fbb4069d | 524 | dhcp->offered_sn_mask.addr = htonl(dhcp_get_option_long(&option_ptr[2])); |
screamer | 0:7a64fbb4069d | 525 | } |
screamer | 0:7a64fbb4069d | 526 | |
screamer | 0:7a64fbb4069d | 527 | /* gateway router */ |
screamer | 0:7a64fbb4069d | 528 | option_ptr = dhcp_get_option_ptr(dhcp, DHCP_OPTION_ROUTER); |
screamer | 0:7a64fbb4069d | 529 | if (option_ptr != NULL) { |
screamer | 0:7a64fbb4069d | 530 | dhcp->offered_gw_addr.addr = htonl(dhcp_get_option_long(&option_ptr[2])); |
screamer | 0:7a64fbb4069d | 531 | } |
screamer | 0:7a64fbb4069d | 532 | |
screamer | 0:7a64fbb4069d | 533 | /* broadcast address */ |
screamer | 0:7a64fbb4069d | 534 | option_ptr = dhcp_get_option_ptr(dhcp, DHCP_OPTION_BROADCAST); |
screamer | 0:7a64fbb4069d | 535 | if (option_ptr != NULL) { |
screamer | 0:7a64fbb4069d | 536 | dhcp->offered_bc_addr.addr = htonl(dhcp_get_option_long(&option_ptr[2])); |
screamer | 0:7a64fbb4069d | 537 | } |
screamer | 0:7a64fbb4069d | 538 | |
screamer | 0:7a64fbb4069d | 539 | /* DNS servers */ |
screamer | 0:7a64fbb4069d | 540 | option_ptr = dhcp_get_option_ptr(dhcp, DHCP_OPTION_DNS_SERVER); |
screamer | 0:7a64fbb4069d | 541 | if (option_ptr != NULL) { |
screamer | 0:7a64fbb4069d | 542 | u8_t n; |
screamer | 0:7a64fbb4069d | 543 | dhcp->dns_count = dhcp_get_option_byte(&option_ptr[1]) / (u32_t)sizeof(struct ip_addr); |
screamer | 0:7a64fbb4069d | 544 | /* limit to at most DHCP_MAX_DNS DNS servers */ |
screamer | 0:7a64fbb4069d | 545 | if (dhcp->dns_count > DHCP_MAX_DNS) |
screamer | 0:7a64fbb4069d | 546 | dhcp->dns_count = DHCP_MAX_DNS; |
screamer | 0:7a64fbb4069d | 547 | for (n = 0; n < dhcp->dns_count; n++) { |
screamer | 0:7a64fbb4069d | 548 | dhcp->offered_dns_addr[n].addr = htonl(dhcp_get_option_long(&option_ptr[2 + n * 4])); |
screamer | 0:7a64fbb4069d | 549 | #if LWIP_DNS |
screamer | 0:7a64fbb4069d | 550 | dns_setserver( n, (struct ip_addr *)(&(dhcp->offered_dns_addr[n].addr))); |
screamer | 0:7a64fbb4069d | 551 | #endif /* LWIP_DNS */ |
screamer | 0:7a64fbb4069d | 552 | } |
screamer | 0:7a64fbb4069d | 553 | #if LWIP_DNS |
screamer | 0:7a64fbb4069d | 554 | dns_setserver( n, (struct ip_addr *)(&ip_addr_any)); |
screamer | 0:7a64fbb4069d | 555 | #endif /* LWIP_DNS */ |
screamer | 0:7a64fbb4069d | 556 | } |
screamer | 0:7a64fbb4069d | 557 | } |
screamer | 0:7a64fbb4069d | 558 | |
screamer | 0:7a64fbb4069d | 559 | /** |
screamer | 0:7a64fbb4069d | 560 | * Start DHCP negotiation for a network interface. |
screamer | 0:7a64fbb4069d | 561 | * |
screamer | 0:7a64fbb4069d | 562 | * If no DHCP client instance was attached to this interface, |
screamer | 0:7a64fbb4069d | 563 | * a new client is created first. If a DHCP client instance |
screamer | 0:7a64fbb4069d | 564 | * was already present, it restarts negotiation. |
screamer | 0:7a64fbb4069d | 565 | * |
screamer | 0:7a64fbb4069d | 566 | * @param netif The lwIP network interface |
screamer | 0:7a64fbb4069d | 567 | * @return lwIP error code |
screamer | 0:7a64fbb4069d | 568 | * - ERR_OK - No error |
screamer | 0:7a64fbb4069d | 569 | * - ERR_MEM - Out of memory |
screamer | 0:7a64fbb4069d | 570 | */ |
screamer | 0:7a64fbb4069d | 571 | err_t |
screamer | 0:7a64fbb4069d | 572 | dhcp_start(struct netif *netif) |
screamer | 0:7a64fbb4069d | 573 | { |
screamer | 0:7a64fbb4069d | 574 | struct dhcp *dhcp; |
screamer | 0:7a64fbb4069d | 575 | err_t result = ERR_OK; |
screamer | 0:7a64fbb4069d | 576 | |
screamer | 0:7a64fbb4069d | 577 | LWIP_ERROR("netif != NULL", (netif != NULL), return ERR_ARG;); |
screamer | 0:7a64fbb4069d | 578 | dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 579 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); |
screamer | 0:7a64fbb4069d | 580 | /* Remove the flag that says this netif is handled by DHCP, |
screamer | 0:7a64fbb4069d | 581 | it is set when we succeeded starting. */ |
screamer | 0:7a64fbb4069d | 582 | netif->flags &= ~NETIF_FLAG_DHCP; |
screamer | 0:7a64fbb4069d | 583 | |
screamer | 0:7a64fbb4069d | 584 | /* check MTU of the netif */ |
screamer | 0:7a64fbb4069d | 585 | if (netif->mtu < DHCP_MAX_MSG_LEN_MIN_REQUIRED) { |
screamer | 0:7a64fbb4069d | 586 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): Cannot use this netif with DHCP: MTU is too small\n")); |
screamer | 0:7a64fbb4069d | 587 | return ERR_MEM; |
screamer | 0:7a64fbb4069d | 588 | } |
screamer | 0:7a64fbb4069d | 589 | |
screamer | 0:7a64fbb4069d | 590 | /* no DHCP client attached yet? */ |
screamer | 0:7a64fbb4069d | 591 | if (dhcp == NULL) { |
screamer | 0:7a64fbb4069d | 592 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): starting new DHCP client\n")); |
screamer | 0:7a64fbb4069d | 593 | dhcp = (struct dhcp *)mem_malloc(sizeof(struct dhcp)); // static_cast<struct dhcp *>(x) |
screamer | 0:7a64fbb4069d | 594 | if (dhcp == NULL) { |
screamer | 0:7a64fbb4069d | 595 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): could not allocate dhcp\n")); |
screamer | 0:7a64fbb4069d | 596 | return ERR_MEM; |
screamer | 0:7a64fbb4069d | 597 | } |
screamer | 0:7a64fbb4069d | 598 | /* store this dhcp client in the netif */ |
screamer | 0:7a64fbb4069d | 599 | netif->dhcp = dhcp; |
screamer | 0:7a64fbb4069d | 600 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): allocated dhcp")); |
screamer | 0:7a64fbb4069d | 601 | /* already has DHCP client attached */ |
screamer | 0:7a64fbb4069d | 602 | } else { |
screamer | 0:7a64fbb4069d | 603 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | 3, ("dhcp_start(): restarting DHCP configuration\n")); |
screamer | 0:7a64fbb4069d | 604 | if (dhcp->pcb != NULL) { |
screamer | 0:7a64fbb4069d | 605 | udp_remove(dhcp->pcb); |
screamer | 0:7a64fbb4069d | 606 | } |
screamer | 0:7a64fbb4069d | 607 | if (dhcp->p != NULL) { |
screamer | 0:7a64fbb4069d | 608 | pbuf_free(dhcp->p); |
screamer | 0:7a64fbb4069d | 609 | } |
screamer | 0:7a64fbb4069d | 610 | } |
screamer | 0:7a64fbb4069d | 611 | |
screamer | 0:7a64fbb4069d | 612 | /* clear data structure */ |
screamer | 0:7a64fbb4069d | 613 | memset(dhcp, 0, sizeof(struct dhcp)); |
screamer | 0:7a64fbb4069d | 614 | /* allocate UDP PCB */ |
screamer | 0:7a64fbb4069d | 615 | dhcp->pcb = udp_new(); |
screamer | 0:7a64fbb4069d | 616 | if (dhcp->pcb == NULL) { |
screamer | 0:7a64fbb4069d | 617 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): could not obtain pcb\n")); |
screamer | 0:7a64fbb4069d | 618 | mem_free((void *)dhcp); |
screamer | 0:7a64fbb4069d | 619 | netif->dhcp = dhcp = NULL; |
screamer | 0:7a64fbb4069d | 620 | return ERR_MEM; |
screamer | 0:7a64fbb4069d | 621 | } |
screamer | 0:7a64fbb4069d | 622 | /* set up local and remote port for the pcb */ |
screamer | 0:7a64fbb4069d | 623 | udp_bind(dhcp->pcb, IP_ADDR_ANY, DHCP_CLIENT_PORT); |
screamer | 0:7a64fbb4069d | 624 | udp_connect(dhcp->pcb, IP_ADDR_ANY, DHCP_SERVER_PORT); |
screamer | 0:7a64fbb4069d | 625 | /* set up the recv callback and argument */ |
screamer | 0:7a64fbb4069d | 626 | udp_recv(dhcp->pcb, dhcp_recv, netif); |
screamer | 0:7a64fbb4069d | 627 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): starting DHCP configuration\n")); |
screamer | 0:7a64fbb4069d | 628 | /* (re)start the DHCP negotiation */ |
screamer | 0:7a64fbb4069d | 629 | result = dhcp_discover(netif); |
screamer | 0:7a64fbb4069d | 630 | if (result != ERR_OK) { |
screamer | 0:7a64fbb4069d | 631 | /* free resources allocated above */ |
screamer | 0:7a64fbb4069d | 632 | dhcp_stop(netif); |
screamer | 0:7a64fbb4069d | 633 | return ERR_MEM; |
screamer | 0:7a64fbb4069d | 634 | } |
screamer | 0:7a64fbb4069d | 635 | /* Set the flag that says this netif is handled by DHCP. */ |
screamer | 0:7a64fbb4069d | 636 | netif->flags |= NETIF_FLAG_DHCP; |
screamer | 0:7a64fbb4069d | 637 | return result; |
screamer | 0:7a64fbb4069d | 638 | } |
screamer | 0:7a64fbb4069d | 639 | |
screamer | 0:7a64fbb4069d | 640 | /** |
screamer | 0:7a64fbb4069d | 641 | * Inform a DHCP server of our manual configuration. |
screamer | 0:7a64fbb4069d | 642 | * |
screamer | 0:7a64fbb4069d | 643 | * This informs DHCP servers of our fixed IP address configuration |
screamer | 0:7a64fbb4069d | 644 | * by sending an INFORM message. It does not involve DHCP address |
screamer | 0:7a64fbb4069d | 645 | * configuration, it is just here to be nice to the network. |
screamer | 0:7a64fbb4069d | 646 | * |
screamer | 0:7a64fbb4069d | 647 | * @param netif The lwIP network interface |
screamer | 0:7a64fbb4069d | 648 | */ |
screamer | 0:7a64fbb4069d | 649 | void |
screamer | 0:7a64fbb4069d | 650 | dhcp_inform(struct netif *netif) |
screamer | 0:7a64fbb4069d | 651 | { |
screamer | 0:7a64fbb4069d | 652 | struct dhcp *dhcp, *old_dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 653 | err_t result = ERR_OK; |
screamer | 0:7a64fbb4069d | 654 | dhcp = (struct dhcp *)mem_malloc(sizeof(struct dhcp)); // static_cast<struct dhcp *>(x) |
screamer | 0:7a64fbb4069d | 655 | if (dhcp == NULL) { |
screamer | 0:7a64fbb4069d | 656 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_inform(): could not allocate dhcp\n")); |
screamer | 0:7a64fbb4069d | 657 | return; |
screamer | 0:7a64fbb4069d | 658 | } |
screamer | 0:7a64fbb4069d | 659 | netif->dhcp = dhcp; |
screamer | 0:7a64fbb4069d | 660 | memset(dhcp, 0, sizeof(struct dhcp)); |
screamer | 0:7a64fbb4069d | 661 | |
screamer | 0:7a64fbb4069d | 662 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_inform(): allocated dhcp\n")); |
screamer | 0:7a64fbb4069d | 663 | dhcp->pcb = udp_new(); |
screamer | 0:7a64fbb4069d | 664 | if (dhcp->pcb == NULL) { |
screamer | 0:7a64fbb4069d | 665 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_inform(): could not obtain pcb")); |
screamer | 0:7a64fbb4069d | 666 | mem_free((void *)dhcp); |
screamer | 0:7a64fbb4069d | 667 | return; |
screamer | 0:7a64fbb4069d | 668 | } |
screamer | 0:7a64fbb4069d | 669 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_inform(): created new udp pcb\n")); |
screamer | 0:7a64fbb4069d | 670 | /* create and initialize the DHCP message header */ |
screamer | 0:7a64fbb4069d | 671 | result = dhcp_create_request(netif); |
screamer | 0:7a64fbb4069d | 672 | if (result == ERR_OK) { |
screamer | 0:7a64fbb4069d | 673 | |
screamer | 0:7a64fbb4069d | 674 | dhcp_option(dhcp, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN); |
screamer | 0:7a64fbb4069d | 675 | dhcp_option_byte(dhcp, DHCP_INFORM); |
screamer | 0:7a64fbb4069d | 676 | |
screamer | 0:7a64fbb4069d | 677 | dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); |
screamer | 0:7a64fbb4069d | 678 | dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif)); |
screamer | 0:7a64fbb4069d | 679 | |
screamer | 0:7a64fbb4069d | 680 | dhcp_option_trailer(dhcp); |
screamer | 0:7a64fbb4069d | 681 | |
screamer | 0:7a64fbb4069d | 682 | pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len); |
screamer | 0:7a64fbb4069d | 683 | |
screamer | 0:7a64fbb4069d | 684 | udp_bind(dhcp->pcb, IP_ADDR_ANY, DHCP_CLIENT_PORT); |
screamer | 0:7a64fbb4069d | 685 | udp_connect(dhcp->pcb, IP_ADDR_BROADCAST, DHCP_SERVER_PORT); |
screamer | 0:7a64fbb4069d | 686 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_inform: INFORMING\n")); |
screamer | 0:7a64fbb4069d | 687 | udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif); |
screamer | 0:7a64fbb4069d | 688 | udp_connect(dhcp->pcb, IP_ADDR_ANY, DHCP_SERVER_PORT); |
screamer | 0:7a64fbb4069d | 689 | dhcp_delete_request(netif); |
screamer | 0:7a64fbb4069d | 690 | } else { |
screamer | 0:7a64fbb4069d | 691 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_inform: could not allocate DHCP request\n")); |
screamer | 0:7a64fbb4069d | 692 | } |
screamer | 0:7a64fbb4069d | 693 | |
screamer | 0:7a64fbb4069d | 694 | if (dhcp->pcb != NULL) { |
screamer | 0:7a64fbb4069d | 695 | udp_remove(dhcp->pcb); |
screamer | 0:7a64fbb4069d | 696 | } |
screamer | 0:7a64fbb4069d | 697 | dhcp->pcb = NULL; |
screamer | 0:7a64fbb4069d | 698 | mem_free((void *)dhcp); |
screamer | 0:7a64fbb4069d | 699 | netif->dhcp = old_dhcp; |
screamer | 0:7a64fbb4069d | 700 | } |
screamer | 0:7a64fbb4069d | 701 | |
screamer | 0:7a64fbb4069d | 702 | #if DHCP_DOES_ARP_CHECK |
screamer | 0:7a64fbb4069d | 703 | /** |
screamer | 0:7a64fbb4069d | 704 | * Match an ARP reply with the offered IP address. |
screamer | 0:7a64fbb4069d | 705 | * |
screamer | 0:7a64fbb4069d | 706 | * @param netif the network interface on which the reply was received |
screamer | 0:7a64fbb4069d | 707 | * @param addr The IP address we received a reply from |
screamer | 0:7a64fbb4069d | 708 | */ |
screamer | 0:7a64fbb4069d | 709 | void dhcp_arp_reply(struct netif *netif, struct ip_addr *addr) |
screamer | 0:7a64fbb4069d | 710 | { |
screamer | 0:7a64fbb4069d | 711 | LWIP_ERROR("netif != NULL", (netif != NULL), return;); |
screamer | 0:7a64fbb4069d | 712 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_arp_reply()\n")); |
screamer | 0:7a64fbb4069d | 713 | /* is a DHCP client doing an ARP check? */ |
screamer | 0:7a64fbb4069d | 714 | if ((netif->dhcp != NULL) && (netif->dhcp->state == DHCP_CHECKING)) { |
screamer | 0:7a64fbb4069d | 715 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_arp_reply(): CHECKING, arp reply for 0x%08"X32_F"\n", addr->addr)); |
screamer | 0:7a64fbb4069d | 716 | /* did a host respond with the address we |
screamer | 0:7a64fbb4069d | 717 | were offered by the DHCP server? */ |
screamer | 0:7a64fbb4069d | 718 | if (ip_addr_cmp(addr, &netif->dhcp->offered_ip_addr)) { |
screamer | 0:7a64fbb4069d | 719 | /* we will not accept the offered address */ |
screamer | 0:7a64fbb4069d | 720 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | 1, ("dhcp_arp_reply(): arp reply matched with offered address, declining\n")); |
screamer | 0:7a64fbb4069d | 721 | dhcp_decline(netif); |
screamer | 0:7a64fbb4069d | 722 | } |
screamer | 0:7a64fbb4069d | 723 | } |
screamer | 0:7a64fbb4069d | 724 | } |
screamer | 0:7a64fbb4069d | 725 | |
screamer | 0:7a64fbb4069d | 726 | /** |
screamer | 0:7a64fbb4069d | 727 | * Decline an offered lease. |
screamer | 0:7a64fbb4069d | 728 | * |
screamer | 0:7a64fbb4069d | 729 | * Tell the DHCP server we do not accept the offered address. |
screamer | 0:7a64fbb4069d | 730 | * One reason to decline the lease is when we find out the address |
screamer | 0:7a64fbb4069d | 731 | * is already in use by another host (through ARP). |
screamer | 0:7a64fbb4069d | 732 | * |
screamer | 0:7a64fbb4069d | 733 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 734 | */ |
screamer | 0:7a64fbb4069d | 735 | static err_t |
screamer | 0:7a64fbb4069d | 736 | dhcp_decline(struct netif *netif) |
screamer | 0:7a64fbb4069d | 737 | { |
screamer | 0:7a64fbb4069d | 738 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 739 | err_t result = ERR_OK; |
screamer | 0:7a64fbb4069d | 740 | u16_t msecs; |
screamer | 0:7a64fbb4069d | 741 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_decline()\n")); |
screamer | 0:7a64fbb4069d | 742 | dhcp_set_state(dhcp, DHCP_BACKING_OFF); |
screamer | 0:7a64fbb4069d | 743 | /* create and initialize the DHCP message header */ |
screamer | 0:7a64fbb4069d | 744 | result = dhcp_create_request(netif); |
screamer | 0:7a64fbb4069d | 745 | if (result == ERR_OK) { |
screamer | 0:7a64fbb4069d | 746 | dhcp_option(dhcp, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN); |
screamer | 0:7a64fbb4069d | 747 | dhcp_option_byte(dhcp, DHCP_DECLINE); |
screamer | 0:7a64fbb4069d | 748 | |
screamer | 0:7a64fbb4069d | 749 | dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4); |
screamer | 0:7a64fbb4069d | 750 | dhcp_option_long(dhcp, ntohl(dhcp->offered_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 751 | |
screamer | 0:7a64fbb4069d | 752 | dhcp_option_trailer(dhcp); |
screamer | 0:7a64fbb4069d | 753 | /* resize pbuf to reflect true size of options */ |
screamer | 0:7a64fbb4069d | 754 | pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len); |
screamer | 0:7a64fbb4069d | 755 | |
screamer | 0:7a64fbb4069d | 756 | /* @todo: should we really connect here? we are performing sendto() */ |
screamer | 0:7a64fbb4069d | 757 | udp_connect(dhcp->pcb, IP_ADDR_ANY, DHCP_SERVER_PORT); |
screamer | 0:7a64fbb4069d | 758 | /* per section 4.4.4, broadcast DECLINE messages */ |
screamer | 0:7a64fbb4069d | 759 | udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif); |
screamer | 0:7a64fbb4069d | 760 | dhcp_delete_request(netif); |
screamer | 0:7a64fbb4069d | 761 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_decline: BACKING OFF\n")); |
screamer | 0:7a64fbb4069d | 762 | } else { |
screamer | 0:7a64fbb4069d | 763 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_decline: could not allocate DHCP request\n")); |
screamer | 0:7a64fbb4069d | 764 | } |
screamer | 0:7a64fbb4069d | 765 | dhcp->tries++; |
screamer | 0:7a64fbb4069d | 766 | msecs = 10*1000; |
screamer | 0:7a64fbb4069d | 767 | dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS; |
screamer | 0:7a64fbb4069d | 768 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_decline(): set request timeout %"U16_F" msecs\n", msecs)); |
screamer | 0:7a64fbb4069d | 769 | return result; |
screamer | 0:7a64fbb4069d | 770 | } |
screamer | 0:7a64fbb4069d | 771 | #endif |
screamer | 0:7a64fbb4069d | 772 | |
screamer | 0:7a64fbb4069d | 773 | |
screamer | 0:7a64fbb4069d | 774 | /** |
screamer | 0:7a64fbb4069d | 775 | * Start the DHCP process, discover a DHCP server. |
screamer | 0:7a64fbb4069d | 776 | * |
screamer | 0:7a64fbb4069d | 777 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 778 | */ |
screamer | 0:7a64fbb4069d | 779 | static err_t |
screamer | 0:7a64fbb4069d | 780 | dhcp_discover(struct netif *netif) |
screamer | 0:7a64fbb4069d | 781 | { |
screamer | 0:7a64fbb4069d | 782 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 783 | err_t result = ERR_OK; |
screamer | 0:7a64fbb4069d | 784 | u16_t msecs; |
screamer | 0:7a64fbb4069d | 785 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_discover()\n")); |
screamer | 0:7a64fbb4069d | 786 | ip_addr_set(&dhcp->offered_ip_addr, IP_ADDR_ANY); |
screamer | 0:7a64fbb4069d | 787 | /* create and initialize the DHCP message header */ |
screamer | 0:7a64fbb4069d | 788 | result = dhcp_create_request(netif); |
screamer | 0:7a64fbb4069d | 789 | if (result == ERR_OK) { |
screamer | 0:7a64fbb4069d | 790 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: making request\n")); |
screamer | 0:7a64fbb4069d | 791 | dhcp_option(dhcp, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN); |
screamer | 0:7a64fbb4069d | 792 | dhcp_option_byte(dhcp, DHCP_DISCOVER); |
screamer | 0:7a64fbb4069d | 793 | |
screamer | 0:7a64fbb4069d | 794 | dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); |
screamer | 0:7a64fbb4069d | 795 | dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif)); |
screamer | 0:7a64fbb4069d | 796 | |
screamer | 0:7a64fbb4069d | 797 | dhcp_option(dhcp, DHCP_OPTION_PARAMETER_REQUEST_LIST, 4/*num options*/); |
screamer | 0:7a64fbb4069d | 798 | dhcp_option_byte(dhcp, DHCP_OPTION_SUBNET_MASK); |
screamer | 0:7a64fbb4069d | 799 | dhcp_option_byte(dhcp, DHCP_OPTION_ROUTER); |
screamer | 0:7a64fbb4069d | 800 | dhcp_option_byte(dhcp, DHCP_OPTION_BROADCAST); |
screamer | 0:7a64fbb4069d | 801 | dhcp_option_byte(dhcp, DHCP_OPTION_DNS_SERVER); |
screamer | 0:7a64fbb4069d | 802 | |
screamer | 0:7a64fbb4069d | 803 | dhcp_option_trailer(dhcp); |
screamer | 0:7a64fbb4069d | 804 | |
screamer | 0:7a64fbb4069d | 805 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: realloc()ing\n")); |
screamer | 0:7a64fbb4069d | 806 | pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len); |
screamer | 0:7a64fbb4069d | 807 | |
screamer | 0:7a64fbb4069d | 808 | udp_connect(dhcp->pcb, IP_ADDR_ANY, DHCP_SERVER_PORT); |
screamer | 0:7a64fbb4069d | 809 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: sendto(DISCOVER, IP_ADDR_BROADCAST, DHCP_SERVER_PORT)\n")); |
screamer | 0:7a64fbb4069d | 810 | udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif); |
screamer | 0:7a64fbb4069d | 811 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: deleting()ing\n")); |
screamer | 0:7a64fbb4069d | 812 | dhcp_delete_request(netif); |
screamer | 0:7a64fbb4069d | 813 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_discover: SELECTING\n")); |
screamer | 0:7a64fbb4069d | 814 | dhcp_set_state(dhcp, DHCP_SELECTING); |
screamer | 0:7a64fbb4069d | 815 | } else { |
screamer | 0:7a64fbb4069d | 816 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_discover: could not allocate DHCP request\n")); |
screamer | 0:7a64fbb4069d | 817 | } |
screamer | 0:7a64fbb4069d | 818 | dhcp->tries++; |
screamer | 0:7a64fbb4069d | 819 | #if LWIP_DHCP_AUTOIP_COOP |
screamer | 0:7a64fbb4069d | 820 | /* that means we waited 57 seconds */ |
screamer | 0:7a64fbb4069d | 821 | if(dhcp->tries >= 9 && dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_OFF) { |
screamer | 0:7a64fbb4069d | 822 | dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_ON; |
screamer | 0:7a64fbb4069d | 823 | autoip_start(netif); |
screamer | 0:7a64fbb4069d | 824 | } |
screamer | 0:7a64fbb4069d | 825 | #endif /* LWIP_DHCP_AUTOIP_COOP */ |
screamer | 0:7a64fbb4069d | 826 | msecs = dhcp->tries < 4 ? (dhcp->tries + 1) * 1000 : 10 * 1000; |
screamer | 0:7a64fbb4069d | 827 | dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS; |
screamer | 0:7a64fbb4069d | 828 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_discover(): set request timeout %"U16_F" msecs\n", msecs)); |
screamer | 0:7a64fbb4069d | 829 | return result; |
screamer | 0:7a64fbb4069d | 830 | } |
screamer | 0:7a64fbb4069d | 831 | |
screamer | 0:7a64fbb4069d | 832 | |
screamer | 0:7a64fbb4069d | 833 | /** |
screamer | 0:7a64fbb4069d | 834 | * Bind the interface to the offered IP address. |
screamer | 0:7a64fbb4069d | 835 | * |
screamer | 0:7a64fbb4069d | 836 | * @param netif network interface to bind to the offered address |
screamer | 0:7a64fbb4069d | 837 | */ |
screamer | 0:7a64fbb4069d | 838 | static void |
screamer | 0:7a64fbb4069d | 839 | dhcp_bind(struct netif *netif) |
screamer | 0:7a64fbb4069d | 840 | { |
screamer | 0:7a64fbb4069d | 841 | u32_t timeout; |
screamer | 0:7a64fbb4069d | 842 | struct dhcp *dhcp; |
screamer | 0:7a64fbb4069d | 843 | struct ip_addr sn_mask, gw_addr; |
screamer | 0:7a64fbb4069d | 844 | LWIP_ERROR("dhcp_bind: netif != NULL", (netif != NULL), return;); |
screamer | 0:7a64fbb4069d | 845 | dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 846 | LWIP_ERROR("dhcp_bind: dhcp != NULL", (dhcp != NULL), return;); |
screamer | 0:7a64fbb4069d | 847 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_bind(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); |
screamer | 0:7a64fbb4069d | 848 | |
screamer | 0:7a64fbb4069d | 849 | /* temporary DHCP lease? */ |
screamer | 0:7a64fbb4069d | 850 | if (dhcp->offered_t1_renew != 0xffffffffUL) { |
screamer | 0:7a64fbb4069d | 851 | /* set renewal period timer */ |
screamer | 0:7a64fbb4069d | 852 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t1 renewal timer %"U32_F" secs\n", dhcp->offered_t1_renew)); |
screamer | 0:7a64fbb4069d | 853 | timeout = (dhcp->offered_t1_renew + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; |
screamer | 0:7a64fbb4069d | 854 | if(timeout > 0xffff) { |
screamer | 0:7a64fbb4069d | 855 | timeout = 0xffff; |
screamer | 0:7a64fbb4069d | 856 | } |
screamer | 0:7a64fbb4069d | 857 | dhcp->t1_timeout = (u16_t)timeout; |
screamer | 0:7a64fbb4069d | 858 | if (dhcp->t1_timeout == 0) { |
screamer | 0:7a64fbb4069d | 859 | dhcp->t1_timeout = 1; |
screamer | 0:7a64fbb4069d | 860 | } |
screamer | 0:7a64fbb4069d | 861 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t1_renew*1000)); |
screamer | 0:7a64fbb4069d | 862 | } |
screamer | 0:7a64fbb4069d | 863 | /* set renewal period timer */ |
screamer | 0:7a64fbb4069d | 864 | if (dhcp->offered_t2_rebind != 0xffffffffUL) { |
screamer | 0:7a64fbb4069d | 865 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t2 rebind timer %"U32_F" secs\n", dhcp->offered_t2_rebind)); |
screamer | 0:7a64fbb4069d | 866 | timeout = (dhcp->offered_t2_rebind + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; |
screamer | 0:7a64fbb4069d | 867 | if(timeout > 0xffff) { |
screamer | 0:7a64fbb4069d | 868 | timeout = 0xffff; |
screamer | 0:7a64fbb4069d | 869 | } |
screamer | 0:7a64fbb4069d | 870 | dhcp->t2_timeout = (u16_t)timeout; |
screamer | 0:7a64fbb4069d | 871 | if (dhcp->t2_timeout == 0) { |
screamer | 0:7a64fbb4069d | 872 | dhcp->t2_timeout = 1; |
screamer | 0:7a64fbb4069d | 873 | } |
screamer | 0:7a64fbb4069d | 874 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t2_rebind*1000)); |
screamer | 0:7a64fbb4069d | 875 | } |
screamer | 0:7a64fbb4069d | 876 | /* copy offered network mask */ |
screamer | 0:7a64fbb4069d | 877 | ip_addr_set(&sn_mask, &dhcp->offered_sn_mask); |
screamer | 0:7a64fbb4069d | 878 | |
screamer | 0:7a64fbb4069d | 879 | /* subnet mask not given? */ |
screamer | 0:7a64fbb4069d | 880 | /* TODO: this is not a valid check. what if the network mask is 0? */ |
screamer | 0:7a64fbb4069d | 881 | if (sn_mask.addr == 0) { |
screamer | 0:7a64fbb4069d | 882 | /* choose a safe subnet mask given the network class */ |
screamer | 0:7a64fbb4069d | 883 | u8_t first_octet = ip4_addr1(&sn_mask); |
screamer | 0:7a64fbb4069d | 884 | if (first_octet <= 127) { |
screamer | 0:7a64fbb4069d | 885 | sn_mask.addr = htonl(0xff000000); |
screamer | 0:7a64fbb4069d | 886 | } else if (first_octet >= 192) { |
screamer | 0:7a64fbb4069d | 887 | sn_mask.addr = htonl(0xffffff00); |
screamer | 0:7a64fbb4069d | 888 | } else { |
screamer | 0:7a64fbb4069d | 889 | sn_mask.addr = htonl(0xffff0000); |
screamer | 0:7a64fbb4069d | 890 | } |
screamer | 0:7a64fbb4069d | 891 | } |
screamer | 0:7a64fbb4069d | 892 | |
screamer | 0:7a64fbb4069d | 893 | ip_addr_set(&gw_addr, &dhcp->offered_gw_addr); |
screamer | 0:7a64fbb4069d | 894 | /* gateway address not given? */ |
screamer | 0:7a64fbb4069d | 895 | if (gw_addr.addr == 0) { |
screamer | 0:7a64fbb4069d | 896 | /* copy network address */ |
screamer | 0:7a64fbb4069d | 897 | gw_addr.addr = (dhcp->offered_ip_addr.addr & sn_mask.addr); |
screamer | 0:7a64fbb4069d | 898 | /* use first host address on network as gateway */ |
screamer | 0:7a64fbb4069d | 899 | gw_addr.addr |= htonl(0x00000001); |
screamer | 0:7a64fbb4069d | 900 | } |
screamer | 0:7a64fbb4069d | 901 | |
screamer | 0:7a64fbb4069d | 902 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_bind(): IP: 0x%08"X32_F"\n", dhcp->offered_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 903 | netif_set_ipaddr(netif, &dhcp->offered_ip_addr); |
screamer | 0:7a64fbb4069d | 904 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_bind(): SN: 0x%08"X32_F"\n", sn_mask.addr)); |
screamer | 0:7a64fbb4069d | 905 | netif_set_netmask(netif, &sn_mask); |
screamer | 0:7a64fbb4069d | 906 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_bind(): GW: 0x%08"X32_F"\n", gw_addr.addr)); |
screamer | 0:7a64fbb4069d | 907 | netif_set_gw(netif, &gw_addr); |
screamer | 0:7a64fbb4069d | 908 | /* bring the interface up */ |
screamer | 0:7a64fbb4069d | 909 | netif_set_up(netif); |
screamer | 0:7a64fbb4069d | 910 | /* netif is now bound to DHCP leased address */ |
screamer | 0:7a64fbb4069d | 911 | dhcp_set_state(dhcp, DHCP_BOUND); |
screamer | 0:7a64fbb4069d | 912 | } |
screamer | 0:7a64fbb4069d | 913 | |
screamer | 0:7a64fbb4069d | 914 | /** |
screamer | 0:7a64fbb4069d | 915 | * Renew an existing DHCP lease at the involved DHCP server. |
screamer | 0:7a64fbb4069d | 916 | * |
screamer | 0:7a64fbb4069d | 917 | * @param netif network interface which must renew its lease |
screamer | 0:7a64fbb4069d | 918 | */ |
screamer | 0:7a64fbb4069d | 919 | err_t |
screamer | 0:7a64fbb4069d | 920 | dhcp_renew(struct netif *netif) |
screamer | 0:7a64fbb4069d | 921 | { |
screamer | 0:7a64fbb4069d | 922 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 923 | err_t result; |
screamer | 0:7a64fbb4069d | 924 | u16_t msecs; |
screamer | 0:7a64fbb4069d | 925 | #if LWIP_NETIF_HOSTNAME |
screamer | 0:7a64fbb4069d | 926 | const char *p; |
screamer | 0:7a64fbb4069d | 927 | #endif /* LWIP_NETIF_HOSTNAME */ |
screamer | 0:7a64fbb4069d | 928 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_renew()\n")); |
screamer | 0:7a64fbb4069d | 929 | dhcp_set_state(dhcp, DHCP_RENEWING); |
screamer | 0:7a64fbb4069d | 930 | |
screamer | 0:7a64fbb4069d | 931 | /* create and initialize the DHCP message header */ |
screamer | 0:7a64fbb4069d | 932 | result = dhcp_create_request(netif); |
screamer | 0:7a64fbb4069d | 933 | if (result == ERR_OK) { |
screamer | 0:7a64fbb4069d | 934 | |
screamer | 0:7a64fbb4069d | 935 | dhcp_option(dhcp, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN); |
screamer | 0:7a64fbb4069d | 936 | dhcp_option_byte(dhcp, DHCP_REQUEST); |
screamer | 0:7a64fbb4069d | 937 | |
screamer | 0:7a64fbb4069d | 938 | dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); |
screamer | 0:7a64fbb4069d | 939 | dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif)); |
screamer | 0:7a64fbb4069d | 940 | |
screamer | 0:7a64fbb4069d | 941 | #if LWIP_NETIF_HOSTNAME |
screamer | 0:7a64fbb4069d | 942 | p = (const char*)netif->hostname; |
screamer | 0:7a64fbb4069d | 943 | if (p != NULL) { |
screamer | 0:7a64fbb4069d | 944 | dhcp_option(dhcp, DHCP_OPTION_HOSTNAME, strlen(p)); |
screamer | 0:7a64fbb4069d | 945 | while (*p) { |
screamer | 0:7a64fbb4069d | 946 | dhcp_option_byte(dhcp, *p++); |
screamer | 0:7a64fbb4069d | 947 | } |
screamer | 0:7a64fbb4069d | 948 | } |
screamer | 0:7a64fbb4069d | 949 | #endif /* LWIP_NETIF_HOSTNAME */ |
screamer | 0:7a64fbb4069d | 950 | |
screamer | 0:7a64fbb4069d | 951 | #if 0 |
screamer | 0:7a64fbb4069d | 952 | dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4); |
screamer | 0:7a64fbb4069d | 953 | dhcp_option_long(dhcp, ntohl(dhcp->offered_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 954 | #endif |
screamer | 0:7a64fbb4069d | 955 | |
screamer | 0:7a64fbb4069d | 956 | #if 0 |
screamer | 0:7a64fbb4069d | 957 | dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4); |
screamer | 0:7a64fbb4069d | 958 | dhcp_option_long(dhcp, ntohl(dhcp->server_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 959 | #endif |
screamer | 0:7a64fbb4069d | 960 | /* append DHCP message trailer */ |
screamer | 0:7a64fbb4069d | 961 | dhcp_option_trailer(dhcp); |
screamer | 0:7a64fbb4069d | 962 | |
screamer | 0:7a64fbb4069d | 963 | pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len); |
screamer | 0:7a64fbb4069d | 964 | |
screamer | 0:7a64fbb4069d | 965 | udp_connect(dhcp->pcb, &dhcp->server_ip_addr, DHCP_SERVER_PORT); |
screamer | 0:7a64fbb4069d | 966 | udp_sendto_if(dhcp->pcb, dhcp->p_out, &dhcp->server_ip_addr, DHCP_SERVER_PORT, netif); |
screamer | 0:7a64fbb4069d | 967 | dhcp_delete_request(netif); |
screamer | 0:7a64fbb4069d | 968 | |
screamer | 0:7a64fbb4069d | 969 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_renew: RENEWING\n")); |
screamer | 0:7a64fbb4069d | 970 | } else { |
screamer | 0:7a64fbb4069d | 971 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_renew: could not allocate DHCP request\n")); |
screamer | 0:7a64fbb4069d | 972 | } |
screamer | 0:7a64fbb4069d | 973 | dhcp->tries++; |
screamer | 0:7a64fbb4069d | 974 | /* back-off on retries, but to a maximum of 20 seconds */ |
screamer | 0:7a64fbb4069d | 975 | msecs = dhcp->tries < 10 ? dhcp->tries * 2000 : 20 * 1000; |
screamer | 0:7a64fbb4069d | 976 | dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS; |
screamer | 0:7a64fbb4069d | 977 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_renew(): set request timeout %"U16_F" msecs\n", msecs)); |
screamer | 0:7a64fbb4069d | 978 | return result; |
screamer | 0:7a64fbb4069d | 979 | } |
screamer | 0:7a64fbb4069d | 980 | |
screamer | 0:7a64fbb4069d | 981 | /** |
screamer | 0:7a64fbb4069d | 982 | * Rebind with a DHCP server for an existing DHCP lease. |
screamer | 0:7a64fbb4069d | 983 | * |
screamer | 0:7a64fbb4069d | 984 | * @param netif network interface which must rebind with a DHCP server |
screamer | 0:7a64fbb4069d | 985 | */ |
screamer | 0:7a64fbb4069d | 986 | static err_t |
screamer | 0:7a64fbb4069d | 987 | dhcp_rebind(struct netif *netif) |
screamer | 0:7a64fbb4069d | 988 | { |
screamer | 0:7a64fbb4069d | 989 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 990 | err_t result; |
screamer | 0:7a64fbb4069d | 991 | u16_t msecs; |
screamer | 0:7a64fbb4069d | 992 | #if LWIP_NETIF_HOSTNAME |
screamer | 0:7a64fbb4069d | 993 | const char *p; |
screamer | 0:7a64fbb4069d | 994 | #endif /* LWIP_NETIF_HOSTNAME */ |
screamer | 0:7a64fbb4069d | 995 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind()\n")); |
screamer | 0:7a64fbb4069d | 996 | dhcp_set_state(dhcp, DHCP_REBINDING); |
screamer | 0:7a64fbb4069d | 997 | |
screamer | 0:7a64fbb4069d | 998 | /* create and initialize the DHCP message header */ |
screamer | 0:7a64fbb4069d | 999 | result = dhcp_create_request(netif); |
screamer | 0:7a64fbb4069d | 1000 | if (result == ERR_OK) { |
screamer | 0:7a64fbb4069d | 1001 | |
screamer | 0:7a64fbb4069d | 1002 | dhcp_option(dhcp, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN); |
screamer | 0:7a64fbb4069d | 1003 | dhcp_option_byte(dhcp, DHCP_REQUEST); |
screamer | 0:7a64fbb4069d | 1004 | |
screamer | 0:7a64fbb4069d | 1005 | dhcp_option(dhcp, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); |
screamer | 0:7a64fbb4069d | 1006 | dhcp_option_short(dhcp, DHCP_MAX_MSG_LEN(netif)); |
screamer | 0:7a64fbb4069d | 1007 | |
screamer | 0:7a64fbb4069d | 1008 | #if LWIP_NETIF_HOSTNAME |
screamer | 0:7a64fbb4069d | 1009 | p = (const char*)netif->hostname; |
screamer | 0:7a64fbb4069d | 1010 | if (p != NULL) { |
screamer | 0:7a64fbb4069d | 1011 | dhcp_option(dhcp, DHCP_OPTION_HOSTNAME, strlen(p)); |
screamer | 0:7a64fbb4069d | 1012 | while (*p) { |
screamer | 0:7a64fbb4069d | 1013 | dhcp_option_byte(dhcp, *p++); |
screamer | 0:7a64fbb4069d | 1014 | } |
screamer | 0:7a64fbb4069d | 1015 | } |
screamer | 0:7a64fbb4069d | 1016 | #endif /* LWIP_NETIF_HOSTNAME */ |
screamer | 0:7a64fbb4069d | 1017 | |
screamer | 0:7a64fbb4069d | 1018 | #if 0 |
screamer | 0:7a64fbb4069d | 1019 | dhcp_option(dhcp, DHCP_OPTION_REQUESTED_IP, 4); |
screamer | 0:7a64fbb4069d | 1020 | dhcp_option_long(dhcp, ntohl(dhcp->offered_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 1021 | |
screamer | 0:7a64fbb4069d | 1022 | dhcp_option(dhcp, DHCP_OPTION_SERVER_ID, 4); |
screamer | 0:7a64fbb4069d | 1023 | dhcp_option_long(dhcp, ntohl(dhcp->server_ip_addr.addr)); |
screamer | 0:7a64fbb4069d | 1024 | #endif |
screamer | 0:7a64fbb4069d | 1025 | |
screamer | 0:7a64fbb4069d | 1026 | dhcp_option_trailer(dhcp); |
screamer | 0:7a64fbb4069d | 1027 | |
screamer | 0:7a64fbb4069d | 1028 | pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len); |
screamer | 0:7a64fbb4069d | 1029 | |
screamer | 0:7a64fbb4069d | 1030 | /* broadcast to server */ |
screamer | 0:7a64fbb4069d | 1031 | udp_connect(dhcp->pcb, IP_ADDR_ANY, DHCP_SERVER_PORT); |
screamer | 0:7a64fbb4069d | 1032 | udp_sendto_if(dhcp->pcb, dhcp->p_out, IP_ADDR_BROADCAST, DHCP_SERVER_PORT, netif); |
screamer | 0:7a64fbb4069d | 1033 | dhcp_delete_request(netif); |
screamer | 0:7a64fbb4069d | 1034 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind: REBINDING\n")); |
screamer | 0:7a64fbb4069d | 1035 | } else { |
screamer | 0:7a64fbb4069d | 1036 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_rebind: could not allocate DHCP request\n")); |
screamer | 0:7a64fbb4069d | 1037 | } |
screamer | 0:7a64fbb4069d | 1038 | dhcp->tries++; |
screamer | 0:7a64fbb4069d | 1039 | msecs = dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000; |
screamer | 0:7a64fbb4069d | 1040 | dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS; |
screamer | 0:7a64fbb4069d | 1041 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind(): set request timeout %"U16_F" msecs\n", msecs)); |
screamer | 0:7a64fbb4069d | 1042 | return result; |
screamer | 0:7a64fbb4069d | 1043 | } |
screamer | 0:7a64fbb4069d | 1044 | |
screamer | 0:7a64fbb4069d | 1045 | /** |
screamer | 0:7a64fbb4069d | 1046 | * Release a DHCP lease. |
screamer | 0:7a64fbb4069d | 1047 | * |
screamer | 0:7a64fbb4069d | 1048 | * @param netif network interface which must release its lease |
screamer | 0:7a64fbb4069d | 1049 | */ |
screamer | 0:7a64fbb4069d | 1050 | err_t |
screamer | 0:7a64fbb4069d | 1051 | dhcp_release(struct netif *netif) |
screamer | 0:7a64fbb4069d | 1052 | { |
screamer | 0:7a64fbb4069d | 1053 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 1054 | err_t result; |
screamer | 0:7a64fbb4069d | 1055 | u16_t msecs; |
screamer | 0:7a64fbb4069d | 1056 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_release()\n")); |
screamer | 0:7a64fbb4069d | 1057 | |
screamer | 0:7a64fbb4069d | 1058 | /* idle DHCP client */ |
screamer | 0:7a64fbb4069d | 1059 | dhcp_set_state(dhcp, DHCP_OFF); |
screamer | 0:7a64fbb4069d | 1060 | /* clean old DHCP offer */ |
screamer | 0:7a64fbb4069d | 1061 | dhcp->server_ip_addr.addr = 0; |
screamer | 0:7a64fbb4069d | 1062 | dhcp->offered_ip_addr.addr = dhcp->offered_sn_mask.addr = 0; |
screamer | 0:7a64fbb4069d | 1063 | dhcp->offered_gw_addr.addr = dhcp->offered_bc_addr.addr = 0; |
screamer | 0:7a64fbb4069d | 1064 | dhcp->offered_t0_lease = dhcp->offered_t1_renew = dhcp->offered_t2_rebind = 0; |
screamer | 0:7a64fbb4069d | 1065 | dhcp->dns_count = 0; |
screamer | 0:7a64fbb4069d | 1066 | |
screamer | 0:7a64fbb4069d | 1067 | /* create and initialize the DHCP message header */ |
screamer | 0:7a64fbb4069d | 1068 | result = dhcp_create_request(netif); |
screamer | 0:7a64fbb4069d | 1069 | if (result == ERR_OK) { |
screamer | 0:7a64fbb4069d | 1070 | dhcp_option(dhcp, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN); |
screamer | 0:7a64fbb4069d | 1071 | dhcp_option_byte(dhcp, DHCP_RELEASE); |
screamer | 0:7a64fbb4069d | 1072 | |
screamer | 0:7a64fbb4069d | 1073 | dhcp_option_trailer(dhcp); |
screamer | 0:7a64fbb4069d | 1074 | |
screamer | 0:7a64fbb4069d | 1075 | pbuf_realloc(dhcp->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + dhcp->options_out_len); |
screamer | 0:7a64fbb4069d | 1076 | |
screamer | 0:7a64fbb4069d | 1077 | udp_connect(dhcp->pcb, &dhcp->server_ip_addr, DHCP_SERVER_PORT); |
screamer | 0:7a64fbb4069d | 1078 | udp_sendto_if(dhcp->pcb, dhcp->p_out, &dhcp->server_ip_addr, DHCP_SERVER_PORT, netif); |
screamer | 0:7a64fbb4069d | 1079 | dhcp_delete_request(netif); |
screamer | 0:7a64fbb4069d | 1080 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_release: RELEASED, DHCP_OFF\n")); |
screamer | 0:7a64fbb4069d | 1081 | } else { |
screamer | 0:7a64fbb4069d | 1082 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_release: could not allocate DHCP request\n")); |
screamer | 0:7a64fbb4069d | 1083 | } |
screamer | 0:7a64fbb4069d | 1084 | dhcp->tries++; |
screamer | 0:7a64fbb4069d | 1085 | msecs = dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000; |
screamer | 0:7a64fbb4069d | 1086 | dhcp->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS; |
screamer | 0:7a64fbb4069d | 1087 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_release(): set request timeout %"U16_F" msecs\n", msecs)); |
screamer | 0:7a64fbb4069d | 1088 | /* bring the interface down */ |
screamer | 0:7a64fbb4069d | 1089 | netif_set_down(netif); |
screamer | 0:7a64fbb4069d | 1090 | /* remove IP address from interface */ |
screamer | 0:7a64fbb4069d | 1091 | netif_set_ipaddr(netif, IP_ADDR_ANY); |
screamer | 0:7a64fbb4069d | 1092 | netif_set_gw(netif, IP_ADDR_ANY); |
screamer | 0:7a64fbb4069d | 1093 | netif_set_netmask(netif, IP_ADDR_ANY); |
screamer | 0:7a64fbb4069d | 1094 | |
screamer | 0:7a64fbb4069d | 1095 | /* TODO: netif_down(netif); */ |
screamer | 0:7a64fbb4069d | 1096 | return result; |
screamer | 0:7a64fbb4069d | 1097 | } |
screamer | 0:7a64fbb4069d | 1098 | |
screamer | 0:7a64fbb4069d | 1099 | /** |
screamer | 0:7a64fbb4069d | 1100 | * Remove the DHCP client from the interface. |
screamer | 0:7a64fbb4069d | 1101 | * |
screamer | 0:7a64fbb4069d | 1102 | * @param netif The network interface to stop DHCP on |
screamer | 0:7a64fbb4069d | 1103 | */ |
screamer | 0:7a64fbb4069d | 1104 | void |
screamer | 0:7a64fbb4069d | 1105 | dhcp_stop(struct netif *netif) |
screamer | 0:7a64fbb4069d | 1106 | { |
screamer | 0:7a64fbb4069d | 1107 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 1108 | LWIP_ERROR("dhcp_stop: netif != NULL", (netif != NULL), return;); |
screamer | 0:7a64fbb4069d | 1109 | /* Remove the flag that says this netif is handled by DHCP. */ |
screamer | 0:7a64fbb4069d | 1110 | netif->flags &= ~NETIF_FLAG_DHCP; |
screamer | 0:7a64fbb4069d | 1111 | |
screamer | 0:7a64fbb4069d | 1112 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_stop()\n")); |
screamer | 0:7a64fbb4069d | 1113 | /* netif is DHCP configured? */ |
screamer | 0:7a64fbb4069d | 1114 | if (dhcp != NULL) { |
screamer | 0:7a64fbb4069d | 1115 | if (dhcp->pcb != NULL) { |
screamer | 0:7a64fbb4069d | 1116 | udp_remove(dhcp->pcb); |
screamer | 0:7a64fbb4069d | 1117 | dhcp->pcb = NULL; |
screamer | 0:7a64fbb4069d | 1118 | } |
screamer | 0:7a64fbb4069d | 1119 | if (dhcp->p != NULL) { |
screamer | 0:7a64fbb4069d | 1120 | pbuf_free(dhcp->p); |
screamer | 0:7a64fbb4069d | 1121 | dhcp->p = NULL; |
screamer | 0:7a64fbb4069d | 1122 | } |
screamer | 0:7a64fbb4069d | 1123 | /* free unfolded reply */ |
screamer | 0:7a64fbb4069d | 1124 | dhcp_free_reply(dhcp); |
screamer | 0:7a64fbb4069d | 1125 | mem_free((void *)dhcp); |
screamer | 0:7a64fbb4069d | 1126 | netif->dhcp = NULL; |
screamer | 0:7a64fbb4069d | 1127 | } |
screamer | 0:7a64fbb4069d | 1128 | } |
screamer | 0:7a64fbb4069d | 1129 | |
screamer | 0:7a64fbb4069d | 1130 | /* |
screamer | 0:7a64fbb4069d | 1131 | * Set the DHCP state of a DHCP client. |
screamer | 0:7a64fbb4069d | 1132 | * |
screamer | 0:7a64fbb4069d | 1133 | * If the state changed, reset the number of tries. |
screamer | 0:7a64fbb4069d | 1134 | * |
screamer | 0:7a64fbb4069d | 1135 | * TODO: we might also want to reset the timeout here? |
screamer | 0:7a64fbb4069d | 1136 | */ |
screamer | 0:7a64fbb4069d | 1137 | static void |
screamer | 0:7a64fbb4069d | 1138 | dhcp_set_state(struct dhcp *dhcp, u8_t new_state) |
screamer | 0:7a64fbb4069d | 1139 | { |
screamer | 0:7a64fbb4069d | 1140 | if (new_state != dhcp->state) { |
screamer | 0:7a64fbb4069d | 1141 | dhcp->state = new_state; |
screamer | 0:7a64fbb4069d | 1142 | dhcp->tries = 0; |
screamer | 0:7a64fbb4069d | 1143 | } |
screamer | 0:7a64fbb4069d | 1144 | } |
screamer | 0:7a64fbb4069d | 1145 | |
screamer | 0:7a64fbb4069d | 1146 | /* |
screamer | 0:7a64fbb4069d | 1147 | * Concatenate an option type and length field to the outgoing |
screamer | 0:7a64fbb4069d | 1148 | * DHCP message. |
screamer | 0:7a64fbb4069d | 1149 | * |
screamer | 0:7a64fbb4069d | 1150 | */ |
screamer | 0:7a64fbb4069d | 1151 | static void |
screamer | 0:7a64fbb4069d | 1152 | dhcp_option(struct dhcp *dhcp, u8_t option_type, u8_t option_len) |
screamer | 0:7a64fbb4069d | 1153 | { |
screamer | 0:7a64fbb4069d | 1154 | LWIP_ASSERT("dhcp_option: dhcp->options_out_len + 2 + option_len <= DHCP_OPTIONS_LEN", dhcp->options_out_len + 2U + option_len <= DHCP_OPTIONS_LEN); |
screamer | 0:7a64fbb4069d | 1155 | dhcp->msg_out->options[dhcp->options_out_len++] = option_type; |
screamer | 0:7a64fbb4069d | 1156 | dhcp->msg_out->options[dhcp->options_out_len++] = option_len; |
screamer | 0:7a64fbb4069d | 1157 | } |
screamer | 0:7a64fbb4069d | 1158 | /* |
screamer | 0:7a64fbb4069d | 1159 | * Concatenate a single byte to the outgoing DHCP message. |
screamer | 0:7a64fbb4069d | 1160 | * |
screamer | 0:7a64fbb4069d | 1161 | */ |
screamer | 0:7a64fbb4069d | 1162 | static void |
screamer | 0:7a64fbb4069d | 1163 | dhcp_option_byte(struct dhcp *dhcp, u8_t value) |
screamer | 0:7a64fbb4069d | 1164 | { |
screamer | 0:7a64fbb4069d | 1165 | LWIP_ASSERT("dhcp_option_byte: dhcp->options_out_len < DHCP_OPTIONS_LEN", dhcp->options_out_len < DHCP_OPTIONS_LEN); |
screamer | 0:7a64fbb4069d | 1166 | dhcp->msg_out->options[dhcp->options_out_len++] = value; |
screamer | 0:7a64fbb4069d | 1167 | } |
screamer | 0:7a64fbb4069d | 1168 | |
screamer | 0:7a64fbb4069d | 1169 | static void |
screamer | 0:7a64fbb4069d | 1170 | dhcp_option_short(struct dhcp *dhcp, u16_t value) |
screamer | 0:7a64fbb4069d | 1171 | { |
screamer | 0:7a64fbb4069d | 1172 | LWIP_ASSERT("dhcp_option_short: dhcp->options_out_len + 2 <= DHCP_OPTIONS_LEN", dhcp->options_out_len + 2U <= DHCP_OPTIONS_LEN); |
screamer | 0:7a64fbb4069d | 1173 | dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0xff00U) >> 8); |
screamer | 0:7a64fbb4069d | 1174 | dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t) (value & 0x00ffU); |
screamer | 0:7a64fbb4069d | 1175 | } |
screamer | 0:7a64fbb4069d | 1176 | |
screamer | 0:7a64fbb4069d | 1177 | static void |
screamer | 0:7a64fbb4069d | 1178 | dhcp_option_long(struct dhcp *dhcp, u32_t value) |
screamer | 0:7a64fbb4069d | 1179 | { |
screamer | 0:7a64fbb4069d | 1180 | LWIP_ASSERT("dhcp_option_long: dhcp->options_out_len + 4 <= DHCP_OPTIONS_LEN", dhcp->options_out_len + 4U <= DHCP_OPTIONS_LEN); |
screamer | 0:7a64fbb4069d | 1181 | dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0xff000000UL) >> 24); |
screamer | 0:7a64fbb4069d | 1182 | dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0x00ff0000UL) >> 16); |
screamer | 0:7a64fbb4069d | 1183 | dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0x0000ff00UL) >> 8); |
screamer | 0:7a64fbb4069d | 1184 | dhcp->msg_out->options[dhcp->options_out_len++] = (u8_t)((value & 0x000000ffUL)); |
screamer | 0:7a64fbb4069d | 1185 | } |
screamer | 0:7a64fbb4069d | 1186 | |
screamer | 0:7a64fbb4069d | 1187 | /** |
screamer | 0:7a64fbb4069d | 1188 | * Extract the DHCP message and the DHCP options. |
screamer | 0:7a64fbb4069d | 1189 | * |
screamer | 0:7a64fbb4069d | 1190 | * Extract the DHCP message and the DHCP options, each into a contiguous |
screamer | 0:7a64fbb4069d | 1191 | * piece of memory. As a DHCP message is variable sized by its options, |
screamer | 0:7a64fbb4069d | 1192 | * and also allows overriding some fields for options, the easy approach |
screamer | 0:7a64fbb4069d | 1193 | * is to first unfold the options into a conitguous piece of memory, and |
screamer | 0:7a64fbb4069d | 1194 | * use that further on. |
screamer | 0:7a64fbb4069d | 1195 | * |
screamer | 0:7a64fbb4069d | 1196 | */ |
screamer | 0:7a64fbb4069d | 1197 | static err_t |
screamer | 0:7a64fbb4069d | 1198 | dhcp_unfold_reply(struct dhcp *dhcp) |
screamer | 0:7a64fbb4069d | 1199 | { |
screamer | 0:7a64fbb4069d | 1200 | u16_t ret; |
screamer | 0:7a64fbb4069d | 1201 | LWIP_ERROR("dhcp != NULL", (dhcp != NULL), return ERR_ARG;); |
screamer | 0:7a64fbb4069d | 1202 | LWIP_ERROR("dhcp->p != NULL", (dhcp->p != NULL), return ERR_VAL;); |
screamer | 0:7a64fbb4069d | 1203 | /* free any left-overs from previous unfolds */ |
screamer | 0:7a64fbb4069d | 1204 | dhcp_free_reply(dhcp); |
screamer | 0:7a64fbb4069d | 1205 | /* options present? */ |
screamer | 0:7a64fbb4069d | 1206 | if (dhcp->p->tot_len > (sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN)) { |
screamer | 0:7a64fbb4069d | 1207 | dhcp->options_in_len = dhcp->p->tot_len - (sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN); |
screamer | 0:7a64fbb4069d | 1208 | dhcp->options_in = (struct dhcp_msg *)mem_malloc(dhcp->options_in_len); // static_cast<struct dhcp_msg *>(x) |
screamer | 0:7a64fbb4069d | 1209 | if (dhcp->options_in == NULL) { |
screamer | 0:7a64fbb4069d | 1210 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_unfold_reply(): could not allocate dhcp->options\n")); |
screamer | 0:7a64fbb4069d | 1211 | return ERR_MEM; |
screamer | 0:7a64fbb4069d | 1212 | } |
screamer | 0:7a64fbb4069d | 1213 | } |
screamer | 0:7a64fbb4069d | 1214 | dhcp->msg_in = (struct dhcp_msg *)mem_malloc(sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN); // static_cast<struct dhcp_msg *>(x) |
screamer | 0:7a64fbb4069d | 1215 | if (dhcp->msg_in == NULL) { |
screamer | 0:7a64fbb4069d | 1216 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_unfold_reply(): could not allocate dhcp->msg_in\n")); |
screamer | 0:7a64fbb4069d | 1217 | mem_free((void *)dhcp->options_in); |
screamer | 0:7a64fbb4069d | 1218 | dhcp->options_in = NULL; |
screamer | 0:7a64fbb4069d | 1219 | return ERR_MEM; |
screamer | 0:7a64fbb4069d | 1220 | } |
screamer | 0:7a64fbb4069d | 1221 | |
screamer | 0:7a64fbb4069d | 1222 | /** copy the DHCP message without options */ |
screamer | 0:7a64fbb4069d | 1223 | ret = pbuf_copy_partial(dhcp->p, dhcp->msg_in, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN, 0); |
screamer | 0:7a64fbb4069d | 1224 | LWIP_ASSERT("ret == sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN", ret == sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN); |
screamer | 0:7a64fbb4069d | 1225 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_unfold_reply(): copied %"U16_F" bytes into dhcp->msg_in[]\n", |
screamer | 0:7a64fbb4069d | 1226 | sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN)); |
screamer | 0:7a64fbb4069d | 1227 | |
screamer | 0:7a64fbb4069d | 1228 | if (dhcp->options_in != NULL) { |
screamer | 0:7a64fbb4069d | 1229 | /** copy the DHCP options */ |
screamer | 0:7a64fbb4069d | 1230 | ret = pbuf_copy_partial(dhcp->p, dhcp->options_in, dhcp->options_in_len, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN); |
screamer | 0:7a64fbb4069d | 1231 | LWIP_ASSERT("ret == dhcp->options_in_len", ret == dhcp->options_in_len); |
screamer | 0:7a64fbb4069d | 1232 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_unfold_reply(): copied %"U16_F" bytes to dhcp->options_in[]\n", |
screamer | 0:7a64fbb4069d | 1233 | dhcp->options_in_len)); |
screamer | 0:7a64fbb4069d | 1234 | } |
screamer | 0:7a64fbb4069d | 1235 | LWIP_UNUSED_ARG(ret); |
screamer | 0:7a64fbb4069d | 1236 | return ERR_OK; |
screamer | 0:7a64fbb4069d | 1237 | } |
screamer | 0:7a64fbb4069d | 1238 | |
screamer | 0:7a64fbb4069d | 1239 | /** |
screamer | 0:7a64fbb4069d | 1240 | * Free the incoming DHCP message including contiguous copy of |
screamer | 0:7a64fbb4069d | 1241 | * its DHCP options. |
screamer | 0:7a64fbb4069d | 1242 | * |
screamer | 0:7a64fbb4069d | 1243 | */ |
screamer | 0:7a64fbb4069d | 1244 | static void dhcp_free_reply(struct dhcp *dhcp) |
screamer | 0:7a64fbb4069d | 1245 | { |
screamer | 0:7a64fbb4069d | 1246 | if (dhcp->msg_in != NULL) { |
screamer | 0:7a64fbb4069d | 1247 | mem_free((void *)dhcp->msg_in); |
screamer | 0:7a64fbb4069d | 1248 | dhcp->msg_in = NULL; |
screamer | 0:7a64fbb4069d | 1249 | } |
screamer | 0:7a64fbb4069d | 1250 | if (dhcp->options_in) { |
screamer | 0:7a64fbb4069d | 1251 | mem_free((void *)dhcp->options_in); |
screamer | 0:7a64fbb4069d | 1252 | dhcp->options_in = NULL; |
screamer | 0:7a64fbb4069d | 1253 | dhcp->options_in_len = 0; |
screamer | 0:7a64fbb4069d | 1254 | } |
screamer | 0:7a64fbb4069d | 1255 | LWIP_DEBUGF(DHCP_DEBUG, ("dhcp_free_reply(): free'd\n")); |
screamer | 0:7a64fbb4069d | 1256 | } |
screamer | 0:7a64fbb4069d | 1257 | |
screamer | 0:7a64fbb4069d | 1258 | |
screamer | 0:7a64fbb4069d | 1259 | /** |
screamer | 0:7a64fbb4069d | 1260 | * If an incoming DHCP message is in response to us, then trigger the state machine |
screamer | 0:7a64fbb4069d | 1261 | */ |
screamer | 0:7a64fbb4069d | 1262 | static void dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct ip_addr *addr, u16_t port) |
screamer | 0:7a64fbb4069d | 1263 | { |
screamer | 0:7a64fbb4069d | 1264 | struct netif *netif = (struct netif *)arg; |
screamer | 0:7a64fbb4069d | 1265 | struct dhcp *dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 1266 | struct dhcp_msg *reply_msg = (struct dhcp_msg *)p->payload; |
screamer | 0:7a64fbb4069d | 1267 | u8_t *options_ptr; |
screamer | 0:7a64fbb4069d | 1268 | u8_t msg_type; |
screamer | 0:7a64fbb4069d | 1269 | u8_t i; |
screamer | 0:7a64fbb4069d | 1270 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 3, ("dhcp_recv(pbuf = %p) from DHCP server %"U16_F".%"U16_F".%"U16_F".%"U16_F" port %"U16_F"\n", (void*)p, |
screamer | 0:7a64fbb4069d | 1271 | (u16_t)(ntohl(addr->addr) >> 24 & 0xff), (u16_t)(ntohl(addr->addr) >> 16 & 0xff), |
screamer | 0:7a64fbb4069d | 1272 | (u16_t)(ntohl(addr->addr) >> 8 & 0xff), (u16_t)(ntohl(addr->addr) & 0xff), port)); |
screamer | 0:7a64fbb4069d | 1273 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("pbuf->len = %"U16_F"\n", p->len)); |
screamer | 0:7a64fbb4069d | 1274 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("pbuf->tot_len = %"U16_F"\n", p->tot_len)); |
screamer | 0:7a64fbb4069d | 1275 | /* prevent warnings about unused arguments */ |
screamer | 0:7a64fbb4069d | 1276 | LWIP_UNUSED_ARG(pcb); |
screamer | 0:7a64fbb4069d | 1277 | LWIP_UNUSED_ARG(addr); |
screamer | 0:7a64fbb4069d | 1278 | LWIP_UNUSED_ARG(port); |
screamer | 0:7a64fbb4069d | 1279 | dhcp->p = p; |
screamer | 0:7a64fbb4069d | 1280 | /* TODO: check packet length before reading them */ |
screamer | 0:7a64fbb4069d | 1281 | if (reply_msg->op != DHCP_BOOTREPLY) { |
screamer | 0:7a64fbb4069d | 1282 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 1, ("not a DHCP reply message, but type %"U16_F"\n", (u16_t)reply_msg->op)); |
screamer | 0:7a64fbb4069d | 1283 | goto free_pbuf_and_return; |
screamer | 0:7a64fbb4069d | 1284 | } |
screamer | 0:7a64fbb4069d | 1285 | /* iterate through hardware address and match against DHCP message */ |
screamer | 0:7a64fbb4069d | 1286 | for (i = 0; i < netif->hwaddr_len; i++) { |
screamer | 0:7a64fbb4069d | 1287 | if (netif->hwaddr[i] != reply_msg->chaddr[i]) { |
screamer | 0:7a64fbb4069d | 1288 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("netif->hwaddr[%"U16_F"]==%02"X16_F" != reply_msg->chaddr[%"U16_F"]==%02"X16_F"\n", |
screamer | 0:7a64fbb4069d | 1289 | (u16_t)i, (u16_t)netif->hwaddr[i], (u16_t)i, (u16_t)reply_msg->chaddr[i])); |
screamer | 0:7a64fbb4069d | 1290 | goto free_pbuf_and_return; |
screamer | 0:7a64fbb4069d | 1291 | } |
screamer | 0:7a64fbb4069d | 1292 | } |
screamer | 0:7a64fbb4069d | 1293 | /* match transaction ID against what we expected */ |
screamer | 0:7a64fbb4069d | 1294 | if (ntohl(reply_msg->xid) != dhcp->xid) { |
screamer | 0:7a64fbb4069d | 1295 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("transaction id mismatch reply_msg->xid(%"X32_F")!=dhcp->xid(%"X32_F")\n",ntohl(reply_msg->xid),dhcp->xid)); |
screamer | 0:7a64fbb4069d | 1296 | goto free_pbuf_and_return; |
screamer | 0:7a64fbb4069d | 1297 | } |
screamer | 0:7a64fbb4069d | 1298 | /* option fields could be unfold? */ |
screamer | 0:7a64fbb4069d | 1299 | if (dhcp_unfold_reply(dhcp) != ERR_OK) { |
screamer | 0:7a64fbb4069d | 1300 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("problem unfolding DHCP message - too short on memory?\n")); |
screamer | 0:7a64fbb4069d | 1301 | goto free_pbuf_and_return; |
screamer | 0:7a64fbb4069d | 1302 | } |
screamer | 0:7a64fbb4069d | 1303 | |
screamer | 0:7a64fbb4069d | 1304 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("searching DHCP_OPTION_MESSAGE_TYPE\n")); |
screamer | 0:7a64fbb4069d | 1305 | /* obtain pointer to DHCP message type */ |
screamer | 0:7a64fbb4069d | 1306 | options_ptr = dhcp_get_option_ptr(dhcp, DHCP_OPTION_MESSAGE_TYPE); |
screamer | 0:7a64fbb4069d | 1307 | if (options_ptr == NULL) { |
screamer | 0:7a64fbb4069d | 1308 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 1, ("DHCP_OPTION_MESSAGE_TYPE option not found\n")); |
screamer | 0:7a64fbb4069d | 1309 | goto free_pbuf_and_return; |
screamer | 0:7a64fbb4069d | 1310 | } |
screamer | 0:7a64fbb4069d | 1311 | |
screamer | 0:7a64fbb4069d | 1312 | /* read DHCP message type */ |
screamer | 0:7a64fbb4069d | 1313 | msg_type = dhcp_get_option_byte(options_ptr + 2); |
screamer | 0:7a64fbb4069d | 1314 | /* message type is DHCP ACK? */ |
screamer | 0:7a64fbb4069d | 1315 | if (msg_type == DHCP_ACK) { |
screamer | 0:7a64fbb4069d | 1316 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 1, ("DHCP_ACK received\n")); |
screamer | 0:7a64fbb4069d | 1317 | /* in requesting state? */ |
screamer | 0:7a64fbb4069d | 1318 | if (dhcp->state == DHCP_REQUESTING) { |
screamer | 0:7a64fbb4069d | 1319 | dhcp_handle_ack(netif); |
screamer | 0:7a64fbb4069d | 1320 | dhcp->request_timeout = 0; |
screamer | 0:7a64fbb4069d | 1321 | #if DHCP_DOES_ARP_CHECK |
screamer | 0:7a64fbb4069d | 1322 | /* check if the acknowledged lease address is already in use */ |
screamer | 0:7a64fbb4069d | 1323 | dhcp_check(netif); |
screamer | 0:7a64fbb4069d | 1324 | #else |
screamer | 0:7a64fbb4069d | 1325 | /* bind interface to the acknowledged lease address */ |
screamer | 0:7a64fbb4069d | 1326 | dhcp_bind(netif); |
screamer | 0:7a64fbb4069d | 1327 | #endif |
screamer | 0:7a64fbb4069d | 1328 | } |
screamer | 0:7a64fbb4069d | 1329 | /* already bound to the given lease address? */ |
screamer | 0:7a64fbb4069d | 1330 | else if ((dhcp->state == DHCP_REBOOTING) || (dhcp->state == DHCP_REBINDING) || (dhcp->state == DHCP_RENEWING)) { |
screamer | 0:7a64fbb4069d | 1331 | dhcp->request_timeout = 0; |
screamer | 0:7a64fbb4069d | 1332 | dhcp_bind(netif); |
screamer | 0:7a64fbb4069d | 1333 | } |
screamer | 0:7a64fbb4069d | 1334 | } |
screamer | 0:7a64fbb4069d | 1335 | /* received a DHCP_NAK in appropriate state? */ |
screamer | 0:7a64fbb4069d | 1336 | else if ((msg_type == DHCP_NAK) && |
screamer | 0:7a64fbb4069d | 1337 | ((dhcp->state == DHCP_REBOOTING) || (dhcp->state == DHCP_REQUESTING) || |
screamer | 0:7a64fbb4069d | 1338 | (dhcp->state == DHCP_REBINDING) || (dhcp->state == DHCP_RENEWING ))) { |
screamer | 0:7a64fbb4069d | 1339 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 1, ("DHCP_NAK received\n")); |
screamer | 0:7a64fbb4069d | 1340 | dhcp->request_timeout = 0; |
screamer | 0:7a64fbb4069d | 1341 | dhcp_handle_nak(netif); |
screamer | 0:7a64fbb4069d | 1342 | } |
screamer | 0:7a64fbb4069d | 1343 | /* received a DHCP_OFFER in DHCP_SELECTING state? */ |
screamer | 0:7a64fbb4069d | 1344 | else if ((msg_type == DHCP_OFFER) && (dhcp->state == DHCP_SELECTING)) { |
screamer | 0:7a64fbb4069d | 1345 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 1, ("DHCP_OFFER received in DHCP_SELECTING state\n")); |
screamer | 0:7a64fbb4069d | 1346 | dhcp->request_timeout = 0; |
screamer | 0:7a64fbb4069d | 1347 | /* remember offered lease */ |
screamer | 0:7a64fbb4069d | 1348 | dhcp_handle_offer(netif); |
screamer | 0:7a64fbb4069d | 1349 | } |
screamer | 0:7a64fbb4069d | 1350 | free_pbuf_and_return: |
screamer | 0:7a64fbb4069d | 1351 | dhcp_free_reply(dhcp); |
screamer | 0:7a64fbb4069d | 1352 | pbuf_free(p); |
screamer | 0:7a64fbb4069d | 1353 | dhcp->p = NULL; |
screamer | 0:7a64fbb4069d | 1354 | } |
screamer | 0:7a64fbb4069d | 1355 | |
screamer | 0:7a64fbb4069d | 1356 | /** |
screamer | 0:7a64fbb4069d | 1357 | * Create a DHCP request, fill in common headers |
screamer | 0:7a64fbb4069d | 1358 | * |
screamer | 0:7a64fbb4069d | 1359 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 1360 | */ |
screamer | 0:7a64fbb4069d | 1361 | static err_t |
screamer | 0:7a64fbb4069d | 1362 | dhcp_create_request(struct netif *netif) |
screamer | 0:7a64fbb4069d | 1363 | { |
screamer | 0:7a64fbb4069d | 1364 | struct dhcp *dhcp; |
screamer | 0:7a64fbb4069d | 1365 | u16_t i; |
screamer | 0:7a64fbb4069d | 1366 | #ifndef DHCP_GLOBAL_XID |
screamer | 0:7a64fbb4069d | 1367 | /** default global transaction identifier starting value (easy to match |
screamer | 0:7a64fbb4069d | 1368 | * with a packet analyser). We simply increment for each new request. |
screamer | 0:7a64fbb4069d | 1369 | * Predefine DHCP_GLOBAL_XID to a better value or a function call to generate one |
screamer | 0:7a64fbb4069d | 1370 | * at runtime, any supporting function prototypes can be defined in DHCP_GLOBAL_XID_HEADER */ |
screamer | 0:7a64fbb4069d | 1371 | static u32_t xid = 0xABCD0000; |
screamer | 0:7a64fbb4069d | 1372 | #else |
screamer | 0:7a64fbb4069d | 1373 | static u32_t xid; |
screamer | 0:7a64fbb4069d | 1374 | static u8_t xid_initialised = 0; |
screamer | 0:7a64fbb4069d | 1375 | if (!xid_initialised) { |
screamer | 0:7a64fbb4069d | 1376 | xid = DHCP_GLOBAL_XID; |
screamer | 0:7a64fbb4069d | 1377 | xid_initialised = !xid_initialised; |
screamer | 0:7a64fbb4069d | 1378 | } |
screamer | 0:7a64fbb4069d | 1379 | #endif |
screamer | 0:7a64fbb4069d | 1380 | LWIP_ERROR("dhcp_create_request: netif != NULL", (netif != NULL), return ERR_ARG;); |
screamer | 0:7a64fbb4069d | 1381 | dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 1382 | LWIP_ERROR("dhcp_create_request: dhcp != NULL", (dhcp != NULL), return ERR_VAL;); |
screamer | 0:7a64fbb4069d | 1383 | LWIP_ASSERT("dhcp_create_request: dhcp->p_out == NULL", dhcp->p_out == NULL); |
screamer | 0:7a64fbb4069d | 1384 | LWIP_ASSERT("dhcp_create_request: dhcp->msg_out == NULL", dhcp->msg_out == NULL); |
screamer | 0:7a64fbb4069d | 1385 | dhcp->p_out = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp_msg), PBUF_RAM); |
screamer | 0:7a64fbb4069d | 1386 | if (dhcp->p_out == NULL) { |
screamer | 0:7a64fbb4069d | 1387 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("dhcp_create_request(): could not allocate pbuf\n")); |
screamer | 0:7a64fbb4069d | 1388 | return ERR_MEM; |
screamer | 0:7a64fbb4069d | 1389 | } |
screamer | 0:7a64fbb4069d | 1390 | LWIP_ASSERT("dhcp_create_request: check that first pbuf can hold struct dhcp_msg", |
screamer | 0:7a64fbb4069d | 1391 | (dhcp->p_out->len >= sizeof(struct dhcp_msg))); |
screamer | 0:7a64fbb4069d | 1392 | |
screamer | 0:7a64fbb4069d | 1393 | /* give unique transaction identifier to this request */ |
screamer | 0:7a64fbb4069d | 1394 | dhcp->xid = xid++; |
screamer | 0:7a64fbb4069d | 1395 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("transaction id xid++(%"X32_F") dhcp->xid(%"U32_F")\n",xid,dhcp->xid)); |
screamer | 0:7a64fbb4069d | 1396 | |
screamer | 0:7a64fbb4069d | 1397 | dhcp->msg_out = (struct dhcp_msg *)dhcp->p_out->payload; |
screamer | 0:7a64fbb4069d | 1398 | |
screamer | 0:7a64fbb4069d | 1399 | dhcp->msg_out->op = DHCP_BOOTREQUEST; |
screamer | 0:7a64fbb4069d | 1400 | /* TODO: make link layer independent */ |
screamer | 0:7a64fbb4069d | 1401 | dhcp->msg_out->htype = DHCP_HTYPE_ETH; |
screamer | 0:7a64fbb4069d | 1402 | /* TODO: make link layer independent */ |
screamer | 0:7a64fbb4069d | 1403 | dhcp->msg_out->hlen = DHCP_HLEN_ETH; |
screamer | 0:7a64fbb4069d | 1404 | dhcp->msg_out->hops = 0; |
screamer | 0:7a64fbb4069d | 1405 | dhcp->msg_out->xid = htonl(dhcp->xid); |
screamer | 0:7a64fbb4069d | 1406 | dhcp->msg_out->secs = 0; |
screamer | 0:7a64fbb4069d | 1407 | dhcp->msg_out->flags = 0; |
screamer | 0:7a64fbb4069d | 1408 | dhcp->msg_out->ciaddr.addr = netif->ip_addr.addr; |
screamer | 0:7a64fbb4069d | 1409 | dhcp->msg_out->yiaddr.addr = 0; |
screamer | 0:7a64fbb4069d | 1410 | dhcp->msg_out->siaddr.addr = 0; |
screamer | 0:7a64fbb4069d | 1411 | dhcp->msg_out->giaddr.addr = 0; |
screamer | 0:7a64fbb4069d | 1412 | for (i = 0; i < DHCP_CHADDR_LEN; i++) { |
screamer | 0:7a64fbb4069d | 1413 | /* copy netif hardware address, pad with zeroes */ |
screamer | 0:7a64fbb4069d | 1414 | dhcp->msg_out->chaddr[i] = (i < netif->hwaddr_len) ? netif->hwaddr[i] : 0/* pad byte*/; |
screamer | 0:7a64fbb4069d | 1415 | } |
screamer | 0:7a64fbb4069d | 1416 | for (i = 0; i < DHCP_SNAME_LEN; i++) { |
screamer | 0:7a64fbb4069d | 1417 | dhcp->msg_out->sname[i] = 0; |
screamer | 0:7a64fbb4069d | 1418 | } |
screamer | 0:7a64fbb4069d | 1419 | for (i = 0; i < DHCP_FILE_LEN; i++) { |
screamer | 0:7a64fbb4069d | 1420 | dhcp->msg_out->file[i] = 0; |
screamer | 0:7a64fbb4069d | 1421 | } |
screamer | 0:7a64fbb4069d | 1422 | dhcp->msg_out->cookie = htonl(0x63825363UL); |
screamer | 0:7a64fbb4069d | 1423 | dhcp->options_out_len = 0; |
screamer | 0:7a64fbb4069d | 1424 | /* fill options field with an incrementing array (for debugging purposes) */ |
screamer | 0:7a64fbb4069d | 1425 | for (i = 0; i < DHCP_OPTIONS_LEN; i++) { |
screamer | 0:7a64fbb4069d | 1426 | dhcp->msg_out->options[i] = (u8_t)i; /* for debugging only, no matter if truncated */ |
screamer | 0:7a64fbb4069d | 1427 | } |
screamer | 0:7a64fbb4069d | 1428 | return ERR_OK; |
screamer | 0:7a64fbb4069d | 1429 | } |
screamer | 0:7a64fbb4069d | 1430 | |
screamer | 0:7a64fbb4069d | 1431 | /** |
screamer | 0:7a64fbb4069d | 1432 | * Free previously allocated memory used to send a DHCP request. |
screamer | 0:7a64fbb4069d | 1433 | * |
screamer | 0:7a64fbb4069d | 1434 | * @param netif the netif under DHCP control |
screamer | 0:7a64fbb4069d | 1435 | */ |
screamer | 0:7a64fbb4069d | 1436 | static void |
screamer | 0:7a64fbb4069d | 1437 | dhcp_delete_request(struct netif *netif) |
screamer | 0:7a64fbb4069d | 1438 | { |
screamer | 0:7a64fbb4069d | 1439 | struct dhcp *dhcp; |
screamer | 0:7a64fbb4069d | 1440 | LWIP_ERROR("dhcp_delete_request: netif != NULL", (netif != NULL), return;); |
screamer | 0:7a64fbb4069d | 1441 | dhcp = netif->dhcp; |
screamer | 0:7a64fbb4069d | 1442 | LWIP_ERROR("dhcp_delete_request: dhcp != NULL", (dhcp != NULL), return;); |
screamer | 0:7a64fbb4069d | 1443 | LWIP_ASSERT("dhcp_delete_request: dhcp->p_out != NULL", dhcp->p_out != NULL); |
screamer | 0:7a64fbb4069d | 1444 | LWIP_ASSERT("dhcp_delete_request: dhcp->msg_out != NULL", dhcp->msg_out != NULL); |
screamer | 0:7a64fbb4069d | 1445 | if (dhcp->p_out != NULL) { |
screamer | 0:7a64fbb4069d | 1446 | pbuf_free(dhcp->p_out); |
screamer | 0:7a64fbb4069d | 1447 | } |
screamer | 0:7a64fbb4069d | 1448 | dhcp->p_out = NULL; |
screamer | 0:7a64fbb4069d | 1449 | dhcp->msg_out = NULL; |
screamer | 0:7a64fbb4069d | 1450 | } |
screamer | 0:7a64fbb4069d | 1451 | |
screamer | 0:7a64fbb4069d | 1452 | /** |
screamer | 0:7a64fbb4069d | 1453 | * Add a DHCP message trailer |
screamer | 0:7a64fbb4069d | 1454 | * |
screamer | 0:7a64fbb4069d | 1455 | * Adds the END option to the DHCP message, and if |
screamer | 0:7a64fbb4069d | 1456 | * necessary, up to three padding bytes. |
screamer | 0:7a64fbb4069d | 1457 | * |
screamer | 0:7a64fbb4069d | 1458 | * @param dhcp DHCP state structure |
screamer | 0:7a64fbb4069d | 1459 | */ |
screamer | 0:7a64fbb4069d | 1460 | static void |
screamer | 0:7a64fbb4069d | 1461 | dhcp_option_trailer(struct dhcp *dhcp) |
screamer | 0:7a64fbb4069d | 1462 | { |
screamer | 0:7a64fbb4069d | 1463 | LWIP_ERROR("dhcp_option_trailer: dhcp != NULL", (dhcp != NULL), return;); |
screamer | 0:7a64fbb4069d | 1464 | LWIP_ASSERT("dhcp_option_trailer: dhcp->msg_out != NULL\n", dhcp->msg_out != NULL); |
screamer | 0:7a64fbb4069d | 1465 | LWIP_ASSERT("dhcp_option_trailer: dhcp->options_out_len < DHCP_OPTIONS_LEN\n", dhcp->options_out_len < DHCP_OPTIONS_LEN); |
screamer | 0:7a64fbb4069d | 1466 | dhcp->msg_out->options[dhcp->options_out_len++] = DHCP_OPTION_END; |
screamer | 0:7a64fbb4069d | 1467 | /* packet is too small, or not 4 byte aligned? */ |
screamer | 0:7a64fbb4069d | 1468 | while ((dhcp->options_out_len < DHCP_MIN_OPTIONS_LEN) || (dhcp->options_out_len & 3)) { |
screamer | 0:7a64fbb4069d | 1469 | /* LWIP_DEBUGF(DHCP_DEBUG,("dhcp_option_trailer:dhcp->options_out_len=%"U16_F", DHCP_OPTIONS_LEN=%"U16_F, dhcp->options_out_len, DHCP_OPTIONS_LEN)); */ |
screamer | 0:7a64fbb4069d | 1470 | LWIP_ASSERT("dhcp_option_trailer: dhcp->options_out_len < DHCP_OPTIONS_LEN\n", dhcp->options_out_len < DHCP_OPTIONS_LEN); |
screamer | 0:7a64fbb4069d | 1471 | /* add a fill/padding byte */ |
screamer | 0:7a64fbb4069d | 1472 | dhcp->msg_out->options[dhcp->options_out_len++] = 0; |
screamer | 0:7a64fbb4069d | 1473 | } |
screamer | 0:7a64fbb4069d | 1474 | } |
screamer | 0:7a64fbb4069d | 1475 | |
screamer | 0:7a64fbb4069d | 1476 | /** |
screamer | 0:7a64fbb4069d | 1477 | * Find the offset of a DHCP option inside the DHCP message. |
screamer | 0:7a64fbb4069d | 1478 | * |
screamer | 0:7a64fbb4069d | 1479 | * @param dhcp DHCP client |
screamer | 0:7a64fbb4069d | 1480 | * @param option_type |
screamer | 0:7a64fbb4069d | 1481 | * |
screamer | 0:7a64fbb4069d | 1482 | * @return a byte offset into the UDP message where the option was found, or |
screamer | 0:7a64fbb4069d | 1483 | * zero if the given option was not found. |
screamer | 0:7a64fbb4069d | 1484 | */ |
screamer | 0:7a64fbb4069d | 1485 | static u8_t *dhcp_get_option_ptr(struct dhcp *dhcp, u8_t option_type) |
screamer | 0:7a64fbb4069d | 1486 | { |
screamer | 0:7a64fbb4069d | 1487 | u8_t overload = DHCP_OVERLOAD_NONE; |
screamer | 0:7a64fbb4069d | 1488 | |
screamer | 0:7a64fbb4069d | 1489 | /* options available? */ |
screamer | 0:7a64fbb4069d | 1490 | if ((dhcp->options_in != NULL) && (dhcp->options_in_len > 0)) { |
screamer | 0:7a64fbb4069d | 1491 | /* start with options field */ |
screamer | 0:7a64fbb4069d | 1492 | u8_t *options = (u8_t *)dhcp->options_in; |
screamer | 0:7a64fbb4069d | 1493 | u16_t offset = 0; |
screamer | 0:7a64fbb4069d | 1494 | /* at least 1 byte to read and no end marker, then at least 3 bytes to read? */ |
screamer | 0:7a64fbb4069d | 1495 | while ((offset < dhcp->options_in_len) && (options[offset] != DHCP_OPTION_END)) { |
screamer | 0:7a64fbb4069d | 1496 | /* LWIP_DEBUGF(DHCP_DEBUG, ("msg_offset=%"U16_F", q->len=%"U16_F, msg_offset, q->len)); */ |
screamer | 0:7a64fbb4069d | 1497 | /* are the sname and/or file field overloaded with options? */ |
screamer | 0:7a64fbb4069d | 1498 | if (options[offset] == DHCP_OPTION_OVERLOAD) { |
screamer | 0:7a64fbb4069d | 1499 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 2, ("overloaded message detected\n")); |
screamer | 0:7a64fbb4069d | 1500 | /* skip option type and length */ |
screamer | 0:7a64fbb4069d | 1501 | offset += 2; |
screamer | 0:7a64fbb4069d | 1502 | overload = options[offset++]; |
screamer | 0:7a64fbb4069d | 1503 | } |
screamer | 0:7a64fbb4069d | 1504 | /* requested option found */ |
screamer | 0:7a64fbb4069d | 1505 | else if (options[offset] == option_type) { |
screamer | 0:7a64fbb4069d | 1506 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("option found at offset %"U16_F" in options\n", offset)); |
screamer | 0:7a64fbb4069d | 1507 | return &options[offset]; |
screamer | 0:7a64fbb4069d | 1508 | /* skip option */ |
screamer | 0:7a64fbb4069d | 1509 | } else { |
screamer | 0:7a64fbb4069d | 1510 | LWIP_DEBUGF(DHCP_DEBUG, ("skipping option %"U16_F" in options\n", options[offset])); |
screamer | 0:7a64fbb4069d | 1511 | /* skip option type */ |
screamer | 0:7a64fbb4069d | 1512 | offset++; |
screamer | 0:7a64fbb4069d | 1513 | /* skip option length, and then length bytes */ |
screamer | 0:7a64fbb4069d | 1514 | offset += 1 + options[offset]; |
screamer | 0:7a64fbb4069d | 1515 | } |
screamer | 0:7a64fbb4069d | 1516 | } |
screamer | 0:7a64fbb4069d | 1517 | /* is this an overloaded message? */ |
screamer | 0:7a64fbb4069d | 1518 | if (overload != DHCP_OVERLOAD_NONE) { |
screamer | 0:7a64fbb4069d | 1519 | u16_t field_len; |
screamer | 0:7a64fbb4069d | 1520 | if (overload == DHCP_OVERLOAD_FILE) { |
screamer | 0:7a64fbb4069d | 1521 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 1, ("overloaded file field\n")); |
screamer | 0:7a64fbb4069d | 1522 | options = (u8_t *)&dhcp->msg_in->file; |
screamer | 0:7a64fbb4069d | 1523 | field_len = DHCP_FILE_LEN; |
screamer | 0:7a64fbb4069d | 1524 | } else if (overload == DHCP_OVERLOAD_SNAME) { |
screamer | 0:7a64fbb4069d | 1525 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 1, ("overloaded sname field\n")); |
screamer | 0:7a64fbb4069d | 1526 | options = (u8_t *)&dhcp->msg_in->sname; |
screamer | 0:7a64fbb4069d | 1527 | field_len = DHCP_SNAME_LEN; |
screamer | 0:7a64fbb4069d | 1528 | /* TODO: check if else if () is necessary */ |
screamer | 0:7a64fbb4069d | 1529 | } else { |
screamer | 0:7a64fbb4069d | 1530 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | 1, ("overloaded sname and file field\n")); |
screamer | 0:7a64fbb4069d | 1531 | options = (u8_t *)&dhcp->msg_in->sname; |
screamer | 0:7a64fbb4069d | 1532 | field_len = DHCP_FILE_LEN + DHCP_SNAME_LEN; |
screamer | 0:7a64fbb4069d | 1533 | } |
screamer | 0:7a64fbb4069d | 1534 | offset = 0; |
screamer | 0:7a64fbb4069d | 1535 | |
screamer | 0:7a64fbb4069d | 1536 | /* at least 1 byte to read and no end marker */ |
screamer | 0:7a64fbb4069d | 1537 | while ((offset < field_len) && (options[offset] != DHCP_OPTION_END)) { |
screamer | 0:7a64fbb4069d | 1538 | if (options[offset] == option_type) { |
screamer | 0:7a64fbb4069d | 1539 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("option found at offset=%"U16_F"\n", offset)); |
screamer | 0:7a64fbb4069d | 1540 | return &options[offset]; |
screamer | 0:7a64fbb4069d | 1541 | /* skip option */ |
screamer | 0:7a64fbb4069d | 1542 | } else { |
screamer | 0:7a64fbb4069d | 1543 | LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("skipping option %"U16_F"\n", options[offset])); |
screamer | 0:7a64fbb4069d | 1544 | /* skip option type */ |
screamer | 0:7a64fbb4069d | 1545 | offset++; |
screamer | 0:7a64fbb4069d | 1546 | offset += 1 + options[offset]; |
screamer | 0:7a64fbb4069d | 1547 | } |
screamer | 0:7a64fbb4069d | 1548 | } |
screamer | 0:7a64fbb4069d | 1549 | } |
screamer | 0:7a64fbb4069d | 1550 | } |
screamer | 0:7a64fbb4069d | 1551 | return NULL; |
screamer | 0:7a64fbb4069d | 1552 | } |
screamer | 0:7a64fbb4069d | 1553 | |
screamer | 0:7a64fbb4069d | 1554 | /** |
screamer | 0:7a64fbb4069d | 1555 | * Return the byte of DHCP option data. |
screamer | 0:7a64fbb4069d | 1556 | * |
screamer | 0:7a64fbb4069d | 1557 | * @param client DHCP client. |
screamer | 0:7a64fbb4069d | 1558 | * @param ptr pointer obtained by dhcp_get_option_ptr(). |
screamer | 0:7a64fbb4069d | 1559 | * |
screamer | 0:7a64fbb4069d | 1560 | * @return byte value at the given address. |
screamer | 0:7a64fbb4069d | 1561 | */ |
screamer | 0:7a64fbb4069d | 1562 | static u8_t |
screamer | 0:7a64fbb4069d | 1563 | dhcp_get_option_byte(u8_t *ptr) |
screamer | 0:7a64fbb4069d | 1564 | { |
screamer | 0:7a64fbb4069d | 1565 | LWIP_DEBUGF(DHCP_DEBUG, ("option byte value=%"U16_F"\n", (u16_t)(*ptr))); |
screamer | 0:7a64fbb4069d | 1566 | return *ptr; |
screamer | 0:7a64fbb4069d | 1567 | } |
screamer | 0:7a64fbb4069d | 1568 | |
screamer | 0:7a64fbb4069d | 1569 | #if 0 /* currently unused */ |
screamer | 0:7a64fbb4069d | 1570 | /** |
screamer | 0:7a64fbb4069d | 1571 | * Return the 16-bit value of DHCP option data. |
screamer | 0:7a64fbb4069d | 1572 | * |
screamer | 0:7a64fbb4069d | 1573 | * @param client DHCP client. |
screamer | 0:7a64fbb4069d | 1574 | * @param ptr pointer obtained by dhcp_get_option_ptr(). |
screamer | 0:7a64fbb4069d | 1575 | * |
screamer | 0:7a64fbb4069d | 1576 | * @return byte value at the given address. |
screamer | 0:7a64fbb4069d | 1577 | */ |
screamer | 0:7a64fbb4069d | 1578 | static u16_t |
screamer | 0:7a64fbb4069d | 1579 | dhcp_get_option_short(u8_t *ptr) |
screamer | 0:7a64fbb4069d | 1580 | { |
screamer | 0:7a64fbb4069d | 1581 | u16_t value; |
screamer | 0:7a64fbb4069d | 1582 | value = *ptr++ << 8; |
screamer | 0:7a64fbb4069d | 1583 | value |= *ptr; |
screamer | 0:7a64fbb4069d | 1584 | LWIP_DEBUGF(DHCP_DEBUG, ("option short value=%"U16_F"\n", value)); |
screamer | 0:7a64fbb4069d | 1585 | return value; |
screamer | 0:7a64fbb4069d | 1586 | } |
screamer | 0:7a64fbb4069d | 1587 | #endif |
screamer | 0:7a64fbb4069d | 1588 | |
screamer | 0:7a64fbb4069d | 1589 | /** |
screamer | 0:7a64fbb4069d | 1590 | * Return the 32-bit value of DHCP option data. |
screamer | 0:7a64fbb4069d | 1591 | * |
screamer | 0:7a64fbb4069d | 1592 | * @param client DHCP client. |
screamer | 0:7a64fbb4069d | 1593 | * @param ptr pointer obtained by dhcp_get_option_ptr(). |
screamer | 0:7a64fbb4069d | 1594 | * |
screamer | 0:7a64fbb4069d | 1595 | * @return byte value at the given address. |
screamer | 0:7a64fbb4069d | 1596 | */ |
screamer | 0:7a64fbb4069d | 1597 | static u32_t dhcp_get_option_long(u8_t *ptr) |
screamer | 0:7a64fbb4069d | 1598 | { |
screamer | 0:7a64fbb4069d | 1599 | u32_t value; |
screamer | 0:7a64fbb4069d | 1600 | value = (u32_t)(*ptr++) << 24; |
screamer | 0:7a64fbb4069d | 1601 | value |= (u32_t)(*ptr++) << 16; |
screamer | 0:7a64fbb4069d | 1602 | value |= (u32_t)(*ptr++) << 8; |
screamer | 0:7a64fbb4069d | 1603 | value |= (u32_t)(*ptr++); |
screamer | 0:7a64fbb4069d | 1604 | LWIP_DEBUGF(DHCP_DEBUG, ("option long value=%"U32_F"\n", value)); |
screamer | 0:7a64fbb4069d | 1605 | return value; |
screamer | 0:7a64fbb4069d | 1606 | } |
screamer | 0:7a64fbb4069d | 1607 | |
screamer | 0:7a64fbb4069d | 1608 | #endif /* LWIP_DHCP */ |