1 /*
2 * Copyright (C) 2020 The Android Open Source Project
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 <errno.h>
18 #include <pthread.h>
19 #include <sys/inotify.h>
20 #include <sys/prctl.h>
21 #include <sys/stat.h>
22 #include <sys/types.h>
23 #include <unistd.h>
24
25 #include <atomic>
26 #include <map>
27 #include <mutex>
28 #include <string>
29 #include <thread>
30
31 #include <android-base/logging.h>
32 #include <android-base/unique_fd.h>
33 #include <packagelistparser/packagelistparser.h>
34
35 #include "LogUtils.h"
36
37 using android::base::unique_fd;
38
39 #define PACKAGES_LIST_FILE "/data/system/packages.list"
40
41 struct PkgIdMap {
42 bool active = false;
43 std::mutex lock;
44 std::atomic<bool> running = false;
45 std::map<uid_t, std::string> appid_to_package;
46 std::unique_ptr<std::thread> pklp_thread;
47 };
48
49 static PkgIdMap* gPkgIdMap = new PkgIdMap;
50
PackageParseCallback(pkg_info * info,void * userdata)51 static bool PackageParseCallback(pkg_info* info, void* userdata) {
52 struct PkgIdMap* global = static_cast<struct PkgIdMap*>(userdata);
53 if (info->name != NULL && info->name[0] != '\0') {
54 global->appid_to_package.emplace(info->uid, info->name);
55 }
56 packagelist_free(info);
57 return true;
58 }
59
ReadPackageList(struct PkgIdMap * global)60 static bool ReadPackageList(struct PkgIdMap* global) {
61 std::lock_guard<std::mutex> guard(global->lock);
62 global->appid_to_package.clear();
63 bool rc = packagelist_parse(PackageParseCallback, global);
64 LOG(INFO) << "ReadPackageList, total packages: " << global->appid_to_package.size();
65 return rc;
66 }
67
WatchPackageList(struct PkgIdMap * global)68 static void WatchPackageList(struct PkgIdMap* global) {
69 struct inotify_event* event;
70 char event_buf[512];
71
72 unique_fd nfd(inotify_init1(IN_CLOEXEC));
73 if (nfd == -1) {
74 LOG(FATAL) << "inotify_init failed";
75 return;
76 }
77
78 global->active = false;
79 while (1) {
80 if (!global->active) {
81 LOG(INFO) << "start watching " PACKAGES_LIST_FILE " ...";
82 int ret = inotify_add_watch(nfd, PACKAGES_LIST_FILE, IN_DELETE_SELF);
83 if (ret == -1) {
84 if (errno == ENOENT || errno == EACCES) {
85 LOG(INFO) << "missing " PACKAGES_LIST_FILE "; retrying...";
86 return;
87 } else {
88 PLOG(ERROR) << "inotify_add_watch failed";
89 return;
90 }
91 }
92
93 if (ReadPackageList(global) == false) {
94 LOG(ERROR) << "ReadPackageList failed";
95 return;
96 }
97 global->active = true;
98 }
99
100 int event_pos = 0;
101 ssize_t res = TEMP_FAILURE_RETRY(read(nfd, event_buf, sizeof(event_buf)));
102 if (res == -1 || static_cast<size_t>(res) < sizeof(*event)) {
103 LOG(ERROR) << "failed to read inotify event, res: " << res;
104 global->active = false;
105 continue;
106 }
107
108 while (res >= static_cast<ssize_t>(sizeof(*event))) {
109 int event_size;
110 event = reinterpret_cast<struct inotify_event*>(event_buf + event_pos);
111
112 if ((event->mask & IN_IGNORED) == IN_IGNORED) {
113 global->active = false;
114 }
115
116 event_size = sizeof(*event) + event->len;
117 res -= event_size;
118 event_pos += event_size;
119 }
120 }
121 }
122
StartHandler(struct PkgIdMap * global)123 static void StartHandler(struct PkgIdMap* global) {
124 prctl(PR_SET_NAME, "logd.pkglist");
125 WatchPackageList(global);
126 global->running = false;
127 }
128
StartPkgMonitor()129 void StartPkgMonitor() {
130 std::lock_guard<std::mutex> guard(gPkgIdMap->lock);
131 if (gPkgIdMap->pklp_thread.get() == nullptr) {
132 gPkgIdMap->running = true;
133 gPkgIdMap->pklp_thread = std::make_unique<std::thread>(StartHandler, gPkgIdMap);
134 } else if (!gPkgIdMap->running) {
135 gPkgIdMap->pklp_thread->join();
136 gPkgIdMap->running = true;
137 gPkgIdMap->pklp_thread.reset(new std::thread(StartHandler, gPkgIdMap));
138 }
139 }
140
uidToName(uid_t u)141 char* android::uidToName(uid_t u) {
142 {
143 std::lock_guard<std::mutex> guard(gPkgIdMap->lock);
144 if (gPkgIdMap->active) {
145 const auto& iter = gPkgIdMap->appid_to_package.find(u);
146 if (iter != gPkgIdMap->appid_to_package.end()) {
147 return strdup(iter->second.c_str());
148 }
149 }
150 }
151
152 struct Userdata {
153 uid_t uid;
154 char* name;
155 } userdata = {
156 .uid = u,
157 .name = nullptr,
158 };
159
160 packagelist_parse(
161 [](pkg_info* info, void* callback_parameter) {
162 auto userdata = reinterpret_cast<Userdata*>(callback_parameter);
163 bool result = true;
164 if (info->uid == userdata->uid) {
165 userdata->name = strdup(info->name);
166 // false to stop processing
167 result = false;
168 }
169 packagelist_free(info);
170 return result;
171 },
172 &userdata);
173
174 if (userdata.name != nullptr) {
175 StartPkgMonitor();
176 }
177 return userdata.name;
178 }
179