blob: 15b23fca1bbc596b91f108d0098fe3951c247272 [file] [log] [blame]
/*
* Copyright 2015 Google Inc. All rights reserved.
*
* 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 <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
/* Request a simple URL from all the known gstatic.com IP/IPv6 addresses. */
#define HOSTNAME "gstatic.com"
#define PORT "80"
#define TIMEOUT_MS 3000
#define HTTP_REQUEST \
"GET /generate_204 HTTP/1.0\r\n" \
"User-Agent: gfiber-cpe-gstatic\r\n" \
"\r\n"
#define BUFLEN 128
#define MAX_ADDRS 128
void perror_die(const char *msg)
{
perror(msg);
exit(1);
}
void socket_set_blocking(int fd, bool blocking)
{
int flags;
int rc;
flags = fcntl(fd, F_GETFL, 0);
if (blocking)
flags &= ~O_NONBLOCK;
else
flags |= O_NONBLOCK;
rc = fcntl(fd, F_SETFL, flags);
if (rc < 0)
perror_die("fcntl");
}
struct timespec timespec_diff(struct timespec *start, struct timespec *end)
{
struct timespec diff;
if (end->tv_nsec > start->tv_nsec) {
diff.tv_sec = end->tv_sec - start->tv_sec - 1;
diff.tv_nsec = 1000000000 + end->tv_nsec - start->tv_nsec;
} else {
diff.tv_sec = end->tv_sec - start->tv_sec;
diff.tv_nsec = end->tv_nsec - start->tv_nsec;
}
return diff;
}
ssize_t xwrite(int fd, const char *buf, size_t count)
{
size_t total;
ssize_t rc;
total = 0;
while (total < count) {
rc = write(fd, buf + total, count - total);
if (rc < 0)
perror_die("write");
else if (rc == 0)
return total;
else
total += rc;
}
return total;
}
const char *inet_ntop46(const struct addrinfo *addr, char *buf, size_t size)
{
switch (addr->ai_family) {
case AF_INET:
inet_ntop(AF_INET, &(((struct sockaddr_in *)(addr->ai_addr))->sin_addr),
buf, size);
break;
case AF_INET6:
inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)(addr->ai_addr))->sin6_addr),
buf, size);
break;
default:
assert(!"Unknown Address Family");
}
return buf;
}
int connect_timeout(int fd, struct addrinfo *addr, int timeout_ms)
{
struct timeval timeout;
fd_set writeset;
socklen_t len;
int error;
int rc;
socket_set_blocking(fd, false);
rc = connect(fd, addr->ai_addr, addr->ai_addrlen);
if (rc < 0 && errno != EINPROGRESS)
perror_die("connect");
if (rc != 0) {
FD_ZERO(&writeset);
FD_SET(fd, &writeset);
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = (timeout_ms % 1000) * 1000;
rc = select(fd + 1, NULL, &writeset, NULL, &timeout);
if (rc < 0) {
perror_die("select");
} else if (rc == 0) {
/* timeout */
return -1;
}
len = sizeof(error);
rc = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len);
if (rc < 0)
perror_die("getsockopt");
else if (error != 0)
return -1;
}
socket_set_blocking(fd, true);
return fd;
}
ssize_t read_timeout(int fd, void *buf, size_t count, int timeout_ms)
{
fd_set readset, exceptset;
struct timeval timeout;
int rc;
FD_ZERO(&readset);
FD_SET(fd, &readset);
exceptset = readset;
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = (timeout_ms % 1000) * 1000;
rc = select(fd + 1, &readset, NULL, &exceptset, &timeout);
if (rc < 0) {
perror_die("select");
} else if (rc == 0) {
/* timeout */
return 0;
}
if (FD_ISSET(fd, &exceptset))
return 0;
return read(fd, buf, count);
}
int do_http_request(int fd, struct addrinfo *addr)
{
char http_response[BUFLEN];
char ip[BUFLEN];
struct timespec start, end;
struct timespec diff;
float elapsed_ms;
int rc;
inet_ntop46(addr, ip, sizeof(ip));
clock_gettime(CLOCK_MONOTONIC, &start);
rc = connect_timeout(fd, addr, TIMEOUT_MS);
if (rc < 0)
goto err;
rc = xwrite(fd, HTTP_REQUEST, sizeof(HTTP_REQUEST));
if (rc < (ssize_t)sizeof(HTTP_REQUEST))
perror_die("write");
rc = read_timeout(fd, http_response, sizeof(http_response), TIMEOUT_MS);
if (rc < 0)
goto err;
clock_gettime(CLOCK_MONOTONIC, &end);
diff = timespec_diff(&start, &end);
elapsed_ms = (diff.tv_sec * 1000) + (diff.tv_nsec / 1000000.0f);
printf("%s %.1fms\n", ip, elapsed_ms);
return 0;
err:
printf("%s ERR\n", ip);
return 1;
}
int main(int argc, const char **argv)
{
struct addrinfo *res, *result;
struct addrinfo hints;
int bad;
int rc;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
rc = getaddrinfo(HOSTNAME, PORT, &hints, &result);
if (rc) {
if (rc == EAI_SYSTEM)
fprintf(stderr, "%s: DNS-ERR (%s)\n", HOSTNAME, strerror(errno));
else
fprintf(stderr, "%s: DNS-ERR (%s)\n", HOSTNAME, gai_strerror(rc));
exit(1);
}
bad = 0;
for (res = result; res != NULL; res = res->ai_next) {
int fd;
fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (fd < 0)
perror_die("socket");
rc = do_http_request(fd, res);
if (rc != 0)
bad = 1;
close(fd);
}
freeaddrinfo(result);
return bad;
}