/**
 * lwip MDNS resolver file.
 *
 * Created on: Jul 29, 2010
 * Author: Daniel Toma
 *

 * ported from uIP resolv.c Copyright (c) 2002-2003, Adam Dunkels.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/**

 * This file implements a MDNS host name and PUCK service registration.

 *-----------------------------------------------------------------------------
 * Includes
 *----------------------------------------------------------------------------*/
#include "lwip/opt.h"
#if LWIP_MDNS /* don't build if not configured for use in lwipopts.h */
#include "lwip/mdns.h"
#include "lwip/puck_def.h"
#include "lwip/udp.h"
#include "lwip/mem.h"
#include "lwip/igmp.h"
#include "osapi.h"
#include "os_type.h"
#include "user_interface.h"
/** DNS server IP address */
#ifndef DNS_MULTICAST_ADDRESS
#define DNS_MULTICAST_ADDRESS        ipaddr_addr("224.0.0.251") /* resolver1.opendns.com */
#endif

/** DNS server IP address */
#ifndef MDNS_LOCAL
#define MDNS_LOCAL                "local" /* resolver1.opendns.com */
#endif

/** DNS server port address */
#ifndef DNS_MDNS_PORT
#define DNS_MDNS_PORT           5353
#endif

/** DNS maximum number of retries when asking for a name, before "timeout". */
#ifndef DNS_MAX_RETRIES
#define DNS_MAX_RETRIES           4
#endif

/** DNS resource record max. TTL (one week as default) */
#ifndef DNS_MAX_TTL
#define DNS_MAX_TTL               604800
#endif

/* DNS protocol flags */
#define DNS_FLAG1_RESPONSE        0x84
#define DNS_FLAG1_OPCODE_STATUS   0x10
#define DNS_FLAG1_OPCODE_INVERSE  0x08
#define DNS_FLAG1_OPCODE_STANDARD 0x00
#define DNS_FLAG1_AUTHORATIVE     0x04
#define DNS_FLAG1_TRUNC           0x02
#define DNS_FLAG1_RD              0x01
#define DNS_FLAG2_RA              0x80
#define DNS_FLAG2_ERR_MASK        0x0f
#define DNS_FLAG2_ERR_NONE        0x00
#define DNS_FLAG2_ERR_NAME        0x03

/* DNS protocol states */
#define DNS_STATE_UNUSED          0
#define DNS_STATE_NEW             1
#define DNS_STATE_ASKING          2
#define DNS_STATE_DONE            3

/* MDNS registration type */
#define MDNS_HOSTNAME_REG         0
#define MDNS_SERVICE_REG          1

/* MDNS registration type */
#define MDNS_REG_ANSWER           1
#define MDNS_SD_ANSWER            2
#define MDNS_SERVICE_REG_ANSWER   3

/* MDNS registration time */
#define MDNS_HOST_TIME            120
#define MDNS_SERVICE_TIME         3600

/** MDNS name length with "." at the beginning and end of name*/
#ifndef MDNS_LENGTH_ADD
#define MDNS_LENGTH_ADD           2
#endif

#ifdef MDNS_MAX_NAME_LENGTH
#undef MDNS_MAX_NAME_LENGTH
#endif
#define MDNS_MAX_NAME_LENGTH      (256)

PACK_STRUCT_BEGIN
/** DNS message header */
struct mdns_hdr {
	PACK_STRUCT_FIELD(u16_t id);
	PACK_STRUCT_FIELD(u8_t flags1);
	PACK_STRUCT_FIELD(u8_t flags2);
	PACK_STRUCT_FIELD(u16_t numquestions);
	PACK_STRUCT_FIELD(u16_t numanswers);
	PACK_STRUCT_FIELD(u16_t numauthrr);
	PACK_STRUCT_FIELD(u16_t numextrarr);
}PACK_STRUCT_STRUCT;
PACK_STRUCT_END

#define SIZEOF_DNS_HDR 12

PACK_STRUCT_BEGIN
/** MDNS query message structure */
struct mdns_query {
	/* MDNS query record starts with either a domain name or a pointer
	 to a name already present somewhere in the packet. */PACK_STRUCT_FIELD(u16_t type);
	PACK_STRUCT_FIELD(u16_t class);
}PACK_STRUCT_STRUCT;
PACK_STRUCT_END

#define SIZEOF_DNS_QUERY 4

