src/Manager/SmackManager.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        SmackManager.cpp
  19  * @brief       This is the implementation file for %SmackManager class.
  20  */
  21
  22 #include <dlfcn.h>
  23 #include <unique_ptr.h>
  24
  25 #include <FIoFile.h>
  26 #include <FIoRegistry.h>
  27 #include <FSecCryptoSha1Hash.h>
  28 #include <FBase_StringConverter.h>
  29
  30 #include "SmackManager.h"
  31 #include "InstallerDefs.h"
  32 #include "InstallerUtil.h"
  33
  34 using namespace Tizen::App;
  35 using namespace Tizen::Base;
  36 using namespace Tizen::Base::Collection;
  37 using namespace Tizen::Base::Utility;
  38 using namespace Tizen::Security::Cert;
  39 using namespace Tizen::Security::Crypto;
  40 using namespace Tizen::Io;
  41
  42 SmackManager::SmackManager(void)
  43 :__pContext(null)
  44 ,__isSmackEnable(false)
  45 {
  46         if (IsSmackEnable() == true)
  47         {
  48                 __isSmackEnable = true;
  49         }
  50 }
  51
  52 SmackManager::~SmackManager(void)
  53 {
  54 }
  55
  56 bool
  57 SmackManager::Construct(InstallationContext* pContext)
  58 {
  59         __pContext = pContext;
  60
  61         return true;
  62 }
  63
  64 bool
  65 SmackManager::Install(const PackageId& packageId)
  66 {
  67         if (__isSmackEnable == false)
  68         {
  69                 return true;
  70         }
  71
  72         int res = 0;
  73
  74         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
  75         TryReturn(pPackageId, false, "pPackageId is null.");
  76
  77         res = Install(pPackageId.get());
  78
  79         return true;
  80 }
  81
  82 bool
  83 SmackManager::Uninstall(const PackageId& packageId)
  84 {
  85         if (__isSmackEnable == false)
  86         {
  87                 return true;
  88         }
  89
  90         int res = 0;
  91
  92         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
  93         TryReturn(pPackageId, false, "pPackageId is null.");
  94
  95         res = Uninstall(pPackageId.get());
  96
  97         return true;
  98 }
  99
 100 bool
 101 SmackManager::AddLabelDir(const String& label, const String& dirPath, bool rootDirectory)
 102 {
 103         if (__isSmackEnable == false)
 104         {
 105                 return true;
 106         }
 107
 108         int res = 0;
 109         String realPath;
 110
 111         std::unique_ptr<char[]> pPath(_StringConverter::CopyToCharArrayN(dirPath));
 112         TryReturn(pPath, false, "pPath is null.");
 113
 114         if (InstallerUtil::IsSymlink(dirPath) == true)
 115         {
 116                 res = AddLabelDir("_", pPath.get());
 117                 InstallerUtil::GetRealPath(dirPath, realPath);
 118         }
 119         else
 120         {
 121                 realPath = dirPath;
 122         }
 123
 124         std::unique_ptr<char[]> pRealPath(_StringConverter::CopyToCharArrayN(realPath));
 125         TryReturn(pRealPath, false, "pRealPath is null");
 126
 127         if (rootDirectory == true)
 128         {
 129                 res = AddLabelDir("_", pRealPath.get());
 130         }
 131         else if (dirPath.Contains(L"shared") == true)
 132         {
 133                 res = AddLabelDir("*", pRealPath.get());
 134         }
 135         else
 136         {
 137                 std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(label));
 138                 TryReturn(pPackageId, false, "pPackageId is null");
 139
 140                 res = AddLabelDir(pPackageId.get(), pRealPath.get());
 141         }
 142
 143         return true;
 144 }
 145
 146 bool
 147 SmackManager::AddLabelSharedDir(const PackageId& packageId, const String& dirPath)
 148 {
 149         if (__isSmackEnable == false)
 150         {
 151                 return true;
 152         }
 153
 154         TryReturn(__pContext, false, "__pContext is null");
 155
 156         if (__pContext->__isVerificationMode == false)
 157         {
 158                 AppLog("VerificationMode is off.");
 159                 return true;
 160         }
 161
 162         int res = 0;
 163         String label = packageId;
 164
 165         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 166         TryReturn(pPackageId, false, "pPackageId is null.");
 167
 168         std::unique_ptr<char[]> pPath(_StringConverter::CopyToCharArrayN(dirPath));
 169         TryReturn(pPath, false, "pPath is null.");
 170
 171         if (dirPath.Contains(L"shared/data") == true)
 172         {
 173                 label = L"*";
 174                 //label.Append("_shareddata");
 175         }
 176         else if (dirPath.Contains(L"shared/res") == true)
 177         {
 178                 label = L"*";
 179                 //label.Append("_sharedres");
 180         }
 181         else if (dirPath.Contains(L"shared/trusted") == true)
 182         {
 183                 Sha1Hash hash;
 184                 String base64Value;
 185                 result r = E_SUCCESS;
 186
 187                 IListT<String *>* pAuthorCertList = __pContext->__pAuthorCertList;
 188                 TryReturn(pAuthorCertList, false, "pAuthorCertList is null.");
 189
 190                 String *pEntity = null;
 191                 r = pAuthorCertList->GetAt(0, pEntity);
 192                 TryReturn(!IsFailed(r), false, "pAuthorCertList->GetAt() is failed.");
 193                 TryReturn(pEntity, false, "pEntity is null.");
 194
 195                 std::unique_ptr<ByteBuffer> pEncodedData(StringUtil::DecodeBase64StringN(*pEntity));
 196                 TryReturn(pEncodedData, false, "pEncodedData is null.");
 197
 198                 std::unique_ptr<ByteBuffer> pHashValue(hash.GetHashN(*pEncodedData.get()));
 199                 TryReturn(pHashValue, false, "pHashValue is null.");
 200
 201                 r = StringUtil::EncodeToBase64String(*pHashValue, base64Value);
 202                 TryReturn(!IsFailed(r), false, "EncodeToBase64String() is failed.");
 203
 204                 // in smack, '/' is not allowed for label.
 205                 r = base64Value.Replace(L"/", L"#");
 206                 TryReturn(!IsFailed(r), false, "base64Value.Replace() is failed.");
 207
 208                 std::unique_ptr<char[]> pHashEncodedValue(_StringConverter::CopyToCharArrayN(base64Value));
 209                 TryReturn(pHashEncodedValue, false, "pHashEncodedValue is null.");
 210
 211                 label = pHashEncodedValue.get();
 212                 AppLog("pHashEncodedValue = [%s]", pHashEncodedValue.get());
 213         }
 214         else
 215         {
 216                 AppLog("Invalid Directory = [%ls]", dirPath.GetPointer());
 217                 return false;
 218         }
 219
 220         std::unique_ptr<char[]> pLabel(_StringConverter::CopyToCharArrayN(label));
 221         TryReturn(pLabel, false, "pLabel is null.");
 222
 223         res = AddLabelSharedDir(pPackageId.get(), pLabel.get(), pPath.get());
 224
 225         return true;
 226 }
 227
 228 bool
 229 SmackManager::AddSharedDirReaders(const Tizen::Base::String& label)
 230 {
 231         if (__isSmackEnable == false)
 232         {
 233                 return true;
 234         }
 235
 236         //int AddSharedDirReaders(const char* pSharedLabel, const char** ppAppList);
 237
 238         return true;
 239 }
 240
 241 bool
 242 SmackManager::AddFriend(const Tizen::App::PackageId& packageId1, const Tizen::App::PackageId& packageId2)
 243 {
 244         if (__isSmackEnable == false)
 245         {
 246                 return true;
 247         }
 248
 249         //int AddFriend(const char* pPackageId1, const char* pPackageId2);
 250
 251         return true;
 252 }
 253
 254 bool
 255 SmackManager::EnablePermissions(const PackageId& packageId)
 256 {
 257         if (__isSmackEnable == false)
 258         {
 259                 return true;
 260         }
 261
 262         TryReturn(__pContext, false, "__pContext is null");
 263
 264         int res = 0;
 265
 266         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 267         TryReturn(pPackageId, false, "pPackageId is null.");
 268
 269         if (__pContext->__pPrivilegeList)
 270         {
 271                 int count = __pContext->__pPrivilegeList->GetCount();
 272
 273                 const char** pList = new (std::nothrow) const char*[count+1];
 274                 TryReturn(pList, false, "pList is null.");
 275
 276                 for (int i = 0; i < count; i++)
 277                 {
 278                         String* pPrivilege = dynamic_cast < String* >(__pContext->__pPrivilegeList->GetAt(i));
 279                         if (pPrivilege)
 280                         {
 281                                 char* pPrivilegeString = _StringConverter::CopyToCharArrayN(*pPrivilege);
 282                                 TryReturn(pPrivilegeString, false, "pPrivilegeString is null.");
 283
 284                                 pList[i] = pPrivilegeString;
 285                         }
 286                  }
 287
 288                 pList[count] = null;
 289
 290                 res = EnablePermissions(pPackageId.get(), 1, pList, true);
 291
 292                 for (int i = 0; pList[i] != null; i++)
 293                 {
 294                         AppLog("delete Privilege - [%s]", pList[i]);
 295                         delete[] pList[i];
 296                  }
 297                 delete[] pList;
 298         }
 299
 300         if ((__pContext->__isPreloaded == true) && (__pContext->__isUpdated == false))
 301         {
 302                 String smackFile(L"/etc/smack/accesses2.d/");
 303                 smackFile.Append(packageId);
 304                 smackFile.Append(L"-temp.rule");
 305
 306                 String smackContext(packageId);
 307                 smackContext.Append(L" all.rule include");
 308
 309                 InstallerUtil::CreateInfoFile(smackFile, &smackContext);
 310         }
 311         else
 312         {
 313                 String script("/usr/bin/smackload-app.sh");
 314                 bool exist = File::IsFileExist(script);
 315                 script.Append(L" ");
 316                 script.Append(packageId);
 317
 318                 std::unique_ptr<char[]> pScript(_StringConverter::CopyToCharArrayN(script));
 319                 TryReturn(pScript, false, "pScript is null.");
 320
 321                 if (exist == true)
 322                 {
 323                         res = system(pScript.get());
 324                         AppLog("[smack] system(%s), result = [%d]", pScript.get(), res);
 325                 }
 326                 else
 327                 {
 328                         AppLog("[%ls] not found", script.GetPointer());
 329                 }
 330         }
 331
 332         return true;
 333 }
 334
 335 #if 0
 336 bool
 337 SmackManager::AddPermissions(const PackageId& packageId)
 338 {
 339         if (__isSmackEnable == false)
 340         {
 341                 return true;
 342         }
 343
 344         TryReturn(__pContext, false, "__pContext is null");
 345
 346         int res = 0;
 347
 348         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 349         TryReturn(pPackageId, false, "pPackageId is null.");
 350
 351         int count = __pContext->__pPrivilegeList->GetCount();
 352
 353         const char** pList = new (std::nothrow) const char*[count+1];
 354         TryReturn(pList, false, "pList is null.");
 355
 356         for (int i = 0; i < count; i++)
 357         {
 358                 String* pPrivilege = dynamic_cast < String* >(__pContext->__pPrivilegeList->GetAt(i));
 359                 if (pPrivilege)
 360                 {
 361                         char* pPrivilegeString = _StringConverter::CopyToCharArrayN(*pPrivilege);
 362                         TryReturn(pPrivilegeString, false, "pPrivilegeString is null.");
 363
 364                         pList[i] = pPrivilegeString;
 365                 }
 366          }
 367
 368         pList[count] = null;
 369
 370         res = AddPermissions(pPackageId.get(), pList);
 371
 372         if (__pContext->__isPreloaded == true)
 373         {
 374                 String smackFile(L"/etc/smack/accesses2.d/");
 375                 smackFile.Append(packageId);
 376                 smackFile.Append(L"-temp.rule");
 377
 378                 String smackContext(packageId);
 379                 smackContext.Append(L" all.rule include");
 380
 381                 InstallerUtil::CreateInfoFile(smackFile, &smackContext);
 382         }
 383         else
 384         {
 385                 String script("/usr/bin/smackload-app.sh");
 386                 bool exist = File::IsFileExist(script);
 387                 script.Append(L" ");
 388                 script.Append(packageId);
 389
 390                 std::unique_ptr<char[]> pScript(_StringConverter::CopyToCharArrayN(script));
 391                 TryReturn(pScript, false, "pScript is null.");
 392
 393                 if (exist == true)
 394                 {
 395                         res = system(pScript.get());
 396                         AppLog("[smack] system(%s), result = [%d]", pScript.get(), res);
 397                 }
 398                 else
 399                 {
 400                         AppLog("[%ls] not found", script.GetPointer());
 401                 }
 402         }
 403
 404         for (int i = 0; pList[i] != null; i++)
 405         {
 406                 AppLog("delete Privilege - [%s]", pList[i]);
 407                 delete[] pList[i];
 408          }
 409         delete[] pList;
 410
 411         return true;
 412 }
 413 #endif
 414
 415 bool
 416 SmackManager::RevokePermissions(const PackageId& packageId)
 417 {
 418         if (__isSmackEnable == false)
 419         {
 420                 return true;
 421         }
 422
 423         int res = 0;
 424
 425         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 426         TryReturn(pPackageId, false, "pPackageId is null.");
 427
 428         res = RevokePermissions(pPackageId.get());
 429
 430         return true;
 431 }
 432
 433 bool
 434 SmackManager::IsSmackEnable()
 435 {
 436         result r;
 437         Registry reg;
 438         String section(L"feature");
 439         String entry(L"smack");
 440         String value;
 441
 442         r = reg.Construct(CONFIG_PATH, "r");
 443         TryReturn(!IsFailed(r), false, "CONFIG file is not found.");
 444
 445         r = reg.GetValue(section, entry, value);
 446         TryReturn(!IsFailed(r), false, "GetValue is failed. entry = [%ls]", entry.GetPointer());
 447
 448         AppLog("[%ls is %ls.]", entry.GetPointer(), value.GetPointer());
 449
 450         if (value == L"on")
 451         {
 452                 return true;
 453         }
 454
 455         return false;
 456 }
 457
 458 int
 459 SmackManager::Install(const char* pPackageId)
 460 {
 461         int ret = 0;
 462         void* pHandle = null;
 463         char* pErrorMsg = null;
 464         int (*app_install)(const char*) = null;
 465
 466         pHandle = dlopen("libprivilege-control.so.0", RTLD_LAZY | RTLD_GLOBAL);
 467         if (!pHandle)
 468         {
 469                 AppLog("Install(): dlopen() failed. [%s]", dlerror());
 470                 return -1;
 471         }
 472
 473         app_install = reinterpret_cast <int (*)(const char*)>(dlsym(pHandle, "app_install"));
 474         pErrorMsg = dlerror();
 475         if ((pErrorMsg != null) || (app_install == null))
 476         {
 477                 AppLog("Install(): dlsym() failed. [%s]", pErrorMsg);
 478                 dlclose(pHandle);
 479                 return -1;
 480         }
 481
 482         AppLog("[smack] app_install(%s)", pPackageId);
 483         ret = app_install(pPackageId);
 484         AppLog("[smack] app_install(%s), result = [%d]", pPackageId, ret);
 485
 486         dlclose(pHandle);
 487
 488         return ret;
 489 }
 490
 491 int
 492 SmackManager::Uninstall(const char* pPackageId)
 493 {
 494         int ret = 0;
 495         void* pHandle = null;
 496         char* pErrorMsg = null;
 497         int (*app_uninstall)(const char*) = null;
 498
 499         pHandle = dlopen("libprivilege-control.so.0", RTLD_LAZY | RTLD_GLOBAL);
 500         if (!pHandle)
 501         {
 502                 AppLog("Uninstall(): dlopen() failed. [%s]", dlerror());
 503                 return -1;
 504         }
 505
 506         app_uninstall = reinterpret_cast <int (*)(const char*)>(dlsym(pHandle, "app_uninstall"));
 507         pErrorMsg = dlerror();
 508         if ((pErrorMsg != null) || (app_uninstall == null))
 509         {
 510                 AppLog("Uninstall(): dlsym() failed. [%s]", pErrorMsg);
 511                 dlclose(pHandle);
 512                 return -1;
 513         }
 514
 515         AppLog("[smack] app_uninstall(%s)", pPackageId);
 516         ret = app_uninstall(pPackageId);
 517         AppLog("[smack] app_uninstall(%s), result = [%d]", pPackageId, ret);
 518
 519         dlclose(pHandle);
 520
 521         return ret;
 522 }
 523
 524 int
 525 SmackManager::AddLabelDir(const char* pLabel, const char* pDirPath)
 526 {
 527         int ret = 0;
 528         void* pHandle = null;
 529         char* pErrorMsg = null;
 530         int (*app_label_dir)(const char*, const char*) = null;
 531
 532         pHandle = dlopen("libprivilege-control.so.0", RTLD_LAZY | RTLD_GLOBAL);
 533         if (!pHandle)
 534         {
 535                 AppLog("AddLabelDir(): dlopen() failed. [%s]", dlerror());
 536                 return -1;
 537         }
 538
 539         app_label_dir = reinterpret_cast <int (*)(const char*, const char*)>(dlsym(pHandle, "app_label_dir"));
 540         pErrorMsg = dlerror();
 541         if ((pErrorMsg != null) || (app_label_dir == null))
 542         {
 543                 AppLog("AddLabelDir(): dlsym() failed. [%s]", pErrorMsg);
 544                 dlclose(pHandle);
 545                 return -1;
 546         }
 547
 548         AppLog("[smack] app_label_dir(%s, %s)", pLabel, pDirPath);
 549         ret = app_label_dir(pLabel, pDirPath);
 550         AppLog("[smack] app_label_dir(%s, %s), result = [%d]", pLabel, pDirPath, ret);
 551
 552         dlclose(pHandle);
 553
 554         return 0;
 555 }
 556
 557 int
 558 SmackManager::AddLabelSharedDir(const char* pLabel, const char* pSharedLabel, const char* pDirPath)
 559 {
 560         int ret = 0;
 561         void* pHandle = null;
 562         char* pErrorMsg = null;
 563         int (*app_label_shared_dir)(const char*, const char*, const char*) = null;
 564
 565         pHandle = dlopen("libprivilege-control.so.0", RTLD_LAZY | RTLD_GLOBAL);
 566         if (!pHandle)
 567         {
 568                 AppLog("AddLabelSharedDir(): dlopen() failed. [%s]", dlerror());
 569                 return -1;
 570         }
 571
 572         app_label_shared_dir = reinterpret_cast <int (*)(const char*, const char*, const char*)>(dlsym(pHandle, "app_label_shared_dir"));
 573         pErrorMsg = dlerror();
 574         if ((pErrorMsg != null) || (app_label_shared_dir == null))
 575         {
 576                 AppLog("AddLabelSharedDir(): dlsym() failed. [%s]", pErrorMsg);
 577                 dlclose(pHandle);
 578                 return -1;
 579         }
 580
 581         AppLog("[smack] app_label_shared_dir(%s, %s, %s)", pLabel, pSharedLabel, pDirPath);
 582         ret = app_label_shared_dir(pLabel, pSharedLabel, pDirPath);
 583         AppLog("[smack] app_label_shared_dir(%s, %s, %s), result = [%d]", pLabel, pSharedLabel, pDirPath, ret);
 584
 585         dlclose(pHandle);
 586
 587         return 0;
 588 }
 589
 590 int
 591 SmackManager::AddSharedDirReaders(const char* pSharedLabel, const char** ppAppList)
 592 {
 593         int ret = 0;
 594         void* pHandle = null;
 595         char* pErrorMsg = null;
 596         int (*add_shared_dir_readers)(const char*, const char**) = null;
 597
 598         pHandle = dlopen("libprivilege-control.so.0", RTLD_LAZY | RTLD_GLOBAL);
 599         if (!pHandle)
 600         {
 601                 AppLog("AddSharedDirReaders(): dlopen() failed. [%s]", dlerror());
 602                 return -1;
 603         }
 604
 605         add_shared_dir_readers = reinterpret_cast <int (*)(const char*, const char**)>(dlsym(pHandle, "add_shared_dir_readers"));
 606         pErrorMsg = dlerror();
 607         if ((pErrorMsg != null) || (add_shared_dir_readers == null))
 608         {
 609                 AppLog("AddSharedDirReaders(): dlsym() failed. [%s]", pErrorMsg);
 610                 dlclose(pHandle);
 611                 return -1;
 612         }
 613
 614         AppLog("[smack] add_shared_dir_readers(%s)", pSharedLabel);
 615         ret = add_shared_dir_readers(pSharedLabel, ppAppList);
 616         AppLog("[smack] add_shared_dir_readers(%s), result = [%d]", pSharedLabel, ret);
 617
 618         dlclose(pHandle);
 619
 620         return 0;
 621 }
 622
 623 int
 624 SmackManager::AddFriend(const char* pPackageId1, const char* pPackageId2)
 625 {
 626         int ret = 0;
 627         void* pHandle = null;
 628         char* pErrorMsg = null;
 629         int (*app_add_friend)(const char*, const char*) = null;
 630
 631         pHandle = dlopen("libprivilege-control.so.0", RTLD_LAZY | RTLD_GLOBAL);
 632         if (!pHandle)
 633         {
 634                 AppLog("AddFriend(): dlopen() failed. [%s]", dlerror());
 635                 return -1;
 636         }
 637
 638         app_add_friend = reinterpret_cast <int (*)(const char*, const char*)>(dlsym(pHandle, "app_add_friend"));
 639         pErrorMsg = dlerror();
 640         if ((pErrorMsg != null) || (app_add_friend == null))
 641         {
 642                 AppLog("AddFriend(): dlsym() failed. [%s]", pErrorMsg);
 643                 dlclose(pHandle);
 644                 return -1;
 645         }
 646
 647         AppLog("[smack] app_add_friend(%s, %s)", pPackageId1, pPackageId2);
 648         ret = app_add_friend(pPackageId1, pPackageId2);
 649         AppLog("[smack] app_add_friend(%s, %s), result = [%d]", pPackageId1, pPackageId2, ret);
 650
 651         dlclose(pHandle);
 652
 653         return 0;
 654 }
 655
 656 int
 657 SmackManager::EnablePermissions(const char* pPackageId, int appType, const char** ppPermissions, bool persistent)
 658 {
 659         int ret = 0;
 660         void* pHandle = null;
 661         char* pErrorMsg = null;
 662         int (*app_enable_permissions)(const char*, int, const char**, bool) = null;
 663
 664         pHandle = dlopen("libprivilege-control.so.0", RTLD_LAZY | RTLD_GLOBAL);
 665         if (!pHandle)
 666         {
 667                 AppLog("EnablePermissions(): dlopen() failed. [%s]", dlerror());
 668                 return -1;
 669         }
 670
 671         app_enable_permissions = reinterpret_cast <int (*)(const char*, int, const char**, bool)>(dlsym(pHandle, "app_enable_permissions"));
 672         pErrorMsg = dlerror();
 673         if ((pErrorMsg != null) || (app_enable_permissions == null))
 674         {
 675                 AppLog("EnablePermissions(): dlsym() failed. [%s]", pErrorMsg);
 676                 dlclose(pHandle);
 677                 return -1;
 678         }
 679
 680         AppLog("[smack] app_enable_permissions(%s, %d)", pPackageId, appType);
 681         ret = app_enable_permissions(pPackageId, appType, ppPermissions, persistent);
 682         AppLog("[smack] app_enable_permissions(%s, %d), result = [%d]", pPackageId, appType, ret);
 683
 684         dlclose(pHandle);
 685
 686         return 0;
 687 }
 688
 689 int
 690 SmackManager::RevokePermissions(const char* pPackageId)
 691 {
 692         int ret = 0;
 693         void* pHandle = null;
 694         char* pErrorMsg = null;
 695         int (*app_revoke_permissions)(const char*) = null;
 696
 697         pHandle = dlopen("libprivilege-control.so.0", RTLD_LAZY | RTLD_GLOBAL);
 698         if (!pHandle)
 699         {
 700                 AppLog("RevokePermissions(): dlopen() failed. [%s][%s]", pPackageId, dlerror());
 701                 return -1;
 702         }
 703
 704         app_revoke_permissions = reinterpret_cast <int (*)(const char*)>(dlsym(pHandle, "app_revoke_permissions"));
 705         pErrorMsg = dlerror();
 706         if ((pErrorMsg != null) || (app_revoke_permissions == null))
 707         {
 708                 AppLog("RevokePermissions(): dlsym() failed. [%s][%s]", pPackageId, pErrorMsg);
 709                 dlclose(pHandle);
 710                 return -1;
 711         }
 712
 713         AppLog("[smack] app_revoke_permissions(%s)", pPackageId);
 714         ret = app_revoke_permissions(pPackageId);
 715         AppLog("[smack] app_revoke_permissions(%s), result = [%d]", pPackageId, ret);
 716
 717         dlclose(pHandle);
 718
 719         return 0;
 720 }
 721
 722 #if 0
 723 int
 724 SmackManager::AddPermissions(const char* pPackageId, const char** ppPermissions)
 725 {
 726         int ret = 0;
 727         void* pHandle = null;
 728         char* pErrorMsg = null;
 729         int (*app_add_permissions)(const char*, const char**) = null;
 730
 731         pHandle = dlopen("libprivilege-control.so.0", RTLD_LAZY | RTLD_GLOBAL);
 732         if (!pHandle)
 733         {
 734                 AppLog("AddPermissions(): dlopen() failed. [%s][%s]", pPackageId, dlerror());
 735                 return -1;
 736         }
 737
 738         app_add_permissions = reinterpret_cast <int (*)(const char*, const char**)>(dlsym(pHandle, "app_add_permissions"));
 739         pErrorMsg = dlerror();
 740         if ((pErrorMsg != null) || (app_add_permissions == null))
 741         {
 742                 AppLog("AddPermissions(): dlsym() failed. [%s][%s]", pPackageId, pErrorMsg);
 743                 dlclose(pHandle);
 744                 return -1;
 745         }
 746
 747         for (int i = 0; ppPermissions[i] != null; i++)
 748         {
 749                 AppLog("Privilege - [%s]", ppPermissions[i]);
 750          }
 751
 752         ret = app_add_permissions(pPackageId, ppPermissions);
 753         AppLog("[smack] app_add_permissions(%s), result = [%d]", pPackageId, ret);
 754
 755         dlclose(pHandle);
 756
 757         return 0;
 758 }
 759 #endif