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
13package main
14
15import (
16	"bufio"
17	"fmt"
18	"os"
19	"path/filepath"
20	"regexp"
21	"sort"
22	"strings"
23)
24
25var (
26	goos, goarch string
27)
28
29// cmdLine returns this programs's commandline arguments.
30func cmdLine() string {
31	return "go run mksysctl_openbsd.go " + strings.Join(os.Args[1:], " ")
32}
33
34// buildTags returns build tags.
35func 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.
40func 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
48type nodeElement struct {
49	n  int
50	t  string
51	pE *map[string]nodeElement
52}
53
54var (
55	debugEnabled bool
56	mib          map[string]nodeElement
57	node         *map[string]nodeElement
58	nodeMap      map[string]string
59	sysCtl       []string
60)
61
62var (
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
74func 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.
81func 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
120func 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/tcp_var.h`,
167		`netinet/udp_var.h`,
168		`netinet6/in6.h`,
169		`netinet6/ip6_divert.h`,
170		`netinet/icmp6.h`,
171		`netmpls/mpls.h`,
172	}
173
174	ctls := [...]string{
175		`kern`,
176		`vm`,
177		`fs`,
178		`net`,
179		//debug			/* Special handling required */
180		`hw`,
181		//machdep		/* Arch specific */
182		`user`,
183		`ddb`,
184		//vfs			/* Special handling required */
185		`fs.posix`,
186		`kern.forkstat`,
187		`kern.intrcnt`,
188		`kern.malloc`,
189		`kern.nchstats`,
190		`kern.seminfo`,
191		`kern.shminfo`,
192		`kern.timecounter`,
193		`kern.tty`,
194		`kern.watchdog`,
195		`net.bpf`,
196		`net.ifq`,
197		`net.inet`,
198		`net.inet.ah`,
199		`net.inet.carp`,
200		`net.inet.divert`,
201		`net.inet.esp`,
202		`net.inet.etherip`,
203		`net.inet.gre`,
204		`net.inet.icmp`,
205		`net.inet.igmp`,
206		`net.inet.ip`,
207		`net.inet.ip.ifq`,
208		`net.inet.ipcomp`,
209		`net.inet.ipip`,
210		`net.inet.mobileip`,
211		`net.inet.pfsync`,
212		`net.inet.tcp`,
213		`net.inet.udp`,
214		`net.inet6`,
215		`net.inet6.divert`,
216		`net.inet6.ip6`,
217		`net.inet6.icmp6`,
218		`net.inet6.tcp6`,
219		`net.inet6.udp6`,
220		`net.mpls`,
221		`net.mpls.ifq`,
222		`net.key`,
223		`net.pflow`,
224		`net.pfsync`,
225		`net.pipex`,
226		`net.rt`,
227		`vm.swapencrypt`,
228		//vfsgenctl		/* Special handling required */
229	}
230
231	// Node name "fixups"
232	ctlMap := map[string]string{
233		"ipproto":             "net.inet",
234		"net.inet.ipproto":    "net.inet",
235		"net.inet6.ipv6proto": "net.inet6",
236		"net.inet6.ipv6":      "net.inet6.ip6",
237		"net.inet.icmpv6":     "net.inet6.icmp6",
238		"net.inet6.divert6":   "net.inet6.divert",
239		"net.inet6.tcp6":      "net.inet.tcp",
240		"net.inet6.udp6":      "net.inet.udp",
241		"mpls":                "net.mpls",
242		"swpenc":              "vm.swapencrypt",
243	}
244
245	// Node mappings
246	nodeMap = map[string]string{
247		"net.inet.ip.ifq": "net.ifq",
248		"net.inet.pfsync": "net.pfsync",
249		"net.mpls.ifq":    "net.ifq",
250	}
251
252	mCtls := make(map[string]bool)
253	for _, ctl := range ctls {
254		mCtls[ctl] = true
255	}
256
257	for _, header := range headers {
258		debug("Processing " + header)
259		file, err := os.Open(filepath.Join("/usr/include", header))
260		if err != nil {
261			fmt.Fprintf(os.Stderr, "%v\n", err)
262			os.Exit(1)
263		}
264		s := bufio.NewScanner(file)
265		for s.Scan() {
266			var sub []string
267			if reMatch(ctlNames1RE, s.Text(), &sub) ||
268				reMatch(ctlNames2RE, s.Text(), &sub) ||
269				reMatch(ctlNames3RE, s.Text(), &sub) {
270				if sub[1] == `CTL_NAMES` {
271					// Top level.
272					node = &mib
273				} else {
274					// Node.
275					nodename := strings.ToLower(sub[2])
276					ctlName := ""
277					if reMatch(netInetRE, header, &sub) {
278						ctlName = "net.inet." + nodename
279					} else if reMatch(netInet6RE, header, &sub) {
280						ctlName = "net.inet6." + nodename
281					} else if reMatch(netRE, header, &sub) {
282						ctlName = "net." + nodename
283					} else {
284						ctlName = nodename
285						ctlName = fsNetKernRE.ReplaceAllString(ctlName, `$1.`)
286					}
287
288					if val, ok := ctlMap[ctlName]; ok {
289						ctlName = val
290					}
291					if _, ok := mCtls[ctlName]; !ok {
292						debug("Ignoring " + ctlName + "...")
293						continue
294					}
295
296					// Walk down from the top of the MIB.
297					node = &mib
298					for _, part := range strings.Split(ctlName, ".") {
299						if _, ok := (*node)[part]; !ok {
300							debug("Missing node " + part)
301							(*node)[part] = nodeElement{n: 0, t: "", pE: &map[string]nodeElement{}}
302						}
303						node = (*node)[part].pE
304					}
305				}
306
307				// Populate current node with entries.
308				i := -1
309				for !strings.HasPrefix(s.Text(), "}") {
310					s.Scan()
311					if reMatch(bracesRE, s.Text(), &sub) {
312						i++
313					}
314					if !reMatch(ctlTypeRE, s.Text(), &sub) {
315						continue
316					}
317					(*node)[sub[1]] = nodeElement{n: i, t: sub[2], pE: &map[string]nodeElement{}}
318				}
319			}
320		}
321		err = s.Err()
322		if err != nil {
323			fmt.Fprintf(os.Stderr, "%v\n", err)
324			os.Exit(1)
325		}
326		file.Close()
327	}
328	buildSysctl(&mib, "", []int{})
329
330	sort.Strings(sysCtl)
331	text := strings.Join(sysCtl, "")
332
333	fmt.Printf(srcTemplate, cmdLine(), buildTags(), text)
334}
335
336const srcTemplate = `// %s
337// Code generated by the command above; DO NOT EDIT.
338
339// +build %s
340
341package unix
342
343type mibentry struct {
344	ctlname string
345	ctloid []_C_int
346}
347
348var sysctlMib = []mibentry {
349%s
350}
351`
352