diff options
Diffstat (limited to 'vendor/golang.org/x/sys/unix/mksysctl_openbsd.go')
-rw-r--r-- | vendor/golang.org/x/sys/unix/mksysctl_openbsd.go | 355 |
1 files changed, 355 insertions, 0 deletions
diff --git a/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go b/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go new file mode 100644 index 0000000..b6b4099 --- /dev/null +++ b/vendor/golang.org/x/sys/unix/mksysctl_openbsd.go | |||
@@ -0,0 +1,355 @@ | |||
1 | // Copyright 2019 The Go Authors. All rights reserved. | ||
2 | // Use of this source code is governed by a BSD-style | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | // +build ignore | ||
6 | |||
7 | // Parse the header files for OpenBSD and generate a Go usable sysctl MIB. | ||
8 | // | ||
9 | // Build a MIB with each entry being an array containing the level, type and | ||
10 | // a hash that will contain additional entries if the current entry is a node. | ||
11 | // We then walk this MIB and create a flattened sysctl name to OID hash. | ||
12 | |||
13 | package main | ||
14 | |||
15 | import ( | ||
16 | "bufio" | ||
17 | "fmt" | ||
18 | "os" | ||
19 | "path/filepath" | ||
20 | "regexp" | ||
21 | "sort" | ||
22 | "strings" | ||
23 | ) | ||
24 | |||
25 | var ( | ||
26 | goos, goarch string | ||
27 | ) | ||
28 | |||
29 | // cmdLine returns this programs's commandline arguments. | ||
30 | func cmdLine() string { | ||
31 | return "go run mksysctl_openbsd.go " + strings.Join(os.Args[1:], " ") | ||
32 | } | ||
33 | |||
34 | // buildTags returns build tags. | ||
35 | func buildTags() string { | ||
36 | return fmt.Sprintf("%s,%s", goarch, goos) | ||
37 | } | ||
38 | |||
39 | // reMatch performs regular expression match and stores the substring slice to value pointed by m. | ||
40 | func reMatch(re *regexp.Regexp, str string, m *[]string) bool { | ||
41 | *m = re.FindStringSubmatch(str) | ||
42 | if *m != nil { | ||
43 | return true | ||
44 | } | ||
45 | return false | ||
46 | } | ||
47 | |||
48 | type nodeElement struct { | ||
49 | n int | ||
50 | t string | ||
51 | pE *map[string]nodeElement | ||
52 | } | ||
53 | |||
54 | var ( | ||
55 | debugEnabled bool | ||
56 | mib map[string]nodeElement | ||
57 | node *map[string]nodeElement | ||
58 | nodeMap map[string]string | ||
59 | sysCtl []string | ||
60 | ) | ||
61 | |||
62 | var ( | ||
63 | ctlNames1RE = regexp.MustCompile(`^#define\s+(CTL_NAMES)\s+{`) | ||
64 | ctlNames2RE = regexp.MustCompile(`^#define\s+(CTL_(.*)_NAMES)\s+{`) | ||
65 | ctlNames3RE = regexp.MustCompile(`^#define\s+((.*)CTL_NAMES)\s+{`) | ||
66 | netInetRE = regexp.MustCompile(`^netinet/`) | ||
67 | netInet6RE = regexp.MustCompile(`^netinet6/`) | ||
68 | netRE = regexp.MustCompile(`^net/`) | ||
69 | bracesRE = regexp.MustCompile(`{.*}`) | ||
70 | ctlTypeRE = regexp.MustCompile(`{\s+"(\w+)",\s+(CTLTYPE_[A-Z]+)\s+}`) | ||
71 | fsNetKernRE = regexp.MustCompile(`^(fs|net|kern)_`) | ||
72 | ) | ||
73 | |||
74 | func debug(s string) { | ||
75 | if debugEnabled { | ||
76 | fmt.Fprintln(os.Stderr, s) | ||
77 | } | ||
78 | } | ||
79 | |||
80 | // Walk the MIB and build a sysctl name to OID mapping. | ||
81 | func buildSysctl(pNode *map[string]nodeElement, name string, oid []int) { | ||
82 | lNode := pNode // local copy of pointer to node | ||
83 | var keys []string | ||
84 | for k := range *lNode { | ||
85 | keys = append(keys, k) | ||
86 | } | ||
87 | sort.Strings(keys) | ||
88 | |||
89 | for _, key := range keys { | ||
90 | nodename := name | ||
91 | if name != "" { | ||
92 | nodename += "." | ||
93 | } | ||
94 | nodename += key | ||
95 | |||
96 | nodeoid := append(oid, (*pNode)[key].n) | ||
97 | |||
98 | if (*pNode)[key].t == `CTLTYPE_NODE` { | ||
99 | if _, ok := nodeMap[nodename]; ok { | ||
100 | lNode = &mib | ||
101 | ctlName := nodeMap[nodename] | ||
102 | for _, part := range strings.Split(ctlName, ".") { | ||
103 | lNode = ((*lNode)[part]).pE | ||
104 | } | ||
105 | } else { | ||
106 | lNode = (*pNode)[key].pE | ||
107 | } | ||
108 | buildSysctl(lNode, nodename, nodeoid) | ||
109 | } else if (*pNode)[key].t != "" { | ||
110 | oidStr := []string{} | ||
111 | for j := range nodeoid { | ||
112 | oidStr = append(oidStr, fmt.Sprintf("%d", nodeoid[j])) | ||
113 | } | ||
114 | text := "\t{ \"" + nodename + "\", []_C_int{ " + strings.Join(oidStr, ", ") + " } }, \n" | ||
115 | sysCtl = append(sysCtl, text) | ||
116 | } | ||
117 | } | ||
118 | } | ||
119 | |||
120 | func main() { | ||
121 | // Get the OS (using GOOS_TARGET if it exist) | ||
122 | goos = os.Getenv("GOOS_TARGET") | ||
123 | if goos == "" { | ||
124 | goos = os.Getenv("GOOS") | ||
125 | } | ||
126 | // Get the architecture (using GOARCH_TARGET if it exists) | ||
127 | goarch = os.Getenv("GOARCH_TARGET") | ||
128 | if goarch == "" { | ||
129 | goarch = os.Getenv("GOARCH") | ||
130 | } | ||
131 | // Check if GOOS and GOARCH environment variables are defined | ||
132 | if goarch == "" || goos == "" { | ||
133 | fmt.Fprintf(os.Stderr, "GOARCH or GOOS not defined in environment\n") | ||
134 | os.Exit(1) | ||
135 | } | ||
136 | |||
137 | mib = make(map[string]nodeElement) | ||
138 | headers := [...]string{ | ||
139 | `sys/sysctl.h`, | ||
140 | `sys/socket.h`, | ||
141 | `sys/tty.h`, | ||
142 | `sys/malloc.h`, | ||
143 | `sys/mount.h`, | ||
144 | `sys/namei.h`, | ||
145 | `sys/sem.h`, | ||
146 | `sys/shm.h`, | ||
147 | `sys/vmmeter.h`, | ||
148 | `uvm/uvmexp.h`, | ||
149 | `uvm/uvm_param.h`, | ||
150 | `uvm/uvm_swap_encrypt.h`, | ||
151 | `ddb/db_var.h`, | ||
152 | `net/if.h`, | ||
153 | `net/if_pfsync.h`, | ||
154 | `net/pipex.h`, | ||
155 | `netinet/in.h`, | ||
156 | `netinet/icmp_var.h`, | ||
157 | `netinet/igmp_var.h`, | ||
158 | `netinet/ip_ah.h`, | ||
159 | `netinet/ip_carp.h`, | ||
160 | `netinet/ip_divert.h`, | ||
161 | `netinet/ip_esp.h`, | ||
162 | `netinet/ip_ether.h`, | ||
163 | `netinet/ip_gre.h`, | ||
164 | `netinet/ip_ipcomp.h`, | ||
165 | `netinet/ip_ipip.h`, | ||
166 | `netinet/pim_var.h`, | ||
167 | `netinet/tcp_var.h`, | ||
168 | `netinet/udp_var.h`, | ||
169 | `netinet6/in6.h`, | ||
170 | `netinet6/ip6_divert.h`, | ||
171 | `netinet6/pim6_var.h`, | ||
172 | `netinet/icmp6.h`, | ||
173 | `netmpls/mpls.h`, | ||
174 | } | ||
175 | |||
176 | ctls := [...]string{ | ||
177 | `kern`, | ||
178 | `vm`, | ||
179 | `fs`, | ||
180 | `net`, | ||
181 | //debug /* Special handling required */ | ||
182 | `hw`, | ||
183 | //machdep /* Arch specific */ | ||
184 | `user`, | ||
185 | `ddb`, | ||
186 | //vfs /* Special handling required */ | ||
187 | `fs.posix`, | ||
188 | `kern.forkstat`, | ||
189 | `kern.intrcnt`, | ||
190 | `kern.malloc`, | ||
191 | `kern.nchstats`, | ||
192 | `kern.seminfo`, | ||
193 | `kern.shminfo`, | ||
194 | `kern.timecounter`, | ||
195 | `kern.tty`, | ||
196 | `kern.watchdog`, | ||
197 | `net.bpf`, | ||
198 | `net.ifq`, | ||
199 | `net.inet`, | ||
200 | `net.inet.ah`, | ||
201 | `net.inet.carp`, | ||
202 | `net.inet.divert`, | ||
203 | `net.inet.esp`, | ||
204 | `net.inet.etherip`, | ||
205 | `net.inet.gre`, | ||
206 | `net.inet.icmp`, | ||
207 | `net.inet.igmp`, | ||
208 | `net.inet.ip`, | ||
209 | `net.inet.ip.ifq`, | ||
210 | `net.inet.ipcomp`, | ||
211 | `net.inet.ipip`, | ||
212 | `net.inet.mobileip`, | ||
213 | `net.inet.pfsync`, | ||
214 | `net.inet.pim`, | ||
215 | `net.inet.tcp`, | ||
216 | `net.inet.udp`, | ||
217 | `net.inet6`, | ||
218 | `net.inet6.divert`, | ||
219 | `net.inet6.ip6`, | ||
220 | `net.inet6.icmp6`, | ||
221 | `net.inet6.pim6`, | ||
222 | `net.inet6.tcp6`, | ||
223 | `net.inet6.udp6`, | ||
224 | `net.mpls`, | ||
225 | `net.mpls.ifq`, | ||
226 | `net.key`, | ||
227 | `net.pflow`, | ||
228 | `net.pfsync`, | ||
229 | `net.pipex`, | ||
230 | `net.rt`, | ||
231 | `vm.swapencrypt`, | ||
232 | //vfsgenctl /* Special handling required */ | ||
233 | } | ||
234 | |||
235 | // Node name "fixups" | ||
236 | ctlMap := map[string]string{ | ||
237 | "ipproto": "net.inet", | ||
238 | "net.inet.ipproto": "net.inet", | ||
239 | "net.inet6.ipv6proto": "net.inet6", | ||
240 | "net.inet6.ipv6": "net.inet6.ip6", | ||
241 | "net.inet.icmpv6": "net.inet6.icmp6", | ||
242 | "net.inet6.divert6": "net.inet6.divert", | ||
243 | "net.inet6.tcp6": "net.inet.tcp", | ||
244 | "net.inet6.udp6": "net.inet.udp", | ||
245 | "mpls": "net.mpls", | ||
246 | "swpenc": "vm.swapencrypt", | ||
247 | } | ||
248 | |||
249 | // Node mappings | ||
250 | nodeMap = map[string]string{ | ||
251 | "net.inet.ip.ifq": "net.ifq", | ||
252 | "net.inet.pfsync": "net.pfsync", | ||
253 | "net.mpls.ifq": "net.ifq", | ||
254 | } | ||
255 | |||
256 | mCtls := make(map[string]bool) | ||
257 | for _, ctl := range ctls { | ||
258 | mCtls[ctl] = true | ||
259 | } | ||
260 | |||
261 | for _, header := range headers { | ||
262 | debug("Processing " + header) | ||
263 | file, err := os.Open(filepath.Join("/usr/include", header)) | ||
264 | if err != nil { | ||
265 | fmt.Fprintf(os.Stderr, "%v\n", err) | ||
266 | os.Exit(1) | ||
267 | } | ||
268 | s := bufio.NewScanner(file) | ||
269 | for s.Scan() { | ||
270 | var sub []string | ||
271 | if reMatch(ctlNames1RE, s.Text(), &sub) || | ||
272 | reMatch(ctlNames2RE, s.Text(), &sub) || | ||
273 | reMatch(ctlNames3RE, s.Text(), &sub) { | ||
274 | if sub[1] == `CTL_NAMES` { | ||
275 | // Top level. | ||
276 | node = &mib | ||
277 | } else { | ||
278 | // Node. | ||
279 | nodename := strings.ToLower(sub[2]) | ||
280 | ctlName := "" | ||
281 | if reMatch(netInetRE, header, &sub) { | ||
282 | ctlName = "net.inet." + nodename | ||
283 | } else if reMatch(netInet6RE, header, &sub) { | ||
284 | ctlName = "net.inet6." + nodename | ||
285 | } else if reMatch(netRE, header, &sub) { | ||
286 | ctlName = "net." + nodename | ||
287 | } else { | ||
288 | ctlName = nodename | ||
289 | ctlName = fsNetKernRE.ReplaceAllString(ctlName, `$1.`) | ||
290 | } | ||
291 | |||
292 | if val, ok := ctlMap[ctlName]; ok { | ||
293 | ctlName = val | ||
294 | } | ||
295 | if _, ok := mCtls[ctlName]; !ok { | ||
296 | debug("Ignoring " + ctlName + "...") | ||
297 | continue | ||
298 | } | ||
299 | |||
300 | // Walk down from the top of the MIB. | ||
301 | node = &mib | ||
302 | for _, part := range strings.Split(ctlName, ".") { | ||
303 | if _, ok := (*node)[part]; !ok { | ||
304 | debug("Missing node " + part) | ||
305 | (*node)[part] = nodeElement{n: 0, t: "", pE: &map[string]nodeElement{}} | ||
306 | } | ||
307 | node = (*node)[part].pE | ||
308 | } | ||
309 | } | ||
310 | |||
311 | // Populate current node with entries. | ||
312 | i := -1 | ||
313 | for !strings.HasPrefix(s.Text(), "}") { | ||
314 | s.Scan() | ||
315 | if reMatch(bracesRE, s.Text(), &sub) { | ||
316 | i++ | ||
317 | } | ||
318 | if !reMatch(ctlTypeRE, s.Text(), &sub) { | ||
319 | continue | ||
320 | } | ||
321 | (*node)[sub[1]] = nodeElement{n: i, t: sub[2], pE: &map[string]nodeElement{}} | ||
322 | } | ||
323 | } | ||
324 | } | ||
325 | err = s.Err() | ||
326 | if err != nil { | ||
327 | fmt.Fprintf(os.Stderr, "%v\n", err) | ||
328 | os.Exit(1) | ||
329 | } | ||
330 | file.Close() | ||
331 | } | ||
332 | buildSysctl(&mib, "", []int{}) | ||
333 | |||
334 | sort.Strings(sysCtl) | ||
335 | text := strings.Join(sysCtl, "") | ||
336 | |||
337 | fmt.Printf(srcTemplate, cmdLine(), buildTags(), text) | ||
338 | } | ||
339 | |||
340 | const srcTemplate = `// %s | ||
341 | // Code generated by the command above; DO NOT EDIT. | ||
342 | |||
343 | // +build %s | ||
344 | |||
345 | package unix | ||
346 | |||
347 | type mibentry struct { | ||
348 | ctlname string | ||
349 | ctloid []_C_int | ||
350 | } | ||
351 | |||
352 | var sysctlMib = []mibentry { | ||
353 | %s | ||
354 | } | ||
355 | ` | ||