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; }