Add multinetwork debugging tools, dnschk and httpurl

Bug: 19537384
Bug: 27199751
Bug: 28719525
Change-Id: Ie983ec12ac6c550fa76c89cd44343220688a99b4

Author: Erik Kline

multinetwork/Android.mk

@@ -0,0 +1,24 @@
+LOCAL_PATH := $(call my-dir)
+
+# Sample util binaries.
+include $(CLEAR_VARS)
+LOCAL_MODULE := dnschk
+
+LOCAL_C_INCLUDES += frameworks/native/include external/libcxx/include
+LOCAL_CPPFLAGS += -std=c++11
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := debug
+LOCAL_SHARED_LIBRARIES := libandroid libbase libc++
+LOCAL_SRC_FILES := dnschk.cpp common.cpp
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := httpurl
+
+LOCAL_C_INCLUDES += frameworks/native/include external/libcxx/include
+LOCAL_CPPFLAGS += -std=c++11
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := debug
+LOCAL_SHARED_LIBRARIES := libandroid libbase libc++
+LOCAL_SRC_FILES := httpurl.cpp common.cpp
+include $(BUILD_EXECUTABLE)

multinetwork/common.cpp

@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2016 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 "common.h"
+
+#include <android/api-level.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+
+
+namespace {
+
+bool strEqual(const char *a, const char *b) {
+    return strcmp(a, b) == 0;
+}
+
+// Allow specifying network handles in decimal and hexadecimal.
+bool parseNetworkHandle(const char *arg, net_handle_t *nethandle) {
+    if (arg == nullptr || !isdigit(arg[0]) || nethandle == nullptr) {
+        return false;
+    }
+
+    net_handle_t nh;
+    char *end = nullptr;
+
+    nh = strtoull(arg, &end, 0);
+    if (end != nullptr && *end == '\0') {
+        *nethandle = nh;
+        return true;
+    }
+    return false;
+}
+
+}  // namespace
+
+
+void printUsage(const char *progname) {
+    std::cerr << "Usage: " << progname
+              << " [--nethandle <nethandle>]"
+              << " [--mode explicit|process]"
+              << " [--family unspec|ipv4|ipv6]"
+              << " <argument>"
+              << std::endl;
+    std::cerr << std::endl;
+    std::cerr << "Learn nethandle values from 'dumpsys connectivity --short' "
+              << "or 'dumpsys connectivity --diag'"
+              << std::endl;
+}
+
+Arguments::~Arguments() {}
+
+bool Arguments::parseArguments(int argc, const char* argv[]) {
+    if (argc < 1 || argv == nullptr) { return false; }
+
+    for (int i = 1; i < argc; i++) {
+        if (strEqual(argv[i], "--nethandle")) {
+            i++;
+            if (argc == i) break;
+            if (!parseNetworkHandle(argv[i], &nethandle)) {
+                std::cerr << "Failed to parse nethandle: '" << argv[i] << "'"
+                          << std::endl;
+                break;
+            }
+        } else if (strEqual(argv[i], "--family")) {
+            i++;
+            if (argc == i) break;
+            if (strEqual(argv[i], "unspec")) {
+                family = AF_UNSPEC;
+            } else if (strEqual(argv[i], "ipv4")) {
+                family = AF_INET;
+            } else if (strEqual(argv[i], "ipv6")) {
+                family = AF_INET6;
+            } else {
+                break;
+            }
+        } else if (strEqual(argv[i], "--mode")) {
+            i++;
+            if (argc == i) break;
+            if (strEqual(argv[i], "explicit")) {
+                api_mode = ApiMode::EXPLICIT;
+            } else if (strEqual(argv[i], "process")) {
+                api_mode = ApiMode::PROCESS;
+            } else {
+                break;
+            }
+        } else if (arg1 == nullptr) {
+            arg1 = argv[i];
+        } else {
+            arg1 = nullptr;
+            break;
+        }
+    }
+
+    if (arg1 != nullptr) {
+        return true;
+    }
+
+    printUsage(argv[0]);
+    return false;
+}
+
+
+std::string inetSockaddrToString(const sockaddr* sa) {
+    const bool is_ipv6 = (sa->sa_family == AF_INET6);
+    char host[INET6_ADDRSTRLEN];
+    char port[sizeof("65535")];
+    getnameinfo(sa, is_ipv6 ? sizeof(sockaddr_in6) : sizeof(sockaddr_in),
+                host, sizeof(host),
+                port, sizeof(port),
+                NI_NUMERICHOST | NI_NUMERICSERV);
+
+    if (port[0] == '0' || port[0] == '\0') {
+        return std::string(host);
+    }
+    return (is_ipv6 ? "[" : "") + std::string(host) + (is_ipv6 ? "]:" : ":") + std::string(port);
+}

