src/CertificateServiceStub.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   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 #include <unique_ptr.h>
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <stdlib.h>
  21 #include <error.h>
  22 #include <memory.h>
  23 #include <new>
  24 #include <sys/stat.h>
  25 #include <assert.h>
  26 #include <dirent.h>
  27 #include <FBaseByteBuffer.h>
  28 #include <FBaseResult.h>
  29 #include <FBaseSysLog.h>
  30 #include <FBaseRt_EventDispatcher.h>
  31 #include <FIo_IpcServer.h>
  32 #include <FSec_AccessController.h>
  33 #include <FSec_AccessControlTypes.h>
  34 #include <FApp_AppInfo.h>
  35 #include <CertificateServiceStub.h>
  36 #include <FSecCert_CertMgrMessages.h>
  37 #include <FSecCert_CertServer.h>
  38
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Base::Collection;
  41 using namespace Tizen::Base::Runtime;
  42 using namespace Tizen::App;
  43 using namespace Tizen::Io;
  44
  45 namespace Tizen { namespace Security { namespace Cert
  46 {
  47
  48 _CertServiceStub::_CertServiceStub(void)
  49         : __pIpcServer(null)
  50         , __context(0)
  51         , __refCount(0)
  52 {
  53 }
  54
  55 _CertServiceStub::~_CertServiceStub(void)
  56 {
  57         if (__pIpcServer != null)
  58         {
  59                 __pIpcServer->Stop();
  60                 delete __pIpcServer;
  61         }
  62 }
  63
  64 result
  65 _CertServiceStub::Construct(void)
  66 {
  67         result r = E_SUCCESS;
  68
  69         std::unique_ptr< _IpcServer > pIpcServer(new (std::nothrow) _IpcServer());
  70         TryReturnResult(pIpcServer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
  71
  72         r = pIpcServer->Construct(L"osp.security.ipcserver.certmanager", *this);
  73         TryReturnResult(!IsFailed(r), r, r, "[%s] Failed to create IPC server(%s)", GetErrorMessage(r), "CertService");
  74
  75         __pIpcServer = pIpcServer.release();
  76
  77         // It was replaced into the script due to N_SE-53394 (mk-cert-db.sh)
  78         // _CertServer::InitializeDb();
  79
  80         return r;
  81 }
  82
  83 bool
  84 _CertServiceStub::OnUpdateRootCa(int type, Tizen::Io::_IpcBuffer certOldBufferIpc, Tizen::Io::_IpcBuffer certNewBufferIpc, result* pRet)
  85 {
  86         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_WRITE);
  87         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
  88
  89         *pRet = _CertServer::UpdateCaCertificate(static_cast< _CaCertType >(type), static_cast< char* >(certOldBufferIpc.pBuffer), certOldBufferIpc.size,
  90                                                                                          static_cast< char* >(certNewBufferIpc.pBuffer), certNewBufferIpc.size);
  91
  92 CATCH:
  93         return true;
  94 }
  95
  96 bool
  97 _CertServiceStub::OnRemoveRootCa(int type, Tizen::Io::_IpcBuffer certBufferIpc, int bufLen, result* pRet)
  98 {
  99         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_WRITE);
 100         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 101
 102         *pRet = _CertServer::RemoveCaCertificate(static_cast< _CaCertType >(type), static_cast< char* >(certBufferIpc.pBuffer), bufLen);
 103
 104 CATCH:
 105         return true;
 106 }
 107
 108 bool
 109 _CertServiceStub::OnInsertCaCertificate(int type, int format, Tizen::Io::_IpcBuffer pCert, long certLen, result* pRet)
 110 {
 111         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_WRITE);
 112         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 113
 114         *pRet = _CertServer::InsertCaCertificate(static_cast< _CaCertType >(type), static_cast< _CertFormat >(format), static_cast< byte* >(pCert.pBuffer), certLen);
 115
 116 CATCH:
 117         return true;
 118 }
 119
 120 bool
 121 _CertServiceStub::OnInsertUserCaCertificate(int format, Tizen::Io::_IpcBuffer pCert, int certLen, result* pRet)
 122 {
 123         *pRet = _CertServer::InsertUserCaCertificate(static_cast< _CertFormat >(format), static_cast< char* >(pCert.pBuffer), certLen);
 124
 125         return true;
 126 }
 127
 128 bool
 129 _CertServiceStub::OnInstallUserRootCertificate(Tizen::Io::_IpcBuffer filePath, result* pRet)
 130 {
 131         *pRet = _CertServer::InsertUserCaCertificate(static_cast< byte* >(filePath.pBuffer));
 132
 133         return true;
 134 }
 135
 136 //User Certificate APIs
 137 bool
 138 _CertServiceStub::OnInsertUserCertChainPrivateKey(Tizen::Io::_IpcBuffer certChainBufferIpc, int certSize, Tizen::Io::_IpcBuffer privateKeyBufferIpc, int userPriKeyLen, result* pRet)
 139 {
 140         result r = E_SUCCESS;
 141
 142         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_WRITE);
 143         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 144
 145         *pRet = _CertServer::InsertUserCertChainPrivateKey(static_cast< char* >(certChainBufferIpc.pBuffer), certSize, static_cast< char* >(privateKeyBufferIpc.pBuffer), userPriKeyLen);
 146
 147         r = UpdateCertStoreContext();
 148         TryCatchResult(!IsFailed(r), , r, "[%s] Failed to update certificate store context.", GetErrorMessage(r), "_CertServer");
 149
 150 CATCH:
 151         return true;
 152 }
 153
 154 bool
 155 _CertServiceStub::OnInsertCertificateChainWithPrivateKey(Tizen::Io::_IpcBuffer certChainPrivateKeyBufferIpc, int certChainPrivateKeyLength, result* pRet)
 156 {
 157         *pRet = _CertServer::InsertCertificateChainWithPrivateKey(static_cast< char* >(certChainPrivateKeyBufferIpc.pBuffer), certChainPrivateKeyLength);
 158
 159         return true;
 160 }
 161
 162 bool
 163 _CertServiceStub::OnInstallPkcs12Content(Tizen::Io::_IpcBuffer pkcs12FilePath, Tizen::Io::_IpcBuffer pkcs12ImportPassword, bool checkPrivilege, result* pRet)
 164 {
 165         result r = E_SUCCESS;
 166
 167         if (checkPrivilege == true)
 168         {
 169                 *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_WRITE);
 170                 TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 171         }
 172
 173         *pRet = _CertServer::InsertPkcs12Content(static_cast< char* >(pkcs12FilePath.pBuffer), static_cast< char* >(pkcs12ImportPassword.pBuffer));
 174
 175         r = UpdateCertStoreContext();
 176         TryCatchResult(!IsFailed(r), , r, "[%s] Failed to update certificate store context.", GetErrorMessage(r), "_CertServer");
 177
 178 CATCH:
 179         return true;
 180 }
 181
 182 bool
 183 _CertServiceStub::OnDeleteUserCertChainByCertId(int certId, result* pRet)
 184 {
 185         result r = E_SUCCESS;
 186
 187         *pRet = _CertServer::RemoveUserCertChainByCertId(certId);
 188
 189         r = UpdateCertStoreContext();
 190         TryCatchResult(!IsFailed(r), , r, "[%s] Failed to update certificate store context.", GetErrorMessage(r), "_CertServer");
 191
 192 CATCH:
 193         return true;
 194 }
 195
 196 bool
 197 _CertServiceStub::OnUninstallUserRootCertificateByCertId(int certId, result* pRet)
 198 {
 199         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_WRITE);
 200         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 201
 202         *pRet = _CertServer::RemoveUserCaCertificateByCertId(certId);
 203
 204 CATCH:
 205         return true;
 206 }
 207
 208 bool
 209 _CertServiceStub::OnGetUserCertChainByIssuerAndSubjectNameN(Tizen::Io::_IpcBuffer issuerBufferIpc, int issuerNameLen, Tizen::Io::_IpcBuffer subjectBufferIpc, int subNameLen, _CertificateListInfo* pCertList, result* pRet)
 210 {
 211         _CertificateListInfo* pCertListIpc = null;
 212
 213         *pRet = _CertServer::GetUserCertChainByIssuerAndSubjectNameN(static_cast< char* >(issuerBufferIpc.pBuffer), issuerNameLen, static_cast< char* >(subjectBufferIpc.pBuffer), subNameLen, pCertListIpc);
 214
 215         if (pCertListIpc != null)
 216         {
 217                 std::unique_ptr< _CertificateListInfo > pCertListAuto(pCertListIpc);
 218
 219                 pCertList->certFileId = pCertListIpc->certFileId;
 220
 221                 pCertList->format = pCertListIpc->format;
 222                 pCertList->certType = pCertListIpc->certType;
 223                 pCertList->length = pCertListIpc->length;
 224                 pCertList->priKeyLen = pCertListIpc->priKeyLen;
 225
 226                 memcpy(pCertList->certificate, pCertListIpc->certificate, _MAX_CERTIFICATE_SIZE);
 227                 memcpy(pCertList->privatekey, pCertListIpc->privatekey, _MAX_CERT_PRIVATE_KEY_SIZE);
 228
 229                 pCertList->pNext = pCertListIpc->pNext;
 230         }
 231         else
 232         {
 233                 memset(pCertList, 0, sizeof(*pCertList));
 234         }
 235
 236         return true;
 237 }
 238
 239 bool
 240 _CertServiceStub::OnGetUserCertificateByCertIdN(int certId, int encodingType, _CertInfo* pUserCertificateList, result* pRet)
 241 {
 242         _CertInfo* pUserCertificateInfoIpc = null;
 243
 244         *pRet = _CertServer::GetUserCertificateByCertIdN(certId, static_cast< _CertEncodingType >(encodingType), pUserCertificateInfoIpc);
 245
 246         if (pUserCertificateInfoIpc != null)
 247         {
 248                 std::unique_ptr< _CertInfo > pCertInfoAuto(pUserCertificateInfoIpc);
 249
 250                 pUserCertificateList->certId = pUserCertificateInfoIpc->certId;
 251                 pUserCertificateList->certFormat = pUserCertificateInfoIpc->certFormat;
 252                 pUserCertificateList->certType = pUserCertificateInfoIpc->certType;
 253                 pUserCertificateList->certLength = pUserCertificateInfoIpc->certLength;
 254                 pUserCertificateList->privateKeyLen = pUserCertificateInfoIpc->privateKeyLen;
 255
 256                 memcpy(pUserCertificateList->certificate, pUserCertificateInfoIpc->certificate, _MAX_CERTIFICATE_SIZE);
 257                 memcpy(pUserCertificateList->privatekey, pUserCertificateInfoIpc->privatekey, _MAX_CERT_PRIVATE_KEY_SIZE);
 258         }
 259         else
 260         {
 261                 memset(pUserCertificateList, 0, sizeof(*pUserCertificateList));
 262         }
 263         return true;
 264 }
 265
 266 bool
 267 _CertServiceStub::OnGetUserCertFieldInfoByCertId(int certId, _CertFieldInfos* pCertInfoBufferIpc, result* pRet)
 268 {
 269         _CertFieldInfos certInfo;
 270
 271         *pRet = _CertServer::GetUserCertFieldInfoByCertId(certId, &certInfo);
 272
 273         if (!IsFailed(*pRet))
 274         {
 275                 pCertInfoBufferIpc->certType = certInfo.certType;
 276                 pCertInfoBufferIpc->certFileId = certInfo.certFileId;
 277
 278                 memcpy(pCertInfoBufferIpc->serialNo, certInfo.serialNo, _MAX_SERIAL_NUMBER_SIZE + 1);
 279                 memcpy(pCertInfoBufferIpc->sigAlgorithm, certInfo.sigAlgorithm, _MAX_CERT_ALGORITHM_SIZE + 1);
 280                 memcpy(pCertInfoBufferIpc->validityFrom, certInfo.validityFrom, _MAX_CERT_VALIDITY_SIZE + 1);
 281                 memcpy(pCertInfoBufferIpc->validityTo, certInfo.validityTo, _MAX_CERT_VALIDITY_SIZE + 1);
 282                 memcpy(pCertInfoBufferIpc->subjectName, certInfo.subjectName, _MAX_ISSUER_SUBJECT_NAME_SIZE + 1);
 283                 memcpy(pCertInfoBufferIpc->issuerName, certInfo.issuerName, _MAX_ISSUER_SUBJECT_NAME_SIZE + 1);
 284                 memcpy(pCertInfoBufferIpc->fingerPrint, certInfo.fingerPrint, _MAX_CERT_FINGERPRINT_SIZE + 1);
 285
 286                 pCertInfoBufferIpc->fingerPrintLen = certInfo.fingerPrintLen;
 287
 288                 memcpy(pCertInfoBufferIpc->publicKey, certInfo.publicKey, _MAX_CERT_PUBLIC_KEY_SIZE + 1);
 289                 memcpy(static_cast< void* >(pCertInfoBufferIpc->certTypeFormat), static_cast< const void* >(certInfo.certTypeFormat), _MAX_CERT_TYPE_SIZE + 1);
 290
 291                 pCertInfoBufferIpc->certVersion = certInfo.certVersion;
 292
 293                 memcpy(pCertInfoBufferIpc->certTitle, certInfo.certTitle, _MAX_ISSUER_SUBJECT_NAME_SIZE + 1);
 294                 memcpy(pCertInfoBufferIpc->certSubTitle, certInfo.certSubTitle, _MAX_ISSUER_SUBJECT_NAME_SIZE + 1);
 295
 296         }
 297         else
 298         {
 299                 memset(pCertInfoBufferIpc, 0, sizeof(*pCertInfoBufferIpc));
 300         }
 301         return true;
 302 }
 303
 304
 305 bool
 306 _CertServiceStub::OnGetName(result* pRet)
 307 {
 308         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_READ);
 309         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 310
 311         *pRet = E_SUCCESS;
 312
 313 CATCH:
 314         return true;
 315 }
 316
 317 bool
 318 _CertServiceStub::OnCloseCertificateStore(int type, result* pRet)
 319 {
 320         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_READ);
 321         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 322
 323         TryCatchResult(type == _CERT_TYPE_USER_CERT, *pRet = E_SYSTEM, E_SYSTEM, "The cert is not user cert.");
 324
 325         if (__refCount > 0)
 326         {
 327                 __refCount -= 1;
 328
 329                 if (__refCount == 0 && __context != 0)
 330                 {
 331                         *pRet = _CertServer::CloseCertificateStore(reinterpret_cast< CertificateStoreCtx >(__context));
 332                         __context = 0;
 333                 }
 334         }
 335
 336         *pRet = E_SUCCESS;
 337
 338 CATCH:
 339         return true;
 340 }
 341
 342 bool
 343 _CertServiceStub::OnOpenCertificateStoreByType(int type, int* pCount, result* pRet)
 344 {
 345         void* pCertList = null;
 346
 347         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_READ);
 348         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 349
 350         TryCatchResult(type == _CERT_TYPE_USER_CERT, *pRet = E_SYSTEM, E_SYSTEM, "The cert is not user cert.");
 351
 352         if (__context == 0)
 353         {
 354                 *pCount = 0;
 355                 pCertList = _CertServer::OpenCertificateStoreByType(static_cast< _CaCertType >(type), pCount);
 356
 357                 __context = reinterpret_cast< int >(pCertList);
 358         }
 359         else
 360         {
 361                 *pCount = _CertServer::GetCertificateCount(reinterpret_cast< CertificateStoreCtx >(__context));
 362         }
 363
 364         __refCount += 1;
 365
 366         *pRet = E_SUCCESS;
 367
 368 CATCH:
 369         return true;
 370 }
 371
 372 bool
 373 _CertServiceStub::OnGetCertificateCount(int type, int* pCertCount, result* pRet)
 374 {
 375         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_READ);
 376         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 377
 378         TryCatchResult(type == _CERT_TYPE_USER_CERT, *pRet = E_SYSTEM, E_SYSTEM, "The cert is not user cert.");
 379
 380         *pCertCount = _CertServer::GetCertificateCount(reinterpret_cast< CertificateStoreCtx >(__context));
 381
 382         *pRet = E_SUCCESS;
 383
 384 CATCH:
 385         return true;
 386 }
 387
 388 bool
 389 _CertServiceStub::OnGetNextCertificate(int type, int curPos, int length, Tizen::Base::ByteBuffer* pCertBufferIpc, int* pNewPos, result* pRet)
 390 {
 391         char* pBuffer = null;
 392
 393         *pRet = _AccessController::CheckSystemPrivilege(__pIpcServer->GetClientPackageId(), _PRV_CERTIFICATE_READ);
 394         TryCatchResult(!IsFailed(*pRet), *pRet = E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method.");
 395
 396         TryCatchResult(type == _CERT_TYPE_USER_CERT, *pRet = E_SYSTEM, E_SYSTEM, "The cert is not user cert.");
 397
 398         pBuffer = new (std::nothrow) char[length];
 399         TryCatchResult(pBuffer, *pRet = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY]Allocation failed");
 400
 401         *pRet = _CertServer::GetNextCertificate(reinterpret_cast< CertificateStoreCtx >(__context), curPos, pBuffer, &length);
 402         *pNewPos = curPos;
 403
 404 CATCH:
 405         if (!IsFailed(*pRet))
 406         {
 407                 pCertBufferIpc->Construct(length);
 408                 pCertBufferIpc->SetArray(reinterpret_cast<const byte*>(pBuffer), 0, length);
 409                 pCertBufferIpc->Flip();
 410         }
 411         else
 412         {
 413                 SysLog(NID_SEC_CERT, "GetNextCertificate failed");
 414         }
 415         delete[] pBuffer;
 416
 417         return true;
 418 }
 419
 420 bool
 421 _CertServiceStub::OnRestoreRootCaIntegrity(void)
 422 {
 423         _CertServer::RestoreRootCaIntegrity();
 424         ClearLastResult();
 425         return true;
 426 }
 427
 428 result
 429 _CertServiceStub::UpdateCertStoreContext(void)
 430 {
 431         result r = E_SUCCESS;
 432         CertificateStoreCtx certList = null;
 433
 434         int count = 0;
 435
 436         if (__refCount > 0)
 437         {
 438                 if (__context != 0)
 439                 {
 440                         r = _CertServer::CloseCertificateStore(reinterpret_cast< CertificateStoreCtx >(__context));
 441                         TryReturnResult(!IsFailed(r), r, r, "[%s] Propagating.", GetErrorMessage(r));
 442                         __context = NULL;
 443                 }
 444                 certList = _CertServer::OpenCertificateStoreByType(_CERT_TYPE_USER_CERT, &count);
 445                 r = GetLastResult();
 446                 SysTryReturnResult(NID_SEC_CERT, !IsFailed(r), E_SYSTEM, "Failed to open certificate store.");
 447                 __context = reinterpret_cast< int >(certList);
 448
 449         }
 450         return r;
 451 }
 452
 453 void
 454 _CertServiceStub::OnIpcRequestReceived(_IpcServer& server, const IPC::Message& message)
 455 {
 456         IPC_BEGIN_MESSAGE_MAP(_CertServiceStub, message)
 457         IPC_MESSAGE_HANDLER_EX(CertServer_GetName, &server, OnGetName)
 458         IPC_MESSAGE_HANDLER_EX(CertServer_CloseCertificateStore, &server, OnCloseCertificateStore)
 459         IPC_MESSAGE_HANDLER_EX(CertServer_OpenCertificateStoreByType, &server, OnOpenCertificateStoreByType)
 460         IPC_MESSAGE_HANDLER_EX(CertServer_GetCertificateCount, &server, OnGetCertificateCount)
 461         IPC_MESSAGE_HANDLER_EX(CertServer_GetNextCertificate, &server, OnGetNextCertificate)
 462         IPC_MESSAGE_HANDLER_EX(CertServer_UpdateRootCa, &server, OnUpdateRootCa)
 463         IPC_MESSAGE_HANDLER_EX(CertServer_RemoveRootCa, &server, OnRemoveRootCa)
 464         IPC_MESSAGE_HANDLER_EX(CertServer_UninstallUserRootCertificateByCertId, &server, OnUninstallUserRootCertificateByCertId)
 465         IPC_MESSAGE_HANDLER_EX(CertServer_InsertCaCertificate, &server, OnInsertCaCertificate)
 466         IPC_MESSAGE_HANDLER_EX(CertServer_InsertUserCaCertificate, &server, OnInsertUserCaCertificate)
 467         IPC_MESSAGE_HANDLER_EX(CertServer_InstallUserRootCertificate, &server, OnInstallUserRootCertificate)
 468
 469         //User Certificates API
 470         IPC_MESSAGE_HANDLER_EX(CertServer_InsertUserCertChainPrivateKey, &server, OnInsertUserCertChainPrivateKey)
 471         IPC_MESSAGE_HANDLER_EX(CertServer_InsertCertificateChainWithPrivateKey, &server, OnInsertCertificateChainWithPrivateKey)
 472         IPC_MESSAGE_HANDLER_EX(CertServer_InstallPkcs12Content, &server, OnInstallPkcs12Content)
 473         IPC_MESSAGE_HANDLER_EX(CertServer_DeleteUserCertChainByCertId, &server, OnDeleteUserCertChainByCertId)
 474         IPC_MESSAGE_HANDLER_EX(CertServer_GetUserCertChainByIssuerAndSubjectNameN, &server, OnGetUserCertChainByIssuerAndSubjectNameN)
 475         IPC_MESSAGE_HANDLER_EX(CertServer_GetUserCertificateByCertIdN, &server, OnGetUserCertificateByCertIdN)
 476         IPC_MESSAGE_HANDLER_EX(CertServer_GetUserCertFieldInfoByCertId, &server, OnGetUserCertFieldInfoByCertId)
 477
 478         IPC_MESSAGE_HANDLER_EX(CertServer_RestoreRootCaIntegrity, &server, OnRestoreRootCaIntegrity)
 479
 480         IPC_END_MESSAGE_MAP_EX();
 481 }
 482
 483
 484 void
 485 _CertServiceStub::OnIpcServerStarted(const _IpcServer& server)
 486 {
 487
 488 }
 489
 490 void
 491 _CertServiceStub::OnIpcServerStopped(const _IpcServer& server)
 492 {
 493
 494 }
 495
 496 void
 497 _CertServiceStub::OnIpcClientConnected(const _IpcServer& server, int clientId)
 498 {
 499
 500 }
 501
 502 void
 503 _CertServiceStub::OnIpcClientDisconnected(const _IpcServer& server, int clientId)
 504 {
 505
 506 }
 507
 508 } } }