fastdns

func (*FastDNS) Close ¶

func (f *FastDNS) Close() error

Close cleans up XDP sockets and programs. It is essential to call Close when you are done using FastDNS to prevent resource leaks. Failing to close may leave file descriptors, network handles, and kernel resources open, which can eventually exhaust system resources, cause failures in network operations, or prevent new FastDNS instances from being created.

func (*FastDNS) Queries ¶

func (f *FastDNS) Queries(msgs ...*dns.Msg) ([]*Response, error)

Queries sends multiple DNS queries and returns their responses. It serializes each DNS message, transmits them, and waits for replies. If caching is enabled, it checks for cached responses before sending. On success, it returns a slice of Response structs with the DNS responses and their round-trip times (RTT). On failure or timeout, it returns an error.

func (*FastDNS) Query ¶

func (f *FastDNS) Query(msg *dns.Msg) *Response

Query sends a DNS query using the XDP socket and returns the response. It serializes the DNS message, transmits it, and waits for a reply. If caching is enabled, it checks for a cached response before sending. On success, it returns the DNS response and round-trip time (RTT). On failure or timeout, it returns an error in the Response struct.

package main

import (
	"fmt"
	"net"
	"os"

	"github.com/dwisiswant0/fastdns"
	"github.com/miekg/dns"
)

func main() {
	// Define the DNS resolver to use.
	// This should be a valid IP address of a DNS resolver.
	resolver := net.ParseIP("1.1.1.1")

	// Create a new FastDNS instance with the default resolver.
	f, err := fastdns.New(resolver)
	if err != nil {
		panic(err)
	}

	// Ensure that the FastDNS instance is closed when done.
	// Closing is essential to properly release all underlying XDP and socket
	// resources.
	//
	// If Close is not called, system resources such as file descriptors and
	// network handles may be leaked, which can eventually exhaust available
	// resources and cause failures in network operations or prevent new FastDNS
	// instances from being created.
	defer func() {
		if err := f.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "Error during cleanup: %v\n", err)
		}
	}()

	// Create a new DNS query message.
	msg := new(dns.Msg)
	msg.SetQuestion(dns.Fqdn("cloudflare.com"), dns.TypeA)

	// Send the DNS query and receive the response.
	resp := f.Query(msg)
	if err := resp.Err(); err != nil {
		_ = f.Close()

		panic(err)
	}

	// Print the response.
	for _, answer := range resp.Message.Answer {
		println(answer.String())
	}
}

Output:

func (*FastDNS) QueryFromFile ¶

func (f *FastDNS) QueryFromFile(file *os.File, mapper func(s string) *dns.Msg) ([]*Response, error)

QueryFromFile reads entries from a file and performs DNS queries using a custom mapper function. Each line in the file is processed by the mapper function to create DNS messages.

The mapper function takes a string from the file and returns a dns.Msg. This allows for custom DNS message creation based on the file content. If the mapper returns nil, that entry is skipped.

func (*FastDNS) Stats ¶

func (f *FastDNS) Stats() (xdp.Stats, error)

Stats returns statistics about the XDP socket's ring queue usage and kernel interactions. This information can be useful for monitoring the performance and health of the XDP socket and the underlying network interface. The statistics are returned as an xdp.Stats struct, which contains various metrics related to the XDP socket's operation.

func (*Response) Err ¶

func (r *Response) Err() error

Err returns the error associated with the [Result]. If there is no error, it returns nil. If there is an error, it returns the error.

func (*Response) IsError ¶

func (r *Response) IsError() bool

IsError checks if the [Result] contains an error. It returns true if there is an error, and false otherwise. This is useful for checking if the DNS query was successful or not. If there is no error, it returns false. If there is an error, it returns true.

func (*Response) IsSuccess ¶

func (r *Response) IsSuccess() bool

IsSuccess checks if the [Result] is successful. It returns true if there is no error and the Message is not nil. This is useful for checking if the DNS query was successful. If there is an error, it returns false. If the Message is nil, it returns false. If the Message is not nil and there is no error, it returns true.

func (*Response) MarshalJSON ¶

func (r *Response) MarshalJSON() ([]byte, error)

MarshalJSON marshals the [Result] into JSON format.

func (*Response) String ¶

func (r *Response) String() string

String returns a string representation of the [Result]. If there is an error, it returns the error message. If there is no error and the Message is nil, it returns an empty string. If there is no error and the Message is not nil, it returns the string representation of the Message.