downloader_test.go 61.6 KB
Newer Older
F
Felix Lange 已提交
1
// Copyright 2015 The go-ethereum Authors
2
// This file is part of the go-ethereum library.
F
Felix Lange 已提交
3
//
4
// The go-ethereum library is free software: you can redistribute it and/or modify
F
Felix Lange 已提交
5 6 7 8
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
9
// The go-ethereum library is distributed in the hope that it will be useful,
F
Felix Lange 已提交
10
// but WITHOUT ANY WARRANTY; without even the implied warranty of
11
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
F
Felix Lange 已提交
12 13 14
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
15
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
F
Felix Lange 已提交
16

17 18 19
package downloader

import (
20
	"errors"
21
	"fmt"
22
	"math/big"
23
	"sync"
24
	"sync/atomic"
25 26 27 28
	"testing"
	"time"

	"github.com/ethereum/go-ethereum/common"
29
	"github.com/ethereum/go-ethereum/core"
30
	"github.com/ethereum/go-ethereum/core/state"
31
	"github.com/ethereum/go-ethereum/core/types"
32
	"github.com/ethereum/go-ethereum/crypto"
33
	"github.com/ethereum/go-ethereum/ethdb"
O
obscuren 已提交
34
	"github.com/ethereum/go-ethereum/event"
35
	"github.com/ethereum/go-ethereum/params"
36
	"github.com/ethereum/go-ethereum/trie"
37 38
)

39
var (
40 41 42 43
	testdb, _   = ethdb.NewMemDatabase()
	testKey, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
	testAddress = crypto.PubkeyToAddress(testKey.PublicKey)
	genesis     = core.GenesisBlockForTesting(testdb, testAddress, big.NewInt(1000000000))
44
)
45

46 47 48 49
// makeChain creates a chain of n blocks starting at and including parent.
// the returned hash chain is ordered head->parent. In addition, every 3rd block
// contains a transaction and every 5th an uncle to allow testing correct block
// reassembly.
50
func makeChain(n int, seed byte, parent *types.Block, parentReceipts types.Receipts) ([]common.Hash, map[common.Hash]*types.Header, map[common.Hash]*types.Block, map[common.Hash]types.Receipts) {
51
	// Generate the block chain
52
	blocks, receipts := core.GenerateChain(parent, testdb, n, func(i int, block *core.BlockGen) {
53 54 55 56 57 58 59 60 61 62 63 64 65 66
		block.SetCoinbase(common.Address{seed})

		// If the block number is multiple of 3, send a bonus transaction to the miner
		if parent == genesis && i%3 == 0 {
			tx, err := types.NewTransaction(block.TxNonce(testAddress), common.Address{seed}, big.NewInt(1000), params.TxGas, nil, nil).SignECDSA(testKey)
			if err != nil {
				panic(err)
			}
			block.AddTx(tx)
		}
		// If the block number is a multiple of 5, add a bonus uncle to the block
		if i%5 == 0 {
			block.AddUncle(&types.Header{ParentHash: block.PrevBlock(i - 1).Hash(), Number: big.NewInt(int64(i - 1))})
		}
67
	})
68
	// Convert the block-chain into a hash-chain and header/block maps
69 70
	hashes := make([]common.Hash, n+1)
	hashes[len(hashes)-1] = parent.Hash()
71 72 73 74

	headerm := make(map[common.Hash]*types.Header, n+1)
	headerm[parent.Hash()] = parent.Header()

75 76
	blockm := make(map[common.Hash]*types.Block, n+1)
	blockm[parent.Hash()] = parent
77

78 79 80
	receiptm := make(map[common.Hash]types.Receipts, n+1)
	receiptm[parent.Hash()] = parentReceipts

81 82
	for i, b := range blocks {
		hashes[len(hashes)-i-2] = b.Hash()
83
		headerm[b.Hash()] = b.Header()
84
		blockm[b.Hash()] = b
85
		receiptm[b.Hash()] = receipts[i]
86
	}
87
	return hashes, headerm, blockm, receiptm
88 89 90 91
}

// makeChainFork creates two chains of length n, such that h1[:f] and
// h2[:f] are different but have a common suffix of length n-f.
92
func makeChainFork(n, f int, parent *types.Block, parentReceipts types.Receipts) ([]common.Hash, []common.Hash, map[common.Hash]*types.Header, map[common.Hash]*types.Header, map[common.Hash]*types.Block, map[common.Hash]*types.Block, map[common.Hash]types.Receipts, map[common.Hash]types.Receipts) {
93
	// Create the common suffix
94
	hashes, headers, blocks, receipts := makeChain(n-f, 0, parent, parentReceipts)
95 96

	// Create the forks
97
	hashes1, headers1, blocks1, receipts1 := makeChain(f, 1, blocks[hashes[0]], receipts[hashes[0]])
98 99
	hashes1 = append(hashes1, hashes[1:]...)

100
	hashes2, headers2, blocks2, receipts2 := makeChain(f, 2, blocks[hashes[0]], receipts[hashes[0]])
101 102 103 104 105 106 107 108 109 110
	hashes2 = append(hashes2, hashes[1:]...)

	for hash, header := range headers {
		headers1[hash] = header
		headers2[hash] = header
	}
	for hash, block := range blocks {
		blocks1[hash] = block
		blocks2[hash] = block
	}
111 112 113 114 115
	for hash, receipt := range receipts {
		receipts1[hash] = receipt
		receipts2[hash] = receipt
	}
	return hashes1, hashes2, headers1, headers2, blocks1, blocks2, receipts1, receipts2
116 117
}

118
// downloadTester is a test simulator for mocking out local block chain.
119
type downloadTester struct {
120
	stateDb    ethdb.Database
121 122
	downloader *Downloader

123 124 125 126 127 128 129 130 131 132 133
	ownHashes   []common.Hash                  // Hash chain belonging to the tester
	ownHeaders  map[common.Hash]*types.Header  // Headers belonging to the tester
	ownBlocks   map[common.Hash]*types.Block   // Blocks belonging to the tester
	ownReceipts map[common.Hash]types.Receipts // Receipts belonging to the tester
	ownChainTd  map[common.Hash]*big.Int       // Total difficulties of the blocks in the local chain

	peerHashes   map[string][]common.Hash                  // Hash chain belonging to different test peers
	peerHeaders  map[string]map[common.Hash]*types.Header  // Headers belonging to different test peers
	peerBlocks   map[string]map[common.Hash]*types.Block   // Blocks belonging to different test peers
	peerReceipts map[string]map[common.Hash]types.Receipts // Receipts belonging to different test peers
	peerChainTds map[string]map[common.Hash]*big.Int       // Total difficulties of the blocks in the peer chains
134 135

	lock sync.RWMutex
136 137
}

138
// newTester creates a new downloader test mocker.
139
func newTester(mode SyncMode) *downloadTester {
140
	tester := &downloadTester{
141
		ownHashes:    []common.Hash{genesis.Hash()},
142
		ownHeaders:   map[common.Hash]*types.Header{genesis.Hash(): genesis.Header()},
143
		ownBlocks:    map[common.Hash]*types.Block{genesis.Hash(): genesis},
144
		ownReceipts:  map[common.Hash]types.Receipts{genesis.Hash(): nil},
145 146
		ownChainTd:   map[common.Hash]*big.Int{genesis.Hash(): genesis.Difficulty()},
		peerHashes:   make(map[string][]common.Hash),
147
		peerHeaders:  make(map[string]map[common.Hash]*types.Header),
148
		peerBlocks:   make(map[string]map[common.Hash]*types.Block),
149
		peerReceipts: make(map[string]map[common.Hash]types.Receipts),
150
		peerChainTds: make(map[string]map[common.Hash]*big.Int),
151
	}
152 153 154
	tester.stateDb, _ = ethdb.NewMemDatabase()
	tester.downloader = New(mode, tester.stateDb, new(event.TypeMux), tester.hasHeader, tester.hasBlock, tester.getHeader,
		tester.getBlock, tester.headHeader, tester.headBlock, tester.headFastBlock, tester.commitHeadBlock, tester.getTd,
155
		tester.insertHeaders, tester.insertBlocks, tester.insertReceipts, tester.rollback, tester.dropPeer)
156 157 158 159

	return tester
}

160
// sync starts synchronizing with a remote peer, blocking until it completes.
161
func (dl *downloadTester) sync(id string, td *big.Int) error {
162
	dl.lock.RLock()
163 164 165 166
	hash := dl.peerHashes[id][0]
	// If no particular TD was requested, load from the peer's blockchain
	if td == nil {
		td = big.NewInt(1)
167 168
		if diff, ok := dl.peerChainTds[id][hash]; ok {
			td = diff
169 170
		}
	}
171
	dl.lock.RUnlock()
172

173
	err := dl.downloader.synchronise(id, hash, td)
174 175
	for {
		// If the queue is empty and processing stopped, break
176
		if dl.downloader.queue.Idle() && atomic.LoadInt32(&dl.downloader.processing) == 0 {
177 178 179
			break
		}
		// Otherwise sleep a bit and retry
180 181 182
		time.Sleep(time.Millisecond)
	}
	return err
O
obscuren 已提交
183 184
}

185 186 187 188 189 190
// hasHeader checks if a header is present in the testers canonical chain.
func (dl *downloadTester) hasHeader(hash common.Hash) bool {
	return dl.getHeader(hash) != nil
}

