upload android base code part6

android/system/netd/client/Android.bp

@@ -0,0 +1,39 @@
+// Copyright (C) 2017 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+cc_library {
+    name: "libnetd_client",
+
+    srcs: [
+        "FwmarkClient.cpp",
+        "NetdClient.cpp",
+    ],
+
+    shared_libs: ["libcutils"],
+
+    header_libs: ["libnetd_client_headers"],
+    export_header_lib_headers: ["libnetd_client_headers"],
+
+    include_dirs: [
+        "bionic/libc/dns/include",
+        "system/netd/include",
+    ],
+
+    cflags: [
+        "-Wall",
+        "-Werror",
+    ],
+
+    clang: true,
+}

android/system/netd/client/FwmarkClient.cpp

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FwmarkClient.h"
+
+#include "FwmarkCommand.h"
+
+#include <errno.h>
+#include <cutils/properties.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))
+
+namespace {
+
+const sockaddr_un FWMARK_SERVER_PATH = {AF_UNIX, "/dev/socket/fwmarkd"};
+
+const bool isBuildDebuggable = property_get_bool("ro.debuggable", 0) == 1;
+
+bool isOverriddenBy(const char *name) {
+    return isBuildDebuggable && getenv(name);
+}
+
+}  // namespace
+
+bool FwmarkClient::shouldSetFwmark(int family) {
+    if (isOverriddenBy(ANDROID_NO_USE_FWMARK_CLIENT)) {
+        return false;
+    }
+    return family == AF_INET || family == AF_INET6;
+}
+
+bool FwmarkClient::shouldReportConnectComplete(int family) {
+    if (isOverriddenBy(ANDROID_FWMARK_METRICS_ONLY)) {
+        return false;
+    }
+    return shouldSetFwmark(family);
+}
+
+FwmarkClient::FwmarkClient() : mChannel(-1) {
+}
+
+FwmarkClient::~FwmarkClient() {
+    if (mChannel >= 0) {
+        close(mChannel);
+    }
+}
+
+int FwmarkClient::send(FwmarkCommand* data, int fd, FwmarkConnectInfo* connectInfo) {
+    mChannel = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
+    if (mChannel == -1) {
+        return -errno;
+    }
+
+    if (TEMP_FAILURE_RETRY(connect(mChannel, reinterpret_cast<const sockaddr*>(&FWMARK_SERVER_PATH),
+                                   sizeof(FWMARK_SERVER_PATH))) == -1) {
+        // If we are unable to connect to the fwmark server, assume there's no error. This protects
+        // against future changes if the fwmark server goes away.
+        return 0;
+    }
+
+    iovec iov[2] = {
+        { data, sizeof(*data) },
+        { connectInfo, (connectInfo ? sizeof(*connectInfo) : 0) },
+    };
+    msghdr message;
+    memset(&message, 0, sizeof(message));
+    message.msg_iov = iov;
+    message.msg_iovlen = ARRAY_SIZE(iov);
+
+    union {
+        cmsghdr cmh;
+        char cmsg[CMSG_SPACE(sizeof(fd))];
+    } cmsgu;
+
+    if (data->cmdId != FwmarkCommand::QUERY_USER_ACCESS) {
+        memset(cmsgu.cmsg, 0, sizeof(cmsgu.cmsg));
+        message.msg_control = cmsgu.cmsg;
+        message.msg_controllen = sizeof(cmsgu.cmsg);
+
+        cmsghdr* const cmsgh = CMSG_FIRSTHDR(&message);
+        cmsgh->cmsg_len = CMSG_LEN(sizeof(fd));
+        cmsgh->cmsg_level = SOL_SOCKET;
+        cmsgh->cmsg_type = SCM_RIGHTS;
+        memcpy(CMSG_DATA(cmsgh), &fd, sizeof(fd));
+    }
+
+    if (TEMP_FAILURE_RETRY(sendmsg(mChannel, &message, 0)) == -1) {
+        return -errno;
+    }
+
+    int error = 0;
+
+    if (TEMP_FAILURE_RETRY(recv(mChannel, &error, sizeof(error), 0)) == -1) {
+        return -errno;
+    }
+
+    return error;
+}

