Ejemplo n.º 1
0
void list_tcps(void)
{
    UInt32 num = 0;
    struct tcp_pcb *pcb;
    char local_ip_str[16];
    char remote_ip_str[16];

    extern struct tcp_pcb *tcp_active_pcbs;
    extern union tcp_listen_pcbs_t tcp_listen_pcbs;
    extern struct tcp_pcb *tcp_tw_pcbs;
    extern const char *tcp_state_str[];

    rt_enter_critical();
    printf("Active PCB states:\n");
    for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next)
    {
        strcpy(local_ip_str, ipaddr_ntoa(&(pcb->local_ip)));
        strcpy(remote_ip_str, ipaddr_ntoa(&(pcb->remote_ip)));

        printf("#%d %s:%d <==> %s:%d snd_nxt 0x%08X rcv_nxt 0x%08X ",
                   num++,
                   local_ip_str,
                   pcb->local_port,
                   remote_ip_str,
                   pcb->remote_port,
                   pcb->snd_nxt,
                   pcb->rcv_nxt);
        printf("state: %s\n", tcp_state_str[pcb->state]);
    }

    printf("Listen PCB states:\n");
    num = 0;
    for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next)
    {
        printf("#%d local port %d ", num++, pcb->local_port);
        printf("state: %s\n", tcp_state_str[pcb->state]);
    }

    printf("TIME-WAIT PCB states:\n");
    num = 0;
    for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next)
    {
        strcpy(local_ip_str, ipaddr_ntoa(&(pcb->local_ip)));
        strcpy(remote_ip_str, ipaddr_ntoa(&(pcb->remote_ip)));

        printf("#%d %s:%d <==> %s:%d snd_nxt 0x%08X rcv_nxt 0x%08X ",
                   num++,
                   local_ip_str,
                   pcb->local_port,
                   remote_ip_str,
                   pcb->remote_port,
                   pcb->snd_nxt,
                   pcb->rcv_nxt);
        printf("state: %s\n", tcp_state_str[pcb->state]);
    }
    rt_exit_critical();
}
Ejemplo n.º 2
0
void list_if(void)
{
    rt_ubase_t index;
    struct netif * netif;

    rt_enter_critical();

    netif = netif_list;

    while( netif != NULL )
    {
        printf("network interface: %c%c%s\n",
                   netif->name[0],
                   netif->name[1],
                   (netif == netif_default)?" (Default)":"");
        printf("MTU: %d\n", netif->mtu);
        printf("MAC: ");
        for (index = 0; index < netif->hwaddr_len; index ++)
            printf("%02x ", netif->hwaddr[index]);
        printf("\nFLAGS:");
        if (netif->flags & NETIF_FLAG_UP) printf(" UP");
        else printf(" DOWN");
        if (netif->flags & NETIF_FLAG_LINK_UP) printf(" LINK_UP");
        else printf(" LINK_DOWN");
        if (netif->flags & NETIF_FLAG_DHCP) printf(" DHCP");
        if (netif->flags & NETIF_FLAG_POINTTOPOINT) printf(" PPP");
        if (netif->flags & NETIF_FLAG_ETHARP) printf(" ETHARP");
        if (netif->flags & NETIF_FLAG_IGMP) printf(" IGMP");
        printf("\n");
        printf("ip address: %s\n", ipaddr_ntoa(&(netif->ip_addr)));
        printf("gw address: %s\n", ipaddr_ntoa(&(netif->gw)));
        printf("net mask  : %s\n", ipaddr_ntoa(&(netif->netmask)));
        printf("\r\n");

        netif = netif->next;
    }

#if LWIP_DNS
    {
        struct ip_addr ip_addr;

        for(index=0; index<DNS_MAX_SERVERS; index++)
        {
            ip_addr = dns_getserver(index);
            printf("dns server #%d: %s\n", index, ipaddr_ntoa(&(ip_addr)));
        }
    }
#endif /**< #if LWIP_DNS */

    rt_exit_critical();
}
Ejemplo n.º 3
0
void
socks_tcp_connect(struct socks_data *data)
{
	struct tcp_pcb *pcb;
	err_t ret;

	bufferevent_disable(data->bev, EV_READ);

	LWIP_DEBUGF(SOCKS_DEBUG, ("%s: %s:%d\n", __func__,
				ipaddr_ntoa(&data->ipaddr), data->port));

	pcb = tcp_new();
	if (!pcb)
		data->connect_failed(data);

	pcb->flags |= TF_NODELAY;
	if (data->keep_alive) {
		pcb->so_options |= SOF_KEEPALIVE;
		pcb->keep_intvl = data->keep_alive;
		pcb->keep_idle = data->keep_alive;
	}

	ret = tcp_connect(pcb, &data->ipaddr, data->port, socks_tcp_connect_ok);
	if (ret < 0) {
		tcp_abort(pcb);
		data->connect_failed(data);
	} else {
		data->pcb = pcb;
		tcp_arg(pcb, data);
		tcp_err(pcb, socks_tcp_connect_err);
	}
}
Ejemplo n.º 4
0
static err_t mg_lwip_accept_cb(void *arg, struct tcp_pcb *newtpcb, err_t err) {
  struct mg_connection *lc = (struct mg_connection *) arg;
  (void) err;
  DBG(("%p conn %p from %s:%u", lc, newtpcb, ipaddr_ntoa(&newtpcb->remote_ip),
       newtpcb->remote_port));
  struct mg_connection *nc = mg_if_accept_new_conn(lc);
  if (nc == NULL) {
    tcp_abort(newtpcb);
    return ERR_ABRT;
  }
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  cs->pcb.tcp = newtpcb;
  tcp_arg(newtpcb, nc);
  tcp_err(newtpcb, mg_lwip_tcp_error_cb);
  tcp_sent(newtpcb, mg_lwip_tcp_sent_cb);
  tcp_recv(newtpcb, mg_lwip_tcp_recv_cb);
#ifdef SSL_KRYPTON
  if (lc->ssl_ctx != NULL) {
    nc->ssl = SSL_new(lc->ssl_ctx);
    if (nc->ssl == NULL || SSL_set_fd(nc->ssl, (intptr_t) nc) != 1) {
      LOG(LL_ERROR, ("SSL error"));
      tcp_close(newtpcb);
    }
  } else
#endif
  {
    mg_lwip_accept_conn(nc, newtpcb);
  }
  return ERR_OK;
}
Ejemplo n.º 5
0
static void
ping_recv(int s, const ip_addr_t *addr)
{
  char buf[200];
  socklen_t fromlen;
  int len;
  struct sockaddr_storage from;
  ip_addr_t ip_from;
  LWIP_UNUSED_ARG(addr);

  len = lwip_recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr*)&from, &fromlen);

