Reintroduce the necessary vendor bits for per-node IDs

* `shirou/gopsutil`
* `shirou/w32`

vendor/github.com/shirou/gopsutil/README.rst

@@ -1,318 +0,0 @@
-gopsutil: psutil for golang
-==============================
-
-.. image:: https://circleci.com/gh/shirou/gopsutil.svg?&style=shield
-        :target: https://circleci.com/gh/shirou/gopsutil
-
-.. image:: https://coveralls.io/repos/shirou/gopsutil/badge.svg?branch=master
-        :target: https://coveralls.io/r/shirou/gopsutil?branch=master
-
-.. image:: https://godoc.org/github.com/shirou/gopsutil?status.svg
-        :target: http://godoc.org/github.com/shirou/gopsutil
-
-This is a port of psutil (http://pythonhosted.org/psutil/). The challenge is porting all
-psutil functions on some architectures.
-
-
-.. highlights:: Breaking Changes!
-
-   Breaking changes is introduced at v2. See `issue 174 <https://github.com/shirou/gopsutil/issues/174>`_ .
-
-
-Migrating to v2
--------------------------
-
-On gopsutil itself, `v2migration.sh <https://github.com/shirou/gopsutil/blob/v2/v2migration.sh>`_ is used for migration. It can not be commonly used, but it may help you with migration.
-
-
-Tag semantics
-^^^^^^^^^^^^^^^
-
-gopsutil tag policy is almost same as Semantic Versioning, but automatically increase like Ubuntu versioning.
-
-for example, `v2.16.10` means
-
-- v2: major version
-- 16: release year, 2016
-- 10: release month
-
-gopsutil aims to keep backwards-compatiblity until major version change.
-
-Taged at every end of month, but there are only a few commits, it can be skipped.
-
-
-Available Architectures
-------------------------------------
-
-- FreeBSD i386/amd64
-- Linux i386/amd64/arm(raspberry pi)
-- Windows/amd64
-- Darwin/amd64
-- OpenBDS amd64 (Thank you @mpfz0r!)
-
-All works are implemented without cgo by porting c struct to golang struct.
-
-
-Usage
----------
-
-Note: gopsutil v2 breaks compatibility. If you want to stay with compatibility, please use v1 branch and vendoring.
-
-.. code:: go
-
-   package main
-
-   import (
-       "fmt"
-
-       "github.com/shirou/gopsutil/mem"
-   )
-
-   func main() {
-       v, _ := mem.VirtualMemory()
-
-       // almost every return value is a struct
-       fmt.Printf("Total: %v, Free:%v, UsedPercent:%f%%\n", v.Total, v.Free, v.UsedPercent)
-
-       // convert to JSON. String() is also implemented
-       fmt.Println(v)
-   }
-
-The output is below.
-
-::
-
-  Total: 3179569152, Free:284233728, UsedPercent:84.508194%
-  {"total":3179569152,"available":492572672,"used":2895335424,"usedPercent":84.50819439828305, (snip...)}
-
-You can set an alternative location to :code:`/proc` by setting the :code:`HOST_PROC` environment variable.
-
-You can set an alternative location to :code:`/sys` by setting the :code:`HOST_SYS` environment variable.
-
-You can set an alternative location to :code:`/etc` by setting the :code:`HOST_ETC` environment variable.
-
-Documentation
-------------------------
-
-see http://godoc.org/github.com/shirou/gopsutil
-
-Requirements
------------------
-
-- go1.5 or above is required.
-
-
-More Info
---------------------
-
-Several methods have been added which are not present in psutil, but will provide useful information.
-
-- host/HostInfo()  (linux)
-
-  - Hostname
-  - Uptime
-  - Procs
-  - OS                    (ex: "linux")
-  - Platform              (ex: "ubuntu", "arch")
-  - PlatformFamily        (ex: "debian")
-  - PlatformVersion       (ex: "Ubuntu 13.10")
-  - VirtualizationSystem  (ex: "LXC")
-  - VirtualizationRole    (ex: "guest"/"host")
-
-- cpu/CPUInfo()  (linux, freebsd)
-
-  - CPU          (ex: 0, 1, ...)
-  - VendorID     (ex: "GenuineIntel")
-  - Family
-  - Model
-  - Stepping
-  - PhysicalID
-  - CoreID
-  - Cores        (ex: 2)
-  - ModelName    (ex: "Intel(R) Core(TM) i7-2640M CPU @ 2.80GHz")
-  - Mhz
-  - CacheSize
-  - Flags        (ex: "fpu vme de pse tsc msr pae mce cx8 ...")
-
-- load/LoadAvg()  (linux, freebsd)
-
-  - Load1
-  - Load5
-  - Load15
-
-- docker/GetDockerIDList() (linux only)
-
-  - container id list ([]string)
-
-- docker/CgroupCPU() (linux only)
-
-  - user
-  - system
-
-- docker/CgroupMem() (linux only)
-
-  - various status
-
-- net_protocols (linux only)
-
-  - system wide stats on network protocols (i.e IP, TCP, UDP, etc.)
-  - sourced from /proc/net/snmp
-
-- iptables nf_conntrack (linux only)
-
-  - system wide stats on netfilter conntrack module
-  - sourced from /proc/sys/net/netfilter/nf_conntrack_count
-
-Some codes are ported from Ohai. many thanks.
-
-
-Current Status
-------------------
-
-- x: work
-- b: almost works, but something is broken
-
-=================== ====== ======= ======= ====== =======
-name                Linux  FreeBSD OpenBSD MacOSX Windows
-cpu_times             x      x       x       x       x
-cpu_count             x      x       x       x       x
-cpu_percent           x      x       x       x       x
-cpu_times_percent     x      x       x       x       x
-virtual_memory        x      x       x       x       x
-swap_memory           x      x       x       x
-disk_partitions       x      x       x       x       x
-disk_io_counters      x      x       x
-disk_usage            x      x       x       x       x
-net_io_counters       x      x       x       b       x
-boot_time             x      x       x       x       x
-users                 x      x       x       x       x
-pids                  x      x       x       x       x
-pid_exists            x      x       x       x       x
-net_connections       x                      x
-net_protocols         x
-net_if_addrs
-net_if_stats
-netfilter_conntrack   x
-=================== ====== ======= ======= ====== =======
-
-Process class
-^^^^^^^^^^^^^^^
-
-================ ===== ======= ======= ====== =======
-name             Linux FreeBSD OpenBSD MacOSX Windows
-pid                 x     x      x       x       x
-ppid                x     x      x       x       x
-name                x     x      x       x       x
-cmdline             x                    x       x
-create_time         x
-status              x     x      x       x
-cwd                 x
-exe                 x     x      x               x
-uids                x     x      x       x
-gids                x     x      x       x
-terminal            x     x      x       x
-io_counters         x     x      x               x
-nice                x     x      x       x       x
-num_fds             x
-num_ctx_switches    x
-num_threads         x     x      x       x       x
-cpu_times           x
-memory_info         x     x      x       x       x
-memory_info_ex      x
-memory_maps         x
-open_files          x
-send_signal         x     x      x       x
-suspend             x     x      x       x
-resume              x     x      x       x
-terminate           x     x      x       x       x
-kill                x     x      x       x
-username            x
-ionice
-rlimit
-num_handlres
-threads
-cpu_percent         x            x       x
-cpu_affinity
-memory_percent
-parent              x            x       x
-children            x     x      x       x
-connections         x            x       x
-is_running
-================ ===== ======= ======= ====== =======
-
-Original Metrics
-^^^^^^^^^^^^^^^^^^^
-
-================== ===== ======= ======= ====== =======
-item               Linux FreeBSD OpenBSD MacOSX Windows
-**HostInfo**
-hostname              x     x      x       x       x
-  uptime              x     x      x       x
-  proces              x     x      x
-  os                  x     x      x       x       x
-  platform            x     x      x       x
-  platformfamily      x     x      x       x
-  virtualization      x
-**CPU**
-  VendorID            x     x      x       x       x
-  Family              x     x      x       x       x
-  Model               x     x      x       x       x
-  Stepping            x     x      x       x       x
-  PhysicalID          x
-  CoreID              x
-  Cores               x                            x
-  ModelName           x     x      x       x       x
-**LoadAvg**
-  Load1               x     x      x       x
-  Load5               x     x      x       x
-  Load15              x     x      x       x
-**GetDockerID**
-  container id        x     no     no      no      no
-**CgroupsCPU**
-  user                x     no     no      no      no
-  system              x     no     no      no      no
-**CgroupsMem**
-  various             x     no     no      no      no
-================== ===== ======= ======= ====== =======
-
-- future work
-
-  - process_iter
-  - wait_procs
-  - Process class
-
-    - as_dict
-    - wait
-
-
-License
-------------
-
-New BSD License (same as psutil)
-
-
-Related Works
------------------------
-
-I have been influenced by the following great works:
-
-- psutil: http://pythonhosted.org/psutil/
-- dstat: https://github.com/dagwieers/dstat
-- gosigar: https://github.com/cloudfoundry/gosigar/
-- goprocinfo: https://github.com/c9s/goprocinfo
-- go-ps: https://github.com/mitchellh/go-ps
-- ohai: https://github.com/opscode/ohai/
-- bosun: https://github.com/bosun-monitor/bosun/tree/master/cmd/scollector/collectors
-- mackerel: https://github.com/mackerelio/mackerel-agent/tree/master/metrics
-
-How to Contribute
----------------------------
-
-1. Fork it
-2. Create your feature branch (git checkout -b my-new-feature)
-3. Commit your changes (git commit -am 'Add some feature')
-4. Push to the branch (git push origin my-new-feature)
-5. Create new Pull Request
-
-My English is terrible, so documentation or correcting comments are also
-welcome.

vendor/github.com/shirou/gopsutil/host/host_darwin_386.go

@@ -0,0 +1,19 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_darwin.go
+
+package host
+
+type Utmpx struct {
+	User      [256]int8
+	ID        [4]int8
+	Line      [32]int8
+	Pid       int32
+	Type      int16
+	Pad_cgo_0 [6]byte
+	Tv        Timeval
+	Host      [256]int8
+	Pad       [16]uint32
+}
+type Timeval struct {
+	Sec int32
+}

vendor/github.com/shirou/gopsutil/host/host_freebsd_arm.go

@@ -0,0 +1,44 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package host
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+	sizeOfUtmpx    = 197 // TODO: why should 197, not 0x118
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type Utmp struct {
+	Line [8]int8
+	Name [16]int8
+	Host [16]int8
+	Time int32
+}
+
+type Utmpx struct {
+	Type int16
+	Tv   Timeval
+	Id   [8]int8
+	Pid  int32
+	User [32]int8
+	Line [16]int8
+	Host [125]int8
+	//      Host [128]int8
+	//      X__ut_spare [64]int8
+}
+
+type Timeval struct {
+	Sec  [4]byte
+	Usec [3]byte
+}

vendor/github.com/shirou/gopsutil/process/process.go

@@ -0,0 +1,188 @@
+package process
+
+import (
+	"encoding/json"
+	"runtime"
+	"time"
+
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/mem"
+)
+
+var invoke common.Invoker
+
+func init() {
+	invoke = common.Invoke{}
+}
+
+type Process struct {
+	Pid            int32 `json:"pid"`
+	name           string
+	status         string
+	parent         int32
+	numCtxSwitches *NumCtxSwitchesStat
+	uids           []int32
+	gids           []int32
+	numThreads     int32
+	memInfo        *MemoryInfoStat
+
+	lastCPUTimes *cpu.TimesStat
+	lastCPUTime  time.Time
+}
+
+type OpenFilesStat struct {
+	Path string `json:"path"`
+	Fd   uint64 `json:"fd"`
+}
+
+type MemoryInfoStat struct {
+	RSS  uint64 `json:"rss"`  // bytes
+	VMS  uint64 `json:"vms"`  // bytes
+	Swap uint64 `json:"swap"` // bytes
+}
+
+type RlimitStat struct {
+	Resource int32 `json:"resource"`
+	Soft     int32 `json:"soft"`
+	Hard     int32 `json:"hard"`
+}
+
+type IOCountersStat struct {
+	ReadCount  uint64 `json:"readCount"`
+	WriteCount uint64 `json:"writeCount"`
+	ReadBytes  uint64 `json:"readBytes"`
+	WriteBytes uint64 `json:"writeBytes"`
+}
+
+type NumCtxSwitchesStat struct {
+	Voluntary   int64 `json:"voluntary"`
+	Involuntary int64 `json:"involuntary"`
+}
+
+// Resource limit constants are from /usr/include/x86_64-linux-gnu/bits/resource.h
+// from libc6-dev package in Ubuntu 16.10
+const (
+	RLIMIT_CPU        int32 = 0
+	RLIMIT_FSIZE      int32 = 1
+	RLIMIT_DATA       int32 = 2
+	RLIMIT_STACK      int32 = 3
+	RLIMIT_CORE       int32 = 4
+	RLIMIT_RSS        int32 = 5
+	RLIMIT_NPROC      int32 = 6
+	RLIMIT_NOFILE     int32 = 7
+	RLIMIT_MEMLOCK    int32 = 8
+	RLIMIT_AS         int32 = 9
+	RLIMIT_LOCKS      int32 = 10
+	RLIMIT_SIGPENDING int32 = 11
+	RLIMIT_MSGQUEUE   int32 = 12
+	RLIMIT_NICE       int32 = 13
+	RLIMIT_RTPRIO     int32 = 14
+	RLIMIT_RTTIME     int32 = 15
+)
+
+func (p Process) String() string {
+	s, _ := json.Marshal(p)
+	return string(s)
+}
+
+func (o OpenFilesStat) String() string {
+	s, _ := json.Marshal(o)
+	return string(s)
+}
+
+func (m MemoryInfoStat) String() string {
+	s, _ := json.Marshal(m)
+	return string(s)
+}
+
+func (r RlimitStat) String() string {
+	s, _ := json.Marshal(r)
+	return string(s)
+}
+
+func (i IOCountersStat) String() string {
+	s, _ := json.Marshal(i)
+	return string(s)
+}
+
+func (p NumCtxSwitchesStat) String() string {
+	s, _ := json.Marshal(p)
+	return string(s)
+}
+
+func PidExists(pid int32) (bool, error) {
+	pids, err := Pids()
+	if err != nil {
+		return false, err
+	}
+
+	for _, i := range pids {
+		if i == pid {
+			return true, err
+		}
+	}
+
+	return false, err
+}
+
+// If interval is 0, return difference from last call(non-blocking).
+// If interval > 0, wait interval sec and return diffrence between start and end.
+func (p *Process) Percent(interval time.Duration) (float64, error) {
+	cpuTimes, err := p.Times()
+	if err != nil {
+		return 0, err
+	}
+	now := time.Now()
+
+	if interval > 0 {
+		p.lastCPUTimes = cpuTimes
+		p.lastCPUTime = now
+		time.Sleep(interval)
+		cpuTimes, err = p.Times()
+		now = time.Now()
+		if err != nil {
+			return 0, err
+		}
+	} else {
+		if p.lastCPUTimes == nil {
+			// invoked first time
+			p.lastCPUTimes = cpuTimes
+			p.lastCPUTime = now
+			return 0, nil
+		}
+	}
+
+	numcpu := runtime.NumCPU()
+	delta := (now.Sub(p.lastCPUTime).Seconds()) * float64(numcpu)
+	ret := calculatePercent(p.lastCPUTimes, cpuTimes, delta, numcpu)
+	p.lastCPUTimes = cpuTimes
+	p.lastCPUTime = now
+	return ret, nil
+}
+
+func calculatePercent(t1, t2 *cpu.TimesStat, delta float64, numcpu int) float64 {
+	if delta == 0 {
+		return 0
+	}
+	delta_proc := t2.Total() - t1.Total()
+	overall_percent := ((delta_proc / delta) * 100) * float64(numcpu)
+	return overall_percent
+}
+
+// MemoryPercent returns how many percent of the total RAM this process uses
+func (p *Process) MemoryPercent() (float32, error) {
+	machineMemory, err := mem.VirtualMemory()
+	if err != nil {
+		return 0, err
+	}
+	total := machineMemory.Total
+
+	processMemory, err := p.MemoryInfo()
+	if err != nil {
+		return 0, err
+	}
+	used := processMemory.RSS
+
+	return (100 * float32(used) / float32(total)), nil
+}

vendor/github.com/shirou/gopsutil/process/process_darwin.go

@@ -0,0 +1,506 @@
+// +build darwin
+
+package process
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/net"
+)
+
+// copied from sys/sysctl.h
+const (
+	CTLKern          = 1  // "high kernel": proc, limits
+	KernProc         = 14 // struct: process entries
+	KernProcPID      = 1  // by process id
+	KernProcProc     = 8  // only return procs
+	KernProcAll      = 0  // everything
+	KernProcPathname = 12 // path to executable
+)
+
+const (
+	ClockTicks = 100 // C.sysconf(C._SC_CLK_TCK)
+)
+
+type _Ctype_struct___0 struct {
+	Pad uint64
+}
+
+// MemoryInfoExStat is different between OSes
+type MemoryInfoExStat struct {
+}
+
+type MemoryMapsStat struct {
+}
+
+func Pids() ([]int32, error) {
+	var ret []int32
+
+	pids, err := callPs("pid", 0, false)
+	if err != nil {
+		return ret, err
+	}
+
+	for _, pid := range pids {
+		v, err := strconv.Atoi(pid[0])
+		if err != nil {
+			return ret, err
+		}
+		ret = append(ret, int32(v))
+	}
+
+	return ret, nil
+}
+
+func (p *Process) Ppid() (int32, error) {
+	r, err := callPs("ppid", p.Pid, false)
+	v, err := strconv.Atoi(r[0][0])
+	if err != nil {
+		return 0, err
+	}
+
+	return int32(v), err
+}
+func (p *Process) Name() (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	return common.IntToString(k.Proc.P_comm[:]), nil
+}
+func (p *Process) Exe() (string, error) {
+	lsof_bin, err := exec.LookPath("lsof")
+	if err != nil {
+		return "", err
+	}
+
+	awk_bin, err := exec.LookPath("awk")
+	if err != nil {
+		return "", err
+	}
+
+	sed_bin, err := exec.LookPath("sed")
+	if err != nil {
+		return "", err
+	}
+
+	lsof := exec.Command(lsof_bin, "-p", strconv.Itoa(int(p.Pid)), "-Fn")
+	awk := exec.Command(awk_bin, "NR==3{print}")
+	sed := exec.Command(sed_bin, "s/n\\//\\//")
+
+	output, _, err := common.Pipeline(lsof, awk, sed)
+
+	if err != nil {
+		return "", err
+	}
+
+	ret := strings.TrimSpace(string(output))
+
+	return ret, nil
+}
+
+// Cmdline returns the command line arguments of the process as a string with
+// each argument separated by 0x20 ascii character.
+func (p *Process) Cmdline() (string, error) {
+	r, err := callPs("command", p.Pid, false)
+	if err != nil {
+		return "", err
+	}
+	return strings.Join(r[0], " "), err
+}
+
+// CmdlineSlice returns the command line arguments of the process as a slice with each
+// element being an argument. Because of current deficiencies in the way that the command
+// line arguments are found, single arguments that have spaces in the will actually be
+// reported as two separate items. In order to do something better CGO would be needed
+// to use the native darwin functions.
+func (p *Process) CmdlineSlice() ([]string, error) {
+	r, err := callPs("command", p.Pid, false)
+	if err != nil {
+		return nil, err
+	}
+	return r[0], err
+}
+func (p *Process) CreateTime() (int64, error) {
+	r, err := callPs("etime", p.Pid, false)
+	if err != nil {
+		return 0, err
+	}
+
+	elapsedSegments := strings.Split(strings.Replace(r[0][0], "-", ":", 1), ":")
+	var elapsedDurations []time.Duration
+	for i := len(elapsedSegments) - 1; i >= 0; i-- {
+		p, err := strconv.ParseInt(elapsedSegments[i], 10, 0)
+		if err != nil {
+			return 0, err
+		}
+		elapsedDurations = append(elapsedDurations, time.Duration(p))
+	}
+
+	var elapsed time.Duration = time.Duration(elapsedDurations[0]) * time.Second
+	if len(elapsedDurations) > 1 {
+		elapsed += time.Duration(elapsedDurations[1]) * time.Minute
+	}
+	if len(elapsedDurations) > 2 {
+		elapsed += time.Duration(elapsedDurations[2]) * time.Hour
+	}
+	if len(elapsedDurations) > 3 {
+		elapsed += time.Duration(elapsedDurations[3]) * time.Hour * 24
+	}
+
+	start := time.Now().Add(-elapsed)
+	return start.Unix() * 1000, nil
+}
+func (p *Process) Cwd() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Parent() (*Process, error) {
+	rr, err := common.CallLsof(invoke, p.Pid, "-FR")
+	if err != nil {
+		return nil, err
+	}
+	for _, r := range rr {
+		if strings.HasPrefix(r, "p") { // skip if process
+			continue
+		}
+		l := string(r)
+		v, err := strconv.Atoi(strings.Replace(l, "R", "", 1))
+		if err != nil {
+			return nil, err
+		}
+		return NewProcess(int32(v))
+	}
+	return nil, fmt.Errorf("could not find parent line")
+}
+func (p *Process) Status() (string, error) {
+	r, err := callPs("state", p.Pid, false)
+	if err != nil {
+		return "", err
+	}
+
+	return r[0][0], err
+}
+func (p *Process) Uids() ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	// See: http://unix.superglobalmegacorp.com/Net2/newsrc/sys/ucred.h.html
+	userEffectiveUID := int32(k.Eproc.Ucred.UID)
+
+	return []int32{userEffectiveUID}, nil
+}
+func (p *Process) Gids() ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	gids := make([]int32, 0, 3)
+	gids = append(gids, int32(k.Eproc.Pcred.P_rgid), int32(k.Eproc.Ucred.Ngroups), int32(k.Eproc.Pcred.P_svgid))
+
+	return gids, nil
+}
+func (p *Process) Terminal() (string, error) {
+	return "", common.ErrNotImplementedError
+	/*
+		k, err := p.getKProc()
+		if err != nil {
+			return "", err
+		}
+
+		ttyNr := uint64(k.Eproc.Tdev)
+		termmap, err := getTerminalMap()
+		if err != nil {
+			return "", err
+		}
+
+		return termmap[ttyNr], nil
+	*/
+}
+func (p *Process) Nice() (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+	return int32(k.Proc.P_nice), nil
+}
+func (p *Process) IOnice() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+	return rlimit, common.ErrNotImplementedError
+}
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumFDs() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) NumThreads() (int32, error) {
+	r, err := callPs("utime,stime", p.Pid, true)
+	if err != nil {
+		return 0, err
+	}
+	return int32(len(r)), nil
+}
+func (p *Process) Threads() (map[string]string, error) {
+	ret := make(map[string]string, 0)
+	return ret, common.ErrNotImplementedError
+}
+
+func convertCPUTimes(s string) (ret float64, err error) {
+	var t int
+	var _tmp string
+	if strings.Contains(s, ":") {
+		_t := strings.Split(s, ":")
+		hour, err := strconv.Atoi(_t[0])
+		if err != nil {
+			return ret, err
+		}
+		t += hour * 60 * 100
+		_tmp = _t[1]
+	} else {
+		_tmp = s
+	}
+
+	_t := strings.Split(_tmp, ".")
+	if err != nil {
+		return ret, err
+	}
+	h, err := strconv.Atoi(_t[0])
+	t += h * 100
+	h, err = strconv.Atoi(_t[1])
+	t += h
+	return float64(t) / ClockTicks, nil
+}
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	r, err := callPs("utime,stime", p.Pid, false)
+
+	if err != nil {
+		return nil, err
+	}
+
+	utime, err := convertCPUTimes(r[0][0])
+	if err != nil {
+		return nil, err
+	}
+	stime, err := convertCPUTimes(r[0][1])
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &cpu.TimesStat{
+		CPU:    "cpu",
+		User:   utime,
+		System: stime,
+	}
+	return ret, nil
+}
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	r, err := callPs("rss,vsize,pagein", p.Pid, false)
+	if err != nil {
+		return nil, err
+	}
+	rss, err := strconv.Atoi(r[0][0])
+	if err != nil {
+		return nil, err
+	}
+	vms, err := strconv.Atoi(r[0][1])
+	if err != nil {
+		return nil, err
+	}
+	pagein, err := strconv.Atoi(r[0][2])
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &MemoryInfoStat{
+		RSS:  uint64(rss) * 1024,
+		VMS:  uint64(vms) * 1024,
+		Swap: uint64(pagein),
+	}
+
+	return ret, nil
+}
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Children() ([]*Process, error) {
+	pids, err := common.CallPgrep(invoke, p.Pid)
+	if err != nil {
+		return nil, err
+	}
+	ret := make([]*Process, 0, len(pids))
+	for _, pid := range pids {
+		np, err := NewProcess(pid)
+		if err != nil {
+			return nil, err
+		}
+		ret = append(ret, np)
+	}
+	return ret, nil
+}
+
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return net.ConnectionsPid("all", p.Pid)
+}
+
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) IsRunning() (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	var ret []MemoryMapsStat
+	return &ret, common.ErrNotImplementedError
+}
+
+func processes() ([]Process, error) {
+	results := make([]Process, 0, 50)
+
+	mib := []int32{CTLKern, KernProc, KernProcAll, 0}
+	buf, length, err := common.CallSyscall(mib)
+	if err != nil {
+		return results, err
+	}
+
+	// get kinfo_proc size
+	k := KinfoProc{}
+	procinfoLen := int(unsafe.Sizeof(k))
+	count := int(length / uint64(procinfoLen))
+	/*
+		fmt.Println(length, procinfoLen, count)
+		b := buf[0*procinfoLen : 0*procinfoLen+procinfoLen]
+		fmt.Println(b)
+		kk, err := parseKinfoProc(b)
+		fmt.Printf("%#v", kk)
+	*/
+
+	// parse buf to procs
+	for i := 0; i < count; i++ {
+		b := buf[i*procinfoLen : i*procinfoLen+procinfoLen]
+		k, err := parseKinfoProc(b)
+		if err != nil {
+			continue
+		}
+		p, err := NewProcess(int32(k.Proc.P_pid))
+		if err != nil {
+			continue
+		}
+		results = append(results, *p)
+	}
+
+	return results, nil
+}
+
+func parseKinfoProc(buf []byte) (KinfoProc, error) {
+	var k KinfoProc
+	br := bytes.NewReader(buf)
+
+	err := common.Read(br, binary.LittleEndian, &k)
+	if err != nil {
+		return k, err
+	}
+
+	return k, nil
+}
+
+// Returns a proc as defined here:
+// http://unix.superglobalmegacorp.com/Net2/newsrc/sys/kinfo_proc.h.html
+func (p *Process) getKProc() (*KinfoProc, error) {
+	mib := []int32{CTLKern, KernProc, KernProcPID, p.Pid}
+	procK := KinfoProc{}
+	length := uint64(unsafe.Sizeof(procK))
+	buf := make([]byte, length)
+	_, _, syserr := syscall.Syscall6(
+		syscall.SYS___SYSCTL,
+		uintptr(unsafe.Pointer(&mib[0])),
+		uintptr(len(mib)),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if syserr != 0 {
+		return nil, syserr
+	}
+	k, err := parseKinfoProc(buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return &k, nil
+}
+
+func NewProcess(pid int32) (*Process, error) {
+	p := &Process{Pid: pid}
+
+	return p, nil
+}
+
+// call ps command.
+// Return value deletes Header line(you must not input wrong arg).
+// And splited by Space. Caller have responsibility to manage.
+// If passed arg pid is 0, get information from all process.
+func callPs(arg string, pid int32, threadOption bool) ([][]string, error) {
+	bin, err := exec.LookPath("ps")
+	if err != nil {
+		return [][]string{}, err
+	}
+
+	var cmd []string
+	if pid == 0 { // will get from all processes.
+		cmd = []string{"-ax", "-o", arg}
+	} else if threadOption {
+		cmd = []string{"-x", "-o", arg, "-M", "-p", strconv.Itoa(int(pid))}
+	} else {
+		cmd = []string{"-x", "-o", arg, "-p", strconv.Itoa(int(pid))}
+	}
+	out, err := invoke.Command(bin, cmd...)
+	if err != nil {
+		return [][]string{}, err
+	}
+	lines := strings.Split(string(out), "\n")
+
+	var ret [][]string
+	for _, l := range lines[1:] {
+		var lr []string
+		for _, r := range strings.Split(l, " ") {
+			if r == "" {
+				continue
+			}
+			lr = append(lr, strings.TrimSpace(r))
+		}
+		if len(lr) != 0 {
+			ret = append(ret, lr)
+		}
+	}
+
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/process/process_darwin_386.go

@@ -0,0 +1,234 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_darwin.go
+
+package process
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type Timespec struct {
+	Sec  int64
+	Nsec int64
+}
+
+type Timeval struct {
+	Sec       int64
+	Usec      int32
+	Pad_cgo_0 [4]byte
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int64
+	Ixrss    int64
+	Idrss    int64
+	Isrss    int64
+	Minflt   int64
+	Majflt   int64
+	Nswap    int64
+	Inblock  int64
+	Oublock  int64
+	Msgsnd   int64
+	Msgrcv   int64
+	Nsignals int64
+	Nvcsw    int64
+	Nivcsw   int64
+}
+
+type Rlimit struct {
+	Cur uint64
+	Max uint64
+}
+
+type UGid_t uint32
+
+type KinfoProc struct {
+	Proc  ExternProc
+	Eproc Eproc
+}
+
+type Eproc struct {
+	Paddr     *uint64
+	Sess      *Session
+	Pcred     Upcred
+	Ucred     Uucred
+	Pad_cgo_0 [4]byte
+	Vm        Vmspace
+	Ppid      int32
+	Pgid      int32
+	Jobc      int16
+	Pad_cgo_1 [2]byte
+	Tdev      int32
+	Tpgid     int32
+	Pad_cgo_2 [4]byte
+	Tsess     *Session
+	Wmesg     [8]int8
+	Xsize     int32
+	Xrssize   int16
+	Xccount   int16
+	Xswrss    int16
+	Pad_cgo_3 [2]byte
+	Flag      int32
+	Login     [12]int8
+	Spare     [4]int32
+	Pad_cgo_4 [4]byte
+}
+
+type Proc struct{}
+
+type Session struct{}
+
+type ucred struct {
+	Link  _Ctype_struct___0
+	Ref   uint64
+	Posix Posix_cred
+	Label *Label
+	Audit Au_session
+}
+
+type Uucred struct {
+	Ref       int32
+	UID       uint32
+	Ngroups   int16
+	Pad_cgo_0 [2]byte
+	Groups    [16]uint32
+}
+
+type Upcred struct {
+	Pc_lock   [72]int8
+	Pc_ucred  *ucred
+	P_ruid    uint32
+	P_svuid   uint32
+	P_rgid    uint32
+	P_svgid   uint32
+	P_refcnt  int32
+	Pad_cgo_0 [4]byte
+}
+
+type Vmspace struct {
+	Dummy     int32
+	Pad_cgo_0 [4]byte
+	Dummy2    *int8
+	Dummy3    [5]int32
+	Pad_cgo_1 [4]byte
+	Dummy4    [3]*int8
+}
+
+type Sigacts struct{}
+
+type ExternProc struct {
+	P_un        [16]byte
+	P_vmspace   uint64
+	P_sigacts   uint64
+	Pad_cgo_0   [3]byte
+	P_flag      int32
+	P_stat      int8
+	P_pid       int32
+	P_oppid     int32
+	P_dupfd     int32
+	Pad_cgo_1   [4]byte
+	User_stack  uint64
+	Exit_thread uint64
+	P_debugger  int32
+	Sigwait     int32
+	P_estcpu    uint32
+	P_cpticks   int32
+	P_pctcpu    uint32
+	Pad_cgo_2   [4]byte
+	P_wchan     uint64
+	P_wmesg     uint64
+	P_swtime    uint32
+	P_slptime   uint32
+	P_realtimer Itimerval
+	P_rtime     Timeval
+	P_uticks    uint64
+	P_sticks    uint64
+	P_iticks    uint64
+	P_traceflag int32
+	Pad_cgo_3   [4]byte
+	P_tracep    uint64
+	P_siglist   int32
+	Pad_cgo_4   [4]byte
+	P_textvp    uint64
+	P_holdcnt   int32
+	P_sigmask   uint32
+	P_sigignore uint32
+	P_sigcatch  uint32
+	P_priority  uint8
+	P_usrpri    uint8
+	P_nice      int8
+	P_comm      [17]int8
+	Pad_cgo_5   [4]byte
+	P_pgrp      uint64
+	P_addr      uint64
+	P_xstat     uint16
+	P_acflag    uint16
+	Pad_cgo_6   [4]byte
+	P_ru        uint64
+}
+
+type Itimerval struct {
+	Interval Timeval
+	Value    Timeval
+}
+
+type Vnode struct{}
+
+type Pgrp struct{}
+
+type UserStruct struct{}
+
+type Au_session struct {
+	Aia_p *AuditinfoAddr
+	Mask  AuMask
+}
+
+type Posix_cred struct {
+	UID       uint32
+	Ruid      uint32
+	Svuid     uint32
+	Ngroups   int16
+	Pad_cgo_0 [2]byte
+	Groups    [16]uint32
+	Rgid      uint32
+	Svgid     uint32
+	Gmuid     uint32
+	Flags     int32
+}
+
+type Label struct{}
+
+type AuditinfoAddr struct {
+	Auid   uint32
+	Mask   AuMask
+	Termid AuTidAddr
+	Asid   int32
+	Flags  uint64
+}
+type AuMask struct {
+	Success uint32
+	Failure uint32
+}
+type AuTidAddr struct {
+	Port int32
+	Type uint32
+	Addr [4]uint32
+}
+
+type UcredQueue struct {
+	Next *ucred
+	Prev **ucred
+}

vendor/github.com/shirou/gopsutil/process/process_darwin_amd64.go

@@ -0,0 +1,234 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_darwin.go
+
+package process
+
+const (
+	sizeofPtr      = 0x8
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x8
+	sizeofLongLong = 0x8
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int64
+	_C_long_long int64
+)
+
+type Timespec struct {
+	Sec  int64
+	Nsec int64
+}
+
+type Timeval struct {
+	Sec       int64
+	Usec      int32
+	Pad_cgo_0 [4]byte
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int64
+	Ixrss    int64
+	Idrss    int64
+	Isrss    int64
+	Minflt   int64
+	Majflt   int64
+	Nswap    int64
+	Inblock  int64
+	Oublock  int64
+	Msgsnd   int64
+	Msgrcv   int64
+	Nsignals int64
+	Nvcsw    int64
+	Nivcsw   int64
+}
+
+type Rlimit struct {
+	Cur uint64
+	Max uint64
+}
+
+type UGid_t uint32
+
+type KinfoProc struct {
+	Proc  ExternProc
+	Eproc Eproc
+}
+
+type Eproc struct {
+	Paddr     *uint64
+	Sess      *Session
+	Pcred     Upcred
+	Ucred     Uucred
+	Pad_cgo_0 [4]byte
+	Vm        Vmspace
+	Ppid      int32
+	Pgid      int32
+	Jobc      int16
+	Pad_cgo_1 [2]byte
+	Tdev      int32
+	Tpgid     int32
+	Pad_cgo_2 [4]byte
+	Tsess     *Session
+	Wmesg     [8]int8
+	Xsize     int32
+	Xrssize   int16
+	Xccount   int16
+	Xswrss    int16
+	Pad_cgo_3 [2]byte
+	Flag      int32
+	Login     [12]int8
+	Spare     [4]int32
+	Pad_cgo_4 [4]byte
+}
+
+type Proc struct{}
+
+type Session struct{}
+
+type ucred struct {
+	Link  _Ctype_struct___0
+	Ref   uint64
+	Posix Posix_cred
+	Label *Label
+	Audit Au_session
+}
+
+type Uucred struct {
+	Ref       int32
+	UID       uint32
+	Ngroups   int16
+	Pad_cgo_0 [2]byte
+	Groups    [16]uint32
+}
+
+type Upcred struct {
+	Pc_lock   [72]int8
+	Pc_ucred  *ucred
+	P_ruid    uint32
+	P_svuid   uint32
+	P_rgid    uint32
+	P_svgid   uint32
+	P_refcnt  int32
+	Pad_cgo_0 [4]byte
+}
+
+type Vmspace struct {
+	Dummy     int32
+	Pad_cgo_0 [4]byte
+	Dummy2    *int8
+	Dummy3    [5]int32
+	Pad_cgo_1 [4]byte
+	Dummy4    [3]*int8
+}
+
+type Sigacts struct{}
+
+type ExternProc struct {
+	P_un        [16]byte
+	P_vmspace   uint64
+	P_sigacts   uint64
+	Pad_cgo_0   [3]byte
+	P_flag      int32
+	P_stat      int8
+	P_pid       int32
+	P_oppid     int32
+	P_dupfd     int32
+	Pad_cgo_1   [4]byte
+	User_stack  uint64
+	Exit_thread uint64
+	P_debugger  int32
+	Sigwait     int32
+	P_estcpu    uint32
+	P_cpticks   int32
+	P_pctcpu    uint32
+	Pad_cgo_2   [4]byte
+	P_wchan     uint64
+	P_wmesg     uint64
+	P_swtime    uint32
+	P_slptime   uint32
+	P_realtimer Itimerval
+	P_rtime     Timeval
+	P_uticks    uint64
+	P_sticks    uint64
+	P_iticks    uint64
+	P_traceflag int32
+	Pad_cgo_3   [4]byte
+	P_tracep    uint64
+	P_siglist   int32
+	Pad_cgo_4   [4]byte
+	P_textvp    uint64
+	P_holdcnt   int32
+	P_sigmask   uint32
+	P_sigignore uint32
+	P_sigcatch  uint32
+	P_priority  uint8
+	P_usrpri    uint8
+	P_nice      int8
+	P_comm      [17]int8
+	Pad_cgo_5   [4]byte
+	P_pgrp      uint64
+	P_addr      uint64
+	P_xstat     uint16
+	P_acflag    uint16
+	Pad_cgo_6   [4]byte
+	P_ru        uint64
+}
+
+type Itimerval struct {
+	Interval Timeval
+	Value    Timeval
+}
+
+type Vnode struct{}
+
+type Pgrp struct{}
+
+type UserStruct struct{}
+
+type Au_session struct {
+	Aia_p *AuditinfoAddr
+	Mask  AuMask
+}
+
+type Posix_cred struct {
+	UID       uint32
+	Ruid      uint32
+	Svuid     uint32
+	Ngroups   int16
+	Pad_cgo_0 [2]byte
+	Groups    [16]uint32
+	Rgid      uint32
+	Svgid     uint32
+	Gmuid     uint32
+	Flags     int32
+}
+
+type Label struct{}
+
+type AuditinfoAddr struct {
+	Auid   uint32
+	Mask   AuMask
+	Termid AuTidAddr
+	Asid   int32
+	Flags  uint64
+}
+type AuMask struct {
+	Success uint32
+	Failure uint32
+}
+type AuTidAddr struct {
+	Port int32
+	Type uint32
+	Addr [4]uint32
+}
+
+type UcredQueue struct {
+	Next *ucred
+	Prev **ucred
+}

vendor/github.com/shirou/gopsutil/process/process_fallback.go

@@ -0,0 +1,145 @@
+// +build !darwin,!linux,!freebsd,!openbsd,!windows
+
+package process
+
+import (
+	"syscall"
+
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/net"
+)
+
+type MemoryMapsStat struct {
+	Path         string `json:"path"`
+	Rss          uint64 `json:"rss"`
+	Size         uint64 `json:"size"`
+	Pss          uint64 `json:"pss"`
+	SharedClean  uint64 `json:"sharedClean"`
+	SharedDirty  uint64 `json:"sharedDirty"`
+	PrivateClean uint64 `json:"privateClean"`
+	PrivateDirty uint64 `json:"privateDirty"`
+	Referenced   uint64 `json:"referenced"`
+	Anonymous    uint64 `json:"anonymous"`
+	Swap         uint64 `json:"swap"`
+}
+
+type MemoryInfoExStat struct {
+}
+
+func Pids() ([]int32, error) {
+	return []int32{}, common.ErrNotImplementedError
+}
+
+func NewProcess(pid int32) (*Process, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Ppid() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Name() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Exe() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Cmdline() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) CmdlineSlice() ([]string, error) {
+	return []string{}, common.ErrNotImplementedError
+}
+func (p *Process) CreateTime() (int64, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Cwd() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Parent() (*Process, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) Status() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Uids() ([]int32, error) {
+	return []int32{}, common.ErrNotImplementedError
+}
+func (p *Process) Gids() ([]int32, error) {
+	return []int32{}, common.ErrNotImplementedError
+}
+func (p *Process) Terminal() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Nice() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) IOnice() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumFDs() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) NumThreads() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Threads() (map[string]string, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) Children() ([]*Process, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return []OpenFilesStat{}, common.ErrNotImplementedError
+}
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return []net.ConnectionStat{}, common.ErrNotImplementedError
+}
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	return []net.IOCountersStat{}, common.ErrNotImplementedError
+}
+func (p *Process) IsRunning() (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) SendSignal(sig syscall.Signal) error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Suspend() error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Resume() error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Terminate() error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Kill() error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Username() (string, error) {
+	return "", common.ErrNotImplementedError
+}