PACK_STRUCT_BEGIN
/** MDNS answer message structure */
struct mdns_answer {
	/* MDNS answer record starts with either a domain name or a pointer
	 to a name already present somewhere in the packet. */PACK_STRUCT_FIELD(u16_t type);
	PACK_STRUCT_FIELD(u16_t class);
	PACK_STRUCT_FIELD(u32_t ttl);
	PACK_STRUCT_FIELD(u16_t len);
}PACK_STRUCT_STRUCT;
PACK_STRUCT_END
#define SIZEOF_DNS_ANSWER 10

PACK_STRUCT_BEGIN
/** MDNS answer message structure */
struct mdns_auth {
	PACK_STRUCT_FIELD(u32_t src);
}PACK_STRUCT_STRUCT;
PACK_STRUCT_END

#define SIZEOF_MDNS_AUTH 4
PACK_STRUCT_BEGIN
/** MDNS service registration message structure */
struct mdns_service {
	PACK_STRUCT_FIELD(u16_t prior);
	PACK_STRUCT_FIELD(u16_t weight);
	PACK_STRUCT_FIELD(u16_t port);
}PACK_STRUCT_STRUCT;
PACK_STRUCT_END

#define SIZEOF_MDNS_SERVICE 6

uint16 PUCK_PORT ;
os_timer_t mdns_timer;
/* forward declarations */
static void mdns_recv(void *s, struct udp_pcb *pcb, struct pbuf *p,
		struct ip_addr *addr, u16_t port);

/*-----------------------------------------------------------------------------
 * Globales
 *----------------------------------------------------------------------------*/

/* MDNS variables */
static char host_name[MDNS_NAME_LENGTH];
static char service_name[MDNS_NAME_LENGTH];
static char server_name[MDNS_NAME_LENGTH];
//static char puck_datasheet[PUCK_DATASHEET_SIZE];
static struct udp_pcb *mdns_pcb;

static struct ip_addr multicast_addr;
static struct ip_addr host_addr;
static uint8 register_flag = 0;
static uint8 mdns_flag = 0;
//#if (DNS_USES_STATIC_BUF == 1)
static u8_t mdns_payload[DNS_MSG_SIZE];
//#endif /* (MDNS_USES_STATIC_BUF == 1) */
/*
 *  Function to set the UDP pcb used to send the mDNS packages
 */
void ICACHE_FLASH_ATTR
getPcb(struct udp_pcb *pcb) {
	mdns_pcb = pcb;
}

#if DNS_DOES_NAME_CHECK
/**
 * Compare the "dotted" name "query" with the encoded name "response"
 * to make sure an answer from the DNS server matches the current mdns_table
 * entry (otherwise, answers might arrive late for hostname not on the list
 * any more).
 *
 * @param query hostname (not encoded) from the mdns_table
 * @param response encoded hostname in the DNS response
 * @return 0: names equal; 1: names differ
 */
static u8_t ICACHE_FLASH_ATTR
mdns_compare_name(unsigned char *query, unsigned char *response) {
	unsigned char n;

	do {
		n = *response++;
		/** @see RFC 1035 - 4.1.4. Message compression */
		if ((n & 0xc0) == 0xc0) {
			/* Compressed name */
			break;
		} else {
			/* Not compressed name */
			while (n > 0) {
				if ((*query) != (*response)) {
					return 1;
				}
				++response;
				++query;
				--n;
			};
			++query;
		}
	} while (*response != 0);

	return 0;
}
#endif /* DNS_DOES_NAME_CHECK */
/**
 * Send a mDNS answer packet.
 *
 * @param type of answer hostname and service registration or service
 * @param name to query
 * @param id transaction ID in the DNS query packet
 * @return ERR_OK if packet is sent; an err_t indicating the problem otherwise
 */
