Suggestion: Expose environment

[tejasmanohar]

Would be useful to expose environment variables a la psutil.Process().environ() in Python

[shirou]

Thank you for your suggestion.

• FreeBSD: procstat -e
• Mac OS X: ps eww
• Windows:
  • powershell: (Get-Process -id ).StartInfo.EnvironmentVariables
  • syscall.GetEnvironmentStrings() can not used because it returns only that process information.
  • kernel32's ReadProcessMemory function

Hmm, so I can get environment variable and psutils also have that method, I will try to add. But I can not promise when to start.

[tejasmanohar]

@shirou I will send PR for OS X soon :)

[dastergon]

Hi @tejasmanohar, Any updates on this feature implementation? I find it a really useful

[tejasmanohar]

Sorry, got busy with other things :\

[Ferguzz]

i would find this feature very useful

[tejasmanohar]

I no longer need it so probably not gonna submit a PR in near future. Feel free to tackle!

[Lomanic]

Thinking about implementing this, we will return a map[string]string. I'm quite unsure how to parse ps -p $PID eww -o command= (darwin), as it includes the executable path and there might be spaces in this path and in variables, will need some testing.

Re: Linux, there is /proc/$PID/environ, as used in psutil, even if it is not updated after process init (option would be to attach a debugger like gdb but this is out of the question).

[Lomanic]

Related psutil issue giampaolo/psutil#52

[Ferguzz]

psutil use a sysctl call to get the environ. with some finessing this code will do the job.

package main

import (
	"bytes"
	"encoding/binary"
	"golang.org/x/sys/unix"
	"syscall"
	"unsafe"
)

const (
	CTL_KERN       = 1
	KERN_ARGMAX    = 8
	KERN_PROCARGS2 = 49
)

func sysctl(mib []int32, out unsafe.Pointer, n uintptr) syscall.Errno {
	_, _, e := unix.Syscall6(
		unix.SYS___SYSCTL,
		uintptr(unsafe.Pointer(&mib[0])),
		uintptr(len(mib)),
		uintptr(out),
		uintptr(unsafe.Pointer(&n)),
		uintptr(unsafe.Pointer(nil)),
		0,
	)
	return e
}

func Environ(pid int32) (map[string]string, error) {
	var argmax int32
	if err := sysctl([]int32{CTL_KERN, KERN_ARGMAX}, unsafe.Pointer(&argmax), unsafe.Sizeof(argmax)); err != 0 {
		return nil, err
	}

	procargs := make([]byte, argmax)
	if err := sysctl([]int32{CTL_KERN, KERN_PROCARGS2, pid}, unsafe.Pointer(&procargs[0]), uintptr(argmax)); err != 0 {
		return nil, err
	}

	var argc uint32
	argc = binary.LittleEndian.Uint32(procargs[:unsafe.Sizeof(argc)])
	procargs = procargs[unsafe.Sizeof(argc):]

	// the command portion is terminated with a null byte
	argsIndex := bytes.Index(procargs, []byte("\000"))

        // arguments and environment vars are also null byte seperated
	args := bytes.Split(procargs[argsIndex:], []byte("\000"))

	// find the end of the argv portion of the output
	environIndex := 0
	for ; argc > 0; environIndex++ {
		if !bytes.Equal(args[environIndex], nil) {
			argc--
		}
	}

	environ := make(map[string]string)
	for _, env := range args[environIndex:] {
		if !bytes.Equal(env, nil) {
			kv := bytes.Split(env, []byte("="))
			environ[string(kv[0])] = string(kv[1])
		}
	}

	return environ, nil
}