/** \brief Helper function to start a ntudp_itor_t with the common parameter
*/
ntudp_err_t ntudp_itor_t::start(ntudp_peer_t *ntudp_peer, const ntudp_addr_t &m_remote_addr
, ntudp_itor_cb_t *callback, void *userptr) throw()
{
ntudp_err_t ntudp_err;
// set the callback
set_callback(callback, userptr);
// bind the socket
ntudp_err = set_remote_addr(ntudp_peer, m_remote_addr);
if( ntudp_err.failed() ) return ntudp_err;
// start the operation
return start();
}
/** \brief Setup all mandatory parameters and start the operation
*/
ntudp_err_t ntudp_client_t::start(ntudp_peer_t *ntudp_peer, const ntudp_addr_t &remote_addr
, ntudp_client_cb_t *callback, void * userptr) throw()
{
ntudp_err_t ntudp_err;
// set the remote_addr
ntudp_err = set_remote_addr(ntudp_peer, remote_addr);
if( ntudp_err.failed() ) return ntudp_err;
// set the callback
set_callback(callback, userptr);
// start the operation now
return start();
}
/** \brief Set the mandatory parameters and start the actions
*
* - This is only a helper function on top of the actual functions
*/
inet_err_t udp_itor_t::start(const ipport_addr_t &remote_addr, udp_itor_cb_t *callback, void *userptr)
throw()
{
inet_err_t inet_err;
// set the remote address
inet_err = set_remote_addr(remote_addr);
if( inet_err.failed() ) return inet_err;
// set the callback
inet_err = set_callback(callback, userptr);
if( inet_err.failed() ) return inet_err;
// start the action
return start();
}
int http_client_init(struct http_client_ctx *ctx,
const char *server, u16_t server_port)
{
int ret;
/* Coverity tells in CID 170743 that the next memset() is
* is overwriting the ctx struct. This is false positive as
* the struct is initialized with proper size.
*/
memset(ctx, 0, sizeof(*ctx));
if (server) {
ret = set_remote_addr(ctx, server, server_port);
if (ret < 0) {
return ret;
}
ctx->tcp.local.family = ctx->tcp.remote.family;
ctx->server = server;
}
ctx->settings.on_body = on_body;
ctx->settings.on_chunk_complete = on_chunk_complete;
ctx->settings.on_chunk_header = on_chunk_header;
ctx->settings.on_headers_complete = on_headers_complete;
ctx->settings.on_header_field = on_header_field;
ctx->settings.on_header_value = on_header_value;
ctx->settings.on_message_begin = on_message_begin;
ctx->settings.on_message_complete = on_message_complete;
ctx->settings.on_status = on_status;
ctx->settings.on_url = on_url;
ctx->tcp.receive_cb = http_receive_cb;
ctx->tcp.timeout = HTTP_NETWORK_TIMEOUT;
ctx->tcp.send_data = net_context_send;
ctx->tcp.recv_cb = recv_cb;
k_sem_init(&ctx->req.wait, 0, 1);
return 0;
}
void COMM::read(unsigned char *buf, unsigned char len)
{
memcpy((void *)rcv_buff, (const void *)buf, PACKAGE_LEN);
#if 0
// printf("len 0x%02x:", len);
printf("%s", rcv_buff);
printf("\n");
#endif
/**********
0,dst_addr;
1,dst_port;
2,src_addr;
3,src_port
***********/
if (rcv_buff[2] != src_addr || (rcv_buff[3] != src_port)) {
return;
}
/*server connect part*/
if (is_server == I_AM_SERVER) {
if (rcv_buff[4] == CONNECT) {
/*只要是来连接的，都让之连接就行*/
// if (status == STATUS_LISTEN) {
set_remote_addr(rcv_buff[0], rcv_buff[1]);
conect_ack(); //ack client
status = STATUS_CONNECTED;
printf("connected:(%d:%d)<--server-client---> \
(%d:%d)\n", \
rcv_buff[2], \
rcv_buff[3],\
rcv_buff[0],\
rcv_buff[1]);
return;
// } else {
// printf("the server aleady connected!!!\n");
// ;
// }
} else {
int https_client_init(struct http_client_ctx *ctx,
const char *server, u16_t server_port,
u8_t *personalization_data,
size_t personalization_data_len,
https_ca_cert_cb_t cert_cb,
const char *cert_host,
https_entropy_src_cb_t entropy_src_cb,
struct k_mem_pool *pool,
k_thread_stack_t https_stack,
size_t https_stack_size)
{
int ret;
if (!cert_cb) {
NET_ERR("Cert callback must be set");
return -EINVAL;
}
memset(ctx, 0, sizeof(*ctx));
if (server) {
ret = set_remote_addr(ctx, server, server_port);
if (ret < 0) {
return ret;
}
ctx->tcp.local.family = ctx->tcp.remote.family;
ctx->server = server;
}
k_sem_init(&ctx->req.wait, 0, 1);
ctx->is_https = true;
ctx->settings.on_body = on_body;
ctx->settings.on_chunk_complete = on_chunk_complete;
ctx->settings.on_chunk_header = on_chunk_header;
ctx->settings.on_headers_complete = on_headers_complete;
ctx->settings.on_header_field = on_header_field;
ctx->settings.on_header_value = on_header_value;
ctx->settings.on_message_begin = on_message_begin;
ctx->settings.on_message_complete = on_message_complete;
ctx->settings.on_status = on_status;
ctx->settings.on_url = on_url;
ctx->tcp.timeout = HTTP_NETWORK_TIMEOUT;
ctx->tcp.send_data = https_send;
ctx->tcp.recv_cb = ssl_received;
ctx->https.cert_host = cert_host;
ctx->https.stack = https_stack;
ctx->https.stack_size = https_stack_size;
ctx->https.mbedtls.cert_cb = cert_cb;
ctx->https.pool = pool;
ctx->https.mbedtls.personalization_data = personalization_data;
ctx->https.mbedtls.personalization_data_len = personalization_data_len;
if (entropy_src_cb) {
ctx->https.mbedtls.entropy_src_cb = entropy_src_cb;
} else {
ctx->https.mbedtls.entropy_src_cb = entropy_source;
}
/* The mbedtls is initialized in HTTPS thread because of mbedtls stack
* requirements.
*/
return 0;
}
