135 lines
3.2 KiB
Go
135 lines
3.2 KiB
Go
package envs
|
|
|
|
import (
|
|
`bytes`
|
|
`errors`
|
|
`fmt`
|
|
`io/ioutil`
|
|
`os`
|
|
`strings`
|
|
|
|
`r00t2.io/sysutils/internal`
|
|
`r00t2.io/sysutils/paths`
|
|
)
|
|
|
|
// GetPathEnv returns a slice of the PATH variable's items.
|
|
func GetPathEnv() (pathList []string, err error) {
|
|
|
|
var pathVar string = internal.GetPathEnvName()
|
|
|
|
pathList = make([]string, 0)
|
|
|
|
for _, p := range strings.Split(os.Getenv(pathVar), string(os.PathListSeparator)) {
|
|
if err = paths.RealPath(&p); err != nil {
|
|
return
|
|
}
|
|
pathList = append(pathList, p)
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetEnvMap returns a map of all environment variables. All values are strings.
|
|
func GetEnvMap() (envVars map[string]string) {
|
|
|
|
var envList []string = os.Environ()
|
|
|
|
envVars = envListToMap(envList)
|
|
|
|
return
|
|
}
|
|
|
|
/*
|
|
GetEnvMapNative returns a map of all environment variables, but attempts to "nativize" them.
|
|
All values are interfaces. It is up to the caller to typeswitch them to proper types.
|
|
|
|
Note that the PATH/Path environment variable (for *Nix and Windows, respectively) will be
|
|
a []string (as per GetPathEnv). No other env vars, even if they contain os.PathListSeparator,
|
|
will be transformed to a slice or the like.
|
|
If an error occurs during parsing the path env var, it will be rendered as a string.
|
|
|
|
All number types will attempt to be their 64-bit version (i.e. int64, uint64, float64, etc.).
|
|
|
|
If a type cannot be determined for a value, its string form will be used
|
|
(as it would be found in GetEnvMap).
|
|
*/
|
|
func GetEnvMapNative() (envMap map[string]interface{}) {
|
|
|
|
var stringMap map[string]string = GetEnvMap()
|
|
|
|
envMap = nativizeEnvMap(stringMap)
|
|
|
|
return
|
|
}
|
|
|
|
/*
|
|
GetPidEnvMap will only work on *NIX-like systems with procfs.
|
|
It gets the environment variables of a given process' PID.
|
|
*/
|
|
func GetPidEnvMap(pid uint32) (envMap map[string]string, err error) {
|
|
|
|
var envBytes []byte
|
|
var envList []string
|
|
var envArr [][]byte
|
|
var procPath string
|
|
var exists bool
|
|
|
|
envMap = make(map[string]string, 0)
|
|
|
|
procPath = fmt.Sprintf("/proc/%v/environ", pid)
|
|
|
|
if exists, err = paths.RealPathExists(&procPath); err != nil {
|
|
return
|
|
}
|
|
if !exists {
|
|
err = errors.New(fmt.Sprintf("information for pid %v does not exist", pid))
|
|
return
|
|
}
|
|
|
|
if envBytes, err = ioutil.ReadFile(procPath); err != nil {
|
|
return
|
|
}
|
|
|
|
envArr = bytes.Split(envBytes, []byte{0x0})
|
|
envList = make([]string, len(envArr))
|
|
for idx, b := range envArr {
|
|
envList[idx] = string(b)
|
|
}
|
|
|
|
envMap = envListToMap(envList)
|
|
|
|
return
|
|
}
|
|
|
|
/*
|
|
GetPidEnvMapNative, like GetEnvMapNative, returns a map of all environment variables, but attempts to "nativize" them.
|
|
All values are interfaces. It is up to the caller to typeswitch them to proper types.
|
|
|
|
See the documentation for GetEnvMapNative for details.
|
|
*/
|
|
func GetPidEnvMapNative(pid uint32) (envMap map[string]interface{}, err error) {
|
|
|
|
var stringMap map[string]string
|
|
|
|
if stringMap, err = GetPidEnvMap(pid); err != nil {
|
|
return
|
|
}
|
|
|
|
envMap = nativizeEnvMap(stringMap)
|
|
|
|
return
|
|
}
|
|
|
|
/*
|
|
HasEnv is much like os.LookupEnv, but only returns a boolean for
|
|
if the environment variable key exists or not.
|
|
|
|
This is useful anywhere you may need to set a boolean in a func call
|
|
depending on the *presence* of an env var or not.
|
|
*/
|
|
func HasEnv(key string) (envIsSet bool) {
|
|
|
|
_, envIsSet = os.LookupEnv(key)
|
|
|
|
return
|
|
}
|