#if LWIP_IPV4
  if(!IP_IS_V6(addr)) {
    struct sockaddr_in *from4 = (struct sockaddr_in*)&from;
    inet_addr_to_ipaddr(ip_2_ip4(&ip_from), &from4->sin_addr);
  }
#endif /* LWIP_IPV4 */

#if LWIP_IPV6
  if(IP_IS_V6(addr)) {
    struct sockaddr_in6 *from6 = (struct sockaddr_in6*)&from;
    inet6_addr_to_ip6addr(ip_2_ip6(&ip_from), &from6->sin6_addr);
  }
#endif /* LWIP_IPV6 */

  printf("Received %d bytes from %s\n", len, ipaddr_ntoa(&ip_from));
}
Ejemplo n.º 6
0
int http_wifi_api_get_status(http_connection *c)
{
    CGI_WIFI_DBG("wifi get_status\n");

    //wait for whole body
    if(c->state <HTTPD_STATE_BODY_END) {
        return HTTPD_CGI_MORE;
    }

    api_cgi_status * status = c->cgi.data;

    //first call, send headers
    if(status==NULL)
    {
        status = (api_cgi_status*)os_malloc(sizeof(api_cgi_status));
        status->state=1;
        c->cgi.data=status;

        http_SET_HEADER(c,HTTP_CONTENT_TYPE,JSON_CONTENT_TYPE);
        http_response_OK(c);

        return HTTPD_CGI_MORE;
    }
    else if(status->state==1)
    {
        wifi_station_get_config(&wifi_status.station_config);
        uint8_t c_status = wifi_station_get_connect_status();

        //return JSON
        cJSON *root = cJSON_CreateObject();
        cJSON_AddBoolToObject(root,"scanning",wifi_status.scanning);
        cJSON_AddStringToObject(root,"ssid",(const char *)wifi_status.station_config.ssid);
        cJSON_AddNumberToObject(root,"mode",wifi_get_opmode());
        cJSON_AddNumberToObject(root,"station_status",c_status);

        //got ip
        if(c_status==5)
        {
            struct ip_info ip;
            wifi_get_ip_info(0x0,&ip);
            char *ip_str = (char*)ipaddr_ntoa(&ip.ip);
            cJSON_AddStringToObject(root,"ip",ip_str);
        }
        else {
            cJSON_AddStringToObject(root,"ip","");
        }

        http_write_json(c,root);
        cJSON_Delete(root);

        status->state=99;
        return HTTPD_CGI_MORE;
    }
    else
    {
        os_free(c->cgi.data);
        return HTTPD_CGI_DONE;
    }
}
Ejemplo n.º 7
0
/**
 * Returns an entry containing addresses of address family AF_INET
 * for the host with name name.
 * Due to dns_gethostbyname limitations, only one address is returned.
 *
 * @param name the hostname to resolve
 * @return an entry containing addresses of address family AF_INET
 *         for the host with name name
 */
struct hostent*
lwip_gethostbyname(const char *name)
{
  err_t err;
  ip_addr_t addr;

  /* buffer variables for lwip_gethostbyname() */
  HOSTENT_STORAGE struct hostent s_hostent;
  HOSTENT_STORAGE char *s_aliases;
  HOSTENT_STORAGE ip_addr_t s_hostent_addr;
  HOSTENT_STORAGE ip_addr_t *s_phostent_addr[2];
  HOSTENT_STORAGE char s_hostname[DNS_MAX_NAME_LENGTH + 1];

  /* query host IP address */
  err = netconn_gethostbyname(name, &addr);
  if (err != ERR_OK) {
    LWIP_DEBUGF(DNS_DEBUG, ("lwip_gethostbyname(%s) failed, err=%d\n", name, err));
    h_errno = HOST_NOT_FOUND;
    return NULL;
  }

  /* fill hostent */
  s_hostent_addr = addr;
  s_phostent_addr[0] = &s_hostent_addr;
  s_phostent_addr[1] = NULL;
  strncpy(s_hostname, name, DNS_MAX_NAME_LENGTH);
  s_hostname[DNS_MAX_NAME_LENGTH] = 0;
  s_hostent.h_name = s_hostname;
  s_aliases = NULL;
  s_hostent.h_aliases = &s_aliases;
  s_hostent.h_addrtype = AF_INET;
  s_hostent.h_length = sizeof(ip_addr_t);
  s_hostent.h_addr_list = (char**)&s_phostent_addr;

#if DNS_DEBUG
  /* dump hostent */
  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_name           == %s\n", s_hostent.h_name));
  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_aliases        == %p\n", (void*)s_hostent.h_aliases));
  /* h_aliases are always empty */
  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addrtype       == %d\n", s_hostent.h_addrtype));
  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_length         == %d\n", s_hostent.h_length));
  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list      == %p\n", (void*)s_hostent.h_addr_list));
  if (s_hostent.h_addr_list != NULL) {
    u8_t idx;
    for (idx=0; s_hostent.h_addr_list[idx]; idx++) {
      LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i]   == %p\n", idx, s_hostent.h_addr_list[idx]));
      LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i]-> == %s\n", idx, ipaddr_ntoa((ip_addr_t*)s_hostent.h_addr_list[idx])));
    }
  }
#endif /* DNS_DEBUG */

#if LWIP_DNS_API_HOSTENT_STORAGE
  /* this function should return the "per-thread" hostent after copy from s_hostent */
  return sys_thread_hostent(&s_hostent);
#else
  return &s_hostent;