multinetwork/common.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2016 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 SYSTEM_EXTRAS_MULTINETWORK_COMMON_H_
+#define SYSTEM_EXTRAS_MULTINETWORK_COMMON_H_
+
+#include <sys/cdefs.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <string>
+#include <android/multinetwork.h>
+
+enum class ApiMode {
+    EXPLICIT,
+    PROCESS,
+};
+
+
+struct Arguments {
+    Arguments() : nethandle(NETWORK_UNSPECIFIED),
+                  api_mode(ApiMode::EXPLICIT),
+                  family(AF_UNSPEC),
+                  arg1(nullptr) {}
+    ~Arguments();
+
+    bool parseArguments(int argc, const char* argv[]);
+
+    net_handle_t nethandle;
+    ApiMode api_mode;
+    sa_family_t family;
+    const char* arg1;
+};
+
+
+void printUsage(const char *progname);
+
+// If port is non-zero returns strings of the form "192.0.2.1:port" or
+// "[2001:db8::1]:port", else it returns the bare IP string literal.
+std::string inetSockaddrToString(const sockaddr* sa);
+
+
+struct FdAutoCloser {
+    FdAutoCloser() : fd(-1) {}
+    /* not explicit */ FdAutoCloser(int fd) : fd(fd) {}
+    ~FdAutoCloser() {
+        if (fd > -1) {
+            close(fd);
+        }
+        fd = -1;
+    }
+
+    int fd;
+};
+
+#endif  // SYSTEM_EXTRAS_MULTINETWORK_COMMON_H_

multinetwork/dnschk.cpp

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2016 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 <arpa/inet.h>
+#include <errno.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <sys/socket.h>
+
+#include <iostream>
+#include <string>
+
+#include <android/multinetwork.h>
+#include "common.h"
+
+
+int main(int argc, const char* argv[]) {
+    int rval = -1;
+
+    struct Arguments args;
+    if (!args.parseArguments(argc, argv)) { return rval; }
+
+    const struct addrinfo hints = {
+            .ai_family = args.family,
+            .ai_socktype = SOCK_DGRAM,
+    };
+    struct addrinfo *result = nullptr;
+
+    std::cout << "# " << args.arg1
+              << " (via nethandle " << args.nethandle << "):"
+              << std::endl;
+
+    switch (args.api_mode) {
+        case ApiMode::EXPLICIT:
+            rval = android_getaddrinfofornetwork(args.nethandle,
+                    args.arg1, nullptr, &hints, &result);
+            break;
+        case ApiMode::PROCESS:
+            if (args.nethandle != NETWORK_UNSPECIFIED) {
+                rval = android_setprocnetwork(args.nethandle);
+                if (rval != 0) {
+                    std::cerr << "android_setprocnetwork returned " << rval
+                              << std::endl;
+                    return rval;
+                }
+            }
+            rval = getaddrinfo(args.arg1, nullptr, &hints, &result);
+            break;
+        default:
+            // Unreachable.
+            std::cerr << "Unknown api mode." << std::endl;
+            return -1;
+    }
+
+    if (rval != 0) {
+        std::cerr << "DNS resolution failure; gaierror=" << rval
+                  << " [" << gai_strerror(rval) << "]"
+                  << std::endl;
+        return rval;
+    }
+
+    for (struct addrinfo* rp = result; rp != nullptr; rp = rp->ai_next) {
+        std::cout << inetSockaddrToString(rp->ai_addr) << std::endl;
+    }
+
+    freeaddrinfo(result);
+    return 0;
+}