static err_t ICACHE_FLASH_ATTR
mdns_answer(u16_t type, const char* name, u8_t id) {
	err_t err;
	struct mdns_hdr *hdr;
	struct mdns_answer ans;
	struct mdns_auth auth;
	struct mdns_service serv;
	struct pbuf *p ,*p_sta;
	char *query, *nptr;
	const char *pHostname;
	struct netif * sta_netif = NULL;
	struct netif * ap_netif = NULL;
	static char tmpBuf[PUCK_DATASHEET_SIZE + PUCK_SERVICE_LENGTH];
	u8_t n;
	u16_t length = 0;
	/* if here, we have either a new query or a retry on a previous query to process */
	p = pbuf_alloc(PBUF_TRANSPORT,
			SIZEOF_DNS_HDR + MDNS_MAX_NAME_LENGTH * 2 + SIZEOF_DNS_QUERY, PBUF_RAM);
	if (p != NULL) {
		LWIP_ASSERT("pbuf must be in one piece", p->next == NULL);
		/* fill dns header */
		hdr = (struct mdns_hdr*) p->payload;
		os_memset(hdr, 0, SIZEOF_DNS_HDR);
		hdr->id = htons(id);
		hdr->flags1 = DNS_FLAG1_RESPONSE;

		if (type == MDNS_SD_ANSWER) {
			pHostname = DNS_SD_SERVICE;
			hdr->numanswers = htons(1);
		} else if (type == MDNS_SERVICE_REG_ANSWER) {
			pHostname = PUCK_SERVICE;
			hdr->numanswers = htons(type);
		} else {
			pHostname = name;
			hdr->numanswers = htons(type);
		}
		query = (char*) hdr + SIZEOF_DNS_HDR;
		--pHostname;
		/* convert hostname into suitable query format. */
		do {
			++pHostname;
			nptr = query;
			++query;
			for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
				*query = *pHostname;
				++query;
				++n;
			}
			*nptr = n;
		} while (*pHostname != 0);
		*query++ = '\0';
		/* fill dns query */

		if (type == MDNS_REG_ANSWER) {

			ans.type = htons(DNS_RRTYPE_A);
			ans.class = htons(DNS_RRCLASS_IN);
			ans.ttl = htonl(MDNS_SERVICE_TIME);
			ans.len = htons(DNS_IP_ADDR_LEN);
			length = DNS_IP_ADDR_LEN;

			MEMCPY( query, &ans, SIZEOF_DNS_ANSWER);

			/* resize the query */
			query = query + SIZEOF_DNS_ANSWER;

			/* set the local IP address */
			auth.src = host_addr.addr;
			MEMCPY( query, &auth, SIZEOF_MDNS_AUTH);
		}
		if (type == MDNS_SD_ANSWER) {

			ans.type = htons(DNS_RRTYPE_PTR);
			ans.class = htons(DNS_RRCLASS_IN);
			ans.ttl = htonl(300);
			ans.len = htons(os_strlen(PUCK_SERVICE) + 1 +1 );
			length = 0;

			MEMCPY( query, &ans, SIZEOF_DNS_ANSWER);

			/* resize the query */
			query = query + SIZEOF_DNS_ANSWER;
			pHostname = PUCK_SERVICE;
			--pHostname;

			/* convert hostname into suitable query format. */
			do {
				++pHostname;
				nptr = query;
				++query;
				for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
					*query = *pHostname;
					++query;
					++n;
				}
				*nptr = n;
			} while (*pHostname != 0);
			*query++ = '\0';
		}

		if (type == MDNS_SERVICE_REG_ANSWER) {

			ans.type = htons(DNS_RRTYPE_PTR);
			ans.class = htons(DNS_RRCLASS_IN);
			ans.ttl = htonl(MDNS_SERVICE_TIME);
			os_strcpy(tmpBuf, name);
			os_strcat(tmpBuf, ".");
			os_strcat(tmpBuf, PUCK_SERVICE);

			length = os_strlen(tmpBuf) + MDNS_LENGTH_ADD;
			ans.len = htons(length);
			length = 0;

			MEMCPY( query, &ans, SIZEOF_DNS_ANSWER);

			/* resize the query */
			query = query + SIZEOF_DNS_ANSWER;

			pHostname = tmpBuf;
			--pHostname;

			/* convert hostname into suitable query format. */
			do {
				++pHostname;
				nptr = query;
				++query;
				for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
					*query = *pHostname;
					++query;
					++n;
				}
				*nptr = n;
			} while (*pHostname != 0);
			*query++ = '\0';

			/* Service query*/
			pHostname = name;
			--pHostname;

			/* convert hostname into suitable query format. */
			do {
				++pHostname;
				nptr = query;
				++query;
				for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
					*query = *pHostname;
					++query;
					++n;
				}
				*nptr = n;
			} while (*pHostname != 0);

			/* Add to the service name the service local
			 * pointing to the beginning of the mDNS message*/
			*query++ = DNS_OFFSET_FLAG;
			*query++ = DNS_DEFAULT_OFFSET;

			/* fill the query */

			ans.type = htons(DNS_RRTYPE_SRV);
			ans.class = htons(DNS_RRCLASS_FLUSH_IN);
			ans.ttl = htonl(MDNS_SERVICE_TIME);
			os_strcpy(tmpBuf, host_name);
			os_strcat(tmpBuf, ".");
			os_strcat(tmpBuf, MDNS_LOCAL);
			length = os_strlen(tmpBuf) + MDNS_LENGTH_ADD;
			ans.len = htons(SIZEOF_MDNS_SERVICE + length);
			length = 0;
			MEMCPY( query, &ans, SIZEOF_DNS_ANSWER);

			/* resize the query */
			query = query + SIZEOF_DNS_ANSWER;
			/* fill the service properties */

			serv.prior = htons(0);
			serv.weight = htons(0);
			serv.port = htons(PUCK_PORT);
			MEMCPY( query, &serv, SIZEOF_MDNS_SERVICE);
			/* resize the query */
			query = query + SIZEOF_MDNS_SERVICE;

			pHostname = tmpBuf;
			--pHostname;

			/* convert hostname into suitable query format. */
			do {
				++pHostname;
				nptr = query;
				++query;
				for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
					*query = *pHostname;
					++query;
					++n;
				}
				*nptr = n;
			} while (*pHostname != 0);
			*query++ = '\0';

			/* TXT answer */
			pHostname = name;
			--pHostname;

			/* convert hostname into suitable query format. */
			do {
				++pHostname;
				nptr = query;
				++query;
				for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
					*query = *pHostname;
					++query;
					++n;
				}
				*nptr = n;
			} while (*pHostname != 0);

			/* Add to the service name the service local
			 * pointing to the beginning of the mDNS message*/
			*query++ = DNS_OFFSET_FLAG;
			*query++ = DNS_DEFAULT_OFFSET;

			/* fill the answer */
			ans.type = htons(DNS_RRTYPE_TXT);
			ans.class = htons(DNS_RRCLASS_IN);
			ans.ttl = htonl(MDNS_SERVICE_TIME);
			length = sizeof(SERVICE_DESCRIPTION);
			ans.len = htons(length);
			length = 0;
			MEMCPY( query, &ans, SIZEOF_DNS_ANSWER);

			/* resize the query */
			query = query + SIZEOF_DNS_ANSWER;

			pHostname = SERVICE_DESCRIPTION;
			--pHostname;

			/* convert hostname into suitable query format. */
			do {
				++pHostname;
				nptr = query;
				++query;
				for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
					*query = *pHostname;
					++query;
					++n;
				}
				*nptr = n;
			} while (*pHostname != 0);
			*query++ = '\0';
		}
		/* resize pbuf to the exact dns query */
		pbuf_realloc(p, (query + length) - ((char*) (p->payload)));

		/* send dns packet */
		/*add by tzx for AP + STA MDNS begin------*/
		sta_netif = (struct netif *)eagle_lwip_getif(0x00);
		ap_netif =  (struct netif *)eagle_lwip_getif(0x01);
		if(wifi_get_opmode() == 0x03 && wifi_get_broadcast_if() == 0x03 &&\
				sta_netif != NULL && ap_netif != NULL) {
			if(netif_is_up(sta_netif) && netif_is_up(ap_netif)) {

				p_sta = pbuf_alloc(PBUF_TRANSPORT,
							SIZEOF_DNS_HDR + MDNS_MAX_NAME_LENGTH * 2 + SIZEOF_DNS_QUERY, PBUF_RAM);
			  if (pbuf_copy (p_sta,p) != ERR_OK) {
				  os_printf("mdns_answer copying to new pbuf failed\n");
				  return -1;
			  }
			  netif_set_default(sta_netif);
			  err = udp_sendto(mdns_pcb, p_sta, &multicast_addr, DNS_MDNS_PORT);
			  pbuf_free(p_sta);
			  netif_set_default(ap_netif);
			}
		}
		/*add by tzx for AP + STA MDNS end------*/
		err = udp_sendto(mdns_pcb, p, &multicast_addr, DNS_MDNS_PORT);
		/* free pbuf */
		pbuf_free(p);
	} else {
		err = ERR_MEM;
	}

	return err;
}

