/*
* TCP code. For TCP, a socket is created and listens.
* A callback occurs when the packet is received. The callback handles the different types of TCP events,
* including the handshake protocol.
* Based off the sample tcpecho app provided in the picotcp library.
*/
void cb_tcpecho(uint16_t ev, struct pico_socket *s)
{
int r = 0;
ZF_LOGD("tcpecho> wakeup ev=%u\n", ev);
if (ev & PICO_SOCK_EV_RD) {
char buf[100];
r = pico_socket_read(s, buf, 100);
pico_socket_write(s, buf, r); // Immediately echo back a response
}
if (ev & PICO_SOCK_EV_CONN) {
uint32_t ka_val = 0;
struct pico_socket *sock_peer;
struct pico_ip4 orig = {0};
uint16_t port = 0;
char peer[30] = {0};
int yes = 1;
sock_peer = pico_socket_accept(s, &orig, &port);
pico_ipv4_to_string(peer, orig.addr);
ZF_LOGD("Connection established with %s:%d.\n", peer, short_be(port));
pico_socket_setoption(sock_peer, PICO_TCP_NODELAY, &yes);
/* Set keepalive options - from picoTCP documentation */
ka_val = 5;
pico_socket_setoption(sock_peer, PICO_SOCKET_OPT_KEEPCNT, &ka_val);
ka_val = 30000;
pico_socket_setoption(sock_peer, PICO_SOCKET_OPT_KEEPIDLE, &ka_val);
ka_val = 5000;
pico_socket_setoption(sock_peer, PICO_SOCKET_OPT_KEEPINTVL, &ka_val);
}
if (ev & PICO_SOCK_EV_FIN) {
ZF_LOGD("Socket closed. Exit normally. \n");
}
if (ev & PICO_SOCK_EV_ERR) {
ZF_LOGD("Socket error received: %s. Bailing out.\n", strerror(pico_err));
}
if (ev & PICO_SOCK_EV_CLOSE) {
ZF_LOGD("Socket received close from peer.\n");
pico_socket_shutdown(s, PICO_SHUT_WR);
}
if (ev & PICO_SOCK_EV_WR) {
ZF_LOGD("TCP Write ack\n");
}
}
static void pico_dns_client_callback(uint16_t ev, struct pico_socket *s)
{
struct pico_dns_header *header = NULL;
char *domain;
struct pico_dns_query_suffix *qsuffix = NULL;
struct pico_dns_answer_suffix *asuffix = NULL;
struct pico_dns_query *q = NULL;
char *p_asuffix = NULL;
char msg[PICO_DNS_MAX_RESPONSE_LEN] = {
0
};
if (ev == PICO_SOCK_EV_ERR) {
dns_dbg("DNS: socket error received\n");
return;
}
if (ev & PICO_SOCK_EV_RD) {
if (pico_socket_read(s, msg, PICO_DNS_MAX_RESPONSE_LEN) <= 0)
return;
}
header = (struct pico_dns_header *)msg;
domain = (char *)header + sizeof(struct pico_dns_header);
qsuffix = (struct pico_dns_query_suffix *)pico_dns_client_seek(domain);
/* valid asuffix is determined dynamically later on */
if (pico_dns_client_check_header(header) < 0)
return;
q = pico_dns_client_find_query(short_be(header->id));
if (!q)
return;
if (pico_dns_client_check_qsuffix(qsuffix, q) < 0)
return;
p_asuffix = (char *)qsuffix + sizeof(struct pico_dns_query_suffix);
p_asuffix = pico_dns_client_seek_suffix(p_asuffix, header, q);
if (!p_asuffix)
return;
asuffix = (struct pico_dns_answer_suffix *)p_asuffix;
pico_dns_client_user_callback(asuffix, q);
return;
}
void cb_tcpclient(uint16_t ev, struct pico_socket *s)
{
static int w_size = 0;
static int r_size = 0;
static int closed = 0;
int r, w;
char buf[1024];
ZF_LOGD("tcpclient> wakeup %lu, event %u\n", count, ev);
if (ev & PICO_SOCK_EV_RD) {
do {
r = pico_socket_read(s, buf, 1024);
if (r > 0) {
printf("READ >>");
fwrite(buf, r, 1, stdout);
}
if (r < 0){
ZF_LOGF("READ ERROR\n");
}
} while(r > 0);
}
if (ev & PICO_SOCK_EV_CONN) {
ZF_LOGD("Connection established with server.\n");
}
if (ev & PICO_SOCK_EV_FIN) {
ZF_LOGD("Socket closed. Exit normally. \n");
}
if (ev & PICO_SOCK_EV_ERR) {
ZF_LOGD("Socket error received: %s. Bailing out.\n", strerror(pico_err));
}
if (ev & PICO_SOCK_EV_CLOSE) {
ZF_LOGD("Socket received close from peer - Wrong case if not all client data sent!\n");
pico_socket_close(s);
}
if (ev & PICO_SOCK_EV_WR) {
ZF_LOGD("Pico socket write cb\n");
}
}
static void pico_dns_client_callback(uint16_t ev, struct pico_socket *s)
{
char *q_qname, *q_suf, *a_hdr, *a_qname, *a_suf, *a_rdata;
struct dns_message_hdr *hdr;
struct dns_query_suffix query_suf;
struct dns_answer_suffix answer_suf;
struct pico_dns_key test, *key;
char *answer;
char dns_answer[PICO_DNS_MAX_RESPONSE_LEN] = {0};
uint8_t valid_suffix = 0;
uint16_t compression = 0;
int i = 0, r = 0;
if (ev & PICO_SOCK_EV_RD) {
r = pico_socket_read(s, dns_answer, PICO_DNS_MAX_RESPONSE_LEN);
pico_socket_close(s);
if (r == PICO_DNS_MAX_RESPONSE_LEN || r < (int)sizeof(struct dns_message_hdr)) {
dns_dbg("DNS ERROR: received incorrect number(%d) of bytes\n", r);
return;
}
/* Check header validity */
a_hdr = dns_answer;
hdr = (struct dns_message_hdr *) a_hdr;
pico_dns_client_hdr_ntoh(hdr);
if (GET_FLAG_QR(hdr) != PICO_DNS_QR_RESPONSE || GET_FLAG_OPCODE(hdr) != PICO_DNS_OPCODE_QUERY
|| GET_FLAG_TC(hdr) == PICO_DNS_TC_IS_TRUNCATED || GET_FLAG_RCODE(hdr) != PICO_DNS_RCODE_NO_ERROR) {
dns_dbg("DNS ERROR: OPCODE %d | TC %d | RCODE %d\n", GET_FLAG_OPCODE(hdr), GET_FLAG_TC(hdr), GET_FLAG_RCODE(hdr));
return;
}
if (hdr->ancount < 1 || r < (int)(sizeof(struct dns_message_hdr) + hdr->qdcount * sizeof(struct dns_query_suffix)
+ hdr->ancount * sizeof(struct dns_answer_suffix))) {
dns_dbg("DNS ERROR: ancount < 1 OR received number(%d) of bytes too low\n", r);
return;
}
/* Find DNS key */
test.id = hdr->id;
key = pico_tree_findKey(&DNSTable,&test);
if (!key) {
dns_dbg("DNS WARNING: key with id %u not found\n", hdr->id);
return;
}
key->retrans = 0;
/* Check query suffix validity */
q_qname = a_hdr + sizeof(struct dns_message_hdr);
q_suf = pico_dns_client_seek(q_qname);
query_suf = *(struct dns_query_suffix *) q_suf;
if (short_be(query_suf.qtype) != key->qtype || short_be(query_suf.qclass) != key->qclass) {
dns_dbg("DNS ERROR: received qtype (%u) or qclass (%u) incorrect\n", short_be(query_suf.qtype), short_be(query_suf.qclass));
return;
}
/* Seek answer suffix */
a_qname = q_suf + sizeof(struct dns_query_suffix);
a_suf = a_qname;
while(i++ < hdr->ancount) {
uint16_t comp_h = short_from(a_suf);
compression = short_be(comp_h);
switch (compression >> 14)
{
case PICO_DNS_POINTER:
while (compression >> 14 == PICO_DNS_POINTER) {
dns_dbg("DNS: pointer\n");
a_suf += sizeof(uint16_t);
comp_h = short_from(a_suf);
compression = short_be(comp_h);
}
break;
case PICO_DNS_LABEL:
dns_dbg("DNS: label\n");
a_suf = pico_dns_client_seek(a_qname);
break;
default:
dns_dbg("DNS ERROR: incorrect compression (%u) value\n", compression);
return;
}
/* Check answer suffix validity */
answer_suf = *(struct dns_answer_suffix *)a_suf;
if (short_be(answer_suf.qtype) != key->qtype || short_be(answer_suf.qclass) != key->qclass) {
dns_dbg("DNS WARNING: received qtype (%u) or qclass (%u) incorrect\n", short_be(answer_suf.qtype), short_be(answer_suf.qclass));
a_suf = a_suf + sizeof(struct dns_answer_suffix) + short_be(answer_suf.rdlength);
continue;
}
if (short_be(answer_suf.ttl) > PICO_DNS_MAX_TTL) {
dns_dbg("DNS WARNING: received TTL (%u) > MAX (%u)\n", short_be(answer_suf.ttl), PICO_DNS_MAX_TTL);
a_suf = a_suf + sizeof(struct dns_answer_suffix) + short_be(answer_suf.rdlength);
continue;
}
valid_suffix = 1;
break;
}
if (!valid_suffix) {
dns_dbg("DNS ERROR: invalid dns answer suffix\n");
return;
}
a_rdata = a_suf + sizeof(struct dns_answer_suffix);
if (key->qtype == PICO_DNS_TYPE_A) {
uint32_t ip_h = long_from(a_rdata);
dns_dbg("DNS: length %u | ip %08X\n", short_be(answer_suf.rdlength), long_be(ip_h));
answer = pico_zalloc(16);
pico_ipv4_to_string(answer, ip_h);
key->callback(answer, key->arg);
} else if (key->qtype == PICO_DNS_TYPE_PTR) {
pico_dns_client_reverse_label((char *) a_rdata);
dns_dbg("DNS: length %u | name %s\n", short_be(answer_suf.rdlength), (char *)a_rdata + 1);
answer = pico_zalloc(answer_suf.rdlength - 1);
memcpy(answer, (char *)a_rdata + 1, short_be(answer_suf.rdlength) - 1);
key->callback(answer, key->arg);
} else {
dns_dbg("DNS ERROR: incorrect qtype (%u)\n", key->qtype);
return;
}
}
void cb_tcpecho(uint16_t ev, struct pico_socket *s)
{
int r = 0;
picoapp_dbg("tcpecho> wakeup ev=%u\n", ev);
if (ev & PICO_SOCK_EV_RD) {
if (flag & PICO_SOCK_EV_CLOSE)
printf("SOCKET> EV_RD, FIN RECEIVED\n");
while (len < BSIZE) {
r = pico_socket_read(s, recvbuf + len, BSIZE - len);
if (r > 0) {
len += r;
flag &= ~(PICO_SOCK_EV_RD);
} else {
flag |= PICO_SOCK_EV_RD;
break;
}
}
if (flag & PICO_SOCK_EV_WR) {
flag &= ~PICO_SOCK_EV_WR;
send_tcpecho(s);
}
}
if (ev & PICO_SOCK_EV_CONN) {
uint32_t ka_val = 0;
struct pico_socket *sock_a = {
0
};
struct pico_ip4 orig = {
0
};
uint16_t port = 0;
char peer[30] = {
0
};
int yes = 1;
sock_a = pico_socket_accept(s, &orig, &port);
pico_ipv4_to_string(peer, orig.addr);
printf("Connection established with %s:%d.\n", peer, short_be(port));
pico_socket_setoption(sock_a, PICO_TCP_NODELAY, &yes);
/* Set keepalive options */
ka_val = 5;
pico_socket_setoption(sock_a, PICO_SOCKET_OPT_KEEPCNT, &ka_val);
ka_val = 30000;
pico_socket_setoption(sock_a, PICO_SOCKET_OPT_KEEPIDLE, &ka_val);
ka_val = 5000;
pico_socket_setoption(sock_a, PICO_SOCKET_OPT_KEEPINTVL, &ka_val);
}
if (ev & PICO_SOCK_EV_FIN) {
printf("Socket closed. Exit normally. \n");
if (!pico_timer_add(2000, deferred_exit, NULL)) {
printf("Failed to start exit timer, exiting now\n");
exit(1);
}
}
if (ev & PICO_SOCK_EV_ERR) {
printf("Socket error received: %s. Bailing out.\n", strerror(pico_err));
exit(1);
}
if (ev & PICO_SOCK_EV_CLOSE) {
printf("Socket received close from peer.\n");
if (flag & PICO_SOCK_EV_RD) {
pico_socket_shutdown(s, PICO_SHUT_WR);
printf("SOCKET> Called shutdown write, ev = %d\n", ev);
}
}
if (ev & PICO_SOCK_EV_WR) {
r = send_tcpecho(s);
if (r == 0)
flag |= PICO_SOCK_EV_WR;
else
flag &= (~PICO_SOCK_EV_WR);
}
}
