MeterLogger
dhcpserver.c
Go to the documentation of this file.
1 #include "lwip/inet.h"
2 #include "lwip/err.h"
3 #include "lwip/pbuf.h"
4 #include "lwip/udp.h"
5 #include "lwip/mem.h"
6 //#include "crypto/common.h"
7 #include "osapi.h"
8 #include "lwip/app/dhcpserver.h"
9 
10 #ifndef LWIP_OPEN_SRC
11 #include "net80211/ieee80211_var.h"
12 #endif
13 
14 #include "user_interface.h"
15 
16 #ifdef MEMLEAK_DEBUG
17 static const char mem_debug_file[] ICACHE_RODATA_ATTR = __FILE__;
18 #endif
19 
20 ////////////////////////////////////////////////////////////////////////////////////
21 //static const uint8_t xid[4] = {0xad, 0xde, 0x12, 0x23};
22 //static u8_t old_xid[4] = {0};
23 static const uint32 magic_cookie ICACHE_RODATA_ATTR = 0x63538263;
24 static struct udp_pcb *pcb_dhcps = NULL;
25 static struct ip_addr broadcast_dhcps;
26 static struct ip_addr server_address;
27 static struct ip_addr client_address;//added
29 
30 static struct ip_addr dns_address = {0};
31 
32 static struct dhcps_lease dhcps_lease;
33 //static bool dhcps_lease_flag = true;
34 static list_node *plist = NULL;
35 static uint8 offer = 0xFF;
36 static bool renew = false;
37 #define DHCPS_LEASE_TIME_DEF (120)
39 /******************************************************************************
40  * FunctionName : node_insert_to_list
41  * Description : insert the node to the list
42  * Parameters : arg -- Additional argument to pass to the callback function
43  * Returns : none
44 *******************************************************************************/
46 {
47  list_node *plist = NULL;
48  struct dhcps_pool *pdhcps_pool = NULL;
49  struct dhcps_pool *pdhcps_node = NULL;
50 
51  if (*phead == NULL)
52  *phead = pinsert;
53  else {
54  plist = *phead;
55  pdhcps_node = pinsert->pnode;
56  pdhcps_pool = plist->pnode;
57 
58  if(pdhcps_node->ip.addr < pdhcps_pool->ip.addr) {
59  pinsert->pnext = plist;
60  *phead = pinsert;
61  } else {
62  while (plist->pnext != NULL) {
63  pdhcps_pool = plist->pnext->pnode;
64  if (pdhcps_node->ip.addr < pdhcps_pool->ip.addr) {
65  pinsert->pnext = plist->pnext;
66  plist->pnext = pinsert;
67  break;
68  }
69  plist = plist->pnext;
70  }
71 
72  if(plist->pnext == NULL) {
73  plist->pnext = pinsert;
74  }
75  }
76  }
77 // pinsert->pnext = NULL;
78 }
79 
80 /******************************************************************************
81  * FunctionName : node_delete_from_list
82  * Description : remove the node from list
83  * Parameters : arg -- Additional argument to pass to the callback function
84  * Returns : none
85 *******************************************************************************/
87 {
88  list_node *plist = NULL;
89 
90  plist = *phead;
91  if (plist == NULL){
92  *phead = NULL;
93  } else {
94  if (plist == pdelete){
95  *phead = plist->pnext;
96  } else {
97  while (plist != NULL) {
98  if (plist->pnext == pdelete){
99  plist->pnext = pdelete->pnext;
100  }
101  plist = plist->pnext;
102  }
103  }
104  }
105 }
106 ///////////////////////////////////////////////////////////////////////////////////
107 /*
108  * ��DHCP msg��Ϣ�ṹ����������
109  *
110  * @param optptr -- DHCP msg��Ϣλ��
111  * @param type -- Ҫ��ӵ�����option
112  *
113  * @return uint8_t* ����DHCP msgƫ�Ƶ�ַ
114  */
115 ///////////////////////////////////////////////////////////////////////////////////
116 static uint8_t* ICACHE_FLASH_ATTR add_msg_type(uint8_t *optptr, uint8_t type)
117 {
118 
119  *optptr++ = DHCP_OPTION_MSG_TYPE;
120  *optptr++ = 1;
121  *optptr++ = type;
122  return optptr;
123 }
124 ///////////////////////////////////////////////////////////////////////////////////
125 /*
126  * ��DHCP msg�ṹ������offerӦ������
127  *
128  * @param optptr -- DHCP msg��Ϣλ��
129  *
130  * @return uint8_t* ����DHCP msgƫ�Ƶ�ַ
131  */
132 ///////////////////////////////////////////////////////////////////////////////////
133 static uint8_t* ICACHE_FLASH_ATTR add_offer_options(uint8_t *optptr)
134 {
135  struct ip_addr ipadd;
136 
137  ipadd.addr = *( (uint32_t *) &server_address);
138 
139 #ifdef USE_CLASS_B_NET
140  *optptr++ = DHCP_OPTION_SUBNET_MASK;
141  *optptr++ = 4; //length
142  *optptr++ = 255;
143  *optptr++ = 240;
144  *optptr++ = 0;
145  *optptr++ = 0;
146 #else
147  *optptr++ = DHCP_OPTION_SUBNET_MASK;
148  *optptr++ = 4;
149  *optptr++ = 255;
150  *optptr++ = 255;
151  *optptr++ = 255;
152  *optptr++ = 0;
153 #endif
154 
155  *optptr++ = DHCP_OPTION_LEASE_TIME;
156  *optptr++ = 4;
157  *optptr++ = ((DHCPS_LEASE_TIMER * 60) >> 24) & 0xFF;
158  *optptr++ = ((DHCPS_LEASE_TIMER * 60) >> 16) & 0xFF;
159  *optptr++ = ((DHCPS_LEASE_TIMER * 60) >> 8) & 0xFF;
160  *optptr++ = ((DHCPS_LEASE_TIMER * 60) >> 0) & 0xFF;
161 
162  *optptr++ = DHCP_OPTION_SERVER_ID;
163  *optptr++ = 4;
164  *optptr++ = ip4_addr1( &ipadd);
165  *optptr++ = ip4_addr2( &ipadd);
166  *optptr++ = ip4_addr3( &ipadd);
167  *optptr++ = ip4_addr4( &ipadd);
168 
170  struct ip_info if_ip;
171  os_bzero(&if_ip, sizeof(struct ip_info));
172  wifi_get_ip_info(SOFTAP_IF, &if_ip);
173 
174  *optptr++ = DHCP_OPTION_ROUTER;
175  *optptr++ = 4;
176  *optptr++ = ip4_addr1( &if_ip.gw);
177  *optptr++ = ip4_addr2( &if_ip.gw);
178  *optptr++ = ip4_addr3( &if_ip.gw);
179  *optptr++ = ip4_addr4( &if_ip.gw);
180  }
181 
182 #ifdef USE_DNS
183  *optptr++ = DHCP_OPTION_DNS_SERVER;
184  *optptr++ = 4;
185  *optptr++ = ip4_addr1( &dns_address);
186  *optptr++ = ip4_addr2( &dns_address);
187  *optptr++ = ip4_addr3( &dns_address);
188  *optptr++ = ip4_addr4( &dns_address);
189 #endif
190 
191 #ifdef CLASS_B_NET
192  *optptr++ = DHCP_OPTION_BROADCAST_ADDRESS;
193  *optptr++ = 4;
194  *optptr++ = ip4_addr1( &ipadd);
195  *optptr++ = 255;
196  *optptr++ = 255;
197  *optptr++ = 255;
198 #else
199  *optptr++ = DHCP_OPTION_BROADCAST_ADDRESS;
200  *optptr++ = 4;
201  *optptr++ = ip4_addr1( &ipadd);
202  *optptr++ = ip4_addr2( &ipadd);
203  *optptr++ = ip4_addr3( &ipadd);
204  *optptr++ = 255;
205 #endif
206 
207  *optptr++ = DHCP_OPTION_INTERFACE_MTU;
208  *optptr++ = 2;
209 #ifdef CLASS_B_NET
210  *optptr++ = 0x05;
211  *optptr++ = 0xdc;
212 #else
213  *optptr++ = 0x02;
214  *optptr++ = 0x40;
215 #endif
216 
218  *optptr++ = 1;
219  *optptr++ = 0x00;
220 
221  *optptr++ = 43;
222  *optptr++ = 6;
223 
224  *optptr++ = 0x01;
225  *optptr++ = 4;
226  *optptr++ = 0x00;
227  *optptr++ = 0x00;
228  *optptr++ = 0x00;
229  *optptr++ = 0x02;
230 
231  return optptr;
232 }
233 ///////////////////////////////////////////////////////////////////////////////////
234 /*
235  * ��DHCP msg�ṹ����ӽ����־����
236  *
237  * @param optptr -- DHCP msg��Ϣλ��
238  *
239  * @return uint8_t* ����DHCP msgƫ�Ƶ�ַ
240  */
241 ///////////////////////////////////////////////////////////////////////////////////
242 static uint8_t* ICACHE_FLASH_ATTR add_end(uint8_t *optptr)
243 {
244 
245  *optptr++ = DHCP_OPTION_END;
246  return optptr;
247 }
248 ///////////////////////////////////////////////////////////////////////////////////
249 ///////////////////////////////////////////////////////////////////////////////////
250 static void ICACHE_FLASH_ATTR create_msg(struct dhcps_msg *m)
251 {
252  struct ip_addr client;
253 
254  client.addr = *( (uint32_t *) &client_address);
255 
256  m->op = DHCP_REPLY;
258  m->hlen = 6;
259  m->hops = 0;
260 // os_memcpy((char *) xid, (char *) m->xid, sizeof(m->xid));
261  m->secs = 0;
262  m->flags = htons(BOOTP_BROADCAST);
263 
264  os_memcpy((char *) m->yiaddr, (char *) &client.addr, sizeof(m->yiaddr));
265 
266  os_memset((char *) m->ciaddr, 0, sizeof(m->ciaddr));
267  os_memset((char *) m->siaddr, 0, sizeof(m->siaddr));
268  os_memset((char *) m->giaddr, 0, sizeof(m->giaddr));
269  os_memset((char *) m->sname, 0, sizeof(m->sname));
270  os_memset((char *) m->file, 0, sizeof(m->file));
271 
272  os_memset((char *) m->options, 0, sizeof(m->options));
273  os_memcpy((char *) m->options, &magic_cookie, sizeof(magic_cookie));
274 }
275 ///////////////////////////////////////////////////////////////////////////////////
276 /*
277  * ����һ��OFFER
278  *
279  * @param -- m ָ����Ҫ���͵�DHCP msg����
280  */
281 ///////////////////////////////////////////////////////////////////////////////////
282 static void ICACHE_FLASH_ATTR send_offer(struct dhcps_msg *m)
283 {
284  uint8_t *end;
285  struct pbuf *p, *q;
286  u8_t *data;
287  u16_t cnt=0;
288  u16_t i;
289  err_t SendOffer_err_t;
290  create_msg(m);
291 
292  end = add_msg_type(&m->options[4], DHCPOFFER);
293  end = add_offer_options(end);
294  end = add_end(end);
295 
296  p = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcps_msg), PBUF_RAM);
297 #if DHCPS_DEBUG
298  os_printf("udhcp: send_offer>>p->ref = %d\n", p->ref);
299 #endif
300  if(p != NULL){
301 
302 #if DHCPS_DEBUG
303  os_printf("dhcps: send_offer>>pbuf_alloc succeed\n");
304  os_printf("dhcps: send_offer>>p->tot_len = %d\n", p->tot_len);
305  os_printf("dhcps: send_offer>>p->len = %d\n", p->len);
306 #endif
307  q = p;
308  while(q != NULL){
309  data = (u8_t *)q->payload;
310  for(i=0; i<q->len; i++)
311  {
312  data[i] = ((u8_t *) m)[cnt++];
313 #if DHCPS_DEBUG
314  os_printf("%02x ",data[i]);
315  if((i+1)%16 == 0){
316  os_printf("\n");
317  }
318 #endif
319  }
320 
321  q = q->next;
322  }
323  }else{
324 
325 #if DHCPS_DEBUG
326  os_printf("dhcps: send_offer>>pbuf_alloc failed\n");
327 #endif
328  return;
329  }
330  SendOffer_err_t = udp_sendto( pcb_dhcps, p, &broadcast_dhcps, DHCPS_CLIENT_PORT );
331 #if DHCPS_DEBUG
332  os_printf("dhcps: send_offer>>udp_sendto result %x\n",SendOffer_err_t);
333 #endif
334  if(p->ref != 0){
335 #if DHCPS_DEBUG
336  os_printf("udhcp: send_offer>>free pbuf\n");
337 #endif
338  pbuf_free(p);
339  }
340 }
341 ///////////////////////////////////////////////////////////////////////////////////
342 /*
343  * ����һ��NAK��Ϣ
344  *
345  * @param m ָ����Ҫ���͵�DHCP msg����
346  */
347 ///////////////////////////////////////////////////////////////////////////////////
348 static void ICACHE_FLASH_ATTR send_nak(struct dhcps_msg *m)
349 {
350 
351  u8_t *end;
352  struct pbuf *p, *q;
353  u8_t *data;
354  u16_t cnt=0;
355  u16_t i;
356  err_t SendNak_err_t;
357  create_msg(m);
358 
359  end = add_msg_type(&m->options[4], DHCPNAK);
360  end = add_end(end);
361 
362  p = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcps_msg), PBUF_RAM);
363 #if DHCPS_DEBUG
364  os_printf("udhcp: send_nak>>p->ref = %d\n", p->ref);
365 #endif
366  if(p != NULL){
367 
368 #if DHCPS_DEBUG
369  os_printf("dhcps: send_nak>>pbuf_alloc succeed\n");
370  os_printf("dhcps: send_nak>>p->tot_len = %d\n", p->tot_len);
371  os_printf("dhcps: send_nak>>p->len = %d\n", p->len);
372 #endif
373  q = p;
374  while(q != NULL){
375  data = (u8_t *)q->payload;
376  for(i=0; i<q->len; i++)
377  {
378  data[i] = ((u8_t *) m)[cnt++];
379 #if DHCPS_DEBUG
380  os_printf("%02x ",data[i]);
381  if((i+1)%16 == 0){
382  os_printf("\n");
383  }
384 #endif
385  }
386 
387  q = q->next;
388  }
389  }else{
390 
391 #if DHCPS_DEBUG
392  os_printf("dhcps: send_nak>>pbuf_alloc failed\n");
393 #endif
394  return;
395  }
396  SendNak_err_t = udp_sendto( pcb_dhcps, p, &broadcast_dhcps, DHCPS_CLIENT_PORT );
397 #if DHCPS_DEBUG
398  os_printf("dhcps: send_nak>>udp_sendto result %x\n",SendNak_err_t);
399 #endif
400  if(p->ref != 0){
401 #if DHCPS_DEBUG
402  os_printf("udhcp: send_nak>>free pbuf\n");
403 #endif
404  pbuf_free(p);
405  }
406 }
407 ///////////////////////////////////////////////////////////////////////////////////
408 /*
409  * ����һ��ACK��DHCP�ͻ���
410  *
411  * @param m ָ����Ҫ���͵�DHCP msg����
412  */
413 ///////////////////////////////////////////////////////////////////////////////////
414 static void ICACHE_FLASH_ATTR send_ack(struct dhcps_msg *m)
415 {
416 
417  u8_t *end;
418  struct pbuf *p, *q;
419  u8_t *data;
420  u16_t cnt=0;
421  u16_t i;
422  err_t SendAck_err_t;
423  create_msg(m);
424 
425  end = add_msg_type(&m->options[4], DHCPACK);
426  end = add_offer_options(end);
427  end = add_end(end);
428 
429  p = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcps_msg), PBUF_RAM);
430 #if DHCPS_DEBUG
431  os_printf("udhcp: send_ack>>p->ref = %d\n", p->ref);
432 #endif
433  if(p != NULL){
434 
435 #if DHCPS_DEBUG
436  os_printf("dhcps: send_ack>>pbuf_alloc succeed\n");
437  os_printf("dhcps: send_ack>>p->tot_len = %d\n", p->tot_len);
438  os_printf("dhcps: send_ack>>p->len = %d\n", p->len);
439 #endif
440  q = p;
441  while(q != NULL){
442  data = (u8_t *)q->payload;
443  for(i=0; i<q->len; i++)
444  {
445  data[i] = ((u8_t *) m)[cnt++];
446 #if DHCPS_DEBUG
447  os_printf("%02x ",data[i]);
448  if((i+1)%16 == 0){
449  os_printf("\n");
450  }
451 #endif
452  }
453 
454  q = q->next;
455  }
456  }else{
457 
458 #if DHCPS_DEBUG
459  os_printf("dhcps: send_ack>>pbuf_alloc failed\n");
460 #endif
461  return;
462  }
463  SendAck_err_t = udp_sendto( pcb_dhcps, p, &broadcast_dhcps, DHCPS_CLIENT_PORT );
464 #if DHCPS_DEBUG
465  os_printf("dhcps: send_ack>>udp_sendto result %x\n",SendAck_err_t);
466 #endif
467 
468  if(p->ref != 0){
469 #if DHCPS_DEBUG
470  os_printf("udhcp: send_ack>>free pbuf\n");
471 #endif
472  pbuf_free(p);
473  }
474 }
475 ///////////////////////////////////////////////////////////////////////////////////
476 /*
477  * ����DHCP�ͻ��˷�����DHCP����������Ϣ�����Բ�ͬ��DHCP��������������Ӧ��Ӧ��
478  *
479  * @param optptr DHCP msg�е���������
480  * @param len ��������Ĵ��?(byte)
481  *
482  * @return uint8_t ���ش�����DHCP Server״ֵ̬
483  */
484 ///////////////////////////////////////////////////////////////////////////////////
485 static uint8_t ICACHE_FLASH_ATTR parse_options(uint8_t *optptr, sint16_t len)
486 {
487  struct ip_addr client;
488  bool is_dhcp_parse_end = false;
489  struct dhcps_state s;
490 
491  client.addr = *( (uint32_t *) &client_address);// Ҫ�����DHCP�ͻ��˵�IP
492 
493  u8_t *end = optptr + len;
494  u16_t type = 0;
495 
497 
498  while (optptr < end) {
499 #if DHCPS_DEBUG
500  os_printf("dhcps: (sint16_t)*optptr = %d\n", (sint16_t)*optptr);
501 #endif
502  switch ((sint16_t) *optptr) {
503 
504  case DHCP_OPTION_MSG_TYPE: //53
505  type = *(optptr + 2);
506  break;
507 
508  case DHCP_OPTION_REQ_IPADDR://50
509  if( os_memcmp( (char *) &client.addr, (char *) optptr+2,4)==0 ) {
510 #if DHCPS_DEBUG
511  os_printf("dhcps: DHCP_OPTION_REQ_IPADDR = 0 ok\n");
512 #endif
514  }else {
515 #if DHCPS_DEBUG
516  os_printf("dhcps: DHCP_OPTION_REQ_IPADDR != 0 err\n");
517 #endif
519  }
520  break;
521  case DHCP_OPTION_END:
522  {
523  is_dhcp_parse_end = true;
524  }
525  break;
526  }
527 
528  if(is_dhcp_parse_end){
529  break;
530  }
531 
532  optptr += optptr[1] + 2;
533  }
534 
535  switch (type){
536 
537  case DHCPDISCOVER://1
539 #if DHCPS_DEBUG
540  os_printf("dhcps: DHCPD_STATE_OFFER\n");
541 #endif
542  break;
543 
544  case DHCPREQUEST://3
545  if ( !(s.state == DHCPS_STATE_ACK || s.state == DHCPS_STATE_NAK) ) {
546  if(renew == true) {
548  } else {
550  }
551 #if DHCPS_DEBUG
552  os_printf("dhcps: DHCPD_STATE_NAK\n");
553 #endif
554  }
555  break;
556 
557  case DHCPDECLINE://4
559 #if DHCPS_DEBUG
560  os_printf("dhcps: DHCPD_STATE_IDLE\n");
561 #endif
562  break;
563 
564  case DHCPRELEASE://7
566 #if DHCPS_DEBUG
567  os_printf("dhcps: DHCPD_STATE_IDLE\n");
568 #endif
569  break;
570  }
571 #if DHCPS_DEBUG
572  os_printf("dhcps: return s.state = %d\n", s.state);
573 #endif
574  return s.state;
575 }
576 ///////////////////////////////////////////////////////////////////////////////////
577 ///////////////////////////////////////////////////////////////////////////////////
579 {
580  if(os_memcmp((char *)m->options,
581  &magic_cookie,
582  sizeof(magic_cookie)) == 0){
583 #if DHCPS_DEBUG
584  os_printf("dhcps: len = %d\n", len);
585 #endif
586  /*
587  * ��¼��ǰ��xid���ﴦ���?
588  * �˺�ΪDHCP�ͻ����������û�ͳһ��ȡIPʱ��
589  */
590 // if((old_xid[0] == 0) &&
591 // (old_xid[1] == 0) &&
592 // (old_xid[2] == 0) &&
593 // (old_xid[3] == 0)){
594 // /*
595 // * old_xidδ��¼�κ����?
596 // * �϶��ǵ�һ��ʹ��
597 // */
598 // os_memcpy((char *)old_xid, (char *)m->xid, sizeof(m->xid));
599 // }else{
600 // /*
601 // * ���δ����DHCP msg��Я���xid���ϴμ�¼�IJ�ͬ��
602 // * �϶�Ϊ��ͬ��DHCP�ͻ��˷��ͣ���ʱ����Ҫ����Ŀͻ���IP
603 // * ���� 192.168.4.100(0x6404A8C0) <--> 192.168.4.200(0xC804A8C0)
604 // *
605 // */
606 // if(os_memcmp((char *)old_xid, (char *)m->xid, sizeof(m->xid)) != 0){
607  /*
608  * ��¼���ε�xid�ţ�ͬʱ�����IP����
609  */
610  struct ip_addr addr_tmp;
611 // os_memcpy((char *)old_xid, (char *)m->xid, sizeof(m->xid));
612 
613 // {
614  struct dhcps_pool *pdhcps_pool = NULL;
615  list_node *pnode = NULL;
616  list_node *pback_node = NULL;
617  struct ip_addr first_address;
618  bool flag = false;
619 
620 // POOL_START:
621  first_address.addr = dhcps_lease.start_ip.addr;
623  renew = false;
624 // addr_tmp.addr = htonl(client_address_plus.addr);
625 // addr_tmp.addr++;
626 // client_address_plus.addr = htonl(addr_tmp.addr);
627  for (pback_node = plist; pback_node != NULL;pback_node = pback_node->pnext) {
628  pdhcps_pool = pback_node->pnode;
629  if (os_memcmp(pdhcps_pool->mac, m->chaddr, sizeof(pdhcps_pool->mac)) == 0){
630 // os_printf("the same device request ip\n");
631  if (os_memcmp(&pdhcps_pool->ip.addr, m->ciaddr, sizeof(pdhcps_pool->ip.addr)) == 0) {
632  renew = true;
633  }
634  client_address.addr = pdhcps_pool->ip.addr;
635  pdhcps_pool->lease_timer = DHCPS_LEASE_TIMER;
636  pnode = pback_node;
637  goto POOL_CHECK;
638  } else if (pdhcps_pool->ip.addr == client_address_plus.addr){
639 // client_address.addr = client_address_plus.addr;
640 // os_printf("the ip addr has been request\n");
641  addr_tmp.addr = htonl(client_address_plus.addr);
642  addr_tmp.addr++;
643  client_address_plus.addr = htonl(addr_tmp.addr);
645  }
646 
647  if(flag == false) { // search the fisrt unused ip
648  if(first_address.addr < pdhcps_pool->ip.addr) {
649  flag = true;
650  } else {
651  addr_tmp.addr = htonl(first_address.addr);
652  addr_tmp.addr++;
653  first_address.addr = htonl(addr_tmp.addr);
654  }
655  }
656  }
658  client_address.addr = first_address.addr;
659  }
662  pdhcps_pool = NULL;
663  pnode = NULL;
664  } else {
665  pdhcps_pool = (struct dhcps_pool *)os_zalloc(sizeof(struct dhcps_pool));
666  pdhcps_pool->ip.addr = client_address.addr;
667  os_memcpy(pdhcps_pool->mac, m->chaddr, sizeof(pdhcps_pool->mac));
668  pdhcps_pool->lease_timer = DHCPS_LEASE_TIMER;
669  pnode = (list_node *)os_zalloc(sizeof(list_node ));
670  pnode->pnode = pdhcps_pool;
671  pnode->pnext = NULL;
672  node_insert_to_list(&plist,pnode);
675  } else {
676  addr_tmp.addr = htonl(client_address.addr);
677  addr_tmp.addr++;
678  client_address_plus.addr = htonl(addr_tmp.addr);
679  }
680  }
681 
682  POOL_CHECK:
684  os_printf("client_address_plus.addr %x %d\n", client_address_plus.addr, system_get_free_heap_size());
685  if(pnode != NULL) {
686  node_remove_from_list(&plist,pnode);
687  os_free(pnode);
688  pnode = NULL;
689  }
690 
691  if (pdhcps_pool != NULL) {
692  os_free(pdhcps_pool);
693  pdhcps_pool = NULL;
694  }
695 // client_address_plus.addr = dhcps_lease.start_ip.addr;
696  return 4;
697  }
698 
699  sint16_t ret = parse_options(&m->options[4], len);;
700 
701  if(ret == DHCPS_STATE_RELEASE) {
702  if(pnode != NULL) {
703  node_remove_from_list(&plist,pnode);
704  os_free(pnode);
705  pnode = NULL;
706  }
707 
708  if (pdhcps_pool != NULL) {
709  os_free(pdhcps_pool);
710  pdhcps_pool = NULL;
711  }
713  }
714 
715  if (wifi_softap_set_station_info(m->chaddr, &client_address) == false) {
716  return 0;
717  }
718 // }
719 
720 #if DHCPS_DEBUG
721  os_printf("dhcps: xid changed\n");
722  os_printf("dhcps: client_address.addr = %x\n", client_address.addr);
723 #endif
724 
725 // }
726 
727 // }
728  return ret;
729  }
730  return 0;
731 }
732 ///////////////////////////////////////////////////////////////////////////////////
733 /*
734  * DHCP ��������ݰ���մ���ص�����˺�����LWIP UDPģ������ʱ������
735  * ��Ҫ����udp_recv()������LWIP����ע��.
736  *
737  * @param arg
738  * @param pcb ���յ�UDP��Ŀ��ƿ�?
739  * @param p ���յ���UDP�е��������?
740  * @param addr ���ʹ�UDP���Դ�����IP��ַ
741  * @param port ���ʹ�UDP���Դ�����UDPͨ���˿ں�
742  */
743 ///////////////////////////////////////////////////////////////////////////////////
744 static void ICACHE_FLASH_ATTR handle_dhcp(void *arg,
745  struct udp_pcb *pcb,
746  struct pbuf *p,
747  struct ip_addr *addr,
748  uint16_t port)
749 {
750  struct dhcps_msg *pmsg_dhcps = NULL;
751  sint16_t tlen = 0;
752  u16_t i = 0;
753  u16_t dhcps_msg_cnt = 0;
754  u8_t *p_dhcps_msg = NULL;
755  u8_t *data = NULL;
756 
757 #if DHCPS_DEBUG
758  os_printf("dhcps: handle_dhcp-> receive a packet\n");
759 #endif
760  if (p==NULL) return;
761 
762  pmsg_dhcps = (struct dhcps_msg *)os_zalloc(sizeof(struct dhcps_msg));
763  if (NULL == pmsg_dhcps){
764  pbuf_free(p);
765  return;
766  }
767  p_dhcps_msg = (u8_t *)pmsg_dhcps;
768  tlen = p->tot_len;
769  data = p->payload;
770 
771 #if DHCPS_DEBUG
772  os_printf("dhcps: handle_dhcp-> p->tot_len = %d\n", tlen);
773  os_printf("dhcps: handle_dhcp-> p->len = %d\n", p->len);
774 #endif
775 
776  for(i=0; i<p->len; i++){
777  p_dhcps_msg[dhcps_msg_cnt++] = data[i];
778 #if DHCPS_DEBUG
779  os_printf("%02x ",data[i]);
780  if((i+1)%16 == 0){
781  os_printf("\n");
782  }
783 #endif
784  }
785 
786  if(p->next != NULL) {
787 #if DHCPS_DEBUG
788  os_printf("dhcps: handle_dhcp-> p->next != NULL\n");
789  os_printf("dhcps: handle_dhcp-> p->next->tot_len = %d\n",p->next->tot_len);
790  os_printf("dhcps: handle_dhcp-> p->next->len = %d\n",p->next->len);
791 #endif
792 
793  data = p->next->payload;
794  for(i=0; i<p->next->len; i++){
795  p_dhcps_msg[dhcps_msg_cnt++] = data[i];
796 #if DHCPS_DEBUG
797  os_printf("%02x ",data[i]);
798  if((i+1)%16 == 0){
799  os_printf("\n");
800  }
801 #endif
802  }
803  }
804 
805  /*
806  * DHCP �ͻ���������Ϣ����
807  */
808 #if DHCPS_DEBUG
809  os_printf("dhcps: handle_dhcp-> parse_msg(p)\n");
810 #endif
811 
812  switch(parse_msg(pmsg_dhcps, tlen - 240)) {
813 
814  case DHCPS_STATE_OFFER://1
815 #if DHCPS_DEBUG
816  os_printf("dhcps: handle_dhcp-> DHCPD_STATE_OFFER\n");
817 #endif
818  send_offer(pmsg_dhcps);
819  break;
820  case DHCPS_STATE_ACK://3
821 #if DHCPS_DEBUG
822  os_printf("dhcps: handle_dhcp-> DHCPD_STATE_ACK\n");
823 #endif
824  send_ack(pmsg_dhcps);
825  break;
826  case DHCPS_STATE_NAK://4
827 #if DHCPS_DEBUG
828  os_printf("dhcps: handle_dhcp-> DHCPD_STATE_NAK\n");
829 #endif
830  send_nak(pmsg_dhcps);
831  break;
832  default :
833  break;
834  }
835 #if DHCPS_DEBUG
836  os_printf("dhcps: handle_dhcp-> pbuf_free(p)\n");
837 #endif
838  pbuf_free(p);
839  os_free(pmsg_dhcps);
840  pmsg_dhcps = NULL;
841 }
842 ///////////////////////////////////////////////////////////////////////////////////
844 {
845  uint32 softap_ip = 0,local_ip = 0;
846  uint32 start_ip = 0;
847  uint32 end_ip = 0;
848 // if (dhcps_lease_flag) {
849  if (dhcps_lease.enable == TRUE) {
850  softap_ip = htonl(ip);
851  start_ip = htonl(dhcps_lease.start_ip.addr);
852  end_ip = htonl(dhcps_lease.end_ip.addr);
853  /*config ip information can't contain local ip*/
854  if ((start_ip <= softap_ip) && (softap_ip <= end_ip)) {
856  } else {
857  /*config ip information must be in the same segment as the local ip*/
858  softap_ip >>= 8;
859  if (((start_ip >> 8 != softap_ip) || (end_ip >> 8 != softap_ip))
860  || (end_ip - start_ip > DHCPS_MAX_LEASE)) {
862  }
863  }
864  }
865 
866  if (dhcps_lease.enable == FALSE) {
867  local_ip = softap_ip = htonl(ip);
868  softap_ip &= 0xFFFFFF00;
869  local_ip &= 0xFF;
870  if (local_ip >= 0x80)
871  local_ip -= DHCPS_MAX_LEASE;
872  else
873  local_ip ++;
874 
875  os_bzero(&dhcps_lease, sizeof(dhcps_lease));
876  dhcps_lease.start_ip.addr = softap_ip | local_ip;
877  dhcps_lease.end_ip.addr = softap_ip | (local_ip + DHCPS_MAX_LEASE - 1);
880  }
881 // dhcps_lease.start_ip.addr = htonl(dhcps_lease.start_ip.addr);
882 // dhcps_lease.end_ip.addr= htonl(dhcps_lease.end_ip.addr);
883 // os_printf("start_ip = 0x%x, end_ip = 0x%x\n",dhcps_lease.start_ip, dhcps_lease.end_ip);
884 }
885 ///////////////////////////////////////////////////////////////////////////////////
887 {
888  struct netif * apnetif = (struct netif *)eagle_lwip_getif(0x01);
889 
890  if(apnetif->dhcps_pcb != NULL) {
891  udp_remove(apnetif->dhcps_pcb);
892  }
893 
894  pcb_dhcps = udp_new();
895  if (pcb_dhcps == NULL || info ==NULL) {
896  os_printf("dhcps_start(): could not obtain pcb\n");
897  }
898 
899  apnetif->dhcps_pcb = pcb_dhcps;
900 
901  IP4_ADDR(&broadcast_dhcps, 255, 255, 255, 255);
902 
903  server_address = info->ip;
904  if (dns_address.addr == 0) {
905  dns_address = server_address;
906  }
907 
910 
911  udp_bind(pcb_dhcps, &info->ip, DHCPS_SERVER_PORT);
912  udp_recv(pcb_dhcps, handle_dhcp, NULL);
913 #if DHCPS_DEBUG
914  os_printf("dhcps:dhcps_start->udp_recv function Set a receive callback handle_dhcp for UDP_PCB pcb_dhcps\n");
915 #endif
916 
917 }
918 
920 {
921  struct netif * apnetif = (struct netif *)eagle_lwip_getif(0x01);
922 
923  udp_disconnect(pcb_dhcps);
924 // dhcps_lease_flag = true;
925  if(apnetif->dhcps_pcb != NULL) {
926  udp_remove(apnetif->dhcps_pcb);
927  apnetif->dhcps_pcb = NULL;
928  }
929 
930  //udp_remove(pcb_dhcps);
931  list_node *pnode = NULL;
932  list_node *pback_node = NULL;
933  pnode = plist;
934  while (pnode != NULL) {
935  pback_node = pnode;
936  pnode = pback_node->pnext;
937  node_remove_from_list(&plist, pback_node);
938  os_free(pback_node->pnode);
939  pback_node->pnode = NULL;
940  os_free(pback_node);
941  pback_node = NULL;
942  }
943 }
944 
945 /******************************************************************************
946  * FunctionName : wifi_softap_set_dhcps_lease
947  * Description : set the lease information of DHCP server
948  * Parameters : please -- Additional argument to set the lease information,
949  * Little-Endian.
950  * Returns : true or false
951 *******************************************************************************/
953 {
954  struct ip_info info;
955  uint32 softap_ip = 0;
956  uint32 start_ip = 0;
957  uint32 end_ip = 0;
958 
959  uint8 opmode = wifi_get_opmode();
960 
961  if (opmode == STATION_MODE || opmode == NULL_MODE) {
962  return false;
963  }
964 
965  if (please == NULL || wifi_softap_dhcps_status() == DHCP_STARTED)
966  return false;
967 
968  if(please->enable) {
969  os_bzero(&info, sizeof(struct ip_info));
970  wifi_get_ip_info(SOFTAP_IF, &info);
971  softap_ip = htonl(info.ip.addr);
972  start_ip = htonl(please->start_ip.addr);
973  end_ip = htonl(please->end_ip.addr);
974 
975  /*config ip information can't contain local ip*/
976  if ((start_ip <= softap_ip) && (softap_ip <= end_ip))
977  return false;
978 
979  /*config ip information must be in the same segment as the local ip*/
980  softap_ip >>= 8;
981  if ((start_ip >> 8 != softap_ip)
982  || (end_ip >> 8 != softap_ip)) {
983  return false;
984  }
985 
986  if (end_ip - start_ip > DHCPS_MAX_LEASE)
987  return false;
988 
989  os_bzero(&dhcps_lease, sizeof(dhcps_lease));
990 // dhcps_lease.start_ip.addr = start_ip;
991 // dhcps_lease.end_ip.addr = end_ip;
993  dhcps_lease.end_ip.addr = please->end_ip.addr;
994  }
995  dhcps_lease.enable = please->enable;
996 // dhcps_lease_flag = false;
997  return true;
998 }
999 
1000 /******************************************************************************
1001  * FunctionName : wifi_softap_get_dhcps_lease
1002  * Description : get the lease information of DHCP server
1003  * Parameters : please -- Additional argument to get the lease information,
1004  * Little-Endian.
1005  * Returns : true or false
1006 *******************************************************************************/
1008 {
1009  uint8 opmode = wifi_get_opmode();
1010 
1011  if (opmode == STATION_MODE || opmode == NULL_MODE) {
1012  return false;
1013  }
1014 
1015  if (NULL == please)
1016  return false;
1017 
1018 // if (dhcps_lease_flag){
1019  if (dhcps_lease.enable == FALSE){
1021  return false;
1022  } else {
1023 // os_bzero(please, sizeof(dhcps_lease));
1024 // if (wifi_softap_dhcps_status() == DHCP_STOPPED){
1025 // please->start_ip.addr = htonl(dhcps_lease.start_ip.addr);
1026 // please->end_ip.addr = htonl(dhcps_lease.end_ip.addr);
1027 // }
1028  }
1029 
1030 // if (wifi_softap_dhcps_status() == DHCP_STARTED){
1031 // os_bzero(please, sizeof(dhcps_lease));
1032 // please->start_ip.addr = dhcps_lease.start_ip.addr;
1033 // please->end_ip.addr = dhcps_lease.end_ip.addr;
1034 // }
1036  please->end_ip.addr = dhcps_lease.end_ip.addr;
1037  return true;
1038 }
1039 
1041 {
1042  list_node *pre = NULL, *p = NULL;
1043  list_node *minpre = NULL, *minp = NULL;
1044  struct dhcps_pool *pdhcps_pool = NULL, *pmin_pool = NULL;
1045  pre = plist;
1046  p = pre->pnext;
1047  minpre = pre;
1048  minp = p;
1049  while (p != NULL){
1050  pdhcps_pool = p->pnode;
1051  pmin_pool = minp->pnode;
1052  if (pdhcps_pool->lease_timer < pmin_pool->lease_timer){
1053  minp = p;
1054  minpre = pre;
1055  }
1056  pre = p;
1057  p = p->pnext;
1058  }
1059  minpre->pnext = minp->pnext;
1060  os_free(minp->pnode);
1061  minp->pnode = NULL;
1062  os_free(minp);
1063  minp = NULL;
1064 }
1065 
1067 {
1068  uint8 num_dhcps_pool = 0;
1069  list_node *pback_node = NULL;
1070  list_node *pnode = NULL;
1071  struct dhcps_pool *pdhcps_pool = NULL;
1072  pnode = plist;
1073  while (pnode != NULL) {
1074  pdhcps_pool = pnode->pnode;
1075  pdhcps_pool->lease_timer --;
1076  if (pdhcps_pool->lease_timer == 0){
1077  pback_node = pnode;
1078  pnode = pback_node->pnext;
1079  node_remove_from_list(&plist,pback_node);
1080  os_free(pback_node->pnode);
1081  pback_node->pnode = NULL;
1082  os_free(pback_node);
1083  pback_node = NULL;
1084  } else {
1085  pnode = pnode ->pnext;
1086  num_dhcps_pool ++;
1087  }
1088  }
1089 
1090  if (num_dhcps_pool >= MAX_STATION_NUM)
1092 }
1093 
1095 {
1096  bool offer_flag = true;
1097  uint8 option = 0;
1098  if (optarg == NULL && wifi_softap_dhcps_status() == false)
1099  return false;
1100 
1101  if (level <= OFFER_START || level >= OFFER_END)
1102  return false;
1103 
1104  switch (level){
1105  case OFFER_ROUTER:
1106  offer = (*(uint8 *)optarg) & 0x01;
1107  offer_flag = true;
1108  break;
1109  default :
1110  offer_flag = false;
1111  break;
1112  }
1113  return offer_flag;
1114 }
1115 
1117 {
1118  uint8 opmode = wifi_get_opmode();
1119 
1120  if (opmode == STATION_MODE || opmode == NULL_MODE) {
1121  return false;
1122  }
1123 
1125  return false;
1126  }
1127 
1128  if(minute == 0) {
1129  return false;
1130  }
1131  dhcps_lease_time = minute;
1132  return true;
1133 }
1134 
1136 {
1137  uint8 opmode = wifi_get_opmode();
1138 
1139  if (opmode == STATION_MODE || opmode == NULL_MODE) {
1140  return false;
1141  }
1142 
1144  return false;
1145  }
1147  return true;
1148 }
1149 
1151 {
1152  return dhcps_lease_time;
1153 }
1154 
1156 {
1157  dns_address = *dns_ip;
1158 }
1159 
1161 {
1162 list_node *pback_node = NULL;
1163 
1164  for (pback_node = plist; pback_node != NULL;pback_node = pback_node->pnext, no--) {
1165  if (no == 0) return pback_node->pnode;
1166  }
1167  return NULL;
1168 }
1169 
1170 void ICACHE_FLASH_ATTR dhcps_set_mapping(struct ip_addr *addr, uint8 *mac, uint32 lease_time)
1171 {
1172 list_node *pback_node = NULL;
1173 list_node *pnode = NULL;
1174 struct dhcps_pool *pdhcps_pool = NULL;
1175 
1176  pdhcps_pool = (struct dhcps_pool *)os_zalloc(sizeof(struct dhcps_pool));
1177  pdhcps_pool->ip.addr = addr->addr;
1178  os_memcpy(pdhcps_pool->mac, mac, sizeof(pdhcps_pool->mac));
1179  pdhcps_pool->lease_timer = lease_time;
1180  pnode = (list_node *)os_zalloc(sizeof(list_node ));
1181  pnode->pnode = pdhcps_pool;
1182  pnode->pnext = NULL;
1183  node_insert_to_list(&plist,pnode);
1184 }
#define DHCPS_SERVER_PORT
Definition: dhcpserver.h:61
#define DHCP_REPLY
Definition: dhcpserver.h:56
bool ICACHE_FLASH_ATTR wifi_softap_reset_dhcps_lease_time(void)
Definition: dhcpserver.c:1135
u16_t tot_len
Definition: pbuf.h:90
static uint8_t *ICACHE_FLASH_ATTR add_offer_options(uint8_t *optptr)
Definition: dhcpserver.c:133
#define DHCPS_STATE_IDLE
Definition: dhcpserver.h:93
#define DHCPRELEASE
Definition: dhcpserver.h:70
struct ip_addr ip
Definition: ip_addr.h:248
void ICACHE_FLASH_ATTR dhcps_set_DNS(struct ip_addr *dns_ip)
Definition: dhcpserver.c:1155
uint8_t hops
Definition: dhcpserver.h:12
#define os_memcmp
Definition: osapi.h:35
#define SOFTAP_IF
#define DHCP_OPTION_REQ_IPADDR
Definition: dhcpserver.h:75
static void ICACHE_FLASH_ATTR wifi_softap_init_dhcps_lease(uint32 ip)
Definition: dhcpserver.c:843
uint8_t op
Definition: dhcpserver.h:12
struct pbuf * next
Definition: pbuf.h:78
u16_t len
Definition: pbuf.h:93
void ICACHE_FLASH_ATTR dhcps_set_mapping(struct ip_addr *addr, uint8 *mac, uint32 lease_time)
Definition: dhcpserver.c:1170
void ICACHE_FLASH_ATTR node_insert_to_list(list_node **phead, list_node *pinsert)
Definition: dhcpserver.c:45
#define DHCPS_STATE_ACK
Definition: dhcpserver.h:91
static uint8_t *ICACHE_FLASH_ATTR add_msg_type(uint8_t *optptr, uint8_t type)
Definition: dhcpserver.c:116
static sint16_t ICACHE_FLASH_ATTR parse_msg(struct dhcps_msg *m, u16_t len)
Definition: dhcpserver.c:578
sint16_t state
Definition: dhcpserver.h:7
#define DHCPS_STATE_RELEASE
Definition: dhcpserver.h:94
void * pnode
Definition: dhcpserver.h:46
uint32 system_get_free_heap_size(void)
uint8_t yiaddr[4]
Definition: dhcpserver.h:16
static struct ip_addr broadcast_dhcps
Definition: dhcpserver.c:25
#define NULL_MODE
#define NULL
Definition: def.h:47
static void ICACHE_FLASH_ATTR send_offer(struct dhcps_msg *m)
Definition: dhcpserver.c:282
uint8_t htype
Definition: dhcpserver.h:12
static uint8_t ICACHE_FLASH_ATTR parse_options(uint8_t *optptr, sint16_t len)
Definition: dhcpserver.c:485
static void ICACHE_FLASH_ATTR send_ack(struct dhcps_msg *m)
Definition: dhcpserver.c:414
uint8_t file[128]
Definition: dhcpserver.h:21
#define htons(x)
Definition: def.h:81
static void ICACHE_FLASH_ATTR send_nak(struct dhcps_msg *m)
Definition: dhcpserver.c:348
static void ICACHE_FLASH_ATTR kill_oldest_dhcps_pool(void)
Definition: dhcpserver.c:1040
struct ip_addr end_ip
#define DHCPACK
Definition: dhcpserver.h:68
#define ICACHE_FLASH_ATTR
Definition: c_types.h:99
#define FALSE
Definition: c_types.h:111
uint8 mac[6]
Definition: dhcpserver.h:41
uint32 lease_timer
Definition: dhcpserver.h:42
bool wifi_get_ip_info(uint8 if_index, struct ip_info *info)
#define DHCP_OPTION_MSG_TYPE
Definition: dhcpserver.h:77
uint16_t flags
Definition: dhcpserver.h:14
#define DHCPS_CLIENT_PORT
Definition: dhcpserver.h:62
uint8_t hlen
Definition: dhcpserver.h:12
#define TRUE
Definition: c_types.h:110
Definition: pbuf.h:58
struct netif * eagle_lwip_getif(uint8 index)
uint32 ICACHE_FLASH_ATTR wifi_softap_get_dhcps_lease_time(void)
Definition: dhcpserver.c:1150
bool ICACHE_FLASH_ATTR wifi_softap_set_dhcps_offer_option(uint8 level, void *optarg)
Definition: dhcpserver.c:1094
struct ip_addr gw
Definition: ip_addr.h:250
#define dhcps_router_enabled(offer)
Definition: dhcpserver.h:96
#define os_printf
Definition: osapi.h:62
#define DHCPS_STATE_NAK
Definition: dhcpserver.h:92
#define MAX_STATION_NUM
Definition: dhcpserver.h:87
uint8 wifi_get_opmode(void)
#define DHCPREQUEST
Definition: dhcpserver.h:66
#define os_zalloc(s)
Definition: mem.h:44
static bool renew
Definition: dhcpserver.c:36
#define DHCP_OPTION_END
Definition: dhcpserver.h:83
#define os_memcpy
Definition: osapi.h:36
#define DHCP_OPTION_PERFORM_ROUTER_DISCOVERY
Definition: dhcpserver.h:80
#define os_memset
Definition: osapi.h:38
#define DHCP_OPTION_LEASE_TIME
Definition: dhcpserver.h:76
enum dhcp_status wifi_softap_dhcps_status(void)
#define DHCP_OPTION_INTERFACE_MTU
Definition: dhcpserver.h:79
signed short sint16_t
Definition: c_types.h:34
#define DHCPDISCOVER
Definition: dhcpserver.h:64
uint8_t giaddr[4]
Definition: dhcpserver.h:18
uint8_t chaddr[16]
Definition: dhcpserver.h:19
static void ICACHE_FLASH_ATTR handle_dhcp(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct ip_addr *addr, uint16_t port)
Definition: dhcpserver.c:744
static struct ip_addr dns_address
Definition: dhcpserver.c:30
Definition: pbuf.h:76
unsigned char uint8
Definition: c_types.h:45
s8_t err_t
Definition: err.h:47
static ip_addr_t dns_ip
Definition: wifi.c:65
struct _list_node * pnext
Definition: dhcpserver.h:47
Definition: netif.h:139
bool ICACHE_FLASH_ATTR wifi_softap_set_dhcps_lease(struct dhcps_lease *please)
Definition: dhcpserver.c:952
#define DHCPS_STATE_OFFER
Definition: dhcpserver.h:89
static struct ip_addr client_address
Definition: dhcpserver.c:27
struct ip_addr ip
Definition: dhcpserver.h:40
#define DHCP_HTYPE_ETHERNET
Definition: dhcpserver.h:57
uint8_t sname[64]
Definition: dhcpserver.h:20
struct dhcps_pool *ICACHE_FLASH_ATTR dhcps_get_mapping(uint16_t no)
Definition: dhcpserver.c:1160
#define os_free(s)
Definition: mem.h:40
static uint8 offer
Definition: dhcpserver.c:35
#define ip_addr_isany(addr1)
Definition: ip_addr.h:200
#define DHCP_OPTION_ROUTER
Definition: dhcpserver.h:73
#define ip4_addr3(ipaddr)
Definition: ip_addr.h:222
#define DHCP_OPTION_BROADCAST_ADDRESS
Definition: dhcpserver.h:81
void ICACHE_FLASH_ATTR dhcps_start(struct ip_info *info)
Definition: dhcpserver.c:886
#define BOOTP_BROADCAST
Definition: dhcpserver.h:53
#define DHCP_OPTION_DNS_SERVER
Definition: dhcpserver.h:74
unsigned int uint32
Definition: c_types.h:54
u8_t pbuf_free(struct pbuf *p) ICACHE_FLASH_ATTR
Definition: pbuf.c:685
struct ip_addr start_ip
uint8_t ciaddr[4]
Definition: dhcpserver.h:15
#define DHCPS_LEASE_TIME_DEF
Definition: dhcpserver.c:37
#define STATION_MODE
void ICACHE_FLASH_ATTR dhcps_stop(void)
Definition: dhcpserver.c:919
void ICACHE_FLASH_ATTR dhcps_coarse_tmr(void)
Definition: dhcpserver.c:1066
bool ICACHE_FLASH_ATTR wifi_softap_set_dhcps_lease_time(uint32 minute)
Definition: dhcpserver.c:1116
uint16_t secs
Definition: dhcpserver.h:14
void ICACHE_FLASH_ATTR node_remove_from_list(list_node **phead, list_node *pdelete)
Definition: dhcpserver.c:86
unsigned char u8_t
Definition: cc.h:52
static struct udp_pcb * pcb_dhcps
Definition: dhcpserver.c:24
#define DHCP_OPTION_SUBNET_MASK
Definition: dhcpserver.h:72
void * payload
Definition: pbuf.h:81
uint32 dhcps_lease_time
Definition: dhcpserver.c:38
#define DHCPOFFER
Definition: dhcpserver.h:65
bool ICACHE_FLASH_ATTR wifi_softap_get_dhcps_lease(struct dhcps_lease *please)
Definition: dhcpserver.c:1007
#define ip4_addr2(ipaddr)
Definition: ip_addr.h:221
#define DHCPS_MAX_LEASE
Definition: dhcpserver.h:52
static uint8_t *ICACHE_FLASH_ATTR add_end(uint8_t *optptr)
Definition: dhcpserver.c:242
uint8_t options[312]
Definition: dhcpserver.h:22
#define os_bzero
Definition: osapi.h:31
static void ICACHE_FLASH_ATTR create_msg(struct dhcps_msg *m)
Definition: dhcpserver.c:250
#define ip4_addr4(ipaddr)
Definition: ip_addr.h:223
static list_node * plist
Definition: dhcpserver.c:34
u16_t ref
Definition: pbuf.h:106
u32_t addr
Definition: ip_addr.h:45
#define ip4_addr1(ipaddr)
Definition: ip_addr.h:220
uint8_t siaddr[4]
Definition: dhcpserver.h:17
static struct ip_addr server_address
Definition: dhcpserver.c:26
static const uint32 magic_cookie ICACHE_RODATA_ATTR
Definition: dhcpserver.c:23
static struct ip_addr client_address_plus
Definition: dhcpserver.c:28
#define htonl(x)
Definition: def.h:83
#define DHCPDECLINE
Definition: dhcpserver.h:67
struct pbuf * pbuf_alloc(pbuf_layer l, u16_t length, pbuf_type type) ICACHE_FLASH_ATTR
Definition: pbuf.c:234
unsigned short u16_t
Definition: cc.h:54
#define DHCP_OPTION_SERVER_ID
Definition: dhcpserver.h:78
#define DHCPNAK
Definition: dhcpserver.h:69
#define IP4_ADDR(ipaddr, a, b, c, d)
Definition: ip_addr.h:139
#define DHCPS_LEASE_TIMER
Definition: dhcpserver.h:51