/**
 * Send a mDNS service answer packet.
 *
 * @param name service name to query
 * @param id transaction ID in the DNS query packet
 * @return ERR_OK if packet is sent; an err_t indicating the problem otherwise
 */
static err_t ICACHE_FLASH_ATTR
mdns_send_service(struct mdns_info *info, u8_t id) {
	err_t err;
	struct mdns_hdr *hdr;
	struct mdns_answer ans;
	struct mdns_service serv;
	struct mdns_auth auth;
	struct pbuf *p ,*p_sta;
	char *query, *nptr;
	const char *pHostname;
	char *device_info;
	const char *name = info->host_name;
	u8_t n;
	u8_t i = 0;
	u16_t length = 0;
	u8_t addr1 = 12, addr2 = 12;
	struct netif * sta_netif = NULL;
	struct netif * ap_netif = NULL;
	static char tmpBuf[PUCK_DATASHEET_SIZE + PUCK_SERVICE_LENGTH];
	/* if here, we have either a new query or a retry on a previous query to process */
	p = pbuf_alloc(PBUF_TRANSPORT,
			SIZEOF_DNS_HDR + MDNS_MAX_NAME_LENGTH * 2 + SIZEOF_DNS_QUERY, PBUF_RAM);
	if (p != NULL) {
		LWIP_ASSERT("pbuf must be in one piece", p->next == NULL);
		/* fill dns header */
		hdr = (struct mdns_hdr*) p->payload;
		os_memset(hdr, 0, SIZEOF_DNS_HDR);
		hdr->id = htons(id);
		hdr->flags1 = DNS_FLAG1_RESPONSE;
		hdr->numanswers = htons(4);
		query = (char*) hdr + SIZEOF_DNS_HDR;
		os_strcpy(tmpBuf, PUCK_SERVICE);

		pHostname = tmpBuf;
		--pHostname;

		/* convert hostname into suitable query format. */
		do {
			++pHostname;
			nptr = query;
			++query;
			++addr1;
			++addr2;
			for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
				*query = *pHostname;
				++query;
				++addr1;
				++addr2;
				++n;
			}
			*nptr = n;
		} while (*pHostname != 0);
		*query++ = '\0';
		length = sizeof(MDNS_LOCAL);
		addr1 -= length;
		length = os_strlen(PUCK_SERVICE) + 1;
		addr2 -= length;

		ans.type = htons(DNS_RRTYPE_PTR);
		ans.class = htons(DNS_RRCLASS_IN);
		ans.ttl = htonl(300);
		os_strcpy(tmpBuf, name);
		length = os_strlen(tmpBuf) + MDNS_LENGTH_ADD + 1;
		ans.len = htons(length);
		length = 0;

		MEMCPY( query, &ans, SIZEOF_DNS_ANSWER);
		/* resize the query */
		query = query + SIZEOF_DNS_ANSWER;

		pHostname = tmpBuf;
		--pHostname;
		/* convert hostname into suitable query format. */
		do {
			++pHostname;
			nptr = query;
			++query;
			for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
				*query = *pHostname;
				++query;
				++n;
			}
			*nptr = n;
		} while (*pHostname != 0);
		*query++ = DNS_OFFSET_FLAG;
		*query++ = DNS_DEFAULT_OFFSET;
		pHostname = name;
		--pHostname;
		/* convert hostname into suitable query format. */
		do {
			++pHostname;
			nptr = query;
			++query;
			for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
				*query = *pHostname;
				++query;
				++n;
			}
			*nptr = n;
		} while (*pHostname != 0);
		//*query++ = '\0';
		*query++ = DNS_OFFSET_FLAG;
		*query++ = DNS_DEFAULT_OFFSET;

		/* fill the answer */
		ans.type = htons(DNS_RRTYPE_TXT);
		ans.class = htons(DNS_RRCLASS_FLUSH_IN);
		ans.ttl = htonl(300);
