Release v0.1.0

vendor/github.com/btcsuite/btcd/addrmgr/cov_report.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+# This script uses gocov to generate a test coverage report.
+# The gocov tool my be obtained with the following command:
+#   go get github.com/axw/gocov/gocov
+#
+# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH.
+
+# Check for gocov.
+type gocov >/dev/null 2>&1
+if [ $? -ne 0 ]; then
+	echo >&2 "This script requires the gocov tool."
+	echo >&2 "You may obtain it with the following command:"
+	echo >&2 "go get github.com/axw/gocov/gocov"
+	exit 1
+fi
+gocov test | gocov report

vendor/github.com/btcsuite/btcd/addrmgr/doc.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+/*
+Package addrmgr implements concurrency safe Bitcoin address manager.
+
+Address Manager Overview
+
+In order maintain the peer-to-peer Bitcoin network, there needs to be a source
+of addresses to connect to as nodes come and go.  The Bitcoin protocol provides
+the getaddr and addr messages to allow peers to communicate known addresses with
+each other.  However, there needs to a mechanism to store those results and
+select peers from them.  It is also important to note that remote peers can't
+be trusted to send valid peers nor attempt to provide you with only peers they
+control with malicious intent.
+
+With that in mind, this package provides a concurrency safe address manager for
+caching and selecting peers in a non-deterministic manner.  The general idea is
+the caller adds addresses to the address manager and notifies it when addresses
+are connected, known good, and attempted.  The caller also requests addresses as
+it needs them.
+
+The address manager internally segregates the addresses into groups and
+non-deterministically selects groups in a cryptographically random manner.  This
+reduce the chances multiple addresses from the same nets are selected which
+generally helps provide greater peer diversity, and perhaps more importantly,
+drastically reduces the chances an attacker is able to coerce your peer into
+only connecting to nodes they control.
+
+The address manager also understands routability and Tor addresses and tries
+hard to only return routable addresses.  In addition, it uses the information
+provided by the caller about connected, known good, and attempted addresses to
+periodically purge peers which no longer appear to be good peers as well as
+bias the selection toward known good peers.  The general idea is to make a best
+effort at only providing usable addresses.
+*/
+package addrmgr

vendor/github.com/btcsuite/btcd/addrmgr/knownaddress.go

@@ -0,0 +1,102 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package addrmgr
+
+import (
+	"time"
+
+	"github.com/btcsuite/btcd/wire"
+)
+
+// KnownAddress tracks information about a known network address that is used
+// to determine how viable an address is.
+type KnownAddress struct {
+	na          *wire.NetAddress
+	srcAddr     *wire.NetAddress
+	attempts    int
+	lastattempt time.Time
+	lastsuccess time.Time
+	tried       bool
+	refs        int // reference count of new buckets
+}
+
+// NetAddress returns the underlying wire.NetAddress associated with the
+// known address.
+func (ka *KnownAddress) NetAddress() *wire.NetAddress {
+	return ka.na
+}
+
+// LastAttempt returns the last time the known address was attempted.
+func (ka *KnownAddress) LastAttempt() time.Time {
+	return ka.lastattempt
+}
+
+// Services returns the services supported by the peer with the known address.
+func (ka *KnownAddress) Services() wire.ServiceFlag {
+	return ka.na.Services
+}
+
+// chance returns the selection probability for a known address.  The priority
+// depends upon how recently the address has been seen, how recently it was last
+// attempted and how often attempts to connect to it have failed.
+func (ka *KnownAddress) chance() float64 {
+	now := time.Now()
+	lastAttempt := now.Sub(ka.lastattempt)
+
+	if lastAttempt < 0 {
+		lastAttempt = 0
+	}
+
+	c := 1.0
+
+	// Very recent attempts are less likely to be retried.
+	if lastAttempt < 10*time.Minute {
+		c *= 0.01
+	}
+
+	// Failed attempts deprioritise.
+	for i := ka.attempts; i > 0; i-- {
+		c /= 1.5
+	}
+
+	return c
+}
+
+// isBad returns true if the address in question has not been tried in the last
+// minute and meets one of the following criteria:
+// 1) It claims to be from the future
+// 2) It hasn't been seen in over a month
+// 3) It has failed at least three times and never succeeded
+// 4) It has failed ten times in the last week
+// All addresses that meet these criteria are assumed to be worthless and not
+// worth keeping hold of.
+func (ka *KnownAddress) isBad() bool {
+	if ka.lastattempt.After(time.Now().Add(-1 * time.Minute)) {
+		return false
+	}
+
+	// From the future?
+	if ka.na.Timestamp.After(time.Now().Add(10 * time.Minute)) {
+		return true
+	}
+
+	// Over a month old?
+	if ka.na.Timestamp.Before(time.Now().Add(-1 * numMissingDays * time.Hour * 24)) {
+		return true
+	}
+
+	// Never succeeded?
+	if ka.lastsuccess.IsZero() && ka.attempts >= numRetries {
+		return true
+	}
+
+	// Hasn't succeeded in too long?
+	if !ka.lastsuccess.After(time.Now().Add(-1*minBadDays*time.Hour*24)) &&
+		ka.attempts >= maxFailures {
+		return true
+	}
+
+	return false
+}

