libxrpl/basics/StringUtilities.cpp

#include <xrpl/basics/StringUtilities.h>
 
#include <xrpl/basics/Blob.h>
#include <xrpl/beast/core/LexicalCast.h>
#include <xrpl/beast/net/IPEndpoint.h>
 
#include <boost/algorithm/hex.hpp>
#include <boost/regex/v5/regbase.hpp>
#include <boost/regex/v5/regex.hpp>
#include <boost/regex/v5/regex_match.hpp>
 
#include <algorithm>
#include <cstdint>
#include <iterator>
#include <optional>
#include <ranges>
#include <string>
#include <string_view>
 
namespace xrpl {
 
std::string
sqlBlobLiteral(Blob const& blob)
{
    std::string j;
 
    j.reserve((blob.size() * 2) + 3);
    j.push_back('X');
    j.push_back('\'');
    boost::algorithm::hex(blob.begin(), blob.end(), std::back_inserter(j));
    j.push_back('\'');
 
    return j;
}
 
bool
parseUrl(ParsedUrl& pUrl, std::string const& strUrl)
{
    // scheme://username:password@hostname:port/rest
    static boost::regex const kReUrl(
        "(?i)\\`\\s*"
        // required scheme
        "([[:alpha:]][-+.[:alpha:][:digit:]]*?):"
        // We choose to support only URIs whose `hier-part` has the form
        // `"//" authority path-abempty`.
        "//"
        // optional userinfo
        "(?:([^:@/]*?)(?::([^@/]*?))?@)?"
        // optional host
        "([[:digit:]:]*[[:digit:]]|\\[[^]]+\\]|[^:/?#]*?)"
        // optional port
        "(?::([[:digit:]]+))?"
        // optional path
        "(/.*)?"
        "\\s*?\\'");
    boost::smatch smMatch;
 
    // Bail if there is no match.
    try
    {
        if (!boost::regex_match(strUrl, smMatch, kReUrl))
            return false;
    }
    catch (...)
    {
        return false;
    }
 
    pUrl.scheme = smMatch[1];
    pUrl.scheme = toLower(pUrl.scheme);
    pUrl.username = smMatch[2];
    pUrl.password = smMatch[3];
    std::string const domain = smMatch[4];
    // We need to use Endpoint to parse the domain to
    // strip surrounding brackets from IPv6 addresses,
    // e.g. [::1] => ::1.
    auto const result = beast::ip::Endpoint::fromStringChecked(domain);
    pUrl.domain = result ? result->address().to_string() : domain;
    std::string const port = smMatch[5];
    if (!port.empty())
    {
        pUrl.port = beast::lexicalCast<std::uint16_t>(port);
 
        // For inputs larger than 2^32-1 (65535), lexicalCast returns 0.
        // parseUrl returns false for such inputs.
        if (pUrl.port == 0)
        {
            return false;
        }
    }
    pUrl.path = smMatch[6];
 
    return true;
}
 
namespace {
 
// Deliberately not std::isspace / std::tolower: those consult the current C
// locale, so the same input could trim or fold differently depending on
// process-wide state set by something else entirely. Everything these helpers
// are used on (config keys and values, URL schemes, hex digests) is ASCII, and
// the callers want a fixed answer, so spell the ASCII rules out.
 
constexpr bool
isAsciiSpace(char c)
{
    return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
}
 
constexpr char
toAsciiLower(char c)
{
    return (c >= 'A' && c <= 'Z') ? static_cast<char>(c - 'A' + 'a') : c;
}
 
}  // namespace
 
std::string
trimWhitespace(std::string str)
{
    auto const end = std::ranges::find_if_not(str | std::views::reverse, isAsciiSpace).base();
    str.erase(end, str.end());
    str.erase(str.begin(), std::ranges::find_if_not(str, isAsciiSpace));
 
    return str;
}
 
std::string
toLower(std::string str)
{
    std::ranges::transform(str, str.begin(), toAsciiLower);
    return str;
}
 
std::optional<std::uint64_t>
toUInt64(std::string const& s)
{
    std::uint64_t result = 0;
    if (beast::lexicalCastChecked(result, s))
        return result;
    return std::nullopt;
}
 
bool
isProperlyFormedTomlDomain(std::string_view domain)
{
    // The domain must be between 4 and 128 characters long
    if (domain.size() < 4 || domain.size() > 128)
        return false;
 
    // This regular expression should do a decent job of weeding out
    // obviously wrong domain names but it isn't perfect. It does not
    // really support IDNs. If this turns out to be an issue, a more
    // thorough regex can be used or this check can just be removed.
    static boost::regex const kRE(
        "^"                   // Beginning of line
        "("                   // Beginning of a segment
        "(?!-)"               //  - must not begin with '-'
        "[a-zA-Z0-9-]{1,63}"  //  - only alphanumeric and '-'
        "(?<!-)"              //  - must not end with '-'
        "\\."                 // segment separator
        ")+"                  // 1 or more segments
        "[A-Za-z]{2,63}"      // TLD
        "$"                   // End of line
        ,
        boost::regex_constants::optimize);
 
    return boost::regex_match(domain.begin(), domain.end(), kRE);
}
 
}  // namespace xrpl