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);
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);
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);
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);
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     if (priority >= MAX_PRIORITY || priority < 0) {
209         USCRIPT_LOGE("ExecuteScript priority not support %d", priority);
210         UPDATER_LAST_WORD(USCRIPT_INVALID_PRIORITY, priority);
211         return USCRIPT_INVALID_PRIORITY;
212     }
213     PkgManager::PkgManagerPtr manager = scriptEnv_->GetPkgManager();
214     if (manager == nullptr) {
215         USCRIPT_LOGE("Failed to get pkg manager");
216         UPDATER_LAST_WORD(USCRIPT_INVALID_PARAM);
217         return USCRIPT_INVALID_PARAM;
218     }
219     if (scriptFiles_[priority].size() == 0) {
220         return USCRIPT_SUCCESS;
221     }
222 
223     // Execute scripts
224     int32_t threadNumber = threadPool_->GetThreadNumber();
225     Task task;
226     int32_t ret = USCRIPT_SUCCESS;
227     int32_t retCode = USCRIPT_SUCCESS;
228     task.workSize = (static_cast<int32_t>(scriptFiles_[priority].size()));
229     task.processor = [&](int iter) {
230         for (size_t i = static_cast<size_t>(iter); i < scriptFiles_[priority].size();
231             i += static_cast<size_t>(threadNumber)) {
232             ret = ExtractAndExecuteScript(manager, scriptFiles_[priority][i]);
233             if (ret != USCRIPT_SUCCESS) {
234                 USCRIPT_LOGE("Failed to execute script %s", scriptFiles_[priority][i].c_str());
235                 retCode = ret;
236             }
237         }
238     };
239     ThreadPool::AddTask(std::move(task));
240     return retCode;
241 }
242 
AddInstruction(const std::string & instrName,const UScriptInstructionPtr instruction)243 int32_t ScriptManagerImpl::AddInstruction(const std::string &instrName, const UScriptInstructionPtr instruction)
244 {
245     USCRIPT_LOGD("AddInstruction instrName: %s ", instrName.c_str());
246     if (scriptInstructions_.find(instrName) != scriptInstructions_.end()) {
247         USCRIPT_LOGW("Instruction: %s exist", instrName.c_str());
248         // New instruction has the same name
249         // with already registered instruction,
250         // just override it.
251         delete scriptInstructions_[instrName];
252     }
253     scriptInstructions_[instrName] = instruction;
254     return USCRIPT_SUCCESS;
255 }
256 
AddScript(const std::string & scriptName,int32_t priority)257 int32_t ScriptManagerImpl::AddScript(const std::string &scriptName, int32_t priority)
258 {
259     Updater::UPDATER_INIT_RECORD;
260     if (priority < 0 || priority >= MAX_PRIORITY) {
261         USCRIPT_LOGE("Invalid priority %d", priority);
262         UPDATER_LAST_WORD(USCRIPT_INVALID_PRIORITY);
263         return USCRIPT_INVALID_PRIORITY;
264     }
265 
266     PkgManager::PkgManagerPtr manager = scriptEnv_->GetPkgManager();
267     if (manager == nullptr) {
268         USCRIPT_LOGE("Failed to get pkg manager");
269         UPDATER_LAST_WORD(USCRIPT_INVALID_PARAM);
270         return USCRIPT_INVALID_PARAM;
271     }
272 
273     if (manager->GetFileInfo(scriptName) == nullptr) {
274         USCRIPT_LOGE("Failed to access script %s", scriptName.c_str());
275         UPDATER_LAST_WORD(USCRIPT_INVALID_SCRIPT);
276         return USCRIPT_INVALID_SCRIPT;
277     }
278     scriptFiles_[priority].push_back(scriptName);
279     return USCRIPT_SUCCESS;
280 }
281 
FindInstruction(const std::string & instrName)282 UScriptInstruction* ScriptManagerImpl::FindInstruction(const std::string &instrName)
283 {
284     if (scriptInstructions_.find(instrName) == scriptInstructions_.end()) {
285         return nullptr;
286     }
287     return scriptInstructions_[instrName];
288 }
289 
GetScriptEnv(const std::string & instrName) const290 UScriptEnv* ScriptManagerImpl::GetScriptEnv(const std::string &instrName) const
291 {
292     return scriptEnv_;
293 }
294 } // namespace Uscript
295