android/system/netd/client/FwmarkClient.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef NETD_CLIENT_FWMARK_CLIENT_H
+#define NETD_CLIENT_FWMARK_CLIENT_H
+
+#include <sys/socket.h>
+
+struct FwmarkCommand;
+struct FwmarkConnectInfo;
+
+class FwmarkClient {
+public:
+    // Returns true if a socket of the given |family| should be sent to the fwmark server to have
+    // its SO_MARK set.
+    static bool shouldSetFwmark(int family);
+
+    // Returns true if an additional call should be made after ON_CONNECT calls, to log extra
+    // information like latency and source IP.
+    static bool shouldReportConnectComplete(int family);
+
+    FwmarkClient();
+    ~FwmarkClient();
+
+    // Sends |data| to the fwmark server, along with |fd| as ancillary data using cmsg(3).
+    // For ON_CONNECT_COMPLETE |data| command, |connectInfo| should be provided.
+    // Returns 0 on success or a negative errno value on failure.
+    int send(FwmarkCommand* data, int fd, FwmarkConnectInfo* connectInfo);
+
+    // Env flag to control whether FwmarkClient sends any information at all about network events
+    // back to the system server through FwmarkServer.
+    static constexpr const char* ANDROID_NO_USE_FWMARK_CLIENT = "ANDROID_NO_USE_FWMARK_CLIENT";
+
+    // Env flag to control whether FwmarkClient should exclude detailed information like IP
+    // addresses and only send basic information necessary for marking sockets.
+    // Has no effect if ANDROID_NO_USE_FWMARK_CLIENT is set.
+    static constexpr const char* ANDROID_FWMARK_METRICS_ONLY = "ANDROID_FWMARK_METRICS_ONLY";
+
+private:
+    int mChannel;
+};
+
+#endif  // NETD_CLIENT_FWMARK_CLIENT_H

android/system/netd/client/NetdClient.cpp

