DAOS-18790 control: Support bytearray property values

src/common/prop.c

@@ -1,6 +1,6 @@
 /**
  * (C) Copyright 2019-2023 Intel Corporation.
- * (C) Copyright 2025 Hewlett Packard Enterprise Development LP
+ * (C) Copyright 2025-2026 Hewlett Packard Enterprise Development LP
  *
  * SPDX-License-Identifier: BSD-2-Clause-Patent
  */
@@ -77,6 +77,18 @@ daos_prop_has_ptr(struct daos_prop_entry *entry)
 	return false;
 }
 
+bool
+daos_prop_has_byteval(struct daos_prop_entry *entry)
+{
+	switch (entry->dpe_type) {
+	/*
+	 * e.g. DAOS_PROP_PO_POOL_CA (DAOS-18783)
+	 */
+	default:
+		return false;
+	}
+}
+
 static void
 daos_prop_entry_free_value(struct daos_prop_entry *entry)
 {
@@ -93,6 +105,16 @@ daos_prop_entry_free_value(struct daos_prop_entry *entry)
 		return;
 	}
 
+	if (daos_prop_has_byteval(entry)) {
+		struct daos_prop_byteval *bv = entry->dpe_val_ptr;
+
+		if (bv != NULL) {
+			D_FREE(bv->dpb_data);
+			D_FREE(entry->dpe_val_ptr);
+		}
+		return;
+	}
+
 	if (daos_prop_has_ptr(entry)) {
 		D_FREE(entry->dpe_val_ptr);
 		return;
@@ -592,6 +614,10 @@ daos_prop_entry_copy(struct daos_prop_entry *entry,
 
 	entry_dup->dpe_type = entry->dpe_type;
 	entry_dup->dpe_flags = entry->dpe_flags;
+
+	if (daos_prop_has_byteval(entry))
+		return daos_prop_entry_dup_byteval(entry_dup, entry);
+
 	switch (entry->dpe_type) {
 	case DAOS_PROP_PO_LABEL:
 	case DAOS_PROP_CO_LABEL:
@@ -751,6 +777,53 @@ daos_prop_set_ptr(daos_prop_t *prop, uint32_t type, const void *ptr, daos_size_t
 	return daos_prop_entry_set_ptr(entry, ptr, size);
 }
 
+int
+daos_prop_set_byteval(daos_prop_t *prop, uint32_t type, const void *data, size_t len)
+{
+	struct daos_prop_entry *entry;
+
+	entry = daos_prop_entry_get(prop, type);
+	if (entry == NULL)
+		return -DER_NONEXIST;
+
+	return daos_prop_entry_set_byteval(entry, data, len);
+}
+
+int
+daos_prop_entry_set_byteval(struct daos_prop_entry *entry, const void *data, size_t len)
+{
+	struct daos_prop_byteval *bv;
+
+	if (entry == NULL)
+		return -DER_INVAL;
+	if (!daos_prop_has_byteval(entry)) {
+		D_ERROR("Entry type %d does not expect a byteval\n", entry->dpe_type);
+		return -DER_INVAL;
+	}
+
+	if (entry->dpe_val_ptr != NULL) {
+		bv = entry->dpe_val_ptr;
+		D_FREE(bv->dpb_data);
+		D_FREE(entry->dpe_val_ptr);
+	}
+
+	if (data == NULL || len == 0)
+		return 0;
+
+	D_ALLOC_PTR(bv);
+	if (bv == NULL)
+		return -DER_NOMEM;
+	D_ALLOC(bv->dpb_data, len);
+	if (bv->dpb_data == NULL) {
+		D_FREE(bv);
+		return -DER_NOMEM;
+	}
+	memcpy(bv->dpb_data, data, len);
+	bv->dpb_len        = len;
+	entry->dpe_val_ptr = bv;
+	return 0;
+}
+
 int
 daos_prop_entry_set_ptr(struct daos_prop_entry *entry, const void *ptr, daos_size_t size)
 {
@@ -966,6 +1039,23 @@ daos_prop_entry_dup_ptr(struct daos_prop_entry *entry_dst,
 	return 0;
 }
 
+int
+daos_prop_entry_dup_byteval(struct daos_prop_entry *entry_dst, struct daos_prop_entry *entry_src)
+{
+	struct daos_prop_byteval *src_bv;
+
+	D_ASSERT(entry_src != NULL);
+	D_ASSERT(entry_dst != NULL);
+
+	src_bv = entry_src->dpe_val_ptr;
+	if (src_bv == NULL || src_bv->dpb_data == NULL || src_bv->dpb_len == 0) {
+		entry_dst->dpe_val_ptr = NULL;
+		return 0;
+	}
+
+	return daos_prop_entry_set_byteval(entry_dst, src_bv->dpb_data, src_bv->dpb_len);
+}
+
 int
 daos_prop_entry_cmp_acl(struct daos_prop_entry *entry1,
 			struct daos_prop_entry *entry2)

src/control/common/proto/mgmt/addons.go

@@ -1,13 +1,14 @@
 //
 // (C) Copyright 2019-2024 Intel Corporation.
-// (C) Copyright 2025 Hewlett Packard Enterprise Development LP
+// (C) Copyright 2025-2026 Hewlett Packard Enterprise Development LP
 //
 // SPDX-License-Identifier: BSD-2-Clause-Patent
 //
 
 package mgmt
 
 import (
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 
@@ -18,8 +19,9 @@ func (p *PoolProperty) UnmarshalJSON(b []byte) error {
 	type fromJSON PoolProperty
 	from := struct {
 		Value struct {
-			Strval string `json:"strval"`
-			Numval uint64 `json:"numval"`
+			Strval  string `json:"strval"`
+			Numval  uint64 `json:"numval"`
+			Byteval string `json:"byteval"`
 		}
 		*fromJSON
 	}{
@@ -30,7 +32,13 @@ func (p *PoolProperty) UnmarshalJSON(b []byte) error {
 		return err
 	}
 
-	if from.Value.Strval != "" {
+	if from.Value.Byteval != "" {
+		decoded, err := base64.StdEncoding.DecodeString(from.Value.Byteval)
+		if err != nil {
+			return err
+		}
+		p.SetValueBytes(decoded)
+	} else if from.Value.Strval != "" {
 		p.SetValueString(from.Value.Strval)
 	} else {
 		p.SetValueNumber(from.Value.Numval)
@@ -53,6 +61,13 @@ func (p *PoolProperty) SetValueNumber(numVal uint64) {
 	}
 }
 
+// SetValueBytes sets the Value field to a byte array.
+func (p *PoolProperty) SetValueBytes(byteVal []byte) {
+	p.Value = &PoolProperty_Byteval{
+		Byteval: byteVal,
+	}
+}
+
 // The following set of addons implements the poolServiceReq interface
 // in mgmt_pool.go.
 

src/control/common/proto/mgmt/addons_test.go

@@ -0,0 +1,67 @@
+//
+// (C) Copyright 2026 Hewlett Packard Enterprise Development LP
+//
+// SPDX-License-Identifier: BSD-2-Clause-Patent
+//
+
+package mgmt
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"google.golang.org/protobuf/testing/protocmp"
+)
+
+func TestPoolProperty_SetValueBytes(t *testing.T) {
+	p := &PoolProperty{Number: 1}
+	data := []byte("test-cert-data")
+
+	p.SetValueBytes(data)
+
+	got := p.GetByteval()
+	if diff := cmp.Diff(data, got); diff != "" {
+		t.Fatalf("unexpected byteval (-want, +got):\n%s\n", diff)
+	}
+}
+
+func TestPoolProperty_UnmarshalJSON(t *testing.T) {
+	for name, tc := range map[string]struct {
+		input string
+		exp   *PoolProperty
+	}{
+		"string value": {
+			input: `{"number": 1, "value": {"strval": "hello"}}`,
+			exp: &PoolProperty{
+				Number: 1,
+				Value:  &PoolProperty_Strval{Strval: "hello"},
+			},
+		},
+		"number value": {
+			input: `{"number": 2, "value": {"numval": 42}}`,
+			exp: &PoolProperty{
+				Number: 2,
+				Value:  &PoolProperty_Numval{Numval: 42},
+			},
+		},
+		"byte value": {
+			// "dGVzdC1jZXJ0LWRhdGE=" is base64 for "test-cert-data"
+			input: `{"number": 3, "value": {"byteval": "dGVzdC1jZXJ0LWRhdGE="}}`,
+			exp: &PoolProperty{
+				Number: 3,
+				Value:  &PoolProperty_Byteval{Byteval: []byte("test-cert-data")},
+			},
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			got := &PoolProperty{}
+			if err := json.Unmarshal([]byte(tc.input), got); err != nil {
+				t.Fatalf("unexpected error: %s", err)
+			}
+			if diff := cmp.Diff(tc.exp, got, protocmp.Transform()); diff != "" {
+				t.Fatalf("unexpected result (-want, +got):\n%s\n", diff)
+			}
+		})
+	}
+}