From 612275454d3277f733531b9e6890ce769be38859 Mon Sep 17 00:00:00 2001 From: P Heam Kumar Date: Wed, 29 Apr 2026 22:24:51 +0530 Subject: [PATCH] RDKBWIFI-364 : Generalizing bus abstraction functions for retrieving and setting bus data property types. This reverts commit 13a7190ac27ff42e202d65cc06f3360ce360f7bf. --- inc/wlan_emu_test_params.h | 2 +- inc/wlan_emu_ui_mgr.h | 4 +- src/bus/rdkb/wlan_emu_bus.cpp | 301 +++++++++++++++----- src/tests/wlan_emu_test_param_stats_get.cpp | 77 +++-- src/ui/wlan_emu_ui_mgr.cpp | 19 +- 5 files changed, 302 insertions(+), 101 deletions(-) diff --git a/inc/wlan_emu_test_params.h b/inc/wlan_emu_test_params.h index 6002b48..9dacf11 100644 --- a/inc/wlan_emu_test_params.h +++ b/inc/wlan_emu_test_params.h @@ -243,7 +243,7 @@ class test_step_param_get_stats_t : public test_step_params_t { char *get_scanmode_str(); int update_output_file_name(); int get_subscription_string(char *str, int str_len); - static void stats_get_event_handler(char *event_name, raw_data_t *data, void *userData); + static void stats_get_event_handler(char *event_name, bus_data_prop_t *data, void *userData); int step_frame_filter(wlan_emu_msg_t *msg); char *get_stats_response_type(); }; diff --git a/inc/wlan_emu_ui_mgr.h b/inc/wlan_emu_ui_mgr.h index 5d63cde..fd29861 100644 --- a/inc/wlan_emu_ui_mgr.h +++ b/inc/wlan_emu_ui_mgr.h @@ -391,8 +391,8 @@ class wlan_emu_ui_mgr_t { static void *heartbeat_function(void *arg); - static void set_webconfig_cci_data(char *event_name, raw_data_t *data, void *userData); - void (*func_ptr)(char *event_name, raw_data_t *data); + static void set_webconfig_cci_data(char *event_name, bus_data_prop_t *data, void *userData); + void (*func_ptr)(char *event_name, bus_data_prop_t *data); void cci_cache_update(webconfig_subdoc_data_t *data); void mac_filter_cci_cache_update(webconfig_subdoc_data_t *data); void update_cci_subdoc_vap_data(webconfig_subdoc_data_t *data); diff --git a/src/bus/rdkb/wlan_emu_bus.cpp b/src/bus/rdkb/wlan_emu_bus.cpp index 18452c9..e69d830 100644 --- a/src/bus/rdkb/wlan_emu_bus.cpp +++ b/src/bus/rdkb/wlan_emu_bus.cpp @@ -489,6 +489,24 @@ static void free_raw_data_struct(raw_data_t *p_data) } } +static void free_bus_data_prop(bus_data_prop_t *bus_data) +{ + if (bus_data == NULL) { + return; + } + + bus_data_prop_t *next = bus_data->next_data; + free_raw_data_struct(&bus_data->value); + memset(bus_data, 0, sizeof(*bus_data)); + + while (next != NULL) { + bus_data_prop_t *cur = next; + next = cur->next_data; + free_raw_data_struct(&cur->value); + free(cur); + } +} + static rbusError_t rbus_set_handler(rbusHandle_t handle, rbusProperty_t property, rbusSetHandlerOptions_t *options) { @@ -596,72 +614,176 @@ static rbusError_t rbus_get_handler(rbusHandle_t handle, rbusProperty_t property return convert_bus_to_rbus_error_code(ret); } -static bus_error_t get_rbus_object_data(char *name, rbusObject_t inParams, raw_data_t *bus_data) +static bus_error_t rbus_value_to_bus_prop(bus_data_prop_t *bus_data, const char *prop_name, + rbusValue_t value) { + if (bus_data == NULL || value == NULL) { + return bus_error_invalid_input; + } + bus_error_t rc = bus_error_success; - int len = 0; + bus_data_prop_t *prop = NULL; + rbusValueType_t type = RBUS_NONE; + bool use_head = (!bus_data->is_data_set && bus_data->next_data == NULL); - if (bus_data == NULL) { - wlan_emu_print(wlan_emu_log_level_err, "%s:%d bus buff is NULL\n", __func__, __LINE__); - return bus_error_invalid_input; + if (use_head) { + prop = bus_data; + memset(prop, 0, sizeof(*prop)); + } else { + prop = (bus_data_prop_t *)calloc(1, sizeof(*prop)); + if (prop == NULL) { + return bus_error_out_of_resources; + } } - rbusValue_t value = rbusObject_GetValue(inParams, NULL); - rbusValueType_t type = rbusValue_GetType(value); - bus_data->data_type = convert_rbus_to_bus_data_type(type); + if (prop_name != NULL) { + size_t name_len = strnlen(prop_name, sizeof(prop->name)); + if (name_len >= sizeof(prop->name)) { + rc = bus_error_invalid_input; + goto cleanup; + } + memcpy(prop->name, prop_name, name_len + 1); + prop->name_len = (uint32_t)name_len; + } else { + prop->name_len = 0; + memset(prop->name, 0, sizeof(prop->name)); + } + + memset(&prop->value, 0, sizeof(prop->value)); + type = rbusValue_GetType(value); + prop->value.data_type = convert_rbus_to_bus_data_type(type); switch (type) { - case RBUS_STRING: - bus_data->raw_data.bytes = (char *)rbusValue_GetString(value, &len); - if (bus_data->raw_data.bytes != NULL) { - bus_data->raw_data_len = (unsigned int)len; - wlan_emu_print(wlan_emu_log_level_info, "%s Rbus get string len=%d\n", __FUNCTION__, - len); - } else { + case RBUS_STRING: { + int len = 0; + const char *str_val = rbusValue_GetString(value, &len); + if (str_val == NULL || len < 0) { rc = bus_error_invalid_input; - wlan_emu_print(wlan_emu_log_level_err, "%s Rbus get string failure len=%d\n", - __FUNCTION__, len); + goto cleanup; } + + prop->value.raw_data.bytes = calloc(1, (size_t)len + 1); + if (prop->value.raw_data.bytes == NULL) { + rc = bus_error_out_of_resources; + goto cleanup; + } + + memcpy(prop->value.raw_data.bytes, str_val, (size_t)len); + ((char *)prop->value.raw_data.bytes)[len] = '\0'; + prop->value.raw_data_len = (unsigned int)len; break; - case RBUS_UINT32: - bus_data->raw_data.u32 = rbusValue_GetUInt32(value); - bus_data->raw_data_len = sizeof(uint32_t); - break; - case RBUS_INT32: - bus_data->raw_data.i32 = rbusValue_GetInt32(value); - bus_data->raw_data_len = sizeof(int32_t); + } + case RBUS_BYTES: { + int len = 0; + const uint8_t *bytes_val = rbusValue_GetBytes(value, &len); + if (len < 0 || (len > 0 && bytes_val == NULL)) { + rc = bus_error_invalid_input; + goto cleanup; + } + + if (len > 0) { + prop->value.raw_data.bytes = calloc(1, (size_t)len); + if (prop->value.raw_data.bytes == NULL) { + rc = bus_error_out_of_resources; + goto cleanup; + } + memcpy(prop->value.raw_data.bytes, bytes_val, (size_t)len); + } + + prop->value.raw_data_len = (unsigned int)len; break; + } case RBUS_BOOLEAN: - bus_data->raw_data.b = rbusValue_GetBoolean(value); - bus_data->raw_data_len = sizeof(bool); + prop->value.raw_data.b = rbusValue_GetBoolean(value); + prop->value.raw_data_len = sizeof(bool); break; - case RBUS_BYTES: - bus_data->raw_data.bytes = (uint8_t *)rbusValue_GetBytes(value, &len); - if (bus_data->raw_data.bytes != NULL) { - bus_data->raw_data_len = (unsigned int)len; - wlan_emu_print(wlan_emu_log_level_info, "%s Rbus get bytes len=%d\n", __FUNCTION__, - len); - } else { - rc = bus_error_invalid_input; - wlan_emu_print(wlan_emu_log_level_err, "%s Rbus get bytes failure len=%d\n", - __FUNCTION__, len); - } + case RBUS_INT32: + prop->value.raw_data.i32 = rbusValue_GetInt32(value); + prop->value.raw_data_len = sizeof(int32_t); + break; + case RBUS_UINT32: + prop->value.raw_data.u32 = rbusValue_GetUInt32(value); + prop->value.raw_data_len = sizeof(uint32_t); break; default: - wlan_emu_print(wlan_emu_log_level_err, "%s Rbus value type not found =%d\n", __FUNCTION__, - type); rc = bus_error_invalid_input; - break; + goto cleanup; } - if (rc != bus_error_success) { - wlan_emu_print(wlan_emu_log_level_err, "%s rbus read failed for %s\n", __FUNCTION__, name); - return rc; + prop->is_data_set = true; + prop->status = bus_error_success; + prop->ref_count = 1; + + if (!use_head) { + prop->next_data = bus_data->next_data; + bus_data->next_data = prop; + } + + return bus_error_success; + +cleanup: + free_raw_data_struct(&prop->value); + if (use_head) { + memset(prop, 0, sizeof(*prop)); + } else { + free(prop); } return rc; } +static bus_error_t get_rbus_object_data(char *name, rbusObject_t inParams, bus_data_prop_t *bus_data) +{ + if (bus_data == NULL || inParams == NULL) { + wlan_emu_print(wlan_emu_log_level_err, "%s:%d bus buff is NULL\n", __func__, __LINE__); + return bus_error_invalid_input; + } + + bus_error_t rc = bus_error_success; + rbusProperty_t prop_head = rbusObject_GetProperties(inParams); + + if (prop_head != NULL) { + for (rbusProperty_t prop = prop_head; prop != NULL && rc == bus_error_success; + prop = rbusProperty_GetNext(prop)) { + const char *prop_name = rbusProperty_GetName(prop); + if (prop_name == NULL) { + rc = bus_error_invalid_input; + break; + } + + rbusValue_t prop_val = rbusProperty_GetValue(prop); + if (prop_val == NULL) { + rc = bus_error_invalid_input; + break; + } + + rc = rbus_value_to_bus_prop(bus_data, prop_name, prop_val); + } + + if (rc != bus_error_success) { + free_bus_data_prop(bus_data); + wlan_emu_print(wlan_emu_log_level_err, + "%s:%d rbus property parse failed for %s\n", __func__, __LINE__, + name ? name : "unknown"); + } + + return rc; + } + + // Fallback: object may carry a single unnamed value. + rbusValue_t value = rbusObject_GetValue(inParams, NULL); + if (value == NULL) { + return bus_error_invalid_input; + } + + rbusValueType_t type = rbusValue_GetType(value); + if (type == RBUS_NONE) { + return bus_error_success; + } + + return rbus_value_to_bus_prop(bus_data, NULL, value); +} + static bus_error_t bus_data_get(bus_handle_t *handle, char const *name, raw_data_t *data) { rbusValue_t value; @@ -772,11 +894,11 @@ static void rbus_sub_handler(rbusHandle_t handle, rbusEvent_t const *event, (void)handle; bus_error_t ret = bus_error_success; - raw_data_t bus_data; + bus_data_prop_t bus_data; char *event_name = (char *)subscription->eventName; void *userData = subscription->userData; - memset(&bus_data, 0, sizeof(raw_data_t)); + memset(&bus_data, 0, sizeof(bus_data_prop_t)); wlan_emu_print(wlan_emu_log_level_info, "%s:%d rbus sub cb triggered for %s\n", __func__, __LINE__, event_name); bus_mux_sub_node_data_t *sub_node_data = (bus_mux_sub_node_data_t *)get_bus_cb_data_info( @@ -790,8 +912,10 @@ static void rbus_sub_handler(rbusHandle_t handle, rbusEvent_t const *event, if (user_cb->sub_handler != NULL) { ret = get_rbus_object_data(event_name, event->data, &bus_data); if (ret == bus_error_success) { - user_cb->sub_handler((char *)event_name, &bus_data, userData); + user_cb->sub_handler((char *)(event->name ? event->name : event_name), &bus_data, + userData); } + free_bus_data_prop(&bus_data); } } @@ -996,30 +1120,67 @@ static rbusError_t rbus_event_sub_handler(rbusHandle_t handle, rbusEventSubActio return RBUS_ERROR_SUCCESS; } -static bus_error_t set_rbus_object_data(char *name, rbusObject_t outParams, raw_data_t *bus_data) +static bus_error_t set_rbus_object_data(char *name, rbusObject_t outParams, bus_data_prop_t *bus_data) { - bus_error_t rc = bus_error_success; - rbusValue_t value; - - rbusValue_Init(&value); - wlan_emu_print(wlan_emu_log_level_info, "%s:%d Rbus object:%s data type=%d set\r\n", __func__, - __LINE__, name, bus_data->data_type); + if (bus_data == NULL) { + return bus_error_invalid_input; + } - switch (bus_data->data_type) { - case bus_data_type_bytes: - rbusValue_SetBytes(value, (uint8_t *)bus_data->raw_data.bytes, bus_data->raw_data_len); - break; - default: - wlan_emu_print(wlan_emu_log_level_err, "%s Rbus:%s value type not found =%d\n", - __FUNCTION__, name, bus_data->data_type); - rc = bus_error_invalid_input; - break; + if (!bus_data->is_data_set && bus_data->next_data == NULL) { + return bus_error_success; } - rbusObject_SetValue(outParams, name, value); - rbusValue_Release(value); + for (bus_data_prop_t *prop = bus_data; prop != NULL; prop = prop->next_data) { + if (!prop->is_data_set) { + continue; + } - return rc; + rbusValue_t value = NULL; + rbusProperty_t property = NULL; + rbusValue_Init(&value); + + switch (prop->value.data_type) { + case bus_data_type_string: + rbusValue_SetString(value, + prop->value.raw_data.bytes ? (char *)prop->value.raw_data.bytes : ""); + break; + case bus_data_type_bytes: + rbusValue_SetBytes(value, (uint8_t *)prop->value.raw_data.bytes, + prop->value.raw_data_len); + break; + case bus_data_type_int32: + rbusValue_SetInt32(value, prop->value.raw_data.i32); + break; + case bus_data_type_uint32: + rbusValue_SetUInt32(value, prop->value.raw_data.u32); + break; + case bus_data_type_boolean: + rbusValue_SetBoolean(value, prop->value.raw_data.b); + break; + default: + wlan_emu_print(wlan_emu_log_level_err, + "%s Rbus:%s unsupported property value type=%d\n", __FUNCTION__, name, + prop->value.data_type); + rbusValue_Release(value); + return bus_error_invalid_input; + } + + const char *prop_name = NULL; + if (prop->name_len > 0) { + prop_name = prop->name; + } else if (name != NULL && *name != '\0') { + prop_name = name; + } else { + prop_name = "value"; + } + + rbusProperty_Init(&property, prop_name, value); + rbusObject_SetProperty(outParams, property); + rbusProperty_Release(property); + rbusValue_Release(value); + } + + return bus_error_success; } static rbusError_t rbus_table_remove_row_handler(rbusHandle_t handle, char const *rowName) @@ -1049,11 +1210,11 @@ static rbusError_t rbus_table_remove_row_handler(rbusHandle_t handle, char const static rbusError_t rbus_method_handler(rbusHandle_t handle, char const *methodName, rbusObject_t inParams, rbusObject_t outParams, rbusMethodAsyncHandle_t asyncHandle) { - raw_data_t bus_input_data, bus_output_data; + bus_data_prop_t bus_input_data, bus_output_data; bus_error_t ret = bus_error_success; - memset(&bus_input_data, 0, sizeof(raw_data_t)); - memset(&bus_output_data, 0, sizeof(raw_data_t)); + memset(&bus_input_data, 0, sizeof(bus_data_prop_t)); + memset(&bus_output_data, 0, sizeof(bus_data_prop_t)); wlan_emu_print(wlan_emu_log_level_info, "%s:%d rbus cb triggered for %s\n", __func__, __LINE__, methodName); bus_mux_reg_node_data_t *reg_node_data = (bus_mux_reg_node_data_t *)get_bus_cb_data_info( @@ -1076,8 +1237,10 @@ static rbusError_t rbus_method_handler(rbusHandle_t handle, char const *methodNa } else { ret = set_rbus_object_data((char *)methodName, outParams, &bus_output_data); } - free_raw_data_struct(&bus_output_data); } + + free_bus_data_prop(&bus_input_data); + free_bus_data_prop(&bus_output_data); } return convert_bus_to_rbus_error_code(ret); diff --git a/src/tests/wlan_emu_test_param_stats_get.cpp b/src/tests/wlan_emu_test_param_stats_get.cpp index c2235ae..a038aef 100644 --- a/src/tests/wlan_emu_test_param_stats_get.cpp +++ b/src/tests/wlan_emu_test_param_stats_get.cpp @@ -26,6 +26,7 @@ #include #include #include +#include #include #include @@ -217,21 +218,34 @@ int test_step_param_get_stats_t::update_output_file_name() return RETURN_ERR; } -void test_step_param_get_stats_t::stats_get_event_handler(char *event_name, raw_data_t *p_data, void *userData) +void test_step_param_get_stats_t::stats_get_event_handler(char *event_name, + bus_data_prop_t *p_data, void *userData) { bus_error_t rc = bus_error_success; - const char *json_str = NULL; - int len = 0; + char *json_str = NULL; test_step_params_t *step = NULL; char file_name[128] = { 0 }; - char *temp_file_name; FILE *fp = NULL; char timestamp[24] = { 0 }; webconfig_cci_t *cci_webconfig; raw_data_t data; + bool is_mutex_locked = false; + + (void)p_data; step = static_cast(userData); + if (step == NULL || step->m_ui_mgr == NULL || step->m_bus_mgr == NULL) { + wlan_emu_print(wlan_emu_log_level_err, "%s:%d: invalid callback context\n", __func__, + __LINE__); + return; + } + cci_webconfig = step->m_ui_mgr->get_webconfig_data(); + if (cci_webconfig == NULL) { + wlan_emu_print(wlan_emu_log_level_err, "%s:%d: cci_webconfig is NULL\n", __func__, + __LINE__); + return; + } memset(&data, 0, sizeof(raw_data_t)); wlan_emu_print(wlan_emu_log_level_dbg, "%s: %d bus event callback Event is %s \n", __func__, @@ -239,30 +253,29 @@ void test_step_param_get_stats_t::stats_get_event_handler(char *event_name, raw_ rc = step->m_bus_mgr->desc.bus_data_get_fn(&cci_webconfig->handle, event_name, &data); - if (rc != bus_error_success || (data.data_type != bus_data_type_string)) { + if (rc != bus_error_success || data.data_type != bus_data_type_string || + data.raw_data.bytes == NULL || data.raw_data_len == 0) { wlan_emu_print(wlan_emu_log_level_err, "%s:%d: bus_data_get_fn failed for %s\n", __func__, __LINE__, event_name); - return; + goto cleanup; } - json_str = new char[data.raw_data_len + 1](); - strncpy((char *)json_str, (char *)data.raw_data.bytes, data.raw_data_len); - len = data.raw_data_len; - + json_str = new (std::nothrow) char[data.raw_data_len + 1](); if (json_str == NULL) { wlan_emu_print(wlan_emu_log_level_err, "%s Null pointer,bus get string len=%d\n", - __FUNCTION__, len); - return; + __FUNCTION__, data.raw_data_len); + goto cleanup; } + strncpy(json_str, (char *)data.raw_data.bytes, data.raw_data_len); pthread_mutex_lock(&step->s_lock); + is_mutex_locked = true; step->u.wifi_stats_get->get_stats_count++; if (get_current_time_string(timestamp, sizeof(timestamp)) != RETURN_OK) { wlan_emu_print(wlan_emu_log_level_err, "%s:%d: get_current_time_string failed\n", __func__, __LINE__); - free((void *)json_str); - return; + goto cleanup; } snprintf(file_name, sizeof(file_name), "%s/%s_%d_%s_%s_%d.json", @@ -277,25 +290,41 @@ void test_step_param_get_stats_t::stats_get_event_handler(char *event_name, raw_ file_name); step->m_ui_mgr->cci_error_code = EFOPEN; step->test_state = wlan_emu_tests_state_cmd_abort; - pthread_mutex_unlock(&step->s_lock); - free((void *)json_str); - return; + goto cleanup; } - fputs((const char *)json_str, fp); + fputs(json_str, fp); fclose(fp); - temp_file_name = strdup(file_name); - if (step->m_ui_mgr->step_upload_files(temp_file_name) != RETURN_OK) { + fp = NULL; + + if (step->m_ui_mgr->step_upload_files(file_name) != RETURN_OK) { wlan_emu_print(wlan_emu_log_level_err, "%s:%d: step_upload_files failed for %s\n", - __func__, __LINE__, temp_file_name); + __func__, __LINE__, file_name); step->test_state = wlan_emu_tests_state_cmd_abort; step->m_ui_mgr->cci_error_code = EPUSHTSTRESFILE; - free((void *)json_str); + goto cleanup; + } + +cleanup: + if (fp != NULL) { + fclose(fp); + } + + if (is_mutex_locked) { pthread_mutex_unlock(&step->s_lock); - return; } - pthread_mutex_unlock(&step->s_lock); + delete[] json_str; + + if (data.raw_data.bytes != NULL) { + if (step->m_bus_mgr->desc.bus_data_free_fn != NULL) { + step->m_bus_mgr->desc.bus_data_free_fn(&data); + } else if (data.data_type == bus_data_type_string || data.data_type == bus_data_type_bytes) { + free(data.raw_data.bytes); + } + } + + return; } int test_step_param_get_stats_t::start_subscription() diff --git a/src/ui/wlan_emu_ui_mgr.cpp b/src/ui/wlan_emu_ui_mgr.cpp index 2a614eb..e47ea5c 100644 --- a/src/ui/wlan_emu_ui_mgr.cpp +++ b/src/ui/wlan_emu_ui_mgr.cpp @@ -29,6 +29,7 @@ #include #include #include +#include #include "wlan_emu_bus.h" #include #include @@ -4852,7 +4853,7 @@ void wlan_emu_ui_mgr_t::cci_cache_update(webconfig_subdoc_data_t *data) } } -void wlan_emu_ui_mgr_t::set_webconfig_cci_data(char *event_name, raw_data_t *bus_data, +void wlan_emu_ui_mgr_t::set_webconfig_cci_data(char *event_name, bus_data_prop_t *bus_data, void *userData) { (void)userData; @@ -4864,15 +4865,22 @@ void wlan_emu_ui_mgr_t::set_webconfig_cci_data(char *event_name, raw_data_t *bus wlan_emu_print(wlan_emu_log_level_dbg, "%s: %d bus event callback Event is %s \n", __func__, __LINE__, event_name); + if (bus_data == NULL || bus_data->value.data_type != bus_data_type_string || + bus_data->value.raw_data.bytes == NULL) { + wlan_emu_print(wlan_emu_log_level_err, "%s:%d invalid bus event payload for %s\n", + __func__, __LINE__, event_name); + return; + } + ptr = static_cast(userData); - pTmp = new char[bus_data->raw_data_len + 1](); + pTmp = new (std::nothrow) char[bus_data->value.raw_data_len + 1](); if (pTmp == NULL) { - wlan_emu_print(wlan_emu_log_level_err, "%s:%d: malloc failed\n", __func__, __LINE__); + wlan_emu_print(wlan_emu_log_level_err, "%s:%d: memory allocation failed\n", __func__, __LINE__); return; } - len = bus_data->raw_data_len; - copy_string(pTmp, (char *)bus_data->raw_data.bytes, bus_data->raw_data_len); + len = bus_data->value.raw_data_len; + copy_string(pTmp, (char *)bus_data->value.raw_data.bytes, bus_data->value.raw_data_len); // setup the raw data data = (webconfig_subdoc_data_t *)malloc(sizeof(webconfig_subdoc_data_t)); @@ -4880,6 +4888,7 @@ void wlan_emu_ui_mgr_t::set_webconfig_cci_data(char *event_name, raw_data_t *bus if (data == NULL) { wlan_emu_print(wlan_emu_log_level_err, "%s %d Failed to allocate memory\n", __func__, __LINE__); + delete[] pTmp; return; } memset(data, 0, sizeof(webconfig_subdoc_data_t));