#endif /* LWIP_DNS_API_HOSTENT_STORAGE */
}
Ejemplo n.º 8
0
void mqtt_dnsCallback(const char *name, ip_addr_t *ipaddr, void *callback_arg)
{
	mqtt_client_t *client = (mqtt_client_t *)callback_arg;

	client->serverAddr.sin_addr.s_addr = ipaddr;

	printf("IP ADDRESS FOUND: %s\n", ipaddr_ntoa(ipaddr));

	dnsDone = 1;
}
Ejemplo n.º 9
0
static void
lwiperf_report(void *arg, enum lwiperf_report_type report_type,
  const ip_addr_t* local_addr, u16_t local_port, const ip_addr_t* remote_addr, u16_t remote_port,
  u32_t bytes_transferred, u32_t ms_duration, u32_t bandwidth_kbitpsec)
{
  LWIP_UNUSED_ARG(arg);
  LWIP_UNUSED_ARG(local_addr);
  LWIP_UNUSED_ARG(local_port);

  printf("IPERF report: type=%d, remote: %s:%d, total bytes: %lu, duration in ms: %lu, kbits/s: %lu\n",
    (int)report_type, ipaddr_ntoa(remote_addr), (int)remote_port, bytes_transferred, ms_duration, bandwidth_kbitpsec);
}
Ejemplo n.º 10
0
/**
 * Initialize the connection struct (from IP address)
 */
static err_t
httpc_init_connection_addr(httpc_state_t **connection, const httpc_connection_t *settings,
                           const ip_addr_t* server_addr, u16_t server_port, const char* uri,
                           altcp_recv_fn recv_fn, void* callback_arg)
{
  char *server_addr_str = ipaddr_ntoa(server_addr);
  if (server_addr_str == NULL) {
    return ERR_VAL;
  }
  return httpc_init_connection_common(connection, settings, server_addr_str, server_port, uri,
    recv_fn, callback_arg, 1);
}
Ejemplo n.º 11
0
static err_t mg_lwip_tcp_conn_cb(void *arg, struct tcp_pcb *tpcb, err_t err) {
  struct mg_connection *nc = (struct mg_connection *) arg;
  DBG(("%p connect to %s:%u = %d", nc, ipaddr_ntoa(&tpcb->remote_ip),
       tpcb->remote_port, err));
  if (nc == NULL) {
    tcp_abort(tpcb);
    return ERR_ARG;
  }
  nc->err = err;
  system_os_post(MG_TASK_PRIORITY, MG_SIG_CONNECT_RESULT, (uint32_t) nc);
  return ERR_OK;
}
Ejemplo n.º 12
0
void eth_onUDPDataReceived(void* arg, struct udp_pcb* upcb, struct pbuf* p, struct ip_addr* addr, u16_t port)
{
	char *srcAddr = ipaddr_ntoa(addr);
	myprintf("src addr: %s %d\r\n", srcAddr, p->tot_len);

	uint16_t packetId;
	uint8_t d[p->tot_len];

	pbuf_copy_partial(p, d, p->tot_len, 0);

	provProcess(d, p->tot_len);

	pbuf_free(p);
}
Ejemplo n.º 13
0
int mg_if_listen_udp(struct mg_connection *nc, union socket_address *sa) {
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  struct udp_pcb *upcb = udp_new();
  ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr;
  u16_t port = ntohs(sa->sin.sin_port);
  cs->err = udp_bind(upcb, ip, port);
  DBG(("%p udb_bind(%s:%u) = %d", nc, ipaddr_ntoa(ip), port, cs->err));
  if (cs->err != ERR_OK) {
    udp_remove(upcb);
    return -1;
  }
  udp_recv(upcb, mg_lwip_udp_recv_cb, nc);
  cs->pcb.udp = upcb;
  return 0;
}
Ejemplo n.º 14
0
int mg_if_listen_tcp(struct mg_connection *nc, union socket_address *sa) {
  struct tcp_pcb *tpcb = tcp_new();
  ip_addr_t *ip = (ip_addr_t *) &sa->sin.sin_addr.s_addr;
  u16_t port = ntohs(sa->sin.sin_port);
  nc->err = tcp_bind(tpcb, ip, port);
  DBG(("%p tcp_bind(%s:%u) = %d", nc, ipaddr_ntoa(ip), port, nc->err));
  if (nc->err != ERR_OK) {
    tcp_close(tpcb);
    return -1;
  }
  nc->sock = (int) tpcb;
  tcp_arg(tpcb, nc);
  tpcb = tcp_listen(tpcb);
  tcp_accept(tpcb, mg_lwip_accept_cb);
  return 0;
}
Ejemplo n.º 15
0
void eth_onUDPDataReceived(void* arg, struct udp_pcb* upcb, struct pbuf* p, struct ip_addr* addr, u16_t port)
{
	TByteBuffer buffer;
	buffer.p = p;
	buffer.pos = 0;

	char *srcAddr = ipaddr_ntoa(addr);
	myprintf("src addr: %s\r\n", srcAddr);

	uint16_t packetId;
	if (BYTEBUFFER_FETCH(&buffer, packetId)) return;

	provProcess(&buffer);

	pbuf_free(p);
}
Ejemplo n.º 16
0
/** Prepare HELO/EHLO message */
static enum smtp_session_state
smtp_prepare_helo(struct smtp_session *s, u16_t *tx_buf_len, struct altcp_pcb *pcb)
{
  size_t ipa_len;
  const char *ipa = ipaddr_ntoa(altcp_get_ip(pcb, 1));
  LWIP_ASSERT("ipaddr_ntoa returned NULL", ipa != NULL);
  ipa_len = strlen(ipa);
  LWIP_ASSERT("string too long", ipa_len <= (SMTP_TX_BUF_LEN-SMTP_CMD_EHLO_1_LEN-SMTP_CMD_EHLO_2_LEN));

  *tx_buf_len = (u16_t)(SMTP_CMD_EHLO_1_LEN + (u16_t)ipa_len + SMTP_CMD_EHLO_2_LEN);
  LWIP_ASSERT("tx_buf overflow detected", *tx_buf_len <= SMTP_TX_BUF_LEN);

  SMEMCPY(s->tx_buf, SMTP_CMD_EHLO_1, SMTP_CMD_EHLO_1_LEN);
  MEMCPY(&s->tx_buf[SMTP_CMD_EHLO_1_LEN], ipa, ipa_len);
  SMEMCPY(&s->tx_buf[SMTP_CMD_EHLO_1_LEN + ipa_len], SMTP_CMD_EHLO_2, SMTP_CMD_EHLO_2_LEN);
  return SMTP_HELO;
}
Ejemplo n.º 17
0
static void mg_lwip_udp_recv_cb(void *arg, struct udp_pcb *pcb, struct pbuf *p,
                                ip_addr_t *addr, u16_t port) {
  struct mg_connection *nc = (struct mg_connection *) arg;
  size_t len = p->len;
  char *data = (char *) malloc(len);
  union socket_address sa;
  DBG(("%p %s:%u %u", nc, ipaddr_ntoa(addr), port, p->len));
  if (data == NULL) {
    DBG(("OOM"));
    pbuf_free(p);
    return;
  }
  sa.sin.sin_addr.s_addr = addr->addr;
  sa.sin.sin_port = htons(port);
  pbuf_copy_partial(p, data, len, 0);
  pbuf_free(p);
  mg_if_recv_udp_cb(nc, data, len, &sa, sizeof(sa.sin));
}
Ejemplo n.º 18
0
static err_t mg_lwip_accept_cb(void *arg, struct tcp_pcb *newtpcb, err_t err) {
  struct mg_connection *lc = (struct mg_connection *) arg, *nc;
  union socket_address sa;
  DBG(("%p conn from %s:%u\n", lc, ipaddr_ntoa(&newtpcb->remote_ip),
       newtpcb->remote_port));
  sa.sin.sin_addr.s_addr = newtpcb->remote_ip.addr;
  sa.sin.sin_port = htons(newtpcb->remote_port);
  nc = mg_if_accept_tcp_cb(lc, &sa, sizeof(sa.sin));
  if (nc == NULL) {
    tcp_abort(newtpcb);
    return ERR_ABRT;
  }
  nc->sock = (int) newtpcb;
  tcp_arg(newtpcb, nc);
  tcp_err(newtpcb, mg_lwip_tcp_error_cb);
  tcp_sent(newtpcb, mg_lwip_tcp_sent_cb);
  tcp_recv(newtpcb, mg_lwip_tcp_recv_cb);
  return ERR_OK;
}
Ejemplo n.º 19
0
static err_t mg_lwip_tcp_conn_cb(void *arg, struct tcp_pcb *tpcb, err_t err) {
  struct mg_connection *nc = (struct mg_connection *) arg;
  DBG(("%p connect to %s:%u = %d", nc, ipaddr_ntoa(&tpcb->remote_ip),
       tpcb->remote_port, err));
  if (nc == NULL) {
    tcp_abort(tpcb);
    return ERR_ARG;
  }
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  cs->err = err;
#ifdef SSL_KRYPTON
  if (err == 0 && nc->ssl != NULL) {
    SSL_set_fd(nc->ssl, (intptr_t) nc);
    mg_lwip_ssl_do_hs(nc);
  } else
#endif
  {
    system_os_post(MG_TASK_PRIORITY, MG_SIG_CONNECT_RESULT, (uint32_t) nc);
  }
  return ERR_OK;
}
Ejemplo n.º 20
0
/**
 * Send out an sntp request.
 *
 * @param arg is unused (only necessary to conform to sys_timeout)
 */
