-
-
Notifications
You must be signed in to change notification settings - Fork 25
/
query.go
148 lines (121 loc) · 3.79 KB
/
query.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
// Copyright 2020 Oz Tiram <[email protected]>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package netbox
import (
"encoding/json"
"fmt"
"net"
"net/http"
"strings"
"github.com/coredns/coredns/plugin/pkg/dnsutil"
)
type Record struct {
Family Family `json:"family"`
Address string `json:"address"`
HostName string `json:"dns_name,omitempty"`
}
type Family struct {
Version int `json:"value"`
Label string `json:"label"`
}
type RecordsList struct {
Records []Record `json:"results"`
}
func get(client *http.Client, url, token string) (*http.Response, error) {
// handle if provided client was not set up
if client == nil {
return nil, fmt.Errorf("provided *http.Client was invalid")
}
// set up HTTP request
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
// set authorization header for request to NetBox
req.Header.Set("Authorization", fmt.Sprintf("Token %s", token))
// do request
return client.Do(req)
}
func (n *Netbox) query(host string, family int) ([]net.IP, error) {
var (
dns_name = strings.TrimSuffix(host, ".")
requrl = fmt.Sprintf("%s/?dns_name=%s", n.Url, dns_name)
records RecordsList
)
// Initialise an empty slice of IP addresses
addresses := make([]net.IP, 0)
// do http request against NetBox instance
resp, err := get(n.Client, requrl, n.Token)
if err != nil {
return addresses, fmt.Errorf("Problem performing request: %w", err)
}
// ensure body is closed once we are done
defer resp.Body.Close()
// status code must be http.StatusOK
if resp.StatusCode != http.StatusOK {
return addresses, fmt.Errorf("Bad HTTP response code: %d", resp.StatusCode)
}
// read and parse response body
decoder := json.NewDecoder(resp.Body)
if err := decoder.Decode(&records); err != nil {
return addresses, fmt.Errorf("Could not unmarshal response: %w", err)
}
// handle empty list of records
if len(records.Records) == 0 {
return addresses, nil
}
// grab returned address of specified address family
for _, r := range records.Records {
if r.Family.Version == family {
if addr := net.ParseIP(strings.Split(r.Address, "/")[0]); addr != nil {
addresses = append(addresses, addr)
}
}
}
return addresses, nil
}
func (n *Netbox) queryreverse(host string) ([]string, error) {
var (
ip = dnsutil.ExtractAddressFromReverse(host)
requrl = fmt.Sprintf("%s/?address=%s", n.Url, ip)
records RecordsList
)
// // Initialise an empty slice of domains
domains := make([]string, 0)
// do http request against NetBox instance
resp, err := get(n.Client, requrl, n.Token)
if err != nil {
return domains, fmt.Errorf("Problem performing request: %w", err)
}
// ensure body is closed once we are done
defer resp.Body.Close()
// status code must be http.StatusOK
if resp.StatusCode != http.StatusOK {
return domains, fmt.Errorf("Bad HTTP response code: %d", resp.StatusCode)
}
// read and parse response body
decoder := json.NewDecoder(resp.Body)
if err := decoder.Decode(&records); err != nil {
return domains, fmt.Errorf("Could not unmarshal response: %w", err)
}
// handle empty list of records
if len(records.Records) == 0 {
return domains, nil
}
// grab returned domains
for _, r := range records.Records {
domains = append(domains, strings.TrimSuffix(r.HostName, ".")+".")
}
return domains, nil
}