vendor/github.com/btcsuite/btcd/addrmgr/log.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package addrmgr
+
+import (
+	"github.com/btcsuite/btclog"
+)
+
+// log is a logger that is initialized with no output filters.  This
+// means the package will not perform any logging by default until the caller
+// requests it.
+var log btclog.Logger
+
+// The default amount of logging is none.
+func init() {
+	DisableLog()
+}
+
+// DisableLog disables all library log output.  Logging output is disabled
+// by default until either UseLogger or SetLogWriter are called.
+func DisableLog() {
+	log = btclog.Disabled
+}
+
+// UseLogger uses a specified Logger to output package logging info.
+// This should be used in preference to SetLogWriter if the caller is also
+// using btclog.
+func UseLogger(logger btclog.Logger) {
+	log = logger
+}

vendor/github.com/btcsuite/btcd/addrmgr/network.go

@@ -0,0 +1,281 @@
+// Copyright (c) 2013-2014 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package addrmgr
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/btcsuite/btcd/wire"
+)
+
+var (
+	// rfc1918Nets specifies the IPv4 private address blocks as defined by
+	// by RFC1918 (10.0.0.0/8, 172.16.0.0/12, and 192.168.0.0/16).
+	rfc1918Nets = []net.IPNet{
+		ipNet("10.0.0.0", 8, 32),
+		ipNet("172.16.0.0", 12, 32),
+		ipNet("192.168.0.0", 16, 32),
+	}
+
+	// rfc2544Net specifies the the IPv4 block as defined by RFC2544
+	// (198.18.0.0/15)
+	rfc2544Net = ipNet("198.18.0.0", 15, 32)
+
+	// rfc3849Net specifies the IPv6 documentation address block as defined
+	// by RFC3849 (2001:DB8::/32).
+	rfc3849Net = ipNet("2001:DB8::", 32, 128)
+
+	// rfc3927Net specifies the IPv4 auto configuration address block as
+	// defined by RFC3927 (169.254.0.0/16).
+	rfc3927Net = ipNet("169.254.0.0", 16, 32)
+
+	// rfc3964Net specifies the IPv6 to IPv4 encapsulation address block as
+	// defined by RFC3964 (2002::/16).
+	rfc3964Net = ipNet("2002::", 16, 128)
+
+	// rfc4193Net specifies the IPv6 unique local address block as defined
+	// by RFC4193 (FC00::/7).
+	rfc4193Net = ipNet("FC00::", 7, 128)
+
+	// rfc4380Net specifies the IPv6 teredo tunneling over UDP address block
+	// as defined by RFC4380 (2001::/32).
+	rfc4380Net = ipNet("2001::", 32, 128)
+
+	// rfc4843Net specifies the IPv6 ORCHID address block as defined by
+	// RFC4843 (2001:10::/28).
+	rfc4843Net = ipNet("2001:10::", 28, 128)
+
+	// rfc4862Net specifies the IPv6 stateless address autoconfiguration
+	// address block as defined by RFC4862 (FE80::/64).
+	rfc4862Net = ipNet("FE80::", 64, 128)
+
+	// rfc5737Net specifies the IPv4 documentation address blocks as defined
+	// by RFC5737 (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24)
+	rfc5737Net = []net.IPNet{
+		ipNet("192.0.2.0", 24, 32),
+		ipNet("198.51.100.0", 24, 32),
+		ipNet("203.0.113.0", 24, 32),
+	}
+
+	// rfc6052Net specifies the IPv6 well-known prefix address block as
+	// defined by RFC6052 (64:FF9B::/96).
+	rfc6052Net = ipNet("64:FF9B::", 96, 128)
+
+	// rfc6145Net specifies the IPv6 to IPv4 translated address range as
+	// defined by RFC6145 (::FFFF:0:0:0/96).
+	rfc6145Net = ipNet("::FFFF:0:0:0", 96, 128)
+
+	// rfc6598Net specifies the IPv4 block as defined by RFC6598 (100.64.0.0/10)
+	rfc6598Net = ipNet("100.64.0.0", 10, 32)
+
+	// onionCatNet defines the IPv6 address block used to support Tor.
+	// bitcoind encodes a .onion address as a 16 byte number by decoding the
+	// address prior to the .onion (i.e. the key hash) base32 into a ten
+	// byte number. It then stores the first 6 bytes of the address as
+	// 0xfd, 0x87, 0xd8, 0x7e, 0xeb, 0x43.
+	//
+	// This is the same range used by OnionCat, which is part part of the
+	// RFC4193 unique local IPv6 range.
+	//
+	// In summary the format is:
+	// { magic 6 bytes, 10 bytes base32 decode of key hash }
+	onionCatNet = ipNet("fd87:d87e:eb43::", 48, 128)
+
+	// zero4Net defines the IPv4 address block for address staring with 0
+	// (0.0.0.0/8).
+	zero4Net = ipNet("0.0.0.0", 8, 32)
+
+	// heNet defines the Hurricane Electric IPv6 address block.
+	heNet = ipNet("2001:470::", 32, 128)
+)
+
+// ipNet returns a net.IPNet struct given the passed IP address string, number
+// of one bits to include at the start of the mask, and the total number of bits
+// for the mask.
+func ipNet(ip string, ones, bits int) net.IPNet {
+	return net.IPNet{IP: net.ParseIP(ip), Mask: net.CIDRMask(ones, bits)}
+}
+
+// IsIPv4 returns whether or not the given address is an IPv4 address.
+func IsIPv4(na *wire.NetAddress) bool {
+	return na.IP.To4() != nil
+}
+
+// IsLocal returns whether or not the given address is a local address.
+func IsLocal(na *wire.NetAddress) bool {
+	return na.IP.IsLoopback() || zero4Net.Contains(na.IP)
+}
+
+// IsOnionCatTor returns whether or not the passed address is in the IPv6 range
+// used by bitcoin to support Tor (fd87:d87e:eb43::/48).  Note that this range
+// is the same range used by OnionCat, which is part of the RFC4193 unique local
+// IPv6 range.
+func IsOnionCatTor(na *wire.NetAddress) bool {
+	return onionCatNet.Contains(na.IP)
+}
+
+// IsRFC1918 returns whether or not the passed address is part of the IPv4
+// private network address space as defined by RFC1918 (10.0.0.0/8,
+// 172.16.0.0/12, or 192.168.0.0/16).
+func IsRFC1918(na *wire.NetAddress) bool {
+	for _, rfc := range rfc1918Nets {
+		if rfc.Contains(na.IP) {
+			return true
+		}
+	}
+	return false
+}
+
+// IsRFC2544 returns whether or not the passed address is part of the IPv4
+// address space as defined by RFC2544 (198.18.0.0/15)
+func IsRFC2544(na *wire.NetAddress) bool {
+	return rfc2544Net.Contains(na.IP)
+}
+
+// IsRFC3849 returns whether or not the passed address is part of the IPv6
+// documentation range as defined by RFC3849 (2001:DB8::/32).
+func IsRFC3849(na *wire.NetAddress) bool {
+	return rfc3849Net.Contains(na.IP)
+}
+
+// IsRFC3927 returns whether or not the passed address is part of the IPv4
+// autoconfiguration range as defined by RFC3927 (169.254.0.0/16).
+func IsRFC3927(na *wire.NetAddress) bool {
+	return rfc3927Net.Contains(na.IP)
+}
+
+// IsRFC3964 returns whether or not the passed address is part of the IPv6 to
+// IPv4 encapsulation range as defined by RFC3964 (2002::/16).
+func IsRFC3964(na *wire.NetAddress) bool {
+	return rfc3964Net.Contains(na.IP)
+}
+
+// IsRFC4193 returns whether or not the passed address is part of the IPv6
+// unique local range as defined by RFC4193 (FC00::/7).
+func IsRFC4193(na *wire.NetAddress) bool {
+	return rfc4193Net.Contains(na.IP)
+}
+
+// IsRFC4380 returns whether or not the passed address is part of the IPv6
+// teredo tunneling over UDP range as defined by RFC4380 (2001::/32).
+func IsRFC4380(na *wire.NetAddress) bool {
+	return rfc4380Net.Contains(na.IP)
+}
+
+// IsRFC4843 returns whether or not the passed address is part of the IPv6
+// ORCHID range as defined by RFC4843 (2001:10::/28).
+func IsRFC4843(na *wire.NetAddress) bool {
+	return rfc4843Net.Contains(na.IP)
+}
+
+// IsRFC4862 returns whether or not the passed address is part of the IPv6
+// stateless address autoconfiguration range as defined by RFC4862 (FE80::/64).
+func IsRFC4862(na *wire.NetAddress) bool {
+	return rfc4862Net.Contains(na.IP)
+}
+
+// IsRFC5737 returns whether or not the passed address is part of the IPv4
+// documentation address space as defined by RFC5737 (192.0.2.0/24,
+// 198.51.100.0/24, 203.0.113.0/24)
+func IsRFC5737(na *wire.NetAddress) bool {
+	for _, rfc := range rfc5737Net {
+		if rfc.Contains(na.IP) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// IsRFC6052 returns whether or not the passed address is part of the IPv6
+// well-known prefix range as defined by RFC6052 (64:FF9B::/96).
+func IsRFC6052(na *wire.NetAddress) bool {
+	return rfc6052Net.Contains(na.IP)
+}
+
+// IsRFC6145 returns whether or not the passed address is part of the IPv6 to
+// IPv4 translated address range as defined by RFC6145 (::FFFF:0:0:0/96).
+func IsRFC6145(na *wire.NetAddress) bool {
+	return rfc6145Net.Contains(na.IP)
+}
+
+// IsRFC6598 returns whether or not the passed address is part of the IPv4
+// shared address space specified by RFC6598 (100.64.0.0/10)
+func IsRFC6598(na *wire.NetAddress) bool {
+	return rfc6598Net.Contains(na.IP)
+}
+
+// IsValid returns whether or not the passed address is valid.  The address is
+// considered invalid under the following circumstances:
+// IPv4: It is either a zero or all bits set address.
+// IPv6: It is either a zero or RFC3849 documentation address.
+func IsValid(na *wire.NetAddress) bool {
+	// IsUnspecified returns if address is 0, so only all bits set, and
+	// RFC3849 need to be explicitly checked.
+	return na.IP != nil && !(na.IP.IsUnspecified() ||
+		na.IP.Equal(net.IPv4bcast))
+}
+
+// IsRoutable returns whether or not the passed address is routable over
+// the public internet.  This is true as long as the address is valid and is not
+// in any reserved ranges.
+func IsRoutable(na *wire.NetAddress) bool {
+	return IsValid(na) && !(IsRFC1918(na) || IsRFC2544(na) ||
+		IsRFC3927(na) || IsRFC4862(na) || IsRFC3849(na) ||
+		IsRFC4843(na) || IsRFC5737(na) || IsRFC6598(na) ||
+		IsLocal(na) || (IsRFC4193(na) && !IsOnionCatTor(na)))
+}
+
+// GroupKey returns a string representing the network group an address is part
+// of.  This is the /16 for IPv4, the /32 (/36 for he.net) for IPv6, the string
+// "local" for a local address, the string "tor:key" where key is the /4 of the
+// onion address for Tor address, and the string "unroutable" for an unroutable
+// address.
+func GroupKey(na *wire.NetAddress) string {
+	if IsLocal(na) {
+		return "local"
+	}
+	if !IsRoutable(na) {
+		return "unroutable"
+	}
+	if IsIPv4(na) {
+		return na.IP.Mask(net.CIDRMask(16, 32)).String()
+	}
+	if IsRFC6145(na) || IsRFC6052(na) {
+		// last four bytes are the ip address
+		ip := na.IP[12:16]
+		return ip.Mask(net.CIDRMask(16, 32)).String()
+	}
+
+	if IsRFC3964(na) {
+		ip := na.IP[2:6]
+		return ip.Mask(net.CIDRMask(16, 32)).String()
+
+	}
+	if IsRFC4380(na) {
+		// teredo tunnels have the last 4 bytes as the v4 address XOR
+		// 0xff.
+		ip := net.IP(make([]byte, 4))
+		for i, byte := range na.IP[12:16] {
+			ip[i] = byte ^ 0xff
+		}
+		return ip.Mask(net.CIDRMask(16, 32)).String()
+	}
+	if IsOnionCatTor(na) {
+		// group is keyed off the first 4 bits of the actual onion key.
+		return fmt.Sprintf("tor:%d", na.IP[6]&((1<<4)-1))
+	}
+
+	// OK, so now we know ourselves to be a IPv6 address.
+	// bitcoind uses /32 for everything, except for Hurricane Electric's
+	// (he.net) IP range, which it uses /36 for.
+	bits := 32
+	if heNet.Contains(na.IP) {
+		bits = 36
+	}
+
+	return na.IP.Mask(net.CIDRMask(bits, 128)).String()
+}

vendor/github.com/btcsuite/btcd/addrmgr/test_coverage.txt

@@ -0,0 +1,62 @@
+
+github.com/conformal/btcd/addrmgr/network.go		 GroupKey				 100.00% (23/23)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.reset			 100.00% (6/6)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC5737				 100.00% (4/4)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC1918				 100.00% (4/4)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 New					 100.00% (3/3)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 NetAddressKey				 100.00% (2/2)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC4862				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.numAddresses		 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/log.go		 init					 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/log.go		 DisableLog				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 ipNet					 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsIPv4					 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsLocal				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsOnionCatTor				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC2544				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC3849				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC3927				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC3964				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC4193				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC4380				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC4843				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC6052				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC6145				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRFC6598				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsValid				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/network.go		 IsRoutable				 100.00% (1/1)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.GetBestLocalAddress	 94.74% (18/19)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddLocalAddress		 90.91% (10/11)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 getReachabilityFrom			 51.52% (17/33)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 ipString				 50.00% (2/4)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.GetAddress			 9.30% (4/43)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.deserializePeers		 0.00% (0/50)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Good			 0.00% (0/44)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.savePeers			 0.00% (0/39)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.updateAddress		 0.00% (0/30)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.expireNew			 0.00% (0/22)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddressCache		 0.00% (0/16)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.HostToNetAddress		 0.00% (0/15)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.getNewBucket		 0.00% (0/15)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddAddressByIP		 0.00% (0/14)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.getTriedBucket		 0.00% (0/14)
+github.com/conformal/btcd/addrmgr/knownaddress.go	 knownAddress.chance			 0.00% (0/13)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.loadPeers			 0.00% (0/11)
+github.com/conformal/btcd/addrmgr/knownaddress.go	 knownAddress.isBad			 0.00% (0/11)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Connected			 0.00% (0/10)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.addressHandler		 0.00% (0/9)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.pickTried			 0.00% (0/8)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.DeserializeNetAddress	 0.00% (0/7)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Stop			 0.00% (0/7)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Attempt			 0.00% (0/7)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Start			 0.00% (0/6)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddAddresses		 0.00% (0/4)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.NeedMoreAddresses		 0.00% (0/3)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.NumAddresses		 0.00% (0/3)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddAddress			 0.00% (0/3)
+github.com/conformal/btcd/addrmgr/knownaddress.go	 knownAddress.LastAttempt		 0.00% (0/1)
+github.com/conformal/btcd/addrmgr/knownaddress.go	 knownAddress.NetAddress		 0.00% (0/1)
+github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.find			 0.00% (0/1)
+github.com/conformal/btcd/addrmgr/log.go		 UseLogger				 0.00% (0/1)
+github.com/conformal/btcd/addrmgr			 ---------------------------------	 21.04% (113/537)
+