Loading...Please purchase the course to watch this video.
Full Course
The net package in Go equips developers with powerful tools for networking, including features for DNS address lookup and reverse DNS resolution. By utilizing functions such as lookup IP, lookup addr, and lookup cname, programmers can create versatile applications for querying DNS records, making it easy to retrieve IP addresses or canonical names associated with various domains. An example project demonstrates how to build a simple command-line DNS lookup tool that allows users to input a domain name and retrieve its corresponding IP addresses efficiently. This functionality not only enhances networking capabilities but also supports the creation of advanced tools for managing and resolving network queries in Go.
No links available for this lesson.
In addition to TCP client servers, UDP client servers and other different types of networking, the net package also provides a number of other functionality when it comes to looking up addresses or DNS records. If we take a look at the documentation, you can see that these are underneath the lookup functions, such as lookup address, lookup CNAME, lookup host, lookup port and lookup TXT. There's also other functions that for some reason aren't listed on here, including looking up MX records as well. They also have a pipe function, which is pretty cool.
In order to see how these lookup functions work, let's go ahead and create a new project called DNS and use the familiar go mod init of dreamsofcode.io/DNS and we use the main.go function:
package main
import "net"
func main() {
Let's begin with a really simple DNS lookup tool where we look up the host address for a given DNS name. We can do this by using the lookup IP method, passing in the value we want to look up. Let's go ahead and set this to be google.com for the meantime and we can pull out the address and an error as follows. Of course, if there's an error, let's go ahead and handle this by logging to the fatal line function:
log.Fatalf("Failed to lookup: %v", err)
Then for the error itself, this is going to be a list of net.IP. So let's iterate over them using:
for _, x := range addr {
fmt.Println(x)
}
Now if I go ahead and run this code, you can see it gives me all of the IP addresses that are associated with the google DNS record. If we want to change this to say dreamsofcode.io, we can do so as follows and use the go run command.
This is pretty cool, but rather than us having to change the value of the function every time, let's go ahead and replace this with a call to the os.Args and take the first argument as follows. Let's import the os package. Now I can go ahead and run this by passing in dreamsofcode.io or passing in google.com, which is much easier than having a hard-coded string that we would need to change in order to test out the different IP functions.
With that, we have a really simple DNS lookup tool. For example, I can go ahead and do youtube.com or even cloudflare.com.
As well as looking up IPs, we can also do a reverse DNS lookup by looking up addresses using the lookup addr function. Now if I go ahead and run this code using passing in say 8.8.8.8, you can see it resolves to dns.google.com. This also works if we say pass in 1.1.1, which also will resolve to this following DNS record.
In addition to performing reverse DNS using the lookup addr commands, we can also look up CNAMEs using the lookup cname function. This one only returns a single string, so let's not iterate over it and instead just print out the address. Now if I run this using say, passing in store.dreamsofcode.io, you can see this resolves to shops.myshopify.com, which is where my store is hosted.
As you can probably see, the net package allows you to build some really interesting tools when it comes to working with networking in Go.