Change the extension of a path or file
[platform/core/dotnet/launcher.git] / NativeLauncher / util / utils.cc
1 /*
2  * Copyright (c) 2016 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 <dirent.h>
18 #include <fcntl.h>
19 #include <sys/stat.h>
20 #include <unistd.h>
21 #include <limits.h>
22 #include <strings.h>
23 #include <pkgmgr_installer_info.h>
24 #include <sys/smack.h>
25 #include <sys/prctl.h>
26 #include <openssl/sha.h>
27
28 #include <cstdlib>
29 #include <cstring>
30 #include <algorithm>
31 #include <unordered_map>
32 #include <vector>
33 #include <iterator>
34 #include <fstream>
35 #include <sstream>
36 #include <map>
37 #include <iomanip>
38
39 #include "log.h"
40 #include "utils.h"
41 #include "path_manager.h"
42
43 static bool iCompare(const std::string& a, int aOffset, const std::string& b, int bOffset, int length)
44 {
45         return static_cast<int>(a.length()) - length >= aOffset &&
46                 static_cast<int>(b.length()) - length >= bOffset &&
47                 std::equal(b.begin() + bOffset, b.begin() + bOffset + length, a.begin() + aOffset,
48                         [](unsigned char a, unsigned char b)
49                         { return std::tolower(a) == std::tolower(b); });
50 }
51
52 bool isManagedAssembly(const std::string& fileName)
53 {
54         return (iCompare(fileName, fileName.size()-4, ".dll", 0, 4) ||
55                         iCompare(fileName, fileName.size()-4, ".exe", 0, 4)) &&
56                         !isNativeImage(fileName);
57 }
58
59 bool isNativeImage(const std::string& fileName)
60 {
61         return iCompare(fileName, fileName.size()-7, ".ni", 0, 3);
62 }
63
64 std::string concatPath(const std::string& path1, const std::string& path2)
65 {
66         std::string path(path1);
67         if (path.back() == PATH_SEPARATOR) {
68                 path.append(path2);
69         } else {
70                 path += PATH_SEPARATOR;
71                 path.append(path2);
72         }
73
74         return path;
75 }
76
77 void splitPath(const std::string& path, std::vector<std::string>& out)
78 {
79         std::istringstream ss(path);
80         std::string token;
81
82         while (std::getline(ss, token, ':')) {
83                 out.push_back(token);
84         }
85 }
86
87 std::string getAbsolutePath(const std::string& path)
88 {
89         std::string absPath;
90         char *realPath = realpath(path.c_str(), NULL);
91         if (realPath) {
92                 absPath.assign(realPath);
93                 free(realPath);
94         }
95
96         return absPath;
97 }
98
99 std::string getRootPath(const std::string& pkgId)
100 {
101         int ret = 0;
102         char *path = 0;
103         std::string rootPath;
104
105         pkgmgrinfo_pkginfo_h pkg_handle;
106         ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
107         if (ret != 0) {
108                 return rootPath;
109         }
110
111         ret = pkgmgrinfo_pkginfo_get_root_path(pkg_handle, &path);
112         if (ret != PMINFO_R_OK) {
113                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
114                 return rootPath;
115         }
116         rootPath = path;
117         pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
118
119         return rootPath;
120 }
121
122 std::string getExecName(const std::string& pkgId)
123 {
124         char *exec = NULL;
125         char *appId = 0;
126         std::string execName;
127
128         pkgmgrinfo_pkginfo_h pkg_handle;
129         int ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
130         if (ret != 0) {
131                 return execName;
132         }
133
134         ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
135         if (ret != PMINFO_R_OK) {
136                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
137                 return execName;
138         }
139
140         pkgmgrinfo_appinfo_h app_handle;
141         ret = pkgmgrGetAppInfo(appId, &app_handle);
142         if (ret != 0) {
143                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
144                 return execName;
145         }
146
147         ret = pkgmgrinfo_appinfo_get_exec(app_handle, &exec);
148         if (ret != PMINFO_R_OK) {
149                 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
150                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
151                 return execName;
152         }
153         execName = std::string(exec).substr(std::string(exec).rfind('/') + 1);
154
155         pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
156         pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
157
158         return execName;
159 }
160
161 std::string getAppType(const std::string& pkgId)
162 {
163         char *appId = 0;
164         char *type = 0;
165         std::string appType;
166
167         pkgmgrinfo_pkginfo_h pkg_handle;
168         int ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
169         if (ret != 0) {
170                 return appType;
171         }
172
173         ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
174         if (ret != PMINFO_R_OK) {
175                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
176                 return appType;
177         }
178
179         pkgmgrinfo_appinfo_h app_handle;
180         ret = pkgmgrGetAppInfo(appId, &app_handle);
181         if (ret != 0) {
182                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
183                 return appType;
184         }
185
186         ret = pkgmgrinfo_appinfo_get_apptype(app_handle, &type);
187         if (ret != PMINFO_R_OK) {
188                 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
189                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
190                 return appType;
191         }
192         appType = type;
193
194         pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
195         pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
196
197         return appType;
198 }
199
200 std::string getMetadataValue(const std::string& pkgId, const std::string& key)
201 {
202         char *value = NULL;
203         char *appId = 0;
204         std::string metadataValue;
205
206         pkgmgrinfo_pkginfo_h pkg_handle;
207         int ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
208         if (ret != 0) {
209                 return metadataValue;
210         }
211
212         ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
213         if (ret != PMINFO_R_OK) {
214                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
215                 return metadataValue;
216         }
217
218         pkgmgrinfo_appinfo_h app_handle;
219         ret = pkgmgrGetAppInfo(appId, &app_handle);
220         if (ret != 0) {
221                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
222                 return metadataValue;
223         }
224
225         ret = pkgmgrinfo_appinfo_get_metadata_value(app_handle, key.c_str(), &value);
226         if (ret != PMINFO_R_OK) {
227                 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
228                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
229                 return metadataValue;
230         }
231         metadataValue = std::string(value);
232
233         pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
234         pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
235
236         return metadataValue;
237 }
238
239 bool isReadOnlyApp(const std::string& pkgId)
240 {
241         bool readOnly = false;
242         int ret = 0;
243         uid_t uid = 0;
244
245         if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
246                 _ERR("Failed to get UID");
247                 return readOnly;
248         }
249
250         pkgmgrinfo_pkginfo_h handle;
251         if (uid == 0) {
252                 ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgId.c_str(), &handle);
253         } else {
254                 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgId.c_str(), uid, &handle);
255         }
256
257         if (ret != PMINFO_R_OK) {
258                 return readOnly;
259         }
260
261         ret = pkgmgrinfo_pkginfo_is_readonly(handle, &readOnly);
262         if (ret != PMINFO_R_OK) {
263                 pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
264                 return readOnly;
265         }
266
267         pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
268
269         return readOnly;
270 }
271
272 std::string getBaseName(const std::string& path)
273 {
274         auto pos = path.find_last_of(PATH_SEPARATOR);
275         if (pos != std::string::npos)
276                 return path.substr(0, pos);
277         else
278                 return std::string(".");
279         return path;
280 }
281
282 std::string replaceAll(const std::string& str, const std::string& pattern, const std::string& replace)
283 {
284         std::string result = str;
285         std::string::size_type pos = 0;
286         std::string::size_type offset = 0;
287
288         while ((pos = result.find(pattern, offset)) != std::string::npos) {
289                 result.replace(result.begin() + pos, result.begin() + pos + pattern.size(), replace);
290                 offset = pos + replace.size();
291         }
292
293         return result;
294 }
295
296 std::string changeExtension(const std::string& path, const std::string& from, const std::string& to)
297 {
298         return path.substr(0, path.rfind(from)) + to;
299 }
300
301 bool isFile(const std::string& path)
302 {
303         struct stat sb;
304         return lstat(path.c_str(), &sb) == 0;
305 }
306
307 bool isDirectory(const std::string& path)
308 {
309         struct stat sb;
310         if (stat(path.c_str(), &sb) != 0) {
311                 return false;
312         }
313         if (sb.st_mode & S_IFDIR) {
314                 return true;
315         } else {
316                 return false;
317         }
318 }
319
320 std::string getAssemblyNameFromPath(const std::string& path)
321 {
322         std::string ret(getFileName(path));
323
324         if (ret.find_last_of(".") == std::string::npos)
325                 return ret;
326         ret.erase(ret.find_last_of("."));
327
328         if (ret.size() > 3 && std::equal(ret.begin() + ret.size() - 3, ret.end(), ".ni"))
329                 ret.erase(ret.size() - 3);
330
331         return ret;
332 }
333
334 void addAssembliesFromDirectories(const std::vector<std::string>& directories, std::string& list)
335 {
336         std::vector<std::string> assems;
337         std::unordered_map<std::string, std::string> assemPaths;
338
339         auto reader = [&assems, &assemPaths](const std::string& path, const std::string& filename) {
340                 if (isManagedAssembly(filename) || isNativeImage(filename)) {
341                         std::string assem = getAssemblyNameFromPath(filename);
342
343                         if (assemPaths.count(assem) == 0) {
344                                 assems.push_back(assem);
345                                 assemPaths[assem] = path;
346                         } else if (isManagedAssembly(assemPaths[assem]) && isNativeImage(filename)) {
347                                 // Update only if a native image is found in the same directory.
348                                 // For example, if we have two directories = { X, Y } where X contains A.dll and
349                                 // Y contains both A.dll and A.ni.dll, always A.dll in X will be used.
350                                 if (getBaseName(assemPaths[assem]).compare(getBaseName(path)) == 0)
351                                         assemPaths[assem] = path;
352                         }
353                 }
354         };
355         for (auto& directory : directories)
356                 scanFilesInDirectory(directory, reader, 0);
357
358         if (!list.empty() && list.back() != ':')
359                 list.push_back(':');
360
361         for (auto& assem : assems)
362                 list += assemPaths[assem] + ":";
363
364         if (list.back() == ':')
365                 list.pop_back();
366 }
367
368 void scanFilesInDirectory(const std::string& directory, FileReader reader, unsigned int depth)
369 {
370         DIR *dir;
371         struct dirent* entry;
372         bool isDir;
373
374         dir = opendir(directory.c_str());
375
376         if (dir == nullptr)
377                 return;
378
379         std::vector<std::string> innerDirectories;
380
381         while ((entry = readdir(dir)) != nullptr) {
382                 isDir = false;
383                 std::string path = concatPath(directory, entry->d_name);
384                 switch (entry->d_type) {
385                         case DT_REG: break;
386                         case DT_DIR:
387                                 isDir = true;
388                                 break;
389                         // symlink is added to the list even if there is no original file.
390                         // It used to remove broken symlinks related to TAC
391                         case DT_LNK:
392                                 break;
393                         case DT_UNKNOWN:
394                                 continue;
395                         default:
396                                 continue;
397                 }
398                 if (!isDir)
399                         reader(path, entry->d_name);
400                 else if (depth > 0 && strcmp(entry->d_name, ".") && strcmp(entry->d_name, ".."))
401                         innerDirectories.push_back(path);
402         }
403
404         if (depth > 0)
405                 for (auto& d : innerDirectories)
406                         scanFilesInDirectory(d, reader, depth - 1);
407
408         closedir(dir);
409 }
410
411 void copySmackAndOwnership(const std::string& fromPath, const std::string& toPath, bool isSymlink)
412 {
413         char* label = NULL;
414         struct stat info;
415
416         if (isSymlink) {
417                 // change smack label for symbolic link.
418                 if (smack_lgetlabel(fromPath.c_str(), &label, SMACK_LABEL_ACCESS) == 0) {
419                         if (smack_lsetlabel(toPath.c_str(), label, SMACK_LABEL_ACCESS) < 0) {
420                                 fprintf(stderr, "Fail to set smack label\n");
421                         }
422                         free(label);
423                 }
424
425                 // change owner and groups for symbolic link.
426                 if (!lstat(fromPath.c_str(), &info)) {
427                         if (lchown(toPath.c_str(), info.st_uid, info.st_gid) == -1)
428                                 fprintf(stderr, "Failed to change owner and group name\n");
429                 }
430         } else {
431                 // change smack label
432                 if (smack_getlabel(fromPath.c_str(), &label, SMACK_LABEL_ACCESS) == 0) {
433                         if (smack_setlabel(toPath.c_str(), label, SMACK_LABEL_ACCESS) < 0) {
434                                 fprintf(stderr, "Fail to set smack label\n");
435                         }
436                         free(label);
437                 }
438
439                 // change owner and groups for generated ni file.
440                 if (!stat(fromPath.c_str(), &info)) {
441                         if (chown(toPath.c_str(), info.st_uid, info.st_gid) == -1)
442                                 fprintf(stderr, "Failed to change owner and group name\n");
443                 }
444         }
445 }
446
447 static bool setOwnership(const bf::path& path, uid_t uid, gid_t gid)
448 {
449         int fd = open(path.c_str(), O_RDONLY);
450         if (fd < 0) {
451                 _ERR("Can't open directory: %s", path.c_str());
452                 return false;
453         }
454         int ret = fchown(fd, uid, gid);
455         close(fd);
456         if (ret != 0) {
457                 _ERR("Failed to change owner of: %s", path.c_str());
458                 return false;
459         }
460         return true;
461 }
462
463 static bool setDirPermissions(const bf::path& path, bf::perms permissions)
464 {
465         bs::error_code error;
466         bf::permissions(path, permissions, error);
467         if (error) {
468                 _ERR("Failed to set permissions for directory: %s, %s", path.c_str(), error.message().c_str());
469                 return false;
470         }
471         return true;
472 }
473
474 static bool setDirOwnershipAndPermissions(const bf::path& path, bf::perms permissions, uid_t uid, gid_t gid)
475 {
476         if (!setOwnership(path, uid, gid)) {
477                 _ERR("Failed to change owner: %s, (uid: %d, gid: %d)", path.c_str(), uid, gid);
478                 return false;
479         }
480         if (!setDirPermissions(path, permissions)) {
481                 _ERR("Failed to change permission: %s, (%d)", path.c_str(), permissions);
482                 return false;
483         }
484         return true;
485 }
486
487 static bool copyOwnershipAndPermissions(const bf::path& path, const bf::path& path2)
488 {
489         if (!exist(path)) {
490                 _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), path2.c_str());
491                 return false;
492         }
493         bf::perms permissions = bf::status(path).permissions();
494         struct stat stats;
495         if (stat(path.c_str(), &stats) != 0) {
496                 return false;
497         }
498         if (!setDirOwnershipAndPermissions(path2, permissions, stats.st_uid, stats.st_gid)) {
499                 _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), path2.c_str());
500                 return false;
501         }
502         return true;
503 }
504
505 bool exist(const bf::path& path)
506 {
507         bs::error_code error;
508         int ret = bf::exists(path, error);
509         if (error) {
510                 if ((error.value() != bs::errc::success) && (error.value() != bs::errc::no_such_file_or_directory)) {
511                         _ERR("Failed to check %s exists : %s", path.c_str(), error.message().c_str());
512                 }
513         }
514         return ret;
515 }
516
517 bool createDir(const bf::path& path)
518 {
519         if (exist(path)) {
520                 return true;
521         }
522         bs::error_code error;
523         bf::create_directories(path, error);
524         if (error) {
525                 _ERR("Failed to create directory: %s", error.message().c_str());
526                 return false;
527         }
528         return true;
529 }
530
531 bool copyDir(const bf::path& path1, const bf::path& path2, FSFlag flags)
532 {
533         try {
534                 // Check whether the function call is valid
535                 if (!exist(path1) || !bf::is_directory(path1)) {
536                         _ERR("Source directory %s does not exist or is not a directory", path1.c_str());
537                         return false;
538                 }
539                 if (!exist(path2)) {
540                         // Create the destination directory
541                         if (!createDir(path2)) {
542                                 _ERR("Unable to create destination directory %s", path2.c_str());
543                                 return false;
544                         }
545                         if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) {
546                                 copyOwnershipAndPermissions(path1, path2);
547                         }
548                 } else {
549                         if (!(flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE))) {
550                                 _ERR("Destination directory %s already exists", path2.c_str());
551                                 return false;
552                         }
553                         if (flags & (FS_MERGE_OVERWRITE | FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS)) {
554                                 copyOwnershipAndPermissions(path1, path2);
555                         }
556                 }
557         } catch (const bf::filesystem_error& error) {
558                 _ERR("Failed to copy directory: %s", error.what());
559                 return false;
560         }
561
562         // Iterate through the source directory
563         for (bf::directory_iterator file(path1); file != bf::directory_iterator(); ++file) {
564                 try {
565                         bf::path current(file->path());
566                         bf::path target = path2 / current.filename();
567                         if (bf::is_symlink(symlink_status(current))) {
568                                 if ((flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE)) && exist(target)) {
569                                         continue;
570                                 }
571                                 bs::error_code error;
572                                 bf::copy_symlink(current, target, error);
573                                 if (error) {
574                                         _ERR("Failed to copy symlink: %s, %s", current.c_str(), error.message().c_str());
575                                         return false;
576                                 }
577                         } else if (bf::is_directory(current)) {
578                                 // Found directory: Recursion
579                                 if (!copyDir(current, target, flags)) {
580                                         return false;
581                                 }
582                         } else {
583                                 if ((flags & FS_MERGE_SKIP) && exist(target)) {
584                                         continue;
585                                 }
586                                 bf::path destination = target;
587                                 if (flags & FS_COMMIT_COPY_FILE) {
588                                         destination = bf::unique_path(target.parent_path() / "%%%%-%%%%-%%%%-%%%%");
589                                 }
590                                 if (flags & FS_MERGE_OVERWRITE) {
591                                         bf::copy_file(current, destination, bf::copy_option::overwrite_if_exists);
592                                 } else {
593                                         bf::copy_file(current, destination);
594                                 }
595                                 if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) {
596                                         copyOwnershipAndPermissions(current, destination);
597                                 }
598                                 if (flags & FS_COMMIT_COPY_FILE) {
599                                         if (flags & FS_MERGE_OVERWRITE) {
600                                                 bf::remove(target);
601                                         }
602                                         bf::rename(destination, target);
603                                 }
604                         }
605                 } catch (const bf::filesystem_error& error) {
606                         _ERR("Failed to copy directory: %s", error.what());
607                         return false;
608                 }
609         }
610         return true;
611 }
612
613 bool copyFile(const bf::path& path1, const bf::path& path2)
614 {
615         bs::error_code error;
616         if (!exist(path1)) {
617                 return false;
618         }
619         bf::copy_file(path1, path2, bf::copy_option::overwrite_if_exists, error);
620         if (error) {
621                 _ERR("copy file %s due to error [%s]", path1.c_str(), error.message().c_str());
622                 return false;
623         }
624         return true;
625 }
626
627 bool moveFile(const bf::path& path1, const bf::path& path2)
628 {
629         if (!exist(path1) || exist(path2)) {
630                 return false;
631         }
632         bs::error_code error;
633         bf::rename(path1, path2, error);
634         if (error) {
635                 _ERR("Cannot move file: %s. Will copy/remove... with error [%s]", path1.c_str(), error.message().c_str());
636                 bf::copy_file(path1, path2, bf::copy_option::overwrite_if_exists, error);
637                 if (error) {
638                         _ERR("Cannot copy file %s due to error [%s]", path1.c_str(), error.message().c_str());
639                         return false;
640                 }
641                 bf::remove_all(path1, error);
642                 if (error) {
643                         _ERR("Cannot remove old file when coping: %s with error [%s]", path1.c_str(), error.message().c_str());
644                         return false;
645                 }
646         }
647         return true;
648 }
649
650 bool removeFile(const bf::path& path)
651 {
652         if (!exist(path)) {
653                 return true;
654         }
655         bs::error_code error;
656         bf::remove(path, error);
657         if (error) {
658                 _ERR("Cannot remove: %s, %s", path.c_str(), error.message().c_str());
659                 return false;
660         }
661         return true;
662 }
663
664 bool removeAll(const bf::path& path)
665 {
666         if (!exist(path)) {
667                 return true;
668         }
669         bs::error_code error;
670         bf::remove_all(path, error);
671         if (error) {
672                 _ERR("Cannot remove: %s, %s", path.c_str(), error.message().c_str());
673                 return false;
674         }
675         return true;
676 }
677
678 void setCmdName(const std::string& name)
679 {
680         #define PRC_NAME_LENGTH         16
681
682         char processName[PRC_NAME_LENGTH] = {0, };
683
684         if (name.empty())
685                 return;
686
687         memset(processName, '\0', PRC_NAME_LENGTH);
688         snprintf(processName, PRC_NAME_LENGTH, "%s", name.c_str());
689         prctl(PR_SET_NAME, processName);
690 }
691
692 std::string getFileName(const std::string& path)
693 {
694         std::string ret(path);
695         size_t index = ret.find_last_of(PATH_SEPARATOR);
696         return index == std::string::npos ? ret : ret.substr(index + 1);
697 }
698
699 std::string SHA256(const std::string& path)
700 {
701         std::string output = "";
702         FILE *file = fopen(path.c_str(), "rb");
703         if (!file) {
704                 return output;
705         }
706
707         unsigned char hash[SHA256_DIGEST_LENGTH];
708         SHA256_CTX sha256;
709         SHA256_Init(&sha256);
710         int bytesRead = 0;
711         const int bufSize = 32768;
712         char *buffer = (char*)malloc(bufSize);
713         if (!buffer) {
714                 fclose(file);
715                 return output;
716         }
717
718         while ((bytesRead = fread(buffer, 1, bufSize, file))) {
719                 SHA256_Update(&sha256, buffer, bytesRead);
720         }
721         SHA256_Final(hash, &sha256);
722
723         std::stringstream ss;
724         for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
725                 ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
726         }
727         output = ss.str();
728
729         fclose(file);
730         free(buffer);
731
732         return output;
733 }
734
735 int pkgmgrGetPkgInfo(const std::string& pkgId, pkgmgrinfo_pkginfo_h* handle)
736 {
737         uid_t uid = 0;
738         int ret = 0;
739
740         if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
741                 _ERR("Failed to get UID");
742                 return -1;
743         }
744
745         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgId.c_str(), uid, handle);
746         if (ret != PMINFO_R_OK) {
747                 _ERR("Failed to get pkginfo (%d)", ret);
748                 return -1;
749         }
750
751         return 0;
752 }
753
754 int pkgmgrGetAppInfo(const std::string& appId, pkgmgrinfo_appinfo_h* handle)
755 {
756         uid_t uid = 0;
757         int ret = 0;
758
759         if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
760                 _ERR("Failed to get UID");
761                 return -1;
762         }
763
764         ret = pkgmgrinfo_appinfo_get_usr_appinfo(appId.c_str(), uid, handle);
765         if (ret != PMINFO_R_OK) {
766                 _ERR("Failed to get appinfo (%d)", ret);
767                 return -1;
768         }
769
770         return 0;
771 }
772
773 int pkgmgrMDFilterForeach(pkgmgrinfo_appinfo_metadata_filter_h handle,
774                                          pkgmgrinfo_app_list_cb app_cb,
775                                          void *user_data)
776 {
777         uid_t uid = 0;
778         int ret = 0;
779
780         if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
781                 _ERR("Failed to get UID");
782                 return -1;
783         }
784
785
786         ret = pkgmgrinfo_appinfo_usr_metadata_filter_foreach(handle, app_cb, user_data, uid);
787         if (ret != PMINFO_R_OK) {
788                 _ERR("Failed to execute the metadata filter query (%d)", ret);
789                 return -1;
790         }
791
792         return 0;
793 }
794