//		length = os_strlen(TXT_DATA) + MDNS_LENGTH_ADD + 1;
		device_info = (char *)os_zalloc(50);
		ets_sprintf(device_info,"vendor = %s","Espressif");
		for(i = 0; i < 10 &&(info->txt_data[i] != NULL);i++) {
			length += os_strlen(info->txt_data[i]);
			length++;
		}
		length += os_strlen(device_info)+ 1 ;
		ans.len = htons(length);
		length = 0;
		MEMCPY( query, &ans, SIZEOF_DNS_ANSWER);
		query = query + SIZEOF_DNS_ANSWER;
		pHostname = device_info;
		--pHostname;
		/* convert hostname into suitable query format. */
		do {
			++pHostname;
			nptr = query;
			++query;
			for (n = 0;  *pHostname != 0; ++pHostname) {
				*query = *pHostname;
				++query;
				++n;
			}
			*nptr = n;
		} while (*pHostname != 0);
		i = 0;
		while(info->txt_data[i] != NULL && i < 10) {
			pHostname = info->txt_data[i];
			--pHostname;
			/* convert hostname into suitable query format. */
			do {
				++pHostname;
				nptr = query;
				++query;
				for (n = 0;  *pHostname != 0; ++pHostname) {
					*query = *pHostname;
					++query;
					++n;
				}
				*nptr = n;
			} while (*pHostname != 0);
			i++;
		}
