Revert "[Badge] Removed package API calls"

This reverts commit 8a47d72481b1b6e32fe79afb957963b12698f5b5.

Change-Id: Iefe69e8befcd6a33e2fdf90af2b11b5c482db735

diff --git a/src/badge/badge.gyp b/src/badge/badge.gyp
index 7fc986e..da96e28 100644 (file)
--- a/src/badge/badge.gyp
+++ b/src/badge/badge.gyp
@@ -24,6 +24,7 @@
             'packages': [
               'aul',
               'badge',
+              'capi-appfw-package-manager',
               'vconf',
             ]
           },

diff --git a/src/badge/badge_manager.cc b/src/badge/badge_manager.cc
index 2f01421..b10dcb1 100644 (file)
--- a/src/badge/badge_manager.cc
+++ b/src/badge/badge_manager.cc
@@ -8,6 +8,8 @@
 #include <badge.h>
 #include <badge_internal.h>
 #include <fcntl.h>
+#include <package_manager.h>
+#include <pkgmgr-info.h>
 #include <unistd.h>
 
 #include "badge/badge_instance.h"
@@ -38,21 +40,52 @@ BadgeManager::~BadgeManager() {
 
 PlatformResult BadgeManager::SetBadgeCount(const std::string& app_id,
                                            unsigned int count) {
-  LoggerD("Entered");
-  LoggerD("app_id : %s ", app_id.c_str());
   int ret = BADGE_ERROR_SERVICE_NOT_READY;
   bool badge_exist = false;
   const char *app_id_str = app_id.c_str();
 
+  if (!IsAppInstalled(app_id)) {
+    LoggerE("fail to get pkgId");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "InvalidValues error : app_id");
+  }
+
+  ret = badge_is_existing(app_id_str, &badge_exist);
+  if (ret != BADGE_ERROR_NONE) {
+    LoggerE("Unknown error : %d", ret);
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
+  }
+
+  if (!badge_exist) {
+    PlatformResult status = CheckPermisionForCreatingBadge(app_id_str);
+    if (status.IsError()) return status;
+
+    ret = badge_create(app_id_str, app_id_str);
+    LoggerD("badge create : %", ret);
+
+    if (ret == BADGE_ERROR_PERMISSION_DENIED) {
+      LoggerE("Security error");
+      return PlatformResult(ErrorCode::SECURITY_ERR, "Security error");
+#ifdef PROFILE_WEARABLE
+    } else if (ret == BADGE_ERROR_INVALID_DATA) {
+#else
+    } else if (ret == BADGE_ERROR_INVALID_PARAMETER) {
+#endif
+      LoggerE("Invalid values error");
+      return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                            "Invalid values error");
+    } else if (ret != BADGE_ERROR_NONE && ret != BADGE_ERROR_ALREADY_EXIST) {
+      LoggerE("Unknown error");
+      return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Unknown error");
+    }
+  }
+
   ret = badge_set_count(app_id_str, count);
   LoggerE("set ret : %d count :%d ", ret, count);
 
   if (ret == BADGE_ERROR_PERMISSION_DENIED) {
     LoggerE("Security error");
     return PlatformResult(ErrorCode::SECURITY_ERR, "Security error");
-  } else if (ret == BADGE_ERROR_NOT_EXIST) {
-    LoggerE("Application is not installed");
-    return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Application is not installed");
 #ifdef PROFILE_WEARABLE
   } else if (ret == BADGE_ERROR_INVALID_DATA) {
 #else
@@ -71,28 +104,38 @@ PlatformResult BadgeManager::SetBadgeCount(const std::string& app_id,
 
 PlatformResult BadgeManager::GetBadgeCount(const std::string& app_id,
                                            unsigned int *count) {
-  LoggerD("Entered");
-  LoggerD("app_id %s" , app_id.c_str());
   assert(count);
 
   int ret = BADGE_ERROR_SERVICE_NOT_READY;
   bool badge_exist = false;
+  if (!IsAppInstalled(app_id)) {
+    LoggerE("fail to get pkgId");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "InvalidValues error : app_id");
+  }
+  ret = badge_is_existing(app_id.c_str(), &badge_exist);
+  if (ret != BADGE_ERROR_NONE) {
+    LoggerE("Unknown error : %d", ret);
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while checking badge.");
+  }
+  LoggerD("badge exist : %d", badge_exist);
+
+  if (!badge_exist) {
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "badge not exist. app_id: " + app_id);
+  }
 
   *count = 0;
   ret = badge_get_count(app_id.c_str(), count);
 
-  LoggerE("get ret : %d count :%d ", ret, count);
-
   switch (ret) {
     case BADGE_ERROR_NONE:
-      LoggerD("success get ret : %d count : %d", *count);
+      LoggerD("success get ret : %d count : ", *count);
       return PlatformResult(ErrorCode::NO_ERROR);
     case BADGE_ERROR_PERMISSION_DENIED:
       LoggerE("Security error");
       return PlatformResult(ErrorCode::SECURITY_ERR, "Security error.");
-    case BADGE_ERROR_NOT_EXIST:
-      LoggerE("Application is not installed");
-      return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Application is not installed");
 #ifdef PROFILE_WEARABLE
     case BADGE_ERROR_INVALID_DATA:
 #else
@@ -159,5 +202,172 @@ void BadgeManager::badge_changed_cb(unsigned int action, const char *pkgname,
   }
 }
 
+bool BadgeManager::IsAppInstalled(const std::string &app_id) {
+  int ret = PACKAGE_MANAGER_ERROR_NONE;
+  pkgmgrinfo_appinfo_h pkgmgrinfo_appinfo;
+  if (app_id.empty()) {
+    return false;
+  }
+  ret = pkgmgrinfo_appinfo_get_appinfo(app_id.c_str(), &pkgmgrinfo_appinfo);
+  if (ret != PMINFO_R_OK) {
+    return false;
+  }
+  return true;
+}
+
+PlatformResult BadgeManager::CheckPermisionForCreatingBadge(
+    const char *app_id) {
+  if (!app_id) {
+    LoggerE("InvalidValues error : app_id");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "InvalidValues error : app_id");
+  }
+
+  char *caller_appid = NULL;
+  caller_appid = GetPkgnameByPid();
+
+  if (!caller_appid) {
+    LoggerE("fail to get caller pkgId");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while getting caller pkgId.");
+  }
+
+  char *caller_pkgname = NULL;
+  caller_pkgname = GetPkgnameByAppid(caller_appid);
+  if (!caller_pkgname) {
+    if (caller_appid) {
+      free(caller_appid);
+    }
+    LoggerE("fail to get caller pkgId");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while getting caller pkgId.");
+  }
+
+  char *pkgname = NULL;
+  pkgname = GetPkgnameByAppid(app_id);
+  if (!pkgname) {
+    if (caller_appid) {
+      free(caller_appid);
+    }
+    if (caller_pkgname) {
+      free(caller_pkgname);
+    }
+    LoggerE("fail to get pkgId");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "InvalidValues error : app_id");
+  }
+
+  bool flag = true;
+  if (IsSameCertInfo(caller_pkgname, pkgname) != 1) {
+    LoggerE("The author signature is not match");
+    flag = false;
+  }
+
+  if (caller_appid) {
+    free(caller_appid);
+  }
+  if (caller_pkgname) {
+    free(caller_pkgname);
+  }
+  if (pkgname) {
+    free(pkgname);
+  }
+
+  if (!flag) {
+    LoggerE("Security error - cannot create badge");
+    return PlatformResult(ErrorCode::SECURITY_ERR,
+                          "Security error - cannot create badge");
+  }
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+char *BadgeManager::GetPkgnameByAppid(const char *app_id) {
+  char *pkg_id = NULL;
+  int ret = PACKAGE_MANAGER_ERROR_NONE;
+  if (!app_id) {
+    LoggerE("app_id is null");
+    return NULL;
+  }
+
+  ret = package_manager_get_package_id_by_app_id(app_id, &pkg_id);
+  if (ret != PACKAGE_MANAGER_ERROR_NONE) {
+    LoggerE("fail to get caller pkg_id : ", ret);
+    return NULL;
+  }
+  if (!pkg_id) {
+    LoggerE("fail to get caller pkg_id");
+    return NULL;
+  }
+
+  return pkg_id;
+}
+
+char *BadgeManager::GetPkgnameByPid() {
+  char *pkgname = NULL;
+  int pid = 0;
+  int ret = AUL_R_OK;
+  int fd = 0;
+  long max = 4096;
+
+  pid = getpid();
+  pkgname = static_cast<char *>(malloc(max));
+  if (!pkgname) {
+    LoggerE("fail to alloc memory");
+    return NULL;
+  }
+  memset(pkgname, 0x00, max);
+
+  ret = aul_app_get_pkgname_bypid(pid, pkgname, max);
+  if (ret != AUL_R_OK) {
+    fd = open("/proc/self/cmdline", O_RDONLY);
+    if (fd < 0) {
+      free(pkgname);
+      return NULL;
+    }
+
+    ret = read(fd, pkgname, max - 1);
+    if (ret <= 0) {
+      close(fd);
+      free(pkgname);
+      return NULL;
+    }
+
+    close(fd);
+  }
+
+  if (pkgname[0] == '\0') {
+    free(pkgname);
+    return NULL;
+  } else
+    return pkgname;
+}
+
+int BadgeManager::IsSameCertInfo(const char *caller, const char *pkgname) {
+  int ret = PACKAGE_MANAGER_ERROR_NONE;
+  package_manager_compare_result_type_e compare_result =
+      PACKAGE_MANAGER_COMPARE_MISMATCH;
+
+  if (!caller) {
+    return 0;
+  }
+  if (!pkgname) {
+    return 0;
+  }
+
+  LoggerE("pkgname : %d caller : ", pkgname, caller);
+
+  ret = package_manager_compare_package_cert_info(pkgname, caller,
+                                                  &compare_result);
+
+  LoggerE("result : %d %d", ret, compare_result);
+  if (ret == PACKAGE_MANAGER_ERROR_NONE &&
+      compare_result == PACKAGE_MANAGER_COMPARE_MATCH) {
+    return 1;
+  }
+
+  return 0;
+}
+
 }  // namespace badge
 }  // namespace extension

diff --git a/src/badge/badge_manager.h b/src/badge/badge_manager.h
index 912225a..19f6488 100644 (file)
--- a/src/badge/badge_manager.h
+++ b/src/badge/badge_manager.h
@@ -36,6 +36,12 @@ class BadgeManager {
   static void badge_changed_cb(unsigned int, const char*, unsigned int, void*);
 
  private:
+  common::PlatformResult CheckPermisionForCreatingBadge(const char* app_id);
+  char* GetPkgnameByAppid(const char* app_id);
+  char* GetPkgnameByPid();
+  int IsSameCertInfo(const char* caller, const char* pkgname);
+  bool IsAppInstalled(const std::string& app_id);
+
   BadgeInstance& instance_;
 
   bool is_cb_registered_;