kaa_error_t kaa_profile_handle_server_sync(kaa_profile_manager_t *self
, kaa_platform_message_reader_t *reader
, uint16_t extension_options
, size_t extension_length)
{
// Only used for logging
(void)extension_options;
(void)extension_length;
KAA_RETURN_IF_NIL2(self, reader, KAA_ERR_BADPARAM);
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Received profile server sync: options %u, payload size %zu", extension_options, extension_length);
kaa_error_t error_code = KAA_ERR_NONE;
self->need_resync = false;
if (extension_options & KAA_PROFILE_RESYNC_OPTION) {
self->need_resync = true;
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Going to resync profile...");
kaa_transport_channel_interface_t *channel =
kaa_channel_manager_get_transport_channel(self->channel_manager, profile_sync_services[0]);
if (channel)
channel->sync_handler(channel->context, profile_sync_services, 1);
}
if (!self->status->is_registered) {
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Endpoint has been registered");
self->status->is_registered = true;
}
return error_code;
}
kaa_error_t kaa_configuration_manager_request_serialize(kaa_configuration_manager_t *self, kaa_platform_message_writer_t *writer)
{
KAA_RETURN_IF_NIL2(self, writer, KAA_ERR_BADPARAM);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Going to serialize client configuration sync");
uint32_t payload_size = sizeof(uint32_t) + SHA_1_DIGEST_LENGTH;
kaa_platform_message_writer_t tmp_writer = *writer;
kaa_error_t error_code = kaa_platform_message_write_extension_header(&tmp_writer, KAA_CONFIGURATION_EXTENSION_TYPE, KAA_CONFIGURATION_ALL_FLAGS, payload_size);
if (error_code) {
KAA_LOG_ERROR(self->logger, error_code, "Failed to write configuration extension header");
return KAA_ERR_WRITE_FAILED;
}
*((uint32_t *) tmp_writer.current) = KAA_HTONL(self->status->config_seq_n);
tmp_writer.current += sizeof(uint32_t);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Configuration state sequence number is '%d'", self->status->config_seq_n);
error_code = kaa_platform_message_write_aligned(&tmp_writer, self->configuration_hash, SHA_1_DIGEST_LENGTH);
if (error_code) {
KAA_LOG_ERROR(self->logger, error_code, "Failed to write configuration hash");
return KAA_ERR_WRITE_FAILED;
}
*writer = tmp_writer;
return KAA_ERR_NONE;
}
kaa_error_t kaa_profile_handle_server_sync(kaa_profile_manager_t *self
, kaa_platform_message_reader_t *reader
, uint16_t extension_options
, size_t extension_length)
{
// Only used for logging
(void)extension_options;
(void)extension_length;
KAA_RETURN_IF_NIL2(self, reader, KAA_ERR_BADPARAM);
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Received profile server sync: options %u, payload size %zu", extension_options, extension_length);
kaa_error_t error_code = KAA_ERR_NONE;
self->need_resync = false;
if (extension_options & KAA_PROFILE_RESYNC_OPTION) {
self->need_resync = true;
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Going to resync profile...");
/* Ignoring an error code: the channels can be not initialized */
(void)kaa_profile_force_sync(self);
}
if (!self->status->is_registered) {
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Endpoint has been registered");
self->status->is_registered = true;
}
return error_code;
}
static bool is_timeout(kaa_log_collector_t *self)
{
KAA_RETURN_IF_NIL2(self, self->timeouts, false);
bool is_timeout = false;
kaa_time_t now = KAA_TIME();
kaa_list_node_t *it = kaa_list_begin(self->timeouts);
while (it) {
timeout_info_t *info = (timeout_info_t *)kaa_list_get_data(it);
if (now >= info->timeout) {
KAA_LOG_WARN(self->logger, KAA_ERR_TIMEOUT, "Log delivery timeout occurred (bucket_id %u)", info->log_bucket_id);
is_timeout = true;
break;
}
it = kaa_list_next(it);
}
if (is_timeout) {
it = kaa_list_begin(self->timeouts);
while (it) {
timeout_info_t *info = (timeout_info_t *)kaa_list_get_data(it);
ext_log_storage_unmark_by_bucket_id(self->log_storage_context, info->log_bucket_id);
it = kaa_list_next(it);
}
kaa_list_clear(self->timeouts, NULL);
ext_log_upload_strategy_on_timeout(self->log_upload_strategy_context);
}
return is_timeout;
}
kaa_error_t kaa_init_security_stuff(const char *kaa_public_key, const size_t kaa_public_key_length)
{
KAA_RETURN_IF_NIL2(kaa_public_key, kaa_public_key_length, KAA_ERR_BADPARAM);
ext_calculate_sha_hash(kaa_public_key, kaa_public_key_length, kaa_public_key_hash);
debug("SHA calculated\r\n");
return KAA_ERR_NONE;
}
kaa_error_t ext_log_storage_write_next_record(void *context, char *buffer, size_t buffer_len,
uint16_t *bucket_id, size_t *record_len)
{
mock_storage_context_t *self = context;
KAA_RETURN_IF_NIL2(self, self->logs, KAA_ERR_NOT_FOUND);
kaa_list_node_t *node = kaa_list_find_next(kaa_list_begin(self->logs),
match_unprocessed, NULL);
if (!node) {
return KAA_ERR_NOT_FOUND;
}
test_log_record_t *record = kaa_list_get_data(node);
if (buffer_len < record->rec.size) {
return KAA_ERR_INSUFFICIENT_BUFFER;
}
*record_len = record->rec.size;
*bucket_id = record->rec.bucket_id;
memcpy(buffer, record->rec.data, *record_len);
record->processed = true;
return KAA_ERR_NONE;
}
kaa_error_t kaa_meta_data_request_serialize(kaa_status_t *status, kaa_platform_message_writer_t* writer, uint32_t request_id)
{
KAA_RETURN_IF_NIL2(status, writer, KAA_ERR_BADPARAM);
uint32_t options = TIMEOUT_VALUE | PUBLIC_KEY_HASH_VALUE | PROFILE_HASH_VALUE | APP_TOKEN_VALUE;
size_t payload_length = 0;
kaa_error_t err_code = kaa_meta_data_request_get_size(&payload_length);
KAA_RETURN_IF_ERR(err_code);
payload_length -= KAA_EXTENSION_HEADER_SIZE;
err_code = kaa_platform_message_write_extension_header(writer
, KAA_META_DATA_EXTENSION_TYPE
, options
, payload_length);
KAA_RETURN_IF_ERR(err_code);
uint32_t request_id_network = KAA_HTONL(request_id);
err_code = kaa_platform_message_write(writer, &request_id_network, sizeof(uint32_t));
KAA_RETURN_IF_ERR(err_code);
uint32_t timeout = KAA_HTONL(KAA_SYNC_TIMEOUT);
err_code = kaa_platform_message_write(writer, &timeout, sizeof(timeout));
KAA_RETURN_IF_ERR(err_code);
err_code = kaa_platform_message_write_aligned(writer, status->endpoint_public_key_hash, SHA_1_DIGEST_LENGTH);
KAA_RETURN_IF_ERR(err_code);
err_code = kaa_platform_message_write_aligned(writer, status->profile_hash, SHA_1_DIGEST_LENGTH);
KAA_RETURN_IF_ERR(err_code);
err_code = kaa_platform_message_write_aligned(writer, KAA_SDK_TOKEN, KAA_SDK_TOKEN_LENGTH);
return err_code;
}
kaa_error_t kaa_configuration_manager_set_root_receiver(kaa_configuration_manager_t *self, const kaa_configuration_root_receiver_t *receiver)
{
KAA_RETURN_IF_NIL2(self, receiver, KAA_ERR_BADPARAM);
self->root_receiver = *receiver;
return KAA_ERR_NONE;
}
kaa_error_t kaa_configuration_manager_get_size(kaa_configuration_manager_t *self, size_t *expected_size)
{
KAA_RETURN_IF_NIL2(self, expected_size, KAA_ERR_BADPARAM);
*expected_size = KAA_EXTENSION_HEADER_SIZE + sizeof(uint32_t) + SHA_1_DIGEST_LENGTH;
return KAA_ERR_NONE;
}
static char* copy_data(const char* data, size_t data_size)
{
KAA_RETURN_IF_NIL2(data, data_size, NULL);
char *new_data = (char *)KAA_MALLOC(data_size);
KAA_RETURN_IF_NIL(new_data, NULL);
memcpy(new_data, data, data_size);
return new_data;
}
kaa_error_t kaa_buffer_get_locked_space(kaa_buffer_t *buffer_p, size_t *size)
{
KAA_RETURN_IF_NIL2(buffer_p, size, KAA_ERR_BADPARAM);
*size = buffer_p->current - buffer_p->begin;
return KAA_ERR_NONE;
}
kaa_error_t kaa_buffer_get_size(kaa_buffer_t *buffer_p, size_t *size)
{
KAA_RETURN_IF_NIL2(buffer_p, size, KAA_ERR_BADPARAM);
*size = buffer_p->end - buffer_p->begin;
return KAA_ERR_NONE;
}
kaa_error_t kaa_buffer_get_free_space(kaa_buffer_t *buffer_p, size_t *size)
{
KAA_RETURN_IF_NIL2(buffer_p, size, KAA_ERR_BADPARAM);
*size = buffer_p->end - buffer_p->current;
return KAA_ERR_NONE;
}
kaa_error_t kaa_profile_manager_update_profile(kaa_profile_manager_t *self, kaa_profile_t *profile_body)
{
#if KAA_PROFILE_SCHEMA_VERSION > 0
KAA_RETURN_IF_NIL2(self, profile_body, KAA_ERR_BADPARAM);
size_t serialized_profile_size = profile_body->get_size(profile_body);
if (!serialized_profile_size) {
KAA_LOG_ERROR(self->logger, KAA_ERR_BADDATA,
"Failed to update profile: serialize profile size is null. Maybe profile schema is empty");
return KAA_ERR_BADDATA;
}
char *serialized_profile = (char *) KAA_MALLOC(serialized_profile_size * sizeof(char));
KAA_RETURN_IF_NIL(serialized_profile, KAA_ERR_NOMEM);
avro_writer_t writer = avro_writer_memory(serialized_profile, serialized_profile_size);
if (!writer) {
KAA_FREE(serialized_profile);
return KAA_ERR_NOMEM;
}
profile_body->serialize(writer, profile_body);
avro_writer_free(writer);
kaa_digest new_hash;
ext_calculate_sha_hash(serialized_profile, serialized_profile_size, new_hash);
if (!memcmp(new_hash, self->status->profile_hash, SHA_1_DIGEST_LENGTH)) {
self->need_resync = false;
KAA_FREE(serialized_profile);
return KAA_ERR_NONE;
}
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Endpoint profile is updated");
if (ext_copy_sha_hash(self->status->profile_hash, new_hash)) {
KAA_FREE(serialized_profile);
return KAA_ERR_BAD_STATE;
}
if (self->profile_body.size > 0) {
KAA_FREE(self->profile_body.buffer);
self->profile_body.buffer = NULL;
}
self->profile_body.buffer = (uint8_t*)serialized_profile;
self->profile_body.size = serialized_profile_size;
self->need_resync = true;
kaa_transport_channel_interface_t *channel =
kaa_channel_manager_get_transport_channel(self->channel_manager, profile_sync_services[0]);
if (channel)
channel->sync_handler(channel->context, profile_sync_services, 1);
#endif
return KAA_ERR_NONE;
}
static kaa_error_t test_get_protocol_info(void *context, kaa_transport_protocol_id_t *protocol_info)
{
KAA_RETURN_IF_NIL2(context, protocol_info, KAA_ERR_BADPARAM);
test_channel_context_t *channel_context = (test_channel_context_t *)context;
*protocol_info = channel_context->protocol_info;
return KAA_ERR_NONE;
}
static kaa_error_t test_set_access_point(void *context
, kaa_access_point_t *access_point)
{
KAA_RETURN_IF_NIL2(context, access_point, KAA_ERR_BADPARAM);
test_channel_context_t *channel_context = (test_channel_context_t *)context;
channel_context->access_point = access_point;
return KAA_ERR_NONE;
}
kaa_error_t kaa_client_create(kaa_client_t **kaa_client, kaa_client_props_t *props)
{
KAA_RETURN_IF_NIL2(kaa_client, props, KAA_ERR_BADPARAM);
kaa_error_t error_code = KAA_ERR_NONE;
kaa_client_t *self = calloc(1, sizeof(kaa_client_t));
KAA_RETURN_IF_NIL(self, KAA_ERR_NOMEM);
esp8266_error_t esp8266_error = esp8266_create(&self->controler, props->serial, DEFAULT_ESP8266_CONTROLER_BUFFER_SIZE);
if (esp8266_error) {
debug("Error during esp8266 creation %d\n", esp8266_error);
kaa_client_destroy(self);
return KAA_ERR_BADDATA;
}
esp8266_error = esp8266_tcp_register_receive_callback(self->controler, esp8266_tcp_receive_fn, (void *)self);
if (esp8266_error) {
debug("Error during esp8266 registering receive callback %d\n", esp8266_error);
kaa_client_destroy(self);
return KAA_ERR_BADDATA;
}
error_code = kaa_init_security_stuff(props->kaa_public_key, props->kaa_public_key_length);
if (error_code) {
debug("Error generate SHA1 diges form Public Key, error %d", error_code);
kaa_client_destroy(self);
return error_code;
}
error_code = kaa_init(&self->kaa_context);
if (error_code) {
debug("Error during Kaa context creation %d\n", error_code);
kaa_client_destroy(self);
return error_code;
}
KAA_LOG_INFO(self->kaa_context->logger, KAA_ERR_NONE, "Kaa framework initialized.");
self->wifi_ssid = props->wifi_ssid;
self->wifi_pswd = props->wifi_pswd;
self->operate = true;
self->blink_timeout = 500;
error_code = kaa_log_collector_init(self);
if (error_code) {
KAA_LOG_ERROR(self->kaa_context->logger, error_code, "Failed to init Kaa log collector %d", error_code);
kaa_client_destroy(self);
return error_code;
}
KAA_LOG_INFO(self->kaa_context->logger, KAA_ERR_NONE, "Kaa log collector initialized.");
*kaa_client = self;
return error_code;
}
kaa_error_t kaa_logging_need_logging_resync(kaa_log_collector_t *self, bool *result)
{
KAA_RETURN_IF_NIL2(self, result, KAA_ERR_BADPARAM);
if (self->is_sync_ignored) {
*result = false;
return KAA_ERR_NONE;
}
*result = true;
return KAA_ERR_NONE;
}
kaa_error_t kaa_buffer_lock_space(kaa_buffer_t *buffer_p, size_t lock_size)
{
KAA_RETURN_IF_NIL2(buffer_p, lock_size, KAA_ERR_BADPARAM);
if (buffer_p->current + lock_size > buffer_p->end)
return KAA_ERR_BUFFER_IS_NOT_ENOUGH;
buffer_p->current += lock_size;
return KAA_ERR_NONE;
}
static kaa_root_configuration_t *kaa_configuration_manager_deserialize(const char *buffer, size_t buffer_size)
{
KAA_RETURN_IF_NIL2(buffer, buffer_size, NULL);
avro_reader_t reader = avro_reader_memory(buffer, buffer_size);
KAA_RETURN_IF_NIL(reader, NULL);
kaa_root_configuration_t *result = KAA_CONFIGURATION_DESERIALIZE(reader);
avro_reader_free(reader);
return result;
}
kaa_error_t kaa_configuration_manager_handle_server_sync(kaa_configuration_manager_t *self
, kaa_platform_message_reader_t *reader
, uint32_t extension_options
, size_t extension_length)
{
KAA_RETURN_IF_NIL2(self, reader, KAA_ERR_BADPARAM);
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Received configuration server sync: options %u, payload size %u", extension_options, extension_length);
if (extension_length >= sizeof(uint32_t)) {
self->status->config_seq_n = KAA_NTOHL(*((uint32_t *) reader->current));
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Configuration state sequence number is '%d'", self->status->config_seq_n);
reader->current += sizeof(uint32_t);
if (extension_options & KAA_CONFIGURATION_BODY_PRESENT) {
uint32_t body_size = KAA_NTOHL(*((uint32_t *) reader->current));
reader->current += sizeof(uint32_t);
KAA_LOG_INFO(self->logger, KAA_ERR_NONE, "Received configuration body, size '%u' ", body_size);
const char* body = reader->current;
kaa_error_t error = kaa_platform_message_skip(reader, kaa_aligned_size_get(body_size));
if (error) {
KAA_LOG_ERROR(self->logger, error, "Failed to read configuration body, size %u", body_size);
return error;
}
#if KAA_CONFIGURATION_DELTA_SUPPORT
#else
if (self->root_record)
self->root_record->destroy(self->root_record);
self->root_record = kaa_configuration_manager_deserialize(body, body_size);
if (!self->root_record) {
KAA_LOG_ERROR(self->logger, KAA_ERR_READ_FAILED, "Failed to deserialize configuration body, size %u", body_size);
return KAA_ERR_READ_FAILED;
}
kaa_error_t err = ext_calculate_sha_hash(body, body_size, self->configuration_hash);
if (err) {
KAA_LOG_WARN(self->logger, err, "Failed to calculate configuration body hash");
return err;
}
ext_configuration_store(body, body_size);
#endif
if (self->root_receiver.on_configuration_updated)
self->root_receiver.on_configuration_updated(self->root_receiver.context, self->root_record);
kaa_transport_channel_interface_t *channel =
kaa_channel_manager_get_transport_channel(self->channel_manager, configuration_sync_services[0]);
if (channel)
channel->sync_handler(channel->context, configuration_sync_services, 1);
}
}
return KAA_ERR_NONE;
}
kaa_error_t kaa_failover_strategy_create(kaa_failover_strategy_t** strategy, kaa_logger_t *logger)
{
KAA_RETURN_IF_NIL2(strategy, logger, KAA_ERR_BADPARAM);
*strategy = (kaa_failover_strategy_t *) KAA_MALLOC(sizeof(kaa_failover_strategy_t));
KAA_RETURN_IF_NIL(*strategy, KAA_ERR_NOMEM);
(*strategy)->decision.action = KAA_USE_NEXT_BOOTSTRAP;
(*strategy)->decision.retry_period = KAA_FAILOVER_RETRY_PERIOD;
(*strategy)->logger = logger;
return KAA_ERR_NONE;
}
kaa_error_t kaa_profile_manager_set_endpoint_access_token(kaa_profile_manager_t *self, const char *token)
{
KAA_RETURN_IF_NIL2(self, token, KAA_ERR_BADPARAM);
kaa_error_t error = kaa_status_set_endpoint_access_token(self->status, token);
if (error == KAA_ERR_NONE) {
self->need_resync = true;
/* Ignoring an error code: the channels can be not initialized */
(void)kaa_profile_force_sync(self);
}
return error;
}
ext_tcp_socket_io_errors_t ext_tcp_utils_tcp_socket_write(kaa_fd_t fd
, const char *buffer
, size_t buffer_size
, size_t *bytes_written)
{
KAA_RETURN_IF_NIL2(buffer, buffer_size, KAA_TCP_SOCK_IO_ERROR);
ssize_t write_result = send(fd, buffer, buffer_size, 0);
if (write_result < 0 && errno != EAGAIN)
return KAA_TCP_SOCK_IO_ERROR;
if (bytes_written)
*bytes_written = (write_result > 0) ? write_result : 0;
return KAA_TCP_SOCK_IO_OK;
}
kaa_error_t ext_tcp_utils_set_sockaddr_port(kaa_sockaddr_t *addr, uint16_t port)
{
KAA_RETURN_IF_NIL2(addr, port, KAA_ERR_BADPARAM);
switch (addr->sa_family) {
case AF_INET: {
struct sockaddr_in *s_in = (struct sockaddr_in *) addr;
s_in->sin_port = KAA_HTONS(port);
break;
}
default:
return KAA_ERR_SOCKET_INVALID_FAMILY;
}
return KAA_ERR_NONE;
}
ext_tcp_socket_io_errors_t ext_tcp_utils_tcp_socket_read(kaa_fd_t fd
, char *buffer
, size_t buffer_size
, size_t *bytes_read)
{
KAA_RETURN_IF_NIL2(buffer, buffer_size, KAA_TCP_SOCK_IO_ERROR);
ssize_t read_result = recv(fd, buffer, buffer_size, 0);
if (!read_result)
return KAA_TCP_SOCK_IO_EOF;
if (read_result < 0 && errno != EAGAIN)
return KAA_TCP_SOCK_IO_ERROR;
if (bytes_read)
*bytes_read = (read_result > 0) ? read_result : 0;
return KAA_TCP_SOCK_IO_OK;
}
kaa_error_t kaa_buffer_free_allocated_space(kaa_buffer_t *buffer_p, size_t size)
{
KAA_RETURN_IF_NIL2(buffer_p, size, KAA_ERR_BADPARAM);
if (buffer_p->begin + size > buffer_p->current)
return KAA_ERR_BUFFER_INVALID_SIZE;
char *byte_to_copy = buffer_p->begin + size;
char *it = buffer_p->begin;
for (; byte_to_copy != buffer_p->current; ++byte_to_copy, ++it)
*it = *byte_to_copy;
buffer_p->current -= size;
return KAA_ERR_NONE;
}
kaa_error_t kaa_buffer_create_buffer(kaa_buffer_t **buffer_p, size_t buffer_size)
{
KAA_RETURN_IF_NIL2(buffer_p, buffer_size, KAA_ERR_BADPARAM);
kaa_buffer_t *buffer = (kaa_buffer_t *) KAA_MALLOC(sizeof(kaa_buffer_t));
KAA_RETURN_IF_NIL(buffer, KAA_ERR_NOMEM);
buffer->begin = (char *) KAA_CALLOC(buffer_size , sizeof(char));
if (!buffer->begin) {
KAA_FREE(buffer);
return KAA_ERR_NOMEM;
}
buffer->end = buffer->begin + buffer_size;
buffer->current = buffer->begin;
*buffer_p = buffer;
return KAA_ERR_NONE;
}
kaatcp_error_t kaatcp_fill_connect_message(uint16_t keepalive, uint32_t next_protocol_id
, char *sync_request, size_t sync_request_size
, char *session_key, size_t session_key_size
, char *signature, size_t signature_size
, kaatcp_connect_t *message)
{
KAA_RETURN_IF_NIL2(sync_request, sync_request_size, KAATCP_ERR_BAD_PARAM);
if ((session_key_size > 0 && !session_key) || (signature_size > 0 && !signature))
return KAATCP_ERR_BAD_PARAM;
KAA_RETURN_IF_NIL(message, KAATCP_ERR_BAD_PARAM);
memset(message, 0, sizeof(kaatcp_connect_t));
message->protocol_name_length = KAA_TCP_NAME_LENGTH;
memcpy(message->protocol_name, KAA_TCP_NAME, KAA_TCP_NAME_LENGTH);
message->protocol_version = PROTOCOL_VERSION;
message->connect_flags = KAA_CONNECT_FLAGS;
message->next_ptorocol_id = next_protocol_id;
if (session_key) {
message->session_key = session_key;
message->session_key_size = session_key_size;
message->session_key_flags = KAA_CONNECT_KEY_AES_RSA;
}
if (signature) {
message->signature = signature;
message->signature_size = signature_size;
message->signature_flags = KAA_CONNECT_SIGNATURE_SHA1;
}
message->keep_alive = keepalive;
message->sync_request_size = sync_request_size;
message->sync_request = sync_request;
return KAATCP_ERR_NONE;
}
kaatcp_error_t kaatcp_get_request_size(const kaatcp_connect_t *message, kaatcp_message_type_t type, size_t *size)
{
KAA_RETURN_IF_NIL2(message, size, KAATCP_ERR_BAD_PARAM);
size_t payload_size = message->sync_request_size
+ message->session_key_size
+ message->signature_size
+ KAA_CONNECT_HEADER_LENGTH;
if (payload_size <= MAX_MESSAGE_LENGTH && type <= MAX_MESSAGE_TYPE_LENGTH) {
uint8_t header_size = 1;
do {
payload_size /= FIRST_BIT;
++header_size;
} while (payload_size);
*size = payload_size + header_size;
return (kaatcp_error_t)KAA_ERR_NONE;
}
return (kaatcp_error_t)KAA_ERR_BADPARAM;
}