@@ -0,0 +1,239 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "NetdClient.h"
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <math.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <atomic>
+
+#include "Fwmark.h"
+#include "FwmarkClient.h"
+#include "FwmarkCommand.h"
+#include "resolv_netid.h"
+#include "Stopwatch.h"
+
+namespace {
+
+std::atomic_uint netIdForProcess(NETID_UNSET);
+std::atomic_uint netIdForResolv(NETID_UNSET);
+
+typedef int (*Accept4FunctionType)(int, sockaddr*, socklen_t*, int);
+typedef int (*ConnectFunctionType)(int, const sockaddr*, socklen_t);
+typedef int (*SocketFunctionType)(int, int, int);
+typedef unsigned (*NetIdForResolvFunctionType)(unsigned);
+
+// These variables are only modified at startup (when libc.so is loaded) and never afterwards, so
+// it's okay that they are read later at runtime without a lock.
+Accept4FunctionType libcAccept4 = 0;
+ConnectFunctionType libcConnect = 0;
+SocketFunctionType libcSocket = 0;
+
+int closeFdAndSetErrno(int fd, int error) {
+    close(fd);
+    errno = -error;
+    return -1;
+}
+
+int netdClientAccept4(int sockfd, sockaddr* addr, socklen_t* addrlen, int flags) {
+    int acceptedSocket = libcAccept4(sockfd, addr, addrlen, flags);
+    if (acceptedSocket == -1) {
+        return -1;
+    }
+    int family;
+    if (addr) {
+        family = addr->sa_family;
+    } else {
+        socklen_t familyLen = sizeof(family);
+        if (getsockopt(acceptedSocket, SOL_SOCKET, SO_DOMAIN, &family, &familyLen) == -1) {
+            return closeFdAndSetErrno(acceptedSocket, -errno);
+        }
+    }
+    if (FwmarkClient::shouldSetFwmark(family)) {
+        FwmarkCommand command = {FwmarkCommand::ON_ACCEPT, 0, 0};
+        if (int error = FwmarkClient().send(&command, acceptedSocket, nullptr)) {
+            return closeFdAndSetErrno(acceptedSocket, error);
+        }
+    }
+    return acceptedSocket;
+}
+
+int netdClientConnect(int sockfd, const sockaddr* addr, socklen_t addrlen) {
+    const bool shouldSetFwmark = (sockfd >= 0) && addr
+            && FwmarkClient::shouldSetFwmark(addr->sa_family);
+    if (shouldSetFwmark) {
+        FwmarkCommand command = {FwmarkCommand::ON_CONNECT, 0, 0};
+        if (int error = FwmarkClient().send(&command, sockfd, nullptr)) {
+            errno = -error;
+            return -1;
+        }
+    }
+    // Latency measurement does not include time of sending commands to Fwmark
+    Stopwatch s;
+    const int ret = libcConnect(sockfd, addr, addrlen);
+    // Save errno so it isn't clobbered by sending ON_CONNECT_COMPLETE
+    const int connectErrno = errno;
+    const unsigned latencyMs = lround(s.timeTaken());
+    // Send an ON_CONNECT_COMPLETE command that includes sockaddr and connect latency for reporting
+    if (shouldSetFwmark && FwmarkClient::shouldReportConnectComplete(addr->sa_family)) {
+        FwmarkConnectInfo connectInfo(ret == 0 ? 0 : connectErrno, latencyMs, addr);
+        // TODO: get the netId from the socket mark once we have continuous benchmark runs
+        FwmarkCommand command = {FwmarkCommand::ON_CONNECT_COMPLETE, /* netId (ignored) */ 0,
+                /* uid (filled in by the server) */ 0};
+        // Ignore return value since it's only used for logging
+        FwmarkClient().send(&command, sockfd, &connectInfo);
+    }
+    errno = connectErrno;
+    return ret;
+}
+
+int netdClientSocket(int domain, int type, int protocol) {
+    int socketFd = libcSocket(domain, type, protocol);
+    if (socketFd == -1) {
+        return -1;
+    }
+    unsigned netId = netIdForProcess;
+    if (netId != NETID_UNSET && FwmarkClient::shouldSetFwmark(domain)) {
+        if (int error = setNetworkForSocket(netId, socketFd)) {
+            return closeFdAndSetErrno(socketFd, error);
+        }
+    }
+    return socketFd;
+}
+
+unsigned getNetworkForResolv(unsigned netId) {
+    if (netId != NETID_UNSET) {
+        return netId;
+    }
+    netId = netIdForProcess;
+    if (netId != NETID_UNSET) {
+        return netId;
+    }
+    return netIdForResolv;
+}
+
+int setNetworkForTarget(unsigned netId, std::atomic_uint* target) {
+    if (netId == NETID_UNSET) {
+        *target = netId;
+        return 0;
+    }
+    // Verify that we are allowed to use |netId|, by creating a socket and trying to have it marked
+    // with the netId. Call libcSocket() directly; else the socket creation (via netdClientSocket())
+    // might itself cause another check with the fwmark server, which would be wasteful.
+    int socketFd;
+    if (libcSocket) {
+        socketFd = libcSocket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+    } else {
+        socketFd = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+    }
+    if (socketFd < 0) {
+        return -errno;
+    }
+    int error = setNetworkForSocket(netId, socketFd);
+    if (!error) {
+        *target = netId;
+    }
+    close(socketFd);
+    return error;
+}
+
+}  // namespace
+
+// accept() just calls accept4(..., 0), so there's no need to handle accept() separately.
+extern "C" void netdClientInitAccept4(Accept4FunctionType* function) {
+    if (function && *function) {
+        libcAccept4 = *function;
+        *function = netdClientAccept4;
+    }
+}
+
+extern "C" void netdClientInitConnect(ConnectFunctionType* function) {
+    if (function && *function) {
+        libcConnect = *function;
+        *function = netdClientConnect;
+    }
+}
+
+extern "C" void netdClientInitSocket(SocketFunctionType* function) {
+    if (function && *function) {
+        libcSocket = *function;
+        *function = netdClientSocket;
+    }
+}
+
+extern "C" void netdClientInitNetIdForResolv(NetIdForResolvFunctionType* function) {
+    if (function) {
+        *function = getNetworkForResolv;
+    }
+}
+
+extern "C" int getNetworkForSocket(unsigned* netId, int socketFd) {
+    if (!netId || socketFd < 0) {
+        return -EBADF;
+    }
+    Fwmark fwmark;
+    socklen_t fwmarkLen = sizeof(fwmark.intValue);
+    if (getsockopt(socketFd, SOL_SOCKET, SO_MARK, &fwmark.intValue, &fwmarkLen) == -1) {
+        return -errno;
+    }
+    *netId = fwmark.netId;
+    return 0;
+}
+
+extern "C" unsigned getNetworkForProcess() {
+    return netIdForProcess;
+}
+
+extern "C" int setNetworkForSocket(unsigned netId, int socketFd) {
+    if (socketFd < 0) {
+        return -EBADF;
+    }
+    FwmarkCommand command = {FwmarkCommand::SELECT_NETWORK, netId, 0};
+    return FwmarkClient().send(&command, socketFd, nullptr);
+}
+
+extern "C" int setNetworkForProcess(unsigned netId) {
+    return setNetworkForTarget(netId, &netIdForProcess);
+}
+
+extern "C" int setNetworkForResolv(unsigned netId) {
+    return setNetworkForTarget(netId, &netIdForResolv);
+}
+
+extern "C" int protectFromVpn(int socketFd) {
+    if (socketFd < 0) {
+        return -EBADF;
+    }
+    FwmarkCommand command = {FwmarkCommand::PROTECT_FROM_VPN, 0, 0};
+    return FwmarkClient().send(&command, socketFd, nullptr);
+}
+
+extern "C" int setNetworkForUser(uid_t uid, int socketFd) {
+    if (socketFd < 0) {
+        return -EBADF;
+    }
+    FwmarkCommand command = {FwmarkCommand::SELECT_FOR_USER, 0, uid};
+    return FwmarkClient().send(&command, socketFd, nullptr);
+}
+
+extern "C" int queryUserAccess(uid_t uid, unsigned netId) {
+    FwmarkCommand command = {FwmarkCommand::QUERY_USER_ACCESS, netId, uid};
+    return FwmarkClient().send(&command, -1, nullptr);
+}