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          20 : static bool ParsePrechecks(const std::string& str)
      22             : {
      23          20 :     if (str.empty()) // No empty string allowed
      24           0 :         return false;
      25          20 :     if (str.size() >= 1 && (json_isspace(str[0]) || json_isspace(str[str.size()-1]))) // No padding allowed
      26           0 :         return false;
      27          20 :     if (str.size() != strlen(str.c_str())) // No embedded NUL characters allowed
      28           0 :         return false;
      29          20 :     return true;
      30          20 : }
      31             : 
      32          20 : bool ParseDouble(const std::string& str, double *out)
      33             : {
      34          20 :     if (!ParsePrechecks(str))
      35           0 :         return false;
      36          20 :     if (str.size() >= 2 && str[0] == '0' && str[1] == 'x') // No hexadecimal floats allowed
      37           0 :         return false;
      38          20 :     std::istringstream text(str);
      39          20 :     text.imbue(std::locale::classic());
      40             :     double result;
      41          20 :     text >> result;
      42          20 :     if(out) *out = result;
      43          20 :     return text.eof() && !text.fail();
      44          20 : }
      45             : }
      46             : 
      47          20 : const std::vector<std::string>& UniValue::getKeys() const
      48             : {
      49          20 :     checkType(VOBJ);
      50          20 :     return keys;
      51             : }
      52             : 
      53          21 : const std::vector<UniValue>& UniValue::getValues() const
      54             : {
      55          21 :     if (typ != VOBJ && typ != VARR)
      56           1 :         throw std::runtime_error("JSON value is not an object or array as expected");
      57          20 :     return values;
      58           0 : }
      59             : 
      60         238 : bool UniValue::get_bool() const
      61             : {
      62         238 :     checkType(VBOOL);
      63         238 :     return isTrue();
      64             : }
      65             : 
      66       97187 : const std::string& UniValue::get_str() const
      67             : {
      68       97187 :     checkType(VSTR);
      69       97187 :     return getValStr();
      70             : }
      71             : 
      72          20 : double UniValue::get_real() const
      73             : {
      74          20 :     checkType(VNUM);
      75             :     double retval;
      76          20 :     if (!ParseDouble(getValStr(), &retval))
      77           0 :         throw std::runtime_error("JSON double out of range");
      78          20 :     return retval;
      79           0 : }
      80             : 
      81         155 : const UniValue& UniValue::get_obj() const
      82             : {
      83         155 :     checkType(VOBJ);
      84         155 :     return *this;
      85             : }
      86             : 
      87        1717 : const UniValue& UniValue::get_array() const
      88             : {
      89        1717 :     checkType(VARR);
      90        1717 :     return *this;
      91             : }