gfwleak/zhangyang-libzt
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

standardization pass: conditional statement spacing, removed NULL shorthand making checks more explicit

Browse Source
This commit is contained in:
Joseph Henry
2017-09-14 13:17:37 -07:00
parent 476f162a19
commit 7c586471f4
10 changed files with 603 additions and 634 deletions
Download Patch File Download Diff File Expand all files Collapse all files

377
src/picoTCP.cpp
View File

@@ -101,7 +101,7 @@ namespace ZeroTier {
_picostack_driver_lock.lock();
// give right to vtap to start the stack
// only one stack loop is permitted
if(!picodev_initialized) {
if (picodev_initialized == false) {
tap->should_start_stack = true;
picodev.send = pico_eth_tx; // tx
picodev.poll = pico_eth_poll; // calls pico_eth_rx
@@ -109,7 +109,7 @@ namespace ZeroTier {
picodev.tap = tap;
uint8_t mac[PICO_SIZE_ETH];
tap->_mac.copyTo(mac, PICO_SIZE_ETH);
if(pico_device_init(&picodev, tap->vtap_abbr_name, mac) != 0) {
if (pico_device_init(&picodev, tap->vtap_abbr_name, mac) != 0) {
DEBUG_ERROR("dev init failed");
handle_general_failure();
err = false;
@@ -128,7 +128,7 @@ namespace ZeroTier {
char ipbuf[INET6_ADDRSTRLEN];
uint8_t hwaddr[6];
// register addresses
if(ip.isV4()) {
if (ip.isV4()) {
struct pico_ip4 ipaddr, netmask;
ipaddr.addr = *((uint32_t *)ip.rawIpData());
netmask.addr = *((uint32_t *)ip.netmask().rawIpData());
@@ -140,7 +140,7 @@ namespace ZeroTier {
DEBUG_INFO("mac=%s", macbuf);
err = true;
}
if(ip.isV6()) {
if (ip.isV6()) {
char ipv6_str[INET6_ADDRSTRLEN], nm_str[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, ip.rawIpData(), ipv6_str, INET6_ADDRSTRLEN);
inet_ntop(AF_INET6, ip.netmask().rawIpData(), nm_str, INET6_ADDRSTRLEN);
@@ -173,7 +173,7 @@ namespace ZeroTier {
struct pico_ip4 gateway;
gateway.addr = *((uint32_t *)gw.rawIpData());
int err = pico_ipv4_route_add(address, netmask, gateway, metric, link);
if(err) {
if (err) {
DEBUG_ERROR("err=%d, %s", err, beautify_pico_error(pico_err));
}
return err;
@@ -186,7 +186,7 @@ namespace ZeroTier {
struct pico_ip4 netmask;
netmask.addr = *((uint32_t *)nm.rawIpData());
int err = pico_ipv4_route_del(address, netmask, metric);
if(err) {
if (err) {
DEBUG_ERROR("err=%d, %s", err, beautify_pico_error(pico_err));
}
return err;
@@ -204,7 +204,7 @@ namespace ZeroTier {
uint32_t ipval = 0;
pico_string_to_ipv4(ipv4_str, &ipval);
ns.addr = ipval;
if((err = pico_dns_client_nameserver(&ns, PICO_DNS_NS_ADD)) < 0) {
if ((err = pico_dns_client_nameserver(&ns, PICO_DNS_NS_ADD)) < 0) {
DEBUG_ERROR("error while adding DNS nameserver, err=%d, pico_err=%d, %s",
err, pico_err, beautify_pico_error(pico_err));
map_pico_err_to_errno(pico_err);
@@ -224,7 +224,7 @@ namespace ZeroTier {
uint32_t ipval = 0;
pico_string_to_ipv4(ipv4_str, &ipval);
ns.addr = ipval;
if((err = pico_dns_client_nameserver(&ns, PICO_DNS_NS_DEL)) < 0) {
if ((err = pico_dns_client_nameserver(&ns, PICO_DNS_NS_DEL)) < 0) {
DEBUG_ERROR("error while removing DNS nameserver, err=%d, pico_err=%d, %s",
err, pico_err, beautify_pico_error(pico_err));
}
@@ -247,19 +247,18 @@ namespace ZeroTier {
void picoTCP::pico_cb_tcp_read(ZeroTier::VirtualTap *tap, struct pico_socket *s)
{
VirtualSocket *vs = (VirtualSocket*)(((VirtualBindingPair*)s->priv)->vs);
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("s->priv yielded no valid vs");
handle_general_failure();
return;
}
Mutex::Lock _l(vs->_rx_m);
if(!tap) {
if (tap == NULL) {
DEBUG_ERROR("invalid tap");
handle_general_failure();
return;
}
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("invalid vs");
handle_general_failure();
return;
@@ -274,7 +273,7 @@ namespace ZeroTier {
do {
int n = 0;
int avail = ZT_TCP_RX_BUF_SZ - vs->RXbuf->count();
if(avail) {
if (avail) {
r = pico_socket_recvfrom(s, vs->RXbuf->get_buf(), ZT_STACK_SOCKET_RD_MAX,
(void *)&peer.ip4.addr, &port);
if (r > 0)
@@ -282,10 +281,10 @@ namespace ZeroTier {
vs->RXbuf->produce(r);
n = tap->_phy.streamSend(vs->sock, vs->RXbuf->get_buf(), r);
if(n>0)
if (n>0)
vs->RXbuf->consume(n);
}
if(vs->RXbuf->count() == 0) {
if (vs->RXbuf->count() == 0) {
tap->_phy.setNotifyWritable(vs->sock, false);
}
else {
@@ -306,19 +305,18 @@ namespace ZeroTier {
{
// DEBUG_INFO();
VirtualSocket *vs = (VirtualSocket*)(((VirtualBindingPair*)s->priv)->vs);
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("s->priv yielded no valid vs");
handle_general_failure();
return;
}
Mutex::Lock _l(vs->_rx_m);
if(!tap) {
if (tap == NULL) {
DEBUG_ERROR("invalid tap");
handle_general_failure();
return;
}
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("invalid vs");
handle_general_failure();
return;
@@ -331,10 +329,10 @@ namespace ZeroTier {
} peer;
int r = 0, w = 0;
// TODO: Consolidate this
if(vs->socket_family == AF_INET) {
if (vs->socket_family == AF_INET) {
struct sockaddr_in in4;
char udp_payload_buf[ZT_MAX_MTU];
if((r = pico_socket_recvfrom(s, udp_payload_buf, ZT_SDK_MTU, (void *)&peer.ip4.addr, &port)) < 0) {
if ((r = pico_socket_recvfrom(s, udp_payload_buf, ZT_SDK_MTU, (void *)&peer.ip4.addr, &port)) < 0) {
DEBUG_ERROR("err=%d, %s", r, beautify_pico_error(pico_err));
}
in4.sin_addr.s_addr = peer.ip4.addr;
@@ -347,14 +345,14 @@ namespace ZeroTier {
memcpy(udp_msg_buf, &len, sizeof(int32_t)); // len: sockaddr+payload
memcpy(udp_msg_buf + sizeof(int32_t), &in4, sizeof(struct sockaddr_storage)); // sockaddr
memcpy(udp_msg_buf + sizeof(int32_t) + sizeof(struct sockaddr_storage), &udp_payload_buf, r); // payload
if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
if ((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
DEBUG_ERROR("write()=%d, errno=%d", w, errno);
}
}
if(vs->socket_family == AF_INET6) {
if (vs->socket_family == AF_INET6) {
struct sockaddr_in6 in6;
char udp_payload_buf[ZT_MAX_MTU];
if((r = pico_socket_recvfrom(s, udp_payload_buf, ZT_SDK_MTU, (void *)&peer.ip6.addr, &port)) < 0) {
if ((r = pico_socket_recvfrom(s, udp_payload_buf, ZT_SDK_MTU, (void *)&peer.ip6.addr, &port)) < 0) {
DEBUG_ERROR("err=%d, %s", r, beautify_pico_error(pico_err));
}
memcpy(&(in6.sin6_addr.s6_addr), &(peer.ip6.addr), sizeof(peer.ip6.addr));
@@ -367,7 +365,7 @@ namespace ZeroTier {
memcpy(udp_msg_buf, &len, sizeof(int32_t)); // len: sockaddr+payload
memcpy(udp_msg_buf + sizeof(int32_t), &in6, sizeof(struct sockaddr_storage)); // sockaddr
memcpy(udp_msg_buf + sizeof(int32_t) + sizeof(struct sockaddr_storage), &udp_payload_buf, r); // payload
if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
if ((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
DEBUG_ERROR("write()=%d, errno=%d", w, errno);
}
}
@@ -376,40 +374,40 @@ namespace ZeroTier {
void picoTCP::pico_cb_tcp_write(VirtualTap *tap, struct pico_socket *s)
{
VirtualSocket *vs = (VirtualSocket*)(((VirtualBindingPair*)s->priv)->vs);
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("s->priv yielded no valid vs");
handle_general_failure();
return;
}
Mutex::Lock _l(vs->_tx_m);
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("invalid VirtualSocket");
handle_general_failure();
return;
}
int txsz = vs->TXbuf->count();
if(txsz <= 0)
if (txsz <= 0)
return;
//DEBUG_INFO("TXbuf->count()=%d", vs->TXbuf->count());
int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX);
if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
if ((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
DEBUG_ERROR("unable to write to pico_socket=%p, err=%d, pico_err=%d, %s",
vs->picosock, r, pico_err, beautify_pico_error(pico_err));
handle_general_failure();
return;
}
if(vs->socket_type == SOCK_STREAM) {
if (vs->socket_type == SOCK_STREAM) {
DEBUG_TRANS("len=%5d buf_len=%13d [VSTXBF --> NSPICO] proto=0x%04x (TCP)", r, vs->TXbuf->count(), PICO_PROTO_TCP);
}
if(r == 0) {
if (r == 0) {
// DEBUG_ERROR("err=%d, pico_err=%d, %s", r, pico_err, beautify_pico_error(pico_err));
// This is a peciliarity of the picoTCP network stack, if we receive no error code, and the size of
// the byte stream written is 0, this is an indication that the buffer for this pico_socket is too small
// DEBUG_ERROR("pico_socket buffer is too small (adjust ZT_STACK_SOCKET_TX_SZ, ZT_STACK_SOCKET_RX_SZ)");
// handle_general_failure();
}
if(r>0)
if (r>0)
vs->TXbuf->consume(r);
}
@@ -430,7 +428,7 @@ namespace ZeroTier {
// PICO_SOCK_EV_ERR - triggered when an error occurs.
if (ev & PICO_SOCK_EV_ERR) {
if(pico_err == PICO_ERR_ECONNRESET) {
if (pico_err == PICO_ERR_ECONNRESET) {
DEBUG_ERROR("PICO_ERR_ECONNRESET");
}
//DEBUG_ERROR("PICO_SOCK_EV_ERR, err=%s, picosock=%p, app_fd=%d, sdk_fd=%d",
@@ -442,7 +440,7 @@ namespace ZeroTier {
// keep the VirtualSocket half-open (only for sending) after the FIN packet has been received,
// allowing new data to be sent in the TCP CLOSE WAIT state.
if (ev & PICO_SOCK_EV_CLOSE) {
if((err = pico_socket_close(s)) < 0) {
if ((err = pico_socket_close(s)) < 0) {
DEBUG_ERROR("pico_socket_close()=%d, pico_err=%d, %s", err, pico_err, beautify_pico_error(pico_err));
}
DEBUG_EXTRA("PICO_SOCK_EV_CLOSE (socket closure) err=%d (%s), picosock=%p", pico_err, beautify_pico_error(pico_err), s);
@@ -454,14 +452,14 @@ namespace ZeroTier {
// --- handle non-error events ---
VirtualBindingPair *vbp = (VirtualBindingPair*)(s->priv);
if(!vbp) {
if (vbp == NULL) {
DEBUG_ERROR("s->priv yielded no valid VirtualBindingPair");
handle_general_failure();
return;
}
VirtualTap *tap = static_cast<VirtualTap*>(vbp->tap);
VirtualSocket *vs = static_cast<VirtualSocket*>(vbp->vs);
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("invalid VirtualSocket");
handle_general_failure();
return;
@@ -472,24 +470,21 @@ namespace ZeroTier {
// may now be issued in order to accept the incoming VirtualSocket from a remote host.
if (ev & PICO_SOCK_EV_CONN) {
DEBUG_EXTRA("PICO_SOCK_EV_CONN");
if(vs->state == ZT_SOCK_STATE_LISTENING)
{
if (vs->state == ZT_SOCK_STATE_LISTENING) {
uint16_t port;
struct pico_socket *client_psock = nullptr;
struct pico_ip4 orig4;
struct pico_ip6 orig6;
if(vs->socket_family == AF_INET) { // NOTE: p->net->proto_number == PICO_PROTO_IPV4
if (vs->socket_family == AF_INET) { // NOTE: p->net->proto_number == PICO_PROTO_IPV4
client_psock = pico_socket_accept(s, &orig4, &port);
}
if(vs->socket_family == AF_INET6) { // NOTE: p->net->proto_number == PICO_PROTO_IPV4
if (vs->socket_family == AF_INET6) { // NOTE: p->net->proto_number == PICO_PROTO_IPV4
client_psock = pico_socket_accept(s, &orig6, &port);
}
if(!client_psock) {
if (client_psock == NULL) {
DEBUG_ERROR("pico_socket_accept(): pico_socket=%p, pico_err=%d, %s", s, pico_err, beautify_pico_error(pico_err));
return;
}
// Create a new VirtualSocket and add it to the queue,
// some time in the future a call to zts_multiplex_accept() will pick up
// this new VirtualSocket, add it to the VirtualSocket list and return its
@@ -497,9 +492,8 @@ namespace ZeroTier {
VirtualSocket *new_vs = new VirtualSocket();
new_vs->socket_type = SOCK_STREAM;
new_vs->picosock = client_psock;
// TODO: Condense this
if(vs->socket_family == AF_INET) {
if (vs->socket_family == AF_INET) {
char addrstr[INET_ADDRSTRLEN];
struct sockaddr_storage ss4;
struct sockaddr_in *in4 = (struct sockaddr_in *)&ss4;
@@ -512,7 +506,7 @@ namespace ZeroTier {
inet.fromString(addrstr);
new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
}
if(vs->socket_family == AF_INET6) {
if (vs->socket_family == AF_INET6) {
char addrstr[INET6_ADDRSTRLEN];
struct sockaddr_in6 in6;
memcpy(&(in6.sin6_addr.s6_addr), &orig6, sizeof(in6.sin6_addr.s6_addr));
@@ -524,7 +518,7 @@ namespace ZeroTier {
inet.fromString(addrstr);
new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
}
if(!new_vs->tap) {
if (new_vs->tap == NULL) {
DEBUG_ERROR("no valid VirtualTap could be found");
handle_general_failure();
return;
@@ -535,7 +529,7 @@ namespace ZeroTier {
vs->_AcceptedConnections.push(new_vs);
new_vs->sock = new_vs->tap->_phy.wrapSocket(new_vs->sdk_fd, new_vs);
}
if(vs->state != ZT_SOCK_STATE_LISTENING) {
if (vs->state != ZT_SOCK_STATE_LISTENING) {
// set state so socket multiplexer logic will pick this up
vs->state = ZT_SOCK_STATE_UNHANDLED_CONNECTED;
}
@@ -543,9 +537,9 @@ namespace ZeroTier {
// PICO_SOCK_EV_RD - triggered when new data arrives on the socket. A new receive action
// can be taken by the socket owner because this event indicates there is new data to receive.
if (ev & PICO_SOCK_EV_RD) {
if(vs->socket_type==SOCK_STREAM)
if (vs->socket_type==SOCK_STREAM)
pico_cb_tcp_read(tap, s);
if(vs->socket_type==SOCK_DGRAM)
if (vs->socket_type==SOCK_DGRAM)
pico_cb_udp_read(tap, s);
}
// PICO_SOCK_EV_WR - triggered when ready to write to the socket. Issuing a write/send call
@@ -559,7 +553,7 @@ namespace ZeroTier {
{
//_picostack_driver_lock.lock();
VirtualTap *tap = static_cast<VirtualTap*>(dev->tap);
if(!tap) {
if (tap == NULL) {
DEBUG_ERROR("invalid dev->tap");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
@@ -570,7 +564,7 @@ namespace ZeroTier {
MAC dest_mac;
src_mac.setTo(ethhdr->saddr, 6);
dest_mac.setTo(ethhdr->daddr, 6);
if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
if (ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
char macBuf[ZT_MAC_ADDRSTRLEN], nodeBuf[ZT_ID_LEN];
mac2str(macBuf, ZT_MAC_ADDRSTRLEN, ethhdr->daddr);
ZeroTier::MAC mac;
@@ -582,16 +576,16 @@ namespace ZeroTier {
struct pico_tcp_hdr *hdr;
void * tcp_hdr_ptr;
if(Utils::ntoh(ethhdr->proto) == 0x86dd) { // tcp, ipv6
if (Utils::ntoh(ethhdr->proto) == 0x86dd) { // tcp, ipv6
tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
}
if(Utils::ntoh(ethhdr->proto) == 0x0800) // tcp
if (Utils::ntoh(ethhdr->proto) == 0x0800) // tcp
{
tcp_hdr_ptr = &buf + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
hdr = (struct pico_tcp_hdr *)tcp_hdr_ptr;
if(hdr) {
if (hdr) {
char *flag_ptr = flagbuf;
if (hdr->flags & PICO_TCP_PSH) {
@@ -632,7 +626,7 @@ namespace ZeroTier {
const void *data,unsigned int len)
{
//_picostack_driver_lock.lock();
if(!tap) {
if (tap == NULL) {
DEBUG_ERROR("invalid tap");
handle_general_failure();
return;
@@ -647,7 +641,7 @@ namespace ZeroTier {
ethhdr.proto = Utils::hton((uint16_t)etherType);
int32_t msg_len = len + sizeof(int32_t) + sizeof(struct pico_eth_hdr);
if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
if (ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
char macBuf[ZT_MAC_ADDRSTRLEN], nodeBuf[ZT_ID_LEN];
mac2str(macBuf, sizeof(macBuf), ethhdr.saddr);
ZeroTier::MAC mac;
@@ -659,15 +653,15 @@ namespace ZeroTier {
struct pico_tcp_hdr *hdr;
void * tcp_hdr_ptr;
if(etherType == 0x86dd) { // tcp, ipv6
if (etherType == 0x86dd) { // tcp, ipv6
tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
}
if(etherType == 0x0800) // tcp, ipv4
if (etherType == 0x0800) // tcp, ipv4
{
tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
hdr = (struct pico_tcp_hdr *)tcp_hdr_ptr;
if(hdr) {
if (hdr) {
char *flag_ptr = flagbuf;
if (hdr->flags & PICO_TCP_PSH) {
@@ -707,7 +701,7 @@ namespace ZeroTier {
int pico_eth_poll(struct pico_device *dev, int loop_score)
{
VirtualTap *tap = static_cast<VirtualTap*>(dev->tap);
if(!tap) {
if (tap == NULL) {
DEBUG_ERROR("invalid dev->tap");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
@@ -721,11 +715,11 @@ namespace ZeroTier {
len = 0;
// get frame len
memcpy(&len, tap->pico_frame_rxbuf, sizeof(int32_t));
if(len > sizeof(int32_t)) { // meaning, since we package the len in the msg, we don't want to recv a 0-(sizeof(int32_t)) sized frame
if (len > sizeof(int32_t)) { // meaning, since we package the len in the msg, we don't want to recv a 0-(sizeof(int32_t)) sized frame
memcpy(frame, tap->pico_frame_rxbuf + sizeof(int32_t), len-(sizeof(int32_t)) ); // get frame data
memmove(tap->pico_frame_rxbuf, tap->pico_frame_rxbuf + len, MAX_PICO_FRAME_RX_BUF_SZ-len); // shift buffer
if((err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(int32_t)))) < 0) {
if(picostack) {
if ((err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(int32_t)))) < 0) {
if (picostack) {
DEBUG_ERROR("pico_stack_recv(), err=%d, pico_err=%d, %s", err, pico_err, picostack->beautify_pico_error(pico_err));
}
}
@@ -743,32 +737,31 @@ namespace ZeroTier {
int picoTCP::pico_Socket(struct pico_socket **p, int socket_family, int socket_type, int protocol)
{
int err = 0;
if(!can_provision_new_socket(socket_type)) {
if (can_provision_new_socket(socket_type) == false) {
DEBUG_ERROR("cannot create additional socket, see PICO_MAX_TIMERS. current=%d", pico_ntimers());
errno = EMFILE;
err = -1;
}
else
{
else {
int protocol_version = 0;
struct pico_socket *psock;
if(socket_family == AF_INET)
if (socket_family == AF_INET)
protocol_version = PICO_PROTO_IPV4;
if(socket_family == AF_INET6)
if (socket_family == AF_INET6)
protocol_version = PICO_PROTO_IPV6;
if(socket_type == SOCK_DGRAM) {
if (socket_type == SOCK_DGRAM) {
psock = pico_socket_open(
protocol_version, PICO_PROTO_UDP, &ZeroTier::picoTCP::pico_cb_socket_ev);
if(psock) {
if (psock) {
// configure size of UDP SND/RCV buffers
// TODO
}
}
if(socket_type == SOCK_STREAM) {
if (socket_type == SOCK_STREAM) {
psock = pico_socket_open(
protocol_version, PICO_PROTO_TCP, &ZeroTier::picoTCP::pico_cb_socket_ev);
if(psock) {
if (psock) {
// configure size of TCP SND/RCV buffers
int tx_buf_sz = ZT_STACK_TCP_SOCKET_TX_SZ;
int rx_buf_sz = ZT_STACK_TCP_SOCKET_RX_SZ;
@@ -777,16 +770,16 @@ namespace ZeroTier {
// int value = 1;
// pico_socket_setoption(psock, PICO_TCP_NODELAY, &value);
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_SNDBUF, &tx_buf_sz)) < 0)
if ((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_SNDBUF, &tx_buf_sz)) < 0)
DEBUG_ERROR("unable to set SNDBUF size, err=%d, pico_err=%d, %s",
t_err, pico_err, beautify_pico_error(pico_err));
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_RCVBUF, &rx_buf_sz)) < 0)
if ((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_RCVBUF, &rx_buf_sz)) < 0)
DEBUG_ERROR("unable to set RCVBUF size, err=%d, pico_err=%d, %s",
t_err, pico_err, beautify_pico_error(pico_err));
if(ZT_SOCK_BEHAVIOR_LINGER) {
if (ZT_SOCK_BEHAVIOR_LINGER) {
int linger_time_ms = ZT_SOCK_BEHAVIOR_LINGER_TIME;
if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_LINGER, &linger_time_ms)) < 0)
if ((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_LINGER, &linger_time_ms)) < 0)
DEBUG_ERROR("unable to set LINGER, err=%d, pico_err=%d, %s",
t_err, pico_err, beautify_pico_error(pico_err));
}
@@ -799,13 +792,13 @@ namespace ZeroTier {
int picoTCP::pico_Connect(VirtualSocket *vs, const struct sockaddr *addr, socklen_t addrlen)
{
if(!vs || !vs->picosock) {
if (vs == NULL || vs->picosock == NULL) {
DEBUG_ERROR("invalid vs or vs->picosock");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
int err = 0;
if(vs->socket_family == AF_INET) {
if (vs->socket_family == AF_INET) {
struct pico_ip4 zaddr;
memset(&zaddr, 0, sizeof (struct pico_ip4));
struct sockaddr_in *in4 = (struct sockaddr_in*)addr;
@@ -814,23 +807,23 @@ namespace ZeroTier {
uint32_t ipval = 0;
pico_string_to_ipv4(ipv4_str, &ipval);
zaddr.addr = ipval;
if(vs->socket_type == SOCK_STREAM) { // connect is an implicit call for non-connection-based VirtualSockets
if (vs->socket_type == SOCK_STREAM) { // connect is an implicit call for non-connection-based VirtualSockets
DEBUG_EXTRA("connecting to addr=%s port=%d", ipv4_str, Utils::ntoh(in4->sin_port));
}
err = pico_socket_connect(vs->picosock, &zaddr, in4->sin_port);
}
if(vs->socket_family == AF_INET6) {
if (vs->socket_family == AF_INET6) {
struct pico_ip6 zaddr;
struct sockaddr_in6 *in6 = (struct sockaddr_in6*)addr;
char ipv6_str[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN);
pico_string_to_ipv6(ipv6_str, zaddr.addr);
if(vs->socket_type == SOCK_STREAM) {
if (vs->socket_type == SOCK_STREAM) {
DEBUG_EXTRA("connecting to addr=%s port=%d", ipv6_str, Utils::ntoh(in6->sin6_port));
}
err = pico_socket_connect(vs->picosock, &zaddr, in6->sin6_port);
}
if(err) {
if (err) {
DEBUG_ERROR("error connecting pico_socket=%p, err=%d, pico_err=%d, %s",
vs->picosock, err, pico_err, beautify_pico_error(pico_err));
return map_pico_err_to_errno(pico_err);
@@ -841,13 +834,13 @@ namespace ZeroTier {
int picoTCP::pico_Bind(VirtualSocket *vs, const struct sockaddr *addr, socklen_t addrlen)
{
if(!vs || !vs->picosock) {
if (vs == NULL || vs->picosock == NULL) {
DEBUG_ERROR("invalid vs or vs->picosock");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
int err = 0;
if(vs->socket_family == AF_INET) {
if (vs->socket_family == AF_INET) {
struct pico_ip4 zaddr;
uint32_t tempaddr;
memset(&zaddr, 0, sizeof (struct pico_ip4));
@@ -859,7 +852,7 @@ namespace ZeroTier {
DEBUG_EXTRA("binding to addr=%s port=%d", ipv4_str, Utils::ntoh(in4->sin_port));
err = pico_socket_bind(vs->picosock, &zaddr, (uint16_t *)&(in4->sin_port));
}
if(vs->socket_family == AF_INET6) {
if (vs->socket_family == AF_INET6) {
struct pico_ip6 pip6;
struct sockaddr_in6 *in6 = (struct sockaddr_in6*)addr;
char ipv6_str[INET6_ADDRSTRLEN];
@@ -869,7 +862,7 @@ namespace ZeroTier {
DEBUG_EXTRA("binding to addr=%s port=%d", ipv6_str, Utils::ntoh(in6->sin6_port));
err = pico_socket_bind(vs->picosock, &pip6, (uint16_t *)&(in6->sin6_port));
}
if(err < 0) {
if (err < 0) {
DEBUG_ERROR("unable to bind pico_socket=%p, err=%d, pico_err=%d, %s",
(vs->picosock), err, pico_err, beautify_pico_error(pico_err));
return map_pico_err_to_errno(pico_err);
@@ -879,13 +872,13 @@ namespace ZeroTier {
int picoTCP::pico_Listen(VirtualSocket *vs, int backlog)
{
if(!vs || !vs->picosock) {
if (vs == NULL || vs->picosock == NULL) {
DEBUG_ERROR("invalid vs or vs->picosock");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
int err = 0;
if((err = pico_socket_listen(vs->picosock, backlog)) < 0) {
if ((err = pico_socket_listen(vs->picosock, backlog)) < 0) {
DEBUG_ERROR("error putting pico_socket=%p into listening state. err=%d, pico_err=%d, %s",
vs->picosock, err, pico_err, beautify_pico_error(pico_err));
return map_pico_err_to_errno(pico_err);
@@ -896,14 +889,14 @@ namespace ZeroTier {
VirtualSocket* picoTCP::pico_Accept(VirtualSocket *vs)
{
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("invalid vs");
handle_general_failure();
return NULL;
}
// Retreive first of queued VirtualSockets from parent VirtualSocket
VirtualSocket *new_vs = NULL;
if(vs->_AcceptedConnections.size()) {
if (vs->_AcceptedConnections.size()) {
new_vs = vs->_AcceptedConnections.front();
vs->_AcceptedConnections.pop();
}
@@ -922,29 +915,29 @@ namespace ZeroTier {
int err = 0;
// TODO: Add RingBuffer overflow checks
// DEBUG_INFO("vs=%p, len=%d", vs, len);
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("invalid vs");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
Mutex::Lock _l(vs->_tx_m);
if(len <= 0) {
if (len <= 0) {
DEBUG_ERROR("invalid write length (len=%d)", len);
handle_general_failure();
return -1;
}
if(vs->picosock->state & PICO_SOCKET_STATE_CLOSED){
if (vs->picosock->state & PICO_SOCKET_STATE_CLOSED) {
DEBUG_ERROR("socket is CLOSED, this wrpico_cb_tcp_writeite() will fail");
return -1;
}
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("invalid VirtualSocket (len=%d)", len);
handle_general_failure();
return -1;
}
if(vs->socket_type == SOCK_DGRAM) {
if (vs->socket_type == SOCK_DGRAM) {
int r;
if((r = pico_socket_write(vs->picosock, data, len)) < 0) {
if ((r = pico_socket_write(vs->picosock, data, len)) < 0) {
DEBUG_ERROR("unable to write to picosock=%p, err=%d, pico_err=%d, %s",
vs->picosock, r, pico_err, beautify_pico_error(pico_err));
err = -1;
@@ -953,9 +946,9 @@ namespace ZeroTier {
err = r; // successful write
}
}
if(vs->socket_type == SOCK_STREAM) {
if (vs->socket_type == SOCK_STREAM) {
int original_txsz = vs->TXbuf->count();
if(original_txsz + len >= ZT_TCP_TX_BUF_SZ) {
if (original_txsz + len >= ZT_TCP_TX_BUF_SZ) {
DEBUG_ERROR("txsz=%d, len=%d", original_txsz, len);
DEBUG_ERROR("TX buffer is too small, try increasing ZT_TCP_TX_BUF_SZ in libzt.h");
handle_general_failure();
@@ -970,7 +963,7 @@ namespace ZeroTier {
}
int txsz = vs->TXbuf->count();
int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX);
if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
if ((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
DEBUG_ERROR("unable to write to picosock=%p, err=%d, pico_err=%d, %s",
vs->picosock, r, pico_err, beautify_pico_error(pico_err));
err = -1;
@@ -978,13 +971,13 @@ namespace ZeroTier {
else {
err = r; // successful write
}
if(r>0){
if (r>0) {
vs->TXbuf->consume(r);
}
if(vs->socket_type == SOCK_STREAM) {
if (vs->socket_type == SOCK_STREAM) {
DEBUG_TRANS("len=%5d buf_len=%13d [VSTXBF --> NSPICO] proto=0x%04x (TCP)", r, vs->TXbuf->count(), PICO_PROTO_TCP);
}
if(vs->socket_type == SOCK_DGRAM) {
if (vs->socket_type == SOCK_DGRAM) {
DEBUG_TRANS("len=%5d buf_len= [APPFDS --> NSPICO] proto=0x%04x (UDP)", r, PICO_PROTO_TCP);
}
}
@@ -993,19 +986,19 @@ namespace ZeroTier {
int picoTCP::pico_Close(VirtualSocket *vs)
{
if(!vs) {
if (vs == NULL) {
DEBUG_ERROR("invalid vs");
handle_general_failure();
return ZT_ERR_GENERAL_FAILURE;
}
DEBUG_EXTRA("vs=%p, picosock=%p, fd=%d", vs, vs->picosock, vs->app_fd);
if(!vs || !vs->picosock)
if (vs == NULL || vs->picosock == NULL)
return ZT_ERR_GENERAL_FAILURE;
int err = 0;
Mutex::Lock _l(vs->tap->_tcpconns_m);
if(vs->closure_ts != -1) // it was closed at some point in the past, it'll work itself out
if (vs->closure_ts != -1) // it was closed at some point in the past, it'll work itself out
return ZT_ERR_OK;
if((err = pico_socket_close(vs->picosock)) < 0) {
if ((err = pico_socket_close(vs->picosock)) < 0) {
errno = pico_err;
DEBUG_ERROR("error closing pico_socket, err=%d, pico_err=%s, %s",
err, pico_err, beautify_pico_error(pico_err));
@@ -1016,16 +1009,16 @@ namespace ZeroTier {
int picoTCP::pico_Shutdown(VirtualSocket *vs, int how)
{
int err = 0, mode = 0;
if(how == SHUT_RD) {
if (how == SHUT_RD) {
mode = PICO_SHUT_RD;
}
if(how == SHUT_WR) {
if (how == SHUT_WR) {
mode = PICO_SHUT_WR;
}
if(how == SHUT_RDWR) {
if (how == SHUT_RDWR) {
mode = PICO_SHUT_RDWR;
}
if((err = pico_socket_shutdown(vs->picosock, mode)) < 0) {
if ((err = pico_socket_shutdown(vs->picosock, mode)) < 0) {
DEBUG_ERROR("error while shutting down socket, fd=%d, pico_err=%d, %s", vs->app_fd, pico_err, beautify_pico_error(pico_err));
}
return err;
@@ -1033,82 +1026,82 @@ namespace ZeroTier {
int picoTCP::map_pico_err_to_errno(int err)
{
if(err == PICO_ERR_NOERR) { errno = 0; return 0; } //
if(err == PICO_ERR_EPERM) { errno = ENXIO; }
if(err == PICO_ERR_ENOENT) { errno = ENXIO; }
if(err == PICO_ERR_EINTR) { errno = ENXIO; }
if(err == PICO_ERR_EIO) { errno = ENXIO; }
if(err == PICO_ERR_ENXIO) { errno = ENXIO; } //
if(err == PICO_ERR_EAGAIN) { errno = ENXIO; }
if(err == PICO_ERR_ENOMEM) { errno = ENOMEM; } //
if(err == PICO_ERR_EACCESS) { errno = ENXIO; }
if(err == PICO_ERR_EFAULT) { errno = ENXIO; }
if(err == PICO_ERR_EBUSY) { errno = ENXIO; }
if(err == PICO_ERR_EEXIST) { errno = ENXIO; }
if(err == PICO_ERR_EINVAL) { errno = EINVAL; } //
if(err == PICO_ERR_ENONET) { errno = ENXIO; }
if(err == PICO_ERR_EPROTO) { errno = ENXIO; }
if(err == PICO_ERR_ENOPROTOOPT) { errno = ENXIO; }
if(err == PICO_ERR_EPROTONOSUPPORT) { errno = ENXIO; }
if(err == PICO_ERR_EOPNOTSUPP) { errno = ENXIO; }
if(err == PICO_ERR_EADDRINUSE) { errno = ENXIO; }
if(err == PICO_ERR_EADDRNOTAVAIL) { errno = ENXIO; }
if(err == PICO_ERR_ENETDOWN) { errno = ENXIO; }
if(err == PICO_ERR_ENETUNREACH) { errno = ENXIO; }
if(err == PICO_ERR_ECONNRESET) { errno = ENXIO; }
if(err == PICO_ERR_EISCONN) { errno = ENXIO; }
if(err == PICO_ERR_ENOTCONN) { errno = ENXIO; }
if(err == PICO_ERR_ESHUTDOWN) { errno = ENXIO; }
if(err == PICO_ERR_ETIMEDOUT) { errno = ENXIO; }
if(err == PICO_ERR_ECONNREFUSED) { errno = ENXIO; }
if(err == PICO_ERR_EHOSTDOWN) { errno = ENXIO; }
if(err == PICO_ERR_EHOSTUNREACH) { errno = ENXIO; }
if (err == PICO_ERR_NOERR) { errno = 0; return 0; } //
if (err == PICO_ERR_EPERM) { errno = ENXIO; }
if (err == PICO_ERR_ENOENT) { errno = ENXIO; }
if (err == PICO_ERR_EINTR) { errno = ENXIO; }
if (err == PICO_ERR_EIO) { errno = ENXIO; }
if (err == PICO_ERR_ENXIO) { errno = ENXIO; } //
if (err == PICO_ERR_EAGAIN) { errno = ENXIO; }
if (err == PICO_ERR_ENOMEM) { errno = ENOMEM; } //
if (err == PICO_ERR_EACCESS) { errno = ENXIO; }
if (err == PICO_ERR_EFAULT) { errno = ENXIO; }
if (err == PICO_ERR_EBUSY) { errno = ENXIO; }
if (err == PICO_ERR_EEXIST) { errno = ENXIO; }
if (err == PICO_ERR_EINVAL) { errno = EINVAL; } //
if (err == PICO_ERR_ENONET) { errno = ENXIO; }
if (err == PICO_ERR_EPROTO) { errno = ENXIO; }
if (err == PICO_ERR_ENOPROTOOPT) { errno = ENXIO; }
if (err == PICO_ERR_EPROTONOSUPPORT) { errno = ENXIO; }
if (err == PICO_ERR_EOPNOTSUPP) { errno = ENXIO; }
if (err == PICO_ERR_EADDRINUSE) { errno = ENXIO; }
if (err == PICO_ERR_EADDRNOTAVAIL) { errno = ENXIO; }
if (err == PICO_ERR_ENETDOWN) { errno = ENXIO; }
if (err == PICO_ERR_ENETUNREACH) { errno = ENXIO; }
if (err == PICO_ERR_ECONNRESET) { errno = ENXIO; }
if (err == PICO_ERR_EISCONN) { errno = ENXIO; }
if (err == PICO_ERR_ENOTCONN) { errno = ENXIO; }
if (err == PICO_ERR_ESHUTDOWN) { errno = ENXIO; }
if (err == PICO_ERR_ETIMEDOUT) { errno = ENXIO; }
if (err == PICO_ERR_ECONNREFUSED) { errno = ENXIO; }
if (err == PICO_ERR_EHOSTDOWN) { errno = ENXIO; }
if (err == PICO_ERR_EHOSTUNREACH) { errno = ENXIO; }
return -1;
}
char *picoTCP::beautify_pico_error(int err)
{
if(err== 0) return (char*)"PICO_ERR_NOERR";
if(err== 1) return (char*)"PICO_ERR_EPERM";
if(err== 2) return (char*)"PICO_ERR_ENOENT";
if (err== 0) return (char*)"PICO_ERR_NOERR";
if (err== 1) return (char*)"PICO_ERR_EPERM";
if (err== 2) return (char*)"PICO_ERR_ENOENT";
// ...
if(err== 4) return (char*)"PICO_ERR_EINTR";
if(err== 5) return (char*)"PICO_ERR_EIO";
if(err== 6) return (char*)"PICO_ERR_ENXIO (no such device or address)";
if (err== 4) return (char*)"PICO_ERR_EINTR";
if (err== 5) return (char*)"PICO_ERR_EIO";
if (err== 6) return (char*)"PICO_ERR_ENXIO (no such device or address)";
// ...
if(err== 11) return (char*)"PICO_ERR_EAGAIN";
if(err== 12) return (char*)"PICO_ERR_ENOMEM (not enough space)";
if(err== 13) return (char*)"PICO_ERR_EACCESS";
if(err== 14) return (char*)"PICO_ERR_EFAULT";
if (err== 11) return (char*)"PICO_ERR_EAGAIN";
if (err== 12) return (char*)"PICO_ERR_ENOMEM (not enough space)";
if (err== 13) return (char*)"PICO_ERR_EACCESS";
if (err== 14) return (char*)"PICO_ERR_EFAULT";
// ...
if(err== 16) return (char*)"PICO_ERR_EBUSY";
if(err== 17) return (char*)"PICO_ERR_EEXIST";
if (err== 16) return (char*)"PICO_ERR_EBUSY";
if (err== 17) return (char*)"PICO_ERR_EEXIST";
// ...
if(err== 22) return (char*)"PICO_ERR_EINVAL (invalid argument)";
if (err== 22) return (char*)"PICO_ERR_EINVAL (invalid argument)";
// ...
if(err== 64) return (char*)"PICO_ERR_ENONET";
if (err== 64) return (char*)"PICO_ERR_ENONET";
// ...
if(err== 71) return (char*)"PICO_ERR_EPROTO";
if (err== 71) return (char*)"PICO_ERR_EPROTO";
// ...
if(err== 92) return (char*)"PICO_ERR_ENOPROTOOPT";
if(err== 93) return (char*)"PICO_ERR_EPROTONOSUPPORT";
if (err== 92) return (char*)"PICO_ERR_ENOPROTOOPT";
if (err== 93) return (char*)"PICO_ERR_EPROTONOSUPPORT";
// ...
if(err== 95) return (char*)"PICO_ERR_EOPNOTSUPP";
if(err== 98) return (char*)"PICO_ERR_EADDRINUSE";
if(err== 99) return (char*)"PICO_ERR_EADDRNOTAVAIL";
if(err==100) return (char*)"PICO_ERR_ENETDOWN";
if(err==101) return (char*)"PICO_ERR_ENETUNREACH";
if (err== 95) return (char*)"PICO_ERR_EOPNOTSUPP";
if (err== 98) return (char*)"PICO_ERR_EADDRINUSE";
if (err== 99) return (char*)"PICO_ERR_EADDRNOTAVAIL";
if (err==100) return (char*)"PICO_ERR_ENETDOWN";
if (err==101) return (char*)"PICO_ERR_ENETUNREACH";
// ...
if(err==104) return (char*)"PICO_ERR_ECONNRESET";
if (err==104) return (char*)"PICO_ERR_ECONNRESET";
// ...
if(err==106) return (char*)"PICO_ERR_EISCONN";
if(err==107) return (char*)"PICO_ERR_ENOTCONN";
if(err==108) return (char*)"PICO_ERR_ESHUTDOWN";
if (err==106) return (char*)"PICO_ERR_EISCONN";
if (err==107) return (char*)"PICO_ERR_ENOTCONN";
if (err==108) return (char*)"PICO_ERR_ESHUTDOWN";
// ...
if(err==110) return (char*)"PICO_ERR_ETIMEDOUT";
if(err==111) return (char*)"PICO_ERR_ECONNREFUSED";
if(err==112) return (char*)"PICO_ERR_EHOSTDOWN";
if(err==113) return (char*)"PICO_ERR_EHOSTUNREACH";
if (err==110) return (char*)"PICO_ERR_ETIMEDOUT";
if (err==111) return (char*)"PICO_ERR_ECONNREFUSED";
if (err==112) return (char*)"PICO_ERR_EHOSTDOWN";
if (err==113) return (char*)"PICO_ERR_EHOSTUNREACH";
return (char*)"UNKNOWN_ERROR";
}
@@ -1143,89 +1136,89 @@ namespace ZeroTier {
static char state_str[512];
char *str_ptr = state_str;
if(state & PICO_SOCKET_STATE_UNDEFINED) {
if (state & PICO_SOCKET_STATE_UNDEFINED) {
sprintf(str_ptr, "UNDEFINED ");
str_ptr += strlen("UNDEFINED ");
}
if(state & PICO_SOCKET_STATE_SHUT_LOCAL) {
if (state & PICO_SOCKET_STATE_SHUT_LOCAL) {
sprintf(str_ptr, "SHUT_LOCAL ");
str_ptr += strlen("SHUT_LOCAL ");
}
if(state & PICO_SOCKET_STATE_SHUT_REMOTE) {
if (state & PICO_SOCKET_STATE_SHUT_REMOTE) {
sprintf(str_ptr, "SHUT_REMOTE ");
str_ptr += strlen("SHUT_REMOTE ");
}
if(state & PICO_SOCKET_STATE_BOUND) {
if (state & PICO_SOCKET_STATE_BOUND) {
sprintf(str_ptr, "BOUND ");
str_ptr += strlen("BOUND ");
}
if(state & PICO_SOCKET_STATE_CONNECTED) {
if (state & PICO_SOCKET_STATE_CONNECTED) {
sprintf(str_ptr, "CONNECTED ");
str_ptr += strlen("CONNECTED ");
}
if(state & PICO_SOCKET_STATE_CLOSING) {
if (state & PICO_SOCKET_STATE_CLOSING) {
sprintf(str_ptr, "CLOSING ");
str_ptr += strlen("CLOSING ");
}
if(state & PICO_SOCKET_STATE_CLOSED) {
if (state & PICO_SOCKET_STATE_CLOSED) {
sprintf(str_ptr, "CLOSED ");
str_ptr += strlen("CLOSED ");
}
if(state & PICO_SOCKET_STATE_TCP) {
if (state & PICO_SOCKET_STATE_TCP) {
sprintf(str_ptr, "TCP ");
str_ptr += strlen("TCP ");
}
if(state & PICO_SOCKET_STATE_TCP_UNDEF) {
if (state & PICO_SOCKET_STATE_TCP_UNDEF) {
sprintf(str_ptr, "TCP_UNDEF ");
str_ptr += strlen("TCP_UNDEF ");
}
if(state & PICO_SOCKET_STATE_TCP_CLOSED) {
if (state & PICO_SOCKET_STATE_TCP_CLOSED) {
sprintf(str_ptr, "TCP_CLOSED ");
str_ptr += strlen("TCP_CLOSED ");
}
if(state & PICO_SOCKET_STATE_TCP_LISTEN) {
if (state & PICO_SOCKET_STATE_TCP_LISTEN) {
sprintf(str_ptr, "TCP_LISTEN ");
str_ptr += strlen("TCP_LISTEN ");
}
if(state & PICO_SOCKET_STATE_TCP_SYN_SENT) {
if (state & PICO_SOCKET_STATE_TCP_SYN_SENT) {
sprintf(str_ptr, "TCP_SYN_SENT ");
str_ptr += strlen("TCP_SYN_SENT ");
}
if(state & PICO_SOCKET_STATE_TCP_SYN_RECV) {
if (state & PICO_SOCKET_STATE_TCP_SYN_RECV) {
sprintf(str_ptr, "TCP_SYN_RECV ");
str_ptr += strlen("TCP_SYN_RECV ");
}
if(state & PICO_SOCKET_STATE_TCP_ESTABLISHED) {
if (state & PICO_SOCKET_STATE_TCP_ESTABLISHED) {
sprintf(str_ptr, "TCP_ESTABLISHED ");
str_ptr += strlen("TCP_ESTABLISHED ");
}
if(state & PICO_SOCKET_STATE_TCP_CLOSE_WAIT) {
if (state & PICO_SOCKET_STATE_TCP_CLOSE_WAIT) {
sprintf(str_ptr, "TCP_CLOSE_WAIT ");
str_ptr += strlen("TCP_CLOSE_WAIT ");
}
if(state & PICO_SOCKET_STATE_TCP_LAST_ACK) {
if (state & PICO_SOCKET_STATE_TCP_LAST_ACK) {
sprintf(str_ptr, "TCP_LAST_ACK ");
str_ptr += strlen("TCP_LAST_ACK ");
}
if(state & PICO_SOCKET_STATE_TCP_FIN_WAIT1) {
if (state & PICO_SOCKET_STATE_TCP_FIN_WAIT1) {
sprintf(str_ptr, "TCP_FIN_WAIT1 ");
str_ptr += strlen("TCP_FIN_WAIT1 ");
}
if(state & PICO_SOCKET_STATE_TCP_FIN_WAIT2) {
if (state & PICO_SOCKET_STATE_TCP_FIN_WAIT2) {
sprintf(str_ptr, "TCP_FIN_WAIT2 ");
str_ptr += strlen("TCP_FIN_WAIT2 ");
}
if(state & PICO_SOCKET_STATE_TCP_CLOSING) {
if (state & PICO_SOCKET_STATE_TCP_CLOSING) {
sprintf(str_ptr, "TCP_CLOSING ");
str_ptr += strlen("TCP_CLOSING ");
}
if(state & PICO_SOCKET_STATE_TCP_TIME_WAIT) {
if (state & PICO_SOCKET_STATE_TCP_TIME_WAIT) {
sprintf(str_ptr, "TCP_TIME_WAIT ");
str_ptr += strlen("TCP_TIME_WAIT ");
}
if(state & PICO_SOCKET_STATE_TCP_ARRAYSIZ) {
if (state & PICO_SOCKET_STATE_TCP_ARRAYSIZ) {
sprintf(str_ptr, "TCP_ARRAYSIZ ");
str_ptr += strlen("TCP_ARRAYSIZ ");
}