vendor/github.com/shirou/gopsutil/process/process_freebsd.go

@@ -0,0 +1,336 @@
+// +build freebsd
+
+package process
+
+import (
+	"bytes"
+	"encoding/binary"
+	"strings"
+	"syscall"
+
+	cpu "github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	net "github.com/shirou/gopsutil/net"
+)
+
+// MemoryInfoExStat is different between OSes
+type MemoryInfoExStat struct {
+}
+
+type MemoryMapsStat struct {
+}
+
+func Pids() ([]int32, error) {
+	var ret []int32
+	procs, err := processes()
+	if err != nil {
+		return ret, nil
+	}
+
+	for _, p := range procs {
+		ret = append(ret, p.Pid)
+	}
+
+	return ret, nil
+}
+
+func (p *Process) Ppid() (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+
+	return k.Ppid, nil
+}
+func (p *Process) Name() (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	return common.IntToString(k.Comm[:]), nil
+}
+func (p *Process) Exe() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+
+func (p *Process) Cmdline() (string, error) {
+	mib := []int32{CTLKern, KernProc, KernProcArgs, p.Pid}
+	buf, _, err := common.CallSyscall(mib)
+	if err != nil {
+		return "", err
+	}
+	ret := strings.FieldsFunc(string(buf), func(r rune) bool {
+		if r == '\u0000' {
+			return true
+		}
+		return false
+	})
+
+	return strings.Join(ret, " "), nil
+}
+
+func (p *Process) CmdlineSlice() ([]string, error) {
+	mib := []int32{CTLKern, KernProc, KernProcArgs, p.Pid}
+	buf, _, err := common.CallSyscall(mib)
+	if err != nil {
+		return nil, err
+	}
+	if len(buf) == 0 {
+		return nil, nil
+	}
+	if buf[len(buf)-1] == 0 {
+		buf = buf[:len(buf)-1]
+	}
+	parts := bytes.Split(buf, []byte{0})
+	var strParts []string
+	for _, p := range parts {
+		strParts = append(strParts, string(p))
+	}
+
+	return strParts, nil
+}
+func (p *Process) CreateTime() (int64, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Cwd() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Parent() (*Process, error) {
+	return p, common.ErrNotImplementedError
+}
+func (p *Process) Status() (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+	var s string
+	switch k.Stat {
+	case SIDL:
+		s = "I"
+	case SRUN:
+		s = "R"
+	case SSLEEP:
+		s = "S"
+	case SSTOP:
+		s = "T"
+	case SZOMB:
+		s = "Z"
+	case SWAIT:
+		s = "W"
+	case SLOCK:
+		s = "L"
+	}
+
+	return s, nil
+}
+func (p *Process) Uids() ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	uids := make([]int32, 0, 3)
+
+	uids = append(uids, int32(k.Ruid), int32(k.Uid), int32(k.Svuid))
+
+	return uids, nil
+}
+func (p *Process) Gids() ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	gids := make([]int32, 0, 3)
+	gids = append(gids, int32(k.Rgid), int32(k.Ngroups), int32(k.Svgid))
+
+	return gids, nil
+}
+func (p *Process) Terminal() (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	ttyNr := uint64(k.Tdev)
+
+	termmap, err := getTerminalMap()
+	if err != nil {
+		return "", err
+	}
+
+	return termmap[ttyNr], nil
+}
+func (p *Process) Nice() (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+	return int32(k.Nice), nil
+}
+func (p *Process) IOnice() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+	return rlimit, common.ErrNotImplementedError
+}
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	return &IOCountersStat{
+		ReadCount:  uint64(k.Rusage.Inblock),
+		WriteCount: uint64(k.Rusage.Oublock),
+	}, nil
+}
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumFDs() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) NumThreads() (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+
+	return k.Numthreads, nil
+}
+func (p *Process) Threads() (map[string]string, error) {
+	ret := make(map[string]string, 0)
+	return ret, common.ErrNotImplementedError
+}
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	return &cpu.TimesStat{
+		CPU:    "cpu",
+		User:   float64(k.Rusage.Utime.Sec) + float64(k.Rusage.Utime.Usec)/1000000,
+		System: float64(k.Rusage.Stime.Sec) + float64(k.Rusage.Stime.Usec)/1000000,
+	}, nil
+}
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	v, err := syscall.Sysctl("vm.stats.vm.v_page_size")
+	if err != nil {
+		return nil, err
+	}
+	pageSize := common.LittleEndian.Uint16([]byte(v))
+
+	return &MemoryInfoStat{
+		RSS: uint64(k.Rssize) * uint64(pageSize),
+		VMS: uint64(k.Size),
+	}, nil
+}
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Children() ([]*Process, error) {
+	pids, err := common.CallPgrep(invoke, p.Pid)
+	if err != nil {
+		return nil, err
+	}
+	ret := make([]*Process, 0, len(pids))
+	for _, pid := range pids {
+		np, err := NewProcess(pid)
+		if err != nil {
+			return nil, err
+		}
+		ret = append(ret, np)
+	}
+	return ret, nil
+}
+
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) IsRunning() (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	var ret []MemoryMapsStat
+	return &ret, common.ErrNotImplementedError
+}
+
+func processes() ([]Process, error) {
+	results := make([]Process, 0, 50)
+
+	mib := []int32{CTLKern, KernProc, KernProcProc, 0}
+	buf, length, err := common.CallSyscall(mib)
+	if err != nil {
+		return results, err
+	}
+
+	// get kinfo_proc size
+	count := int(length / uint64(sizeOfKinfoProc))
+
+	// parse buf to procs
+	for i := 0; i < count; i++ {
+		b := buf[i*sizeOfKinfoProc : (i+1)*sizeOfKinfoProc]
+		k, err := parseKinfoProc(b)
+		if err != nil {
+			continue
+		}
+		p, err := NewProcess(int32(k.Pid))
+		if err != nil {
+			continue
+		}
+
+		results = append(results, *p)
+	}
+
+	return results, nil
+}
+
+func parseKinfoProc(buf []byte) (KinfoProc, error) {
+	var k KinfoProc
+	br := bytes.NewReader(buf)
+	err := common.Read(br, binary.LittleEndian, &k)
+	return k, err
+}
+
+func (p *Process) getKProc() (*KinfoProc, error) {
+	mib := []int32{CTLKern, KernProc, KernProcPID, p.Pid}
+
+	buf, length, err := common.CallSyscall(mib)
+	if err != nil {
+		return nil, err
+	}
+	if length != sizeOfKinfoProc {
+		return nil, err
+	}
+
+	k, err := parseKinfoProc(buf)
+	if err != nil {
+		return nil, err
+	}
+	return &k, nil
+}
+
+func NewProcess(pid int32) (*Process, error) {
+	p := &Process{Pid: pid}
+
+	return p, nil
+}

vendor/github.com/shirou/gopsutil/process/process_freebsd_386.go

@@ -0,0 +1,192 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package process
+
+const (
+	CTLKern			= 1
+	KernProc		= 14
+	KernProcPID		= 1
+	KernProcProc		= 8
+	KernProcPathname	= 12
+	KernProcArgs		= 7
+)
+
+const (
+	sizeofPtr	= 0x4
+	sizeofShort	= 0x2
+	sizeofInt	= 0x4
+	sizeofLong	= 0x4
+	sizeofLongLong	= 0x8
+)
+
+const (
+	sizeOfKinfoVmentry	= 0x488
+	sizeOfKinfoProc		= 0x300
+)
+
+const (
+	SIDL	= 1
+	SRUN	= 2
+	SSLEEP	= 3
+	SSTOP	= 4
+	SZOMB	= 5
+	SWAIT	= 6
+	SLOCK	= 7
+)
+
+type (
+	_C_short	int16
+	_C_int		int32
+	_C_long		int32
+	_C_long_long	int64
+)
+
+type Timespec struct {
+	Sec	int32
+	Nsec	int32
+}
+
+type Timeval struct {
+	Sec	int32
+	Usec	int32
+}
+
+type Rusage struct {
+	Utime		Timeval
+	Stime		Timeval
+	Maxrss		int32
+	Ixrss		int32
+	Idrss		int32
+	Isrss		int32
+	Minflt		int32
+	Majflt		int32
+	Nswap		int32
+	Inblock		int32
+	Oublock		int32
+	Msgsnd		int32
+	Msgrcv		int32
+	Nsignals	int32
+	Nvcsw		int32
+	Nivcsw		int32
+}
+
+type Rlimit struct {
+	Cur	int64
+	Max	int64
+}
+
+type KinfoProc struct {
+	Structsize	int32
+	Layout		int32
+	Args		int32 /* pargs */
+	Paddr		int32 /* proc */
+	Addr		int32 /* user */
+	Tracep		int32 /* vnode */
+	Textvp		int32 /* vnode */
+	Fd		int32 /* filedesc */
+	Vmspace		int32 /* vmspace */
+	Wchan		int32
+	Pid		int32
+	Ppid		int32
+	Pgid		int32
+	Tpgid		int32
+	Sid		int32
+	Tsid		int32
+	Jobc		int16
+	Spare_short1	int16
+	Tdev		uint32
+	Siglist		[16]byte /* sigset */
+	Sigmask		[16]byte /* sigset */
+	Sigignore	[16]byte /* sigset */
+	Sigcatch	[16]byte /* sigset */
+	Uid		uint32
+	Ruid		uint32
+	Svuid		uint32
+	Rgid		uint32
+	Svgid		uint32
+	Ngroups		int16
+	Spare_short2	int16
+	Groups		[16]uint32
+	Size		uint32
+	Rssize		int32
+	Swrss		int32
+	Tsize		int32
+	Dsize		int32
+	Ssize		int32
+	Xstat		uint16
+	Acflag		uint16
+	Pctcpu		uint32
+	Estcpu		uint32
+	Slptime		uint32
+	Swtime		uint32
+	Cow		uint32
+	Runtime		uint64
+	Start		Timeval
+	Childtime	Timeval
+	Flag		int32
+	Kiflag		int32
+	Traceflag	int32
+	Stat		int8
+	Nice		int8
+	Lock		int8
+	Rqindex		int8
+	Oncpu		uint8
+	Lastcpu		uint8
+	Tdname		[17]int8
+	Wmesg		[9]int8
+	Login		[18]int8
+	Lockname	[9]int8
+	Comm		[20]int8
+	Emul		[17]int8
+	Loginclass	[18]int8
+	Sparestrings	[50]int8
+	Spareints	[7]int32
+	Flag2		int32
+	Fibnum		int32
+	Cr_flags	uint32
+	Jid		int32
+	Numthreads	int32
+	Tid		int32
+	Pri		Priority
+	Rusage		Rusage
+	Rusage_ch	Rusage
+	Pcb		int32 /* pcb */
+	Kstack		int32
+	Udata		int32
+	Tdaddr		int32 /* thread */
+	Spareptrs	[6]int32
+	Sparelongs	[12]int32
+	Sflag		int32
+	Tdflags		int32
+}
+
+type Priority struct {
+	Class	uint8
+	Level	uint8
+	Native	uint8
+	User	uint8
+}
+
+type KinfoVmentry struct {
+	Structsize		int32
+	Type			int32
+	Start			uint64
+	End			uint64
+	Offset			uint64
+	Vn_fileid		uint64
+	Vn_fsid			uint32
+	Flags			int32
+	Resident		int32
+	Private_resident	int32
+	Protection		int32
+	Ref_count		int32
+	Shadow_count		int32
+	Vn_type			int32
+	Vn_size			uint64
+	Vn_rdev			uint32
+	Vn_mode			uint16
+	Status			uint16
+	X_kve_ispare		[12]int32
+	Path			[1024]int8
+}

vendor/github.com/shirou/gopsutil/process/process_freebsd_amd64.go

@@ -0,0 +1,192 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package process
+
+const (
+	CTLKern			= 1
+	KernProc		= 14
+	KernProcPID		= 1
+	KernProcProc		= 8
+	KernProcPathname	= 12
+	KernProcArgs		= 7
+)
+
+const (
+	sizeofPtr	= 0x8
+	sizeofShort	= 0x2
+	sizeofInt	= 0x4
+	sizeofLong	= 0x8
+	sizeofLongLong	= 0x8
+)
+
+const (
+	sizeOfKinfoVmentry	= 0x488
+	sizeOfKinfoProc		= 0x440
+)
+
+const (
+	SIDL	= 1
+	SRUN	= 2
+	SSLEEP	= 3
+	SSTOP	= 4
+	SZOMB	= 5
+	SWAIT	= 6
+	SLOCK	= 7
+)
+
+type (
+	_C_short	int16
+	_C_int		int32
+	_C_long		int64
+	_C_long_long	int64
+)
+
+type Timespec struct {
+	Sec	int64
+	Nsec	int64
+}
+
+type Timeval struct {
+	Sec	int64
+	Usec	int64
+}
+
+type Rusage struct {
+	Utime		Timeval
+	Stime		Timeval
+	Maxrss		int64
+	Ixrss		int64
+	Idrss		int64
+	Isrss		int64
+	Minflt		int64
+	Majflt		int64
+	Nswap		int64
+	Inblock		int64
+	Oublock		int64
+	Msgsnd		int64
+	Msgrcv		int64
+	Nsignals	int64
+	Nvcsw		int64
+	Nivcsw		int64
+}
+
+type Rlimit struct {
+	Cur	int64
+	Max	int64
+}
+
+type KinfoProc struct {
+	Structsize	int32
+	Layout		int32
+	Args		int64 /* pargs */
+	Paddr		int64 /* proc */
+	Addr		int64 /* user */
+	Tracep		int64 /* vnode */
+	Textvp		int64 /* vnode */
+	Fd		int64 /* filedesc */
+	Vmspace		int64 /* vmspace */
+	Wchan		int64
+	Pid		int32
+	Ppid		int32
+	Pgid		int32
+	Tpgid		int32
+	Sid		int32
+	Tsid		int32
+	Jobc		int16
+	Spare_short1	int16
+	Tdev		uint32
+	Siglist		[16]byte /* sigset */
+	Sigmask		[16]byte /* sigset */
+	Sigignore	[16]byte /* sigset */
+	Sigcatch	[16]byte /* sigset */
+	Uid		uint32
+	Ruid		uint32
+	Svuid		uint32
+	Rgid		uint32
+	Svgid		uint32
+	Ngroups		int16
+	Spare_short2	int16
+	Groups		[16]uint32
+	Size		uint64
+	Rssize		int64
+	Swrss		int64
+	Tsize		int64
+	Dsize		int64
+	Ssize		int64
+	Xstat		uint16
+	Acflag		uint16
+	Pctcpu		uint32
+	Estcpu		uint32
+	Slptime		uint32
+	Swtime		uint32
+	Cow		uint32
+	Runtime		uint64
+	Start		Timeval
+	Childtime	Timeval
+	Flag		int64
+	Kiflag		int64
+	Traceflag	int32
+	Stat		int8
+	Nice		int8
+	Lock		int8
+	Rqindex		int8
+	Oncpu		uint8
+	Lastcpu		uint8
+	Tdname		[17]int8
+	Wmesg		[9]int8
+	Login		[18]int8
+	Lockname	[9]int8
+	Comm		[20]int8
+	Emul		[17]int8
+	Loginclass	[18]int8
+	Sparestrings	[50]int8
+	Spareints	[7]int32
+	Flag2		int32
+	Fibnum		int32
+	Cr_flags	uint32
+	Jid		int32
+	Numthreads	int32
+	Tid		int32
+	Pri		Priority
+	Rusage		Rusage
+	Rusage_ch	Rusage
+	Pcb		int64 /* pcb */
+	Kstack		int64
+	Udata		int64
+	Tdaddr		int64 /* thread */
+	Spareptrs	[6]int64
+	Sparelongs	[12]int64
+	Sflag		int64
+	Tdflags		int64
+}
+
+type Priority struct {
+	Class	uint8
+	Level	uint8
+	Native	uint8
+	User	uint8
+}
+
+type KinfoVmentry struct {
+	Structsize		int32
+	Type			int32
+	Start			uint64
+	End			uint64
+	Offset			uint64
+	Vn_fileid		uint64
+	Vn_fsid			uint32
+	Flags			int32
+	Resident		int32
+	Private_resident	int32
+	Protection		int32
+	Ref_count		int32
+	Shadow_count		int32
+	Vn_type			int32
+	Vn_size			uint64
+	Vn_rdev			uint32
+	Vn_mode			uint16
+	Status			uint16
+	X_kve_ispare		[12]int32
+	Path			[1024]int8
+}

vendor/github.com/shirou/gopsutil/process/process_freebsd_arm.go

@@ -0,0 +1,192 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_freebsd.go
+
+package process
+
+const (
+	CTLKern          = 1
+	KernProc         = 14
+	KernProcPID      = 1
+	KernProcProc     = 8
+	KernProcPathname = 12
+	KernProcArgs     = 7
+)
+
+const (
+	sizeofPtr      = 0x4
+	sizeofShort    = 0x2
+	sizeofInt      = 0x4
+	sizeofLong     = 0x4
+	sizeofLongLong = 0x8
+)
+
+const (
+	sizeOfKinfoVmentry = 0x488
+	sizeOfKinfoProc    = 0x440
+)
+
+const (
+	SIDL   = 1
+	SRUN   = 2
+	SSLEEP = 3
+	SSTOP  = 4
+	SZOMB  = 5
+	SWAIT  = 6
+	SLOCK  = 7
+)
+
+type (
+	_C_short     int16
+	_C_int       int32
+	_C_long      int32
+	_C_long_long int64
+)
+
+type Timespec struct {
+	Sec  int64
+	Nsec int64
+}
+
+type Timeval struct {
+	Sec  int64
+	Usec int64
+}
+
+type Rusage struct {
+	Utime    Timeval
+	Stime    Timeval
+	Maxrss   int32
+	Ixrss    int32
+	Idrss    int32
+	Isrss    int32
+	Minflt   int32
+	Majflt   int32
+	Nswap    int32
+	Inblock  int32
+	Oublock  int32
+	Msgsnd   int32
+	Msgrcv   int32
+	Nsignals int32
+	Nvcsw    int32
+	Nivcsw   int32
+}
+
+type Rlimit struct {
+	Cur int32
+	Max int32
+}
+
+type KinfoProc struct {
+	Structsize   int32
+	Layout       int32
+	Args         int32 /* pargs */
+	Paddr        int32 /* proc */
+	Addr         int32 /* user */
+	Tracep       int32 /* vnode */
+	Textvp       int32 /* vnode */
+	Fd           int32 /* filedesc */
+	Vmspace      int32 /* vmspace */
+	Wchan        int32
+	Pid          int32
+	Ppid         int32
+	Pgid         int32
+	Tpgid        int32
+	Sid          int32
+	Tsid         int32
+	Jobc         int16
+	Spare_short1 int16
+	Tdev         uint32
+	Siglist      [16]byte /* sigset */
+	Sigmask      [16]byte /* sigset */
+	Sigignore    [16]byte /* sigset */
+	Sigcatch     [16]byte /* sigset */
+	Uid          uint32
+	Ruid         uint32
+	Svuid        uint32
+	Rgid         uint32
+	Svgid        uint32
+	Ngroups      int16
+	Spare_short2 int16
+	Groups       [16]uint32
+	Size         uint32
+	Rssize       int32
+	Swrss        int32
+	Tsize        int32
+	Dsize        int32
+	Ssize        int32
+	Xstat        uint16
+	Acflag       uint16
+	Pctcpu       uint32
+	Estcpu       uint32
+	Slptime      uint32
+	Swtime       uint32
+	Cow          uint32
+	Runtime      uint64
+	Start        Timeval
+	Childtime    Timeval
+	Flag         int32
+	Kiflag       int32
+	Traceflag    int32
+	Stat         int8
+	Nice         int8
+	Lock         int8
+	Rqindex      int8
+	Oncpu        uint8
+	Lastcpu      uint8
+	Tdname       [17]int8
+	Wmesg        [9]int8
+	Login        [18]int8
+	Lockname     [9]int8
+	Comm         [20]int8
+	Emul         [17]int8
+	Loginclass   [18]int8
+	Sparestrings [50]int8
+	Spareints    [4]int32
+	Flag2        int32
+	Fibnum       int32
+	Cr_flags     uint32
+	Jid          int32
+	Numthreads   int32
+	Tid          int32
+	Pri          Priority
+	Rusage       Rusage
+	Rusage_ch    Rusage
+	Pcb          int32 /* pcb */
+	Kstack       int32
+	Udata        int32
+	Tdaddr       int32 /* thread */
+	Spareptrs    [6]int64
+	Sparelongs   [12]int64
+	Sflag        int64
+	Tdflags      int64
+}
+
+type Priority struct {
+	Class  uint8
+	Level  uint8
+	Native uint8
+	User   uint8
+}
+
+type KinfoVmentry struct {
+	Structsize       int32
+	Type             int32
+	Start            uint64
+	End              uint64
+	Offset           uint64
+	Vn_fileid        uint64
+	Vn_fsid          uint32
+	Flags            int32
+	Resident         int32
+	Private_resident int32
+	Protection       int32
+	Ref_count        int32
+	Shadow_count     int32
+	Vn_type          int32
+	Vn_size          uint64
+	Vn_rdev          uint32
+	Vn_mode          uint16
+	Status           uint16
+	X_kve_ispare     [12]int32
+	Path             [1024]int8
+}

vendor/github.com/shirou/gopsutil/process/process_linux.go

