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