// hasBlock checks if a block is present in the testers canonical chain.
191
func (dl *downloadTester) hasBlock(hash common.Hash) bool {
192 193 194 195 196
	return dl.getBlock(hash) != nil
}

// getHeader retrieves a header from the testers canonical chain.
func (dl *downloadTester) getHeader(hash common.Hash) *types.Header {
197 198 199
	dl.lock.RLock()
	defer dl.lock.RUnlock()

200
	return dl.ownHeaders[hash]
201 202
}

203
// getBlock retrieves a block from the testers canonical chain.
204
func (dl *downloadTester) getBlock(hash common.Hash) *types.Block {
205 206 207
	dl.lock.RLock()
	defer dl.lock.RUnlock()

208 209 210
	return dl.ownBlocks[hash]
}

211 212 213 214 215
// headHeader retrieves the current head header from the canonical chain.
func (dl *downloadTester) headHeader() *types.Header {
	dl.lock.RLock()
	defer dl.lock.RUnlock()

216 217 218 219 220
	for i := len(dl.ownHashes) - 1; i >= 0; i-- {
		if header := dl.getHeader(dl.ownHashes[i]); header != nil {
			return header
		}
	}
221
	return genesis.Header()
222 223
}

224 225
// headBlock retrieves the current head block from the canonical chain.
func (dl *downloadTester) headBlock() *types.Block {
226 227 228
	dl.lock.RLock()
	defer dl.lock.RUnlock()

229 230
	for i := len(dl.ownHashes) - 1; i >= 0; i-- {
		if block := dl.getBlock(dl.ownHashes[i]); block != nil {
231 232 233
			if _, err := dl.stateDb.Get(block.Root().Bytes()); err == nil {
				return block
			}
234 235
		}
	}
236
	return genesis
237 238
}

239 240 241 242 243 244 245
// headFastBlock retrieves the current head fast-sync block from the canonical chain.
func (dl *downloadTester) headFastBlock() *types.Block {
	dl.lock.RLock()
	defer dl.lock.RUnlock()

	for i := len(dl.ownHashes) - 1; i >= 0; i-- {
		if block := dl.getBlock(dl.ownHashes[i]); block != nil {
246
			return block
247 248
		}
	}
249 250 251 252 253 254 255 256 257 258 259
	return genesis
}

// commitHeadBlock manually sets the head block to a given hash.
func (dl *downloadTester) commitHeadBlock(hash common.Hash) error {
	// For now only check that the state trie is correct
	if block := dl.getBlock(hash); block != nil {
		_, err := trie.NewSecure(block.Root(), dl.stateDb)
		return err
	}
	return fmt.Errorf("non existent block: %x", hash[:4])
260 261
}

262 263
// getTd retrieves the block's total difficulty from the canonical chain.
func (dl *downloadTester) getTd(hash common.Hash) *big.Int {
264 265 266
	dl.lock.RLock()
	defer dl.lock.RUnlock()

267 268 269
	return dl.ownChainTd[hash]
}

270
// insertHeaders injects a new batch of headers into the simulated chain.
271
func (dl *downloadTester) insertHeaders(headers []*types.Header, checkFreq int) (int, error) {
272 273 274
	dl.lock.Lock()
	defer dl.lock.Unlock()

275 276 277 278 279 280 281 282 283 284
	// Do a quick check, as the blockchain.InsertHeaderChain doesn't insert anthing in case of errors
	if _, ok := dl.ownHeaders[headers[0].ParentHash]; !ok {
		return 0, errors.New("unknown parent")
	}
	for i := 1; i < len(headers); i++ {
		if headers[i].ParentHash != headers[i-1].Hash() {
			return i, errors.New("unknown parent")
		}
	}
	// Do a full insert if pre-checks passed
285
	for i, header := range headers {
286 287 288
		if _, ok := dl.ownHeaders[header.Hash()]; ok {
			continue
		}
289 290 291 292 293 294 295 296 297 298 299 300
		if _, ok := dl.ownHeaders[header.ParentHash]; !ok {
			return i, errors.New("unknown parent")
		}
		dl.ownHashes = append(dl.ownHashes, header.Hash())
		dl.ownHeaders[header.Hash()] = header
		dl.ownChainTd[header.Hash()] = dl.ownChainTd[header.ParentHash]
	}
	return len(headers), nil
}

// insertBlocks injects a new batch of blocks into the simulated chain.
func (dl *downloadTester) insertBlocks(blocks types.Blocks) (int, error) {
301 302 303
	dl.lock.Lock()
	defer dl.lock.Unlock()

304 305 306 307 308
	for i, block := range blocks {
		if _, ok := dl.ownBlocks[block.ParentHash()]; !ok {
			return i, errors.New("unknown parent")
		}
		dl.ownHashes = append(dl.ownHashes, block.Hash())
309
		dl.ownHeaders[block.Hash()] = block.Header()
310
		dl.ownBlocks[block.Hash()] = block
311
		dl.stateDb.Put(block.Root().Bytes(), []byte{})
312
		dl.ownChainTd[block.Hash()] = dl.ownChainTd[block.ParentHash()]
313 314 315 316
	}
	return len(blocks), nil
}

317 318
// insertReceipts injects a new batch of blocks into the simulated chain.
func (dl *downloadTester) insertReceipts(blocks types.Blocks, receipts []types.Receipts) (int, error) {
319 320 321 322
	dl.lock.Lock()
	defer dl.lock.Unlock()

	for i := 0; i < len(blocks) && i < len(receipts); i++ {
323 324 325
		if _, ok := dl.ownHeaders[blocks[i].Hash()]; !ok {
			return i, errors.New("unknown owner")
		}
326 327 328 329
		if _, ok := dl.ownBlocks[blocks[i].ParentHash()]; !ok {
			return i, errors.New("unknown parent")
		}
		dl.ownBlocks[blocks[i].Hash()] = blocks[i]
330
		dl.ownReceipts[blocks[i].Hash()] = receipts[i]
331 332 333 334
	}
	return len(blocks), nil
}

335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
// rollback removes some recently added elements from the chain.
func (dl *downloadTester) rollback(hashes []common.Hash) {
	dl.lock.Lock()
	defer dl.lock.Unlock()

	for i := len(hashes) - 1; i >= 0; i-- {
		if dl.ownHashes[len(dl.ownHashes)-1] == hashes[i] {
			dl.ownHashes = dl.ownHashes[:len(dl.ownHashes)-1]
		}
		delete(dl.ownChainTd, hashes[i])
		delete(dl.ownHeaders, hashes[i])
		delete(dl.ownReceipts, hashes[i])
		delete(dl.ownBlocks, hashes[i])
	}
}

351
// newPeer registers a new block download source into the downloader.
352 353
func (dl *downloadTester) newPeer(id string, version int, hashes []common.Hash, headers map[common.Hash]*types.Header, blocks map[common.Hash]*types.Block, receipts map[common.Hash]types.Receipts) error {
	return dl.newSlowPeer(id, version, hashes, headers, blocks, receipts, 0)
354 355 356 357 358
}

// newSlowPeer registers a new block download source into the downloader, with a
// specific delay time on processing the network packets sent to it, simulating
// potentially slow network IO.
359
func (dl *downloadTester) newSlowPeer(id string, version int, hashes []common.Hash, headers map[common.Hash]*types.Header, blocks map[common.Hash]*types.Block, receipts map[common.Hash]types.Receipts, delay time.Duration) error {
360 361 362
	dl.lock.Lock()
	defer dl.lock.Unlock()

363 364 365
	var err error
	switch version {
	case 61:
366
		err = dl.downloader.RegisterPeer(id, version, hashes[0], dl.peerGetRelHashesFn(id, delay), dl.peerGetAbsHashesFn(id, delay), dl.peerGetBlocksFn(id, delay), nil, nil, nil, nil, nil)
367
	case 62:
368
		err = dl.downloader.RegisterPeer(id, version, hashes[0], nil, nil, nil, dl.peerGetRelHeadersFn(id, delay), dl.peerGetAbsHeadersFn(id, delay), dl.peerGetBodiesFn(id, delay), nil, nil)
369
	case 63:
370
		err = dl.downloader.RegisterPeer(id, version, hashes[0], nil, nil, nil, dl.peerGetRelHeadersFn(id, delay), dl.peerGetAbsHeadersFn(id, delay), dl.peerGetBodiesFn(id, delay), dl.peerGetReceiptsFn(id, delay), dl.peerGetNodeDataFn(id, delay))
371
	case 64:
372
		err = dl.downloader.RegisterPeer(id, version, hashes[0], nil, nil, nil, dl.peerGetRelHeadersFn(id, delay), dl.peerGetAbsHeadersFn(id, delay), dl.peerGetBodiesFn(id, delay), dl.peerGetReceiptsFn(id, delay), dl.peerGetNodeDataFn(id, delay))
373
	}
374
	if err == nil {
375
		// Assign the owned hashes, headers and blocks to the peer (deep copy)
376 377
		dl.peerHashes[id] = make([]common.Hash, len(hashes))
		copy(dl.peerHashes[id], hashes)
378

379
		dl.peerHeaders[id] = make(map[common.Hash]*types.Header)
380
		dl.peerBlocks[id] = make(map[common.Hash]*types.Block)
381
		dl.peerReceipts[id] = make(map[common.Hash]types.Receipts)
382
		dl.peerChainTds[id] = make(map[common.Hash]*big.Int)
383

384
		for _, hash := range hashes {
385 386 387 388 389 390
			if header, ok := headers[hash]; ok {
				dl.peerHeaders[id][hash] = header
				if _, ok := dl.peerHeaders[id][header.ParentHash]; ok {
					dl.peerChainTds[id][hash] = new(big.Int).Add(header.Difficulty, dl.peerChainTds[id][header.ParentHash])
				}
			}
391 392
			if block, ok := blocks[hash]; ok {
				dl.peerBlocks[id][hash] = block
393 394
				if _, ok := dl.peerBlocks[id][block.ParentHash()]; ok {
					dl.peerChainTds[id][hash] = new(big.Int).Add(block.Difficulty(), dl.peerChainTds[id][block.ParentHash()])
395 396
				}
			}
397 398 399
			if receipt, ok := receipts[hash]; ok {
				dl.peerReceipts[id][hash] = receipt
			}
400
		}
401 402
	}
	return err
403 404
}

