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