1 /*
2 * Copyright (C) 2008 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 <stdarg.h>
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <errno.h>
22
23 #define LOG_TAG "Netd"
24
25 #include <log/log.h>
26
27 #include <android-base/parseint.h>
28 #include <android-base/strings.h>
29 #include <netutils/ifc.h>
30 #include <sysutils/NetlinkEvent.h>
31 #include "Controllers.h"
32 #include "NetlinkHandler.h"
33 #include "NetlinkManager.h"
34 #include "SockDiag.h"
35
36 #include <charconv>
37
38 #define BINDER_RETRY(exp) \
39 ({ \
40 bool res = true; \
41 for (int attempt = 0; /*nop*/; ++attempt) { \
42 auto _rc = (exp); \
43 if (_rc.exceptionCode() == binder::Status::EX_TRANSACTION_FAILED && \
44 attempt < RETRY_ATTEMPTS) { \
45 usleep(RETRY_INTERVAL_MICRO_S); \
46 } else { \
47 res = _rc.isOk(); \
48 break; \
49 } \
50 } \
51 res; \
52 })
53
54 #define LOG_EVENT_FUNC(retry, func, ...) \
55 do { \
56 const auto listenerMap = gCtls->eventReporter.getNetdUnsolicitedEventListenerMap(); \
57 for (auto& listener : listenerMap) { \
58 auto entry = gUnsolicitedLog.newEntry().function(#func).args(__VA_ARGS__); \
59 if (retry(listener.first->func(__VA_ARGS__))) { \
60 gUnsolicitedLog.log(entry.withAutomaticDuration()); \
61 } \
62 } \
63 } while (0)
64
65 namespace android {
66 namespace net {
67
68 constexpr int RETRY_ATTEMPTS = 2;
69 constexpr int RETRY_INTERVAL_MICRO_S = 100000;
70
NetlinkHandler(NetlinkManager * nm,int listenerSocket,int format)71 NetlinkHandler::NetlinkHandler(NetlinkManager *nm, int listenerSocket,
72 int format) :
73 NetlinkListener(listenerSocket, format) {
74 mNm = nm;
75 }
76
~NetlinkHandler()77 NetlinkHandler::~NetlinkHandler() {
78 }
79
start()80 int NetlinkHandler::start() {
81 return this->startListener();
82 }
83
stop()84 int NetlinkHandler::stop() {
85 return this->stopListener();
86 }
87
parseIfIndex(const char * ifIndex)88 static long parseIfIndex(const char* ifIndex) {
89 if (ifIndex == nullptr) {
90 return 0;
91 }
92 long ifaceIndex = strtol(ifIndex, nullptr, 10);
93 // strtol returns 0 on error, which is fine because 0 is not a valid ifindex.
94 if (errno == ERANGE && (ifaceIndex == LONG_MAX || ifaceIndex == LONG_MIN)) {
95 return 0;
96 }
97 return ifaceIndex;
98 }
99
onEvent(NetlinkEvent * evt)100 void NetlinkHandler::onEvent(NetlinkEvent *evt) {
101 const char *subsys = evt->getSubsystem();
102 if (!subsys) {
103 ALOGW("No subsystem found in netlink event");
104 return;
105 }
106
107 if (!strcmp(subsys, "net")) {
108 NetlinkEvent::Action action = evt->getAction();
109 const char *iface = evt->findParam("INTERFACE");
110 if ((action == NetlinkEvent::Action::kAdd) ||
111 (action == NetlinkEvent::Action::kLinkUp) ||
112 (action == NetlinkEvent::Action::kLinkDown)) {
113 const char *ifIndex = evt->findParam("IFINDEX");
114 long ifaceIndex = parseIfIndex(ifIndex);
115 if (ifaceIndex) {
116 gCtls->trafficCtrl.addInterface(iface, ifaceIndex);
117 } else {
118 ALOGE("invalid interface index: %s(%s)", iface, ifIndex);
119 }
120 }
121
122 if (action == NetlinkEvent::Action::kAdd) {
123 notifyInterfaceAdded(iface);
124 } else if (action == NetlinkEvent::Action::kRemove) {
125 notifyInterfaceRemoved(iface);
126 } else if (action == NetlinkEvent::Action::kChange) {
127 evt->dump();
128 notifyInterfaceChanged("nana", true);
129 } else if (action == NetlinkEvent::Action::kLinkUp) {
130 notifyInterfaceLinkChanged(iface, true);
131 } else if (action == NetlinkEvent::Action::kLinkDown) {
132 notifyInterfaceLinkChanged(iface, false);
133 } else if (action == NetlinkEvent::Action::kAddressUpdated ||
134 action == NetlinkEvent::Action::kAddressRemoved) {
135 const char *address = evt->findParam("ADDRESS");
136 const char *flags = evt->findParam("FLAGS");
137 const char *scope = evt->findParam("SCOPE");
138 const char *ifIndex = evt->findParam("IFINDEX");
139 char addrstr[INET6_ADDRSTRLEN + strlen("/128")];
140 strlcpy(addrstr, address, sizeof(addrstr));
141 char *slash = strchr(addrstr, '/');
142 if (slash) {
143 *slash = '\0';
144 }
145
146 long ifaceIndex = parseIfIndex(ifIndex);
147 if (!ifaceIndex) {
148 ALOGE("invalid interface index: %s(%s)", iface, ifIndex);
149 }
150 const bool addrUpdated = (action == NetlinkEvent::Action::kAddressUpdated);
151 if (addrUpdated) {
152 gCtls->netCtrl.addInterfaceAddress(ifaceIndex, address);
153 } else { // action == NetlinkEvent::Action::kAddressRemoved
154 bool shouldDestroy = gCtls->netCtrl.removeInterfaceAddress(ifaceIndex, address);
155 if (shouldDestroy) {
156 SockDiag sd;
157 if (sd.open()) {
158 // Pass the interface index iff. destroying sockets on a link-local address.
159 // This cannot use an interface name as the interface might no longer exist.
160 int destroyIfaceIndex =
161 std::string_view(addrstr).starts_with("fe80:") ? ifaceIndex : 0;
162 int ret = sd.destroySockets(addrstr, destroyIfaceIndex);
163 if (ret < 0) {
164 ALOGE("Error destroying sockets: %s", strerror(-ret));
165 }
166 } else {
167 ALOGE("Error opening NETLINK_SOCK_DIAG socket: %s", strerror(errno));
168 }
169 }
170 }
171 // Note: if this interface was deleted, iface is "" and we don't notify.
172 if (iface && iface[0] && address && flags && scope) {
173 if (addrUpdated) {
174 notifyAddressUpdated(address, iface, std::stoi(flags), std::stoi(scope));
175 } else {
176 notifyAddressRemoved(address, iface, std::stoi(flags), std::stoi(scope));
177 }
178 }
179 } else if (action == NetlinkEvent::Action::kRdnss) {
180 const char *lifetime = evt->findParam("LIFETIME");
181 const char *servers = evt->findParam("SERVERS");
182 if (lifetime && servers) {
183 notifyInterfaceDnsServers(iface, strtol(lifetime, nullptr, 10),
184 android::base::Split(servers, ","));
185 }
186 } else if (action == NetlinkEvent::Action::kRouteUpdated ||
187 action == NetlinkEvent::Action::kRouteRemoved) {
188 const char *route = evt->findParam("ROUTE");
189 const char *gateway = evt->findParam("GATEWAY");
190 const char *iface = evt->findParam("INTERFACE");
191 if (route && (gateway || iface)) {
192 notifyRouteChange((action == NetlinkEvent::Action::kRouteUpdated) ? true : false,
193 route, (gateway == nullptr) ? "" : gateway,
194 (iface == nullptr) ? "" : iface);
195 }
196 }
197
198 } else if (!strcmp(subsys, "qlog") || !strcmp(subsys, "xt_quota2")) {
199 const char *alertName = evt->findParam("ALERT_NAME");
200 const char *iface = evt->findParam("INTERFACE");
201 if (alertName && iface) {
202 notifyQuotaLimitReached(alertName, iface);
203 }
204
205 } else if (!strcmp(subsys, "strict")) {
206 const char *uid = evt->findParam("UID");
207 const char *hex = evt->findParam("HEX");
208 if (uid && hex) {
209 notifyStrictCleartext(strtol(uid, nullptr, 10), hex);
210 }
211
212 } else if (!strcmp(subsys, "xt_idletimer")) {
213 const char *label = evt->findParam("INTERFACE");
214 const char *state = evt->findParam("STATE");
215 const char *timestamp = evt->findParam("TIME_NS");
216 const char *uid = evt->findParam("UID");
217 if (state) {
218 bool isActive = !strcmp("active", state);
219 int64_t processTimestamp = (timestamp == nullptr) ? 0 : strtoll(timestamp, nullptr, 10);
220 int intLabel;
221 // NMS only accepts interface class activity changes with integer labels, and only ever
222 // creates idletimers with integer labels.
223 if (android::base::ParseInt(label, &intLabel)) {
224 const long reportedUid =
225 (uid != nullptr && isActive) ? strtol(uid, nullptr, 10) : -1;
226 notifyInterfaceClassActivityChanged(intLabel, isActive, processTimestamp,
227 reportedUid);
228 }
229 }
230
231 #if !LOG_NDEBUG
232 } else if (strcmp(subsys, "platform") && strcmp(subsys, "backlight")) {
233 /* It is not a VSYNC or a backlight event */
234 ALOGV("unexpected event from subsystem %s", subsys);
235 #endif
236 }
237 }
238
notifyInterfaceAdded(const std::string & ifName)239 void NetlinkHandler::notifyInterfaceAdded(const std::string& ifName) {
240 LOG_EVENT_FUNC(BINDER_RETRY, onInterfaceAdded, ifName);
241 }
242
notifyInterfaceRemoved(const std::string & ifName)243 void NetlinkHandler::notifyInterfaceRemoved(const std::string& ifName) {
244 LOG_EVENT_FUNC(BINDER_RETRY, onInterfaceRemoved, ifName);
245 }
246
notifyInterfaceChanged(const std::string & ifName,bool up)247 void NetlinkHandler::notifyInterfaceChanged(const std::string& ifName, bool up) {
248 LOG_EVENT_FUNC(BINDER_RETRY, onInterfaceChanged, ifName, up);
249 }
250
notifyInterfaceLinkChanged(const std::string & ifName,bool up)251 void NetlinkHandler::notifyInterfaceLinkChanged(const std::string& ifName, bool up) {
252 LOG_EVENT_FUNC(BINDER_RETRY, onInterfaceLinkStateChanged, ifName, up);
253 }
254
notifyQuotaLimitReached(const std::string & labelName,const std::string & ifName)255 void NetlinkHandler::notifyQuotaLimitReached(const std::string& labelName,
256 const std::string& ifName) {
257 LOG_EVENT_FUNC(BINDER_RETRY, onQuotaLimitReached, labelName, ifName);
258 }
259
notifyInterfaceClassActivityChanged(int label,bool isActive,int64_t timestamp,int uid)260 void NetlinkHandler::notifyInterfaceClassActivityChanged(int label, bool isActive,
261 int64_t timestamp, int uid) {
262 LOG_EVENT_FUNC(BINDER_RETRY, onInterfaceClassActivityChanged, isActive, label, timestamp, uid);
263 }
264
notifyAddressUpdated(const std::string & addr,const std::string & ifName,int flags,int scope)265 void NetlinkHandler::notifyAddressUpdated(const std::string& addr, const std::string& ifName,
266 int flags, int scope) {
267 LOG_EVENT_FUNC(BINDER_RETRY, onInterfaceAddressUpdated, addr, ifName, flags, scope);
268 }
269
notifyAddressRemoved(const std::string & addr,const std::string & ifName,int flags,int scope)270 void NetlinkHandler::notifyAddressRemoved(const std::string& addr, const std::string& ifName,
271 int flags, int scope) {
272 LOG_EVENT_FUNC(BINDER_RETRY, onInterfaceAddressRemoved, addr, ifName, flags, scope);
273 }
274
notifyInterfaceDnsServers(const std::string & ifName,int64_t lifetime,const std::vector<std::string> & servers)275 void NetlinkHandler::notifyInterfaceDnsServers(const std::string& ifName, int64_t lifetime,
276 const std::vector<std::string>& servers) {
277 LOG_EVENT_FUNC(BINDER_RETRY, onInterfaceDnsServerInfo, ifName, lifetime, servers);
278 }
279
notifyRouteChange(bool updated,const std::string & route,const std::string & gateway,const std::string & ifName)280 void NetlinkHandler::notifyRouteChange(bool updated, const std::string& route,
281 const std::string& gateway, const std::string& ifName) {
282 LOG_EVENT_FUNC(BINDER_RETRY, onRouteChanged, updated, route, gateway, ifName);
283 }
284
notifyStrictCleartext(uid_t uid,const std::string & hex)285 void NetlinkHandler::notifyStrictCleartext(uid_t uid, const std::string& hex) {
286 LOG_EVENT_FUNC(BINDER_RETRY, onStrictCleartextDetected, uid, hex);
287 }
288
289 } // namespace net
290 } // namespace android
291