feat(zigbee_ep): changed model and manufacturer to heap

Author: SuGlider

libraries/Zigbee/src/ZigbeeEP.cpp

@@ -19,8 +19,8 @@ ZigbeeEP::ZigbeeEP(uint8_t endpoint) {
   _ep_config.endpoint = 0;
   _cluster_list = nullptr;
   _on_identify = nullptr;
-  _read_model = nullptr;
-  _read_manufacturer = nullptr;  
+  _read_model[0] = '\0';
+  _read_manufacturer[0] = '\0';  
   _time_status = 0;
   if (!lock) {
     lock = xSemaphoreCreateBinary();
@@ -38,7 +38,7 @@ bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) {
   // Convert manufacturer to ZCL string
   size_t name_length = strlen(name);
   size_t model_length = strlen(model);
-  if (name_length > 32 || model_length > 32) {
+  if (name_length > ZB_MAX_NAME_LENGTH || model_length > ZB_MAX_NAME_LENGTH) {
     log_e("Manufacturer or model name is too long");
     return false;
   }
@@ -49,15 +49,8 @@ bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) {
     return false;
   }  
   // Allocate a new array of size length + 2 (1 for the length, 1 for null terminator)
-  char *zb_name = (char *) malloc(name_length + 2);
-  char *zb_model = (char *) malloc(model_length + 2);
-  if (zb_name == nullptr || zb_model == nullptr) {
-    log_e("Failed to allocate memory for name and model data");
-    // make sure any allocated memory is returned to heap
-    free(zb_name);
-    free(zb_model);
-    return false;
-  }
+  char zb_name[ZB_MAX_NAME_LENGTH + 2];
+  char zb_model[ZB_MAX_NAME_LENGTH + 2];
   // Store the length as the first element
   zb_name[0] = static_cast<char>(name_length);  // Cast size_t to char
   zb_model[0] = static_cast<char>(model_length);
@@ -76,8 +69,6 @@ bool ZigbeeEP::setManufacturerAndModel(const char *name, const char *model) {
   if (ret_model != ESP_OK) {
     log_e("Failed to set model: 0x%x: %s", ret_model, esp_err_to_name(ret_model));
   }
-  free(zb_model);
-  free(zb_name);
   return ret_name == ESP_OK && ret_model == ESP_OK;
 }
 
@@ -176,8 +167,7 @@ char *ZigbeeEP::readManufacturer(uint8_t endpoint, uint16_t short_addr, esp_zb_i
   read_req.attr_number = ZB_ARRAY_LENTH(attributes);
   read_req.attr_field = attributes;
 
-  free(_read_manufacturer);
-  _read_manufacturer = nullptr;
+  _read_manufacturer[0] = '\0';
 
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_zb_zcl_read_attr_cmd_req(&read_req);
@@ -212,8 +202,7 @@ char *ZigbeeEP::readModel(uint8_t endpoint, uint16_t short_addr, esp_zb_ieee_add
   read_req.attr_number = ZB_ARRAY_LENTH(attributes);
   read_req.attr_field = attributes;
 
-  free(_read_model);
-  _read_model = nullptr;
+  _read_model[0] = '\0';
 
   esp_zb_lock_acquire(portMAX_DELAY);
   esp_zb_zcl_read_attr_cmd_req(&read_req);
@@ -254,30 +243,16 @@ void ZigbeeEP::zbReadBasicCluster(const esp_zb_zcl_attribute_t *attribute) {
   /* Basic cluster attributes */
   if (attribute->id == ESP_ZB_ZCL_ATTR_BASIC_MANUFACTURER_NAME_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_CHAR_STRING && attribute->data.value) {
     zbstring_t *zbstr = (zbstring_t *)attribute->data.value;
-    char *zb_manufacturer = (char *)malloc(zbstr->len + 1);
-    if (zb_manufacturer == nullptr) {
-      log_e("Failed to allocate memory for manufacturer data");
-      xSemaphoreGive(lock);
-      return;
-    } 
-    memcpy(zb_manufacturer, zbstr->data, zbstr->len);
-    zb_manufacturer[zbstr->len] = '\0';
+    memcpy(_read_manufacturer, zbstr->data, zbstr->len);
+    _read_manufacturer[zbstr->len] = '\0';
     log_i("Peer Manufacturer is \"%s\"", zb_manufacturer);
-    _read_manufacturer = zb_manufacturer;
     xSemaphoreGive(lock);
   }
   if (attribute->id == ESP_ZB_ZCL_ATTR_BASIC_MODEL_IDENTIFIER_ID && attribute->data.type == ESP_ZB_ZCL_ATTR_TYPE_CHAR_STRING && attribute->data.value) {
     zbstring_t *zbstr = (zbstring_t *)attribute->data.value;
-    char *zb_model = (char *)malloc(zbstr->len + 1);
-    if (zb_model == nullptr) {
-      log_e("Failed to allocate memory for model data");
-      xSemaphoreGive(lock);
-      return;
-    } 
-    memcpy(zb_model, zbstr->data, zbstr->len);
-    zb_model[zbstr->len] = '\0';
+    memcpy(_read_model, zbstr->data, zbstr->len);
+    _read_model[zbstr->len] = '\0';
     log_i("Peer Model is \"%s\"", zb_model);
-    _read_model = zb_model;
     xSemaphoreGive(lock);
   }
 }