me-no-dev/AsyncTCP
1
0
Fork 1
mirror of https://github.com/me-no-dev/AsyncTCP.git synced 2025-08-05 21:54:38 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #32 from me-no-dev/idf-update

Browse Source 
Idf update
This commit is contained in:
Me No Dev
2019-01-12 19:03:46 +01:00
committed by GitHub
parent 952b7eb6ba 0dfd5b647e
commit 1656fed6fb
2 changed files with 77 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
src/AsyncTCP.cpp
View File

@@ -256,7 +256,7 @@ static void _tcp_error(void * arg, int8_t err) {
#include "lwip/priv/tcpip_priv.h" #include "lwip/priv/tcpip_priv.h"
typedef struct { typedef struct {
struct tcpip_api_call call; struct tcpip_api_call_data call;
tcp_pcb * pcb; tcp_pcb * pcb;
int8_t err; int8_t err;
union { union {
@@ -279,20 +279,24 @@ typedef struct {
}; };
} tcp_api_call_t; } tcp_api_call_t;
static err_t _tcp_output_api(struct tcpip_api_call *api_call_msg){ static err_t _tcp_output_api(struct tcpip_api_call_data *api_call_msg){
tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg; tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
msg->err = tcp_output(msg->pcb); if(msg->pcb){
msg->err = tcp_output(msg->pcb);
} else {
msg->err = 0;
}
return msg->err; return msg->err;
} }
static esp_err_t _tcp_output(tcp_pcb * pcb) { static esp_err_t _tcp_output(tcp_pcb * pcb) {
tcp_api_call_t msg; tcp_api_call_t msg;
msg.pcb = pcb; msg.pcb = pcb;
tcpip_api_call(_tcp_output_api, (struct tcpip_api_call*)&msg); tcpip_api_call(_tcp_output_api, (struct tcpip_api_call_data*)&msg);
return msg.err; return msg.err;
} }
static err_t _tcp_write_api(struct tcpip_api_call *api_call_msg){ static err_t _tcp_write_api(struct tcpip_api_call_data *api_call_msg){
tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg; tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
msg->err = tcp_write(msg->pcb, msg->write.data, msg->write.size, msg->write.apiflags); msg->err = tcp_write(msg->pcb, msg->write.data, msg->write.size, msg->write.apiflags);
return msg->err; return msg->err;
@@ -304,11 +308,11 @@ static esp_err_t _tcp_write(tcp_pcb * pcb, const char* data, size_t size, uint8_
msg.write.data = data; msg.write.data = data;
msg.write.size = size; msg.write.size = size;
msg.write.apiflags = apiflags; msg.write.apiflags = apiflags;
tcpip_api_call(_tcp_write_api, (struct tcpip_api_call*)&msg); tcpip_api_call(_tcp_write_api, (struct tcpip_api_call_data*)&msg);
return msg.err; return msg.err;
} }
static err_t _tcp_recved_api(struct tcpip_api_call *api_call_msg){ static err_t _tcp_recved_api(struct tcpip_api_call_data *api_call_msg){
tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg; tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
msg->err = 0; msg->err = 0;
tcp_recved(msg->pcb, msg->received); tcp_recved(msg->pcb, msg->received);
@@ -319,11 +323,11 @@ static esp_err_t _tcp_recved(tcp_pcb * pcb, size_t len) {
tcp_api_call_t msg; tcp_api_call_t msg;
msg.pcb = pcb; msg.pcb = pcb;
msg.received = len; msg.received = len;
tcpip_api_call(_tcp_recved_api, (struct tcpip_api_call*)&msg); tcpip_api_call(_tcp_recved_api, (struct tcpip_api_call_data*)&msg);
return msg.err; return msg.err;
} }
static err_t _tcp_connect_api(struct tcpip_api_call *api_call_msg){ static err_t _tcp_connect_api(struct tcpip_api_call_data *api_call_msg){
tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg; tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
msg->err = tcp_connect(msg->pcb, msg->connect.addr, msg->connect.port, msg->connect.cb); msg->err = tcp_connect(msg->pcb, msg->connect.addr, msg->connect.port, msg->connect.cb);
return msg->err; return msg->err;
@@ -335,11 +339,11 @@ static esp_err_t _tcp_connect(tcp_pcb * pcb, ip_addr_t * addr, uint16_t port, tc
msg.connect.addr = addr; msg.connect.addr = addr;
msg.connect.port = port; msg.connect.port = port;
msg.connect.cb = cb; msg.connect.cb = cb;
tcpip_api_call(_tcp_connect_api, (struct tcpip_api_call*)&msg); tcpip_api_call(_tcp_connect_api, (struct tcpip_api_call_data*)&msg);
return msg.err; return msg.err;
} }
static err_t _tcp_close_api(struct tcpip_api_call *api_call_msg){ static err_t _tcp_close_api(struct tcpip_api_call_data *api_call_msg){
tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg; tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
msg->err = tcp_close(msg->pcb); msg->err = tcp_close(msg->pcb);
return msg->err; return msg->err;
@@ -349,11 +353,11 @@ static esp_err_t _tcp_close(tcp_pcb * pcb) {
tcp_api_call_t msg; tcp_api_call_t msg;
msg.pcb = pcb; msg.pcb = pcb;
//ets_printf("close 0x%08x\n", (uint32_t)pcb); //ets_printf("close 0x%08x\n", (uint32_t)pcb);
tcpip_api_call(_tcp_close_api, (struct tcpip_api_call*)&msg); tcpip_api_call(_tcp_close_api, (struct tcpip_api_call_data*)&msg);
return msg.err; return msg.err;
} }
static err_t _tcp_abort_api(struct tcpip_api_call *api_call_msg){ static err_t _tcp_abort_api(struct tcpip_api_call_data *api_call_msg){
tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg; tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
msg->err = 0; msg->err = 0;
tcp_abort(msg->pcb); tcp_abort(msg->pcb);
@@ -364,11 +368,11 @@ static esp_err_t _tcp_abort(tcp_pcb * pcb) {
tcp_api_call_t msg; tcp_api_call_t msg;
msg.pcb = pcb; msg.pcb = pcb;
//ets_printf("abort 0x%08x\n", (uint32_t)pcb); //ets_printf("abort 0x%08x\n", (uint32_t)pcb);
tcpip_api_call(_tcp_abort_api, (struct tcpip_api_call*)&msg); tcpip_api_call(_tcp_abort_api, (struct tcpip_api_call_data*)&msg);
return msg.err; return msg.err;
} }
static err_t _tcp_bind_api(struct tcpip_api_call *api_call_msg){ static err_t _tcp_bind_api(struct tcpip_api_call_data *api_call_msg){
tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg; tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
msg->err = tcp_bind(msg->pcb, msg->bind.addr, msg->bind.port); msg->err = tcp_bind(msg->pcb, msg->bind.addr, msg->bind.port);
return msg->err; return msg->err;
@@ -379,11 +383,11 @@ static esp_err_t _tcp_bind(tcp_pcb * pcb, ip_addr_t * addr, uint16_t port) {
msg.pcb = pcb; msg.pcb = pcb;
msg.bind.addr = addr; msg.bind.addr = addr;
msg.bind.port = port; msg.bind.port = port;
tcpip_api_call(_tcp_bind_api, (struct tcpip_api_call*)&msg); tcpip_api_call(_tcp_bind_api, (struct tcpip_api_call_data*)&msg);
return msg.err; return msg.err;
} }
static err_t _tcp_listen_api(struct tcpip_api_call *api_call_msg){ static err_t _tcp_listen_api(struct tcpip_api_call_data *api_call_msg){
tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg; tcp_api_call_t * msg = (tcp_api_call_t *)api_call_msg;
msg->err = 0; msg->err = 0;
msg->pcb = tcp_listen_with_backlog(msg->pcb, msg->backlog); msg->pcb = tcp_listen_with_backlog(msg->pcb, msg->backlog);
@@ -394,7 +398,7 @@ static tcp_pcb * _tcp_listen_with_backlog(tcp_pcb * pcb, uint8_t backlog) {
tcp_api_call_t msg; tcp_api_call_t msg;
msg.pcb = pcb; msg.pcb = pcb;
msg.backlog = backlog?backlog:0xFF; msg.backlog = backlog?backlog:0xFF;
tcpip_api_call(_tcp_listen_api, (struct tcpip_api_call*)&msg); tcpip_api_call(_tcp_listen_api, (struct tcpip_api_call_data*)&msg);
return msg.pcb; return msg.pcb;
} }
#define _tcp_listen(p) _tcp_listen_with_backlog(p, 0xFF); #define _tcp_listen(p) _tcp_listen_with_backlog(p, 0xFF);
@@ -432,6 +436,8 @@ AsyncClient::AsyncClient(tcp_pcb* pcb)
, next(NULL) , next(NULL)
, _in_lwip_thread(false) , _in_lwip_thread(false)
{ {
//ets_printf("+: 0x%08x\n", (uint32_t)this);
_pcb = pcb; _pcb = pcb;
if(_pcb){ if(_pcb){
_rx_last_packet = millis(); _rx_last_packet = millis();
@@ -447,6 +453,8 @@ AsyncClient::AsyncClient(tcp_pcb* pcb)
AsyncClient::~AsyncClient(){ AsyncClient::~AsyncClient(){
if(_pcb) if(_pcb)
_close(); _close();
//ets_printf("-: 0x%08x\n", (uint32_t)this);
} }
bool AsyncClient::connect(IPAddress ip, uint16_t port){ bool AsyncClient::connect(IPAddress ip, uint16_t port){
@@ -512,6 +520,7 @@ int8_t AsyncClient::_connected(void* pcb, int8_t err){
} }
int8_t AsyncClient::_close(){ int8_t AsyncClient::_close(){
//ets_printf("X: 0x%08x\n", (uint32_t)this);
int8_t err = ERR_OK; int8_t err = ERR_OK;
if(_pcb) { if(_pcb) {
//log_i(""); //log_i("");
@@ -520,6 +529,7 @@ int8_t AsyncClient::_close(){
tcp_recv(_pcb, NULL); tcp_recv(_pcb, NULL);
tcp_err(_pcb, NULL); tcp_err(_pcb, NULL);
tcp_poll(_pcb, NULL, 0); tcp_poll(_pcb, NULL, 0);
_tcp_clear_events(this);
if(_in_lwip_thread){ if(_in_lwip_thread){
err = tcp_close(_pcb); err = tcp_close(_pcb);
} else { } else {
@@ -529,7 +539,6 @@ int8_t AsyncClient::_close(){
err = abort(); err = abort();
} }
_pcb = NULL; _pcb = NULL;
_tcp_clear_events(this);
if(_discard_cb) if(_discard_cb)
_discard_cb(_discard_cb_arg, this); _discard_cb(_discard_cb_arg, this);
} }
@@ -562,6 +571,13 @@ int8_t AsyncClient::_sent(tcp_pcb* pcb, uint16_t len) {
} }
int8_t AsyncClient::_recv(tcp_pcb* pcb, pbuf* pb, int8_t err) { int8_t AsyncClient::_recv(tcp_pcb* pcb, pbuf* pb, int8_t err) {
if(!_pcb || pcb != _pcb){
log_e("0x%08x != 0x%08x", (uint32_t)pcb, (uint32_t)_pcb);
if(pb){
pbuf_free(pb);
}
return ERR_OK;
}
_in_lwip_thread = false; _in_lwip_thread = false;
if(pb == NULL){ if(pb == NULL){
return _close(); return _close();
@@ -621,7 +637,7 @@ int8_t AsyncClient::_poll(tcp_pcb* pcb){
return ERR_OK; return ERR_OK;
} }
void AsyncClient::_dns_found(ip_addr_t *ipaddr){ void AsyncClient::_dns_found(struct ip_addr *ipaddr){
_in_lwip_thread = true; _in_lwip_thread = true;
if(ipaddr){ if(ipaddr){
connect(IPAddress(ipaddr->u_addr.ip4.addr), _connect_port); connect(IPAddress(ipaddr->u_addr.ip4.addr), _connect_port);
@@ -943,31 +959,58 @@ void AsyncClient::onPoll(AcConnectHandler cb, void* arg){
} }
void AsyncClient::_s_dns_found(const char * name, ip_addr_t * ipaddr, void * arg){ void AsyncClient::_s_dns_found(const char * name, struct ip_addr * ipaddr, void * arg){
reinterpret_cast<AsyncClient*>(arg)->_dns_found(ipaddr); if(arg){
reinterpret_cast<AsyncClient*>(arg)->_dns_found(ipaddr);
} else {
log_e("Bad Arg: 0x%08x", arg);
}
} }
int8_t AsyncClient::_s_poll(void * arg, struct tcp_pcb * pcb) { int8_t AsyncClient::_s_poll(void * arg, struct tcp_pcb * pcb) {
reinterpret_cast<AsyncClient*>(arg)->_poll(pcb); if(arg && pcb){
reinterpret_cast<AsyncClient*>(arg)->_poll(pcb);
} else {
log_e("Bad Args: 0x%08x 0x%08x", arg, pcb);
}
return ERR_OK; return ERR_OK;
} }
int8_t AsyncClient::_s_recv(void * arg, struct tcp_pcb * pcb, struct pbuf *pb, int8_t err) { int8_t AsyncClient::_s_recv(void * arg, struct tcp_pcb * pcb, struct pbuf *pb, int8_t err) {
reinterpret_cast<AsyncClient*>(arg)->_recv(pcb, pb, err); if(arg && pcb){
reinterpret_cast<AsyncClient*>(arg)->_recv(pcb, pb, err);
} else {
if(pb){
pbuf_free(pb);
}
log_e("Bad Args: 0x%08x 0x%08x", arg, pcb);
}
return ERR_OK; return ERR_OK;
} }
int8_t AsyncClient::_s_sent(void * arg, struct tcp_pcb * pcb, uint16_t len) { int8_t AsyncClient::_s_sent(void * arg, struct tcp_pcb * pcb, uint16_t len) {
reinterpret_cast<AsyncClient*>(arg)->_sent(pcb, len); if(arg && pcb){
reinterpret_cast<AsyncClient*>(arg)->_sent(pcb, len);
} else {
log_e("Bad Args: 0x%08x 0x%08x", arg, pcb);
}
return ERR_OK; return ERR_OK;
} }
void AsyncClient::_s_error(void * arg, int8_t err) { void AsyncClient::_s_error(void * arg, int8_t err) {
reinterpret_cast<AsyncClient*>(arg)->_error(err); if(arg){
reinterpret_cast<AsyncClient*>(arg)->_error(err);
} else {
log_e("Bad Arg: 0x%08x", arg);
}
} }
int8_t AsyncClient::_s_connected(void * arg, void * pcb, int8_t err){ int8_t AsyncClient::_s_connected(void * arg, void * pcb, int8_t err){
reinterpret_cast<AsyncClient*>(arg)->_connected(pcb, err); if(arg && pcb){
reinterpret_cast<AsyncClient*>(arg)->_connected(pcb, err);
} else {
log_e("Bad Args: 0x%08x 0x%08x", arg, pcb);
}
return ERR_OK; return ERR_OK;
} }
@@ -1122,9 +1165,9 @@ void AsyncServer::end(){
tcp_arg(_pcb, NULL); tcp_arg(_pcb, NULL);
tcp_accept(_pcb, NULL); tcp_accept(_pcb, NULL);
if(_in_lwip_thread){ if(_in_lwip_thread){
tcp_abort(_pcb); tcp_close(_pcb);
} else { } else {
_tcp_abort(_pcb); _tcp_close(_pcb);
} }
_pcb = NULL; _pcb = NULL;
} }

10
src/AsyncTCP.h
View File

@@ -43,7 +43,7 @@ typedef std::function<void(void*, AsyncClient*, struct pbuf *pb)> AcPacketHandle
typedef std::function<void(void*, AsyncClient*, uint32_t time)> AcTimeoutHandler; typedef std::function<void(void*, AsyncClient*, uint32_t time)> AcTimeoutHandler;
struct tcp_pcb; struct tcp_pcb;
struct _ip_addr; struct ip_addr;
class AsyncClient { class AsyncClient {
protected: protected:
@@ -81,7 +81,7 @@ class AsyncClient {
void _error(int8_t err); void _error(int8_t err);
int8_t _poll(tcp_pcb* pcb); int8_t _poll(tcp_pcb* pcb);
int8_t _sent(tcp_pcb* pcb, uint16_t len); int8_t _sent(tcp_pcb* pcb, uint16_t len);
void _dns_found(struct _ip_addr *ipaddr); void _dns_found(struct ip_addr *ipaddr);
public: public:
@@ -108,13 +108,13 @@ class AsyncClient {
bool canSend();//ack is not pending bool canSend();//ack is not pending
size_t space(); size_t space();
size_t add(const char* data, size_t size, uint8_t apiflags=0);//add for sending size_t add(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY);//add for sending
bool send();//send all data added with the method above bool send();//send all data added with the method above
size_t ack(size_t len); //ack data that you have not acked using the method below size_t ack(size_t len); //ack data that you have not acked using the method below
void ackLater(){ _ack_pcb = false; } //will not ack the current packet. Call from onData void ackLater(){ _ack_pcb = false; } //will not ack the current packet. Call from onData
size_t write(const char* data); size_t write(const char* data);
size_t write(const char* data, size_t size, uint8_t apiflags=0); //only when canSend() == true size_t write(const char* data, size_t size, uint8_t apiflags=ASYNC_WRITE_FLAG_COPY); //only when canSend() == true
uint8_t state(); uint8_t state();
bool connecting(); bool connecting();
@@ -161,7 +161,7 @@ class AsyncClient {
static void _s_error(void *arg, int8_t err); static void _s_error(void *arg, int8_t err);
static int8_t _s_sent(void *arg, struct tcp_pcb *tpcb, uint16_t len); static int8_t _s_sent(void *arg, struct tcp_pcb *tpcb, uint16_t len);
static int8_t _s_connected(void* arg, void* tpcb, int8_t err); static int8_t _s_connected(void* arg, void* tpcb, int8_t err);
static void _s_dns_found(const char *name, struct _ip_addr *ipaddr, void *arg); static void _s_dns_found(const char *name, struct ip_addr *ipaddr, void *arg);
bool _in_lwip_thread; bool _in_lwip_thread;
}; };