//		*query++ = '\0';
		os_free(device_info);
		os_strcpy(tmpBuf, name);
		pHostname = tmpBuf;
		--pHostname;
		do {
			++pHostname;
			nptr = query;
			++query;
			for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
				*query = *pHostname;
				++query;
				++n;
			}
			*nptr = n;
		} while (*pHostname != 0);

		*query++ = DNS_OFFSET_FLAG;
		*query++ = DNS_DEFAULT_OFFSET;

		ans.type = htons(DNS_RRTYPE_SRV);
		ans.class = htons(DNS_RRCLASS_FLUSH_IN);
		ans.ttl = htonl(300);
		os_strcpy(tmpBuf,service_name);
		os_strcat(tmpBuf, ".");
		os_strcat(tmpBuf, MDNS_LOCAL);
		length = os_strlen(tmpBuf) + MDNS_LENGTH_ADD;
		ans.len = htons(SIZEOF_MDNS_SERVICE + length);
		length = 0;
		MEMCPY( query, &ans, SIZEOF_DNS_ANSWER);

		/* resize the query */
		query = query + SIZEOF_DNS_ANSWER;

		serv.prior = htons(0);
		serv.weight = htons(0);
		serv.port = htons(PUCK_PORT);
		MEMCPY( query, &serv, SIZEOF_MDNS_SERVICE);
		/* resize the query */
		query = query + SIZEOF_MDNS_SERVICE;

		pHostname = tmpBuf;
		--pHostname;
		do {
			++pHostname;
			nptr = query;
			++query;
			for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
				*query = *pHostname;
				++query;
				++n;
			}
			*nptr = n;
		} while (*pHostname != 0);
		*query++ = '\0';
		/* set the name of the authority field.
		 * The same name as the Query using the offset address*/
		os_strcpy(tmpBuf,service_name);
		os_strcat(tmpBuf, ".");
		os_strcat(tmpBuf, MDNS_LOCAL);
		pHostname = tmpBuf;
		--pHostname;
		do {
			++pHostname;
			nptr = query;
			++query;
			for (n = 0; *pHostname != '.' && *pHostname != 0; ++pHostname) {
				*query = *pHostname;
				++query;
				++n;
			}
			*nptr = n;
		} while (*pHostname != 0);
		*query++ = '\0';
		/* set the name of the authority field.
		 * The same name as the Query using the offset address*/
		//*query++ = DNS_OFFSET_FLAG;
		//*query++ = DNS_DEFAULT_OFFSET;
		ans.type = htons(DNS_RRTYPE_A);
		ans.class = htons(DNS_RRCLASS_FLUSH_IN);
		ans.ttl = htonl(300);
		ans.len = htons(DNS_IP_ADDR_LEN);

		MEMCPY( query, &ans, SIZEOF_DNS_ANSWER);

		/* resize the query */
		query = query + SIZEOF_DNS_ANSWER;

		/* fill the payload of the mDNS message */
		/* set the local IP address */
		auth.src = host_addr.addr; //ipAddr;
		MEMCPY( query, &auth, SIZEOF_MDNS_AUTH);
		/* resize the query */
		query = query + SIZEOF_MDNS_AUTH;

		/* set the name of the authority field.
		 * The same name as the Query using the offset address*/

		/* resize pbuf to the exact dns query */
		pbuf_realloc(p, (query) - ((char*) (p->payload)));
		/* send dns packet */
		sta_netif = (struct netif *)eagle_lwip_getif(0x00);
		ap_netif =  (struct netif *)eagle_lwip_getif(0x01);
		if(wifi_get_opmode() == 0x03 && wifi_get_broadcast_if() == 0x03 &&\
				sta_netif != NULL && ap_netif != NULL) {
			if(netif_is_up(sta_netif) && netif_is_up(ap_netif)) {

				p_sta = pbuf_alloc(PBUF_TRANSPORT,
							SIZEOF_DNS_HDR + MDNS_MAX_NAME_LENGTH * 2 + SIZEOF_DNS_QUERY, PBUF_RAM);
			  if (pbuf_copy (p_sta,p) != ERR_OK) {
				  os_printf("mdns_send_service copying to new pbuf failed\n");
				  return -1;
			  }
			  netif_set_default(sta_netif);
			  err = udp_sendto(mdns_pcb, p_sta, &multicast_addr, DNS_MDNS_PORT);
			  pbuf_free(p_sta);
			  netif_set_default(ap_netif);
			}
		}
		err = udp_sendto(mdns_pcb, p, &multicast_addr, DNS_MDNS_PORT);

		/* free pbuf */
		pbuf_free(p);
	} else {
		os_printf("ERR_MEM \n");
		err = ERR_MEM;
	}

	return err;
}

