Line data Source code
1 : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : // Copyright (c) 2009-2014 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 : /**
7 : * Utilities for converting data from/to strings.
8 : */
9 : #ifndef BITCOIN_UTILSTRENCODINGS_H
10 : #define BITCOIN_UTILSTRENCODINGS_H
11 :
12 : #include <stdint.h>
13 : #include <string>
14 : #include <vector>
15 :
16 : #define BEGIN(a) ((char*)&(a))
17 : #define END(a) ((char*)&((&(a))[1]))
18 : #define UBEGIN(a) ((unsigned char*)&(a))
19 : #define UEND(a) ((unsigned char*)&((&(a))[1]))
20 : #define ARRAYLEN(array) (sizeof(array)/sizeof((array)[0]))
21 :
22 : /** This is needed because the foreach macro can't get over the comma in pair<t1, t2> */
23 : #define PAIRTYPE(t1, t2) std::pair<t1, t2>
24 :
25 : /** Used by SanitizeString() */
26 : enum SafeChars
27 : {
28 : SAFE_CHARS_DEFAULT, //!< The full set of allowed chars
29 : SAFE_CHARS_UA_COMMENT //!< BIP-0014 subset
30 : };
31 :
32 : /**
33 : * Remove unsafe chars. Safe chars chosen to allow simple messages/URLs/email
34 : * addresses, but avoid anything even possibly remotely dangerous like & or >
35 : * @param[in] str The string to sanitize
36 : * @param[in] rule The set of safe chars to choose (default: least restrictive)
37 : * @return A new string without unsafe chars
38 : */
39 : std::string SanitizeString(const std::string& str, int rule = SAFE_CHARS_DEFAULT);
40 : std::vector<unsigned char> ParseHex(const char* psz);
41 : std::vector<unsigned char> ParseHex(const std::string& str);
42 : signed char HexDigit(char c);
43 : bool IsHex(const std::string& str);
44 : std::vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid = NULL);
45 : std::string DecodeBase64(const std::string& str);
46 : std::string EncodeBase64(const unsigned char* pch, size_t len);
47 : std::string EncodeBase64(const std::string& str);
48 : std::vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid = NULL);
49 : std::string DecodeBase32(const std::string& str);
50 : std::string EncodeBase32(const unsigned char* pch, size_t len);
51 : std::string EncodeBase32(const std::string& str);
52 :
53 : std::string i64tostr(int64_t n);
54 : std::string itostr(int n);
55 : int64_t atoi64(const char* psz);
56 : int64_t atoi64(const std::string& str);
57 : int atoi(const std::string& str);
58 :
59 : /**
60 : * Convert string to signed 32-bit integer with strict parse error feedback.
61 : * @returns true if the entire string could be parsed as valid integer,
62 : * false if not the entire string could be parsed or when overflow or underflow occurred.
63 : */
64 : bool ParseInt32(const std::string& str, int32_t *out);
65 :
66 : /**
67 : * Convert string to signed 64-bit integer with strict parse error feedback.
68 : * @returns true if the entire string could be parsed as valid integer,
69 : * false if not the entire string could be parsed or when overflow or underflow occurred.
70 : */
71 : bool ParseInt64(const std::string& str, int64_t *out);
72 :
73 : /**
74 : * Convert string to double with strict parse error feedback.
75 : * @returns true if the entire string could be parsed as valid double,
76 : * false if not the entire string could be parsed or when overflow or underflow occurred.
77 : */
78 : bool ParseDouble(const std::string& str, double *out);
79 :
80 : template<typename T>
81 1945 : std::string HexStr(const T itbegin, const T itend, bool fSpaces=false)
82 : {
83 : std::string rv;
84 : static const char hexmap[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
85 : '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
86 1945 : rv.reserve((itend-itbegin)*3);
87 111795 : for(T it = itbegin; it < itend; ++it)
88 : {
89 109868 : unsigned char val = (unsigned char)(*it);
90 109873 : if(fSpaces && it != itbegin)
91 8 : rv.push_back(' ');
92 109868 : rv.push_back(hexmap[val>>4]);
93 109868 : rv.push_back(hexmap[val&15]);
94 : }
95 :
96 1945 : return rv;
97 : }
98 :
99 : template<typename T>
100 15 : inline std::string HexStr(const T& vch, bool fSpaces=false)
101 : {
102 2994 : return HexStr(vch.begin(), vch.end(), fSpaces);
103 : }
104 :
105 : /**
106 : * Format a paragraph of text to a fixed width, adding spaces for
107 : * indentation to any added line.
108 : */
109 : std::string FormatParagraph(const std::string& in, size_t width = 79, size_t indent = 0);
110 :
111 : /**
112 : * Timing-attack-resistant comparison.
113 : * Takes time proportional to length
114 : * of first argument.
115 : */
116 : template <typename T>
117 3526 : bool TimingResistantEqual(const T& a, const T& b)
118 : {
119 3528 : if (b.size() == 0) return a.size() == 0;
120 3524 : size_t accumulator = a.size() ^ b.size();
121 21128 : for (size_t i = 0; i < a.size(); i++)
122 35208 : accumulator |= a[i] ^ b[i%b.size()];
123 3524 : return accumulator == 0;
124 : }
125 :
126 : /** Parse number as fixed point according to JSON number syntax.
127 : * See http://json.org/number.gif
128 : * @returns true on success, false on error.
129 : * @note The result must be in the range (-10^18,10^18), otherwise an overflow error will trigger.
130 : */
131 : bool ParseFixedPoint(const std::string &val, int decimals, int64_t *amount_out);
132 :
133 : #endif // BITCOIN_UTILSTRENCODINGS_H
|
