kaa_error_t kaa_platform_protocol_serialize_client_sync(kaa_platform_protocol_t *self
, const kaa_serialize_info_t *info
, char **buffer
, size_t *buffer_size)
{
KAA_RETURN_IF_NIL4(self, info, buffer, buffer_size, KAA_ERR_BADPARAM);
KAA_RETURN_IF_NIL3(info->allocator, info->services, info->services_count, KAA_ERR_BADDATA);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Serializing client sync...");
*buffer_size = 0;
kaa_error_t error = kaa_client_sync_get_size(self, info->services, info->services_count, buffer_size);
KAA_RETURN_IF_ERR(error)
KAA_LOG_DEBUG(self->logger, KAA_ERR_NONE, "Going to request sync buffer (size %zu)", *buffer_size);
*buffer = info->allocator(info->allocator_context, *buffer_size);
if (*buffer) {
self->request_id++;
error = kaa_client_sync_serialize(self, info->services, info->services_count, *buffer, buffer_size);
} else {
error = KAA_ERR_WRITE_FAILED;
}
if (error) {
self->request_id--;
} else {
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Client sync successfully serialized");
}
return error;
}
kaa_error_t kaa_platform_protocol_create(kaa_platform_protocol_t **platform_protocol_p
, kaa_context_t *context
, kaa_status_t *status)
{
KAA_RETURN_IF_NIL4(platform_protocol_p, context, context->logger, status, KAA_ERR_BADPARAM);
*platform_protocol_p = KAA_MALLOC(sizeof(kaa_platform_protocol_t));
KAA_RETURN_IF_NIL(*platform_protocol_p, KAA_ERR_NOMEM);
(*platform_protocol_p)->request_id = 0;
(*platform_protocol_p)->kaa_context = context;
(*platform_protocol_p)->status = status;
(*platform_protocol_p)->logger = context->logger;
return KAA_ERR_NONE;
}
ext_tcp_utils_function_return_state_t ext_tcp_utils_getaddrbyhost(kaa_dns_resolve_listener_t *resolve_listener, const kaa_dns_resolve_info_t *resolve_props, kaa_sockaddr_t *result, kaa_socklen_t *result_size)
{
KAA_RETURN_IF_NIL4(resolve_props, resolve_props->hostname, result, result_size, RET_STATE_VALUE_ERROR);
if (*result_size < sizeof(struct sockaddr_in))
return RET_STATE_BUFFER_NOT_ENOUGH;
char hostname_str[resolve_props->hostname_length + 1];
memcpy(hostname_str, resolve_props->hostname, resolve_props->hostname_length);
hostname_str[resolve_props->hostname_length] = '\0';
KAA_LOG_INFO(logger, KAA_ERR_NONE, "getaddrbyhost() Hostname=%s:%d", hostname_str, resolve_props->port);
struct addrinfo hints;
memset(&hints, 0 , sizeof(struct addrinfo));
hints.ai_socktype = SOCK_STREAM;
if (*result_size < sizeof(struct sockaddr_in6))
hints.ai_family = AF_INET;
struct addrinfo *resolve_result = NULL;
int resolve_error = 0;
if (resolve_props->port) {
char port_str[6];
snprintf(port_str, 6, "%u", resolve_props->port);
resolve_error = getaddrinfo(hostname_str, port_str, &hints, &resolve_result);
} else {
resolve_error = getaddrinfo(hostname_str, NULL, &hints, &resolve_result);
}
if (resolve_error || !resolve_result)
return RET_STATE_VALUE_ERROR;
if (resolve_result->ai_addrlen > *result_size) {
freeaddrinfo(resolve_result);
return RET_STATE_BUFFER_NOT_ENOUGH;
}
memcpy(result, resolve_result->ai_addr, resolve_result->ai_addrlen);
*result_size = resolve_result->ai_addrlen;
freeaddrinfo(resolve_result);
access_point_test_info.gethostbyaddr_requested = true;
return RET_STATE_VALUE_READY;
}
ext_tcp_utils_function_return_state_t ext_tcp_utils_getaddrbyhost(kaa_dns_resolve_listener_t *resolve_listener
, const kaa_dns_resolve_info_t *resolve_props
, kaa_sockaddr_t *result
, kaa_socklen_t *result_size)
{
(void)resolve_listener;
KAA_RETURN_IF_NIL4(resolve_props, resolve_props->hostname, result, result_size, RET_STATE_VALUE_ERROR);
if (*result_size < sizeof(struct sockaddr_in))
return RET_STATE_BUFFER_NOT_ENOUGH;
struct addrinfo hints;
memset(&hints, 0 , sizeof(struct addrinfo));
hints.ai_socktype = SOCK_STREAM;
/* LWIP does not support ipv6, so sockaddr_in6 is not even defined in lwip/sockets.h */
/* if (*result_size < sizeof(struct sockaddr_in6)) */
hints.ai_family = AF_INET;
char hostname_str[resolve_props->hostname_length + 1];
memcpy(hostname_str, resolve_props->hostname, resolve_props->hostname_length);
hostname_str[resolve_props->hostname_length] = '\0';
struct addrinfo *resolve_result = NULL;
int resolve_error = 0;
if (resolve_props->port) {
char port_str[6];
snprintf(port_str, 6, "%u", resolve_props->port);
resolve_error = getaddrinfo(hostname_str, port_str, &hints, &resolve_result);
} else {
resolve_error = getaddrinfo(hostname_str, NULL, &hints, &resolve_result);
}
if (resolve_error || !resolve_result)
return RET_STATE_VALUE_ERROR;
if (resolve_result->ai_addrlen > *result_size) {
freeaddrinfo(resolve_result);
return RET_STATE_BUFFER_NOT_ENOUGH;
}
memcpy(result, resolve_result->ai_addr, resolve_result->ai_addrlen);
*result_size = resolve_result->ai_addrlen;
freeaddrinfo(resolve_result);
return RET_STATE_VALUE_READY;
}
kaa_error_t kaa_platform_protocol_create(kaa_platform_protocol_t **platform_protocol_p
, kaa_context_t *context
, kaa_status_t *status)
{
KAA_RETURN_IF_NIL4(platform_protocol_p, context, context->logger, status, KAA_ERR_BADPARAM);
kaa_platform_protocol_t *protocol = KAA_MALLOC(sizeof(*protocol));
if (!protocol)
return KAA_ERR_NOMEM;
protocol->request_id = 0;
protocol->kaa_context = context;
protocol->status = status;
protocol->logger = context->logger;
*platform_protocol_p = protocol;
return KAA_ERR_NONE;
}
ext_tcp_utils_function_return_state_t ext_tcp_utils_getaddrbyhost(kaa_dns_resolve_listener_t *resolve_listener
, const kaa_dns_resolve_info_t *resolve_props
, kaa_sockaddr_t *result
, kaa_socklen_t *result_size)
{
(void)resolve_listener;
KAA_RETURN_IF_NIL4(resolve_props, resolve_props->hostname, result, result_size, RET_STATE_VALUE_ERROR);
if (*result_size < sizeof(struct sockaddr_in))
return RET_STATE_BUFFER_NOT_ENOUGH;
unsigned long out_ip = 0;
int ai_family;
int resolve_error = 0;
struct sockaddr_in tmp_addr;
ai_family = AF_INET;
*result_size = sizeof(struct sockaddr_in);
char hostname_str[resolve_props->hostname_length + 1];
memcpy(hostname_str, resolve_props->hostname, resolve_props->hostname_length);
hostname_str[resolve_props->hostname_length] = '\0';
if (strcmp(hostname_str, "localhost"))
resolve_error = sl_NetAppDnsGetHostByName((signed char*)hostname_str, resolve_props->hostname_length, &out_ip, ai_family);
else
out_ip = 0x7F000001;
memset(&tmp_addr, 0, *result_size);
tmp_addr.sin_family = ai_family;
tmp_addr.sin_addr.s_addr = sl_Htonl((unsigned int)out_ip);
tmp_addr.sin_port = sl_Htons((unsigned short)resolve_props->port);
if (resolve_error || !out_ip)
return RET_STATE_VALUE_ERROR;
memcpy(result, (struct sockaddr*)&tmp_addr, *result_size);
return RET_STATE_VALUE_READY;
}
static kaa_error_t kaa_client_sync_get_size(kaa_platform_protocol_t *self
, const kaa_service_t services[]
, size_t services_count
, size_t *expected_size)
{
KAA_RETURN_IF_NIL4(self, services, services_count, expected_size, KAA_ERR_BADPARAM)
*expected_size = KAA_PROTOCOL_MESSAGE_HEADER_SIZE;
size_t extension_size = 0;
kaa_error_t err_code = kaa_meta_data_request_get_size(&extension_size);
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to query size for meta extension");
return err_code;
}
*expected_size += extension_size;
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated meta extension size %u", extension_size);
while (!err_code && services_count--) {
switch (services[services_count]) {
case KAA_SERVICE_BOOTSTRAP: {
err_code = kaa_channel_manager_bootstrap_request_get_size(self->kaa_context->channel_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated bootstrap extension size %u", extension_size);
break;
}
case KAA_SERVICE_PROFILE: {
bool need_resync = false;
err_code = kaa_profile_need_profile_resync(self->kaa_context->profile_manager
, &need_resync);
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to read 'need_resync' flag");
}
if (!err_code && need_resync) {
err_code = kaa_profile_request_get_size(self->kaa_context->profile_manager
, &extension_size);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated profile extension size %u", extension_size);
}
break;
}
case KAA_SERVICE_USER: {
err_code = kaa_user_request_get_size(self->kaa_context->user_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated user extension size %u", extension_size);
break;
}
#ifndef KAA_DISABLE_FEATURE_EVENTS
case KAA_SERVICE_EVENT: {
err_code = kaa_event_request_get_size(self->kaa_context->event_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated event extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_LOGGING
case KAA_SERVICE_LOGGING: {
err_code = kaa_logging_request_get_size(self->kaa_context->log_collector
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated logging extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_CONFIGURATION
case KAA_SERVICE_CONFIGURATION: {
err_code = kaa_configuration_manager_get_size(self->kaa_context->configuration_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated configuration extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_NOTIFICATION
case KAA_SERVICE_NOTIFICATION: {
err_code = kaa_notification_manager_get_size(self->kaa_context->notification_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated notification extension size %u", extension_size);
break;
}
#endif
default:
extension_size = 0;
break;
}
*expected_size += extension_size;
}
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to query extension size in %u service"
, services[services_count]);
}
return err_code;
}
