func TryConnect(h string, networkSecret *secure.NetworkSecret, ln *LocalNode) (*RemoteNode, error) { host, portStr, errSplit := net.SplitHostPort(h) if errSplit != nil { return nil, errSplit } port, errConvert := strconv.Atoi(portStr) if errConvert != nil { return nil, errConvert } rn := new(RemoteNode) rn.lastHeartbeat = time.Now() rn.publicAddress = fmt.Sprintf("%s:%d", host, port+1) rn.logger = log.L(fmt.Sprintf("public %s", rn.publicAddress)) rn.logger.Debug("trying to connect...") s, errSocket := utp.NewSocket("udp4", ":0") if errSocket != nil { rn.logger.Error("unable to crete a socket, %v", errSocket) return nil, errSocket } conn, errDial := s.DialTimeout(rn.publicAddress, 10*time.Second) if errDial != nil { rn.logger.Error("unable to dial, %s", errDial) return nil, errDial } rn.conn = conn rn.sessionKey = RandomBytes(16) if err := protocol.WriteEncodeHandshake(rn.conn, rn.sessionKey, networkSecret); err != nil { return nil, err } if _, okError := protocol.ReadDecodeOk(rn.conn); okError != nil { return nil, okError } peerInfo, errPeerInfo := protocol.ReadDecodePeerInfo(rn.conn) if errPeerInfo != nil { return nil, errPeerInfo } rn.privateIP = peerInfo.PrivateIP() // create new logger log.RemoveLogger(rn.logger.Name()) rn.logger = log.L(fmt.Sprintf(rnLoggerFormat, rn.privateIP.String())) if err := protocol.WriteEncodePeerInfo(rn.conn, ln.State().PrivateIP); err != nil { return nil, err } rn.logger.Info("connected, with public address %q", rn.publicAddress) return rn, nil }
func NewLocalNode(cfg *Config) (*LocalNode, error) { var err error n := new(LocalNode) n.logger = log.L("local") n.secret, err = secure.NetworkSecretUnmarshal(cfg.SecretKey) if err != nil { return nil, err } n.config = cfg n.config.NetworkID = n.secret.InfoHash() n.state = NewState(n.secret) n.services = make(map[string]Service) n.AddService(&NetTable{}) n.AddService(&ListenerService{}) n.AddService(&DiscoveryDHT{}) n.AddService(&InterfaceService{}) //n.AddService(&STUNService{}) n.AddService(&UPnPService{}) n.AddService(&HttpService{}) return n, nil }
func (nt *NetTable) Init(ln *LocalNode) error { nt.logger = log.L(nt.Name()) nt.localNode = ln nt.dhtInChan = make(chan string, 10) nt.blackList = make(map[string]time.Time) nt.peers = make(map[string]*RemoteNode) return nil }
func NewRemoteNode(conn net.Conn, sessionKey []byte, privateIP net.IP) *RemoteNode { return &RemoteNode{ conn: conn, sessionKey: sessionKey, privateIP: privateIP, publicAddress: conn.RemoteAddr().String(), logger: log.L(fmt.Sprintf(rnLoggerFormat, privateIP.String())), lastHeartbeat: time.Now(), } }
func (l *ListenerService) Init(ln *LocalNode) error { l.logger = log.L(l.Name()) port := ln.State().ListenPort + 1 l.logger.Info("listening on %d port", port) socket, err := utp.NewSocket("udp4", fmt.Sprintf("0.0.0.0:%d", port)) if err != nil { return err } l.localNode = ln l.socket = socket return nil }
func (is *InterfaceService) Init(ln *LocalNode) (err error) { is.logger = log.L(is.Name()) is.ln = ln is.netTable = ln.NetTable() netSize, _ := ln.State().Secret.Net.Mask.Size() IPAddress := fmt.Sprintf("%s/%s", ln.State().PrivateIP, strconv.Itoa(netSize)) if is.instance, err = network.CreateTunInterfaceWithIp("", IPAddress); err != nil { return err } if err = network.SetMTU(is.instance.Name(), 1400); err != nil { is.logger.Warning("unable to set mtu, %v", err) } return nil }
const ( TypeHandshake uint8 = iota TypeOk TypeHeartbeat TypeTransfer TypePeerInfo ) const ( CurrentVersion = 1 bodyVectorLen = 16 ) var ( logger = log.L("proto") ErrorUnableToReadVector = errors.New("unable to read vector") ErrorUnableToReadMessage = errors.New("unable to read message") ErrorUnknownType = errors.New("unknown type") knownTypes = []uint8{ TypeHandshake, TypeOk, TypeHeartbeat, TypeTransfer, TypePeerInfo, } ) type (
func (s *UPnPService) Init(ln *LocalNode) error { s.logger = log.L(s.Name()) s.mapping = new(upnp.Upnp) s.port = ln.State().ListenPort + 1 return nil }
func (s *STUNService) Init(ln *LocalNode) error { s.logger = log.L(s.Name()) s.client = stun.NewClient() s.client.SetServerAddr(STUNAddress) return nil }
func (d *DiscoveryDHT) Init(ln *LocalNode) error { d.logger = log.L(d.Name()) d.localNode = ln d.stopChan = make(chan bool) return nil }