func TestServerDefaultNodeIdSecure(t *testing.T) { s, err := NewServer(nil) if err != nil { t.Fatal(err) } defer s.Close() if !nodeIdSecure(s.ID(), util.AddrIP(s.Addr())) { t.Fatal("not secure") } }
// Writes the node info to its compact binary representation in b. See // CompactNodeInfoLen. func (ni *NodeInfo) PutCompact(b []byte) error { if n := copy(b[:], ni.ID[:]); n != 20 { panic(n) } ip := util.AddrIP(ni.Addr).To4() if len(ip) != 4 { return errors.New("expected ipv4 address") } if n := copy(b[20:], ip); n != 4 { panic(n) } binary.BigEndian.PutUint16(b[24:], uint16(util.AddrPort(ni.Addr))) return nil }
// Add response nodes to node table. func (s *Server) liftNodes(d Msg) { if d["y"] != "r" { return } for _, cni := range d.Nodes() { if util.AddrPort(cni.Addr) == 0 { // TODO: Why would people even do this? continue } if s.ipBlocked(util.AddrIP(cni.Addr)) { continue } n := s.getNode(cni.Addr, string(cni.ID[:])) n.SetIDFromBytes(cni.ID[:]) } }
func TestClientTransfer(t *testing.T) { greetingTempDir, mi := testutil.GreetingTestTorrent() defer os.RemoveAll(greetingTempDir) cfg := TestingConfig cfg.Seed = true cfg.DataDir = greetingTempDir seeder, err := NewClient(&cfg) if err != nil { t.Fatal(err) } defer seeder.Close() seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi)) leecherDataDir, err := ioutil.TempDir("", "") if err != nil { t.Fatal(err) } defer os.RemoveAll(leecherDataDir) // cfg.TorrentDataOpener = func(info *metainfo.Info) (data.Data, error) { // return blob.TorrentData(info, leecherDataDir), nil // } cfg.TorrentDataOpener = blob.NewStore(leecherDataDir).OpenTorrent leecher, _ := NewClient(&cfg) defer leecher.Close() leecherGreeting, _, _ := leecher.AddTorrentSpec(func() (ret *TorrentSpec) { ret = TorrentSpecFromMetaInfo(mi) ret.ChunkSize = 2 return }()) leecherGreeting.AddPeers([]Peer{ Peer{ IP: util.AddrIP(seeder.ListenAddr()), Port: util.AddrPort(seeder.ListenAddr()), }, }) r := leecherGreeting.NewReader() defer r.Close() _greeting, err := ioutil.ReadAll(r) if err != nil { t.Fatalf("%q %s", string(_greeting), err) } greeting := string(_greeting) if greeting != testutil.GreetingFileContents { t.Fatal(":(") } }
func (s *Server) writeToNode(b []byte, node dHTAddr) (err error) { if list := s.ipBlockList; list != nil { if r := list.Lookup(util.AddrIP(node.UDPAddr())); r != nil { err = fmt.Errorf("write to %s blocked: %s", node, r.Description) return } } n, err := s.socket.WriteTo(b, node.UDPAddr()) if err != nil { err = fmt.Errorf("error writing %d bytes to %s: %#v", len(b), node, err) return } if n != len(b) { err = io.ErrShortWrite return } return }
func connRemoteAddrIP(network, laddr string, dialHost string) net.IP { l, err := net.Listen(network, laddr) if err != nil { panic(err) } go func() { c, err := net.Dial(network, net.JoinHostPort(dialHost, fmt.Sprintf("%d", util.AddrPort(l.Addr())))) if err != nil { panic(err) } defer c.Close() }() c, err := l.Accept() if err != nil { panic(err) } defer c.Close() ret := util.AddrIP(c.RemoteAddr()) return ret }
func TestResponsive(t *testing.T) { seederDataDir, mi := testutil.GreetingTestTorrent() defer os.RemoveAll(seederDataDir) cfg := TestingConfig cfg.Seed = true cfg.DataDir = seederDataDir seeder, err := NewClient(&cfg) require.Nil(t, err) defer seeder.Close() seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi)) leecherDataDir, err := ioutil.TempDir("", "") require.Nil(t, err) defer os.RemoveAll(leecherDataDir) cfg = TestingConfig cfg.DataDir = leecherDataDir leecher, err := NewClient(&cfg) require.Nil(t, err) defer leecher.Close() leecherTorrent, _, _ := leecher.AddTorrentSpec(func() (ret *TorrentSpec) { ret = TorrentSpecFromMetaInfo(mi) ret.ChunkSize = 2 return }()) leecherTorrent.AddPeers([]Peer{ Peer{ IP: util.AddrIP(seeder.ListenAddr()), Port: util.AddrPort(seeder.ListenAddr()), }, }) reader := leecherTorrent.NewReader() reader.SetReadahead(0) reader.SetResponsive() b := make([]byte, 2) _, err = reader.ReadAt(b, 3) assert.Nil(t, err) assert.EqualValues(t, "lo", string(b)) n, err := reader.ReadAt(b, 11) assert.Nil(t, err) assert.EqualValues(t, 2, n) assert.EqualValues(t, "d\n", string(b)) }
func (s *Server) serve() error { var b [0x10000]byte for { n, addr, err := s.socket.ReadFrom(b[:]) if err != nil { return err } read.Add(1) if n == len(b) { logonce.Stderr.Printf("received dht packet exceeds buffer size") continue } s.mu.Lock() blocked := s.ipBlocked(util.AddrIP(addr)) s.mu.Unlock() if blocked { readBlocked.Add(1) continue } s.processPacket(b[:n], newDHTAddr(addr)) } }
func (s *Server) setDefaults() (err error) { if s.id == "" { var id [20]byte h := crypto.SHA1.New() ss, err := os.Hostname() if err != nil { log.Print(err) } ss += s.socket.LocalAddr().String() h.Write([]byte(ss)) if b := h.Sum(id[:0:20]); len(b) != 20 { panic(len(b)) } if len(id) != 20 { panic(len(id)) } secureNodeId(id[:], util.AddrIP(s.socket.LocalAddr())) s.id = string(id[:]) } s.nodes = make(map[string]*node, maxNodes) return }
func newDHTAddr(addr net.Addr) dHTAddr { return cachedAddr{addr, addr.String(), util.AddrIP(addr)} }