Esempio n. 1
0
func (a AddrVer) AddrAllowed(ip string) bool {
	if utilNet.IsValidIpv6(ip) && (a == Any || a == Ipv6) {
		return true
	} else if utilNet.IsValidIpv4(ip) && (a == Any || a == Ipv4) {
		return true
	}
	return false
}
Esempio n. 2
0
func (s *Server) ipver(addr net.Addr) {
	a := addr.String()
	if utilNet.IsValidIpv6(a) {
		s.AddrVer = Ipv6
	} else if utilNet.IsValidIpv4(a) {
		s.AddrVer = Ipv4
	}
}
Esempio n. 3
0
File: dns.go Progetto: fcavani/net
func lookupHost(host string, config *dns.ClientConfig) (addrs []string, err error) {
	if utilNet.IsValidIpv4(host) || utilNet.IsValidIpv6(host) {
		return []string{host}, nil
	}
	if host == "localhost" {
		return []string{"127.0.0.1", "::1"}, nil
	}

	c := new(dns.Client)
	c.DialTimeout = DialTimeout
	c.ReadTimeout = ReadTimeout
	c.WriteTimeout = WriteTimeout
	m := new(dns.Msg)
	m.SetQuestion(dns.Fqdn(host), dns.TypeA)
	var r *dns.Msg
	for i := 0; i < len(config.Servers); i++ {
		r, _, err = c.Exchange(m, config.Servers[i]+":"+config.Port)
		if err != nil {
			continue
		}
		err = nil
	}
	if err != nil {
		return nil, e.Forward(err)
	}
	if r.Rcode != dns.RcodeSuccess {
		return nil, e.New("can't resolve %v", host)
	}

	addrs = make([]string, 0, 10)
	for _, a := range r.Answer {
		if addr, ok := a.(*dns.A); ok {
			addrs = append(addrs, addr.A.String())
		}
	}

	m.SetQuestion(dns.Fqdn(host), dns.TypeAAAA)
	for i := 0; i < len(config.Servers); i++ {
		r, _, err = c.Exchange(m, config.Servers[0]+":"+config.Port)
		if err != nil {
			continue
		}
		err = nil
	}
	if err != nil {
		return nil, e.Forward(err)
	}
	if r.Rcode != dns.RcodeSuccess {
		return nil, e.New("no success")
	}

	for _, a := range r.Answer {
		if addr, ok := a.(*dns.AAAA); ok {
			addrs = append(addrs, addr.AAAA.String())
		}
	}
	return
}
Esempio n. 4
0
func ipport(in, ip, port string) (string, error) {
	if utilNet.IsValidIpv4(ip) {
		return ip + ":" + port, nil
	} else if utilNet.IsValidIpv6(ip) {
		return "[" + ip + "%" + in + "]:" + port, nil
	} else {
		return "", e.New("invalid ip address")
	}
}
Esempio n. 5
0
File: dns.go Progetto: fcavani/net
func LookupIp(ip string) (host string, err error) {
	if !utilNet.IsValidIpv4(ip) && !utilNet.IsValidIpv6(ip) {
		return "", e.New("not a valid ip address")
	}
	if ip == "127.0.0.1" || ip == "::1" {
		return "localhost", nil
	}
	config, err := dns.ClientConfigFromFile(ConfigurationFile)
	if err != nil {
		return "", e.Forward(err)
	}
	config.Timeout = Timeout

	c := new(dns.Client)
	c.DialTimeout = DialTimeout
	c.ReadTimeout = ReadTimeout
	c.WriteTimeout = WriteTimeout
	m := new(dns.Msg)
	rev, err := dns.ReverseAddr(ip)
	if err != nil {
		return "", e.Forward(err)
	}
	m.SetQuestion(rev, dns.TypePTR)
	var r *dns.Msg
	for i := 0; i < len(config.Servers); i++ {
		r, _, err = c.Exchange(m, config.Servers[i]+":"+config.Port)
		if err != nil {
			continue
		}
		err = nil
	}
	if err != nil {
		return "", e.Forward(err)
	}
	if r.Rcode != dns.RcodeSuccess {
		return "", e.New("can't resolve %v", ip)
	}

	for _, a := range r.Answer {
		if ptr, ok := a.(*dns.PTR); ok {
			return strings.TrimSuffix(ptr.Ptr, "."), nil
		}
	}
	return "", e.New("no ptr available")
}
Esempio n. 6
0
func broadcast(addr net.Addr, port string) (*net.UDPAddr, error) {
	p, err := strconv.ParseInt(port, 10, 32)
	if err != nil {
		return nil, e.New(err)
	}
	udpAddr := &net.UDPAddr{Port: int(p)}
	a, ok := addr.(*net.UDPAddr)
	if !ok {
		return nil, e.New("addr isn't an *UDPAddr")
	}
	if utilNet.IsValidIpv4(a.IP.String()) {
		udpAddr.IP = net.IPv4bcast
	} else if utilNet.IsValidIpv6(a.IP.String()) {
		udpAddr.IP = net.IPv6linklocalallnodes
		udpAddr.Zone = a.Zone
	} else {
		return nil, e.New("invalid ip address")
	}
	return udpAddr, nil
}
Esempio n. 7
0
func (c *Client) multicast(addr net.Addr) (*net.UDPAddr, error) {
	host, _, err := utilNet.SplitHostPort(addr.String())
	if err != nil {
		return nil, e.Forward(err)
	}
	if utilNet.IsValidIpv4(host) {
		addr, err := net.ResolveUDPAddr("udp", c.McIpv4+":"+c.Port)
		if err != nil {
			return nil, e.Forward(err)
		}
		return addr, nil
	} else if utilNet.IsValidIpv6(host) {
		addr, err := net.ResolveUDPAddr("udp", c.McIpv6+":"+c.Port)
		if err != nil {
			return nil, e.Forward(err)
		}
		return addr, nil
	} else {
		return nil, e.New("invalid ip address")
	}
}
Esempio n. 8
0
func (a *Server) haveIpv6() (bool, error) {
	ipv4 := false
	addrs, err := a.iface.Addrs()
	if err != nil {
		return false, e.New(err)
	}
	for _, addr := range addrs {
		a := addr.String()
		i := strings.Index(a, "/")
		if i != -1 {
			a = a[:i]
		}
		if utilNet.IsValidIpv6(a) {
			return true, nil
		} else if utilNet.IsValidIpv4(a) {
			ipv4 = true
		}
	}
	if ipv4 {
		return false, nil
	}
	return false, e.New("no valid ip address")
}