@@ -0,0 +1,890 @@
+// +build linux
+
+package process
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"math"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/host"
+	"github.com/shirou/gopsutil/internal/common"
+	"github.com/shirou/gopsutil/net"
+)
+
+var (
+	ErrorNoChildren = errors.New("process does not have children")
+	PageSize        = uint64(os.Getpagesize())
+)
+
+const (
+	PrioProcess = 0   // linux/resource.h
+	ClockTicks  = 100 // C.sysconf(C._SC_CLK_TCK)
+)
+
+// MemoryInfoExStat is different between OSes
+type MemoryInfoExStat struct {
+	RSS    uint64 `json:"rss"`    // bytes
+	VMS    uint64 `json:"vms"`    // bytes
+	Shared uint64 `json:"shared"` // bytes
+	Text   uint64 `json:"text"`   // bytes
+	Lib    uint64 `json:"lib"`    // bytes
+	Data   uint64 `json:"data"`   // bytes
+	Dirty  uint64 `json:"dirty"`  // bytes
+}
+
+func (m MemoryInfoExStat) String() string {
+	s, _ := json.Marshal(m)
+	return string(s)
+}
+
+type MemoryMapsStat struct {
+	Path         string `json:"path"`
+	Rss          uint64 `json:"rss"`
+	Size         uint64 `json:"size"`
+	Pss          uint64 `json:"pss"`
+	SharedClean  uint64 `json:"sharedClean"`
+	SharedDirty  uint64 `json:"sharedDirty"`
+	PrivateClean uint64 `json:"privateClean"`
+	PrivateDirty uint64 `json:"privateDirty"`
+	Referenced   uint64 `json:"referenced"`
+	Anonymous    uint64 `json:"anonymous"`
+	Swap         uint64 `json:"swap"`
+}
+
+// String returns JSON value of the process.
+func (m MemoryMapsStat) String() string {
+	s, _ := json.Marshal(m)
+	return string(s)
+}
+
+// NewProcess creates a new Process instance, it only stores the pid and
+// checks that the process exists. Other method on Process can be used
+// to get more information about the process. An error will be returned
+// if the process does not exist.
+func NewProcess(pid int32) (*Process, error) {
+	p := &Process{
+		Pid: int32(pid),
+	}
+	file, err := os.Open(common.HostProc(strconv.Itoa(int(p.Pid))))
+	defer file.Close()
+	return p, err
+}
+
+// Ppid returns Parent Process ID of the process.
+func (p *Process) Ppid() (int32, error) {
+	_, ppid, _, _, _, err := p.fillFromStat()
+	if err != nil {
+		return -1, err
+	}
+	return ppid, nil
+}
+
+// Name returns name of the process.
+func (p *Process) Name() (string, error) {
+	if p.name == "" {
+		if err := p.fillFromStatus(); err != nil {
+			return "", err
+		}
+	}
+	return p.name, nil
+}
+
+// Exe returns executable path of the process.
+func (p *Process) Exe() (string, error) {
+	return p.fillFromExe()
+}
+
+// Cmdline returns the command line arguments of the process as a string with
+// each argument separated by 0x20 ascii character.
+func (p *Process) Cmdline() (string, error) {
+	return p.fillFromCmdline()
+}
+
+// CmdlineSlice returns the command line arguments of the process as a slice with each
+// element being an argument.
+func (p *Process) CmdlineSlice() ([]string, error) {
+	return p.fillSliceFromCmdline()
+}
+
+// CreateTime returns created time of the process in seconds since the epoch, in UTC.
+func (p *Process) CreateTime() (int64, error) {
+	_, _, _, createTime, _, err := p.fillFromStat()
+	if err != nil {
+		return 0, err
+	}
+	return createTime, nil
+}
+
+// Cwd returns current working directory of the process.
+func (p *Process) Cwd() (string, error) {
+	return p.fillFromCwd()
+}
+
+// Parent returns parent Process of the process.
+func (p *Process) Parent() (*Process, error) {
+	err := p.fillFromStatus()
+	if err != nil {
+		return nil, err
+	}
+	if p.parent == 0 {
+		return nil, fmt.Errorf("wrong number of parents")
+	}
+	return NewProcess(p.parent)
+}
+
+// Status returns the process status.
+// Return value could be one of these.
+// R: Running S: Sleep T: Stop I: Idle
+// Z: Zombie W: Wait L: Lock
+// The charactor is same within all supported platforms.
+func (p *Process) Status() (string, error) {
+	err := p.fillFromStatus()
+	if err != nil {
+		return "", err
+	}
+	return p.status, nil
+}
+
+// Uids returns user ids of the process as a slice of the int
+func (p *Process) Uids() ([]int32, error) {
+	err := p.fillFromStatus()
+	if err != nil {
+		return []int32{}, err
+	}
+	return p.uids, nil
+}
+
+// Gids returns group ids of the process as a slice of the int
+func (p *Process) Gids() ([]int32, error) {
+	err := p.fillFromStatus()
+	if err != nil {
+		return []int32{}, err
+	}
+	return p.gids, nil
+}
+
+// Terminal returns a terminal which is associated with the process.
+func (p *Process) Terminal() (string, error) {
+	terminal, _, _, _, _, err := p.fillFromStat()
+	if err != nil {
+		return "", err
+	}
+	return terminal, nil
+}
+
+// Nice returns a nice value (priority).
+// Notice: gopsutil can not set nice value.
+func (p *Process) Nice() (int32, error) {
+	_, _, _, _, nice, err := p.fillFromStat()
+	if err != nil {
+		return 0, err
+	}
+	return nice, nil
+}
+
+// IOnice returns process I/O nice value (priority).
+func (p *Process) IOnice() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+
+// Rlimit returns Resource Limits.
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	return p.fillFromLimits()
+}
+
+// IOCounters returns IO Counters.
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	return p.fillFromIO()
+}
+
+// NumCtxSwitches returns the number of the context switches of the process.
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	err := p.fillFromStatus()
+	if err != nil {
+		return nil, err
+	}
+	return p.numCtxSwitches, nil
+}
+
+// NumFDs returns the number of File Descriptors used by the process.
+func (p *Process) NumFDs() (int32, error) {
+	numFds, _, err := p.fillFromfd()
+	return numFds, err
+}
+
+// NumThreads returns the number of threads used by the process.
+func (p *Process) NumThreads() (int32, error) {
+	err := p.fillFromStatus()
+	if err != nil {
+		return 0, err
+	}
+	return p.numThreads, nil
+}
+
+// Threads returns a map of threads
+//
+// Notice: Not implemented yet. always returns empty map.
+func (p *Process) Threads() (map[string]string, error) {
+	ret := make(map[string]string, 0)
+	return ret, nil
+}
+
+// Times returns CPU times of the process.
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	_, _, cpuTimes, _, _, err := p.fillFromStat()
+	if err != nil {
+		return nil, err
+	}
+	return cpuTimes, nil
+}
+
+// CPUAffinity returns CPU affinity of the process.
+//
+// Notice: Not implemented yet.
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+// MemoryInfo returns platform in-dependend memory information, such as RSS, VMS and Swap
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	meminfo, _, err := p.fillFromStatm()
+	if err != nil {
+		return nil, err
+	}
+	return meminfo, nil
+}
+
+// MemoryInfoEx returns platform dependend memory information.
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	_, memInfoEx, err := p.fillFromStatm()
+	if err != nil {
+		return nil, err
+	}
+	return memInfoEx, nil
+}
+
+// Children returns a slice of Process of the process.
+func (p *Process) Children() ([]*Process, error) {
+	pids, err := common.CallPgrep(invoke, p.Pid)
+	if err != nil {
+		if pids == nil || len(pids) == 0 {
+			return nil, ErrorNoChildren
+		}
+		return nil, err
+	}
+	ret := make([]*Process, 0, len(pids))
+	for _, pid := range pids {
+		np, err := NewProcess(pid)
+		if err != nil {
+			return nil, err
+		}
+		ret = append(ret, np)
+	}
+	return ret, nil
+}
+
+// OpenFiles returns a slice of OpenFilesStat opend by the process.
+// OpenFilesStat includes a file path and file descriptor.
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	_, ofs, err := p.fillFromfd()
+	if err != nil {
+		return nil, err
+	}
+	ret := make([]OpenFilesStat, len(ofs))
+	for i, o := range ofs {
+		ret[i] = *o
+	}
+
+	return ret, nil
+}
+
+// Connections returns a slice of net.ConnectionStat used by the process.
+// This returns all kind of the connection. This measn TCP, UDP or UNIX.
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return net.ConnectionsPid("all", p.Pid)
+}
+
+// NetIOCounters returns NetIOCounters of the process.
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	filename := common.HostProc(strconv.Itoa(int(p.Pid)), "net/dev")
+	return net.IOCountersByFile(pernic, filename)
+}
+
+// IsRunning returns whether the process is running or not.
+// Not implemented yet.
+func (p *Process) IsRunning() (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+
+// MemoryMaps get memory maps from /proc/(pid)/smaps
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	pid := p.Pid
+	var ret []MemoryMapsStat
+	smapsPath := common.HostProc(strconv.Itoa(int(pid)), "smaps")
+	contents, err := ioutil.ReadFile(smapsPath)
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(string(contents), "\n")
+
+	// function of parsing a block
+	getBlock := func(first_line []string, block []string) (MemoryMapsStat, error) {
+		m := MemoryMapsStat{}
+		m.Path = first_line[len(first_line)-1]
+
+		for _, line := range block {
+			if strings.Contains(line, "VmFlags") {
+				continue
+			}
+			field := strings.Split(line, ":")
+			if len(field) < 2 {
+				continue
+			}
+			v := strings.Trim(field[1], " kB") // remove last "kB"
+			t, err := strconv.ParseUint(v, 10, 64)
+			if err != nil {
+				return m, err
+			}
+
+			switch field[0] {
+			case "Size":
+				m.Size = t
+			case "Rss":
+				m.Rss = t
+			case "Pss":
+				m.Pss = t
+			case "Shared_Clean":
+				m.SharedClean = t
+			case "Shared_Dirty":
+				m.SharedDirty = t
+			case "Private_Clean":
+				m.PrivateClean = t
+			case "Private_Dirty":
+				m.PrivateDirty = t
+			case "Referenced":
+				m.Referenced = t
+			case "Anonymous":
+				m.Anonymous = t
+			case "Swap":
+				m.Swap = t
+			}
+		}
+		return m, nil
+	}
+
+	blocks := make([]string, 16)
+	for _, line := range lines {
+		field := strings.Split(line, " ")
+		if strings.HasSuffix(field[0], ":") == false {
+			// new block section
+			if len(blocks) > 0 {
+				g, err := getBlock(field, blocks)
+				if err != nil {
+					return &ret, err
+				}
+				ret = append(ret, g)
+			}
+			// starts new block
+			blocks = make([]string, 16)
+		} else {
+			blocks = append(blocks, line)
+		}
+	}
+
+	return &ret, nil
+}
+
+/**
+** Internal functions
+**/
+
+func limitToInt(val string) (int32, error) {
+	if val == "unlimited" {
+		return math.MaxInt32, nil
+	} else {
+		res, err := strconv.ParseInt(val, 10, 32)
+		if err != nil {
+			return 0, err
+		}
+		return int32(res), nil
+	}
+}
+
+// Get num_fds from /proc/(pid)/limits
+func (p *Process) fillFromLimits() ([]RlimitStat, error) {
+	pid := p.Pid
+	limitsFile := common.HostProc(strconv.Itoa(int(pid)), "limits")
+	d, err := os.Open(limitsFile)
+	if err != nil {
+		return nil, err
+	}
+	defer d.Close()
+
+	var limitStats []RlimitStat
+
+	limitsScanner := bufio.NewScanner(d)
+	for limitsScanner.Scan() {
+		var statItem RlimitStat
+
+		str := strings.Fields(limitsScanner.Text())
+
+		// Remove the header line
+		if strings.Contains(str[len(str)-1], "Units") {
+			continue
+		}
+
+		// Assert that last item is a Hard limit
+		statItem.Hard, err = limitToInt(str[len(str)-1])
+		if err != nil {
+			// On error remove last item an try once again since it can be unit or header line
+			str = str[:len(str)-1]
+			statItem.Hard, err = limitToInt(str[len(str)-1])
+			if err != nil {
+				return nil, err
+			}
+		}
+		// Remove last item from string
+		str = str[:len(str)-1]
+
+		//Now last item is a Soft limit
+		statItem.Soft, err = limitToInt(str[len(str)-1])
+		if err != nil {
+			return nil, err
+		}
+		// Remove last item from string
+		str = str[:len(str)-1]
+
+		//The rest is a stats name
+		resourceName := strings.Join(str, " ")
+		switch resourceName {
+		case "Max cpu time":
+			statItem.Resource = RLIMIT_CPU
+		case "Max file size":
+			statItem.Resource = RLIMIT_FSIZE
+		case "Max data size":
+			statItem.Resource = RLIMIT_DATA
+		case "Max stack size":
+			statItem.Resource = RLIMIT_STACK
+		case "Max core file size":
+			statItem.Resource = RLIMIT_CORE
+		case "Max resident set":
+			statItem.Resource = RLIMIT_RSS
+		case "Max processes":
+			statItem.Resource = RLIMIT_NPROC
+		case "Max open files":
+			statItem.Resource = RLIMIT_NOFILE
+		case "Max locked memory":
+			statItem.Resource = RLIMIT_MEMLOCK
+		case "Max address space":
+			statItem.Resource = RLIMIT_AS
+		case "Max file locks":
+			statItem.Resource = RLIMIT_LOCKS
+		case "Max pending signals":
+			statItem.Resource = RLIMIT_SIGPENDING
+		case "Max msgqueue size":
+			statItem.Resource = RLIMIT_MSGQUEUE
+		case "Max nice priority":
+			statItem.Resource = RLIMIT_NICE
+		case "Max realtime priority":
+			statItem.Resource = RLIMIT_RTPRIO
+		case "Max realtime timeout":
+			statItem.Resource = RLIMIT_RTTIME
+		default:
+			continue
+		}
+
+		limitStats = append(limitStats, statItem)
+	}
+
+	if err := limitsScanner.Err(); err != nil {
+		return nil, err
+	}
+
+	return limitStats, nil
+}
+
+// Get num_fds from /proc/(pid)/fd
+func (p *Process) fillFromfd() (int32, []*OpenFilesStat, error) {
+	pid := p.Pid
+	statPath := common.HostProc(strconv.Itoa(int(pid)), "fd")
+	d, err := os.Open(statPath)
+	if err != nil {
+		return 0, nil, err
+	}
+	defer d.Close()
+	fnames, err := d.Readdirnames(-1)
+	numFDs := int32(len(fnames))
+
+	var openfiles []*OpenFilesStat
+	for _, fd := range fnames {
+		fpath := filepath.Join(statPath, fd)
+		filepath, err := os.Readlink(fpath)
+		if err != nil {
+			continue
+		}
+		t, err := strconv.ParseUint(fd, 10, 64)
+		if err != nil {
+			return numFDs, openfiles, err
+		}
+		o := &OpenFilesStat{
+			Path: filepath,
+			Fd:   t,
+		}
+		openfiles = append(openfiles, o)
+	}
+
+	return numFDs, openfiles, nil
+}
+
+// Get cwd from /proc/(pid)/cwd
+func (p *Process) fillFromCwd() (string, error) {
+	pid := p.Pid
+	cwdPath := common.HostProc(strconv.Itoa(int(pid)), "cwd")
+	cwd, err := os.Readlink(cwdPath)
+	if err != nil {
+		return "", err
+	}
+	return string(cwd), nil
+}
+
+// Get exe from /proc/(pid)/exe
+func (p *Process) fillFromExe() (string, error) {
+	pid := p.Pid
+	exePath := common.HostProc(strconv.Itoa(int(pid)), "exe")
+	exe, err := os.Readlink(exePath)
+	if err != nil {
+		return "", err
+	}
+	return string(exe), nil
+}
+
+// Get cmdline from /proc/(pid)/cmdline
+func (p *Process) fillFromCmdline() (string, error) {
+	pid := p.Pid
+	cmdPath := common.HostProc(strconv.Itoa(int(pid)), "cmdline")
+	cmdline, err := ioutil.ReadFile(cmdPath)
+	if err != nil {
+		return "", err
+	}
+	ret := strings.FieldsFunc(string(cmdline), func(r rune) bool {
+		if r == '\u0000' {
+			return true
+		}
+		return false
+	})
+
+	return strings.Join(ret, " "), nil
+}
+
+func (p *Process) fillSliceFromCmdline() ([]string, error) {
+	pid := p.Pid
+	cmdPath := common.HostProc(strconv.Itoa(int(pid)), "cmdline")
+	cmdline, err := ioutil.ReadFile(cmdPath)
+	if err != nil {
+		return nil, err
+	}
+	if len(cmdline) == 0 {
+		return nil, nil
+	}
+	if cmdline[len(cmdline)-1] == 0 {
+		cmdline = cmdline[:len(cmdline)-1]
+	}
+	parts := bytes.Split(cmdline, []byte{0})
+	var strParts []string
+	for _, p := range parts {
+		strParts = append(strParts, string(p))
+	}
+
+	return strParts, nil
+}
+
+// Get IO status from /proc/(pid)/io
+func (p *Process) fillFromIO() (*IOCountersStat, error) {
+	pid := p.Pid
+	ioPath := common.HostProc(strconv.Itoa(int(pid)), "io")
+	ioline, err := ioutil.ReadFile(ioPath)
+	if err != nil {
+		return nil, err
+	}
+	lines := strings.Split(string(ioline), "\n")
+	ret := &IOCountersStat{}
+
+	for _, line := range lines {
+		field := strings.Fields(line)
+		if len(field) < 2 {
+			continue
+		}
+		t, err := strconv.ParseUint(field[1], 10, 64)
+		if err != nil {
+			return nil, err
+		}
+		param := field[0]
+		if strings.HasSuffix(param, ":") {
+			param = param[:len(param)-1]
+		}
+		switch param {
+		case "syscr":
+			ret.ReadCount = t
+		case "syscw":
+			ret.WriteCount = t
+		case "read_bytes":
+			ret.ReadBytes = t
+		case "write_bytes":
+			ret.WriteBytes = t
+		}
+	}
+
+	return ret, nil
+}
+
+// Get memory info from /proc/(pid)/statm
+func (p *Process) fillFromStatm() (*MemoryInfoStat, *MemoryInfoExStat, error) {
+	pid := p.Pid
+	memPath := common.HostProc(strconv.Itoa(int(pid)), "statm")
+	contents, err := ioutil.ReadFile(memPath)
+	if err != nil {
+		return nil, nil, err
+	}
+	fields := strings.Split(string(contents), " ")
+
+	vms, err := strconv.ParseUint(fields[0], 10, 64)
+	if err != nil {
+		return nil, nil, err
+	}
+	rss, err := strconv.ParseUint(fields[1], 10, 64)
+	if err != nil {
+		return nil, nil, err
+	}
+	memInfo := &MemoryInfoStat{
+		RSS: rss * PageSize,
+		VMS: vms * PageSize,
+	}
+
+	shared, err := strconv.ParseUint(fields[2], 10, 64)
+	if err != nil {
+		return nil, nil, err
+	}
+	text, err := strconv.ParseUint(fields[3], 10, 64)
+	if err != nil {
+		return nil, nil, err
+	}
+	lib, err := strconv.ParseUint(fields[4], 10, 64)
+	if err != nil {
+		return nil, nil, err
+	}
+	dirty, err := strconv.ParseUint(fields[5], 10, 64)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	memInfoEx := &MemoryInfoExStat{
+		RSS:    rss * PageSize,
+		VMS:    vms * PageSize,
+		Shared: shared * PageSize,
+		Text:   text * PageSize,
+		Lib:    lib * PageSize,
+		Dirty:  dirty * PageSize,
+	}
+
+	return memInfo, memInfoEx, nil
+}
+
+// Get various status from /proc/(pid)/status
+func (p *Process) fillFromStatus() error {
+	pid := p.Pid
+	statPath := common.HostProc(strconv.Itoa(int(pid)), "status")
+	contents, err := ioutil.ReadFile(statPath)
+	if err != nil {
+		return err
+	}
+	lines := strings.Split(string(contents), "\n")
+	p.numCtxSwitches = &NumCtxSwitchesStat{}
+	p.memInfo = &MemoryInfoStat{}
+	for _, line := range lines {
+		tabParts := strings.SplitN(line, "\t", 2)
+		if len(tabParts) < 2 {
+			continue
+		}
+		value := tabParts[1]
+		switch strings.TrimRight(tabParts[0], ":") {
+		case "Name":
+			p.name = strings.Trim(value, " \t")
+			if len(p.name) >= 15 {
+				cmdlineSlice, err := p.CmdlineSlice()
+				if err != nil {
+					return err
+				}
+				if len(cmdlineSlice) > 0 {
+					extendedName := filepath.Base(cmdlineSlice[0])
+					if strings.HasPrefix(extendedName, p.name) {
+						p.name = extendedName
+					}
+				}
+			}
+		case "State":
+			p.status = value[0:1]
+		case "PPid", "Ppid":
+			pval, err := strconv.ParseInt(value, 10, 32)
+			if err != nil {
+				return err
+			}
+			p.parent = int32(pval)
+		case "Uid":
+			p.uids = make([]int32, 0, 4)
+			for _, i := range strings.Split(value, "\t") {
+				v, err := strconv.ParseInt(i, 10, 32)
+				if err != nil {
+					return err
+				}
+				p.uids = append(p.uids, int32(v))
+			}
+		case "Gid":
+			p.gids = make([]int32, 0, 4)
+			for _, i := range strings.Split(value, "\t") {
+				v, err := strconv.ParseInt(i, 10, 32)
+				if err != nil {
+					return err
+				}
+				p.gids = append(p.gids, int32(v))
+			}
+		case "Threads":
+			v, err := strconv.ParseInt(value, 10, 32)
+			if err != nil {
+				return err
+			}
+			p.numThreads = int32(v)
+		case "voluntary_ctxt_switches":
+			v, err := strconv.ParseInt(value, 10, 64)
+			if err != nil {
+				return err
+			}
+			p.numCtxSwitches.Voluntary = v
+		case "nonvoluntary_ctxt_switches":
+			v, err := strconv.ParseInt(value, 10, 64)
+			if err != nil {
+				return err
+			}
+			p.numCtxSwitches.Involuntary = v
+		case "VmRSS":
+			value := strings.Trim(value, " kB") // remove last "kB"
+			v, err := strconv.ParseUint(value, 10, 64)
+			if err != nil {
+				return err
+			}
+			p.memInfo.RSS = v * 1024
+		case "VmSize":
+			value := strings.Trim(value, " kB") // remove last "kB"
+			v, err := strconv.ParseUint(value, 10, 64)
+			if err != nil {
+				return err
+			}
+			p.memInfo.VMS = v * 1024
+		case "VmSwap":
+			value := strings.Trim(value, " kB") // remove last "kB"
+			v, err := strconv.ParseUint(value, 10, 64)
+			if err != nil {
+				return err
+			}
+			p.memInfo.Swap = v * 1024
+		}
+
+	}
+	return nil
+}
+
+func (p *Process) fillFromStat() (string, int32, *cpu.TimesStat, int64, int32, error) {
+	pid := p.Pid
+	statPath := common.HostProc(strconv.Itoa(int(pid)), "stat")
+	contents, err := ioutil.ReadFile(statPath)
+	if err != nil {
+		return "", 0, nil, 0, 0, err
+	}
+	fields := strings.Fields(string(contents))
+
+	i := 1
+	for !strings.HasSuffix(fields[i], ")") {
+		i++
+	}
+
+	termmap, err := getTerminalMap()
+	terminal := ""
+	if err == nil {
+		t, err := strconv.ParseUint(fields[i+5], 10, 64)
+		if err != nil {
+			return "", 0, nil, 0, 0, err
+		}
+		terminal = termmap[t]
+	}
+
+	ppid, err := strconv.ParseInt(fields[i+2], 10, 32)
+	if err != nil {
+		return "", 0, nil, 0, 0, err
+	}
+	utime, err := strconv.ParseFloat(fields[i+12], 64)
+	if err != nil {
+		return "", 0, nil, 0, 0, err
+	}
+
+	stime, err := strconv.ParseFloat(fields[i+13], 64)
+	if err != nil {
+		return "", 0, nil, 0, 0, err
+	}
+
+	cpuTimes := &cpu.TimesStat{
+		CPU:    "cpu",
+		User:   float64(utime / ClockTicks),
+		System: float64(stime / ClockTicks),
+	}
+
+	bootTime, _ := host.BootTime()
+	t, err := strconv.ParseUint(fields[i+20], 10, 64)
+	if err != nil {
+		return "", 0, nil, 0, 0, err
+	}
+	ctime := (t / uint64(ClockTicks)) + uint64(bootTime)
+	createTime := int64(ctime * 1000)
+
+	//	p.Nice = mustParseInt32(fields[18])
+	// use syscall instead of parse Stat file
+	snice, _ := syscall.Getpriority(PrioProcess, int(pid))
+	nice := int32(snice) // FIXME: is this true?
+
+	return terminal, int32(ppid), cpuTimes, createTime, nice, nil
+}
+
+// Pids returns a slice of process ID list which are running now.
+func Pids() ([]int32, error) {
+	var ret []int32
+
+	d, err := os.Open(common.HostProc())
+	if err != nil {
+		return nil, err
+	}
+	defer d.Close()
+
+	fnames, err := d.Readdirnames(-1)
+	if err != nil {
+		return nil, err
+	}
+	for _, fname := range fnames {
+		pid, err := strconv.ParseInt(fname, 10, 32)
+		if err != nil {
+			// if not numeric name, just skip
+			continue
+		}
+		ret = append(ret, int32(pid))
+	}
+
+	return ret, nil
+}

vendor/github.com/shirou/gopsutil/process/process_openbsd.go

