mirror of
https://github.com/yggdrasil-network/yggdrasil-go
synced 2024-11-10 15:30:34 +03:00
Remove legacy debug functions
This commit is contained in:
Neil Alexander
parent
881d0a1ada
commit
764f9c8e11
@ -2,20 +2,7 @@
|
|||||||
|
|
||||||
package yggdrasil
|
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 "fmt"
|
||||||
import "net"
|
|
||||||
import "regexp"
|
|
||||||
import "encoding/hex"
|
|
||||||
|
|
||||||
import _ "net/http/pprof"
|
import _ "net/http/pprof"
|
||||||
import "net/http"
|
import "net/http"
|
||||||
@ -24,13 +11,6 @@ import "os"
|
|||||||
|
|
||||||
import "github.com/gologme/log"
|
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.
|
// Start the profiler in debug builds, if the required environment variable is set.
|
||||||
func init() {
|
func init() {
|
||||||
envVarName := "PPROFLISTEN"
|
envVarName := "PPROFLISTEN"
|
||||||
@ -51,589 +31,3 @@ func StartProfiler(log *log.Logger) error {
|
|||||||
go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()
|
go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()
|
||||||
return 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