251                strprintf("Corrupt AddrMan serialization: nNew=%d, should be in [0, %d]",
252                    nNew,
253                    ADDRMAN_NEW_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
254    }
255
256    if (nTried > ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE || nTried < 0) {
257        throw std::ios_base::failure(
258                strprintf("Corrupt AddrMan serialization: nTried=%d, should be in [0, %d]",
259                    nTried,
260                    ADDRMAN_TRIED_BUCKET_COUNT * ADDRMAN_BUCKET_SIZE));
261    }
262
263    // Deserialize entries from the new table.
264    for (int n = 0; n < nNew; n++) {
265        AddrInfo& info = mapInfo[n];
266        s >> info;
267        mapAddr[info] = n;
268        info.nRandomPos = vRandom.size();
269        vRandom.push_back(n);
270        m_network_counts[info.GetNetwork()].n_new++;
271    }
272    nIdCount = nNew;
273
274    // Deserialize entries from the tried table.
275    int nLost = 0;
276    for (int n = 0; n < nTried; n++) {
277        AddrInfo info;
278        s >> info;
279        int nKBucket = info.GetTriedBucket(nKey, m_netgroupman);
280        int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);
281        if (info.IsValid()
282                && vvTried[nKBucket][nKBucketPos] == -1) {
283            info.nRandomPos = vRandom.size();
284            info.fInTried = true;
285            vRandom.push_back(nIdCount);
286            mapInfo[nIdCount] = info;
287            mapAddr[info] = nIdCount;
288            vvTried[nKBucket][nKBucketPos] = nIdCount;
289            nIdCount++;
290            m_network_counts[info.GetNetwork()].n_tried++;
291        } else {
292            nLost++;
293        }
294    }
295    nTried -= nLost;
296
297    // Store positions in the new table buckets to apply later (if possible).
298    // An entry may appear in up to ADDRMAN_NEW_BUCKETS_PER_ADDRESS buckets,
299    // so we store all bucket-entry_index pairs to iterate through later.
300    std::vector<std::pair<int, int>> bucket_entries;
301
302    for (int bucket = 0; bucket < nUBuckets; ++bucket) {
303        int num_entries{0};
304        s >> num_entries;
305        for (int n = 0; n < num_entries; ++n) {
306            int entry_index{0};
307            s >> entry_index;
308            if (entry_index >= 0 && entry_index < nNew) {
309                bucket_entries.emplace_back(bucket, entry_index);
310            }
311        }
312    }
313
314    // If the bucket count and asmap version haven't changed, then attempt
315    // to restore the entries to the buckets/positions they were in before
316    // serialization.
317    uint256 supplied_asmap_version{m_netgroupman.GetAsmapVersion()};
318    uint256 serialized_asmap_version;
319    if (format >= Format::V2_ASMAP) {
320        s >> serialized_asmap_version;
321    }
322    const bool restore_bucketing{nUBuckets == ADDRMAN_NEW_BUCKET_COUNT &&
323        serialized_asmap_version == supplied_asmap_version};
324
325    if (!restore_bucketing) {
326        LogDebug(BCLog::ADDRMAN, "Bucketing method was updated, re-bucketing addrman entries from disk\n");
327    }
328
329    for (auto bucket_entry : bucket_entries) {
330        int bucket{bucket_entry.first};
331        const int entry_index{bucket_entry.second};
332        AddrInfo& info = mapInfo[entry_index];
333
334        // Don't store the entry in the new bucket if it's not a valid address for our addrman
335        if (!info.IsValid()) continue;
336
337        // The entry shouldn't appear in more than
338        // ADDRMAN_NEW_BUCKETS_PER_ADDRESS. If it has already, just skip
339        // this bucket_entry.
340        if (info.nRefCount >= ADDRMAN_NEW_BUCKETS_PER_ADDRESS) continue;
341
342        int bucket_position = info.GetBucketPosition(nKey, true, bucket);
343        if (restore_bucketing && vvNew[bucket][bucket_position] == -1) {
344            // Bucketing has not changed, using existing bucket positions for the new table
345            vvNew[bucket][bucket_position] = entry_index;
346            ++info.nRefCount;
347        } else {
348            // In case the new table data cannot be used (bucket count wrong or new asmap),
349            // try to give them a reference based on their primary source address.
350            bucket = info.GetNewBucket(nKey, m_netgroupman);
351            bucket_position = info.GetBucketPosition(nKey, true, bucket);
352            if (vvNew[bucket][bucket_position] == -1) {
353                vvNew[bucket][bucket_position] = entry_index;
354                ++info.nRefCount;
355            }
356        }
357    }
358
359    // Prune new entries with refcount 0 (as a result of collisions or invalid address).
360    int nLostUnk = 0;
361    for (auto it = mapInfo.cbegin(); it != mapInfo.cend(); ) {
362        if (it->second.fInTried == false && it->second.nRefCount == 0) {
363            const auto itCopy = it++;
364            Delete(itCopy->first);
365            ++nLostUnk;
366        } else {
367            ++it;
368        }
369    }
370    if (nLost + nLostUnk > 0) {
371        LogDebug(BCLog::ADDRMAN, "addrman lost %i new and %i tried addresses due to collisions or invalid addresses\n", nLostUnk, nLost);
372    }
373
374    const int check_code{CheckAddrman()};
375    if (check_code != 0) {
376        throw std::ios_base::failure(strprintf(
377            "Corrupt data. Consistency check failed with code %s",
378            check_code));
379    }
380}
381
382AddrInfo* AddrManImpl::Find(const CService& addr, nid_type* pnId)
383{
384    AssertLockHeld(cs);
385
386    const auto it = mapAddr.find(addr);
387    if (it == mapAddr.end())
388        return nullptr;
389    if (pnId)
390        *pnId = (*it).second;
391    const auto it2 = mapInfo.find((*it).second);
392    if (it2 != mapInfo.end())
393        return &(*it2).second;
394    return nullptr;
395}
396
397AddrInfo* AddrManImpl::Create(const CAddress& addr, const CNetAddr& addrSource, nid_type* pnId)
398{
399    AssertLockHeld(cs);
400
401    nid_type nId = nIdCount++;
402    mapInfo[nId] = AddrInfo(addr, addrSource);
403    mapAddr[addr] = nId;
404    mapInfo[nId].nRandomPos = vRandom.size();
405    vRandom.push_back(nId);
406    nNew++;
407    m_network_counts[addr.GetNetwork()].n_new++;
408    if (pnId)
409        *pnId = nId;
410    return &mapInfo[nId];
411}
412
413void AddrManImpl::SwapRandom(unsigned int nRndPos1, unsigned int nRndPos2) const
414{
415    AssertLockHeld(cs);
416
417    if (nRndPos1 == nRndPos2)
418        return;
419
420    assert(nRndPos1 < vRandom.size() && nRndPos2 < vRandom.size());
421
422    nid_type nId1 = vRandom[nRndPos1];
423    nid_type nId2 = vRandom[nRndPos2];
424
425    const auto it_1{mapInfo.find(nId1)};
426    const auto it_2{mapInfo.find(nId2)};
427    assert(it_1 != mapInfo.end());
428    assert(it_2 != mapInfo.end());
429
430    it_1->second.nRandomPos = nRndPos2;
431    it_2->second.nRandomPos = nRndPos1;
432
433    vRandom[nRndPos1] = nId2;
434    vRandom[nRndPos2] = nId1;
435}
436
437void AddrManImpl::Delete(nid_type nId)
438{
439    AssertLockHeld(cs);
440
441    assert(mapInfo.contains(nId));
442    AddrInfo& info = mapInfo[nId];
443    assert(!info.fInTried);
444    assert(info.nRefCount == 0);
445
446    SwapRandom(info.nRandomPos, vRandom.size() - 1);
447    m_network_counts[info.GetNetwork()].n_new--;
448    vRandom.pop_back();
449    mapAddr.erase(info);
450    mapInfo.erase(nId);
451    nNew--;
452}
453
454void AddrManImpl::ClearNew(int nUBucket, int nUBucketPos)
455{
456    AssertLockHeld(cs);
457
458    // if there is an entry in the specified bucket, delete it.
459    if (vvNew[nUBucket][nUBucketPos] != -1) {
460        nid_type nIdDelete = vvNew[nUBucket][nUBucketPos];
461        AddrInfo& infoDelete = mapInfo[nIdDelete];
462        assert(infoDelete.nRefCount > 0);
463        infoDelete.nRefCount--;
464        vvNew[nUBucket][nUBucketPos] = -1;
465        LogDebug(BCLog::ADDRMAN, "Removed %s from new[%i][%i]\n", infoDelete.ToStringAddrPort(), nUBucket, nUBucketPos);
466        if (infoDelete.nRefCount == 0) {
467            Delete(nIdDelete);
468        }
469    }
470}
471
472void AddrManImpl::MakeTried(AddrInfo& info, nid_type nId)
473{
474    AssertLockHeld(cs);
475
476    // remove the entry from all new buckets
477    const int start_bucket{info.GetNewBucket(nKey, m_netgroupman)};
478    for (int n = 0; n < ADDRMAN_NEW_BUCKET_COUNT; ++n) {
479        const int bucket{(start_bucket + n) % ADDRMAN_NEW_BUCKET_COUNT};
480        const int pos{info.GetBucketPosition(nKey, true, bucket)};
481        if (vvNew[bucket][pos] == nId) {
482            vvNew[bucket][pos] = -1;
483            info.nRefCount--;
484            if (info.nRefCount == 0) break;
485        }
486    }
487    nNew--;
488    m_network_counts[info.GetNetwork()].n_new--;
489
490    assert(info.nRefCount == 0);
491
492    // which tried bucket to move the entry to
493    int nKBucket = info.GetTriedBucket(nKey, m_netgroupman);
494    int nKBucketPos = info.GetBucketPosition(nKey, false, nKBucket);
495
496    // first make space to add it (the existing tried entry there is moved to new, deleting whatever is there).
497    if (vvTried[nKBucket][nKBucketPos] != -1) {
498        // find an item to evict
499        nid_type nIdEvict = vvTried[nKBucket][nKBucketPos];
500        assert(mapInfo.contains(nIdEvict));