@@ -0,0 +1,362 @@
+// +build openbsd
+
+package process
+
+import (
+	"bytes"
+	"C"
+	"encoding/binary"
+	"strings"
+	"syscall"
+	"unsafe"
+
+	cpu "github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	net "github.com/shirou/gopsutil/net"
+	mem "github.com/shirou/gopsutil/mem"
+)
+
+// MemoryInfoExStat is different between OSes
+type MemoryInfoExStat struct {
+}
+
+type MemoryMapsStat struct {
+}
+
+func Pids() ([]int32, error) {
+	var ret []int32
+	procs, err := processes()
+	if err != nil {
+		return ret, nil
+	}
+
+	for _, p := range procs {
+		ret = append(ret, p.Pid)
+	}
+
+	return ret, nil
+}
+
+func (p *Process) Ppid() (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+
+	return k.Ppid, nil
+}
+func (p *Process) Name() (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	return common.IntToString(k.Comm[:]), nil
+}
+func (p *Process) Exe() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+
+func (p *Process) CmdlineSlice() ([]string, error) {
+	mib := []int32{CTLKern, KernProcArgs, p.Pid, KernProcArgv }
+	buf, _, err := common.CallSyscall(mib)
+
+	if err != nil {
+		return nil, err
+	}
+
+	argc := 0
+	argvp := unsafe.Pointer(&buf[0])
+	argv := *(**C.char)(unsafe.Pointer(argvp))
+	size := unsafe.Sizeof(argv)
+	var strParts []string
+
+	for argv != nil {
+		strParts = append(strParts, C.GoString(argv))
+
+		argc++
+		argv = *(**C.char)(unsafe.Pointer(uintptr(argvp) + uintptr(argc) * size))
+	}
+	return strParts, nil
+}
+
+func (p *Process) Cmdline() (string, error) {
+	argv, err := p.CmdlineSlice()
+	if err != nil {
+		return "", err
+	}
+	return strings.Join(argv, " "), nil
+}
+
+func (p *Process) CreateTime() (int64, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Cwd() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Parent() (*Process, error) {
+	return p, common.ErrNotImplementedError
+}
+func (p *Process) Status() (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+	var s string
+	switch k.Stat {
+	case SIDL:
+	case SRUN:
+	case SONPROC:
+		s = "R"
+	case SSLEEP:
+		s = "S"
+	case SSTOP:
+		s = "T"
+	case SDEAD:
+		s = "Z"
+	}
+
+	return s, nil
+}
+func (p *Process) Uids() ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	uids := make([]int32, 0, 3)
+
+	uids = append(uids, int32(k.Ruid), int32(k.Uid), int32(k.Svuid))
+
+	return uids, nil
+}
+func (p *Process) Gids() ([]int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+
+	gids := make([]int32, 0, 3)
+	gids = append(gids, int32(k.Rgid), int32(k.Ngroups), int32(k.Svgid))
+
+	return gids, nil
+}
+func (p *Process) Terminal() (string, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return "", err
+	}
+
+	ttyNr := uint64(k.Tdev)
+
+	termmap, err := getTerminalMap()
+	if err != nil {
+		return "", err
+	}
+
+	return termmap[ttyNr], nil
+}
+func (p *Process) Nice() (int32, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return 0, err
+	}
+	return int32(k.Nice), nil
+}
+func (p *Process) IOnice() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+	return rlimit, common.ErrNotImplementedError
+}
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	return &IOCountersStat{
+		ReadCount:  uint64(k.Uru_inblock),
+		WriteCount: uint64(k.Uru_oublock),
+	}, nil
+}
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumFDs() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) NumThreads() (int32, error) {
+	/* not supported, just return 1 */
+	return 1, nil
+}
+func (p *Process) Threads() (map[string]string, error) {
+	ret := make(map[string]string, 0)
+	return ret, common.ErrNotImplementedError
+}
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	return &cpu.TimesStat{
+		CPU:    "cpu",
+		User:   float64(k.Uutime_sec) + float64(k.Uutime_usec)/1000000,
+		System: float64(k.Ustime_sec) + float64(k.Ustime_usec)/1000000,
+	}, nil
+}
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	k, err := p.getKProc()
+	if err != nil {
+		return nil, err
+	}
+	pageSize, err := mem.GetPageSize()
+	if err != nil {
+		return nil, err
+	}
+
+	return &MemoryInfoStat{
+		RSS: uint64(k.Vm_rssize) * pageSize,
+		VMS: uint64(k.Vm_tsize) + uint64(k.Vm_dsize) +
+			uint64(k.Vm_ssize),
+	}, nil
+}
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Children() ([]*Process, error) {
+	pids, err := common.CallPgrep(invoke, p.Pid)
+	if err != nil {
+		return nil, err
+	}
+	ret := make([]*Process, 0, len(pids))
+	for _, pid := range pids {
+		np, err := NewProcess(pid)
+		if err != nil {
+			return nil, err
+		}
+		ret = append(ret, np)
+	}
+	return ret, nil
+}
+
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) IsRunning() (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	var ret []MemoryMapsStat
+	return &ret, common.ErrNotImplementedError
+}
+
+func processes() ([]Process, error) {
+	results := make([]Process, 0, 50)
+
+	buf, length, err := CallKernProcSyscall(KernProcAll, 0)
+
+	if err != nil {
+		return results, err
+	}
+
+	// get kinfo_proc size
+	count := int(length / uint64(sizeOfKinfoProc))
+
+	// parse buf to procs
+	for i := 0; i < count; i++ {
+		b := buf[i*sizeOfKinfoProc : (i+1)*sizeOfKinfoProc]
+		k, err := parseKinfoProc(b)
+		if err != nil {
+			continue
+		}
+		p, err := NewProcess(int32(k.Pid))
+		if err != nil {
+			continue
+		}
+
+		results = append(results, *p)
+	}
+
+	return results, nil
+}
+
+func parseKinfoProc(buf []byte) (KinfoProc, error) {
+	var k KinfoProc
+	br := bytes.NewReader(buf)
+	err := common.Read(br, binary.LittleEndian, &k)
+	return k, err
+}
+
+func (p *Process) getKProc() (*KinfoProc, error) {
+	buf, length, err := CallKernProcSyscall(KernProcPID, p.Pid)
+	if err != nil {
+		return nil, err
+	}
+	if length != sizeOfKinfoProc {
+		return nil, err
+	}
+
+	k, err := parseKinfoProc(buf)
+	if err != nil {
+		return nil, err
+	}
+	return &k, nil
+}
+
+func NewProcess(pid int32) (*Process, error) {
+	p := &Process{Pid: pid}
+
+	return p, nil
+}
+
+func CallKernProcSyscall(op int32, arg int32) ([]byte, uint64, error) {
+	mib := []int32{CTLKern, KernProc, op, arg, sizeOfKinfoProc, 0}
+	mibptr := unsafe.Pointer(&mib[0])
+	miblen := uint64(len(mib))
+	length := uint64(0)
+	_, _, err := syscall.Syscall6(
+		syscall.SYS___SYSCTL,
+		uintptr(mibptr),
+		uintptr(miblen),
+		0,
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		return nil, length, err
+	}
+
+	count := int32(length / uint64(sizeOfKinfoProc))
+	mib = []int32{CTLKern, KernProc, op, arg, sizeOfKinfoProc, count}
+	mibptr = unsafe.Pointer(&mib[0])
+	miblen = uint64(len(mib))
+	// get proc info itself
+	buf := make([]byte, length)
+	_, _, err = syscall.Syscall6(
+		syscall.SYS___SYSCTL,
+		uintptr(mibptr),
+		uintptr(miblen),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if err != 0 {
+		return buf, length, err
+	}
+
+	return buf, length, nil
+}

vendor/github.com/shirou/gopsutil/process/process_openbsd_amd64.go

@@ -0,0 +1,200 @@
+// Created by cgo -godefs - DO NOT EDIT
+// cgo -godefs types_openbsd.go
+
+package process
+
+const (
+	CTLKern			= 1
+	KernProc		= 66
+	KernProcAll		= 0
+	KernProcPID		= 1
+	KernProcProc		= 8
+	KernProcPathname	= 12
+	KernProcArgs		= 55
+	KernProcArgv		= 1
+	KernProcEnv		= 3
+)
+
+const (
+	ArgMax = 256 * 1024
+)
+
+const (
+	sizeofPtr	= 0x8
+	sizeofShort	= 0x2
+	sizeofInt	= 0x4
+	sizeofLong	= 0x8
+	sizeofLongLong	= 0x8
+)
+
+const (
+	sizeOfKinfoVmentry	= 0x50
+	sizeOfKinfoProc		= 0x268
+)
+
+const (
+	SIDL	= 1
+	SRUN	= 2
+	SSLEEP	= 3
+	SSTOP	= 4
+	SZOMB	= 5
+	SDEAD	= 6
+	SONPROC	= 7
+)
+
+type (
+	_C_short	int16
+	_C_int		int32
+	_C_long		int64
+	_C_long_long	int64
+)
+
+type Timespec struct {
+	Sec	int64
+	Nsec	int64
+}
+
+type Timeval struct {
+	Sec	int64
+	Usec	int64
+}
+
+type Rusage struct {
+	Utime		Timeval
+	Stime		Timeval
+	Maxrss		int64
+	Ixrss		int64
+	Idrss		int64
+	Isrss		int64
+	Minflt		int64
+	Majflt		int64
+	Nswap		int64
+	Inblock		int64
+	Oublock		int64
+	Msgsnd		int64
+	Msgrcv		int64
+	Nsignals	int64
+	Nvcsw		int64
+	Nivcsw		int64
+}
+
+type Rlimit struct {
+	Cur	uint64
+	Max	uint64
+}
+
+type KinfoProc struct {
+	Forw		uint64
+	Back		uint64
+	Paddr		uint64
+	Addr		uint64
+	Fd		uint64
+	Stats		uint64
+	Limit		uint64
+	Vmspace		uint64
+	Sigacts		uint64
+	Sess		uint64
+	Tsess		uint64
+	Ru		uint64
+	Eflag		int32
+	Exitsig		int32
+	Flag		int32
+	Pid		int32
+	Ppid		int32
+	Sid		int32
+	X_pgid		int32
+	Tpgid		int32
+	Uid		uint32
+	Ruid		uint32
+	Gid		uint32
+	Rgid		uint32
+	Groups		[16]uint32
+	Ngroups		int16
+	Jobc		int16
+	Tdev		uint32
+	Estcpu		uint32
+	Rtime_sec	uint32
+	Rtime_usec	uint32
+	Cpticks		int32
+	Pctcpu		uint32
+	Swtime		uint32
+	Slptime		uint32
+	Schedflags	int32
+	Uticks		uint64
+	Sticks		uint64
+	Iticks		uint64
+	Tracep		uint64
+	Traceflag	int32
+	Holdcnt		int32
+	Siglist		int32
+	Sigmask		uint32
+	Sigignore	uint32
+	Sigcatch	uint32
+	Stat		int8
+	Priority	uint8
+	Usrpri		uint8
+	Nice		uint8
+	Xstat		uint16
+	Acflag		uint16
+	Comm		[24]int8
+	Wmesg		[8]int8
+	Wchan		uint64
+	Login		[32]int8
+	Vm_rssize	int32
+	Vm_tsize	int32
+	Vm_dsize	int32
+	Vm_ssize	int32
+	Uvalid		int64
+	Ustart_sec	uint64
+	Ustart_usec	uint32
+	Uutime_sec	uint32
+	Uutime_usec	uint32
+	Ustime_sec	uint32
+	Ustime_usec	uint32
+	Pad_cgo_0	[4]byte
+	Uru_maxrss	uint64
+	Uru_ixrss	uint64
+	Uru_idrss	uint64
+	Uru_isrss	uint64
+	Uru_minflt	uint64
+	Uru_majflt	uint64
+	Uru_nswap	uint64
+	Uru_inblock	uint64
+	Uru_oublock	uint64
+	Uru_msgsnd	uint64
+	Uru_msgrcv	uint64
+	Uru_nsignals	uint64
+	Uru_nvcsw	uint64
+	Uru_nivcsw	uint64
+	Uctime_sec	uint32
+	Uctime_usec	uint32
+	Psflags		int32
+	Spare		int32
+	Svuid		uint32
+	Svgid		uint32
+	Emul		[8]int8
+	Rlim_rss_cur	uint64
+	Cpuid		uint64
+	Vm_map_size	uint64
+	Tid		int32
+	Rtableid	uint32
+}
+
+type Priority struct{}
+
+type KinfoVmentry struct {
+	Start		uint64
+	End		uint64
+	Guard		uint64
+	Fspace		uint64
+	Fspace_augment	uint64
+	Offset		uint64
+	Wired_count	int32
+	Etype		int32
+	Protection	int32
+	Max_protection	int32
+	Advice		int32
+	Inheritance	int32
+	Flags		uint8
+	Pad_cgo_0	[7]byte
+}

vendor/github.com/shirou/gopsutil/process/process_posix.go

@@ -0,0 +1,130 @@
+// +build linux freebsd openbsd darwin
+
+package process
+
+import (
+	"os"
+	"os/exec"
+	"os/user"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/shirou/gopsutil/internal/common"
+)
+
+// POSIX
+func getTerminalMap() (map[uint64]string, error) {
+	ret := make(map[uint64]string)
+	var termfiles []string
+
+	d, err := os.Open("/dev")
+	if err != nil {
+		return nil, err
+	}
+	defer d.Close()
+
+	devnames, err := d.Readdirnames(-1)
+	for _, devname := range devnames {
+		if strings.HasPrefix(devname, "/dev/tty") {
+			termfiles = append(termfiles, "/dev/tty/"+devname)
+		}
+	}
+
+	var ptsnames []string
+	ptsd, err := os.Open("/dev/pts")
+	if err != nil {
+		ptsnames, _ = filepath.Glob("/dev/ttyp*")
+		if ptsnames == nil {
+			return nil, err
+		}
+	}
+	if ptsnames == nil {
+		defer ptsd.Close()
+		ptsnames, err = ptsd.Readdirnames(-1)
+		for _, ptsname := range ptsnames {
+			termfiles = append(termfiles, "/dev/pts/"+ptsname)
+		}
+	} else {
+		termfiles = ptsnames
+	}
+
+	for _, name := range termfiles {
+		stat := syscall.Stat_t{}
+		if err = syscall.Stat(name, &stat); err != nil {
+			return nil, err
+		}
+		rdev := uint64(stat.Rdev)
+		ret[rdev] = strings.Replace(name, "/dev", "", -1)
+	}
+	return ret, nil
+}
+
+// SendSignal sends a syscall.Signal to the process.
+// Currently, SIGSTOP, SIGCONT, SIGTERM and SIGKILL are supported.
+func (p *Process) SendSignal(sig syscall.Signal) error {
+	sigAsStr := "INT"
+	switch sig {
+	case syscall.SIGSTOP:
+		sigAsStr = "STOP"
+	case syscall.SIGCONT:
+		sigAsStr = "CONT"
+	case syscall.SIGTERM:
+		sigAsStr = "TERM"
+	case syscall.SIGKILL:
+		sigAsStr = "KILL"
+	}
+
+	kill, err := exec.LookPath("kill")
+	if err != nil {
+		return err
+	}
+	cmd := exec.Command(kill, "-s", sigAsStr, strconv.Itoa(int(p.Pid)))
+	cmd.Stderr = os.Stderr
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+	err = common.WaitTimeout(cmd, common.Timeout)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Suspend sends SIGSTOP to the process.
+func (p *Process) Suspend() error {
+	return p.SendSignal(syscall.SIGSTOP)
+}
+
+// Resume sends SIGCONT to the process.
+func (p *Process) Resume() error {
+	return p.SendSignal(syscall.SIGCONT)
+}
+
+// Terminate sends SIGTERM to the process.
+func (p *Process) Terminate() error {
+	return p.SendSignal(syscall.SIGTERM)
+}
+
+// Kill sends SIGKILL to the process.
+func (p *Process) Kill() error {
+	return p.SendSignal(syscall.SIGKILL)
+}
+
+// Username returns a username of the process.
+func (p *Process) Username() (string, error) {
+	uids, err := p.Uids()
+	if err != nil {
+		return "", err
+	}
+	if len(uids) > 0 {
+		u, err := user.LookupId(strconv.Itoa(int(uids[0])))
+		if err != nil {
+			return "", err
+		}
+		return u.Username, nil
+	}
+	return "", nil
+}

vendor/github.com/shirou/gopsutil/process/process_windows.go

@@ -0,0 +1,437 @@
+// +build windows
+
+package process
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"github.com/StackExchange/wmi"
+	"github.com/shirou/w32"
+
+	cpu "github.com/shirou/gopsutil/cpu"
+	"github.com/shirou/gopsutil/internal/common"
+	net "github.com/shirou/gopsutil/net"
+)
+
+const (
+	NoMoreFiles   = 0x12
+	MaxPathLength = 260
+)
+
+var (
+	modpsapi                 = syscall.NewLazyDLL("psapi.dll")
+	procGetProcessMemoryInfo = modpsapi.NewProc("GetProcessMemoryInfo")
+)
+
+type SystemProcessInformation struct {
+	NextEntryOffset   uint64
+	NumberOfThreads   uint64
+	Reserved1         [48]byte
+	Reserved2         [3]byte
+	UniqueProcessID   uintptr
+	Reserved3         uintptr
+	HandleCount       uint64
+	Reserved4         [4]byte
+	Reserved5         [11]byte
+	PeakPagefileUsage uint64
+	PrivatePageCount  uint64
+	Reserved6         [6]uint64
+}
+
+// Memory_info_ex is different between OSes
+type MemoryInfoExStat struct {
+}
+
+type MemoryMapsStat struct {
+}
+
+type Win32_Process struct {
+	Name                string
+	ExecutablePath      *string
+	CommandLine         *string
+	Priority            uint32
+	CreationDate        *time.Time
+	ProcessID           uint32
+	ThreadCount         uint32
+	Status              *string
+	ReadOperationCount  uint64
+	ReadTransferCount   uint64
+	WriteOperationCount uint64
+	WriteTransferCount  uint64
+
+	/*
+		CSCreationClassName   string
+		CSName                string
+		Caption               *string
+		CreationClassName     string
+		Description           *string
+		ExecutionState        *uint16
+		HandleCount           uint32
+		KernelModeTime        uint64
+		MaximumWorkingSetSize *uint32
+		MinimumWorkingSetSize *uint32
+		OSCreationClassName   string
+		OSName                string
+		OtherOperationCount   uint64
+		OtherTransferCount    uint64
+		PageFaults            uint32
+		PageFileUsage         uint32
+		ParentProcessID       uint32
+		PeakPageFileUsage     uint32
+		PeakVirtualSize       uint64
+		PeakWorkingSetSize    uint32
+		PrivatePageCount      uint64
+		TerminationDate       *time.Time
+		UserModeTime          uint64
+		WorkingSetSize        uint64
+	*/
+}
+
+func Pids() ([]int32, error) {
+	var ret []int32
+
+	procs, err := processes()
+	if err != nil {
+		return ret, nil
+	}
+
+	for _, proc := range procs {
+		ret = append(ret, proc.Pid)
+	}
+
+	return ret, nil
+}
+
+func (p *Process) Ppid() (int32, error) {
+	ret, _, _, err := p.getFromSnapProcess(p.Pid)
+	if err != nil {
+		return 0, err
+	}
+	return ret, nil
+}
+
+func GetWin32Proc(pid int32) ([]Win32_Process, error) {
+	var dst []Win32_Process
+	query := fmt.Sprintf("WHERE ProcessId = %d", pid)
+	q := wmi.CreateQuery(&dst, query)
+	err := wmi.Query(q, &dst)
+	if err != nil {
+		return []Win32_Process{}, fmt.Errorf("could not get win32Proc: %s", err)
+	}
+	if len(dst) != 1 {
+		return []Win32_Process{}, fmt.Errorf("could not get win32Proc: empty")
+	}
+	return dst, nil
+}
+
+func (p *Process) Name() (string, error) {
+	dst, err := GetWin32Proc(p.Pid)
+	if err != nil {
+		return "", fmt.Errorf("could not get Name: %s", err)
+	}
+	return dst[0].Name, nil
+}
+func (p *Process) Exe() (string, error) {
+	dst, err := GetWin32Proc(p.Pid)
+	if err != nil {
+		return "", fmt.Errorf("could not get ExecutablePath: %s", err)
+	}
+	return *dst[0].ExecutablePath, nil
+}
+func (p *Process) Cmdline() (string, error) {
+	dst, err := GetWin32Proc(p.Pid)
+	if err != nil {
+		return "", fmt.Errorf("could not get CommandLine: %s", err)
+	}
+	return *dst[0].CommandLine, nil
+}
+
+// CmdlineSlice returns the command line arguments of the process as a slice with each
+// element being an argument. This merely returns the CommandLine informations passed
+// to the process split on the 0x20 ASCII character.
+func (p *Process) CmdlineSlice() ([]string, error) {
+	cmdline, err := p.Cmdline()
+	if err != nil {
+		return nil, err
+	}
+	return strings.Split(cmdline, " "), nil
+}
+
+func (p *Process) CreateTime() (int64, error) {
+	ru, err := getRusage(p.Pid)
+	if err != nil {
+		return 0, fmt.Errorf("could not get CreationDate: %s", err)
+	}
+
+	return ru.CreationTime.Nanoseconds() / 1000000, nil
+}
+
+func (p *Process) Cwd() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Parent() (*Process, error) {
+	return p, common.ErrNotImplementedError
+}
+func (p *Process) Status() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Username() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+func (p *Process) Uids() ([]int32, error) {
+	var uids []int32
+
+	return uids, common.ErrNotImplementedError
+}
+func (p *Process) Gids() ([]int32, error) {
+	var gids []int32
+	return gids, common.ErrNotImplementedError
+}
+func (p *Process) Terminal() (string, error) {
+	return "", common.ErrNotImplementedError
+}
+
+// Nice returnes priority in Windows
+func (p *Process) Nice() (int32, error) {
+	dst, err := GetWin32Proc(p.Pid)
+	if err != nil {
+		return 0, fmt.Errorf("could not get Priority: %s", err)
+	}
+	return int32(dst[0].Priority), nil
+}
+func (p *Process) IOnice() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) Rlimit() ([]RlimitStat, error) {
+	var rlimit []RlimitStat
+
+	return rlimit, common.ErrNotImplementedError
+}
+
+func (p *Process) IOCounters() (*IOCountersStat, error) {
+	dst, err := GetWin32Proc(p.Pid)
+	if err != nil || len(dst) == 0 {
+		return nil, fmt.Errorf("could not get Win32Proc: %s", err)
+	}
+	ret := &IOCountersStat{
+		ReadCount:  uint64(dst[0].ReadOperationCount),
+		ReadBytes:  uint64(dst[0].ReadTransferCount),
+		WriteCount: uint64(dst[0].WriteOperationCount),
+		WriteBytes: uint64(dst[0].WriteTransferCount),
+	}
+
+	return ret, nil
+}
+func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) NumFDs() (int32, error) {
+	return 0, common.ErrNotImplementedError
+}
+func (p *Process) NumThreads() (int32, error) {
+	dst, err := GetWin32Proc(p.Pid)
+	if err != nil {
+		return 0, fmt.Errorf("could not get ThreadCount: %s", err)
+	}
+	return int32(dst[0].ThreadCount), nil
+}
+func (p *Process) Threads() (map[string]string, error) {
+	ret := make(map[string]string, 0)
+	return ret, common.ErrNotImplementedError
+}
+func (p *Process) Times() (*cpu.TimesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) CPUAffinity() ([]int32, error) {
+	return nil, common.ErrNotImplementedError
+}
+func (p *Process) MemoryInfo() (*MemoryInfoStat, error) {
+	mem, err := getMemoryInfo(p.Pid)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &MemoryInfoStat{
+		RSS: uint64(mem.WorkingSetSize),
+		VMS: uint64(mem.PagefileUsage),
+	}
+
+	return ret, nil
+}
+func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Children() ([]*Process, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) OpenFiles() ([]OpenFilesStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) Connections() ([]net.ConnectionStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) {
+	return nil, common.ErrNotImplementedError
+}
+
+func (p *Process) IsRunning() (bool, error) {
+	return true, common.ErrNotImplementedError
+}
+
+func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) {
+	var ret []MemoryMapsStat
+	return &ret, common.ErrNotImplementedError
+}
+
+func NewProcess(pid int32) (*Process, error) {
+	p := &Process{Pid: pid}
+
+	return p, nil
+}
+
+func (p *Process) SendSignal(sig syscall.Signal) error {
+	return common.ErrNotImplementedError
+}
+
+func (p *Process) Suspend() error {
+	return common.ErrNotImplementedError
+}
+func (p *Process) Resume() error {
+	return common.ErrNotImplementedError
+}
+
+func (p *Process) Terminate() error {
+	// PROCESS_TERMINATE = 0x0001
+	proc := w32.OpenProcess(0x0001, false, uint32(p.Pid))
+	ret := w32.TerminateProcess(proc, 0)
+	w32.CloseHandle(proc)
+
+	if ret == false {
+		return syscall.GetLastError()
+	} else {
+		return nil
+	}
+}
+
+func (p *Process) Kill() error {
+	return common.ErrNotImplementedError
+}
+
+func (p *Process) getFromSnapProcess(pid int32) (int32, int32, string, error) {
+	snap := w32.CreateToolhelp32Snapshot(w32.TH32CS_SNAPPROCESS, uint32(pid))
+	if snap == 0 {
+		return 0, 0, "", syscall.GetLastError()
+	}
+	defer w32.CloseHandle(snap)
+	var pe32 w32.PROCESSENTRY32
+	pe32.DwSize = uint32(unsafe.Sizeof(pe32))
+	if w32.Process32First(snap, &pe32) == false {
+		return 0, 0, "", syscall.GetLastError()
+	}
+
+	if pe32.Th32ProcessID == uint32(pid) {
+		szexe := syscall.UTF16ToString(pe32.SzExeFile[:])
+		return int32(pe32.Th32ParentProcessID), int32(pe32.CntThreads), szexe, nil
+	}
+
+	for w32.Process32Next(snap, &pe32) {
+		if pe32.Th32ProcessID == uint32(pid) {
+			szexe := syscall.UTF16ToString(pe32.SzExeFile[:])
+			return int32(pe32.Th32ParentProcessID), int32(pe32.CntThreads), szexe, nil
+		}
+	}
+	return 0, 0, "", errors.New("Couldn't find pid:" + string(pid))
+}
+
+// Get processes
+func processes() ([]*Process, error) {
+
+	var dst []Win32_Process
+	q := wmi.CreateQuery(&dst, "")
+	err := wmi.Query(q, &dst)
+	if err != nil {
+		return []*Process{}, err
+	}
+	if len(dst) == 0 {
+		return []*Process{}, fmt.Errorf("could not get Process")
+	}
+	results := make([]*Process, 0, len(dst))
+	for _, proc := range dst {
+		p, err := NewProcess(int32(proc.ProcessID))
+		if err != nil {
+			continue
+		}
+		results = append(results, p)
+	}
+
+	return results, nil
+}
+
+func getProcInfo(pid int32) (*SystemProcessInformation, error) {
+	initialBufferSize := uint64(0x4000)
+	bufferSize := initialBufferSize
+	buffer := make([]byte, bufferSize)
+
+	var sysProcInfo SystemProcessInformation
+	ret, _, _ := common.ProcNtQuerySystemInformation.Call(
+		uintptr(unsafe.Pointer(&sysProcInfo)),
+		uintptr(unsafe.Pointer(&buffer[0])),
+		uintptr(unsafe.Pointer(&bufferSize)),
+		uintptr(unsafe.Pointer(&bufferSize)))
+	if ret != 0 {
+		return nil, syscall.GetLastError()
+	}
+
+	return &sysProcInfo, nil
+}
+
+func getRusage(pid int32) (*syscall.Rusage, error) {
+	var CPU syscall.Rusage
+
+	c, err := syscall.OpenProcess(syscall.PROCESS_QUERY_INFORMATION, false, uint32(pid))
+	if err != nil {
+		return nil, err
+	}
+	defer syscall.CloseHandle(c)
+
+	if err := syscall.GetProcessTimes(c, &CPU.CreationTime, &CPU.ExitTime, &CPU.KernelTime, &CPU.UserTime); err != nil {
+		return nil, err
+	}
+
+	return &CPU, nil
+}
+
+func getMemoryInfo(pid int32) (PROCESS_MEMORY_COUNTERS, error) {
+	var mem PROCESS_MEMORY_COUNTERS
+	c, err := syscall.OpenProcess(syscall.PROCESS_QUERY_INFORMATION, false, uint32(pid))
+	if err != nil {
+		return mem, err
+	}
+	defer syscall.CloseHandle(c)
+	if err := getProcessMemoryInfo(c, &mem); err != nil {
+		return mem, err
+	}
+
+	return mem, err
+}
+
+func getProcessMemoryInfo(h syscall.Handle, mem *PROCESS_MEMORY_COUNTERS) (err error) {
+	r1, _, e1 := syscall.Syscall(procGetProcessMemoryInfo.Addr(), 3, uintptr(h), uintptr(unsafe.Pointer(mem)), uintptr(unsafe.Sizeof(*mem)))
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}

vendor/github.com/shirou/gopsutil/process/process_windows_386.go

@@ -0,0 +1,16 @@
+// +build windows
+
+package process
+
+type PROCESS_MEMORY_COUNTERS struct {
+	CB                         uint32
+	PageFaultCount             uint32
+	PeakWorkingSetSize         uint32
+	WorkingSetSize             uint32
+	QuotaPeakPagedPoolUsage    uint32
+	QuotaPagedPoolUsage        uint32
+	QuotaPeakNonPagedPoolUsage uint32
+	QuotaNonPagedPoolUsage     uint32
+	PagefileUsage              uint32
+	PeakPagefileUsage          uint32
+}

vendor/github.com/shirou/gopsutil/process/process_windows_amd64.go

@@ -0,0 +1,16 @@
+// +build windows
+
+package process
+
+type PROCESS_MEMORY_COUNTERS struct {
+	CB                         uint32
+	PageFaultCount             uint32
+	PeakWorkingSetSize         uint64
+	WorkingSetSize             uint64
+	QuotaPeakPagedPoolUsage    uint64
+	QuotaPagedPoolUsage        uint64
+	QuotaPeakNonPagedPoolUsage uint64
+	QuotaNonPagedPoolUsage     uint64
+	PagefileUsage              uint64
+	PeakPagefileUsage          uint64
+}

vendor/github.com/shirou/gopsutil/process/types_darwin.go

@@ -0,0 +1,160 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Hand Writing
+// - all pointer in ExternProc to uint64
+
+// +build ignore
+
+/*
+Input to cgo -godefs.
+*/
+
+// +godefs map struct_in_addr [4]byte /* in_addr */
+// +godefs map struct_in6_addr [16]byte /* in6_addr */
+// +godefs map struct_ [16]byte /* in6_addr */
+
+package process
+
+/*
+#define __DARWIN_UNIX03 0
+#define KERNEL
+#define _DARWIN_USE_64_BIT_INODE
+#include <dirent.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <termios.h>
+#include <unistd.h>
+#include <mach/mach.h>
+#include <mach/message.h>
+#include <sys/event.h>
+#include <sys/mman.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/select.h>
+#include <sys/signal.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <net/bpf.h>
+#include <net/if_dl.h>
+#include <net/if_var.h>
+#include <net/route.h>
+#include <netinet/in.h>
+
+#include <sys/sysctl.h>
+#include <sys/ucred.h>
+#include <sys/proc.h>
+#include <sys/time.h>
+#include <sys/_types/_timeval.h>
+#include <sys/appleapiopts.h>
+#include <sys/cdefs.h>
+#include <sys/param.h>
+#include <bsm/audit.h>
+#include <sys/queue.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+union sockaddr_all {
+	struct sockaddr s1;	// this one gets used for fields
+	struct sockaddr_in s2;	// these pad it out
+	struct sockaddr_in6 s3;
+	struct sockaddr_un s4;
+	struct sockaddr_dl s5;
+};
+
+struct sockaddr_any {
+	struct sockaddr addr;
+	char pad[sizeof(union sockaddr_all) - sizeof(struct sockaddr)];
+};
+
+struct ucred_queue {
+        struct ucred *tqe_next;
+        struct ucred **tqe_prev;
+        TRACEBUF
+};
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type UGid_t C.gid_t
+
+type KinfoProc C.struct_kinfo_proc
+
+type Eproc C.struct_eproc
+
+type Proc C.struct_proc
+
+type Session C.struct_session
+
+type ucred C.struct_ucred
+
+type Uucred C.struct__ucred
+
+type Upcred C.struct__pcred
+
+type Vmspace C.struct_vmspace
+
+type Sigacts C.struct_sigacts
+
+type ExternProc C.struct_extern_proc
+
+type Itimerval C.struct_itimerval
+
+type Vnode C.struct_vnode
+
+type Pgrp C.struct_pgrp
+
+type UserStruct C.struct_user
+
+type Au_session C.struct_au_session
+
+type Posix_cred C.struct_posix_cred
+
+type Label C.struct_label
+
+type AuditinfoAddr C.struct_auditinfo_addr
+type AuMask C.struct_au_mask
+type AuTidAddr C.struct_au_tid_addr
+
+// TAILQ(ucred)
+type UcredQueue C.struct_ucred_queue

vendor/github.com/shirou/gopsutil/process/types_freebsd.go

@@ -0,0 +1,95 @@
+// +build ignore
+
+// We still need editing by hands.
+// go tool cgo -godefs types_freebsd.go | sed 's/\*int64/int64/' | sed 's/\*byte/int64/'  > process_freebsd_amd64.go
+
+/*
+Input to cgo -godefs.
+*/
+
+// +godefs map struct_pargs int64 /* pargs */
+// +godefs map struct_proc int64 /* proc */
+// +godefs map struct_user int64 /* user */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_filedesc int64 /* filedesc */
+// +godefs map struct_vmspace int64 /* vmspace */
+// +godefs map struct_pcb int64 /* pcb */
+// +godefs map struct_thread int64 /* thread */
+// +godefs map struct___sigset [16]byte /* sigset */
+
+package process
+
+/*
+#include <sys/types.h>
+#include <sys/user.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	CTLKern          = 1  // "high kernel": proc, limits
+	KernProc         = 14 // struct: process entries
+	KernProcPID      = 1  // by process id
+	KernProcProc     = 8  // only return procs
+	KernProcPathname = 12 // path to executable
+	KernProcArgs     = 7  // get/set arguments/proctitle
+)
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+)
+
+const (
+	sizeOfKinfoVmentry = C.sizeof_struct_kinfo_vmentry
+	sizeOfKinfoProc    = C.sizeof_struct_kinfo_proc
+)
+
+// from sys/proc.h
+const (
+	SIDL   = 1 /* Process being created by fork. */
+	SRUN   = 2 /* Currently runnable. */
+	SSLEEP = 3 /* Sleeping on an address. */
+	SSTOP  = 4 /* Process debugging or suspension. */
+	SZOMB  = 5 /* Awaiting collection by parent. */
+	SWAIT  = 6 /* Waiting for interrupt. */
+	SLOCK  = 7 /* Blocked on a lock. */
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type KinfoProc C.struct_kinfo_proc
+
+type Priority C.struct_priority
+
+type KinfoVmentry C.struct_kinfo_vmentry

vendor/github.com/shirou/gopsutil/process/types_openbsd.go

@@ -0,0 +1,104 @@
+// +build ignore
+
+// We still need editing by hands.
+// go tool cgo -godefs types_openbsd.go | sed 's/\*int64/int64/' | sed 's/\*byte/int64/'  > process_openbsd_amd64.go
+
+/*
+Input to cgo -godefs.
+*/
+
+// +godefs map struct_pargs int64 /* pargs */
+// +godefs map struct_proc int64 /* proc */
+// +godefs map struct_user int64 /* user */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_vnode int64 /* vnode */
+// +godefs map struct_filedesc int64 /* filedesc */
+// +godefs map struct_vmspace int64 /* vmspace */
+// +godefs map struct_pcb int64 /* pcb */
+// +godefs map struct_thread int64 /* thread */
+// +godefs map struct___sigset [16]byte /* sigset */
+
+package process
+
+/*
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+
+enum {
+	sizeofPtr = sizeof(void*),
+};
+
+
+*/
+import "C"
+
+// Machine characteristics; for internal use.
+
+const (
+	CTLKern          = 1  // "high kernel": proc, limits
+	KernProc         = 66 // struct: process entries
+	KernProcAll      = 0
+	KernProcPID      = 1  // by process id
+	KernProcProc     = 8  // only return procs
+	KernProcPathname = 12 // path to executable
+	KernProcArgs     = 55  // get/set arguments/proctitle
+	KernProcArgv	 = 1
+	KernProcEnv	 = 3
+)
+
+const (
+	ArgMax	=	256 * 1024 // sys/syslimits.h:#define  ARG_MAX
+)
+
+
+const (
+	sizeofPtr      = C.sizeofPtr
+	sizeofShort    = C.sizeof_short
+	sizeofInt      = C.sizeof_int
+	sizeofLong     = C.sizeof_long
+	sizeofLongLong = C.sizeof_longlong
+)
+
+const (
+	sizeOfKinfoVmentry = C.sizeof_struct_kinfo_vmentry
+	sizeOfKinfoProc    = C.sizeof_struct_kinfo_proc
+)
+
+// from sys/proc.h
+const (
+	SIDL   = 1 /* Process being created by fork. */
+	SRUN   = 2 /* Currently runnable. */
+	SSLEEP = 3 /* Sleeping on an address. */
+	SSTOP  = 4 /* Process debugging or suspension. */
+	SZOMB  = 5 /* Awaiting collection by parent. */
+	SDEAD  = 6 /* Thread is almost gone */
+	SONPROC = 7 /* Thread is currently on a CPU. */
+)
+
+// Basic types
+
+type (
+	_C_short     C.short
+	_C_int       C.int
+	_C_long      C.long
+	_C_long_long C.longlong
+)
+
+// Time
+
+type Timespec C.struct_timespec
+
+type Timeval C.struct_timeval
+
+// Processes
+
+type Rusage C.struct_rusage
+
+type Rlimit C.struct_rlimit
+
+type KinfoProc C.struct_kinfo_proc
+
+type Priority C.struct_priority
+
+type KinfoVmentry C.struct_kinfo_vmentry

vendor/github.com/shirou/w32/AUTHORS

@@ -0,0 +1,16 @@
+# This is the official list of 'w32' authors for copyright purposes.
+
+# Names should be added to this file as
+#   Name or Organization <email address>
+# The email address is not required for organizations.
+
+# Please keep the list sorted.
+
+# Contributors
+# ============
+
+Allen Dang <allengnr@gmail.com>
+Benny Siegert <bsiegert@gmail.com>
+Bruno Bigras <bigras.bruno@gmail.com>
+Gerald Rosenberg <gerald.rosenberg@gmail.com>
+Michael Henke

vendor/github.com/shirou/w32/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2010-2012 The w32 Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The names of the authors may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/shirou/w32/advapi32.go

@@ -0,0 +1,301 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"errors"
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modadvapi32 = syscall.NewLazyDLL("advapi32.dll")
+
+	procRegCreateKeyEx = modadvapi32.NewProc("RegCreateKeyExW")
+	procRegOpenKeyEx   = modadvapi32.NewProc("RegOpenKeyExW")
+	procRegCloseKey    = modadvapi32.NewProc("RegCloseKey")
+	procRegGetValue    = modadvapi32.NewProc("RegGetValueW")
+	procRegEnumKeyEx   = modadvapi32.NewProc("RegEnumKeyExW")
+	//	procRegSetKeyValue     = modadvapi32.NewProc("RegSetKeyValueW")
+	procRegSetValueEx      = modadvapi32.NewProc("RegSetValueExW")
+	procOpenEventLog       = modadvapi32.NewProc("OpenEventLogW")
+	procReadEventLog       = modadvapi32.NewProc("ReadEventLogW")
+	procCloseEventLog      = modadvapi32.NewProc("CloseEventLog")
+	procOpenSCManager      = modadvapi32.NewProc("OpenSCManagerW")
+	procCloseServiceHandle = modadvapi32.NewProc("CloseServiceHandle")
+	procOpenService        = modadvapi32.NewProc("OpenServiceW")
+	procStartService       = modadvapi32.NewProc("StartServiceW")
+	procControlService     = modadvapi32.NewProc("ControlService")
+)
+
+func RegCreateKey(hKey HKEY, subKey string) HKEY {
+	var result HKEY
+	ret, _, _ := procRegCreateKeyEx.Call(
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))),
+		uintptr(0),
+		uintptr(0),
+		uintptr(0),
+		uintptr(KEY_ALL_ACCESS),
+		uintptr(0),
+		uintptr(unsafe.Pointer(&result)),
+		uintptr(0))
+	_ = ret
+	return result
+}
+
+func RegOpenKeyEx(hKey HKEY, subKey string, samDesired uint32) HKEY {
+	var result HKEY
+	ret, _, _ := procRegOpenKeyEx.Call(
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))),
+		uintptr(0),
+		uintptr(samDesired),
+		uintptr(unsafe.Pointer(&result)))
+
+	if ret != ERROR_SUCCESS {
+		panic(fmt.Sprintf("RegOpenKeyEx(%d, %s, %d) failed", hKey, subKey, samDesired))
+	}
+	return result
+}
+
+func RegCloseKey(hKey HKEY) error {
+	var err error
+	ret, _, _ := procRegCloseKey.Call(
+		uintptr(hKey))
+
+	if ret != ERROR_SUCCESS {
+		err = errors.New("RegCloseKey failed")
+	}
+	return err
+}
+
+func RegGetRaw(hKey HKEY, subKey string, value string) []byte {
+	var bufLen uint32
+	var valptr unsafe.Pointer
+	if len(value) > 0 {
+		valptr = unsafe.Pointer(syscall.StringToUTF16Ptr(value))
+	}
+	procRegGetValue.Call(
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))),
+		uintptr(valptr),
+		uintptr(RRF_RT_ANY),
+		0,
+		0,
+		uintptr(unsafe.Pointer(&bufLen)))
+
+	if bufLen == 0 {
+		return nil
+	}
+
+	buf := make([]byte, bufLen)
+	ret, _, _ := procRegGetValue.Call(
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))),
+		uintptr(valptr),
+		uintptr(RRF_RT_ANY),
+		0,
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&bufLen)))
+
+	if ret != ERROR_SUCCESS {
+		return nil
+	}
+
+	return buf
+}
+
+func RegSetBinary(hKey HKEY, subKey string, value []byte) (errno int) {
+	var lptr, vptr unsafe.Pointer
+	if len(subKey) > 0 {
+		lptr = unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))
+	}
+	if len(value) > 0 {
+		vptr = unsafe.Pointer(&value[0])
+	}
+	ret, _, _ := procRegSetValueEx.Call(
+		uintptr(hKey),
+		uintptr(lptr),
+		uintptr(0),
+		uintptr(REG_BINARY),
+		uintptr(vptr),
+		uintptr(len(value)))
+
+	return int(ret)
+}
+
+func RegGetString(hKey HKEY, subKey string, value string) string {
+	var bufLen uint32
+	procRegGetValue.Call(
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(value))),
+		uintptr(RRF_RT_REG_SZ),
+		0,
+		0,
+		uintptr(unsafe.Pointer(&bufLen)))
+
+	if bufLen == 0 {
+		return ""
+	}
+
+	buf := make([]uint16, bufLen)
+	ret, _, _ := procRegGetValue.Call(
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(value))),
+		uintptr(RRF_RT_REG_SZ),
+		0,
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&bufLen)))
+
+	if ret != ERROR_SUCCESS {
+		return ""
+	}
+
+	return syscall.UTF16ToString(buf)
+}
+
+/*
+func RegSetKeyValue(hKey HKEY, subKey string, valueName string, dwType uint32, data uintptr, cbData uint16) (errno int) {
+	ret, _, _ := procRegSetKeyValue.Call(
+		uintptr(hKey),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(subKey))),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(valueName))),
+		uintptr(dwType),
+		data,
+		uintptr(cbData))
+
+	return int(ret)
+}
+*/
+
+func RegEnumKeyEx(hKey HKEY, index uint32) string {
+	var bufLen uint32 = 255
+	buf := make([]uint16, bufLen)
+	procRegEnumKeyEx.Call(
+		uintptr(hKey),
+		uintptr(index),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&bufLen)),
+		0,
+		0,
+		0,
+		0)
+	return syscall.UTF16ToString(buf)
+}
+
+func OpenEventLog(servername string, sourcename string) HANDLE {
+	ret, _, _ := procOpenEventLog.Call(
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(servername))),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(sourcename))))
+
+	return HANDLE(ret)
+}
+
+func ReadEventLog(eventlog HANDLE, readflags, recordoffset uint32, buffer []byte, numberofbytestoread uint32, bytesread, minnumberofbytesneeded *uint32) bool {
+	ret, _, _ := procReadEventLog.Call(
+		uintptr(eventlog),
+		uintptr(readflags),
+		uintptr(recordoffset),
+		uintptr(unsafe.Pointer(&buffer[0])),
+		uintptr(numberofbytestoread),
+		uintptr(unsafe.Pointer(bytesread)),
+		uintptr(unsafe.Pointer(minnumberofbytesneeded)))
+
+	return ret != 0
+}
+
+func CloseEventLog(eventlog HANDLE) bool {
+	ret, _, _ := procCloseEventLog.Call(
+		uintptr(eventlog))
+
+	return ret != 0
+}
+
+func OpenSCManager(lpMachineName, lpDatabaseName string, dwDesiredAccess uint32) (HANDLE, error) {
+	var p1, p2 uintptr
+	if len(lpMachineName) > 0 {
+		p1 = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(lpMachineName)))
+	}
+	if len(lpDatabaseName) > 0 {
+		p2 = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(lpDatabaseName)))
+	}
+	ret, _, _ := procOpenSCManager.Call(
+		p1,
+		p2,
+		uintptr(dwDesiredAccess))
+
+	if ret == 0 {
+		return 0, syscall.GetLastError()
+	}
+
+	return HANDLE(ret), nil
+}
+
+func CloseServiceHandle(hSCObject HANDLE) error {
+	ret, _, _ := procCloseServiceHandle.Call(uintptr(hSCObject))
+	if ret == 0 {
+		return syscall.GetLastError()
+	}
+	return nil
+}
+
+func OpenService(hSCManager HANDLE, lpServiceName string, dwDesiredAccess uint32) (HANDLE, error) {
+	ret, _, _ := procOpenService.Call(
+		uintptr(hSCManager),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(lpServiceName))),
+		uintptr(dwDesiredAccess))
+
+	if ret == 0 {
+		return 0, syscall.GetLastError()
+	}
+
+	return HANDLE(ret), nil
+}
+
+func StartService(hService HANDLE, lpServiceArgVectors []string) error {
+	l := len(lpServiceArgVectors)
+	var ret uintptr
+	if l == 0 {
+		ret, _, _ = procStartService.Call(
+			uintptr(hService),
+			0,
+			0)
+	} else {
+		lpArgs := make([]uintptr, l)
+		for i := 0; i < l; i++ {
+			lpArgs[i] = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(lpServiceArgVectors[i])))
+		}
+
+		ret, _, _ = procStartService.Call(
+			uintptr(hService),
+			uintptr(l),
+			uintptr(unsafe.Pointer(&lpArgs[0])))
+	}
+
+	if ret == 0 {
+		return syscall.GetLastError()
+	}
+
+	return nil
+}
+
+func ControlService(hService HANDLE, dwControl uint32, lpServiceStatus *SERVICE_STATUS) bool {
+	if lpServiceStatus == nil {
+		panic("ControlService:lpServiceStatus cannot be nil")
+	}
+
+	ret, _, _ := procControlService.Call(
+		uintptr(hService),
+		uintptr(dwControl),
+		uintptr(unsafe.Pointer(lpServiceStatus)))
+
+	return ret != 0
+}

vendor/github.com/shirou/w32/comctl32.go

