Topic: iOS Bread Wallet - page 2. (Read 31048 times)

sendGetblocksMessageWithLocators

void static ProcessGetData(CNode* pfrom)
{
    std::deque::iterator it = pfrom->vRecvGetData.begin();

    vector vNotFound;

    LOCK(cs_main);

    while (it != pfrom->vRecvGetData.end()) {
        // Don't bother if send buffer is too full to respond anyway
        if (pfrom->nSendSize >= SendBufferSize())
            break;

        const CInv &inv = *it;
        {
            boost::this_thread::interruption_point();
            it++;

            if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK)
            {
                // Send block from disk
                map::iterator mi = mapBlockIndex.find(inv.hash);
                if (mi != mapBlockIndex.end())
                {
                    CBlock block;
					if (!block.ReadFromDisk((*mi).second)) {
						assert(!"cannot load block from disk");
					}
						
					if (inv.type == MSG_BLOCK) {
						pfrom->PushMessage("block", block);
					
					}
					else {
						CBlockIndex *pindex = NULL;
						pindex = (*mi).second;
						pindex = pindex->pnext;
						
						map::iterator mi = mapBlockIndex.find(block.hashMerkleRoot);
						pindex = (*mi).second;

						pindex = pindex->pnext;

						pfrom->PushMessage("merkleblock", pindex->GetBlockHeader());
						cout << "Merkleblock sended\n";
						
						//typedef std::pair PairType;
						
						//foreach found Transactions
						//BOOST_FOREACH(PairType& pair, merkleBlock.vMatchedTxn)
						
						//send TRANSACTION
						//pfrom->PushMessage(NetMsgType::TX, block.vtx[pair.first]);
					}

                    // Trigger them to send a getblocks request for the next batch of inventory
                    if (inv.hash == pfrom->hashContinue)
                    {
                        // Bypass PushInventory, this must send even if redundant,
                        // and we want it right after the last block so they don't
                        // wait for other stuff first.
                        vector vInv;
                        vInv.push_back(CInv(MSG_BLOCK, hashBestChain));
                        pfrom->PushMessage("inv", vInv);
                        pfrom->hashContinue = 0;
                    }
                }
            }
            else if (inv.IsKnownType())
            {
                // Send stream from relay memory
                bool pushed = false;
                {
                    LOCK(cs_mapRelay);
                    map::iterator mi = mapRelay.find(inv);
                    if (mi != mapRelay.end()) {
                        pfrom->PushMessage(inv.GetCommand(), (*mi).second);
                        pushed = true;
                    }
                }
                if (!pushed && inv.type == MSG_TX) {
                    CTransaction tx;
                    if (mempool.lookup(inv.hash, tx)) {
                        CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
                        ss.reserve(1000);
                        ss << tx;
                        pfrom->PushMessage("tx", ss);
                        pushed = true;
                    }
                }
                if (!pushed) {
                    vNotFound.push_back(inv);
                }
            }

            // Track requests for our stuff.
            g_signals.Inventory(inv.hash);

            if (inv.type == MSG_BLOCK || inv.type == MSG_FILTERED_BLOCK)
                break;
        }
    }

    pfrom->vRecvGetData.erase(pfrom->vRecvGetData.begin(), it);

    if (!vNotFound.empty()) {
        // Let the peer know that we didn't find what it asked for, so it doesn't
        // have to wait around forever. Currently only SPV clients actually care
        // about this message: it's needed when they are recursively walking the
        // dependencies of relevant unconfirmed transactions. SPV clients want to
        // do that because they want to know about (and store and rebroadcast and
        // risk analyze) the dependencies of transactions relevant to them, without
        // having to download the entire memory pool.
        pfrom->PushMessage("notfound", vNotFound);
    }
}

pfrom->PushMessage("merkleblock", pindex->GetBlockHeader());

pfrom->PushMessage("merkleblock", pindex->GetMerkleBlock());