func (t *transport) handleSkipSuccessor(ch *e3x.Channel) {
var (
err error
stream io.ReadWriteCloser
req struct {
Target string
Self *completeVnode
}
)
defer ch.Close()
stream = newStream(ch)
err = json.NewDecoder(stream).Decode(&req)
if err != nil {
// log
// tracef("(SkipSuccessor) error: %s", err)
return
}
rpc := t.lookupRPC(req.Target)
if rpc == nil {
// log
// tracef("(SkipSuccessor) error: %s", "no RPC")
return
}
err = rpc.SkipSuccessor(t.internalVnode(req.Self))
if err != nil {
// log
// tracef("(SkipSuccessor) error: %s", err)
return
}
}
func (t *transport) handleListVnodes(ch *e3x.Channel) {
var (
err error
res []*completeVnode
)
defer ch.Close()
_, err = ch.ReadPacket()
if err != nil {
// log error
// tracef("error: %s", err)
return
}
for _, rpc := range t.localVnodes {
res = append(res, t.completeVnode(rpc.vn))
}
err = json.NewEncoder(newStream(ch)).Encode(&res)
if err != nil {
// log error
// tracef("error: %s", err)
return
}
// tracef("handle.ListVnodes() => %s", res)
}
// Gets a list of the vnodes on the box
func (t *transport) ListVnodes(hn string) ([]*chord.Vnode, error) {
var (
addr *e3x.Addr
ch *e3x.Channel
res []*completeVnode
err error
)
addr = t.lookupAddr(hashname.H(hn))
if addr == nil {
return nil, e3x.ErrNoAddress
}
ch, err = t.e.Open(addr, "chord.list", true)
if err != nil {
return nil, err
}
defer ch.Close()
// ch.SetReadDeadline(time.Now().Add(30*time.Second))
// ch.SetWriteDeadline(time.Now().Add(30*time.Second))
err = ch.WritePacket(&lob.Packet{})
if err != nil {
return nil, err
}
err = json.NewDecoder(newStream(ch)).Decode(&res)
if err != nil {
return nil, err
}
return t.internalVnodes(res), nil
}
// Find a successor
func (t *transport) FindSuccessors(vn *chord.Vnode, n int, k []byte) ([]*chord.Vnode, error) {
var (
addr *e3x.Addr
ch *e3x.Channel
stream io.ReadWriteCloser
res []*completeVnode
err error
req = struct {
Target string
N int
K []byte
}{vn.String(), n, k}
)
// tracef("FindSuccessors(target:Vnode(%q))", vn.String())
addr = t.lookupAddr(hashname.H(vn.Host))
if addr == nil {
return nil, e3x.ErrNoAddress
}
ch, err = t.e.Open(addr, "chord.successors.find", true)
if err != nil {
return nil, err
}
defer ch.Close()
// ch.SetReadDeadline(time.Now().Add(30*time.Second))
// ch.SetWriteDeadline(time.Now().Add(30*time.Second))
stream = newStream(ch)
err = json.NewEncoder(stream).Encode(&req)
if err != nil {
// tracef("(FindSuccessors) error: %s", err)
return nil, err
}
err = json.NewDecoder(stream).Decode(&res)
if err != nil {
// tracef("(FindSuccessors) error: %s", err)
return nil, err
}
return t.internalVnodes(res), nil
}
func (t *transport) handleNotify(ch *e3x.Channel) {
var (
err error
stream io.ReadWriteCloser
req struct {
Target string
Self *completeVnode
}
vnodes []*chord.Vnode
res []*completeVnode
)
defer ch.Close()
stream = newStream(ch)
err = json.NewDecoder(stream).Decode(&req)
if err != nil {
// log
// tracef("(Notify) error: %s", err)
return
}
rpc := t.lookupRPC(req.Target)
if rpc == nil {
// log
// tracef("(Notify) error: %s", "no RPC")
return
}
vnodes, err = rpc.Notify(t.internalVnode(req.Self))
if err != nil {
// log
// tracef("(Notify) error: %s", err)
return
}
res = t.completeVnodes(vnodes)
err = json.NewEncoder(stream).Encode(&res)
if err != nil {
// log
// tracef("(Notify) error: %s", err)
return
}
// tracef("handle.Notify(target:Vnode(%q), self:Vnode(%q)) => []Vnode(%v)", req.Target, req.Self.Id, res)
}
func (rt *RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
var (
hashname = hashname.H(req.URL.Host)
c *e3x.Channel
resp *http.Response
err error
)
x := rt.Endpoint.GetExchange(hashname)
if x == nil {
return nil, e3x.UnreachableEndpointError(hashname)
}
c, err = x.Open("thtp", true)
if err != nil {
c.Close()
return nil, err
}
err = rt.writeRequest(req, c)
if err != nil {
c.Close()
return nil, err
}
resp, err = rt.readResponse(c)
if err != nil {
c.Close()
return nil, err
}
resp.Request = req
return resp, nil
}
func (t *transport) handleGetPredecessor(ch *e3x.Channel) {
var (
err error
pkt *lob.Packet
id string
vnode *chord.Vnode
res *completeVnode
)
defer ch.Close()
pkt, err = ch.ReadPacket()
if err != nil {
// log error
// tracef("error: %s", err)
return
}
id, _ = pkt.Header().GetString("vn")
rpc := t.lookupRPC(id)
if rpc == nil {
// log
// tracef("error: %s", "no RPC")
return
}
vnode, err = rpc.GetPredecessor()
if err != nil {
// log
// tracef("error: %s", err)
return
}
res = t.completeVnode(vnode)
err = json.NewEncoder(newStream(ch)).Encode(&res)
if err != nil {
// log
// tracef("error: %s", err)
return
}
if res != nil {
// tracef("handle.GetPredecessor(Vnode(%q)) => Vnode(%q)", id, res.Id)
}
}
// Notify our successor of ourselves
func (t *transport) Notify(target, self *chord.Vnode) ([]*chord.Vnode, error) {
var (
addr *e3x.Addr
ch *e3x.Channel
stream io.ReadWriteCloser
res []*completeVnode
err error
req = struct {
Target string
Self *completeVnode
}{target.String(), t.completeVnode(self)}
)
addr = t.lookupAddr(hashname.H(target.Host))
if addr == nil {
return nil, e3x.ErrNoAddress
}
ch, err = t.e.Open(addr, "chord.notify", true)
if err != nil {
return nil, err
}
defer ch.Close()
// ch.SetReadDeadline(time.Now().Add(30*time.Second))
// ch.SetWriteDeadline(time.Now().Add(30*time.Second))
stream = newStream(ch)
err = json.NewEncoder(stream).Encode(&req)
if err != nil {
return nil, err
}
err = json.NewDecoder(stream).Decode(&res)
if err != nil {
return nil, err
}
// tracef("Notify(target:Vnode(%q), self:Vnode(%q)) => []Vnode(%v)", target.String(), self.String(), res)
return t.internalVnodes(res), nil
}
// Request a nodes predecessor
func (t *transport) GetPredecessor(vn *chord.Vnode) (*chord.Vnode, error) {
var (
addr *e3x.Addr
ch *e3x.Channel
pkt *lob.Packet
res *completeVnode
err error
)
addr = t.lookupAddr(hashname.H(vn.Host))
if addr == nil {
return nil, e3x.ErrNoAddress
}
ch, err = t.e.Open(addr, "chord.predecessor.get", true)
if err != nil {
return nil, err
}
defer ch.Close()
// ch.SetReadDeadline(time.Now().Add(30*time.Second))
// ch.SetWriteDeadline(time.Now().Add(30*time.Second))
pkt = &lob.Packet{}
pkt.Header().SetString("vn", vn.String())
err = ch.WritePacket(pkt)
if err != nil {
return nil, err
}
err = json.NewDecoder(newStream(ch)).Decode(&res)
if err != nil {
return nil, err
}
if res != nil {
// tracef("GetPredecessor(Vnode(%q)) => Vnode(%q)", vn.String(), res.Id)
}
return t.internalVnode(res), nil
}
func (t *transport) handleFindSuccessors(ch *e3x.Channel) {
var (
err error
stream io.ReadWriteCloser
req struct {
Target string
N int
K []byte
}
res []*chord.Vnode
)
defer ch.Close()
stream = newStream(ch)
err = json.NewDecoder(stream).Decode(&req)
if err != nil {
// log
// tracef("(FindSuccessors) error: %s", err)
return
}
rpc := t.lookupRPC(req.Target)
if rpc != nil {
res, err = rpc.FindSuccessors(req.N, req.K)
if err != nil {
// log
// tracef("(FindSuccessors) error: %s", err)
return
}
}
err = json.NewEncoder(stream).Encode(t.completeVnodes(res))
if err != nil {
// log
// tracef("(FindSuccessors) error: %s", err)
return
}
}
func (t *transport) handlePing(ch *e3x.Channel) {
var (
err error
pkt *lob.Packet
id string
alive bool
)
defer ch.Close()
pkt, err = ch.ReadPacket()
if err != nil {
// log error
// tracef("error: %s", err)
return
}
id, _ = pkt.Header().GetString("vn")
rpc := t.lookupRPC(id)
if rpc == nil {
alive = false
} else {
alive = true
}
pkt = &lob.Packet{}
pkt.Header().SetBool("alive", alive)
err = ch.WritePacket(pkt)
if err != nil {
// log error
// tracef("error: %s", err)
return
}
}
func (mod *module) serveTelehash(c *e3x.Channel) {
defer c.Close()
defer func() {
if err := recover(); err != nil {
const size = 64 << 10
buf := make([]byte, size)
buf = buf[:runtime.Stack(buf, false)]
mod.logf("thtp: panic serving %s: %v\n%s", c.RemoteHashname(), err, buf)
}
}()
req, err := mod.readRequest(c)
if err != nil {
return
}
rw := newResponseWriter(c)
defer rw.Flush()
mod.handler.ServeHTTP(rw, req)
}
func (mod *module) handlePathRequest(c *e3x.Channel) {
defer c.Kill()
pkt, err := c.ReadPacket()
if err != nil {
return // ignore
}
// decode paths known by peer and add them as candidates
if header, found := pkt.Header().Get("paths"); found {
data, err := json.Marshal(header)
if err != nil {
return // ignore
}
var entries []json.RawMessage
err = json.Unmarshal(data, &entries)
if err != nil {
return // ignore
}
for _, entry := range entries {
addr, err := transports.DecodeAddr(entry)
if err != nil {
}
if err == nil {
c.Exchange().AddPathCandidate(addr)
}
}
}
var pipes = c.Exchange().KnownPipes()
for _, pipe := range pipes {
pkt := &lob.Packet{}
pkt.Header().Set("path", pipe.RemoteAddr())
c.WritePacketTo(pkt, pipe)
}
}
// Instructs a node to skip a given successor. Used to leave.
func (t *transport) SkipSuccessor(target, self *chord.Vnode) error {
var (
addr *e3x.Addr
ch *e3x.Channel
stream io.ReadWriteCloser
err error
req = struct {
Target string
Self *completeVnode
}{target.String(), t.completeVnode(self)}
)
addr = t.lookupAddr(hashname.H(target.Host))
if addr == nil {
return e3x.ErrNoAddress
}
ch, err = t.e.Open(addr, "chord.successor.skip", true)
if err != nil {
return err
}
defer ch.Close()
// ch.SetReadDeadline(time.Now().Add(30*time.Second))
// ch.SetWriteDeadline(time.Now().Add(30*time.Second))
stream = newStream(ch)
err = json.NewEncoder(stream).Encode(&req)
if err != nil {
return err
}
return nil
}
// Ping a Vnode, check for liveness
func (t *transport) Ping(vn *chord.Vnode) (bool, error) {
var (
addr *e3x.Addr
ch *e3x.Channel
pkt *lob.Packet
alive bool
err error
)
addr = t.lookupAddr(hashname.H(vn.Host))
if addr == nil {
return false, e3x.ErrNoAddress
}
ch, err = t.e.Open(addr, "chord.ping", true)
if err != nil {
return false, err
}
defer ch.Close()
// ch.SetReadDeadline(time.Now().Add(30*time.Second))
// ch.SetWriteDeadline(time.Now().Add(30*time.Second))
pkt = &lob.Packet{}
pkt.Header().SetString("vn", vn.String())
err = ch.WritePacket(pkt)
if err != nil {
return false, err
}
pkt, err = ch.ReadPacket()
if err != nil {
return false, err
}
alive, _ = pkt.Header().GetBool("alive")
// tracef("Ping(Vnode(%q)) => %v", vn.String(), alive)
return alive, nil
}
func (d *dht) handle_see(c *e3x.Channel) {
defer c.Close()
pkt, err := c.ReadPacket()
if err != nil {
return
}
key, ok := pkt.Header().GetString("key")
if !ok {
return
}
h := d.localLookup(key)
pkt = &lob.Packet{}
pkt.Header().Set("see", h)
pkt.Header().SetBool("end", true)
err = c.WritePacket(pkt)
if err != nil {
return
}
}
func (mod *module) handle_connect(ch *e3x.Channel) {
defer ch.Kill()
var (
from hashname.H
localIdent *e3x.Identity
remoteIdent *e3x.Identity
handshake cipherset.Handshake
innerData = bufpool.New()
err error
)
localIdent, err = mod.e.LocalIdentity()
if err != nil {
return
}
pkt, err := ch.ReadPacket()
if err != nil {
return
}
pkt.Body(innerData.SetLen(pkt.BodyLen()).RawBytes()[:0])
inner, err := lob.Decode(innerData)
if err != nil {
return
}
innerHdr := inner.Header()
if innerHdr.IsBinary() && len(innerHdr.Bytes) == 1 {
// handshake
var (
csid = innerHdr.Bytes[0]
key = localIdent.Keys()[csid]
)
if key == nil {
return
}
handshake, err = cipherset.DecryptHandshake(csid, key, inner.Body(nil))
if err != nil {
return
}
from, err = hashname.FromIntermediates(handshake.Parts())
if err != nil {
return
}
remoteIdent, err = e3x.NewIdentity(cipherset.Keys{
handshake.CSID(): handshake.PublicKey(),
}, handshake.Parts(), nil)
if err != nil {
return
}
} else {
// key packet
var parts = make(cipherset.Parts)
var csid uint8
for key, value := range inner.Header().Extra {
if len(key) != 2 {
continue
}
keyData, err := hex.DecodeString(key)
if err != nil {
continue
}
partCSID := keyData[0]
switch v := value.(type) {
case bool:
csid = partCSID
case string:
parts[partCSID] = v
}
}
hn, err := hashname.FromKeyAndIntermediates(csid, inner.Body(nil), parts)
if err != nil {
return
}
from = hn
pubKey, err := cipherset.DecodeKeyBytes(csid, inner.Body(nil), nil)
if err != nil {
return
}
remoteIdent, err = e3x.NewIdentity(cipherset.Keys{csid: pubKey}, parts, nil)
if err != nil {
return
}
}
if from == "" {
return
}
if mod.config.AllowConnect != nil && !mod.config.AllowConnect(from, ch.RemoteHashname()) {
return
}
x, err := mod.e.CreateExchange(remoteIdent)
if err != nil {
return
}
// when the BODY contains a handshake
if handshake != nil {
routerExchange := ch.Exchange()
routerAddr := &peerAddr{
router: routerExchange.RemoteHashname(),
}
conn := newConnection(x.RemoteHashname(), routerAddr, routerExchange, func() {
mod.unregisterConnection(routerExchange, x.LocalToken())
})
pipe, added := x.AddPipeConnection(conn, nil)
if added {
mod.registerConnection(routerExchange, x.LocalToken(), conn)
}
resp, ok := x.ApplyHandshake(handshake, pipe)
if !ok {
return
}
if resp != nil {
err = mod.peerVia(ch.Exchange(), from, resp)
if err != nil {
return
}
}
}
// when the BODY contains a key packet
if handshake == nil {
pkt, err := x.GenerateHandshake()
if err != nil {
return
}
err = mod.peerVia(ch.Exchange(), from, pkt)
if err != nil {
return
}
}
// Notify on-exchange callbacks
mod.getIntroduction(from).resolve(x, nil)
}
func (mod *module) handle_peer(ch *e3x.Channel) {
defer ch.Kill()
log := mod.log.From(ch.RemoteHashname()).To(mod.e.LocalHashname())
// MUST allow router role
if mod.config.DisableRouter {
log.Println("drop: router disabled")
return
}
pkt, err := ch.ReadPacket()
if err != nil {
log.Printf("drop: failed to read packet: %s", err)
return
}
peerStr, ok := pkt.Header().GetString("peer")
if !ok {
log.Printf("drop: no peer in packet")
return
}
peer := hashname.H(peerStr)
// MUST have link to either endpoint
if mod.e.GetExchange(ch.RemoteHashname()) == nil && mod.e.GetExchange(peer) == nil {
log.Printf("drop: no link to either peer")
return
}
// MUST pass firewall
if mod.config.AllowPeer != nil && !mod.config.AllowPeer(ch.RemoteHashname(), peer) {
log.Printf("drop: blocked by firewall")
return
}
ex := mod.e.GetExchange(peer)
if ex == nil {
log.Printf("drop: no exchange to target")
// resolve?
return
}
token := cipherset.ExtractToken(pkt.Body(nil))
if token != cipherset.ZeroToken {
// add bridge back to requester
mod.RouteToken(token, ch.Exchange())
}
mod.connect(ex, bufpool.New().Set(pkt.Body(nil)))
}