static void ICACHE_FLASH_ATTR
incoming_connection_callback(void *arg)
{
struct espconn *pconnection = arg;
remot_info *premot = NULL;
uint8_t idx;
int8_t value;
espconn_regist_recvcb(pconnection, tcpserver_recv_callback);
espconn_regist_reconcb(pconnection, tcpserver_reconnect_callback);
espconn_regist_disconcb(pconnection, tcpserver_disconnect_callback);
value = espconn_get_connection_info(&tcp_server, &premot, 0);
os_printf("Incoming TCP connection. link_cnt=%d. Get connnection info result:[%d]\r\n",
tcp_server.link_cnt, value);
if (value == ESPCONN_OK)
{
//char *testString = "Hello! This is a TCP server on ESP8266.\r\n";
for (idx = 0; idx < tcp_server.link_cnt; idx++)
{
os_printf("TCP client %d: %d.%d.%d.%d:%d\r\n",
idx + 1,
premot[idx].remote_ip[0],
premot[idx].remote_ip[1],
premot[idx].remote_ip[2],
premot[idx].remote_ip[3],
premot[idx].remote_port);
}
}
os_printf("\r\n");
}
/*
* 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 httpdConnectCb(void *arg) {
struct espconn *conn=arg;
int i;
//Find empty conndata in pool
for (i=0; i<MAX_CONN; i++) if (connData[i].conn==NULL) break;
os_printf("Con req, conn=%p, pool slot %d\n", conn, i);
if (i==MAX_CONN) {
os_printf("Aiee, conn pool overflow!\n");
espconn_disconnect(conn);
return;
}
connData[i].priv=&connPrivData[i];
connData[i].conn=conn;
connData[i].priv->headPos=0;
connData[i].post=&connPostData[i];
connData[i].post->buff=NULL;
connData[i].post->buffLen=0;
connData[i].post->received=0;
connData[i].post->len=-1;
espconn_regist_recvcb(conn, httpdRecvCb);
espconn_regist_reconcb(conn, httpdReconCb);
espconn_regist_disconcb(conn, httpdDisconCb);
espconn_regist_sentcb(conn, httpdSentCb);
}
/**
* Callback function registered to the ESP8266 environment that is
* invoked when a new inbound connection has been formed.
*/
static void esp8266_callback_connectCB_inbound(
void *arg //!<
) {
struct espconn *pEspconn = (struct espconn *)arg;
assert(pEspconn != NULL);
struct socketData *pClientSocketData = allocateNewSocket();
if (pClientSocketData == NULL) {
DBG("%s: out of sockets, dropping inbound connection\n", DBG_LIB);
espconn_disconnect(pEspconn);
return;
}
DBG("%s: accepted socket %d inbound to port %d from %d.%d.%d.%d:%d\n", DBG_LIB,
pClientSocketData->socketId, pEspconn->proto.tcp->local_port,
IP2STR(pEspconn->proto.tcp->remote_ip), pEspconn->proto.tcp->remote_port);
//dumpEspConn(pEspconn);
// register callbacks on the new connection
espconn_regist_disconcb(pEspconn, esp8266_callback_disconnectCB);
espconn_regist_reconcb(pEspconn, esp8266_callback_reconnectCB);
espconn_regist_sentcb(pEspconn, esp8266_callback_sentCB);
espconn_regist_recvcb(pEspconn, esp8266_callback_recvCB);
pClientSocketData->pEspconn = pEspconn;
pClientSocketData->pEspconn->reverse = pClientSocketData;
pClientSocketData->creationType = SOCKET_CREATED_INBOUND;
pClientSocketData->state = SOCKET_STATE_UNACCEPTED;
}
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");
}
// 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);
}
// Allocate a new connection dynamically and return it. Returns NULL if buf alloc failed
static TcpConn* ICACHE_FLASH_ATTR
tcpConnAlloc(uint8_t chan) {
TcpConn *tci = tcpConn+chan;
if (tci->state != TCP_idle && tci->conn != NULL) return tci;
// malloc and return espconn struct
tci->conn = os_malloc(sizeof(struct espconn));
if (tci->conn == NULL) goto fail;
memset(tci->conn, 0, sizeof(struct espconn));
// malloc esp_tcp struct
tci->tcp = os_malloc(sizeof(esp_tcp));
if (tci->tcp == NULL) goto fail;
memset(tci->tcp, 0, sizeof(esp_tcp));
// common init
tci->state = TCP_dns;
tci->conn->type = ESPCONN_TCP;
tci->conn->state = ESPCONN_NONE;
tci->conn->proto.tcp = tci->tcp;
tci->tcp->remote_port = 80;
espconn_regist_connectcb(tci->conn, tcpConnectCb);
espconn_regist_reconcb(tci->conn, tcpResetCb);
espconn_regist_sentcb(tci->conn, tcpSentCb);
espconn_regist_recvcb(tci->conn, tcpRecvCb);
espconn_regist_disconcb(tci->conn, tcpDisconCb);
tci->conn->reverse = tci;
return tci;
fail:
tcpConnFree(tci);
return NULL;
}
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);
}
LOCAL void ICACHE_FLASH_ATTR dhconnector_init_connection(ip_addr_t *ip) {
os_memcpy(mDHConnector.proto.tcp->remote_ip, &ip->addr, sizeof(ip->addr));
espconn_regist_connectcb(&mDHConnector, network_connect_cb);
espconn_regist_recvcb(&mDHConnector, network_recv_cb);
espconn_regist_reconcb(&mDHConnector, network_error_cb);
espconn_regist_disconcb(&mDHConnector, network_disconnect_cb);
}
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
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");
}
}
LOCAL void ICACHE_FLASH_ATTR
at_tcpserver_listen(void *arg)
{
struct espconn *pespconn = (struct espconn *)arg;
uint8_t i;
printf("get tcpClient:\r\n");
for( i = 0; i < MAX_CONNS; i++ )
{
if( connections[i].pespconn == 0 )
{
break;
}
}
if( i == MAX_CONNS )
{
return;
}
connections[i].pespconn = pespconn;
connections[i].cansend = 1;
connections[i].id = i;
pespconn->reverse = (void*)&connections[i];
espconn_regist_recvcb(pespconn, at_tcpclient_recv);
espconn_regist_reconcb(pespconn, at_tcpserver_recon_cb);
espconn_regist_disconcb(pespconn, at_tcpserver_discon_cb);
espconn_regist_sentcb(pespconn, at_tcpclient_sent_cb);
uart0_sendStr("Link\r\n");
AddPlayer( i );
}
void
setup_server ( void )
{
register struct espconn *c = &server_conn;
char *x;
c->type = ESPCONN_TCP;
c->state = ESPCONN_NONE;
my_tcp_conn.local_port=88;
c->proto.tcp=&my_tcp_conn;
espconn_regist_reconcb ( c, tcp_reconnect_cb);
espconn_regist_connectcb ( c, tcp_connect_cb);
espconn_regist_disconcb ( c, tcp_disconnect_cb);
if ( espconn_accept(c) != ESPCONN_OK ) {
os_printf("Error starting server %d\n", 0);
return;
}
/* Interval in seconds to timeout inactive connections */
espconn_regist_time(c, 20, 0);
// x = (char *) os_zalloc ( 4 );
// os_printf ( "Got mem: %08x\n", x );
os_printf ( "Server ready\n" );
}
static void ICACHE_FLASH_ATTR dnsLookupCb(const char *name, ip_addr_t *ipaddr, void *arg){
struct espconn* conn = arg;
if(ipaddr == NULL){
os_printf("Logger: couldn't resolve IP address for %s;\n", name);
return;
}
os_printf("Successfully resolved %s as %d.%d.%d.%d\n", name,
*((uint8 *) &ipaddr->addr),
*((uint8 *) &ipaddr->addr + 1),
*((uint8 *) &ipaddr->addr + 2),
*((uint8 *) &ipaddr->addr + 3));
if(master_addr.addr == 0 && ipaddr->addr != 0){
master_addr.addr = ipaddr->addr;
os_memcpy(conn->proto.tcp->remote_ip, &ipaddr->addr, 4);
os_printf("Will send to %d.%d.%d.%d\n", (int)conn->proto.tcp->remote_ip[0], (int)conn->proto.tcp->remote_ip[1], (int)conn->proto.tcp->remote_ip[2], (int)conn->proto.tcp->remote_ip[3]);
conn->proto.tcp->local_port = espconn_port();
}
//espconn_create(conn);
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);
os_timer_arm(&broadcastTimer, 60000, 1);
}
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 mqtt_socket_disconnected(void *arg) // tcp only
{
NODE_DBG("enter mqtt_socket_disconnected.\n");
struct espconn *pesp_conn = arg;
bool call_back = false;
if(pesp_conn == NULL)
return;
lmqtt_userdata *mud = (lmqtt_userdata *)pesp_conn->reverse;
if(mud == NULL)
return;
os_timer_disarm(&mud->mqttTimer);
if(mud->connected){ // call back only called when socket is from connection to disconnection.
mud->connected = false;
if((mud->L != NULL) && (mud->cb_disconnect_ref != LUA_NOREF) && (mud->self_ref != LUA_NOREF)) {
lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->cb_disconnect_ref);
lua_rawgeti(mud->L, LUA_REGISTRYINDEX, mud->self_ref); // pass the userdata(client) to callback func in lua
call_back = true;
}
}
if(mud->mqtt_state.auto_reconnect){
mud->pesp_conn->reverse = mud;
mud->pesp_conn->type = ESPCONN_TCP;
mud->pesp_conn->state = ESPCONN_NONE;
mud->connected = false;
mud->pesp_conn->proto.tcp->remote_port = mud->mqtt_state.port;
mud->pesp_conn->proto.tcp->local_port = espconn_port();
espconn_regist_connectcb(mud->pesp_conn, mqtt_socket_connected);
espconn_regist_reconcb(mud->pesp_conn, mqtt_socket_reconnected);
socket_connect(pesp_conn);
} else {
if(mud->pesp_conn){
mud->pesp_conn->reverse = NULL;
if(mud->pesp_conn->proto.tcp)
c_free(mud->pesp_conn->proto.tcp);
mud->pesp_conn->proto.tcp = NULL;
c_free(mud->pesp_conn);
mud->pesp_conn = NULL;
}
if(mud->L == NULL)
return;
lua_gc(mud->L, LUA_GCSTOP, 0);
if(mud->self_ref != LUA_NOREF){ // TODO: should we unref the client and delete it?
luaL_unref(mud->L, LUA_REGISTRYINDEX, mud->self_ref);
mud->self_ref = LUA_NOREF; // unref this, and the mqtt.socket userdata will delete it self
}
lua_gc(mud->L, LUA_GCRESTART, 0);
}
if((mud->L != NULL) && call_back){
lua_call(mud->L, 1, 0);
}
NODE_DBG("leave mqtt_socket_disconnected.\n");
}
LOCAL void ICACHE_FLASH_ATTR
server_listen(void *arg)
{
struct espconn *pesp_conn = arg;
espconn_regist_recvcb(pesp_conn, webserver_recv);
espconn_regist_reconcb(pesp_conn, webserver_recon);
espconn_regist_disconcb(pesp_conn, webserver_discon);
}
LOCAL ICACHE_FLASH_ATTR
void webserver_listen(void *arg) {
struct espconn *pesp_conn = arg;
espconn_regist_recvcb(pesp_conn, webserver_recv);//接收到数据调用webserver_recv
espconn_regist_reconcb(pesp_conn, webserver_recon);//
espconn_regist_disconcb(pesp_conn, webserver_discon);//未接收到数据调用webserver_discon
}
static int tls_socket_connect( lua_State *L ) {
tls_socket_ud *ud = (tls_socket_ud *)luaL_checkudata(L, 1, "tls.socket");
luaL_argcheck(L, ud, 1, "TLS socket expected");
if(ud==NULL){
NODE_DBG("userdata is nil.\n");
return 0;
}
if (ud->pesp_conn) {
return luaL_error(L, "already connected");
}
u16 port = luaL_checkinteger( L, 2 );
size_t il;
const char *domain = "127.0.0.1";
if( lua_isstring(L, 3) )
domain = luaL_checklstring( L, 3, &il );
if (port == 0)
return luaL_error(L, "invalid port");
if (domain == NULL)
return luaL_error(L, "invalid domain");
ud->pesp_conn = (struct espconn*)c_zalloc(sizeof(struct espconn));
if(!ud->pesp_conn)
return luaL_error(L, "not enough memory");
ud->pesp_conn->proto.udp = NULL;
ud->pesp_conn->proto.tcp = (esp_tcp *)c_zalloc(sizeof(esp_tcp));
if(!ud->pesp_conn->proto.tcp){
c_free(ud->pesp_conn);
ud->pesp_conn = NULL;
return luaL_error(L, "not enough memory");
}
ud->pesp_conn->type = ESPCONN_TCP;
ud->pesp_conn->state = ESPCONN_NONE;
ud->pesp_conn->reverse = ud;
ud->pesp_conn->proto.tcp->remote_port = port;
espconn_regist_connectcb(ud->pesp_conn, (espconn_connect_callback)tls_socket_onconnect);
espconn_regist_disconcb(ud->pesp_conn, (espconn_connect_callback)tls_socket_ondisconnect);
espconn_regist_reconcb(ud->pesp_conn, (espconn_reconnect_callback)tls_socket_onreconnect);
espconn_regist_recvcb(ud->pesp_conn, (espconn_recv_callback)tls_socket_onrecv);
espconn_regist_sentcb(ud->pesp_conn, (espconn_sent_callback)tls_socket_onsent);
if (ud->self_ref == LUA_NOREF) {
lua_pushvalue(L, 1); // copy to the top of stack
ud->self_ref = luaL_ref(L, LUA_REGISTRYINDEX);
}
ip_addr_t addr;
err_t err = dns_gethostbyname(domain, &addr, (dns_found_callback)tls_socket_dns_cb, ud);
if (err == ERR_OK) {
tls_socket_dns_cb(domain, &addr, ud);
} else if (err != ERR_INPROGRESS) {
tls_socket_dns_cb(domain, NULL, ud);
}
return 0;
}
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));
}
}
/**
* @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;
}
static void ICACHE_FLASH_ATTR platConnCb(void *arg) {
ConnTypePtr conn=arg;
if (httpdConnectCb(conn, (char*)conn->proto.tcp->remote_ip, conn->proto.tcp->remote_port)) {
espconn_regist_recvcb(conn, platRecvCb);
espconn_regist_reconcb(conn, platReconCb);
espconn_regist_disconcb(conn, platDisconCb);
espconn_regist_sentcb(conn, platSentCb);
} else {
espconn_disconnect(conn);
}
}
void ICACHE_FLASH_ATTR client_connected_cb(void* conn)
{
struct espconn* pconn = (struct espconn*)conn;
os_printf("client connected\n");
os_printf("debug: [%p], [" IPSTR ":%d], state, [%d]\n",
pconn, IP2STR(pconn->proto.tcp->remote_ip), pconn->proto.tcp->remote_port, pconn->state);
espconn_regist_recvcb(pconn, data_received_cb);
espconn_regist_sentcb(pconn, sent_cloud_cb);
espconn_regist_disconcb(pconn, client_disconnected_cb);
espconn_regist_reconcb(pconn, client_reconnect_cb);
}
static void
esp8266_cb_connect(void *arg)
{
struct espconn *cs = arg;
// struct ip_addr *ipa = (struct ip_addr *)cs->proto.tcp->remote_ip;
struct lws_vhost *vh = hacky_context->vhost_list;
// struct ip_info info;
struct lws *wsi;
int n;
lwsl_notice("%s: (wsi coming): %p\n", __func__, cs->reverse);
#if 0
wifi_get_ip_info(0, &info);
if (ip_addr_netcmp(ipa, &info.ip, &info.netmask)) {
/* we are on the same subnet as the AP, ie, connected to AP */
while (vh && strcmp(vh->name, "ap"))
vh = vh->vhost_next;
} else
while (vh && !strcmp(vh->name, "ap"))
vh = vh->vhost_next;
if (!vh)
goto bail;
#endif
n = esp8266_find_free_conn(hacky_context);
if (n < 0)
goto bail;
hacky_context->connpool[n] = cs;
espconn_recv_hold(cs);
wsi = lws_adopt_socket_vhost(vh, cs);
if (!wsi)
goto bail;
lwsl_err("%s: wsi %p (using free_conn %d): vh %s\n", __func__, wsi, n, vh->name);
espconn_regist_recvcb(cs, esp8266_cb_rx);
espconn_regist_reconcb(cs, esp8266_cb_recon);
espconn_regist_disconcb(cs, esp8266_cb_disconnected);
espconn_regist_sentcb(cs, esp8266_cb_sent);
espconn_set_opt(cs, ESPCONN_NODELAY | ESPCONN_REUSEADDR);
espconn_regist_time(cs, 7200, 1);
return;
bail:
lwsl_err("%s: bailed]n", __func__);
espconn_disconnect(cs);
}
void ICACHE_FLASH_ATTR
tcpserver_listen(void *arg)
{
struct espconn *pesp_conn = arg;
os_printf("TCP listen\r\n");
espconn_regist_recvcb(pesp_conn, tcpserver_recv_cb);
espconn_regist_reconcb(pesp_conn, tcpserver_recon_cb);
espconn_regist_disconcb(pesp_conn, tcpserver_discon_cb);
//espconn_regist_sentcb(pesp_conn, tcp_server_sent_cb);
//tcp_server_multi_send();
}
static void ICACHE_FLASH_ATTR serverConnectCb(void *arg) {
struct espconn *conn = arg;
connData->conn=conn;
connData->txbufferlen = 0;
connData->readytosend = true;
DBG_MSG("Client connected!!! txbufferlen=%d\r\n", connData->txbufferlen);
espconn_regist_recvcb(conn, serverRecvCb);
espconn_regist_reconcb(conn, serverReconCb);
espconn_regist_disconcb(conn, serverDisconCb);
espconn_regist_sentcb(conn, serverSentCb);
config_status = CONFIG_STATUS_TELNET_CONNNECTED;
}
void ICACHE_FLASH_ATTR dhap_httpd_init() {
struct espconn *httpdConn = (struct espconn *)os_zalloc(sizeof(struct espconn ));
esp_tcp *httpdTcp = (esp_tcp *)os_zalloc(sizeof(esp_tcp));
httpdConn->type = ESPCONN_TCP;
httpdConn->state = ESPCONN_NONE;
httpdTcp->local_port = HTTPD_PORT;
httpdConn->proto.tcp = httpdTcp;
espconn_regist_connectcb(httpdConn, dhap_httpd_connect_cb);
espconn_regist_reconcb(httpdConn, dhap_httpd_reconnect_cb);
sint8 res = espconn_accept(httpdConn);
if(res)
dhdebug("espconn_accept returned: %d", res);
}
/**
* @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;
}
static void webserver_listen(void *arg)
{
struct espconn *pesp_conn = arg;
console_printf("connect | %d.%d.%d.%d:%d \n",
pesp_conn->proto.tcp->remote_ip[0],
pesp_conn->proto.tcp->remote_ip[1],
pesp_conn->proto.tcp->remote_ip[2],
pesp_conn->proto.tcp->remote_ip[3],
pesp_conn->proto.tcp->remote_port);
espconn_regist_recvcb(pesp_conn, webserver_recv);
espconn_regist_reconcb(pesp_conn, webserver_recon);
espconn_regist_disconcb(pesp_conn, webserver_discon);
}
/************************************************
* name: httpdConnectCb
* parameters: ptArgument - esp connection
* return value: none
* purpose: assign connection to request
************************************************/
static void ICACHE_FLASH_ATTR httpdConnectCb(void * ptArgument)
{
/* initialization */
struct espconn * ptEspConnection = ptArgument;
int iIndex = 0;
/* find empty g_ptConnectionData in pool */
for (iIndex = 0; HTTPD_MAX_CONNECTIONS > iIndex; iIndex++)
{
if (NULL == g_ptConnectionData[iIndex].ptEspConnection)
{
break;
}
#ifdef HTTPD_DEBUG
os_printf("httpdConnectCb: connection request: connection %p, pool slot %d\n", ptEspConnection, iIndex);
#endif
if (HTTPD_MAX_CONNECTIONS == iIndex)
{
#ifdef HTTPD_DEBUG
os_printf("httpdConnectCb: connection pool overflow!\n");
#endif
espconn_disconnect(ptEspConnection);
goto lblCleanup;
}
}
g_ptConnectionData[iIndex].ptPrivate = &g_ptConnectionPrivateData[iIndex];
g_ptConnectionData[iIndex].ptEspConnection = ptEspConnection;
g_ptConnectionData[iIndex].ptPrivate->cbHeaderLength = 0;
g_ptConnectionData[iIndex].ptPost = &g_ptConnectionPost[iIndex];
g_ptConnectionData[iIndex].ptPost->pbBuffer = NULL;
g_ptConnectionData[iIndex].ptPost->cbBufferLength = 0;
g_ptConnectionData[iIndex].ptPost->cbReceived = 0;
g_ptConnectionData[iIndex].ptPost->cbProcessed = 0;
g_ptConnectionData[iIndex].ptPost->cbPostLength = -1;
espconn_regist_recvcb(ptEspConnection, httpdRecvCb);
espconn_regist_reconcb(ptEspConnection, httpdReconCb);
espconn_regist_disconcb(ptEspConnection, httpdDisconCb);
espconn_regist_sentcb(ptEspConnection, httpdSentCb);
lblCleanup:
return;
}
