1 /*
2  * Copyright (c) 2022-2024 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 
16 #include "quick_fix_manager_service.h"
17 
18 #include "bundle_mgr_helper.h"
19 #include "hilog_tag_wrapper.h"
20 #include "hitrace_meter.h"
21 #include "permission_verification.h"
22 #include "quick_fix_error_utils.h"
23 #include "quick_fix_utils.h"
24 
25 namespace OHOS {
26 namespace AAFwk {
27 std::mutex QuickFixManagerService::mutex_;
28 sptr<QuickFixManagerService> QuickFixManagerService::instance_;
29 
GetInstance()30 sptr<QuickFixManagerService> QuickFixManagerService::GetInstance()
31 {
32     std::lock_guard<std::mutex> lock(mutex_);
33 
34     if (instance_ == nullptr) {
35         instance_ = new QuickFixManagerService();
36     }
37     return instance_;
38 }
39 
Init()40 bool QuickFixManagerService::Init()
41 {
42     std::lock_guard<std::mutex> lock(eventMutex_);
43     eventRunner_ = AppExecFwk::EventRunner::Create("QuickFixMgrSvrMain");
44     if (eventRunner_ == nullptr) {
45         TAG_LOGE(AAFwkTag::QUICKFIX, "Create event runner failed");
46         return false;
47     }
48 
49     eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(eventRunner_);
50     if (eventHandler_ == nullptr) {
51         TAG_LOGE(AAFwkTag::QUICKFIX, "Create event handler failed");
52         return false;
53     }
54 
55     return true;
56 }
57 
ApplyQuickFix(const std::vector<std::string> & quickFixFiles,bool isDebug)58 int32_t QuickFixManagerService::ApplyQuickFix(const std::vector<std::string> &quickFixFiles, bool isDebug)
59 {
60     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
61     TAG_LOGD(AAFwkTag::QUICKFIX, "called");
62     if (!AAFwk::PermissionVerification::GetInstance()->JudgeCallerIsAllowedToUseSystemAPI()) {
63         TAG_LOGE(AAFwkTag::QUICKFIX, "The caller is not system-app, can not use system-api");
64         return QUICK_FIX_NOT_SYSTEM_APP;
65     }
66     if (!AAFwk::PermissionVerification::GetInstance()->VerifyInstallBundlePermission()) {
67         return QUICK_FIX_VERIFY_PERMISSION_FAILED;
68     }
69 
70     auto bundleQfMgr = QuickFixUtil::GetBundleQuickFixMgrProxy();
71     if (bundleQfMgr == nullptr) {
72         TAG_LOGE(AAFwkTag::QUICKFIX, "Bundle quick fix manager is nullptr");
73         return QUICK_FIX_CONNECT_FAILED;
74     }
75 
76     auto appMgr = QuickFixUtil::GetAppManagerProxy();
77     if (appMgr == nullptr) {
78         TAG_LOGE(AAFwkTag::QUICKFIX, "App manager is nullptr");
79         return QUICK_FIX_CONNECT_FAILED;
80     }
81     auto applyTask = std::make_shared<QuickFixManagerApplyTask>(bundleQfMgr, appMgr, eventHandler_, this);
82     AddApplyTask(applyTask);
83     applyTask->Run(quickFixFiles, isDebug);
84 
85     return QUICK_FIX_OK;
86 }
87 
GetApplyedQuickFixInfo(const std::string & bundleName,ApplicationQuickFixInfo & quickFixInfo)88 int32_t QuickFixManagerService::GetApplyedQuickFixInfo(const std::string &bundleName,
89     ApplicationQuickFixInfo &quickFixInfo)
90 {
91     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
92     TAG_LOGD(AAFwkTag::QUICKFIX, "called");
93     if (!AAFwk::PermissionVerification::GetInstance()->JudgeCallerIsAllowedToUseSystemAPI()) {
94         TAG_LOGE(AAFwkTag::QUICKFIX, "The caller is not system-app, can not use system-api");
95         return QUICK_FIX_NOT_SYSTEM_APP;
96     }
97     if (!AAFwk::PermissionVerification::GetInstance()->VerifyGetBundleInfoPrivilegedPermission()) {
98         return QUICK_FIX_VERIFY_PERMISSION_FAILED;
99     }
100 
101     auto bundleMgrHelper = DelayedSingleton<AppExecFwk::BundleMgrHelper>::GetInstance();
102     if (bundleMgrHelper == nullptr) {
103         TAG_LOGE(AAFwkTag::QUICKFIX, "Failed to get bundle manager helper");
104         return QUICK_FIX_CONNECT_FAILED;
105     }
106 
107     AppExecFwk::BundleInfo bundleInfo;
108     if (!bundleMgrHelper->GetBundleInfo(bundleName, AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo,
109         AppExecFwk::Constants::ANY_USERID)) {
110         TAG_LOGE(AAFwkTag::QUICKFIX, "Get bundle info failed!");
111         return QUICK_FIX_GET_BUNDLE_INFO_FAILED;
112     }
113 
114     quickFixInfo.bundleName = bundleName;
115     quickFixInfo.bundleVersionCode = bundleInfo.versionCode;
116     quickFixInfo.bundleVersionName = bundleInfo.versionName;
117     quickFixInfo.appqfInfo = bundleInfo.applicationInfo.appQuickFix.deployedAppqfInfo;
118 
119     return QUICK_FIX_OK;
120 }
121 
RevokeQuickFix(const std::string & bundleName)122 int32_t QuickFixManagerService::RevokeQuickFix(const std::string &bundleName)
123 {
124     TAG_LOGD(AAFwkTag::QUICKFIX, "called");
125     if (!AAFwk::PermissionVerification::GetInstance()->JudgeCallerIsAllowedToUseSystemAPI()) {
126         TAG_LOGE(AAFwkTag::QUICKFIX, "The caller is not system-app, can not use system-api");
127         return QUICK_FIX_NOT_SYSTEM_APP;
128     }
129 
130     if (!AAFwk::PermissionVerification::GetInstance()->VerifyGetBundleInfoPrivilegedPermission() ||
131         !AAFwk::PermissionVerification::GetInstance()->VerifyInstallBundlePermission()) {
132         TAG_LOGE(AAFwkTag::QUICKFIX, "Permission verification failed");
133         return QUICK_FIX_VERIFY_PERMISSION_FAILED;
134     }
135 
136     if (CheckTaskRunningState(bundleName)) {
137         TAG_LOGE(AAFwkTag::QUICKFIX, "Has a apply quick fix task");
138         return QUICK_FIX_DEPLOYING_TASK;
139     }
140 
141     auto patchExists = false;
142     auto isSoContained = false;
143     auto ret = GetQuickFixInfo(bundleName, patchExists, isSoContained);
144     if (ret != QUICK_FIX_OK || !patchExists) {
145         TAG_LOGE(AAFwkTag::QUICKFIX, "Get bundle info failed or patch does not exist");
146         return QUICK_FIX_GET_BUNDLE_INFO_FAILED;
147     }
148 
149     auto appMgr = QuickFixUtil::GetAppManagerProxy();
150     if (appMgr == nullptr) {
151         TAG_LOGE(AAFwkTag::QUICKFIX, "App manager is nullptr");
152         return QUICK_FIX_CONNECT_FAILED;
153     }
154 
155     auto bundleQfMgr = QuickFixUtil::GetBundleQuickFixMgrProxy();
156     if (bundleQfMgr == nullptr) {
157         TAG_LOGE(AAFwkTag::QUICKFIX, "Bundle quick fix manager is nullptr");
158         return QUICK_FIX_CONNECT_FAILED;
159     }
160 
161     auto applyTask = std::make_shared<QuickFixManagerApplyTask>(bundleQfMgr, appMgr, eventHandler_, this);
162     if (applyTask == nullptr) {
163         TAG_LOGE(AAFwkTag::QUICKFIX, "Task connect failed");
164         return QUICK_FIX_CONNECT_FAILED;
165     }
166 
167     applyTask->InitRevokeTask(bundleName, isSoContained);
168     AddApplyTask(applyTask);
169     applyTask->RunRevoke();
170     return QUICK_FIX_OK;
171 }
172 
AddApplyTask(std::shared_ptr<QuickFixManagerApplyTask> applyTask)173 void QuickFixManagerService::AddApplyTask(std::shared_ptr<QuickFixManagerApplyTask> applyTask)
174 {
175     std::lock_guard<std::mutex> lock(taskMutex_);
176     applyTasks_.emplace_back(applyTask);
177 }
178 
RemoveApplyTask(std::shared_ptr<QuickFixManagerApplyTask> applyTask)179 void QuickFixManagerService::RemoveApplyTask(std::shared_ptr<QuickFixManagerApplyTask> applyTask)
180 {
181     std::lock_guard<std::mutex> lock(taskMutex_);
182     for (auto it = applyTasks_.begin(); it != applyTasks_.end();) {
183         if (*it == applyTask) {
184             it = applyTasks_.erase(it);
185         } else {
186             it++;
187         }
188     }
189 }
190 
CheckTaskRunningState(const std::string & bundleName)191 bool QuickFixManagerService::CheckTaskRunningState(const std::string &bundleName)
192 {
193     std::lock_guard<std::mutex> lock(taskMutex_);
194     for (auto &item : applyTasks_) {
195         if (item != nullptr && item->GetBundleName() == bundleName) {
196             return true;
197         }
198     }
199 
200     TAG_LOGD(AAFwkTag::QUICKFIX, "bundleName %{public}s not found in tasks", bundleName.c_str());
201     return false;
202 }
203 
GetQuickFixInfo(const std::string & bundleName,bool & patchExists,bool & isSoContained)204 int32_t QuickFixManagerService::GetQuickFixInfo(const std::string &bundleName, bool &patchExists, bool &isSoContained)
205 {
206     auto bundleMgrHelper = DelayedSingleton<AppExecFwk::BundleMgrHelper>::GetInstance();
207     if (bundleMgrHelper == nullptr) {
208         TAG_LOGE(AAFwkTag::QUICKFIX, "Failed to get bundle manager helper");
209         return QUICK_FIX_CONNECT_FAILED;
210     }
211 
212     AppExecFwk::BundleInfo bundleInfo;
213     if (!bundleMgrHelper->GetBundleInfo(bundleName, AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT, bundleInfo,
214         AppExecFwk::Constants::ANY_USERID)) {
215         TAG_LOGE(AAFwkTag::QUICKFIX, "Get bundle info failed");
216         return QUICK_FIX_GET_BUNDLE_INFO_FAILED;
217     }
218 
219     for (auto &item : bundleInfo.hapModuleInfos) {
220         if (!item.hqfInfo.moduleName.empty()) {
221             patchExists = true;
222             break;
223         }
224     }
225 
226     isSoContained = !bundleInfo.applicationInfo.appQuickFix.deployedAppqfInfo.nativeLibraryPath.empty();
227     return QUICK_FIX_OK;
228 }
229 }  // namespace AAFwk
230 }  // namespace OHOS
231