static void
sntp_request(void *arg)
{
  ip_addr_t sntp_server_address;
  err_t err;

  LWIP_UNUSED_ARG(arg);

  /* initialize SNTP server address */
#if SNTP_SERVER_DNS
  if (sntp_servers[sntp_current_server].name) {
    /* always resolve the name and rely on dns-internal caching & timeout */
    ip_addr_set_zero(&sntp_servers[sntp_current_server].addr);
    err = dns_gethostbyname(sntp_servers[sntp_current_server].name, &sntp_server_address,
      sntp_dns_found, NULL);
    if (err == ERR_INPROGRESS) {
      /* DNS request sent, wait for sntp_dns_found being called */
      LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_request: Waiting for server address to be resolved.\n"));
      return;
    } else if (err == ERR_OK) {
      sntp_servers[sntp_current_server].addr = sntp_server_address;
    }
  } else
#endif /* SNTP_SERVER_DNS */
  {
    sntp_server_address = sntp_servers[sntp_current_server].addr;
    err = (ip_addr_isany_val(sntp_server_address)) ? ERR_ARG : ERR_OK;
  }

  if (err == ERR_OK) {
    LWIP_DEBUGF(SNTP_DEBUG_TRACE, ("sntp_request: current server address is %s\n",
      ipaddr_ntoa(&sntp_server_address)));
    sntp_send_request(&sntp_server_address);
  } else {
    /* address conversion failed, try another server */
    LWIP_DEBUGF(SNTP_DEBUG_WARN_STATE, ("sntp_request: Invalid server address, trying next server.\n"));
    sys_timeout((u32_t)SNTP_RETRY_TIMEOUT, sntp_try_next_server, NULL);
  }
}
Ejemplo n.º 21
0
static err_t mg_lwip_tcp_conn_cb(void *arg, struct tcp_pcb *tpcb, err_t err) {
  struct mg_connection *nc = (struct mg_connection *) arg;
  DBG(("%p connect to %s:%u = %d", nc, ipaddr_ntoa(&tpcb->remote_ip),
       tpcb->remote_port, err));
  if (nc == NULL) {
    tcp_abort(tpcb);
    return ERR_ARG;
  }
  struct mg_lwip_conn_state *cs = (struct mg_lwip_conn_state *) nc->sock;
  cs->err = err;
  if (err == 0) mg_lwip_set_keepalive_params(nc, 60, 10, 6);
#ifdef SSL_KRYPTON
  if (err == 0 && nc->ssl != NULL) {
    SSL_set_fd(nc->ssl, (intptr_t) nc);
    mg_lwip_ssl_do_hs(nc);
  } else
#endif
  {
    mg_lwip_post_signal(MG_SIG_CONNECT_RESULT, nc);
  }
  return ERR_OK;
}
Ejemplo n.º 22
0
/******************************************************************************
 * FunctionName : on_found
 * Description  : dns found callback
 * Parameters   : name -- pointer to the name that was looked up.
 *                ipaddr -- pointer to an ip_addr_t containing the IP address of
 *                the hostname, or NULL if the name could not be found (or on any
 *                other error).
 *                callback_arg -- a user-specified callback argument passed to
 *                dns_gethostbyname
 * Returns      : none
*******************************************************************************/
static void ICACHE_FLASH_ATTR
on_found(const char *name, ip_addr_t *ipaddr, void *arg)
{
    struct user_dns_param *param = (struct user_dns_param *)arg;

    DEBUG_PRINTF("ipaddr=%p\n", ipaddr);
    DEBUG_PRINTF("param->ip=%p\n", &param->ip);
    
    if(!ipaddr)
    {
        DEBUG_INFO("ipaddr=NULL\n");
        return;
    }

    DEBUG_NOTICE("%s\n", ipaddr_ntoa(ipaddr));

    if(ipaddr->addr)
    {
        param->ip.addr = ipaddr->addr;
        os_timer_disarm(&param->tmr);
        os_timer_arm(&param->tmr, 1, 0);
    }
}
Ejemplo n.º 23
0
int ICACHE_FLASH_ATTR
user_dns_request(struct user_dns_param *param)
{
    int err = EFAULT;

    if(!param)
    {
        DEBUG_WARNING("EINVAL\n");
        return EINVAL;
    }

    DEBUG_INFO("%s\n", ipaddr_ntoa(&param->ip));

    err = dns_gethostbyname(param->hostname, &param->ip, on_found, param);
    DEBUG_INFO("dns_gethostbyname=%d | %s\n", err, lwip_strerr(err));
    switch(err)
    {
        case ERR_INPROGRESS:
            DEBUG_NOTICE("wait for callback\n");
            os_timer_setfn(&param->tmr, (os_timer_func_t *)on_timer, param);
            os_timer_arm(&param->tmr, 1000, 0);
            err = 0;
            break;
        case ERR_OK:
            DEBUG_NOTICE("is ipaddr\n");
            os_timer_setfn(&param->tmr, (os_timer_func_t *)on_timer, param);
            os_timer_arm(&param->tmr, 1, 0);
            err = 0;
            break;
        default:
            DEBUG_WARNING("bad hostname\n");
            break;
    }

    return err;
}
Ejemplo n.º 24
0
static void LwipInitTask(void* pvArguments) {
    err_t err;
  struct netif fsl_netif0;
  ip_addr_t fsl_netif0_ipaddr, fsl_netif0_netmask, fsl_netif0_gw;

  char msg[] = "This is my message";

  (void)pvArguments;

  // Init lwip stack
  tcpip_init(NULL,NULL);
  printf("%s: lwip init called ..\n", __FUNCTION__);

  // Setup IP Config for DHCP ...
  IP4_ADDR(&fsl_netif0_ipaddr, 0,0,0,0);
  IP4_ADDR(&fsl_netif0_netmask, 0,0,0,0);
  IP4_ADDR(&fsl_netif0_gw, 0,0,0,0);

  /* Add a network interface to the list of lwIP netifs. */
  netif_add(&fsl_netif0, &fsl_netif0_ipaddr, &fsl_netif0_netmask, &fsl_netif0_gw, NULL, ethernetif_init, ethernet_input);
  /* Set the network interface as the default network interface. */
  netif_set_default(&fsl_netif0);
  /* obtain the IP address, default gateway and subnet mask by using DHCP*/
  err = dhcp_start(&fsl_netif0);

  printf("%s : Started DCHP request (%s)\n", __FUNCTION__, lwip_strerr(err));

  for(int i=0; i < DHCP_TIMEOUT && fsl_netif0.dhcp->state != DHCP_BOUND; i++) {
    printf("%s : Current DHCP State : %d\n", __FUNCTION__, fsl_netif0.dhcp->state);
    // Wait a second
    vTaskDelay(1000/portTICK_PERIOD_MS);
  }

  // Make it active ...
  netif_set_up(&fsl_netif0);

  printf("%s : Interface is up : %d\n", __FUNCTION__, fsl_netif0.dhcp->state);
  printf("%s : IP %s\n", __FUNCTION__, ipaddr_ntoa(&fsl_netif0.ip_addr));
  printf("%s : NM %s\n", __FUNCTION__, ipaddr_ntoa(&fsl_netif0.netmask));
  printf("%s : GW %s\n", __FUNCTION__, ipaddr_ntoa(&fsl_netif0.gw));

  if (fsl_netif0.dhcp->state == DHCP_BOUND) {
    // Send out some UDP data
    struct netconn* pConnection;

    // Create UDP connection
    pConnection = netconn_new(NETCONN_UDP);
    // Connect to local port
    err = netconn_bind(pConnection, IP_ADDR_ANY, 12345);
    printf("%s : Bound to IP_ADDR_ANY port 12345 (%s)\n", __FUNCTION__, lwip_strerr(err));

    err = netconn_connect(pConnection, IP_ADDR_BROADCAST, 12346 );
    printf("%s : Connected to IP_ADDR_BROADCAST port 12346 (%s)\n", __FUNCTION__, lwip_strerr(err));

    for(int i = 0; i < 10; i++ ){
      struct netbuf* buf = netbuf_new();
        void* data = netbuf_alloc(buf, sizeof(msg));

        memcpy (data, msg, sizeof (msg));
        err = netconn_send(pConnection, buf);
      printf("%s : Sending to IP_ADDR_BROADCAST port 12346 (%s)\n", __FUNCTION__, lwip_strerr(err));

        netbuf_delete(buf); // De-allocate packet buffer

        // Wait a second
      vTaskDelay(1000/portTICK_PERIOD_MS);
    }

    err = netconn_disconnect(pConnection);
    printf("%s : Disconnected from IP_ADDR_BROADCAST port 12346 (%s)\n", __FUNCTION__, lwip_strerr(err));

    err = netconn_delete(pConnection);
    printf("%s : Deleted connection (%s)\n", __FUNCTION__, lwip_strerr(err));
  }
  // Wait a second
  vTaskDelay(1000/portTICK_PERIOD_MS);

  /* finish the lease of the IP address */
  err = dhcp_release(&fsl_netif0);
  printf("%s : DHCP Release (%s)\n", __FUNCTION__, lwip_strerr(err));

  for(;;) {};
}
Ejemplo n.º 25
0
int http_wifi_api_get_info(http_connection *c)
{
    CGI_WIFI_DBG("http_wifi_api_get_info\n");

    //wait for whole body
    if(c->state <HTTPD_STATE_BODY_END) {
        return HTTPD_CGI_MORE;
    }

    api_cgi_status * status = c->cgi.data;

    if(status==NULL) { //first call, send headers

        status = (api_cgi_status*)os_malloc(sizeof(api_cgi_status));
        status->state=1;
        c->cgi.data=status;

        http_SET_HEADER(c,HTTP_CONTENT_TYPE,JSON_CONTENT_TYPE);
        http_response_OK(c);

        return HTTPD_CGI_MORE;
    }
    else if(status->state==1)
    {
        //json data
        char mac[20];
        wifi_station_get_config(&wifi_status.station_config);
        char *wifistatus = "unknown";
        uint8_t c_status = wifi_station_get_connect_status();
        if (c_status >= 0 && c_status < sizeof(connStatuses)) wifistatus = connStatuses[c_status];
        int p = wifi_get_phy_mode();
        char *phy = wifiPhy[p&3];
        sint8 rssi = wifi_station_get_rssi();
        if (rssi > 0) rssi = 0;
        uint8_t op = wifi_get_opmode() & 0x3;
        char *warn = wifiWarn[op];
        uint8 mac_addr[6];
        wifi_get_macaddr(0, mac_addr);
        uint8_t chan = wifi_get_channel();

        char *hostname = wifi_station_get_hostname();
        os_sprintf(mac,"%02x:%02x:%02x:%02x:%02x:%02x", mac_addr[0], mac_addr[1],
                   mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);

        cJSON *root = cJSON_CreateObject();
        cJSON_AddNumberToObject(root,"mode",wifi_get_opmode());
        cJSON_AddStringToObject(root,"modechange", MODECHANGE);
        cJSON_AddStringToObject(root,"ssid", (const char *)wifi_status.station_config.ssid);
        cJSON_AddStringToObject(root,"status", (const char *)wifistatus);
        cJSON_AddStringToObject(root,"phy", (const char *)phy);
        cJSON_AddNumberToObject(root,"rssi", rssi);
        cJSON_AddStringToObject(root,"warn", (const char *)warn);
        cJSON_AddStringToObject(root,"mac", (const char *)mac);
        cJSON_AddNumberToObject(root,"chan", chan);
        cJSON_AddStringToObject(root,"hostname", (const char *)hostname);
        cJSON_AddStringToObject(root,"domain", (const char *)INTERFACE_DOMAIN);

        // got ip
        if(c_status==5)
        {
            struct ip_info ip;
            wifi_get_ip_info(0x0,&ip);
            char *ip_str = (char*)ipaddr_ntoa(&ip.ip);
            cJSON_AddStringToObject(root,"ip",ip_str);
        }
        else {
            cJSON_AddStringToObject(root,"ip","");
        }

        http_write_json(c,root);
        cJSON_Delete(root);

        status->state=99;
        return HTTPD_CGI_MORE;
    }
    else
    {
        os_free(c->cgi.data);
        return HTTPD_CGI_DONE;
    }
}
Ejemplo n.º 26
0
Archivo: main.c Proyecto: 10code/lwip
int
main(int argc, char **argv)
{
  struct netif netif;
  sigset_t mask, oldmask, empty;
  int ch;
  char ip_str[16] = {0}, nm_str[16] = {0}, gw_str[16] = {0};

  /* startup defaults (may be overridden by one or more opts) */
  IP4_ADDR(&gw, 192,168,0,1);
  IP4_ADDR(&ipaddr, 192,168,0,2);
  IP4_ADDR(&netmask, 255,255,255,0);

  trap_flag = 0;
  /* use debug flags defined by debug.h */
  debug_flags = LWIP_DBG_OFF;

  while ((ch = getopt_long(argc, argv, "dhg:i:m:t:", longopts, NULL)) != -1) {
    switch (ch) {
      case 'd':
        debug_flags |= (LWIP_DBG_ON|LWIP_DBG_TRACE|LWIP_DBG_STATE|LWIP_DBG_FRESH|LWIP_DBG_HALT);
        break;
      case 'h':
        usage();
        exit(0);
        break;
      case 'g':
        ipaddr_aton(optarg, &gw);
        break;
      case 'i':
        ipaddr_aton(optarg, &ipaddr);
        break;
      case 'm':
        ipaddr_aton(optarg, &netmask);
        break;
      case 't':
        trap_flag = !0;
        /* @todo: remove this authentraps tweak 
          when we have proper SET & non-volatile mem */
        snmpauthentraps_set = 1;
        ipaddr_aton(optarg, &trap_addr);
        strncpy(ip_str, ipaddr_ntoa(&trap_addr),sizeof(ip_str));
        printf("SNMP trap destination %s\n", ip_str);
        break;
      default:
        usage();
        break;
    }
  }
  argc -= optind;
  argv += optind;

  strncpy(ip_str, ipaddr_ntoa(&ipaddr), sizeof(ip_str));
  strncpy(nm_str, ipaddr_ntoa(&netmask), sizeof(nm_str));
  strncpy(gw_str, ipaddr_ntoa(&gw), sizeof(gw_str));
  printf("Host at %s mask %s gateway %s\n", ip_str, nm_str, gw_str);


#ifdef PERF
  perf_init("/tmp/minimal.perf");
#endif /* PERF */

  lwip_init();

  printf("TCP/IP initialized.\n");

  netif_add(&netif, &ipaddr, &netmask, &gw, NULL, mintapif_init, ethernet_input);
  netif_set_default(&netif);
  netif_set_up(&netif);


#if SNMP_PRIVATE_MIB != 0
  /* initialize our private example MIB */
  lwip_privmib_init();
#endif
  snmp_trap_dst_ip_set(0,&trap_addr);
  snmp_trap_dst_enable(0,trap_flag);
  snmp_set_syscontact(syscontact_str,&syscontact_len);
  snmp_set_syslocation(syslocation_str,&syslocation_len);
  snmp_set_snmpenableauthentraps(&snmpauthentraps_set);
  snmp_init();

  echo_init();

  timer_init();
  timer_set_interval(TIMER_EVT_ETHARPTMR, ARP_TMR_INTERVAL / 10);
  timer_set_interval(TIMER_EVT_TCPTMR, TCP_TMR_INTERVAL / 10);
#if IP_REASSEMBLY
  timer_set_interval(TIMER_EVT_IPREASSTMR, IP_TMR_INTERVAL / 10);
#endif
  
  printf("Applications started.\n");
    

  while (1) {
    
      /* poll for input packet and ensure
         select() or read() arn't interrupted */
      sigemptyset(&mask);
      sigaddset(&mask, SIGALRM);
      sigprocmask(SIG_BLOCK, &mask, &oldmask);

      /* start of critical section,
         poll netif, pass packet to lwIP */
      if (mintapif_select(&netif) > 0)
      {
        /* work, immediatly end critical section 
           hoping lwIP ended quickly ... */
        sigprocmask(SIG_SETMASK, &oldmask, NULL);
      }
      else
      {
        /* no work, wait a little (10 msec) for SIGALRM */
          sigemptyset(&empty);
          sigsuspend(&empty);
        /* ... end critical section */
          sigprocmask(SIG_SETMASK, &oldmask, NULL);
      }
    
      if(timer_testclr_evt(TIMER_EVT_TCPTMR))
      {
        tcp_tmr();
      }
#if IP_REASSEMBLY
      if(timer_testclr_evt(TIMER_EVT_IPREASSTMR))
      {
        ip_reass_tmr();
      }
#endif
      if(timer_testclr_evt(TIMER_EVT_ETHARPTMR))
      {
        etharp_tmr();
      }
      
  }
  
  return 0;
}
Ejemplo n.º 27
0
/*-----------------------------------------------------------------------------------*/
int
main(int argc, char **argv)
{
  int ch;
  char ip_str[16] = {0};

  /* startup defaults (may be overridden by one or more opts) */
#if LWIP_IPV4
  IP_ADDR4(&gw,      192,168,  0,1);
  IP_ADDR4(&netmask, 255,255,255,0);
  IP_ADDR4(&ipaddr,  192,168,  0,2);
#if LWIP_HAVE_SLIPIF
  IP_ADDR4(&gw_slip,      192,168,  2,  1);
  IP_ADDR4(&netmask_slip, 255,255,255,255);
  IP_ADDR4(&ipaddr_slip,  192,168,  2,  2);
#endif
#endif /* LWIP_IPV4 */
  
  ping_flag = 0;
  /* use debug flags defined by debug.h */
  debug_flags = LWIP_DBG_OFF;
  
  while ((ch = getopt_long(argc, argv, "dhg:i:m:p:", longopts, NULL)) != -1) {
    switch (ch) {
      case 'd':
        debug_flags |= (LWIP_DBG_ON|LWIP_DBG_TRACE|LWIP_DBG_STATE|LWIP_DBG_FRESH|LWIP_DBG_HALT);
        break;
      case 'h':
        usage();
        exit(0);
        break;
#if LWIP_IPV4
      case 'g':
        ipaddr_aton(optarg, &gw);
        break;
      case 'i':
        ipaddr_aton(optarg, &ipaddr);
        break;
      case 'm':
        ipaddr_aton(optarg, &netmask);
        break;
#endif /* LWIP_IPV4 */
      case 'p':
        ping_flag = !0;
        ipaddr_aton(optarg, &ping_addr);
        strncpy(ip_str,ipaddr_ntoa(&ping_addr),sizeof(ip_str));
        ip_str[sizeof(ip_str)-1] = 0; /* ensure \0 termination */
        printf("Using %s to ping\n", ip_str);
        break;
      default:
        usage();
        break;
    }
  }
  argc -= optind;
  argv += optind;
  
#ifdef PERF
  perf_init("/tmp/simhost.perf");
#endif /* PERF */

  printf("System initialized.\n");
    
  sys_thread_new("main_thread", main_thread, NULL, DEFAULT_THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);
  pause();
  return 0;
}
Ejemplo n.º 28
0
/**
 * @brief Displays the IP address on the Console
 * 
 * @param ipAddr The desired IP address to display.
 */