/**
 * Receive input function for DNS response packets arriving for the dns UDP pcb.
 *
 * @params see udp.h
 */
static void ICACHE_FLASH_ATTR
mdns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct ip_addr *addr,
		u16_t port) {
	u8_t i;
	struct mdns_hdr *hdr;
	u8_t nquestions;
	LWIP_UNUSED_ARG(arg);
	LWIP_UNUSED_ARG(pcb);
	LWIP_UNUSED_ARG(addr);
	LWIP_UNUSED_ARG(port);
	struct mdns_info *info = (struct mdns_info *)arg;
	/* is the dns message too big ? */
	if (p->tot_len > DNS_MSG_SIZE) {
		LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: pbuf too big\n"));
		/* free pbuf and return */
		goto memerr1;
	}

	/* is the dns message big enough ? */
	if (p->tot_len < (SIZEOF_DNS_HDR + SIZEOF_DNS_QUERY + SIZEOF_DNS_ANSWER)) {
		LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: pbuf too small\n"));
		/* free pbuf and return */
		goto memerr1;
	}
	/* copy dns payload inside static buffer for processing */
	if (pbuf_copy_partial(p, mdns_payload, p->tot_len, 0) == p->tot_len) {
		/* The ID in the DNS header should be our entry into the name table. */
		hdr = (struct mdns_hdr*) mdns_payload;

		i = htons(hdr->id);
		if (i < DNS_TABLE_SIZE) {

			nquestions = htons(hdr->numquestions);
			//nanswers   = htons(hdr->numanswers);
			/* if we have a question send an answer if necessary */
			if (nquestions > 0) {
				/* MDNS_DS_DOES_NAME_CHECK */
				/* Check if the name in the "question" part match with the name of the MDNS DS service. */
				if (mdns_compare_name((unsigned char *) DNS_SD_SERVICE,
						(unsigned char *) mdns_payload + SIZEOF_DNS_HDR) == 0) {
					/* respond with the puck service*/
					mdns_answer(MDNS_SD_ANSWER, PUCK_SERVICE, 0);
				} else if (mdns_compare_name((unsigned char *) PUCK_SERVICE,
						(unsigned char *) mdns_payload + SIZEOF_DNS_HDR) == 0) {
					/* respond with the puck service*/
					mdns_send_service(info, 0);
				} else
					goto memerr2;
			}
		}
	}
	goto memerr2;
	memerr2:
	mem_free(mdns_payload);
	memerr1:
	/* free pbuf */
	pbuf_free(p);
	return;
}

/**
 * close the UDP pcb .
 */
void ICACHE_FLASH_ATTR
mdns_close(void)
{
	if (mdns_pcb != NULL)
		udp_remove(mdns_pcb);
}

void ICACHE_FLASH_ATTR
mdns_set_name(const char *name)
{
	//strcpy(host_name, name);
	os_strcpy(service_name, name);
}

void ICACHE_FLASH_ATTR
mdns_enable(void)
{
	if(mdns_flag == 0) {
		udp_recv(mdns_pcb, mdns_recv, NULL);
	}
}

void ICACHE_FLASH_ATTR
mdns_disable(void)
{
	if (mdns_flag == 1) {
		udp_recv(mdns_pcb, NULL, NULL);
	}
}

/**
 * close the UDP pcb .
 */
