tests/netdb_test.cpp

/*
 * Copyright (C) 2013 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 <netdb.h>

#include <gtest/gtest.h>

#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/cdefs.h>
#include <sys/socket.h>
#include <sys/types.h>

// https://code.google.com/p/android/issues/detail?id=13228
TEST(netdb, freeaddrinfo_NULL) {
  freeaddrinfo(nullptr);
}

TEST(netdb, getaddrinfo_NULL_host) {
  // It's okay for the host argument to be NULL, as long as service isn't.
  addrinfo* ai = nullptr;
  ASSERT_EQ(0, getaddrinfo(nullptr, "smtp", nullptr, &ai));
  // (sockaddr_in::sin_port and sockaddr_in6::sin6_port overlap.)
  ASSERT_EQ(25U, ntohs(reinterpret_cast<sockaddr_in*>(ai->ai_addr)->sin_port));
  freeaddrinfo(ai);
}

TEST(netdb, getaddrinfo_NULL_service) {
  // It's okay for the service argument to be NULL, as long as host isn't.
  addrinfo* ai = nullptr;
  ASSERT_EQ(0, getaddrinfo("localhost", nullptr, nullptr, &ai));
  ASSERT_TRUE(ai != nullptr);
  freeaddrinfo(ai);
}

TEST(netdb, getaddrinfo_NULL_hints) {
  addrinfo* ai = nullptr;
  ASSERT_EQ(0, getaddrinfo("localhost", "9999", nullptr, &ai));

  bool saw_tcp = false;
  bool saw_udp = false;
  for (addrinfo* p = ai; p != nullptr; p = p->ai_next) {
    ASSERT_TRUE(p->ai_family == AF_INET || p->ai_family == AF_INET6);
    if (p->ai_socktype == SOCK_STREAM) {
      ASSERT_EQ(IPPROTO_TCP, p->ai_protocol);
      saw_tcp = true;
    } else if (p->ai_socktype == SOCK_DGRAM) {
      ASSERT_EQ(IPPROTO_UDP, p->ai_protocol);
      saw_udp = true;
    }
  }
  ASSERT_TRUE(saw_tcp);
  ASSERT_TRUE(saw_udp);

  freeaddrinfo(ai);
}

TEST(netdb, getaddrinfo_service_lookup) {
  addrinfo* ai = nullptr;
  ASSERT_EQ(0, getaddrinfo("localhost", "smtp", nullptr, &ai));
  ASSERT_EQ(SOCK_STREAM, ai->ai_socktype);
  ASSERT_EQ(IPPROTO_TCP, ai->ai_protocol);
  ASSERT_EQ(25, ntohs(reinterpret_cast<sockaddr_in*>(ai->ai_addr)->sin_port));
  freeaddrinfo(ai);
}

TEST(netdb, getaddrinfo_hints) {
  addrinfo hints = {.ai_family = AF_INET, .ai_socktype = SOCK_STREAM, .ai_protocol = IPPROTO_TCP};

  addrinfo* ai = nullptr;
  ASSERT_EQ(0, getaddrinfo( "localhost", "9999", &hints, &ai));
  ASSERT_TRUE(ai != nullptr);
  // In glibc, getaddrinfo() converts ::1 to 127.0.0.1 for localhost,
  // so one or two addrinfo may be returned.
  addrinfo* tai = ai;
  while (tai != nullptr) {
    ASSERT_EQ(AF_INET, tai->ai_family);
    ASSERT_EQ(SOCK_STREAM, tai->ai_socktype);
    ASSERT_EQ(IPPROTO_TCP, tai->ai_protocol);
    tai = tai->ai_next;
  }
  freeaddrinfo(ai);
}

TEST(netdb, getaddrinfo_ip6_localhost) {
  addrinfo* ai = nullptr;
  ASSERT_EQ(0, getaddrinfo("ip6-localhost", nullptr, nullptr, &ai));
  ASSERT_TRUE(ai != nullptr);
  ASSERT_GE(ai->ai_addrlen, static_cast<socklen_t>(sizeof(sockaddr_in6)));
  ASSERT_TRUE(ai->ai_addr != nullptr);
  sockaddr_in6 *addr = reinterpret_cast<sockaddr_in6*>(ai->ai_addr);
  ASSERT_EQ(addr->sin6_family, AF_INET6);
  ASSERT_EQ(0, memcmp(&addr->sin6_addr, &in6addr_loopback, sizeof(in6_addr)));
  freeaddrinfo(ai);
}

TEST(netdb, getnameinfo_salen) {
  sockaddr_storage ss = {};
  sockaddr* sa = reinterpret_cast<sockaddr*>(&ss);
  char tmp[16];

  ss.ss_family = AF_INET;
  socklen_t too_much = sizeof(ss);
  socklen_t just_right = sizeof(sockaddr_in);
  socklen_t too_little = sizeof(sockaddr_in) - 1;

  ASSERT_EQ(0, getnameinfo(sa, too_much, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
  ASSERT_STREQ("0.0.0.0", tmp);
  ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
  ASSERT_STREQ("0.0.0.0", tmp);
  ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));

  ss.ss_family = AF_INET6;
  just_right = sizeof(sockaddr_in6);
  too_little = sizeof(sockaddr_in6) - 1;
  too_much = just_right + 1;

  ASSERT_EQ(0, getnameinfo(sa, too_much, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
  ASSERT_STREQ("::", tmp);
  ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
  ASSERT_STREQ("::", tmp);
  ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
}

TEST(netdb, getnameinfo_localhost) {
  char host[NI_MAXHOST];
  sockaddr_in addr = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(0x7f000001)};
  ASSERT_EQ(0, getnameinfo(reinterpret_cast<sockaddr*>(&addr), sizeof(addr),
                           host, sizeof(host), nullptr, 0, 0));
  ASSERT_STREQ(host, "localhost");
}

static void VerifyLocalhostName(const char* name) {
  // Test possible localhost name and aliases, which depend on /etc/hosts or /system/etc/hosts.
  ASSERT_TRUE(strcmp(name, "localhost") == 0 ||
              strcmp(name, "ip6-localhost") == 0 ||
              strcmp(name, "ip6-loopback") == 0) << name;
}

TEST(netdb, getnameinfo_ip6_localhost) {
  char host[NI_MAXHOST];
  sockaddr_in6 addr = {.sin6_family = AF_INET6, .sin6_addr = in6addr_loopback};
  ASSERT_EQ(0, getnameinfo(reinterpret_cast<sockaddr*>(&addr), sizeof(addr),
                           host, sizeof(host), nullptr, 0, 0));
  VerifyLocalhostName(host);
}

static void VerifyLocalhost(hostent *hent) {
  ASSERT_TRUE(hent != nullptr);
  VerifyLocalhostName(hent->h_name);
  for (size_t i = 0; hent->h_aliases[i] != nullptr; ++i) {
    VerifyLocalhostName(hent->h_aliases[i]);
  }
  ASSERT_EQ(hent->h_addrtype, AF_INET);
  ASSERT_EQ(hent->h_addr[0], 127);
  ASSERT_EQ(hent->h_addr[1], 0);
  ASSERT_EQ(hent->h_addr[2], 0);
  ASSERT_EQ(hent->h_addr[3], 1);
}

TEST(netdb, gethostbyname) {
  hostent* hp = gethostbyname("localhost");
  VerifyLocalhost(hp);
}

TEST(netdb, gethostbyname2) {
  hostent* hp = gethostbyname2("localhost", AF_INET);
  VerifyLocalhost(hp);
}

TEST(netdb, gethostbyname_r) {
  hostent hent;
  hostent *hp;
  char buf[512];
  int err;
  int result = gethostbyname_r("localhost", &hent, buf, sizeof(buf), &hp, &err);
  ASSERT_EQ(0, result);
  VerifyLocalhost(hp);

  // Change hp->h_addr to test reentrancy.
  hp->h_addr[0] = 0;

  hostent hent2;
  hostent *hp2;
  char buf2[512];
  result = gethostbyname_r("localhost", &hent2, buf2, sizeof(buf2), &hp2, &err);
  ASSERT_EQ(0, result);
  VerifyLocalhost(hp2);

  ASSERT_EQ(0, hp->h_addr[0]);
}

TEST(netdb, gethostbyname2_r) {
  hostent hent;
  hostent *hp;
  char buf[512];
  int err;
  int result = gethostbyname2_r("localhost", AF_INET, &hent, buf, sizeof(buf), &hp, &err);
  ASSERT_EQ(0, result);
  VerifyLocalhost(hp);

  // Change hp->h_addr to test reentrancy.
  hp->h_addr[0] = 0;

  hostent hent2;
  hostent *hp2;
  char buf2[512];
  result = gethostbyname2_r("localhost", AF_INET, &hent2, buf2, sizeof(buf2), &hp2, &err);
  ASSERT_EQ(0, result);
  VerifyLocalhost(hp2);

  ASSERT_EQ(0, hp->h_addr[0]);
}

TEST(netdb, gethostbyaddr) {
  in_addr addr = { htonl(0x7f000001) };
  hostent *hp = gethostbyaddr(&addr, sizeof(addr), AF_INET);
  VerifyLocalhost(hp);
}

TEST(netdb, gethostbyaddr_r) {
  in_addr addr = { htonl(0x7f000001) };
  hostent hent;
  hostent *hp;
  char buf[512];
  int err;
  int result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent, buf, sizeof(buf), &hp, &err);
  ASSERT_EQ(0, result);
  VerifyLocalhost(hp);

  // Change hp->h_addr to test reentrancy.
  hp->h_addr[0] = 0;

  hostent hent2;
  hostent *hp2;
  char buf2[512];
  result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent2, buf2, sizeof(buf2), &hp2, &err);
  ASSERT_EQ(0, result);
  VerifyLocalhost(hp2);

  ASSERT_EQ(0, hp->h_addr[0]);
}

#if defined(ANDROID_HOST_MUSL)
// musl doesn't define NETDB_INTERNAL.  It also never sets *err to -1, but
// since gethostbyname_r is a glibc extension, the difference in behavior
// between musl and  glibc should probably be considered a bug in musl.
#define NETDB_INTERNAL -1
#endif

TEST(netdb, gethostbyname_r_ERANGE) {
  hostent hent;
  hostent *hp;
  char buf[4]; // Use too small buffer.
  int err = 0;
  int result = gethostbyname_r("localhost", &hent, buf, sizeof(buf), &hp, &err);
  EXPECT_EQ(NETDB_INTERNAL, err);
  EXPECT_EQ(ERANGE, result);
  EXPECT_EQ(nullptr, hp);
}

TEST(netdb, gethostbyname2_r_ERANGE) {
  hostent hent;
  hostent *hp;
  char buf[4]; // Use too small buffer.
  int err = 0;
  int result = gethostbyname2_r("localhost", AF_INET, &hent, buf, sizeof(buf), &hp, &err);
  EXPECT_EQ(NETDB_INTERNAL, err);
  EXPECT_EQ(ERANGE, result);
  EXPECT_EQ(nullptr, hp);
}

TEST(netdb, gethostbyaddr_r_ERANGE) {
  in_addr addr = { htonl(0x7f000001) };
  hostent hent;
  hostent *hp;
  char buf[4]; // Use too small buffer.
  int err = 0;
  int result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent, buf, sizeof(buf), &hp, &err);
  EXPECT_EQ(NETDB_INTERNAL, err);
  EXPECT_EQ(ERANGE, result);
  EXPECT_EQ(nullptr, hp);
}

TEST(netdb, gethostbyname_r_HOST_NOT_FOUND) {
  hostent hent;
  hostent *hp;
  char buf[BUFSIZ];
  int err;
  int result = gethostbyname_r("does.not.exist.google.com", &hent, buf, sizeof(buf), &hp, &err);
  EXPECT_EQ(HOST_NOT_FOUND, err);
  EXPECT_EQ(0, result);
  EXPECT_EQ(nullptr, hp);
}

TEST(netdb, gethostbyname2_r_HOST_NOT_FOUND) {
  hostent hent;
  hostent *hp;
  char buf[BUFSIZ];
  int err;
  int result = gethostbyname2_r("does.not.exist.google.com", AF_INET, &hent, buf, sizeof(buf), &hp, &err);
  EXPECT_EQ(HOST_NOT_FOUND, err);
  EXPECT_EQ(0, result);
  EXPECT_EQ(nullptr, hp);
}

TEST(netdb, gethostbyaddr_r_HOST_NOT_FOUND) {
  in_addr addr = { htonl(0xffffffff) };
  hostent hent;
  hostent *hp;
  char buf[BUFSIZ];
  int err;
  int result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent, buf, sizeof(buf), &hp, &err);
  EXPECT_EQ(HOST_NOT_FOUND, err);
  EXPECT_EQ(0, result);
  EXPECT_EQ(nullptr, hp);
}

TEST(netdb, getservbyname) {
  // smtp is TCP-only, so we know we'll get 25/tcp back.
  servent* s = getservbyname("smtp", nullptr);
  ASSERT_TRUE(s != nullptr);
  ASSERT_STREQ("smtp", s->s_name);
  ASSERT_EQ(25, ntohs(s->s_port));
  ASSERT_STREQ("tcp", s->s_proto);

  // We get the same result by explicitly asking for tcp.
  s = getservbyname("smtp", "tcp");
  ASSERT_TRUE(s != nullptr);
  ASSERT_STREQ("smtp", s->s_name);
  ASSERT_EQ(25, ntohs(s->s_port));
  ASSERT_STREQ("tcp", s->s_proto);

  // And we get a failure if we explicitly ask for udp.
  s = getservbyname("smtp", "udp");
  ASSERT_TRUE(s == nullptr);

  // But there are actually udp services.
  s = getservbyname("echo", "udp");
  ASSERT_TRUE(s != nullptr);
  ASSERT_STREQ("echo", s->s_name);
  ASSERT_EQ(7, ntohs(s->s_port));
  ASSERT_STREQ("udp", s->s_proto);
}

TEST(netdb, getservbyport) {
  // smtp is TCP-only, so we know we'll get 25/tcp back.
  servent* s = getservbyport(htons(25), nullptr);
  ASSERT_TRUE(s != nullptr);
  ASSERT_STREQ("smtp", s->s_name);
  ASSERT_EQ(25, ntohs(s->s_port));
  ASSERT_STREQ("tcp", s->s_proto);

  // We get the same result by explicitly asking for tcp.
  s = getservbyport(htons(25), "tcp");
  ASSERT_TRUE(s != nullptr);
  ASSERT_STREQ("smtp", s->s_name);
  ASSERT_EQ(25, ntohs(s->s_port));
  ASSERT_STREQ("tcp", s->s_proto);

  // And we get a failure if we explicitly ask for udp.
  s = getservbyport(htons(25), "udp");
  ASSERT_TRUE(s == nullptr);

  // But there are actually udp services.
  s = getservbyport(htons(7), "udp");
  ASSERT_TRUE(s != nullptr);
  ASSERT_STREQ("echo", s->s_name);
  ASSERT_EQ(7, ntohs(s->s_port));
  ASSERT_STREQ("udp", s->s_proto);
}

TEST(netdb, endnetent_getnetent_setnetent) {
  setnetent(0);
  setnetent(1);
  endnetent();
  while (getnetent() != nullptr) {
  }
}

TEST(netdb, getnetbyaddr) {
  getnetbyaddr(0, 0);
}

TEST(netdb, getnetbyname) {
  getnetbyname("x");
}

TEST(netdb, endprotoent_getprotoent_setprotoent) {
  setprotoent(0);
  setprotoent(1);
  endprotoent();
  while (getprotoent() != nullptr) {
  }
}

TEST(netdb, getprotobyname) {
  getprotobyname("tcp");
}

TEST(netdb, getprotobynumber) {
  getprotobynumber(6);
}

TEST(netdb, endservent_getservent_setservent) {
  setservent(0);
  setservent(1);
  endservent();
  size_t service_count = 0;
  while (getservent() != nullptr) {
    ++service_count;
  }
  ASSERT_GT(service_count, 0U);
}

TEST(netdb, getservbyname_getservent_conflicts) {
  // Calling getservbyname shouldn't affect getservent's iteration order.
  endservent();
  while (getservent() != nullptr) {
    ASSERT_TRUE(getservbyname("smtp", "tcp") != nullptr);
  }
}

TEST(netdb, getservbyport_getservent_conflicts) {
  // Calling getservbyport shouldn't affect getservent's iteration order.
  endservent();
  while (getservent() != nullptr) {
    ASSERT_TRUE(getservbyport(htons(25), "tcp") != nullptr);
  }
}

TEST(netdb, endservent_resets) {
  endservent();
  std::string first_service(getservent()->s_name);
  endservent();
  ASSERT_EQ(first_service, std::string(getservent()->s_name));
}

TEST(netdb, setservent_resets) {
  endservent();
  std::string first_service(getservent()->s_name);
  setservent(0);
  ASSERT_EQ(first_service, std::string(getservent()->s_name));
}

TEST(netdb, endhostent_gethostent_sethostent) {
  sethostent(0);
  sethostent(1);
  endhostent();
  size_t host_count = 0;
  while (gethostent() != nullptr) {
    ++host_count;
  }
  ASSERT_GT(host_count, 0U);
}

TEST(netdb, endhostent_resets) {
  endhostent();
  std::string first_host(gethostent()->h_name);
  endhostent();
  ASSERT_EQ(first_host, std::string(gethostent()->h_name));
}

TEST(netdb, sethostent_resets) {
  endhostent();
  std::string first_host(gethostent()->h_name);
  sethostent(0);
  ASSERT_EQ(first_host, std::string(gethostent()->h_name));
}