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.
7 #include "primitives/block.h"
8 #include "primitives/transaction.h"
10 #include "httpserver.h"
11 #include "rpcserver.h"
14 #include "txmempool.h"
15 #include "utilstrencodings.h"
18 #include <boost/algorithm/string.hpp>
19 #include <boost/dynamic_bitset.hpp>
25 static const size_t MAX_GETUTXOS_OUTPOINTS
= 15; //allow a max of 15 outpoints to be queried at once
45 uint32_t nTxVer
; // Don't call this nVersion, that name has a special meaning inside IMPLEMENT_SERIALIZE
49 ADD_SERIALIZE_METHODS
;
51 template <typename Stream
, typename Operation
>
52 inline void SerializationOp(Stream
& s
, Operation ser_action
, int nType
, int nVersion
)
60 extern void TxToJSON(const CTransaction
& tx
, const uint256 hashBlock
, UniValue
& entry
);
61 extern UniValue
blockToJSON(const CBlock
& block
, const CBlockIndex
* blockindex
, bool txDetails
= false);
62 extern UniValue
mempoolInfoToJSON();
63 extern UniValue
mempoolToJSON(bool fVerbose
= false);
64 extern void ScriptPubKeyToJSON(const CScript
& scriptPubKey
, UniValue
& out
, bool fIncludeHex
);
65 extern UniValue
blockheaderToJSON(const CBlockIndex
* blockindex
);
67 static bool RESTERR(HTTPRequest
* req
, enum HTTPStatusCode status
, string message
)
69 req
->WriteHeader("Content-Type", "text/plain");
70 req
->WriteReply(status
, message
+ "\r\n");
74 static enum RetFormat
ParseDataFormat(std::string
& param
, const std::string
& strReq
)
76 const std::string::size_type pos
= strReq
.rfind('.');
77 if (pos
== std::string::npos
)
80 return rf_names
[0].rf
;
83 param
= strReq
.substr(0, pos
);
84 const std::string
suff(strReq
, pos
+ 1);
86 for (unsigned int i
= 0; i
< ARRAYLEN(rf_names
); i
++)
87 if (suff
== rf_names
[i
].name
)
88 return rf_names
[i
].rf
;
90 /* If no suffix is found, return original string. */
92 return rf_names
[0].rf
;
95 static string
AvailableDataFormatsString()
98 for (unsigned int i
= 0; i
< ARRAYLEN(rf_names
); i
++)
99 if (strlen(rf_names
[i
].name
) > 0) {
101 formats
.append(rf_names
[i
].name
);
102 formats
.append(", ");
105 if (formats
.length() > 0)
106 return formats
.substr(0, formats
.length() - 2);
111 static bool ParseHashStr(const string
& strReq
, uint256
& v
)
113 if (!IsHex(strReq
) || (strReq
.size() != 64))
120 static bool CheckWarmup(HTTPRequest
* req
)
122 std::string statusmessage
;
123 if (RPCIsInWarmup(&statusmessage
))
124 return RESTERR(req
, HTTP_SERVICE_UNAVAILABLE
, "Service temporarily unavailable: " + statusmessage
);
128 static bool rest_headers(HTTPRequest
* req
,
129 const std::string
& strURIPart
)
131 if (!CheckWarmup(req
))
134 const RetFormat rf
= ParseDataFormat(param
, strURIPart
);
136 boost::split(path
, param
, boost::is_any_of("/"));
138 if (path
.size() != 2)
139 return RESTERR(req
, HTTP_BAD_REQUEST
, "No header count specified. Use /rest/headers/<count>/<hash>.<ext>.");
141 long count
= strtol(path
[0].c_str(), NULL
, 10);
142 if (count
< 1 || count
> 2000)
143 return RESTERR(req
, HTTP_BAD_REQUEST
, "Header count out of range: " + path
[0]);
145 string hashStr
= path
[1];
147 if (!ParseHashStr(hashStr
, hash
))
148 return RESTERR(req
, HTTP_BAD_REQUEST
, "Invalid hash: " + hashStr
);
150 std::vector
<const CBlockIndex
*> headers
;
151 headers
.reserve(count
);
154 BlockMap::const_iterator it
= mapBlockIndex
.find(hash
);
155 const CBlockIndex
*pindex
= (it
!= mapBlockIndex
.end()) ? it
->second
: NULL
;
156 while (pindex
!= NULL
&& chainActive
.Contains(pindex
)) {
157 headers
.push_back(pindex
);
158 if (headers
.size() == (unsigned long)count
)
160 pindex
= chainActive
.Next(pindex
);
164 CDataStream
ssHeader(SER_NETWORK
, PROTOCOL_VERSION
);
165 BOOST_FOREACH(const CBlockIndex
*pindex
, headers
) {
166 ssHeader
<< pindex
->GetBlockHeader();
171 string binaryHeader
= ssHeader
.str();
172 req
->WriteHeader("Content-Type", "application/octet-stream");
173 req
->WriteReply(HTTP_OK
, binaryHeader
);
178 string strHex
= HexStr(ssHeader
.begin(), ssHeader
.end()) + "\n";
179 req
->WriteHeader("Content-Type", "text/plain");
180 req
->WriteReply(HTTP_OK
, strHex
);
184 UniValue
jsonHeaders(UniValue::VARR
);
185 BOOST_FOREACH(const CBlockIndex
*pindex
, headers
) {
186 jsonHeaders
.push_back(blockheaderToJSON(pindex
));
188 string strJSON
= jsonHeaders
.write() + "\n";
189 req
->WriteHeader("Content-Type", "application/json");
190 req
->WriteReply(HTTP_OK
, strJSON
);
194 return RESTERR(req
, HTTP_NOT_FOUND
, "output format not found (available: .bin, .hex)");
199 return true; // continue to process further HTTP reqs on this cxn
202 static bool rest_block(HTTPRequest
* req
,
203 const std::string
& strURIPart
,
206 if (!CheckWarmup(req
))
209 const RetFormat rf
= ParseDataFormat(hashStr
, strURIPart
);
212 if (!ParseHashStr(hashStr
, hash
))
213 return RESTERR(req
, HTTP_BAD_REQUEST
, "Invalid hash: " + hashStr
);
216 CBlockIndex
* pblockindex
= NULL
;
219 if (mapBlockIndex
.count(hash
) == 0)
220 return RESTERR(req
, HTTP_NOT_FOUND
, hashStr
+ " not found");
222 pblockindex
= mapBlockIndex
[hash
];
223 if (fHavePruned
&& !(pblockindex
->nStatus
& BLOCK_HAVE_DATA
) && pblockindex
->nTx
> 0)
224 return RESTERR(req
, HTTP_NOT_FOUND
, hashStr
+ " not available (pruned data)");
226 if (!ReadBlockFromDisk(block
, pblockindex
))
227 return RESTERR(req
, HTTP_NOT_FOUND
, hashStr
+ " not found");
230 CDataStream
ssBlock(SER_NETWORK
, PROTOCOL_VERSION
);
235 string binaryBlock
= ssBlock
.str();
236 req
->WriteHeader("Content-Type", "application/octet-stream");
237 req
->WriteReply(HTTP_OK
, binaryBlock
);
242 string strHex
= HexStr(ssBlock
.begin(), ssBlock
.end()) + "\n";
243 req
->WriteHeader("Content-Type", "text/plain");
244 req
->WriteReply(HTTP_OK
, strHex
);
249 UniValue objBlock
= blockToJSON(block
, pblockindex
, showTxDetails
);
250 string strJSON
= objBlock
.write() + "\n";
251 req
->WriteHeader("Content-Type", "application/json");
252 req
->WriteReply(HTTP_OK
, strJSON
);
257 return RESTERR(req
, HTTP_NOT_FOUND
, "output format not found (available: " + AvailableDataFormatsString() + ")");
262 return true; // continue to process further HTTP reqs on this cxn
265 static bool rest_block_extended(HTTPRequest
* req
, const std::string
& strURIPart
)
267 return rest_block(req
, strURIPart
, true);
270 static bool rest_block_notxdetails(HTTPRequest
* req
, const std::string
& strURIPart
)
272 return rest_block(req
, strURIPart
, false);
275 static bool rest_chaininfo(HTTPRequest
* req
, const std::string
& strURIPart
)
277 if (!CheckWarmup(req
))
280 const RetFormat rf
= ParseDataFormat(param
, strURIPart
);
284 UniValue
rpcParams(UniValue::VARR
);
285 UniValue chainInfoObject
= getblockchaininfo(rpcParams
, false);
286 string strJSON
= chainInfoObject
.write() + "\n";
287 req
->WriteHeader("Content-Type", "application/json");
288 req
->WriteReply(HTTP_OK
, strJSON
);
292 return RESTERR(req
, HTTP_NOT_FOUND
, "output format not found (available: json)");
297 return true; // continue to process further HTTP reqs on this cxn
300 static bool rest_mempool_info(HTTPRequest
* req
, const std::string
& strURIPart
)
302 if (!CheckWarmup(req
))
305 const RetFormat rf
= ParseDataFormat(param
, strURIPart
);
309 UniValue mempoolInfoObject
= mempoolInfoToJSON();
311 string strJSON
= mempoolInfoObject
.write() + "\n";
312 req
->WriteHeader("Content-Type", "application/json");
313 req
->WriteReply(HTTP_OK
, strJSON
);
317 return RESTERR(req
, HTTP_NOT_FOUND
, "output format not found (available: json)");
322 return true; // continue to process further HTTP reqs on this cxn
325 static bool rest_mempool_contents(HTTPRequest
* req
, const std::string
& strURIPart
)
327 if (!CheckWarmup(req
))
330 const RetFormat rf
= ParseDataFormat(param
, strURIPart
);
334 UniValue mempoolObject
= mempoolToJSON(true);
336 string strJSON
= mempoolObject
.write() + "\n";
337 req
->WriteHeader("Content-Type", "application/json");
338 req
->WriteReply(HTTP_OK
, strJSON
);
342 return RESTERR(req
, HTTP_NOT_FOUND
, "output format not found (available: json)");
347 return true; // continue to process further HTTP reqs on this cxn
350 static bool rest_tx(HTTPRequest
* req
, const std::string
& strURIPart
)
352 if (!CheckWarmup(req
))
355 const RetFormat rf
= ParseDataFormat(hashStr
, strURIPart
);
358 if (!ParseHashStr(hashStr
, hash
))
359 return RESTERR(req
, HTTP_BAD_REQUEST
, "Invalid hash: " + hashStr
);
362 uint256 hashBlock
= uint256();
363 if (!GetTransaction(hash
, tx
, hashBlock
, true))
364 return RESTERR(req
, HTTP_NOT_FOUND
, hashStr
+ " not found");
366 CDataStream
ssTx(SER_NETWORK
, PROTOCOL_VERSION
);
371 string binaryTx
= ssTx
.str();
372 req
->WriteHeader("Content-Type", "application/octet-stream");
373 req
->WriteReply(HTTP_OK
, binaryTx
);
378 string strHex
= HexStr(ssTx
.begin(), ssTx
.end()) + "\n";
379 req
->WriteHeader("Content-Type", "text/plain");
380 req
->WriteReply(HTTP_OK
, strHex
);
385 UniValue
objTx(UniValue::VOBJ
);
386 TxToJSON(tx
, hashBlock
, objTx
);
387 string strJSON
= objTx
.write() + "\n";
388 req
->WriteHeader("Content-Type", "application/json");
389 req
->WriteReply(HTTP_OK
, strJSON
);
394 return RESTERR(req
, HTTP_NOT_FOUND
, "output format not found (available: " + AvailableDataFormatsString() + ")");
399 return true; // continue to process further HTTP reqs on this cxn
402 static bool rest_getutxos(HTTPRequest
* req
, const std::string
& strURIPart
)
404 if (!CheckWarmup(req
))
407 const RetFormat rf
= ParseDataFormat(param
, strURIPart
);
409 vector
<string
> uriParts
;
410 if (param
.length() > 1)
412 std::string strUriParams
= param
.substr(1);
413 boost::split(uriParts
, strUriParams
, boost::is_any_of("/"));
416 // throw exception in case of a empty request
417 std::string strRequestMutable
= req
->ReadBody();
418 if (strRequestMutable
.length() == 0 && uriParts
.size() == 0)
419 return RESTERR(req
, HTTP_INTERNAL_SERVER_ERROR
, "Error: empty request");
421 bool fInputParsed
= false;
422 bool fCheckMemPool
= false;
423 vector
<COutPoint
> vOutPoints
;
425 // parse/deserialize input
426 // input-format = output-format, rest/getutxos/bin requires binary input, gives binary output, ...
428 if (uriParts
.size() > 0)
431 //inputs is sent over URI scheme (/rest/getutxos/checkmempool/txid1-n/txid2-n/...)
432 if (uriParts
.size() > 0 && uriParts
[0] == "checkmempool")
433 fCheckMemPool
= true;
435 for (size_t i
= (fCheckMemPool
) ? 1 : 0; i
< uriParts
.size(); i
++)
439 std::string strTxid
= uriParts
[i
].substr(0, uriParts
[i
].find("-"));
440 std::string strOutput
= uriParts
[i
].substr(uriParts
[i
].find("-")+1);
442 if (!ParseInt32(strOutput
, &nOutput
) || !IsHex(strTxid
))
443 return RESTERR(req
, HTTP_INTERNAL_SERVER_ERROR
, "Parse error");
445 txid
.SetHex(strTxid
);
446 vOutPoints
.push_back(COutPoint(txid
, (uint32_t)nOutput
));
449 if (vOutPoints
.size() > 0)
452 return RESTERR(req
, HTTP_INTERNAL_SERVER_ERROR
, "Error: empty request");
457 // convert hex to bin, continue then with bin part
458 std::vector
<unsigned char> strRequestV
= ParseHex(strRequestMutable
);
459 strRequestMutable
.assign(strRequestV
.begin(), strRequestV
.end());
464 //deserialize only if user sent a request
465 if (strRequestMutable
.size() > 0)
467 if (fInputParsed
) //don't allow sending input over URI and HTTP RAW DATA
468 return RESTERR(req
, HTTP_INTERNAL_SERVER_ERROR
, "Combination of URI scheme inputs and raw post data is not allowed");
470 CDataStream
oss(SER_NETWORK
, PROTOCOL_VERSION
);
471 oss
<< strRequestMutable
;
472 oss
>> fCheckMemPool
;
475 } catch (const std::ios_base::failure
& e
) {
476 // abort in case of unreadable binary data
477 return RESTERR(req
, HTTP_INTERNAL_SERVER_ERROR
, "Parse error");
484 return RESTERR(req
, HTTP_INTERNAL_SERVER_ERROR
, "Error: empty request");
488 return RESTERR(req
, HTTP_NOT_FOUND
, "output format not found (available: " + AvailableDataFormatsString() + ")");
492 // limit max outpoints
493 if (vOutPoints
.size() > MAX_GETUTXOS_OUTPOINTS
)
494 return RESTERR(req
, HTTP_INTERNAL_SERVER_ERROR
, strprintf("Error: max outpoints exceeded (max: %d, tried: %d)", MAX_GETUTXOS_OUTPOINTS
, vOutPoints
.size()));
496 // check spentness and form a bitmap (as well as a JSON capable human-readble string representation)
497 vector
<unsigned char> bitmap
;
499 std::string bitmapStringRepresentation
;
500 boost::dynamic_bitset
<unsigned char> hits(vOutPoints
.size());
502 LOCK2(cs_main
, mempool
.cs
);
504 CCoinsView viewDummy
;
505 CCoinsViewCache
view(&viewDummy
);
507 CCoinsViewCache
& viewChain
= *pcoinsTip
;
508 CCoinsViewMemPool
viewMempool(&viewChain
, mempool
);
511 view
.SetBackend(viewMempool
); // switch cache backend to db+mempool in case user likes to query mempool
513 for (size_t i
= 0; i
< vOutPoints
.size(); i
++) {
515 uint256 hash
= vOutPoints
[i
].hash
;
516 if (view
.GetCoins(hash
, coins
)) {
517 mempool
.pruneSpent(hash
, coins
);
518 if (coins
.IsAvailable(vOutPoints
[i
].n
)) {
520 // Safe to index into vout here because IsAvailable checked if it's off the end of the array, or if
521 // n is valid but points to an already spent output (IsNull).
523 coin
.nTxVer
= coins
.nVersion
;
524 coin
.nHeight
= coins
.nHeight
;
525 coin
.out
= coins
.vout
.at(vOutPoints
[i
].n
);
526 assert(!coin
.out
.IsNull());
527 outs
.push_back(coin
);
531 bitmapStringRepresentation
.append(hits
[i
] ? "1" : "0"); // form a binary string representation (human-readable for json output)
534 boost::to_block_range(hits
, std::back_inserter(bitmap
));
539 // use exact same output as mentioned in Bip64
540 CDataStream
ssGetUTXOResponse(SER_NETWORK
, PROTOCOL_VERSION
);
541 ssGetUTXOResponse
<< chainActive
.Height() << chainActive
.Tip()->GetBlockHash() << bitmap
<< outs
;
542 string ssGetUTXOResponseString
= ssGetUTXOResponse
.str();
544 req
->WriteHeader("Content-Type", "application/octet-stream");
545 req
->WriteReply(HTTP_OK
, ssGetUTXOResponseString
);
550 CDataStream
ssGetUTXOResponse(SER_NETWORK
, PROTOCOL_VERSION
);
551 ssGetUTXOResponse
<< chainActive
.Height() << chainActive
.Tip()->GetBlockHash() << bitmap
<< outs
;
552 string strHex
= HexStr(ssGetUTXOResponse
.begin(), ssGetUTXOResponse
.end()) + "\n";
554 req
->WriteHeader("Content-Type", "text/plain");
555 req
->WriteReply(HTTP_OK
, strHex
);
560 UniValue
objGetUTXOResponse(UniValue::VOBJ
);
562 // pack in some essentials
563 // use more or less the same output as mentioned in Bip64
564 objGetUTXOResponse
.push_back(Pair("chainHeight", chainActive
.Height()));
565 objGetUTXOResponse
.push_back(Pair("chaintipHash", chainActive
.Tip()->GetBlockHash().GetHex()));
566 objGetUTXOResponse
.push_back(Pair("bitmap", bitmapStringRepresentation
));
568 UniValue
utxos(UniValue::VARR
);
569 BOOST_FOREACH (const CCoin
& coin
, outs
) {
570 UniValue
utxo(UniValue::VOBJ
);
571 utxo
.push_back(Pair("txvers", (int32_t)coin
.nTxVer
));
572 utxo
.push_back(Pair("height", (int32_t)coin
.nHeight
));
573 utxo
.push_back(Pair("value", ValueFromAmount(coin
.out
.nValue
)));
575 // include the script in a json output
576 UniValue
o(UniValue::VOBJ
);
577 ScriptPubKeyToJSON(coin
.out
.scriptPubKey
, o
, true);
578 utxo
.push_back(Pair("scriptPubKey", o
));
579 utxos
.push_back(utxo
);
581 objGetUTXOResponse
.push_back(Pair("utxos", utxos
));
583 // return json string
584 string strJSON
= objGetUTXOResponse
.write() + "\n";
585 req
->WriteHeader("Content-Type", "application/json");
586 req
->WriteReply(HTTP_OK
, strJSON
);
590 return RESTERR(req
, HTTP_NOT_FOUND
, "output format not found (available: " + AvailableDataFormatsString() + ")");
595 return true; // continue to process further HTTP reqs on this cxn
598 static const struct {
600 bool (*handler
)(HTTPRequest
* req
, const std::string
& strReq
);
602 {"/rest/tx/", rest_tx
},
603 {"/rest/block/notxdetails/", rest_block_notxdetails
},
604 {"/rest/block/", rest_block_extended
},
605 {"/rest/chaininfo", rest_chaininfo
},
606 {"/rest/mempool/info", rest_mempool_info
},
607 {"/rest/mempool/contents", rest_mempool_contents
},
608 {"/rest/headers/", rest_headers
},
609 {"/rest/getutxos", rest_getutxos
},
614 for (unsigned int i
= 0; i
< ARRAYLEN(uri_prefixes
); i
++)
615 RegisterHTTPHandler(uri_prefixes
[i
].prefix
, false, uri_prefixes
[i
].handler
);
625 for (unsigned int i
= 0; i
< ARRAYLEN(uri_prefixes
); i
++)
626 UnregisterHTTPHandler(uri_prefixes
[i
].prefix
, false);