@@ -0,0 +1,111 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modcomctl32 = syscall.NewLazyDLL("comctl32.dll")
+
+	procInitCommonControlsEx    = modcomctl32.NewProc("InitCommonControlsEx")
+	procImageList_Create        = modcomctl32.NewProc("ImageList_Create")
+	procImageList_Destroy       = modcomctl32.NewProc("ImageList_Destroy")
+	procImageList_GetImageCount = modcomctl32.NewProc("ImageList_GetImageCount")
+	procImageList_SetImageCount = modcomctl32.NewProc("ImageList_SetImageCount")
+	procImageList_Add           = modcomctl32.NewProc("ImageList_Add")
+	procImageList_ReplaceIcon   = modcomctl32.NewProc("ImageList_ReplaceIcon")
+	procImageList_Remove        = modcomctl32.NewProc("ImageList_Remove")
+	procTrackMouseEvent         = modcomctl32.NewProc("_TrackMouseEvent")
+)
+
+func InitCommonControlsEx(lpInitCtrls *INITCOMMONCONTROLSEX) bool {
+	ret, _, _ := procInitCommonControlsEx.Call(
+		uintptr(unsafe.Pointer(lpInitCtrls)))
+
+	return ret != 0
+}
+
+func ImageList_Create(cx, cy int, flags uint, cInitial, cGrow int) HIMAGELIST {
+	ret, _, _ := procImageList_Create.Call(
+		uintptr(cx),
+		uintptr(cy),
+		uintptr(flags),
+		uintptr(cInitial),
+		uintptr(cGrow))
+
+	if ret == 0 {
+		panic("Create image list failed")
+	}
+
+	return HIMAGELIST(ret)
+}
+
+func ImageList_Destroy(himl HIMAGELIST) bool {
+	ret, _, _ := procImageList_Destroy.Call(
+		uintptr(himl))
+
+	return ret != 0
+}
+
+func ImageList_GetImageCount(himl HIMAGELIST) int {
+	ret, _, _ := procImageList_GetImageCount.Call(
+		uintptr(himl))
+
+	return int(ret)
+}
+
+func ImageList_SetImageCount(himl HIMAGELIST, uNewCount uint) bool {
+	ret, _, _ := procImageList_SetImageCount.Call(
+		uintptr(himl),
+		uintptr(uNewCount))
+
+	return ret != 0
+}
+
+func ImageList_Add(himl HIMAGELIST, hbmImage, hbmMask HBITMAP) int {
+	ret, _, _ := procImageList_Add.Call(
+		uintptr(himl),
+		uintptr(hbmImage),
+		uintptr(hbmMask))
+
+	return int(ret)
+}
+
+func ImageList_ReplaceIcon(himl HIMAGELIST, i int, hicon HICON) int {
+	ret, _, _ := procImageList_ReplaceIcon.Call(
+		uintptr(himl),
+		uintptr(i),
+		uintptr(hicon))
+
+	return int(ret)
+}
+
+func ImageList_AddIcon(himl HIMAGELIST, hicon HICON) int {
+	return ImageList_ReplaceIcon(himl, -1, hicon)
+}
+
+func ImageList_Remove(himl HIMAGELIST, i int) bool {
+	ret, _, _ := procImageList_Remove.Call(
+		uintptr(himl),
+		uintptr(i))
+
+	return ret != 0
+}
+
+func ImageList_RemoveAll(himl HIMAGELIST) bool {
+	return ImageList_Remove(himl, -1)
+}
+
+func TrackMouseEvent(tme *TRACKMOUSEEVENT) bool {
+	ret, _, _ := procTrackMouseEvent.Call(
+		uintptr(unsafe.Pointer(tme)))
+
+	return ret != 0
+}

vendor/github.com/shirou/w32/comdlg32.go

@@ -0,0 +1,40 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modcomdlg32 = syscall.NewLazyDLL("comdlg32.dll")
+
+	procGetSaveFileName      = modcomdlg32.NewProc("GetSaveFileNameW")
+	procGetOpenFileName      = modcomdlg32.NewProc("GetOpenFileNameW")
+	procCommDlgExtendedError = modcomdlg32.NewProc("CommDlgExtendedError")
+)
+
+func GetOpenFileName(ofn *OPENFILENAME) bool {
+	ret, _, _ := procGetOpenFileName.Call(
+		uintptr(unsafe.Pointer(ofn)))
+
+	return ret != 0
+}
+
+func GetSaveFileName(ofn *OPENFILENAME) bool {
+	ret, _, _ := procGetSaveFileName.Call(
+		uintptr(unsafe.Pointer(ofn)))
+
+	return ret != 0
+}
+
+func CommDlgExtendedError() uint {
+	ret, _, _ := procCommDlgExtendedError.Call()
+
+	return uint(ret)
+}

vendor/github.com/shirou/w32/dwmapi.go

@@ -0,0 +1,256 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+// DEFINED IN THE DWM API BUT NOT IMPLEMENTED BY MS:
+// DwmAttachMilContent
+// DwmDetachMilContent
+// DwmEnableComposition
+// DwmGetGraphicsStreamClient
+// DwmGetGraphicsStreamTransformHint
+
+var (
+	moddwmapi = syscall.NewLazyDLL("dwmapi.dll")
+
+	procDwmDefWindowProc                 = moddwmapi.NewProc("DwmDefWindowProc")
+	procDwmEnableBlurBehindWindow        = moddwmapi.NewProc("DwmEnableBlurBehindWindow")
+	procDwmEnableMMCSS                   = moddwmapi.NewProc("DwmEnableMMCSS")
+	procDwmExtendFrameIntoClientArea     = moddwmapi.NewProc("DwmExtendFrameIntoClientArea")
+	procDwmFlush                         = moddwmapi.NewProc("DwmFlush")
+	procDwmGetColorizationColor          = moddwmapi.NewProc("DwmGetColorizationColor")
+	procDwmGetCompositionTimingInfo      = moddwmapi.NewProc("DwmGetCompositionTimingInfo")
+	procDwmGetTransportAttributes        = moddwmapi.NewProc("DwmGetTransportAttributes")
+	procDwmGetWindowAttribute            = moddwmapi.NewProc("DwmGetWindowAttribute")
+	procDwmInvalidateIconicBitmaps       = moddwmapi.NewProc("DwmInvalidateIconicBitmaps")
+	procDwmIsCompositionEnabled          = moddwmapi.NewProc("DwmIsCompositionEnabled")
+	procDwmModifyPreviousDxFrameDuration = moddwmapi.NewProc("DwmModifyPreviousDxFrameDuration")
+	procDwmQueryThumbnailSourceSize      = moddwmapi.NewProc("DwmQueryThumbnailSourceSize")
+	procDwmRegisterThumbnail             = moddwmapi.NewProc("DwmRegisterThumbnail")
+	procDwmRenderGesture                 = moddwmapi.NewProc("DwmRenderGesture")
+	procDwmSetDxFrameDuration            = moddwmapi.NewProc("DwmSetDxFrameDuration")
+	procDwmSetIconicLivePreviewBitmap    = moddwmapi.NewProc("DwmSetIconicLivePreviewBitmap")
+	procDwmSetIconicThumbnail            = moddwmapi.NewProc("DwmSetIconicThumbnail")
+	procDwmSetPresentParameters          = moddwmapi.NewProc("DwmSetPresentParameters")
+	procDwmSetWindowAttribute            = moddwmapi.NewProc("DwmSetWindowAttribute")
+	procDwmShowContact                   = moddwmapi.NewProc("DwmShowContact")
+	procDwmTetherContact                 = moddwmapi.NewProc("DwmTetherContact")
+	procDwmTransitionOwnedWindow         = moddwmapi.NewProc("DwmTransitionOwnedWindow")
+	procDwmUnregisterThumbnail           = moddwmapi.NewProc("DwmUnregisterThumbnail")
+	procDwmUpdateThumbnailProperties     = moddwmapi.NewProc("DwmUpdateThumbnailProperties")
+)
+
+func DwmDefWindowProc(hWnd HWND, msg uint, wParam, lParam uintptr) (bool, uint) {
+	var result uint
+	ret, _, _ := procDwmDefWindowProc.Call(
+		uintptr(hWnd),
+		uintptr(msg),
+		wParam,
+		lParam,
+		uintptr(unsafe.Pointer(&result)))
+	return ret != 0, result
+}
+
+func DwmEnableBlurBehindWindow(hWnd HWND, pBlurBehind *DWM_BLURBEHIND) HRESULT {
+	ret, _, _ := procDwmEnableBlurBehindWindow.Call(
+		uintptr(hWnd),
+		uintptr(unsafe.Pointer(pBlurBehind)))
+	return HRESULT(ret)
+}
+
+func DwmEnableMMCSS(fEnableMMCSS bool) HRESULT {
+	ret, _, _ := procDwmEnableMMCSS.Call(
+		uintptr(BoolToBOOL(fEnableMMCSS)))
+	return HRESULT(ret)
+}
+
+func DwmExtendFrameIntoClientArea(hWnd HWND, pMarInset *MARGINS) HRESULT {
+	ret, _, _ := procDwmExtendFrameIntoClientArea.Call(
+		uintptr(hWnd),
+		uintptr(unsafe.Pointer(pMarInset)))
+	return HRESULT(ret)
+}
+
+func DwmFlush() HRESULT {
+	ret, _, _ := procDwmFlush.Call()
+	return HRESULT(ret)
+}
+
+func DwmGetColorizationColor(pcrColorization *uint32, pfOpaqueBlend *BOOL) HRESULT {
+	ret, _, _ := procDwmGetColorizationColor.Call(
+		uintptr(unsafe.Pointer(pcrColorization)),
+		uintptr(unsafe.Pointer(pfOpaqueBlend)))
+	return HRESULT(ret)
+}
+
+func DwmGetCompositionTimingInfo(hWnd HWND, pTimingInfo *DWM_TIMING_INFO) HRESULT {
+	ret, _, _ := procDwmGetCompositionTimingInfo.Call(
+		uintptr(hWnd),
+		uintptr(unsafe.Pointer(pTimingInfo)))
+	return HRESULT(ret)
+}
+
+func DwmGetTransportAttributes(pfIsRemoting *BOOL, pfIsConnected *BOOL, pDwGeneration *uint32) HRESULT {
+	ret, _, _ := procDwmGetTransportAttributes.Call(
+		uintptr(unsafe.Pointer(pfIsRemoting)),
+		uintptr(unsafe.Pointer(pfIsConnected)),
+		uintptr(unsafe.Pointer(pDwGeneration)))
+	return HRESULT(ret)
+}
+
+// TODO: verify handling of variable arguments
+func DwmGetWindowAttribute(hWnd HWND, dwAttribute uint32) (pAttribute interface{}, result HRESULT) {
+	var pvAttribute, pvAttrSize uintptr
+	switch dwAttribute {
+	case DWMWA_NCRENDERING_ENABLED:
+		v := new(BOOL)
+		pAttribute = v
+		pvAttribute = uintptr(unsafe.Pointer(v))
+		pvAttrSize = unsafe.Sizeof(*v)
+	case DWMWA_CAPTION_BUTTON_BOUNDS, DWMWA_EXTENDED_FRAME_BOUNDS:
+		v := new(RECT)
+		pAttribute = v
+		pvAttribute = uintptr(unsafe.Pointer(v))
+		pvAttrSize = unsafe.Sizeof(*v)
+	case DWMWA_CLOAKED:
+		panic(fmt.Sprintf("DwmGetWindowAttribute(%d) is not currently supported.", dwAttribute))
+	default:
+		panic(fmt.Sprintf("DwmGetWindowAttribute(%d) is not valid.", dwAttribute))
+	}
+
+	ret, _, _ := procDwmGetWindowAttribute.Call(
+		uintptr(hWnd),
+		uintptr(dwAttribute),
+		pvAttribute,
+		pvAttrSize)
+	result = HRESULT(ret)
+	return
+}
+
+func DwmInvalidateIconicBitmaps(hWnd HWND) HRESULT {
+	ret, _, _ := procDwmInvalidateIconicBitmaps.Call(
+		uintptr(hWnd))
+	return HRESULT(ret)
+}
+
+func DwmIsCompositionEnabled(pfEnabled *BOOL) HRESULT {
+	ret, _, _ := procDwmIsCompositionEnabled.Call(
+		uintptr(unsafe.Pointer(pfEnabled)))
+	return HRESULT(ret)
+}
+
+func DwmModifyPreviousDxFrameDuration(hWnd HWND, cRefreshes int, fRelative bool) HRESULT {
+	ret, _, _ := procDwmModifyPreviousDxFrameDuration.Call(
+		uintptr(hWnd),
+		uintptr(cRefreshes),
+		uintptr(BoolToBOOL(fRelative)))
+	return HRESULT(ret)
+}
+
+func DwmQueryThumbnailSourceSize(hThumbnail HTHUMBNAIL, pSize *SIZE) HRESULT {
+	ret, _, _ := procDwmQueryThumbnailSourceSize.Call(
+		uintptr(hThumbnail),
+		uintptr(unsafe.Pointer(pSize)))
+	return HRESULT(ret)
+}
+
+func DwmRegisterThumbnail(hWndDestination HWND, hWndSource HWND, phThumbnailId *HTHUMBNAIL) HRESULT {
+	ret, _, _ := procDwmRegisterThumbnail.Call(
+		uintptr(hWndDestination),
+		uintptr(hWndSource),
+		uintptr(unsafe.Pointer(phThumbnailId)))
+	return HRESULT(ret)
+}
+
+func DwmRenderGesture(gt GESTURE_TYPE, cContacts uint, pdwPointerID *uint32, pPoints *POINT) {
+	procDwmRenderGesture.Call(
+		uintptr(gt),
+		uintptr(cContacts),
+		uintptr(unsafe.Pointer(pdwPointerID)),
+		uintptr(unsafe.Pointer(pPoints)))
+	return
+}
+
+func DwmSetDxFrameDuration(hWnd HWND, cRefreshes int) HRESULT {
+	ret, _, _ := procDwmSetDxFrameDuration.Call(
+		uintptr(hWnd),
+		uintptr(cRefreshes))
+	return HRESULT(ret)
+}
+
+func DwmSetIconicLivePreviewBitmap(hWnd HWND, hbmp HBITMAP, pptClient *POINT, dwSITFlags uint32) HRESULT {
+	ret, _, _ := procDwmSetIconicLivePreviewBitmap.Call(
+		uintptr(hWnd),
+		uintptr(hbmp),
+		uintptr(unsafe.Pointer(pptClient)),
+		uintptr(dwSITFlags))
+	return HRESULT(ret)
+}
+
+func DwmSetIconicThumbnail(hWnd HWND, hbmp HBITMAP, dwSITFlags uint32) HRESULT {
+	ret, _, _ := procDwmSetIconicThumbnail.Call(
+		uintptr(hWnd),
+		uintptr(hbmp),
+		uintptr(dwSITFlags))
+	return HRESULT(ret)
+}
+
+func DwmSetPresentParameters(hWnd HWND, pPresentParams *DWM_PRESENT_PARAMETERS) HRESULT {
+	ret, _, _ := procDwmSetPresentParameters.Call(
+		uintptr(hWnd),
+		uintptr(unsafe.Pointer(pPresentParams)))
+	return HRESULT(ret)
+}
+
+func DwmSetWindowAttribute(hWnd HWND, dwAttribute uint32, pvAttribute LPCVOID, cbAttribute uint32) HRESULT {
+	ret, _, _ := procDwmSetWindowAttribute.Call(
+		uintptr(hWnd),
+		uintptr(dwAttribute),
+		uintptr(pvAttribute),
+		uintptr(cbAttribute))
+	return HRESULT(ret)
+}
+
+func DwmShowContact(dwPointerID uint32, eShowContact DWM_SHOWCONTACT) {
+	procDwmShowContact.Call(
+		uintptr(dwPointerID),
+		uintptr(eShowContact))
+	return
+}
+
+func DwmTetherContact(dwPointerID uint32, fEnable bool, ptTether POINT) {
+	procDwmTetherContact.Call(
+		uintptr(dwPointerID),
+		uintptr(BoolToBOOL(fEnable)),
+		uintptr(unsafe.Pointer(&ptTether)))
+	return
+}
+
+func DwmTransitionOwnedWindow(hWnd HWND, target DWMTRANSITION_OWNEDWINDOW_TARGET) {
+	procDwmTransitionOwnedWindow.Call(
+		uintptr(hWnd),
+		uintptr(target))
+	return
+}
+
+func DwmUnregisterThumbnail(hThumbnailId HTHUMBNAIL) HRESULT {
+	ret, _, _ := procDwmUnregisterThumbnail.Call(
+		uintptr(hThumbnailId))
+	return HRESULT(ret)
+}
+
+func DwmUpdateThumbnailProperties(hThumbnailId HTHUMBNAIL, ptnProperties *DWM_THUMBNAIL_PROPERTIES) HRESULT {
+	ret, _, _ := procDwmUpdateThumbnailProperties.Call(
+		uintptr(hThumbnailId),
+		uintptr(unsafe.Pointer(ptnProperties)))
+	return HRESULT(ret)
+}

vendor/github.com/shirou/w32/gdi32.go

@@ -0,0 +1,511 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modgdi32 = syscall.NewLazyDLL("gdi32.dll")
+
+	procGetDeviceCaps             = modgdi32.NewProc("GetDeviceCaps")
+	procDeleteObject              = modgdi32.NewProc("DeleteObject")
+	procCreateFontIndirect        = modgdi32.NewProc("CreateFontIndirectW")
+	procAbortDoc                  = modgdi32.NewProc("AbortDoc")
+	procBitBlt                    = modgdi32.NewProc("BitBlt")
+	procCloseEnhMetaFile          = modgdi32.NewProc("CloseEnhMetaFile")
+	procCopyEnhMetaFile           = modgdi32.NewProc("CopyEnhMetaFileW")
+	procCreateBrushIndirect       = modgdi32.NewProc("CreateBrushIndirect")
+	procCreateCompatibleDC        = modgdi32.NewProc("CreateCompatibleDC")
+	procCreateDC                  = modgdi32.NewProc("CreateDCW")
+	procCreateDIBSection          = modgdi32.NewProc("CreateDIBSection")
+	procCreateEnhMetaFile         = modgdi32.NewProc("CreateEnhMetaFileW")
+	procCreateIC                  = modgdi32.NewProc("CreateICW")
+	procDeleteDC                  = modgdi32.NewProc("DeleteDC")
+	procDeleteEnhMetaFile         = modgdi32.NewProc("DeleteEnhMetaFile")
+	procEllipse                   = modgdi32.NewProc("Ellipse")
+	procEndDoc                    = modgdi32.NewProc("EndDoc")
+	procEndPage                   = modgdi32.NewProc("EndPage")
+	procExtCreatePen              = modgdi32.NewProc("ExtCreatePen")
+	procGetEnhMetaFile            = modgdi32.NewProc("GetEnhMetaFileW")
+	procGetEnhMetaFileHeader      = modgdi32.NewProc("GetEnhMetaFileHeader")
+	procGetObject                 = modgdi32.NewProc("GetObjectW")
+	procGetStockObject            = modgdi32.NewProc("GetStockObject")
+	procGetTextExtentExPoint      = modgdi32.NewProc("GetTextExtentExPointW")
+	procGetTextExtentPoint32      = modgdi32.NewProc("GetTextExtentPoint32W")
+	procGetTextMetrics            = modgdi32.NewProc("GetTextMetricsW")
+	procLineTo                    = modgdi32.NewProc("LineTo")
+	procMoveToEx                  = modgdi32.NewProc("MoveToEx")
+	procPlayEnhMetaFile           = modgdi32.NewProc("PlayEnhMetaFile")
+	procRectangle                 = modgdi32.NewProc("Rectangle")
+	procResetDC                   = modgdi32.NewProc("ResetDCW")
+	procSelectObject              = modgdi32.NewProc("SelectObject")
+	procSetBkMode                 = modgdi32.NewProc("SetBkMode")
+	procSetBrushOrgEx             = modgdi32.NewProc("SetBrushOrgEx")
+	procSetStretchBltMode         = modgdi32.NewProc("SetStretchBltMode")
+	procSetTextColor              = modgdi32.NewProc("SetTextColor")
+	procSetBkColor                = modgdi32.NewProc("SetBkColor")
+	procStartDoc                  = modgdi32.NewProc("StartDocW")
+	procStartPage                 = modgdi32.NewProc("StartPage")
+	procStretchBlt                = modgdi32.NewProc("StretchBlt")
+	procSetDIBitsToDevice         = modgdi32.NewProc("SetDIBitsToDevice")
+	procChoosePixelFormat         = modgdi32.NewProc("ChoosePixelFormat")
+	procDescribePixelFormat       = modgdi32.NewProc("DescribePixelFormat")
+	procGetEnhMetaFilePixelFormat = modgdi32.NewProc("GetEnhMetaFilePixelFormat")
+	procGetPixelFormat            = modgdi32.NewProc("GetPixelFormat")
+	procSetPixelFormat            = modgdi32.NewProc("SetPixelFormat")
+	procSwapBuffers               = modgdi32.NewProc("SwapBuffers")
+)
+
+func GetDeviceCaps(hdc HDC, index int) int {
+	ret, _, _ := procGetDeviceCaps.Call(
+		uintptr(hdc),
+		uintptr(index))
+
+	return int(ret)
+}
+
+func DeleteObject(hObject HGDIOBJ) bool {
+	ret, _, _ := procDeleteObject.Call(
+		uintptr(hObject))
+
+	return ret != 0
+}
+
+func CreateFontIndirect(logFont *LOGFONT) HFONT {
+	ret, _, _ := procCreateFontIndirect.Call(
+		uintptr(unsafe.Pointer(logFont)))
+
+	return HFONT(ret)
+}
+
+func AbortDoc(hdc HDC) int {
+	ret, _, _ := procAbortDoc.Call(
+		uintptr(hdc))
+
+	return int(ret)
+}
+
+func BitBlt(hdcDest HDC, nXDest, nYDest, nWidth, nHeight int, hdcSrc HDC, nXSrc, nYSrc int, dwRop uint) {
+	ret, _, _ := procBitBlt.Call(
+		uintptr(hdcDest),
+		uintptr(nXDest),
+		uintptr(nYDest),
+		uintptr(nWidth),
+		uintptr(nHeight),
+		uintptr(hdcSrc),
+		uintptr(nXSrc),
+		uintptr(nYSrc),
+		uintptr(dwRop))
+
+	if ret == 0 {
+		panic("BitBlt failed")
+	}
+}
+
+func CloseEnhMetaFile(hdc HDC) HENHMETAFILE {
+	ret, _, _ := procCloseEnhMetaFile.Call(
+		uintptr(hdc))
+
+	return HENHMETAFILE(ret)
+}
+
+func CopyEnhMetaFile(hemfSrc HENHMETAFILE, lpszFile *uint16) HENHMETAFILE {
+	ret, _, _ := procCopyEnhMetaFile.Call(
+		uintptr(hemfSrc),
+		uintptr(unsafe.Pointer(lpszFile)))
+
+	return HENHMETAFILE(ret)
+}
+
+func CreateBrushIndirect(lplb *LOGBRUSH) HBRUSH {
+	ret, _, _ := procCreateBrushIndirect.Call(
+		uintptr(unsafe.Pointer(lplb)))
+
+	return HBRUSH(ret)
+}
+
+func CreateCompatibleDC(hdc HDC) HDC {
+	ret, _, _ := procCreateCompatibleDC.Call(
+		uintptr(hdc))
+
+	if ret == 0 {
+		panic("Create compatible DC failed")
+	}
+
+	return HDC(ret)
+}
+
+func CreateDC(lpszDriver, lpszDevice, lpszOutput *uint16, lpInitData *DEVMODE) HDC {
+	ret, _, _ := procCreateDC.Call(
+		uintptr(unsafe.Pointer(lpszDriver)),
+		uintptr(unsafe.Pointer(lpszDevice)),
+		uintptr(unsafe.Pointer(lpszOutput)),
+		uintptr(unsafe.Pointer(lpInitData)))
+
+	return HDC(ret)
+}
+
+func CreateDIBSection(hdc HDC, pbmi *BITMAPINFO, iUsage uint, ppvBits *unsafe.Pointer, hSection HANDLE, dwOffset uint) HBITMAP {
+	ret, _, _ := procCreateDIBSection.Call(
+		uintptr(hdc),
+		uintptr(unsafe.Pointer(pbmi)),
+		uintptr(iUsage),
+		uintptr(unsafe.Pointer(ppvBits)),
+		uintptr(hSection),
+		uintptr(dwOffset))
+
+	return HBITMAP(ret)
+}
+
+func CreateEnhMetaFile(hdcRef HDC, lpFilename *uint16, lpRect *RECT, lpDescription *uint16) HDC {
+	ret, _, _ := procCreateEnhMetaFile.Call(
+		uintptr(hdcRef),
+		uintptr(unsafe.Pointer(lpFilename)),
+		uintptr(unsafe.Pointer(lpRect)),
+		uintptr(unsafe.Pointer(lpDescription)))
+
+	return HDC(ret)
+}
+
+func CreateIC(lpszDriver, lpszDevice, lpszOutput *uint16, lpdvmInit *DEVMODE) HDC {
+	ret, _, _ := procCreateIC.Call(
+		uintptr(unsafe.Pointer(lpszDriver)),
+		uintptr(unsafe.Pointer(lpszDevice)),
+		uintptr(unsafe.Pointer(lpszOutput)),
+		uintptr(unsafe.Pointer(lpdvmInit)))
+
+	return HDC(ret)
+}
+
+func DeleteDC(hdc HDC) bool {
+	ret, _, _ := procDeleteDC.Call(
+		uintptr(hdc))
+
+	return ret != 0
+}
+
+func DeleteEnhMetaFile(hemf HENHMETAFILE) bool {
+	ret, _, _ := procDeleteEnhMetaFile.Call(
+		uintptr(hemf))
+
+	return ret != 0
+}
+
+func Ellipse(hdc HDC, nLeftRect, nTopRect, nRightRect, nBottomRect int) bool {
+	ret, _, _ := procEllipse.Call(
+		uintptr(hdc),
+		uintptr(nLeftRect),
+		uintptr(nTopRect),
+		uintptr(nRightRect),
+		uintptr(nBottomRect))
+
+	return ret != 0
+}
+
+func EndDoc(hdc HDC) int {
+	ret, _, _ := procEndDoc.Call(
+		uintptr(hdc))
+
+	return int(ret)
+}
+
+func EndPage(hdc HDC) int {
+	ret, _, _ := procEndPage.Call(
+		uintptr(hdc))
+
+	return int(ret)
+}
+
+func ExtCreatePen(dwPenStyle, dwWidth uint, lplb *LOGBRUSH, dwStyleCount uint, lpStyle *uint) HPEN {
+	ret, _, _ := procExtCreatePen.Call(
+		uintptr(dwPenStyle),
+		uintptr(dwWidth),
+		uintptr(unsafe.Pointer(lplb)),
+		uintptr(dwStyleCount),
+		uintptr(unsafe.Pointer(lpStyle)))
+
+	return HPEN(ret)
+}
+
+func GetEnhMetaFile(lpszMetaFile *uint16) HENHMETAFILE {
+	ret, _, _ := procGetEnhMetaFile.Call(
+		uintptr(unsafe.Pointer(lpszMetaFile)))
+
+	return HENHMETAFILE(ret)
+}
+
+func GetEnhMetaFileHeader(hemf HENHMETAFILE, cbBuffer uint, lpemh *ENHMETAHEADER) uint {
+	ret, _, _ := procGetEnhMetaFileHeader.Call(
+		uintptr(hemf),
+		uintptr(cbBuffer),
+		uintptr(unsafe.Pointer(lpemh)))
+
+	return uint(ret)
+}
+
+func GetObject(hgdiobj HGDIOBJ, cbBuffer uintptr, lpvObject unsafe.Pointer) int {
+	ret, _, _ := procGetObject.Call(
+		uintptr(hgdiobj),
+		uintptr(cbBuffer),
+		uintptr(lpvObject))
+
+	return int(ret)
+}
+
+func GetStockObject(fnObject int) HGDIOBJ {
+	ret, _, _ := procGetDeviceCaps.Call(
+		uintptr(fnObject))
+
+	return HGDIOBJ(ret)
+}
+
+func GetTextExtentExPoint(hdc HDC, lpszStr *uint16, cchString, nMaxExtent int, lpnFit, alpDx *int, lpSize *SIZE) bool {
+	ret, _, _ := procGetTextExtentExPoint.Call(
+		uintptr(hdc),
+		uintptr(unsafe.Pointer(lpszStr)),
+		uintptr(cchString),
+		uintptr(nMaxExtent),
+		uintptr(unsafe.Pointer(lpnFit)),
+		uintptr(unsafe.Pointer(alpDx)),
+		uintptr(unsafe.Pointer(lpSize)))
+
+	return ret != 0
+}
+
+func GetTextExtentPoint32(hdc HDC, lpString *uint16, c int, lpSize *SIZE) bool {
+	ret, _, _ := procGetTextExtentPoint32.Call(
+		uintptr(hdc),
+		uintptr(unsafe.Pointer(lpString)),
+		uintptr(c),
+		uintptr(unsafe.Pointer(lpSize)))
+
+	return ret != 0
+}
+
+func GetTextMetrics(hdc HDC, lptm *TEXTMETRIC) bool {
+	ret, _, _ := procGetTextMetrics.Call(
+		uintptr(hdc),
+		uintptr(unsafe.Pointer(lptm)))
+
+	return ret != 0
+}
+
+func LineTo(hdc HDC, nXEnd, nYEnd int) bool {
+	ret, _, _ := procLineTo.Call(
+		uintptr(hdc),
+		uintptr(nXEnd),
+		uintptr(nYEnd))
+
+	return ret != 0
+}
+
+func MoveToEx(hdc HDC, x, y int, lpPoint *POINT) bool {
+	ret, _, _ := procMoveToEx.Call(
+		uintptr(hdc),
+		uintptr(x),
+		uintptr(y),
+		uintptr(unsafe.Pointer(lpPoint)))
+
+	return ret != 0
+}
+
+func PlayEnhMetaFile(hdc HDC, hemf HENHMETAFILE, lpRect *RECT) bool {
+	ret, _, _ := procPlayEnhMetaFile.Call(
+		uintptr(hdc),
+		uintptr(hemf),
+		uintptr(unsafe.Pointer(lpRect)))
+
+	return ret != 0
+}
+
+func Rectangle(hdc HDC, nLeftRect, nTopRect, nRightRect, nBottomRect int) bool {
+	ret, _, _ := procRectangle.Call(
+		uintptr(hdc),
+		uintptr(nLeftRect),
+		uintptr(nTopRect),
+		uintptr(nRightRect),
+		uintptr(nBottomRect))
+
+	return ret != 0
+}
+
+func ResetDC(hdc HDC, lpInitData *DEVMODE) HDC {
+	ret, _, _ := procResetDC.Call(
+		uintptr(hdc),
+		uintptr(unsafe.Pointer(lpInitData)))
+
+	return HDC(ret)
+}
+
+func SelectObject(hdc HDC, hgdiobj HGDIOBJ) HGDIOBJ {
+	ret, _, _ := procSelectObject.Call(
+		uintptr(hdc),
+		uintptr(hgdiobj))
+
+	if ret == 0 {
+		panic("SelectObject failed")
+	}
+
+	return HGDIOBJ(ret)
+}
+
+func SetBkMode(hdc HDC, iBkMode int) int {
+	ret, _, _ := procSetBkMode.Call(
+		uintptr(hdc),
+		uintptr(iBkMode))
+
+	if ret == 0 {
+		panic("SetBkMode failed")
+	}
+
+	return int(ret)
+}
+
+func SetBrushOrgEx(hdc HDC, nXOrg, nYOrg int, lppt *POINT) bool {
+	ret, _, _ := procSetBrushOrgEx.Call(
+		uintptr(hdc),
+		uintptr(nXOrg),
+		uintptr(nYOrg),
+		uintptr(unsafe.Pointer(lppt)))
+
+	return ret != 0
+}
+
+func SetStretchBltMode(hdc HDC, iStretchMode int) int {
+	ret, _, _ := procSetStretchBltMode.Call(
+		uintptr(hdc),
+		uintptr(iStretchMode))
+
+	return int(ret)
+}
+
+func SetTextColor(hdc HDC, crColor COLORREF) COLORREF {
+	ret, _, _ := procSetTextColor.Call(
+		uintptr(hdc),
+		uintptr(crColor))
+
+	if ret == CLR_INVALID {
+		panic("SetTextColor failed")
+	}
+
+	return COLORREF(ret)
+}
+
+func SetBkColor(hdc HDC, crColor COLORREF) COLORREF {
+	ret, _, _ := procSetBkColor.Call(
+		uintptr(hdc),
+		uintptr(crColor))
+
+	if ret == CLR_INVALID {
+		panic("SetBkColor failed")
+	}
+
+	return COLORREF(ret)
+}
+
+func StartDoc(hdc HDC, lpdi *DOCINFO) int {
+	ret, _, _ := procStartDoc.Call(
+		uintptr(hdc),
+		uintptr(unsafe.Pointer(lpdi)))
+
+	return int(ret)
+}
+
+func StartPage(hdc HDC) int {
+	ret, _, _ := procStartPage.Call(
+		uintptr(hdc))
+
+	return int(ret)
+}
+
+func StretchBlt(hdcDest HDC, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest int, hdcSrc HDC, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc int, dwRop uint) {
+	ret, _, _ := procStretchBlt.Call(
+		uintptr(hdcDest),
+		uintptr(nXOriginDest),
+		uintptr(nYOriginDest),
+		uintptr(nWidthDest),
+		uintptr(nHeightDest),
+		uintptr(hdcSrc),
+		uintptr(nXOriginSrc),
+		uintptr(nYOriginSrc),
+		uintptr(nWidthSrc),
+		uintptr(nHeightSrc),
+		uintptr(dwRop))
+
+	if ret == 0 {
+		panic("StretchBlt failed")
+	}
+}
+
+func SetDIBitsToDevice(hdc HDC, xDest, yDest, dwWidth, dwHeight, xSrc, ySrc int, uStartScan, cScanLines uint, lpvBits []byte, lpbmi *BITMAPINFO, fuColorUse uint) int {
+	ret, _, _ := procSetDIBitsToDevice.Call(
+		uintptr(hdc),
+		uintptr(xDest),
+		uintptr(yDest),
+		uintptr(dwWidth),
+		uintptr(dwHeight),
+		uintptr(xSrc),
+		uintptr(ySrc),
+		uintptr(uStartScan),
+		uintptr(cScanLines),
+		uintptr(unsafe.Pointer(&lpvBits[0])),
+		uintptr(unsafe.Pointer(lpbmi)),
+		uintptr(fuColorUse))
+
+	return int(ret)
+}
+
+func ChoosePixelFormat(hdc HDC, pfd *PIXELFORMATDESCRIPTOR) int {
+	ret, _, _ := procChoosePixelFormat.Call(
+		uintptr(hdc),
+		uintptr(unsafe.Pointer(pfd)),
+	)
+	return int(ret)
+}
+
+func DescribePixelFormat(hdc HDC, iPixelFormat int, nBytes uint, pfd *PIXELFORMATDESCRIPTOR) int {
+	ret, _, _ := procDescribePixelFormat.Call(
+		uintptr(hdc),
+		uintptr(iPixelFormat),
+		uintptr(nBytes),
+		uintptr(unsafe.Pointer(pfd)),
+	)
+	return int(ret)
+}
+
+func GetEnhMetaFilePixelFormat(hemf HENHMETAFILE, cbBuffer uint32, pfd *PIXELFORMATDESCRIPTOR) uint {
+	ret, _, _ := procGetEnhMetaFilePixelFormat.Call(
+		uintptr(hemf),
+		uintptr(cbBuffer),
+		uintptr(unsafe.Pointer(pfd)),
+	)
+	return uint(ret)
+}
+
+func GetPixelFormat(hdc HDC) int {
+	ret, _, _ := procGetPixelFormat.Call(
+		uintptr(hdc),
+	)
+	return int(ret)
+}
+
+func SetPixelFormat(hdc HDC, iPixelFormat int, pfd *PIXELFORMATDESCRIPTOR) bool {
+	ret, _, _ := procSetPixelFormat.Call(
+		uintptr(hdc),
+		uintptr(iPixelFormat),
+		uintptr(unsafe.Pointer(pfd)),
+	)
+	return ret == TRUE
+}
+
+func SwapBuffers(hdc HDC) bool {
+	ret, _, _ := procSwapBuffers.Call(uintptr(hdc))
+	return ret == TRUE
+}

