[RFC] tee-supplicant: add support for accessing custom REE service

libteec/CMakeLists.txt

@@ -24,6 +24,7 @@ set (CFG_TEE_CLIENT_LOG_FILE "/data/tee/teec.log" CACHE STRING "Location of libt
 set (SRC
 	src/tee_client_api.c
 	src/teec_trace.c
+	src/ree_service_api.c
 )
 
 if (CFG_TEE_BENCHMARK)

libteec/Makefile

@@ -18,7 +18,8 @@ LIB_MAJ_MIN	:= $(LIB_NAME).$(MAJOR_VERSION).$(MINOR_VERSION)
 LIB_MAJ_MIN_P	:= $(LIB_NAME).$(MAJOR_VERSION).$(MINOR_VERSION).$(PATCH_VERSION)
 
 TEEC_SRCS	:= tee_client_api.c \
-		   teec_trace.c
+		   teec_trace.c \
+		   ree_service_api.c
 ifeq ($(CFG_TEE_BENCHMARK),y)
 TEEC_SRCS	+= teec_benchmark.c
 endif

libteec/src/ree_service_api.c

@@ -0,0 +1,255 @@
+
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include <tee_client_api.h>
+#include <teec_trace.h>
+#include <ree_service_api.h>
+
+#ifndef __aligned
+#define __aligned(x) __attribute__((__aligned__(x)))
+#endif
+#include <linux/tee.h>
+
+struct service {
+	int msgqid;
+	void *buf;
+	size_t buf_sz;
+};
+
+static bool is_param_type_value(uint64_t param_type)
+{
+	if (param_type == TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INPUT ||
+			param_type == TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_OUTPUT ||
+			param_type == TEE_IOCTL_PARAM_ATTR_TYPE_VALUE_INOUT)
+		return true;
+	return false;
+}
+
+static bool is_param_type_memref(uint64_t param_type)
+{
+	if (param_type == TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INPUT ||
+			param_type == TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_OUTPUT ||
+			param_type == TEE_IOCTL_PARAM_ATTR_TYPE_MEMREF_INOUT)
+		return true;
+	return false;
+}
+
+/**
+ * uuid_to_str() - convert uuid structure to string
+ *
+ * Example uuid: 2aa2685c-fba3-44be-a218-fbdafebd639a
+ * Convert the structure to the string form as above
+ */
+TEEC_Result uuid_to_str(REEC_UUID *uuid, char *uuid_str, size_t size)
+{
+	uint32_t i, idx;
+
+	if (!uuid || !uuid_str)
+		return TEEC_ERROR_BAD_PARAMETERS;
+
+	/* Convert to the uuid string */
+	snprintf(uuid_str, size, "%08x-", uuid->timeLow);
+	idx = strlen(uuid_str);
+
+	snprintf(uuid_str + idx, size - idx, "%04x-", uuid->timeMid);
+	idx = strlen(uuid_str);
+
+	snprintf(uuid_str + idx, size - idx,
+				"%04x-", uuid->timeHiAndVersion);
+	idx = strlen(uuid_str);
+
+	snprintf(uuid_str + idx, size,
+				"%02x%02x-", uuid->clockSeqAndNode[0],
+				uuid->clockSeqAndNode[1]);
+	idx = strlen(uuid_str);
+
+	for (i = 2; i < 8; i++) {
+		snprintf(uuid_str + idx, size - idx,
+				"%02x", uuid->clockSeqAndNode[i]);
+		idx = strlen(uuid_str);
+	}
+
+	return TEEC_SUCCESS;
+}
+
+TEEC_Result ree_service_init(REEC_UUID *uuid, void **service)
+{
+	int ret = -1;
+	size_t size;
+	FILE *fp = NULL;
+	char filename[64];
+	key_t msgqkey = 0;
+	TEEC_Result result;
+	char uuid_str[48];
+
+	result = uuid_to_str(uuid, uuid_str, sizeof(uuid_str));
+	if (result != TEEC_SUCCESS)
+		return result;
+
+	struct service *s = malloc(sizeof(struct service));
+	if (!s)
+		return -ENOMEM;
+
+	/* Create a file in /data/<uuid> */
+	snprintf(filename, sizeof(filename), "/data/%s", uuid_str);
+	fp = fopen(filename, "w");
+	if (!fp) {
+		printf("Failed to create a file for token\n");
+		goto err;
+	}
+
+	size = fwrite(uuid_str, 1, strlen(uuid_str), fp);
+	if (size != strlen(uuid_str)) {
+		printf("Failed to write to %s\n", filename);
+		result = TEEC_ERROR_GENERIC;
+		goto err;
+	}
+
+	if (fclose(fp)) {
+		printf("Failed to commit data to storage\n");
+		result = TEEC_ERROR_GENERIC;
+		goto err;
+	}
+
+	/* Create a message queue and wait for the msg */
+	msgqkey = ftok(filename, 'O');
+	if (msgqkey == -1) {
+		printf("Failed to create a msg queue key (%d: %s)\n",
+							errno, strerror(errno));
+		result = TEEC_ERROR_GENERIC;
+		goto err;
+	}
+
+	s->msgqid = msgget(msgqkey, 0600 | IPC_CREAT);
+	if (s->msgqid == -1) {
+		printf("Failed to get the msg queue\n");
+		result = TEEC_ERROR_GENERIC;
+		goto err;
+	}
+
+	*service = s;
+
+	return 0;
+
+err:
+	if (s)
+		free(s);
+
+	return ret;
+}
+
+void ree_service_exit(void *service)
+{
+	struct service *s = service;
+
+	if (!s)
+		return;
+
+	if (s->msgqid != -1) {
+		if (msgctl(s->msgqid, IPC_RMID, NULL) == -1)
+			printf("Failed to delete msgq, try using ipcrm\n");
+	}
+
+	if (s->buf)
+		free(s->buf);
+
+	free(s);
+}
+
+TEEC_Result ree_rcv_params(void *service, size_t *num_params,
+					struct tee_params *params)
+{
+	int ret, idx = 0;
+	char *buf = NULL, *ptr;
+	struct service *s = service;
+	long msg_size[2] = {0};
+	size_t size, attr_sz, value_sz, mtype_sz = sizeof(long);
+
+	if (!s || !num_params || !params)
+		return TEEC_ERROR_BAD_PARAMETERS;
+
+	attr_sz = sizeof(params->attr);
+	value_sz = sizeof(params->u.value);
+
+	/* The first message will tell the size of buffer */
+	ret = msgrcv(s->msgqid, &msg_size,
+				sizeof(msg_size[1]), OPTEE_MRC_MSG_SEND, 0);
+	if (ret == -1) {
+		printf("Failed to get the size of buffer\n");
+		goto err;
+	}
+	size = msg_size[1];
+	s->buf_sz = size;
+
+	buf = calloc(size, 1);
+	if (!buf) {
+		printf("Out of memory to receive message\n");
+		goto err;
+	}
+
+	/* The second message will retrive full contents */
+	ret = msgrcv(s->msgqid, buf, size - mtype_sz, OPTEE_MRC_MSG_SEND, 0);
+	if (ret == -1) {
+		printf("Failed to receive msg\n");
+		goto err;
+	}
+
+	/* Real params start from here: buf + mtype_sz */
+	for (ptr = buf + mtype_sz; ptr < buf + size - sizeof(TEEC_Result);) {
+
+		if (is_param_type_value(*(long *)ptr)) {
+
+			memcpy(&params[idx].attr, ptr, attr_sz);
+			ptr += attr_sz;
+
+			memcpy(&params[idx].u.value, ptr, value_sz);
+			ptr += value_sz;
+
+		} else if (is_param_type_memref(*(long *)ptr)) {
+
+			memcpy(&params[idx].attr, ptr, attr_sz);
+			ptr += attr_sz;
+
+			params[idx].u.memref.size = *(size_t *)ptr;
+			params[idx].u.memref.buffer = ptr +
+					sizeof(params[idx].u.memref.size);
+			ptr = (char *)params[idx].u.memref.buffer +
+					params[idx].u.memref.size;
+		}
+		idx++;
+		if (idx == 4)
+			break;
+	}
+
+	s->buf = buf;
+	*num_params = idx;
+	return 0;
+
+err:
+	if (buf)
+		free(buf);
+	return TEEC_ERROR_GENERIC;
+}
+
+TEEC_Result ree_snd_params(void *service, size_t num_params,
+				struct tee_params *params, int32_t error)
+{
+	struct service *s = service;
+	size_t mtype_sz = sizeof(long);
+
+	(void)num_params;
+	(void)params;
+	(void)error;
+
+	*(TEEC_Result *)((uint8_t *)s->buf + s->buf_sz - sizeof(TEEC_Result)) = error;
+
+	*((long *)s->buf) = OPTEE_MRC_MSG_RCV;
+	if (msgsnd(s->msgqid, s->buf, s->buf_sz - mtype_sz, 0) == -1)
+		printf("Failed to send the response\n");
+
+	return 0;
+}

public/ree_service_api.h

@@ -0,0 +1,76 @@
+#ifndef __REE_SERVICE_H__
+#define __REE_SERVICE_H__
+
+/*
+ * Attributes for struct tee_ioctl_param, selects field in the union
+ */
+#define TEE_PARAM_ATTR_TYPE_NONE		0	/* parameter not used */
+
+/*
+ * These defines value parameters (struct tee_ioctl_param_value)
+ */
+#define TEE_PARAM_ATTR_TYPE_VALUE_INPUT	1
+#define TEE_PARAM_ATTR_TYPE_VALUE_OUTPUT	2
+#define TEE_PARAM_ATTR_TYPE_VALUE_INOUT	3	/* input and output */
+
+/*
+ * These defines shared memory reference parameters (struct
+ * tee_ioctl_param_memref)
+ */
+#define TEE_PARAM_ATTR_TYPE_MEMREF_INPUT	5
+#define TEE_PARAM_ATTR_TYPE_MEMREF_OUTPUT	6
+#define TEE_PARAM_ATTR_TYPE_MEMREF_INOUT	7	/* input and output */
+struct tee_param_memref {
+	void *buffer;
+	uint64_t size;
+};
+
+struct tee_param_value {
+	uint64_t a;
+	uint64_t b;
+	uint64_t c;
+};
+
+struct tee_params {
+	uint64_t attr;
+	union {
+		struct tee_param_memref memref;
+		struct tee_param_value value;
+	} u;
+};
+
+TEEC_Result uuid_to_str(REEC_UUID *uuid, char *uuid_str, size_t size);
+TEEC_Result ree_service_init(REEC_UUID *uuid, void **service);
+void ree_service_exit(void *service);
+TEEC_Result ree_rcv_params(void *service, size_t *num_params,
+					struct tee_params *params);
+TEEC_Result ree_snd_params(void *service, size_t num_params,
+				struct tee_params *params, int32_t error);
+
+/*
+ * Define protocol for messages with .cmd == OPTEE_MSG_RPC_CMD_GENERIC
+ */
+
+/*
+ * Open REE Service
+ *
+ * [in]     param[0].u.value.a  OPTEE_MRC_GENERIC_OPEN
+ * [in]     param[0].u.value.b  TA instance id
+ * [out]    param[1].u.value.c  service handle
+ */
+#define OPTEE_MRC_GENERIC_SERVICE_START		3
+
+/*
+ * Close REE Service
+ *
+ * [in]     param[0].u.value.a  OPTEE_MRC_GENERIC_CLOSE
+ * [in]     param[0].u.value.b  TA instance id
+ */
+#define OPTEE_MRC_GENERIC_SERVICE_STOP		4
+
+/* mtype for message queue message exchange */
+#define OPTEE_MRC_MSG_SEND		1 /* send params to service */
+#define OPTEE_MRC_MSG_RCV		2 /* receive params from service */
+
+
+#endif

public/tee_client_api.h

@@ -270,6 +270,8 @@ typedef struct {
 	uint8_t clockSeqAndNode[8];
 } TEEC_UUID;
 
+typedef TEEC_UUID REEC_UUID;
+
 /**
  * struct TEEC_SharedMemory - Memory to transfer data between a client
  * application and trusted code.

tee-supplicant/CMakeLists.txt

@@ -26,6 +26,8 @@ set (SRC
 	src/tee_supp_fs.c
 	src/tee_supplicant.c
 	src/teec_ta_load.c
+	src/tee_service.c
+	src/tee_service_handle.c
 )
 
 if (CFG_GP_SOCKETS)
@@ -86,6 +88,7 @@ target_include_directories(${PROJECT_NAME} PRIVATE src)
 
 target_link_libraries (${PROJECT_NAME}
 	PRIVATE teec
+	PRIVATE dl
 	PRIVATE optee-client-headers)
 
 ################################################################################

tee-supplicant/Makefile

@@ -18,7 +18,9 @@ TEES_SRCS	:= tee_supplicant.c \
 		   teec_ta_load.c \
 		   tee_supp_fs.c \
 		   rpmb.c \
-		   handle.c
+		   handle.c	\
+		   tee_service.c \
+		   tee_service_handle.c
 
 
 ifeq ($(CFG_GP_SOCKETS),y)
@@ -55,7 +57,7 @@ ifeq ($(CFG_TA_TEST_PATH),y)
 TEES_CFLAGS	+= -DCFG_TA_TEST_PATH=1
 endif
 TEES_FILE	:= $(OUT_DIR)/$(PACKAGE_NAME)
-TEES_LFLAGS    := $(LDFLAGS) -L$(OUT_DIR)/../libteec -lteec
+TEES_LFLAGS    := $(LDFLAGS) -L$(OUT_DIR)/../libteec -lteec -ldl
 
 ifeq ($(CFG_TA_GPROF_SUPPORT),y)
 TEES_CFLAGS	+= -DCFG_TA_GPROF_SUPPORT