net: openthread: rpc: update SRP client's RPC client side

This commit updates previously implemented functions and adds new ones.

Signed-off-by: Konrad Derda <[email protected]>

Author: kderda

subsys/net/openthread/rpc/client/ot_rpc_srp_client.c

@@ -26,6 +26,7 @@ static otSrpClientAutoStartCallback auto_start_cb;
 static void *auto_start_ctx;
 static otSrpClientCallback client_cb;
 static void *client_ctx;
+static otSockAddr decoded_server_sockaddr;
 
 static void clear_host(void)
 {
@@ -74,22 +75,109 @@ static void calc_txt_space(const otDnsTxtEntry *txt, uint8_t num, size_t *out_cb
 	*out_cbor_size = cbor_size;
 }
 
+const char *otSrpClientItemStateToString(otSrpClientItemState state)
+{
+	switch (state) {
+	case OT_SRP_CLIENT_ITEM_STATE_TO_ADD:
+		return "ToAdd";
+	case OT_SRP_CLIENT_ITEM_STATE_ADDING:
+		return "Adding";
+	case OT_SRP_CLIENT_ITEM_STATE_TO_REFRESH:
+		return "ToRefresh";
+	case OT_SRP_CLIENT_ITEM_STATE_REFRESHING:
+		return "Refreshing";
+	case OT_SRP_CLIENT_ITEM_STATE_TO_REMOVE:
+		return "ToRemove";
+	case OT_SRP_CLIENT_ITEM_STATE_REMOVING:
+		return "Removing";
+	case OT_SRP_CLIENT_ITEM_STATE_REGISTERED:
+		return "Registered";
+	case OT_SRP_CLIENT_ITEM_STATE_REMOVED:
+		return "Removed";
+	};
+
+	return "Unknown";
+}
+
+otError otSrpClientStart(otInstance *aInstance, const otSockAddr *aServerSockAddr)
+{
+	otError error;
+	struct nrf_rpc_cbor_ctx ctx;
+
+	ARG_UNUSED(aInstance);
+
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, OT_IP6_ADDRESS_SIZE + sizeof(uint16_t) + 2);
+
+	ot_rpc_encode_sockaddr(&ctx, aServerSockAddr);
+
+	nrf_rpc_cbor_cmd_no_err(&ot_group, OT_RPC_CMD_SRP_CLIENT_START, &ctx,
+				ot_rpc_decode_error, &error);
+
+	return error;
+}
+
+void otSrpClientStop(otInstance *aInstance)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+
+	ARG_UNUSED(aInstance);
+
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, 0);
+
+	nrf_rpc_cbor_cmd_no_err(&ot_group, OT_RPC_CMD_SRP_CLIENT_STOP, &ctx,
+				nrf_rpc_rsp_decode_void, NULL);
+}
+
+bool otSrpClientIsRunning(otInstance *aInstance)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+	bool running;
+
+	ARG_UNUSED(aInstance);
+
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, 0);
+
+	nrf_rpc_cbor_cmd_no_err(&ot_group, OT_RPC_CMD_SRP_CLIENT_IS_RUNNING, &ctx,
+				nrf_rpc_rsp_decode_bool, &running);
+
+	return running;
+}
+
+const otSockAddr *otSrpClientGetServerAddress(otInstance *aInstance)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+
+	ARG_UNUSED(aInstance);
+
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, 0);
+
+	nrf_rpc_cbor_cmd_rsp_no_err(&ot_group, OT_RPC_CMD_SRP_CLIENT_GET_SERVER_ADDRESS, &ctx);
+
+	ot_rpc_decode_sockaddr(&ctx, &decoded_server_sockaddr);
+
+	nrf_rpc_cbor_decoding_done(&ot_group, &ctx);
+
+	return &decoded_server_sockaddr;
+}
+
 otError otSrpClientAddService(otInstance *aInstance, otSrpClientService *aService)
 {
 	struct nrf_rpc_cbor_ctx ctx;
 	size_t num_subtypes;
 	size_t subtypes_size;
 	size_t txt_size;
 	size_t cbor_buffer_size;
+	size_t name_len = strlen(aService->mName);
+	size_t instance_len = strlen(aService->mInstanceName);
 	otError error;
 
 	ARG_UNUSED(aInstance);
 	calc_subtypes_space(aService->mSubTypeLabels, &num_subtypes, &subtypes_size);
 	calc_txt_space(aService->mTxtEntries, aService->mNumTxtEntries, &txt_size);
 
 	cbor_buffer_size = 1 + sizeof(uintptr_t); /* Service pointer */
-	cbor_buffer_size += 2 + strlen(aService->mName);
-	cbor_buffer_size += 2 + strlen(aService->mInstanceName);
+	cbor_buffer_size += 2 + name_len;
+	cbor_buffer_size += 2 + instance_len;
 	cbor_buffer_size += 1 + subtypes_size; /* Array of service subtypes */
 	cbor_buffer_size += 1 + txt_size;      /* Map of TXT entries */
 	cbor_buffer_size += 1 + sizeof(aService->mPort);
@@ -100,8 +188,15 @@ otError otSrpClientAddService(otInstance *aInstance, otSrpClientService *aServic
 
 	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, cbor_buffer_size);
 	nrf_rpc_encode_uint(&ctx, (uintptr_t)aService);
-	nrf_rpc_encode_str(&ctx, aService->mName, -1);
-	nrf_rpc_encode_str(&ctx, aService->mInstanceName, -1);
+	nrf_rpc_encode_uint(&ctx, num_subtypes);
+	nrf_rpc_encode_uint(&ctx, aService->mNumTxtEntries);
+	nrf_rpc_encode_uint(&ctx, name_len + instance_len + 2);
+	nrf_rpc_encode_uint(&ctx, subtypes_size);
+	nrf_rpc_encode_uint(&ctx, txt_size);
+
+	nrf_rpc_encode_str(&ctx, aService->mName, name_len);
+	nrf_rpc_encode_str(&ctx, aService->mInstanceName, instance_len);
+
 	zcbor_list_start_encode(ctx.zs, num_subtypes);
 
 	for (const char *const *subtype = aService->mSubTypeLabels; *subtype != NULL; ++subtype) {
@@ -207,6 +302,36 @@ otError otSrpClientEnableAutoHostAddress(otInstance *aInstance)
 	return error;
 }
 
+otError otSrpClientSetHostAddresses(otInstance *aInstance, const otIp6Address *aIp6Addresses,
+				    uint8_t aNumAddresses)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+	otError error;
+
+	ARG_UNUSED(aInstance);
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, 5 + aNumAddresses * (OT_IP6_ADDRESS_SIZE + 1));
+
+	nrf_rpc_encode_uint(&ctx, aNumAddresses);
+
+	zcbor_list_start_encode(ctx.zs, aNumAddresses);
+
+	for (int i = 0; i < aNumAddresses; ++i) {
+		nrf_rpc_encode_buffer(&ctx, &aIp6Addresses[i], OT_IP6_ADDRESS_SIZE);
+	}
+
+	zcbor_list_end_encode(ctx.zs, aNumAddresses);
+
+	nrf_rpc_cbor_cmd_no_err(&ot_group, OT_RPC_CMD_SRP_CLIENT_SET_HOST_ADDRESSES, &ctx,
+				ot_rpc_decode_error, &error);
+
+	if (error == OT_ERROR_NONE) {
+		host_info.mAutoAddress = false;
+	}
+
+	return error;
+}
+
+
 void otSrpClientEnableAutoStartMode(otInstance *aInstance, otSrpClientAutoStartCallback aCallback,
 				    void *aContext)
 {
@@ -293,6 +418,50 @@ otError otSrpClientSetHostName(otInstance *aInstance, const char *aName)
 	return error;
 }
 