405 406
// dropPeer simulates a hard peer removal from the connection pool.
func (dl *downloadTester) dropPeer(id string) {
407 408 409
	dl.lock.Lock()
	defer dl.lock.Unlock()

410
	delete(dl.peerHashes, id)
411
	delete(dl.peerHeaders, id)
412
	delete(dl.peerBlocks, id)
413
	delete(dl.peerChainTds, id)
414 415 416 417

	dl.downloader.UnregisterPeer(id)
}

418
// peerGetRelHashesFn constructs a GetHashes function associated with a specific
419 420
// peer in the download tester. The returned function can be used to retrieve
// batches of hashes from the particularly requested peer.
421
func (dl *downloadTester) peerGetRelHashesFn(id string, delay time.Duration) func(head common.Hash) error {
422
	return func(head common.Hash) error {
423 424
		time.Sleep(delay)

425 426 427
		dl.lock.RLock()
		defer dl.lock.RUnlock()

428 429
		// Gather the next batch of hashes
		hashes := dl.peerHashes[id]
430
		result := make([]common.Hash, 0, MaxHashFetch)
431 432
		for i, hash := range hashes {
			if hash == head {
433
				i++
434 435 436 437 438
				for len(result) < cap(result) && i < len(hashes) {
					result = append(result, hashes[i])
					i++
				}
				break
439 440
			}
		}
441 442 443
		// Delay delivery a bit to allow attacks to unfold
		go func() {
			time.Sleep(time.Millisecond)
444
			dl.downloader.DeliverHashes(id, result)
445 446
		}()
		return nil
447
	}
448 449
}

450 451 452
// peerGetAbsHashesFn constructs a GetHashesFromNumber function associated with
// a particular peer in the download tester. The returned function can be used to
// retrieve batches of hashes from the particularly requested peer.
453
func (dl *downloadTester) peerGetAbsHashesFn(id string, delay time.Duration) func(uint64, int) error {
454 455 456
	return func(head uint64, count int) error {
		time.Sleep(delay)

457 458 459
		dl.lock.RLock()
		defer dl.lock.RUnlock()

460 461
		// Gather the next batch of hashes
		hashes := dl.peerHashes[id]
462 463
		result := make([]common.Hash, 0, count)
		for i := 0; i < count && len(hashes)-int(head)-1-i >= 0; i++ {
464 465 466 467 468
			result = append(result, hashes[len(hashes)-int(head)-1-i])
		}
		// Delay delivery a bit to allow attacks to unfold
		go func() {
			time.Sleep(time.Millisecond)
469
			dl.downloader.DeliverHashes(id, result)
470 471 472 473 474
		}()
		return nil
	}
}

475 476 477
// peerGetBlocksFn constructs a getBlocks function associated with a particular
// peer in the download tester. The returned function can be used to retrieve
// batches of blocks from the particularly requested peer.
478
func (dl *downloadTester) peerGetBlocksFn(id string, delay time.Duration) func([]common.Hash) error {
479
	return func(hashes []common.Hash) error {
480
		time.Sleep(delay)
481 482 483 484

		dl.lock.RLock()
		defer dl.lock.RUnlock()

485 486
		blocks := dl.peerBlocks[id]
		result := make([]*types.Block, 0, len(hashes))
487
		for _, hash := range hashes {
488 489
			if block, ok := blocks[hash]; ok {
				result = append(result, block)
490
			}
491
		}
492
		go dl.downloader.DeliverBlocks(id, result)
493 494 495 496 497

		return nil
	}
}

498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
// peerGetRelHeadersFn constructs a GetBlockHeaders function based on a hashed
// origin; associated with a particular peer in the download tester. The returned
// function can be used to retrieve batches of headers from the particular peer.
func (dl *downloadTester) peerGetRelHeadersFn(id string, delay time.Duration) func(common.Hash, int, int, bool) error {
	return func(origin common.Hash, amount int, skip int, reverse bool) error {
		// Find the canonical number of the hash
		dl.lock.RLock()
		number := uint64(0)
		for num, hash := range dl.peerHashes[id] {
			if hash == origin {
				number = uint64(len(dl.peerHashes[id]) - num - 1)
				break
			}
		}
		dl.lock.RUnlock()

		// Use the absolute header fetcher to satisfy the query
		return dl.peerGetAbsHeadersFn(id, delay)(number, amount, skip, reverse)
	}
}

519 520 521 522 523 524 525
// peerGetAbsHeadersFn constructs a GetBlockHeaders function based on a numbered
// origin; associated with a particular peer in the download tester. The returned
// function can be used to retrieve batches of headers from the particular peer.
func (dl *downloadTester) peerGetAbsHeadersFn(id string, delay time.Duration) func(uint64, int, int, bool) error {
	return func(origin uint64, amount int, skip int, reverse bool) error {
		time.Sleep(delay)

526 527 528
		dl.lock.RLock()
		defer dl.lock.RUnlock()

529
		// Gather the next batch of headers
530
		hashes := dl.peerHashes[id]
531
		headers := dl.peerHeaders[id]
532 533
		result := make([]*types.Header, 0, amount)
		for i := 0; i < amount && len(hashes)-int(origin)-1-i >= 0; i++ {
534 535
			if header, ok := headers[hashes[len(hashes)-int(origin)-1-i]]; ok {
				result = append(result, header)
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
			}
		}
		// Delay delivery a bit to allow attacks to unfold
		go func() {
			time.Sleep(time.Millisecond)
			dl.downloader.DeliverHeaders(id, result)
		}()
		return nil
	}
}

// peerGetBodiesFn constructs a getBlockBodies method associated with a particular
// peer in the download tester. The returned function can be used to retrieve
// batches of block bodies from the particularly requested peer.
func (dl *downloadTester) peerGetBodiesFn(id string, delay time.Duration) func([]common.Hash) error {
	return func(hashes []common.Hash) error {
		time.Sleep(delay)
553 554 555 556

		dl.lock.RLock()
		defer dl.lock.RUnlock()

557 558 559 560 561 562 563 564 565 566 567 568
		blocks := dl.peerBlocks[id]

		transactions := make([][]*types.Transaction, 0, len(hashes))
		uncles := make([][]*types.Header, 0, len(hashes))

		for _, hash := range hashes {
			if block, ok := blocks[hash]; ok {
				transactions = append(transactions, block.Transactions())
				uncles = append(uncles, block.Uncles())
			}
		}
		go dl.downloader.DeliverBodies(id, transactions, uncles)
569 570 571 572 573

		return nil
	}
}

574 575 576 577 578 579 580 581 582 583
// peerGetReceiptsFn constructs a getReceipts method associated with a particular
// peer in the download tester. The returned function can be used to retrieve
// batches of block receipts from the particularly requested peer.
func (dl *downloadTester) peerGetReceiptsFn(id string, delay time.Duration) func([]common.Hash) error {
	return func(hashes []common.Hash) error {
		time.Sleep(delay)

		dl.lock.RLock()
		defer dl.lock.RUnlock()

584
		receipts := dl.peerReceipts[id]
585

586
		results := make([][]*types.Receipt, 0, len(hashes))
587
		for _, hash := range hashes {
588 589
			if receipt, ok := receipts[hash]; ok {
				results = append(results, receipt)
590 591
			}
		}
592
		go dl.downloader.DeliverReceipts(id, results)
593 594 595 596 597

		return nil
	}
}

598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
// peerGetNodeDataFn constructs a getNodeData method associated with a particular
// peer in the download tester. The returned function can be used to retrieve
// batches of node state data from the particularly requested peer.
func (dl *downloadTester) peerGetNodeDataFn(id string, delay time.Duration) func([]common.Hash) error {
	return func(hashes []common.Hash) error {
		time.Sleep(delay)

		dl.lock.RLock()
		defer dl.lock.RUnlock()

		results := make([][]byte, 0, len(hashes))
		for _, hash := range hashes {
			if data, err := testdb.Get(hash.Bytes()); err == nil {
				results = append(results, data)
			}
		}
		go dl.downloader.DeliverNodeData(id, results)

		return nil
	}
}

620 621 622
// assertOwnChain checks if the local chain contains the correct number of items
// of the various chain components.
func assertOwnChain(t *testing.T, tester *downloadTester, length int) {
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
	assertOwnForkedChain(t, tester, 1, []int{length})
}

