env/env.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
package env import ( "bufio" "fmt" "os" "strings" "syscall" "mvdan.cc/sh/v3/expand" ) func GenerateEnv() (expand.Environ, error) { // syscall.Uname _should_ be supported on all *nix systems and is backed // by posix var env expand.Environ uname := syscall.Utsname{} err := syscall.Uname(&uname) if err != nil { return env, err } // shell := "/bin/sh"? // $PATH is annoyingly non-standard, so we hardcode the var // to the binary paths described in the fhs standard. // in most cases, this will "just work" for people, but special // cases should be evaluated - this may need some adjustment in the future. // i am resistant to making it over-rideable. // // users can always call their special binaries with their full paths // if they are resistant to moving them for some reason. path := envString("PATH", "/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin") uname_os := envString("OS", charsToString(uname.Sysname[:])) uname_release := envString("RELEASE", charsToString(uname.Release[:])) uname_arch := envString("ARCH", charsToString(uname.Machine[:])) if err != nil { return env, err } // standards are extremely annoying about hostnames. // // "Note that there is no standard that // says that the hostname set by sethostname(2) // is the same string as the nodename field of // the struct returned by uname() (indeed, some // systems allow a 256-byte hostname and an 8-byte // nodename), but this is true on Linux. The same // holds for setdomainname(2) and the domainname field." // // in practice, there's usually not a difference between HOSTNAME // and NODENAME, so i've chosen to only expose HOSTNAME for the // sake of simplicity. i'm using the Golang implementation, which // does call out to uname, annoyingly. // // if this becomes an issue, i'll revisit it. i doubt it though. // tldr: i'm ignoring that golang's os.Hostname() implementation // isn't standards-compliant by the letter of the law. // in actual practice, the hostname and nodename // are always identical in every case i've observed. // // and i'm exposing only 1 because otherwise things get annoying. // shrug. h, err := os.Hostname() if err != nil { return env, err } uname_hostname := fmt.Sprintf("HOSTNAME=%s", h) // !OS_RELEASE_* VARS ARE NOT STANDARDS-BACKED! // OS_* vars may or may not exist depending on the distro in question, so // they're not reliable _at all_. they're scraped from /etc/os-release // and are useful for identifying specific Linux distros, or their versions. // // if you rely on these variables, I highly suggest checking for their // existence with test -z before utilizing them. there be no standards here. os_release, err := getOSRelease() if err != nil { return env, err } osReleaseID := envString("OS_RELEASE_ID", os_release.ID) osReleaseVersionID := envString("OS_RELEASE_VERSION_ID", os_release.VersionID) env = expand.ListEnviron(path, // normie shit uname_os, uname_hostname, uname_release, uname_arch, // uname-derivated env vars osReleaseID, osReleaseVersionID) // /etc/os-release return env, nil } func envString(key string, value string) string { return fmt.Sprintf("%s=%s", key, value) } func charsToString(arr []int8) string { b := make([]byte, 0, len(arr)) for _, v := range arr { if v == 0x00 { break } b = append(b, byte(v)) } return string(b) } // I want to keep this list as small as possible, since // this struct is unreliable. // design principle: only 1 way to do common things type OSRelease struct { ID string // distro name - "arch" VersionID string // for debian distros, this is set to "22.04" } // getOsRelease parses /etc/os-release data // into a struct func getOSRelease() (OSRelease, error) { var osr = OSRelease{} f, err := os.Open("/etc/os-release") if err != nil { return osr, err } defer f.Close() scanner := bufio.NewScanner(f) for scanner.Scan() { key, value, _ := strings.Cut(scanner.Text(), "=") value = strings.Trim(value, `"`) switch key { case "ID": osr.ID = value case "VERSION_ID": osr.VersionID = value } } return osr, nil }