Golang net.LookupAddr函數代碼示例

func (x *Imp) Defined(s string) bool {
	//
	x.Clr()
	if x.fmt == Hostname {
		if ip, err := net.LookupHost(s); err == nil {
			x.ip = net.ParseIP(ip[0]) // default
			for _, n := range ip {    // get first IPv4-number, if such exists
				if len(n) == 4 {
					x.ip = net.ParseIP(n)
					break
				}
			}
			if h, err1 := net.LookupAddr(s); err1 == nil {
				x.name = h
			} else {
				x.name = []string{s}
			}
			return true
		}
	} else { // x.fmt == IPnumber
		if h, err := net.LookupAddr(s); err == nil {
			x.ip = net.ParseIP(s)
			x.name = h
			return true
		}
	}
	return false
}

// Return the current machines fully qualified domain name.
func Fqdn() (string, error) {
	hostname, err := os.Hostname()
	if err != nil {
		return "", err
	}

	addrs, err := net.LookupHost(hostname)
	if err != nil {
		return "", err
	}

	for _, addr := range addrs {
		names, err := net.LookupAddr(addr)
		if err != nil {
			return "", err
		}
		for _, name := range names {
			if strings.Contains(name, ".") {
				return name, nil
			}
		}
	}

	return hostname, nil
}

// ServeHTTP is an http.Handler ServeHTTP method
func (h *bandwidthQuotaHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	host, _, _ := net.SplitHostPort(req.RemoteAddr)
	longIP := longIP{net.ParseIP(host)}.IptoUint32()
	if h.quotas.WillExceedQuota(longIP, req.ContentLength) {
		hosts, _ := net.LookupAddr(uint32ToIP(longIP).String())
		log.Debug.Printf("Offending Host: %s, BandwidthUsed: %d", hosts, h.quotas.GetQuotaUsed(longIP))
		writeErrorResponse(w, req, BandWidthInsufficientToProceed, req.URL.Path)
		return
	}
	qr := &quotaReader{
		ReadCloser: req.Body,
		quotas:     h.quotas,
		ip:         longIP,
		w:          w,
		req:        req,
		lock:       &sync.RWMutex{},
	}
	req.Body = qr
	w = &quotaWriter{
		ResponseWriter: w,
		quotas:         h.quotas,
		ip:             longIP,
		quotaReader:    qr,
	}
	h.handler.ServeHTTP(w, req)
}

func (milter *milter) Connect(ctx uintptr, hostname string, ip net.IP) (sfsistat int8) {
	defer milterHandleError(ctx, &sfsistat)

	sess := &milterSession{
		id:        milterGetNewSessionId(),
		timeStart: time.Now(),
		persisted: false,
	}
	sess.Hostname = hostname
	sess.Ip = ip.String()
	sess.MtaHostName = m.GetSymVal(ctx, "j")
	sess.MtaDaemonName = m.GetSymVal(ctx, "{daemon_name}")

	if reverse, _ := net.LookupAddr(ip.String()); len(reverse) != 0 {
		sess.ReverseDns = reverse[0]
	}

	MilterDataIndex.addNewSession(sess)
	sessId := sess.getId()
	res := m.SetPriv(ctx, sessId)
	if res != 0 {
		panic(fmt.Sprintf("Session could not be stored in milterDataIndex"))
	}

	StatsCounters["MilterCallbackConnect"].increase(1)
	Log.Debug("%s Milter.Connect() called: ip = %s, hostname = %s", sess.milterGetDisplayId(), ip, sess.ReverseDns)

	return m.Continue
}

func lookupAddr(ip net.IP) ([]string, error) {
	names, err := net.LookupAddr(ip.String())
	for i, _ := range names {
		names[i] = strings.TrimRight(names[i], ".") // Always return unrooted name
	}
	return names, err
}

func TestPingMonitor(t *testing.T) {
	conn, _ := rados.NewConn()
	conn.ReadDefaultConfigFile()
	conn.Connect()

	// mon id that should work with vstart.sh
	reply, err := conn.PingMonitor("a")
	if err == nil {
		assert.NotEqual(t, reply, "")
		return
	}

	// mon id that should work with micro-osd.sh
	reply, err = conn.PingMonitor("0")
	if err == nil {
		assert.NotEqual(t, reply, "")
		return
	}

	// try to use a hostname as the monitor id
	mon_addr, _ := conn.GetConfigOption("mon_host")
	hosts, _ := net.LookupAddr(mon_addr)
	for _, host := range hosts {
		reply, err := conn.PingMonitor(host)
		if err == nil {
			assert.NotEqual(t, reply, "")
			return
		}
	}

	t.Error("Could not find a valid monitor id")

	conn.Shutdown()
}

func (a *API) requestFilter(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		ip, err := ipFromRequest(r)
		if err != nil {
			r.Header.Set(IP_HEADER, err.Error())
		} else {
			r.Header.Set(IP_HEADER, ip.String())
			country, err := a.lookupCountry(ip)
			if err != nil {
				r.Header.Set(COUNTRY_HEADER, err.Error())
			} else {
				r.Header.Set(COUNTRY_HEADER, country)
			}
		}
		hostname, err := net.LookupAddr(ip.String())
		if err != nil {
			r.Header.Set(HOSTNAME_HEADER, err.Error())
		} else {
			r.Header.Set(HOSTNAME_HEADER, strings.Join(hostname, ", "))
		}
		if a.CORS {
			w.Header().Set("Access-Control-Allow-Methods", "GET")
			w.Header().Set("Access-Control-Allow-Origin", "*")
		}
		next.ServeHTTP(w, r)
	})
}