vendor/github.com/shirou/w32/gdiplus.go

@@ -0,0 +1,177 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"errors"
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+const (
+	Ok                        = 0
+	GenericError              = 1
+	InvalidParameter          = 2
+	OutOfMemory               = 3
+	ObjectBusy                = 4
+	InsufficientBuffer        = 5
+	NotImplemented            = 6
+	Win32Error                = 7
+	WrongState                = 8
+	Aborted                   = 9
+	FileNotFound              = 10
+	ValueOverflow             = 11
+	AccessDenied              = 12
+	UnknownImageFormat        = 13
+	FontFamilyNotFound        = 14
+	FontStyleNotFound         = 15
+	NotTrueTypeFont           = 16
+	UnsupportedGdiplusVersion = 17
+	GdiplusNotInitialized     = 18
+	PropertyNotFound          = 19
+	PropertyNotSupported      = 20
+	ProfileNotFound           = 21
+)
+
+func GetGpStatus(s int32) string {
+	switch s {
+	case Ok:
+		return "Ok"
+	case GenericError:
+		return "GenericError"
+	case InvalidParameter:
+		return "InvalidParameter"
+	case OutOfMemory:
+		return "OutOfMemory"
+	case ObjectBusy:
+		return "ObjectBusy"
+	case InsufficientBuffer:
+		return "InsufficientBuffer"
+	case NotImplemented:
+		return "NotImplemented"
+	case Win32Error:
+		return "Win32Error"
+	case WrongState:
+		return "WrongState"
+	case Aborted:
+		return "Aborted"
+	case FileNotFound:
+		return "FileNotFound"
+	case ValueOverflow:
+		return "ValueOverflow"
+	case AccessDenied:
+		return "AccessDenied"
+	case UnknownImageFormat:
+		return "UnknownImageFormat"
+	case FontFamilyNotFound:
+		return "FontFamilyNotFound"
+	case FontStyleNotFound:
+		return "FontStyleNotFound"
+	case NotTrueTypeFont:
+		return "NotTrueTypeFont"
+	case UnsupportedGdiplusVersion:
+		return "UnsupportedGdiplusVersion"
+	case GdiplusNotInitialized:
+		return "GdiplusNotInitialized"
+	case PropertyNotFound:
+		return "PropertyNotFound"
+	case PropertyNotSupported:
+		return "PropertyNotSupported"
+	case ProfileNotFound:
+		return "ProfileNotFound"
+	}
+	return "Unknown Status Value"
+}
+
+var (
+	token uintptr
+
+	modgdiplus = syscall.NewLazyDLL("gdiplus.dll")
+
+	procGdipCreateBitmapFromFile     = modgdiplus.NewProc("GdipCreateBitmapFromFile")
+	procGdipCreateBitmapFromHBITMAP  = modgdiplus.NewProc("GdipCreateBitmapFromHBITMAP")
+	procGdipCreateHBITMAPFromBitmap  = modgdiplus.NewProc("GdipCreateHBITMAPFromBitmap")
+	procGdipCreateBitmapFromResource = modgdiplus.NewProc("GdipCreateBitmapFromResource")
+	procGdipCreateBitmapFromStream   = modgdiplus.NewProc("GdipCreateBitmapFromStream")
+	procGdipDisposeImage             = modgdiplus.NewProc("GdipDisposeImage")
+	procGdiplusShutdown              = modgdiplus.NewProc("GdiplusShutdown")
+	procGdiplusStartup               = modgdiplus.NewProc("GdiplusStartup")
+)
+
+func GdipCreateBitmapFromFile(filename string) (*uintptr, error) {
+	var bitmap *uintptr
+	ret, _, _ := procGdipCreateBitmapFromFile.Call(
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(filename))),
+		uintptr(unsafe.Pointer(&bitmap)))
+
+	if ret != Ok {
+		return nil, errors.New(fmt.Sprintf("GdipCreateBitmapFromFile failed with status '%s' for file '%s'", GetGpStatus(int32(ret)), filename))
+	}
+
+	return bitmap, nil
+}
+
+func GdipCreateBitmapFromResource(instance HINSTANCE, resId *uint16) (*uintptr, error) {
+	var bitmap *uintptr
+	ret, _, _ := procGdipCreateBitmapFromResource.Call(
+		uintptr(instance),
+		uintptr(unsafe.Pointer(resId)),
+		uintptr(unsafe.Pointer(&bitmap)))
+
+	if ret != Ok {
+		return nil, errors.New(fmt.Sprintf("GdiCreateBitmapFromResource failed with status '%s'", GetGpStatus(int32(ret))))
+	}
+
+	return bitmap, nil
+}
+
+func GdipCreateBitmapFromStream(stream *IStream) (*uintptr, error) {
+	var bitmap *uintptr
+	ret, _, _ := procGdipCreateBitmapFromStream.Call(
+		uintptr(unsafe.Pointer(stream)),
+		uintptr(unsafe.Pointer(&bitmap)))
+
+	if ret != Ok {
+		return nil, errors.New(fmt.Sprintf("GdipCreateBitmapFromStream failed with status '%s'", GetGpStatus(int32(ret))))
+	}
+
+	return bitmap, nil
+}
+
+func GdipCreateHBITMAPFromBitmap(bitmap *uintptr, background uint32) (HBITMAP, error) {
+	var hbitmap HBITMAP
+	ret, _, _ := procGdipCreateHBITMAPFromBitmap.Call(
+		uintptr(unsafe.Pointer(bitmap)),
+		uintptr(unsafe.Pointer(&hbitmap)),
+		uintptr(background))
+
+	if ret != Ok {
+		return 0, errors.New(fmt.Sprintf("GdipCreateHBITMAPFromBitmap failed with status '%s'", GetGpStatus(int32(ret))))
+	}
+
+	return hbitmap, nil
+}
+
+func GdipDisposeImage(image *uintptr) {
+	procGdipDisposeImage.Call(uintptr(unsafe.Pointer(image)))
+}
+
+func GdiplusShutdown() {
+	procGdiplusShutdown.Call(token)
+}
+
+func GdiplusStartup(input *GdiplusStartupInput, output *GdiplusStartupOutput) {
+	ret, _, _ := procGdiplusStartup.Call(
+		uintptr(unsafe.Pointer(&token)),
+		uintptr(unsafe.Pointer(input)),
+		uintptr(unsafe.Pointer(output)))
+
+	if ret != Ok {
+		panic("GdiplusStartup failed with status " + GetGpStatus(int32(ret)))
+	}
+}

vendor/github.com/shirou/w32/idispatch.go

@@ -0,0 +1,45 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"unsafe"
+)
+
+type pIDispatchVtbl struct {
+	pQueryInterface   uintptr
+	pAddRef           uintptr
+	pRelease          uintptr
+	pGetTypeInfoCount uintptr
+	pGetTypeInfo      uintptr
+	pGetIDsOfNames    uintptr
+	pInvoke           uintptr
+}
+
+type IDispatch struct {
+	lpVtbl *pIDispatchVtbl
+}
+
+func (this *IDispatch) QueryInterface(id *GUID) *IDispatch {
+	return ComQueryInterface((*IUnknown)(unsafe.Pointer(this)), id)
+}
+
+func (this *IDispatch) AddRef() int32 {
+	return ComAddRef((*IUnknown)(unsafe.Pointer(this)))
+}
+
+func (this *IDispatch) Release() int32 {
+	return ComRelease((*IUnknown)(unsafe.Pointer(this)))
+}
+
+func (this *IDispatch) GetIDsOfName(names []string) []int32 {
+	return ComGetIDsOfName(this, names)
+}
+
+func (this *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) *VARIANT {
+	return ComInvoke(this, dispid, dispatch, params...)
+}

vendor/github.com/shirou/w32/istream.go

@@ -0,0 +1,33 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"unsafe"
+)
+
+type pIStreamVtbl struct {
+	pQueryInterface uintptr
+	pAddRef         uintptr
+	pRelease        uintptr
+}
+
+type IStream struct {
+	lpVtbl *pIStreamVtbl
+}
+
+func (this *IStream) QueryInterface(id *GUID) *IDispatch {
+	return ComQueryInterface((*IUnknown)(unsafe.Pointer(this)), id)
+}
+
+func (this *IStream) AddRef() int32 {
+	return ComAddRef((*IUnknown)(unsafe.Pointer(this)))
+}
+
+func (this *IStream) Release() int32 {
+	return ComRelease((*IUnknown)(unsafe.Pointer(this)))
+}

vendor/github.com/shirou/w32/iunknown.go

@@ -0,0 +1,29 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+type pIUnknownVtbl struct {
+	pQueryInterface uintptr
+	pAddRef         uintptr
+	pRelease        uintptr
+}
+
+type IUnknown struct {
+	lpVtbl *pIUnknownVtbl
+}
+
+func (this *IUnknown) QueryInterface(id *GUID) *IDispatch {
+	return ComQueryInterface(this, id)
+}
+
+func (this *IUnknown) AddRef() int32 {
+	return ComAddRef(this)
+}
+
+func (this *IUnknown) Release() int32 {
+	return ComRelease(this)
+}

vendor/github.com/shirou/w32/kernel32.go

@@ -0,0 +1,316 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modkernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+	procGetModuleHandle            = modkernel32.NewProc("GetModuleHandleW")
+	procMulDiv                     = modkernel32.NewProc("MulDiv")
+	procGetConsoleWindow           = modkernel32.NewProc("GetConsoleWindow")
+	procGetCurrentThread           = modkernel32.NewProc("GetCurrentThread")
+	procGetLogicalDrives           = modkernel32.NewProc("GetLogicalDrives")
+	procGetUserDefaultLCID         = modkernel32.NewProc("GetUserDefaultLCID")
+	procLstrlen                    = modkernel32.NewProc("lstrlenW")
+	procLstrcpy                    = modkernel32.NewProc("lstrcpyW")
+	procGlobalAlloc                = modkernel32.NewProc("GlobalAlloc")
+	procGlobalFree                 = modkernel32.NewProc("GlobalFree")
+	procGlobalLock                 = modkernel32.NewProc("GlobalLock")
+	procGlobalUnlock               = modkernel32.NewProc("GlobalUnlock")
+	procMoveMemory                 = modkernel32.NewProc("RtlMoveMemory")
+	procFindResource               = modkernel32.NewProc("FindResourceW")
+	procSizeofResource             = modkernel32.NewProc("SizeofResource")
+	procLockResource               = modkernel32.NewProc("LockResource")
+	procLoadResource               = modkernel32.NewProc("LoadResource")
+	procGetLastError               = modkernel32.NewProc("GetLastError")
+	procOpenProcess                = modkernel32.NewProc("OpenProcess")
+	procTerminateProcess           = modkernel32.NewProc("TerminateProcess")
+	procCloseHandle                = modkernel32.NewProc("CloseHandle")
+	procCreateToolhelp32Snapshot   = modkernel32.NewProc("CreateToolhelp32Snapshot")
+	procModule32First              = modkernel32.NewProc("Module32FirstW")
+	procModule32Next               = modkernel32.NewProc("Module32NextW")
+	procProcess32First             = modkernel32.NewProc("Process32FirstW")
+	procProcess32Next              = modkernel32.NewProc("Process32NextW")
+	procGetSystemTimes             = modkernel32.NewProc("GetSystemTimes")
+	procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo")
+	procSetConsoleTextAttribute    = modkernel32.NewProc("SetConsoleTextAttribute")
+	procGetDiskFreeSpaceEx         = modkernel32.NewProc("GetDiskFreeSpaceExW")
+	procGetProcessTimes            = modkernel32.NewProc("GetProcessTimes")
+)
+
+func GetModuleHandle(modulename string) HINSTANCE {
+	var mn uintptr
+	if modulename == "" {
+		mn = 0
+	} else {
+		mn = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(modulename)))
+	}
+	ret, _, _ := procGetModuleHandle.Call(mn)
+	return HINSTANCE(ret)
+}
+
+func MulDiv(number, numerator, denominator int) int {
+	ret, _, _ := procMulDiv.Call(
+		uintptr(number),
+		uintptr(numerator),
+		uintptr(denominator))
+
+	return int(ret)
+}
+
+func GetConsoleWindow() HWND {
+	ret, _, _ := procGetConsoleWindow.Call()
+
+	return HWND(ret)
+}
+
+func GetCurrentThread() HANDLE {
+	ret, _, _ := procGetCurrentThread.Call()
+
+	return HANDLE(ret)
+}
+
+func GetLogicalDrives() uint32 {
+	ret, _, _ := procGetLogicalDrives.Call()
+
+	return uint32(ret)
+}
+
+func GetUserDefaultLCID() uint32 {
+	ret, _, _ := procGetUserDefaultLCID.Call()
+
+	return uint32(ret)
+}
+
+func Lstrlen(lpString *uint16) int {
+	ret, _, _ := procLstrlen.Call(uintptr(unsafe.Pointer(lpString)))
+
+	return int(ret)
+}
+
+func Lstrcpy(buf []uint16, lpString *uint16) {
+	procLstrcpy.Call(
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(lpString)))
+}
+
+func GlobalAlloc(uFlags uint, dwBytes uint32) HGLOBAL {
+	ret, _, _ := procGlobalAlloc.Call(
+		uintptr(uFlags),
+		uintptr(dwBytes))
+
+	if ret == 0 {
+		panic("GlobalAlloc failed")
+	}
+
+	return HGLOBAL(ret)
+}
+
+func GlobalFree(hMem HGLOBAL) {
+	ret, _, _ := procGlobalFree.Call(uintptr(hMem))
+
+	if ret != 0 {
+		panic("GlobalFree failed")
+	}
+}
+
+func GlobalLock(hMem HGLOBAL) unsafe.Pointer {
+	ret, _, _ := procGlobalLock.Call(uintptr(hMem))
+
+	if ret == 0 {
+		panic("GlobalLock failed")
+	}
+
+	return unsafe.Pointer(ret)
+}
+
+func GlobalUnlock(hMem HGLOBAL) bool {
+	ret, _, _ := procGlobalUnlock.Call(uintptr(hMem))
+
+	return ret != 0
+}
+
+func MoveMemory(destination, source unsafe.Pointer, length uint32) {
+	procMoveMemory.Call(
+		uintptr(unsafe.Pointer(destination)),
+		uintptr(source),
+		uintptr(length))
+}
+
+func FindResource(hModule HMODULE, lpName, lpType *uint16) (HRSRC, error) {
+	ret, _, _ := procFindResource.Call(
+		uintptr(hModule),
+		uintptr(unsafe.Pointer(lpName)),
+		uintptr(unsafe.Pointer(lpType)))
+
+	if ret == 0 {
+		return 0, syscall.GetLastError()
+	}
+
+	return HRSRC(ret), nil
+}
+
+func SizeofResource(hModule HMODULE, hResInfo HRSRC) uint32 {
+	ret, _, _ := procSizeofResource.Call(
+		uintptr(hModule),
+		uintptr(hResInfo))
+
+	if ret == 0 {
+		panic("SizeofResource failed")
+	}
+
+	return uint32(ret)
+}
+
+func LockResource(hResData HGLOBAL) unsafe.Pointer {
+	ret, _, _ := procLockResource.Call(uintptr(hResData))
+
+	if ret == 0 {
+		panic("LockResource failed")
+	}
+
+	return unsafe.Pointer(ret)
+}
+
+func LoadResource(hModule HMODULE, hResInfo HRSRC) HGLOBAL {
+	ret, _, _ := procLoadResource.Call(
+		uintptr(hModule),
+		uintptr(hResInfo))
+
+	if ret == 0 {
+		panic("LoadResource failed")
+	}
+
+	return HGLOBAL(ret)
+}
+
+func GetLastError() uint32 {
+	ret, _, _ := procGetLastError.Call()
+	return uint32(ret)
+}
+
+func OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) HANDLE {
+	inherit := 0
+	if inheritHandle {
+		inherit = 1
+	}
+
+	ret, _, _ := procOpenProcess.Call(
+		uintptr(desiredAccess),
+		uintptr(inherit),
+		uintptr(processId))
+	return HANDLE(ret)
+}
+
+func TerminateProcess(hProcess HANDLE, uExitCode uint) bool {
+	ret, _, _ := procTerminateProcess.Call(
+		uintptr(hProcess),
+		uintptr(uExitCode))
+	return ret != 0
+}
+
+func CloseHandle(object HANDLE) bool {
+	ret, _, _ := procCloseHandle.Call(
+		uintptr(object))
+	return ret != 0
+}
+
+func CreateToolhelp32Snapshot(flags, processId uint32) HANDLE {
+	ret, _, _ := procCreateToolhelp32Snapshot.Call(
+		uintptr(flags),
+		uintptr(processId))
+
+	if ret <= 0 {
+		return HANDLE(0)
+	}
+
+	return HANDLE(ret)
+}
+
+func Module32First(snapshot HANDLE, me *MODULEENTRY32) bool {
+	ret, _, _ := procModule32First.Call(
+		uintptr(snapshot),
+		uintptr(unsafe.Pointer(me)))
+
+	return ret != 0
+}
+
+func Module32Next(snapshot HANDLE, me *MODULEENTRY32) bool {
+	ret, _, _ := procModule32Next.Call(
+		uintptr(snapshot),
+		uintptr(unsafe.Pointer(me)))
+
+	return ret != 0
+}
+func Process32First(snapshot HANDLE, pe *PROCESSENTRY32) bool {
+	ret, _, _ := procProcess32First.Call(
+		uintptr(snapshot),
+		uintptr(unsafe.Pointer(pe)))
+
+	return ret != 0
+}
+
+func Process32Next(snapshot HANDLE, pe *PROCESSENTRY32) bool {
+	ret, _, _ := procProcess32Next.Call(
+		uintptr(snapshot),
+		uintptr(unsafe.Pointer(pe)))
+
+	return ret != 0
+}
+func GetSystemTimes(lpIdleTime, lpKernelTime, lpUserTime *FILETIME) bool {
+	ret, _, _ := procGetSystemTimes.Call(
+		uintptr(unsafe.Pointer(lpIdleTime)),
+		uintptr(unsafe.Pointer(lpKernelTime)),
+		uintptr(unsafe.Pointer(lpUserTime)))
+
+	return ret != 0
+}
+
+func GetProcessTimes(hProcess HANDLE, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime *FILETIME) bool {
+	ret, _, _ := procGetProcessTimes.Call(
+		uintptr(hProcess),
+		uintptr(unsafe.Pointer(lpCreationTime)),
+		uintptr(unsafe.Pointer(lpExitTime)),
+		uintptr(unsafe.Pointer(lpKernelTime)),
+		uintptr(unsafe.Pointer(lpUserTime)))
+
+	return ret != 0
+}
+
+func GetConsoleScreenBufferInfo(hConsoleOutput HANDLE) *CONSOLE_SCREEN_BUFFER_INFO {
+	var csbi CONSOLE_SCREEN_BUFFER_INFO
+	ret, _, _ := procGetConsoleScreenBufferInfo.Call(
+		uintptr(hConsoleOutput),
+		uintptr(unsafe.Pointer(&csbi)))
+	if ret == 0 {
+		return nil
+	}
+	return &csbi
+}
+
+func SetConsoleTextAttribute(hConsoleOutput HANDLE, wAttributes uint16) bool {
+	ret, _, _ := procSetConsoleTextAttribute.Call(
+		uintptr(hConsoleOutput),
+		uintptr(wAttributes))
+	return ret != 0
+}
+
+func GetDiskFreeSpaceEx(dirName string) (r bool,
+	freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes uint64) {
+	ret, _, _ := procGetDiskFreeSpaceEx.Call(
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(dirName))),
+		uintptr(unsafe.Pointer(&freeBytesAvailable)),
+		uintptr(unsafe.Pointer(&totalNumberOfBytes)),
+		uintptr(unsafe.Pointer(&totalNumberOfFreeBytes)))
+	return ret != 0,
+		freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes
+}

vendor/github.com/shirou/w32/ole32.go

@@ -0,0 +1,65 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modole32 = syscall.NewLazyDLL("ole32.dll")
+
+	procCoInitializeEx        = modole32.NewProc("CoInitializeEx")
+	procCoInitialize          = modole32.NewProc("CoInitialize")
+	procCoUninitialize        = modole32.NewProc("CoUninitialize")
+	procCreateStreamOnHGlobal = modole32.NewProc("CreateStreamOnHGlobal")
+)
+
+func CoInitializeEx(coInit uintptr) HRESULT {
+	ret, _, _ := procCoInitializeEx.Call(
+		0,
+		coInit)
+
+	switch uint32(ret) {
+	case E_INVALIDARG:
+		panic("CoInitializeEx failed with E_INVALIDARG")
+	case E_OUTOFMEMORY:
+		panic("CoInitializeEx failed with E_OUTOFMEMORY")
+	case E_UNEXPECTED:
+		panic("CoInitializeEx failed with E_UNEXPECTED")
+	}
+
+	return HRESULT(ret)
+}
+
+func CoInitialize() {
+	procCoInitialize.Call(0)
+}
+
+func CoUninitialize() {
+	procCoUninitialize.Call()
+}
+
+func CreateStreamOnHGlobal(hGlobal HGLOBAL, fDeleteOnRelease bool) *IStream {
+	stream := new(IStream)
+	ret, _, _ := procCreateStreamOnHGlobal.Call(
+		uintptr(hGlobal),
+		uintptr(BoolToBOOL(fDeleteOnRelease)),
+		uintptr(unsafe.Pointer(&stream)))
+
+	switch uint32(ret) {
+	case E_INVALIDARG:
+		panic("CreateStreamOnHGlobal failed with E_INVALIDARG")
+	case E_OUTOFMEMORY:
+		panic("CreateStreamOnHGlobal failed with E_OUTOFMEMORY")
+	case E_UNEXPECTED:
+		panic("CreateStreamOnHGlobal failed with E_UNEXPECTED")
+	}
+
+	return stream
+}

vendor/github.com/shirou/w32/oleaut32.go

@@ -0,0 +1,50 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modoleaut32 = syscall.NewLazyDLL("oleaut32")
+
+	procVariantInit        = modoleaut32.NewProc("VariantInit")
+	procSysAllocString     = modoleaut32.NewProc("SysAllocString")
+	procSysFreeString      = modoleaut32.NewProc("SysFreeString")
+	procSysStringLen       = modoleaut32.NewProc("SysStringLen")
+	procCreateDispTypeInfo = modoleaut32.NewProc("CreateDispTypeInfo")
+	procCreateStdDispatch  = modoleaut32.NewProc("CreateStdDispatch")
+)
+
+func VariantInit(v *VARIANT) {
+	hr, _, _ := procVariantInit.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		panic("Invoke VariantInit error.")
+	}
+	return
+}
+
+func SysAllocString(v string) (ss *int16) {
+	pss, _, _ := procSysAllocString.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(v))))
+	ss = (*int16)(unsafe.Pointer(pss))
+	return
+}
+
+func SysFreeString(v *int16) {
+	hr, _, _ := procSysFreeString.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		panic("Invoke SysFreeString error.")
+	}
+	return
+}
+
+func SysStringLen(v *int16) uint {
+	l, _, _ := procSysStringLen.Call(uintptr(unsafe.Pointer(v)))
+	return uint(l)
+}

vendor/github.com/shirou/w32/opengl32.go

@@ -0,0 +1,74 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modopengl32 = syscall.NewLazyDLL("opengl32.dll")
+
+	procwglCreateContext      = modopengl32.NewProc("wglCreateContext")
+	procwglCreateLayerContext = modopengl32.NewProc("wglCreateLayerContext")
+	procwglDeleteContext      = modopengl32.NewProc("wglDeleteContext")
+	procwglGetProcAddress     = modopengl32.NewProc("wglGetProcAddress")
+	procwglMakeCurrent        = modopengl32.NewProc("wglMakeCurrent")
+	procwglShareLists         = modopengl32.NewProc("wglShareLists")
+)
+
+func WglCreateContext(hdc HDC) HGLRC {
+	ret, _, _ := procwglCreateContext.Call(
+		uintptr(hdc),
+	)
+
+	return HGLRC(ret)
+}
+
+func WglCreateLayerContext(hdc HDC, iLayerPlane int) HGLRC {
+	ret, _, _ := procwglCreateLayerContext.Call(
+		uintptr(hdc),
+		uintptr(iLayerPlane),
+	)
+
+	return HGLRC(ret)
+}
+
+func WglDeleteContext(hglrc HGLRC) bool {
+	ret, _, _ := procwglDeleteContext.Call(
+		uintptr(hglrc),
+	)
+
+	return ret == TRUE
+}
+
+func WglGetProcAddress(szProc string) uintptr {
+	ret, _, _ := procwglGetProcAddress.Call(
+		uintptr(unsafe.Pointer(syscall.StringBytePtr(szProc))),
+	)
+
+	return ret
+}
+
+func WglMakeCurrent(hdc HDC, hglrc HGLRC) bool {
+	ret, _, _ := procwglMakeCurrent.Call(
+		uintptr(hdc),
+		uintptr(hglrc),
+	)
+
+	return ret == TRUE
+}
+
+func WglShareLists(hglrc1, hglrc2 HGLRC) bool {
+	ret, _, _ := procwglShareLists.Call(
+		uintptr(hglrc1),
+		uintptr(hglrc2),
+	)
+
+	return ret == TRUE
+}

vendor/github.com/shirou/w32/psapi.go

@@ -0,0 +1,27 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modpsapi = syscall.NewLazyDLL("psapi.dll")
+
+	procEnumProcesses = modpsapi.NewProc("EnumProcesses")
+)
+
+func EnumProcesses(processIds []uint32, cb uint32, bytesReturned *uint32) bool {
+	ret, _, _ := procEnumProcesses.Call(
+		uintptr(unsafe.Pointer(&processIds[0])),
+		uintptr(cb),
+		uintptr(unsafe.Pointer(bytesReturned)))
+
+	return ret != 0
+}

vendor/github.com/shirou/w32/shell32.go

@@ -0,0 +1,155 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"errors"
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+var (
+	modshell32 = syscall.NewLazyDLL("shell32.dll")
+
+	procSHBrowseForFolder   = modshell32.NewProc("SHBrowseForFolderW")
+	procSHGetPathFromIDList = modshell32.NewProc("SHGetPathFromIDListW")
+	procDragAcceptFiles     = modshell32.NewProc("DragAcceptFiles")
+	procDragQueryFile       = modshell32.NewProc("DragQueryFileW")
+	procDragQueryPoint      = modshell32.NewProc("DragQueryPoint")
+	procDragFinish          = modshell32.NewProc("DragFinish")
+	procShellExecute        = modshell32.NewProc("ShellExecuteW")
+	procExtractIcon         = modshell32.NewProc("ExtractIconW")
+)
+
+func SHBrowseForFolder(bi *BROWSEINFO) uintptr {
+	ret, _, _ := procSHBrowseForFolder.Call(uintptr(unsafe.Pointer(bi)))
+
+	return ret
+}
+
+func SHGetPathFromIDList(idl uintptr) string {
+	buf := make([]uint16, 1024)
+	procSHGetPathFromIDList.Call(
+		idl,
+		uintptr(unsafe.Pointer(&buf[0])))
+
+	return syscall.UTF16ToString(buf)
+}
+
+func DragAcceptFiles(hwnd HWND, accept bool) {
+	procDragAcceptFiles.Call(
+		uintptr(hwnd),
+		uintptr(BoolToBOOL(accept)))
+}
+
+func DragQueryFile(hDrop HDROP, iFile uint) (fileName string, fileCount uint) {
+	ret, _, _ := procDragQueryFile.Call(
+		uintptr(hDrop),
+		uintptr(iFile),
+		0,
+		0)
+
+	fileCount = uint(ret)
+
+	if iFile != 0xFFFFFFFF {
+		buf := make([]uint16, fileCount+1)
+
+		ret, _, _ := procDragQueryFile.Call(
+			uintptr(hDrop),
+			uintptr(iFile),
+			uintptr(unsafe.Pointer(&buf[0])),
+			uintptr(fileCount+1))
+
+		if ret == 0 {
+			panic("Invoke DragQueryFile error.")
+		}
+
+		fileName = syscall.UTF16ToString(buf)
+	}
+
+	return
+}
+
+func DragQueryPoint(hDrop HDROP) (x, y int, isClientArea bool) {
+	var pt POINT
+	ret, _, _ := procDragQueryPoint.Call(
+		uintptr(hDrop),
+		uintptr(unsafe.Pointer(&pt)))
+
+	return int(pt.X), int(pt.Y), (ret == 1)
+}
+
+func DragFinish(hDrop HDROP) {
+	procDragFinish.Call(uintptr(hDrop))
+}
+
+func ShellExecute(hwnd HWND, lpOperation, lpFile, lpParameters, lpDirectory string, nShowCmd int) error {
+	var op, param, directory uintptr
+	if len(lpOperation) != 0 {
+		op = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(lpOperation)))
+	}
+	if len(lpParameters) != 0 {
+		param = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(lpParameters)))
+	}
+	if len(lpDirectory) != 0 {
+		directory = uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(lpDirectory)))
+	}
+
+	ret, _, _ := procShellExecute.Call(
+		uintptr(hwnd),
+		op,
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(lpFile))),
+		param,
+		directory,
+		uintptr(nShowCmd))
+
+	errorMsg := ""
+	if ret != 0 && ret <= 32 {
+		switch int(ret) {
+		case ERROR_FILE_NOT_FOUND:
+			errorMsg = "The specified file was not found."
+		case ERROR_PATH_NOT_FOUND:
+			errorMsg = "The specified path was not found."
+		case ERROR_BAD_FORMAT:
+			errorMsg = "The .exe file is invalid (non-Win32 .exe or error in .exe image)."
+		case SE_ERR_ACCESSDENIED:
+			errorMsg = "The operating system denied access to the specified file."
+		case SE_ERR_ASSOCINCOMPLETE:
+			errorMsg = "The file name association is incomplete or invalid."
+		case SE_ERR_DDEBUSY:
+			errorMsg = "The DDE transaction could not be completed because other DDE transactions were being processed."
+		case SE_ERR_DDEFAIL:
+			errorMsg = "The DDE transaction failed."
+		case SE_ERR_DDETIMEOUT:
+			errorMsg = "The DDE transaction could not be completed because the request timed out."
+		case SE_ERR_DLLNOTFOUND:
+			errorMsg = "The specified DLL was not found."
+		case SE_ERR_NOASSOC:
+			errorMsg = "There is no application associated with the given file name extension. This error will also be returned if you attempt to print a file that is not printable."
+		case SE_ERR_OOM:
+			errorMsg = "There was not enough memory to complete the operation."
+		case SE_ERR_SHARE:
+			errorMsg = "A sharing violation occurred."
+		default:
+			errorMsg = fmt.Sprintf("Unknown error occurred with error code %v", ret)
+		}
+	} else {
+		return nil
+	}
+
+	return errors.New(errorMsg)
+}
+
+func ExtractIcon(lpszExeFileName string, nIconIndex int) HICON {
+	ret, _, _ := procExtractIcon.Call(
+		0,
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(lpszExeFileName))),
+		uintptr(nIconIndex))
+
+	return HICON(ret)
+}

vendor/github.com/shirou/w32/typedef.go

