vcore/server/src/cert-server-logic.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-logic.c
  18  * @author   Madhan A K (madhan.ak@samsung.com)
  19  *           Kyungwook Tak (k.tak@samsung.com)
  20  * @version  1.0
  21  * @brief    cert-server logic.
  22  */
  23 #include <unistd.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <dirent.h>
  30 #include <sys/smack.h>
  31 #include <sys/socket.h>
  32
  33 #include <ckmc/ckmc-manager.h>
  34 #include <ckmc/ckmc-error.h>
  35
  36 #include "orig/cert-service.h"
  37 #include "orig/cert-service-debug.h"
  38 #include <cert-svc/cerror.h>
  39 #include <cert-svc/ccert.h>
  40 #include <vcore/cert-svc-client.h>
  41
  42 #include <cert-server-logic.h>
  43
  44 static CertStatus int_to_CertStatus(int intval)
  45 {
  46         switch (intval) {
  47         case 1:
  48                 return ENABLED;
  49         case 0:
  50         default:
  51                 return DISABLED;
  52         }
  53 }
  54
  55 static int CertStatus_to_int(CertStatus status)
  56 {
  57         switch (status) {
  58         case ENABLED:
  59                 return 1;
  60         case DISABLED:
  61         default:
  62                 return 0;
  63         }
  64 }
  65
  66 char *add_shared_owner_prefix(const char *name)
  67 {
  68         size_t alias_len = strlen(name) + strlen(ckmc_owner_id_system) + strlen(ckmc_owner_id_separator);
  69         char *ckm_alias = (char *)malloc(alias_len + 1);
  70         if (!ckm_alias) {
  71                 SLOGE("Failed to allocate memory");
  72                 return NULL;
  73         }
  74         memset(ckm_alias, 0, alias_len + 1);
  75         strncat(ckm_alias, ckmc_owner_id_system, alias_len + 1);
  76         strncat(ckm_alias, ckmc_owner_id_separator, alias_len + 1 - strlen(ckmc_owner_id_system));
  77         strncat(ckm_alias, name, alias_len + 1 - strlen(ckmc_owner_id_system) + strlen(ckmc_owner_id_separator));
  78
  79         return ckm_alias;
  80 }
  81
  82 int ckmc_remove_alias_with_shared_owner_prefix(const char *name, int *result)
  83 {
  84         char *ckm_alias = add_shared_owner_prefix(name);
  85         if (!ckm_alias) {
  86                 SLOGE("Failed to allocate memory");
  87                 return CERTSVC_BAD_ALLOC;
  88         }
  89
  90         *result = ckmc_remove_alias(ckm_alias);
  91
  92         free(ckm_alias);
  93
  94         return CERTSVC_SUCCESS;
  95 }
  96
  97 char *get_complete_path(const char *str1, const char *str2)
  98 {
  99         char *result = NULL;
 100         int as_result;
 101
 102         if (!str1 || !str2)
 103                 return NULL;
 104
 105         if (str1[strlen(str1) - 1] != '/')
 106                 as_result = asprintf(&result, "%s/%s", str1, str2);
 107         else
 108                 as_result = asprintf(&result, "%s%s", str1, str2);
 109
 110         if (as_result < 0)
 111                 return NULL;
 112
 113         return result;
 114 }
 115
 116 /* TODO: root ssl file system refactor */
 117 int add_file_to_dir(const char* dir, const char* pGname, const char* pData, size_t dataLen)
 118 {
 119         char *systemFile = get_complete_path(dir, pGname);
 120         if (!systemFile) {
 121                 SLOGE("Failed to get system file path.");
 122                 return CERTSVC_FAIL;
 123         }
 124
 125         char realFile[FILENAME_MAX] = {0};
 126         if (!realpath(systemFile, realFile)) {
 127                 SLOGE("Failed to get realpath. systemFile[%s]", systemFile);
 128                 return CERTSVC_FAIL;
 129         }
 130
 131         FILE *stream = fopen(realFile, "ab");
 132         if (!stream) {
 133                 SLOGE("Fail to open file [%s]", realFile);
 134                 return CERTSVC_FAIL;
 135         }
 136
 137         if (fwrite(pData, sizeof(char), dataLen, stream) != dataLen) {
 138                 SLOGE("Fail to write file in system store.");
 139                 fclose(stream);
 140                 return CERTSVC_FAIL;
 141         }
 142
 143         fclose(stream);
 144         return CERTSVC_SUCCESS;
 145 }
 146
 147 int add_file_to_system_cert_dir(const char* pGname, const char* pData, size_t dataLen)
 148 {
 149         return add_file_to_dir(SYSTEM_CERT_DIR, pGname, pData, dataLen);
 150 }
 151
 152 /* TODO: root ssl file system refactor */
 153 int del_file_from_dir(const char* dir, const char *pGname)
 154 {
 155         const char *systemFile = get_complete_path(dir, pGname);
 156         if (!systemFile)   {
 157                 SLOGE("Failed to construct source file path.");
 158                 return CERTSVC_FAIL;
 159         }
 160
 161         char realFile[FILENAME_MAX] = {0};
 162         if (!realpath(systemFile, realFile)) {
 163                 SLOGE("Failed to get realpath. systemFile[%s]", systemFile);
 164                 return CERTSVC_FAIL;
 165         }
 166
 167         /* instead of removing the file, the file is trimmed to zero size */
 168         FILE *stream = fopen(realFile, "wb");
 169         if (!stream) {
 170                 SLOGE("Failed to open the file for writing, [%s].", realFile);
 171                 return CERTSVC_FAIL;
 172         }
 173
 174         fclose(stream);
 175         return CERTSVC_SUCCESS;
 176 }
 177
 178 int del_file_from_system_cert_dir(const char *pGname)
 179 {
 180         return del_file_from_dir(SYSTEM_CERT_DIR, pGname);
 181 }
 182
 183 int execute_insert_update_query(sqlite3 *db_handle, char *query)
 184 {
 185         if (!db_handle) {
 186                 SLOGE("Database not initialised.");
 187                 return CERTSVC_WRONG_ARGUMENT;
 188         }
 189
 190         if (!query) {
 191                 SLOGE("Query is NULL.");
 192                 return CERTSVC_WRONG_ARGUMENT;
 193         }
 194
 195         /* Begin transaction */
 196         int result = sqlite3_exec(db_handle, "BEGIN EXCLUSIVE", NULL, NULL, NULL);
 197         if (result != SQLITE_OK) {
 198                 SLOGE("Failed to begin transaction.");
 199                 return CERTSVC_FAIL;
 200         }
 201
 202         /* Executing command */
 203         result = sqlite3_exec(db_handle, query, NULL, NULL, NULL);
 204         if (result != SQLITE_OK) {
 205                 SLOGE("Failed to execute query (%s).", query);
 206                 return CERTSVC_FAIL;
 207         }
 208
 209         /* Committing the transaction */
 210         result = sqlite3_exec(db_handle, "COMMIT", NULL, NULL, NULL);
 211         if (result) {
 212                 SLOGE("Failed to commit transaction. Roll back now.");
 213                 result = sqlite3_exec(db_handle, "ROLLBACK", NULL, NULL, NULL);
 214                 if (result != SQLITE_OK)
 215                         SLOGE("Failed to commit transaction. Roll back now.");
 216
 217                 return CERTSVC_FAIL;
 218         }
 219
 220         SLOGD("Transaction Commit and End.");
 221
 222         return CERTSVC_SUCCESS;
 223 }
 224
 225 int execute_select_query(sqlite3 *db_handle, char *query, sqlite3_stmt **stmt)
 226 {
 227         if (!db_handle || !query)
 228                 return CERTSVC_WRONG_ARGUMENT;
 229
 230         sqlite3_stmt *stmts = NULL;
 231         if (sqlite3_prepare_v2(db_handle, query, strlen(query), &stmts, NULL) != SQLITE_OK) {
 232                 SLOGE("sqlite3_prepare_v2 failed [%s].", query);
 233                 return CERTSVC_FAIL;
 234         }
 235
 236         *stmt = stmts;
 237         return CERTSVC_SUCCESS;
 238 }
 239
 240 int write_to_file(const char *fileName, const char *mode_of_writing, const char *certBuffer, size_t certLength)
 241 {
 242         int result = CERTSVC_SUCCESS;
 243         FILE *fp_write = NULL;
 244
 245         if (!certBuffer || certLength <= 0) {
 246                 SLOGE("Input buffer is NULL.");
 247                 return CERTSVC_WRONG_ARGUMENT;
 248         }
 249
 250         if (!(fp_write = fopen(fileName, mode_of_writing))) {
 251                 SLOGE("Failed to open the file for writing, [%s].", fileName);
 252                 return CERTSVC_FAIL;
 253         }
 254
 255         /* if mode of writing is to append, then goto end of file */
 256         if (strcmp(mode_of_writing,"ab") == 0)
 257                 fseek(fp_write, 0L, SEEK_END);
 258
 259         if (fwrite(certBuffer, sizeof(char), certLength, fp_write) != certLength) {
 260                 SLOGE("Fail to write into file.");
 261                 result = CERTSVC_FAIL;
 262                 goto error;
 263         }
 264
 265         /* adding empty line at the end */
 266         fwrite("\n",sizeof(char), 1, fp_write);
 267
 268 error:
 269         if (fp_write)
 270                 fclose(fp_write);
 271
 272         return result;
 273 }
 274
 275 int write_to_ca_cert_crt_file(const char *mode_of_writing, const char *certBuffer, size_t certLength)
 276 {
 277         return write_to_file(CERTSVC_CRT_FILE_PATH, mode_of_writing, certBuffer, certLength);
 278 }
 279
 280 int saveCertificateToStore(
 281         const char *pGname,
 282         const char *pData,
 283         size_t dataLen)
 284 {
 285         if (!pGname || !pData || dataLen < 1) {
 286                 SLOGE("Invalid input parameter passed.");
 287                 return CERTSVC_WRONG_ARGUMENT;
 288         }
 289
 290         ckmc_policy_s cert_policy;
 291         cert_policy.password = NULL;
 292         cert_policy.extractable = true;
 293
 294         ckmc_raw_buffer_s cert_data;
 295         cert_data.data = (unsigned char *)pData;
 296         cert_data.size = dataLen;
 297
 298         char *ckm_alias = add_shared_owner_prefix(pGname);
 299         if (!ckm_alias) {
 300                 SLOGE("Failed to make alias. memory allocation error.");
 301                 return CERTSVC_BAD_ALLOC;
 302         }
 303
 304         int result = ckmc_save_data(ckm_alias, cert_data, cert_policy);
 305         free(ckm_alias);
 306
 307         if (result != CKMC_ERROR_NONE) {
 308                 SLOGE("Failed to save trusted data. ckm errcode[%d]", result);
 309                 return CERTSVC_FAIL;
 310         }
 311
 312         return CERTSVC_SUCCESS;
 313 }
 314
 315 int saveCertificateToSystemStore(
 316         const char *pGname,
 317         const char *pData,
 318         size_t dataLen)
 319 {
 320         if (!pGname || !pData || dataLen < 1) {
 321                 SLOGE("Invalid input parameter passed.");
 322                 return CERTSVC_WRONG_ARGUMENT;
 323         }
 324
 325         int result = add_file_to_system_cert_dir(pGname, pData, dataLen);
 326         if (result != CERTSVC_SUCCESS)
 327                 SLOGE("Failed to store the certificate in store.");
 328
 329         return result;
 330 }
 331
 332 int get_certificate_buffer_from_store(
 333         sqlite3 *db_handle,
 334         CertStoreType storeType,
 335         const char *pGname,
 336         char **certBuffer,
 337         size_t *certSize)
 338 {
 339         int result = CERTSVC_SUCCESS;
 340         int records = 0;
 341         char *tempBuffer = NULL;
 342         char *query = NULL;
 343         sqlite3_stmt *stmt = NULL;
 344
 345         if (!pGname) {
 346                 SLOGE("Invalid input parameter passed.");
 347                 return CERTSVC_WRONG_ARGUMENT;
 348         }
 349
 350         if (storeType != SYSTEM_STORE)
 351                 query = sqlite3_mprintf("select * from %Q where gname=%Q and enabled=%d and is_root_app_enabled=%d", \
 352                                                            ((storeType == WIFI_STORE)? "wifi" : (storeType == VPN_STORE)? "vpn" : \
 353                                                            (storeType == EMAIL_STORE)? "email" : "ssl"), pGname, ENABLED, ENABLED);
 354         else
 355                 query = sqlite3_mprintf("select certificate from ssl where gname=%Q and enabled=%d and is_root_app_enabled=%d", \
 356                                                                 pGname, ENABLED, ENABLED);
 357
 358         result = execute_select_query(db_handle, query, &stmt);
 359         if (result != CERTSVC_SUCCESS) {
 360                 SLOGE("Querying database failed.");
 361                 result = CERTSVC_FAIL;
 362                 goto error;
 363         }
 364
 365         records = sqlite3_step(stmt);
 366         if (records != SQLITE_ROW || records == SQLITE_DONE) {
 367                 SLOGE("No valid records found for given gname [%s].",pGname);
 368                 result = CERTSVC_FAIL;
 369                 goto error;
 370         }
 371
 372         tempBuffer = (char *)malloc(sizeof(char) * VCORE_MAX_RECV_DATA_SIZE);
 373         if (!tempBuffer) {
 374                 SLOGE("Fail to allocate memory");
 375                 result = CERTSVC_FAIL;
 376                 goto error;
 377         }
 378
 379         memset(tempBuffer, 0x00, VCORE_MAX_RECV_DATA_SIZE);
 380
 381         if (storeType == SYSTEM_STORE)
 382                 result = getCertificateDetailFromSystemStore(db_handle, pGname, tempBuffer, certSize);
 383         else
 384                 result = getCertificateDetailFromStore(db_handle, storeType, PEM_CRT, pGname, tempBuffer, certSize);
 385
 386         if (result != CERTSVC_SUCCESS) {
 387                 SLOGE("Failed to set request data.");
 388                 result = CERTSVC_WRONG_ARGUMENT;
 389                 goto error;
 390         }
 391
 392         *certBuffer = tempBuffer;
 393
 394 error:
 395         if (result != CERTSVC_SUCCESS)
 396                 free(tempBuffer);
 397
 398         if (query)
 399                 sqlite3_free(query);
 400
 401         if (stmt)
 402                 sqlite3_finalize(stmt);
 403
 404         return result;
 405 }
 406
 407 int update_ca_certificate_file(sqlite3 *db_handle, char *certBuffer, size_t certLength)
 408 {
 409         int result = CERTSVC_SUCCESS;
 410         int records = 0;
 411         int count = 0;
 412         int counter = 0;
 413         char *pValue = NULL;
 414         char *query = NULL;
 415         const char *text;
 416         sqlite3_stmt *stmt = NULL;
 417
 418         int storeType[4] = {SYSTEM_STORE, WIFI_STORE, VPN_STORE, EMAIL_STORE};
 419
 420         /* During install of a root certificate, the root certificate gets appended at
 421          * the end to optimise the write operation onto ca-certificate.crt file. */
 422         if (certBuffer && certLength > 0) {
 423                 result = write_to_ca_cert_crt_file("ab", certBuffer, certLength);
 424                 if (result != CERTSVC_SUCCESS) {
 425                         SLOGE("Failed to write to file.");
 426                         result = CERTSVC_FAIL;
 427                 }
 428                 goto error_and_exit;
 429         }
 430
 431         while (count < 4) {
 432                 /* get the ssl certificate from database */
 433                 if (count == 0)
 434                         query = sqlite3_mprintf("select certificate from ssl where enabled=%d and is_root_app_enabled=%d", ENABLED, ENABLED);
 435                 else if (count > 0 && count < 4)
 436                         /* gets all the gname which is marked as root certificate and enabled = TRUE */
 437                         query = sqlite3_mprintf("select gname from %Q where is_root_cert=%d and enabled=%d and is_root_app_enabled=%d", \
 438                                                           ((count == 1)?"wifi":(count == 2)?"vpn":"email"), ENABLED, ENABLED, ENABLED);
 439
 440                 result = execute_select_query(db_handle, query, &stmt);
 441                 if (result != CERTSVC_SUCCESS) {
 442                         SLOGE("Querying database failed.");
 443                         goto next;
 444                 }
 445
 446                 /* update the ca-certificate.crt file */
 447                 while (1) {
 448                         records = sqlite3_step(stmt);
 449                         if (records != SQLITE_ROW || records == SQLITE_DONE) {
 450                                 result = CERTSVC_SUCCESS;
 451                                 break;
 452                         }
 453
 454                         if (records == SQLITE_ROW) {
 455                                 certLength = 0;
 456                                 certBuffer = NULL;
 457                                 pValue = NULL;
 458
 459                                 if (count == 0) {
 460                                         /* gets the certificate from database for system store */
 461                                         text = (const char *)sqlite3_column_text(stmt, 0);
 462                                         if (text) {
 463                                                 certLength = strlen(text);
 464                                                 certBuffer = strndup(text, certLength);
 465                                         }
 466                                 } else {
 467                                         /* gets the certificate from key-manager for other stores */
 468                                         text = (const char *)sqlite3_column_text(stmt, 0);
 469                                         if (text)
 470                                                 pValue = strndup(text, strlen(text));
 471
 472                                         result = get_certificate_buffer_from_store(db_handle, storeType[count], pValue, &certBuffer, &certLength);
 473                                         if (result != CERTSVC_SUCCESS) {
 474                                                 SLOGE("Failed to get certificate buffer from key-manager.");
 475                                                 goto error_and_exit;
 476                                         }
 477                                 }
 478
 479                                 if (certBuffer) {
 480                                         if (counter++ == 0)
 481                                                 result = write_to_ca_cert_crt_file("wb", certBuffer, certLength);
 482                                         else
 483                                                 result = write_to_ca_cert_crt_file("ab", certBuffer, certLength);
 484
 485                                         if (result != CERTSVC_SUCCESS) {
 486                                                 SLOGE("Failed to write to file.");
 487                                                 result = CERTSVC_FAIL;
 488                                                 goto error_and_exit;
 489                                         }
 490                                 }
 491                         }
 492                 }
 493 next:
 494                 count++;
 495                 if (query) {
 496                         sqlite3_free(query);
 497                         query = NULL;
 498                 }
 499         }
 500         SLOGD("Successfully updated ca-certificate.crt file.");
 501
 502 error_and_exit:
 503         if (query)
 504                 sqlite3_free(query);
 505
 506         if (stmt)
 507                 sqlite3_finalize(stmt);
 508
 509         return result;
 510 }
 511
 512 int enable_disable_cert_status(
 513         sqlite3 *db_handle,
 514         CertStoreType storeType,
 515         int is_root_app,
 516         const char *pGname,
 517         CertStatus status)
 518 {
 519         int ckmc_result = CKMC_ERROR_UNKNOWN;
 520         int result = CERTSVC_SUCCESS;
 521         int records = 0;
 522         size_t certSize = 0;
 523         size_t certLength = 0;
 524         char *certBuffer = NULL;
 525         char *query = NULL;
 526         const char *text = NULL;
 527         sqlite3_stmt *stmt = NULL;
 528
 529         if (status != DISABLED && status != ENABLED) {
 530                 SLOGE("Invalid cert status");
 531                 return CERTSVC_INVALID_STATUS;
 532         }
 533
 534         query = sqlite3_mprintf("select * from %Q where gname=%Q", ((storeType == WIFI_STORE)? "wifi" : \
 535                         (storeType == VPN_STORE)? "vpn" : (storeType == EMAIL_STORE)? "email" : "ssl"), pGname);
 536         if (!query) {
 537                 SLOGE("Failed to generate query");
 538                 return CERTSVC_BAD_ALLOC;
 539         }
 540
 541         result = execute_select_query(db_handle, query, &stmt);
 542         sqlite3_free(query);
 543
 544         if (result != CERTSVC_SUCCESS || !stmt) {
 545                 SLOGE("Querying database failed.");
 546                 return CERTSVC_FAIL;
 547         }
 548
 549         records = sqlite3_step(stmt);
 550         sqlite3_finalize(stmt);
 551         stmt = NULL;
 552
 553         if (records != SQLITE_ROW) {
 554                 SLOGE("No valid records found.");
 555                 return CERTSVC_FAIL;
 556         }
 557
 558         if (status == DISABLED) {
 559                 /* check certificate presence in disabled_certs table before inserting */
 560                 query = sqlite3_mprintf("select * from disabled_certs where gname=%Q", pGname);
 561                 if (!query) {
 562                         SLOGE("Failed to generate query");
 563                         return CERTSVC_BAD_ALLOC;
 564                 }
 565
 566                 result = execute_select_query(db_handle, query, &stmt);
 567                 sqlite3_free(query);
 568                 query = NULL;
 569
 570                 if (result != CERTSVC_SUCCESS) {
 571                         SLOGE("Querying database failed.");
 572                         return CERTSVC_FAIL;
 573                 }
 574
 575                 records = sqlite3_step(stmt);
 576                 sqlite3_finalize(stmt);
 577                 stmt = NULL;
 578
 579                 if (records == SQLITE_ROW) {
 580                         SLOGE("Selected certificate identifier is already disabled.", pGname);
 581                         return CERTSVC_FAIL;
 582                 }
 583
 584                 /* get certificate from keymanager*/
 585                 result = get_certificate_buffer_from_store(db_handle, storeType, pGname, &certBuffer, &certSize);
 586                 if (result != CERTSVC_SUCCESS) {
 587                         SLOGE("Failed to get certificate buffer. result[%d]", result);
 588                         return result;
 589                 }
 590
 591                 /* inserting the disabled certificate to disabled_certs table */
 592                 query = sqlite3_mprintf("insert into disabled_certs (gname, certificate) values (%Q, %Q)", pGname, certBuffer);
 593                 free(certBuffer);
 594
 595                 if (!query) {
 596                         SLOGE("Failed to generate query");
 597                         return CERTSVC_BAD_ALLOC;
 598                 }
 599
 600                 result = execute_insert_update_query(db_handle, query);
 601                 sqlite3_free(query);
 602
 603                 if (result != CERTSVC_SUCCESS) {
 604                         SLOGE("Insert to database failed.");
 605                         return result;
 606                 }
 607
 608                 if (storeType != SYSTEM_STORE) {
 609                         result = ckmc_remove_alias_with_shared_owner_prefix(pGname, &ckmc_result);
 610
 611                         if (result != CERTSVC_SUCCESS || ckmc_result != CKMC_ERROR_NONE) {
 612                                 SLOGE("Failed to delete certificate from key-manager. ckmc_result[%d]", ckmc_result);
 613                                 return CERTSVC_FAIL;
 614                         }
 615
 616                 } else {
 617                         result = del_file_from_system_cert_dir(pGname);
 618                         if (result != CERTSVC_SUCCESS) {
 619                                 SLOGE("Error in del_file_from_system_cert_dir. ret[%d]", result);
 620                                 return result;
 621                         }
 622                 }
 623         } else { /* moving the certificate to enabled state */
 624                 query = sqlite3_mprintf("select certificate from disabled_certs where gname=%Q", pGname);
 625                 if (!query) {
 626                         SLOGE("Failed to generate query");
 627                         return CERTSVC_BAD_ALLOC;
 628                 }
 629
 630                 result = execute_select_query(db_handle, query, &stmt);
 631                 sqlite3_free(query);
 632
 633                 if (result != CERTSVC_SUCCESS) {
 634                         SLOGE("Querying database failed.");
 635                         return CERTSVC_FAIL;
 636                 }
 637
 638                 records = sqlite3_step(stmt);
 639                 if (records == SQLITE_ROW) {
 640                         text = (const char *)sqlite3_column_text(stmt, 0);
 641
 642                         if (!text) {
 643                                 SLOGE("Invalid column text");
 644                                 sqlite3_finalize(stmt);
 645                                 return CERTSVC_FAIL;
 646                         }
 647
 648                         certBuffer = strndup(text, strlen(text));
 649
 650                         sqlite3_finalize(stmt);
 651
 652                         if (!certBuffer) {
 653                                 SLOGE("Failed to allocate memory");
 654                                 return CERTSVC_BAD_ALLOC;
 655                         }
 656
 657                         certLength = strlen(certBuffer);
 658
 659                         if (storeType == SYSTEM_STORE)
 660                                 result = saveCertificateToSystemStore(pGname, certBuffer, certLength);
 661                         else
 662                                 result = saveCertificateToStore(pGname, certBuffer, certLength);
 663
 664                         free(certBuffer);
 665
 666                         if (result != CERTSVC_SUCCESS) {
 667                                 SLOGE("Failed to save certificate to key-manager. ret[%d]", result);
 668                                 return result;
 669                         }
 670
 671                         query = sqlite3_mprintf("delete from disabled_certs where gname=%Q", pGname);
 672                         if (!query) {
 673                                 SLOGE("Failed to generate query");
 674                                 return CERTSVC_BAD_ALLOC;
 675                         }
 676
 677                         result = execute_insert_update_query(db_handle, query);
 678                         sqlite3_free(query);
 679
 680                         if (result != CERTSVC_SUCCESS) {
 681                                 SLOGE("Unable to delete certificate entry from database. ret[%d]", result);
 682                                 return result;
 683                         }
 684                 }
 685         }
 686
 687         if (is_root_app == ENABLED)
 688                 query = sqlite3_mprintf("update %Q set is_root_app_enabled=%d , enabled=%d where gname=%Q", ((storeType == WIFI_STORE)? "wifi" : \
 689                                                            (storeType == VPN_STORE)? "vpn" : (storeType == EMAIL_STORE)? "email" : "ssl"), CertStatus_to_int(status), status, pGname);
 690         else
 691                 query = sqlite3_mprintf("update %Q set enabled=%d where gname=%Q", ((storeType == WIFI_STORE)? "wifi" : \
 692                                                            (storeType == VPN_STORE)? "vpn" : (storeType == EMAIL_STORE)? "email" : "ssl"), CertStatus_to_int(status), pGname);
 693
 694         if (!query) {
 695                 SLOGE("Failed to generate query");
 696                 return CERTSVC_BAD_ALLOC;
 697         }
 698
 699         result = execute_insert_update_query(db_handle, query);
 700         sqlite3_free(query);
 701
 702         if (result != CERTSVC_SUCCESS) {
 703                 SLOGE("Update failed. ret[%d]", result);
 704                 return result;
 705         }
 706
 707         return result;
 708 }
 709
 710 int setCertificateStatusToStore(
 711         sqlite3 *db_handle,
 712         CertStoreType storeType,
 713         int is_root_app,
 714         const char *pGname,
 715         CertStatus status)
 716 {
 717         if (!pGname) {
 718                 SLOGE("Invalid input parameter passed.");
 719                 return CERTSVC_WRONG_ARGUMENT;
 720         }
 721
 722         int result = enable_disable_cert_status(db_handle, storeType, is_root_app, pGname, status);
 723         if (result != CERTSVC_SUCCESS) {
 724                 SLOGE("Failed to disable certificate.");
 725                 return result;
 726         }
 727
 728         SLOGD("Successfully updated the certificate status from %s to %s.",
 729                 (status == DISABLED) ? "ENABLED" : "DISABLED", (status == DISABLED) ? "DISABLED" : "ENABLED");
 730         return CERTSVC_SUCCESS;
 731 }
 732
 733 int getCertificateStatusFromStore(
 734         sqlite3 *db_handle,
 735         CertStoreType storeType,
 736         const char* pGname,
 737         CertStatus *status)
 738 {
 739         if (!pGname) {
 740                 SLOGE("Invalid input parameter passed.");
 741                 return CERTSVC_WRONG_ARGUMENT;
 742         }
 743
 744         char *query = sqlite3_mprintf("select gname, common_name, enabled from %Q where gname=%Q",\
 745                                                    ((storeType == WIFI_STORE)? "wifi" : (storeType == VPN_STORE)? "vpn" : \
 746                                                    (storeType == EMAIL_STORE)? "email" : "ssl"), pGname);
 747         if (!query) {
 748                 SLOGE("Failed to generate query");
 749                 return CERTSVC_BAD_ALLOC;
 750         }
 751
 752         sqlite3_stmt *stmt = NULL;
 753         int result = execute_select_query(db_handle, query, &stmt);
 754         sqlite3_free(query);
 755
 756         if (result != CERTSVC_SUCCESS || !stmt) {
 757                 SLOGE("Querying database failed.");
 758                 *status = DISABLED;
 759                 return CERTSVC_FAIL;
 760         }
 761
 762         result = sqlite3_step(stmt);
 763         if (result != SQLITE_ROW || result == SQLITE_DONE) {
 764                 SLOGE("No valid records found.");
 765                 *status = DISABLED;
 766                 sqlite3_finalize(stmt);
 767                 return CERTSVC_FAIL;
 768         }
 769
 770         *status = int_to_CertStatus(sqlite3_column_int(stmt, 2));
 771
 772         sqlite3_finalize(stmt);
 773
 774         return CERTSVC_SUCCESS;
 775 }
 776
 777 int check_alias_exist_in_database(
 778         sqlite3 *db_handle,
 779         CertStoreType storeType,
 780         const char *alias,
 781         int *isUnique)
 782 {
 783         sqlite3_stmt *stmt = NULL;
 784
 785         if (!alias || !isUnique) {
 786                 SLOGE("Invalid input parameter passed.");
 787                 return CERTSVC_WRONG_ARGUMENT;
 788         }
 789
 790         char *query = sqlite3_mprintf("select * from %Q where common_name=%Q", ((storeType == WIFI_STORE)? "wifi" : \
 791                                                    (storeType == VPN_STORE)? "vpn" : "email"),alias);
 792
 793         if (!query) {
 794                 SLOGE("Failed to generate query");
 795                 return CERTSVC_BAD_ALLOC;
 796         }
 797
 798         int result = execute_select_query(db_handle, query, &stmt);
 799         sqlite3_free(query);
 800
 801         if (result != CERTSVC_SUCCESS || !stmt) {
 802                 SLOGE("Querying database failed.");
 803                 return CERTSVC_FAIL;
 804         }
 805
 806         result = sqlite3_step(stmt);
 807         sqlite3_finalize(stmt);
 808
 809         if (result != SQLITE_ROW)
 810                 *isUnique = CERTSVC_TRUE;
 811         else
 812                 *isUnique = CERTSVC_FALSE;
 813
 814         return CERTSVC_SUCCESS;
 815 }
 816
 817 int installCertificateToStore(
 818         sqlite3 *db_handle,
 819         CertStoreType storeType,
 820         const char *pGname,
 821         const char *common_name,
 822         const char *private_key_gname,
 823         const char *associated_gname,
 824         const char *dataBlock,
 825         size_t dataBlockLen,
 826         CertType certType)
 827 {
 828         if ((!pGname)
 829                 || (certType == P12_END_USER && !common_name && !private_key_gname)
 830                 || (certType != P12_END_USER && !common_name && !associated_gname)) {
 831                 SLOGE("Invalid input parameter passed.");
 832                 return CERTSVC_WRONG_ARGUMENT;
 833         }
 834
 835         if (storeType != SYSTEM_STORE
 836                 && saveCertificateToStore(
 837                         pGname,
 838                         dataBlock,
 839                         dataBlockLen) != CERTSVC_SUCCESS) {
 840                 SLOGE("FAIL to save certificate to key-manager.");
 841                 return CERTSVC_FAIL;
 842         }
 843
 844         if (certType == P12_PKEY) {
 845                 SLOGD("Don't save private key in store");
 846                 return CERTSVC_SUCCESS;
 847         }
 848
 849         char *query = NULL;
 850         if (certType == P12_END_USER && private_key_gname) {
 851                 query = sqlite3_mprintf("insert into %Q (gname, common_name, private_key_gname, associated_gname, enabled, is_root_app_enabled) "\
 852                                                                 "values (%Q, %Q, %Q, %Q, %d, %d)",((storeType == WIFI_STORE)? "wifi" : \
 853                                                                 (storeType == VPN_STORE)? "vpn" : "email"), pGname, common_name, private_key_gname, pGname, ENABLED, ENABLED);
 854         } else if (certType == PEM_CRT || certType == P12_TRUSTED) {
 855                 query = sqlite3_mprintf("insert into %Q (gname, common_name, is_root_cert, associated_gname, enabled, is_root_app_enabled) values "\
 856                                                                 "(%Q, %Q, %d, %Q, %d, %d)", ((storeType == WIFI_STORE)? "wifi" : \
 857                                                                 (storeType == VPN_STORE)? "vpn" : "email"), pGname, common_name, ENABLED, associated_gname, ENABLED, ENABLED);
 858         } else if (certType == P12_INTERMEDIATE) {
 859                 query = sqlite3_mprintf("insert into %Q (gname, common_name, associated_gname, enabled, is_root_app_enabled) values (%Q, %Q, %Q, %d, %d)", \
 860                                                                 ((storeType == WIFI_STORE)? "wifi" : (storeType == VPN_STORE)? "vpn" : "email"),
 861                                                                 pGname, common_name, associated_gname, ENABLED, ENABLED);
 862         }
 863
 864         if (!query) {
 865                 SLOGE("Failed to generate query");
 866                 return CERTSVC_BAD_ALLOC;
 867         }
 868
 869         int result = execute_insert_update_query(db_handle, query);
 870         sqlite3_free(query);
 871
 872         if (result != CERTSVC_SUCCESS) {
 873                 SLOGE("Insert to database failed.");
 874                 return CERTSVC_FAIL;
 875         }
 876
 877         return CERTSVC_SUCCESS;
 878 }
 879
 880 int checkAliasExistsInStore(
 881         sqlite3 *db_handle,
 882         CertStoreType storeType,
 883         const char* alias,
 884         int *isUnique)
 885 {
 886         if (!alias) {
 887                 SLOGE("Invalid input parameter passed.");
 888                 return CERTSVC_WRONG_ARGUMENT;
 889         }
 890
 891         *isUnique = CERTSVC_FAIL;
 892         int result = check_alias_exist_in_database(db_handle, storeType, alias, isUnique);
 893         if (result != CERTSVC_SUCCESS) {
 894                 SLOGE("Failed to check_alias_exist_in_database. err[%d]", result);
 895                 return CERTSVC_FAIL;
 896         }
 897
 898         if (*isUnique == CERTSVC_TRUE) {
 899                 SLOGD("Alias (%s) does not exist in %s store.",
 900                         alias,
 901                         (storeType == VPN_STORE) ? "VPN" :
 902                                 (storeType == WIFI_STORE) ? "WIFI" : "EMAIL");
 903         } else {
 904                 SLOGD("Alias (%s) exist in %s store.",
 905                         alias,
 906                         (storeType == VPN_STORE) ? "VPN" :
 907                                 (storeType == WIFI_STORE) ? "WIFI" : "EMAIL");
 908         }
 909
 910         return CERTSVC_SUCCESS;
 911 }
 912
 913 int getCertificateDetailFromStore(
 914         sqlite3 *db_handle,
 915         CertStoreType storeType,
 916         CertType certType,
 917         const char *pGname,
 918         char *pOutData,
 919         size_t *size)
 920 {
 921         int result = CERTSVC_SUCCESS;
 922         int records = 0;
 923         char *query = NULL;
 924         const char *text = NULL;
 925         sqlite3_stmt *stmt = NULL;
 926         ckmc_raw_buffer_s *cert_data = NULL;
 927
 928         if (!pGname || !pOutData) {
 929                 SLOGE("Invalid input parameter passed.");
 930                 return CERTSVC_WRONG_ARGUMENT;
 931         }
 932
 933         /* start constructing query */
 934         if (certType == P12_PKEY) {
 935                 /* From the given certificate identifier, get the associated_gname for the certificate.
 936                  * Then query the database for records matching the associated_gname to get the private key */
 937                 query = sqlite3_mprintf("select associated_gname from %Q where gname=%Q", \
 938                                                            ((storeType == WIFI_STORE)? "wifi" : (storeType == VPN_STORE)? "vpn" : "email"), pGname);
 939                 if (!query) {
 940                         SLOGE("Failed to generate query");
 941                         return CERTSVC_BAD_ALLOC;
 942                 }
 943
 944                 result = execute_select_query(db_handle, query, &stmt);
 945                 sqlite3_free(query);
 946
 947                 if (result != CERTSVC_SUCCESS) {
 948                         SLOGE("Querying database failed.");
 949                         return result;
 950                 }
 951
 952                 records = sqlite3_step(stmt);
 953                 if (records != SQLITE_ROW) {
 954                         SLOGE("No valid records found.");
 955                         sqlite3_finalize(stmt);
 956                         return CERTSVC_FAIL;
 957                 }
 958
 959                 text = (const char *)sqlite3_column_text(stmt, 0);
 960
 961                 if (!text) {
 962                         SLOGE("No valid column text");
 963                         sqlite3_finalize(stmt);
 964                         return CERTSVC_FAIL;
 965                 }
 966
 967                 query = sqlite3_mprintf("select private_key_gname from %Q where gname=%Q and enabled=%d and is_root_app_enabled=%d", \
 968                                          ((storeType == WIFI_STORE)? "wifi" : (storeType == VPN_STORE)? "vpn" : "email"), text, ENABLED, ENABLED);
 969
 970                 sqlite3_finalize(stmt);
 971         } else if (storeType != SYSTEM_STORE) {
 972                 query = sqlite3_mprintf("select * from %Q where gname=%Q and enabled=%d and is_root_app_enabled=%d", \
 973                                                            ((storeType == WIFI_STORE)? "wifi" : (storeType == VPN_STORE)? "vpn" : \
 974                                                            (storeType == EMAIL_STORE)? "email" : "ssl"), pGname, ENABLED, ENABLED);
 975         }
 976
 977         if (!query) {
 978                 SLOGE("Failed to generate query");
 979                 return CERTSVC_BAD_ALLOC;
 980         }
 981
 982         result = execute_select_query(db_handle, query, &stmt);
 983         sqlite3_free(query);
 984
 985         if (result != CERTSVC_SUCCESS) {
 986                 SLOGE("Querying database failed.");
 987                 return result;
 988         }
 989
 990         records = sqlite3_step(stmt);
 991         if (records != SQLITE_ROW) {
 992                 SLOGE("No valid records found.");
 993                 sqlite3_finalize(stmt);
 994                 return CERTSVC_FAIL;
 995         }
 996
 997         if (certType == P12_PKEY) {
 998                 if (!(text = (const char *)sqlite3_column_text(stmt, 0))) {
 999                         SLOGE("No valid column text");
1000                         sqlite3_finalize(stmt);
1001                         return CERTSVC_FAIL;
1002                 }
1003
1004                 pGname = text;
1005         }
1006
1007         char *ckm_alias = add_shared_owner_prefix(pGname);
1008         if (!ckm_alias) {
1009                 SLOGE("Failed to make alias. memory allocation error.");
1010                 return CERTSVC_BAD_ALLOC;
1011         }
1012
1013         result = ckmc_get_data(ckm_alias, NULL, &cert_data);
1014         free(ckm_alias);
1015
1016         sqlite3_finalize(stmt);
1017
1018         if (result != CKMC_ERROR_NONE) {
1019                 SLOGE("Failed to get certificate from key-manager. ckm ret[%d]", result);
1020                 *size = CERTSVC_FAIL;
1021                 return CERTSVC_FAIL;
1022         }
1023
1024         memcpy(pOutData, cert_data->data, cert_data->size);
1025         pOutData[cert_data->size] = 0;
1026         *size = cert_data->size;
1027
1028         ckmc_buffer_free(cert_data);
1029
1030         return CERTSVC_SUCCESS;
1031 }
1032
1033 int getCertificateDetailFromSystemStore(
1034         sqlite3 *db_handle,
1035         const char *pGname,
1036         char *pOutData,
1037         size_t *size)
1038 {
1039         int result = CERTSVC_SUCCESS;
1040         int records = 0;
1041         size_t certLength = 0;
1042         char *query = NULL;
1043         const char *text = NULL;
1044         sqlite3_stmt *stmt = NULL;
1045
1046         if (!pGname) {
1047                 SLOGE("Invalid input parameter passed.");
1048                 return CERTSVC_WRONG_ARGUMENT;
1049         }
1050
1051         query = sqlite3_mprintf("select certificate from ssl where gname=%Q and is_root_app_enabled=%d", \
1052                                                         pGname, ENABLED, ENABLED);
1053         if (!query) {
1054                 SLOGE("Query is NULL.");
1055                 return CERTSVC_FAIL;
1056         }
1057
1058         result = execute_select_query(db_handle, query, &stmt);
1059         sqlite3_free(query);
1060
1061         if (result != CERTSVC_SUCCESS) {
1062                 SLOGE("Querying database failed.");
1063                 return result;
1064         }
1065
1066         records = sqlite3_step(stmt);
1067         if (records != SQLITE_ROW) {
1068                 SLOGE("No valid records found for passed gname [%s].", pGname);
1069                 sqlite3_finalize(stmt);
1070                 return CERTSVC_FAIL;
1071         }
1072
1073         text = (const char *)sqlite3_column_text(stmt, 0);
1074
1075         if (!text) {
1076                 SLOGE("Fail to sqlite3_column_text");
1077                 sqlite3_finalize(stmt);
1078                 return CERTSVC_FAIL;
1079         }
1080
1081         certLength = strlen(text);
1082         if (certLength >= 4096) {
1083                 sqlite3_finalize(stmt);
1084                 SLOGE("certificate is too long");
1085                 return CERTSVC_FAIL;
1086         }
1087
1088         memcpy(pOutData, text, certLength);
1089         pOutData[certLength] = 0;
1090         *size = certLength;
1091
1092         sqlite3_finalize(stmt);
1093         return CERTSVC_SUCCESS;
1094 }
1095
1096 int deleteCertificateFromStore(sqlite3 *db_handle, CertStoreType storeType, const char *pGname) {
1097
1098         int result = CERTSVC_SUCCESS;
1099         int ckmc_result = CKMC_ERROR_UNKNOWN;
1100         int records = 0;
1101         char *query = NULL;
1102         char *private_key_name = NULL;
1103         sqlite3_stmt *stmt = NULL;
1104
1105         if (!pGname) {
1106                 SLOGE("Invalid input parameter passed.");
1107                 return CERTSVC_WRONG_ARGUMENT;
1108         }
1109
1110         if (storeType != SYSTEM_STORE) {
1111                 /* start constructing query */
1112                 query = sqlite3_mprintf("select private_key_gname from %Q where gname=%Q", ((storeType == WIFI_STORE)? "wifi" :\
1113                                                            (storeType == VPN_STORE)? "vpn" : "email"), pGname);
1114
1115                 result = execute_select_query(db_handle, query, &stmt);
1116                 if (result != CERTSVC_SUCCESS) {
1117                         SLOGE("Querying database failed.");
1118                         result = CERTSVC_FAIL;
1119                         goto error;
1120                 }
1121
1122                 records = sqlite3_step(stmt);
1123                 if ((records != SQLITE_ROW) || (records == SQLITE_DONE)) {
1124                         SLOGE("No valid records found for passed gname [%s].",pGname);
1125                         result = CERTSVC_FAIL;
1126                         goto error;
1127                 }
1128
1129                 /* if a cert is having private-key in it, the private key should
1130                  * be deleted first from key-manager, then the actual cert */
1131                 if (sqlite3_column_text(stmt, 0) != NULL) {
1132                         private_key_name = strdup((const char *)sqlite3_column_text(stmt, 0));
1133                         result = ckmc_remove_alias_with_shared_owner_prefix(private_key_name, &ckmc_result);
1134                         if (result != CERTSVC_SUCCESS || ckmc_result != CKMC_ERROR_NONE) {
1135                                 SLOGE("Failed to delete certificate from key-manager. ckmc_result[%d]", ckmc_result);
1136                                 result = CERTSVC_FAIL;
1137                                 goto error;
1138                         }
1139                 }
1140
1141                 /* removing the actual cert */
1142                 result = ckmc_remove_alias_with_shared_owner_prefix(pGname, &ckmc_result);
1143                 if (result != CERTSVC_SUCCESS || ckmc_result != CKMC_ERROR_NONE) {
1144                         query = sqlite3_mprintf("delete from disabled_certs where gname=%Q", pGname);
1145                         result = execute_insert_update_query(db_handle, query);
1146                         if (result != CERTSVC_SUCCESS) {
1147                                 SLOGE("Unable to delete certificate entry from database.");
1148                                 result = CERTSVC_FAIL;
1149                                 goto error;
1150                         }
1151                 }
1152
1153                 if (query) {
1154                         sqlite3_free(query);
1155                         query = NULL;
1156                 }
1157
1158                 if (stmt) {
1159                         sqlite3_finalize(stmt);
1160                         stmt = NULL;
1161                 }
1162
1163                 query = sqlite3_mprintf("delete from %Q where gname=%Q", ((storeType == WIFI_STORE)? "wifi" : \
1164                                                            (storeType == VPN_STORE)? "vpn" : "email"), pGname);
1165
1166                 result = execute_insert_update_query(db_handle, query);
1167                 if (result != CERTSVC_SUCCESS) {
1168                         SLOGE("Unable to delete certificate entry from database.");
1169                         result = CERTSVC_FAIL;
1170                         goto error;
1171                 }
1172         } else {
1173                 SLOGE("Invalid store type passed.");
1174                 result = CERTSVC_INVALID_STORE_TYPE;
1175         }
1176         SLOGD("Success in deleting the certificate from store.");
1177
1178 error:
1179         if (query)
1180                 sqlite3_free(query);
1181
1182         if (stmt)
1183                 sqlite3_finalize(stmt);
1184
1185         free(private_key_name);
1186         return result;
1187 }
1188
1189
1190 int getCertificateListFromStore(
1191         sqlite3 *db_handle,
1192         int reqType,
1193         CertStoreType storeType,
1194         int is_root_app,
1195         char **certListBuffer,
1196         size_t *bufferLen,
1197         size_t *certCount)
1198 {
1199         int result = CERTSVC_SUCCESS;
1200         CertSvcStoreCertList *rootCertHead = NULL;
1201         CertSvcStoreCertList *tmpNode = NULL;
1202         CertSvcStoreCertList *currentNode = NULL;
1203         sqlite3_stmt *stmt = NULL;
1204         char *query = NULL;
1205         int loopCount = 0;
1206         int records = 0;
1207         size_t count = 0;
1208         size_t i = 0;
1209
1210
1211         while (1) {
1212                 /* Iteration only possible from VPN_STORE till SYSTEM_STORE */
1213                 if (loopCount == (MAX_STORE_ENUMS - 1))
1214                         break;
1215
1216                 /* Check if the passed store type matches with any of the in-built store type */
1217                 if ((1 << loopCount) & storeType) {
1218                         /* if a store type matches, put that value as storetype argument in the below function */
1219                         CertStoreType tempStore = (CertStoreType) (1 << loopCount);
1220                         SLOGD("Processing storetype [%s]", (tempStore == WIFI_STORE)? "WIFI" : (tempStore == VPN_STORE)? "VPN" : \
1221                                                                                           (tempStore == EMAIL_STORE)? "EMAIL" : "SYSTEM");
1222
1223                         if (reqType == CERTSVC_GET_ROOT_CERTIFICATE_LIST) {
1224                         // For get_root_certificate_list_from_store
1225                                 if (storeType == SYSTEM_STORE) {
1226                                         query = sqlite3_mprintf("select gname, common_name, enabled from %Q where enabled=%d "\
1227                                                                                         "and is_root_app_enabled=%d and order by common_name asc", "ssl", ENABLED, ENABLED);
1228                                 } else {
1229                                         query = sqlite3_mprintf("select gname, common_name, enabled from %Q where "\
1230                                                                                         "is_root_cert IS NOT NULL and is_root_app_enabled=%d and enabled=%d", \
1231                                                                                         (storeType== WIFI_STORE)? "wifi" : (storeType == VPN_STORE)? "vpn" : \
1232                                                                                         (storeType == EMAIL_STORE)? "email" : "ssl", ENABLED, ENABLED);
1233                                 }
1234                         } else if (reqType == CERTSVC_GET_USER_CERTIFICATE_LIST) {
1235                         // For get_end_user_certificate_list_from_store
1236                                 if (storeType == SYSTEM_STORE) {
1237                                         SLOGE("Invalid store type passed.");
1238                                         return CERTSVC_WRONG_ARGUMENT;
1239                                 } else {
1240                                         query = sqlite3_mprintf("select gname, common_name, enabled from %Q where "\
1241                                                                                          "private_key_gname IS NOT NULL and is_root_app_enabled=%d and enabled=%d", \
1242                                                                                    (storeType== WIFI_STORE)? "wifi" : (storeType == VPN_STORE)? "vpn" : \
1243                                                                                    (storeType == EMAIL_STORE)? "email" : "ssl", ENABLED, ENABLED);
1244                                 }
1245                         } else {
1246                         // For get_certificate_list_from_store
1247                                 if (is_root_app != ENABLED) {
1248                                 /* Gets only the list of certificates where is_root_app = 1 (which are enabled by the master application) */
1249                                         if (tempStore == SYSTEM_STORE) {
1250                                                 query = sqlite3_mprintf("select gname, common_name, enabled from %Q where "\
1251                                                                                                 "is_root_app_enabled=%d order by common_name asc", \
1252                                                                                                 (tempStore== WIFI_STORE)? "wifi" : (tempStore == VPN_STORE)? "vpn" : \
1253                                                                                                 (tempStore == EMAIL_STORE)? "email" : "ssl", ENABLED, ENABLED);
1254                                         } else {
1255                                                 query = sqlite3_mprintf("select gname, common_name, enabled from %Q where is_root_app_enabled=%d", \
1256                                                                                            (tempStore== WIFI_STORE)? "wifi" : (tempStore == VPN_STORE)? "vpn" : \
1257                                                                                            (tempStore == EMAIL_STORE)? "email" : "ssl", ENABLED, ENABLED);
1258                                         }
1259                                 } else {
1260                                 /* Gets all the certificates from store without any restrictions */
1261                                         if (tempStore == SYSTEM_STORE) {
1262                                                 query = sqlite3_mprintf("select gname, common_name, enabled from %Q order by common_name asc", \
1263                                                                                            (tempStore== WIFI_STORE)? "wifi" : (tempStore == VPN_STORE)? "vpn" : \
1264                                                                                            (tempStore == EMAIL_STORE)? "email" : "ssl", ENABLED);
1265                                         } else {
1266                                                 query = sqlite3_mprintf("select gname, common_name, enabled from %Q", \
1267                                                                                            (tempStore== WIFI_STORE)? "wifi" : (tempStore == VPN_STORE)? "vpn" : \
1268                                                                                            (tempStore == EMAIL_STORE)? "email" : "ssl", ENABLED);
1269                                         }
1270                                 }
1271                         }
1272
1273                         result = execute_select_query(db_handle, query, &stmt);
1274                         if (result != CERTSVC_SUCCESS) {
1275                                 SLOGE("Querying database failed.");
1276                                 result = CERTSVC_FAIL;
1277                                 goto error;
1278                         }
1279
1280                         while (1) {
1281                                 records = sqlite3_step(stmt);
1282                                 if (records != SQLITE_ROW || records == SQLITE_DONE) {
1283                                         if (count == 0) {
1284                                                 SLOGE("No records found");
1285                                                 result = CERTSVC_SUCCESS;
1286                                                 goto error;
1287                                         } else {
1288                                                 break;
1289                                         }
1290                                 }
1291
1292                                 if (records == SQLITE_ROW) {
1293                                         tmpNode = (CertSvcStoreCertList *)malloc(sizeof(CertSvcStoreCertList));
1294                                         if (!tmpNode) {
1295                                                 SLOGE("Failed to allocate memory.");
1296                                                 result = CERTSVC_BAD_ALLOC;
1297                                                 goto error;
1298                                         } else {
1299                                                 tmpNode->next = NULL;
1300                                                 const char *textGname = (const char *)sqlite3_column_text(stmt, 0);
1301                                                 const char *textAlias = (const char *)sqlite3_column_text(stmt, 1);
1302                                                 if (!textGname || !textAlias) {
1303                                                         SLOGE("Failed to read texts from records");
1304                                                         free(tmpNode);
1305                                                         result = CERTSVC_FAIL;
1306                                                         goto error;
1307                                                 }
1308
1309                                                 int gnameLen = strlen(textGname);
1310                                                 int aliasLen = strlen(textAlias);
1311
1312                                                 tmpNode->gname = (char *)malloc(sizeof(char) * (gnameLen + 1));
1313                                                 tmpNode->title = (char *)malloc(sizeof(char) * (aliasLen + 1));
1314                                                 if (!tmpNode->title || !tmpNode->gname) {
1315                                                         free(tmpNode->gname);
1316                                                         free(tmpNode->title);
1317                                                         free(tmpNode);
1318                                                         SLOGE("Failed to allocate memory");
1319                                                         result = CERTSVC_BAD_ALLOC;
1320                                                         goto error;
1321                                                 }
1322
1323                                                 memset(tmpNode->gname, 0x00, gnameLen + 1);
1324                                                 memset(tmpNode->title, 0x00, aliasLen + 1);
1325
1326                                                 memcpy(tmpNode->gname, textGname, gnameLen);
1327                                                 memcpy(tmpNode->title, textAlias, aliasLen);
1328
1329                                                 tmpNode->status = (int)sqlite3_column_int(stmt, 2); /* for status */
1330                                                 tmpNode->storeType = tempStore;
1331                                         }
1332
1333                                         /* When multiple stores are passed, we need to ensure that the rootcerthead is
1334                                            assigned to currentNode once, else previous store data gets overwritten */
1335                                         if (count == 0) {
1336                                                 rootCertHead = tmpNode;
1337                                                 currentNode = rootCertHead;
1338                                                 tmpNode = NULL;
1339                                         } else {
1340                                                 currentNode->next = tmpNode;
1341                                                 currentNode = tmpNode;
1342                                                 tmpNode = NULL;
1343                                         }
1344                                         count++;
1345                                 }
1346                         }
1347
1348                         if (count == 0) {
1349                                 SLOGD("No entries found in database.");
1350                                 result = CERTSVC_SUCCESS;
1351                         }
1352
1353                         if (query) {
1354                                 sqlite3_free(query);
1355                                 query = NULL;
1356                         }
1357
1358                         if (stmt) {
1359                                 sqlite3_finalize(stmt);
1360                                 stmt = NULL;
1361                         }
1362                 }
1363                 loopCount++;
1364         }
1365
1366         *certCount = count;
1367         VcoreCertResponseData *respCertData = (VcoreCertResponseData *)malloc(count * sizeof(VcoreCertResponseData));
1368         if (!respCertData) {
1369                 SLOGE("Failed to allocate memory");
1370                 result = CERTSVC_BAD_ALLOC;
1371                 goto error;
1372         }
1373         if (count > 0)
1374                 memset(respCertData, 0x00, count * sizeof(VcoreCertResponseData));
1375         VcoreCertResponseData* currRespCertData = NULL;
1376
1377         currentNode = rootCertHead;
1378         for (i = 0; i < count; i++) {
1379            tmpNode = currentNode->next;
1380
1381            currRespCertData = respCertData + i;
1382            if (strlen(currentNode->gname) > sizeof(currRespCertData->gname)
1383                    || strlen(currentNode->title) > sizeof(currRespCertData->title)) {
1384                    SLOGE("String is too long. [%s], [%s]", currentNode->gname, currentNode->title);
1385                    result = CERTSVC_FAIL;
1386                    *certListBuffer = NULL;
1387                    free(respCertData);
1388                    goto error;
1389            }
1390            strncpy(currRespCertData->gname, currentNode->gname, strlen(currentNode->gname));
1391            strncpy(currRespCertData->title, currentNode->title, strlen(currentNode->title));
1392            currRespCertData->status = currentNode->status;
1393            currRespCertData->storeType = currentNode->storeType;
1394            //SLOGD("get cert list: %d th cert: gname=%s, title=%s, status=%d, storeType=%d", i, currRespCertData->gname, currRespCertData->title, currRespCertData->status, currRespCertData->storeType);
1395
1396            currentNode = tmpNode;
1397         }
1398
1399         *certListBuffer = (char *) respCertData;
1400         *bufferLen = count * sizeof(VcoreCertResponseData);
1401
1402         SLOGD("Success to create certificate list. cert_count=%d", count);
1403         result= CERTSVC_SUCCESS;
1404 error:
1405         if (query)
1406                 sqlite3_free(query);
1407
1408         if (stmt)
1409                 sqlite3_finalize(stmt);
1410
1411         if (rootCertHead) {
1412                 currentNode = rootCertHead;
1413                 while (currentNode) {
1414                         tmpNode = currentNode->next;
1415                         free(currentNode->title);
1416                         free(currentNode->gname);
1417                         free(currentNode);
1418                         currentNode=tmpNode;
1419                 }
1420                 rootCertHead = NULL;
1421         }
1422
1423         return result;
1424 }
1425
1426 int getCertificateAliasFromStore(sqlite3 *db_handle, CertStoreType storeType, const char *gname, char *alias)
1427 {
1428         int result = CERTSVC_SUCCESS;
1429         int records = 0;
1430         sqlite3_stmt *stmt = NULL;
1431         char *query = NULL;
1432         const char *text = NULL;
1433
1434         query = sqlite3_mprintf("select common_name from %Q where gname=%Q", ((storeType==WIFI_STORE)? "wifi" : \
1435                                                    (storeType==VPN_STORE)? "vpn" : "email"), gname);
1436
1437         result = execute_select_query(db_handle, query, &stmt);
1438         if (result != CERTSVC_SUCCESS) {
1439                 SLOGE("Querying database failed.");
1440                 result = CERTSVC_FAIL;
1441                 goto error;
1442         }
1443
1444         records = sqlite3_step(stmt);
1445         if (records != SQLITE_ROW || records == SQLITE_DONE) {
1446                 SLOGE("No valid records found for gname passed [%s].",gname);
1447                 result = CERTSVC_FAIL;
1448                 goto error;
1449         }
1450
1451         if (!(text = (const char *)sqlite3_column_text(stmt, 0))) {
1452                 SLOGE("No column text in returned records");
1453                 result = CERTSVC_FAIL;
1454                 goto error;
1455         }
1456
1457         strncpy(alias, text, strlen(text));
1458
1459         if (strlen(alias) == 0) {
1460                 SLOGE("Unable to get the alias name for the gname passed.");
1461                 result = CERTSVC_FAIL;
1462                 goto error;
1463         }
1464
1465         result = CERTSVC_SUCCESS;
1466
1467         SLOGD("success : getCertificateAliasFromStore");
1468 error:
1469         if (query)
1470                 sqlite3_free(query);
1471
1472         if (stmt)
1473                 sqlite3_finalize(stmt);
1474
1475         return result;
1476 }
1477
1478 int loadCertificatesFromStore(
1479         sqlite3 *db_handle,
1480         CertStoreType storeType,
1481         const char* gname,
1482         char **ppCertBlockBuffer,
1483         size_t *bufferLen,
1484         size_t *certBlockCount)
1485 {
1486         int result = CERTSVC_SUCCESS;
1487         size_t count = 0;
1488         int records = 0;
1489         sqlite3_stmt *stmt = NULL;
1490         char *query = NULL;
1491         char **certs = NULL;
1492         const char *tmpText = NULL;
1493         size_t i = 0;
1494
1495         query = sqlite3_mprintf("select associated_gname from %Q where gname=%Q", ((storeType==WIFI_STORE)? "wifi" : \
1496                                                    (storeType==VPN_STORE)? "vpn" : "email"), gname);
1497
1498         result = execute_select_query(db_handle, query, &stmt);
1499         if (result != CERTSVC_SUCCESS) {
1500                 SLOGE("Querying database failed.");
1501                 result = CERTSVC_FAIL;
1502                 goto error;
1503         }
1504
1505         records = sqlite3_step(stmt);
1506         if (records != SQLITE_ROW || records == SQLITE_DONE) {
1507                 SLOGE("No valid records found for gname passed [%s].",gname);
1508                 result = CERTSVC_FAIL;
1509                 goto error;
1510         }
1511
1512
1513         if (records == SQLITE_ROW) {
1514                 if (query)
1515                         sqlite3_free(query);
1516
1517                 const char *columnText = (const char *)sqlite3_column_text(stmt, 0);
1518                 if (!columnText) {
1519                         SLOGE("Failed to sqlite3_column_text");
1520                         result = CERTSVC_FAIL;
1521                         goto error;
1522                 }
1523
1524                 query = sqlite3_mprintf("select gname from %Q where associated_gname=%Q and enabled=%d and is_root_app_enabled=%d", \
1525                                                            ((storeType==WIFI_STORE)? "wifi" : (storeType==VPN_STORE)? "vpn" : "email"), \
1526                                                            columnText, ENABLED, ENABLED);
1527
1528                 if (stmt)
1529                         sqlite3_finalize(stmt);
1530
1531                 result = execute_select_query(db_handle, query, &stmt);
1532                 if (result != CERTSVC_SUCCESS) {
1533                         SLOGE("Querying database failed.");
1534                         result = CERTSVC_FAIL;
1535                         goto error;
1536                 }
1537
1538                 while (1) {
1539                         records = sqlite3_step(stmt);
1540                         if (records != SQLITE_ROW || records == SQLITE_DONE)
1541                                 break;
1542
1543                         if (count == 0) {
1544                                 certs = (char**) malloc(4 * sizeof(char *));
1545                                 if (!certs) {
1546                                         SLOGE("Failed to allocate memory");
1547                                         result = CERTSVC_BAD_ALLOC;
1548                                         goto error;
1549                                 }
1550                                 memset(certs, 0x00, 4 * sizeof(char *));
1551                         }
1552
1553                         if (records == SQLITE_ROW) {
1554                                 tmpText = (const char *)sqlite3_column_text(stmt, 0);
1555                                 if (!tmpText) {
1556                                         SLOGE("Failed to sqlite3_column_text.");
1557                                         result = CERTSVC_FAIL;
1558                                         goto error;
1559                                 }
1560
1561                                 if (!((certs)[count] = strdup(tmpText))) {
1562                                         SLOGE("Failed to allocate memory");
1563                                         result = CERTSVC_BAD_ALLOC;
1564                                         goto error;
1565                                 }
1566                         }
1567
1568                         count++;
1569                 }
1570
1571                 if (count == 0) {
1572                         SLOGE("No valid records found for the gname passed [%s].",gname);
1573                         return CERTSVC_FAIL;
1574                 }
1575         }
1576
1577         *certBlockCount = count;
1578         *bufferLen = count * sizeof(ResponseCertBlock);
1579         ResponseCertBlock *certBlockList = (ResponseCertBlock *) malloc(*bufferLen);
1580         if (!certBlockList) {
1581                 SLOGE("Failed to allocate memory for ResponseCertBlock");
1582                 result = CERTSVC_BAD_ALLOC;
1583                 goto error;
1584         }
1585
1586         if (count > 0)
1587                 memset(certBlockList, 0x00, *bufferLen);
1588
1589         ResponseCertBlock *currentBlock = NULL;
1590         for (i = 0; i < count; i++) {
1591                 currentBlock = certBlockList + i;
1592                 if (sizeof(currentBlock->dataBlock) < strlen(certs[i])) {
1593                         SLOGE("src is longer than dst. src[%s] dst size[%d]", certs[i], sizeof(currentBlock->dataBlock));
1594                         free(certBlockList);
1595                         result = CERTSVC_FAIL;
1596                         goto error;
1597                 }
1598                 strncpy(currentBlock->dataBlock, certs[i], strlen(certs[i]));
1599                 currentBlock->dataBlockLen = strlen(certs[i]);
1600         }
1601         *ppCertBlockBuffer = (char *)certBlockList;
1602
1603         result = CERTSVC_SUCCESS;
1604
1605         SLOGD("success: loadCertificatesFromStore. CERT_COUNT=%d", count);
1606
1607 error:
1608         if (query)
1609                 sqlite3_free(query);
1610
1611         if (stmt)
1612                 sqlite3_finalize(stmt);
1613
1614         if (certs) {
1615                 for(i = 0; i < count; i++)
1616                         free(certs[i]);
1617
1618                 free(certs);
1619         }
1620
1621         return result;
1622 }