// assertOwnForkedChain checks if the local forked chain contains the correct
// number of items of the various chain components.
func assertOwnForkedChain(t *testing.T, tester *downloadTester, common int, lengths []int) {
	// Initialize the counters for the first fork
	headers, blocks, receipts := lengths[0], lengths[0], lengths[0]-minFullBlocks
	if receipts < 0 {
		receipts = 1
	}
	// Update the counters for each subsequent fork
	for _, length := range lengths[1:] {
		headers += length - common
		blocks += length - common
		receipts += length - common - minFullBlocks
	}
640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
	switch tester.downloader.mode {
	case FullSync:
		receipts = 1
	case LightSync:
		blocks, receipts = 1, 1
	}
	if hs := len(tester.ownHeaders); hs != headers {
		t.Fatalf("synchronised headers mismatch: have %v, want %v", hs, headers)
	}
	if bs := len(tester.ownBlocks); bs != blocks {
		t.Fatalf("synchronised blocks mismatch: have %v, want %v", bs, blocks)
	}
	if rs := len(tester.ownReceipts); rs != receipts {
		t.Fatalf("synchronised receipts mismatch: have %v, want %v", rs, receipts)
	}
655 656 657 658 659 660 661 662
	// Verify the state trie too for fast syncs
	if tester.downloader.mode == FastSync {
		if index := lengths[len(lengths)-1] - minFullBlocks - 1; index > 0 {
			if statedb := state.New(tester.ownHeaders[tester.ownHashes[index]].Root, tester.stateDb); statedb == nil {
				t.Fatalf("state reconstruction failed")
			}
		}
	}
663 664
}

665 666 667
// Tests that simple synchronization against a canonical chain works correctly.
// In this test common ancestor lookup should be short circuited and not require
// binary searching.
668 669 670 671 672 673 674 675 676
func TestCanonicalSynchronisation61(t *testing.T)      { testCanonicalSynchronisation(t, 61, FullSync) }
func TestCanonicalSynchronisation62(t *testing.T)      { testCanonicalSynchronisation(t, 62, FullSync) }
func TestCanonicalSynchronisation63Full(t *testing.T)  { testCanonicalSynchronisation(t, 63, FullSync) }
func TestCanonicalSynchronisation63Fast(t *testing.T)  { testCanonicalSynchronisation(t, 63, FastSync) }
func TestCanonicalSynchronisation64Full(t *testing.T)  { testCanonicalSynchronisation(t, 64, FullSync) }
func TestCanonicalSynchronisation64Fast(t *testing.T)  { testCanonicalSynchronisation(t, 64, FastSync) }
func TestCanonicalSynchronisation64Light(t *testing.T) { testCanonicalSynchronisation(t, 64, LightSync) }

func testCanonicalSynchronisation(t *testing.T, protocol int, mode SyncMode) {
677 678
	// Create a small enough block chain to download
	targetBlocks := blockCacheLimit - 15
679
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
680

681
	tester := newTester(mode)
682
	tester.newPeer("peer", protocol, hashes, headers, blocks, receipts)
683

684
	// Synchronise with the peer and make sure all relevant data was retrieved
685
	if err := tester.sync("peer", nil); err != nil {
686
		t.Fatalf("failed to synchronise blocks: %v", err)
687
	}
688
	assertOwnChain(t, tester, targetBlocks+1)
689 690
}

691 692
// Tests that if a large batch of blocks are being downloaded, it is throttled
// until the cached blocks are retrieved.
693 694 695 696 697 698 699 700
func TestThrottling61(t *testing.T)     { testThrottling(t, 61, FullSync) }
func TestThrottling62(t *testing.T)     { testThrottling(t, 62, FullSync) }
func TestThrottling63Full(t *testing.T) { testThrottling(t, 63, FullSync) }
func TestThrottling63Fast(t *testing.T) { testThrottling(t, 63, FastSync) }
func TestThrottling64Full(t *testing.T) { testThrottling(t, 64, FullSync) }
func TestThrottling64Fast(t *testing.T) { testThrottling(t, 64, FastSync) }

func testThrottling(t *testing.T, protocol int, mode SyncMode) {
701 702
	// Create a long block chain to download and the tester
	targetBlocks := 8 * blockCacheLimit
703
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
704

705
	tester := newTester(mode)
706
	tester.newPeer("peer", protocol, hashes, headers, blocks, receipts)
707

708
	// Wrap the importer to allow stepping
709
	blocked, proceed := uint32(0), make(chan struct{})
710 711
	tester.downloader.chainInsertHook = func(results []*fetchResult) {
		atomic.StoreUint32(&blocked, uint32(len(results)))
712
		<-proceed
713
	}
714 715 716
	// Start a synchronisation concurrently
	errc := make(chan error)
	go func() {
717
		errc <- tester.sync("peer", nil)
718 719
	}()
	// Iteratively take some blocks, always checking the retrieval count
720 721 722 723 724 725 726 727
	for {
		// Check the retrieval count synchronously (! reason for this ugly block)
		tester.lock.RLock()
		retrieved := len(tester.ownBlocks)
		tester.lock.RUnlock()
		if retrieved >= targetBlocks+1 {
			break
		}
728 729
		// Wait a bit for sync to throttle itself
		var cached int
730
		for start := time.Now(); time.Since(start) < time.Second; {
731
			time.Sleep(25 * time.Millisecond)
732

733
			tester.downloader.queue.lock.RLock()
734 735 736
			cached = len(tester.downloader.queue.blockDonePool)
			if mode == FastSync {
				if receipts := len(tester.downloader.queue.receiptDonePool); receipts < cached {
737 738 739
					if tester.downloader.queue.resultCache[receipts].Header.Number.Uint64() < tester.downloader.queue.fastSyncPivot {
						cached = receipts
					}
740 741
				}
			}
742 743
			tester.downloader.queue.lock.RUnlock()

744
			if cached == blockCacheLimit || len(tester.ownBlocks)+cached+int(atomic.LoadUint32(&blocked)) == targetBlocks+1 {
745 746 747
				break
			}
		}
748 749
		// Make sure we filled up the cache, then exhaust it
		time.Sleep(25 * time.Millisecond) // give it a chance to screw up
750 751
		if cached != blockCacheLimit && len(tester.ownBlocks)+cached+int(atomic.LoadUint32(&blocked)) != targetBlocks+1 {
			t.Fatalf("block count mismatch: have %v, want %v (owned %v, target %v)", cached, blockCacheLimit, len(tester.ownBlocks), targetBlocks+1)
752
		}
753 754 755 756
		// Permit the blocked blocks to import
		if atomic.LoadUint32(&blocked) > 0 {
			atomic.StoreUint32(&blocked, uint32(0))
			proceed <- struct{}{}
757
		}
758 759
	}
	// Check that we haven't pulled more blocks than available
760
	assertOwnChain(t, tester, targetBlocks+1)
761 762
	if err := <-errc; err != nil {
		t.Fatalf("block synchronization failed: %v", err)
763 764
	}
}
765

766 767 768
// Tests that simple synchronization against a forked chain works correctly. In
// this test common ancestor lookup should *not* be short circuited, and a full
// binary search should be executed.
769 770 771 772 773 774 775 776 777
func TestForkedSynchronisation61(t *testing.T)      { testForkedSynchronisation(t, 61, FullSync) }
func TestForkedSynchronisation62(t *testing.T)      { testForkedSynchronisation(t, 62, FullSync) }
func TestForkedSynchronisation63Full(t *testing.T)  { testForkedSynchronisation(t, 63, FullSync) }
func TestForkedSynchronisation63Fast(t *testing.T)  { testForkedSynchronisation(t, 63, FastSync) }
func TestForkedSynchronisation64Full(t *testing.T)  { testForkedSynchronisation(t, 64, FullSync) }
func TestForkedSynchronisation64Fast(t *testing.T)  { testForkedSynchronisation(t, 64, FastSync) }
func TestForkedSynchronisation64Light(t *testing.T) { testForkedSynchronisation(t, 64, LightSync) }