@@ -0,0 +1,901 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package w32
+
+import (
+	"unsafe"
+)
+
+// From MSDN: Windows Data Types
+// http://msdn.microsoft.com/en-us/library/s3f49ktz.aspx
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa383751.aspx
+// ATOM                  WORD
+// BOOL                  int32
+// BOOLEAN               byte
+// BYTE                  byte
+// CCHAR                 int8
+// CHAR                  int8
+// COLORREF              DWORD
+// DWORD                 uint32
+// DWORDLONG             ULONGLONG
+// DWORD_PTR             ULONG_PTR
+// DWORD32               uint32
+// DWORD64               uint64
+// FLOAT                 float32
+// HACCEL                HANDLE
+// HALF_PTR              struct{} // ???
+// HANDLE                PVOID
+// HBITMAP               HANDLE
+// HBRUSH                HANDLE
+// HCOLORSPACE           HANDLE
+// HCONV                 HANDLE
+// HCONVLIST             HANDLE
+// HCURSOR               HANDLE
+// HDC                   HANDLE
+// HDDEDATA              HANDLE
+// HDESK                 HANDLE
+// HDROP                 HANDLE
+// HDWP                  HANDLE
+// HENHMETAFILE          HANDLE
+// HFILE                 HANDLE
+// HFONT                 HANDLE
+// HGDIOBJ               HANDLE
+// HGLOBAL               HANDLE
+// HHOOK                 HANDLE
+// HICON                 HANDLE
+// HINSTANCE             HANDLE
+// HKEY                  HANDLE
+// HKL                   HANDLE
+// HLOCAL                HANDLE
+// HMENU                 HANDLE
+// HMETAFILE             HANDLE
+// HMODULE               HANDLE
+// HPALETTE              HANDLE
+// HPEN                  HANDLE
+// HRESULT               int32
+// HRGN                  HANDLE
+// HSZ                   HANDLE
+// HWINSTA               HANDLE
+// HWND                  HANDLE
+// INT                   int32
+// INT_PTR               uintptr
+// INT8                  int8
+// INT16                 int16
+// INT32                 int32
+// INT64                 int64
+// LANGID                WORD
+// LCID                  DWORD
+// LCTYPE                DWORD
+// LGRPID                DWORD
+// LONG                  int32
+// LONGLONG              int64
+// LONG_PTR              uintptr
+// LONG32                int32
+// LONG64                int64
+// LPARAM                LONG_PTR
+// LPBOOL                *BOOL
+// LPBYTE                *BYTE
+// LPCOLORREF            *COLORREF
+// LPCSTR                *int8
+// LPCTSTR               LPCWSTR
+// LPCVOID               unsafe.Pointer
+// LPCWSTR               *WCHAR
+// LPDWORD               *DWORD
+// LPHANDLE              *HANDLE
+// LPINT                 *INT
+// LPLONG                *LONG
+// LPSTR                 *CHAR
+// LPTSTR                LPWSTR
+// LPVOID                unsafe.Pointer
+// LPWORD                *WORD
+// LPWSTR                *WCHAR
+// LRESULT               LONG_PTR
+// PBOOL                 *BOOL
+// PBOOLEAN              *BOOLEAN
+// PBYTE                 *BYTE
+// PCHAR                 *CHAR
+// PCSTR                 *CHAR
+// PCTSTR                PCWSTR
+// PCWSTR                *WCHAR
+// PDWORD                *DWORD
+// PDWORDLONG            *DWORDLONG
+// PDWORD_PTR            *DWORD_PTR
+// PDWORD32              *DWORD32
+// PDWORD64              *DWORD64
+// PFLOAT                *FLOAT
+// PHALF_PTR             *HALF_PTR
+// PHANDLE               *HANDLE
+// PHKEY                 *HKEY
+// PINT_PTR              *INT_PTR
+// PINT8                 *INT8
+// PINT16                *INT16
+// PINT32                *INT32
+// PINT64                *INT64
+// PLCID                 *LCID
+// PLONG                 *LONG
+// PLONGLONG             *LONGLONG
+// PLONG_PTR             *LONG_PTR
+// PLONG32               *LONG32
+// PLONG64               *LONG64
+// POINTER_32            struct{} // ???
+// POINTER_64            struct{} // ???
+// POINTER_SIGNED        uintptr
+// POINTER_UNSIGNED      uintptr
+// PSHORT                *SHORT
+// PSIZE_T               *SIZE_T
+// PSSIZE_T              *SSIZE_T
+// PSTR                  *CHAR
+// PTBYTE                *TBYTE
+// PTCHAR                *TCHAR
+// PTSTR                 PWSTR
+// PUCHAR                *UCHAR
+// PUHALF_PTR            *UHALF_PTR
+// PUINT                 *UINT
+// PUINT_PTR             *UINT_PTR
+// PUINT8                *UINT8
+// PUINT16               *UINT16
+// PUINT32               *UINT32
+// PUINT64               *UINT64
+// PULONG                *ULONG
+// PULONGLONG            *ULONGLONG
+// PULONG_PTR            *ULONG_PTR
+// PULONG32              *ULONG32
+// PULONG64              *ULONG64
+// PUSHORT               *USHORT
+// PVOID                 unsafe.Pointer
+// PWCHAR                *WCHAR
+// PWORD                 *WORD
+// PWSTR                 *WCHAR
+// QWORD                 uint64
+// SC_HANDLE             HANDLE
+// SC_LOCK               LPVOID
+// SERVICE_STATUS_HANDLE HANDLE
+// SHORT                 int16
+// SIZE_T                ULONG_PTR
+// SSIZE_T               LONG_PTR
+// TBYTE                 WCHAR
+// TCHAR                 WCHAR
+// UCHAR                 uint8
+// UHALF_PTR             struct{} // ???
+// UINT                  uint32
+// UINT_PTR              uintptr
+// UINT8                 uint8
+// UINT16                uint16
+// UINT32                uint32
+// UINT64                uint64
+// ULONG                 uint32
+// ULONGLONG             uint64
+// ULONG_PTR             uintptr
+// ULONG32               uint32
+// ULONG64               uint64
+// USHORT                uint16
+// USN                   LONGLONG
+// WCHAR                 uint16
+// WORD                  uint16
+// WPARAM                UINT_PTR
+type (
+	ATOM            uint16
+	BOOL            int32
+	COLORREF        uint32
+	DWM_FRAME_COUNT uint64
+	HACCEL          HANDLE
+	HANDLE          uintptr
+	HBITMAP         HANDLE
+	HBRUSH          HANDLE
+	HCURSOR         HANDLE
+	HDC             HANDLE
+	HDROP           HANDLE
+	HDWP            HANDLE
+	HENHMETAFILE    HANDLE
+	HFONT           HANDLE
+	HGDIOBJ         HANDLE
+	HGLOBAL         HANDLE
+	HGLRC           HANDLE
+	HICON           HANDLE
+	HIMAGELIST      HANDLE
+	HINSTANCE       HANDLE
+	HKEY            HANDLE
+	HKL             HANDLE
+	HMENU           HANDLE
+	HMODULE         HANDLE
+	HMONITOR        HANDLE
+	HPEN            HANDLE
+	HRESULT         int32
+	HRGN            HANDLE
+	HRSRC           HANDLE
+	HTHUMBNAIL      HANDLE
+	HWND            HANDLE
+	LPCVOID         unsafe.Pointer
+	PVOID           unsafe.Pointer
+	QPC_TIME        uint64
+)
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd162805.aspx
+type POINT struct {
+	X, Y int32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd162897.aspx
+type RECT struct {
+	Left, Top, Right, Bottom int32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms633577.aspx
+type WNDCLASSEX struct {
+	Size       uint32
+	Style      uint32
+	WndProc    uintptr
+	ClsExtra   int32
+	WndExtra   int32
+	Instance   HINSTANCE
+	Icon       HICON
+	Cursor     HCURSOR
+	Background HBRUSH
+	MenuName   *uint16
+	ClassName  *uint16
+	IconSm     HICON
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms644958.aspx
+type MSG struct {
+	Hwnd    HWND
+	Message uint32
+	WParam  uintptr
+	LParam  uintptr
+	Time    uint32
+	Pt      POINT
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd145037.aspx
+type LOGFONT struct {
+	Height         int32
+	Width          int32
+	Escapement     int32
+	Orientation    int32
+	Weight         int32
+	Italic         byte
+	Underline      byte
+	StrikeOut      byte
+	CharSet        byte
+	OutPrecision   byte
+	ClipPrecision  byte
+	Quality        byte
+	PitchAndFamily byte
+	FaceName       [LF_FACESIZE]uint16
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms646839.aspx
+type OPENFILENAME struct {
+	StructSize      uint32
+	Owner           HWND
+	Instance        HINSTANCE
+	Filter          *uint16
+	CustomFilter    *uint16
+	MaxCustomFilter uint32
+	FilterIndex     uint32
+	File            *uint16
+	MaxFile         uint32
+	FileTitle       *uint16
+	MaxFileTitle    uint32
+	InitialDir      *uint16
+	Title           *uint16
+	Flags           uint32
+	FileOffset      uint16
+	FileExtension   uint16
+	DefExt          *uint16
+	CustData        uintptr
+	FnHook          uintptr
+	TemplateName    *uint16
+	PvReserved      unsafe.Pointer
+	DwReserved      uint32
+	FlagsEx         uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb773205.aspx
+type BROWSEINFO struct {
+	Owner        HWND
+	Root         *uint16
+	DisplayName  *uint16
+	Title        *uint16
+	Flags        uint32
+	CallbackFunc uintptr
+	LParam       uintptr
+	Image        int32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa373931.aspx
+type GUID struct {
+	Data1 uint32
+	Data2 uint16
+	Data3 uint16
+	Data4 [8]byte
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms221627.aspx
+type VARIANT struct {
+	VT         uint16 //  2
+	WReserved1 uint16 //  4
+	WReserved2 uint16 //  6
+	WReserved3 uint16 //  8
+	Val        int64  // 16
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms221416.aspx
+type DISPPARAMS struct {
+	Rgvarg            uintptr
+	RgdispidNamedArgs uintptr
+	CArgs             uint32
+	CNamedArgs        uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms221133.aspx
+type EXCEPINFO struct {
+	WCode             uint16
+	WReserved         uint16
+	BstrSource        *uint16
+	BstrDescription   *uint16
+	BstrHelpFile      *uint16
+	DwHelpContext     uint32
+	PvReserved        uintptr
+	PfnDeferredFillIn uintptr
+	Scode             int32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd145035.aspx
+type LOGBRUSH struct {
+	LbStyle uint32
+	LbColor COLORREF
+	LbHatch uintptr
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd183565.aspx
+type DEVMODE struct {
+	DmDeviceName       [CCHDEVICENAME]uint16
+	DmSpecVersion      uint16
+	DmDriverVersion    uint16
+	DmSize             uint16
+	DmDriverExtra      uint16
+	DmFields           uint32
+	DmOrientation      int16
+	DmPaperSize        int16
+	DmPaperLength      int16
+	DmPaperWidth       int16
+	DmScale            int16
+	DmCopies           int16
+	DmDefaultSource    int16
+	DmPrintQuality     int16
+	DmColor            int16
+	DmDuplex           int16
+	DmYResolution      int16
+	DmTTOption         int16
+	DmCollate          int16
+	DmFormName         [CCHFORMNAME]uint16
+	DmLogPixels        uint16
+	DmBitsPerPel       uint32
+	DmPelsWidth        uint32
+	DmPelsHeight       uint32
+	DmDisplayFlags     uint32
+	DmDisplayFrequency uint32
+	DmICMMethod        uint32
+	DmICMIntent        uint32
+	DmMediaType        uint32
+	DmDitherType       uint32
+	DmReserved1        uint32
+	DmReserved2        uint32
+	DmPanningWidth     uint32
+	DmPanningHeight    uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd183376.aspx
+type BITMAPINFOHEADER struct {
+	BiSize          uint32
+	BiWidth         int32
+	BiHeight        int32
+	BiPlanes        uint16
+	BiBitCount      uint16
+	BiCompression   uint32
+	BiSizeImage     uint32
+	BiXPelsPerMeter int32
+	BiYPelsPerMeter int32
+	BiClrUsed       uint32
+	BiClrImportant  uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd162938.aspx
+type RGBQUAD struct {
+	RgbBlue     byte
+	RgbGreen    byte
+	RgbRed      byte
+	RgbReserved byte
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd183375.aspx
+type BITMAPINFO struct {
+	BmiHeader BITMAPINFOHEADER
+	BmiColors *RGBQUAD
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd183371.aspx
+type BITMAP struct {
+	BmType       int32
+	BmWidth      int32
+	BmHeight     int32
+	BmWidthBytes int32
+	BmPlanes     uint16
+	BmBitsPixel  uint16
+	BmBits       unsafe.Pointer
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd183567.aspx
+type DIBSECTION struct {
+	DsBm        BITMAP
+	DsBmih      BITMAPINFOHEADER
+	DsBitfields [3]uint32
+	DshSection  HANDLE
+	DsOffset    uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd162607.aspx
+type ENHMETAHEADER struct {
+	IType          uint32
+	NSize          uint32
+	RclBounds      RECT
+	RclFrame       RECT
+	DSignature     uint32
+	NVersion       uint32
+	NBytes         uint32
+	NRecords       uint32
+	NHandles       uint16
+	SReserved      uint16
+	NDescription   uint32
+	OffDescription uint32
+	NPalEntries    uint32
+	SzlDevice      SIZE
+	SzlMillimeters SIZE
+	CbPixelFormat  uint32
+	OffPixelFormat uint32
+	BOpenGL        uint32
+	SzlMicrometers SIZE
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd145106.aspx
+type SIZE struct {
+	CX, CY int32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd145132.aspx
+type TEXTMETRIC struct {
+	TmHeight           int32
+	TmAscent           int32
+	TmDescent          int32
+	TmInternalLeading  int32
+	TmExternalLeading  int32
+	TmAveCharWidth     int32
+	TmMaxCharWidth     int32
+	TmWeight           int32
+	TmOverhang         int32
+	TmDigitizedAspectX int32
+	TmDigitizedAspectY int32
+	TmFirstChar        uint16
+	TmLastChar         uint16
+	TmDefaultChar      uint16
+	TmBreakChar        uint16
+	TmItalic           byte
+	TmUnderlined       byte
+	TmStruckOut        byte
+	TmPitchAndFamily   byte
+	TmCharSet          byte
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd183574.aspx
+type DOCINFO struct {
+	CbSize       int32
+	LpszDocName  *uint16
+	LpszOutput   *uint16
+	LpszDatatype *uint16
+	FwType       uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb775514.aspx
+type NMHDR struct {
+	HwndFrom HWND
+	IdFrom   uintptr
+	Code     uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb774743.aspx
+type LVCOLUMN struct {
+	Mask       uint32
+	Fmt        int32
+	Cx         int32
+	PszText    *uint16
+	CchTextMax int32
+	ISubItem   int32
+	IImage     int32
+	IOrder     int32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb774760.aspx
+type LVITEM struct {
+	Mask       uint32
+	IItem      int32
+	ISubItem   int32
+	State      uint32
+	StateMask  uint32
+	PszText    *uint16
+	CchTextMax int32
+	IImage     int32
+	LParam     uintptr
+	IIndent    int32
+	IGroupId   int32
+	CColumns   uint32
+	PuColumns  uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb774754.aspx
+type LVHITTESTINFO struct {
+	Pt       POINT
+	Flags    uint32
+	IItem    int32
+	ISubItem int32
+	IGroup   int32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb774771.aspx
+type NMITEMACTIVATE struct {
+	Hdr       NMHDR
+	IItem     int32
+	ISubItem  int32
+	UNewState uint32
+	UOldState uint32
+	UChanged  uint32
+	PtAction  POINT
+	LParam    uintptr
+	UKeyFlags uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb774773.aspx
+type NMLISTVIEW struct {
+	Hdr       NMHDR
+	IItem     int32
+	ISubItem  int32
+	UNewState uint32
+	UOldState uint32
+	UChanged  uint32
+	PtAction  POINT
+	LParam    uintptr
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb774780.aspx
+type NMLVDISPINFO struct {
+	Hdr  NMHDR
+	Item LVITEM
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb775507.aspx
+type INITCOMMONCONTROLSEX struct {
+	DwSize uint32
+	DwICC  uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb760256.aspx
+type TOOLINFO struct {
+	CbSize     uint32
+	UFlags     uint32
+	Hwnd       HWND
+	UId        uintptr
+	Rect       RECT
+	Hinst      HINSTANCE
+	LpszText   *uint16
+	LParam     uintptr
+	LpReserved unsafe.Pointer
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms645604.aspx
+type TRACKMOUSEEVENT struct {
+	CbSize      uint32
+	DwFlags     uint32
+	HwndTrack   HWND
+	DwHoverTime uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms534067.aspx
+type GdiplusStartupInput struct {
+	GdiplusVersion           uint32
+	DebugEventCallback       uintptr
+	SuppressBackgroundThread BOOL
+	SuppressExternalCodecs   BOOL
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms534068.aspx
+type GdiplusStartupOutput struct {
+	NotificationHook   uintptr
+	NotificationUnhook uintptr
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd162768.aspx
+type PAINTSTRUCT struct {
+	Hdc         HDC
+	FErase      BOOL
+	RcPaint     RECT
+	FRestore    BOOL
+	FIncUpdate  BOOL
+	RgbReserved [32]byte
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa363646.aspx
+type EVENTLOGRECORD struct {
+	Length              uint32
+	Reserved            uint32
+	RecordNumber        uint32
+	TimeGenerated       uint32
+	TimeWritten         uint32
+	EventID             uint32
+	EventType           uint16
+	NumStrings          uint16
+	EventCategory       uint16
+	ReservedFlags       uint16
+	ClosingRecordNumber uint32
+	StringOffset        uint32
+	UserSidLength       uint32
+	UserSidOffset       uint32
+	DataLength          uint32
+	DataOffset          uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms685996.aspx
+type SERVICE_STATUS struct {
+	DwServiceType             uint32
+	DwCurrentState            uint32
+	DwControlsAccepted        uint32
+	DwWin32ExitCode           uint32
+	DwServiceSpecificExitCode uint32
+	DwCheckPoint              uint32
+	DwWaitHint                uint32
+}
+type PROCESSENTRY32 struct {
+	DwSize              uint32
+	CntUsage            uint32
+	Th32ProcessID       uint32
+	Th32DefaultHeapID   uintptr
+	Th32ModuleID        uint32
+	CntThreads          uint32
+	Th32ParentProcessID uint32
+	PcPriClassBase      int32
+	DwFlags             uint32
+	SzExeFile           [MAX_PATH]uint16
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms684225.aspx
+type MODULEENTRY32 struct {
+	Size         uint32
+	ModuleID     uint32
+	ProcessID    uint32
+	GlblcntUsage uint32
+	ProccntUsage uint32
+	ModBaseAddr  *uint8
+	ModBaseSize  uint32
+	HModule      HMODULE
+	SzModule     [MAX_MODULE_NAME32 + 1]uint16
+	SzExePath    [MAX_PATH]uint16
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms724284.aspx
+type FILETIME struct {
+	DwLowDateTime  uint32
+	DwHighDateTime uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms682119.aspx
+type COORD struct {
+	X, Y int16
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms686311.aspx
+type SMALL_RECT struct {
+	Left, Top, Right, Bottom int16
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms682093.aspx
+type CONSOLE_SCREEN_BUFFER_INFO struct {
+	DwSize              COORD
+	DwCursorPosition    COORD
+	WAttributes         uint16
+	SrWindow            SMALL_RECT
+	DwMaximumWindowSize COORD
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/bb773244.aspx
+type MARGINS struct {
+	CxLeftWidth, CxRightWidth, CyTopHeight, CyBottomHeight int32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa969500.aspx
+type DWM_BLURBEHIND struct {
+	DwFlags                uint32
+	fEnable                BOOL
+	hRgnBlur               HRGN
+	fTransitionOnMaximized BOOL
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa969501.aspx
+type DWM_PRESENT_PARAMETERS struct {
+	cbSize             uint32
+	fQueue             BOOL
+	cRefreshStart      DWM_FRAME_COUNT
+	cBuffer            uint32
+	fUseSourceRate     BOOL
+	rateSource         UNSIGNED_RATIO
+	cRefreshesPerFrame uint32
+	eSampling          DWM_SOURCE_FRAME_SAMPLING
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa969502.aspx
+type DWM_THUMBNAIL_PROPERTIES struct {
+	dwFlags               uint32
+	rcDestination         RECT
+	rcSource              RECT
+	opacity               byte
+	fVisible              BOOL
+	fSourceClientAreaOnly BOOL
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa969503.aspx
+type DWM_TIMING_INFO struct {
+	cbSize                 uint32
+	rateRefresh            UNSIGNED_RATIO
+	qpcRefreshPeriod       QPC_TIME
+	rateCompose            UNSIGNED_RATIO
+	qpcVBlank              QPC_TIME
+	cRefresh               DWM_FRAME_COUNT
+	cDXRefresh             uint32
+	qpcCompose             QPC_TIME
+	cFrame                 DWM_FRAME_COUNT
+	cDXPresent             uint32
+	cRefreshFrame          DWM_FRAME_COUNT
+	cFrameSubmitted        DWM_FRAME_COUNT
+	cDXPresentSubmitted    uint32
+	cFrameConfirmed        DWM_FRAME_COUNT
+	cDXPresentConfirmed    uint32
+	cRefreshConfirmed      DWM_FRAME_COUNT
+	cDXRefreshConfirmed    uint32
+	cFramesLate            DWM_FRAME_COUNT
+	cFramesOutstanding     uint32
+	cFrameDisplayed        DWM_FRAME_COUNT
+	qpcFrameDisplayed      QPC_TIME
+	cRefreshFrameDisplayed DWM_FRAME_COUNT
+	cFrameComplete         DWM_FRAME_COUNT
+	qpcFrameComplete       QPC_TIME
+	cFramePending          DWM_FRAME_COUNT
+	qpcFramePending        QPC_TIME
+	cFramesDisplayed       DWM_FRAME_COUNT
+	cFramesComplete        DWM_FRAME_COUNT
+	cFramesPending         DWM_FRAME_COUNT
+	cFramesAvailable       DWM_FRAME_COUNT
+	cFramesDropped         DWM_FRAME_COUNT
+	cFramesMissed          DWM_FRAME_COUNT
+	cRefreshNextDisplayed  DWM_FRAME_COUNT
+	cRefreshNextPresented  DWM_FRAME_COUNT
+	cRefreshesDisplayed    DWM_FRAME_COUNT
+	cRefreshesPresented    DWM_FRAME_COUNT
+	cRefreshStarted        DWM_FRAME_COUNT
+	cPixelsReceived        uint64
+	cPixelsDrawn           uint64
+	cBuffersEmpty          DWM_FRAME_COUNT
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd389402.aspx
+type MilMatrix3x2D struct {
+	S_11, S_12, S_21, S_22 float64
+	DX, DY                 float64
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/aa969505.aspx
+type UNSIGNED_RATIO struct {
+	uiNumerator   uint32
+	uiDenominator uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms632603.aspx
+type CREATESTRUCT struct {
+	CreateParams uintptr
+	Instance     HINSTANCE
+	Menu         HMENU
+	Parent       HWND
+	Cy, Cx       int32
+	Y, X         int32
+	Style        int32
+	Name         *uint16
+	Class        *uint16
+	dwExStyle    uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd145065.aspx
+type MONITORINFO struct {
+	CbSize    uint32
+	RcMonitor RECT
+	RcWork    RECT
+	DwFlags   uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd145066.aspx
+type MONITORINFOEX struct {
+	MONITORINFO
+	SzDevice [CCHDEVICENAME]uint16
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/dd368826.aspx
+type PIXELFORMATDESCRIPTOR struct {
+	Size                   uint16
+	Version                uint16
+	DwFlags                uint32
+	IPixelType             byte
+	ColorBits              byte
+	RedBits, RedShift      byte
+	GreenBits, GreenShift  byte
+	BlueBits, BlueShift    byte
+	AlphaBits, AlphaShift  byte
+	AccumBits              byte
+	AccumRedBits           byte
+	AccumGreenBits         byte
+	AccumBlueBits          byte
+	AccumAlphaBits         byte
+	DepthBits, StencilBits byte
+	AuxBuffers             byte
+	ILayerType             byte
+	Reserved               byte
+	DwLayerMask            uint32
+	DwVisibleMask          uint32
+	DwDamageMask           uint32
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms646270(v=vs.85).aspx
+type INPUT struct {
+	Type uint32
+	Mi   MOUSEINPUT
+	Ki   KEYBDINPUT
+	Hi   HARDWAREINPUT
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms646273(v=vs.85).aspx
+type MOUSEINPUT struct {
+	Dx          int32
+	Dy          int32
+	MouseData   uint32
+	DwFlags     uint32
+	Time        uint32
+	DwExtraInfo uintptr
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms646271(v=vs.85).aspx
+type KEYBDINPUT struct {
+	WVk         uint16
+	WScan       uint16
+	DwFlags     uint32
+	Time        uint32
+	DwExtraInfo uintptr
+}
+
+// http://msdn.microsoft.com/en-us/library/windows/desktop/ms646269(v=vs.85).aspx
+type HARDWAREINPUT struct {
+	UMsg    uint32
+	WParamL uint16
+	WParamH uint16
+}
+
+type KbdInput struct {
+	typ uint32
+	ki  KEYBDINPUT
+}
+
+type MouseInput struct {
+	typ uint32
+	mi  MOUSEINPUT
+}
+
+type HardwareInput struct {
+	typ uint32
+	hi  HARDWAREINPUT
+}

vendor/github.com/shirou/w32/user32.go

@@ -0,0 +1,950 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+var (
+	moduser32 = syscall.NewLazyDLL("user32.dll")
+
+	procRegisterClassEx               = moduser32.NewProc("RegisterClassExW")
+	procLoadIcon                      = moduser32.NewProc("LoadIconW")
+	procLoadCursor                    = moduser32.NewProc("LoadCursorW")
+	procShowWindow                    = moduser32.NewProc("ShowWindow")
+	procUpdateWindow                  = moduser32.NewProc("UpdateWindow")
+	procCreateWindowEx                = moduser32.NewProc("CreateWindowExW")
+	procAdjustWindowRect              = moduser32.NewProc("AdjustWindowRect")
+	procAdjustWindowRectEx            = moduser32.NewProc("AdjustWindowRectEx")
+	procDestroyWindow                 = moduser32.NewProc("DestroyWindow")
+	procDefWindowProc                 = moduser32.NewProc("DefWindowProcW")
+	procDefDlgProc                    = moduser32.NewProc("DefDlgProcW")
+	procPostQuitMessage               = moduser32.NewProc("PostQuitMessage")
+	procGetMessage                    = moduser32.NewProc("GetMessageW")
+	procTranslateMessage              = moduser32.NewProc("TranslateMessage")
+	procDispatchMessage               = moduser32.NewProc("DispatchMessageW")
+	procSendMessage                   = moduser32.NewProc("SendMessageW")
+	procPostMessage                   = moduser32.NewProc("PostMessageW")
+	procWaitMessage                   = moduser32.NewProc("WaitMessage")
+	procSetWindowText                 = moduser32.NewProc("SetWindowTextW")
+	procGetWindowTextLength           = moduser32.NewProc("GetWindowTextLengthW")
+	procGetWindowText                 = moduser32.NewProc("GetWindowTextW")
+	procGetWindowRect                 = moduser32.NewProc("GetWindowRect")
+	procMoveWindow                    = moduser32.NewProc("MoveWindow")
+	procScreenToClient                = moduser32.NewProc("ScreenToClient")
+	procCallWindowProc                = moduser32.NewProc("CallWindowProcW")
+	procSetWindowLong                 = moduser32.NewProc("SetWindowLongW")
+	procSetWindowLongPtr              = moduser32.NewProc("SetWindowLongW")
+	procGetWindowLong                 = moduser32.NewProc("GetWindowLongW")
+	procGetWindowLongPtr              = moduser32.NewProc("GetWindowLongW")
+	procEnableWindow                  = moduser32.NewProc("EnableWindow")
+	procIsWindowEnabled               = moduser32.NewProc("IsWindowEnabled")
+	procIsWindowVisible               = moduser32.NewProc("IsWindowVisible")
+	procSetFocus                      = moduser32.NewProc("SetFocus")
+	procInvalidateRect                = moduser32.NewProc("InvalidateRect")
+	procGetClientRect                 = moduser32.NewProc("GetClientRect")
+	procGetDC                         = moduser32.NewProc("GetDC")
+	procReleaseDC                     = moduser32.NewProc("ReleaseDC")
+	procSetCapture                    = moduser32.NewProc("SetCapture")
+	procReleaseCapture                = moduser32.NewProc("ReleaseCapture")
+	procGetWindowThreadProcessId      = moduser32.NewProc("GetWindowThreadProcessId")
+	procMessageBox                    = moduser32.NewProc("MessageBoxW")
+	procGetSystemMetrics              = moduser32.NewProc("GetSystemMetrics")
+	procCopyRect                      = moduser32.NewProc("CopyRect")
+	procEqualRect                     = moduser32.NewProc("EqualRect")
+	procInflateRect                   = moduser32.NewProc("InflateRect")
+	procIntersectRect                 = moduser32.NewProc("IntersectRect")
+	procIsRectEmpty                   = moduser32.NewProc("IsRectEmpty")
+	procOffsetRect                    = moduser32.NewProc("OffsetRect")
+	procPtInRect                      = moduser32.NewProc("PtInRect")
+	procSetRect                       = moduser32.NewProc("SetRect")
+	procSetRectEmpty                  = moduser32.NewProc("SetRectEmpty")
+	procSubtractRect                  = moduser32.NewProc("SubtractRect")
+	procUnionRect                     = moduser32.NewProc("UnionRect")
+	procCreateDialogParam             = moduser32.NewProc("CreateDialogParamW")
+	procDialogBoxParam                = moduser32.NewProc("DialogBoxParamW")
+	procGetDlgItem                    = moduser32.NewProc("GetDlgItem")
+	procDrawIcon                      = moduser32.NewProc("DrawIcon")
+	procClientToScreen                = moduser32.NewProc("ClientToScreen")
+	procIsDialogMessage               = moduser32.NewProc("IsDialogMessageW")
+	procIsWindow                      = moduser32.NewProc("IsWindow")
+	procEndDialog                     = moduser32.NewProc("EndDialog")
+	procPeekMessage                   = moduser32.NewProc("PeekMessageW")
+	procTranslateAccelerator          = moduser32.NewProc("TranslateAcceleratorW")
+	procSetWindowPos                  = moduser32.NewProc("SetWindowPos")
+	procFillRect                      = moduser32.NewProc("FillRect")
+	procDrawText                      = moduser32.NewProc("DrawTextW")
+	procAddClipboardFormatListener    = moduser32.NewProc("AddClipboardFormatListener")
+	procRemoveClipboardFormatListener = moduser32.NewProc("RemoveClipboardFormatListener")
+	procOpenClipboard                 = moduser32.NewProc("OpenClipboard")
+	procCloseClipboard                = moduser32.NewProc("CloseClipboard")
+	procEnumClipboardFormats          = moduser32.NewProc("EnumClipboardFormats")
+	procGetClipboardData              = moduser32.NewProc("GetClipboardData")
+	procSetClipboardData              = moduser32.NewProc("SetClipboardData")
+	procEmptyClipboard                = moduser32.NewProc("EmptyClipboard")
+	procGetClipboardFormatName        = moduser32.NewProc("GetClipboardFormatNameW")
+	procIsClipboardFormatAvailable    = moduser32.NewProc("IsClipboardFormatAvailable")
+	procBeginPaint                    = moduser32.NewProc("BeginPaint")
+	procEndPaint                      = moduser32.NewProc("EndPaint")
+	procGetKeyboardState              = moduser32.NewProc("GetKeyboardState")
+	procMapVirtualKey                 = moduser32.NewProc("MapVirtualKeyExW")
+	procGetAsyncKeyState              = moduser32.NewProc("GetAsyncKeyState")
+	procToAscii                       = moduser32.NewProc("ToAscii")
+	procSwapMouseButton               = moduser32.NewProc("SwapMouseButton")
+	procGetCursorPos                  = moduser32.NewProc("GetCursorPos")
+	procSetCursorPos                  = moduser32.NewProc("SetCursorPos")
+	procSetCursor                     = moduser32.NewProc("SetCursor")
+	procCreateIcon                    = moduser32.NewProc("CreateIcon")
+	procDestroyIcon                   = moduser32.NewProc("DestroyIcon")
+	procMonitorFromPoint              = moduser32.NewProc("MonitorFromPoint")
+	procMonitorFromRect               = moduser32.NewProc("MonitorFromRect")
+	procMonitorFromWindow             = moduser32.NewProc("MonitorFromWindow")
+	procGetMonitorInfo                = moduser32.NewProc("GetMonitorInfoW")
+	procEnumDisplayMonitors           = moduser32.NewProc("EnumDisplayMonitors")
+	procEnumDisplaySettingsEx         = moduser32.NewProc("EnumDisplaySettingsExW")
+	procChangeDisplaySettingsEx       = moduser32.NewProc("ChangeDisplaySettingsExW")
+	procSendInput                     = moduser32.NewProc("SendInput")
+)
+
+func RegisterClassEx(wndClassEx *WNDCLASSEX) ATOM {
+	ret, _, _ := procRegisterClassEx.Call(uintptr(unsafe.Pointer(wndClassEx)))
+	return ATOM(ret)
+}
+
+func LoadIcon(instance HINSTANCE, iconName *uint16) HICON {
+	ret, _, _ := procLoadIcon.Call(
+		uintptr(instance),
+		uintptr(unsafe.Pointer(iconName)))
+
+	return HICON(ret)
+
+}
+
+func LoadCursor(instance HINSTANCE, cursorName *uint16) HCURSOR {
+	ret, _, _ := procLoadCursor.Call(
+		uintptr(instance),
+		uintptr(unsafe.Pointer(cursorName)))
+
+	return HCURSOR(ret)
+
+}
+
+func ShowWindow(hwnd HWND, cmdshow int) bool {
+	ret, _, _ := procShowWindow.Call(
+		uintptr(hwnd),
+		uintptr(cmdshow))
+
+	return ret != 0
+
+}
+
+func UpdateWindow(hwnd HWND) bool {
+	ret, _, _ := procUpdateWindow.Call(
+		uintptr(hwnd))
+	return ret != 0
+}
+
+func CreateWindowEx(exStyle uint, className, windowName *uint16,
+	style uint, x, y, width, height int, parent HWND, menu HMENU,
+	instance HINSTANCE, param unsafe.Pointer) HWND {
+	ret, _, _ := procCreateWindowEx.Call(
+		uintptr(exStyle),
+		uintptr(unsafe.Pointer(className)),
+		uintptr(unsafe.Pointer(windowName)),
+		uintptr(style),
+		uintptr(x),
+		uintptr(y),
+		uintptr(width),
+		uintptr(height),
+		uintptr(parent),
+		uintptr(menu),
+		uintptr(instance),
+		uintptr(param))
+
+	return HWND(ret)
+}
+
+func AdjustWindowRectEx(rect *RECT, style uint, menu bool, exStyle uint) bool {
+	ret, _, _ := procAdjustWindowRectEx.Call(
+		uintptr(unsafe.Pointer(rect)),
+		uintptr(style),
+		uintptr(BoolToBOOL(menu)),
+		uintptr(exStyle))
+
+	return ret != 0
+}
+
+func AdjustWindowRect(rect *RECT, style uint, menu bool) bool {
+	ret, _, _ := procAdjustWindowRect.Call(
+		uintptr(unsafe.Pointer(rect)),
+		uintptr(style),
+		uintptr(BoolToBOOL(menu)))
+
+	return ret != 0
+}
+
+func DestroyWindow(hwnd HWND) bool {
+	ret, _, _ := procDestroyWindow.Call(
+		uintptr(hwnd))
+
+	return ret != 0
+}
+
+func DefWindowProc(hwnd HWND, msg uint32, wParam, lParam uintptr) uintptr {
+	ret, _, _ := procDefWindowProc.Call(
+		uintptr(hwnd),
+		uintptr(msg),
+		wParam,
+		lParam)
+
+	return ret
+}
+
+func DefDlgProc(hwnd HWND, msg uint32, wParam, lParam uintptr) uintptr {
+	ret, _, _ := procDefDlgProc.Call(
+		uintptr(hwnd),
+		uintptr(msg),
+		wParam,
+		lParam)
+
+	return ret
+}
+
+func PostQuitMessage(exitCode int) {
+	procPostQuitMessage.Call(
+		uintptr(exitCode))
+}
+
+func GetMessage(msg *MSG, hwnd HWND, msgFilterMin, msgFilterMax uint32) int {
+	ret, _, _ := procGetMessage.Call(
+		uintptr(unsafe.Pointer(msg)),
+		uintptr(hwnd),
+		uintptr(msgFilterMin),
+		uintptr(msgFilterMax))
+
+	return int(ret)
+}
+
+func TranslateMessage(msg *MSG) bool {
+	ret, _, _ := procTranslateMessage.Call(
+		uintptr(unsafe.Pointer(msg)))
+
+	return ret != 0
+
+}
+
+func DispatchMessage(msg *MSG) uintptr {
+	ret, _, _ := procDispatchMessage.Call(
+		uintptr(unsafe.Pointer(msg)))
+
+	return ret
+
+}
+
+func SendMessage(hwnd HWND, msg uint32, wParam, lParam uintptr) uintptr {
+	ret, _, _ := procSendMessage.Call(
+		uintptr(hwnd),
+		uintptr(msg),
+		wParam,
+		lParam)
+
+	return ret
+}
+
+func PostMessage(hwnd HWND, msg uint32, wParam, lParam uintptr) bool {
+	ret, _, _ := procPostMessage.Call(
+		uintptr(hwnd),
+		uintptr(msg),
+		wParam,
+		lParam)
+
+	return ret != 0
+}
+
+func WaitMessage() bool {
+	ret, _, _ := procWaitMessage.Call()
+	return ret != 0
+}
+
+func SetWindowText(hwnd HWND, text string) {
+	procSetWindowText.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(text))))
+}
+
+func GetWindowTextLength(hwnd HWND) int {
+	ret, _, _ := procGetWindowTextLength.Call(
+		uintptr(hwnd))
+
+	return int(ret)
+}
+
+func GetWindowText(hwnd HWND) string {
+	textLen := GetWindowTextLength(hwnd) + 1
+
+	buf := make([]uint16, textLen)
+	procGetWindowText.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(textLen))
+
+	return syscall.UTF16ToString(buf)
+}
+
+func GetWindowRect(hwnd HWND) *RECT {
+	var rect RECT
+	procGetWindowRect.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(&rect)))
+
+	return &rect
+}
+
+func MoveWindow(hwnd HWND, x, y, width, height int, repaint bool) bool {
+	ret, _, _ := procMoveWindow.Call(
+		uintptr(hwnd),
+		uintptr(x),
+		uintptr(y),
+		uintptr(width),
+		uintptr(height),
+		uintptr(BoolToBOOL(repaint)))
+
+	return ret != 0
+
+}
+
+func ScreenToClient(hwnd HWND, x, y int) (X, Y int, ok bool) {
+	pt := POINT{X: int32(x), Y: int32(y)}
+	ret, _, _ := procScreenToClient.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(&pt)))
+
+	return int(pt.X), int(pt.Y), ret != 0
+}
+
+func CallWindowProc(preWndProc uintptr, hwnd HWND, msg uint32, wParam, lParam uintptr) uintptr {
+	ret, _, _ := procCallWindowProc.Call(
+		preWndProc,
+		uintptr(hwnd),
+		uintptr(msg),
+		wParam,
+		lParam)
+
+	return ret
+}
+
+func SetWindowLong(hwnd HWND, index int, value uint32) uint32 {
+	ret, _, _ := procSetWindowLong.Call(
+		uintptr(hwnd),
+		uintptr(index),
+		uintptr(value))
+
+	return uint32(ret)
+}
+
+func SetWindowLongPtr(hwnd HWND, index int, value uintptr) uintptr {
+	ret, _, _ := procSetWindowLongPtr.Call(
+		uintptr(hwnd),
+		uintptr(index),
+		value)
+
+	return ret
+}
+
+func GetWindowLong(hwnd HWND, index int) int32 {
+	ret, _, _ := procGetWindowLong.Call(
+		uintptr(hwnd),
+		uintptr(index))
+
+	return int32(ret)
+}
+
+func GetWindowLongPtr(hwnd HWND, index int) uintptr {
+	ret, _, _ := procGetWindowLongPtr.Call(
+		uintptr(hwnd),
+		uintptr(index))
+
+	return ret
+}
+
+func EnableWindow(hwnd HWND, b bool) bool {
+	ret, _, _ := procEnableWindow.Call(
+		uintptr(hwnd),
+		uintptr(BoolToBOOL(b)))
+	return ret != 0
+}
+
+func IsWindowEnabled(hwnd HWND) bool {
+	ret, _, _ := procIsWindowEnabled.Call(
+		uintptr(hwnd))
+
+	return ret != 0
+}
+
+func IsWindowVisible(hwnd HWND) bool {
+	ret, _, _ := procIsWindowVisible.Call(
+		uintptr(hwnd))
+
+	return ret != 0
+}
+
+func SetFocus(hwnd HWND) HWND {
+	ret, _, _ := procSetFocus.Call(
+		uintptr(hwnd))
+
+	return HWND(ret)
+}
+
+func InvalidateRect(hwnd HWND, rect *RECT, erase bool) bool {
+	ret, _, _ := procInvalidateRect.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(rect)),
+		uintptr(BoolToBOOL(erase)))
+
+	return ret != 0
+}
+
+func GetClientRect(hwnd HWND) *RECT {
+	var rect RECT
+	ret, _, _ := procGetClientRect.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(&rect)))
+
+	if ret == 0 {
+		panic(fmt.Sprintf("GetClientRect(%d) failed", hwnd))
+	}
+
+	return &rect
+}
+
+func GetDC(hwnd HWND) HDC {
+	ret, _, _ := procGetDC.Call(
+		uintptr(hwnd))
+
+	return HDC(ret)
+}
+
+func ReleaseDC(hwnd HWND, hDC HDC) bool {
+	ret, _, _ := procReleaseDC.Call(
+		uintptr(hwnd),
+		uintptr(hDC))
+
+	return ret != 0
+}
+
+func SetCapture(hwnd HWND) HWND {
+	ret, _, _ := procSetCapture.Call(
+		uintptr(hwnd))
+
+	return HWND(ret)
+}
+
+func ReleaseCapture() bool {
+	ret, _, _ := procReleaseCapture.Call()
+
+	return ret != 0
+}
+
+func GetWindowThreadProcessId(hwnd HWND) (HANDLE, int) {
+	var processId int
+	ret, _, _ := procGetWindowThreadProcessId.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(&processId)))
+
+	return HANDLE(ret), processId
+}
+
+func MessageBox(hwnd HWND, title, caption string, flags uint) int {
+	ret, _, _ := procMessageBox.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(title))),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(caption))),
+		uintptr(flags))
+
+	return int(ret)
+}
+
+func GetSystemMetrics(index int) int {
+	ret, _, _ := procGetSystemMetrics.Call(
+		uintptr(index))
+
+	return int(ret)
+}
+
+func CopyRect(dst, src *RECT) bool {
+	ret, _, _ := procCopyRect.Call(
+		uintptr(unsafe.Pointer(dst)),
+		uintptr(unsafe.Pointer(src)))
+
+	return ret != 0
+}
+
+func EqualRect(rect1, rect2 *RECT) bool {
+	ret, _, _ := procEqualRect.Call(
+		uintptr(unsafe.Pointer(rect1)),
+		uintptr(unsafe.Pointer(rect2)))
+
+	return ret != 0
+}
+
+func InflateRect(rect *RECT, dx, dy int) bool {
+	ret, _, _ := procInflateRect.Call(
+		uintptr(unsafe.Pointer(rect)),
+		uintptr(dx),
+		uintptr(dy))
+
+	return ret != 0
+}
+
+func IntersectRect(dst, src1, src2 *RECT) bool {
+	ret, _, _ := procIntersectRect.Call(
+		uintptr(unsafe.Pointer(dst)),
+		uintptr(unsafe.Pointer(src1)),
+		uintptr(unsafe.Pointer(src2)))
+
+	return ret != 0
+}
+
+func IsRectEmpty(rect *RECT) bool {
+	ret, _, _ := procIsRectEmpty.Call(
+		uintptr(unsafe.Pointer(rect)))
+
+	return ret != 0
+}
+
+func OffsetRect(rect *RECT, dx, dy int) bool {
+	ret, _, _ := procOffsetRect.Call(
+		uintptr(unsafe.Pointer(rect)),
+		uintptr(dx),
+		uintptr(dy))
+
+	return ret != 0
+}
+
+func PtInRect(rect *RECT, x, y int) bool {
+	pt := POINT{X: int32(x), Y: int32(y)}
+	ret, _, _ := procPtInRect.Call(
+		uintptr(unsafe.Pointer(rect)),
+		uintptr(unsafe.Pointer(&pt)))
+
+	return ret != 0
+}
+
+func SetRect(rect *RECT, left, top, right, bottom int) bool {
+	ret, _, _ := procSetRect.Call(
+		uintptr(unsafe.Pointer(rect)),
+		uintptr(left),
+		uintptr(top),
+		uintptr(right),
+		uintptr(bottom))
+
+	return ret != 0
+}
+
+func SetRectEmpty(rect *RECT) bool {
+	ret, _, _ := procSetRectEmpty.Call(
+		uintptr(unsafe.Pointer(rect)))
+
+	return ret != 0
+}
+
+func SubtractRect(dst, src1, src2 *RECT) bool {
+	ret, _, _ := procSubtractRect.Call(
+		uintptr(unsafe.Pointer(dst)),
+		uintptr(unsafe.Pointer(src1)),
+		uintptr(unsafe.Pointer(src2)))
+
+	return ret != 0
+}
+
+func UnionRect(dst, src1, src2 *RECT) bool {
+	ret, _, _ := procUnionRect.Call(
+		uintptr(unsafe.Pointer(dst)),
+		uintptr(unsafe.Pointer(src1)),
+		uintptr(unsafe.Pointer(src2)))
+
+	return ret != 0
+}
+
+func CreateDialog(hInstance HINSTANCE, lpTemplate *uint16, hWndParent HWND, lpDialogProc uintptr) HWND {
+	ret, _, _ := procCreateDialogParam.Call(
+		uintptr(hInstance),
+		uintptr(unsafe.Pointer(lpTemplate)),
+		uintptr(hWndParent),
+		lpDialogProc,
+		0)
+
+	return HWND(ret)
+}
+
+func DialogBox(hInstance HINSTANCE, lpTemplateName *uint16, hWndParent HWND, lpDialogProc uintptr) int {
+	ret, _, _ := procDialogBoxParam.Call(
+		uintptr(hInstance),
+		uintptr(unsafe.Pointer(lpTemplateName)),
+		uintptr(hWndParent),
+		lpDialogProc,
+		0)
+
+	return int(ret)
+}
+
+func GetDlgItem(hDlg HWND, nIDDlgItem int) HWND {
+	ret, _, _ := procGetDlgItem.Call(
+		uintptr(unsafe.Pointer(hDlg)),
+		uintptr(nIDDlgItem))
+
+	return HWND(ret)
+}
+
+func DrawIcon(hDC HDC, x, y int, hIcon HICON) bool {
+	ret, _, _ := procDrawIcon.Call(
+		uintptr(unsafe.Pointer(hDC)),
+		uintptr(x),
+		uintptr(y),
+		uintptr(unsafe.Pointer(hIcon)))
+
+	return ret != 0
+}
+
+func ClientToScreen(hwnd HWND, x, y int) (int, int) {
+	pt := POINT{X: int32(x), Y: int32(y)}
+
+	procClientToScreen.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(&pt)))
+
+	return int(pt.X), int(pt.Y)
+}
+
+func IsDialogMessage(hwnd HWND, msg *MSG) bool {
+	ret, _, _ := procIsDialogMessage.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(msg)))
+
+	return ret != 0
+}
+
+func IsWindow(hwnd HWND) bool {
+	ret, _, _ := procIsWindow.Call(
+		uintptr(hwnd))
+
+	return ret != 0
+}
+
+func EndDialog(hwnd HWND, nResult uintptr) bool {
+	ret, _, _ := procEndDialog.Call(
+		uintptr(hwnd),
+		nResult)
+
+	return ret != 0
+}
+
+func PeekMessage(lpMsg *MSG, hwnd HWND, wMsgFilterMin, wMsgFilterMax, wRemoveMsg uint32) bool {
+	ret, _, _ := procPeekMessage.Call(
+		uintptr(unsafe.Pointer(lpMsg)),
+		uintptr(hwnd),
+		uintptr(wMsgFilterMin),
+		uintptr(wMsgFilterMax),
+		uintptr(wRemoveMsg))
+
+	return ret != 0
+}
+
+func TranslateAccelerator(hwnd HWND, hAccTable HACCEL, lpMsg *MSG) bool {
+	ret, _, _ := procTranslateMessage.Call(
+		uintptr(hwnd),
+		uintptr(hAccTable),
+		uintptr(unsafe.Pointer(lpMsg)))
+
+	return ret != 0
+}
+
+func SetWindowPos(hwnd, hWndInsertAfter HWND, x, y, cx, cy int, uFlags uint) bool {
+	ret, _, _ := procSetWindowPos.Call(
+		uintptr(hwnd),
+		uintptr(hWndInsertAfter),
+		uintptr(x),
+		uintptr(y),
+		uintptr(cx),
+		uintptr(cy),
+		uintptr(uFlags))
+
+	return ret != 0
+}
+
+func FillRect(hDC HDC, lprc *RECT, hbr HBRUSH) bool {
+	ret, _, _ := procFillRect.Call(
+		uintptr(hDC),
+		uintptr(unsafe.Pointer(lprc)),
+		uintptr(hbr))
+
+	return ret != 0
+}
+
+func DrawText(hDC HDC, text string, uCount int, lpRect *RECT, uFormat uint) int {
+	ret, _, _ := procDrawText.Call(
+		uintptr(hDC),
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(text))),
+		uintptr(uCount),
+		uintptr(unsafe.Pointer(lpRect)),
+		uintptr(uFormat))
+
+	return int(ret)
+}
+
+func AddClipboardFormatListener(hwnd HWND) bool {
+	ret, _, _ := procAddClipboardFormatListener.Call(
+		uintptr(hwnd))
+	return ret != 0
+}
+
+func RemoveClipboardFormatListener(hwnd HWND) bool {
+	ret, _, _ := procRemoveClipboardFormatListener.Call(
+		uintptr(hwnd))
+	return ret != 0
+}
+
+func OpenClipboard(hWndNewOwner HWND) bool {
+	ret, _, _ := procOpenClipboard.Call(
+		uintptr(hWndNewOwner))
+	return ret != 0
+}
+
+func CloseClipboard() bool {
+	ret, _, _ := procCloseClipboard.Call()
+	return ret != 0
+}
+
+func EnumClipboardFormats(format uint) uint {
+	ret, _, _ := procEnumClipboardFormats.Call(
+		uintptr(format))
+	return uint(ret)
+}
+
+func GetClipboardData(uFormat uint) HANDLE {
+	ret, _, _ := procGetClipboardData.Call(
+		uintptr(uFormat))
+	return HANDLE(ret)
+}
+
+func SetClipboardData(uFormat uint, hMem HANDLE) HANDLE {
+	ret, _, _ := procSetClipboardData.Call(
+		uintptr(uFormat),
+		uintptr(hMem))
+	return HANDLE(ret)
+}
+
+func EmptyClipboard() bool {
+	ret, _, _ := procEmptyClipboard.Call()
+	return ret != 0
+}
+
+func GetClipboardFormatName(format uint) (string, bool) {
+	cchMaxCount := 255
+	buf := make([]uint16, cchMaxCount)
+	ret, _, _ := procGetClipboardFormatName.Call(
+		uintptr(format),
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(cchMaxCount))
+
+	if ret > 0 {
+		return syscall.UTF16ToString(buf), true
+	}
+
+	return "Requested format does not exist or is predefined", false
+}
+
+func IsClipboardFormatAvailable(format uint) bool {
+	ret, _, _ := procIsClipboardFormatAvailable.Call(uintptr(format))
+	return ret != 0
+}
+
+func BeginPaint(hwnd HWND, paint *PAINTSTRUCT) HDC {
+	ret, _, _ := procBeginPaint.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(paint)))
+	return HDC(ret)
+}
+
+func EndPaint(hwnd HWND, paint *PAINTSTRUCT) {
+	procBeginPaint.Call(
+		uintptr(hwnd),
+		uintptr(unsafe.Pointer(paint)))
+}
+
+func GetKeyboardState(lpKeyState *[]byte) bool {
+	ret, _, _ := procGetKeyboardState.Call(
+		uintptr(unsafe.Pointer(&(*lpKeyState)[0])))
+	return ret != 0
+}
+
+func MapVirtualKeyEx(uCode, uMapType uint, dwhkl HKL) uint {
+	ret, _, _ := procMapVirtualKey.Call(
+		uintptr(uCode),
+		uintptr(uMapType),
+		uintptr(dwhkl))
+	return uint(ret)
+}
+
+func GetAsyncKeyState(vKey int) uint16 {
+	ret, _, _ := procGetAsyncKeyState.Call(uintptr(vKey))
+	return uint16(ret)
+}
+
+func ToAscii(uVirtKey, uScanCode uint, lpKeyState *byte, lpChar *uint16, uFlags uint) int {
+	ret, _, _ := procToAscii.Call(
+		uintptr(uVirtKey),
+		uintptr(uScanCode),
+		uintptr(unsafe.Pointer(lpKeyState)),
+		uintptr(unsafe.Pointer(lpChar)),
+		uintptr(uFlags))
+	return int(ret)
+}
+
+func SwapMouseButton(fSwap bool) bool {
+	ret, _, _ := procSwapMouseButton.Call(
+		uintptr(BoolToBOOL(fSwap)))
+	return ret != 0
+}
+
+func GetCursorPos() (x, y int, ok bool) {
+	pt := POINT{}
+	ret, _, _ := procGetCursorPos.Call(uintptr(unsafe.Pointer(&pt)))
+	return int(pt.X), int(pt.Y), ret != 0
+}
+
+func SetCursorPos(x, y int) bool {
+	ret, _, _ := procSetCursorPos.Call(
+		uintptr(x),
+		uintptr(y),
+	)
+	return ret != 0
+}
+
+func SetCursor(cursor HCURSOR) HCURSOR {
+	ret, _, _ := procSetCursor.Call(
+		uintptr(cursor),
+	)
+	return HCURSOR(ret)
+}
+
+func CreateIcon(instance HINSTANCE, nWidth, nHeight int, cPlanes, cBitsPerPixel byte, ANDbits, XORbits *byte) HICON {
+	ret, _, _ := procCreateIcon.Call(
+		uintptr(instance),
+		uintptr(nWidth),
+		uintptr(nHeight),
+		uintptr(cPlanes),
+		uintptr(cBitsPerPixel),
+		uintptr(unsafe.Pointer(ANDbits)),
+		uintptr(unsafe.Pointer(XORbits)),
+	)
+	return HICON(ret)
+}
+
+func DestroyIcon(icon HICON) bool {
+	ret, _, _ := procDestroyIcon.Call(
+		uintptr(icon),
+	)
+	return ret != 0
+}
+
+func MonitorFromPoint(x, y int, dwFlags uint32) HMONITOR {
+	ret, _, _ := procMonitorFromPoint.Call(
+		uintptr(x),
+		uintptr(y),
+		uintptr(dwFlags),
+	)
+	return HMONITOR(ret)
+}
+
+func MonitorFromRect(rc *RECT, dwFlags uint32) HMONITOR {
+	ret, _, _ := procMonitorFromRect.Call(
+		uintptr(unsafe.Pointer(rc)),
+		uintptr(dwFlags),
+	)
+	return HMONITOR(ret)
+}
+
+func MonitorFromWindow(hwnd HWND, dwFlags uint32) HMONITOR {
+	ret, _, _ := procMonitorFromWindow.Call(
+		uintptr(hwnd),
+		uintptr(dwFlags),
+	)
+	return HMONITOR(ret)
+}
+
+func GetMonitorInfo(hMonitor HMONITOR, lmpi *MONITORINFO) bool {
+	ret, _, _ := procGetMonitorInfo.Call(
+		uintptr(hMonitor),
+		uintptr(unsafe.Pointer(lmpi)),
+	)
+	return ret != 0
+}
+
+func EnumDisplayMonitors(hdc HDC, clip *RECT, fnEnum, dwData uintptr) bool {
+	ret, _, _ := procEnumDisplayMonitors.Call(
+		uintptr(hdc),
+		uintptr(unsafe.Pointer(clip)),
+		fnEnum,
+		dwData,
+	)
+	return ret != 0
+}
+
+func EnumDisplaySettingsEx(szDeviceName *uint16, iModeNum uint32, devMode *DEVMODE, dwFlags uint32) bool {
+	ret, _, _ := procEnumDisplaySettingsEx.Call(
+		uintptr(unsafe.Pointer(szDeviceName)),
+		uintptr(iModeNum),
+		uintptr(unsafe.Pointer(devMode)),
+		uintptr(dwFlags),
+	)
+	return ret != 0
+}
+
+func ChangeDisplaySettingsEx(szDeviceName *uint16, devMode *DEVMODE, hwnd HWND, dwFlags uint32, lParam uintptr) int32 {
+	ret, _, _ := procChangeDisplaySettingsEx.Call(
+		uintptr(unsafe.Pointer(szDeviceName)),
+		uintptr(unsafe.Pointer(devMode)),
+		uintptr(hwnd),
+		uintptr(dwFlags),
+		lParam,
+	)
+	return int32(ret)
+}
+
+/* remove to build without cgo
+func SendInput(inputs []INPUT) uint32 {
+	var validInputs []C.INPUT
+
+	for _, oneInput := range inputs {
+		input := C.INPUT{_type: C.DWORD(oneInput.Type)}
+
+		switch oneInput.Type {
+		case INPUT_MOUSE:
+			(*MouseInput)(unsafe.Pointer(&input)).mi = oneInput.Mi
+		case INPUT_KEYBOARD:
+			(*KbdInput)(unsafe.Pointer(&input)).ki = oneInput.Ki
+		case INPUT_HARDWARE:
+			(*HardwareInput)(unsafe.Pointer(&input)).hi = oneInput.Hi
+		default:
+			panic("unkown type")
+		}
+
+		validInputs = append(validInputs, input)
+	}
+
+	ret, _, _ := procSendInput.Call(
+		uintptr(len(validInputs)),
+		uintptr(unsafe.Pointer(&validInputs[0])),
+		uintptr(unsafe.Sizeof(C.INPUT{})),
+	)
+	return uint32(ret)
+}
+*/

vendor/github.com/shirou/w32/utils.go

@@ -0,0 +1,203 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package w32
+
+import (
+	"syscall"
+	"unicode/utf16"
+	"unsafe"
+)
+
+func MakeIntResource(id uint16) *uint16 {
+	return (*uint16)(unsafe.Pointer(uintptr(id)))
+}
+
+func LOWORD(dw uint32) uint16 {
+	return uint16(dw)
+}
+
+func HIWORD(dw uint32) uint16 {
+	return uint16(dw >> 16 & 0xffff)
+}
+
+func BoolToBOOL(value bool) BOOL {
+	if value {
+		return 1
+	}
+
+	return 0
+}
+
+func UTF16PtrToString(cstr *uint16) string {
+	if cstr != nil {
+		us := make([]uint16, 0, 256)
+		for p := uintptr(unsafe.Pointer(cstr)); ; p += 2 {
+			u := *(*uint16)(unsafe.Pointer(p))
+			if u == 0 {
+				return string(utf16.Decode(us))
+			}
+			us = append(us, u)
+		}
+	}
+
+	return ""
+}
+
+func ComAddRef(unknown *IUnknown) int32 {
+	ret, _, _ := syscall.Syscall(unknown.lpVtbl.pAddRef, 1,
+		uintptr(unsafe.Pointer(unknown)),
+		0,
+		0)
+	return int32(ret)
+}
+
+func ComRelease(unknown *IUnknown) int32 {
+	ret, _, _ := syscall.Syscall(unknown.lpVtbl.pRelease, 1,
+		uintptr(unsafe.Pointer(unknown)),
+		0,
+		0)
+	return int32(ret)
+}
+
+func ComQueryInterface(unknown *IUnknown, id *GUID) *IDispatch {
+	var disp *IDispatch
+	hr, _, _ := syscall.Syscall(unknown.lpVtbl.pQueryInterface, 3,
+		uintptr(unsafe.Pointer(unknown)),
+		uintptr(unsafe.Pointer(id)),
+		uintptr(unsafe.Pointer(&disp)))
+	if hr != 0 {
+		panic("Invoke QieryInterface error.")
+	}
+	return disp
+}
+
+func ComGetIDsOfName(disp *IDispatch, names []string) []int32 {
+	wnames := make([]*uint16, len(names))
+	dispid := make([]int32, len(names))
+	for i := 0; i < len(names); i++ {
+		wnames[i] = syscall.StringToUTF16Ptr(names[i])
+	}
+	hr, _, _ := syscall.Syscall6(disp.lpVtbl.pGetIDsOfNames, 6,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(IID_NULL)),
+		uintptr(unsafe.Pointer(&wnames[0])),
+		uintptr(len(names)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&dispid[0])))
+	if hr != 0 {
+		panic("Invoke GetIDsOfName error.")
+	}
+	return dispid
+}
+
+func ComInvoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (result *VARIANT) {
+	var dispparams DISPPARAMS
+
+	if dispatch&DISPATCH_PROPERTYPUT != 0 {
+		dispnames := [1]int32{DISPID_PROPERTYPUT}
+		dispparams.RgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0]))
+		dispparams.CNamedArgs = 1
+	}
+	var vargs []VARIANT
+	if len(params) > 0 {
+		vargs = make([]VARIANT, len(params))
+		for i, v := range params {
+			//n := len(params)-i-1
+			n := len(params) - i - 1
+			VariantInit(&vargs[n])
+			switch v.(type) {
+			case bool:
+				if v.(bool) {
+					vargs[n] = VARIANT{VT_BOOL, 0, 0, 0, 0xffff}
+				} else {
+					vargs[n] = VARIANT{VT_BOOL, 0, 0, 0, 0}
+				}
+			case *bool:
+				vargs[n] = VARIANT{VT_BOOL | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*bool))))}
+			case byte:
+				vargs[n] = VARIANT{VT_I1, 0, 0, 0, int64(v.(byte))}
+			case *byte:
+				vargs[n] = VARIANT{VT_I1 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*byte))))}
+			case int16:
+				vargs[n] = VARIANT{VT_I2, 0, 0, 0, int64(v.(int16))}
+			case *int16:
+				vargs[n] = VARIANT{VT_I2 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*int16))))}
+			case uint16:
+				vargs[n] = VARIANT{VT_UI2, 0, 0, 0, int64(v.(int16))}
+			case *uint16:
+				vargs[n] = VARIANT{VT_UI2 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*uint16))))}
+			case int, int32:
+				vargs[n] = VARIANT{VT_UI4, 0, 0, 0, int64(v.(int))}
+			case *int, *int32:
+				vargs[n] = VARIANT{VT_I4 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*int))))}
+			case uint, uint32:
+				vargs[n] = VARIANT{VT_UI4, 0, 0, 0, int64(v.(uint))}
+			case *uint, *uint32:
+				vargs[n] = VARIANT{VT_UI4 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*uint))))}
+			case int64:
+				vargs[n] = VARIANT{VT_I8, 0, 0, 0, v.(int64)}
+			case *int64:
+				vargs[n] = VARIANT{VT_I8 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*int64))))}
+			case uint64:
+				vargs[n] = VARIANT{VT_UI8, 0, 0, 0, int64(v.(uint64))}
+			case *uint64:
+				vargs[n] = VARIANT{VT_UI8 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*uint64))))}
+			case float32:
+				vargs[n] = VARIANT{VT_R4, 0, 0, 0, int64(v.(float32))}
+			case *float32:
+				vargs[n] = VARIANT{VT_R4 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*float32))))}
+			case float64:
+				vargs[n] = VARIANT{VT_R8, 0, 0, 0, int64(v.(float64))}
+			case *float64:
+				vargs[n] = VARIANT{VT_R8 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*float64))))}
+			case string:
+				vargs[n] = VARIANT{VT_BSTR, 0, 0, 0, int64(uintptr(unsafe.Pointer(SysAllocString(v.(string)))))}
+			case *string:
+				vargs[n] = VARIANT{VT_BSTR | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*string))))}
+			case *IDispatch:
+				vargs[n] = VARIANT{VT_DISPATCH, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*IDispatch))))}
+			case **IDispatch:
+				vargs[n] = VARIANT{VT_DISPATCH | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(**IDispatch))))}
+			case nil:
+				vargs[n] = VARIANT{VT_NULL, 0, 0, 0, 0}
+			case *VARIANT:
+				vargs[n] = VARIANT{VT_VARIANT | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*VARIANT))))}
+			default:
+				panic("unknown type")
+			}
+		}
+		dispparams.Rgvarg = uintptr(unsafe.Pointer(&vargs[0]))
+		dispparams.CArgs = uint32(len(params))
+	}
+
+	var ret VARIANT
+	var excepInfo EXCEPINFO
+	VariantInit(&ret)
+	hr, _, _ := syscall.Syscall9(disp.lpVtbl.pInvoke, 8,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(dispid),
+		uintptr(unsafe.Pointer(IID_NULL)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(dispatch),
+		uintptr(unsafe.Pointer(&dispparams)),
+		uintptr(unsafe.Pointer(&ret)),
+		uintptr(unsafe.Pointer(&excepInfo)),
+		0)
+	if hr != 0 {
+		if excepInfo.BstrDescription != nil {
+			bs := UTF16PtrToString(excepInfo.BstrDescription)
+			panic(bs)
+		}
+	}
+	for _, varg := range vargs {
+		if varg.VT == VT_BSTR && varg.Val != 0 {
+			SysFreeString(((*int16)(unsafe.Pointer(uintptr(varg.Val)))))
+		}
+	}
+	result = &ret
+	return
+}

