//Callback called when there's data available on a socket. static void ICACHE_FLASH_ATTR http_process_received_cb(void *arg, char *data, unsigned short len) { NODE_DBG("\nhttp_process_received_cb, len: %d",len); http_connection *conn = http_process_find_connection(arg); if(conn==NULL){ espconn_disconnect(arg); return; } //pass data to http_parser size_t nparsed = http_parser_execute( &(conn->parser), &(conn->parser_settings), data, len); if (conn->parser.upgrade) { /* handle new protocol */ on_websocket_data(&conn->parser,data,len); } else if (nparsed != len) { /* Handle error. Usually just close the connection. */ espconn_disconnect(conn->espConnection); http_process_free_connection(conn); } }
static void webserver_recv(void *arg, char *pusrdata, unsigned short length) { while (length--) { if ((*pusrdata == 13) || (*pusrdata == 10)) { linebuffer[lineptr++]=0x0; console_printf("receive | %s\n", linebuffer); lineptr = 0; pusrdata++; if (disconn) { espconn_disconnect(arg); return; } continue; } else if (lineptr == LINEBUFFER_SIZE) { linebuffer[LINEBUFFER_SIZE - 1]=0x0; console_printf("receive | %s\n", linebuffer); lineptr = 0; pusrdata++; if (disconn) { espconn_disconnect(arg); return; } continue; } linebuffer[lineptr++] = *pusrdata++; } }
//这里有可能需要加入 数据包的处理,譬如 多包同时到达,单包分次抵达 void ICACHE_FLASH_ATTR data_received_cb(void* param, char* pdata, unsigned short len) { struct espconn* conn = (struct espconn*)param; os_printf("datareceived_cloud_cb, conn: [%p]\n", conn); uint8 i = 0; uint8 pack_len = pdata[0]; uint8 glfunc_size = sizeof(gl_procs) / sizeof(struct pack_proc); msg_pack_proc_fn fn = NULL; uint8 msgtype = pdata[1]; bool matched = false; //TODO: 数据包可能分批抵达,亦可能一次抵达多个 if(len < pack_len) { os_printf("network error, or pack error, or protocol error\n"); espconn_disconnect(conn); return ; } for(; i != glfunc_size; ++i) { if(msgtype == gl_procs[i].msgtype) { matched = true; fn = gl_procs[i].fn; fn(conn, pdata, len); } } if(!matched) { os_printf("unknown protocol, connection [%p] closed\n", conn); espconn_disconnect(conn); } }
static void http_ws_handle_message(http_connection *c,ws_frame *msg){ if(c->cgi.function!=NULL){ //put frame on argument c->cgi.argument=(void *)msg; //call cgi int r = c->cgi.function(c); int sent = http_transmit(c); if(r==HTTP_WS_CGI_DONE){ //we should close the socket c->cgi.done=1; if(sent==0){ //we should active close it now as no data was sent, so there will be no further callback //TODO send close frame instead of hard closing espconn_disconnect(c->espConnection); http_process_free_connection(c); } } } }
LOCAL void network_connect_cb(void *arg) { HTTP_REQUEST *request; switch(mConnectionState) { case CS_GETINFO: request = &mInfoRequest; dhdebug("Send info request..."); break; case CS_REGISTER: request = &mRegisterRequest; dhdebug("Send register request..."); break; case CS_POLL: request = &mPollRequest; dhdebug("Send poll request..."); break; default: dhdebug("ASSERT: networkConnectCb wrong state %d", mConnectionState); } int res; if( (res = espconn_send(&mDHConnector, request->data, request->len)) != ESPCONN_OK) { mConnectionState = CS_DISCONNECT; dhesperrors_espconn_result("network_connect_cb failed:", res); espconn_disconnect(&mDHConnector); } else { dhstatistic_add_bytes_sent(request->len); } }
//Callback called when the data on a socket has been successfully sent. static void ICACHE_FLASH_ATTR httpdSentCb(void *arg) { debugConn(arg, "httpdSentCb"); int r; HttpdConnData *conn=httpdFindConnData(arg); char sendBuff[MAX_SENDBUFF_LEN]; if (conn==NULL) return; conn->priv->sendBuff=sendBuff; conn->priv->sendBuffLen=0; if (conn->cgi==NULL) { //Marked for destruction? //os_printf("Closing 0x%p/0x%p->0x%p\n", arg, conn->conn, conn); espconn_disconnect(conn->conn); //httpdRetireConn(conn); // can't call this, we will get a diconnect callback! return; //No need to call xmitSendBuff. } r=conn->cgi(conn); //Execute cgi fn. if (r==HTTPD_CGI_DONE) { conn->cgi=NULL; //mark for destruction. } if (r==HTTPD_CGI_NOTFOUND || r==HTTPD_CGI_AUTHENTICATED) { os_printf("%s ERROR! CGI fn returns code %d after sending data! Bad CGI!\n", connStr, r); conn->cgi=NULL; //mark for destruction. } xmitSendBuff(conn); }
/** * 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 httpserver_connectcb(void *arg) { int i; struct espconn *pespconn = (struct espconn *)arg; for( i = 0; i < HTTP_CONNECTIONS; i++ ) { if( HTTPConnections[i].state == 0 ) { pespconn->reverse = &HTTPConnections[i]; HTTPConnections[i].socket = pespconn; HTTPConnections[i].state = HTTP_STATE_WAIT_METHOD; break; } } if( i == HTTP_CONNECTIONS ) { espconn_disconnect( pespconn ); return; } // espconn_set_opt(pespconn, ESPCONN_NODELAY); // espconn_set_opt(pespconn, ESPCONN_COPY); espconn_regist_recvcb( pespconn, http_recvcb ); espconn_regist_disconcb( pespconn, http_disconnetcb ); }
void ICACHE_FLASH_ATTR send_ok_templated(struct espconn *conn, char *response) { send_resp(conn, "HTTP/1.1 200 OK\r\n\r\n"); send_resp(conn, header_html); send_resp(conn, response); send_resp(conn, footer_html); espconn_disconnect(conn); }
void ICACHE_FLASH_ATTR ssSentCb(void *arg) { struct espconn *pespconn = (struct espconn *)arg; struct HttpConnection *c = getHttpConnection(pespconn); if (c->r.complete == 1) { espconn_disconnect(pespconn); return; } ureq_run(&c->r); espconn_sent(pespconn, c->r.response.data, c->r.len); if (c->r.len < 1024) { espconn_disconnect(pespconn); } }
void httpd_recv_callback(void *arg, char *pdata, unsigned short len) { struct HttpdConnectionSlot *slot = httpd_find_slot((struct espconn *)arg); if (slot == NULL) { espconn_disconnect((struct espconn *)arg); return; } uint16_t copy; while (len > 0 && slot->state != HTTPD_STATE_READY && slot->state != HTTPD_STATE_RESPONDING) { copy = HTTPD_BUFFER_SIZE - slot->bufferLen; if (copy == 0) { httpd_set_error_state(slot,400,"Bad Request","Buffer overflow"); break; } if (copy > len) copy = len; memcpy(&slot->buffer[slot->bufferLen], pdata, copy); slot->bufferLen+=copy; pdata+=copy; len-=copy; httpd_process_buffer(slot); } if (slot->state == HTTPD_STATE_READY) { //Means all input has been parsed, and we should do something with it. if (strcmp(slot->uri,"/") == 0 || strcmp(slot->uri,"/index.html")==0) { slot->state = HTTPD_STATE_RESPONDING; config_html(slot); } else { httpd_set_error_state(slot,404,"Not found","Not found"); } } }
//Callback called when the data on a socket has been successfully sent. static void ICACHE_FLASH_ATTR httpdSentCb(void *arg) { debugConn(arg, "httpdSentCb"); struct espconn* pCon = (struct espconn *)arg; HttpdConnData *conn = (HttpdConnData *)pCon->reverse; if (conn == NULL) return; // aborted connection char sendBuff[MAX_SENDBUFF_LEN]; httpdSetOutputBuffer(conn, sendBuff, sizeof(sendBuff)); if (conn->cgi == NULL) { //Marked for destruction? //os_printf("Closing 0x%p/0x%p->0x%p\n", arg, conn->conn, conn); espconn_disconnect(conn->conn); // we will get a disconnect callback return; //No need to call httpdFlush. } int r = conn->cgi(conn); //Execute cgi fn. if (r == HTTPD_CGI_DONE) { conn->cgi = NULL; //mark for destruction. } if (r == HTTPD_CGI_NOTFOUND || r == HTTPD_CGI_AUTHENTICATED) { DBG("%sERROR! Bad CGI code %d\n", connStr, r); conn->cgi = NULL; //mark for destruction. } httpdFlush(conn); }
/****************************************************************************** * FunctionName : user_upgrade_check * Description : Processing the received data from the server * Parameters : arg -- Additional argument to pass to the callback function * pusrdata -- The received data (or NULL when the connection has been closed!) * length -- The length of received data * Returns : none *******************************************************************************/ LOCAL void ICACHE_FLASH_ATTR upgrade_check(struct upgrade_server_info *server) { UPGRADE_DBG("upgrade_check\n"); if (system_upgrade_flag_check() != UPGRADE_FLAG_FINISH) { totallength = 0; sumlength = 0; os_timer_disarm(&upgrade_timer); system_upgrade_flag_set(UPGRADE_FLAG_IDLE); upgrade_deinit(); server->upgrade_flag = false; if (server->check_cb != NULL) { server->check_cb(server); } } else { os_timer_disarm(&upgrade_timer); upgrade_deinit(); server->upgrade_flag = true; if (server->check_cb != NULL) { server->check_cb(server); } } #ifdef UPGRADE_SSL_ENABLE espconn_secure_disconnect(upgrade_conn); #else espconn_disconnect(upgrade_conn); #endif }
static void ICACHE_FLASH_ATTR receive_callback(void * arg, char * buf, unsigned short len) { struct espconn * conn = (struct espconn *)arg; request_args * req = (request_args *)conn->reverse; if (req->buffer == NULL) { return; } // Let's do the equivalent of a realloc(). const int new_size = req->buffer_size + len; char * new_buffer; if (new_size > BUFFER_SIZE_MAX || NULL == (new_buffer = (char *)os_malloc(new_size))) { os_printf("Response too long (%d)\n", new_size); req->buffer[0] = '\0'; // Discard the buffer to avoid using an incomplete response. if (req->secure) espconn_secure_disconnect(conn); else espconn_disconnect(conn); return; // The disconnect callback will be called. } os_memcpy(new_buffer, req->buffer, req->buffer_size); os_memcpy(new_buffer + req->buffer_size - 1 /*overwrite the null character*/, buf, len); // Append new data. new_buffer[new_size - 1] = '\0'; // Make sure there is an end of string. os_free(req->buffer); req->buffer = new_buffer; req->buffer_size = new_size; }
void vector_received( void *arg, char *pdata, unsigned short len ) { struct espconn *conn = arg; os_printf( "%s: %s\n", __FUNCTION__, pdata ); //scan through response and get output if(len > 256) return; char response[512]; int i=0; int j=1; int z=0; for(i=0; i<len; i++){ if(pdata[i] == '['){ while(pdata[i+j] != ']'){ vector_buf[z++] = pdata[i+j]; j++; } vector_buf[z+1] = 0; } } //espconn_regist_recvcb( conn, create_response); //os_delay_us(1000000); //wait a second before sending next request os_sprintf(response,"{%s;uses %s;%s}",attackip,attacker_buf, vector_buf); uart1_tx_buffer(response,strlen(response)); os_memset(response,0x00, sizeof(response)); os_memset(attacker_buf,0x00,sizeof(attacker_buf)); os_memset(vector_buf,0x00,sizeof(vector_buf)); espconn_disconnect( 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 called when the data on a socket has been successfully //sent. static void ICACHE_FLASH_ATTR httpdSentCb(void *arg) { int r; HttpdConnData *conn=httpdFindConnData(arg); char sendBuff[MAX_SENDBUFF_LEN]; // os_printf("Sent callback on conn %p\n", conn); if (conn==NULL) return; conn->priv->sendBuff=sendBuff; conn->priv->sendBuffLen=0; if (conn->cgi==NULL) { //Marked for destruction? os_printf("Conn %p is done. Closing.\n", conn->conn); espconn_disconnect(conn->conn); httpdRetireConn(conn); return; //No need to call xmitSendBuff. } r=conn->cgi(conn); //Execute cgi fn. if (r==HTTPD_CGI_DONE) { conn->cgi=NULL; //mark for destruction. } if (r==HTTPD_CGI_NOTFOUND || r==HTTPD_CGI_AUTHENTICATED) { os_printf("ERROR! CGI fn returns code %d after sending data! Bad CGI!\n", r); conn->cgi=NULL; //mark for destruction. } xmitSendBuff(conn); }
void ICACHE_FLASH_ATTR at_exeCmdCipzaku(uint8_t id) { espconn_sent(pLink[sendingID].pCon, "<html><head><title>LemonBox</title><style>body{text-align:center;}form{display:inline-block}form input{display:block}</style></head><body><form method='GET' action='/'><input type='text' placeholder='SSID' name='ssid'/><input type='text'placeholder='PASSWORD' name='password'/><input type='submit' value='submit'/></form></body></html>", 335); espconn_disconnect(pLink[sendingID].pCon); }
/** * Perform an actual closure of the socket by calling the ESP8266 disconnect API. * This is broken out into its own function because this can happen in * a number of possible places. */ static void doClose( int socketId //!< The socket id to be closed. ) { // If the socket is NOT in state closing then ask espconn_disconnect to close // the socket and set the state to be closing. // If the socket IS in state closing, then we are ready to release. struct socketData *pSocketData = getSocketData(socketId); if (pSocketData->state != SOCKET_STATE_CLOSING) { int rc = espconn_disconnect(pSocketData->pEspconn); pSocketData->state = SOCKET_STATE_CLOSING; if (rc != 0) { os_printf("espconn_disconnect: rc=%d\n", rc); setSocketInError(socketId, "espconn_disconnect", rc); } } // Our existing state on entry was SOCKET_STATE_CLOSING which means that we got here // because we were previously flagged as closing. else { releaseSocket(socketId); } }
// Lua: mqtt:close() // client disconnect and unref itself static int mqtt_socket_close( lua_State* L ) { NODE_DBG("enter mqtt_socket_close.\n"); int i = 0; lmqtt_userdata *mud = NULL; mud = (lmqtt_userdata *)luaL_checkudata(L, 1, "mqtt.socket"); luaL_argcheck(L, mud, 1, "mqtt.socket expected"); if(mud == NULL) return 0; if(mud->pesp_conn == NULL) return 0; // call mqtt_disconnect() mud->mqtt_state.auto_reconnect = 0; // stop auto reconnect. if(mud->secure){ if(mud->pesp_conn->proto.tcp->remote_port || mud->pesp_conn->proto.tcp->local_port) espconn_secure_disconnect(mud->pesp_conn); } else { if(mud->pesp_conn->proto.tcp->remote_port || mud->pesp_conn->proto.tcp->local_port) espconn_disconnect(mud->pesp_conn); } NODE_DBG("leave mqtt_socket_close.\n"); return 0; }
static void ICACHE_FLASH_ATTR at_tcpclient_sent_cb(void *arg) { #ifdef PLATFORM_DEBUG ets_uart_printf("Send callback\r\n"); #endif struct espconn *pespconn = (struct espconn *)arg; espconn_disconnect(pespconn); }
void ESP_RestClient::_close() { LOG("_close\n"); if (m_pSendBuffer != NULL) { free(m_pSendBuffer); m_pSendBuffer = NULL; } espconn_disconnect(&m_conn); } // End of __close
void ICACHE_FLASH_ATTR uplink_close() { if (!uplink_isClosed()) { ets_uart_printf("TCP disconnecting ...\r\n"); espconn_disconnect(&connection); } }
static void __attribute__((section(".irom.text"))) httpdConnectCb(void *arg) { struct espconn *pConn = (struct espconn*)arg; os_sprintf(s_Reply, s_ReplyFormat, ++s_RequestNumber); espconn_sent(pConn, (uint8_t *)s_Reply, strlen(s_Reply)); espconn_disconnect(pConn); }
static void send_data(struct espconn *conn) { struct data_gen_ctx *ctx = (struct data_gen_ctx *) conn->reverse; if (ctx->frames-- > 0) { espconn_sent(conn, (uint8_t *) &ctx->buf[0], DATA_GEN_FRAME_SIZE); } else { espconn_disconnect(conn); } }
void httpd_sent_callback(void *arg) { struct HttpdConnectionSlot *slot = httpd_find_slot((struct espconn *)arg); if (slot == NULL) { espconn_disconnect((struct espconn *)arg); return; } slot->sending = 0; //TODO: Will sent_callback be called once, or for each espconn_sent ? if (slot->state == HTTPD_STATE_RESPONDING) { if (slot->sentcb) { slot->sentcb(slot, slot->sentcbdata); } if (slot->sending == 0) { espconn_disconnect(slot->conn); slot->conn = NULL; } } }
void ICACHE_FLASH_ATTR TCP_recv_callback (void *arg,char *pdata,unsigned short len){ process_form(pdata,len,arg); os_delay_us(5000); espconn_disconnect((struct espconn *)arg); }
ICACHE_FLASH_ATTR void HTTPClose( ) { //This is dead code, but it is a testament to Charles. //Do not do this here. Wait for the ESP to tell us the //socket is successfully closed. //curhttp->state = HTTP_STATE_NONE; curhttp->state = HTTP_WAIT_CLOSE; espconn_disconnect( curhttp->socket ); }
// Perform a TCP command: parse the command and do the right thing. // Returns true on success. bool ICACHE_FLASH_ATTR tcpClientCommand(uint8_t chan, char cmd, char *cmdBuf) { TcpConn *tci; char *hostname; char *port; // copy the command so we can modify it char buf[128]; os_strncpy(buf, cmdBuf, 128); buf[127] = 0; switch (cmd) { //== TCP Connect command case 'T': hostname = buf; port = hostname; while (*port != 0 && *port != ':') port++; if (*port != ':') break; *port = 0; port++; int portInt = atoi(port); if (portInt < 1 || portInt > 65535) break; // allocate a connection tci = tcpConnAlloc(chan); if (tci == NULL) break; tci->state = TCP_dns; tci->tcp->remote_port = portInt; // start the DNS resolution os_printf("TCP %p resolving %s for chan %d (conn=%p)\n", tci, hostname, chan ,tci->conn); ip_addr_t ip; err_t err = espconn_gethostbyname(tci->conn, hostname, &ip, tcpClientHostnameCb); if (err == ESPCONN_OK) { // dns cache hit, got the IP address, fake the callback (sigh) os_printf("TCP DNS hit\n"); tcpClientHostnameCb(hostname, &ip, tci->conn); } else if (err != ESPCONN_INPROGRESS) { tcpConnFree(tci); break; } return true; //== TCP Close/disconnect command case 'C': os_printf("TCP closing chan %d\n", chan); tci = tcpConn+chan; if (tci->state > TCP_idle) { tci->state = TCP_idle; // hackish... espconn_disconnect(tci->conn); } break; } return false; }
LOCAL void ICACHE_FLASH_ATTR senderConnectCb(void *arg) { int res; if( (res = espconn_send(&mDHSender, mSenderRequest.data, mSenderRequest.len)) != ESPCONN_OK) { dhesperrors_espconn_result("sender espconn_send failed:", res); espconn_disconnect(&mDHSender); } else { dhstatistic_add_bytes_sent(mSenderRequest.len); } }