func getIP(s string) string {
	a, err := net.LookupAddr(s)
	if err != nil {
		return ""
	}
	return a[0]
}

func LookupAddress(ip string) chan string {
	r := make(chan string)

	go func() {
		names, error := net.LookupAddr(ip)

		if error != nil {
			// Error? Use the IP.
			r <- ip
		}

		if len(names) > 0 {
			// Use the first value, but strip the leading ".".
			host := names[0]
			l := len(host)

			if host[l-1] == '.' {
				r <- host[0 : l-1]
			} else {
				r <- host
			}
		} else {
			// Use the IP
			r <- ip
		}
	}()

	return r
}

func (info *Info) SetBasicInfo(url string, response *http.Response) {
	info.Url = url
	for key, values := range response.Header {
		info.RawHeaders[key] = values
	}
	cookies := response.Cookies()
	for _, cookie := range cookies {
		info.Cookies[cookie.Name] = cookie
	}
	u, err := urlLib.Parse(url)
	if err != nil {
		panic(err)
	}
	info.Host = u.Host
	ips, err := net.LookupHost(u.Host)
	if err == nil {
		info.Ip = ips
		for _, ip := range info.Ip {
			hosts, err := net.LookupAddr(ip)
			if err == nil {
				info.RealHost = hosts
			}
		}

	}
}

func (msg milterMessage) String() []byte {
	sess := *msg.getSession()
	fqdn, err := os.Hostname()
	if err != nil {
		Log.Error("Could not determine FQDN")
		fqdn = sess.getMtaHostName()
	}
	revdns, err := net.LookupAddr(sess.getIp())
	revdnsStr := "unknown"
	if err == nil {
		revdnsStr = strings.Join(revdns, "")
	}

	body := make([]string, 0)

	body = append(body, fmt.Sprintf("Received: from %s (%s [%s])\r\n\tby %s with SMTP id %[email protected]%s; %s\r\n",
		sess.getHelo(),
		revdnsStr,
		sess.getIp(),
		fqdn,
		sess.getId(),
		fqdn,
		time.Now().Format(time.RFC1123Z)))

	for _, header := range msg.getHeaders() {
		body = append(body, (*header).getKey()+": "+(*header).getValue()+"\r\n")
	}

	body = append(body, "\r\n")
	for _, bodyChunk := range msg.getBody() {
		body = append(body, bodyChunk)
	}

	return []byte(strings.Join(body, ""))
}

func getHostNamesFromIP(ip string) ([]string, error) {
	hostNames, err := net.LookupAddr(ip)
	if err != nil {
		return nil, err
	}
	return hostNames, nil
}

func NewConn(p *PeerConnection) (*Conn, error) {
	c := &Conn{
		Host: p.Host,
		Port: p.Port,
		conn: p.Conn,
	}
	names, err := net.LookupAddr(c.Host)
	if err == nil {
		c.Resolved = names[0]
	} else {
		c.Resolved = "No reverse DNS possible"
	}
	if c.conn == nil {
		var err error
		if c.conn, err = net.DialTimeout("tcp", c.String(), peerTimeout); err != nil {
			return c, fmt.Errorf("Connect: %s", err.Error())
		}
	}
	config := &sslconn.Config{
		CipherList: defaultCipher,
	}
	if c.Conn, err = sslconn.NewConn(c.conn, c.conn, config, false); err != nil {
		return c, fmt.Errorf("Connect: %s", err.Error())
	}
	if err := c.Handshake(); err != nil {
		return c, fmt.Errorf("Connect: %s", err.Error())
	}
	return c, nil
}

func handlePost(w http.ResponseWriter, req *http.Request) {
	logRequest(req)
	author, _, _ := net.SplitHostPort(req.RemoteAddr)
	addrs, err := net.LookupAddr(author)
	if err != nil && len(addrs) > 0 {
		author = addrs[0]
	}

	title := req.FormValue("title")
	text := req.FormValue("text")
	title = strings.TrimSpace(title)
	text = strings.TrimSpace(text)
	if title == "" || text == "" {
		err = fmt.Errorf("empty title or text")
		logError(w, req, http.StatusBadRequest, err)
		return
	}
	post := Post{
		Title:  title,
		Text:   text,
		Author: author,
		When:   time.Now(),
	}
	err = savePost(post)
	if err != nil {
		logError(w, req, http.StatusInternalServerError, err)
		return
	}
	w.Write([]byte("OK"))
}

// Resolve an IP to a domain name using the system DNS settings first, then HypeDNS
func resolveIP(ip string) (hostname string, err error) {
	var try2 string

	// try the system DNS setup
	result, _ := net.LookupAddr(ip)
	if len(result) > 0 {
		goto end
	}

	// Try HypeDNS
	try2, err = reverseHypeDNSLookup(ip)
	if try2 == "" || err != nil {
		err = fmt.Errorf("Unable to resolve IP address. This is usually caused by not having a route to hypedns. Please try again in a few seconds.")
		return
	}
	result = append(result, try2)
end:
	for _, addr := range result {
		hostname = addr
	}

	// Trim the trailing period becuase it annoys me
	if hostname[len(hostname)-1] == '.' {
		hostname = hostname[:len(hostname)-1]
	}
	return
}