Branch data     Line data    Source code

       1                 :             : // Copyright 2014 BitPay Inc.
       2                 :             : // Copyright 2015 Bitcoin Core Developers
       3                 :             : // Distributed under the MIT software license, see the accompanying
       4                 :             : // file COPYING or https://opensource.org/licenses/mit-license.php.
       5                 :             : 
       6                 :             : #include <univalue.h>
       7                 :             : 
       8                 :             : #include <cerrno>
       9                 :             : #include <cstdint>
      10                 :             : #include <cstdlib>
      11                 :             : #include <cstring>
      12                 :             : #include <limits>
      13                 :             : #include <locale>
      14                 :             : #include <sstream>
      15                 :             : #include <stdexcept>
      16                 :             : #include <string>
      17                 :             : #include <vector>
      18                 :             : 
      19                 :             : namespace
      20                 :             : {
      21                 :          36 : static bool ParsePrechecks(const std::string& str)
      22                 :             : {
      23         [ +  - ]:          36 :     if (str.empty()) // No empty string allowed
      24                 :             :         return false;
      25   [ +  -  +  - ]:          36 :     if (str.size() >= 1 && (json_isspace(str[0]) || json_isspace(str[str.size()-1]))) // No padding allowed
      26                 :             :         return false;
      27         [ -  + ]:          36 :     if (str.size() != strlen(str.c_str())) // No embedded NUL characters allowed
      28                 :           0 :         return false;
      29                 :             :     return true;
      30                 :             : }
      31                 :             : 
      32                 :          36 : bool ParseDouble(const std::string& str, double *out)
      33                 :             : {
      34         [ +  - ]:          36 :     if (!ParsePrechecks(str))
      35                 :             :         return false;
      36   [ +  +  +  +  :          36 :     if (str.size() >= 2 && str[0] == '0' && str[1] == 'x') // No hexadecimal floats allowed
                   +  - ]
      37                 :             :         return false;
      38                 :          36 :     std::istringstream text(str);
      39   [ +  -  +  - ]:          36 :     text.imbue(std::locale::classic());
      40                 :          36 :     double result;
      41         [ +  - ]:          36 :     text >> result;
      42         [ +  - ]:          36 :     if(out) *out = result;
      43   [ +  -  +  + ]:          36 :     return text.eof() && !text.fail();
      44                 :          36 : }
      45                 :             : }
      46                 :             : 
      47                 :        3162 : const std::vector<std::string>& UniValue::getKeys() const
      48                 :             : {
      49                 :        3162 :     checkType(VOBJ);
      50                 :        3162 :     return keys;
      51                 :             : }
      52                 :             : 
      53                 :        3812 : const std::vector<UniValue>& UniValue::getValues() const
      54                 :             : {
      55         [ +  + ]:        3812 :     if (typ != VOBJ && typ != VARR)
      56         [ +  - ]:          63 :         throw std::runtime_error("JSON value is not an object or array as expected");
      57                 :        3749 :     return values;
      58                 :             : }
      59                 :             : 
      60                 :         162 : bool UniValue::get_bool() const
      61                 :             : {
      62                 :         162 :     checkType(VBOOL);
      63                 :         162 :     return isTrue();
      64                 :             : }
      65                 :             : 
      66                 :      112928 : const std::string& UniValue::get_str() const
      67                 :             : {
      68                 :      112928 :     checkType(VSTR);
      69                 :      108190 :     return getValStr();
      70                 :             : }
      71                 :             : 
      72                 :          36 : double UniValue::get_real() const
      73                 :             : {
      74                 :          36 :     checkType(VNUM);
      75                 :          36 :     double retval;
      76         [ +  + ]:          36 :     if (!ParseDouble(getValStr(), &retval))
      77         [ +  - ]:           2 :         throw std::runtime_error("JSON double out of range");
      78                 :          34 :     return retval;
      79                 :             : }
      80                 :             : 
      81                 :          18 : const UniValue& UniValue::get_obj() const
      82                 :             : {
      83                 :          18 :     checkType(VOBJ);
      84                 :           1 :     return *this;
      85                 :             : }
      86                 :             : 
      87                 :        1959 : const UniValue& UniValue::get_array() const
      88                 :             : {
      89                 :        1959 :     checkType(VARR);
      90                 :        1958 :     return *this;
      91                 :             : }