1 /*
2 * Copyright (c) 2021 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 #include "script_manager_impl.h"
16 #include <cstring>
17 #include <dlfcn.h>
18 #include "dump.h"
19 #include "pkg_manager.h"
20 #include "script_instructionhelper.h"
21 #include "script_interpreter.h"
22 #include "script_utils.h"
23 #include "thread_pool.h"
24 #include "updater_const.h"
25 #include "utils.h"
26
27 using namespace Hpackage;
28
29 namespace Uscript {
30 constexpr const char *LOAD_SCRIPT_NAME = "loadScript.us";
31 constexpr const char *REGISTER_CMD_SCRIPT_NAME = "registerCmd.us";
32
33 static ScriptManagerImpl* g_scriptManager = nullptr;
GetScriptManager(UScriptEnv * env,const Hpackage::HashDataVerifier * verifier)34 ScriptManager* ScriptManager::GetScriptManager(UScriptEnv *env, const Hpackage::HashDataVerifier *verifier)
35 {
36 if (env == nullptr || verifier == nullptr) {
37 USCRIPT_LOGE("Env or verifier is null");
38 return nullptr;
39 }
40 if (g_scriptManager != nullptr) {
41 return g_scriptManager;
42 }
43 g_scriptManager = new (std::nothrow) ScriptManagerImpl(env, verifier);
44 if (g_scriptManager == nullptr) {
45 USCRIPT_LOGE("Create g_scriptManager failed");
46 return nullptr;
47 }
48 if (g_scriptManager->Init() != USCRIPT_SUCCESS) {
49 USCRIPT_LOGE("g_scriptManager init failed");
50 return nullptr;
51 }
52 return g_scriptManager;
53 }
54
ReleaseScriptManager()55 void ScriptManager::ReleaseScriptManager()
56 {
57 if (g_scriptManager != nullptr) {
58 delete g_scriptManager;
59 }
60 g_scriptManager = nullptr;
61 }
62
~ScriptManagerImpl()63 ScriptManagerImpl::~ScriptManagerImpl()
64 {
65 if (threadPool_) {
66 ThreadPool::Destroy();
67 threadPool_ = nullptr;
68 }
69 for (int i = 0; i < MAX_PRIORITY; i++) {
70 scriptFiles_[i].clear();
71 }
72 auto iter1 = scriptInstructions_.begin();
73 while (iter1 != scriptInstructions_.end()) {
74 UScriptInstructionPtr inst = (*iter1).second;
75 delete inst;
76 iter1 = scriptInstructions_.erase(iter1);
77 }
78 scriptInstructions_.clear();
79 ScriptInstructionHelper::ReleaseBasicInstructionHelper();
80 }
81
Init()82 int32_t ScriptManagerImpl::Init()
83 {
84 if (scriptEnv_ == nullptr) {
85 USCRIPT_LOGE("Env null");
86 return USCRIPT_INVALID_PARAM;
87 }
88
89 // Register system reserved instructions
90 ScriptInstructionHelper* helper = ScriptInstructionHelper::GetBasicInstructionHelper(this);
91 if (helper == nullptr) {
92 USCRIPT_LOGE("Failed to get helper");
93 return USCRIPT_INVALID_PARAM;
94 }
95 helper->RegisterInstructions();
96
97 // Register customized instructions
98 RegisterInstruction(*helper);
99
100 PkgManager::PkgManagerPtr manager = scriptEnv_->GetPkgManager();
101 if (manager == nullptr) {
102 USCRIPT_LOGE("Failed to get pkg manager");
103 return USCRIPT_INVALID_PARAM;
104 }
105
106 // Register other instructions from scripts
107 int32_t ret = USCRIPT_SUCCESS;
108 const FileInfo *registerScriptInfo = manager->GetFileInfo(REGISTER_CMD_SCRIPT_NAME);
109 if (registerScriptInfo != nullptr) {
110 ret = ExtractAndExecuteScript(manager, REGISTER_CMD_SCRIPT_NAME);
111 }
112 if (ret != USCRIPT_SUCCESS) {
113 USCRIPT_LOGE("Failed to extract and execute script %s", REGISTER_CMD_SCRIPT_NAME);
114 return ret;
115 }
116
117 // Collect scripts
118 const FileInfo *loadScriptInfo = manager->GetFileInfo(LOAD_SCRIPT_NAME);
119 if (loadScriptInfo != nullptr) {
120 ret = ExtractAndExecuteScript(manager, LOAD_SCRIPT_NAME);
121 }
122 if (ret != USCRIPT_SUCCESS) {
123 USCRIPT_LOGE("Failed to extract and execute script %s", LOAD_SCRIPT_NAME);
124 return ret;
125 }
126
127 int32_t threadnum = 0;
128 for (int32_t i = 0; i < ScriptManager::MAX_PRIORITY; i++) {
129 int32_t scriptFileSize = (static_cast<int32_t>(scriptFiles_[i].size()));
130 threadnum = threadnum > scriptFileSize ? threadnum : scriptFileSize;
131 }
132 threadPool_ = ThreadPool::CreateThreadPool(threadnum > MAX_THREAD_POOL ? MAX_THREAD_POOL : threadnum);
133 if (threadPool_ == nullptr) {
134 USCRIPT_LOGE("Failed to create thread pool");
135 return USCRIPT_INVALID_PARAM;
136 }
137 return USCRIPT_SUCCESS;
138 }
139
RegisterInstruction(ScriptInstructionHelper & helper)140 int32_t ScriptManagerImpl::RegisterInstruction(ScriptInstructionHelper &helper)
141 {
142 Uscript::UScriptInstructionFactoryPtr factory = scriptEnv_->GetInstructionFactory();
143 if (factory == nullptr) {
144 USCRIPT_LOGE("None factory");
145 return USCRIPT_SUCCESS;
146 }
147
148 for (auto instrName : scriptEnv_->GetInstructionNames()) {
149 // Create instructions and register it.
150 UScriptInstructionPtr instr = nullptr;
151 int32_t ret = factory->CreateInstructionInstance(instr, instrName);
152 if (ret != USCRIPT_SUCCESS) {
153 USCRIPT_LOGE("Failed to create instruction for %s", instrName.c_str());
154 return ret;
155 }
156 helper.AddInstruction(instrName, instr);
157 if (ret != USCRIPT_SUCCESS) {
158 USCRIPT_LOGE("Failed to add instruction for %s", instrName.c_str());
159 return ret;
160 }
161 }
162 return USCRIPT_SUCCESS;
163 }
164
ExtractAndExecuteScript(PkgManager::PkgManagerPtr manager,const std::string & scriptName)165 int32_t ScriptManagerImpl::ExtractAndExecuteScript(PkgManager::PkgManagerPtr manager,
166 const std::string &scriptName)
167 {
168 Updater::UPDATER_INIT_RECORD;
169 PkgManager::StreamPtr outStream = nullptr;
170 const std::string path = Updater::Utils::IsUpdaterMode() ? "/tmp" : Updater::UPDATER_PATH;
171 const FileInfo *info = manager->GetFileInfo(scriptName);
172 if (info == nullptr) {
173 USCRIPT_LOGE("Error to get file info");
174 UPDATER_LAST_WORD(USCRIPT_INVALID_PARAM, "Error to get file info");
175 return USCRIPT_INVALID_PARAM;
176 }
177 int32_t ret = manager->CreatePkgStream(outStream, path + "/" + scriptName,
178 info->unpackedSize, PkgStream::PkgStreamType_MemoryMap);
179 if (ret != USCRIPT_SUCCESS) {
180 USCRIPT_LOGE("Failed to create script stream %s", scriptName.c_str());
181 UPDATER_LAST_WORD(ret, "Failed to create script stream " + scriptName);
182 return ret;
183 }
184 ret = manager->ExtractFile(scriptName, outStream);
185 if (ret != USCRIPT_SUCCESS) {
186 manager->ClosePkgStream(outStream);
187 USCRIPT_LOGE("Failed to extract script stream %s", scriptName.c_str());
188 UPDATER_LAST_WORD(ret, "Failed to extract script stream" + scriptName);
189 return ret;
190 }
191 if (scriptVerifier_ == nullptr || !scriptVerifier_->VerifyHashData("build_tools/", scriptName, outStream)) {
192 manager->ClosePkgStream(outStream);
193 USCRIPT_LOGE("verify script %s by hash signed data failed", scriptName.c_str());
194 UPDATER_LAST_WORD(ret, "verify script by hash signed data failed" + scriptName);
195 return USCRIPT_INVALID_SCRIPT;
196 }
197 ret = ScriptInterpreter::ExecuteScript(this, outStream);
198 manager->ClosePkgStream(outStream);
199 if (ret != USCRIPT_SUCCESS) {
200 USCRIPT_LOGE("Failed to ExecuteScript %s", scriptName.c_str());
201 return ret;
202 }
203 return ret;
204 }
205
ExecuteScript(int32_t priority)206 int32_t ScriptManagerImpl::ExecuteScript(int32_t priority)
207 {
208 Updater::UPDATER_INIT_RECORD;
209 if (priority >= MAX_PRIORITY || priority < 0) {
210 USCRIPT_LOGE("ExecuteScript priority not support %d", priority);
211 UPDATER_LAST_WORD(USCRIPT_INVALID_PRIORITY, priority);
212 return USCRIPT_INVALID_PRIORITY;
213 }
214 PkgManager::PkgManagerPtr manager = scriptEnv_->GetPkgManager();
215 if (manager == nullptr) {
216 USCRIPT_LOGE("Failed to get pkg manager");
217 UPDATER_LAST_WORD(USCRIPT_INVALID_PARAM, "Failed to get pkg manager");
218 return USCRIPT_INVALID_PARAM;
219 }
220 if (scriptFiles_[priority].size() == 0) {
221 return USCRIPT_SUCCESS;
222 }
223
224 // Execute scripts
225 int32_t threadNumber = threadPool_->GetThreadNumber();
226 Task task;
227 int32_t ret = USCRIPT_SUCCESS;
228 int32_t retCode = USCRIPT_SUCCESS;
229 task.workSize = (static_cast<int32_t>(scriptFiles_[priority].size()));
230 task.processor = [&](int iter) {
231 for (size_t i = static_cast<size_t>(iter); i < scriptFiles_[priority].size();
232 i += static_cast<size_t>(threadNumber)) {
233 ret = ExtractAndExecuteScript(manager, scriptFiles_[priority][i]);
234 if (ret != USCRIPT_SUCCESS) {
235 USCRIPT_LOGE("Failed to execute script %s", scriptFiles_[priority][i].c_str());
236 retCode = ret;
237 }
238 }
239 };
240 ThreadPool::AddTask(std::move(task));
241 return retCode;
242 }
243
AddInstruction(const std::string & instrName,const UScriptInstructionPtr instruction)244 int32_t ScriptManagerImpl::AddInstruction(const std::string &instrName, const UScriptInstructionPtr instruction)
245 {
246 USCRIPT_LOGD("AddInstruction instrName: %s ", instrName.c_str());
247 if (scriptInstructions_.find(instrName) != scriptInstructions_.end()) {
248 USCRIPT_LOGW("Instruction: %s exist", instrName.c_str());
249 // New instruction has the same name
250 // with already registered instruction,
251 // just override it.
252 delete scriptInstructions_[instrName];
253 }
254 scriptInstructions_[instrName] = instruction;
255 return USCRIPT_SUCCESS;
256 }
257
AddScript(const std::string & scriptName,int32_t priority)258 int32_t ScriptManagerImpl::AddScript(const std::string &scriptName, int32_t priority)
259 {
260 Updater::UPDATER_INIT_RECORD;
261 if (priority < 0 || priority >= MAX_PRIORITY) {
262 USCRIPT_LOGE("Invalid priority %d", priority);
263 UPDATER_LAST_WORD(USCRIPT_INVALID_PRIORITY);
264 return USCRIPT_INVALID_PRIORITY;
265 }
266
267 PkgManager::PkgManagerPtr manager = scriptEnv_->GetPkgManager();
268 if (manager == nullptr) {
269 USCRIPT_LOGE("Failed to get pkg manager");
270 UPDATER_LAST_WORD(USCRIPT_INVALID_PARAM, "Failed to get pkg manager");
271 return USCRIPT_INVALID_PARAM;
272 }
273
274 if (manager->GetFileInfo(scriptName) == nullptr) {
275 USCRIPT_LOGE("Failed to access script %s", scriptName.c_str());
276 UPDATER_LAST_WORD(USCRIPT_INVALID_SCRIPT, "Failed to access script " + scriptName);
277 return USCRIPT_INVALID_SCRIPT;
278 }
279 scriptFiles_[priority].push_back(scriptName);
280 return USCRIPT_SUCCESS;
281 }
282
FindInstruction(const std::string & instrName)283 UScriptInstruction* ScriptManagerImpl::FindInstruction(const std::string &instrName)
284 {
285 if (scriptInstructions_.find(instrName) == scriptInstructions_.end()) {
286 return nullptr;
287 }
288 return scriptInstructions_[instrName];
289 }
290
GetScriptEnv(const std::string & instrName) const291 UScriptEnv* ScriptManagerImpl::GetScriptEnv(const std::string &instrName) const
292 {
293 return scriptEnv_;
294 }
295 } // namespace Uscript
296