Golang net.LookupCNAME函数代码示例

// NewHttpClient is the constructor for the bucket API implementation of HttpClient.
func NewHttpClient(client *http.Client, url string) (*HttpClient, error) {

	// get hostname
	hostname, err := os.Hostname()
	if err != nil {
		return nil, err
	}

	// get canonical hostname
	canonical, err := net.LookupCNAME(hostname)
	if err != nil {
		return nil, err
	}

	// get ipv4
	var ip string
	addrs, err := net.LookupIP(canonical)
	if err != nil {
		return nil, err
	}
	for _, addr := range addrs {
		if ipv4 := addr.To4(); ipv4 != nil {
			ip = ipv4.String()
		}
	}

	// create instance
	return &HttpClient{instance: client, url: url, ipv4: ip, hostname: canonical}, nil

}

//export ReturnString
func ReturnString(val string) string {
	cname, err := net.LookupCNAME(val)
	if err != nil {
		return "Could not find CNAME"
	}
	return cname
}

func (me *WorkerDaemon) report(coordinator string, port int) {
	client, err := rpc.DialHTTP("tcp", coordinator)
	if err != nil {
		log.Println("dialing coordinator:", err)
		return
	}

	hostname, err := os.Hostname()
	if err != nil {
		log.Println("hostname", err)
		return
	}

	cname, err := net.LookupCNAME(hostname)
	if err != nil {
		log.Println("cname", err)
		return
	}
	cname = strings.TrimRight(cname, ".")
	req := Registration{
		Address: fmt.Sprintf("%v:%d", cname, port),
		Name:    fmt.Sprintf("%s:%d", hostname, port),
		Version: Version(),
	}

	rep := 0
	err = client.Call("Coordinator.Register", &req, &rep)
	if err != nil {
		log.Println("coordinator rpc error:", err)
	}
}

func getOurIP() (ip string, err error) {
	hostname, err := os.Hostname()
	if err != nil {
		return
	}
	return net.LookupCNAME(hostname)
}

func (me *Worker) Report() {
	if me.options.Coordinator == "" {
		return
	}
	client, err := rpc.DialHTTP("tcp", me.options.Coordinator)
	if err != nil {
		log.Println("dialing coordinator:", err)
		return
	}

	cname, err := net.LookupCNAME(Hostname)
	if err != nil {
		log.Println("cname", err)
		return
	}
	cname = strings.TrimRight(cname, ".")
	req := Registration{
		Address: fmt.Sprintf("%v:%d", cname, me.options.Port),
		Name:    fmt.Sprintf("%s:%d", Hostname, me.options.Port),
		Version: Version(),
	}
	rep := 0
	err = client.Call("Coordinator.Register", &req, &rep)
	if err != nil {
		log.Println("coordinator rpc error:", err)
	}
}

//export ReturnString
func ReturnString(val string) *C.char {
	cname, err := net.LookupCNAME(val)
	if err != nil {
		C.CString("Could not find CNAME")
	}
	return C.CString(cname)
}

// GetCNAME resolves an IP or hostname into a normalized valid CNAME
func GetCNAME(hostname string) (string, error) {
	res, err := net.LookupCNAME(hostname)
	if err != nil {
		return hostname, err
	}
	res = strings.TrimRight(res, ".")
	return res, nil
}

func resourceDnsCnameRecordRead(d *schema.ResourceData, meta interface{}) error {
	cname, err := net.LookupCNAME(d.Id())
	if err != nil {
		return err
	}

	d.Set("cname", cname)
	return nil
}

// FullyQualifiedHostname returns the full hostname with domain
func FullyQualifiedHostname() (string, error) {
	hostname, err := os.Hostname()
	if err != nil {
		return "", err
	}

	cname, err := net.LookupCNAME(hostname)
	if err != nil {
		return "", err
	}
	return strings.TrimRight(cname, "."), nil
}

func dataSourceDnsCnameRecordRead(d *schema.ResourceData, meta interface{}) error {
	host := d.Get("host").(string)

	cname, err := net.LookupCNAME(host)
	if err != nil {
		return err
	}

	d.Set("cname", cname)
	d.SetId(host)

	return nil
}

func cname(host string) (data []byte, err error) {
	cname, err := net.LookupCNAME(host)
	if err != nil {
		err = os.ErrNotExist
		return
	}

	buf := bytes.NewBuffer(make([]byte, 0, len(cname)+1))
	buf.WriteString(cname)
	buf.WriteByte('\n')
	data = buf.Bytes()
	return
}

func lcname(domain string) {
	cname, err := net.LookupCNAME(domain)

	if err != nil {
		//fmt.Printf("err:%s\n", err)
		return
	}

	fmt.Printf("-------------------\n")
	fmt.Printf(" Information CNAME \n")
	fmt.Printf("-------------------\n")

	fmt.Printf("\t%s\n", cname)
}

// FullHostname is a best effort attempt to resolve the canonical FQDN of
// the host. On failure it will fall back to a reasonable looking default
// such as 'localhost.' or 'hostname.invalid.'
func FullHostname() string {
	hostname, err := os.Hostname()
	if err != nil || hostname == "localhost" || hostname == "(none)" {
		return "localhost."
	}
	fullname, err := net.LookupCNAME(hostname)
	if err != nil {
		fullname = hostname
		if !strings.Contains(fullname, ".") {
			fullname += ".invalid."
		}
	}
	return fullname
}

func main() {
	if len(os.Args) != 2 {
		fmt.Fprintf(os.Stderr, "Usage:%s hostname\n", os.Args[0])
		os.Exit(1)
	}
	name := os.Args[1]
	cname, err := net.LookupCNAME(name)
	if err != nil {
		fmt.Println("LookupCNAME error:", err.Error())
		os.Exit(1)
	}
	fmt.Println("The host caonical name is:", cname)
	os.Exit(0)
}

// printInfo prints a brief informative header about the connection
func printInfo(urlTarget string, resp *http.Response) {
	fmt.Println("********* This is gobble version ", version, " ***************")

	urlInfo, err := url.Parse(urlTarget)
	if err != nil {
		return
	}
	cname, _ := net.LookupCNAME(urlInfo.Host)
	ips, _ := net.LookupIP(cname)
	fmt.Println("Connecting to", cname, "  ", ips)
	fmt.Printf("Status %s   Protocol %s  TransferEncoding %v\n", resp.Status,
		resp.Proto, resp.TransferEncoding)
	fmt.Printf("Content Length: %d bytes\n", resp.ContentLength)
	fmt.Println()
}