static inline void IpAddrDisplay(const ip_addr_t* const ipAddr)
{
    printk("\n\r\n\rIP Address Assigned: %s\r\n", ipaddr_ntoa(ipAddr));
}
Ejemplo n.º 29
0
int ICACHE_FLASH_ATTR NetworkConnect(Network* n, char* addr, int port) {
    struct sockaddr_in sAddr;
    int retVal = -1;

    bzero(&sAddr, sizeof(struct sockaddr_in));
    if (!getIpForHost(addr, &sAddr)) {
        printf("get ip by hostname fail\n");
        return -1;
    }

    sAddr.sin_port = FreeRTOS_htons(port);

    if ((n->my_socket = FreeRTOS_socket(PF_INET, FREERTOS_SOCK_STREAM, 0)) < 0)
        goto exit;

//	printf("Connecting to server %s...\n", ipaddr_ntoa((const ip_addr_t*)&sAddr.sin_addr.s_addr));

    if ((retVal = FreeRTOS_connect(n->my_socket, (struct sockaddr * )(&sAddr),
                                   sizeof(struct sockaddr))) < 0) {
        FreeRTOS_closesocket(n->my_socket);
        goto exit;
    }

exit:
//	printf("------------>connect init: %d, sock:%d \n", retVal, n->my_socket);
    return retVal;

#if 0
    struct freertos_sockaddr sAddr;
    int retVal = -1;
    uint32_t ipAddress;
    struct sockaddr_in *name_in;

    struct ip_addr *ad;
    struct hostent *pHost;
    if ((pHost = FreeRTOS_gethostbyname(addr)) == 0)
        goto exit;

    ad = (struct ip_addr *)&pHost->h_addr_list[0];
    ipAddress = ad->addr;

    sAddr.sa_family = AF_INET;
    name_in = (struct sockaddr_in *)(void*)(&sAddr);
    name_in->sin_port = FreeRTOS_htons(port);
    name_in->sin_addr.s_addr = ipAddress;
    printf("----->get ip: %08x, %08x, %08x\n", ipAddress, port, FreeRTOS_htons(port));

    if ((n->my_socket = FreeRTOS_socket(FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP)) < 0)
        goto exit;

    printf("++++++++++>get ip: %s\n", addr);

    if ((retVal = FreeRTOS_connect(n->my_socket, &sAddr, sizeof(sAddr))) < 0)
    {
        FreeRTOS_closesocket(n->my_socket);
        goto exit;
    }

exit:
    printf("------------>connect init fail \n");
    return retVal;
#endif

#if 0
    int type = SOCK_STREAM;
    struct sockaddr_in address;
    int retVal = -1;
    sa_family_t family = AF_INET;
    struct addrinfo *result = NULL;
    struct addrinfo hints = {0, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0, NULL, NULL, NULL};

    if ((retVal = getaddrinfo(addr, NULL, &hints, &result)) == 0)
    {
        printf("------------------->1\n");
        struct addrinfo* res = result;
        /* prefer ip4 addresses */
        while (res)
        {
            if (res->ai_family == AF_INET)
            {
                result = res;
                break;
            }
            res = res->ai_next;
        }
        if (result->ai_family == AF_INET)
        {
            address.sin_port = htons(port);
            address.sin_family = family = AF_INET;
            address.sin_addr = ((struct sockaddr_in*)(result->ai_addr))->sin_addr;
            printf("------------------->2, %08x, %08x\n", address.sin_port, address.sin_addr);
        }
        else
            retVal = -1;

        freeaddrinfo(result);
    }

    if (retVal == 0) {
        printf("------------------->3\n");
        n->my_socket = socket(family, type, 0);
        if (n->my_socket != -1) {
            printf("Connecting to server %s...\n", ipaddr_ntoa((const ip_addr_t*)&address.sin_addr.s_addr));
            printf("------------------->4, socket:%d\n", n->my_socket);
            while (1) {
                retVal = FreeRTOS_connect(n->my_socket, (struct sockaddr*)&address, sizeof(struct sockaddr));
                if (retVal == 0) break;
            }
            printf("------------------->5, retrun:%d\n", retVal);
        }
    }

exit:
    return retVal;
#endif
}
Ejemplo n.º 30
0
int http_wifi_api_connect_ap(http_connection *c)
{
    CGI_WIFI_DBG("http_wifi_api_connect_ap\n");

    //wait for whole body
    if(c->state <HTTPD_STATE_BODY_END) {
        return HTTPD_CGI_MORE;
    }

    api_cgi_connect_status * status = c->cgi.data;

    if(status==NULL)
    {
        // CGI_WIFI_DBG("http_wifi_api_connect_ap status NULL\n");

        status = (api_cgi_connect_status*)os_malloc(sizeof(api_cgi_connect_status));
        status->state=1;
        c->cgi.data=status;

        //parse json and validate
        cJSON * root = cJSON_Parse(c->body.data);
        if(root==NULL) goto badrequest;

        cJSON * ssid = cJSON_GetObjectItem(root,"ssid");
        if(ssid==NULL) goto badrequest;
        else if(ssid->type != cJSON_String) goto badrequest;

        cJSON * pwd = cJSON_GetObjectItem(root,"pwd");
        if(pwd==NULL) goto badrequest;
        else if(pwd->type!=cJSON_String) goto badrequest;

        //parse ok
        strncpy(status->ssid,ssid->valuestring,32);
        strncpy(status->pwd,pwd->valuestring,64);

        //set timer to connect
        os_timer_disarm(&status->timer);
        os_timer_setfn(&status->timer, (os_timer_func_t *)http_execute_cgi, c);
        os_timer_arm(&status->timer, 10, 0);

        return HTTPD_CGI_MORE;
    }
    else if (status->state==1)
    {
        CGI_WIFI_DBG("connect_ap status %d\n",status->state);
        //try connect

        if(strlen(status->ssid)>32 || strlen(status->pwd)>64)
            goto badrequest;

        CGI_WIFI_DBG("ap connect ssid: %s, pwd: %s\n",status->ssid,status->pwd);

        strcpy(wifi_status.station_config.ssid,status->ssid);
        strcpy(wifi_status.station_config.password,status->pwd);
        wifi_status.station_config.bssid_set=0;

        wifi_station_disconnect();
        wifi_station_set_config(&wifi_status.station_config);
        wifi_station_connect();

        //set timer to check status
        os_timer_disarm(&status->timer);
        os_timer_setfn(&status->timer, (os_timer_func_t *)http_execute_cgi, c);
        os_timer_arm(&status->timer, 500, 0);

        status->state=2;

        return HTTPD_CGI_MORE;
    }
    else if (status->state==2)
    {
        CGI_WIFI_DBG("connect_ap status %d\n",status->state);
        uint8_t c_status = wifi_station_get_connect_status();

        CGI_WIFI_DBG("wifi sta status %d\n",c_status);
        if (c_status>=2 && c_status <= 4 )
        {
            wifi_station_disconnect();
            strcpy(wifi_status.station_config.ssid,"");
            strcpy(wifi_status.station_config.password,"");
            wifi_station_set_config(&wifi_status.station_config);
        }

        if (c_status==1)
        {
            //set timer to check status
            os_timer_disarm(&status->timer);
            os_timer_setfn(&status->timer, (os_timer_func_t *)http_execute_cgi, c);
            os_timer_arm(&status->timer, 500, 0);
            return HTTPD_CGI_MORE;
        }
        else
        {
            //write headers
            http_SET_HEADER(c,HTTP_CONTENT_TYPE,JSON_CONTENT_TYPE);
            http_response_OK(c);

            //create json
            cJSON *root = cJSON_CreateObject();
            cJSON_AddNumberToObject(root,"status",c_status);

            //got ip
            if(c_status==5)
            {
                struct ip_info ip;
                wifi_get_ip_info(0x0,&ip);
                char *ip_str = (char*)ipaddr_ntoa(&ip.ip);
                cJSON_AddStringToObject(root,"ip",ip_str);
            }
            else
            {
                cJSON_AddStringToObject(root,"ip","");
            }

            http_write_json(c,root);

            //delete json struct
            cJSON_Delete(root);

            status->state=99;

            return HTTPD_CGI_MORE;
        }
    }
    else //status=99
    {
        CGI_WIFI_DBG("connect_ap status %d\n",status->state);
        //clean
        os_free(c->cgi.data);
        return HTTPD_CGI_DONE;
    }

badrequest:
    http_response_BAD_REQUEST(c);
    status->state=99;
    return HTTPD_CGI_MORE;

    //shut up compiler
    return HTTPD_CGI_DONE;
}