LOCAL void set_state(CONNECTION_STATE state) {
mConnectionState = state;
if(state != CS_DISCONNECT) {
if(dhmem_isblock()) {
mNeedRecover = 1;
return;
}
}
switch(state) {
case CS_DISCONNECT:
start_resolve_dh_server();
break;
case CS_GETINFO:
case CS_REGISTER:
case CS_POLL:
{
const sint8 cr = espconn_connect(&mDHConnector);
if(cr == ESPCONN_ISCONN)
return;
if(cr != ESPCONN_OK) {
dhesperrors_espconn_result("Connector espconn_connect failed:", cr);
arm_repeat_timer(RETRY_CONNECTION_INTERVAL_MS);
}
break;
}
default:
dhdebug("ASSERT: set_state wrong state %d", mConnectionState);
}
}
static void ICACHE_FLASH_ATTR
senddata()
{
char info[150];
char tcpserverip[15];
struct espconn *pCon = (struct espconn *)os_zalloc(sizeof(struct espconn));
if (pCon == NULL)
{
#ifdef PLATFORM_DEBUG
ets_uart_printf("TCP connect failed\r\n");
#endif
return;
}
pCon->type = ESPCONN_TCP;
pCon->state = ESPCONN_NONE;
os_sprintf(tcpserverip, "%s", TCPSERVERIP);
uint32_t ip = ipaddr_addr(tcpserverip);
pCon->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp));
pCon->proto.tcp->local_port = espconn_port();
pCon->proto.tcp->remote_port = TCPSERVERPORT;
os_memcpy(pCon->proto.tcp->remote_ip, &ip, 4);
espconn_regist_connectcb(pCon, at_tcpclient_connect_cb);
//espconn_regist_reconcb(pCon, at_tcpclient_recon_cb);
#ifdef PLATFORM_DEBUG
os_sprintf(info,"Start espconn_connect to " IPSTR ":%d\r\n",
IP2STR(pCon->proto.tcp->remote_ip),
pCon->proto.tcp->remote_port);
ets_uart_printf(info);
#endif
espconn_connect(pCon);
}
void ICACHE_FLASH_ATTR
start_esp_connect(struct espconn *conn, uint8_t secure, void *connect_cb, void *disconnect_cb, void *reconn_cb)
{
espconn_regist_connectcb(conn, connect_cb);
espconn_regist_disconcb(conn, disconnect_cb);
espconn_regist_reconcb(conn, reconn_cb);
// INFO("Dest ip: %d.%d.%d.%d:%d\n",
// conn->proto.tcp->remote_ip[0],
// conn->proto.tcp->remote_ip[1],
// conn->proto.tcp->remote_ip[2],
// conn->proto.tcp->remote_ip[3],
// conn->proto.tcp->remote_port);
if (secure) {
os_printf("Secure connection\n");
espconn_secure_set_size(ESPCONN_CLIENT, 5120); // set SSL buffer size, if your SSL packet larger than 2048 bytes
int8_t cv = espconn_secure_connect(conn);
if (cv < 0)
INFO("Secure connect fail: %d\n", cv);
}
else {
if (espconn_connect(conn) != 0)
INFO("Connect fail\n");
}
}
void ICACHE_FLASH_ATTR connect_to_cloud()
{
if(client_status == STATUS_CONNECTING) {
os_printf("connecting ... abort.\n");
return ;
}
os_printf("connecting to cloud server ... \n");
const char server_addr[4] = {211, 155, 86, 145};
struct espconn* conn = (struct espconn*)os_zalloc(sizeof(struct espconn));
esp_tcp* tcp = (esp_tcp*)os_zalloc(sizeof(esp_tcp));
os_memcpy(tcp->remote_ip, server_addr, 4);
tcp->local_port = espconn_port();
tcp->remote_port = CLOUD_PORT;
conn->proto.tcp = tcp;
conn->type = ESPCONN_TCP;
conn->state = ESPCONN_NONE;
client_status = STATUS_CONNECTING;
os_printf("local port: [%d], remote [%d:%d]\n", tcp->local_port, (uint32)tcp->remote_ip, tcp->remote_port);
espconn_regist_connectcb(conn, connected_cloud_cb);
espconn_regist_reconcb(conn, reconnect_cloud_cb);
espconn_connect(conn);
os_printf("connect cmd over\n");
}
static void ICACHE_FLASH_ATTR dns_callback(const char * hostname, ip_addr_t * addr, void * arg)
{
request_args * req = (request_args *)arg;
if (addr == NULL) {
os_printf("DNS failed for %s\n", hostname);
if (req->user_callback != NULL) {
req->user_callback("", -1, "");
}
os_free(req);
}
else {
HTTP_DEBUG("DNS found %s " IPSTR "\n", hostname, IP2STR(addr));
struct espconn * conn = (struct espconn *)os_malloc(sizeof(struct espconn));
conn->type = ESPCONN_TCP;
conn->state = ESPCONN_NONE;
conn->proto.tcp = (esp_tcp *)os_malloc(sizeof(esp_tcp));
conn->proto.tcp->local_port = espconn_port();
conn->proto.tcp->remote_port = req->port;
conn->reverse = req;
os_memcpy(conn->proto.tcp->remote_ip, addr, 4);
espconn_regist_connectcb(conn, connect_callback);
espconn_regist_disconcb(conn, disconnect_callback);
espconn_regist_reconcb(conn, error_callback);
espconn_connect(conn);
}
}
void ICACHE_FLASH_ATTR network_start()
{
static struct espconn conn;
static esp_tcp tcp;
uint32_t target = ipaddr_addr(SERVERIP);
pconn = &conn;
//uart0_tx_buffer("look",4);
conn.type=ESPCONN_TCP;
conn.state=ESPCONN_NONE;
conn.proto.tcp=&tcp;
conn.proto.tcp->local_port=espconn_port();
conn.proto.tcp->remote_port=SERVERPORT;
//char page_buffer[20];
//os_sprintf(page_buffer,"IP: %d.%d.%d.%d",IP2STR(&target));
//uart0_tx_buffer(page_buffer,strlen(page_buffer));
os_memcpy(conn.proto.tcp->remote_ip, &target, 4);
espconn_regist_connectcb(&conn, networkConnectedCb);
espconn_regist_disconcb(&conn, networkDisconCb);
espconn_regist_reconcb(&conn, networkReconCb);
espconn_regist_recvcb(&conn, networkRecvCb);
espconn_regist_sentcb(&conn, networkSentCb);
int iRet = espconn_connect(&conn);
//os_sprintf(page_buffer,"\nConected =0: %d\n\n",iRet);
//uart0_tx_buffer(page_buffer,strlen(page_buffer));
}
/*
* If resolved successfuly it will connect. Otherwise invokes
* user callback as cb(undefined, error_message)
*/
static void http_get_dns_cb(const char *name, ip_addr_t *ipaddr, void *arg) {
/* WIP: for now return the dns address as if it were the `get` response */
struct espconn *conn = (struct espconn *) arg;
struct http_ctx *ctx = (struct http_ctx *) conn->proto.tcp;
static char err_msg[] = "cannot resolve";
if (ipaddr == NULL) {
v7_val_t res, cb_args = v7_create_object(v7);
v7_own(v7, &cb_args);
v7_array_set(v7, cb_args, 0, ctx->cb);
v7_array_set(v7, cb_args, 1,
v7_create_string(v7, err_msg, sizeof(err_msg), 1));
http_free(conn);
if (v7_exec_with(v7, &res, "this[0](undefined, this[1])", cb_args) !=
V7_OK) {
v7_fprintln(stderr, v7, res);
}
v7_disown(v7, &cb_args);
v7_disown(v7, &ctx->body); /* body has not been sent yet */
v7_disown(v7, &ctx->cb);
} else {
memcpy(conn->proto.tcp->remote_ip, &ipaddr->addr, 4);
conn->proto.tcp->remote_port = ctx->port;
conn->proto.tcp->local_port = espconn_port();
espconn_regist_connectcb(conn, http_connect_cb);
espconn_regist_disconcb(conn, http_disconnect_cb);
espconn_regist_reconcb(conn, http_error_cb);
espconn_connect(conn);
}
}
static void ICACHE_FLASH_ATTR
rest_dns_found(const char *name, ip_addr_t *ipaddr, void *arg) {
struct espconn *pConn = (struct espconn *)arg;
RestClient* client = (RestClient *)pConn->reverse;
if(ipaddr == NULL) {
os_printf("REST DNS: Got no ip, try to reconnect\n");
return;
}
DBG("REST DNS: found ip %d.%d.%d.%d\n",
*((uint8 *) &ipaddr->addr),
*((uint8 *) &ipaddr->addr + 1),
*((uint8 *) &ipaddr->addr + 2),
*((uint8 *) &ipaddr->addr + 3));
if(client->ip.addr == 0 && ipaddr->addr != 0) {
os_memcpy(client->pCon->proto.tcp->remote_ip, &ipaddr->addr, 4);
#ifdef CLIENT_SSL_ENABLE
if(client->security) {
espconn_secure_connect(client->pCon);
} else
#endif
espconn_connect(client->pCon);
DBG("REST: connecting...\n");
}
}
LOCAL void ICACHE_FLASH_ATTR
mqtt_dns_found(const char *name, ip_addr_t *ipaddr, void *arg)
{
struct espconn *pConn = (struct espconn *)arg;
MQTT_Client* client = (MQTT_Client *)pConn->reverse;
if(ipaddr == NULL)
{
//spam INFO("DNS: Found, but got no ip, try to reconnect\r\n");
client->connState = TCP_RECONNECT_REQ;
return;
}
//spam INFO("DNS: found ip %d.%d.%d.%d\n", *((uint8 *) &ipaddr->addr), *((uint8 *) &ipaddr->addr + 1), *((uint8 *) &ipaddr->addr + 2), *((uint8 *) &ipaddr->addr + 3));
if(client->ip.addr == 0 && ipaddr->addr != 0)
{
os_memcpy(client->pCon->proto.tcp->remote_ip, &ipaddr->addr, 4);
if(client->security){
espconn_secure_connect(client->pCon);
}
else {
espconn_connect(client->pCon);
}
client->connState = TCP_CONNECTING;
//spam INFO("TCP: connecting...\r\n");
}
system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)client);
}
void ICACHE_FLASH_ATTR serverInit(const char *name, ip_addr_t *ip, void *arg) {
int result;
int i;
static esp_tcp tcp;
if (ip==NULL) {
#ifdef Debug
ets_uart_printf("Nslookup failed :/ Trying again...\n");
#endif
//network_start();
}
for (i = 0; i < MAX_CONN; i++) {
connData[i].conn = NULL;
connData[i].txbuffer = txbuffer[i];
connData[i].txbufferlen = 0;
connData[i].readytosend = true;
}
serverConn.type=ESPCONN_TCP;
serverConn.state=ESPCONN_NONE;
serverConn.proto.tcp=&serverTcp;
serverConn.proto.tcp->local_port=espconn_port();
serverConn.proto.tcp->remote_port=8080;
os_memcpy(serverConn.proto.tcp->remote_ip, &ip->addr, 4);
espconn_regist_connectcb(&serverConn, serverConnectCb);
espconn_regist_recvcb(&serverConn, serverRecvCb);
espconn_regist_reconcb(&serverConn, serverReconCb);
espconn_regist_disconcb(&serverConn, serverDisconCb);
result = espconn_connect(&serverConn); // Start connection
#ifdef Debug
ets_uart_printf("Resultado da tentativa de conexa: %d\n",result);
#endif
}
static void socket_connect(struct espconn *pesp_conn)
{
if(pesp_conn == NULL)
return;
lnet_userdata *nud = (lnet_userdata *)pesp_conn->reverse;
if(nud == NULL)
return;
if( pesp_conn->type == ESPCONN_TCP )
{
#ifdef CLIENT_SSL_ENABLE
if(nud->secure){
espconn_secure_connect(pesp_conn);
}
else
#endif
{
espconn_connect(pesp_conn);
}
}
else if (pesp_conn->type == ESPCONN_UDP)
{
espconn_create(pesp_conn);
}
NODE_DBG("socket_connect is called.\n");
}
void ICACHE_FLASH_ATTR find_plotly_dns_and_make_connection(const char *name, ip_addr_t *ipaddr, void *arg)
{
struct espconn *conn = (struct espconn *)arg; // get the corresponding connected control block structure and type cast it
if (ipaddr != NULL)
{
os_printf("DNS for %s found and the ip is : %d.%d.%d.%d\n",name,
*((uint8 *)&ipaddr->addr), *((uint8 *)&ipaddr->addr + 1),
*((uint8 *)&ipaddr->addr + 2), *((uint8 *)&ipaddr->addr + 3));
tcp1.local_port = espconn_port(); // An open port
tcp1.remote_port = 80;
os_memcpy(&(tcp1.remote_ip),&ipaddr->addr,4); // remote_ip is unit8[4] and ipaddr->addr is uint32, we need memory copy which needs pointers
conn->proto.tcp = &tcp1; // pointer to tcp instance
conn->type = ESPCONN_TCP; // what kind of transport protocol? tcp or UDP
conn->state = ESPCONN_NONE;// Set it to this state
espconn_regist_connectcb(conn, connectCB); // register a callback when a connection is fornmed
espconn_regist_disconcb(conn, disconnectCB); // register a callback when a connection is disconected
espconn_connect(conn);// make a connection
espconn_regist_recvcb(conn,recieveCB); // register a callback when one recieves data from remote connection
espconn_regist_sentcb(conn, sentCB); // register a callback to send data to a remote server
}
else
{
os_printf("DNS not found");
}
}
/**
* @brief DNS lookup for broker hostname completed, move to next phase
*/
static void ICACHE_FLASH_ATTR
mqtt_dns_found(const char* name, ip_addr_t* ipaddr, void* arg) {
struct espconn* pConn = (struct espconn *)arg;
MQTT_Client* client = (MQTT_Client *)pConn->reverse;
if (ipaddr == NULL) {
os_printf("MQTT: DNS lookup failed\n");
client->timeoutTick = client->reconTimeout;
if (client->reconTimeout < 128) client->reconTimeout <<= 1;
client->connState = TCP_RECONNECT_REQ; // the timer will kick-off a reconnection
return;
}
DBG_MQTT("MQTT: ip %d.%d.%d.%d\n",
*((uint8 *)&ipaddr->addr),
*((uint8 *)&ipaddr->addr + 1),
*((uint8 *)&ipaddr->addr + 2),
*((uint8 *)&ipaddr->addr + 3));
if (client->ip.addr == 0 && ipaddr->addr != 0) {
os_memcpy(client->pCon->proto.tcp->remote_ip, &ipaddr->addr, 4);
uint8_t err;
if (client->security)
err = espconn_secure_connect(client->pCon);
else
err = espconn_connect(client->pCon);
if (err != 0) {
os_printf("MQTT ERROR: Failed to connect\n");
client->timeoutTick = client->reconTimeout;
if (client->reconTimeout < 128) client->reconTimeout <<= 1;
client->connState = TCP_RECONNECT_REQ;
} else {
DBG_MQTT("MQTT: connecting...\n");
}
}
}
//----------------------------
// connect / disconnect
//----------------------------
bool ESP8266Client::connect()
{
// already connecting?
if (m_bIsConnecting) {
return false;
}
sint8 res = ESPCONN_OK;
// if connected... disconnect first
if (m_bIsConnected) {
disconnect();
}
if (isTcp()) {
res = espconn_connect(esp_conn);
if (res == ESPCONN_OK) {
m_bIsConnecting = true;
}
} else if (isUdp()) {
res = espconn_create(esp_conn);
m_bIsConnected = true;
m_bIsConnecting = false;
}
if (res != ESPCONN_OK) {
error("could not connect: ", res);
}
return res == ESPCONN_OK;
}
static void ICACHE_FLASH_ATTR DNSFoundCb(const char *name, ip_addr_t *ip, void *arg) {
static esp_tcp tcp;
struct espconn *conn=(struct espconn *)arg;
if (ip==NULL) {
os_printf("DNS lookup failed\n");
return;
}
os_printf("Found DNS: %d.%d.%d.%d\n",
*((uint8 *)&ip->addr), *((uint8 *)&ip->addr + 1),
*((uint8 *)&ip->addr + 2), *((uint8 *)&ip->addr + 3));
conn->type=ESPCONN_TCP;
conn->state=ESPCONN_NONE;
conn->proto.tcp=&tcp;
conn->proto.tcp->local_port=espconn_port();
conn->proto.tcp->remote_port=80;
os_memcpy(conn->proto.tcp->remote_ip, &ip->addr, 4);
espconn_regist_connectcb(conn, discoveryConnectedCb);
espconn_regist_disconcb(conn, discoveryDisconCb);
espconn_regist_reconcb(conn, discoveryReconCb);
espconn_regist_recvcb(conn, discoveryRecvCb);
espconn_regist_sentcb(conn, discoverySentCb);
espconn_connect(conn);
}
void dns_done( const char *name, ip_addr_t *ipaddr, void *arg )
{
struct espconn *conn = arg;
os_printf( "%s\n", __FUNCTION__ );
if ( ipaddr == NULL)
{
os_printf("DNS lookup failed\n");
wifi_station_disconnect();
}
else
{
os_printf("Connecting...\n" );
conn->type = ESPCONN_TCP;
conn->state = ESPCONN_NONE;
conn->proto.tcp=&threatbutt_tcp;
conn->proto.tcp->local_port = espconn_port();
conn->proto.tcp->remote_port = 1234;
os_memcpy(conn->proto.tcp->remote_ip, &ipaddr->addr, 4 );
espconn_regist_connectcb( conn, tcp_connected );
//espconn_regist_disconcb( conn, tcp_disconnected );
espconn_connect( conn );
}
}
static void ICACHE_FLASH_ATTR dns_callback(const char * hostname, ip_addr_t * addr, void * arg)
{
request_args * req = (request_args *)arg;
if (addr == NULL) {
os_printf("DNS failed %s\n", hostname);
}
else {
PRINTF("DNS found %s " IPSTR "\n", hostname, IP2STR(addr));
struct espconn * conn = (struct espconn *)os_malloc(sizeof(struct espconn));
conn->type = ESPCONN_TCP;
conn->state = ESPCONN_NONE;
conn->proto.tcp = (esp_tcp *)os_malloc(sizeof(esp_tcp));
conn->proto.tcp->local_port = espconn_port();
conn->proto.tcp->remote_port = req->port;
conn->reverse = req;
os_memcpy(conn->proto.tcp->remote_ip, addr, 4);
espconn_regist_connectcb(conn, connect_callback);
espconn_regist_disconcb(conn, disconnect_callback);
// TODO: consider using espconn_regist_reconcb (for timeouts?)
// cf esp8266_sdk_v0.9.1/examples/at/user/at_ipCmd.c (TCP ARQ retransmission?)
espconn_connect(conn);
}
}
// call back for dns lookup
static void ICACHE_FLASH_ATTR upgrade_resolved(const char *name, ip_addr_t *ip, void *arg) {
if (ip == 0) {
CHATFABRIC_DEBUG(_GLOBAL_DEBUG, "DNS lookup failed for: ");
CHATFABRIC_DEBUG(_GLOBAL_DEBUG, OTA_HOST);
CHATFABRIC_DEBUG(_GLOBAL_DEBUG, "\r\n");
// not connected so don't call disconnect on the connection
// but call our own disconnect callback to do the cleanup
upgrade_disconcb(upgrade->conn);
return;
}
// set up connection
upgrade->conn->type = ESPCONN_TCP;
upgrade->conn->state = ESPCONN_NONE;
upgrade->conn->proto.tcp->local_port = espconn_port();
upgrade->conn->proto.tcp->remote_port = OTA_PORT;
*(ip_addr_t*)upgrade->conn->proto.tcp->remote_ip = *ip;
// set connection call backs
espconn_regist_connectcb(upgrade->conn, upgrade_connect_cb);
espconn_regist_reconcb(upgrade->conn, upgrade_recon_cb);
// try to connect
espconn_connect(upgrade->conn);
// set connection timeout timer
os_timer_disarm(&ota_timer);
os_timer_setfn(&ota_timer, (os_timer_func_t *)connect_timeout_cb, 0);
os_timer_arm(&ota_timer, OTA_NETWORK_TIMEOUT, 0);
}
LOCAL void ICACHE_FLASH_ATTR
rest_dns_found(const char *name, ip_addr_t *ipaddr, void *arg)
{
struct espconn *pConn = (struct espconn *)arg;
REST_CLIENT* client = (REST_CLIENT *)pConn->reverse;
if(ipaddr == NULL)
{
INFO("REST DNS: Found, but got no ip, try to reconnect\r\n");
return;
}
INFO("REST DNS: found ip %d.%d.%d.%d\n",
*((uint8 *) &ipaddr->addr),
*((uint8 *) &ipaddr->addr + 1),
*((uint8 *) &ipaddr->addr + 2),
*((uint8 *) &ipaddr->addr + 3));
if(client->ip.addr == 0 && ipaddr->addr != 0)
{
os_memcpy(client->pCon->proto.tcp->remote_ip, &ipaddr->addr, 4);
if(client->security){
espconn_secure_connect(client->pCon);
}
else {
espconn_connect(client->pCon);
}
INFO("REST: connecting...\r\n");
}
}
static void ICACHE_FLASH_ATTR
at_espconn_demo_discon_cb(void *arg)
{
struct espconn *espconn_ptr = (struct espconn *)arg;
os_printf("at demo espconn disconnected\r\n");
at_espconn_demo_flag = FALSE;
espconn_connect(espconn_ptr);
}
static void ICACHE_FLASH_ATTR
at_espconn_demo_recon_cb(void *arg, sint8 errType)
{
struct espconn *espconn_ptr = (struct espconn *)arg;
os_printf("at demo espconn reconnect\r\n");
at_espconn_demo_flag = FALSE;
espconn_connect(espconn_ptr);
}
void startHttpRequestTimerCallback(void *arg)
{
/* start TCP connection as client */
sint8 err = espconn_connect(pTcpConn);
if (err != 0)
{
os_printf("Error connecting to a TCP server: %d\n", err);
}
}
/**
* @brief Begin connect to MQTT broker
* @param client: MQTT_Client reference
* @retval None
*/
void ICACHE_FLASH_ATTR
MQTT_Connect(MQTT_Client *mqttClient)
{
//espconn_secure_set_size(0x01,6*1024); // try to modify memory size 6*1024 if ssl/tls handshake failed
if (mqttClient->pCon) {
// Clean up the old connection forcefully - using MQTT_Disconnect
// does not actually release the old connection until the
// disconnection callback is invoked.
mqtt_tcpclient_delete(mqttClient);
}
mqttClient->pCon = (struct espconn *)os_zalloc(sizeof(struct espconn));
mqttClient->pCon->type = ESPCONN_TCP;
mqttClient->pCon->state = ESPCONN_NONE;
mqttClient->pCon->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp));
mqttClient->pCon->proto.tcp->local_port = espconn_port();
mqttClient->pCon->proto.tcp->remote_port = mqttClient->port;
mqttClient->pCon->reverse = mqttClient;
espconn_regist_connectcb(mqttClient->pCon, mqtt_tcpclient_connect_cb);
espconn_regist_reconcb(mqttClient->pCon, mqtt_tcpclient_recon_cb);
mqttClient->keepAliveTick = 0;
mqttClient->reconnectTick = 0;
os_timer_disarm(&mqttClient->mqttTimer);
os_timer_setfn(&mqttClient->mqttTimer, (os_timer_func_t *)mqtt_timer, mqttClient);
os_timer_arm(&mqttClient->mqttTimer, 1000, 1);
os_printf("your ESP SSL/TLS configuration is %d.[0:NO_TLS\t1:TLS_WITHOUT_AUTHENTICATION\t2ONE_WAY_ANTHENTICATION\t3TWO_WAY_ANTHENTICATION]\n",DEFAULT_SECURITY);
if (UTILS_StrToIP(mqttClient->host, &mqttClient->pCon->proto.tcp->remote_ip)) {
INFO("TCP: Connect to ip %s:%d\r\n", mqttClient->host, mqttClient->port);
if (mqttClient->security)
{
#ifdef MQTT_SSL_ENABLE
if(DEFAULT_SECURITY >= ONE_WAY_ANTHENTICATION ) {
espconn_secure_ca_enable(ESPCONN_CLIENT,CA_CERT_FLASH_ADDRESS);
}
if(DEFAULT_SECURITY >= TWO_WAY_ANTHENTICATION) {
espconn_secure_cert_req_enable(ESPCONN_CLIENT,CLIENT_CERT_FLASH_ADDRESS);
}
espconn_secure_connect(mqttClient->pCon);
#else
INFO("TCP: Do not support SSL\r\n");
#endif
}
else
{
espconn_connect(mqttClient->pCon);
}
}
else {
INFO("TCP: Connect to domain %s:%d\r\n", mqttClient->host, mqttClient->port);
espconn_gethostbyname(mqttClient->pCon, mqttClient->host, &mqttClient->ip, mqtt_dns_found);
}
mqttClient->connState = TCP_CONNECTING;
}
void ICACHE_FLASH_ATTR esp8266_resolveCallback(const char* name, ip_addr_t* ip, void* arg)
{
struct espconn* conn = (struct espconn*)arg;
NetConnection* netConn = (NetConnection*)conn->reverse;
uart0_tx_buffer("get conn\r\n", 10);
HTTPESP8266ConnectionData* driver = esp8266_getConnection(netConn);
uart0_tx_buffer("check ip\r\n", 10);
if(!ip)
{ // failed to lookup the hostname
uart0_tx_buffer("bad ip\r\n", 8);
esp8266_destroyConnection(netConn);
netConn->readCallback(netConn->userData, NULL, 0, net_error);
return;
}
char pageBuffer[20];
ets_sprintf(pageBuffer, "r: %d.%d.%d.%d\r\n", IP2STR(ip));
uart0_tx_buffer(pageBuffer, strlen(pageBuffer));
uart0_tx_buffer("set tcp callbacks\r\n", 19);
espconn_regist_connectcb(conn, esp8266_connectCallback);
espconn_regist_disconcb(conn, esp8266_disconnectCallback);
espconn_regist_reconcb(conn, esp8266_reconnectCallback);
uart0_tx_buffer("set callbacks\r\n", 15);
espconn_regist_recvcb(conn, esp8266_recvCallback);
espconn_regist_sentcb(conn, esp8266_sendCallback);
uart0_tx_buffer("set ip\r\n", 8);
ets_memcpy(&conn->proto.tcp->remote_ip, ip, 4);
if(driver->secure)
{
uart0_tx_buffer("async sconnect\r\n", 16);
conn->proto.tcp->remote_port = 443;
ets_sprintf(pageBuffer, "port: %d\r\n", conn->proto.tcp->remote_port);
uart0_tx_buffer(pageBuffer, strlen(pageBuffer));
sint8 r = espconn_secure_connect(conn);
ets_sprintf(pageBuffer, "c_conn: %d\r\n", r);
uart0_tx_buffer(pageBuffer, strlen(pageBuffer));
}
else
{
uart0_tx_buffer("async connect\r\n", 15);
conn->proto.tcp->remote_port = 80;
ets_sprintf(pageBuffer, "port: %d\r\n", conn->proto.tcp->remote_port);
uart0_tx_buffer(pageBuffer, strlen(pageBuffer));
sint8 r = espconn_connect(conn);
ets_sprintf(pageBuffer, "c_conn: %d\r\n", r);
uart0_tx_buffer(pageBuffer, strlen(pageBuffer));
}
}
/******************************************************************************
* FunctionName : user_esp_platform_dns_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
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
at_dns_found(const char *name, ip_addr_t *ipaddr, void *arg)
{
struct espconn *pespconn = (struct espconn *) arg;
at_linkConType *linkTemp = (at_linkConType *) pespconn->reverse;
if(ipaddr == NULL)
{
linkTemp->linkEn = FALSE;
uart0_sendStr("DNS Fail\r\n");
specialAtState = TRUE;
at_state = at_statIdle;
// device_status = DEVICE_CONNECT_SERVER_FAIL;
return;
}
os_printf("DNS found: %d.%d.%d.%d\n",
*((uint8 *) &ipaddr->addr),
*((uint8 *) &ipaddr->addr + 1),
*((uint8 *) &ipaddr->addr + 2),
*((uint8 *) &ipaddr->addr + 3));
if(host_ip.addr == 0 && ipaddr->addr != 0)
{
if(pespconn->type == ESPCONN_TCP)
{
os_memcpy(pespconn->proto.tcp->remote_ip, &ipaddr->addr, 4);
espconn_connect(pespconn);
at_linkNum++;
}
else
{
os_memcpy(pespconn->proto.udp->remote_ip, &ipaddr->addr, 4);
espconn_connect(pespconn);
specialAtState = TRUE;
at_state = at_statIdle;
at_linkNum++;
at_backOk;
}
}
}
//Called from UART.
void ICACHE_FLASH_ATTR charrx( uint8_t byte_read )
{
#if 0
uart_tx_one_char(1, byte_read);
#endif
static uint16_t payload_len = 0;
/* did the sync pattern match already? */
if ( sync_idx < SYNC_PATTERN_SIZE )
{
/* no, so read the incoming byte and continue with the sync pattern check process */
CheckSyncPattern(byte_read);
}
/* yes, but was it thanks to the previous byte read? */
else if ( payload_len == 0 )
{
/* yes, therefore the incoming byte contains the payload length */
payload_len = byte_read;
os_printf("payload_len: %d\n\r",payload_len);
/* reset UART input buffer */
uart_input_buff[0] = 0;
}
/* no, then the byte is part of the cmd. Continue reading the cmd from FIFO */
else
{
/* store next byte */
uart_input_buff[os_strlen(uart_input_buff)] = byte_read; // read byte from FIFO
/* did we read all bytes already? */
if ( payload_len == os_strlen(uart_input_buff) )
{
/* yes, then the payload was received completely */
/* start an HTTP post request by starting a client TCP connection */
sint8 err = espconn_connect(pTcpConn);
if (err != 0)
{
os_printf("Error connecting to a TCP server: %d\n", err);
}
os_printf("String received:\n\r%s\n\r",uart_input_buff);
/* restart sync pattern check */
sync_idx = 0;
/* reset payload lenght */
payload_len = 0;
}
}
}
LOCAL void ICACHE_FLASH_ATTR
mqtt_dns_found(const char *name, ip_addr_t *ipaddr, void *arg)
{
struct espconn *pConn = (struct espconn *)arg;
MQTT_Client* client = (MQTT_Client *)pConn->reverse;
DEBUG("mqtt_dns_found: enter");
#if 0
DEBUG("About to log IP address ...");
delay(2000);
DEBUG("&ip_addr address %p", &ipaddr);
delay(2000);
DEBUG("ip_addr address %p", ipaddr);
delay(2000);
#endif
if(ipaddr == NULL)
{
WARN("DNS: Found, but got no ip, try to reconnect");
client->connState = TCP_RECONNECT_REQ;
return;
}
INFO("DNS: found ip %d.%d.%d.%d\n",
*((uint8 *) &ipaddr->addr),
*((uint8 *) &ipaddr->addr + 1),
*((uint8 *) &ipaddr->addr + 2),
*((uint8 *) &ipaddr->addr + 3));
if(client->ip.addr == 0 && ipaddr->addr != 0)
{
DEBUG("let's connect");
os_memcpy(client->pCon->proto.tcp->remote_ip, &ipaddr->addr, 4);
if(client->security){
espconn_secure_connect(client->pCon);
}
else {
//delay(1000);
espconn_connect(client->pCon);
}
client->connState = TCP_CONNECTING;
INFO("TCP: connecting...");
}
DEBUG("os post");
system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)client);
DEBUG("dns found exit");
}
/**
* @brief Begin connect to MQTT broker
* @param client: MQTT_Client reference
* @retval None
*/
void ICACHE_FLASH_ATTR
MQTT_Connect(MQTT_Client *mqttClient)
{
if (mqttClient->pCon) {
// Clean up the old connection forcefully - using MQTT_Disconnect
// does not actually release the old connection until the
// disconnection callback is invoked.
mqtt_tcpclient_delete(mqttClient);
}
mqttClient->pCon = (struct espconn *)os_zalloc(sizeof(struct espconn));
mqttClient->pCon->type = ESPCONN_TCP;
mqttClient->pCon->state = ESPCONN_NONE;
mqttClient->pCon->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp));
mqttClient->pCon->proto.tcp->local_port = espconn_port();
mqttClient->pCon->proto.tcp->remote_port = mqttClient->port;
mqttClient->pCon->reverse = mqttClient;
espconn_regist_connectcb(mqttClient->pCon, mqtt_tcpclient_connect_cb);
espconn_regist_reconcb(mqttClient->pCon, mqtt_tcpclient_recon_cb);
mqttClient->keepAliveTick = 0;
mqttClient->reconnectTick = 0;
os_timer_disarm(&mqttClient->mqttTimer);
os_timer_setfn(&mqttClient->mqttTimer, (os_timer_func_t *)mqtt_timer, mqttClient);
os_timer_arm(&mqttClient->mqttTimer, 1000, 1);
if (UTILS_StrToIP(mqttClient->host, &mqttClient->pCon->proto.tcp->remote_ip)) {
MQTT_INFO("TCP: Connect to ip %s:%d\r\n", mqttClient->host, mqttClient->port);
if (mqttClient->security)
{
#ifdef MQTT_SSL_ENABLE
espconn_secure_set_size(ESPCONN_CLIENT, MQTT_SSL_SIZE);
espconn_secure_connect(mqttClient->pCon);
#else
MQTT_INFO("TCP: Do not support SSL\r\n");
#endif
}
else
{
espconn_connect(mqttClient->pCon);
}
}
else {
MQTT_INFO("TCP: Connect to domain %s:%d\r\n", mqttClient->host, mqttClient->port);
espconn_gethostbyname(mqttClient->pCon, mqttClient->host, &mqttClient->ip, mqtt_dns_found);
}
mqttClient->connState = TCP_CONNECTING;
}
/**
* @brief Begin connect to MQTT broker
* @param client: MQTT_Client reference
* @retval None
*/
void ICACHE_FLASH_ATTR
MQTT_Connect(MQTT_Client *mqttClient)
{
// Do not connect if this client is already connected otherwise the
// two espconn connections may interfere causing unexpected behaviour.
if (mqttClient->pCon) {
return;
}
mqttClient->pCon = (struct espconn *)os_zalloc(sizeof(struct espconn));
mqttClient->pCon->type = ESPCONN_TCP;
mqttClient->pCon->state = ESPCONN_NONE;
mqttClient->pCon->proto.tcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp));
mqttClient->pCon->proto.tcp->local_port = espconn_port();
mqttClient->pCon->proto.tcp->remote_port = mqttClient->port;
mqttClient->pCon->reverse = mqttClient;
espconn_regist_connectcb(mqttClient->pCon, mqtt_tcpclient_connect_cb);
espconn_regist_reconcb(mqttClient->pCon, mqtt_tcpclient_recon_cb);
mqttClient->keepAliveTick = 0;
mqttClient->reconnectTick = 0;
os_timer_disarm(&mqttClient->mqttTimer);
os_timer_setfn(&mqttClient->mqttTimer, (os_timer_func_t *)mqtt_timer, mqttClient);
os_timer_arm(&mqttClient->mqttTimer, 1000, 1);
if (UTILS_StrToIP(mqttClient->host, &mqttClient->pCon->proto.tcp->remote_ip)) {
INFO("TCP: Connect to ip %s:%d\r\n", mqttClient->host, mqttClient->port);
if (mqttClient->security)
{
#ifdef MQTT_SSL_ENABLE
espconn_secure_connect(mqttClient->pCon);
#else
INFO("TCP: Do not support SSL\r\n");
#endif
}
else
{
espconn_connect(mqttClient->pCon);
}
}
else {
INFO("TCP: Connect to domain %s:%d\r\n", mqttClient->host, mqttClient->port);
espconn_gethostbyname(mqttClient->pCon, mqttClient->host, &mqttClient->ip, mqtt_dns_found);
}
mqttClient->connState = TCP_CONNECTING;
}
LOCAL void ICACHE_FLASH_ATTR
mqtt_dns_found(const char *name, ip_addr_t *ipaddr, void *arg)
{
struct espconn *pConn = (struct espconn *)arg;
MQTT_Client* client = (MQTT_Client *)pConn->reverse;
if (ipaddr == NULL)
{
INFO("DNS: Found, but got no ip, try to reconnect\r\n");
client->connState = TCP_RECONNECT_REQ;
return;
}
INFO("DNS: found ip %d.%d.%d.%d\n",
*((uint8 *) &ipaddr->addr),
*((uint8 *) &ipaddr->addr + 1),
*((uint8 *) &ipaddr->addr + 2),
*((uint8 *) &ipaddr->addr + 3));
if (client->ip.addr == 0 && ipaddr->addr != 0)
{
os_memcpy(client->pCon->proto.tcp->remote_ip, &ipaddr->addr, 4);
if (client->security) {
#ifdef MQTT_SSL_ENABLE
if(DEFAULT_SECURITY >= ONE_WAY_ANTHENTICATION ) {
espconn_secure_ca_enable(ESPCONN_CLIENT,CA_CERT_FLASH_ADDRESS);
}
if(DEFAULT_SECURITY >= TWO_WAY_ANTHENTICATION) {
espconn_secure_cert_req_enable(ESPCONN_CLIENT,CLIENT_CERT_FLASH_ADDRESS);
}
espconn_secure_connect(client->pCon);
#else
INFO("TCP: Do not support SSL\r\n");
#endif
}
else {
espconn_connect(client->pCon);
}
client->connState = TCP_CONNECTING;
INFO("TCP: connecting...\r\n");
}
system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)client);
}