+const otSrpClientService *otSrpClientGetServices(otInstance *aInstance)
+{
+	ARG_UNUSED(aInstance);
+
+	return services;
+}
+
+const otSrpClientHostInfo *otSrpClientGetHostInfo(otInstance *aInstance)
+{
+	ARG_UNUSED(aInstance);
+
+	return &host_info;
+}
+
+bool otSrpClientIsAutoStartModeEnabled(otInstance *aInstance)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+	bool enabled;
+
+	ARG_UNUSED(aInstance);
+
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, 0);
+
+	nrf_rpc_cbor_cmd_no_err(&ot_group, OT_RPC_CMD_SRP_CLIENT_IS_AUTO_START_MODE_ENABLED, &ctx,
+				nrf_rpc_rsp_decode_bool, &enabled);
+
+	return enabled;
+}
+
+uint32_t otSrpClientGetKeyLeaseInterval(otInstance *aInstance)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+	uint32_t key_lease_int;
+
+	ARG_UNUSED(aInstance);
+
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, 0);
+
+	nrf_rpc_cbor_cmd_no_err(&ot_group, OT_RPC_CMD_SRP_CLIENT_GET_KEY_LEASE_INTERVAL, &ctx,
+				nrf_rpc_rsp_decode_u32, &key_lease_int);
+
+	return key_lease_int;
+}
+
 void otSrpClientSetKeyLeaseInterval(otInstance *aInstance, uint32_t aInterval)
 {
 	struct nrf_rpc_cbor_ctx ctx;
@@ -305,6 +474,21 @@ void otSrpClientSetKeyLeaseInterval(otInstance *aInstance, uint32_t aInterval)
 				nrf_rpc_rsp_decode_void, NULL);
 }
 
+uint32_t otSrpClientGetLeaseInterval(otInstance *aInstance)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+	uint32_t lease_int;
+
+	ARG_UNUSED(aInstance);
+
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, 0);
+
+	nrf_rpc_cbor_cmd_no_err(&ot_group, OT_RPC_CMD_SRP_CLIENT_GET_LEASE_INTERVAL, &ctx,
+				nrf_rpc_rsp_decode_u32, &lease_int);
+
+	return lease_int;
+}
+
 void otSrpClientSetLeaseInterval(otInstance *aInstance, uint32_t aInterval)
 {
 	struct nrf_rpc_cbor_ctx ctx;
@@ -329,6 +513,21 @@ void otSrpClientSetTtl(otInstance *aInstance, uint32_t aTtl)
 				nrf_rpc_rsp_decode_void, NULL);
 }
 
+uint32_t otSrpClientGetTtl(otInstance *aInstance)
+{
+	struct nrf_rpc_cbor_ctx ctx;
+	uint32_t ttl;
+
+	ARG_UNUSED(aInstance);
+
+	NRF_RPC_CBOR_ALLOC(&ot_group, ctx, 0);
+
+	nrf_rpc_cbor_cmd_no_err(&ot_group, OT_RPC_CMD_SRP_CLIENT_GET_TTL, &ctx,
+				nrf_rpc_rsp_decode_u32, &ttl);
+
+	return ttl;
+}
+
 static void ot_rpc_cmd_srp_client_cb(const struct nrf_rpc_group *group,
 				     struct nrf_rpc_cbor_ctx *ctx, void *handler_data)
 {