bool Node::isVBlocking(const Hash& qSetHash, const std::vector<uint256>& nodeSet) { CLOG(DEBUG, "SCP") << "Node::isVBlocking" << "@" << binToHex(mNodeID).substr(0, 6) << " qSet: " << binToHex(qSetHash).substr(0, 6) << " nodeSet.size: " << nodeSet.size(); // This call can throw a `QuorumSetNotFound` if the quorumSet is unknown. const SCPQuorumSet& qSet = retrieveQuorumSet(qSetHash); // There is no v-blocking set for {\empty} if (qSet.threshold == 0) { return false; } uint32 count = 0; for (auto n : qSet.validators) { auto it = std::find(nodeSet.begin(), nodeSet.end(), n); count += (it != nodeSet.end()) ? 1 : 0; } auto result = (qSet.validators.size() - count < qSet.threshold); CLOG(DEBUG, "SCP") << "Node::isVBlocking" << "@" << binToHex(mNodeID).substr(0, 6) << " is " << result; return result; }
std::shared_ptr<Bucket> BucketManagerImpl::getBucketByHash(uint256 const& hash) { std::lock_guard<std::recursive_mutex> lock(mBucketMutex); if (isZero(hash)) { return std::make_shared<Bucket>(); } auto i = mSharedBuckets.find(hash); if (i != mSharedBuckets.end()) { CLOG(TRACE, "Bucket") << "BucketManager::getBucketByHash(" << binToHex(hash) << ") found bucket " << i->second->getFilename(); return i->second; } std::string canonicalName = bucketFilename(hash); if (fs::exists(canonicalName)) { CLOG(TRACE, "Bucket") << "BucketManager::getBucketByHash(" << binToHex(hash) << ") found no bucket, making new one"; auto p = std::make_shared<Bucket>(canonicalName, hash); mSharedBuckets.insert(std::make_pair(hash, p)); mSharedBucketsSize.set_count(mSharedBuckets.size()); return p; } return std::shared_ptr<Bucket>(); }
std::string BigInt::toHexString() const { std::string response = "0x"; std::string nStr = n.to_string<char, std::char_traits<char>, std::allocator<char> >(); int limit = nStr.length(); int halfword = 1; for(int i=0;i<limit;){ if((nStr.substr(i, 16) == "0000000000000000") && (response == "0x")){ i=i+16; } else{ for(int j=0;j<4;j++){ response += binToHex(nStr.substr(i, 4)); if(halfword%4 == 0){ response += " "; } halfword++; i=i+4; } } }//end for loop. if(response=="0x"){ response += "00"; } return response; }
const SCPQuorumSet& Node::retrieveQuorumSet(const uint256& qSetHash) { // Notify that we touched this node. mSCP->nodeTouched(mNodeID); assert(mCacheLRU.size() == mCache.size()); auto it = mCache.find(qSetHash); if (it != mCache.end()) { return it->second; } CLOG(DEBUG, "SCP") << "Node::retrieveQuorumSet" << "@" << binToHex(mNodeID).substr(0, 6) << " qSet: " << binToHex(qSetHash).substr(0, 6); throw QuorumSetNotFound(mNodeID, qSetHash); }
void ApplyBucketsWork::startLevel() { assert(isLevelComplete()); CLOG(DEBUG, "History") << "ApplyBuckets : starting level " << mLevel; auto& level = getBucketLevel(mLevel); HistoryStateBucket const& i = mApplyState.currentBuckets.at(mLevel); bool applySnap = (i.snap != binToHex(level.getSnap()->getHash())); bool applyCurr = (i.curr != binToHex(level.getCurr()->getHash())); if (!mApplying && (applySnap || applyCurr)) { uint32_t oldestLedger = applySnap ? BucketList::oldestLedgerInSnap( mApplyState.currentLedger, mLevel) : BucketList::oldestLedgerInCurr( mApplyState.currentLedger, mLevel); auto& lsRoot = mApp.getLedgerTxnRoot(); lsRoot.deleteObjectsModifiedOnOrAfterLedger(oldestLedger); } if (mApplying || applySnap) { mSnapBucket = getBucket(i.snap); mSnapApplicator = std::make_unique<BucketApplicator>( mApp, mMaxProtocolVersion, mSnapBucket); CLOG(DEBUG, "History") << "ApplyBuckets : starting level[" << mLevel << "].snap = " << i.snap; mApplying = true; mBucketApplyStart.Mark(); } if (mApplying || applyCurr) { mCurrBucket = getBucket(i.curr); mCurrApplicator = std::make_unique<BucketApplicator>( mApp, mMaxProtocolVersion, mCurrBucket); CLOG(DEBUG, "History") << "ApplyBuckets : starting level[" << mLevel << "].curr = " << i.curr; mApplying = true; mBucketApplyStart.Mark(); } }
void FutureBucket::setLiveOutput(std::shared_ptr<Bucket> output) { mState = FB_LIVE_OUTPUT; mOutputBucketHash = binToHex(output->getHash()); // Given an output bucket, fake-up a promise for it connected to // the future so that it can be immediately retrieved. std::promise<std::shared_ptr<Bucket>> promise; mOutputBucket = promise.get_future().share(); promise.set_value(output); checkState(); }
FutureBucket::FutureBucket(Application& app, std::shared_ptr<Bucket> const& curr, std::shared_ptr<Bucket> const& snap, std::vector<std::shared_ptr<Bucket>> const& shadows) : mState(FB_LIVE_INPUTS) , mInputCurrBucket(curr) , mInputSnapBucket(snap) , mInputShadowBuckets(shadows) { // Constructed with a bunch of inputs, _immediately_ commence merging // them; there's no valid state for have-inputs-but-not-merging, the // presence of inputs implies merging, and vice-versa. assert(curr); assert(snap); mInputCurrBucketHash = binToHex(curr->getHash()); mInputSnapBucketHash = binToHex(snap->getHash()); for (auto const& b : mInputShadowBuckets) { mInputShadowBucketHashes.push_back(binToHex(b->getHash())); } startMerge(app); }
bool Node::hasQuorum(const Hash& qSetHash, const std::vector<uint256>& nodeSet) { CLOG(DEBUG, "SCP") << "Node::hasQuorum" << "@" << binToHex(mNodeID).substr(0, 6) << " qSet: " << binToHex(qSetHash).substr(0, 6) << " nodeSet.size: " << nodeSet.size(); // This call can throw a `QuorumSetNotFound` if the quorumSet is unknown. const SCPQuorumSet& qSet = retrieveQuorumSet(qSetHash); uint32 count = 0; for (auto n : qSet.validators) { auto it = std::find(nodeSet.begin(), nodeSet.end(), n); count += (it != nodeSet.end()) ? 1 : 0; } auto result = (count >= qSet.threshold); CLOG(DEBUG, "SCP") << "Node::hasQuorum" << "@" << binToHex(mNodeID).substr(0, 6) << " is " << result; return result; }
void Node::cacheQuorumSet(const SCPQuorumSet& qSet) { uint256 qSetHash = sha256(xdr::xdr_to_opaque(qSet)); CLOG(DEBUG, "SCP") << "Node::cacheQuorumSet" << "@" << binToHex(mNodeID).substr(0, 6) << " qSet: " << binToHex(qSetHash).substr(0, 6); if (mCache.find(qSetHash) != mCache.end()) { return; } while (mCacheCapacity >= 0 && mCache.size() >= (size_t)mCacheCapacity) { assert(mCacheLRU.size() == mCache.size()); auto it = mCacheLRU.begin(); mCache.erase(*it); mCacheLRU.erase(it); } mCacheLRU.push_back(qSetHash); mCache[qSetHash] = qSet; }
static std::string randomBucketName(std::string const& tmpDir) { for (;;) { std::string name = tmpDir + "/tmp-bucket-" + binToHex(randomBytes(8)) + ".xdr"; std::ifstream ifile(name); if (!ifile) { return name; } } }
std::string mkContractInfoDecl(std::string input) { Node n = parseSerpent(input); std::string s = mkFullExtern(n); std::string c = compileLLL(rewrite(n)); return "{\n" " \"code\": \"0x" + binToHex(c) + "\",\n" " \"info\": {\n" " \"abiDefinition\": " + indentLines(indentLines(s)).substr(8) + "\n" " },\n" " \"language\": \"serpent\",\n" " \"languageVersion\": \"2\",\n" " \"source\": \""+input+"\",\n" " \"userDoc\": {}\n" "}"; }
void ArchivePublisher::enterObservedState(HistoryArchiveState const& has) { assert(mState == PUBLISH_BEGIN); mState = PUBLISH_OBSERVED; mArchiveState = has; std::vector<std::string> bucketsToSend = mSnap->mLocalState.differingBuckets(mArchiveState); std::map<std::string, std::shared_ptr<Bucket>> bucketsByHash; for (auto b : mSnap->mLocalBuckets) { bucketsByHash[binToHex(b->getHash())] = b; } std::vector<std::shared_ptr<FilePublishInfo>> filePublishInfos = { mSnap->mLedgerSnapFile, mSnap->mTransactionSnapFile, mSnap->mTransactionResultSnapFile}; for (auto const& hash : bucketsToSend) { auto b = bucketsByHash[hash]; assert(b); filePublishInfos.push_back( std::make_shared<FilePublishInfo>(FILE_PUBLISH_NEEDED, *b)); } for (auto pi : filePublishInfos) { auto name = pi->baseName_nogz(); auto i = mFileInfos.find(name); if (i == mFileInfos.end() || i->second->getState() == FILE_PUBLISH_FAILED) { CLOG(DEBUG, "History") << "Queueing file " << name << " to send to archive '" << mArchive->getName() << "'"; mFileInfos[name] = pi; } else { CLOG(DEBUG, "History") << "Not queueing file " << name << " to send to archive '" << mArchive->getName() << "'; file already queued"; } } enterSendingState(); }
string generateSHA(string& value) { CSHA1 sha; sha.Update((UINT_8*)value.c_str(), value.length()); sha.Final(); UINT_8 digest[20]; if (sha.GetHash(digest)) { const int size = sizeof(digest) / sizeof(UINT_8); return binToHex((char*)digest, size); } return ""; }
std::shared_ptr<Bucket> FutureBucket::resolve() { checkState(); assert(isLive()); clearInputs(); std::shared_ptr<Bucket> bucket = mOutputBucket.get(); if (mOutputBucketHash.empty()) { mOutputBucketHash = binToHex(bucket->getHash()); } else { checkHashEq(bucket, mOutputBucketHash); } mState = FB_LIVE_OUTPUT; checkState(); return bucket; }
/*----------------------------------------------------------------------------*/ static void printAddress(struct Interface *serial, uint64_t address) { const uint8_t * const overlay = (const uint8_t *)&address; uint8_t serialized[25]; uint8_t *position = serialized; for (unsigned int i = 0; i < 8; ++i) { if (i > 0) *position++ = ' '; *position++ = binToHex(overlay[i] >> 4); *position++ = binToHex(overlay[i] & 0x0F); } *position++ = '\r'; *position = '\n'; ifWrite(serial, serialized, sizeof(serialized)); }
int main(int argv, char** argc) { if (argv == 1) { std::cerr << "Must provide a command and arguments! Try parse, rewrite, compile, assemble\n"; return 0; } std::string flag = ""; std::string command = argc[1]; std::string input; std::string secondInput; if (std::string(argc[1]) == "-s") { flag = command.substr(1); command = argc[2]; input = ""; std::string line; while (std::getline(std::cin, line)) { input += line + "\n"; } secondInput = argv == 3 ? "" : argc[3]; } else { if (argv == 2) { std::cerr << "Not enough arguments for serpent cmdline\n"; throw(0); } input = argc[2]; secondInput = argv == 3 ? "" : argc[3]; } bool haveSec = secondInput.length() > 0; if (command == "parse" || command == "parse_serpent") { std::cout << printAST(parseSerpent(input), haveSec) << "\n"; } else if (command == "rewrite") { std::cout << printAST(rewrite(parseLLL(input, true)), haveSec) << "\n"; } else if (command == "compile_to_lll") { std::cout << printAST(compileToLLL(input), haveSec) << "\n"; } else if (command == "build_fragtree") { std::cout << printAST(buildFragmentTree(parseLLL(input, true))) << "\n"; } else if (command == "compile_lll") { std::cout << binToHex(compileLLL(parseLLL(input, true))) << "\n"; } else if (command == "dereference") { std::cout << printAST(dereference(parseLLL(input, true)), haveSec) <<"\n"; } else if (command == "pretty_assemble") { std::cout << printTokens(prettyAssemble(parseLLL(input, true))) <<"\n"; } else if (command == "pretty_compile_lll") { std::cout << printTokens(prettyCompileLLL(parseLLL(input, true))) << "\n"; } else if (command == "pretty_compile") { std::cout << printTokens(prettyCompile(input)) << "\n"; } else if (command == "assemble") { std::cout << assemble(parseLLL(input, true)) << "\n"; } else if (command == "serialize") { std::cout << binToHex(serialize(tokenize(input, Metadata(), false))) << "\n"; } else if (command == "flatten") { std::cout << printTokens(flatten(parseLLL(input, true))) << "\n"; } else if (command == "deserialize") { std::cout << printTokens(deserialize(hexToBin(input))) << "\n"; } else if (command == "compile") { std::cout << binToHex(compile(input)) << "\n"; } else if (command == "encode_datalist") { std::vector<Node> tokens = tokenize(input); std::vector<std::string> o; for (int i = 0; i < (int)tokens.size(); i++) { o.push_back(tokens[i].val); } std::cout << binToHex(encodeDatalist(o)) << "\n"; } else if (command == "decode_datalist") { std::vector<std::string> o = decodeDatalist(hexToBin(input)); std::vector<Node> tokens; for (int i = 0; i < (int)o.size(); i++) tokens.push_back(token(o[i])); std::cout << printTokens(tokens) << "\n"; } else if (command == "tokenize") { std::cout << printTokens(tokenize(input)); } else if (command == "biject") { if (argv == 3) std::cerr << "Not enough arguments for biject\n"; int pos = decimalToUnsigned(secondInput); std::vector<Node> n = prettyCompile(input); if (pos >= (int)n.size()) std::cerr << "Code position too high\n"; Metadata m = n[pos].metadata; std::cout << "Opcode: " << n[pos].val << ", file: " << m.file << ", line: " << m.ln << ", char: " << m.ch << "\n"; } }
int main(int argc, char *argv[]) { int i; int digitCount = 0; int inputLength; if(argc != 4) /*If no/too few input arguments are given, OR there's more than 3 arguments passed to the program:*/ { fprintf(stderr,"Error: Invalid number of arguments passed.\n"); /*Standard error is printed and help function is run.*/ help(); } else { if(strcmp(argv[1],"-b") != 0 && strcmp(argv[1],"-d") != 0 && strcmp(argv[1],"-h") != 0 && strcmp(argv[1],"-o") != 0 && strcmp(argv[3],"-b") != 0 && strcmp(argv[3],"-d") != 0 && strcmp(argv[3],"-h") != 0 && strcmp(argv[3],"-o") != 0) /*Checks that both the input and output arguments are valid ones.*/ { fprintf(stderr,"Error: Invalid input or output type argument given.\n"); help(); } else { if(strcmp(argv[1],"-b") == 0) /*If the input value is -b for binary:*/ { inputLength = strlen(argv[2]); for(i = 0; i != inputLength; i++) /*Checks the valid input of 1s and 0s are given.*/ { if (argv[2][i] != '0' && argv[2][i] != '1' && argv[2][i] != '.') { fprintf(stderr,"Error: Binary values can only consist of 1\'s or 0\'s.\n"); help(); } if(argv[2][i] != '.') /*Counts the number of digits to ensure the input length is not more than 8 (excluding the decimal point)*/ digitCount++; } if(digitCount > 8) { fprintf(stderr,"Error: Maximum number of digits exceeded.\n"); help(); } if(strcmp(argv[3],"-b") == 0) /*If user wants to go from binary to binary, it prints the input string.*/ printf("%s\n",argv[2]); if(strcmp(argv[3],"-d") == 0) printf("%G\n",binToDec(argv[2])); /*If the user wants to go from binary to decimal, it executes the correct function and prints type double with the proper number of decimal places.*/ if(strcmp(argv[3],"-h") == 0) printf("%s\n",binToHex(argv[2])); if(strcmp(argv[3],"-o") == 0) printf("%s\n",binToOct(argv[2])); } if(strcmp(argv[1],"-d") == 0) /*If the input type is decimal, does the same checks as if the input type was binary but instead checks that each digit is a valid base 10 number.*/ { inputLength = strlen(argv[2]); for(i = 0; i != inputLength; i++) { if (argv[2][i] != '0' && argv[2][i] != '1' && argv[2][i] != '2' && argv[2][i] != '3' && argv[2][i] != '4' && argv[2][i] != '5' && argv[2][i] != '6' && argv[2][i] != '7' && argv[2][i] != '8' && argv[2][i] != '9' && argv[2][i] != '.') { fprintf(stderr,"Error: Decimal values can only consist of 0-9.\n"); help(); } if(argv[2][i] != '.') digitCount++; } if(digitCount > 8) { fprintf(stderr,"Error: Maximum number of digits exceeded.\n"); help(); } else { if(strcmp(argv[3],"-b") == 0) printf("%s\n",dectoBin(argv[2])); if(strcmp(argv[3],"-d") == 0) printf("%s\n",argv[2]); if(strcmp(argv[3],"-h") == 0) printf("%s\n",binToHex(dectoBin(argv[2]))); if(strcmp(argv[3],"-o") == 0) printf("%s\n",binToOct(dectoBin(argv[2]))); } } if(strcmp(argv[1],"-h") == 0) /*See above comments. Performs the same checks but for hex values.*/ { inputLength = strlen(argv[2]); for(i = 0; i != inputLength; i++) { if (argv[2][i] != '0' && argv[2][i] != '1' && argv[2][i] != '2' && argv[2][i] != '3' && argv[2][i] != '4' && argv[2][i] != '5' && argv[2][i] != '6' && argv[2][i] != '7' && argv[2][i] != '8' && argv[2][i] != '9' && argv[2][i] != 'a' && argv[2][i] != 'A' && argv[2][i] != 'b' && argv[2][i] != 'B' && argv[2][i] != 'c' && argv[2][i] != 'C' && argv[2][i] != 'd' && argv[2][i] != 'D' && argv[2][i] != 'e' && argv[2][i] != 'E' && argv[2][i] != 'f' && argv[2][i] != 'F' && argv[2][i] != '.') { fprintf(stderr,"Error: Hex values can only consist of 0-9 & A-F.\n"); help(); } if(argv[2][i] != '.') digitCount++; } if(digitCount > 4) { fprintf(stderr,"Error: Maximum number of digits exceeded.\n"); help(); } else { if(strcmp(argv[3],"-b") == 0) printf("%s\n",hextoBin(argv[2])); if(strcmp(argv[3],"-d") == 0) printf("%G\n",binToDec(hextoBin(argv[2]))); if(strcmp(argv[3],"-h") == 0) printf("%s\n",argv[2]); if(strcmp(argv[3],"-o") == 0) printf("%s\n",binToOct(hextoBin(argv[2]))); } } if(strcmp(argv[1],"-o") == 0) /*See above comments. Does the same checks but for octal numbers.*/ { inputLength = strlen(argv[2]); for(i = 0; i != inputLength; i++) { if (argv[2][i] != '0' && argv[2][i] != '1' && argv[2][i] != '2' && argv[2][i] != '3' && argv[2][i] != '4' && argv[2][i] != '5' && argv[2][i] != '6' && argv[2][i] != '7' && argv[2][i] != '.') { fprintf(stderr,"Error: Octal values can only consist of 0-7.\n"); help(); } if(argv[2][i] != '.') digitCount++; } if(digitCount > 8) { fprintf(stderr,"Error: Maximum number of digits exceeded.\n"); help(); } else { if(strcmp(argv[3],"-b") == 0) printf("%s\n",octtoBin(argv[2])); if(strcmp(argv[3],"-d") == 0) printf("%G\n",binToDec(octtoBin(argv[2]))); if(strcmp(argv[3],"-h") == 0) printf("%s\n",binToHex(octtoBin(argv[2]))); if(strcmp(argv[3],"-o") == 0) printf("%s\n",argv[2]); } } } } return 0; /*In order to meet C standards, the main function must return an int. 0 indicates successful program execution.*/ }
// ----------------------------------------- // main function // ----------------------------------------- // // Input: // none // // Returns: // 0/1 - success/failure // // Notes: // - character input is not handled yet. // int main(void) { int idx; // general purpose index int inputIdx; // index specific to stepping through user input int littleEndian = 0; // flag for little endian: 0 = false, 1 = true int jump; // amount to jump when parsing user input string int decimalNumber; // final integer to convert long long inputDecimalNumber; // temp placeholder for value to convert char ch, scrap; // holds prompt for little endian conversion + stdin flush char decIntBits[INTBITS + 1]; // holds bits that describe decimal integer char hexBits[HEXINTBITS + 1]; // holds hex value for decIntBits[] char promptString[] = "Enter a number (0 to cancel): "; int maxchars = 100; // maximum number of characters in user input char inputNumbers[maxchars]; // holds user input // Prompt for big endian or little endian output // printf("Byte ordering is set to big endian. Switch to little endian? (Y = yes): "); scanf(" %c", &ch); while ((scrap = getchar()) != '\n' && scrap != EOF); // flush stdin if(tolower(ch) == 'y') { littleEndian = 1; printf("Byte order: little-endian\n"); } else { printf("Byte order: big-endian\n"); } // Prompt for a number. Loop until we get a number we can use, then // display the binary number and break the loop. // while(1 && (inputDecimalNumber != 0)) { printf("\n%s", promptString); if(fgets(inputNumbers, sizeof(inputNumbers), stdin) != NULL) // no valid characters input? { for(inputIdx = 0; (sscanf(&inputNumbers[inputIdx], "%25lld%n", &inputDecimalNumber, &jump) != EOF) && (jump <= maxchars); inputIdx += jump) { // If the number entered was outside the min/max range of regular integers... // if( inputDecimalNumber < INT_MIN || inputDecimalNumber > INT_MAX ) { printf("Number is outside of integer range (%d to %d).\n", INT_MIN, INT_MAX); } // If we get this far, we have a valid number. Convert it, then // display it and break from the while loop. // else if( inputDecimalNumber != 0 ) { decimalNumber = (int)inputDecimalNumber; // convert input number to normal int intToBin(decimalNumber, decIntBits); // convert int to binary // print the integer being converted // printf("%10d ", decimalNumber); // convert to little endian byte ordering if requested // if(littleEndian == 1) { toLittleEndian(decIntBits); } // convert final bit array to hex // idx = 0; while(idx < HEXINTBITS) { hexBits[idx++] = '0'; } binToHex(decIntBits, hexBits); // convert to hex printf("0x"); // start the hex string // display the hex string // idx = 0; while(idx < strlen(hexBits)) { printf("%c", hexBits[idx]); idx++; } printf("\n"); } } } else { break; } } return 0; } // end of main()
std::string BucketManagerImpl::bucketFilename(Hash const& hash) { return bucketFilename(binToHex(hash)); }