service/drm_trusted_client_ipc.cpp

   1 /*\r
   2  *  drm-trusted-client\r
   3  *\r
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
   5  *\r
   6  * Contact: Hakjoo Ko <hakjoo.ko@samsung.com>\r
   7  *                      Mahendra Kumar Prajapat <mahendra.p@samsung.com>\r
   8  *                      Harsha Shekar <h.shekar@samsung.com>\r
   9  *\r
  10  *\r
  11  * Licensed under the Apache License, Version 2.0 (the "License");\r
  12  * you may not use this file except in compliance with the License.\r
  13  * You may obtain a copy of the License at\r
  14  *\r
  15  * http://www.apache.org/licenses/LICENSE-2.0\r
  16  *\r
  17  * Unless required by applicable law or agreed to in writing, software\r
  18  * distributed under the License is distributed on an "AS IS" BASIS,\r
  19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  20  * See the License for the specific language governing permissions and\r
  21  * limitations under the License.\r
  22  *\r
  23  */\r
  24 \r
  25 /**\r
  26  * @file                drm_trusted_client_ipc.cpp\r
  27  * @brief       DRM Trusted Client Inter process communication definitions.\r
  28  * @author      Mahendra Kumar Prajapat (mahendra.p@samsung.com)\r
  29  * @author      Harsha Shekar (h.shekar@samsung.com)\r
  30  * @version     0.1\r
  31  * @history     0.1: DRM Trusted Client Inter process communication definitions.\r
  32  */\r
  33 \r
  34 #include <stdio.h>\r
  35 #include <stdlib.h>\r
  36 #include <string.h>\r
  37 #include <unistd.h>\r
  38 #include <sys/stat.h>\r
  39 #include <sys/un.h>\r
  40 #include <sys/types.h>\r
  41 #include <sys/socket.h>\r
  42 #include <errno.h>\r
  43 \r
  44 #include "drm_trusted_client_ipc.h"\r
  45 #include "drm_trusted_client_log.h"\r
  46 \r
  47 /**\r
  48  *  This API is used to send a request to the Server to call corresponding API\r
  49  *\r
  50  * @param[in]   client_in       Carries the input parameters of Trusted Client API to Server\r
  51  * @param[out]  server_out      Carries the output parameters of Trusted Client API from Server\r
  52  * @return              0 on success & other values on failure\r
  53  * @remarks\r
  54  * @see\r
  55  * @since       0.1\r
  56  */\r
  57 int drm_trusted_client_comm(drm_trusted_request_data_s *client_in, drm_trusted_response_data_s *server_out)\r
  58 {\r
  59         int sockfd = 0;\r
  60         struct sockaddr_un clientaddr;\r
  61         drm_trusted_request_data_s send_data;\r
  62         drm_trusted_response_data_s recv_data;\r
  63         int temp_len_sock = 0;\r
  64         int retval = 0;\r
  65         drm_trusted_result_e result = DRM_TRUSTED_RETURN_SUCCESS;\r
  66         unsigned int offset = 0;\r
  67 \r
  68         int bytes_write = DRM_TRUSTED_MAX_CHUNK_SIZE;\r
  69         int bytes_read = DRM_TRUSTED_MAX_CHUNK_SIZE;\r
  70 \r
  71         /* memset the structures */\r
  72         memset(&send_data, 0x0, sizeof(drm_trusted_request_data_s));\r
  73         memset(&recv_data, 0x0, sizeof(drm_trusted_response_data_s));\r
  74 \r
  75         /* Create a socket */\r
  76         if ((sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {\r
  77                 DRM_TRUSTED_CLIENT_EXCEPTION("socket error!!, sockfd = %d, error = %s",\r
  78                                 sockfd, strerror(errno));\r
  79                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
  80                 goto ErrorExit;\r
  81         }\r
  82         DRM_TRUSTED_CLIENT_LOG("Opened socket sockfd = %d",sockfd);\r
  83 \r
  84         /* Copy the data received from the client into local */\r
  85         memcpy(&send_data, client_in, sizeof(drm_trusted_request_data_s));\r
  86 \r
  87         /* Set parameters to be used in connect */\r
  88         temp_len_sock = strlen(DRM_TRUSTED_SOCK_PATH);\r
  89 \r
  90         memset(&clientaddr, 0x00, sizeof(clientaddr));\r
  91         clientaddr.sun_family = AF_UNIX;\r
  92         memcpy(clientaddr.sun_path, DRM_TRUSTED_SOCK_PATH, temp_len_sock);\r
  93         clientaddr.sun_path[temp_len_sock] = '\0';\r
  94 \r
  95         DRM_TRUSTED_CLIENT_LOG("Connecting socket sockfd = %d",sockfd);\r
  96         if ((retval = connect(sockfd, (struct sockaddr*) &clientaddr,\r
  97                         sizeof(clientaddr))) < 0) {\r
  98                 DRM_TRUSTED_CLIENT_EXCEPTION("connect error!!, retval = %d, error = %s",\r
  99                                 retval, strerror(errno));\r
 100                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 101                 goto ErrorExit;\r
 102         }\r
 103 \r
 104         /* First write the static structures */\r
 105         DRM_TRUSTED_CLIENT_LOG("Writing socket sockfd = %d size=%d",sockfd,sizeof(drm_trusted_req_fixed_data_s));\r
 106         if ((retval = write(sockfd, (char*) &send_data.fixed_data,\r
 107                         sizeof(drm_trusted_req_fixed_data_s))) < 0) {\r
 108                 DRM_TRUSTED_CLIENT_EXCEPTION("write error!!, retval = %d, error = %s",\r
 109                                 retval, strerror(errno));\r
 110                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 111                 goto ErrorExit;\r
 112         }\r
 113         DRM_TRUSTED_CLIENT_LOG("Written socket sockfd = %d retval=%d",sockfd,retval);\r
 114 \r
 115         /* Now send the additional data items if any */\r
 116         if (send_data.fixed_data.num_data_items > 0) {\r
 117 \r
 118                 for (int i = 0; i < send_data.fixed_data.num_data_items; i++) {\r
 119 \r
 120                         if (send_data.fixed_data.data_length[i] > DRM_TRUSTED_MAX_CHUNK_SIZE) {\r
 121 \r
 122                                 while (bytes_write > 0) {\r
 123                                         DRM_TRUSTED_CLIENT_LOG("Writing socket sockfd = %d size=%d",sockfd,bytes_write);\r
 124                                         if ((retval = write(sockfd,\r
 125                                                         (void*)(send_data.data_items[i] + offset), bytes_write))\r
 126                                                         < 0) {\r
 127                                                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 128                                                                 "write error!!, retval = %d, error = %s",\r
 129                                                                 retval, strerror(errno));\r
 130                                                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 131                                                 goto ErrorExit;\r
 132                                         }\r
 133                                         DRM_TRUSTED_CLIENT_LOG("Written socket sockfd = %d retval=%d",sockfd,retval);\r
 134 \r
 135                                         offset += DRM_TRUSTED_MAX_CHUNK_SIZE;\r
 136                                         bytes_write = (int)(send_data.fixed_data.data_length[i] - offset) > (int)DRM_TRUSTED_MAX_CHUNK_SIZE ?\r
 137                                                                         DRM_TRUSTED_MAX_CHUNK_SIZE :\r
 138                                                                         (int)(send_data.fixed_data.data_length[i] - offset);\r
 139 \r
 140                                         DRM_TRUSTED_CLIENT_LOG("offset = %d, bytes_write = %d", offset, bytes_write);\r
 141 \r
 142                                 }\r
 143                                 bytes_write = 0;\r
 144                         } else{\r
 145                                 DRM_TRUSTED_CLIENT_LOG("Writing socket sockfd = %d size=%d",sockfd,send_data.fixed_data.data_length[i]);\r
 146                                 if ((retval = write(sockfd, send_data.data_items[i], send_data.fixed_data.data_length[i])) < 0) {\r
 147                                         DRM_TRUSTED_CLIENT_EXCEPTION("write error!!, retval = %d, error = %s",\r
 148                                                         retval, strerror(errno));\r
 149                                         result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 150                                         goto ErrorExit;\r
 151                                 }\r
 152                                 DRM_TRUSTED_CLIENT_LOG("Written socket sockfd = %d retval=%d",sockfd,retval);\r
 153                         }\r
 154                 }\r
 155         }\r
 156 \r
 157         /* Set offset to be used again */\r
 158         offset = 0;\r
 159 \r
 160         /* Read the fixed data into the receive structure */\r
 161         DRM_TRUSTED_CLIENT_LOG("Reading socket sockfd = %d size=%d",sockfd,sizeof(drm_trusted_resp_fixed_data_s));\r
 162         if ((retval = read(sockfd, (char*) &recv_data.fixed_data,\r
 163                         sizeof(drm_trusted_resp_fixed_data_s))) < 0) {\r
 164                 DRM_TRUSTED_CLIENT_EXCEPTION("read error!!, retval = %d, error = %s",\r
 165                                 retval, strerror(errno));\r
 166                 result = DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 167                 goto ErrorExit;\r
 168         }\r
 169         DRM_TRUSTED_CLIENT_LOG("Read socket sockfd = %d retval=%d",sockfd,retval);\r
 170 \r
 171         if (recv_data.fixed_data.num_data_items > 0) {\r
 172 \r
 173                 for (int loop = 0; loop < recv_data.fixed_data.num_data_items; loop++) {\r
 174 \r
 175                         /* Allocate memory for the data items */\r
 176                         recv_data.data_items[loop] = (char*) malloc(\r
 177                                         recv_data.fixed_data.data_length[loop]);\r
 178                         if (!recv_data.data_items[loop]) {\r
 179                                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 180                                                 "Memory Allocation Error!, buf = %p",\r
 181                                                 recv_data.data_items[loop]);\r
 182                                 recv_data.fixed_data.resp_result =\r
 183                                                 DRM_TRUSTED_RETURN_INSUFFICIENT_MEMORY;\r
 184                                 goto ErrorExit;\r
 185                         }\r
 186 \r
 187                         if (recv_data.fixed_data.data_length[loop] > DRM_TRUSTED_MAX_CHUNK_SIZE) {\r
 188 \r
 189                                 while (bytes_read > 0) {\r
 190                                         DRM_TRUSTED_CLIENT_LOG("Reading socket sockfd = %d size=%d",sockfd,bytes_read);\r
 191                                         if ((retval = read(sockfd,\r
 192                                                         (void*)(recv_data.data_items[loop] + offset),\r
 193                                                         bytes_read)) < 0) {\r
 194                                                 DRM_TRUSTED_CLIENT_EXCEPTION(\r
 195                                                                 "Read error!!, retval = %d, error = %s", retval,\r
 196                                                                 strerror(errno));\r
 197                                                 recv_data.fixed_data.resp_result =\r
 198                                                                 DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 199                                                 goto ErrorExit;\r
 200                                         }\r
 201                                         DRM_TRUSTED_CLIENT_LOG("Read socket sockfd = %d retval=%d",sockfd,retval);\r
 202 \r
 203                                         offset += DRM_TRUSTED_MAX_CHUNK_SIZE;\r
 204                                         bytes_read = (int)(recv_data.fixed_data.data_length[loop] - offset) > (int) DRM_TRUSTED_MAX_CHUNK_SIZE ?\r
 205                                                                                         DRM_TRUSTED_MAX_CHUNK_SIZE :\r
 206                                                                         (int)(recv_data.fixed_data.data_length[loop] - offset);\r
 207 \r
 208                                         DRM_TRUSTED_CLIENT_LOG("offset = %d, bytes_write = %d", offset, bytes_read);\r
 209 \r
 210                                 }\r
 211                                 bytes_write = 0;\r
 212                         } else\r
 213                         {\r
 214                                 DRM_TRUSTED_CLIENT_LOG("Reading socket sockfd = %d size=%d",sockfd,recv_data.fixed_data.data_length[loop]);\r
 215                                 if ((retval = read(sockfd,\r
 216                                                 recv_data.data_items[loop],\r
 217                                                 recv_data.fixed_data.data_length[loop])) < 0) {\r
 218                                         DRM_TRUSTED_CLIENT_EXCEPTION("Read error!!, retval = %d, error = %s",\r
 219                                                         retval, strerror(errno));\r
 220                                         recv_data.fixed_data.resp_result =\r
 221                                                         DRM_TRUSTED_RETURN_COMMUNICATION_ERROR;\r
 222                                         goto ErrorExit;\r
 223                                 }\r
 224                                 DRM_TRUSTED_CLIENT_LOG("Read socket sockfd = %d retval=%d",sockfd,retval);\r
 225                         }\r
 226                 }\r
 227         }\r
 228 \r
 229         /* Copy the data from the server back to the client into the output parameter */\r
 230         memcpy(server_out, &recv_data, sizeof(drm_trusted_response_data_s));\r
 231 \r
 232         DRM_TRUSTED_CLIENT_LOG("drm_trusted_client_comm success!!!, result = %d", result);\r
 233 \r
 234 ErrorExit:\r
 235         if(-1 != sockfd){\r
 236                 DRM_TRUSTED_CLIENT_LOG("Closing Socket:sockfd=%d",sockfd);\r
 237                 retval = close(sockfd);\r
 238                 DRM_TRUSTED_CLIENT_LOG("Closed Socket:sockfd=%d retval=%d",sockfd,retval);\r
 239                 sockfd = -1;\r
 240         }\r
 241 \r
 242         return result;\r
 243 }\r