vendor/github.com/shirou/w32/vars.go

@@ -0,0 +1,13 @@
+// Copyright 2010-2012 The W32 Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package w32
+
+var (
+	IID_NULL                      = &GUID{0x00000000, 0x0000, 0x0000, [8]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}
+	IID_IUnknown                  = &GUID{0x00000000, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
+	IID_IDispatch                 = &GUID{0x00020400, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
+	IID_IConnectionPointContainer = &GUID{0xB196B284, 0xBAB4, 0x101A, [8]byte{0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07}}
+	IID_IConnectionPoint          = &GUID{0xB196B286, 0xBAB4, 0x101A, [8]byte{0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07}}
+)

vendor/vendor.json

@@ -675,22 +675,34 @@
 			"revisionTime": "2016-07-12T16:32:29Z"
 		},
 		{
-			"checksumSHA1": "HoB8jOyjbTgm03BTbwkwqH+lrXs=",
+			"checksumSHA1": "9rCHOi3ELajBtQUPWxxmEo/Nalk=",
 			"path": "github.com/shirou/gopsutil",
-			"revision": "70a1b78fe69202d93d6718fc9e3a4d6f81edfd58",
-			"revisionTime": "2017-01-30T15:34:44Z"
+			"revision": "b68f0fdb25a7785ce7a38e77330d3dd415010106",
+			"revisionTime": "2017-02-01T16:25:48Z"
 		},
 		{
-			"checksumSHA1": "74PIzS+la5td63oGs74K66mQ7hk=",
+			"checksumSHA1": "z30Q7+rqd6FGTNeJlvmAccYrHQ0=",
 			"path": "github.com/shirou/gopsutil/host",
-			"revision": "70a1b78fe69202d93d6718fc9e3a4d6f81edfd58",
-			"revisionTime": "2017-01-30T15:34:44Z"
+			"revision": "b68f0fdb25a7785ce7a38e77330d3dd415010106",
+			"revisionTime": "2017-02-01T16:25:48Z"
 		},
 		{
 			"checksumSHA1": "F4xYQ60JlmamCUSCJl7zuuq58Kw=",
 			"path": "github.com/shirou/gopsutil/internal/common",
-			"revision": "70a1b78fe69202d93d6718fc9e3a4d6f81edfd58",
-			"revisionTime": "2017-01-30T15:34:44Z"
+			"revision": "b68f0fdb25a7785ce7a38e77330d3dd415010106",
+			"revisionTime": "2017-02-01T16:25:48Z"
+		},
+		{
+			"checksumSHA1": "6PZpekfhutCewqXOVB2Pu8OuUnE=",
+			"path": "github.com/shirou/gopsutil/process",
+			"revision": "b68f0fdb25a7785ce7a38e77330d3dd415010106",
+			"revisionTime": "2017-02-01T16:25:48Z"
+		},
+		{
+			"checksumSHA1": "Nve7SpDmjsv6+rhkXAkfg/UQx94=",
+			"path": "github.com/shirou/w32",
+			"revision": "bb4de0191aa41b5507caa14b0650cdbddcd9280b",
+			"revisionTime": "2016-09-30T03:27:40Z"
 		},
 		{
 			"checksumSHA1": "9jjO5GjLa0XF/nfWihF02RoH4qc=",