char* ICACHE_FLASH_ATTR
mdns_get_hostname(void) {
	//strcpy(host_name, name);
	char *name = host_name;
	if (host_name[0] != 0 ) {
	return name;
	} else {
		return ("Espressif");
	}
}

void ICACHE_FLASH_ATTR
mdns_set_hostname(char *name) {
	if (name == NULL) {
		os_strncpy(host_name, "Espressif", os_strlen("Espressif")+3);
		return;
	}
	if (os_strlen(name) + 3 <= MDNS_NAME_LENGTH ){
		os_strncpy(host_name, name, os_strlen(name) );
//		os_memset(host_name + os_strlen(host_name) ,0x00,3);
	} else {
		os_strncpy(host_name, name, MDNS_NAME_LENGTH);
	}
}

void ICACHE_FLASH_ATTR
mdns_set_servername(const char *name) {
	if (name == NULL) {
		PUCK_SERVICE = "_Espressif._tcp._local";
	}else {
		os_sprintf(server_name ,"_%s._tcp.local",name);
		PUCK_SERVICE = server_name;
	}
}

char* ICACHE_FLASH_ATTR
mdns_get_servername(void) {
	char *name = PUCK_SERVICE;
	if (name == NULL) {
		PUCK_SERVICE = "_Espressif._tcp._local";
	}
	return name;
}

void ICACHE_FLASH_ATTR
mdns_server_unregister(void) {
	if(register_flag == 1){
		if (igmp_leavegroup(&host_addr, &multicast_addr) != ERR_OK) {
			os_printf("udp_leave_multigrup failed!\n");
			return;
		};
		register_flag = 0;
	}
}

void ICACHE_FLASH_ATTR
mdns_server_register(void) {

	if (register_flag == 1) {
		os_printf("mdns server is already registered !\n");
		return;
	} else if (igmp_joingroup(&host_addr, &multicast_addr) != ERR_OK) {
		os_printf("udp_join_multigrup failed!\n");
		return;
	};
	register_flag = 1;
}

void ICACHE_FLASH_ATTR
mdns_reg(struct mdns_info *info) {

   static uint8 i = 0;
   if (i <= 3) {
	   mdns_send_service(info,0);
	   i++;
   } else {
	   os_timer_disarm(&mdns_timer);
   }
}

/**
 * Initialize the resolver: set up the UDP pcb and configure the default server
 * (NEW IP).
 */
void ICACHE_FLASH_ATTR
mdns_init(struct mdns_info *info) {
	/* initialize default DNS server address */
	multicast_addr.addr = DNS_MULTICAST_ADDRESS;
	if (info->ipAddr == 0) {
		os_printf("mdns ip error!\n ");
		return;
	}
	host_addr.addr = info->ipAddr ;
	LWIP_DEBUGF(DNS_DEBUG, ("dns_init: initializing\n"));
	//get the datasheet from PUCK
	mdns_set_hostname(info->host_name);
	mdns_set_servername(info->server_name);
	mdns_set_name(info->host_name);

	// get the host name as instrumentName_serialNumber for MDNS
	// set the name of the service, the same as host name
	os_printf("host_name = %s\n", host_name);
	os_printf("server_name = %s\n", PUCK_SERVICE);
	if (info->server_port == 0)
	{
		PUCK_PORT = 80;
	} else {
		PUCK_PORT = info->server_port;
	}

	/* initialize mDNS */
	mdns_pcb = udp_new();

	if (mdns_pcb != NULL) {
		/* join to the multicast address 224.0.0.251 */
		if (igmp_joingroup(&host_addr, &multicast_addr) != ERR_OK) {
			os_printf("udp_join_multigrup failed!\n");
			return;
		};
		register_flag = 1;
		/* join to any IP address at the port 5353 */
		if (udp_bind(mdns_pcb, IP_ADDR_ANY, DNS_MDNS_PORT) != ERR_OK) {
			os_printf("udp_bind failed!\n");
			return;
		};

		/*loopback function for the multicast(224.0.0.251) messages received at port 5353*/
//		mdns_enable();
		udp_recv(mdns_pcb, mdns_recv, info);
		mdns_flag = 1;
		/*
		 * Register the name of the instrument
		 */

		os_timer_disarm(&mdns_timer);
		os_timer_setfn(&mdns_timer, (os_timer_func_t *)mdns_reg,info);
		os_timer_arm(&mdns_timer, 1000, 1);
	}
}

#endif /* LWIP_MDNS */