func testForkedSynchronisation(t *testing.T, protocol int, mode SyncMode) {
778 779
	// Create a long enough forked chain
	common, fork := MaxHashFetch, 2*MaxHashFetch
780
	hashesA, hashesB, headersA, headersB, blocksA, blocksB, receiptsA, receiptsB := makeChainFork(common+fork, fork, genesis, nil)
781

782
	tester := newTester(mode)
783 784
	tester.newPeer("fork A", protocol, hashesA, headersA, blocksA, receiptsA)
	tester.newPeer("fork B", protocol, hashesB, headersB, blocksB, receiptsB)
785 786

	// Synchronise with the peer and make sure all blocks were retrieved
787
	if err := tester.sync("fork A", nil); err != nil {
788 789
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
790 791
	assertOwnChain(t, tester, common+fork+1)

792
	// Synchronise with the second peer and make sure that fork is pulled too
793
	if err := tester.sync("fork B", nil); err != nil {
794 795
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
796
	assertOwnForkedChain(t, tester, common+1, []int{common + fork + 1, common + fork + 1})
797 798 799
}

// Tests that an inactive downloader will not accept incoming hashes and blocks.
800
func TestInactiveDownloader61(t *testing.T) {
801
	tester := newTester(FullSync)
802 803

	// Check that neither hashes nor blocks are accepted
804
	if err := tester.downloader.DeliverHashes("bad peer", []common.Hash{}); err != errNoSyncActive {
805 806
		t.Errorf("error mismatch: have %v, want %v", err, errNoSyncActive)
	}
807
	if err := tester.downloader.DeliverBlocks("bad peer", []*types.Block{}); err != errNoSyncActive {
808 809 810 811
		t.Errorf("error mismatch: have %v, want %v", err, errNoSyncActive)
	}
}

812 813
// Tests that an inactive downloader will not accept incoming block headers and
// bodies.
814
func TestInactiveDownloader62(t *testing.T) {
815
	tester := newTester(FullSync)
816 817 818

	// Check that neither block headers nor bodies are accepted
	if err := tester.downloader.DeliverHeaders("bad peer", []*types.Header{}); err != errNoSyncActive {
819 820
		t.Errorf("error mismatch: have %v, want %v", err, errNoSyncActive)
	}
821
	if err := tester.downloader.DeliverBodies("bad peer", [][]*types.Transaction{}, [][]*types.Header{}); err != errNoSyncActive {
822 823 824 825
		t.Errorf("error mismatch: have %v, want %v", err, errNoSyncActive)
	}
}

826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841
// Tests that an inactive downloader will not accept incoming block headers,
// bodies and receipts.
func TestInactiveDownloader63(t *testing.T) {
	tester := newTester(FullSync)

	// Check that neither block headers nor bodies are accepted
	if err := tester.downloader.DeliverHeaders("bad peer", []*types.Header{}); err != errNoSyncActive {
		t.Errorf("error mismatch: have %v, want %v", err, errNoSyncActive)
	}
	if err := tester.downloader.DeliverBodies("bad peer", [][]*types.Transaction{}, [][]*types.Header{}); err != errNoSyncActive {
		t.Errorf("error mismatch: have %v, want %v", err, errNoSyncActive)
	}
	if err := tester.downloader.DeliverReceipts("bad peer", [][]*types.Receipt{}); err != errNoSyncActive {
		t.Errorf("error mismatch: have %v, want %v", err, errNoSyncActive)
	}
}
842

843 844 845 846 847 848 849 850 851 852
// Tests that a canceled download wipes all previously accumulated state.
func TestCancel61(t *testing.T)      { testCancel(t, 61, FullSync) }
func TestCancel62(t *testing.T)      { testCancel(t, 62, FullSync) }
func TestCancel63Full(t *testing.T)  { testCancel(t, 63, FullSync) }
func TestCancel63Fast(t *testing.T)  { testCancel(t, 63, FastSync) }
func TestCancel64Full(t *testing.T)  { testCancel(t, 64, FullSync) }
func TestCancel64Fast(t *testing.T)  { testCancel(t, 64, FastSync) }
func TestCancel64Light(t *testing.T) { testCancel(t, 64, LightSync) }

func testCancel(t *testing.T, protocol int, mode SyncMode) {
853 854 855 856 857
	// Create a small enough block chain to download and the tester
	targetBlocks := blockCacheLimit - 15
	if targetBlocks >= MaxHashFetch {
		targetBlocks = MaxHashFetch - 15
	}
858 859 860
	if targetBlocks >= MaxHeaderFetch {
		targetBlocks = MaxHeaderFetch - 15
	}
861
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
862

863
	tester := newTester(mode)
864
	tester.newPeer("peer", protocol, hashes, headers, blocks, receipts)
865 866 867

	// Make sure canceling works with a pristine downloader
	tester.downloader.cancel()
868 869
	if !tester.downloader.queue.Idle() {
		t.Errorf("download queue not idle")
870 871
	}
	// Synchronise with the peer, but cancel afterwards
872
	if err := tester.sync("peer", nil); err != nil {
873 874 875
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
	tester.downloader.cancel()
876 877
	if !tester.downloader.queue.Idle() {
		t.Errorf("download queue not idle")
878 879 880
	}
}

881
// Tests that synchronisation from multiple peers works as intended (multi thread sanity test).
882 883 884 885 886 887 888 889 890
func TestMultiSynchronisation61(t *testing.T)      { testMultiSynchronisation(t, 61, FullSync) }
func TestMultiSynchronisation62(t *testing.T)      { testMultiSynchronisation(t, 62, FullSync) }
func TestMultiSynchronisation63Full(t *testing.T)  { testMultiSynchronisation(t, 63, FullSync) }
func TestMultiSynchronisation63Fast(t *testing.T)  { testMultiSynchronisation(t, 63, FastSync) }
func TestMultiSynchronisation64Full(t *testing.T)  { testMultiSynchronisation(t, 64, FullSync) }
func TestMultiSynchronisation64Fast(t *testing.T)  { testMultiSynchronisation(t, 64, FastSync) }
func TestMultiSynchronisation64Light(t *testing.T) { testMultiSynchronisation(t, 64, LightSync) }

func testMultiSynchronisation(t *testing.T, protocol int, mode SyncMode) {
891
	// Create various peers with various parts of the chain
892
	targetPeers := 8
893
	targetBlocks := targetPeers*blockCacheLimit - 15
894
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
895

896
	tester := newTester(mode)
897 898
	for i := 0; i < targetPeers; i++ {
		id := fmt.Sprintf("peer #%d", i)
899
		tester.newPeer(id, protocol, hashes[i*blockCacheLimit:], headers, blocks, receipts)
900
	}
901
	if err := tester.sync("peer #0", nil); err != nil {
902 903
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
904
	assertOwnChain(t, tester, targetBlocks+1)
905 906
}

907 908
// Tests that synchronisations behave well in multi-version protocol environments
// and not wreak havok on other nodes in the network.
909 910 911 912 913 914 915 916 917
func TestMultiProtoSynchronisation61(t *testing.T)      { testMultiProtoSync(t, 61, FullSync) }
func TestMultiProtoSynchronisation62(t *testing.T)      { testMultiProtoSync(t, 62, FullSync) }
func TestMultiProtoSynchronisation63Full(t *testing.T)  { testMultiProtoSync(t, 63, FullSync) }
func TestMultiProtoSynchronisation63Fast(t *testing.T)  { testMultiProtoSync(t, 63, FastSync) }
func TestMultiProtoSynchronisation64Full(t *testing.T)  { testMultiProtoSync(t, 64, FullSync) }
func TestMultiProtoSynchronisation64Fast(t *testing.T)  { testMultiProtoSync(t, 64, FastSync) }
func TestMultiProtoSynchronisation64Light(t *testing.T) { testMultiProtoSync(t, 64, LightSync) }

func testMultiProtoSync(t *testing.T, protocol int, mode SyncMode) {
918 919
	// Create a small enough block chain to download
	targetBlocks := blockCacheLimit - 15
920
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
921 922

	// Create peers of every type
923
	tester := newTester(mode)
924 925 926 927
	tester.newPeer("peer 61", 61, hashes, headers, blocks, receipts)
	tester.newPeer("peer 62", 62, hashes, headers, blocks, receipts)
	tester.newPeer("peer 63", 63, hashes, headers, blocks, receipts)
	tester.newPeer("peer 64", 64, hashes, headers, blocks, receipts)
928 929 930 931 932

	// Synchronise with the requestd peer and make sure all blocks were retrieved
	if err := tester.sync(fmt.Sprintf("peer %d", protocol), nil); err != nil {
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
933 934
	assertOwnChain(t, tester, targetBlocks+1)

935 936 937 938 939 940 941 942 943
	// Check that no peers have been dropped off
	for _, version := range []int{61, 62, 63, 64} {
		peer := fmt.Sprintf("peer %d", version)
		if _, ok := tester.peerHashes[peer]; !ok {
			t.Errorf("%s dropped", peer)
		}
	}
}

944
// Tests that if a block is empty (e.g. header only), no body request should be
945
// made, and instead the header should be assembled into a whole block in itself.
946 947 948 949 950 951 952 953
func TestEmptyShortCircuit62(t *testing.T)      { testEmptyShortCircuit(t, 62, FullSync) }
func TestEmptyShortCircuit63Full(t *testing.T)  { testEmptyShortCircuit(t, 63, FullSync) }
func TestEmptyShortCircuit63Fast(t *testing.T)  { testEmptyShortCircuit(t, 63, FastSync) }
func TestEmptyShortCircuit64Full(t *testing.T)  { testEmptyShortCircuit(t, 64, FullSync) }
func TestEmptyShortCircuit64Fast(t *testing.T)  { testEmptyShortCircuit(t, 64, FastSync) }
func TestEmptyShortCircuit64Light(t *testing.T) { testEmptyShortCircuit(t, 64, LightSync) }

func testEmptyShortCircuit(t *testing.T, protocol int, mode SyncMode) {
954 955
	// Create a block chain to download
	targetBlocks := 2*blockCacheLimit - 15
956
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
957

958
	tester := newTester(mode)
959
	tester.newPeer("peer", protocol, hashes, headers, blocks, receipts)
960 961

	// Instrument the downloader to signal body requests
962
	bodiesHave, receiptsHave := int32(0), int32(0)
963
	tester.downloader.bodyFetchHook = func(headers []*types.Header) {
964
		atomic.AddInt32(&bodiesHave, int32(len(headers)))
965 966
	}
	tester.downloader.receiptFetchHook = func(headers []*types.Header) {
967
		atomic.AddInt32(&receiptsHave, int32(len(headers)))
968 969 970 971 972
	}
	// Synchronise with the peer and make sure all blocks were retrieved
	if err := tester.sync("peer", nil); err != nil {
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
973 974
	assertOwnChain(t, tester, targetBlocks+1)

975
	// Validate the number of block bodies that should have been requested
976
	bodiesNeeded, receiptsNeeded := 0, 0
977
	for _, block := range blocks {
978 979
		if mode != LightSync && block != genesis && (len(block.Transactions()) > 0 || len(block.Uncles()) > 0) {
			bodiesNeeded++
980
		}
981
	}
982 983
	for hash, receipt := range receipts {
		if mode == FastSync && len(receipt) > 0 && headers[hash].Number.Uint64() <= uint64(targetBlocks-minFullBlocks) {
984 985 986
			receiptsNeeded++
		}
	}
987 988
	if int(bodiesHave) != bodiesNeeded {
		t.Errorf("body retrieval count mismatch: have %v, want %v", bodiesHave, bodiesNeeded)
989
	}
990 991
	if int(receiptsHave) != receiptsNeeded {
		t.Errorf("receipt retrieval count mismatch: have %v, want %v", receiptsHave, receiptsNeeded)
992 993 994
	}
}

995 996
// Tests that headers are enqueued continuously, preventing malicious nodes from
// stalling the downloader by feeding gapped header chains.
997 998 999 1000 1001 1002 1003 1004
func TestMissingHeaderAttack62(t *testing.T)      { testMissingHeaderAttack(t, 62, FullSync) }
func TestMissingHeaderAttack63Full(t *testing.T)  { testMissingHeaderAttack(t, 63, FullSync) }
func TestMissingHeaderAttack63Fast(t *testing.T)  { testMissingHeaderAttack(t, 63, FastSync) }
func TestMissingHeaderAttack64Full(t *testing.T)  { testMissingHeaderAttack(t, 64, FullSync) }
func TestMissingHeaderAttack64Fast(t *testing.T)  { testMissingHeaderAttack(t, 64, FastSync) }
func TestMissingHeaderAttack64Light(t *testing.T) { testMissingHeaderAttack(t, 64, LightSync) }

func testMissingHeaderAttack(t *testing.T, protocol int, mode SyncMode) {
1005 1006
	// Create a small enough block chain to download
	targetBlocks := blockCacheLimit - 15
1007
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
1008

1009
	tester := newTester(mode)
1010 1011

	// Attempt a full sync with an attacker feeding gapped headers
1012
	tester.newPeer("attack", protocol, hashes, headers, blocks, receipts)
1013
	missing := targetBlocks / 2
1014
	delete(tester.peerHeaders["attack"], hashes[missing])
1015 1016 1017 1018 1019

	if err := tester.sync("attack", nil); err == nil {
		t.Fatalf("succeeded attacker synchronisation")
	}
	// Synchronise with the valid peer and make sure sync succeeds
1020
	tester.newPeer("valid", protocol, hashes, headers, blocks, receipts)
1021 1022 1023
	if err := tester.sync("valid", nil); err != nil {
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
1024
	assertOwnChain(t, tester, targetBlocks+1)
1025 1026 1027 1028
}

// Tests that if requested headers are shifted (i.e. first is missing), the queue
// detects the invalid numbering.
1029 1030 1031 1032 1033 1034 1035 1036
func TestShiftedHeaderAttack62(t *testing.T)      { testShiftedHeaderAttack(t, 62, FullSync) }
func TestShiftedHeaderAttack63Full(t *testing.T)  { testShiftedHeaderAttack(t, 63, FullSync) }
func TestShiftedHeaderAttack63Fast(t *testing.T)  { testShiftedHeaderAttack(t, 63, FastSync) }
func TestShiftedHeaderAttack64Full(t *testing.T)  { testShiftedHeaderAttack(t, 64, FullSync) }
func TestShiftedHeaderAttack64Fast(t *testing.T)  { testShiftedHeaderAttack(t, 64, FastSync) }
func TestShiftedHeaderAttack64Light(t *testing.T) { testShiftedHeaderAttack(t, 64, LightSync) }

func testShiftedHeaderAttack(t *testing.T, protocol int, mode SyncMode) {
1037 1038
	// Create a small enough block chain to download
	targetBlocks := blockCacheLimit - 15
1039
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
1040

1041
	tester := newTester(mode)
1042 1043

	// Attempt a full sync with an attacker feeding shifted headers
1044
	tester.newPeer("attack", protocol, hashes, headers, blocks, receipts)
1045
	delete(tester.peerHeaders["attack"], hashes[len(hashes)-2])
1046
	delete(tester.peerBlocks["attack"], hashes[len(hashes)-2])
1047
	delete(tester.peerReceipts["attack"], hashes[len(hashes)-2])
1048 1049 1050 1051 1052

	if err := tester.sync("attack", nil); err == nil {
		t.Fatalf("succeeded attacker synchronisation")
	}
	// Synchronise with the valid peer and make sure sync succeeds
1053
	tester.newPeer("valid", protocol, hashes, headers, blocks, receipts)
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
	if err := tester.sync("valid", nil); err != nil {
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
	assertOwnChain(t, tester, targetBlocks+1)
}

// Tests that upon detecting an invalid header, the recent ones are rolled back
func TestInvalidHeaderRollback63Fast(t *testing.T)  { testInvalidHeaderRollback(t, 63, FastSync) }
func TestInvalidHeaderRollback64Fast(t *testing.T)  { testInvalidHeaderRollback(t, 64, FastSync) }
func TestInvalidHeaderRollback64Light(t *testing.T) { testInvalidHeaderRollback(t, 64, LightSync) }

func testInvalidHeaderRollback(t *testing.T, protocol int, mode SyncMode) {
	// Create a small enough block chain to download
	targetBlocks := 3*minCheckedHeaders + minFullBlocks
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)

	tester := newTester(mode)

	// Attempt to sync with an attacker that feeds junk during the fast sync phase
	tester.newPeer("fast-attack", protocol, hashes, headers, blocks, receipts)
	missing := minCheckedHeaders + MaxHeaderFetch + 1
	delete(tester.peerHeaders["fast-attack"], hashes[len(hashes)-missing])

	if err := tester.sync("fast-attack", nil); err == nil {
		t.Fatalf("succeeded fast attacker synchronisation")
	}
	if head := tester.headHeader().Number.Int64(); int(head) > MaxHeaderFetch {
		t.Fatalf("rollback head mismatch: have %v, want at most %v", head, MaxHeaderFetch)
	}
	// Attempt to sync with an attacker that feeds junk during the block import phase
	tester.newPeer("block-attack", protocol, hashes, headers, blocks, receipts)
	missing = 3*minCheckedHeaders + MaxHeaderFetch + 1
	delete(tester.peerHeaders["block-attack"], hashes[len(hashes)-missing])

	if err := tester.sync("block-attack", nil); err == nil {
		t.Fatalf("succeeded block attacker synchronisation")
	}
	if mode == FastSync {
		// Fast sync should not discard anything below the verified pivot point
		if head := tester.headHeader().Number.Int64(); int(head) < 3*minCheckedHeaders {
			t.Fatalf("rollback head mismatch: have %v, want at least %v", head, 3*minCheckedHeaders)
		}
	} else if mode == LightSync {
		// Light sync should still discard data as before
		if head := tester.headHeader().Number.Int64(); int(head) > 3*minCheckedHeaders {
			t.Fatalf("rollback head mismatch: have %v, want at most %v", head, 3*minCheckedHeaders)
		}
	}
	// Synchronise with the valid peer and make sure sync succeeds
	tester.newPeer("valid", protocol, hashes, headers, blocks, receipts)
1104 1105 1106
	if err := tester.sync("valid", nil); err != nil {
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
1107
	assertOwnChain(t, tester, targetBlocks+1)
1108 1109
}

1110 1111 1112 1113 1114 1115 1116 1117
// Tests that if a peer sends an invalid block piece (body or receipt) for a
// requested block, it gets dropped immediately by the downloader.
func TestInvalidContentAttack62(t *testing.T)      { testInvalidContentAttack(t, 62, FullSync) }
func TestInvalidContentAttack63Full(t *testing.T)  { testInvalidContentAttack(t, 63, FullSync) }
func TestInvalidContentAttack63Fast(t *testing.T)  { testInvalidContentAttack(t, 63, FastSync) }
func TestInvalidContentAttack64Full(t *testing.T)  { testInvalidContentAttack(t, 64, FullSync) }
func TestInvalidContentAttack64Fast(t *testing.T)  { testInvalidContentAttack(t, 64, FastSync) }
func TestInvalidContentAttack64Light(t *testing.T) { testInvalidContentAttack(t, 64, LightSync) }
1118

1119
func testInvalidContentAttack(t *testing.T, protocol int, mode SyncMode) {
1120 1121
	// Create two peers, one feeding invalid block bodies
	targetBlocks := 4*blockCacheLimit - 15
1122
	hashes, headers, validBlocks, validReceipts := makeChain(targetBlocks, 0, genesis, nil)
1123 1124 1125 1126 1127

	invalidBlocks := make(map[common.Hash]*types.Block)
	for hash, block := range validBlocks {
		invalidBlocks[hash] = types.NewBlockWithHeader(block.Header())
	}
1128 1129 1130
	invalidReceipts := make(map[common.Hash]types.Receipts)
	for hash, _ := range validReceipts {
		invalidReceipts[hash] = types.Receipts{&types.Receipt{}}
1131
	}
1132

1133
	tester := newTester(mode)
1134
	tester.newPeer("valid", protocol, hashes, headers, validBlocks, validReceipts)
1135
	if mode != LightSync {
1136
		tester.newPeer("body attack", protocol, hashes, headers, invalidBlocks, validReceipts)
1137 1138
	}
	if mode == FastSync {
1139
		tester.newPeer("receipt attack", protocol, hashes, headers, validBlocks, invalidReceipts)
1140
	}
1141 1142 1143 1144
	// Synchronise with the valid peer (will pull contents from the attacker too)
	if err := tester.sync("valid", nil); err != nil {
		t.Fatalf("failed to synchronise blocks: %v", err)
	}
1145 1146
	assertOwnChain(t, tester, targetBlocks+1)

1147
	// Make sure the attacker was detected and dropped in the mean time
1148
	if _, ok := tester.peerHashes["body attack"]; ok {
1149 1150
		t.Fatalf("block body attacker not detected/dropped")
	}
1151 1152 1153
	if _, ok := tester.peerHashes["receipt attack"]; ok {
		t.Fatalf("receipt attacker not detected/dropped")
	}
1154 1155
}

1156 1157
// Tests that a peer advertising an high TD doesn't get to stall the downloader
// afterwards by not sending any useful hashes.
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
func TestHighTDStarvationAttack61(t *testing.T)      { testHighTDStarvationAttack(t, 61, FullSync) }
func TestHighTDStarvationAttack62(t *testing.T)      { testHighTDStarvationAttack(t, 62, FullSync) }
func TestHighTDStarvationAttack63Full(t *testing.T)  { testHighTDStarvationAttack(t, 63, FullSync) }
func TestHighTDStarvationAttack63Fast(t *testing.T)  { testHighTDStarvationAttack(t, 63, FastSync) }
func TestHighTDStarvationAttack64Full(t *testing.T)  { testHighTDStarvationAttack(t, 64, FullSync) }
func TestHighTDStarvationAttack64Fast(t *testing.T)  { testHighTDStarvationAttack(t, 64, FastSync) }
func TestHighTDStarvationAttack64Light(t *testing.T) { testHighTDStarvationAttack(t, 64, LightSync) }

func testHighTDStarvationAttack(t *testing.T, protocol int, mode SyncMode) {
	tester := newTester(mode)
1168
	hashes, headers, blocks, receipts := makeChain(0, 0, genesis, nil)
1169

1170
	tester.newPeer("attack", protocol, []common.Hash{hashes[0]}, headers, blocks, receipts)
1171
	if err := tester.sync("attack", big.NewInt(1000000)); err != errStallingPeer {
1172 1173 1174 1175
		t.Fatalf("synchronisation error mismatch: have %v, want %v", err, errStallingPeer)
	}
}

1176
// Tests that misbehaving peers are disconnected, whilst behaving ones are not.
1177 1178 1179 1180 1181 1182
func TestBlockHeaderAttackerDropping61(t *testing.T) { testBlockHeaderAttackerDropping(t, 61) }
func TestBlockHeaderAttackerDropping62(t *testing.T) { testBlockHeaderAttackerDropping(t, 62) }
func TestBlockHeaderAttackerDropping63(t *testing.T) { testBlockHeaderAttackerDropping(t, 63) }
func TestBlockHeaderAttackerDropping64(t *testing.T) { testBlockHeaderAttackerDropping(t, 64) }

func testBlockHeaderAttackerDropping(t *testing.T, protocol int) {
1183
	// Define the disconnection requirement for individual hash fetch errors
1184 1185 1186 1187
	tests := []struct {
		result error
		drop   bool
	}{
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
		{nil, false},                  // Sync succeeded, all is well
		{errBusy, false},              // Sync is already in progress, no problem
		{errUnknownPeer, false},       // Peer is unknown, was already dropped, don't double drop
		{errBadPeer, true},            // Peer was deemed bad for some reason, drop it
		{errStallingPeer, true},       // Peer was detected to be stalling, drop it
		{errNoPeers, false},           // No peers to download from, soft race, no issue
		{errPendingQueue, false},      // There are blocks still cached, wait to exhaust, no issue
		{errTimeout, true},            // No hashes received in due time, drop the peer
		{errEmptyHashSet, true},       // No hashes were returned as a response, drop as it's a dead end
		{errEmptyHeaderSet, true},     // No headers were returned as a response, drop as it's a dead end
		{errPeersUnavailable, true},   // Nobody had the advertised blocks, drop the advertiser
		{errInvalidChain, true},       // Hash chain was detected as invalid, definitely drop
1200
		{errInvalidBlock, false},      // A bad peer was detected, but not the sync origin
1201
		{errInvalidBody, false},       // A bad peer was detected, but not the sync origin
1202
		{errInvalidReceipt, false},    // A bad peer was detected, but not the sync origin
1203 1204 1205 1206
		{errCancelHashFetch, false},   // Synchronisation was canceled, origin may be innocent, don't drop
		{errCancelBlockFetch, false},  // Synchronisation was canceled, origin may be innocent, don't drop
		{errCancelHeaderFetch, false}, // Synchronisation was canceled, origin may be innocent, don't drop
		{errCancelBodyFetch, false},   // Synchronisation was canceled, origin may be innocent, don't drop
1207 1208
	}
	// Run the tests and check disconnection status
1209
	tester := newTester(FullSync)
1210 1211 1212
	for i, tt := range tests {
		// Register a new peer and ensure it's presence
		id := fmt.Sprintf("test %d", i)
1213
		if err := tester.newPeer(id, protocol, []common.Hash{genesis.Hash()}, nil, nil, nil); err != nil {
1214 1215 1216 1217 1218 1219 1220 1221
			t.Fatalf("test %d: failed to register new peer: %v", i, err)
		}
		if _, ok := tester.peerHashes[id]; !ok {
			t.Fatalf("test %d: registered peer not found", i)
		}
		// Simulate a synchronisation and check the required result
		tester.downloader.synchroniseMock = func(string, common.Hash) error { return tt.result }

1222
		tester.downloader.Synchronise(id, genesis.Hash(), big.NewInt(1000))
1223 1224 1225 1226 1227
		if _, ok := tester.peerHashes[id]; !ok != tt.drop {
			t.Errorf("test %d: peer drop mismatch for %v: have %v, want %v", i, tt.result, !ok, tt.drop)
		}
	}
}
1228

1229 1230
// Tests that synchronisation boundaries (origin block number and highest block
// number) is tracked and updated correctly.
1231 1232 1233 1234 1235 1236 1237 1238 1239
func TestSyncBoundaries61(t *testing.T)      { testSyncBoundaries(t, 61, FullSync) }
func TestSyncBoundaries62(t *testing.T)      { testSyncBoundaries(t, 62, FullSync) }
func TestSyncBoundaries63Full(t *testing.T)  { testSyncBoundaries(t, 63, FullSync) }
func TestSyncBoundaries63Fast(t *testing.T)  { testSyncBoundaries(t, 63, FastSync) }
func TestSyncBoundaries64Full(t *testing.T)  { testSyncBoundaries(t, 64, FullSync) }
func TestSyncBoundaries64Fast(t *testing.T)  { testSyncBoundaries(t, 64, FastSync) }
func TestSyncBoundaries64Light(t *testing.T) { testSyncBoundaries(t, 64, LightSync) }

func testSyncBoundaries(t *testing.T, protocol int, mode SyncMode) {
1240 1241
	// Create a small enough block chain to download
	targetBlocks := blockCacheLimit - 15
1242
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
1243 1244 1245 1246 1247

	// Set a sync init hook to catch boundary changes
	starting := make(chan struct{})
	progress := make(chan struct{})

1248
	tester := newTester(mode)
1249 1250 1251 1252 1253 1254 1255 1256 1257
	tester.downloader.syncInitHook = func(origin, latest uint64) {
		starting <- struct{}{}
		<-progress
	}
	// Retrieve the sync boundaries and ensure they are zero (pristine sync)
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != 0 {
		t.Fatalf("Pristine boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, 0)
	}
	// Synchronise half the blocks and check initial boundaries
1258
	tester.newPeer("peer-half", protocol, hashes[targetBlocks/2:], headers, blocks, receipts)
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
	pending := new(sync.WaitGroup)
	pending.Add(1)

	go func() {
		defer pending.Done()
		if err := tester.sync("peer-half", nil); err != nil {
			t.Fatalf("failed to synchronise blocks: %v", err)
		}
	}()
	<-starting
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != uint64(targetBlocks/2+1) {
		t.Fatalf("Initial boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, targetBlocks/2+1)
	}
	progress <- struct{}{}
	pending.Wait()

	// Synchronise all the blocks and check continuation boundaries
1276
	tester.newPeer("peer-full", protocol, hashes, headers, blocks, receipts)
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
	pending.Add(1)

	go func() {
		defer pending.Done()
		if err := tester.sync("peer-full", nil); err != nil {
			t.Fatalf("failed to synchronise blocks: %v", err)
		}
	}()
	<-starting
	if origin, latest := tester.downloader.Boundaries(); origin != uint64(targetBlocks/2+1) || latest != uint64(targetBlocks) {
		t.Fatalf("Completing boundary mismatch: have %v/%v, want %v/%v", origin, latest, targetBlocks/2+1, targetBlocks)
	}
	progress <- struct{}{}
	pending.Wait()
}

// Tests that synchronisation boundaries (origin block number and highest block
// number) is tracked and updated correctly in case of a fork (or manual head
// revertal).
1296 1297 1298 1299 1300 1301 1302 1303 1304
func TestForkedSyncBoundaries61(t *testing.T)      { testForkedSyncBoundaries(t, 61, FullSync) }
func TestForkedSyncBoundaries62(t *testing.T)      { testForkedSyncBoundaries(t, 62, FullSync) }
func TestForkedSyncBoundaries63Full(t *testing.T)  { testForkedSyncBoundaries(t, 63, FullSync) }
func TestForkedSyncBoundaries63Fast(t *testing.T)  { testForkedSyncBoundaries(t, 63, FastSync) }
func TestForkedSyncBoundaries64Full(t *testing.T)  { testForkedSyncBoundaries(t, 64, FullSync) }
func TestForkedSyncBoundaries64Fast(t *testing.T)  { testForkedSyncBoundaries(t, 64, FastSync) }
func TestForkedSyncBoundaries64Light(t *testing.T) { testForkedSyncBoundaries(t, 64, LightSync) }

func testForkedSyncBoundaries(t *testing.T, protocol int, mode SyncMode) {
1305 1306
	// Create a forked chain to simulate origin revertal
	common, fork := MaxHashFetch, 2*MaxHashFetch
1307
	hashesA, hashesB, headersA, headersB, blocksA, blocksB, receiptsA, receiptsB := makeChainFork(common+fork, fork, genesis, nil)
1308 1309 1310 1311 1312

	// Set a sync init hook to catch boundary changes
	starting := make(chan struct{})
	progress := make(chan struct{})

1313
	tester := newTester(mode)
1314 1315 1316 1317 1318 1319 1320 1321 1322
	tester.downloader.syncInitHook = func(origin, latest uint64) {
		starting <- struct{}{}
		<-progress
	}
	// Retrieve the sync boundaries and ensure they are zero (pristine sync)
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != 0 {
		t.Fatalf("Pristine boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, 0)
	}
	// Synchronise with one of the forks and check boundaries
1323
	tester.newPeer("fork A", protocol, hashesA, headersA, blocksA, receiptsA)
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
	pending := new(sync.WaitGroup)
	pending.Add(1)

	go func() {
		defer pending.Done()
		if err := tester.sync("fork A", nil); err != nil {
			t.Fatalf("failed to synchronise blocks: %v", err)
		}
	}()
	<-starting
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != uint64(len(hashesA)-1) {
		t.Fatalf("Initial boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, len(hashesA)-1)
	}
	progress <- struct{}{}
	pending.Wait()

	// Simulate a successful sync above the fork
1341
	tester.downloader.syncStatsChainOrigin = tester.downloader.syncStatsChainHeight
1342 1343

	// Synchronise with the second fork and check boundary resets
1344
	tester.newPeer("fork B", protocol, hashesB, headersB, blocksB, receiptsB)
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
	pending.Add(1)

	go func() {
		defer pending.Done()
		if err := tester.sync("fork B", nil); err != nil {
			t.Fatalf("failed to synchronise blocks: %v", err)
		}
	}()
	<-starting
	if origin, latest := tester.downloader.Boundaries(); origin != uint64(common) || latest != uint64(len(hashesB)-1) {
		t.Fatalf("Forking boundary mismatch: have %v/%v, want %v/%v", origin, latest, common, len(hashesB)-1)
	}
	progress <- struct{}{}
	pending.Wait()
}

// Tests that if synchronisation is aborted due to some failure, then the boundary
// origin is not updated in the next sync cycle, as it should be considered the
// continuation of the previous sync and not a new instance.
1364 1365 1366 1367 1368 1369 1370 1371 1372
func TestFailedSyncBoundaries61(t *testing.T)      { testFailedSyncBoundaries(t, 61, FullSync) }
func TestFailedSyncBoundaries62(t *testing.T)      { testFailedSyncBoundaries(t, 62, FullSync) }
func TestFailedSyncBoundaries63Full(t *testing.T)  { testFailedSyncBoundaries(t, 63, FullSync) }
func TestFailedSyncBoundaries63Fast(t *testing.T)  { testFailedSyncBoundaries(t, 63, FastSync) }
func TestFailedSyncBoundaries64Full(t *testing.T)  { testFailedSyncBoundaries(t, 64, FullSync) }
func TestFailedSyncBoundaries64Fast(t *testing.T)  { testFailedSyncBoundaries(t, 64, FastSync) }
func TestFailedSyncBoundaries64Light(t *testing.T) { testFailedSyncBoundaries(t, 64, LightSync) }

func testFailedSyncBoundaries(t *testing.T, protocol int, mode SyncMode) {
1373 1374
	// Create a small enough block chain to download
	targetBlocks := blockCacheLimit - 15
1375
	hashes, headers, blocks, receipts := makeChain(targetBlocks, 0, genesis, nil)
1376 1377 1378 1379 1380

	// Set a sync init hook to catch boundary changes
	starting := make(chan struct{})
	progress := make(chan struct{})

1381
	tester := newTester(mode)
1382 1383 1384 1385 1386 1387 1388 1389 1390
	tester.downloader.syncInitHook = func(origin, latest uint64) {
		starting <- struct{}{}
		<-progress
	}
	// Retrieve the sync boundaries and ensure they are zero (pristine sync)
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != 0 {
		t.Fatalf("Pristine boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, 0)
	}
	// Attempt a full sync with a faulty peer
1391
	tester.newPeer("faulty", protocol, hashes, headers, blocks, receipts)
1392
	missing := targetBlocks / 2
1393
	delete(tester.peerHeaders["faulty"], hashes[missing])
1394
	delete(tester.peerBlocks["faulty"], hashes[missing])
1395
	delete(tester.peerReceipts["faulty"], hashes[missing])
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413

	pending := new(sync.WaitGroup)
	pending.Add(1)

	go func() {
		defer pending.Done()
		if err := tester.sync("faulty", nil); err == nil {
			t.Fatalf("succeeded faulty synchronisation")
		}
	}()
	<-starting
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != uint64(targetBlocks) {
		t.Fatalf("Initial boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, targetBlocks)
	}
	progress <- struct{}{}
	pending.Wait()

	// Synchronise with a good peer and check that the boundary origin remind the same after a failure
1414
	tester.newPeer("valid", protocol, hashes, headers, blocks, receipts)
1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
	pending.Add(1)

	go func() {
		defer pending.Done()
		if err := tester.sync("valid", nil); err != nil {
			t.Fatalf("failed to synchronise blocks: %v", err)
		}
	}()
	<-starting
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != uint64(targetBlocks) {
		t.Fatalf("Completing boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, targetBlocks)
	}
	progress <- struct{}{}
	pending.Wait()
}

// Tests that if an attacker fakes a chain height, after the attack is detected,
// the boundary height is successfully reduced at the next sync invocation.
1433 1434 1435 1436 1437 1438 1439 1440 1441
func TestFakedSyncBoundaries61(t *testing.T)      { testFakedSyncBoundaries(t, 61, FullSync) }
func TestFakedSyncBoundaries62(t *testing.T)      { testFakedSyncBoundaries(t, 62, FullSync) }
func TestFakedSyncBoundaries63Full(t *testing.T)  { testFakedSyncBoundaries(t, 63, FullSync) }
func TestFakedSyncBoundaries63Fast(t *testing.T)  { testFakedSyncBoundaries(t, 63, FastSync) }
func TestFakedSyncBoundaries64Full(t *testing.T)  { testFakedSyncBoundaries(t, 64, FullSync) }
func TestFakedSyncBoundaries64Fast(t *testing.T)  { testFakedSyncBoundaries(t, 64, FastSync) }
func TestFakedSyncBoundaries64Light(t *testing.T) { testFakedSyncBoundaries(t, 64, LightSync) }

func testFakedSyncBoundaries(t *testing.T, protocol int, mode SyncMode) {
1442 1443
	// Create a small block chain
	targetBlocks := blockCacheLimit - 15
1444
	hashes, headers, blocks, receipts := makeChain(targetBlocks+3, 0, genesis, nil)
1445 1446 1447 1448 1449

	// Set a sync init hook to catch boundary changes
	starting := make(chan struct{})
	progress := make(chan struct{})

1450
	tester := newTester(mode)
1451 1452 1453 1454 1455 1456 1457 1458 1459
	tester.downloader.syncInitHook = func(origin, latest uint64) {
		starting <- struct{}{}
		<-progress
	}
	// Retrieve the sync boundaries and ensure they are zero (pristine sync)
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != 0 {
		t.Fatalf("Pristine boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, 0)
	}
	//  Create and sync with an attacker that promises a higher chain than available
1460
	tester.newPeer("attack", protocol, hashes, headers, blocks, receipts)
1461
	for i := 1; i < 3; i++ {
1462
		delete(tester.peerHeaders["attack"], hashes[i])
1463
		delete(tester.peerBlocks["attack"], hashes[i])
1464
		delete(tester.peerReceipts["attack"], hashes[i])
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483
	}

	pending := new(sync.WaitGroup)
	pending.Add(1)

	go func() {
		defer pending.Done()
		if err := tester.sync("attack", nil); err == nil {
			t.Fatalf("succeeded attacker synchronisation")
		}
	}()
	<-starting
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != uint64(targetBlocks+3) {
		t.Fatalf("Initial boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, targetBlocks+3)
	}
	progress <- struct{}{}
	pending.Wait()

	// Synchronise with a good peer and check that the boundary height has been reduced to the true value
1484
	tester.newPeer("valid", protocol, hashes[3:], headers, blocks, receipts)
1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499
	pending.Add(1)

	go func() {
		defer pending.Done()
		if err := tester.sync("valid", nil); err != nil {
			t.Fatalf("failed to synchronise blocks: %v", err)
		}
	}()
	<-starting
	if origin, latest := tester.downloader.Boundaries(); origin != 0 || latest != uint64(targetBlocks) {
		t.Fatalf("Initial boundary mismatch: have %v/%v, want %v/%v", origin, latest, 0, targetBlocks)
	}
	progress <- struct{}{}
	pending.Wait()
}