uri.cpp

/*
* (C) 2019 Nuno Goncalves <nunojpg@gmail.com>
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/internal/uri.h>
#include <botan/exceptn.h>

#include <regex>

#if defined(BOTAN_TARGET_OS_HAS_SOCKETS)
   #include <arpa/inet.h>
   #include <sys/socket.h>
   #include <netinet/in.h>
#elif defined(BOTAN_TARGET_OS_HAS_WINSOCK2)
   #include <ws2tcpip.h>
#endif

#if defined(BOTAN_TARGET_OS_HAS_SOCKETS) || defined(BOTAN_TARGET_OS_HAS_WINSOCK2)

namespace {

constexpr bool isdigit(char ch)
   {
   return ch >= '0' && ch <= '9';
   }

bool isDomain(const std::string& domain)
   {
#if defined(__GLIBCXX__) && (__GLIBCXX__ < 20160726)
   // GCC 4.8 does not support regex
   BOTAN_UNUSED(domain);
   return true;
#else
   std::regex re(
      R"(^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$)");
   std::cmatch m;
   return std::regex_match(domain.c_str(), m, re);
#endif
   }

bool isIPv4(const std::string& ip)
   {
   sockaddr_storage inaddr;
   return !!inet_pton(AF_INET, ip.c_str(), &inaddr);
   }

bool isIPv6(const std::string& ip)
   {
   sockaddr_storage in6addr;
   return !!inet_pton(AF_INET6, ip.c_str(), &in6addr);
   }
}

namespace Botan {

URI URI::fromDomain(const std::string& uri)
   {
   unsigned port = 0;
   const auto port_pos = uri.find(':');
   if(port_pos != std::string::npos)
      {
      for(char c : uri.substr(port_pos+1))
         {
         if(!isdigit(c))
            { throw Invalid_Argument("invalid"); }
         port = port*10 + c - '0';
         if(port > 65535)
            { throw Invalid_Argument("invalid"); }
         }
      }
   const auto domain = uri.substr(0, port_pos);
   if(isIPv4(domain))
      { throw Invalid_Argument("invalid"); }
   if(!isDomain(domain))
      { throw Invalid_Argument("invalid"); }
   return {Type::Domain, domain, uint16_t(port)};
   }

URI URI::fromIPv4(const std::string& uri)
   {
   unsigned port = 0;
   const auto port_pos = uri.find(':');
   if(port_pos != std::string::npos)
      {
      for(char c : uri.substr(port_pos+1))
         {
         if(!isdigit(c))
            { throw Invalid_Argument("invalid"); }
         port = port*10 + c - '0';
         if(port > 65535)
            { throw Invalid_Argument("invalid"); }
         }
      }
   const auto ip = uri.substr(0, port_pos);
   if(!isIPv4(ip))
      { throw Invalid_Argument("invalid"); }
   return { Type::IPv4, ip, uint16_t(port) };
   }

URI URI::fromIPv6(const std::string& uri)
   {
   unsigned port = 0;
   const auto port_pos = uri.find(']');
   const bool with_braces = (port_pos != std::string::npos);
   if((uri[0]=='[') != with_braces)
      { throw Invalid_Argument("invalid"); }

   if(with_braces && (uri.size() > port_pos + 1))
      {
      if(uri[port_pos+1]!=':')
         { throw Invalid_Argument("invalid"); }
      for(char c : uri.substr(port_pos+2))
         {
         if(!isdigit(c))
            { throw Invalid_Argument("invalid"); }
         port = port*10 + c - '0';
         if(port > 65535)
            { throw Invalid_Argument("invalid"); }
         }
      }
   const auto ip = uri.substr((with_braces ? 1 : 0), port_pos - with_braces);
   if(!isIPv6(ip))
      { throw Invalid_Argument("invalid"); }
   return { Type::IPv6, ip, uint16_t(port) };
   }

URI URI::fromAny(const std::string& uri)
   {

   bool colon_seen=false;
   bool non_number=false;
   if(uri[0]=='[')
      { return fromIPv6(uri); }
   for(auto c : uri)
      {
      if(c == ':')
         {
         if(colon_seen) //seen two ':'
            { return fromIPv6(uri); }
         colon_seen = true;
         }
      else if(!isdigit(c) && c !=  '.')
         {
         non_number=true;
         }
      }
   if(!non_number)
      {
      if(isIPv4(uri.substr(0, uri.find(':'))))
         {
         return fromIPv4(uri);
         }
      }
   return fromDomain(uri);
   }

std::string URI::to_string() const
   {
   if(type == Type::NotSet)
      {
      throw Invalid_Argument("not set");
      }

   if(port != 0)
      {
      if(type == Type::IPv6)
         { return "[" + host + "]:" + std::to_string(port); }
      return host + ":" + std::to_string(port);
      }
   return host;
   }

}

#else

namespace Botan {

URI URI::fromDomain(const std::string&) {throw Not_Implemented("No socket support enabled in build");}
URI URI::fromIPv4(const std::string&) {throw Not_Implemented("No socket support enabled in build");}
URI URI::fromIPv6(const std::string&) {throw Not_Implemented("No socket support enabled in build");}
URI URI::fromAny(const std::string&) {throw Not_Implemented("No socket support enabled in build");}

}

#endif