vcore/src/server/src/cert-server-main.c

   1 /**
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *  http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  */
  16 /**
  17  * @file     cert-server-main.c
  18  * @author   Madhan A K (madhan.ak@samsung.com)
  19  *           Kyungwook Tak (k.tak@samsung.com)
  20  * @version  1.0
  21  * @brief    cert-svc server.
  22  */
  23
  24 #include <signal.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <sys/un.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <sys/socket.h>
  31 #include <sys/time.h>
  32 #include <sys/select.h>
  33 #include <systemd/sd-daemon.h>
  34
  35 #include <cert-service-debug.h>
  36 #include <cert-svc/cerror.h>
  37 #include <cert-svc/ccert.h>
  38 #include <cert-svc-client.h>
  39
  40 #include <cert-server-logic.h>
  41
  42 sqlite3 *cert_store_db = NULL;
  43
  44 int open_db(sqlite3 **db_handle, const char *db_path) {
  45
  46         int result = CERTSVC_FAIL;
  47         sqlite3 *handle;
  48
  49         if (access(db_path, F_OK) == 0) {
  50                 result = db_util_open(db_path, &handle, 0);
  51                 if (result != SQLITE_OK) {
  52                         SLOGE("connect db [%s] failed!", db_path);
  53                         return CERTSVC_FAIL;
  54                 }
  55                 *db_handle = handle;
  56                 return CERTSVC_SUCCESS;
  57         }
  58         SLOGD("%s DB does not exists. Creating one!!", db_path);
  59
  60         result = db_util_open(db_path, &handle, 0);
  61         if (result != SQLITE_OK) {
  62                 SLOGE("connect to db [%s] failed!.", db_path);
  63                 return CERTSVC_FAIL;
  64         }
  65         *db_handle = handle;
  66         return CERTSVC_SUCCESS;
  67 }
  68
  69 int evaluate_query(sqlite3 *db_handle, char *query) {
  70
  71         int result = CERTSVC_SUCCESS;
  72         sqlite3_stmt* p_statement;
  73
  74         if (!db_handle) {
  75                 SLOGE("Database not initialised.");
  76                 return CERTSVC_WRONG_ARGUMENT;
  77         }
  78
  79         if (!query) {
  80                 SLOGE("Query is NULL.");
  81                 return CERTSVC_WRONG_ARGUMENT;
  82         }
  83
  84         result = sqlite3_prepare_v2(db_handle, query, strlen(query), &p_statement, NULL);
  85         if (result != SQLITE_OK) {
  86                 SLOGE("Sqlite3 error [%d] : <%s> preparing <%s> query.", result, sqlite3_errmsg(db_handle), query);
  87                 return CERTSVC_FAIL;
  88         }
  89
  90         result = sqlite3_step(p_statement);
  91         if (result != SQLITE_DONE) {
  92                 SLOGE("Sqlite3 error [%d] : <%s> executing <%s> statement.", result, sqlite3_errmsg(db_handle), query);
  93                 return CERTSVC_FAIL;
  94         }
  95
  96         result = sqlite3_finalize(p_statement);
  97         if (result != SQLITE_OK) {
  98                 SLOGE("Sqlite3 error [%d] : <%s> finalising <%s> statement.", result, sqlite3_errmsg(db_handle), query);
  99                 return CERTSVC_FAIL;
 100         }
 101         return CERTSVC_SUCCESS;
 102 }
 103
 104 int initialize_db(void)
 105 {
 106         int result = CERTSVC_SUCCESS;
 107
 108         if (cert_store_db != NULL)
 109                 return CERTSVC_SUCCESS;
 110
 111         result = open_db(&cert_store_db, CERTSVC_SYSTEM_STORE_DB);
 112         if (result != CERTSVC_SUCCESS)
 113                 SLOGE("Certsvc store DB creation failed. result[%d]", result);
 114
 115         return result;
 116 }
 117
 118 void CertSigHandler(int signo)
 119 {
 120         SLOGD("Got Signal %d, exiting now.", signo);
 121         if (cert_store_db != NULL) {
 122                 sqlite3_close(cert_store_db);
 123                 cert_store_db = NULL;
 124         }
 125         exit(1);
 126 }
 127
 128 int CertSvcGetSocketFromSystemd(int* pSockfd)
 129 {
 130         int n = sd_listen_fds(0);
 131         int fd;
 132
 133         for (fd = SD_LISTEN_FDS_START; fd < SD_LISTEN_FDS_START+n; ++fd) {
 134                 if (0 < sd_is_socket_unix(fd, SOCK_STREAM, 1, VCORE_SOCK_PATH, 0)) {
 135                         LOGD("Get socket from systemd. fd[%d]", fd);
 136                         *pSockfd = fd;
 137                         return CERTSVC_SUCCESS;
 138                 }
 139         }
 140         return CERTSVC_FAIL;
 141 }
 142
 143 void CertSvcServerComm()
 144 {
 145         int server_sockfd = 0;
 146         int client_sockfd = 0;
 147         int read_len = 0;
 148         int client_len = 0;
 149         struct sockaddr_un clientaddr;
 150         int result = CERTSVC_SUCCESS;
 151         char *certListBuffer = NULL;
 152         char *certBlockBuffer = NULL;
 153         size_t bufferLen = 0;
 154         size_t blockBufferLen = 0;
 155
 156         struct timeval timeout;
 157         timeout.tv_sec = 10;
 158         timeout.tv_usec = 0;
 159
 160         SLOGI("cert-server is starting...");
 161
 162         VcoreRequestData recv_data;
 163         VcoreResponseData send_data;
 164
 165         if (!CertSvcGetSocketFromSystemd(&server_sockfd)) {
 166                 SLOGE("Failed to get sockfd from systemd.");
 167                 return;
 168         }
 169
 170         client_len = sizeof(clientaddr);
 171         signal(SIGINT, (void*)CertSigHandler);
 172
 173         result = initialize_db();
 174         if (result != CERTSVC_SUCCESS) {
 175                 SLOGE("Failed to initialize database.");
 176                 result = CERTSVC_IO_ERROR;
 177                 goto Error_close_exit;
 178         }
 179
 180         fd_set fd;
 181         struct timeval tv;
 182         while (1) {
 183                 errno = 0;
 184
 185                 FD_ZERO(&fd);
 186                 FD_SET(server_sockfd, &fd);
 187
 188                 tv.tv_sec = 1;
 189                 tv.tv_usec = 0;
 190
 191                 memset(&recv_data, 0x00, sizeof(VcoreRequestData));
 192                 memset(&send_data, 0x00, sizeof(VcoreResponseData));
 193
 194                 int ret = select(server_sockfd + 1, &fd, NULL, NULL, &tv);
 195                 if (ret == 0) { // timeout
 196                         SLOGD("cert-server timeout. exit.");
 197                         break;
 198                 }
 199
 200                 if (ret == -1) {
 201                         SLOGE("select() error.");
 202                         break;
 203                 }
 204
 205                 if ((client_sockfd = accept(server_sockfd, (struct sockaddr*)&clientaddr, (socklen_t*)&client_len)) < 0) {
 206                         SLOGE("Error in function accept().[socket desc :%d, error no :%d].", client_sockfd, errno);
 207                         continue;
 208                 }
 209
 210                 SLOGD("cert-server Accept! client sock[%d]", client_sockfd);
 211
 212                 if (setsockopt (client_sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)) < 0) {
 213                         SLOGE("Error in Set SO_RCVTIMEO Socket Option");
 214                         send_data.result = CERTSVC_FAIL;
 215                         goto Error_close_exit;
 216                 }
 217
 218                 if (setsockopt (client_sockfd, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout)) < 0) {
 219                         SLOGE("Error in Set SO_SNDTIMEO Socket Option");
 220                         send_data.result = CERTSVC_FAIL;
 221                         goto Error_close_exit;
 222                 }
 223
 224                 SLOGD("Connected to a client...");
 225
 226                 read_len = recv(client_sockfd, (char*)&recv_data, sizeof(recv_data), 0);
 227                 if (read_len < 0) {
 228                         SLOGE("Error in function recv().");
 229                         send_data.result = CERTSVC_FAIL;
 230                         goto Error_close_exit;
 231                 }
 232
 233                 SLOGD("revc request: reqType=%d", recv_data.reqType);
 234
 235                 switch (recv_data.reqType) {
 236                 case CERTSVC_EXTRACT_CERT:
 237                 {
 238                         send_data.result = getCertificateDetailFromStore(
 239                                         cert_store_db,
 240                                         recv_data.storeType,
 241                                         recv_data.certType,
 242                                         recv_data.gname,
 243                                         send_data.dataBlock,
 244                                         &send_data.dataBlockLen);
 245                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 246                         break;
 247                 }
 248
 249                 case CERTSVC_EXTRACT_SYSTEM_CERT:
 250                 {
 251                         send_data.result = getCertificateDetailFromSystemStore(
 252                                         cert_store_db,
 253                                         recv_data.gname,
 254                                         send_data.dataBlock,
 255                                         &send_data.dataBlockLen);
 256                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 257                         break;
 258                 }
 259
 260                 case CERTSVC_DELETE_CERT:
 261                 {
 262                         send_data.result = deleteCertificateFromStore(
 263                                         cert_store_db,
 264                                         recv_data.storeType,
 265                                         recv_data.gname);
 266                         if (send_data.result == CERTSVC_SUCCESS)
 267                                 send_data.result = update_ca_certificate_file(cert_store_db, NULL, 0);
 268                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 269                         break;
 270                 }
 271
 272                 case CERTSVC_GET_CERTIFICATE_STATUS:
 273                 {
 274                         send_data.result = getCertificateStatusFromStore(
 275                                         cert_store_db,
 276                                         recv_data.storeType,
 277                                         recv_data.gname,
 278                                         &send_data.certStatus);
 279                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 280                         break;
 281                 }
 282
 283                 case CERTSVC_SET_CERTIFICATE_STATUS:
 284                 {
 285                         send_data.result = setCertificateStatusToStore(
 286                                         cert_store_db,
 287                                         recv_data.storeType,
 288                                         recv_data.is_root_app,
 289                                         recv_data.gname,
 290                                         recv_data.certStatus);
 291                         if (send_data.result == CERTSVC_SUCCESS)
 292                                 send_data.result = update_ca_certificate_file(cert_store_db, NULL, 0);
 293                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 294                         break;
 295                 }
 296
 297                 case CERTSVC_CHECK_ALIAS_EXISTS:
 298                 {
 299                         send_data.result = checkAliasExistsInStore(
 300                                         cert_store_db,
 301                                         recv_data.storeType,
 302                                         recv_data.gname,
 303                                         &send_data.isAliasUnique);
 304                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 305                         break;
 306                 }
 307
 308                 case CERTSVC_INSTALL_CERTIFICATE:
 309                 {
 310                         send_data.result = installCertificateToStore(
 311                                         cert_store_db,
 312                                         recv_data.storeType,
 313                                         recv_data.gname,
 314                                         recv_data.common_name,
 315                                         recv_data.private_key_gname,
 316                                         recv_data.associated_gname,
 317                                         recv_data.dataBlock,
 318                                         recv_data.dataBlockLen,
 319                                         recv_data.certType);
 320
 321                         if ((send_data.result == CERTSVC_SUCCESS) && ((recv_data.certType == PEM_CRT) || (recv_data.certType == P12_TRUSTED)))
 322                                 send_data.result = update_ca_certificate_file(cert_store_db, recv_data.dataBlock, recv_data.dataBlockLen);
 323                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 324                         break;
 325                 }
 326
 327                 case CERTSVC_GET_CERTIFICATE_LIST:
 328                 case CERTSVC_GET_USER_CERTIFICATE_LIST:
 329                 case CERTSVC_GET_ROOT_CERTIFICATE_LIST:
 330                 {
 331                         send_data.result = getCertificateListFromStore(
 332                                         cert_store_db,
 333                                         recv_data.reqType,
 334                                         recv_data.storeType,
 335                                         recv_data.is_root_app,
 336                                         &certListBuffer,
 337                                         &bufferLen,
 338                                         &send_data.certCount);
 339                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 340                         if (bufferLen > 0)
 341                                 result = send(client_sockfd, certListBuffer, bufferLen, 0);
 342
 343                         break;
 344                 }
 345
 346                 case CERTSVC_GET_CERTIFICATE_ALIAS:
 347                 {
 348                         send_data.result = getCertificateAliasFromStore(
 349                                         cert_store_db,
 350                                         recv_data.storeType,
 351                                         recv_data.gname,
 352                                         send_data.common_name);
 353                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 354                         break;
 355                 }
 356
 357                 case CERTSVC_LOAD_CERTIFICATES:
 358                 {
 359                         send_data.result = loadCertificatesFromStore(
 360                                         cert_store_db,
 361                                         recv_data.storeType,
 362                                         recv_data.gname,
 363                                         &certBlockBuffer,
 364                                         &blockBufferLen,
 365                                         &send_data.certBlockCount);
 366                         result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 367                         if (blockBufferLen > 0)
 368                                 result = send(client_sockfd, certBlockBuffer, blockBufferLen, 0);
 369                         break;
 370                 }
 371
 372                 default:
 373                         SLOGE("Input error. Please check request type");
 374                         break;
 375                 }
 376
 377                 if (result <= 0) {
 378                         SLOGE("send failed :%d, errno %d try once", result, errno);
 379                         //result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 380                         //SLOGE("retry result :%d, errno %d", result, errno);
 381                 }
 382         }
 383
 384 Error_close_exit:
 385         close(server_sockfd);
 386         if (cert_store_db) {
 387                 sqlite3_close(cert_store_db);
 388                 cert_store_db = NULL;
 389         }
 390
 391         if (certListBuffer)
 392                 free(certListBuffer);
 393
 394         if (certBlockBuffer)
 395                 free(certBlockBuffer);
 396
 397         if (client_sockfd >= 0) {
 398                 result = send(client_sockfd, (char*)&send_data, sizeof(send_data), 0);
 399                 close(client_sockfd);
 400         }
 401         else
 402                 SLOGE("cannot connect to client socket.");
 403
 404         SLOGI("CertSvcServerComm done.");
 405 }
 406
 407 int main(void)
 408 {
 409         SLOGI("cert-server start");
 410         CertSvcServerComm();
 411         SLOGI("cert-server end");
 412
 413         return 0;
 414 }