LCOV - code coverage report
Current view: top level - src/util - strencodings.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 61 304 20.1 %
Date: 2023-11-06 23:13:05 Functions: 7 40 17.5 %
Branches: 36 389 9.3 %

           Branch data     Line data    Source code
       1                 :            : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :            : // Copyright (c) 2009-2022 The Bitcoin Core developers
       3                 :            : // Distributed under the MIT software license, see the accompanying
       4                 :            : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :            : 
       6                 :            : #include <span.h>
       7                 :            : #include <util/strencodings.h>
       8                 :            : 
       9                 :            : #include <array>
      10                 :            : #include <cassert>
      11                 :            : #include <cstring>
      12                 :            : #include <limits>
      13                 :            : #include <optional>
      14                 :            : #include <ostream>
      15                 :            : #include <string>
      16                 :            : #include <vector>
      17                 :            : 
      18         [ +  - ]:          2 : static const std::string CHARS_ALPHA_NUM = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
      19                 :            : 
      20                 :          0 : static const std::string SAFE_CHARS[] =
      21                 :          2 : {
      22         [ +  - ]:          2 :     CHARS_ALPHA_NUM + " .,;-_/:?@()", // SAFE_CHARS_DEFAULT
      23         [ +  - ]:          2 :     CHARS_ALPHA_NUM + " .,;-_?@", // SAFE_CHARS_UA_COMMENT
      24         [ +  - ]:          2 :     CHARS_ALPHA_NUM + ".-_", // SAFE_CHARS_FILENAME
      25         [ +  - ]:          2 :     CHARS_ALPHA_NUM + "!*'();:@&=+$,/?#[]-_.~%", // SAFE_CHARS_URI
      26                 :            : };
      27                 :            : 
      28                 :         15 : std::string SanitizeString(std::string_view str, int rule)
      29                 :            : {
      30                 :         15 :     std::string result;
      31         [ +  - ]:         15 :     for (char c : str) {
      32         [ #  # ]:          0 :         if (SAFE_CHARS[rule].find(c) != std::string::npos) {
      33         [ #  # ]:          0 :             result.push_back(c);
      34                 :          0 :         }
      35                 :            :     }
      36                 :         15 :     return result;
      37         [ +  - ]:         15 : }
      38                 :            : 
      39                 :            : const signed char p_util_hexdigit[256] =
      40                 :            : { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      41                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      42                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      43                 :            :   0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,
      44                 :            :   -1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      45                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      46                 :            :   -1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      47                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      48                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      49                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      50                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      51                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      52                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      53                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      54                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
      55                 :            :   -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, };
      56                 :            : 
      57                 :       7758 : signed char HexDigit(char c)
      58                 :            : {
      59                 :       7758 :     return p_util_hexdigit[(unsigned char)c];
      60                 :            : }
      61                 :            : 
      62                 :          0 : bool IsHex(std::string_view str)
      63                 :            : {
      64         [ #  # ]:          0 :     for (char c : str) {
      65         [ #  # ]:          0 :         if (HexDigit(c) < 0) return false;
      66                 :            :     }
      67         [ #  # ]:          0 :     return (str.size() > 0) && (str.size()%2 == 0);
      68                 :          0 : }
      69                 :            : 
      70                 :          0 : bool IsHexNumber(std::string_view str)
      71                 :            : {
      72         [ #  # ]:          0 :     if (str.substr(0, 2) == "0x") str.remove_prefix(2);
      73         [ #  # ]:          0 :     for (char c : str) {
      74         [ #  # ]:          0 :         if (HexDigit(c) < 0) return false;
      75                 :            :     }
      76                 :            :     // Return false for empty string or "0x".
      77                 :          0 :     return str.size() > 0;
      78                 :          0 : }
      79                 :            : 
      80                 :            : template <typename Byte>
      81                 :          6 : std::optional<std::vector<Byte>> TryParseHex(std::string_view str)
      82                 :            : {
      83                 :          6 :     std::vector<Byte> vch;
      84                 :          6 :     auto it = str.begin();
      85 [ #  # ][ +  + ]:        402 :     while (it != str.end()) {
      86 [ #  # ][ -  + ]:        396 :         if (IsSpace(*it)) {
      87                 :          0 :             ++it;
      88                 :          0 :             continue;
      89                 :            :         }
      90                 :        396 :         auto c1 = HexDigit(*(it++));
      91 [ #  # ][ +  - ]:        396 :         if (it == str.end()) return std::nullopt;
      92                 :        396 :         auto c2 = HexDigit(*(it++));
      93 [ #  # ][ #  # ]:        396 :         if (c1 < 0 || c2 < 0) return std::nullopt;
         [ +  - ][ -  + ]
      94 [ #  # ][ +  - ]:        396 :         vch.push_back(Byte(c1 << 4) | Byte(c2));
      95                 :            :     }
      96                 :          6 :     return vch;
      97                 :          6 : }
      98                 :            : template std::optional<std::vector<std::byte>> TryParseHex(std::string_view);
      99                 :            : template std::optional<std::vector<uint8_t>> TryParseHex(std::string_view);
     100                 :            : 
     101                 :        144 : bool SplitHostPort(std::string_view in, uint16_t& portOut, std::string& hostOut)
     102                 :            : {
     103                 :        144 :     bool valid = false;
     104                 :        144 :     size_t colon = in.find_last_of(':');
     105                 :            :     // if a : is found, and it either follows a [...], or no other : is in the string, treat it as port separator
     106                 :        144 :     bool fHaveColon = colon != in.npos;
     107 [ -  + ][ +  - ]:        288 :     bool fBracketed = fHaveColon && (in[0] == '[' && in[colon - 1] == ']'); // if there is a colon, and in[0]=='[', colon is not 0, so in[colon-1] is safe
     108 [ +  - ][ -  + ]:        144 :     bool fMultiColon{fHaveColon && colon != 0 && (in.find_last_of(':', colon - 1) != in.npos)};
     109 [ +  - ][ +  - ]:        144 :     if (fHaveColon && (colon == 0 || fBracketed || !fMultiColon)) {
         [ +  - ][ -  + ]
     110                 :            :         uint16_t n;
     111         [ -  + ]:        144 :         if (ParseUInt16(in.substr(colon + 1), &n)) {
     112                 :        144 :             in = in.substr(0, colon);
     113                 :        144 :             portOut = n;
     114                 :        144 :             valid = (portOut != 0);
     115                 :        144 :         }
     116                 :        144 :     } else {
     117                 :          0 :         valid = true;
     118                 :            :     }
     119 [ +  - ][ -  + ]:        144 :     if (in.size() > 0 && in[0] == '[' && in[in.size() - 1] == ']') {
                 [ #  # ]
     120                 :          0 :         hostOut = in.substr(1, in.size() - 2);
     121                 :          0 :     } else {
     122                 :        144 :         hostOut = in;
     123                 :            :     }
     124                 :            : 
     125                 :        144 :     return valid;
     126                 :            : }
     127                 :            : 
     128                 :          0 : std::string EncodeBase64(Span<const unsigned char> input)
     129                 :            : {
     130                 :            :     static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     131                 :            : 
     132                 :          0 :     std::string str;
     133         [ #  # ]:          0 :     str.reserve(((input.size() + 2) / 3) * 4);
     134         [ #  # ]:          0 :     ConvertBits<8, 6, true>([&](int v) { str += pbase64[v]; }, input.begin(), input.end());
     135 [ #  # ][ #  # ]:          0 :     while (str.size() % 4) str += '=';
     136                 :          0 :     return str;
     137         [ #  # ]:          0 : }
     138                 :            : 
     139                 :          0 : std::optional<std::vector<unsigned char>> DecodeBase64(std::string_view str)
     140                 :            : {
     141                 :            :     static const int8_t decode64_table[256]{
     142                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     143                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     144                 :            :         -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
     145                 :            :         -1, -1, -1, -1, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
     146                 :            :         15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
     147                 :            :         29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
     148                 :            :         49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     149                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     150                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     151                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     152                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     153                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     154                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
     155                 :            :     };
     156                 :            : 
     157         [ #  # ]:          0 :     if (str.size() % 4 != 0) return {};
     158                 :            :     /* One or two = characters at the end are permitted. */
     159 [ #  # ][ #  # ]:          0 :     if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
     160 [ #  # ][ #  # ]:          0 :     if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
     161                 :            : 
     162                 :          0 :     std::vector<unsigned char> ret;
     163         [ #  # ]:          0 :     ret.reserve((str.size() * 3) / 4);
     164         [ #  # ]:          0 :     bool valid = ConvertBits<6, 8, false>(
     165                 :          0 :         [&](unsigned char c) { ret.push_back(c); },
     166                 :          0 :         str.begin(), str.end(),
     167                 :          0 :         [](char c) { return decode64_table[uint8_t(c)]; }
     168                 :            :     );
     169         [ #  # ]:          0 :     if (!valid) return {};
     170                 :            : 
     171                 :          0 :     return ret;
     172                 :          0 : }
     173                 :            : 
     174                 :          0 : std::string EncodeBase32(Span<const unsigned char> input, bool pad)
     175                 :            : {
     176                 :            :     static const char *pbase32 = "abcdefghijklmnopqrstuvwxyz234567";
     177                 :            : 
     178                 :          0 :     std::string str;
     179         [ #  # ]:          0 :     str.reserve(((input.size() + 4) / 5) * 8);
     180         [ #  # ]:          0 :     ConvertBits<8, 5, true>([&](int v) { str += pbase32[v]; }, input.begin(), input.end());
     181         [ #  # ]:          0 :     if (pad) {
     182         [ #  # ]:          0 :         while (str.size() % 8) {
     183         [ #  # ]:          0 :             str += '=';
     184                 :            :         }
     185                 :          0 :     }
     186                 :          0 :     return str;
     187         [ #  # ]:          0 : }
     188                 :            : 
     189                 :          0 : std::string EncodeBase32(std::string_view str, bool pad)
     190                 :            : {
     191                 :          0 :     return EncodeBase32(MakeUCharSpan(str), pad);
     192                 :            : }
     193                 :            : 
     194                 :          0 : std::optional<std::vector<unsigned char>> DecodeBase32(std::string_view str)
     195                 :            : {
     196                 :            :     static const int8_t decode32_table[256]{
     197                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     198                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     199                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, -1, -1, -1, -1,
     200                 :            :         -1, -1, -1, -1, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
     201                 :            :         15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1,  0,  1,  2,
     202                 :            :          3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
     203                 :            :         23, 24, 25, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     204                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     205                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     206                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     207                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     208                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     209                 :            :         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
     210                 :            :     };
     211                 :            : 
     212         [ #  # ]:          0 :     if (str.size() % 8 != 0) return {};
     213                 :            :     /* 1, 3, 4, or 6 padding '=' suffix characters are permitted. */
     214 [ #  # ][ #  # ]:          0 :     if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
     215 [ #  # ][ #  # ]:          0 :     if (str.size() >= 2 && str.substr(str.size() - 2) == "==") str.remove_suffix(2);
     216 [ #  # ][ #  # ]:          0 :     if (str.size() >= 1 && str.back() == '=') str.remove_suffix(1);
     217 [ #  # ][ #  # ]:          0 :     if (str.size() >= 2 && str.substr(str.size() - 2) == "==") str.remove_suffix(2);
     218                 :            : 
     219                 :          0 :     std::vector<unsigned char> ret;
     220         [ #  # ]:          0 :     ret.reserve((str.size() * 5) / 8);
     221         [ #  # ]:          0 :     bool valid = ConvertBits<5, 8, false>(
     222                 :          0 :         [&](unsigned char c) { ret.push_back(c); },
     223                 :          0 :         str.begin(), str.end(),
     224                 :          0 :         [](char c) { return decode32_table[uint8_t(c)]; }
     225                 :            :     );
     226                 :            : 
     227         [ #  # ]:          0 :     if (!valid) return {};
     228                 :            : 
     229                 :          0 :     return ret;
     230                 :          0 : }
     231                 :            : 
     232                 :            : namespace {
     233                 :            : template <typename T>
     234                 :        144 : bool ParseIntegral(std::string_view str, T* out)
     235                 :            : {
     236                 :            :     static_assert(std::is_integral<T>::value);
     237                 :            :     // Replicate the exact behavior of strtol/strtoll/strtoul/strtoull when
     238                 :            :     // handling leading +/- for backwards compatibility.
     239 [ #  # ][ #  # ]:        144 :     if (str.length() >= 2 && str[0] == '+' && str[1] == '-') {
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ +  - ]
         [ -  + ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     240                 :          0 :         return false;
     241                 :            :     }
     242 [ #  # ][ #  # ]:        144 :     const std::optional<T> opt_int = ToIntegral<T>((!str.empty() && str[0] == '+') ? str.substr(1) : str);
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
         [ +  - ][ +  - ]
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     243 [ #  # ][ #  # ]:        144 :     if (!opt_int) {
         [ #  # ][ +  - ]
         [ #  # ][ #  # ]
     244                 :          0 :         return false;
     245                 :            :     }
     246 [ #  # ][ #  # ]:        144 :     if (out != nullptr) {
         [ #  # ][ +  - ]
         [ #  # ][ #  # ]
     247                 :        144 :         *out = *opt_int;
     248                 :        144 :     }
     249                 :        144 :     return true;
     250                 :        144 : }
     251                 :            : }; // namespace
     252                 :            : 
     253                 :          0 : bool ParseInt32(std::string_view str, int32_t* out)
     254                 :            : {
     255                 :          0 :     return ParseIntegral<int32_t>(str, out);
     256                 :            : }
     257                 :            : 
     258                 :          0 : bool ParseInt64(std::string_view str, int64_t* out)
     259                 :            : {
     260                 :          0 :     return ParseIntegral<int64_t>(str, out);
     261                 :            : }
     262                 :            : 
     263                 :          0 : bool ParseUInt8(std::string_view str, uint8_t* out)
     264                 :            : {
     265                 :          0 :     return ParseIntegral<uint8_t>(str, out);
     266                 :            : }
     267                 :            : 
     268                 :        144 : bool ParseUInt16(std::string_view str, uint16_t* out)
     269                 :            : {
     270                 :        144 :     return ParseIntegral<uint16_t>(str, out);
     271                 :            : }
     272                 :            : 
     273                 :          0 : bool ParseUInt32(std::string_view str, uint32_t* out)
     274                 :            : {
     275                 :          0 :     return ParseIntegral<uint32_t>(str, out);
     276                 :            : }
     277                 :            : 
     278                 :          0 : bool ParseUInt64(std::string_view str, uint64_t* out)
     279                 :            : {
     280                 :          0 :     return ParseIntegral<uint64_t>(str, out);
     281                 :            : }
     282                 :            : 
     283                 :          0 : std::string FormatParagraph(std::string_view in, size_t width, size_t indent)
     284                 :            : {
     285         [ #  # ]:          0 :     assert(width >= indent);
     286                 :          0 :     std::stringstream out;
     287                 :          0 :     size_t ptr = 0;
     288                 :          0 :     size_t indented = 0;
     289         [ #  # ]:          0 :     while (ptr < in.size())
     290                 :            :     {
     291                 :          0 :         size_t lineend = in.find_first_of('\n', ptr);
     292         [ #  # ]:          0 :         if (lineend == std::string::npos) {
     293                 :          0 :             lineend = in.size();
     294                 :          0 :         }
     295                 :          0 :         const size_t linelen = lineend - ptr;
     296                 :          0 :         const size_t rem_width = width - indented;
     297         [ #  # ]:          0 :         if (linelen <= rem_width) {
     298 [ #  # ][ #  # ]:          0 :             out << in.substr(ptr, linelen + 1);
     299                 :          0 :             ptr = lineend + 1;
     300                 :          0 :             indented = 0;
     301                 :          0 :         } else {
     302                 :          0 :             size_t finalspace = in.find_last_of(" \n", ptr + rem_width);
     303 [ #  # ][ #  # ]:          0 :             if (finalspace == std::string::npos || finalspace < ptr) {
     304                 :            :                 // No place to break; just include the entire word and move on
     305                 :          0 :                 finalspace = in.find_first_of("\n ", ptr);
     306         [ #  # ]:          0 :                 if (finalspace == std::string::npos) {
     307                 :            :                     // End of the string, just add it and break
     308 [ #  # ][ #  # ]:          0 :                     out << in.substr(ptr);
     309                 :          0 :                     break;
     310                 :            :                 }
     311                 :          0 :             }
     312 [ #  # ][ #  # ]:          0 :             out << in.substr(ptr, finalspace - ptr) << "\n";
                 [ #  # ]
     313         [ #  # ]:          0 :             if (in[finalspace] == '\n') {
     314                 :          0 :                 indented = 0;
     315         [ #  # ]:          0 :             } else if (indent) {
     316 [ #  # ][ #  # ]:          0 :                 out << std::string(indent, ' ');
     317                 :          0 :                 indented = indent;
     318                 :          0 :             }
     319                 :          0 :             ptr = finalspace + 1;
     320                 :            :         }
     321                 :            :     }
     322         [ #  # ]:          0 :     return out.str();
     323                 :          0 : }
     324                 :            : 
     325                 :            : /** Upper bound for mantissa.
     326                 :            :  * 10^18-1 is the largest arbitrary decimal that will fit in a signed 64-bit integer.
     327                 :            :  * Larger integers cannot consist of arbitrary combinations of 0-9:
     328                 :            :  *
     329                 :            :  *   999999999999999999  1^18-1
     330                 :            :  *  9223372036854775807  (1<<63)-1  (max int64_t)
     331                 :            :  *  9999999999999999999  1^19-1     (would overflow)
     332                 :            :  */
     333                 :            : static const int64_t UPPER_BOUND = 1000000000000000000LL - 1LL;
     334                 :            : 
     335                 :            : /** Helper function for ParseFixedPoint */
     336                 :          0 : static inline bool ProcessMantissaDigit(char ch, int64_t &mantissa, int &mantissa_tzeros)
     337                 :            : {
     338         [ #  # ]:          0 :     if(ch == '0')
     339                 :          0 :         ++mantissa_tzeros;
     340                 :            :     else {
     341         [ #  # ]:          0 :         for (int i=0; i<=mantissa_tzeros; ++i) {
     342         [ #  # ]:          0 :             if (mantissa > (UPPER_BOUND / 10LL))
     343                 :          0 :                 return false; /* overflow */
     344                 :          0 :             mantissa *= 10;
     345                 :          0 :         }
     346                 :          0 :         mantissa += ch - '0';
     347                 :          0 :         mantissa_tzeros = 0;
     348                 :            :     }
     349                 :          0 :     return true;
     350                 :          0 : }
     351                 :            : 
     352                 :          0 : bool ParseFixedPoint(std::string_view val, int decimals, int64_t *amount_out)
     353                 :            : {
     354                 :          0 :     int64_t mantissa = 0;
     355                 :          0 :     int64_t exponent = 0;
     356                 :          0 :     int mantissa_tzeros = 0;
     357                 :          0 :     bool mantissa_sign = false;
     358                 :          0 :     bool exponent_sign = false;
     359                 :          0 :     int ptr = 0;
     360                 :          0 :     int end = val.size();
     361                 :          0 :     int point_ofs = 0;
     362                 :            : 
     363 [ #  # ][ #  # ]:          0 :     if (ptr < end && val[ptr] == '-') {
     364                 :          0 :         mantissa_sign = true;
     365                 :          0 :         ++ptr;
     366                 :          0 :     }
     367         [ #  # ]:          0 :     if (ptr < end)
     368                 :            :     {
     369         [ #  # ]:          0 :         if (val[ptr] == '0') {
     370                 :            :             /* pass single 0 */
     371                 :          0 :             ++ptr;
     372 [ #  # ][ #  # ]:          0 :         } else if (val[ptr] >= '1' && val[ptr] <= '9') {
     373 [ #  # ][ #  # ]:          0 :             while (ptr < end && IsDigit(val[ptr])) {
     374         [ #  # ]:          0 :                 if (!ProcessMantissaDigit(val[ptr], mantissa, mantissa_tzeros))
     375                 :          0 :                     return false; /* overflow */
     376                 :          0 :                 ++ptr;
     377                 :            :             }
     378                 :          0 :         } else return false; /* missing expected digit */
     379                 :          0 :     } else return false; /* empty string or loose '-' */
     380 [ #  # ][ #  # ]:          0 :     if (ptr < end && val[ptr] == '.')
     381                 :            :     {
     382                 :          0 :         ++ptr;
     383 [ #  # ][ #  # ]:          0 :         if (ptr < end && IsDigit(val[ptr]))
     384                 :            :         {
     385 [ #  # ][ #  # ]:          0 :             while (ptr < end && IsDigit(val[ptr])) {
     386         [ #  # ]:          0 :                 if (!ProcessMantissaDigit(val[ptr], mantissa, mantissa_tzeros))
     387                 :          0 :                     return false; /* overflow */
     388                 :          0 :                 ++ptr;
     389                 :          0 :                 ++point_ofs;
     390                 :            :             }
     391                 :          0 :         } else return false; /* missing expected digit */
     392                 :          0 :     }
     393 [ #  # ][ #  # ]:          0 :     if (ptr < end && (val[ptr] == 'e' || val[ptr] == 'E'))
                 [ #  # ]
     394                 :            :     {
     395                 :          0 :         ++ptr;
     396 [ #  # ][ #  # ]:          0 :         if (ptr < end && val[ptr] == '+')
     397                 :          0 :             ++ptr;
     398 [ #  # ][ #  # ]:          0 :         else if (ptr < end && val[ptr] == '-') {
     399                 :          0 :             exponent_sign = true;
     400                 :          0 :             ++ptr;
     401                 :          0 :         }
     402 [ #  # ][ #  # ]:          0 :         if (ptr < end && IsDigit(val[ptr])) {
     403 [ #  # ][ #  # ]:          0 :             while (ptr < end && IsDigit(val[ptr])) {
     404         [ #  # ]:          0 :                 if (exponent > (UPPER_BOUND / 10LL))
     405                 :          0 :                     return false; /* overflow */
     406                 :          0 :                 exponent = exponent * 10 + val[ptr] - '0';
     407                 :          0 :                 ++ptr;
     408                 :            :             }
     409                 :          0 :         } else return false; /* missing expected digit */
     410                 :          0 :     }
     411         [ #  # ]:          0 :     if (ptr != end)
     412                 :          0 :         return false; /* trailing garbage */
     413                 :            : 
     414                 :            :     /* finalize exponent */
     415         [ #  # ]:          0 :     if (exponent_sign)
     416                 :          0 :         exponent = -exponent;
     417                 :          0 :     exponent = exponent - point_ofs + mantissa_tzeros;
     418                 :            : 
     419                 :            :     /* finalize mantissa */
     420         [ #  # ]:          0 :     if (mantissa_sign)
     421                 :          0 :         mantissa = -mantissa;
     422                 :            : 
     423                 :            :     /* convert to one 64-bit fixed-point value */
     424                 :          0 :     exponent += decimals;
     425         [ #  # ]:          0 :     if (exponent < 0)
     426                 :          0 :         return false; /* cannot represent values smaller than 10^-decimals */
     427         [ #  # ]:          0 :     if (exponent >= 18)
     428                 :          0 :         return false; /* cannot represent values larger than or equal to 10^(18-decimals) */
     429                 :            : 
     430         [ #  # ]:          0 :     for (int i=0; i < exponent; ++i) {
     431 [ #  # ][ #  # ]:          0 :         if (mantissa > (UPPER_BOUND / 10LL) || mantissa < -(UPPER_BOUND / 10LL))
     432                 :          0 :             return false; /* overflow */
     433                 :          0 :         mantissa *= 10;
     434                 :          0 :     }
     435 [ #  # ][ #  # ]:          0 :     if (mantissa > UPPER_BOUND || mantissa < -UPPER_BOUND)
     436                 :          0 :         return false; /* overflow */
     437                 :            : 
     438         [ #  # ]:          0 :     if (amount_out)
     439                 :          0 :         *amount_out = mantissa;
     440                 :            : 
     441                 :          0 :     return true;
     442                 :          0 : }
     443                 :            : 
     444                 :          0 : std::string ToLower(std::string_view str)
     445                 :            : {
     446                 :          0 :     std::string r;
     447 [ #  # ][ #  # ]:          0 :     for (auto ch : str) r += ToLower(ch);
                 [ #  # ]
     448                 :          0 :     return r;
     449         [ #  # ]:          0 : }
     450                 :            : 
     451                 :          0 : std::string ToUpper(std::string_view str)
     452                 :            : {
     453                 :          0 :     std::string r;
     454 [ #  # ][ #  # ]:          0 :     for (auto ch : str) r += ToUpper(ch);
                 [ #  # ]
     455                 :          0 :     return r;
     456         [ #  # ]:          0 : }
     457                 :            : 
     458                 :          0 : std::string Capitalize(std::string str)
     459                 :            : {
     460         [ #  # ]:          0 :     if (str.empty()) return str;
     461                 :          0 :     str[0] = ToUpper(str.front());
     462                 :          0 :     return str;
     463                 :          0 : }
     464                 :            : 
     465                 :            : namespace {
     466                 :            : 
     467                 :            : using ByteAsHex = std::array<char, 2>;
     468                 :            : 
     469                 :            : constexpr std::array<ByteAsHex, 256> CreateByteToHexMap()
     470                 :            : {
     471                 :            :     constexpr char hexmap[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
     472                 :            : 
     473                 :            :     std::array<ByteAsHex, 256> byte_to_hex{};
     474                 :            :     for (size_t i = 0; i < byte_to_hex.size(); ++i) {
     475                 :            :         byte_to_hex[i][0] = hexmap[i >> 4];
     476                 :            :         byte_to_hex[i][1] = hexmap[i & 15];
     477                 :            :     }
     478                 :            :     return byte_to_hex;
     479                 :            : }
     480                 :            : 
     481                 :            : } // namespace
     482                 :            : 
     483                 :        414 : std::string HexStr(const Span<const uint8_t> s)
     484                 :            : {
     485         [ +  - ]:        414 :     std::string rv(s.size() * 2, '\0');
     486                 :            :     static constexpr auto byte_to_hex = CreateByteToHexMap();
     487                 :            :     static_assert(sizeof(byte_to_hex) == 512);
     488                 :            : 
     489                 :        414 :     char* it = rv.data();
     490         [ +  + ]:      13566 :     for (uint8_t v : s) {
     491                 :      13152 :         std::memcpy(it, byte_to_hex[v].data(), 2);
     492                 :      13152 :         it += 2;
     493                 :            :     }
     494                 :            : 
     495         [ -  + ]:        414 :     assert(it == rv.data() + rv.size());
     496                 :        414 :     return rv;
     497         [ +  - ]:        414 : }
     498                 :            : 
     499                 :          0 : std::optional<uint64_t> ParseByteUnits(std::string_view str, ByteUnit default_multiplier)
     500                 :            : {
     501         [ #  # ]:          0 :     if (str.empty()) {
     502                 :          0 :         return std::nullopt;
     503                 :            :     }
     504                 :          0 :     auto multiplier = default_multiplier;
     505                 :          0 :     char unit = str.back();
     506   [ #  #  #  #  :          0 :     switch (unit) {
             #  #  #  #  
                      # ]
     507                 :            :     case 'k':
     508                 :          0 :         multiplier = ByteUnit::k;
     509                 :          0 :         break;
     510                 :            :     case 'K':
     511                 :          0 :         multiplier = ByteUnit::K;
     512                 :          0 :         break;
     513                 :            :     case 'm':
     514                 :          0 :         multiplier = ByteUnit::m;
     515                 :          0 :         break;
     516                 :            :     case 'M':
     517                 :          0 :         multiplier = ByteUnit::M;
     518                 :          0 :         break;
     519                 :            :     case 'g':
     520                 :          0 :         multiplier = ByteUnit::g;
     521                 :          0 :         break;
     522                 :            :     case 'G':
     523                 :          0 :         multiplier = ByteUnit::G;
     524                 :          0 :         break;
     525                 :            :     case 't':
     526                 :          0 :         multiplier = ByteUnit::t;
     527                 :          0 :         break;
     528                 :            :     case 'T':
     529                 :          0 :         multiplier = ByteUnit::T;
     530                 :          0 :         break;
     531                 :            :     default:
     532                 :          0 :         unit = 0;
     533                 :          0 :         break;
     534                 :            :     }
     535                 :            : 
     536                 :          0 :     uint64_t unit_amount = static_cast<uint64_t>(multiplier);
     537         [ #  # ]:          0 :     auto parsed_num = ToIntegral<uint64_t>(unit ? str.substr(0, str.size() - 1) : str);
     538 [ #  # ][ #  # ]:          0 :     if (!parsed_num || parsed_num > std::numeric_limits<uint64_t>::max() / unit_amount) { // check overflow
     539                 :          0 :         return std::nullopt;
     540                 :            :     }
     541                 :          0 :     return *parsed_num * unit_amount;
     542                 :          0 : }

Generated by: LCOV version 1.14