mirror of
https://github.com/cwinfo/yggdrasil-go.git
synced 2024-11-22 13:00:47 +00:00
Remove legacy debug functions
This commit is contained in:
Neil Alexander
parent
881d0a1ada
commit
764f9c8e11
@ -2,20 +2,7 @@
|
||||
|
||||
package yggdrasil
|
||||
|
||||
// These are functions that should not exist
|
||||
// They are (or were) used during development, to work around missing features
|
||||
// They're also used to configure things from the outside
|
||||
// It would be better to define and export a few config functions elsewhere
|
||||
// Or define some remote API and call it to send/request configuration info
|
||||
|
||||
import _ "golang.org/x/net/ipv6" // TODO put this somewhere better
|
||||
|
||||
//import "golang.org/x/net/proxy"
|
||||
|
||||
import "fmt"
|
||||
import "net"
|
||||
import "regexp"
|
||||
import "encoding/hex"
|
||||
|
||||
import _ "net/http/pprof"
|
||||
import "net/http"
|
||||
@ -24,13 +11,6 @@ import "os"
|
||||
|
||||
import "github.com/gologme/log"
|
||||
|
||||
import "github.com/yggdrasil-network/yggdrasil-go/src/address"
|
||||
import "github.com/yggdrasil-network/yggdrasil-go/src/config"
|
||||
import "github.com/yggdrasil-network/yggdrasil-go/src/crypto"
|
||||
import "github.com/yggdrasil-network/yggdrasil-go/src/defaults"
|
||||
|
||||
import "github.com/Arceliar/phony"
|
||||
|
||||
// Start the profiler in debug builds, if the required environment variable is set.
|
||||
func init() {
|
||||
envVarName := "PPROFLISTEN"
|
||||
@ -51,589 +31,3 @@ func StartProfiler(log *log.Logger) error {
|
||||
go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()
|
||||
return nil
|
||||
}
|
||||
|
||||
// This function is only called by the simulator to set up a node with random
|
||||
// keys. It should not be used and may be removed in the future.
|
||||
func (c *Core) Init() {
|
||||
bpub, bpriv := crypto.NewBoxKeys()
|
||||
spub, spriv := crypto.NewSigKeys()
|
||||
hbpub := hex.EncodeToString(bpub[:])
|
||||
hbpriv := hex.EncodeToString(bpriv[:])
|
||||
hspub := hex.EncodeToString(spub[:])
|
||||
hspriv := hex.EncodeToString(spriv[:])
|
||||
cfg := config.NodeConfig{
|
||||
EncryptionPublicKey: hbpub,
|
||||
EncryptionPrivateKey: hbpriv,
|
||||
SigningPublicKey: hspub,
|
||||
SigningPrivateKey: hspriv,
|
||||
}
|
||||
c.config = config.NodeState{
|
||||
Current: cfg,
|
||||
Previous: cfg,
|
||||
}
|
||||
c.init()
|
||||
c.switchTable.start()
|
||||
c.router.start()
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Core
|
||||
|
||||
func (c *Core) DEBUG_getSigningPublicKey() crypto.SigPubKey {
|
||||
return (crypto.SigPubKey)(c.sigPub)
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_getEncryptionPublicKey() crypto.BoxPubKey {
|
||||
return (crypto.BoxPubKey)(c.boxPub)
|
||||
}
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_getSend() chan<- []byte {
|
||||
return c.router.tun.send
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_getRecv() <-chan []byte {
|
||||
return c.router.tun.recv
|
||||
}
|
||||
*/
|
||||
|
||||
// Peer
|
||||
|
||||
func (c *Core) DEBUG_getPeers() *peers {
|
||||
return &c.peers
|
||||
}
|
||||
|
||||
func (ps *peers) DEBUG_newPeer(box crypto.BoxPubKey, sig crypto.SigPubKey, link crypto.BoxSharedKey) *peer {
|
||||
sim := linkInterface{
|
||||
name: "(simulator)",
|
||||
info: linkInfo{
|
||||
local: "(simulator)",
|
||||
remote: "(simulator)",
|
||||
linkType: "sim",
|
||||
},
|
||||
}
|
||||
return ps.newPeer(&box, &sig, &link, &sim, nil)
|
||||
}
|
||||
|
||||
/*
|
||||
func (ps *peers) DEBUG_startPeers() {
|
||||
ps.mutex.RLock()
|
||||
defer ps.mutex.RUnlock()
|
||||
for _, p := range ps.ports {
|
||||
if p == nil { continue }
|
||||
go p.MainLoop()
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
func (ps *peers) DEBUG_hasPeer(key crypto.SigPubKey) bool {
|
||||
ports := ps.ports.Load().(map[switchPort]*peer)
|
||||
for _, p := range ports {
|
||||
if p == nil {
|
||||
continue
|
||||
}
|
||||
if p.sig == key {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (ps *peers) DEBUG_getPorts() map[switchPort]*peer {
|
||||
ports := ps.ports.Load().(map[switchPort]*peer)
|
||||
newPeers := make(map[switchPort]*peer)
|
||||
for port, p := range ports {
|
||||
newPeers[port] = p
|
||||
}
|
||||
return newPeers
|
||||
}
|
||||
|
||||
func (p *peer) DEBUG_getSigKey() crypto.SigPubKey {
|
||||
return p.sig
|
||||
}
|
||||
|
||||
func (p *peer) DEEBUG_getPort() switchPort {
|
||||
return p.port
|
||||
}
|
||||
|
||||
// Router
|
||||
|
||||
func (c *Core) DEBUG_getSwitchTable() *switchTable {
|
||||
return &c.switchTable
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_getLocator() switchLocator {
|
||||
return c.switchTable.getLocator()
|
||||
}
|
||||
|
||||
func (l *switchLocator) DEBUG_getCoords() []byte {
|
||||
return l.getCoords()
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_switchLookup(dest []byte) switchPort {
|
||||
return c.switchTable.DEBUG_lookup(dest)
|
||||
}
|
||||
|
||||
// This does the switch layer lookups that decide how to route traffic.
|
||||
// Traffic uses greedy routing in a metric space, where the metric distance between nodes is equal to the distance between them on the tree.
|
||||
// Traffic must be routed to a node that is closer to the destination via the metric space distance.
|
||||
// In the event that two nodes are equally close, it gets routed to the one with the longest uptime (due to the order that things are iterated over).
|
||||
// The size of the outgoing packet queue is added to a node's tree distance when the cost of forwarding to a node, subject to the constraint that the real tree distance puts them closer to the destination than ourself.
|
||||
// Doing so adds a limited form of backpressure routing, based on local information, which allows us to forward traffic around *local* bottlenecks, provided that another greedy path exists.
|
||||
func (t *switchTable) DEBUG_lookup(dest []byte) switchPort {
|
||||
table := t.getTable()
|
||||
myDist := table.self.dist(dest)
|
||||
if myDist == 0 {
|
||||
return 0
|
||||
}
|
||||
// cost is in units of (expected distance) + (expected queue size), where expected distance is used as an approximation of the minimum backpressure gradient needed for packets to flow
|
||||
ports := t.core.peers.getPorts()
|
||||
var best switchPort
|
||||
bestCost := int64(^uint64(0) >> 1)
|
||||
for _, info := range table.elems {
|
||||
dist := info.locator.dist(dest)
|
||||
if !(dist < myDist) {
|
||||
continue
|
||||
}
|
||||
//p, isIn := ports[info.port]
|
||||
_, isIn := ports[info.port]
|
||||
if !isIn {
|
||||
continue
|
||||
}
|
||||
cost := int64(dist) // + p.getQueueSize()
|
||||
if cost < bestCost {
|
||||
best = info.port
|
||||
bestCost = cost
|
||||
}
|
||||
}
|
||||
return best
|
||||
}
|
||||
|
||||
/*
|
||||
func (t *switchTable) DEBUG_isDirty() bool {
|
||||
//data := t.data.Load().(*tabledata)
|
||||
t.mutex.RLock()
|
||||
defer t.mutex.RUnlock()
|
||||
data := t.data
|
||||
return data.dirty
|
||||
}
|
||||
*/
|
||||
|
||||
func (t *switchTable) DEBUG_dumpTable() {
|
||||
//data := t.data.Load().(*tabledata)
|
||||
t.mutex.RLock()
|
||||
defer t.mutex.RUnlock()
|
||||
data := t.data
|
||||
for _, peer := range data.peers {
|
||||
//fmt.Println("DUMPTABLE:", t.treeID, peer.treeID, peer.port,
|
||||
// peer.locator.Root, peer.coords,
|
||||
// peer.reverse.Root, peer.reverse.Coords, peer.forward)
|
||||
fmt.Println("DUMPTABLE:", t.key, peer.key, peer.locator.coords, peer.port /*, peer.forward*/)
|
||||
}
|
||||
}
|
||||
|
||||
func (t *switchTable) DEBUG_getReversePort(port switchPort) switchPort {
|
||||
// Returns Port(0) if it cannot get the reverse peer for any reason
|
||||
//data := t.data.Load().(*tabledata)
|
||||
t.mutex.RLock()
|
||||
defer t.mutex.RUnlock()
|
||||
data := t.data
|
||||
if port >= switchPort(len(data.peers)) {
|
||||
return switchPort(0)
|
||||
}
|
||||
pinfo := data.peers[port]
|
||||
if len(pinfo.locator.coords) < 1 {
|
||||
return switchPort(0)
|
||||
}
|
||||
return pinfo.locator.coords[len(pinfo.locator.coords)-1]
|
||||
}
|
||||
|
||||
// Wire
|
||||
|
||||
func DEBUG_wire_encode_coords(coords []byte) []byte {
|
||||
return wire_encode_coords(coords)
|
||||
}
|
||||
|
||||
// DHT, via core
|
||||
|
||||
func (c *Core) DEBUG_getDHTSize() int {
|
||||
var total int
|
||||
phony.Block(&c.router, func() {
|
||||
total = len(c.router.dht.table)
|
||||
})
|
||||
return total
|
||||
}
|
||||
|
||||
// TUN defaults
|
||||
|
||||
func (c *Core) DEBUG_GetTUNDefaultIfName() string {
|
||||
return defaults.GetDefaults().DefaultIfName
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_GetTUNDefaultIfMTU() int {
|
||||
return defaults.GetDefaults().DefaultIfMTU
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_GetTUNDefaultIfTAPMode() bool {
|
||||
return defaults.GetDefaults().DefaultIfTAPMode
|
||||
}
|
||||
|
||||
// udpInterface
|
||||
// FIXME udpInterface isn't exported
|
||||
// So debug functions need to work differently...
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_setupLoopbackUDPInterface() {
|
||||
iface := udpInterface{}
|
||||
iface.init(c, "[::1]:0")
|
||||
c.ifaces = append(c.ifaces[:0], &iface)
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_getLoopbackAddr() net.Addr {
|
||||
iface := c.ifaces[0]
|
||||
return iface.sock.LocalAddr()
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_addLoopbackPeer(addr *net.UDPAddr,
|
||||
in (chan<- []byte),
|
||||
out (<-chan []byte)) {
|
||||
iface := c.ifaces[0]
|
||||
iface.addPeer(addr, in, out)
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_startLoopbackUDPInterface() {
|
||||
iface := c.ifaces[0]
|
||||
go iface.reader()
|
||||
for addr, chs := range iface.peers {
|
||||
udpAddr, err := net.ResolveUDPAddr("udp6", addr)
|
||||
if err != nil { panic(err) }
|
||||
go iface.writer(udpAddr, chs.out)
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func (c *Core) DEBUG_getAddr() *address.Address {
|
||||
return address.AddrForNodeID(&c.router.dht.nodeID)
|
||||
}
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_startTun(ifname string, iftapmode bool) {
|
||||
c.DEBUG_startTunWithMTU(ifname, iftapmode, 1280)
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_startTunWithMTU(ifname string, iftapmode bool, mtu int) {
|
||||
addr := c.DEBUG_getAddr()
|
||||
straddr := fmt.Sprintf("%s/%v", net.IP(addr[:]).String(), 8*len(address.GetPrefix()))
|
||||
if ifname != "none" {
|
||||
err := c.router.tun.setup(ifname, iftapmode, straddr, mtu)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
c.log.Println("Setup TUN/TAP:", c.router.tun.iface.Name(), straddr)
|
||||
go func() { panic(c.router.tun.read()) }()
|
||||
}
|
||||
go func() { panic(c.router.tun.write()) }()
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_stopTun() {
|
||||
c.router.tun.close()
|
||||
}
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func (c *Core) DEBUG_newBoxKeys() (*crypto.BoxPubKey, *crypto.BoxPrivKey) {
|
||||
return crypto.NewBoxKeys()
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_getSharedKey(myPrivKey *crypto.BoxPrivKey, othersPubKey *crypto.BoxPubKey) *crypto.BoxSharedKey {
|
||||
return crypto.GetSharedKey(myPrivKey, othersPubKey)
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_newSigKeys() (*crypto.SigPubKey, *crypto.SigPrivKey) {
|
||||
return crypto.NewSigKeys()
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_getNodeID(pub *crypto.BoxPubKey) *crypto.NodeID {
|
||||
return crypto.GetNodeID(pub)
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_getTreeID(pub *crypto.SigPubKey) *crypto.TreeID {
|
||||
return crypto.GetTreeID(pub)
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_addrForNodeID(nodeID *crypto.NodeID) string {
|
||||
return net.IP(address.AddrForNodeID(nodeID)[:]).String()
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_init(bpub []byte,
|
||||
bpriv []byte,
|
||||
spub []byte,
|
||||
spriv []byte) {
|
||||
/*var boxPub crypto.BoxPubKey
|
||||
var boxPriv crypto.BoxPrivKey
|
||||
var sigPub crypto.SigPubKey
|
||||
var sigPriv crypto.SigPrivKey
|
||||
copy(boxPub[:], bpub)
|
||||
copy(boxPriv[:], bpriv)
|
||||
copy(sigPub[:], spub)
|
||||
copy(sigPriv[:], spriv)
|
||||
c.init(&boxPub, &boxPriv, &sigPub, &sigPriv)*/
|
||||
hbpub := hex.EncodeToString(bpub[:])
|
||||
hbpriv := hex.EncodeToString(bpriv[:])
|
||||
hspub := hex.EncodeToString(spub[:])
|
||||
hspriv := hex.EncodeToString(spriv[:])
|
||||
cfg := config.NodeConfig{
|
||||
EncryptionPublicKey: hbpub,
|
||||
EncryptionPrivateKey: hbpriv,
|
||||
SigningPublicKey: hspub,
|
||||
SigningPrivateKey: hspriv,
|
||||
}
|
||||
c.config = config.NodeState{
|
||||
Current: cfg,
|
||||
Previous: cfg,
|
||||
}
|
||||
c.init()
|
||||
|
||||
if err := c.router.start(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_setupAndStartGlobalUDPInterface(addrport string) {
|
||||
if err := c.udp.init(c, addrport); err != nil {
|
||||
c.log.Println("Failed to start UDP interface:", err)
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_getGlobalUDPAddr() *net.UDPAddr {
|
||||
return c.udp.sock.LocalAddr().(*net.UDPAddr)
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_maybeSendUDPKeys(saddr string) {
|
||||
udpAddr, err := net.ResolveUDPAddr("udp", saddr)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
var addr connAddr
|
||||
addr.fromUDPAddr(udpAddr)
|
||||
c.udp.mutex.RLock()
|
||||
_, isIn := c.udp.conns[addr]
|
||||
c.udp.mutex.RUnlock()
|
||||
if !isIn {
|
||||
c.udp.sendKeys(addr)
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/*
|
||||
func (c *Core) DEBUG_addPeer(addr string) {
|
||||
err := c.admin.addPeer(addr, "")
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
*/
|
||||
/*
|
||||
func (c *Core) DEBUG_addSOCKSConn(socksaddr, peeraddr string) {
|
||||
go func() {
|
||||
dialer, err := proxy.SOCKS5("tcp", socksaddr, nil, proxy.Direct)
|
||||
if err == nil {
|
||||
conn, err := dialer.Dial("tcp", peeraddr)
|
||||
if err == nil {
|
||||
c.tcp.callWithConn(&wrappedConn{
|
||||
c: conn,
|
||||
raddr: &wrappedAddr{
|
||||
network: "tcp",
|
||||
addr: peeraddr,
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_setupAndStartGlobalTCPInterface(addrport string) {
|
||||
c.config.Listen = []string{addrport}
|
||||
if err := c.link.init(c); err != nil {
|
||||
c.log.Println("Failed to start interfaces:", err)
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_getGlobalTCPAddr() *net.TCPAddr {
|
||||
return c.link.tcp.getAddr()
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_addTCPConn(saddr string) {
|
||||
c.link.tcp.call(saddr, nil, "")
|
||||
}
|
||||
|
||||
//*/
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_startSelfPeer() {
|
||||
c.Peers.mutex.RLock()
|
||||
defer c.Peers.mutex.RUnlock()
|
||||
p := c.Peers.ports[0]
|
||||
go p.MainLoop()
|
||||
}
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_setupAndStartGlobalKCPInterface(addrport string) {
|
||||
iface := kcpInterface{}
|
||||
iface.init(c, addrport)
|
||||
c.kcp = &iface
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_getGlobalKCPAddr() net.Addr {
|
||||
return c.kcp.serv.Addr()
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_addKCPConn(saddr string) {
|
||||
c.kcp.call(saddr)
|
||||
}
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_setupAndStartAdminInterface(addrport string) {
|
||||
a := admin{}
|
||||
c.config.AdminListen = addrport
|
||||
a.init()
|
||||
c.admin = a
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_setupAndStartMulticastInterface() {
|
||||
m := multicast{}
|
||||
m.init(c)
|
||||
c.multicast = m
|
||||
m.start()
|
||||
}
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func (c *Core) DEBUG_setLogger(log *log.Logger) {
|
||||
c.log = log
|
||||
}
|
||||
|
||||
func (c *Core) DEBUG_setIfceExpr(expr *regexp.Regexp) {
|
||||
c.log.Println("DEBUG_setIfceExpr no longer implemented")
|
||||
}
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_addAllowedEncryptionPublicKey(boxStr string) {
|
||||
err := c.admin.addAllowedEncryptionPublicKey(boxStr)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
*/
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func DEBUG_simLinkPeers(p, q *peer) {
|
||||
// Sets q.out() to point to p and starts p.start()
|
||||
goWorkers := func(source, dest *peer) {
|
||||
linkOut := make(chan []byte, 1)
|
||||
source.linkOut = func(bs []byte) { linkOut <- bs }
|
||||
send := make(chan []byte, 1)
|
||||
source.out = func(bss [][]byte) {
|
||||
for _, bs := range bss {
|
||||
send <- bs
|
||||
}
|
||||
}
|
||||
go source.start()
|
||||
go func() {
|
||||
var packets [][]byte
|
||||
for {
|
||||
select {
|
||||
case packet := <-linkOut:
|
||||
packets = append(packets, packet)
|
||||
continue
|
||||
case packet := <-send:
|
||||
packets = append(packets, packet)
|
||||
phony.Block(&source.core.switchTable, func() {
|
||||
source.core.switchTable._idleIn(source.port)
|
||||
})
|
||||
continue
|
||||
default:
|
||||
}
|
||||
if len(packets) > 0 {
|
||||
phony.Block(dest, func() { dest._handlePacket(packets[0]) })
|
||||
packets = packets[1:]
|
||||
continue
|
||||
}
|
||||
select {
|
||||
case packet := <-linkOut:
|
||||
packets = append(packets, packet)
|
||||
case packet := <-send:
|
||||
packets = append(packets, packet)
|
||||
phony.Block(&source.core.switchTable, func() {
|
||||
source.core.switchTable._idleIn(source.port)
|
||||
})
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
goWorkers(p, q)
|
||||
goWorkers(q, p)
|
||||
phony.Block(&p.core.switchTable, func() {
|
||||
p.core.switchTable._idleIn(p.port)
|
||||
})
|
||||
phony.Block(&q.core.switchTable, func() {
|
||||
q.core.switchTable._idleIn(q.port)
|
||||
})
|
||||
}
|
||||
|
||||
/*
|
||||
func (c *Core) DEBUG_simFixMTU() {
|
||||
c.router.tun.mtu = 65535
|
||||
}
|
||||
*/
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
func Util_testAddrIDMask() {
|
||||
for idx := 0; idx < 16; idx++ {
|
||||
var orig crypto.NodeID
|
||||
orig[8] = 42
|
||||
for bidx := 0; bidx < idx; bidx++ {
|
||||
orig[bidx/8] |= (0x80 >> uint8(bidx%8))
|
||||
}
|
||||
addr := address.AddrForNodeID(&orig)
|
||||
nid, mask := addr.GetNodeIDandMask()
|
||||
for b := 0; b < len(mask); b++ {
|
||||
nid[b] &= mask[b]
|
||||
orig[b] &= mask[b]
|
||||
}
|
||||
if *nid != orig {
|
||||
fmt.Println(orig)
|
||||
fmt.Println(*addr)
|
||||
fmt.Println(*nid)
|
||||
fmt.Println(*mask)
|
||||
panic(idx)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user