1 /* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #ifndef INTERFACES_KITS_ACCESSTOKEN_NAPI_INCLUDE_NAPI_ATMANAGER_H 16 #define INTERFACES_KITS_ACCESSTOKEN_NAPI_INCLUDE_NAPI_ATMANAGER_H 17 18 #include <pthread.h> 19 #include <cstdio> 20 #include <cstring> 21 #include <unistd.h> 22 #include <uv.h> 23 24 #include "ability.h" 25 #include "ability_context.h" 26 #include "access_token.h" 27 #include "accesstoken_kit.h" 28 #include "napi_common.h" 29 #include "napi_error.h" 30 #include "napi_context_common.h" 31 #include "napi/native_api.h" 32 #include "napi/native_node_api.h" 33 #include "perm_state_change_callback_customize.h" 34 #include "token_callback_stub.h" 35 36 namespace OHOS { 37 namespace Security { 38 namespace AccessToken { 39 const int AT_PERM_OPERA_FAIL = -1; 40 const int AT_PERM_OPERA_SUCC = 0; 41 const int32_t PARAM_DEFAULT_VALUE = -1; 42 43 enum PermissionStateChangeType { 44 PERMISSION_REVOKED_OPER = 0, 45 PERMISSION_GRANTED_OPER = 1, 46 }; 47 48 static thread_local napi_ref g_atManagerRef_; 49 const std::string ATMANAGER_CLASS_NAME = "atManager"; 50 static int32_t curRequestCode_ = 0; 51 class RegisterPermStateChangeScopePtr : public PermStateChangeCallbackCustomize { 52 public: 53 explicit RegisterPermStateChangeScopePtr(const PermStateChangeScope& subscribeInfo); 54 ~RegisterPermStateChangeScopePtr(); 55 void PermStateChangeCallback(PermStateChangeInfo& result) override; 56 void SetEnv(const napi_env& env); 57 void SetCallbackRef(const napi_ref& ref); 58 void SetValid(bool valid); 59 private: 60 napi_env env_ = nullptr; 61 napi_ref ref_ = nullptr; 62 bool valid_ = true; 63 std::mutex validMutex_; 64 }; 65 66 struct RegisterPermStateChangeWorker { 67 napi_env env = nullptr; 68 napi_ref ref = nullptr; 69 PermStateChangeInfo result; 70 RegisterPermStateChangeScopePtr* subscriber = nullptr; 71 }; 72 73 struct PermStateChangeContext { 74 virtual ~PermStateChangeContext(); 75 napi_env env = nullptr; 76 napi_ref callbackRef = nullptr; 77 int32_t errCode = RET_FAILED; 78 std::string permStateChangeType; 79 AccessTokenKit* accessTokenKit = nullptr; 80 std::shared_ptr<RegisterPermStateChangeScopePtr> subscriber = nullptr; 81 void DeleteNapiRef(); 82 }; 83 84 typedef PermStateChangeContext RegisterPermStateChangeInfo; 85 86 struct UnregisterPermStateChangeInfo : public PermStateChangeContext { 87 PermStateChangeScope scopeInfo; 88 }; 89 90 struct AtManagerAsyncContext : public AtManagerAsyncWorkData { AtManagerAsyncContextAtManagerAsyncContext91 explicit AtManagerAsyncContext(napi_env env) : AtManagerAsyncWorkData(env) {} 92 93 AccessTokenID tokenId = 0; 94 std::string permissionName; 95 int32_t flag = 0; 96 int32_t result = AT_PERM_OPERA_FAIL; 97 int32_t errorCode = 0; 98 }; 99 100 struct PermissionStatusCache { 101 int32_t status; 102 std::string paramValue; 103 }; 104 105 struct PermissionParamCache { 106 long long sysCommitIdCache = PARAM_DEFAULT_VALUE; 107 int32_t commitIdCache = PARAM_DEFAULT_VALUE; 108 int32_t handle = PARAM_DEFAULT_VALUE; 109 std::string sysParamCache; 110 }; 111 112 struct RequestAsyncContext : public AtManagerAsyncWorkData { RequestAsyncContextRequestAsyncContext113 explicit RequestAsyncContext(napi_env env) : AtManagerAsyncWorkData(env) {} 114 AccessTokenID tokenId = 0; 115 bool isResultCalled = true; 116 int32_t result = AT_PERM_OPERA_SUCC; 117 std::vector<std::string> permissionList; 118 std::vector<int32_t> permissionsState; 119 napi_value requestResult = nullptr; 120 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext; 121 }; 122 123 struct ResultCallback { 124 std::vector<std::string> permissions; 125 std::vector<int32_t> grantResults; 126 int32_t requestCode; 127 void* data = nullptr; 128 }; 129 130 class AuthorizationResult : public Security::AccessToken::TokenCallbackStub { 131 public: AuthorizationResult(int32_t requestCode,void * data)132 explicit AuthorizationResult(int32_t requestCode, void* data) : requestCode_(requestCode), data_(data) {} 133 virtual ~AuthorizationResult() = default; 134 135 virtual void GrantResultsCallback(const std::vector<std::string>& permissions, 136 const std::vector<int>& grantResults) override; 137 138 private: 139 int32_t requestCode_ = 0; 140 void* data_ = nullptr; 141 }; 142 143 class NapiAtManager { 144 public: 145 static napi_value Init(napi_env env, napi_value exports); 146 147 private: 148 static napi_value JsConstructor(napi_env env, napi_callback_info cbinfo); 149 static napi_value CreateAtManager(napi_env env, napi_callback_info cbInfo); 150 static napi_value VerifyAccessToken(napi_env env, napi_callback_info info); 151 static napi_value VerifyAccessTokenSync(napi_env env, napi_callback_info info); 152 static napi_value GrantUserGrantedPermission(napi_env env, napi_callback_info info); 153 static napi_value RevokeUserGrantedPermission(napi_env env, napi_callback_info info); 154 static napi_value CheckAccessToken(napi_env env, napi_callback_info info); 155 static napi_value GetPermissionFlags(napi_env env, napi_callback_info info); 156 static napi_value GetVersion(napi_env env, napi_callback_info info); 157 158 static bool ParseInputVerifyPermissionOrGetFlag(const napi_env env, const napi_callback_info info, 159 AtManagerAsyncContext& asyncContext); 160 static void VerifyAccessTokenExecute(napi_env env, void *data); 161 static void VerifyAccessTokenComplete(napi_env env, napi_status status, void *data); 162 static void CheckAccessTokenExecute(napi_env env, void* data); 163 static void CheckAccessTokenComplete(napi_env env, napi_status status, void* data); 164 static bool ParseInputGrantOrRevokePermission(const napi_env env, const napi_callback_info info, 165 AtManagerAsyncContext& asyncContext); 166 static void GrantUserGrantedPermissionExecute(napi_env env, void *data); 167 static void GrantUserGrantedPermissionComplete(napi_env env, napi_status status, void *data); 168 static void RevokeUserGrantedPermissionExecute(napi_env env, void *data); 169 static void RevokeUserGrantedPermissionComplete(napi_env env, napi_status status, void *data); 170 static void GetVersionExecute(napi_env env, void *data); 171 static void GetVersionComplete(napi_env env, napi_status status, void *data); 172 static void GetPermissionFlagsExecute(napi_env env, void *data); 173 static void GetPermissionFlagsComplete(napi_env env, napi_status status, void *data); 174 static void SetNamedProperty(napi_env env, napi_value dstObj, const int32_t objValue, const char *propName); 175 static bool FillPermStateChangeInfo(const napi_env env, const napi_value* argv, const std::string& type, 176 const napi_value thisVar, RegisterPermStateChangeInfo& registerPermStateChangeInfo); 177 static bool ParseInputToRegister(const napi_env env, napi_callback_info cbInfo, 178 RegisterPermStateChangeInfo& registerPermStateChangeInfo); 179 static napi_value RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo); 180 static bool IsExistRegister(const RegisterPermStateChangeInfo* registerPermStateChangeInfo); 181 static bool ParseInputToUnregister(const napi_env env, napi_callback_info cbInfo, 182 UnregisterPermStateChangeInfo& unregisterPermStateChangeInfo); 183 static napi_value UnregisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo); 184 static bool FindAndGetSubscriberInVector(UnregisterPermStateChangeInfo* unregisterPermStateChangeInfo); 185 static void DeleteRegisterInVector(const PermStateChangeScope& scopeInfo); 186 static std::string GetPermParamValue(); 187 static void UpdatePermissionCache(AtManagerAsyncContext* asyncContext); 188 static napi_value RequestPermissionsFromUser(napi_env env, napi_callback_info info); 189 static bool ParseRequestPermissionFromUser( 190 const napi_env& env, const napi_callback_info& cbInfo, RequestAsyncContext& asyncContext); 191 static void RequestPermissionsFromUserComplete(napi_env env, napi_status status, void* data); 192 static void RequestPermissionsFromUserExecute(napi_env env, void* data); 193 static bool IsDynamicRequest(const std::vector<std::string>& permissions, std::vector<int32_t>& permissionsState); 194 }; 195 } // namespace AccessToken 196 } // namespace Security 197 } // namespace OHOS 198 /* 199 * function for module exports 200 */ 201 static napi_value Init(napi_env env, napi_value exports); 202 203 #endif /* INTERFACES_KITS_ACCESSTOKEN_NAPI_INCLUDE_NAPI_ATMANAGER_H */ 204