dhcpserver.c 36 KB

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