| /* |
| * 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 <errno.h> |
| #include <fcntl.h> |
| #include <netdb.h> |
| #include <netinet/in.h> |
| #include <sys/socket.h> |
| #include <sys/types.h> |
| #include <sys/uio.h> |
| #include <iostream> |
| #include <string> |
| |
| #include <android/multinetwork.h> |
| #include <android-base/stringprintf.h> |
| #include "common.h" |
| |
| |
| |
| struct Parameters { |
| Parameters() : ss({}), port("80"), path("/") {} |
| |
| struct sockaddr_storage ss; |
| std::string host; |
| std::string hostname; |
| std::string port; |
| std::string path; |
| }; |
| |
| |
| bool parseUrl(const struct Arguments& args, struct Parameters* parameters) { |
| if (parameters == nullptr) { return false; } |
| |
| static const char HTTP_PREFIX[] = "http://"; |
| if (strncmp(args.arg1, HTTP_PREFIX, strlen(HTTP_PREFIX)) != 0) { |
| std::cerr << "Only " << HTTP_PREFIX << " URLs supported." << std::endl; |
| return false; |
| } |
| |
| parameters->host = std::string(args.arg1).substr(strlen(HTTP_PREFIX)); |
| const auto first_slash = parameters->host.find_first_of("/"); |
| if (first_slash != std::string::npos) { |
| parameters->path = parameters->host.substr(first_slash); |
| parameters->host.erase(first_slash); |
| } |
| |
| if (parameters->host.size() == 0) { |
| std::cerr << "Host portion cannot be empty." << std::endl; |
| return false; |
| } |
| |
| if (parameters->host[0] == '[') { |
| const auto closing_bracket = parameters->host.find_first_of("]"); |
| if (closing_bracket == std::string::npos) { |
| std::cerr << "Missing closing bracket." << std::endl; |
| return false; |
| } |
| parameters->hostname = parameters->host.substr(1, closing_bracket - 1); |
| |
| const auto colon_port = closing_bracket + 1; |
| if (colon_port < parameters->host.size()) { |
| if (parameters->host[colon_port] != ':') { |
| std::cerr << "Malformed port portion." << std::endl; |
| return false; |
| } |
| parameters->port = parameters->host.substr(closing_bracket + 2); |
| } |
| } else { |
| const auto first_colon = parameters->host.find_first_of(":"); |
| if (first_colon != std::string::npos) { |
| parameters->port = parameters->host.substr(first_colon + 1); |
| parameters->hostname = parameters->host.substr(0, first_colon); |
| } else { |
| parameters->hostname = parameters->host; |
| } |
| } |
| |
| // TODO: find the request portion to send (before '#...'). |
| |
| std::cerr << "Resolving hostname=" << parameters->hostname |
| << ", port=" << parameters->port |
| << std::endl; |
| |
| struct addrinfo hints = { |
| .ai_family = args.family, |
| .ai_socktype = SOCK_STREAM, |
| }; |
| struct addrinfo *result = nullptr; |
| |
| int rval = -1; |
| switch (args.api_mode) { |
| case ApiMode::EXPLICIT: |
| rval = android_getaddrinfofornetwork(args.nethandle, |
| parameters->hostname.c_str(), |
| parameters->port.c_str(), |
| &hints, &result); |
| break; |
| case ApiMode::PROCESS: |
| rval = getaddrinfo(parameters->hostname.c_str(), |
| parameters->port.c_str(), |
| &hints, &result); |
| break; |
| default: |
| // Unreachable. |
| std::cerr << "Unknown api mode." << std::endl; |
| return false; |
| } |
| |
| if (rval != 0) { |
| std::cerr << "DNS resolution failure; gaierror=" << rval |
| << " [" << gai_strerror(rval) << "]" |
| << std::endl; |
| return rval; |
| } |
| |
| memcpy(&(parameters->ss), result[0].ai_addr, result[0].ai_addrlen); |
| std::cerr << "Connecting to: " |
| << inetSockaddrToString(result[0].ai_addr) |
| << std::endl; |
| |
| freeaddrinfo(result); |
| return true; |
| } |
| |
| |
| int makeTcpSocket(sa_family_t address_family, net_handle_t nethandle) { |
| int fd = socket(address_family, SOCK_STREAM, IPPROTO_TCP); |
| if (fd < 0) { |
| std::cerr << "failed to create TCP socket" << std::endl; |
| return -1; |
| } |
| |
| // Don't let reads or writes block indefinitely. We cannot control |
| // connect() timeouts without nonblocking sockets and select/poll/epoll. |
| const struct timeval timeo = { 5, 0 }; // 5 seconds |
| setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo)); |
| setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo)); |
| |
| if (nethandle != NETWORK_UNSPECIFIED) { |
| if (android_setsocknetwork(nethandle, fd) != 0) { |
| int errnum = errno; |
| std::cerr << "android_setsocknetwork() failed;" |
| << " errno: " << errnum << " [" << strerror(errnum) << "]" |
| << std::endl; |
| close(fd); |
| return -1; |
| } |
| } |
| return fd; |
| } |
| |
| |
| int doHttpQuery(int fd, const struct Parameters& parameters) { |
| int rval = -1; |
| if (connect(fd, |
| reinterpret_cast<const struct sockaddr *>(&(parameters.ss)), |
| (parameters.ss.ss_family == AF_INET6) |
| ? sizeof(struct sockaddr_in6) |
| : sizeof(struct sockaddr_in)) != 0) { |
| int errnum = errno; |
| std::cerr << "Failed to connect; errno=" << errnum |
| << " [" << strerror(errnum) << "]" |
| << std::endl; |
| return -1; |
| } |
| |
| const std::string request(android::base::StringPrintf( |
| "GET %s HTTP/1.1\r\n" |
| "Host: %s\r\n" |
| "Accept: */*\r\n" |
| "Connection: close\r\n" |
| "User-Agent: httpurl/0.0\r\n" |
| "\r\n", |
| parameters.path.c_str(), parameters.host.c_str())); |
| const ssize_t sent = write(fd, request.c_str(), request.size()); |
| if (sent != static_cast<ssize_t>(request.size())) { |
| std::cerr << "Sent only " << sent << "/" << request.size() << " bytes" |
| << std::endl; |
| return -1; |
| } |
| |
| char buf[4*1024]; |
| do { |
| rval = recv(fd, buf, sizeof(buf), 0); |
| |
| if (rval < 0) { |
| const int saved_errno = errno; |
| std::cerr << "Failed to recv; errno=" << saved_errno |
| << " [" << strerror(saved_errno) << "]" |
| << std::endl; |
| } else if (rval > 0) { |
| std::cout.write(buf, rval); |
| std::cout.flush(); |
| } |
| } while (rval > 0); |
| std::cout << std::endl; |
| |
| return 0; |
| } |
| |
| |
| int main(int argc, const char* argv[]) { |
| int rval = -1; |
| |
| struct Arguments args; |
| if (!args.parseArguments(argc, argv)) { return rval; } |
| |
| if (args.api_mode == ApiMode::PROCESS) { |
| rval = android_setprocnetwork(args.nethandle); |
| if (rval != 0) { |
| int errnum = errno; |
| std::cerr << "android_setprocnetwork(" << args.nethandle << ") failed;" |
| << " errno: " << errnum << " [" << strerror(errnum) << "]" |
| << std::endl; |
| return rval; |
| } |
| } |
| |
| struct Parameters parameters; |
| if (!parseUrl(args, ¶meters)) { return -1; } |
| |
| // TODO: Fall back from IPv6 to IPv4 if ss.ss_family is AF_UNSPEC. |
| // This will involve changes to parseUrl() as well. |
| struct FdAutoCloser closer = makeTcpSocket( |
| parameters.ss.ss_family, |
| (args.api_mode == ApiMode::EXPLICIT) ? args.nethandle |
| : NETWORK_UNSPECIFIED); |
| if (closer.fd < 0) { return closer.fd; } |
| |
| return doHttpQuery(closer.fd, parameters); |
| } |
