Modify the parameter name of the database function
[platform/core/dotnet/launcher.git] / NativeLauncher / tool / tac_common.cc
1 /*
2  * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
3  *
4  * Licensed under the Apache License, Version 2.0 (the License);
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an AS IS BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <fstream>
18 #include <json/json.h>
19 #include <pkgmgr-info.h>
20 #include <pkgmgr_installer_info.h>
21
22 #include "log.h"
23 #include "utils.h"
24 #include "tac_common.h"
25 #include "db_manager.h"
26 #include "path_manager.h"
27
28 #ifdef  LOG_TAG
29 #undef  LOG_TAG
30 #endif
31 #define LOG_TAG "DOTNET_INSTALLER_PLUGIN"
32
33 #define __XSTR(x) #x
34 #define __STR(x) __XSTR(x)
35 static const char* __TAC_DIR = __STR(TAC_DIR);
36 #undef __STR
37 #undef __XSTR
38
39 static sqlite3 *tac_db = NULL;
40 std::vector<std::string> restore_nuget;
41
42 static void cleanupDirectory()
43 {
44         std::vector<std::string> removeNuget;
45         try {
46                 for (auto& nuget : bf::recursive_directory_iterator(__TAC_DIR)) {
47                         bool isExist = false;
48                         std::string nugetPath = nuget.path().string();
49                         for (auto& restore : restore_nuget) {
50                                 if (!bf::is_directory(nugetPath)) {
51                                         isExist = true;
52                                 }
53                                 if (!strcmp(nugetPath.c_str(), restore.c_str()) ||
54                                         !strcmp(nugetPath.c_str(), restore.substr(0, restore.rfind('/')).c_str())) {
55                                         isExist = true;
56                                         break;
57                                 }
58                         }
59                         if (!isExist) {
60                                 removeNuget.push_back(nugetPath);
61                         }
62                 }
63
64                 for (auto& rm : removeNuget) {
65                         if (!removeAll(rm)) {
66                                 fprintf(stderr, "Failed to remove of %s\n", rm.c_str());
67                         }
68                 }
69                 removeNuget.clear();
70         } catch (const bf::filesystem_error& error) {
71                 fprintf(stderr, "Failed to recursive directory: %s\n", error.what());
72                 return;
73         }
74 }
75
76 // callback function of "pkgmgrinfo_appinfo_metadata_filter_foreach"
77 static int restoreDBCb(pkgmgrinfo_appinfo_h handle, void *userData)
78 {
79         char *pkgId = NULL;
80         char *root = NULL;
81         char *exec = NULL;
82         std::string rootPath;
83         std::string execName;
84
85         int ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgId);
86         if (ret != PMINFO_R_OK) {
87                 fprintf(stderr, "Failed to get pkgid\n");
88                 return -1;
89         }
90
91         enableTACPackage(std::string(pkgId));
92
93         ret = pkgmgrinfo_appinfo_get_root_path(handle, &root);
94         if (ret != PMINFO_R_OK) {
95                 fprintf(stderr, "Failed to get root path\n");
96                 return -1;
97         }
98         rootPath = root;
99
100         ret = pkgmgrinfo_appinfo_get_exec(handle, &exec);
101         if (ret != PMINFO_R_OK) {
102                 fprintf(stderr, "Failed to get exec name\n");
103                 return -1;
104         }
105         execName = std::string(exec).substr(std::string(exec).rfind('/') + 1);
106
107         std::vector<std::string> parserData;
108         std::string binDir = concatPath(rootPath, "bin");
109         std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
110         for (auto& npAssembly : depsJsonParser(rootPath, execName, getTPA())) {
111                 std::string nugetPackage = npAssembly.substr(0, npAssembly.rfind(':'));
112                 std::string assemblyName = npAssembly.substr(npAssembly.rfind(':') + 1);
113                 if (bf::exists(tacDir) && bf::exists(concatPath(tacDir, assemblyName))) {
114                         parserData.push_back(nugetPackage);
115                 }
116         }
117         std::sort(parserData.begin(), parserData.end());
118         parserData.erase(unique(parserData.begin(), parserData.end()), parserData.end());
119
120         for (auto& nuget : parserData) {
121                 if (tac_db) {
122                         std::string name = nuget.substr(0, nuget.find('/'));
123                         std::string version = nuget.substr(nuget.rfind('/') + 1);
124                         char *sql = sqlite3_mprintf(
125                                 "INSERT INTO TAC (PKGID, NUGET, NAME, VERSION) " \
126                                 "VALUES (%Q, %Q, %Q, %Q);",     pkgId, nuget.c_str(), name.c_str(), version.c_str());
127                         dbInsert(tac_db, TAC_APP_LIST_RESTORE_DB, sql);
128                         restore_nuget.push_back(concatPath(__TAC_DIR, nuget));
129                         sqlite3_free(sql);
130                 }
131         }
132         parserData.clear();
133         return 0;
134 }
135
136 tac_error_e restoreTACDB()
137 {
138         if (!removeFile(TAC_APP_LIST_RESTORE_DB)) {
139                 fprintf(stderr, "Failed to remove of %s\n", TAC_APP_LIST_RESTORE_DB);
140                 return TAC_ERROR_UNKNOWN;
141         }
142
143         std::string dbRestoreJournal = TAC_APP_LIST_RESTORE_DB + std::string("-journal");
144         if (!removeFile(dbRestoreJournal)) {
145                 fprintf(stderr, "Failed to remove of %s\n", dbRestoreJournal.c_str());
146                 return TAC_ERROR_UNKNOWN;
147         }
148
149         if (initializePathManager(std::string(), std::string(), std::string())) {
150                 fprintf(stderr, "Fail to initialize PathManger\n");
151                 return TAC_ERROR_UNKNOWN;
152         }
153
154         tac_db = dbCreate(TAC_APP_LIST_RESTORE_DB, CREATE_TAC_DB_TABLE);
155         if (!tac_db) {
156                 fprintf(stderr, "Sqlite create error\n");
157                 return TAC_ERROR_UNKNOWN;
158         }
159
160         pkgmgrinfo_appinfo_metadata_filter_h handle;
161         int ret = pkgmgrinfo_appinfo_metadata_filter_create(&handle);
162         if (ret != PMINFO_R_OK) {
163                 return TAC_ERROR_UNKNOWN;
164         }
165
166         ret = pkgmgrinfo_appinfo_metadata_filter_add(handle, TAC_METADATA_KEY, METADATA_VALUE);
167         if (ret != PMINFO_R_OK) {
168                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
169                 return TAC_ERROR_UNKNOWN;
170         }
171
172         ret = pkgmgrinfo_appinfo_metadata_filter_foreach(handle, restoreDBCb, NULL);
173         if (ret != PMINFO_R_OK) {
174                 fprintf(stderr, "Failed pkgmgrinfo_appinfo_metadata_filter_foreach\n");
175                 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
176                 return TAC_ERROR_UNKNOWN;
177         }
178         fprintf(stderr, "Success pkgmgrinfo_appinfo_metadata_filter_foreach\n");
179
180         pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
181
182         if (tac_db) {
183                 dbClose(tac_db);
184                 tac_db = NULL;
185         }
186
187         uid_t g_uid = 301; // app_fw
188         gid_t g_gid = 301; // app_fw
189
190         if (!copyFile(TAC_APP_LIST_RESTORE_DB, TAC_APP_LIST_DB)) {
191                 fprintf(stderr, "Failed to copy of %s\n", TAC_APP_LIST_DB);
192                 return TAC_ERROR_UNKNOWN;
193         }
194         if (!removeFile(TAC_APP_LIST_RESTORE_DB)) {
195                 fprintf(stderr, "Failed to remove of %s\n", TAC_APP_LIST_RESTORE_DB);
196                 return TAC_ERROR_UNKNOWN;
197         }
198         if (chown(TAC_APP_LIST_DB, g_uid, g_gid) == -1) {
199                 fprintf(stderr, "Failed to change owner and group name\n");
200         }
201
202         std::string dbJournal = TAC_APP_LIST_DB + std::string("-journal");
203         if (!copyFile(dbRestoreJournal, dbJournal)) {
204                 fprintf(stderr, "Failed to copy of %s\n", dbJournal.c_str());
205                 return TAC_ERROR_UNKNOWN;
206         }
207         if (!removeFile(dbRestoreJournal)) {
208                 fprintf(stderr, "Failed to remove of %s\n", dbRestoreJournal.c_str());
209                 return TAC_ERROR_UNKNOWN;
210         }
211         if (chown(dbJournal.c_str(), g_uid, g_gid) == -1) {
212                 fprintf(stderr, "Failed to change owner and group name\n");
213         }
214
215         cleanupDirectory();
216
217         return TAC_ERROR_NONE;
218 }
219
220 tac_error_e resetTACPackage(const std::string& pkgId)
221 {
222         std::string pkgRoot;
223         if (getRootPath(pkgId, pkgRoot) < 0) {
224                 return TAC_ERROR_INVALID_PACKAGE;
225         }
226
227         std::vector<std::string> tacNativeImage;
228         std::string binDir = concatPath(pkgRoot, "bin");
229         std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
230         if (bf::exists(tacDir)) {
231                 try {
232                         for (auto& symlinkAssembly : bf::recursive_directory_iterator(tacDir)) {
233                                 std::string symPath = symlinkAssembly.path().string();
234                                 if (bf::is_symlink(symPath)) {
235                                         if (isNativeImage(symPath)) {
236                                                 tacNativeImage.push_back(symPath);
237                                         }
238                                 }
239                         }
240                         for (auto& path : tacNativeImage) {
241                                 if (!removeFile(path)) {
242                                         fprintf(stderr, "Failed to remove of %s\n", path.c_str());
243                                         return TAC_ERROR_UNKNOWN;
244                                 }
245                         }
246                         tacNativeImage.clear();
247                 } catch (const bf::filesystem_error& error) {
248                         fprintf(stderr, "Failed to recursive directory: %s\n", error.what());
249                         return TAC_ERROR_UNKNOWN;
250                 }
251         }
252         return TAC_ERROR_NONE;
253 }
254
255 tac_error_e disableTACPackage(const std::string& pkgId)
256 {
257         std::string pkgRoot;
258         if (getRootPath(pkgId, pkgRoot) < 0) {
259                 return TAC_ERROR_INVALID_PACKAGE;
260         }
261
262         std::string binDir = concatPath(pkgRoot, "bin");
263         std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
264         std::string binNIDir = concatPath(binDir, APP_NI_SUB_DIR);
265         if (bf::exists(tacDir)) {
266                 try {
267                         for (auto& symlinkAssembly : bf::recursive_directory_iterator(tacDir)) {
268                                 std::string symPath = symlinkAssembly.path().string();
269                                 std::string fileName = symlinkAssembly.path().filename().string();
270                                 if (bf::is_symlink(symPath)) {
271                                         std::string originPath = bf::read_symlink(symPath).string();
272                                         if (!isNativeImage(symPath)) {
273                                                 std::string dllPath = concatPath(binDir, fileName);
274                                                 if (!copyFile(originPath, dllPath)) {
275                                                         fprintf(stderr, "Failed to copy of %s\n", dllPath.c_str());
276                                                         return TAC_ERROR_UNKNOWN;
277                                                 }
278                                                 updateAssemblyInfo(binDir.c_str(), concatPath(binDir, fileName).c_str());
279                                         } else {
280                                                 std::string niPath = concatPath(binNIDir, fileName);
281                                                 if (!copyFile(originPath, niPath)) {
282                                                         fprintf(stderr, "Failed to copy of %s\n", niPath.c_str());
283                                                         return TAC_ERROR_UNKNOWN;
284                                                 }
285                                                 updateAssemblyInfo(binDir.c_str(), niPath.c_str());
286                                         }
287                                 }
288                         }
289                         if (!removeAll(tacDir)) {
290                                 fprintf(stderr, "Failed to remove of %s\n", tacDir.c_str());
291                                 return TAC_ERROR_UNKNOWN;
292                         }
293                 } catch (const bf::filesystem_error& error) {
294                         fprintf(stderr, "Failed to recursive directory: %s\n", error.what());
295                         return TAC_ERROR_UNKNOWN;
296                 }
297         }
298         return TAC_ERROR_NONE;
299 }
300
301 tac_error_e enableTACPackage(const std::string& pkgId)
302 {
303         std::string rootPath;
304         if (getRootPath(pkgId, rootPath) < 0) {
305                 return TAC_ERROR_INVALID_PACKAGE;
306         }
307
308         std::string execName;
309         if (getExecName(pkgId, execName) < 0) {
310                 return TAC_ERROR_INVALID_PACKAGE;
311         }
312
313         std::string metaValue;
314         if (getMetadataValue(pkgId, TAC_METADATA_KEY, metaValue) < 0) {
315                 return TAC_ERROR_INVALID_PACKAGE;
316         }
317
318         if (initializePathManager(std::string(), std::string(), std::string())) {
319                 fprintf(stderr, "Fail to initialize PathManger\n");
320                 return TAC_ERROR_UNKNOWN;
321         }
322
323         if (!strcmp(metaValue.c_str(), "true")) {
324                 std::string binDir = concatPath(rootPath, "bin");
325                 std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
326                 std::string binNIDir = concatPath(binDir, APP_NI_SUB_DIR);
327                 if (!bf::exists(tacDir)) {
328                         if (!createDir(tacDir)) {
329                                 fprintf(stderr, "Cannot create directory: %s\n", tacDir.c_str());
330                                 return TAC_ERROR_UNKNOWN;
331                         }
332                         updateAssemblyInfo(binDir.c_str(), tacDir.c_str());
333
334                         std::vector<std::string> enableNuget;
335                         for (auto& npAssembly : depsJsonParser(rootPath, execName, getTPA())) {
336                                 std::string nugetPackage = npAssembly.substr(0, npAssembly.rfind(':'));
337                                 std::string assemblyName = npAssembly.substr(npAssembly.rfind(':') + 1);
338                                 std::string nugetPath = concatPath(__TAC_DIR, nugetPackage);
339                                 if (bf::exists(nugetPath)) {
340                                         std::string originPath = concatPath(nugetPath, assemblyName);
341                                         if (bf::exists(originPath)) {
342                                                 enableNuget.push_back(originPath);
343                                         }
344                                 }
345                         }
346
347                         for (auto& originPath : enableNuget) {
348                                 if (bf::exists(originPath)) {
349                                         std::string fileName = originPath.substr(originPath.rfind('/') + 1);
350                                         std::string NIFileName = fileName.substr(0, fileName.rfind(".dll")) + ".ni.dll";
351                                         if (bf::exists(binNIDir)) {
352                                                 std::string originNIPath = originPath.substr(0, originPath.rfind(".dll")) + ".ni.dll";
353                                                 if (bf::exists(originNIPath)) {
354                                                         bf::create_symlink(originNIPath, concatPath(tacDir, NIFileName));
355                                                         fprintf(stderr, "%s symbolic link file generated successfully.\n", concatPath(tacDir, NIFileName).c_str());
356                                                         updateAssemblyInfo(tacDir.c_str(), concatPath(tacDir, NIFileName).c_str(), true);
357
358                                                         if (!removeFile(concatPath(binNIDir, NIFileName))) {
359                                                                 fprintf(stderr, "Failed to remove of %s\n", concatPath(binNIDir, NIFileName).c_str());
360                                                                 return TAC_ERROR_UNKNOWN;
361                                                         }
362                                                 }
363                                         }
364                                         bf::create_symlink(originPath, concatPath(tacDir, fileName));
365                                         fprintf(stderr, "%s symbolic link file generated successfully.\n", concatPath(tacDir, fileName).c_str());
366                                         updateAssemblyInfo(tacDir.c_str(), concatPath(tacDir, fileName).c_str(), true);
367
368                                         if (!removeFile(concatPath(binDir, fileName))) {
369                                                 fprintf(stderr, "Failed to remove of %s\n", concatPath(binDir, fileName).c_str());
370                                                 return TAC_ERROR_UNKNOWN;
371                                         }
372                                 }
373                         }
374                         if (enableNuget.empty()) {
375                                 if (!removeAll(tacDir)) {
376                                         fprintf(stderr, "Failed to remove of %s\n", tacDir.c_str());
377                                 }
378                         }
379                         enableNuget.clear();
380                 }
381         } else {
382                 fprintf(stderr, "The metadata key is missing or the metadata value is false of [%s]\n", pkgId.c_str());
383         }
384         return TAC_ERROR_NONE;
385 }
386
387 //Parser the .deps.json file to get nuget information.
388 std::vector<std::string> depsJsonParser(std::string rootPath, std::string execName, std::string tpaList)
389 {
390         std::vector<std::string> tpaAssemblies;
391         splitPath(tpaList, tpaAssemblies);
392
393         std::vector<std::string> parserData;
394         std::string depsJsonName = execName.substr(0, execName.rfind(".dll")) + ".deps.json";
395         std::string depsJsonPath = concatPath(rootPath, depsJsonName);
396         try {
397                 if (bf::exists(depsJsonPath)) {
398                         std::ifstream ifs(depsJsonPath);
399                         Json::CharReaderBuilder reader;
400                         Json::Value root;
401                         std::string error;
402                         if (ifs.is_open()) {
403                                 if (!Json::parseFromStream(reader, ifs, &root, &error)) {
404                                         _ERR("Failed to parse of deps.json");
405                                         ifs.close();
406                                         tpaAssemblies.clear();
407                                         return parserData;
408                                 }
409                                 const Json::Value runtimeTargetName = root["runtimeTarget"]["name"];
410                                 const Json::Value nugetPackages = root["targets"][runtimeTargetName.asString().c_str()];
411                                 std::vector<std::string> appDependencies;
412                                 for (auto& nuget : nugetPackages.getMemberNames()) {
413                                         if (strstr(nuget.c_str(), (execName.substr(0, execName.find(".Tizen."))).c_str()) != NULL ||
414                                                 strstr(nuget.c_str(), (execName.substr(0, execName.find(".dll"))).c_str()) != NULL) {
415                                                 const Json::Value assemblies = nugetPackages[nuget.c_str()]["runtime"];
416                                                 if (assemblies != Json::nullValue) {
417                                                         const Json::Value dependencies = nugetPackages[nuget.c_str()]["dependencies"];
418                                                         for (auto& dependency : dependencies.getMemberNames()) {
419                                                                 appDependencies.push_back(dependency);
420                                                         }
421                                                 }
422                                         }
423                                 }
424                                 for (auto& nuget : nugetPackages.getMemberNames()) {
425                                         //Skip the nuget package related to Tizen
426                                         if (strstr(nuget.c_str(), TIZEN_DOTNET_NUGET) == NULL &&
427                                                 strstr(nuget.c_str(), TIZEN_DOTNET_SDK_NUGET) == NULL &&
428                                                 strstr(nuget.c_str(), (execName.substr(0, execName.find(".Tizen."))).c_str()) == NULL &&
429                                                 strstr(nuget.c_str(), (execName.substr(0, execName.find(".dll"))).c_str()) == NULL) {
430                                                 const Json::Value assemblies = nugetPackages[nuget.c_str()]["runtime"];
431                                                 if (assemblies != Json::nullValue) {
432                                                         const Json::Value dependencies = nugetPackages[nuget.c_str()]["dependencies"];
433                                                         bool hasDependency = false;
434                                                         for (auto& dependency : dependencies.getMemberNames()) {
435                                                                 //Skip the nugget package that is dependent on another nuget package
436                                                                 if (strstr(dependency.c_str(), TIZEN_DOTNET_NUGET) == NULL &&
437                                                                         strstr(dependency.c_str(), NET_STANDARD_LIBRARY_NUGET) == NULL) {
438                                                                         hasDependency = true;
439                                                                         for (auto& ad : appDependencies) {
440                                                                                 if (!strcmp(ad.c_str(), dependency.c_str())) {
441                                                                                         hasDependency = true;
442                                                                                         break;
443                                                                                 } else {
444                                                                                         hasDependency = false;
445                                                                                 }
446                                                                         }
447                                                                         if (hasDependency) break;
448                                                                 }
449                                                         }
450                                                         if (!hasDependency) {
451                                                                 bool isExistTpaAssembly = false;
452                                                                 for (auto& assembly : assemblies.getMemberNames()) {
453                                                                         std::string assemblyName = assembly.substr(assembly.rfind('/') + 1);
454                                                                         //Skip the assembly present in the TPA list
455                                                                         for (auto& tpaPath : tpaAssemblies) {
456                                                                                 std::string tpaName = replaceAll(tpaPath.substr(tpaPath.rfind('/') + 1), ".ni.dll", ".dll");
457                                                                                 if (!strcmp(tpaName.c_str(), assemblyName.c_str())) {
458                                                                                         isExistTpaAssembly = true;
459                                                                                         break;
460                                                                                 }
461                                                                         }
462                                                                         if (isExistTpaAssembly) break;
463                                                                 }
464                                                                 if (!isExistTpaAssembly) {
465                                                                         for (auto& assembly : assemblies.getMemberNames()) {
466                                                                                 std::string assemblyName = assembly.substr(assembly.rfind('/') + 1);
467                                                                                 parserData.push_back(nuget + ":" + assemblyName);
468                                                                                 _INFO("Nuget : [%s] / Assembly : [%s]", nuget.c_str(), assemblyName.c_str());
469                                                                         }
470                                                                 }
471                                                         }
472                                                 }
473                                         }
474                                 }
475                                 appDependencies.clear();
476                                 ifs.close();
477                         }
478                 }
479         } catch (const Json::LogicError& error) {
480                 _ERR("Failed to parse Json: %s", error.what());
481         }
482         tpaAssemblies.clear();
483         return parserData;
484 }