3 |
4 |
doggo
5 |
6 | 🐶 Command-line DNS client for humans
7 |
8 |
10 | Web Interface 11 | · 12 | Documentation 13 |
14 |
15 |
16 |
17 | ---
18 |
19 | **doggo** is a modern command-line DNS client (like _dig_) written in Golang. It outputs information in a neat concise manner and supports protocols like DoH, DoT, DoQ, and DNSCrypt as well.
20 |
21 | It's totally inspired by [dog](https://github.com/ogham/dog/) which is written in Rust. I wanted to add some features to it but since I don't know Rust, I found it as a nice opportunity to experiment with writing a DNS Client from scratch in `Go` myself. Hence the name `dog` + `go` => **doggo**.
22 |
23 | ## Installation
24 |
25 | ### Easy Install (Recommended)
26 |
27 | ```shell
28 | curl -sS https://raw.githubusercontent.com/mr-karan/doggo/main/install.sh | sh
29 | ```
30 |
31 | ### Package Managers
32 |
33 | - Homebrew: `brew install doggo`
34 | - MacPorts (macOS): `port install doggo`
35 | - Arch Linux: `yay -S doggo-bin`
36 | - Scoop (Windows): `scoop install doggo`
37 | - Eget: `eget mr-karan/doggo`
38 |
39 | ### Binary Install
40 |
41 | You can download pre-compiled binaries for various operating systems and architectures from the [Releases](https://github.com/mr-karan/doggo/releases) page.
42 |
43 | ### Go Install
44 |
45 | If you have Go installed on your system, you can use the `go install` command:
46 |
47 | ```shell
48 | go install github.com/mr-karan/doggo/cmd/doggo@latest
49 | ```
50 |
51 | The binary will be available at `$GOPATH/bin/doggo`.
52 |
53 | ### Docker
54 |
55 | ```shell
56 | docker pull ghcr.io/mr-karan/doggo:latest
57 | docker run --rm ghcr.io/mr-karan/doggo:latest example.com
58 | ```
59 |
60 | For more installation options, including binary downloads and Docker images, please refer to the [full installation guide](https://doggo.mrkaran.dev/docs/intro/installation/).
61 |
62 | ## Quick Start
63 |
64 | Here are some quick examples to get you started with doggo:
65 |
66 | ```shell
67 | # Simple DNS lookup
68 | doggo example.com
69 |
70 | # Query MX records using a specific nameserver
71 | doggo MX github.com @9.9.9.9
72 |
73 | # Use DNS over HTTPS
74 | doggo example.com @https://cloudflare-dns.com/dns-query
75 |
76 | # JSON output for scripting
77 | doggo example.com --json | jq '.responses[0].answers[].address'
78 |
79 | # Reverse DNS lookup
80 | doggo --reverse 8.8.8.8 --short
81 |
82 | # Using Globalping
83 | doggo example.com --gp-from Germany,Japan --gp-limit 2
84 | ```
85 |
86 | ## Features
87 |
88 | - Human-readable output with color-coded and tabular format
89 | - JSON output support for easy scripting and parsing
90 | - Multiple transport protocols: DoH, DoT, DoQ, TCP, UDP, DNSCrypt
91 | - Support for `ndots` and `search` configurations
92 | - Multiple resolver support with customizable query strategies
93 | - IPv4 and IPv6 support
94 | - Web interface available
95 | - Shell completions for `zsh` and `fish`
96 | - Reverse DNS lookups
97 | - Flexible query options including various DNS flags
98 | - Debug mode for troubleshooting
99 | - Response time measurement
100 | - Cross-platform support
101 |
102 | ## Documentation
103 |
104 | For comprehensive documentation, including detailed usage instructions, configuration options, and advanced features, please visit our [official documentation site](https://doggo.mrkaran.dev/docs/).
105 |
106 | ## Sponsorship
107 |
108 | If you find doggo useful and would like to support its development, please consider becoming a sponsor. Your support helps maintain and improve this open-source project.
109 |
110 | [](https://github.com/sponsors/mr-karan)
111 |
112 | Every contribution, no matter how small, is greatly appreciated and helps keep this project alive and growing. Thank you for your support! 🐶❤️
113 |
114 | ## License
115 |
116 | This project is licensed under the [MIT License](./LICENSE).
117 |
--------------------------------------------------------------------------------
/TODO.md:
--------------------------------------------------------------------------------
1 | # todo
2 |
3 | ## Resolver
4 | - [x] Create a DNS Resolver struct
5 | - [x] Add methods to initialise the config, set defaults
6 | - [x] Add a resolve method
7 | - [x] Make it separate from Hub
8 | - [x] Parse output into separate fields
9 | - [x] Test IPv6/IPv4 only options
10 | - [x] Add DOH support
11 | - [x] Add DOT support
12 | - [x] Add DNS protocol on TCP mode support.
13 | - [x] Change lookup method.
14 | - [x] Major records supported
15 | - [x] Support multiple resolvers
16 | - [x] Take multiple transport options and initialise resolvers accordingly.
17 | - [x] Add timeout support
18 | - [x] Support SOA/NXDOMAIN
19 |
20 | ## CLI Features
21 | - [x] `ndots` support
22 | - [x] `search list` support
23 | - [x] JSON output
24 | - [x] Colorized output
25 | - [x] Table output
26 | - [x] Parsing options free-form
27 |
28 | ## CLI Grunt
29 | - [x] Query args
30 | - [x] Neatly package them to load args in different functions
31 | - [x] Upper case is not mandatory for query type/classes
32 | - [x] Output
33 | - [x] Custom Help Text
34 | - [x] Add examples
35 | - [x] Colorize
36 | - [x] Add different commands
37 | - [x] Add client transport options
38 | - [x] Fix an issue while loading free form args, where the same records are being added twice
39 | - [x] Remove urfave/cli in favour of `pflag + koanf`
40 | - [x] Flags - Remove unneeded ones
41 |
42 | ## Documentation
43 | - [x] README
44 | - [x] Usage
45 | - [x] Installation
46 | - [x] Features
47 |
48 |
49 | ## Release Checklist
50 | - [x] Goreleaser
51 | - [x] Snap
52 | - [x] Docker
53 | ---
54 | # Future Release
55 |
56 | - [x] Support obscure protocol tweaks in `dig`
57 | - [x] Support more DNS Record Types
58 | - [x] Shell completions
59 | - [x] zsh
60 | - [x] fish
61 | - [x] Homebrew - Goreleaser
62 | - [x] Add `dig +short` short output
63 | - [x] Add `--strategy` for picking nameservers.
64 | - [x] Separate Authority/Answer in JSON output.
65 | - [x] Error on NXDomain (Related upstream [bug](https://github.com/miekg/dns/issues/1198))
66 | - [x] Reverse Lookup (dig -x)
67 | - [x] Shell completion proper
68 | - [x] CLI docs
69 | - [x] Merge those as misc docs or usage
70 | - [x] Example Guide
71 |
72 | - [ ] Add tests for Resolvers.
73 | - [ ] Add tests for CLI Output.
74 | - [ ] Add support for `dig +trace` like functionality.
75 | - [ ] Explore `dig.rc` kinda file
76 |
--------------------------------------------------------------------------------
/cli.Dockerfile:
--------------------------------------------------------------------------------
1 | # Dockerfile
2 | ARG ARCH
3 | FROM ${ARCH}/alpine
4 | COPY doggo /usr/bin/doggo
5 | ENTRYPOINT ["/usr/bin/doggo"]
--------------------------------------------------------------------------------
/cmd/doggo/cli.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "fmt"
7 | "log/slog"
8 | "math"
9 | "os"
10 | "sync"
11 | "time"
12 |
13 | "github.com/jsdelivr/globalping-cli/globalping"
14 | "github.com/knadh/koanf/providers/posflag"
15 | "github.com/knadh/koanf/v2"
16 | "github.com/mr-karan/doggo/internal/app"
17 | "github.com/mr-karan/doggo/pkg/resolvers"
18 | "github.com/mr-karan/doggo/pkg/utils"
19 | flag "github.com/spf13/pflag"
20 | )
21 |
22 | var (
23 | buildVersion = "unknown"
24 | buildDate = "unknown"
25 | k = koanf.New(".")
26 | )
27 |
28 | func main() {
29 | if len(os.Args) > 1 && os.Args[1] == "completions" {
30 | completionsCommand()
31 | return
32 | }
33 |
34 | cfg, err := loadConfig()
35 | if err != nil {
36 | fmt.Printf("Error loading configuration: %v\n", err)
37 | os.Exit(1)
38 | }
39 |
40 | if cfg.showVersion {
41 | fmt.Printf("%s - %s\n", buildVersion, buildDate)
42 | os.Exit(0)
43 | }
44 |
45 | logger := utils.InitLogger(cfg.debug)
46 | app := initializeApp(logger, cfg)
47 |
48 | if app.QueryFlags.GPFrom != "" {
49 | res, err := app.GlobalpingMeasurement()
50 | if err != nil {
51 | logger.Error("Error fetching globalping measurement", "error", err)
52 | os.Exit(2)
53 | }
54 | if app.QueryFlags.ShowJSON {
55 | err = app.OutputGlobalpingJSON(res)
56 | } else if app.QueryFlags.ShortOutput {
57 | err = app.OutputGlobalpingShort(res)
58 | } else {
59 | err = app.OutputGlobalping(res)
60 | }
61 | if err != nil {
62 | logger.Error("Error outputting globalping measurement", "error", err)
63 | os.Exit(2)
64 | }
65 | return
66 | }
67 |
68 | if cfg.reverseLookup {
69 | app.ReverseLookup()
70 | }
71 |
72 | app.LoadFallbacks()
73 | app.PrepareQuestions()
74 |
75 | if err := app.LoadNameservers(); err != nil {
76 | logger.Error("Error loading nameservers", "error", err)
77 | os.Exit(2)
78 | }
79 |
80 | resolvers, err := loadResolvers(app, cfg)
81 | if err != nil {
82 | logger.Error("Error loading resolvers", "error", err)
83 | os.Exit(2)
84 | }
85 | app.Resolvers = resolvers
86 |
87 | if len(app.QueryFlags.QNames) == 0 {
88 | cfg.flagSet.Usage()
89 | os.Exit(0)
90 | }
91 |
92 | responses, errors := performLookup(app, cfg)
93 | outputResults(app, responses, errors)
94 | }
95 |
96 | type config struct {
97 | flagSet *flag.FlagSet
98 | showVersion bool
99 | debug bool
100 | reverseLookup bool
101 | timeout time.Duration
102 | queryFlags resolvers.QueryFlags
103 | outputJSON bool
104 | showTime bool
105 | useColor bool
106 | }
107 |
108 | func loadConfig() (*config, error) {
109 | cfg := &config{}
110 | cfg.flagSet = setupFlags()
111 |
112 | if err := parseAndLoadFlags(cfg.flagSet); err != nil {
113 | return nil, fmt.Errorf("error parsing or loading flags: %w", err)
114 | }
115 |
116 | cfg.showVersion = k.Bool("version")
117 | cfg.debug = k.Bool("debug")
118 | cfg.reverseLookup = k.Bool("reverse")
119 | cfg.timeout = k.Duration("timeout")
120 | cfg.outputJSON = k.Bool("json")
121 | cfg.showTime = k.Bool("time")
122 | cfg.useColor = k.Bool("color")
123 |
124 | cfg.queryFlags = resolvers.QueryFlags{
125 | AA: k.Bool("aa"),
126 | AD: k.Bool("ad"),
127 | CD: k.Bool("cd"),
128 | RD: k.Bool("rd"),
129 | Z: k.Bool("z"),
130 | DO: k.Bool("do"),
131 | }
132 |
133 | return cfg, nil
134 | }
135 |
136 | func setupFlags() *flag.FlagSet {
137 | f := flag.NewFlagSet("config", flag.ContinueOnError)
138 | f.Usage = renderCustomHelp
139 |
140 | f.StringSliceP("query", "q", []string{}, "Domain name to query")
141 | f.StringSliceP("type", "t", []string{}, "Type of DNS record to be queried (A, AAAA, MX etc)")
142 | f.StringSliceP("class", "c", []string{}, "Network class of the DNS record to be queried (IN, CH, HS etc)")
143 | f.StringSliceP("nameserver", "n", []string{}, "Address of the nameserver to send packets to")
144 | f.BoolP("reverse", "x", false, "Performs a DNS Lookup for an IPv4 or IPv6 address")
145 |
146 | f.String("gp-from", "", "Probe locations as a comma-separated list")
147 | f.Int("gp-limit", 1, "Limit the number of probes to use")
148 |
149 | f.DurationP("timeout", "T", 5*time.Second, "Sets the timeout for a query")
150 | f.Bool("search", true, "Use the search list provided in resolv.conf")
151 | f.Int("ndots", -1, "Specify the ndots parameter")
152 | f.BoolP("ipv4", "4", false, "Use IPv4 only")
153 | f.BoolP("ipv6", "6", false, "Use IPv6 only")
154 | f.String("strategy", "all", "Strategy to query nameservers in resolv.conf file")
155 | f.String("tls-hostname", "", "Hostname for certificate verification")
156 | f.Bool("skip-hostname-verification", false, "Skip TLS Hostname Verification")
157 |
158 | f.Bool("any", false, "Query all supported DNS record types")
159 |
160 | f.BoolP("json", "J", false, "Set the output format as JSON")
161 | f.Bool("short", false, "Short output format")
162 | f.Bool("time", false, "Display how long the response took")
163 | f.Bool("color", true, "Show colored output")
164 | f.Bool("debug", false, "Enable debug mode")
165 |
166 | // Add flags for DNS query options
167 | f.Bool("aa", false, "Set Authoritative Answer flag")
168 | f.Bool("ad", false, "Set Authenticated Data flag")
169 | f.Bool("cd", false, "Set Checking Disabled flag")
170 | f.Bool("rd", true, "Set Recursion Desired flag (default: true)")
171 | f.Bool("z", false, "Set Z flag (reserved for future use)")
172 | f.Bool("do", false, "Set DNSSEC OK flag")
173 |
174 | f.Bool("version", false, "Show version of doggo")
175 |
176 | return f
177 | }
178 |
179 | func parseAndLoadFlags(f *flag.FlagSet) error {
180 | if err := f.Parse(os.Args[1:]); err != nil {
181 | return fmt.Errorf("error parsing flags: %w", err)
182 | }
183 | if err := k.Load(posflag.Provider(f, ".", k), nil); err != nil {
184 | return fmt.Errorf("error loading flags: %w", err)
185 | }
186 | return nil
187 | }
188 |
189 | func initializeApp(logger *slog.Logger, cfg *config) *app.App {
190 | gpConfig := globalping.Config{
191 | APIURL: "https://api.globalping.io/v1",
192 | AuthURL: "https://auth.globalping.io",
193 | UserAgent: fmt.Sprintf("doggo/%s (https://github.com/mr-karan/doggo)", buildVersion),
194 | }
195 | gpToken := os.Getenv("GLOBALPING_TOKEN")
196 | if gpToken != "" {
197 | gpConfig.AuthToken = &globalping.Token{
198 | AccessToken: gpToken,
199 | Expiry: time.Now().Add(math.MaxInt64),
200 | }
201 | }
202 | globlpingClient := globalping.NewClient(gpConfig)
203 |
204 | app := app.New(logger, globlpingClient, buildVersion)
205 |
206 | if err := k.Unmarshal("", &app.QueryFlags); err != nil {
207 | logger.Error("Error loading args", "error", err)
208 | os.Exit(2)
209 | }
210 |
211 | loadNameservers(&app, cfg.flagSet.Args())
212 | return &app
213 | }
214 |
215 | func loadNameservers(app *app.App, args []string) {
216 | flagNameservers := k.Strings("nameserver")
217 | unparsedNameservers, qt, qc, qn := loadUnparsedArgs(args)
218 |
219 | if len(flagNameservers) > 0 {
220 | app.QueryFlags.Nameservers = flagNameservers
221 | } else {
222 | app.QueryFlags.Nameservers = unparsedNameservers
223 | }
224 |
225 | app.QueryFlags.QTypes = append(app.QueryFlags.QTypes, qt...)
226 | app.QueryFlags.QClasses = append(app.QueryFlags.QClasses, qc...)
227 | app.QueryFlags.QNames = append(app.QueryFlags.QNames, qn...)
228 | }
229 |
230 | func loadResolvers(app *app.App, cfg *config) ([]resolvers.Resolver, error) {
231 | return resolvers.LoadResolvers(resolvers.Options{
232 | Nameservers: app.Nameservers,
233 | UseIPv4: app.QueryFlags.UseIPv4,
234 | UseIPv6: app.QueryFlags.UseIPv6,
235 | SearchList: app.ResolverOpts.SearchList,
236 | Ndots: app.ResolverOpts.Ndots,
237 | Timeout: cfg.timeout,
238 | Logger: app.Logger,
239 | Strategy: app.QueryFlags.Strategy,
240 | InsecureSkipVerify: app.QueryFlags.InsecureSkipVerify,
241 | TLSHostname: app.QueryFlags.TLSHostname,
242 | })
243 | }
244 |
245 | func performLookup(app *app.App, cfg *config) ([]resolvers.Response, []error) {
246 | ctx, cancel := context.WithTimeout(context.Background(), cfg.timeout)
247 | defer cancel()
248 |
249 | var (
250 | wg sync.WaitGroup
251 | mu sync.Mutex
252 | allResponses []resolvers.Response
253 | allErrors []error
254 | )
255 |
256 | for _, resolver := range app.Resolvers {
257 | wg.Add(1)
258 | go func(r resolvers.Resolver) {
259 | defer wg.Done()
260 | responses, err := r.Lookup(ctx, app.Questions, cfg.queryFlags)
261 | mu.Lock()
262 | if err != nil {
263 | allErrors = append(allErrors, err)
264 | } else {
265 | allResponses = append(allResponses, responses...)
266 | }
267 | mu.Unlock()
268 | }(resolver)
269 | }
270 |
271 | wg.Wait()
272 | return allResponses, allErrors
273 | }
274 |
275 | func outputResults(app *app.App, responses []resolvers.Response, responseErrors []error) {
276 | if app.QueryFlags.ShowJSON {
277 | outputJSON(app.Logger, responses, responseErrors)
278 | } else {
279 | if len(responseErrors) > 0 {
280 | app.Logger.Error("Error looking up DNS records", "error", responseErrors[0])
281 | os.Exit(9)
282 | }
283 | app.Output(responses)
284 | }
285 | }
286 |
287 | func outputJSON(logger *slog.Logger, responses []resolvers.Response, responseErrors []error) {
288 | jsonOutput := struct {
289 | Responses []resolvers.Response `json:"responses,omitempty"`
290 | Error string `json:"error,omitempty"`
291 | }{
292 | Responses: responses,
293 | }
294 |
295 | if len(responseErrors) > 0 {
296 | jsonOutput.Error = responseErrors[0].Error()
297 | }
298 |
299 | jsonData, err := json.MarshalIndent(jsonOutput, "", " ")
300 | if err != nil {
301 | logger.Error("Error marshaling JSON")
302 | os.Exit(1)
303 | }
304 | fmt.Println(string(jsonData))
305 | }
306 |
--------------------------------------------------------------------------------
/cmd/doggo/completions.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | )
7 |
8 | var (
9 | bashCompletion = `
10 | _doggo() {
11 | local cur prev opts
12 | COMPREPLY=()
13 | cur="${COMP_WORDS[COMP_CWORD]}"
14 | prev="${COMP_WORDS[COMP_CWORD-1]}"
15 |
16 | opts="-v --version -h --help -q --query -t --type -n --nameserver -c --class -r --reverse --strategy --ndots --search --timeout -4 --ipv4 -6 --ipv6 --tls-hostname --skip-hostname-verification -J --json --short --color --debug --time --gp-from --gp-limit"
17 |
18 | case "${prev}" in
19 | -t|--type)
20 | COMPREPLY=( $(compgen -W "A AAAA CAA CNAME HINFO MX NS PTR SOA SRV TXT" -- ${cur}) )
21 | return 0
22 | ;;
23 | -c|--class)
24 | COMPREPLY=( $(compgen -W "IN CH HS" -- ${cur}) )
25 | return 0
26 | ;;
27 | -n|--nameserver)
28 | COMPREPLY=( $(compgen -A hostname -- ${cur}) )
29 | return 0
30 | ;;
31 | --strategy)
32 | COMPREPLY=( $(compgen -W "all random first" -- ${cur}) )
33 | return 0
34 | ;;
35 | --search|--color)
36 | COMPREPLY=( $(compgen -W "true false" -- ${cur}) )
37 | return 0
38 | ;;
39 | esac
40 |
41 | if [[ ${cur} == -* ]]; then
42 | COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
43 | else
44 | COMPREPLY=( $(compgen -A hostname -- ${cur}) )
45 | fi
46 | }
47 |
48 | complete -F _doggo doggo
49 | `
50 |
51 | zshCompletion = `#compdef doggo
52 |
53 | _doggo() {
54 | local -a commands
55 | commands=(
56 | 'completions:Generate shell completion scripts'
57 | )
58 |
59 | _arguments -C \
60 | '(-v --version)'{-v,--version}'[Show version of doggo]' \
61 | '(-h --help)'{-h,--help}'[Show list of command-line options]' \
62 | '(-q --query)'{-q,--query}'[Hostname to query the DNS records for]:hostname:_hosts' \
63 | '(-t --type)'{-t,--type}'[Type of the DNS Record]:record type:(A AAAA CAA CNAME HINFO MX NS PTR SOA SRV TXT)' \
64 | '(-n --nameserver)'{-n,--nameserver}'[Address of a specific nameserver to send queries to]:nameserver:_hosts' \
65 | '(-c --class)'{-c,--class}'[Network class of the DNS record being queried]:network class:(IN CH HS)' \
66 | '(-r --reverse)'{-r,--reverse}'[Performs a DNS Lookup for an IPv4 or IPv6 address]' \
67 | '--strategy[Strategy to query nameserver listed in etc/resolv.conf]:strategy:(all random first)' \
68 | '--ndots[Number of required dots in hostname to assume FQDN]:number of dots' \
69 | '--search[Use the search list defined in resolv.conf]:setting:(true false)' \
70 | '--timeout[Timeout (in seconds) for the resolver to return a response]:seconds' \
71 | '(-4 --ipv4)'{-4,--ipv4}'[Use IPv4 only]' \
72 | '(-6 --ipv6)'{-6,--ipv6}'[Use IPv6 only]' \
73 | '--tls-hostname[Hostname used for verification of certificate incase the provided DoT nameserver is an IP]:hostname:_hosts' \
74 | '--skip-hostname-verification[Skip TLS hostname verification in case of DoT lookups]' \
75 | '(-J --json)'{-J,--json}'[Format the output as JSON]' \
76 | '--short[Shows only the response section in the output]' \
77 | '--color[Colored output]:setting:(true false)' \
78 | '--debug[Enable debug logging]' \
79 | '--time[Shows how long the response took from the server]' \
80 | '--gp-from[Query using Globalping API from a specific location]' \
81 | '--gp-limit[Limit the number of probes to use from Globalping]' \
82 | '*:hostname:_hosts' \
83 | && ret=0
84 |
85 | case $state in
86 | (commands)
87 | _describe -t commands 'doggo commands' commands && ret=0
88 | ;;
89 | esac
90 |
91 | return ret
92 | }
93 |
94 | _doggo
95 | `
96 |
97 | fishCompletion = `
98 | function __fish_doggo_no_subcommand
99 | set cmd (commandline -opc)
100 | if [ (count $cmd) -eq 1 ]
101 | return 0
102 | end
103 | return 1
104 | end
105 |
106 | # Meta options
107 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'version' -d "Show version of doggo"
108 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'help' -d "Show list of command-line options"
109 |
110 | # Query options
111 | complete -c doggo -n '__fish_doggo_no_subcommand' -s 'q' -l 'query' -d "Hostname to query the DNS records for" -x -a "(__fish_print_hostnames)"
112 | complete -c doggo -n '__fish_doggo_no_subcommand' -s 't' -l 'type' -d "Type of the DNS Record" -x -a "A AAAA CAA CNAME HINFO MX NS PTR SOA SRV TXT"
113 | complete -c doggo -n '__fish_doggo_no_subcommand' -s 'n' -l 'nameserver' -d "Address of a specific nameserver to send queries to" -x -a "(__fish_print_hostnames)"
114 | complete -c doggo -n '__fish_doggo_no_subcommand' -s 'c' -l 'class' -d "Network class of the DNS record being queried" -x -a "IN CH HS"
115 | complete -c doggo -n '__fish_doggo_no_subcommand' -s 'r' -l 'reverse' -d "Performs a DNS Lookup for an IPv4 or IPv6 address"
116 |
117 | # Resolver options
118 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'strategy' -d "Strategy to query nameserver listed in etc/resolv.conf" -x -a "all random first"
119 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'ndots' -d "Specify ndots parameter"
120 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'search' -d "Use the search list defined in resolv.conf" -x -a "true false"
121 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'timeout' -d "Specify timeout (in seconds) for the resolver to return a response"
122 | complete -c doggo -n '__fish_doggo_no_subcommand' -s '4' -l 'ipv4' -d "Use IPv4 only"
123 | complete -c doggo -n '__fish_doggo_no_subcommand' -s '6' -l 'ipv6' -d "Use IPv6 only"
124 |
125 | # Output options
126 | complete -c doggo -n '__fish_doggo_no_subcommand' -s 'J' -l 'json' -d "Format the output as JSON"
127 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'short' -d "Shows only the response section in the output"
128 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'color' -d "Colored output" -x -a "true false"
129 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'debug' -d "Enable debug logging"
130 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'time' -d "Shows how long the response took from the server"
131 |
132 | # TLS options
133 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'tls-hostname' -d "Hostname for certificate verification" -x -a "(__fish_print_hostnames)"
134 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'skip-hostname-verification' -d "Skip TLS hostname verification in case of DoT lookups"
135 |
136 | # Globalping options
137 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'gp-from' -d "Query using Globalping API from a specific location"
138 | complete -c doggo -n '__fish_doggo_no_subcommand' -l 'gp-limit' -d "Limit the number of probes to use from Globalping"
139 |
140 | # Completions command
141 | complete -c doggo -n '__fish_doggo_no_subcommand' -a completions -d "Generate shell completion scripts"
142 | complete -c doggo -n '__fish_seen_subcommand_from completions' -a "bash zsh fish" -d "Shell type"
143 | `
144 | )
145 |
146 | func completionsCommand() {
147 | if len(os.Args) < 3 {
148 | fmt.Println("Usage: doggo completions [bash|zsh|fish]")
149 | os.Exit(1)
150 | }
151 |
152 | shell := os.Args[2]
153 | switch shell {
154 | case "bash":
155 | fmt.Println(bashCompletion)
156 | case "zsh":
157 | fmt.Println(zshCompletion)
158 | case "fish":
159 | fmt.Println(fishCompletion)
160 | default:
161 | fmt.Printf("Unsupported shell: %s\n", shell)
162 | os.Exit(1)
163 | }
164 | }
165 |
--------------------------------------------------------------------------------
/cmd/doggo/help.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "os"
5 | "text/template"
6 |
7 | "github.com/fatih/color"
8 | )
9 |
10 | // appHelpTextTemplate is the text/template to customise the Help output.
11 | var appHelpTextTemplate = `{{ "NAME" | color "" "heading" }}:
12 | {{ .Name | color "green" "bold" }} 🐶 {{ .Description }}
13 |
14 | {{ "USAGE" | color "" "heading" }}:
15 | {{ .Name | color "green" "bold" }} [--] {{ "[query options]" | color "yellow" "" }} {{ "[arguments...]" | color "cyan" "" }}
16 |
17 | {{ "VERSION" | color "" "heading" }}:
18 | {{ .Version | color "red" "" }} - {{ .Date | color "red" "" }}
19 |
20 | {{ "EXAMPLES" | color "" "heading" }}:
21 | {{- range $example := .Examples }}
22 | {{ $.Name | color "green" "bold" }} {{ printf "%-40s" $example.Command | color "cyan" "" }}{{ $example.Description }}
23 | {{- end }}
24 |
25 | {{ "FREE FORM ARGUMENTS" | color "" "heading" }}:
26 | Supply hostnames, query types, and classes without flags. Example:
27 | {{ .Name | color "green" "bold" }} {{ "mrkaran.dev A @1.1.1.1" | color "cyan" "" }}
28 |
29 | {{ "TRANSPORT OPTIONS" | color "" "heading" }}:
30 | Specify the protocol with a URL-type scheme.
31 | UDP is used if no scheme is specified.
32 |
33 | {{- range $opt := .TransportOptions }}
34 | {{ printf "%-12s" $opt.Scheme | color "yellow" "" }}{{ printf "%-68s" $opt.Example }}{{ $opt.Description | color "cyan" "" }}
35 | {{- end }}
36 |
37 | {{ "SUBCOMMANDS" | color "" "heading" }}:
38 | {{- range $opt := .Subcommands }}
39 | {{ printf "%-30s" $opt.Flag | color "yellow" "" }}{{ $opt.Description }}
40 | {{- end }}
41 |
42 | {{ "QUERY OPTIONS" | color "" "heading" }}:
43 | {{- range $opt := .QueryOptions }}
44 | {{ printf "%-30s" $opt.Flag | color "yellow" "" }}{{ $opt.Description }}
45 | {{- end }}
46 |
47 | {{ "RESOLVER OPTIONS" | color "" "heading" }}:
48 | {{- range $opt := .ResolverOptions }}
49 | {{ printf "%-30s" $opt.Flag | color "yellow" "" }}{{ $opt.Description }}
50 | {{- end }}
51 |
52 | {{ "QUERY FLAGS" | color "" "heading" }}:
53 | {{- range $flag := .QueryFlags }}
54 | {{ printf "%-30s" $flag.Flag | color "yellow" "" }}{{ $flag.Description }}
55 | {{- end }}
56 |
57 | {{ "OUTPUT OPTIONS" | color "" "heading" }}:
58 | {{- range $opt := .OutputOptions }}
59 | {{ printf "%-30s" $opt.Flag | color "yellow" "" }}{{ $opt.Description }}
60 | {{- end }}
61 |
62 | {{ "GLOBALPING OPTIONS" | color "" "heading" }}:
63 | {{- range $opt := .GlobalPingOptions }}
64 | {{ printf "%-30s" $opt.Flag | color "yellow" "" }}{{ $opt.Description }}
65 | {{- end }}
66 | `
67 |
68 | func renderCustomHelp() {
69 | type Option struct {
70 | Flag string
71 | Description string
72 | }
73 |
74 | type Example struct {
75 | Command string
76 | Description string
77 | }
78 |
79 | type TransportOption struct {
80 | Scheme string
81 | Example string
82 | Description string
83 | }
84 |
85 | helpTmplVars := map[string]interface{}{
86 | "Name": "doggo",
87 | "Description": "DNS Client for Humans",
88 | "Version": buildVersion,
89 | "Date": buildDate,
90 | "Examples": []Example{
91 | {"mrkaran.dev", "Query a domain using defaults."},
92 | {"mrkaran.dev CNAME", "Query for a CNAME record."},
93 | {"mrkaran.dev MX @9.9.9.9", "Uses a custom DNS resolver."},
94 | {"-q mrkaran.dev -t MX -n 1.1.1.1", "Using named arguments."},
95 | {"mrkaran.dev --aa --ad", "Query with Authoritative Answer and Authenticated Data flags set."},
96 | {"mrkaran.dev --cd --do", "Query with Checking Disabled and DNSSEC OK flags set."},
97 | {"mrkaran.dev --gp-from Germany", "Query using Globalping API from a specific location."},
98 | },
99 | "TransportOptions": []TransportOption{
100 | {"@udp://", "eg: @1.1.1.1", "initiates a UDP query to 1.1.1.1:53."},
101 | {"@tcp://", "eg: @tcp://1.1.1.1", "initiates a TCP query to 1.1.1.1:53."},
102 | {"@https://", "eg: @https://cloudflare-dns.com/dns-query", "initiates a DOH query to Cloudflare via DoH."},
103 | {"@tls://", "eg: @tls://1.1.1.1", "initiates a DoT query to 1.1.1.1:853."},
104 | {"@sdns://", "initiates a DNSCrypt or DoH query using a DNS stamp.", ""},
105 | {"@quic://", "initiates a DOQ query.", ""},
106 | },
107 | "Subcommands": []Option{
108 | {"completions [bash|zsh|fish]", "Generate the shell completion script for the specified shell."},
109 | },
110 | "QueryOptions": []Option{
111 | {"-q, --query=HOSTNAME", "Hostname to query the DNS records for (eg mrkaran.dev)."},
112 | {"-t, --type=TYPE", "Type of the DNS Record (A, MX, NS etc)."},
113 | {"-n, --nameserver=ADDR", "Address of a specific nameserver to send queries to (9.9.9.9, 8.8.8.8 etc)."},
114 | {"-c, --class=CLASS", "Network class of the DNS record (IN, CH, HS etc)."},
115 | {"-x, --reverse", "Performs a DNS Lookup for an IPv4 or IPv6 address. Sets the query type and class to PTR and IN respectively."},
116 | {"--any", "Query all supported DNS record types (A, AAAA, CNAME, MX, NS, PTR, SOA, SRV, TXT, CAA)."},
117 | },
118 | "ResolverOptions": []Option{
119 | {"--strategy=STRATEGY", "Specify strategy to query nameserver listed in etc/resolv.conf. (all, random, first)."},
120 | {"--ndots=INT", "Specify ndots parameter. Takes value from /etc/resolv.conf if using the system namesever or 1 otherwise."},
121 | {"--search", "Use the search list defined in resolv.conf. Defaults to true. Set --search=false to disable search list."},
122 | {"--timeout=DURATION", "Specify timeout for the resolver to return a response (e.g., 5s, 400ms, 1m)."},
123 | {"-4, --ipv4", "Use IPv4 only."},
124 | {"-6, --ipv6", "Use IPv6 only."},
125 | {"--tls-hostname=HOSTNAME", "Provide a hostname for verification of the certificate if the provided DoT nameserver is an IP."},
126 | {"--skip-hostname-verification", "Skip TLS Hostname Verification in case of DOT Lookups."},
127 | },
128 | "QueryFlags": []Option{
129 | {"--aa", "Set Authoritative Answer flag."},
130 | {"--ad", "Set Authenticated Data flag."},
131 | {"--cd", "Set Checking Disabled flag."},
132 | {"--rd", "Set Recursion Desired flag (default: true)."},
133 | {"--z", "Set Z flag (reserved for future use)."},
134 | {"--do", "Set DNSSEC OK flag."},
135 | },
136 | "OutputOptions": []Option{
137 | {"-J, --json", "Format the output as JSON."},
138 | {"--short", "Short output format. Shows only the response section."},
139 | {"--color", "Defaults to true. Set --color=false to disable colored output."},
140 | {"--debug", "Enable debug logging."},
141 | {"--time", "Shows how long the response took from the server."},
142 | },
143 | "GlobalPingOptions": []Option{
144 | {"--gp-from=Germany", "Query using Globalping API from a specific location."},
145 | {"--gp-limit=INT", "Limit the number of probes to use from Globalping."},
146 | },
147 | }
148 |
149 | tmpl, err := template.New("help").Funcs(template.FuncMap{
150 | "color": func(clr string, format string, str string) string {
151 | formatter := color.New()
152 | switch clr {
153 | case "yellow":
154 | formatter = formatter.Add(color.FgYellow)
155 | case "red":
156 | formatter = formatter.Add(color.FgRed)
157 | case "cyan":
158 | formatter = formatter.Add(color.FgCyan)
159 | case "green":
160 | formatter = formatter.Add(color.FgGreen)
161 | }
162 | switch format {
163 | case "bold":
164 | formatter = formatter.Add(color.Bold)
165 | case "underline":
166 | formatter = formatter.Add(color.Underline)
167 | case "heading":
168 | formatter = formatter.Add(color.Bold, color.Underline)
169 | }
170 | return formatter.SprintFunc()(str)
171 | },
172 | }).Parse(appHelpTextTemplate)
173 | if err != nil {
174 | panic(err)
175 | }
176 | err = tmpl.Execute(color.Output, helpTmplVars)
177 | if err != nil {
178 | panic(err)
179 | }
180 | os.Exit(0)
181 | }
182 |
--------------------------------------------------------------------------------
/cmd/doggo/parse.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "strings"
5 |
6 | "github.com/miekg/dns"
7 | )
8 |
9 | // loadUnparsedArgs tries to parse all the arguments
10 | // which are unparsed by `flag` library. These arguments don't have any specific
11 | // order so we have to deduce based on the pattern of argument.
12 | // For eg, a nameserver must always begin with `@`. In this
13 | // pattern we deduce the arguments and append it to the
14 | // list of internal query flags.
15 | // In case an argument isn't able to fit in any of the existing
16 | // pattern it is considered to be a "hostname".
17 | // Eg of unparsed argument: `dig mrkaran.dev @1.1.1.1 AAAA`
18 | // where `@1.1.1.1` and `AAAA` are "unparsed" args.
19 | // Returns a list of nameserver, queryTypes, queryClasses, queryNames.
20 | func loadUnparsedArgs(args []string) ([]string, []string, []string, []string) {
21 | var nameservers, queryTypes, queryClasses, queryNames []string
22 | for _, arg := range args {
23 | if strings.HasPrefix(arg, "@") {
24 | nameservers = append(nameservers, strings.TrimPrefix(arg, "@"))
25 | } else if qt, ok := dns.StringToType[strings.ToUpper(arg)]; ok {
26 | queryTypes = append(queryTypes, dns.TypeToString[qt])
27 | } else if qc, ok := dns.StringToClass[strings.ToUpper(arg)]; ok {
28 | queryClasses = append(queryClasses, dns.ClassToString[qc])
29 | } else {
30 | queryNames = append(queryNames, arg)
31 | }
32 | }
33 | return nameservers, queryTypes, queryClasses, queryNames
34 | }
35 |
--------------------------------------------------------------------------------
/config-api-sample.toml:
--------------------------------------------------------------------------------
1 | [server]
2 | address = ":8080"
3 | name = "doggo-api"
4 | # WARNING If these timeouts are less than 1s,
5 | # the server connection breaks.
6 | read_timeout=7000
7 | write_timeout=7000
8 | keepalive_timeout=5000
9 | max_body_size=10000
--------------------------------------------------------------------------------
/docs/.gitignore:
--------------------------------------------------------------------------------
1 | # build output
2 | dist/
3 | # generated types
4 | .astro/
5 |
6 | # dependencies
7 | node_modules/
8 |
9 | # logs
10 | npm-debug.log*
11 | yarn-debug.log*
12 | yarn-error.log*
13 | pnpm-debug.log*
14 |
15 |
16 | # environment variables
17 | .env
18 | .env.production
19 |
20 | # macOS-specific files
21 | .DS_Store
22 |
--------------------------------------------------------------------------------
/docs/.vscode/extensions.json:
--------------------------------------------------------------------------------
1 | {
2 | "recommendations": ["astro-build.astro-vscode"],
3 | "unwantedRecommendations": []
4 | }
5 |
--------------------------------------------------------------------------------
/docs/.vscode/launch.json:
--------------------------------------------------------------------------------
1 | {
2 | "version": "0.2.0",
3 | "configurations": [
4 | {
5 | "command": "./node_modules/.bin/astro dev",
6 | "name": "Development server",
7 | "request": "launch",
8 | "type": "node-terminal"
9 | }
10 | ]
11 | }
12 |
--------------------------------------------------------------------------------
/docs/README.md:
--------------------------------------------------------------------------------
1 | # Starlight Starter Kit: Basics
2 |
3 | [](https://starlight.astro.build)
4 |
5 | ```
6 | npm create astro@latest -- --template starlight
7 | ```
8 |
9 | [](https://stackblitz.com/github/withastro/starlight/tree/main/examples/basics)
10 | [](https://codesandbox.io/p/sandbox/github/withastro/starlight/tree/main/examples/basics)
11 | [](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fwithastro%2Fstarlight%2Ftree%2Fmain%2Fexamples%2Fbasics&project-name=my-starlight-docs&repository-name=my-starlight-docs)
12 |
13 | > 🧑🚀 **Seasoned astronaut?** Delete this file. Have fun!
14 |
15 | ## 🚀 Project Structure
16 |
17 | Inside of your Astro + Starlight project, you'll see the following folders and files:
18 |
19 | ```
20 | .
21 | ├── public/
22 | ├── src/
23 | │ ├── assets/
24 | │ ├── content/
25 | │ │ ├── docs/
26 | │ │ └── config.ts
27 | │ └── env.d.ts
28 | ├── astro.config.mjs
29 | ├── package.json
30 | └── tsconfig.json
31 | ```
32 |
33 | Starlight looks for `.md` or `.mdx` files in the `src/content/docs/` directory. Each file is exposed as a route based on its file name.
34 |
35 | Images can be added to `src/assets/` and embedded in Markdown with a relative link.
36 |
37 | Static assets, like favicons, can be placed in the `public/` directory.
38 |
39 | ## 🧞 Commands
40 |
41 | All commands are run from the root of the project, from a terminal:
42 |
43 | | Command | Action |
44 | | :------------------------ | :----------------------------------------------- |
45 | | `npm install` | Installs dependencies |
46 | | `npm run dev` | Starts local dev server at `localhost:4321` |
47 | | `npm run build` | Build your production site to `./dist/` |
48 | | `npm run preview` | Preview your build locally, before deploying |
49 | | `npm run astro ...` | Run CLI commands like `astro add`, `astro check` |
50 | | `npm run astro -- --help` | Get help using the Astro CLI |
51 |
52 | ## 👀 Want to learn more?
53 |
54 | Check out [Starlight’s docs](https://starlight.astro.build/), read [the Astro documentation](https://docs.astro.build), or jump into the [Astro Discord server](https://astro.build/chat).
55 |
--------------------------------------------------------------------------------
/docs/astro.config.mjs:
--------------------------------------------------------------------------------
1 | import { defineConfig } from "astro/config";
2 | import starlight from "@astrojs/starlight";
3 | import { defineConfig, passthroughImageService } from "astro/config";
4 |
5 | // https://astro.build/config
6 | export default defineConfig({
7 | base: "/docs",
8 | site: "https://doggo.mrkaran.dev/docs/",
9 | image: {
10 | service: passthroughImageService(),
11 | },
12 | integrations: [
13 | starlight({
14 | title: "Doggo",
15 | customCss: ["./src/assets/custom.css"],
16 | social: {
17 | github: "https://github.com/mr-karan/doggo",
18 | },
19 | sidebar: [
20 | {
21 | label: "Introduction",
22 | items: [{ label: "Installation", link: "/intro/installation" }],
23 | },
24 | {
25 | label: "Usage Guide",
26 | items: [
27 | { label: "Examples", link: "/guide/examples" },
28 | { label: "CLI Reference", link: "/guide/reference" },
29 | ],
30 | },
31 | {
32 | label: "Resolvers",
33 | items: [
34 | { label: "Classic (UDP and TCP)", link: "/resolvers/classic" },
35 | { label: "System", link: "/resolvers/system" },
36 | { label: "DNS over HTTPS (DoH)", link: "/resolvers/doh" },
37 | { label: "DNS over TLS (DoT)", link: "/resolvers/dot" },
38 | { label: "DNSCrypt", link: "/resolvers/dnscrypt" },
39 | { label: "DNS over HTTPS (DoQ)", link: "/resolvers/quic" },
40 | ],
41 | },
42 | {
43 | label: "Features",
44 | items: [
45 | { label: "Output Formats", link: "/features/output" },
46 | { label: "Multiple Resolvers", link: "/features/multiple" },
47 | { label: "IPv4 and IPv6", link: "/features/ip" },
48 | { label: "Reverse IP Lookups", link: "/features/reverse" },
49 | { label: "Protocol Tweaks", link: "/features/tweaks" },
50 | { label: "Shell Completions", link: "/features/shell" },
51 | { label: "Common Record Types", link: "/features/any" },
52 | ],
53 | },
54 | ],
55 | }),
56 | ],
57 | });
58 |
--------------------------------------------------------------------------------
/docs/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "docs",
3 | "type": "module",
4 | "version": "0.0.1",
5 | "scripts": {
6 | "dev": "astro dev",
7 | "start": "astro dev",
8 | "build": "astro build",
9 | "preview": "astro preview",
10 | "astro": "astro"
11 | },
12 | "dependencies": {
13 | "@astrojs/starlight": "^0.24.4",
14 | "astro": "^4.10.2",
15 | "sharp": "^0.33.4"
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/docs/public/favicon.svg:
--------------------------------------------------------------------------------
1 |
29 |
--------------------------------------------------------------------------------
/docs/src/assets/custom.css:
--------------------------------------------------------------------------------
1 | .hero {
2 | padding-block: unset;
3 | }
--------------------------------------------------------------------------------
/docs/src/assets/doggo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mr-karan/doggo/16ba284a136354fb4f11fd4d566db9b4364e9a32/docs/src/assets/doggo.png
--------------------------------------------------------------------------------
/docs/src/content/config.ts:
--------------------------------------------------------------------------------
1 | import { defineCollection } from 'astro:content';
2 | import { docsSchema } from '@astrojs/starlight/schema';
3 |
4 | export const collections = {
5 | docs: defineCollection({ schema: docsSchema() }),
6 | };
7 |
--------------------------------------------------------------------------------
/docs/src/content/docs/features/any.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Common record types
3 | description: Learn how to query multiple DNS record types simultaneously
4 | ---
5 |
6 | The `--any` flag in Doggo allows you to query all supported DNS record types for a given domain in a single command. This can be particularly useful when you want to get a comprehensive view of a domain's DNS configuration without running multiple queries.
7 |
8 | ## Syntax
9 |
10 | ```bash
11 | doggo [domain] --any
12 | ```
13 |
14 | ## Supported Record Types
15 |
16 | When you use the `--any` flag, Doggo will query for the following common DNS record types:
17 |
18 | - A (IPv4 address)
19 | - AAAA (IPv6 address)
20 | - CNAME (Canonical name)
21 | - MX (Mail exchange)
22 | - NS (Name server)
23 | - PTR (Pointer)
24 | - SOA (Start of authority)
25 | - SRV (Service)
26 | - TXT (Text)
27 | - CAA (Certification Authority Authorization)
28 |
29 | ## Example Usage
30 |
31 | ```bash
32 | doggo mrkaran.dev --any
33 | ```
34 |
35 | ## Example Output
36 |
37 | ```bash
38 | $ doggo example.com --any
39 | NAME TYPE CLASS TTL ADDRESS NAMESERVER
40 | example.com. A IN 3401s 93.184.215.14 127.0.0.53:53
41 | example.com. AAAA IN 3600s 2606:2800:21f:cb07:6820:80da:af6b:8b2c 127.0.0.53:53
42 | example.com. MX IN 77316s 0 . 127.0.0.53:53
43 | example.com. NS IN 86400s a.iana-servers.net. 127.0.0.53:53
44 | example.com. NS IN 86400s b.iana-servers.net. 127.0.0.53:53
45 | example.com. SOA IN 3600s ns.icann.org. 127.0.0.53:53
46 | noc.dns.icann.org. 2024041841
47 | 7200 3600 1209600 3600
48 | example.com. TXT IN 86400s "v=spf1 -all" 127.0.0.53:53
49 | example.com. TXT IN 86400s "wgyf8z8cgvm2qmxpnbnldrcltvk4xqfn" 127.0.0.53:53
50 | ```
51 |
52 | ## Considerations
53 |
54 | - The `--any` query may take longer to complete compared to querying a single record type, as it's fetching multiple record types.
55 |
--------------------------------------------------------------------------------
/docs/src/content/docs/features/ip.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: IPv4 and IPv6 Support
3 | description: Learn how Doggo handles both IPv4 and IPv6 DNS queries
4 | ---
5 |
6 | Doggo provides support for both IPv4 and IPv6, allowing you to perform DNS queries over either protocol.
7 |
8 | ### Default Behavior
9 |
10 | By default, Doggo will query for A (IPv4) records only. This means it will return only IPv4 addresses when querying a domain without specifying a record type.
11 |
12 | ```bash
13 | $ doggo mrkaran.dev
14 | NAME TYPE CLASS TTL ADDRESS NAMESERVER
15 | mrkaran.dev. A IN 300s 104.21.7.168 127.0.0.53:53
16 | mrkaran.dev. A IN 300s 172.67.187.239 127.0.0.53:53
17 | ```
18 |
19 | ### Querying for IPv6 (AAAA) Records
20 |
21 | To query for IPv6 addresses, you need to explicitly request AAAA records:
22 |
23 | ```bash
24 | $ doggo AAAA mrkaran.dev
25 | NAME TYPE CLASS TTL ADDRESS NAMESERVER
26 | mrkaran.dev. AAAA IN 300s 2606:4700:3030::ac43:bbef 127.0.0.53:53
27 | mrkaran.dev. AAAA IN 300s 2606:4700:3035::6815:7a8 127.0.0.53:53
28 | ```
29 |
30 | ### Querying for Both IPv4 and IPv6
31 |
32 | To get both IPv4 and IPv6 addresses, you can specify both A and AAAA record types:
33 |
34 | ```bash
35 | $ doggo A AAAA mrkaran.dev
36 | NAME TYPE CLASS TTL ADDRESS NAMESERVER
37 | mrkaran.dev. A IN 204s 104.21.7.168 127.0.0.53:53
38 | mrkaran.dev. A IN 204s 172.67.187.239 127.0.0.53:53
39 | mrkaran.dev. AAAA IN 284s 2606:4700:3035::6815:7a8 127.0.0.53:53
40 | mrkaran.dev. AAAA IN 284s 2606:4700:3030::ac43:bbef 127.0.0.53:53
41 | ```
42 |
43 | ### Forcing IPv4 or IPv6
44 |
45 | You can force Doggo to use only IPv4 or IPv6 with the `-4` and `-6` flags respectively:
46 |
47 | #### IPv4 Only (Default behavior)
48 |
49 | ```bash
50 | $ doggo -4 mrkaran.dev
51 | ```
52 |
53 | #### IPv6 Only
54 |
55 | ```bash
56 | $ doggo -6 mrkaran.dev
57 | ```
58 |
--------------------------------------------------------------------------------
/docs/src/content/docs/features/multiple.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Multiple Resolvers
3 | description: Learn how to use multiple DNS resolvers simultaneously with Doggo
4 | ---
5 |
6 | Doggo supports querying multiple DNS resolvers simultaneously, allowing you to compare responses or use different resolvers for different purposes.
7 |
8 | ### Using Multiple Resolvers
9 |
10 | To use multiple resolvers, simply specify them in your command:
11 |
12 | ```bash
13 | $ doggo mrkaran.dev @1.1.1.1 @8.8.8.8 @9.9.9.9
14 | ```
15 |
16 | This will query the domain `mrkaran.dev` using Cloudflare (1.1.1.1), Google (8.8.8.8), and Quad9 (9.9.9.9) DNS servers.
17 |
18 | ### Mixing Resolver Types
19 |
20 | You can mix different types of resolvers in a single query:
21 |
22 | ```bash
23 | doggo mrkaran.dev @1.1.1.1 @https://dns.google/dns-query @tls://9.9.9.9
24 | ```
25 |
26 | This command uses a standard DNS resolver (1.1.1.1), a DoH resolver (Google), and a DoT resolver (Quad9).
27 |
--------------------------------------------------------------------------------
/docs/src/content/docs/features/output.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Output Formats
3 | description: Learn about Doggo's various output formats including colored, JSON, and short outputs
4 | ---
5 |
6 | Doggo provides flexible output formats to suit different use cases, from human-readable colored output to machine-parsable JSON.
7 |
8 | ### Colored Output
9 |
10 | By default, Doggo uses a colored, tabular format for easy readability.
11 |
12 | ```bash
13 | doggo mrkaran.dev
14 | NAME TYPE CLASS TTL ADDRESS NAMESERVER
15 | mrkaran.dev. A IN 300s 104.21.7.168 127.0.0.53:53
16 | mrkaran.dev. A IN 300s 172.67.187.239 127.0.0.53:53
17 | ```
18 |
19 | ```bash
20 | doggo mrkaran.dev --gp-from Europe,Asia --gp-limit 2
21 | LOCATION NAME TYPE CLASS TTL ADDRESS NAMESERVER
22 | Vienna, AT, EU, EDIS GmbH
23 | (AS57169)
24 | mrkaran.dev. A IN 300s 104.21.7.168 private
25 | mrkaran.dev. A IN 300s 172.67.187.239 private
26 | Tokyo, JP, AS, Tencent
27 | Building, Kejizhongyi Avenue
28 | (AS132203)
29 | mrkaran.dev. A IN 300s 104.21.7.168 private
30 | mrkaran.dev. A IN 300s 172.67.187.239 private
31 | ```
32 |
33 | To disable colored output, use the `--color=false` flag:
34 |
35 | ```bash
36 | doggo mrkaran.dev --color=false
37 | ```
38 |
39 | ### JSON Output
40 |
41 | For scripting and programmatic use, Doggo supports JSON output using the `--json` or `-J` flag:
42 |
43 | ```bash
44 | doggo internetfreedom.in --json | jq
45 | ```
46 |
47 | ```json
48 | {
49 | "responses": {
50 | "answers": [
51 | {
52 | "name": "internetfreedom.in.",
53 | "type": "A",
54 | "class": "IN",
55 | "ttl": "22s",
56 | "address": "104.27.158.96",
57 | "rtt": "37ms",
58 | "nameserver": "127.0.0.1:53"
59 | }
60 | // ... more entries ...
61 | ],
62 | "queries": [
63 | {
64 | "name": "internetfreedom.in.",
65 | "type": "A",
66 | "class": "IN"
67 | }
68 | ]
69 | }
70 | }
71 | ```
72 |
73 | ```bash
74 | doggo mrkaran.dev --gp-from Europe,Asia --gp-limit 2 --json | jq
75 | ```
76 |
77 | ```json
78 | {
79 | "responses": [
80 | {
81 | "location": "Groningen, NL, EU, Google LLC (AS396982)",
82 | "answers": [
83 | {
84 | "name": "mrkaran.dev.",
85 | "type": "A",
86 | "class": "IN",
87 | "ttl": "300s",
88 | "address": "172.67.187.239",
89 | "status": "",
90 | "rtt": "",
91 | "nameserver": "private"
92 | }
93 | // ... more entries ...
94 | ]
95 | },
96 | {
97 | "location": "Jakarta, ID, AS, Zenlayer Inc (AS21859)",
98 | "answers": [
99 | {
100 | "name": "mrkaran.dev.",
101 | "type": "A",
102 | "class": "IN",
103 | "ttl": "300s",
104 | "address": "172.67.187.239",
105 | "status": "",
106 | "rtt": "",
107 | "nameserver": "private"
108 | }
109 | // ... more entries ...
110 | ]
111 | }
112 | ]
113 | }
114 | ```
115 |
116 | ### Short Output
117 |
118 | For a more concise view, use the `--short` flag to show only the response section:
119 |
120 | ```bash
121 | doggo mrkaran.dev --short
122 | 104.21.7.168
123 | 172.67.187.239
124 | ```
125 |
126 | ```bash
127 | doggo mrkaran.dev --gp-from Europe,Asia --gp-limit 2 --short
128 | Frankfurt, DE, EU, WIBO Baltic UAB (AS59939)
129 | 104.21.7.168
130 | 172.67.187.239
131 | Saratov, RU, AS, LLC "SMART CENTER" (AS48763)
132 | 172.67.187.239
133 | 104.21.7.168
134 | ```
135 |
--------------------------------------------------------------------------------
/docs/src/content/docs/features/reverse.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Reverse IP Lookups
3 | description: Learn how to perform reverse IP lookups with Doggo
4 | ---
5 |
6 | Doggo supports reverse IP lookups, allowing you to find the domain name associated with a given IP address. This feature is particularly useful for network diagnostics, security analysis, and understanding the ownership of IP addresses.
7 |
8 | ### Performing a Reverse IP Lookup
9 |
10 | To perform a reverse IP lookup, use the `--reverse` flag followed by the IP address:
11 |
12 | ```bash
13 | doggo --reverse 8.8.4.4
14 | ```
15 |
16 | ### Short Output Format
17 |
18 | You can combine the reverse lookup with the `--short` flag to get a concise output:
19 |
20 | ```bash
21 | doggo --reverse 8.8.4.4 --short
22 | dns.google.
23 | ```
24 |
25 | This command returns only the domain name associated with the IP address, without any additional information.
26 |
27 | ### Full Output Format
28 |
29 | Without the `--short` flag, Doggo will provide more detailed information:
30 |
31 | ```bash
32 | $ doggo --reverse 8.8.4.4
33 | NAME TYPE CLASS TTL ADDRESS NAMESERVER
34 | 4.4.8.8.in-addr.arpa. PTR IN 21599s dns.google. 127.0.0.53:53
35 | ```
36 |
37 | ### IPv6 Support
38 |
39 | Reverse IP lookups also work with IPv6 addresses:
40 |
41 | ```bash
42 | $ doggo --reverse 2001:4860:4860::8888 --short
43 | dns.google.
44 | ```
45 |
--------------------------------------------------------------------------------
/docs/src/content/docs/features/shell.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Shell Completions
3 | description: Learn how to use Doggo's shell completions for zsh and fish
4 | ---
5 |
6 | Doggo provides shell completions for `zsh` and `fish`, enhancing your command-line experience with auto-completion for commands and options.
7 |
8 | ### Bash Completions
9 |
10 | To enable Bash completions for Doggo:
11 |
12 | 1. Generate the completion script:
13 |
14 | ```bash
15 | doggo completions bash > doggo_completion.bash
16 | ```
17 |
18 | 2. Source the generated file in your `.bashrc` or `.bash_profile`:
19 |
20 | ```bash
21 | echo "source ~/path/to/doggo_completion.bash" >> ~/.bashrc
22 | ```
23 |
24 | Replace `~/path/to/` with the actual path where you saved the completion script.
25 |
26 | 3. Restart your shell or run `source ~/.bashrc`.
27 |
28 |
29 | ### Zsh Completions
30 |
31 | To enable Zsh completions for Doggo:
32 |
33 | 1. Ensure that shell completions are enabled in your `.zshrc` file:
34 |
35 | ```zsh
36 | autoload -U compinit
37 | compinit
38 | ```
39 |
40 | 2. Generate the completion script and add it to your Zsh functions path:
41 |
42 | ```bash
43 | doggo completions zsh > "${fpath[1]}/_doggo"
44 | ```
45 |
46 | 3. Restart your shell or run `source ~/.zshrc`.
47 |
48 | Now you can use Tab to auto-complete Doggo commands and options in Zsh.
49 |
50 | ### Fish Completions
51 |
52 | To enable Fish completions for Doggo:
53 |
54 | 1. Generate the completion script and save it to the Fish completions directory:
55 |
56 | ```bash
57 | $ doggo completions fish > ~/.config/fish/completions/doggo.fish
58 | ```
59 |
60 | 2. Restart your Fish shell or run `source ~/.config/fish/config.fish`.
61 |
62 | You can now use Tab to auto-complete Doggo commands and options in Fish.
63 |
64 | ### Using Completions
65 |
66 | With completions enabled, you can:
67 |
68 | - Auto-complete command-line flags (e.g., `doggo --
11 |
12 |
14 |
15 |
66 |
67 |
68 |
80 |
81 |
90 |
91 |
92 |
98 |
99 |
100 |
101 |
--------------------------------------------------------------------------------
/www/api/api.md:
--------------------------------------------------------------------------------
1 | # Usage
2 |
3 | ```
4 | curl --request POST \
5 | --url http://localhost:8080/lookup/ \
6 | --header 'Content-Type: application/json' \
7 | --data '{
8 | "query": ["mrkaran.dev"],
9 | "type": ["A"],
10 | "class": ["IN"],
11 | "nameservers": ["9.9.9.9"]
12 | }'
13 | ```
14 |
--------------------------------------------------------------------------------
/www/static/doggo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mr-karan/doggo/16ba284a136354fb4f11fd4d566db9b4364e9a32/www/static/doggo.png
--------------------------------------------------------------------------------
/www/static/help.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mr-karan/doggo/16ba284a136354fb4f11fd4d566db9b4364e9a32/www/static/help.png
--------------------------------------------------------------------------------