summaryrefslogtreecommitdiff
path: root/client
diff options
context:
space:
mode:
Diffstat (limited to 'client')
-rw-r--r--client/include/ss_client_intf.h68
-rw-r--r--client/include/ss_client_ipc.h32
-rw-r--r--client/src/ss_client_intf.c417
-rw-r--r--client/src/ss_client_ipc.c105
-rw-r--r--client/src/ss_manager.c214
5 files changed, 836 insertions, 0 deletions
diff --git a/client/include/ss_client_intf.h b/client/include/ss_client_intf.h
new file mode 100644
index 0000000..49255ea
--- /dev/null
+++ b/client/include/ss_client_intf.h
@@ -0,0 +1,68 @@
+/*
+ * secure storage
+ *
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Contact: Kidong Kim <kd0228.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __SS_MANAGER__
+#include "ss_manager.h"
+#endif
+
+/*
+ * Declare new function
+ *
+ * @name: SsClientDataStore
+ * @parameter
+ * - filepath: [in]
+ * - flag: [in]
+ * @return type: int
+ * - 1: success
+ * - <1: error
+ */
+int SsClientDataStoreFromFile(const char* filepath, ssm_flag flag, const char* group_id);
+int SsClientDataStoreFromBuffer(char* writebuffer, size_t bufLen, const char* filename, ssm_flag flag, const char* group_id);
+
+/*
+ * Declare new function
+ *
+ * @name: SsClientDataRead
+ * @parameter
+ * - filepath: [in]
+ * - pRetBuf: [out]
+ * - bufLen: [in]
+ * - readLen: [out]
+ * @return type: int
+ * - 1: success
+ * - <1: error
+ */
+int SsClientDataRead(const char* filepath, char* pRetBuf, size_t bufLen, size_t *readLen, ssm_flag flag, const char* group_id);
+
+/*
+ * Declare new function
+ *
+ * @name: SsClientGetInfo
+ * @parameter
+ * - filepath: [in]
+ * - sfi: [out]
+ * @return type: int
+ * - 1: success
+ * - <1: error
+ */
+int SsClientGetInfo(const char* filepath, ssm_file_info_t* sfi, ssm_flag flag, const char* group_id);
+
+int SsClientDeleteFile(const char* pFilePath, ssm_flag flag, const char* group_id);
diff --git a/client/include/ss_client_ipc.h b/client/include/ss_client_ipc.h
new file mode 100644
index 0000000..036d49b
--- /dev/null
+++ b/client/include/ss_client_ipc.h
@@ -0,0 +1,32 @@
+/*
+ * secure storage
+ *
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Contact: Kidong Kim <kd0228.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/*
+ * Declare new function
+ *
+ * @name: SsClientComm
+ * @parameter: client_data
+ * @return type: RspData_t
+ */
+
+#include "secure_storage.h"
+
+RspData_t SsClientComm(ReqData_t* client_data);
diff --git a/client/src/ss_client_intf.c b/client/src/ss_client_intf.c
new file mode 100644
index 0000000..27a2282
--- /dev/null
+++ b/client/src/ss_client_intf.c
@@ -0,0 +1,417 @@
+/*
+ * secure storage
+ *
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Contact: Kidong Kim <kd0228.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "secure_storage.h"
+#include "ss_client_intf.h"
+#include "ss_client_ipc.h"
+#include "ss_manager.h"
+
+#include "security-server.h"
+
+int SsClientDataStoreFromFile(const char* filepath, ssm_flag flag, const char* group_id)
+{
+ ReqData_t* send_data = NULL;
+ RspData_t recv_data;
+ int temp_len = 0;
+ int cookie_size;
+
+ cookie_size = security_server_get_cookie_size();
+ char cookie_content[cookie_size];
+
+ if(security_server_request_cookie(cookie_content, cookie_size) < 0) // error while getting cookie
+ {
+ SLOGE("[%s] Fail to get cookie\n", __func__);
+ recv_data.rsp_type = SS_SECURE_STORAGE_ERROR;
+ goto Error;
+ }
+
+ if(!filepath)
+ {
+ SLOGE( "[%s] Parameter error in SsClientDataStoreFromFile..\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ send_data = (ReqData_t*)malloc(sizeof(ReqData_t));
+
+ if(!send_data)
+ {
+ SLOGE( "[%s] Memory allocation fail in SsClientDataStoreFromFile..\n", __func__);
+ recv_data.rsp_type = SS_MEMORY_ERROR;
+ goto Error;
+ }
+
+ send_data->req_type = 1; // file store
+ send_data->enc_type = 1; // initial type
+ send_data->count = 0;
+ send_data->flag = flag; // flag
+ temp_len = strlen(filepath);
+ if(temp_len < MAX_FILENAME_LEN)
+ {
+ strncpy(send_data->data_infilepath, filepath, MAX_FILENAME_LEN - 1);
+ send_data->data_infilepath[temp_len] = '\0';
+ }
+ else
+ {
+ SLOGE("[%s] filepath is too long.\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Free_and_Error;
+ }
+ memset(send_data->cookie, 0x00, MAX_COOKIE_LEN);
+ memset(send_data->group_id, 0x00, MAX_GROUP_ID_LEN);
+ memcpy(send_data->cookie, cookie_content, cookie_size);
+ if(group_id)
+ strncpy(send_data->group_id, group_id, MAX_GROUP_ID_LEN - 1);
+ else
+ strncpy(send_data->group_id, "NOTUSED", MAX_GROUP_ID_LEN - 1);
+
+ memset(send_data->buffer, 0x00, MAX_SEND_DATA_LEN + 1);
+ recv_data = SsClientComm(send_data);
+
+Free_and_Error:
+ free(send_data);
+Error:
+ return recv_data.rsp_type;
+}
+
+int SsClientDataStoreFromBuffer(char* writebuffer, size_t bufLen, const char* filename, ssm_flag flag, const char* group_id)
+{
+ ReqData_t* send_data = NULL;
+ RspData_t recv_data;
+ int temp_len = 0;
+ int cookie_size;
+
+ cookie_size = security_server_get_cookie_size();
+ char cookie_content[cookie_size];
+
+ if(security_server_request_cookie(cookie_content, cookie_size) < 0) // error while getting cookie
+ {
+ SLOGE("[%s] Fail to get cookie\n", __func__);
+ recv_data.rsp_type = SS_SECURE_STORAGE_ERROR;
+ goto Error;
+ }
+
+ if(!writebuffer || !filename)
+ {
+ SLOGE("[%s] Parameter error in SsClientDataStoreFromBuffer..\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ send_data = (ReqData_t*)malloc(sizeof(ReqData_t));
+ if(!send_data)
+ {
+ SLOGE("[%s] Memory allocation fail in SsClientDataStoreFromBuffer..\n", __func__);
+ recv_data.rsp_type = SS_MEMORY_ERROR;
+ goto Error;
+ }
+
+ send_data->req_type = 2; // buffer store
+ send_data->enc_type = 1;
+ send_data->count = bufLen;
+ send_data->flag = flag;
+ temp_len = strlen(filename);
+ if(temp_len < MAX_FILENAME_LEN)
+ {
+ strncpy(send_data->data_infilepath, filename, MAX_FILENAME_LEN - 1);
+ send_data->data_infilepath[temp_len] = '\0';
+ }
+ else
+ {
+ SLOGE("[%s] filepath is too long.\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Free_and_Error;
+ }
+ memset(send_data->cookie, 0x00, MAX_COOKIE_LEN);
+ memset(send_data->group_id, 0x00, MAX_GROUP_ID_LEN);
+ memcpy(send_data->cookie, cookie_content, cookie_size);
+ if(group_id)
+ strncpy(send_data->group_id, group_id, MAX_GROUP_ID_LEN - 1);
+ else
+ strncpy(send_data->group_id, "NOTUSED", MAX_GROUP_ID_LEN - 1);
+
+ memcpy(send_data->buffer, writebuffer, bufLen);
+ recv_data = SsClientComm(send_data);
+
+Free_and_Error:
+ free(send_data);
+Error:
+ return recv_data.rsp_type;
+}
+
+int SsClientDataRead(const char* filepath, char* pRetBuf, size_t bufLen, size_t *readLen, ssm_flag flag, const char* group_id)
+{
+ unsigned int count = (unsigned int)(bufLen / MAX_RECV_DATA_LEN + 1);
+ unsigned int rest = (unsigned int)(bufLen % MAX_RECV_DATA_LEN);
+ char* buffer;
+ ReqData_t* send_data = NULL;
+ RspData_t recv_data;
+ int temp_len = 0;
+ int cookie_size;
+
+ cookie_size = security_server_get_cookie_size();
+ char cookie_content[cookie_size];
+
+ if(security_server_request_cookie(cookie_content, cookie_size) < 0) // error while getting cookie
+ {
+ SLOGE("[%s] Fail to get cookie\n", __func__);
+ recv_data.rsp_type = SS_SECURE_STORAGE_ERROR;
+ goto Error;
+ }
+
+ if(!filepath)
+ {
+ SLOGE("[%s] filepath Parameter error in SsClientDataRead..\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Error;
+ }
+ if(!readLen)
+ {
+ SLOGE("[%s] readLen Parameter error in SsClientDataRead..\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ *readLen = 0;
+ buffer = pRetBuf;
+
+ send_data = (ReqData_t*)malloc(sizeof(ReqData_t));
+
+ if(!send_data)
+ {
+ SLOGE("[%s] Memory allocation fail in SsClientDataRead..\n", __func__);
+ recv_data.rsp_type = SS_MEMORY_ERROR;
+ goto Error;
+ }
+
+ // fill send_data
+ send_data->req_type = 3; // read data from storage
+ send_data->enc_type = 1; // initial type
+ send_data->count = 0;
+ send_data->flag = flag & 0x000000ff; //flag;
+ temp_len = strlen(filepath);
+ if(temp_len < MAX_FILENAME_LEN)
+ {
+ strncpy(send_data->data_infilepath, filepath, MAX_FILENAME_LEN - 1);
+ send_data->data_infilepath[temp_len] = '\0';
+ }
+ else
+ {
+ SLOGE("[%s] filepath is too long.\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Free_and_Error;
+ }
+ memset(send_data->cookie, 0x00, MAX_COOKIE_LEN);
+ memset(send_data->group_id, 0x00, MAX_GROUP_ID_LEN);
+ memcpy(send_data->cookie, cookie_content, MAX_COOKIE_LEN);
+ if(group_id)
+ strncpy(send_data->group_id, group_id, MAX_GROUP_ID_LEN - 1);
+ else
+ strncpy(send_data->group_id, "NOTUSED", MAX_GROUP_ID_LEN - 1);
+ memset(send_data->buffer, 0x00, MAX_SEND_DATA_LEN+1);
+
+ // Call Server per 4KB data (count from 0 to ~)
+ for ( ; send_data->count < count; send_data->count++)
+ {
+ //receive data from server
+ recv_data = SsClientComm(send_data);
+
+ // check response type
+ if(recv_data.rsp_type != 1)
+ {
+ SLOGE("[%s] data read error from server...\n", __func__);
+ goto Free_and_Error;
+ }
+ // copy the last data (last count)
+ if(send_data->count == (count - 1))
+ {
+ memcpy(buffer, recv_data.buffer, rest);
+ *readLen += (size_t)rest;
+ goto Last;
+ //break;
+ }
+
+ memcpy(buffer, recv_data.buffer, MAX_RECV_DATA_LEN);
+ *readLen += (size_t)recv_data.readLen;
+ buffer += recv_data.readLen;
+ }
+Last :
+ if(bufLen != *readLen)
+ {
+ SLOGE( "[%s] Decrypted abnormally\n", __func__);
+ recv_data.rsp_type = SS_DECRYPTION_ERROR;
+ goto Free_and_Error;
+ }
+
+ SLOGE("[%s] Decrypted file name : %s\n", __func__, recv_data.data_filepath);
+Free_and_Error:
+ free(send_data);
+Error:
+ return recv_data.rsp_type;
+}
+
+int SsClientGetInfo(const char* filepath, ssm_file_info_t* sfi, ssm_flag flag, const char* group_id)
+{
+
+ ReqData_t* send_data = NULL;
+ RspData_t recv_data;
+ ssm_file_info_convert_t sfic;
+ int temp_len = 0;
+ int cookie_size;
+
+ cookie_size = security_server_get_cookie_size();
+ char cookie_content[cookie_size];
+
+ if(security_server_request_cookie(cookie_content, cookie_size) < 0) // error while getting cookie
+ {
+ SLOGE("[%s] Fail to get cookie\n", __func__);
+ recv_data.rsp_type = SS_SECURE_STORAGE_ERROR;
+ goto Error;
+ }
+
+ if(!filepath || !sfi)
+ {
+ SLOGE("[%s] Parameter error in SsClientGetInfo..\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ send_data = (ReqData_t*)malloc(sizeof(ReqData_t));
+
+ if(!send_data)
+ {
+ SLOGE("[%s] Memory allocation fail in SsClientGetInfo..\n", __func__);
+ recv_data.rsp_type = SS_MEMORY_ERROR;
+ goto Error;
+ }
+
+ // fill send_data
+ send_data->req_type = 4; // get info type
+ send_data->enc_type = 1; // initial type
+ send_data->count = 0;
+ send_data->flag = flag & 0x000000ff; //flag;
+ temp_len = strlen(filepath);
+ if(temp_len < MAX_FILENAME_LEN)
+ {
+ strncpy(send_data->data_infilepath, filepath, MAX_FILENAME_LEN - 1);
+ send_data->data_infilepath[temp_len] = '\0';
+ }
+ else
+ {
+ SLOGE("[%s] filepath is too long.\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Free_and_Error;
+ }
+ memset(send_data->cookie, 0x00, MAX_COOKIE_LEN);
+ memset(send_data->group_id, 0x00, MAX_GROUP_ID_LEN);
+ memcpy(send_data->cookie, cookie_content, cookie_size);
+ if(group_id)
+ strncpy(send_data->group_id, group_id, MAX_GROUP_ID_LEN - 1);
+ else
+ strncpy(send_data->group_id, "NOTUSED", MAX_GROUP_ID_LEN - 1);
+ memset(send_data->buffer, 0x00, MAX_SEND_DATA_LEN + 1);
+
+ recv_data = SsClientComm(send_data);
+
+ memcpy(sfic.fInfoArray, recv_data.buffer, sizeof(ssm_file_info_t));
+ sfi->originSize = sfic.fInfoStruct.originSize;
+ sfi->storedSize = sfic.fInfoStruct.storedSize;
+ memcpy(sfi->reserved, sfic.fInfoStruct.reserved, 8);
+
+Free_and_Error:
+ free(send_data);
+Error:
+ return recv_data.rsp_type;
+}
+
+int SsClientDeleteFile(const char *pFilePath, ssm_flag flag, const char* group_id)
+{
+ ReqData_t* send_data = NULL;
+ RspData_t recv_data;
+ int temp_len = 0;
+ int cookie_size;
+
+ cookie_size = security_server_get_cookie_size();
+ char cookie_content[cookie_size];
+
+ if(security_server_request_cookie(cookie_content, cookie_size) < 0) // error while getting cookie
+ {
+ SLOGE("[%s] Fail to get cookie\n", __func__);
+ recv_data.rsp_type = SS_SECURE_STORAGE_ERROR;
+ goto Error;
+ }
+
+ if(!pFilePath)
+ {
+ SLOGE("[%s] Parameter error in SsClientDeleteFile..\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ send_data = (ReqData_t*)malloc(sizeof(ReqData_t));
+
+ if(!send_data)
+ {
+ SLOGE("[%s] Memory allocation fail in SsClientDeleteFile..\n", __func__);
+ recv_data.rsp_type = SS_MEMORY_ERROR;
+ goto Error;
+ }
+
+ send_data->req_type = 10; // delete file
+ send_data->enc_type = 1; // initial type
+ send_data->count = 0;
+ send_data->flag = flag; // flag
+ temp_len = strlen(pFilePath);
+ if(temp_len < MAX_FILENAME_LEN)
+ {
+ strncpy(send_data->data_infilepath, pFilePath, MAX_FILENAME_LEN - 1);
+ send_data->data_infilepath[temp_len] = '\0';
+ }
+ else
+ {
+ SLOGE("[%s] filepath is too long.\n", __func__);
+ recv_data.rsp_type = SS_PARAM_ERROR;
+ goto Free_and_Error;
+ }
+ memset(send_data->cookie, 0x00, MAX_COOKIE_LEN);
+ memset(send_data->group_id, 0x00, MAX_GROUP_ID_LEN);
+ memcpy(send_data->cookie, cookie_content, cookie_size);
+ if(group_id)
+ strncpy(send_data->group_id, group_id, MAX_GROUP_ID_LEN - 1);
+ else
+ strncpy(send_data->group_id, "NOTUSED", MAX_GROUP_ID_LEN - 1);
+ memset(send_data->buffer, 0x00, MAX_SEND_DATA_LEN+1);
+
+ recv_data = SsClientComm(send_data);
+
+Free_and_Error:
+ free(send_data);
+
+ SLOGE("[%s] Deleted file name: %s\n", __func__, recv_data.data_filepath);
+
+Error:
+ return recv_data.rsp_type;
+}
diff --git a/client/src/ss_client_ipc.c b/client/src/ss_client_ipc.c
new file mode 100644
index 0000000..59899e2
--- /dev/null
+++ b/client/src/ss_client_ipc.c
@@ -0,0 +1,105 @@
+/*
+ * secure storage
+ *
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Contact: Kidong Kim <kd0228.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <errno.h>
+
+#include "ss_client_ipc.h"
+#include "secure_storage.h"
+
+#include "security-server.h"
+
+RspData_t SsClientComm(ReqData_t* client_data)
+{
+ int sockfd = 0;
+ int client_len = 0;
+ struct sockaddr_un clientaddr;
+ ReqData_t send_data = {0, };
+ RspData_t recv_data = {0, };
+ int temp_len_in = 0;
+ int temp_len_sock = 0;
+ int cookie_size = 0;
+
+ send_data.req_type = client_data->req_type;
+ send_data.enc_type = client_data->enc_type;
+ send_data.count = client_data->count;
+ send_data.flag = client_data->flag;
+
+ temp_len_in = strlen(client_data->data_infilepath);
+
+ strncpy(send_data.data_infilepath, client_data->data_infilepath, MAX_FILENAME_LEN - 1);
+ send_data.data_infilepath[temp_len_in] = '\0';
+
+ cookie_size = security_server_get_cookie_size();
+ memcpy(send_data.cookie, client_data->cookie, cookie_size);
+ strncpy(send_data.group_id, client_data->group_id, MAX_GROUP_ID_LEN - 1);
+
+ memcpy(send_data.buffer, client_data->buffer, MAX_SEND_DATA_LEN);
+
+ if((sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
+ {
+ SLOGE("[%s] Error in function socket()..\n", __func__);
+ recv_data.rsp_type = SS_SOCKET_ERROR; // ipc error
+ goto Error_exit;
+ }
+
+ temp_len_sock = strlen(SS_SOCK_PATH);
+
+ bzero(&clientaddr, sizeof(clientaddr));
+ clientaddr.sun_family = AF_UNIX;
+ strncpy(clientaddr.sun_path, SS_SOCK_PATH, temp_len_sock);
+ clientaddr.sun_path[temp_len_sock] = '\0';
+ client_len = sizeof(clientaddr);
+
+ if(connect(sockfd, (struct sockaddr*)&clientaddr, client_len) < 0)
+ {
+ SLOGE("[%s] Error in function connect()..\n", __func__);
+ recv_data.rsp_type = SS_SOCKET_ERROR; // ipc error
+ goto Error_close_exit;
+ }
+
+ if(write(sockfd, (char*)&send_data, sizeof(send_data)) < 0)
+ {
+ SLOGE("[%s] Error in function write()..\n", __func__);
+ recv_data.rsp_type = SS_SOCKET_ERROR; // ipc error
+ goto Error_close_exit;
+ }
+
+ if(read(sockfd, (char*)&recv_data, sizeof(recv_data)) < 0)
+ {
+ SLOGE("[%s] Error in function read()..\n", __func__);
+ recv_data.rsp_type = SS_SOCKET_ERROR; // ipc error
+ goto Error_close_exit;
+ }
+
+Error_close_exit:
+ close(sockfd);
+
+Error_exit:
+ return recv_data;
+}
diff --git a/client/src/ss_manager.c b/client/src/ss_manager.c
new file mode 100644
index 0000000..be8bc0f
--- /dev/null
+++ b/client/src/ss_manager.c
@@ -0,0 +1,214 @@
+/*
+ * secure storage
+ *
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Contact: Kidong Kim <kd0228.kim@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "secure_storage.h"
+#include "ss_client_intf.h"
+
+#ifndef SS_API
+#define SS_API __attribute__((visibility("default")))
+#endif
+
+/*****************************************************************************
+ * Internal Functions
+ *****************************************************************************/
+SS_API
+int ssm_getinfo(const char* pFilePath, ssm_file_info_t *sfi, ssm_flag flag, const char* group_id)
+{
+ int ret = 0;
+
+ if(!pFilePath || !sfi)
+ {
+ SLOGE("[%s] Parameter error in ssm_getinfo()..\n", __func__);
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ ret = SsClientGetInfo(pFilePath, sfi, flag, group_id);
+
+ if(ret == 1)
+ {
+ SLOGI("[%s] Getinfo Success.\n", __func__);
+ ret = 0; // return true
+ }
+ else
+ SLOGE("[%s] Getinfo Fail.\n", __func__);
+
+Error:
+ return -(ret);
+}
+
+/*****************************************************************************
+ * Manager APIs
+ *****************************************************************************/
+SS_API
+int ssm_write_file(const char* pFilePath, ssm_flag flag, const char* group_id)
+{
+ int ret = 0;
+
+ if(!pFilePath)
+ {
+ SLOGE("[%s] Parameter error in ssm_write_file()..\n", __func__);
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ if(flag <= SSM_FLAG_NONE || flag >= SSM_FLAG_MAX)
+ {
+ SLOGE("[%s] Parameter error in ssm_write_file()..\n", __func__);
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ ret = SsClientDataStoreFromFile(pFilePath, flag, group_id);
+ if(ret == 1)
+ {
+ if(unlink(pFilePath) != 0) // if fail
+ {
+ SLOGE("[%s] unlink fail. [%s]\n", __func__, pFilePath);
+ return -1; // return false
+ }
+ SLOGI("[%s] Write file Success.\n", __func__);
+ return 0; // return true
+ }
+ else
+ SLOGE( "[%s] Write file Fail.\n", __func__);
+
+Error:
+ return -(ret);
+}
+
+SS_API
+int ssm_write_buffer(char* pWriteBuffer, size_t bufLen, const char* pFileName, ssm_flag flag, const char* group_id)
+{
+ int ret = 0;
+
+ if(!pWriteBuffer || !pFileName || (pFileName[0] == '/'))
+ {
+ SLOGE("[%s] Parameter error in ssm_write_buffer()..\n", __func__);
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+ if(bufLen <= 0 || bufLen > 4096)
+ {
+ SLOGE( "[%s] Parameter error in ssm_write_buffer()..\n", __func__ );
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+ if(flag <= SSM_FLAG_NONE || flag >= SSM_FLAG_MAX)
+ {
+ SLOGE( "[%s] Parameter error in ssm_write_buffer()..\n", __func__ );
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ ret = SsClientDataStoreFromBuffer(pWriteBuffer, bufLen, pFileName, flag, group_id);
+ if(ret == 1)
+ {
+ SLOGI("[%s] Write buffer Success.\n", __func__);
+ return 0; // return true
+ }
+ else
+ SLOGE("[%s] Write buffer Fail.\n", __func__);
+
+Error:
+ return -(ret);
+}
+
+SS_API
+int ssm_read(const char* pFilePath, char* pRetBuf, size_t bufLen, size_t *readLen, ssm_flag flag, const char* group_id)
+{
+ int ret = 0;
+ ssm_file_info_t sfi;
+
+ if(!pFilePath || !pRetBuf)
+ {
+ SLOGE( "[%s] Parameter error in ssm_read()..\n", __func__ );
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+ if(!readLen)
+ {
+ SLOGE("[%s] Parameter error in ssm_read()...\n", __func__);
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ // get info
+ ret = ssm_getinfo(pFilePath, &sfi, flag, group_id);
+ if(ret != 0) // ret != true?
+ {
+ SLOGE("[%s] getinfo error in ssm_read()..\n", __func__);
+ goto Error;
+ }
+ // in case of flag mismatch...
+ // check flag...
+ // To do :
+ if((bufLen > sfi.originSize) || (sfi.reserved[0] != (flag & 0x000000ff)))
+ {
+ SLOGE("[%s] Flag mismatch or buffer length error in ssm_read()..\n", __func__);
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ ret = SsClientDataRead(pFilePath, pRetBuf, sfi.originSize, readLen, flag, group_id);
+
+ if(ret == 1)
+ {
+ SLOGI("[%s] Read Success.\n", __func__);
+ return 0; // return true
+ }
+ else
+ SLOGE("[%s] Read Fail.\n", __func__);
+
+Error:
+ return -(ret);
+}
+
+SS_API
+int ssm_delete_file(const char *pFilePath, ssm_flag flag, const char* group_id)
+{
+ int ret = 0;
+
+ if(!pFilePath)
+ {
+ SLOGE("[%s] Parameter error in ssm_delete_file()..\n", __func__);
+ ret = SS_PARAM_ERROR;
+ goto Error;
+ }
+
+ ret = SsClientDeleteFile(pFilePath, flag, group_id);
+
+ if(ret == 1) // success
+ {
+ SLOGI("[%s] Delete file Success.\n", __func__);
+ return 0;
+ }
+ else // fail
+ SLOGE("[%s] Delete file Fail.\n", __func__);
+
+Error:
+ return -(ret);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 22:35:34 +0000