1 /*
2 * Copyright 2016 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 * sock_diag_test.cpp - unit tests for SockDiag.cpp
17 */
18
19 #include <sys/socket.h>
20 #include <netdb.h>
21 #include <arpa/inet.h>
22 #include <netinet/in.h>
23 #include <netinet/tcp.h>
24 #include <linux/inet_diag.h>
25
26 #include <gtest/gtest.h>
27
28 #include "Fwmark.h"
29 #include "NetdConstants.h"
30 #include "SockDiag.h"
31 #include "UidRanges.h"
32
33 namespace android {
34 namespace net {
35
36 class SockDiagTest : public ::testing::Test {
37 protected:
isLoopbackSocket(const inet_diag_msg * msg)38 static bool isLoopbackSocket(const inet_diag_msg *msg) {
39 return SockDiag::isLoopbackSocket(msg);
40 };
41 };
42
bindAndListen(int s)43 uint16_t bindAndListen(int s) {
44 for (int i = 0; i < 10; i++) {
45 uint16_t port = 1024 + arc4random_uniform(0xffff - 1024);
46 sockaddr_in6 sin6 = { .sin6_family = AF_INET6, .sin6_port = htons(port) };
47 if (bind(s, (sockaddr *) &sin6, sizeof(sin6)) == 0) {
48 listen(s, 1);
49 return port;
50 }
51 }
52 close(s);
53 return 0;
54 }
55
tcpStateName(uint8_t state)56 const char *tcpStateName(uint8_t state) {
57 static const char *states[] = {
58 "???",
59 "TCP_ESTABLISHED",
60 "TCP_SYN_SENT",
61 "TCP_SYN_RECV",
62 "TCP_FIN_WAIT1",
63 "TCP_FIN_WAIT2",
64 "TCP_TIME_WAIT",
65 "TCP_CLOSE",
66 "TCP_CLOSE_WAIT",
67 "TCP_LAST_ACK",
68 "TCP_LISTEN",
69 "TCP_CLOSING",
70 "TCP_NEW_SYN_RECV",
71 };
72 return states[(state < ARRAY_SIZE(states)) ? state : 0];
73 }
74
TEST_F(SockDiagTest,TestDump)75 TEST_F(SockDiagTest, TestDump) {
76 int v4socket = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
77 ASSERT_NE(-1, v4socket) << "Failed to open IPv4 socket: " << strerror(errno);
78 int v6socket = socket(AF_INET6, SOCK_STREAM | SOCK_CLOEXEC, 0);
79 ASSERT_NE(-1, v6socket) << "Failed to open IPv6 socket: " << strerror(errno);
80 int listensocket = socket(AF_INET6, SOCK_STREAM | SOCK_CLOEXEC, 0);
81 ASSERT_NE(-1, listensocket) << "Failed to open listen socket: " << strerror(errno);
82
83 uint16_t port = bindAndListen(listensocket);
84 ASSERT_NE(0, port) << "Can't bind to server port";
85
86 // Connect to loopback.
87 sockaddr_in server4 = { .sin_family = AF_INET, .sin_port = htons(port) };
88 sockaddr_in6 server6 = { .sin6_family = AF_INET6, .sin6_port = htons(port) };
89 ASSERT_EQ(0, connect(v4socket, (sockaddr *) &server4, sizeof(server4)))
90 << "IPv4 connect failed: " << strerror(errno);
91 ASSERT_EQ(0, connect(v6socket, (sockaddr *) &server6, sizeof(server6)))
92 << "IPv6 connect failed: " << strerror(errno);
93
94 sockaddr_in6 client46, client6;
95 socklen_t clientlen = std::max(sizeof(client46), sizeof(client6));
96 int accepted4 = accept4(
97 listensocket, (sockaddr *) &client46, &clientlen, SOCK_CLOEXEC);
98 int accepted6 = accept4(
99 listensocket, (sockaddr *) &client6, &clientlen, SOCK_CLOEXEC);
100 ASSERT_NE(-1, accepted4);
101 ASSERT_NE(-1, accepted6);
102
103 int v4SocketsSeen = 0;
104 bool seenclient46 = false;
105 char src[INET6_ADDRSTRLEN], dst[INET6_ADDRSTRLEN];
106
107 fprintf(stderr, "Ports:\n server=%d. client46=%d, client6=%d\n",
108 port, ntohs(client46.sin6_port), ntohs(client6.sin6_port));
109
110 auto checkIPv4Dump = [&] (uint8_t /* proto */, const inet_diag_msg *msg) {
111 EXPECT_EQ(htonl(INADDR_LOOPBACK), msg->id.idiag_src[0]);
112 v4SocketsSeen++;
113 seenclient46 |= (msg->id.idiag_sport == client46.sin6_port);
114 inet_ntop(AF_INET, msg->id.idiag_src, src, sizeof(src));
115 inet_ntop(AF_INET, msg->id.idiag_src, dst, sizeof(dst));
116 fprintf(stderr, " v4 %s:%d -> %s:%d %s\n",
117 src, htons(msg->id.idiag_sport),
118 dst, htons(msg->id.idiag_dport),
119 tcpStateName(msg->idiag_state));
120 if (msg->idiag_state == TCP_ESTABLISHED) {
121 EXPECT_TRUE(isLoopbackSocket(msg));
122 }
123 return false;
124 };
125
126 int v6SocketsSeen = 0;
127 bool seenClient6 = false, seenServer46 = false, seenServer6 = false;
128
129 auto checkIPv6Dump = [&] (uint8_t /* proto */, const inet_diag_msg *msg) {
130 struct in6_addr *saddr = (struct in6_addr *) msg->id.idiag_src;
131 EXPECT_TRUE(
132 IN6_IS_ADDR_LOOPBACK(saddr) ||
133 (IN6_IS_ADDR_V4MAPPED(saddr) && saddr->s6_addr32[3] == htonl(INADDR_LOOPBACK)));
134 v6SocketsSeen++;
135 seenClient6 |= (msg->id.idiag_sport == client6.sin6_port);
136 seenServer46 |= (msg->id.idiag_sport == htons(port));
137 seenServer6 |= (msg->id.idiag_sport == htons(port));
138 inet_ntop(AF_INET6, msg->id.idiag_src, src, sizeof(src));
139 inet_ntop(AF_INET6, msg->id.idiag_src, dst, sizeof(dst));
140 fprintf(stderr, " v6 [%s]:%d -> [%s]:%d %s\n",
141 src, htons(msg->id.idiag_sport),
142 dst, htons(msg->id.idiag_dport),
143 tcpStateName(msg->idiag_state));
144 if (msg->idiag_state == TCP_ESTABLISHED) {
145 EXPECT_TRUE(isLoopbackSocket(msg));
146 }
147 return false;
148 };
149
150 SockDiag sd;
151 ASSERT_TRUE(sd.open()) << "Failed to open SOCK_DIAG socket";
152
153 int ret = sd.sendDumpRequest(IPPROTO_TCP, AF_INET, "127.0.0.1");
154 ASSERT_EQ(0, ret) << "Failed to send IPv4 dump request: " << strerror(-ret);
155 fprintf(stderr, "Sent IPv4 dump\n");
156 sd.readDiagMsg(IPPROTO_TCP, checkIPv4Dump);
157 EXPECT_GE(v4SocketsSeen, 1);
158 EXPECT_TRUE(seenclient46);
159 EXPECT_FALSE(seenServer46);
160
161 ret = sd.sendDumpRequest(IPPROTO_TCP, AF_INET6, "127.0.0.1");
162 ASSERT_EQ(0, ret) << "Failed to send mapped dump request: " << strerror(-ret);
163 fprintf(stderr, "Sent mapped dump\n");
164 sd.readDiagMsg(IPPROTO_TCP, checkIPv6Dump);
165 EXPECT_TRUE(seenServer46);
166
167 ret = sd.sendDumpRequest(IPPROTO_TCP, AF_INET6, "::1");
168 ASSERT_EQ(0, ret) << "Failed to send IPv6 dump request: " << strerror(-ret);
169 fprintf(stderr, "Sent IPv6 dump\n");
170
171 sd.readDiagMsg(IPPROTO_TCP, checkIPv6Dump);
172 EXPECT_GE(v6SocketsSeen, 1);
173 EXPECT_TRUE(seenClient6);
174 EXPECT_TRUE(seenServer6);
175
176 close(v4socket);
177 close(v6socket);
178 close(listensocket);
179 close(accepted4);
180 close(accepted6);
181 }
182
fillDiagAddr(__be32 addr[4],const sockaddr * sa)183 bool fillDiagAddr(__be32 addr[4], const sockaddr *sa) {
184 switch (sa->sa_family) {
185 case AF_INET: {
186 sockaddr_in *sin = (sockaddr_in *) sa;
187 memcpy(addr, &sin->sin_addr, sizeof(sin->sin_addr));
188 return true;
189 }
190 case AF_INET6: {
191 sockaddr_in6 *sin6 = (sockaddr_in6 *) sa;
192 memcpy(addr, &sin6->sin6_addr, sizeof(sin6->sin6_addr));
193 return true;
194 }
195 default:
196 return false;
197 }
198 }
199
makeDiagMessage(__u8 family,const sockaddr * src,const sockaddr * dst)200 inet_diag_msg makeDiagMessage(__u8 family, const sockaddr *src, const sockaddr *dst) {
201 inet_diag_msg msg = {
202 .idiag_family = family,
203 .idiag_state = TCP_ESTABLISHED,
204 .id =
205 {
206 .idiag_sport = 1234,
207 .idiag_dport = 4321,
208 },
209 .idiag_uid = AID_APP + 123,
210 .idiag_inode = 123456789,
211 };
212 EXPECT_TRUE(fillDiagAddr(msg.id.idiag_src, src));
213 EXPECT_TRUE(fillDiagAddr(msg.id.idiag_dst, dst));
214 return msg;
215 }
216
makeDiagMessage(const char * srcstr,const char * dststr)217 inet_diag_msg makeDiagMessage(const char* srcstr, const char* dststr) {
218 addrinfo hints = { .ai_flags = AI_NUMERICHOST }, *src, *dst;
219 EXPECT_EQ(0, getaddrinfo(srcstr, nullptr, &hints, &src));
220 EXPECT_EQ(0, getaddrinfo(dststr, nullptr, &hints, &dst));
221 EXPECT_EQ(src->ai_addr->sa_family, dst->ai_addr->sa_family);
222 inet_diag_msg msg = makeDiagMessage(src->ai_addr->sa_family, src->ai_addr, dst->ai_addr);
223 freeaddrinfo(src);
224 freeaddrinfo(dst);
225 return msg;
226 }
227
TEST_F(SockDiagTest,TestIsLoopbackSocket)228 TEST_F(SockDiagTest, TestIsLoopbackSocket) {
229 inet_diag_msg msg;
230
231 msg = makeDiagMessage("127.0.0.1", "127.0.0.1");
232 EXPECT_TRUE(isLoopbackSocket(&msg));
233
234 msg = makeDiagMessage("::1", "::1");
235 EXPECT_TRUE(isLoopbackSocket(&msg));
236
237 msg = makeDiagMessage("::1", "::ffff:127.0.0.1");
238 EXPECT_TRUE(isLoopbackSocket(&msg));
239
240 msg = makeDiagMessage("192.0.2.1", "192.0.2.1");
241 EXPECT_TRUE(isLoopbackSocket(&msg));
242
243 msg = makeDiagMessage("192.0.2.1", "8.8.8.8");
244 EXPECT_FALSE(isLoopbackSocket(&msg));
245
246 msg = makeDiagMessage("192.0.2.1", "127.0.0.1");
247 EXPECT_TRUE(isLoopbackSocket(&msg));
248
249 msg = makeDiagMessage("2001:db8::1", "2001:db8::1");
250 EXPECT_TRUE(isLoopbackSocket(&msg));
251
252 msg = makeDiagMessage("2001:db8::1", "2001:4860:4860::6464");
253 EXPECT_FALSE(isLoopbackSocket(&msg));
254
255 // While isLoopbackSocket returns true on these sockets, we usually don't want to close them
256 // because they aren't specific to any particular network and thus don't become unusable when
257 // an app's routing changes or its network access is removed.
258 //
259 // This isn't a problem, as anything that calls destroyLiveSockets will skip them because
260 // destroyLiveSockets only enumerates ESTABLISHED, SYN_SENT, and SYN_RECV sockets.
261 msg = makeDiagMessage("127.0.0.1", "0.0.0.0");
262 EXPECT_TRUE(isLoopbackSocket(&msg));
263
264 msg = makeDiagMessage("::1", "::");
265 EXPECT_TRUE(isLoopbackSocket(&msg));
266 }
267
268 enum MicroBenchmarkTestType {
269 ADDRESS,
270 UID,
271 UID_EXCLUDE_LOOPBACK,
272 UIDRANGE,
273 UIDRANGE_EXCLUDE_LOOPBACK,
274 PERMISSION,
275 };
276
testTypeName(MicroBenchmarkTestType mode)277 const char *testTypeName(MicroBenchmarkTestType mode) {
278 #define TO_STRING_TYPE(x) case ((x)): return #x;
279 switch((mode)) {
280 TO_STRING_TYPE(ADDRESS);
281 TO_STRING_TYPE(UID);
282 TO_STRING_TYPE(UID_EXCLUDE_LOOPBACK);
283 TO_STRING_TYPE(UIDRANGE);
284 TO_STRING_TYPE(UIDRANGE_EXCLUDE_LOOPBACK);
285 TO_STRING_TYPE(PERMISSION);
286 }
287 #undef TO_STRING_TYPE
288 }
289
290 static struct {
291 unsigned netId;
292 bool explicitlySelected;
293 Permission permission;
294 } permissionTestcases[] = {
295 { 42, false, PERMISSION_NONE, },
296 { 42, false, PERMISSION_NETWORK, },
297 { 42, false, PERMISSION_SYSTEM, },
298 { 42, true, PERMISSION_NONE, },
299 { 42, true, PERMISSION_NETWORK, },
300 { 42, true, PERMISSION_SYSTEM, },
301 { 43, false, PERMISSION_NONE, },
302 { 43, false, PERMISSION_NETWORK, },
303 { 43, false, PERMISSION_SYSTEM, },
304 { 43, true, PERMISSION_NONE, },
305 { 43, true, PERMISSION_NETWORK, },
306 { 43, true, PERMISSION_SYSTEM, },
307 };
308
309 class SockDiagMicroBenchmarkTest : public ::testing::TestWithParam<MicroBenchmarkTestType> {
310
311 public:
SetUp()312 void SetUp() {
313 ASSERT_TRUE(mSd.open()) << "Failed to open SOCK_DIAG socket";
314 }
315
316 protected:
317 SockDiag mSd;
318
319 constexpr static int MAX_SOCKETS = 500;
320 constexpr static int ADDRESS_SOCKETS = 500;
321 constexpr static int UID_SOCKETS = 50;
322 constexpr static int PERMISSION_SOCKETS = 16;
323
324 constexpr static uid_t START_UID = 8000; // START_UID + number of sockets must be <= 9999.
325 constexpr static int CLOSE_UID = START_UID + UID_SOCKETS - 42; // Close to the end
326 static_assert(START_UID + MAX_SOCKETS < 9999, "Too many sockets");
327
328 constexpr static int TEST_NETID = 42; // One of the OEM netIds.
329
330
howManySockets()331 int howManySockets() {
332 MicroBenchmarkTestType mode = GetParam();
333 switch (mode) {
334 case ADDRESS:
335 return ADDRESS_SOCKETS;
336 case UID:
337 case UID_EXCLUDE_LOOPBACK:
338 case UIDRANGE:
339 case UIDRANGE_EXCLUDE_LOOPBACK:
340 return UID_SOCKETS;
341 case PERMISSION:
342 return ARRAY_SIZE(permissionTestcases);
343 }
344 }
345
modifySocketForTest(int s,int i)346 int modifySocketForTest(int s, int i) {
347 MicroBenchmarkTestType mode = GetParam();
348 switch (mode) {
349 case UID:
350 case UID_EXCLUDE_LOOPBACK:
351 case UIDRANGE:
352 case UIDRANGE_EXCLUDE_LOOPBACK: {
353 uid_t uid = START_UID + i;
354 return fchown(s, uid, -1);
355 }
356 case PERMISSION: {
357 Fwmark fwmark;
358 fwmark.netId = permissionTestcases[i].netId;
359 fwmark.explicitlySelected = permissionTestcases[i].explicitlySelected;
360 fwmark.permission = permissionTestcases[i].permission;
361 return setsockopt(s, SOL_SOCKET, SO_MARK, &fwmark.intValue, sizeof(fwmark.intValue));
362 }
363 default:
364 return 0;
365 }
366 }
367
destroySockets()368 int destroySockets() {
369 MicroBenchmarkTestType mode = GetParam();
370 int ret;
371 switch (mode) {
372 case ADDRESS:
373 ret = mSd.destroySockets("::1", 0 /* ifindex */);
374 EXPECT_LE(0, ret) << ": Failed to destroy sockets on ::1: " << strerror(-ret);
375 break;
376 case UID:
377 case UID_EXCLUDE_LOOPBACK: {
378 bool excludeLoopback = (mode == UID_EXCLUDE_LOOPBACK);
379 ret = mSd.destroySockets(IPPROTO_TCP, CLOSE_UID, excludeLoopback);
380 EXPECT_LE(0, ret) << ": Failed to destroy sockets for UID " << CLOSE_UID << ": " <<
381 strerror(-ret);
382 break;
383 }
384 case UIDRANGE:
385 case UIDRANGE_EXCLUDE_LOOPBACK: {
386 bool excludeLoopback = (mode == UIDRANGE_EXCLUDE_LOOPBACK);
387 const char *uidRangeStrings[] = { "8005-8012", "8042", "8043", "8090-8099" };
388 std::set<uid_t> skipUids { 8007, 8043, 8098, 8099 };
389 UidRanges uidRanges;
390 uidRanges.parseFrom(ARRAY_SIZE(uidRangeStrings), (char **) uidRangeStrings);
391 ret = mSd.destroySockets(uidRanges, skipUids, excludeLoopback);
392 break;
393 }
394 case PERMISSION: {
395 ret = mSd.destroySocketsLackingPermission(TEST_NETID, PERMISSION_NETWORK, false);
396 break;
397 }
398 }
399 return ret;
400 }
401
shouldHaveClosedSocket(int i)402 bool shouldHaveClosedSocket(int i) {
403 MicroBenchmarkTestType mode = GetParam();
404 switch (mode) {
405 case ADDRESS:
406 return true;
407 case UID:
408 return i == CLOSE_UID - START_UID;
409 case UIDRANGE: {
410 uid_t uid = i + START_UID;
411 // Skip UIDs in skipUids.
412 if (uid == 8007 || uid == 8043 || uid == 8098 || uid == 8099) {
413 return false;
414 }
415 // Include UIDs in uidRanges.
416 if ((8005 <= uid && uid <= 8012) || uid == 8042 || (8090 <= uid && uid <= 8099)) {
417 return true;
418 }
419 return false;
420 }
421 case UID_EXCLUDE_LOOPBACK:
422 case UIDRANGE_EXCLUDE_LOOPBACK:
423 return false;
424 case PERMISSION:
425 if (permissionTestcases[i].netId != 42) return false;
426 if (permissionTestcases[i].explicitlySelected != 1) return true;
427 Permission permission = permissionTestcases[i].permission;
428 return permission != PERMISSION_NETWORK && permission != PERMISSION_SYSTEM;
429 }
430 }
431
checkSocketState(int i,int sock,const char * msg)432 bool checkSocketState(int i, int sock, const char *msg) {
433 const char data[] = "foo";
434 const int ret = send(sock, data, sizeof(data), 0);
435 const int err = errno;
436 if (!shouldHaveClosedSocket(i)) {
437 EXPECT_EQ((ssize_t) sizeof(data), ret) <<
438 "Write on open socket failed: " << strerror(err);
439 return false;
440 }
441
442 EXPECT_EQ(-1, ret) << msg << " " << i << " not closed";
443 if (ret != -1) {
444 return false;
445 }
446
447 // Since we're connected to ourselves, the error might be ECONNABORTED (if we destroyed the
448 // socket) or ECONNRESET (if the other end was destroyed and sent a RST).
449 EXPECT_TRUE(err == ECONNABORTED || err == ECONNRESET)
450 << msg << ": unexpected error: " << strerror(err);
451 return (err == ECONNABORTED); // Return true iff. SOCK_DESTROY closed this socket.
452 }
453 };
454
TEST_P(SockDiagMicroBenchmarkTest,TestMicroBenchmark)455 TEST_P(SockDiagMicroBenchmarkTest, TestMicroBenchmark) {
456 MicroBenchmarkTestType mode = GetParam();
457
458 int numSockets = howManySockets();
459
460 fprintf(stderr, "Benchmarking closing %d sockets based on %s\n",
461 numSockets, testTypeName(mode));
462
463 int listensocket = socket(AF_INET6, SOCK_STREAM | SOCK_CLOEXEC, 0);
464 ASSERT_NE(-1, listensocket) << "Failed to open listen socket";
465
466 uint16_t port = bindAndListen(listensocket);
467 ASSERT_NE(0, port) << "Can't bind to server port";
468 sockaddr_in6 server = { .sin6_family = AF_INET6, .sin6_port = htons(port) };
469
470 using ms = std::chrono::duration<float, std::ratio<1, 1000>>;
471
472 int clientsockets[MAX_SOCKETS], serversockets[MAX_SOCKETS];
473 uint16_t clientports[MAX_SOCKETS];
474 sockaddr_in6 client;
475 socklen_t clientlen;
476
477 auto start = std::chrono::steady_clock::now();
478 for (int i = 0; i < numSockets; i++) {
479 int s = socket(AF_INET6, SOCK_STREAM | SOCK_CLOEXEC, 0);
480 clientlen = sizeof(client);
481 ASSERT_EQ(0, connect(s, (sockaddr *) &server, sizeof(server)))
482 << "Connecting socket " << i << " failed " << strerror(errno);
483 ASSERT_EQ(0, modifySocketForTest(s, i));
484 serversockets[i] = accept4(
485 listensocket, (sockaddr *) &client, &clientlen, SOCK_CLOEXEC);
486 ASSERT_NE(-1, serversockets[i])
487 << "Accepting socket " << i << " failed " << strerror(errno);
488 clientports[i] = client.sin6_port;
489 clientsockets[i] = s;
490 }
491 fprintf(stderr, " Connecting: %6.1f ms\n",
492 std::chrono::duration_cast<ms>(std::chrono::steady_clock::now() - start).count());
493
494 start = std::chrono::steady_clock::now();
495 destroySockets();
496 fprintf(stderr, " Destroying: %6.1f ms\n",
497 std::chrono::duration_cast<ms>(std::chrono::steady_clock::now() - start).count());
498
499 start = std::chrono::steady_clock::now();
500 int socketsClosed = 0;
501 for (int i = 0; i < numSockets; i++) {
502 socketsClosed += checkSocketState(i, clientsockets[i], "Client socket");
503 socketsClosed += checkSocketState(i, serversockets[i], "Server socket");
504 }
505 fprintf(stderr, " Verifying: %6.1f ms (%d sockets destroyed)\n",
506 std::chrono::duration_cast<ms>(std::chrono::steady_clock::now() - start).count(),
507 socketsClosed);
508 if (strstr(testTypeName(mode), "_EXCLUDE_LOOPBACK") == nullptr) {
509 EXPECT_GT(socketsClosed, 0); // Just in case there's a bug in the test.
510 }
511
512 start = std::chrono::steady_clock::now();
513 for (int i = 0; i < numSockets; i++) {
514 close(clientsockets[i]);
515 close(serversockets[i]);
516 }
517 fprintf(stderr, " Closing: %6.1f ms\n",
518 std::chrono::duration_cast<ms>(std::chrono::steady_clock::now() - start).count());
519
520 close(listensocket);
521 }
522
523 // "SockDiagTest.cpp:232: error: undefined reference to 'SockDiagMicroBenchmarkTest::CLOSE_UID'".
524 constexpr int SockDiagMicroBenchmarkTest::CLOSE_UID;
525
526 INSTANTIATE_TEST_CASE_P(Address, SockDiagMicroBenchmarkTest,
527 testing::Values(ADDRESS, UID, UIDRANGE,
528 UID_EXCLUDE_LOOPBACK, UIDRANGE_EXCLUDE_LOOPBACK,
529 PERMISSION));
530
531 } // namespace net
532 } // namespace android
533