1/*
2 * Copyright (C) 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
17
18#include <errno.h>
19#include <fcntl.h>
20#include <netdb.h>
21#include <netinet/in.h>
22#include <sys/socket.h>
23#include <sys/types.h>
24#include <sys/uio.h>
25#include <iostream>
26#include <string>
27
28#include <android/multinetwork.h>
29#include <android-base/stringprintf.h>
30#include "common.h"
31
32
33
34struct Parameters {
35    Parameters() : ss({}), port("80"), path("/") {}
36
37    struct sockaddr_storage ss;
38    std::string host;
39    std::string hostname;
40    std::string port;
41    std::string path;
42};
43
44
45bool parseUrl(const struct Arguments& args, struct Parameters* parameters) {
46    if (parameters == nullptr) { return false; }
47
48    static const char HTTP_PREFIX[] = "http://";
49    if (strncmp(args.arg1, HTTP_PREFIX, strlen(HTTP_PREFIX)) != 0) {
50        std::cerr << "Only " << HTTP_PREFIX << " URLs supported." << std::endl;
51        return false;
52    }
53
54    parameters->host = std::string(args.arg1).substr(strlen(HTTP_PREFIX));
55    const auto first_slash = parameters->host.find_first_of("/");
56    if (first_slash != std::string::npos) {
57        parameters->path = parameters->host.substr(first_slash);
58        parameters->host.erase(first_slash);
59    }
60
61    if (parameters->host.size() == 0) {
62        std::cerr << "Host portion cannot be empty." << std::endl;
63        return false;
64    }
65
66    if (parameters->host[0] == '[') {
67        const auto closing_bracket = parameters->host.find_first_of("]");
68        if (closing_bracket == std::string::npos) {
69            std::cerr << "Missing closing bracket." << std::endl;
70            return false;
71        }
72        parameters->hostname = parameters->host.substr(1, closing_bracket - 1);
73
74        const auto colon_port = closing_bracket + 1;
75        if (colon_port < parameters->host.size()) {
76            if (parameters->host[colon_port] != ':') {
77                std::cerr << "Malformed port portion." << std::endl;
78                return false;
79            }
80            parameters->port = parameters->host.substr(closing_bracket + 2);
81        }
82    } else {
83        const auto first_colon = parameters->host.find_first_of(":");
84        if (first_colon != std::string::npos) {
85            parameters->port = parameters->host.substr(first_colon + 1);
86            parameters->hostname = parameters->host.substr(0, first_colon);
87        } else {
88            parameters->hostname = parameters->host;
89        }
90    }
91
92    // TODO: find the request portion to send (before '#...').
93
94    std::cerr << "Resolving hostname=" << parameters->hostname
95              << ", port=" << parameters->port
96              << std::endl;
97
98    struct addrinfo hints = {
99            .ai_family = args.family,
100            .ai_socktype = SOCK_STREAM,
101    };
102    struct addrinfo *result = nullptr;
103
104    int rval = -1;
105    switch (args.api_mode) {
106        case ApiMode::EXPLICIT:
107            rval = android_getaddrinfofornetwork(args.nethandle,
108                                                 parameters->hostname.c_str(),
109                                                 parameters->port.c_str(),
110                                                 &hints, &result);
111            break;
112        case ApiMode::PROCESS:
113            rval = getaddrinfo(parameters->hostname.c_str(),
114                               parameters->port.c_str(),
115                               &hints, &result);
116            break;
117        default:
118            // Unreachable.
119            std::cerr << "Unknown api mode." << std::endl;
120            return false;
121    }
122
123    if (rval != 0) {
124        std::cerr << "DNS resolution failure; gaierror=" << rval
125                  << " [" << gai_strerror(rval) << "]"
126                  << std::endl;
127        return rval;
128    }
129
130    memcpy(&(parameters->ss), result[0].ai_addr, result[0].ai_addrlen);
131    std::cerr << "Connecting to: "
132              << inetSockaddrToString(result[0].ai_addr)
133              << std::endl;
134
135    freeaddrinfo(result);
136    return true;
137}
138
139
140int makeTcpSocket(sa_family_t address_family, net_handle_t nethandle) {
141    int fd = socket(address_family, SOCK_STREAM, IPPROTO_TCP);
142    if (fd < 0) {
143        std::cerr << "failed to create TCP socket" << std::endl;
144        return -1;
145    }
146
147    // Don't let reads or writes block indefinitely. We cannot control
148    // connect() timeouts without nonblocking sockets and select/poll/epoll.
149    const struct timeval timeo = { 5, 0 };  // 5 seconds
150    setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
151    setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo));
152
153    if (nethandle != NETWORK_UNSPECIFIED) {
154        if (android_setsocknetwork(nethandle, fd) != 0) {
155            int errnum = errno;
156            std::cerr << "android_setsocknetwork() failed;"
157                      << " errno: " << errnum << " [" << strerror(errnum) << "]"
158                      << std::endl;
159            close(fd);
160            return -1;
161        }
162    }
163    return fd;
164}
165
166
167int doHttpQuery(int fd, const struct Parameters& parameters) {
168    int rval = -1;
169    if (connect(fd,
170                reinterpret_cast<const struct sockaddr *>(&(parameters.ss)),
171                (parameters.ss.ss_family == AF_INET6)
172                        ? sizeof(struct sockaddr_in6)
173                        : sizeof(struct sockaddr_in)) != 0) {
174        int errnum = errno;
175        std::cerr << "Failed to connect; errno=" << errnum
176                  << " [" << strerror(errnum) << "]"
177                  << std::endl;
178        return -1;
179    }
180
181    const std::string request(android::base::StringPrintf(
182            "GET %s HTTP/1.1\r\n"
183            "Host: %s\r\n"
184            "Accept: */*\r\n"
185            "Connection: close\r\n"
186            "User-Agent: httpurl/0.0\r\n"
187            "\r\n",
188            parameters.path.c_str(), parameters.host.c_str()));
189    const ssize_t sent = write(fd, request.c_str(), request.size());
190    if (sent != static_cast<ssize_t>(request.size())) {
191        std::cerr << "Sent only " << sent << "/" << request.size() << " bytes"
192                  << std::endl;
193        return -1;
194    }
195
196    char buf[4*1024];
197    do {
198        rval = recv(fd, buf, sizeof(buf), 0);
199
200        if (rval < 0) {
201            const int saved_errno = errno;
202            std::cerr << "Failed to recv; errno=" << saved_errno
203                      << " [" << strerror(saved_errno) << "]"
204                      << std::endl;
205        } else if (rval > 0) {
206            std::cout.write(buf, rval);
207            std::cout.flush();
208        }
209    } while (rval > 0);
210    std::cout << std::endl;
211
212    return 0;
213}
214
215
216int main(int argc, const char* argv[]) {
217    int rval = -1;
218
219    struct Arguments args;
220    if (!args.parseArguments(argc, argv)) { return rval; }
221
222    if (args.api_mode == ApiMode::PROCESS) {
223        rval = android_setprocnetwork(args.nethandle);
224        if (rval != 0) {
225            int errnum = errno;
226            std::cerr << "android_setprocnetwork(" << args.nethandle << ") failed;"
227                      << " errno: " << errnum << " [" << strerror(errnum) << "]"
228                      << std::endl;
229            return rval;
230        }
231    }
232
233    struct Parameters parameters;
234    if (!parseUrl(args, &parameters)) { return -1; }
235
236    // TODO: Fall back from IPv6 to IPv4 if ss.ss_family is AF_UNSPEC.
237    // This will involve changes to parseUrl() as well.
238    struct FdAutoCloser closer = makeTcpSocket(
239            parameters.ss.ss_family,
240            (args.api_mode == ApiMode::EXPLICIT) ? args.nethandle
241                                                 : NETWORK_UNSPECIFIED);
242    if (closer.fd < 0) { return closer.fd; }
243
244    return doHttpQuery(closer.fd, parameters);
245}
246