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 #include <thread> 24 25 #include "ability.h" 26 #include "ability_context.h" 27 #include "access_token.h" 28 #include "accesstoken_kit.h" 29 #include "access_token_error.h" 30 #include "napi_common.h" 31 #include "napi_error.h" 32 #include "napi_context_common.h" 33 #include "napi/native_api.h" 34 #include "napi/native_node_api.h" 35 #include "permission_grant_info.h" 36 #include "perm_state_change_callback_customize.h" 37 #include "token_callback_stub.h" 38 #include "ui_content.h" 39 #include "ui_extension_context.h" 40 41 namespace OHOS { 42 namespace Security { 43 namespace AccessToken { 44 const int AT_PERM_OPERA_FAIL = -1; 45 const int AT_PERM_OPERA_SUCC = 0; 46 const int32_t PARAM_DEFAULT_VALUE = -1; 47 48 enum PermissionStateChangeType { 49 PERMISSION_REVOKED_OPER = 0, 50 PERMISSION_GRANTED_OPER = 1, 51 }; 52 53 static thread_local napi_ref g_atManagerRef_; 54 const std::string ATMANAGER_CLASS_NAME = "atManager"; 55 static int32_t curRequestCode_ = 0; 56 class RegisterPermStateChangeScopePtr : public std::enable_shared_from_this<RegisterPermStateChangeScopePtr>, 57 public PermStateChangeCallbackCustomize { 58 public: 59 explicit RegisterPermStateChangeScopePtr(const PermStateChangeScope& subscribeInfo); 60 ~RegisterPermStateChangeScopePtr() override; 61 void PermStateChangeCallback(PermStateChangeInfo& result) override; 62 void SetEnv(const napi_env& env); 63 void SetCallbackRef(const napi_ref& ref); 64 void SetValid(bool valid); 65 void DeleteNapiRef(); 66 private: 67 napi_env env_ = nullptr; 68 napi_ref ref_ = nullptr; 69 bool valid_ = true; 70 std::mutex validMutex_; 71 }; 72 73 struct RegisterPermStateChangeWorker { 74 napi_env env = nullptr; 75 napi_ref ref = nullptr; 76 PermStateChangeInfo result; 77 std::shared_ptr<RegisterPermStateChangeScopePtr> subscriber = nullptr; 78 }; 79 80 struct PermStateChangeContext { 81 virtual ~PermStateChangeContext(); 82 napi_env env = nullptr; 83 napi_ref callbackRef = nullptr; 84 int32_t errCode = RET_SUCCESS; 85 std::string permStateChangeType; 86 AccessTokenKit* accessTokenKit = nullptr; 87 std::thread::id threadId_; 88 std::shared_ptr<RegisterPermStateChangeScopePtr> subscriber = nullptr; 89 }; 90 91 typedef PermStateChangeContext RegisterPermStateChangeInfo; 92 93 struct UnregisterPermStateChangeInfo : public PermStateChangeContext { 94 PermStateChangeScope scopeInfo; 95 }; 96 97 struct AtManagerAsyncContext : public AtManagerAsyncWorkData { AtManagerAsyncContextAtManagerAsyncContext98 explicit AtManagerAsyncContext(napi_env env) : AtManagerAsyncWorkData(env) {} 99 100 AccessTokenID tokenId = 0; 101 std::string permissionName; 102 uint32_t flag = 0; 103 int32_t result = AT_PERM_OPERA_FAIL; 104 int32_t errorCode = 0; 105 }; 106 107 struct PermissionStatusCache { 108 int32_t status; 109 std::string paramValue; 110 }; 111 112 struct PermissionParamCache { 113 long long sysCommitIdCache = PARAM_DEFAULT_VALUE; 114 int32_t commitIdCache = PARAM_DEFAULT_VALUE; 115 int32_t handle = PARAM_DEFAULT_VALUE; 116 std::string sysParamCache; 117 }; 118 119 struct RequestAsyncContext : public AtManagerAsyncWorkData { RequestAsyncContextRequestAsyncContext120 explicit RequestAsyncContext(napi_env env) : AtManagerAsyncWorkData(env) 121 { 122 this->env = env; 123 } 124 125 AccessTokenID tokenId = 0; 126 bool needDynamicRequest = true; 127 int32_t result = AT_PERM_OPERA_SUCC; 128 std::vector<std::string> permissionList; 129 std::vector<int32_t> permissionsState; 130 napi_value requestResult = nullptr; 131 PermissionGrantInfo info; 132 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext; 133 std::shared_ptr<AbilityRuntime::UIExtensionContext> uiExtensionContext; 134 bool uiAbilityFlag = false; 135 }; 136 137 struct RequestAsyncContextHandle { RequestAsyncContextHandleRequestAsyncContextHandle138 explicit RequestAsyncContextHandle(std::shared_ptr<RequestAsyncContext>& requestAsyncContext) 139 { 140 asyncContextPtr = requestAsyncContext; 141 } 142 143 std::shared_ptr<RequestAsyncContext> asyncContextPtr; 144 }; 145 146 class UIExtensionCallback { 147 public: 148 explicit UIExtensionCallback(const std::shared_ptr<RequestAsyncContext>& reqContext); 149 ~UIExtensionCallback(); 150 void SetSessionId(int32_t sessionId); 151 void OnRelease(int32_t releaseCode); 152 void OnResult(int32_t resultCode, const OHOS::AAFwk::Want& result); 153 void OnReceive(const OHOS::AAFwk::WantParams& request); 154 void OnError(int32_t code, const std::string& name, const std::string& message); 155 void OnRemoteReady(const std::shared_ptr<OHOS::Ace::ModalUIExtensionProxy>& uiProxy); 156 void OnDestroy(); 157 void ReleaseOrErrorHandle(int32_t code); 158 159 private: 160 int32_t sessionId_ = 0; 161 std::shared_ptr<RequestAsyncContext> reqContext_ = nullptr; 162 }; 163 164 struct ResultCallback { 165 std::vector<std::string> permissions; 166 std::vector<int32_t> grantResults; 167 int32_t requestCode; 168 std::shared_ptr<RequestAsyncContext> data = nullptr; 169 }; 170 171 class AuthorizationResult : public Security::AccessToken::TokenCallbackStub { 172 public: AuthorizationResult(int32_t requestCode,std::shared_ptr<RequestAsyncContext> & data)173 AuthorizationResult(int32_t requestCode, std::shared_ptr<RequestAsyncContext>& data) 174 : requestCode_(requestCode), data_(data) 175 {} 176 virtual ~AuthorizationResult() override = default; 177 178 virtual void GrantResultsCallback(const std::vector<std::string>& permissions, 179 const std::vector<int>& grantResults) override; 180 181 private: 182 int32_t requestCode_ = 0; 183 std::shared_ptr<RequestAsyncContext> data_ = nullptr; 184 }; 185 186 class NapiAtManager { 187 public: 188 static napi_value Init(napi_env env, napi_value exports); 189 190 private: 191 static napi_value JsConstructor(napi_env env, napi_callback_info cbinfo); 192 static napi_value CreateAtManager(napi_env env, napi_callback_info cbInfo); 193 static napi_value VerifyAccessToken(napi_env env, napi_callback_info info); 194 static napi_value VerifyAccessTokenSync(napi_env env, napi_callback_info info); 195 static napi_value GrantUserGrantedPermission(napi_env env, napi_callback_info info); 196 static napi_value RevokeUserGrantedPermission(napi_env env, napi_callback_info info); 197 static napi_value CheckAccessToken(napi_env env, napi_callback_info info); 198 static napi_value GetPermissionFlags(napi_env env, napi_callback_info info); 199 static napi_value GetVersion(napi_env env, napi_callback_info info); 200 201 static bool ParseInputVerifyPermissionOrGetFlag(const napi_env env, const napi_callback_info info, 202 AtManagerAsyncContext& asyncContext); 203 static void VerifyAccessTokenExecute(napi_env env, void *data); 204 static void VerifyAccessTokenComplete(napi_env env, napi_status status, void *data); 205 static void CheckAccessTokenExecute(napi_env env, void* data); 206 static void CheckAccessTokenComplete(napi_env env, napi_status status, void* data); 207 static bool ParseInputGrantOrRevokePermission(const napi_env env, const napi_callback_info info, 208 AtManagerAsyncContext& asyncContext); 209 static void GrantUserGrantedPermissionExecute(napi_env env, void *data); 210 static void GrantUserGrantedPermissionComplete(napi_env env, napi_status status, void *data); 211 static void RevokeUserGrantedPermissionExecute(napi_env env, void *data); 212 static void RevokeUserGrantedPermissionComplete(napi_env env, napi_status status, void *data); 213 static void GetVersionExecute(napi_env env, void *data); 214 static void GetVersionComplete(napi_env env, napi_status status, void *data); 215 static void GetPermissionFlagsExecute(napi_env env, void *data); 216 static void GetPermissionFlagsComplete(napi_env env, napi_status status, void *data); 217 static void SetNamedProperty(napi_env env, napi_value dstObj, const int32_t objValue, const char *propName); 218 static bool FillPermStateChangeInfo(const napi_env env, const napi_value* argv, const std::string& type, 219 const napi_value thisVar, RegisterPermStateChangeInfo& registerPermStateChangeInfo); 220 static bool ParseInputToRegister(const napi_env env, const napi_callback_info cbInfo, 221 RegisterPermStateChangeInfo& registerPermStateChangeInfo); 222 static napi_value RegisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo); 223 static bool IsExistRegister(const napi_env env, const RegisterPermStateChangeInfo* registerPermStateChangeInfo); 224 static bool ParseInputToUnregister(const napi_env env, napi_callback_info cbInfo, 225 UnregisterPermStateChangeInfo& unregisterPermStateChangeInfo); 226 static napi_value UnregisterPermStateChangeCallback(napi_env env, napi_callback_info cbInfo); 227 static bool FindAndGetSubscriberInVector(UnregisterPermStateChangeInfo* unregisterPermStateChangeInfo, 228 std::vector<RegisterPermStateChangeInfo*>& batchPermStateChangeRegisters, const napi_env env); 229 static void DeleteRegisterFromVector(const PermStateChangeScope& scopeInfo, const napi_env env, 230 napi_ref subscriberRef); 231 static std::string GetPermParamValue(); 232 static void UpdatePermissionCache(AtManagerAsyncContext* asyncContext); 233 static napi_value RequestPermissionsFromUser(napi_env env, napi_callback_info info); 234 static bool ParseRequestPermissionFromUser( 235 const napi_env& env, const napi_callback_info& cbInfo, std::shared_ptr<RequestAsyncContext>& asyncContext); 236 static void RequestPermissionsFromUserComplete(napi_env env, napi_status status, void* data); 237 static void RequestPermissionsFromUserExecute(napi_env env, void* data); 238 static bool IsDynamicRequest(const std::vector<std::string>& permissions, std::vector<int32_t>& permissionsState, 239 PermissionGrantInfo& info); 240 }; 241 } // namespace AccessToken 242 } // namespace Security 243 } // namespace OHOS 244 /* 245 * function for module exports 246 */ 247 static napi_value Init(napi_env env, napi_value exports); 248 249 #endif /* INTERFACES_KITS_ACCESSTOKEN_NAPI_INCLUDE_NAPI_ATMANAGER_H */ 250