Repository: go-playground/stats Branch: v1 Commit: 02c0e2b6980a Files: 150 Total size: 491.2 KB Directory structure: gitextract_a633ijnj/ ├── .gitignore ├── LICENSE ├── README.md ├── client.go ├── examples/ │ ├── client/ │ │ └── client.go │ └── server/ │ └── server.go ├── http.go ├── server.go ├── stats.go ├── stats_test.go ├── vendor/ │ └── github.com/ │ ├── StackExchange/ │ │ └── wmi/ │ │ ├── LICENSE │ │ ├── README.md │ │ └── wmi.go │ ├── go-ole/ │ │ └── go-ole/ │ │ ├── ChangeLog.md │ │ ├── README.md │ │ ├── appveyor.yml │ │ ├── com.go │ │ ├── com_func.go │ │ ├── connect.go │ │ ├── constants.go │ │ ├── error.go │ │ ├── error_func.go │ │ ├── error_windows.go │ │ ├── guid.go │ │ ├── iconnectionpoint.go │ │ ├── iconnectionpoint_func.go │ │ ├── iconnectionpoint_windows.go │ │ ├── iconnectionpointcontainer.go │ │ ├── iconnectionpointcontainer_func.go │ │ ├── iconnectionpointcontainer_windows.go │ │ ├── idispatch.go │ │ ├── idispatch_func.go │ │ ├── idispatch_windows.go │ │ ├── ienumvariant.go │ │ ├── ienumvariant_func.go │ │ ├── ienumvariant_windows.go │ │ ├── iinspectable.go │ │ ├── iinspectable_func.go │ │ ├── iinspectable_windows.go │ │ ├── iprovideclassinfo.go │ │ ├── iprovideclassinfo_func.go │ │ ├── iprovideclassinfo_windows.go │ │ ├── itypeinfo.go │ │ ├── itypeinfo_func.go │ │ ├── itypeinfo_windows.go │ │ ├── iunknown.go │ │ ├── iunknown_func.go │ │ ├── iunknown_windows.go │ │ ├── ole.go │ │ ├── oleutil/ │ │ │ ├── connection.go │ │ │ ├── connection_func.go │ │ │ ├── connection_windows.go │ │ │ ├── go-get.go │ │ │ └── oleutil.go │ │ ├── safearray.go │ │ ├── safearray_func.go │ │ ├── safearray_windows.go │ │ ├── safearrayconversion.go │ │ ├── safearrayslices.go │ │ ├── utility.go │ │ ├── variables.go │ │ ├── variant.go │ │ ├── variant_386.go │ │ ├── variant_amd64.go │ │ ├── vt_string.go │ │ ├── winrt.go │ │ └── winrt_doc.go │ └── shirou/ │ ├── gopsutil/ │ │ ├── LICENSE │ │ ├── README.rst │ │ ├── circle.yml │ │ ├── coverall.sh │ │ ├── cpu/ │ │ │ ├── cpu.go │ │ │ ├── cpu_darwin.go │ │ │ ├── cpu_darwin_cgo.go │ │ │ ├── cpu_darwin_nocgo.go │ │ │ ├── cpu_freebsd.go │ │ │ ├── cpu_linux.go │ │ │ ├── cpu_unix.go │ │ │ └── cpu_windows.go │ │ ├── doc.go │ │ ├── host/ │ │ │ ├── host.go │ │ │ ├── host_darwin.go │ │ │ ├── host_darwin_amd64.go │ │ │ ├── host_freebsd.go │ │ │ ├── host_freebsd_amd64.go │ │ │ ├── host_linux.go │ │ │ ├── host_linux_386.go │ │ │ ├── host_linux_amd64.go │ │ │ ├── host_linux_arm.go │ │ │ ├── host_windows.go │ │ │ ├── types_darwin.go │ │ │ ├── types_freebsd.go │ │ │ └── types_linux.go │ │ ├── internal/ │ │ │ └── common/ │ │ │ ├── binary.go │ │ │ ├── common.go │ │ │ ├── common_darwin.go │ │ │ ├── common_freebsd.go │ │ │ ├── common_linux.go │ │ │ ├── common_unix.go │ │ │ └── common_windows.go │ │ ├── mem/ │ │ │ ├── mem.go │ │ │ ├── mem_darwin.go │ │ │ ├── mem_freebsd.go │ │ │ ├── mem_linux.go │ │ │ └── mem_windows.go │ │ ├── mktypes.sh │ │ ├── net/ │ │ │ ├── net.go │ │ │ ├── net_darwin.go │ │ │ ├── net_freebsd.go │ │ │ ├── net_linux.go │ │ │ ├── net_unix.go │ │ │ └── net_windows.go │ │ ├── process/ │ │ │ ├── process.go │ │ │ ├── process_darwin.go │ │ │ ├── process_darwin_amd64.go │ │ │ ├── process_freebsd.go │ │ │ ├── process_freebsd_386.go │ │ │ ├── process_freebsd_amd64.go │ │ │ ├── process_linux.go │ │ │ ├── process_linux_386.go │ │ │ ├── process_linux_amd64.go │ │ │ ├── process_linux_arm.go │ │ │ ├── process_posix.go │ │ │ ├── process_windows.go │ │ │ └── types_darwin.go │ │ └── windows_memo.rst │ └── w32/ │ ├── AUTHORS │ ├── LICENSE │ ├── README.md │ ├── advapi32.go │ ├── comctl32.go │ ├── comdlg32.go │ ├── constants.go │ ├── dwmapi.go │ ├── gdi32.go │ ├── gdiplus.go │ ├── idispatch.go │ ├── istream.go │ ├── iunknown.go │ ├── kernel32.go │ ├── ole32.go │ ├── oleaut32.go │ ├── opengl32.go │ ├── psapi.go │ ├── shell32.go │ ├── typedef.go │ ├── user32.go │ ├── utils.go │ └── vars.go └── vendor.yml ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ # Compiled Object files, Static and Dynamic libs (Shared Objects) *.o *.a *.so # Folders _obj _test # Architecture specific extensions/prefixes *.[568vq] [568vq].out *.cgo1.go *.cgo2.c _cgo_defun.c _cgo_gotypes.go _cgo_export.* _testmain.go *.exe *.test *.prof # Custom Ignores stats *.profile ================================================ FILE: LICENSE ================================================ The MIT License (MIT) Copyright (c) 2015 Dean Karn Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ Package stats ============= ![Project status](https://img.shields.io/badge/version-1.0.2-green.svg) [![Build Status](https://semaphoreci.com/api/v1/projects/b5c5d4f1-ec31-441f-a6d2-88f4e73105df/563578/badge.svg)](https://semaphoreci.com/joeybloggs/stats) [![GoDoc](https://godoc.org/gopkg.in/go-playground/stats.v1?status.svg)](https://godoc.org/gopkg.in/go-playground/stats.v1) Package stats allows for gathering of statistics regarding your Go application and system it is running on and sent them via UDP to a server where you can do whatever you wish to the stats; display, store in database or send off to a logging service. ###### We currently gather the following Go related information: * # of Garbabage collects * Last Garbage Collection * Last Garbage Collection Pause Duration * Memory Allocated * Memory Heap Allocated * Memory Heap System Allocated * Go version * Number of goroutines * HTTP request logging; when implemented via middleware ###### And the following System Information: * Host Information; hostname, OS.... * CPU Information; type, model, # of cores... * Total CPU Timings * Per Core CPU Timings * Memory + Swap Information Installation ------------ Use go get. go get gopkg.in/go-playground/stats.v1 or to update go get -u gopkg.in/go-playground/stats.v1 Then import the validator package into your own code. import "gopkg.in/go-playground/stats.v1" #### Example Server ```go package main import ( "fmt" "gopkg.in/go-playground/stats.v1" ) func main() { config := &stats.ServerConfig{ Domain: "", Port: 3008, Debug: false, } server, err := stats.NewServer(config) if err != nil { panic(err) } for stat := range server.Run() { // calculate CPU times // totalCPUTimes := stat.CalculateTotalCPUTimes() // perCoreCPUTimes := stat.CalculateCPUTimes() // Do whatever you want with the data // * Save to database // * Stream elsewhere // * Print to console // fmt.Println(stat) } } ``` Client ```go package main import ( "fmt" "net/http" "runtime" "gopkg.in/go-playground/stats.v1" ) var statsClient *stats.ClientStats func main() { serverConfig := &stats.ServerConfig{ Domain: "remoteserver", Port: 3008, Debug: false, } clientConfig := &stats.ClientConfig{ Domain: "", Port: 3009, PollInterval: 1000, Debug: false, LogHostInfo: true, LogCPUInfo: true, LogTotalCPUTimes: true, LogPerCPUTimes: true, LogMemory: true, LogGoMemory: true, } client, err := stats.NewClient(clientConfig, serverConfig) if err != nil { panic(err) } go client.Run() // if you want to capture HTTP requests in a middleware you'll have // to have access to the client. // see below for middleware example statsClient = client } // LoggingRecoveryHandler ... // // // Middleware example for capturing HTTP Request info // NOTE: this is standard go middlware, but could be adapted to other types/styles easily // func LoggingRecoveryHandler(next http.Handler) http.Handler { fn := func(w http.ResponseWriter, r *http.Request) { // log incoming request logReq := statsClient.NewHTTPRequest(w, r) defer func() { if err := recover(); err != nil { trace := make([]byte, 1<<16) n := runtime.Stack(trace, true) // log failure logReq.Failure(fmt.Sprintf("%s\n%s", err, trace[:n])) http.Error(w, "Friendly error message", 500) return } }() next.ServeHTTP(logReq.Writer(), r) // log completion logReq.Complete() } return http.HandlerFunc(fn) } ``` License ------ - [MIT License](https://github.com/go-playground/stats/blob/v1/LICENSE), Copyright (c) 2015 Dean Karn - [BSD License](https://github.com/go-playground/stats/tree/v1/vendor/github.com/shirou/gopsutil/LICENSE) - Copyright (c) 2014, WAKAYAMA Shirou - Copyright (c) 2009 The Go Authors. All rights reserved. - [BSD License](https://github.com/go-playground/stats/tree/v1/vendor/github.com/shirou/w32/LICENSE), Copyright (c) 2010-2012 The w32 Authors. All rights reserved. ================================================ FILE: client.go ================================================ package stats import ( "encoding/json" "fmt" "net" "strconv" "sync" "time" ) type httpStats struct { lock sync.RWMutex requests []*HTTPRequest } func (h *httpStats) add(r *HTTPRequest) { h.lock.Lock() defer h.lock.Unlock() h.requests = append(h.requests, r) } func (h *httpStats) extract() []*HTTPRequest { h.lock.Lock() defer h.lock.Unlock() old := h.requests h.requests = []*HTTPRequest{} return old } // ClientConfig is used to initialize a new ClientStats object type ClientConfig struct { Domain string Port int PollInterval int Debug bool LogHostInfo bool LogCPUInfo bool LogTotalCPUTimes bool LogPerCPUTimes bool LogMemory bool LogGoMemory bool CustomBufferSize int } // ClientStats is the object used to collect and send data to the server for processing type ClientStats struct { localAddr string serverAddr string stop chan struct{} interval int debug bool httpStats *httpStats logHostInfo bool logCPUInfo bool logTotalCPUTimes bool logPerCPUTimes bool logMemory bool logGoMemory bool bufferSize int } // NewClient create a new client object for use func NewClient(clientConfig *ClientConfig, serverConfig *ServerConfig) (*ClientStats, error) { bSize := clientConfig.CustomBufferSize if bSize == 0 { bSize = defaultBufferSize } return &ClientStats{ localAddr: clientConfig.Domain + ":" + strconv.Itoa(clientConfig.Port), serverAddr: serverConfig.Domain + ":" + strconv.Itoa(serverConfig.Port), interval: clientConfig.PollInterval, stop: make(chan struct{}), debug: clientConfig.Debug, httpStats: new(httpStats), logHostInfo: clientConfig.LogHostInfo, logCPUInfo: clientConfig.LogCPUInfo, logTotalCPUTimes: clientConfig.LogTotalCPUTimes, logPerCPUTimes: clientConfig.LogPerCPUTimes, logMemory: clientConfig.LogMemory, logGoMemory: clientConfig.LogGoMemory, bufferSize: bSize, }, nil } // Run starts sending the profiling stats to the server // NOTE: the server must be running prior to starting func (c *ClientStats) Run() { var localAddr *net.UDPAddr var serverAddr *net.UDPAddr var client *net.UDPConn var err error serverAddr, err = net.ResolveUDPAddr(udp, c.serverAddr) if err != nil { panic(err) } localAddr, err = net.ResolveUDPAddr(udp, c.localAddr) if err != nil { panic(err) } client, err = net.DialUDP(udp, localAddr, serverAddr) if err != nil { panic(err) } defer client.Close() client.SetWriteBuffer(c.bufferSize) stats := new(Stats) if c.logHostInfo { stats.GetHostInfo() } if c.logCPUInfo { stats.GetCPUInfo() } var bytesWritten int var bytes []byte ticker := time.NewTicker(time.Millisecond * time.Duration(c.interval)) defer ticker.Stop() for { select { case <-ticker.C: if c.logTotalCPUTimes { stats.GetTotalCPUTimes() } if c.logPerCPUTimes { stats.GetCPUTimes() } stats.GetMemoryInfo(c.logMemory, c.logGoMemory) stats.HTTPRequests = c.httpStats.extract() bytes, err = json.Marshal(stats) bytesWritten, err = client.Write(bytes) if err != nil { fmt.Println(err) continue } if c.debug { fmt.Println("Wrote:", bytesWritten, "bytes") } case <-c.stop: fmt.Println("done") return } } } // Stop halts the client from sending any more data to the server, // but may be run again at any time. func (c *ClientStats) Stop() { c.stop <- struct{}{} } ================================================ FILE: examples/client/client.go ================================================ package main import ( "fmt" "net/http" "runtime" "gopkg.in/go-playground/stats.v1" ) var statsClient *stats.ClientStats func main() { serverConfig := &stats.ServerConfig{ Domain: "localhost", Port: 3008, Debug: false, } clientConfig := &stats.ClientConfig{ Domain: "", Port: 3009, PollInterval: 1000, Debug: false, LogHostInfo: true, LogCPUInfo: true, LogTotalCPUTimes: true, LogPerCPUTimes: true, LogMemory: true, LogGoMemory: true, } client, err := stats.NewClient(clientConfig, serverConfig) if err != nil { panic(err) } go client.Run() // if you want to capture HTTP requests in a middleware you'll have // to have access to the client. // see below for middleware example statsClient = client <-make(chan struct{}) } // LoggingRecoveryHandler ... // // // Middleware example for capturing HTTP Request info // NOTE: this is standard go middlware, but could be adapted to other types/styles easily // func LoggingRecoveryHandler(next http.Handler) http.Handler { fn := func(w http.ResponseWriter, r *http.Request) { // log incoming request logReq := statsClient.NewHTTPRequest(w, r) defer func() { if err := recover(); err != nil { trace := make([]byte, 1<<16) n := runtime.Stack(trace, true) // log failure logReq.Failure(fmt.Sprintf("%s\n%s", err, trace[:n])) http.Error(w, "Friendly error message", 500) return } }() next.ServeHTTP(logReq.Writer(), r) // log completion logReq.Complete() } return http.HandlerFunc(fn) } ================================================ FILE: examples/server/server.go ================================================ package main import ( "fmt" "gopkg.in/go-playground/stats.v1" ) func main() { config := &stats.ServerConfig{ Domain: "", Port: 3008, Debug: false, } server, err := stats.NewServer(config) if err != nil { panic(err) } for stat := range server.Run() { // calculate CPU times // totalCPUTimes := stat.CalculateTotalCPUTimes() // perCoreCPUTimes := stat.CalculateCPUTimes() // Do whatever you want with the data // * Save to database // * Stream elsewhere // * Print to console // fmt.Println(stat) } } ================================================ FILE: http.go ================================================ package stats import ( "net/http" "time" ) // LogResponseWritter wraps the standard http.ResponseWritter allowing for more // verbose logging type LogResponseWritter struct { status int size int http.ResponseWriter } // Status provides an easy way to retrieve the status code func (w *LogResponseWritter) Status() int { return w.status } // Size provides an easy way to retrieve the response size in bytes func (w *LogResponseWritter) Size() int { return w.size } // Header returns & satisfies the http.ResponseWriter interface func (w *LogResponseWritter) Header() http.Header { return w.ResponseWriter.Header() } // Write satisfies the http.ResponseWriter interface and // captures data written, in bytes func (w *LogResponseWritter) Write(data []byte) (int, error) { written, err := w.ResponseWriter.Write(data) w.size += written return written, err } // WriteHeader satisfies the http.ResponseWriter interface and // allows us to cach the status code func (w *LogResponseWritter) WriteHeader(statusCode int) { w.status = statusCode w.ResponseWriter.WriteHeader(statusCode) } // HTTPRequest contains information about the life of an http request type HTTPRequest struct { URL string `json:"url"` Method string `json:"method"` RequestContentLength int64 `json:"reqContent"` Headers http.Header `json:"headers"` Start time.Time `json:"start"` End time.Time `json:"end"` Duration int64 `json:"duration"` ResponseContentLength int64 `json:"resContent"` StatusCode int `json:"status"` HasErrors bool `json:"hasErrs"` Error string `json:"err"` writer *LogResponseWritter clientStats *ClientStats } // NewHTTPRequest creates a new HTTPRequest for monitoring which wraps the ResponseWriter in order // to collect stats so you need to call the Writer() function from the HTTPRequest created by this call func (s *ClientStats) NewHTTPRequest(w http.ResponseWriter, r *http.Request) *HTTPRequest { return &HTTPRequest{ Start: time.Now().UTC(), URL: r.URL.String(), Method: r.Method, RequestContentLength: r.ContentLength, Headers: r.Header, writer: &LogResponseWritter{status: 200, ResponseWriter: w}, clientStats: s, } } // Writer returns a wrapped http.ResponseWriter for logging purposes func (r *HTTPRequest) Writer() http.ResponseWriter { return r.writer } // Failure records an HTTP failure and automatically completes the request func (r *HTTPRequest) Failure(err string) { r.HasErrors = true r.Error = err r.Complete() } // Complete finalizes an HTTPRequest and logs it. func (r *HTTPRequest) Complete() { r.End = time.Now().UTC() r.Duration = r.End.Sub(r.Start).Nanoseconds() r.ResponseContentLength = int64(r.writer.Size()) r.StatusCode = r.writer.Status() r.clientStats.httpStats.add(r) } ================================================ FILE: server.go ================================================ package stats import ( "encoding/json" "fmt" "net" "strconv" ) // ServerConfig is used to initialize a new ServerStats object type ServerConfig struct { Domain string Port int Debug bool CustomBufferSize int } // ServerStats is the object used to receive, store and send data for usage type ServerStats struct { addr string debug bool bufferSize int } // NewServer create a new server object for use func NewServer(config *ServerConfig) (*ServerStats, error) { bSize := config.CustomBufferSize if bSize == 0 { bSize = defaultBufferSize } return &ServerStats{ addr: config.Domain + ":" + strconv.Itoa(config.Port), debug: config.Debug, bufferSize: bSize, }, nil } // Run starts receiving the profiling stats for storage and usage func (s *ServerStats) Run() <-chan *Stats { results := make(chan *Stats) go func(results chan<- *Stats) { var serverAddr *net.UDPAddr var server *net.UDPConn var err error serverAddr, err = net.ResolveUDPAddr(udp, s.addr) if err != nil { panic(err) } server, err = net.ListenUDP(udp, serverAddr) if err != nil { panic(err) } defer server.Close() server.SetReadBuffer(s.bufferSize) var addr *net.UDPAddr var bytesRead int buff := make([]byte, s.bufferSize) stats := new(Stats) for { bytesRead, addr, err = server.ReadFromUDP(buff) if err != nil { fmt.Printf("Error:%s bytes read %d\n", err, bytesRead) continue } if s.debug { fmt.Printf("Recieved: %s from %s Read %d bytes\n", string(buff[0:bytesRead]), addr, bytesRead) } if err := json.Unmarshal(buff[0:bytesRead], &stats); err != nil { fmt.Println("Error Unmarshalling:", err) } results <- stats } }(results) return results } ================================================ FILE: stats.go ================================================ package stats import ( "runtime" "github.com/shirou/gopsutil/cpu" "github.com/shirou/gopsutil/host" "github.com/shirou/gopsutil/mem" ) const ( udp = "udp" defaultBufferSize = 1024 * 1000 ) // CPUPercentages contains the CPU percentage information type CPUPercentages struct { CPU string User float64 System float64 Idle float64 Nice float64 IOWait float64 IRQ float64 SoftIRQ float64 Steal float64 Guest float64 GuestNice float64 Stolen float64 Total float64 } // GoMemory contains go specific memory metrics type GoMemory struct { NumGC uint32 `json:"numgc"` LastGC uint64 `json:"lastgc"` LastGCPauseDuration uint64 `json:"lastgcpause"` Alloc uint64 `json:"alloc"` HeapAlloc uint64 `json:"heap"` HeapSys uint64 `json:"sys"` lastNumGC uint32 mem *runtime.MemStats } // GoInfo contains go specific metrics and stats type GoInfo struct { Version string `json:"gover"` Memory GoMemory `json:"gomem"` GoRoutines int `json:"goroutines"` } // MemInfo contains memory info including swap information type MemInfo struct { Memory *mem.VirtualMemoryStat `json:"mem,omitempty"` Swap *mem.SwapMemoryStat `json:"swap,omitempty"` } // CPUInfo contains CPU information type CPUInfo struct { CPU []cpu.CPUInfoStat `json:"cpu,omitempty"` PerCPUTimes []cpu.CPUTimesStat `json:"percputimes,omitempty"` TotalTimes []cpu.CPUTimesStat `json:"totaltimes,omitempty"` PrevCPUTimes []cpu.CPUTimesStat `json:"prevpercputimes,omitempty"` PrevTotalTimes []cpu.CPUTimesStat `json:"prevtotaltimes,omitempty"` } // Stats contains all of the statistics to be passed and Encoded/Decoded on the Client and Server sides type Stats struct { HostInfo *host.HostInfoStat `json:"hostInfo,omitempty"` CPUInfo *CPUInfo `json:"cpu,omitempty"` MemInfo *MemInfo `json:"memInfo,omitempty"` GoInfo *GoInfo `json:"goInfo,omitempty"` HTTPRequests []*HTTPRequest `json:"http"` } func (s *Stats) initGoInfo() { s.GoInfo = new(GoInfo) s.GoInfo.Memory.mem = new(runtime.MemStats) } // GetHostInfo populates Stats with host system information func (s *Stats) GetHostInfo() { if s.GoInfo == nil { s.initGoInfo() } info, _ := host.HostInfo() s.HostInfo = info s.GoInfo.Version = runtime.Version() } // GetCPUInfo populates Stats with hosts CPU information func (s *Stats) GetCPUInfo() { if s.CPUInfo == nil { s.CPUInfo = new(CPUInfo) } s.CPUInfo.CPU, _ = cpu.CPUInfo() } // GetCPUTimes populates Stats with hosts CPU timing information func (s *Stats) GetCPUTimes() { if s.CPUInfo == nil { s.CPUInfo = new(CPUInfo) } s.CPUInfo.PrevCPUTimes = s.CPUInfo.PerCPUTimes s.CPUInfo.PerCPUTimes, _ = cpu.CPUTimes(true) if len(s.CPUInfo.PrevCPUTimes) == 0 { s.CPUInfo.PrevCPUTimes = s.CPUInfo.PerCPUTimes } } // CalculateCPUTimes calculates the total CPU times percentages per core func (s *Stats) CalculateCPUTimes() []CPUPercentages { percentages := make([]CPUPercentages, len(s.CPUInfo.PerCPUTimes)) if len(s.CPUInfo.PrevCPUTimes) == 0 || len(s.CPUInfo.PerCPUTimes) == 0 { return percentages } var diff float64 var total float64 var prevTotal float64 var prevStat cpu.CPUTimesStat var cpuStat *CPUPercentages for i, t := range s.CPUInfo.PerCPUTimes { cpuStat = &percentages[i] prevStat = s.CPUInfo.PrevCPUTimes[i] total = t.User + t.System + t.Idle + t.Nice + t.Iowait + t.Irq + t.Softirq + t.Steal + t.Guest + t.GuestNice + t.Stolen prevTotal = prevStat.User + prevStat.System + prevStat.Idle + prevStat.Nice + prevStat.Iowait + prevStat.Irq + prevStat.Softirq + prevStat.Steal + prevStat.Guest + prevStat.GuestNice + prevStat.Stolen diff = total - prevTotal cpuStat.CPU = t.CPU cpuStat.User = (t.User - prevStat.User) / diff * 100 cpuStat.System = (t.System - prevStat.System) / diff * 100 cpuStat.Idle = (t.Idle - prevStat.Idle) / diff * 100 cpuStat.Nice = (t.Nice - prevStat.Nice) / diff * 100 cpuStat.IOWait = (t.Iowait - prevStat.Iowait) / diff * 100 cpuStat.IRQ = (t.Irq - prevStat.Irq) / diff * 100 cpuStat.SoftIRQ = (t.Softirq - prevStat.Softirq) / diff * 100 cpuStat.Steal = (t.Steal - prevStat.Steal) / diff * 100 cpuStat.Guest = (t.Guest - prevStat.Guest) / diff * 100 cpuStat.GuestNice = (t.GuestNice - prevStat.GuestNice) / diff * 100 cpuStat.Stolen = (t.Stolen - prevStat.Stolen) / diff * 100 cpuStat.Total = 100 * (diff - (t.Idle - prevStat.Idle)) / diff } return percentages } // GetAllCPUInfo populates Stats with hosts CPU information and Timings func (s *Stats) GetAllCPUInfo() { s.GetCPUInfo() s.GetCPUTimes() } // GetTotalCPUTimes populates Stats with hosts CPU timing information func (s *Stats) GetTotalCPUTimes() { if s.CPUInfo == nil { s.CPUInfo = new(CPUInfo) } s.CPUInfo.PrevTotalTimes = s.CPUInfo.TotalTimes s.CPUInfo.TotalTimes, _ = cpu.CPUTimes(false) if len(s.CPUInfo.PrevTotalTimes) == 0 { s.CPUInfo.PrevTotalTimes = s.CPUInfo.TotalTimes } } // CalculateTotalCPUTimes calculates the total CPU times percentages func (s *Stats) CalculateTotalCPUTimes() []CPUPercentages { percentages := make([]CPUPercentages, len(s.CPUInfo.TotalTimes)) if len(s.CPUInfo.PrevTotalTimes) == 0 || len(s.CPUInfo.TotalTimes) == 0 { return percentages } var diff float64 var total float64 var prevTotal float64 var prevStat cpu.CPUTimesStat var cpuStat *CPUPercentages for i, t := range s.CPUInfo.TotalTimes { cpuStat = &percentages[i] prevStat = s.CPUInfo.PrevTotalTimes[i] total = t.User + t.System + t.Idle + t.Nice + t.Iowait + t.Irq + t.Softirq + t.Steal + t.Guest + t.GuestNice + t.Stolen prevTotal = prevStat.User + prevStat.System + prevStat.Idle + prevStat.Nice + prevStat.Iowait + prevStat.Irq + prevStat.Softirq + prevStat.Steal + prevStat.Guest + prevStat.GuestNice + prevStat.Stolen diff = total - prevTotal cpuStat.CPU = t.CPU cpuStat.User = (t.User - prevStat.User) / diff * 100 cpuStat.System = (t.System - prevStat.System) / diff * 100 cpuStat.Idle = (t.Idle - prevStat.Idle) / diff * 100 cpuStat.Nice = (t.Nice - prevStat.Nice) / diff * 100 cpuStat.IOWait = (t.Iowait - prevStat.Iowait) / diff * 100 cpuStat.IRQ = (t.Irq - prevStat.Irq) / diff * 100 cpuStat.SoftIRQ = (t.Softirq - prevStat.Softirq) / diff * 100 cpuStat.Steal = (t.Steal - prevStat.Steal) / diff * 100 cpuStat.Guest = (t.Guest - prevStat.Guest) / diff * 100 cpuStat.GuestNice = (t.GuestNice - prevStat.GuestNice) / diff * 100 cpuStat.Stolen = (t.Stolen - prevStat.Stolen) / diff * 100 cpuStat.Total = 100 * (diff - (t.Idle - prevStat.Idle)) / diff } return percentages } // GetMemoryInfo populates Stats with host and go process memory information func (s *Stats) GetMemoryInfo(logMemory, logGoMemory bool) { if logGoMemory { if s.GoInfo == nil { s.initGoInfo() } runtime.ReadMemStats(s.GoInfo.Memory.mem) s.GoInfo.GoRoutines = runtime.NumGoroutine() s.GoInfo.Memory.Alloc = s.GoInfo.Memory.mem.Alloc s.GoInfo.Memory.HeapAlloc = s.GoInfo.Memory.mem.HeapAlloc s.GoInfo.Memory.HeapSys = s.GoInfo.Memory.mem.HeapSys if s.GoInfo.Memory.LastGC != s.GoInfo.Memory.mem.LastGC { s.GoInfo.Memory.LastGC = s.GoInfo.Memory.mem.LastGC s.GoInfo.Memory.NumGC = s.GoInfo.Memory.mem.NumGC - s.GoInfo.Memory.lastNumGC s.GoInfo.Memory.lastNumGC = s.GoInfo.Memory.mem.NumGC s.GoInfo.Memory.LastGCPauseDuration = s.GoInfo.Memory.mem.PauseNs[(s.GoInfo.Memory.mem.NumGC+255)%256] } else { s.GoInfo.Memory.NumGC = 0 s.GoInfo.Memory.LastGCPauseDuration = 0 } } if logMemory { if s.MemInfo == nil { s.MemInfo = new(MemInfo) } s.MemInfo.Memory, _ = mem.VirtualMemory() s.MemInfo.Swap, _ = mem.SwapMemory() } } ================================================ FILE: stats_test.go ================================================ package stats import ( "os" "testing" "time" . "gopkg.in/go-playground/assert.v1" ) // NOTES: // - Run "go test" to run tests // - Run "gocov test | gocov report" to report on test converage by file // - Run "gocov test | gocov annotate -" to report on all code and functions, those ,marked with "MISS" were never called // // or // // -- may be a good idea to change to output path to somewherelike /tmp // go test -coverprofile cover.out && go tool cover -html=cover.out -o cover.html // func TestMain(m *testing.M) { // setup // // setup server for tests config := &ServerConfig{ Domain: "", Port: 3010, } server, err := NewServer(config) if err != nil { panic(err) } go server.Run() <-time.Tick(time.Second * 1) os.Exit(m.Run()) // teardown } func TestClientSendingData(t *testing.T) { serverConfig := &ServerConfig{ Domain: "", Port: 3010, } localConfig := &ClientConfig{ Domain: "", Port: 3011, PollInterval: 1000, LogHostInfo: true, LogCPUInfo: true, LogTotalCPUTimes: true, LogPerCPUTimes: true, LogMemory: true, LogGoMemory: true, } client, err := NewClient(localConfig, serverConfig) Equal(t, err, nil) go client.Run() ticker := time.NewTicker(time.Second * 1) i := 0 for range ticker.C { if i == 1 { client.Stop() return } i++ } } ================================================ FILE: vendor/github.com/StackExchange/wmi/LICENSE ================================================ The MIT License (MIT) Copyright (c) 2013 Stack Exchange Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: vendor/github.com/StackExchange/wmi/README.md ================================================ wmi === Package wmi provides a WQL interface for WMI on Windows. ================================================ FILE: vendor/github.com/StackExchange/wmi/wmi.go ================================================ // +build windows /* Package wmi provides a WQL interface for WMI on Windows. Example code to print names of running processes: type Win32_Process struct { Name string } func main() { var dst []Win32_Process q := wmi.CreateQuery(&dst, "") err := wmi.Query(q, &dst) if err != nil { log.Fatal(err) } for i, v := range dst { println(i, v.Name) } } */ package wmi import ( "bytes" "errors" "fmt" "log" "os" "reflect" "runtime" "strconv" "strings" "sync" "time" "github.com/go-ole/go-ole" "github.com/go-ole/go-ole/oleutil" ) var l = log.New(os.Stdout, "", log.LstdFlags) var ( ErrInvalidEntityType = errors.New("wmi: invalid entity type") // ErrNilCreateObject is the error returned if CreateObject returns nil even // if the error was nil. ErrNilCreateObject = errors.New("wmi: create object returned nil") lock sync.Mutex ) // S_FALSE is returned by CoInitializeEx if it was already called on this thread. const S_FALSE = 0x00000001 // QueryNamespace invokes Query with the given namespace on the local machine. func QueryNamespace(query string, dst interface{}, namespace string) error { return Query(query, dst, nil, namespace) } // Query runs the WQL query and appends the values to dst. // // dst must have type *[]S or *[]*S, for some struct type S. Fields selected in // the query must have the same name in dst. Supported types are all signed and // unsigned integers, time.Time, string, bool, or a pointer to one of those. // Array types are not supported. // // By default, the local machine and default namespace are used. These can be // changed using connectServerArgs. See // http://msdn.microsoft.com/en-us/library/aa393720.aspx for details. // // Query is a wrapper around DefaultClient.Query. func Query(query string, dst interface{}, connectServerArgs ...interface{}) error { return DefaultClient.Query(query, dst, connectServerArgs...) } // A Client is an WMI query client. // // Its zero value (DefaultClient) is a usable client. type Client struct { // NonePtrZero specifies if nil values for fields which aren't pointers // should be returned as the field types zero value. // // Setting this to true allows stucts without pointer fields to be used // without the risk failure should a nil value returned from WMI. NonePtrZero bool // PtrNil specifies if nil values for pointer fields should be returned // as nil. // // Setting this to true will set pointer fields to nil where WMI // returned nil, otherwise the types zero value will be returned. PtrNil bool // AllowMissingFields specifies that struct fields not present in the // query result should not result in an error. // // Setting this to true allows custom queries to be used with full // struct definitions instead of having to define multiple structs. AllowMissingFields bool } // DefaultClient is the default Client and is used by Query, QueryNamespace var DefaultClient = &Client{} // Query runs the WQL query and appends the values to dst. // // dst must have type *[]S or *[]*S, for some struct type S. Fields selected in // the query must have the same name in dst. Supported types are all signed and // unsigned integers, time.Time, string, bool, or a pointer to one of those. // Array types are not supported. // // By default, the local machine and default namespace are used. These can be // changed using connectServerArgs. See // http://msdn.microsoft.com/en-us/library/aa393720.aspx for details. func (c *Client) Query(query string, dst interface{}, connectServerArgs ...interface{}) error { dv := reflect.ValueOf(dst) if dv.Kind() != reflect.Ptr || dv.IsNil() { return ErrInvalidEntityType } dv = dv.Elem() mat, elemType := checkMultiArg(dv) if mat == multiArgTypeInvalid { return ErrInvalidEntityType } lock.Lock() defer lock.Unlock() runtime.LockOSThread() defer runtime.UnlockOSThread() err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED) if err != nil { oleCode := err.(*ole.OleError).Code() if oleCode != ole.S_OK && oleCode != S_FALSE { return err } } defer ole.CoUninitialize() unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator") if err != nil { return err } else if unknown == nil { return ErrNilCreateObject } defer unknown.Release() wmi, err := unknown.QueryInterface(ole.IID_IDispatch) if err != nil { return err } defer wmi.Release() // service is a SWbemServices serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", connectServerArgs...) if err != nil { return err } service := serviceRaw.ToIDispatch() defer serviceRaw.Clear() // result is a SWBemObjectSet resultRaw, err := oleutil.CallMethod(service, "ExecQuery", query) if err != nil { return err } result := resultRaw.ToIDispatch() defer resultRaw.Clear() count, err := oleInt64(result, "Count") if err != nil { return err } enumProperty, err := result.GetProperty("_NewEnum") if err != nil { return err } defer enumProperty.Clear() enum, err := enumProperty.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant) if err != nil { return err } if enum == nil { return fmt.Errorf("can't get IEnumVARIANT, enum is nil") } defer enum.Release() // Initialize a slice with Count capacity dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count))) var errFieldMismatch error for itemRaw, length, err := enum.Next(1); length > 0; itemRaw, length, err = enum.Next(1) { if err != nil { return err } err := func() error { // item is a SWbemObject, but really a Win32_Process item := itemRaw.ToIDispatch() defer item.Release() ev := reflect.New(elemType) if err = c.loadEntity(ev.Interface(), item); err != nil { if _, ok := err.(*ErrFieldMismatch); ok { // We continue loading entities even in the face of field mismatch errors. // If we encounter any other error, that other error is returned. Otherwise, // an ErrFieldMismatch is returned. errFieldMismatch = err } else { return err } } if mat != multiArgTypeStructPtr { ev = ev.Elem() } dv.Set(reflect.Append(dv, ev)) return nil }() if err != nil { return err } } return errFieldMismatch } // ErrFieldMismatch is returned when a field is to be loaded into a different // type than the one it was stored from, or when a field is missing or // unexported in the destination struct. // StructType is the type of the struct pointed to by the destination argument. type ErrFieldMismatch struct { StructType reflect.Type FieldName string Reason string } func (e *ErrFieldMismatch) Error() string { return fmt.Sprintf("wmi: cannot load field %q into a %q: %s", e.FieldName, e.StructType, e.Reason) } var timeType = reflect.TypeOf(time.Time{}) // loadEntity loads a SWbemObject into a struct pointer. func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismatch error) { v := reflect.ValueOf(dst).Elem() for i := 0; i < v.NumField(); i++ { f := v.Field(i) of := f isPtr := f.Kind() == reflect.Ptr if isPtr { ptr := reflect.New(f.Type().Elem()) f.Set(ptr) f = f.Elem() } n := v.Type().Field(i).Name if !f.CanSet() { return &ErrFieldMismatch{ StructType: of.Type(), FieldName: n, Reason: "CanSet() is false", } } prop, err := oleutil.GetProperty(src, n) if err != nil { if !c.AllowMissingFields { errFieldMismatch = &ErrFieldMismatch{ StructType: of.Type(), FieldName: n, Reason: "no such struct field", } } continue } defer prop.Clear() switch val := prop.Value().(type) { case int8, int16, int32, int64, int: v := reflect.ValueOf(val).Int() switch f.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: f.SetInt(v) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: f.SetUint(uint64(v)) default: return &ErrFieldMismatch{ StructType: of.Type(), FieldName: n, Reason: "not an integer class", } } case uint8, uint16, uint32, uint64: v := reflect.ValueOf(val).Uint() switch f.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: f.SetInt(int64(v)) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: f.SetUint(v) default: return &ErrFieldMismatch{ StructType: of.Type(), FieldName: n, Reason: "not an integer class", } } case string: switch f.Kind() { case reflect.String: f.SetString(val) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: iv, err := strconv.ParseInt(val, 10, 64) if err != nil { return err } f.SetInt(iv) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: uv, err := strconv.ParseUint(val, 10, 64) if err != nil { return err } f.SetUint(uv) case reflect.Struct: switch f.Type() { case timeType: if len(val) == 25 { mins, err := strconv.Atoi(val[22:]) if err != nil { return err } val = val[:22] + fmt.Sprintf("%02d%02d", mins/60, mins%60) } t, err := time.Parse("20060102150405.000000-0700", val) if err != nil { return err } f.Set(reflect.ValueOf(t)) } } case bool: switch f.Kind() { case reflect.Bool: f.SetBool(val) default: return &ErrFieldMismatch{ StructType: of.Type(), FieldName: n, Reason: "not a bool", } } case float32: switch f.Kind() { case reflect.Float32: f.SetFloat(float64(val)) default: return &ErrFieldMismatch{ StructType: of.Type(), FieldName: n, Reason: "not a Float32", } } default: typeof := reflect.TypeOf(val) if typeof == nil && (isPtr || c.NonePtrZero) { if (isPtr && c.PtrNil) || (!isPtr && c.NonePtrZero) { of.Set(reflect.Zero(of.Type())) } break } return &ErrFieldMismatch{ StructType: of.Type(), FieldName: n, Reason: fmt.Sprintf("unsupported type (%T)", val), } } } return errFieldMismatch } type multiArgType int const ( multiArgTypeInvalid multiArgType = iota multiArgTypeStruct multiArgTypeStructPtr ) // checkMultiArg checks that v has type []S, []*S for some struct type S. // // It returns what category the slice's elements are, and the reflect.Type // that represents S. func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) { if v.Kind() != reflect.Slice { return multiArgTypeInvalid, nil } elemType = v.Type().Elem() switch elemType.Kind() { case reflect.Struct: return multiArgTypeStruct, elemType case reflect.Ptr: elemType = elemType.Elem() if elemType.Kind() == reflect.Struct { return multiArgTypeStructPtr, elemType } } return multiArgTypeInvalid, nil } func oleInt64(item *ole.IDispatch, prop string) (int64, error) { v, err := oleutil.GetProperty(item, prop) if err != nil { return 0, err } defer v.Clear() i := int64(v.Val) return i, nil } // CreateQuery returns a WQL query string that queries all columns of src. where // is an optional string that is appended to the query, to be used with WHERE // clauses. In such a case, the "WHERE" string should appear at the beginning. func CreateQuery(src interface{}, where string) string { var b bytes.Buffer b.WriteString("SELECT ") s := reflect.Indirect(reflect.ValueOf(src)) t := s.Type() if s.Kind() == reflect.Slice { t = t.Elem() } if t.Kind() != reflect.Struct { return "" } var fields []string for i := 0; i < t.NumField(); i++ { fields = append(fields, t.Field(i).Name) } b.WriteString(strings.Join(fields, ", ")) b.WriteString(" FROM ") b.WriteString(t.Name()) b.WriteString(" " + where) return b.String() } ================================================ FILE: vendor/github.com/go-ole/go-ole/ChangeLog.md ================================================ # Version 1.x.x * **Add more test cases and reference new test COM server project.** (Placeholder for future additions) # Version 1.2.0-alphaX **Minimum supported version is now Go 1.4. Go 1.1 support is deprecated, but should still build.** * Added CI configuration for Travis-CI and AppVeyor. * Added test InterfaceID and ClassID for the COM Test Server project. * Added more inline documentation (#83). * Added IEnumVARIANT implementation (#88). * Added IEnumVARIANT test cases (#99, #100, #101). * Added support for retrieving `time.Time` from VARIANT (#92). * Added test case for IUnknown (#64). * Added test case for IDispatch (#64). * Added test cases for scalar variants (#64, #76). # Version 1.1.1 * Fixes for Linux build. * Fixes for Windows build. # Version 1.1.0 The change to provide building on all platforms is a new feature. The increase in minor version reflects that and allows those who wish to stay on 1.0.x to continue to do so. Support for 1.0.x will be limited to bug fixes. * Move GUID out of variables.go into its own file to make new documentation available. * Move OleError out of ole.go into its own file to make new documentation available. * Add documentation to utility functions. * Add documentation to variant receiver functions. * Add documentation to ole structures. * Make variant available to other systems outside of Windows. * Make OLE structures available to other systems outside of Windows. ## New Features * Library should now be built on all platforms supported by Go. Library will NOOP on any platform that is not Windows. * More functions are now documented and available on godoc.org. # Version 1.0.1 1. Fix package references from repository location change. # Version 1.0.0 This version is stable enough for use. The COM API is still incomplete, but provides enough functionality for accessing COM servers using IDispatch interface. There is no changelog for this version. Check commits for history. ================================================ FILE: vendor/github.com/go-ole/go-ole/README.md ================================================ #Go OLE [![Build status](https://ci.appveyor.com/api/projects/status/qr0u2sf7q43us9fj?svg=true)](https://ci.appveyor.com/project/jacobsantos/go-ole-jgs28) [![Build Status](https://travis-ci.org/go-ole/go-ole.svg?branch=master)](https://travis-ci.org/go-ole/go-ole) [![GoDoc](https://godoc.org/github.com/go-ole/go-ole?status.svg)](https://godoc.org/github.com/go-ole/go-ole) Go bindings for Windows COM using shared libraries instead of cgo. By Yasuhiro Matsumoto. ## Install To experiment with go-ole, you can just compile and run the example program: ``` go get github.com/go-ole/go-ole cd /path/to/go-ole/ go test cd /path/to/go-ole/example/excel go run excel.go ``` ## Continuous Integration Continuous integration configuration has been added for both Travis-CI and AppVeyor. You will have to add these to your own account for your fork in order for it to run. **Travis-CI** Travis-CI was added to check builds on Linux to ensure that `go get` works when cross building. Currently, Travis-CI is not used to test cross-building, but this may be changed in the future. It is also not currently possible to test the library on Linux, since COM API is specific to Windows and it is not currently possible to run a COM server on Linux or even connect to a remote COM server. **AppVeyor** AppVeyor is used to build on Windows using the (in-development) test COM server. It is currently only used to test the build and ensure that the code works on Windows. It will be used to register a COM server and then run the test cases based on the test COM server. The tests currently do run and do pass and this should be maintained with commits. ##Versioning Go OLE uses [semantic versioning](http://semver.org) for version numbers, which is similar to the version contract of the Go language. Which means that the major version will always maintain backwards compatibility with minor versions. Minor versions will only add new additions and changes. Fixes will always be in patch. This contract should allow you to upgrade to new minor and patch versions without breakage or modifications to your existing code. Leave a ticket, if there is breakage, so that it could be fixed. ##LICENSE Under the MIT License: http://mattn.mit-license.org/2013 ================================================ FILE: vendor/github.com/go-ole/go-ole/appveyor.yml ================================================ # Notes: # - Minimal appveyor.yml file is an empty file. All sections are optional. # - Indent each level of configuration with 2 spaces. Do not use tabs! # - All section names are case-sensitive. # - Section names should be unique on each level. version: "1.3.0.{build}-alpha-{branch}" os: Windows Server 2012 R2 branches: only: - master - v1.2 - v1.1 - v1.0 skip_tags: true clone_folder: c:\gopath\src\github.com\go-ole\go-ole environment: GOPATH: c:\gopath matrix: - GOARCH: amd64 GOVERSION: 1.4 GOROOT: c:\go DOWNLOADPLATFORM: "x64" install: - choco install mingw - SET PATH=c:\tools\mingw64\bin;%PATH% # - Download COM Server - ps: Start-FileDownload "https://github.com/go-ole/test-com-server/releases/download/v1.0.2/test-com-server-${env:DOWNLOADPLATFORM}.zip" - 7z e test-com-server-%DOWNLOADPLATFORM%.zip -oc:\gopath\src\github.com\go-ole\go-ole > NUL - c:\gopath\src\github.com\go-ole\go-ole\build\register-assembly.bat # - set - go version - go env - c:\gopath\src\github.com\go-ole\go-ole\build\compile-go.bat - go tool dist install -v cmd/8a - go tool dist install -v cmd/8c - go tool dist install -v cmd/8g - go tool dist install -v cmd/8l - go tool dist install -v cmd/6a - go tool dist install -v cmd/6c - go tool dist install -v cmd/6g - go tool dist install -v cmd/6l - go get -u golang.org/x/tools/cmd/cover - go get -u golang.org/x/tools/cmd/godoc - go get -u golang.org/x/tools/cmd/stringer build_script: - cd c:\gopath\src\github.com\go-ole\go-ole - go get -v -t ./... - go build - go test -v -cover ./... # disable automatic tests test: off # disable deployment deploy: off ================================================ FILE: vendor/github.com/go-ole/go-ole/com.go ================================================ // +build windows package ole import ( "errors" "syscall" "time" "unicode/utf16" "unsafe" ) var ( procCoInitialize, _ = modole32.FindProc("CoInitialize") procCoInitializeEx, _ = modole32.FindProc("CoInitializeEx") procCoUninitialize, _ = modole32.FindProc("CoUninitialize") procCoCreateInstance, _ = modole32.FindProc("CoCreateInstance") procCoTaskMemFree, _ = modole32.FindProc("CoTaskMemFree") procCLSIDFromProgID, _ = modole32.FindProc("CLSIDFromProgID") procCLSIDFromString, _ = modole32.FindProc("CLSIDFromString") procStringFromCLSID, _ = modole32.FindProc("StringFromCLSID") procStringFromIID, _ = modole32.FindProc("StringFromIID") procIIDFromString, _ = modole32.FindProc("IIDFromString") procGetUserDefaultLCID, _ = modkernel32.FindProc("GetUserDefaultLCID") procCopyMemory, _ = modkernel32.FindProc("RtlMoveMemory") procVariantInit, _ = modoleaut32.FindProc("VariantInit") procVariantClear, _ = modoleaut32.FindProc("VariantClear") procVariantTimeToSystemTime, _ = modoleaut32.FindProc("VariantTimeToSystemTime") procSysAllocString, _ = modoleaut32.FindProc("SysAllocString") procSysAllocStringLen, _ = modoleaut32.FindProc("SysAllocStringLen") procSysFreeString, _ = modoleaut32.FindProc("SysFreeString") procSysStringLen, _ = modoleaut32.FindProc("SysStringLen") procCreateDispTypeInfo, _ = modoleaut32.FindProc("CreateDispTypeInfo") procCreateStdDispatch, _ = modoleaut32.FindProc("CreateStdDispatch") procGetActiveObject, _ = modoleaut32.FindProc("GetActiveObject") procGetMessageW, _ = moduser32.FindProc("GetMessageW") procDispatchMessageW, _ = moduser32.FindProc("DispatchMessageW") ) // coInitialize initializes COM library on current thread. // // MSDN documentation suggests that this function should not be called. Call // CoInitializeEx() instead. The reason has to do with threading and this // function is only for single-threaded apartments. // // That said, most users of the library have gotten away with just this // function. If you are experiencing threading issues, then use // CoInitializeEx(). func coInitialize() (err error) { // http://msdn.microsoft.com/en-us/library/windows/desktop/ms678543(v=vs.85).aspx // Suggests that no value should be passed to CoInitialized. // Could just be Call() since the parameter is optional. <-- Needs testing to be sure. hr, _, _ := procCoInitialize.Call(uintptr(0)) if hr != 0 { err = NewError(hr) } return } // coInitializeEx initializes COM library with concurrency model. func coInitializeEx(coinit uint32) (err error) { // http://msdn.microsoft.com/en-us/library/windows/desktop/ms695279(v=vs.85).aspx // Suggests that the first parameter is not only optional but should always be NULL. hr, _, _ := procCoInitializeEx.Call(uintptr(0), uintptr(coinit)) if hr != 0 { err = NewError(hr) } return } // CoInitialize initializes COM library on current thread. // // MSDN documentation suggests that this function should not be called. Call // CoInitializeEx() instead. The reason has to do with threading and this // function is only for single-threaded apartments. // // That said, most users of the library have gotten away with just this // function. If you are experiencing threading issues, then use // CoInitializeEx(). func CoInitialize(p uintptr) (err error) { // p is ignored and won't be used. // Avoid any variable not used errors. p = uintptr(0) return coInitialize() } // CoInitializeEx initializes COM library with concurrency model. func CoInitializeEx(p uintptr, coinit uint32) (err error) { // Avoid any variable not used errors. p = uintptr(0) return coInitializeEx(coinit) } // CoUninitialize uninitializes COM Library. func CoUninitialize() { procCoUninitialize.Call() } // CoTaskMemFree frees memory pointer. func CoTaskMemFree(memptr uintptr) { procCoTaskMemFree.Call(memptr) } // CLSIDFromProgID retrieves Class Identifier with the given Program Identifier. // // The Programmatic Identifier must be registered, because it will be looked up // in the Windows Registry. The registry entry has the following keys: CLSID, // Insertable, Protocol and Shell // (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx). // // programID identifies the class id with less precision and is not guaranteed // to be unique. These are usually found in the registry under // HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of // "Program.Component.Version" with version being optional. // // CLSIDFromProgID in Windows API. func CLSIDFromProgID(progId string) (clsid *GUID, err error) { var guid GUID lpszProgID := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId))) hr, _, _ := procCLSIDFromProgID.Call(lpszProgID, uintptr(unsafe.Pointer(&guid))) if hr != 0 { err = NewError(hr) } clsid = &guid return } // CLSIDFromString retrieves Class ID from string representation. // // This is technically the string version of the GUID and will convert the // string to object. // // CLSIDFromString in Windows API. func CLSIDFromString(str string) (clsid *GUID, err error) { var guid GUID lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(str))) hr, _, _ := procCLSIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid))) if hr != 0 { err = NewError(hr) } clsid = &guid return } // StringFromCLSID returns GUID formated string from GUID object. func StringFromCLSID(clsid *GUID) (str string, err error) { var p *uint16 hr, _, _ := procStringFromCLSID.Call(uintptr(unsafe.Pointer(clsid)), uintptr(unsafe.Pointer(&p))) if hr != 0 { err = NewError(hr) } str = LpOleStrToString(p) return } // IIDFromString returns GUID from program ID. func IIDFromString(progId string) (clsid *GUID, err error) { var guid GUID lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId))) hr, _, _ := procIIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid))) if hr != 0 { err = NewError(hr) } clsid = &guid return } // StringFromIID returns GUID formatted string from GUID object. func StringFromIID(iid *GUID) (str string, err error) { var p *uint16 hr, _, _ := procStringFromIID.Call(uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&p))) if hr != 0 { err = NewError(hr) } str = LpOleStrToString(p) return } // CreateInstance of single uninitialized object with GUID. func CreateInstance(clsid *GUID, iid *GUID) (unk *IUnknown, err error) { if iid == nil { iid = IID_IUnknown } hr, _, _ := procCoCreateInstance.Call( uintptr(unsafe.Pointer(clsid)), 0, CLSCTX_SERVER, uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&unk))) if hr != 0 { err = NewError(hr) } return } // GetActiveObject retrieves pointer to active object. func GetActiveObject(clsid *GUID, iid *GUID) (unk *IUnknown, err error) { if iid == nil { iid = IID_IUnknown } hr, _, _ := procGetActiveObject.Call( uintptr(unsafe.Pointer(clsid)), uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&unk))) if hr != 0 { err = NewError(hr) } return } // VariantInit initializes variant. func VariantInit(v *VARIANT) (err error) { hr, _, _ := procVariantInit.Call(uintptr(unsafe.Pointer(v))) if hr != 0 { err = NewError(hr) } return } // VariantClear clears value in Variant settings to VT_EMPTY. func VariantClear(v *VARIANT) (err error) { hr, _, _ := procVariantClear.Call(uintptr(unsafe.Pointer(v))) if hr != 0 { err = NewError(hr) } return } // SysAllocString allocates memory for string and copies string into memory. func SysAllocString(v string) (ss *int16) { pss, _, _ := procSysAllocString.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(v)))) ss = (*int16)(unsafe.Pointer(pss)) return } // SysAllocStringLen copies up to length of given string returning pointer. func SysAllocStringLen(v string) (ss *int16) { utf16 := utf16.Encode([]rune(v + "\x00")) ptr := &utf16[0] pss, _, _ := procSysAllocStringLen.Call(uintptr(unsafe.Pointer(ptr)), uintptr(len(utf16)-1)) ss = (*int16)(unsafe.Pointer(pss)) return } // SysFreeString frees string system memory. This must be called with SysAllocString. func SysFreeString(v *int16) (err error) { hr, _, _ := procSysFreeString.Call(uintptr(unsafe.Pointer(v))) if hr != 0 { err = NewError(hr) } return } // SysStringLen is the length of the system allocated string. func SysStringLen(v *int16) uint32 { l, _, _ := procSysStringLen.Call(uintptr(unsafe.Pointer(v))) return uint32(l) } // CreateStdDispatch provides default IDispatch implementation for IUnknown. // // This handles default IDispatch implementation for objects. It haves a few // limitations with only supporting one language. It will also only return // default exception codes. func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (disp *IDispatch, err error) { hr, _, _ := procCreateStdDispatch.Call( uintptr(unsafe.Pointer(unk)), v, uintptr(unsafe.Pointer(ptinfo)), uintptr(unsafe.Pointer(&disp))) if hr != 0 { err = NewError(hr) } return } // CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch. // // This will not handle the full implementation of the interface. func CreateDispTypeInfo(idata *INTERFACEDATA) (pptinfo *IUnknown, err error) { hr, _, _ := procCreateDispTypeInfo.Call( uintptr(unsafe.Pointer(idata)), uintptr(GetUserDefaultLCID()), uintptr(unsafe.Pointer(&pptinfo))) if hr != 0 { err = NewError(hr) } return } // copyMemory moves location of a block of memory. func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) { procCopyMemory.Call(uintptr(dest), uintptr(src), uintptr(length)) } // GetUserDefaultLCID retrieves current user default locale. func GetUserDefaultLCID() (lcid uint32) { ret, _, _ := procGetUserDefaultLCID.Call() lcid = uint32(ret) return } // GetMessage in message queue from runtime. // // This function appears to block. PeekMessage does not block. func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, err error) { r0, _, err := procGetMessageW.Call(uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax)) ret = int32(r0) return } // DispatchMessage to window procedure. func DispatchMessage(msg *Msg) (ret int32) { r0, _, _ := procDispatchMessageW.Call(uintptr(unsafe.Pointer(msg))) ret = int32(r0) return } // GetVariantDate converts COM Variant Time value to Go time.Time. func GetVariantDate(value float64) (time.Time, error) { var st syscall.Systemtime r, _, _ := procVariantTimeToSystemTime.Call(uintptr(unsafe.Pointer(&value)), uintptr(unsafe.Pointer(&st))) if r != 0 { return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), nil), nil } return time.Now(), errors.New("Could not convert to time, passing current time.") } ================================================ FILE: vendor/github.com/go-ole/go-ole/com_func.go ================================================ // +build !windows package ole import ( "time" "unsafe" ) // coInitialize initializes COM library on current thread. // // MSDN documentation suggests that this function should not be called. Call // CoInitializeEx() instead. The reason has to do with threading and this // function is only for single-threaded apartments. // // That said, most users of the library have gotten away with just this // function. If you are experiencing threading issues, then use // CoInitializeEx(). func coInitialize() error { return NewError(E_NOTIMPL) } // coInitializeEx initializes COM library with concurrency model. func coInitializeEx(coinit uint32) error { return NewError(E_NOTIMPL) } // CoInitialize initializes COM library on current thread. // // MSDN documentation suggests that this function should not be called. Call // CoInitializeEx() instead. The reason has to do with threading and this // function is only for single-threaded apartments. // // That said, most users of the library have gotten away with just this // function. If you are experiencing threading issues, then use // CoInitializeEx(). func CoInitialize(p uintptr) error { return NewError(E_NOTIMPL) } // CoInitializeEx initializes COM library with concurrency model. func CoInitializeEx(p uintptr, coinit uint32) error { return NewError(E_NOTIMPL) } // CoUninitialize uninitializes COM Library. func CoUninitialize() {} // CoTaskMemFree frees memory pointer. func CoTaskMemFree(memptr uintptr) {} // CLSIDFromProgID retrieves Class Identifier with the given Program Identifier. // // The Programmatic Identifier must be registered, because it will be looked up // in the Windows Registry. The registry entry has the following keys: CLSID, // Insertable, Protocol and Shell // (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx). // // programID identifies the class id with less precision and is not guaranteed // to be unique. These are usually found in the registry under // HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of // "Program.Component.Version" with version being optional. // // CLSIDFromProgID in Windows API. func CLSIDFromProgID(progId string) (*GUID, error) { return nil, NewError(E_NOTIMPL) } // CLSIDFromString retrieves Class ID from string representation. // // This is technically the string version of the GUID and will convert the // string to object. // // CLSIDFromString in Windows API. func CLSIDFromString(str string) (*GUID, error) { return nil, NewError(E_NOTIMPL) } // StringFromCLSID returns GUID formated string from GUID object. func StringFromCLSID(clsid *GUID) (string, error) { return "", NewError(E_NOTIMPL) } // IIDFromString returns GUID from program ID. func IIDFromString(progId string) (*GUID, error) { return nil, NewError(E_NOTIMPL) } // StringFromIID returns GUID formatted string from GUID object. func StringFromIID(iid *GUID) (string, error) { return "", NewError(E_NOTIMPL) } // CreateInstance of single uninitialized object with GUID. func CreateInstance(clsid *GUID, iid *GUID) (*IUnknown, error) { return nil, NewError(E_NOTIMPL) } // GetActiveObject retrieves pointer to active object. func GetActiveObject(clsid *GUID, iid *GUID) (*IUnknown, error) { return nil, NewError(E_NOTIMPL) } // VariantInit initializes variant. func VariantInit(v *VARIANT) error { return NewError(E_NOTIMPL) } // VariantClear clears value in Variant settings to VT_EMPTY. func VariantClear(v *VARIANT) error { return NewError(E_NOTIMPL) } // SysAllocString allocates memory for string and copies string into memory. func SysAllocString(v string) *int16 { u := int16(0) return &u } // SysAllocStringLen copies up to length of given string returning pointer. func SysAllocStringLen(v string) *int16 { u := int16(0) return &u } // SysFreeString frees string system memory. This must be called with SysAllocString. func SysFreeString(v *int16) error { return NewError(E_NOTIMPL) } // SysStringLen is the length of the system allocated string. func SysStringLen(v *int16) uint32 { return uint32(0) } // CreateStdDispatch provides default IDispatch implementation for IUnknown. // // This handles default IDispatch implementation for objects. It haves a few // limitations with only supporting one language. It will also only return // default exception codes. func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (*IDispatch, error) { return nil, NewError(E_NOTIMPL) } // CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch. // // This will not handle the full implementation of the interface. func CreateDispTypeInfo(idata *INTERFACEDATA) (*IUnknown, error) { return nil, NewError(E_NOTIMPL) } // copyMemory moves location of a block of memory. func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {} // GetUserDefaultLCID retrieves current user default locale. func GetUserDefaultLCID() uint32 { return uint32(0) } // GetMessage in message queue from runtime. // // This function appears to block. PeekMessage does not block. func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (int32, error) { return int32(0), NewError(E_NOTIMPL) } // DispatchMessage to window procedure. func DispatchMessage(msg *Msg) int32 { return int32(0) } func GetVariantDate(value float64) (time.Time, error) { return time.Now(), NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/connect.go ================================================ package ole // Connection contains IUnknown for fluent interface interaction. // // Deprecated. Use oleutil package instead. type Connection struct { Object *IUnknown // Access COM } // Initialize COM. func (*Connection) Initialize() (err error) { return coInitialize() } // Uninitialize COM. func (*Connection) Uninitialize() { CoUninitialize() } // Create IUnknown object based first on ProgId and then from String. func (c *Connection) Create(progId string) (err error) { var clsid *GUID clsid, err = CLSIDFromProgID(progId) if err != nil { clsid, err = CLSIDFromString(progId) if err != nil { return } } unknown, err := CreateInstance(clsid, IID_IUnknown) if err != nil { return } c.Object = unknown return } // Release IUnknown object. func (c *Connection) Release() { c.Object.Release() } // Load COM object from list of programIDs or strings. func (c *Connection) Load(names ...string) (errors []error) { var tempErrors []error = make([]error, len(names)) var numErrors int = 0 for _, name := range names { err := c.Create(name) if err != nil { tempErrors = append(tempErrors, err) numErrors += 1 continue } break } copy(errors, tempErrors[0:numErrors]) return } // Dispatch returns Dispatch object. func (c *Connection) Dispatch() (object *Dispatch, err error) { dispatch, err := c.Object.QueryInterface(IID_IDispatch) if err != nil { return } object = &Dispatch{dispatch} return } // Dispatch stores IDispatch object. type Dispatch struct { Object *IDispatch // Dispatch object. } // Call method on IDispatch with parameters. func (d *Dispatch) Call(method string, params ...interface{}) (result *VARIANT, err error) { id, err := d.GetId(method) if err != nil { return } result, err = d.Invoke(id, DISPATCH_METHOD, params) return } // MustCall method on IDispatch with parameters. func (d *Dispatch) MustCall(method string, params ...interface{}) (result *VARIANT) { id, err := d.GetId(method) if err != nil { panic(err) } result, err = d.Invoke(id, DISPATCH_METHOD, params) if err != nil { panic(err) } return } // Get property on IDispatch with parameters. func (d *Dispatch) Get(name string, params ...interface{}) (result *VARIANT, err error) { id, err := d.GetId(name) if err != nil { return } result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params) return } // MustGet property on IDispatch with parameters. func (d *Dispatch) MustGet(name string, params ...interface{}) (result *VARIANT) { id, err := d.GetId(name) if err != nil { panic(err) } result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params) if err != nil { panic(err) } return } // Set property on IDispatch with parameters. func (d *Dispatch) Set(name string, params ...interface{}) (result *VARIANT, err error) { id, err := d.GetId(name) if err != nil { return } result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params) return } // MustSet property on IDispatch with parameters. func (d *Dispatch) MustSet(name string, params ...interface{}) (result *VARIANT) { id, err := d.GetId(name) if err != nil { panic(err) } result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params) if err != nil { panic(err) } return } // GetId retrieves ID of name on IDispatch. func (d *Dispatch) GetId(name string) (id int32, err error) { var dispid []int32 dispid, err = d.Object.GetIDsOfName([]string{name}) if err != nil { return } id = dispid[0] return } // GetIds retrieves all IDs of names on IDispatch. func (d *Dispatch) GetIds(names ...string) (dispid []int32, err error) { dispid, err = d.Object.GetIDsOfName(names) return } // Invoke IDispatch on DisplayID of dispatch type with parameters. // // There have been problems where if send cascading params..., it would error // out because the parameters would be empty. func (d *Dispatch) Invoke(id int32, dispatch int16, params []interface{}) (result *VARIANT, err error) { if len(params) < 1 { result, err = d.Object.Invoke(id, dispatch) } else { result, err = d.Object.Invoke(id, dispatch, params...) } return } // Release IDispatch object. func (d *Dispatch) Release() { d.Object.Release() } // Connect initializes COM and attempts to load IUnknown based on given names. func Connect(names ...string) (connection *Connection) { connection.Initialize() connection.Load(names...) return } ================================================ FILE: vendor/github.com/go-ole/go-ole/constants.go ================================================ package ole const ( CLSCTX_INPROC_SERVER = 1 CLSCTX_INPROC_HANDLER = 2 CLSCTX_LOCAL_SERVER = 4 CLSCTX_INPROC_SERVER16 = 8 CLSCTX_REMOTE_SERVER = 16 CLSCTX_ALL = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER ) const ( COINIT_APARTMENTTHREADED = 0x2 COINIT_MULTITHREADED = 0x0 COINIT_DISABLE_OLE1DDE = 0x4 COINIT_SPEED_OVER_MEMORY = 0x8 ) const ( DISPATCH_METHOD = 1 DISPATCH_PROPERTYGET = 2 DISPATCH_PROPERTYPUT = 4 DISPATCH_PROPERTYPUTREF = 8 ) const ( S_OK = 0x00000000 E_UNEXPECTED = 0x8000FFFF E_NOTIMPL = 0x80004001 E_OUTOFMEMORY = 0x8007000E E_INVALIDARG = 0x80070057 E_NOINTERFACE = 0x80004002 E_POINTER = 0x80004003 E_HANDLE = 0x80070006 E_ABORT = 0x80004004 E_FAIL = 0x80004005 E_ACCESSDENIED = 0x80070005 E_PENDING = 0x8000000A CO_E_CLASSSTRING = 0x800401F3 ) const ( CC_FASTCALL = iota CC_CDECL CC_MSCPASCAL CC_PASCAL = CC_MSCPASCAL CC_MACPASCAL CC_STDCALL CC_FPFASTCALL CC_SYSCALL CC_MPWCDECL CC_MPWPASCAL CC_MAX = CC_MPWPASCAL ) type VT uint16 const ( VT_EMPTY VT = 0x0 VT_NULL VT = 0x1 VT_I2 VT = 0x2 VT_I4 VT = 0x3 VT_R4 VT = 0x4 VT_R8 VT = 0x5 VT_CY VT = 0x6 VT_DATE VT = 0x7 VT_BSTR VT = 0x8 VT_DISPATCH VT = 0x9 VT_ERROR VT = 0xa VT_BOOL VT = 0xb VT_VARIANT VT = 0xc VT_UNKNOWN VT = 0xd VT_DECIMAL VT = 0xe VT_I1 VT = 0x10 VT_UI1 VT = 0x11 VT_UI2 VT = 0x12 VT_UI4 VT = 0x13 VT_I8 VT = 0x14 VT_UI8 VT = 0x15 VT_INT VT = 0x16 VT_UINT VT = 0x17 VT_VOID VT = 0x18 VT_HRESULT VT = 0x19 VT_PTR VT = 0x1a VT_SAFEARRAY VT = 0x1b VT_CARRAY VT = 0x1c VT_USERDEFINED VT = 0x1d VT_LPSTR VT = 0x1e VT_LPWSTR VT = 0x1f VT_RECORD VT = 0x24 VT_INT_PTR VT = 0x25 VT_UINT_PTR VT = 0x26 VT_FILETIME VT = 0x40 VT_BLOB VT = 0x41 VT_STREAM VT = 0x42 VT_STORAGE VT = 0x43 VT_STREAMED_OBJECT VT = 0x44 VT_STORED_OBJECT VT = 0x45 VT_BLOB_OBJECT VT = 0x46 VT_CF VT = 0x47 VT_CLSID VT = 0x48 VT_BSTR_BLOB VT = 0xfff VT_VECTOR VT = 0x1000 VT_ARRAY VT = 0x2000 VT_BYREF VT = 0x4000 VT_RESERVED VT = 0x8000 VT_ILLEGAL VT = 0xffff VT_ILLEGALMASKED VT = 0xfff VT_TYPEMASK VT = 0xfff ) const ( DISPID_UNKNOWN = -1 DISPID_VALUE = 0 DISPID_PROPERTYPUT = -3 DISPID_NEWENUM = -4 DISPID_EVALUATE = -5 DISPID_CONSTRUCTOR = -6 DISPID_DESTRUCTOR = -7 DISPID_COLLECT = -8 ) const ( TKIND_ENUM = 1 TKIND_RECORD = 2 TKIND_MODULE = 3 TKIND_INTERFACE = 4 TKIND_DISPATCH = 5 TKIND_COCLASS = 6 TKIND_ALIAS = 7 TKIND_UNION = 8 TKIND_MAX = 9 ) // Safe Array Feature Flags const ( FADF_AUTO = 0x0001 FADF_STATIC = 0x0002 FADF_EMBEDDED = 0x0004 FADF_FIXEDSIZE = 0x0010 FADF_RECORD = 0x0020 FADF_HAVEIID = 0x0040 FADF_HAVEVARTYPE = 0x0080 FADF_BSTR = 0x0100 FADF_UNKNOWN = 0x0200 FADF_DISPATCH = 0x0400 FADF_VARIANT = 0x0800 FADF_RESERVED = 0xF008 ) ================================================ FILE: vendor/github.com/go-ole/go-ole/error.go ================================================ package ole // OleError stores COM errors. type OleError struct { hr uintptr description string subError error } // NewError creates new error with HResult. func NewError(hr uintptr) *OleError { return &OleError{hr: hr} } // NewErrorWithDescription creates new COM error with HResult and description. func NewErrorWithDescription(hr uintptr, description string) *OleError { return &OleError{hr: hr, description: description} } // NewErrorWithSubError creates new COM error with parent error. func NewErrorWithSubError(hr uintptr, description string, err error) *OleError { return &OleError{hr: hr, description: description, subError: err} } // Code is the HResult. func (v *OleError) Code() uintptr { return uintptr(v.hr) } // String description, either manually set or format message with error code. func (v *OleError) String() string { if v.description != "" { return errstr(int(v.hr)) + " (" + v.description + ")" } return errstr(int(v.hr)) } // Error implements error interface. func (v *OleError) Error() string { return v.String() } // Description retrieves error summary, if there is one. func (v *OleError) Description() string { return v.description } // SubError returns parent error, if there is one. func (v *OleError) SubError() error { return v.subError } ================================================ FILE: vendor/github.com/go-ole/go-ole/error_func.go ================================================ // +build !windows package ole // errstr converts error code to string. func errstr(errno int) string { return "" } ================================================ FILE: vendor/github.com/go-ole/go-ole/error_windows.go ================================================ // +build windows package ole import ( "fmt" "syscall" "unicode/utf16" ) // errstr converts error code to string. func errstr(errno int) string { // ask windows for the remaining errors var flags uint32 = syscall.FORMAT_MESSAGE_FROM_SYSTEM | syscall.FORMAT_MESSAGE_ARGUMENT_ARRAY | syscall.FORMAT_MESSAGE_IGNORE_INSERTS b := make([]uint16, 300) n, err := syscall.FormatMessage(flags, 0, uint32(errno), 0, b, nil) if err != nil { return fmt.Sprintf("error %d (FormatMessage failed with: %v)", errno, err) } // trim terminating \r and \n for ; n > 0 && (b[n-1] == '\n' || b[n-1] == '\r'); n-- { } return string(utf16.Decode(b[:n])) } ================================================ FILE: vendor/github.com/go-ole/go-ole/guid.go ================================================ package ole var ( // IID_NULL is null Interface ID, used when no other Interface ID is known. IID_NULL = NewGUID("{00000000-0000-0000-0000-000000000000}") // IID_IUnknown is for IUnknown interfaces. IID_IUnknown = NewGUID("{00000000-0000-0000-C000-000000000046}") // IID_IDispatch is for IDispatch interfaces. IID_IDispatch = NewGUID("{00020400-0000-0000-C000-000000000046}") // IID_IEnumVariant is for IEnumVariant interfaces IID_IEnumVariant = NewGUID("{00020404-0000-0000-C000-000000000046}") // IID_IConnectionPointContainer is for IConnectionPointContainer interfaces. IID_IConnectionPointContainer = NewGUID("{B196B284-BAB4-101A-B69C-00AA00341D07}") // IID_IConnectionPoint is for IConnectionPoint interfaces. IID_IConnectionPoint = NewGUID("{B196B286-BAB4-101A-B69C-00AA00341D07}") // IID_IInspectable is for IInspectable interfaces. IID_IInspectable = NewGUID("{AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90}") // IID_IProvideClassInfo is for IProvideClassInfo interfaces. IID_IProvideClassInfo = NewGUID("{B196B283-BAB4-101A-B69C-00AA00341D07}") ) // These are for testing and not part of any library. var ( // IID_ICOMTestString is for ICOMTestString interfaces. // // {E0133EB4-C36F-469A-9D3D-C66B84BE19ED} IID_ICOMTestString = NewGUID("{E0133EB4-C36F-469A-9D3D-C66B84BE19ED}") // IID_ICOMTestInt8 is for ICOMTestInt8 interfaces. // // {BEB06610-EB84-4155-AF58-E2BFF53680B4} IID_ICOMTestInt8 = NewGUID("{BEB06610-EB84-4155-AF58-E2BFF53680B4}") // IID_ICOMTestInt16 is for ICOMTestInt16 interfaces. // // {DAA3F9FA-761E-4976-A860-8364CE55F6FC} IID_ICOMTestInt16 = NewGUID("{DAA3F9FA-761E-4976-A860-8364CE55F6FC}") // IID_ICOMTestInt32 is for ICOMTestInt32 interfaces. // // {E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0} IID_ICOMTestInt32 = NewGUID("{E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}") // IID_ICOMTestInt64 is for ICOMTestInt64 interfaces. // // {8D437CBC-B3ED-485C-BC32-C336432A1623} IID_ICOMTestInt64 = NewGUID("{8D437CBC-B3ED-485C-BC32-C336432A1623}") // IID_ICOMTestFloat is for ICOMTestFloat interfaces. // // {BF1ED004-EA02-456A-AA55-2AC8AC6B054C} IID_ICOMTestFloat = NewGUID("{BF1ED004-EA02-456A-AA55-2AC8AC6B054C}") // IID_ICOMTestDouble is for ICOMTestDouble interfaces. // // {BF908A81-8687-4E93-999F-D86FAB284BA0} IID_ICOMTestDouble = NewGUID("{BF908A81-8687-4E93-999F-D86FAB284BA0}") // IID_ICOMTestBoolean is for ICOMTestBoolean interfaces. // // {D530E7A6-4EE8-40D1-8931-3D63B8605010} IID_ICOMTestBoolean = NewGUID("{D530E7A6-4EE8-40D1-8931-3D63B8605010}") // IID_ICOMEchoTestObject is for ICOMEchoTestObject interfaces. // // {6485B1EF-D780-4834-A4FE-1EBB51746CA3} IID_ICOMEchoTestObject = NewGUID("{6485B1EF-D780-4834-A4FE-1EBB51746CA3}") // IID_ICOMTestTypes is for ICOMTestTypes interfaces. // // {CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0} IID_ICOMTestTypes = NewGUID("{CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}") // CLSID_COMEchoTestObject is for COMEchoTestObject class. // // {3C24506A-AE9E-4D50-9157-EF317281F1B0} CLSID_COMEchoTestObject = NewGUID("{3C24506A-AE9E-4D50-9157-EF317281F1B0}") // CLSID_COMTestScalarClass is for COMTestScalarClass class. // // {865B85C5-0334-4AC6-9EF6-AACEC8FC5E86} CLSID_COMTestScalarClass = NewGUID("{865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}") ) const hextable = "0123456789ABCDEF" const emptyGUID = "{00000000-0000-0000-0000-000000000000}" // GUID is Windows API specific GUID type. // // This exists to match Windows GUID type for direct passing for COM. // Format is in xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx. type GUID struct { Data1 uint32 Data2 uint16 Data3 uint16 Data4 [8]byte } // NewGUID converts the given string into a globally unique identifier that is // compliant with the Windows API. // // The supplied string may be in any of these formats: // // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX // XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX // {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} // // The conversion of the supplied string is not case-sensitive. func NewGUID(guid string) *GUID { d := []byte(guid) var d1, d2, d3, d4a, d4b []byte switch len(d) { case 38: if d[0] != '{' || d[37] != '}' { return nil } d = d[1:37] fallthrough case 36: if d[8] != '-' || d[13] != '-' || d[18] != '-' || d[23] != '-' { return nil } d1 = d[0:8] d2 = d[9:13] d3 = d[14:18] d4a = d[19:23] d4b = d[24:36] case 32: d1 = d[0:8] d2 = d[8:12] d3 = d[12:16] d4a = d[16:20] d4b = d[20:32] default: return nil } var g GUID var ok1, ok2, ok3, ok4 bool g.Data1, ok1 = decodeHexUint32(d1) g.Data2, ok2 = decodeHexUint16(d2) g.Data3, ok3 = decodeHexUint16(d3) g.Data4, ok4 = decodeHexByte64(d4a, d4b) if ok1 && ok2 && ok3 && ok4 { return &g } return nil } func decodeHexUint32(src []byte) (value uint32, ok bool) { var b1, b2, b3, b4 byte var ok1, ok2, ok3, ok4 bool b1, ok1 = decodeHexByte(src[0], src[1]) b2, ok2 = decodeHexByte(src[2], src[3]) b3, ok3 = decodeHexByte(src[4], src[5]) b4, ok4 = decodeHexByte(src[6], src[7]) value = (uint32(b1) << 24) | (uint32(b2) << 16) | (uint32(b3) << 8) | uint32(b4) ok = ok1 && ok2 && ok3 && ok4 return } func decodeHexUint16(src []byte) (value uint16, ok bool) { var b1, b2 byte var ok1, ok2 bool b1, ok1 = decodeHexByte(src[0], src[1]) b2, ok2 = decodeHexByte(src[2], src[3]) value = (uint16(b1) << 8) | uint16(b2) ok = ok1 && ok2 return } func decodeHexByte64(s1 []byte, s2 []byte) (value [8]byte, ok bool) { var ok1, ok2, ok3, ok4, ok5, ok6, ok7, ok8 bool value[0], ok1 = decodeHexByte(s1[0], s1[1]) value[1], ok2 = decodeHexByte(s1[2], s1[3]) value[2], ok3 = decodeHexByte(s2[0], s2[1]) value[3], ok4 = decodeHexByte(s2[2], s2[3]) value[4], ok5 = decodeHexByte(s2[4], s2[5]) value[5], ok6 = decodeHexByte(s2[6], s2[7]) value[6], ok7 = decodeHexByte(s2[8], s2[9]) value[7], ok8 = decodeHexByte(s2[10], s2[11]) ok = ok1 && ok2 && ok3 && ok4 && ok5 && ok6 && ok7 && ok8 return } func decodeHexByte(c1, c2 byte) (value byte, ok bool) { var n1, n2 byte var ok1, ok2 bool n1, ok1 = decodeHexChar(c1) n2, ok2 = decodeHexChar(c2) value = (n1 << 4) | n2 ok = ok1 && ok2 return } func decodeHexChar(c byte) (byte, bool) { switch { case '0' <= c && c <= '9': return c - '0', true case 'a' <= c && c <= 'f': return c - 'a' + 10, true case 'A' <= c && c <= 'F': return c - 'A' + 10, true } return 0, false } // String converts the GUID to string form. It will adhere to this pattern: // // {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} // // If the GUID is nil, the string representation of an empty GUID is returned: // // {00000000-0000-0000-0000-000000000000} func (guid *GUID) String() string { if guid == nil { return emptyGUID } var c [38]byte c[0] = '{' putUint32Hex(c[1:9], guid.Data1) c[9] = '-' putUint16Hex(c[10:14], guid.Data2) c[14] = '-' putUint16Hex(c[15:19], guid.Data3) c[19] = '-' putByteHex(c[20:24], guid.Data4[0:2]) c[24] = '-' putByteHex(c[25:37], guid.Data4[2:8]) c[37] = '}' return string(c[:]) } func putUint32Hex(b []byte, v uint32) { b[0] = hextable[byte(v>>24)>>4] b[1] = hextable[byte(v>>24)&0x0f] b[2] = hextable[byte(v>>16)>>4] b[3] = hextable[byte(v>>16)&0x0f] b[4] = hextable[byte(v>>8)>>4] b[5] = hextable[byte(v>>8)&0x0f] b[6] = hextable[byte(v)>>4] b[7] = hextable[byte(v)&0x0f] } func putUint16Hex(b []byte, v uint16) { b[0] = hextable[byte(v>>8)>>4] b[1] = hextable[byte(v>>8)&0x0f] b[2] = hextable[byte(v)>>4] b[3] = hextable[byte(v)&0x0f] } func putByteHex(dst, src []byte) { for i := 0; i < len(src); i++ { dst[i*2] = hextable[src[i]>>4] dst[i*2+1] = hextable[src[i]&0x0f] } } // IsEqualGUID compares two GUID. // // Not constant time comparison. func IsEqualGUID(guid1 *GUID, guid2 *GUID) bool { return guid1.Data1 == guid2.Data1 && guid1.Data2 == guid2.Data2 && guid1.Data3 == guid2.Data3 && guid1.Data4[0] == guid2.Data4[0] && guid1.Data4[1] == guid2.Data4[1] && guid1.Data4[2] == guid2.Data4[2] && guid1.Data4[3] == guid2.Data4[3] && guid1.Data4[4] == guid2.Data4[4] && guid1.Data4[5] == guid2.Data4[5] && guid1.Data4[6] == guid2.Data4[6] && guid1.Data4[7] == guid2.Data4[7] } ================================================ FILE: vendor/github.com/go-ole/go-ole/iconnectionpoint.go ================================================ package ole import "unsafe" type IConnectionPoint struct { IUnknown } type IConnectionPointVtbl struct { IUnknownVtbl GetConnectionInterface uintptr GetConnectionPointContainer uintptr Advise uintptr Unadvise uintptr EnumConnections uintptr } func (v *IConnectionPoint) VTable() *IConnectionPointVtbl { return (*IConnectionPointVtbl)(unsafe.Pointer(v.RawVTable)) } ================================================ FILE: vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go ================================================ // +build !windows package ole import "unsafe" func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 { return int32(0) } func (v *IConnectionPoint) Advise(unknown *IUnknown) (uint32, error) { return uint32(0), NewError(E_NOTIMPL) } func (v *IConnectionPoint) Unadvise(cookie uint32) error { return NewError(E_NOTIMPL) } func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) (err error) { return NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go ================================================ // +build windows package ole import ( "syscall" "unsafe" ) func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 { // XXX: This doesn't look like it does what it's supposed to return release((*IUnknown)(unsafe.Pointer(v))) } func (v *IConnectionPoint) Advise(unknown *IUnknown) (cookie uint32, err error) { hr, _, _ := syscall.Syscall( v.VTable().Advise, 3, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(unknown)), uintptr(unsafe.Pointer(&cookie))) if hr != 0 { err = NewError(hr) } return } func (v *IConnectionPoint) Unadvise(cookie uint32) (err error) { hr, _, _ := syscall.Syscall( v.VTable().Unadvise, 2, uintptr(unsafe.Pointer(v)), uintptr(cookie), 0) if hr != 0 { err = NewError(hr) } return } func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) error { return NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go ================================================ package ole import "unsafe" type IConnectionPointContainer struct { IUnknown } type IConnectionPointContainerVtbl struct { IUnknownVtbl EnumConnectionPoints uintptr FindConnectionPoint uintptr } func (v *IConnectionPointContainer) VTable() *IConnectionPointContainerVtbl { return (*IConnectionPointContainerVtbl)(unsafe.Pointer(v.RawVTable)) } ================================================ FILE: vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go ================================================ // +build !windows package ole func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error { return NewError(E_NOTIMPL) } func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) error { return NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go ================================================ // +build windows package ole import ( "syscall" "unsafe" ) func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error { return NewError(E_NOTIMPL) } func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) (err error) { hr, _, _ := syscall.Syscall( v.VTable().FindConnectionPoint, 3, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(point))) if hr != 0 { err = NewError(hr) } return } ================================================ FILE: vendor/github.com/go-ole/go-ole/idispatch.go ================================================ package ole import "unsafe" type IDispatch struct { IUnknown } type IDispatchVtbl struct { IUnknownVtbl GetTypeInfoCount uintptr GetTypeInfo uintptr GetIDsOfNames uintptr Invoke uintptr } func (v *IDispatch) VTable() *IDispatchVtbl { return (*IDispatchVtbl)(unsafe.Pointer(v.RawVTable)) } func (v *IDispatch) GetIDsOfName(names []string) (dispid []int32, err error) { dispid, err = getIDsOfName(v, names) return } func (v *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) { result, err = invoke(v, dispid, dispatch, params...) return } func (v *IDispatch) GetTypeInfoCount() (c uint32, err error) { c, err = getTypeInfoCount(v) return } func (v *IDispatch) GetTypeInfo() (tinfo *ITypeInfo, err error) { tinfo, err = getTypeInfo(v) return } // GetSingleIDOfName is a helper that returns single display ID for IDispatch name. // // This replaces the common pattern of attempting to get a single name from the list of available // IDs. It gives the first ID, if it is available. func (v *IDispatch) GetSingleIDOfName(name string) (displayID int32, err error) { var displayIDs []int32 displayIDs, err = v.GetIDsOfName([]string{name}) if err != nil { return } displayID = displayIDs[0] return } // InvokeWithOptionalArgs accepts arguments as an array, works like Invoke. // // Accepts name and will attempt to retrieve Display ID to pass to Invoke. // // Passing params as an array is a workaround that could be fixed in later versions of Go that // prevent passing empty params. During testing it was discovered that this is an acceptable way of // getting around not being able to pass params normally. func (v *IDispatch) InvokeWithOptionalArgs(name string, dispatch int16, params []interface{}) (result *VARIANT, err error) { displayID, err := v.GetSingleIDOfName(name) if err != nil { return } if len(params) < 1 { result, err = v.Invoke(displayID, dispatch) } else { result, err = v.Invoke(displayID, dispatch, params...) } return } // CallMethod invokes named function with arguments on object. func (v *IDispatch) CallMethod(name string, params ...interface{}) (*VARIANT, error) { return v.InvokeWithOptionalArgs(name, DISPATCH_METHOD, params) } // GetProperty retrieves the property with the name with the ability to pass arguments. // // Most of the time you will not need to pass arguments as most objects do not allow for this // feature. Or at least, should not allow for this feature. Some servers don't follow best practices // and this is provided for those edge cases. func (v *IDispatch) GetProperty(name string, params ...interface{}) (*VARIANT, error) { return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYGET, params) } // PutProperty attempts to mutate a property in the object. func (v *IDispatch) PutProperty(name string, params ...interface{}) (*VARIANT, error) { return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYPUT, params) } ================================================ FILE: vendor/github.com/go-ole/go-ole/idispatch_func.go ================================================ // +build !windows package ole func getIDsOfName(disp *IDispatch, names []string) ([]int32, error) { return []int32{}, NewError(E_NOTIMPL) } func getTypeInfoCount(disp *IDispatch) (uint32, error) { return uint32(0), NewError(E_NOTIMPL) } func getTypeInfo(disp *IDispatch) (*ITypeInfo, error) { return nil, NewError(E_NOTIMPL) } func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (*VARIANT, error) { return nil, NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/idispatch_windows.go ================================================ // +build windows package ole import ( "syscall" "time" "unsafe" ) func getIDsOfName(disp *IDispatch, names []string) (dispid []int32, err error) { wnames := make([]*uint16, len(names)) for i := 0; i < len(names); i++ { wnames[i] = syscall.StringToUTF16Ptr(names[i]) } dispid = make([]int32, len(names)) namelen := uint32(len(names)) hr, _, _ := syscall.Syscall6( disp.VTable().GetIDsOfNames, 6, uintptr(unsafe.Pointer(disp)), uintptr(unsafe.Pointer(IID_NULL)), uintptr(unsafe.Pointer(&wnames[0])), uintptr(namelen), uintptr(GetUserDefaultLCID()), uintptr(unsafe.Pointer(&dispid[0]))) if hr != 0 { err = NewError(hr) } return } func getTypeInfoCount(disp *IDispatch) (c uint32, err error) { hr, _, _ := syscall.Syscall( disp.VTable().GetTypeInfoCount, 2, uintptr(unsafe.Pointer(disp)), uintptr(unsafe.Pointer(&c)), 0) if hr != 0 { err = NewError(hr) } return } func getTypeInfo(disp *IDispatch) (tinfo *ITypeInfo, err error) { hr, _, _ := syscall.Syscall( disp.VTable().GetTypeInfo, 3, uintptr(unsafe.Pointer(disp)), uintptr(GetUserDefaultLCID()), uintptr(unsafe.Pointer(&tinfo))) if hr != 0 { err = NewError(hr) } return } func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) { 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 vv := v.(type) { case bool: if vv { vargs[n] = NewVariant(VT_BOOL, 0xffff) } else { vargs[n] = NewVariant(VT_BOOL, 0) } case *bool: vargs[n] = NewVariant(VT_BOOL|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*bool))))) case uint8: vargs[n] = NewVariant(VT_I1, int64(v.(uint8))) case *uint8: vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8))))) case int8: vargs[n] = NewVariant(VT_I1, int64(v.(int8))) case *int8: vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8))))) case int16: vargs[n] = NewVariant(VT_I2, int64(v.(int16))) case *int16: vargs[n] = NewVariant(VT_I2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int16))))) case uint16: vargs[n] = NewVariant(VT_UI2, int64(v.(uint16))) case *uint16: vargs[n] = NewVariant(VT_UI2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint16))))) case int32: vargs[n] = NewVariant(VT_I4, int64(v.(int32))) case *int32: vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int32))))) case uint32: vargs[n] = NewVariant(VT_UI4, int64(v.(uint32))) case *uint32: vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint32))))) case int64: vargs[n] = NewVariant(VT_I8, int64(v.(int64))) case *int64: vargs[n] = NewVariant(VT_I8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int64))))) case uint64: vargs[n] = NewVariant(VT_UI8, int64(uintptr(v.(uint64)))) case *uint64: vargs[n] = NewVariant(VT_UI8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint64))))) case int: vargs[n] = NewVariant(VT_I4, int64(v.(int))) case *int: vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int))))) case uint: vargs[n] = NewVariant(VT_UI4, int64(v.(uint))) case *uint: vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint))))) case float32: vargs[n] = NewVariant(VT_R4, *(*int64)(unsafe.Pointer(&vv))) case *float32: vargs[n] = NewVariant(VT_R4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float32))))) case float64: vargs[n] = NewVariant(VT_R8, *(*int64)(unsafe.Pointer(&vv))) case *float64: vargs[n] = NewVariant(VT_R8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float64))))) case string: vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(v.(string)))))) case *string: vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*string))))) case time.Time: s := vv.Format("2006-01-02 15:04:05") vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(s))))) case *time.Time: s := vv.Format("2006-01-02 15:04:05") vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(&s)))) case *IDispatch: vargs[n] = NewVariant(VT_DISPATCH, int64(uintptr(unsafe.Pointer(v.(*IDispatch))))) case **IDispatch: vargs[n] = NewVariant(VT_DISPATCH|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(**IDispatch))))) case nil: vargs[n] = NewVariant(VT_NULL, 0) case *VARIANT: vargs[n] = NewVariant(VT_VARIANT|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*VARIANT))))) case []byte: safeByteArray := safeArrayFromByteSlice(v.([]byte)) vargs[n] = NewVariant(VT_ARRAY|VT_UI1, int64(uintptr(unsafe.Pointer(safeByteArray)))) defer VariantClear(&vargs[n]) case []string: safeByteArray := safeArrayFromStringSlice(v.([]string)) vargs[n] = NewVariant(VT_ARRAY|VT_BSTR, int64(uintptr(unsafe.Pointer(safeByteArray)))) defer VariantClear(&vargs[n]) default: panic("unknown type") } } dispparams.rgvarg = uintptr(unsafe.Pointer(&vargs[0])) dispparams.cArgs = uint32(len(params)) } result = new(VARIANT) var excepInfo EXCEPINFO VariantInit(result) hr, _, _ := syscall.Syscall9( disp.VTable().Invoke, 9, uintptr(unsafe.Pointer(disp)), uintptr(dispid), uintptr(unsafe.Pointer(IID_NULL)), uintptr(GetUserDefaultLCID()), uintptr(dispatch), uintptr(unsafe.Pointer(&dispparams)), uintptr(unsafe.Pointer(result)), uintptr(unsafe.Pointer(&excepInfo)), 0) if hr != 0 { err = NewErrorWithSubError(hr, BstrToString(excepInfo.bstrDescription), excepInfo) } for i, varg := range vargs { n := len(params) - i - 1 if varg.VT == VT_BSTR && varg.Val != 0 { SysFreeString(((*int16)(unsafe.Pointer(uintptr(varg.Val))))) } if varg.VT == (VT_BSTR|VT_BYREF) && varg.Val != 0 { *(params[n].(*string)) = LpOleStrToString(*(**uint16)(unsafe.Pointer(uintptr(varg.Val)))) } } return } ================================================ FILE: vendor/github.com/go-ole/go-ole/ienumvariant.go ================================================ package ole import "unsafe" type IEnumVARIANT struct { IUnknown } type IEnumVARIANTVtbl struct { IUnknownVtbl Next uintptr Skip uintptr Reset uintptr Clone uintptr } func (v *IEnumVARIANT) VTable() *IEnumVARIANTVtbl { return (*IEnumVARIANTVtbl)(unsafe.Pointer(v.RawVTable)) } ================================================ FILE: vendor/github.com/go-ole/go-ole/ienumvariant_func.go ================================================ // +build !windows package ole func (enum *IEnumVARIANT) Clone() (*IEnumVARIANT, error) { return nil, NewError(E_NOTIMPL) } func (enum *IEnumVARIANT) Reset() error { return NewError(E_NOTIMPL) } func (enum *IEnumVARIANT) Skip(celt uint) error { return NewError(E_NOTIMPL) } func (enum *IEnumVARIANT) Next(celt uint) (VARIANT, uint, error) { return NewVariant(VT_NULL, int64(0)), 0, NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/ienumvariant_windows.go ================================================ // +build windows package ole import ( "syscall" "unsafe" ) func (enum *IEnumVARIANT) Clone() (cloned *IEnumVARIANT, err error) { hr, _, _ := syscall.Syscall( enum.VTable().Clone, 2, uintptr(unsafe.Pointer(enum)), uintptr(unsafe.Pointer(&cloned)), 0) if hr != 0 { err = NewError(hr) } return } func (enum *IEnumVARIANT) Reset() (err error) { hr, _, _ := syscall.Syscall( enum.VTable().Reset, 1, uintptr(unsafe.Pointer(enum)), 0, 0) if hr != 0 { err = NewError(hr) } return } func (enum *IEnumVARIANT) Skip(celt uint) (err error) { hr, _, _ := syscall.Syscall( enum.VTable().Skip, 2, uintptr(unsafe.Pointer(enum)), uintptr(celt), 0) if hr != 0 { err = NewError(hr) } return } func (enum *IEnumVARIANT) Next(celt uint) (array VARIANT, length uint, err error) { hr, _, _ := syscall.Syscall6( enum.VTable().Next, 4, uintptr(unsafe.Pointer(enum)), uintptr(celt), uintptr(unsafe.Pointer(&array)), uintptr(unsafe.Pointer(&length)), 0, 0) if hr != 0 { err = NewError(hr) } return } ================================================ FILE: vendor/github.com/go-ole/go-ole/iinspectable.go ================================================ package ole import "unsafe" type IInspectable struct { IUnknown } type IInspectableVtbl struct { IUnknownVtbl GetIIds uintptr GetRuntimeClassName uintptr GetTrustLevel uintptr } func (v *IInspectable) VTable() *IInspectableVtbl { return (*IInspectableVtbl)(unsafe.Pointer(v.RawVTable)) } ================================================ FILE: vendor/github.com/go-ole/go-ole/iinspectable_func.go ================================================ // +build !windows package ole func (v *IInspectable) GetIids() ([]*GUID, error) { return []*GUID{}, NewError(E_NOTIMPL) } func (v *IInspectable) GetRuntimeClassName() (string, error) { return "", NewError(E_NOTIMPL) } func (v *IInspectable) GetTrustLevel() (uint32, error) { return uint32(0), NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/iinspectable_windows.go ================================================ // +build windows package ole import ( "bytes" "encoding/binary" "reflect" "syscall" "unsafe" ) func (v *IInspectable) GetIids() (iids []*GUID, err error) { var count uint32 var array uintptr hr, _, _ := syscall.Syscall( v.VTable().GetIIds, 3, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(&count)), uintptr(unsafe.Pointer(&array))) if hr != 0 { err = NewError(hr) return } defer CoTaskMemFree(array) iids = make([]*GUID, count) byteCount := count * uint32(unsafe.Sizeof(GUID{})) slicehdr := reflect.SliceHeader{Data: array, Len: int(byteCount), Cap: int(byteCount)} byteSlice := *(*[]byte)(unsafe.Pointer(&slicehdr)) reader := bytes.NewReader(byteSlice) for i := range iids { guid := GUID{} err = binary.Read(reader, binary.LittleEndian, &guid) if err != nil { return } iids[i] = &guid } return } func (v *IInspectable) GetRuntimeClassName() (s string, err error) { var hstring HString hr, _, _ := syscall.Syscall( v.VTable().GetRuntimeClassName, 2, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(&hstring)), 0) if hr != 0 { err = NewError(hr) return } s = hstring.String() DeleteHString(hstring) return } func (v *IInspectable) GetTrustLevel() (level uint32, err error) { hr, _, _ := syscall.Syscall( v.VTable().GetTrustLevel, 2, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(&level)), 0) if hr != 0 { err = NewError(hr) } return } ================================================ FILE: vendor/github.com/go-ole/go-ole/iprovideclassinfo.go ================================================ package ole import "unsafe" type IProvideClassInfo struct { IUnknown } type IProvideClassInfoVtbl struct { IUnknownVtbl GetClassInfo uintptr } func (v *IProvideClassInfo) VTable() *IProvideClassInfoVtbl { return (*IProvideClassInfoVtbl)(unsafe.Pointer(v.RawVTable)) } func (v *IProvideClassInfo) GetClassInfo() (cinfo *ITypeInfo, err error) { cinfo, err = getClassInfo(v) return } ================================================ FILE: vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go ================================================ // +build !windows package ole func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) { return nil, NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go ================================================ // +build windows package ole import ( "syscall" "unsafe" ) func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) { hr, _, _ := syscall.Syscall( disp.VTable().GetClassInfo, 2, uintptr(unsafe.Pointer(disp)), uintptr(unsafe.Pointer(&tinfo)), 0) if hr != 0 { err = NewError(hr) } return } ================================================ FILE: vendor/github.com/go-ole/go-ole/itypeinfo.go ================================================ package ole import "unsafe" type ITypeInfo struct { IUnknown } type ITypeInfoVtbl struct { IUnknownVtbl GetTypeAttr uintptr GetTypeComp uintptr GetFuncDesc uintptr GetVarDesc uintptr GetNames uintptr GetRefTypeOfImplType uintptr GetImplTypeFlags uintptr GetIDsOfNames uintptr Invoke uintptr GetDocumentation uintptr GetDllEntry uintptr GetRefTypeInfo uintptr AddressOfMember uintptr CreateInstance uintptr GetMops uintptr GetContainingTypeLib uintptr ReleaseTypeAttr uintptr ReleaseFuncDesc uintptr ReleaseVarDesc uintptr } func (v *ITypeInfo) VTable() *ITypeInfoVtbl { return (*ITypeInfoVtbl)(unsafe.Pointer(v.RawVTable)) } ================================================ FILE: vendor/github.com/go-ole/go-ole/itypeinfo_func.go ================================================ // +build !windows package ole func (v *ITypeInfo) GetTypeAttr() (*TYPEATTR, error) { return nil, NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/itypeinfo_windows.go ================================================ // +build windows package ole import ( "syscall" "unsafe" ) func (v *ITypeInfo) GetTypeAttr() (tattr *TYPEATTR, err error) { hr, _, _ := syscall.Syscall( uintptr(v.VTable().GetTypeAttr), 2, uintptr(unsafe.Pointer(v)), uintptr(unsafe.Pointer(&tattr)), 0) if hr != 0 { err = NewError(hr) } return } ================================================ FILE: vendor/github.com/go-ole/go-ole/iunknown.go ================================================ package ole import "unsafe" type IUnknown struct { RawVTable *interface{} } type IUnknownVtbl struct { QueryInterface uintptr AddRef uintptr Release uintptr } type UnknownLike interface { QueryInterface(iid *GUID) (disp *IDispatch, err error) AddRef() int32 Release() int32 } func (v *IUnknown) VTable() *IUnknownVtbl { return (*IUnknownVtbl)(unsafe.Pointer(v.RawVTable)) } func (v *IUnknown) PutQueryInterface(interfaceID *GUID, obj interface{}) error { return reflectQueryInterface(v, v.VTable().QueryInterface, interfaceID, obj) } func (v *IUnknown) IDispatch(interfaceID *GUID) (dispatch *IDispatch, err error) { err = v.PutQueryInterface(interfaceID, &dispatch) return } func (v *IUnknown) IEnumVARIANT(interfaceID *GUID) (enum *IEnumVARIANT, err error) { err = v.PutQueryInterface(interfaceID, &enum) return } func (v *IUnknown) QueryInterface(iid *GUID) (*IDispatch, error) { return queryInterface(v, iid) } func (v *IUnknown) MustQueryInterface(iid *GUID) (disp *IDispatch) { unk, err := queryInterface(v, iid) if err != nil { panic(err) } return unk } func (v *IUnknown) AddRef() int32 { return addRef(v) } func (v *IUnknown) Release() int32 { return release(v) } ================================================ FILE: vendor/github.com/go-ole/go-ole/iunknown_func.go ================================================ // +build !windows package ole func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) { return NewError(E_NOTIMPL) } func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) { return nil, NewError(E_NOTIMPL) } func addRef(unk *IUnknown) int32 { return 0 } func release(unk *IUnknown) int32 { return 0 } ================================================ FILE: vendor/github.com/go-ole/go-ole/iunknown_windows.go ================================================ // +build windows package ole import ( "reflect" "syscall" "unsafe" ) func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) { selfValue := reflect.ValueOf(self).Elem() objValue := reflect.ValueOf(obj).Elem() hr, _, _ := syscall.Syscall( method, 3, selfValue.UnsafeAddr(), uintptr(unsafe.Pointer(interfaceID)), objValue.Addr().Pointer()) if hr != 0 { err = NewError(hr) } return } func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) { hr, _, _ := syscall.Syscall( unk.VTable().QueryInterface, 3, uintptr(unsafe.Pointer(unk)), uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&disp))) if hr != 0 { err = NewError(hr) } return } func addRef(unk *IUnknown) int32 { ret, _, _ := syscall.Syscall( unk.VTable().AddRef, 1, uintptr(unsafe.Pointer(unk)), 0, 0) return int32(ret) } func release(unk *IUnknown) int32 { ret, _, _ := syscall.Syscall( unk.VTable().Release, 1, uintptr(unsafe.Pointer(unk)), 0, 0) return int32(ret) } ================================================ FILE: vendor/github.com/go-ole/go-ole/ole.go ================================================ package ole import ( "fmt" "strings" ) // DISPPARAMS are the arguments that passed to methods or property. type DISPPARAMS struct { rgvarg uintptr rgdispidNamedArgs uintptr cArgs uint32 cNamedArgs uint32 } // EXCEPINFO defines exception info. type EXCEPINFO struct { wCode uint16 wReserved uint16 bstrSource *uint16 bstrDescription *uint16 bstrHelpFile *uint16 dwHelpContext uint32 pvReserved uintptr pfnDeferredFillIn uintptr scode uint32 } // String convert EXCEPINFO to string. func (e EXCEPINFO) String() string { var src, desc, hlp string if e.bstrSource == nil { src = "" } else { src = BstrToString(e.bstrSource) } if e.bstrDescription == nil { desc = "" } else { desc = BstrToString(e.bstrDescription) } if e.bstrHelpFile == nil { hlp = "" } else { hlp = BstrToString(e.bstrHelpFile) } return fmt.Sprintf( "wCode: %#x, bstrSource: %v, bstrDescription: %v, bstrHelpFile: %v, dwHelpContext: %#x, scode: %#x", e.wCode, src, desc, hlp, e.dwHelpContext, e.scode, ) } // Error implements error interface and returns error string. func (e EXCEPINFO) Error() string { if e.bstrDescription != nil { return strings.TrimSpace(BstrToString(e.bstrDescription)) } src := "Unknown" if e.bstrSource != nil { src = BstrToString(e.bstrSource) } code := e.scode if e.wCode != 0 { code = uint32(e.wCode) } return fmt.Sprintf("%v: %#x", src, code) } // PARAMDATA defines parameter data type. type PARAMDATA struct { Name *int16 Vt uint16 } // METHODDATA defines method info. type METHODDATA struct { Name *uint16 Data *PARAMDATA Dispid int32 Meth uint32 CC int32 CArgs uint32 Flags uint16 VtReturn uint32 } // INTERFACEDATA defines interface info. type INTERFACEDATA struct { MethodData *METHODDATA CMembers uint32 } // Point is 2D vector type. type Point struct { X int32 Y int32 } // Msg is message between processes. type Msg struct { Hwnd uint32 Message uint32 Wparam int32 Lparam int32 Time uint32 Pt Point } // TYPEDESC defines data type. type TYPEDESC struct { Hreftype uint32 VT uint16 } // IDLDESC defines IDL info. type IDLDESC struct { DwReserved uint32 WIDLFlags uint16 } // TYPEATTR defines type info. type TYPEATTR struct { Guid GUID Lcid uint32 dwReserved uint32 MemidConstructor int32 MemidDestructor int32 LpstrSchema *uint16 CbSizeInstance uint32 Typekind int32 CFuncs uint16 CVars uint16 CImplTypes uint16 CbSizeVft uint16 CbAlignment uint16 WTypeFlags uint16 WMajorVerNum uint16 WMinorVerNum uint16 TdescAlias TYPEDESC IdldescType IDLDESC } ================================================ FILE: vendor/github.com/go-ole/go-ole/oleutil/connection.go ================================================ // +build windows package oleutil import ( "reflect" "unsafe" ole "github.com/go-ole/go-ole" ) type stdDispatch struct { lpVtbl *stdDispatchVtbl ref int32 iid *ole.GUID iface interface{} funcMap map[string]int32 } type stdDispatchVtbl struct { pQueryInterface uintptr pAddRef uintptr pRelease uintptr pGetTypeInfoCount uintptr pGetTypeInfo uintptr pGetIDsOfNames uintptr pInvoke uintptr } func dispQueryInterface(this *ole.IUnknown, iid *ole.GUID, punk **ole.IUnknown) uint32 { pthis := (*stdDispatch)(unsafe.Pointer(this)) *punk = nil if ole.IsEqualGUID(iid, ole.IID_IUnknown) || ole.IsEqualGUID(iid, ole.IID_IDispatch) { dispAddRef(this) *punk = this return ole.S_OK } if ole.IsEqualGUID(iid, pthis.iid) { dispAddRef(this) *punk = this return ole.S_OK } return ole.E_NOINTERFACE } func dispAddRef(this *ole.IUnknown) int32 { pthis := (*stdDispatch)(unsafe.Pointer(this)) pthis.ref++ return pthis.ref } func dispRelease(this *ole.IUnknown) int32 { pthis := (*stdDispatch)(unsafe.Pointer(this)) pthis.ref-- return pthis.ref } func dispGetIDsOfNames(this *ole.IUnknown, iid *ole.GUID, wnames []*uint16, namelen int, lcid int, pdisp []int32) uintptr { pthis := (*stdDispatch)(unsafe.Pointer(this)) names := make([]string, len(wnames)) for i := 0; i < len(names); i++ { names[i] = ole.LpOleStrToString(wnames[i]) } for n := 0; n < namelen; n++ { if id, ok := pthis.funcMap[names[n]]; ok { pdisp[n] = id } } return ole.S_OK } func dispGetTypeInfoCount(pcount *int) uintptr { if pcount != nil { *pcount = 0 } return ole.S_OK } func dispGetTypeInfo(ptypeif *uintptr) uintptr { return ole.E_NOTIMPL } func dispInvoke(this *ole.IDispatch, dispid int32, riid *ole.GUID, lcid int, flags int16, dispparams *ole.DISPPARAMS, result *ole.VARIANT, pexcepinfo *ole.EXCEPINFO, nerr *uint) uintptr { pthis := (*stdDispatch)(unsafe.Pointer(this)) found := "" for name, id := range pthis.funcMap { if id == dispid { found = name } } if found != "" { rv := reflect.ValueOf(pthis.iface).Elem() rm := rv.MethodByName(found) rr := rm.Call([]reflect.Value{}) println(len(rr)) return ole.S_OK } return ole.E_NOTIMPL } ================================================ FILE: vendor/github.com/go-ole/go-ole/oleutil/connection_func.go ================================================ // +build !windows package oleutil import ole "github.com/go-ole/go-ole" // ConnectObject creates a connection point between two services for communication. func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (uint32, error) { return 0, ole.NewError(ole.E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go ================================================ // +build windows package oleutil import ( "reflect" "syscall" "unsafe" ole "github.com/go-ole/go-ole" ) // ConnectObject creates a connection point between two services for communication. func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (cookie uint32, err error) { unknown, err := disp.QueryInterface(ole.IID_IConnectionPointContainer) if err != nil { return } container := (*ole.IConnectionPointContainer)(unsafe.Pointer(unknown)) var point *ole.IConnectionPoint err = container.FindConnectionPoint(iid, &point) if err != nil { return } if edisp, ok := idisp.(*ole.IUnknown); ok { cookie, err = point.Advise(edisp) container.Release() if err != nil { return } } rv := reflect.ValueOf(disp).Elem() if rv.Type().Kind() == reflect.Struct { dest := &stdDispatch{} dest.lpVtbl = &stdDispatchVtbl{} dest.lpVtbl.pQueryInterface = syscall.NewCallback(dispQueryInterface) dest.lpVtbl.pAddRef = syscall.NewCallback(dispAddRef) dest.lpVtbl.pRelease = syscall.NewCallback(dispRelease) dest.lpVtbl.pGetTypeInfoCount = syscall.NewCallback(dispGetTypeInfoCount) dest.lpVtbl.pGetTypeInfo = syscall.NewCallback(dispGetTypeInfo) dest.lpVtbl.pGetIDsOfNames = syscall.NewCallback(dispGetIDsOfNames) dest.lpVtbl.pInvoke = syscall.NewCallback(dispInvoke) dest.iface = disp dest.iid = iid cookie, err = point.Advise((*ole.IUnknown)(unsafe.Pointer(dest))) container.Release() if err != nil { point.Release() return } } container.Release() return 0, ole.NewError(ole.E_INVALIDARG) } ================================================ FILE: vendor/github.com/go-ole/go-ole/oleutil/go-get.go ================================================ // This file is here so go get succeeds as without it errors with: // no buildable Go source files in ... // // +build !windows package oleutil ================================================ FILE: vendor/github.com/go-ole/go-ole/oleutil/oleutil.go ================================================ package oleutil import ole "github.com/go-ole/go-ole" // ClassIDFrom retrieves class ID whether given is program ID or application string. func ClassIDFrom(programID string) (classID *ole.GUID, err error) { return ole.ClassIDFrom(programID) } // CreateObject creates object from programID based on interface type. // // Only supports IUnknown. // // Program ID can be either program ID or application string. func CreateObject(programID string) (unknown *ole.IUnknown, err error) { classID, err := ole.ClassIDFrom(programID) if err != nil { return } unknown, err = ole.CreateInstance(classID, ole.IID_IUnknown) if err != nil { return } return } // GetActiveObject retrieves active object for program ID and interface ID based // on interface type. // // Only supports IUnknown. // // Program ID can be either program ID or application string. func GetActiveObject(programID string) (unknown *ole.IUnknown, err error) { classID, err := ole.ClassIDFrom(programID) if err != nil { return } unknown, err = ole.GetActiveObject(classID, ole.IID_IUnknown) if err != nil { return } return } // CallMethod calls method on IDispatch with parameters. func CallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) { return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_METHOD, params) } // MustCallMethod calls method on IDispatch with parameters or panics. func MustCallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) { r, err := CallMethod(disp, name, params...) if err != nil { panic(err.Error()) } return r } // GetProperty retrieves property from IDispatch. func GetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) { return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYGET, params) } // MustGetProperty retrieves property from IDispatch or panics. func MustGetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) { r, err := GetProperty(disp, name, params...) if err != nil { panic(err.Error()) } return r } // PutProperty mutates property. func PutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) { return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUT, params) } // MustPutProperty mutates property or panics. func MustPutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) { r, err := PutProperty(disp, name, params...) if err != nil { panic(err.Error()) } return r } ================================================ FILE: vendor/github.com/go-ole/go-ole/safearray.go ================================================ // Package is meant to retrieve and process safe array data returned from COM. package ole // SafeArrayBound defines the SafeArray boundaries. type SafeArrayBound struct { Elements uint32 LowerBound int32 } // SafeArray is how COM handles arrays. type SafeArray struct { Dimensions uint16 FeaturesFlag uint16 ElementsSize uint32 LocksAmount uint32 Data uint32 Bounds [16]byte } // SAFEARRAY is obsolete, exists for backwards compatibility. // Use SafeArray type SAFEARRAY SafeArray // SAFEARRAYBOUND is obsolete, exists for backwards compatibility. // Use SafeArrayBound type SAFEARRAYBOUND SafeArrayBound ================================================ FILE: vendor/github.com/go-ole/go-ole/safearray_func.go ================================================ // +build !windows package ole import ( "unsafe" ) // safeArrayAccessData returns raw array pointer. // // AKA: SafeArrayAccessData in Windows API. func safeArrayAccessData(safearray *SafeArray) (uintptr, error) { return uintptr(0), NewError(E_NOTIMPL) } // safeArrayUnaccessData releases raw array. // // AKA: SafeArrayUnaccessData in Windows API. func safeArrayUnaccessData(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayAllocData allocates SafeArray. // // AKA: SafeArrayAllocData in Windows API. func safeArrayAllocData(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayAllocDescriptor allocates SafeArray. // // AKA: SafeArrayAllocDescriptor in Windows API. func safeArrayAllocDescriptor(dimensions uint32) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayAllocDescriptorEx allocates SafeArray. // // AKA: SafeArrayAllocDescriptorEx in Windows API. func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCopy returns copy of SafeArray. // // AKA: SafeArrayCopy in Windows API. func safeArrayCopy(original *SafeArray) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCopyData duplicates SafeArray into another SafeArray object. // // AKA: SafeArrayCopyData in Windows API. func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayCreate creates SafeArray. // // AKA: SafeArrayCreate in Windows API. func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCreateEx creates SafeArray. // // AKA: SafeArrayCreateEx in Windows API. func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCreateVector creates SafeArray. // // AKA: SafeArrayCreateVector in Windows API. func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayCreateVectorEx creates SafeArray. // // AKA: SafeArrayCreateVectorEx in Windows API. func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (*SafeArray, error) { return nil, NewError(E_NOTIMPL) } // safeArrayDestroy destroys SafeArray object. // // AKA: SafeArrayDestroy in Windows API. func safeArrayDestroy(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayDestroyData destroys SafeArray object. // // AKA: SafeArrayDestroyData in Windows API. func safeArrayDestroyData(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayDestroyDescriptor destroys SafeArray object. // // AKA: SafeArrayDestroyDescriptor in Windows API. func safeArrayDestroyDescriptor(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayGetDim is the amount of dimensions in the SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetDim in Windows API. func safeArrayGetDim(safearray *SafeArray) (*uint32, error) { u := uint32(0) return &u, NewError(E_NOTIMPL) } // safeArrayGetElementSize is the element size in bytes. // // AKA: SafeArrayGetElemsize in Windows API. func safeArrayGetElementSize(safearray *SafeArray) (*uint32, error) { u := uint32(0) return &u, NewError(E_NOTIMPL) } // safeArrayGetElement retrieves element at given index. func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error { return NewError(E_NOTIMPL) } // safeArrayGetElement retrieves element at given index and converts to string. func safeArrayGetElementString(safearray *SafeArray, index int64) (string, error) { return "", NewError(E_NOTIMPL) } // safeArrayGetIID is the InterfaceID of the elements in the SafeArray. // // AKA: SafeArrayGetIID in Windows API. func safeArrayGetIID(safearray *SafeArray) (*GUID, error) { return nil, NewError(E_NOTIMPL) } // safeArrayGetLBound returns lower bounds of SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetLBound in Windows API. func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int64, error) { return int64(0), NewError(E_NOTIMPL) } // safeArrayGetUBound returns upper bounds of SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetUBound in Windows API. func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (int64, error) { return int64(0), NewError(E_NOTIMPL) } // safeArrayGetVartype returns data type of SafeArray. // // AKA: SafeArrayGetVartype in Windows API. func safeArrayGetVartype(safearray *SafeArray) (uint16, error) { return uint16(0), NewError(E_NOTIMPL) } // safeArrayLock locks SafeArray for reading to modify SafeArray. // // This must be called during some calls to ensure that another process does not // read or write to the SafeArray during editing. // // AKA: SafeArrayLock in Windows API. func safeArrayLock(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayUnlock unlocks SafeArray for reading. // // AKA: SafeArrayUnlock in Windows API. func safeArrayUnlock(safearray *SafeArray) error { return NewError(E_NOTIMPL) } // safeArrayPutElement stores the data element at the specified location in the // array. // // AKA: SafeArrayPutElement in Windows API. func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) error { return NewError(E_NOTIMPL) } // safeArrayGetRecordInfo accesses IRecordInfo info for custom types. // // AKA: SafeArrayGetRecordInfo in Windows API. // // XXX: Must implement IRecordInfo interface for this to return. func safeArrayGetRecordInfo(safearray *SafeArray) (interface{}, error) { return nil, NewError(E_NOTIMPL) } // safeArraySetRecordInfo mutates IRecordInfo info for custom types. // // AKA: SafeArraySetRecordInfo in Windows API. // // XXX: Must implement IRecordInfo interface for this to return. func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) error { return NewError(E_NOTIMPL) } ================================================ FILE: vendor/github.com/go-ole/go-ole/safearray_windows.go ================================================ // +build windows package ole import ( "unsafe" ) var ( procSafeArrayAccessData, _ = modoleaut32.FindProc("SafeArrayAccessData") procSafeArrayAllocData, _ = modoleaut32.FindProc("SafeArrayAllocData") procSafeArrayAllocDescriptor, _ = modoleaut32.FindProc("SafeArrayAllocDescriptor") procSafeArrayAllocDescriptorEx, _ = modoleaut32.FindProc("SafeArrayAllocDescriptorEx") procSafeArrayCopy, _ = modoleaut32.FindProc("SafeArrayCopy") procSafeArrayCopyData, _ = modoleaut32.FindProc("SafeArrayCopyData") procSafeArrayCreate, _ = modoleaut32.FindProc("SafeArrayCreate") procSafeArrayCreateEx, _ = modoleaut32.FindProc("SafeArrayCreateEx") procSafeArrayCreateVector, _ = modoleaut32.FindProc("SafeArrayCreateVector") procSafeArrayCreateVectorEx, _ = modoleaut32.FindProc("SafeArrayCreateVectorEx") procSafeArrayDestroy, _ = modoleaut32.FindProc("SafeArrayDestroy") procSafeArrayDestroyData, _ = modoleaut32.FindProc("SafeArrayDestroyData") procSafeArrayDestroyDescriptor, _ = modoleaut32.FindProc("SafeArrayDestroyDescriptor") procSafeArrayGetDim, _ = modoleaut32.FindProc("SafeArrayGetDim") procSafeArrayGetElement, _ = modoleaut32.FindProc("SafeArrayGetElement") procSafeArrayGetElemsize, _ = modoleaut32.FindProc("SafeArrayGetElemsize") procSafeArrayGetIID, _ = modoleaut32.FindProc("SafeArrayGetIID") procSafeArrayGetLBound, _ = modoleaut32.FindProc("SafeArrayGetLBound") procSafeArrayGetUBound, _ = modoleaut32.FindProc("SafeArrayGetUBound") procSafeArrayGetVartype, _ = modoleaut32.FindProc("SafeArrayGetVartype") procSafeArrayLock, _ = modoleaut32.FindProc("SafeArrayLock") procSafeArrayPtrOfIndex, _ = modoleaut32.FindProc("SafeArrayPtrOfIndex") procSafeArrayUnaccessData, _ = modoleaut32.FindProc("SafeArrayUnaccessData") procSafeArrayUnlock, _ = modoleaut32.FindProc("SafeArrayUnlock") procSafeArrayPutElement, _ = modoleaut32.FindProc("SafeArrayPutElement") //procSafeArrayRedim, _ = modoleaut32.FindProc("SafeArrayRedim") // TODO //procSafeArraySetIID, _ = modoleaut32.FindProc("SafeArraySetIID") // TODO procSafeArrayGetRecordInfo, _ = modoleaut32.FindProc("SafeArrayGetRecordInfo") procSafeArraySetRecordInfo, _ = modoleaut32.FindProc("SafeArraySetRecordInfo") ) // safeArrayAccessData returns raw array pointer. // // AKA: SafeArrayAccessData in Windows API. // Todo: Test func safeArrayAccessData(safearray *SafeArray) (element uintptr, err error) { err = convertHresultToError( procSafeArrayAccessData.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&element)))) return } // safeArrayUnaccessData releases raw array. // // AKA: SafeArrayUnaccessData in Windows API. func safeArrayUnaccessData(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayUnaccessData.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayAllocData allocates SafeArray. // // AKA: SafeArrayAllocData in Windows API. func safeArrayAllocData(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayAllocData.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayAllocDescriptor allocates SafeArray. // // AKA: SafeArrayAllocDescriptor in Windows API. func safeArrayAllocDescriptor(dimensions uint32) (safearray *SafeArray, err error) { err = convertHresultToError( procSafeArrayAllocDescriptor.Call(uintptr(dimensions), uintptr(unsafe.Pointer(&safearray)))) return } // safeArrayAllocDescriptorEx allocates SafeArray. // // AKA: SafeArrayAllocDescriptorEx in Windows API. func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (safearray *SafeArray, err error) { err = convertHresultToError( procSafeArrayAllocDescriptorEx.Call( uintptr(variantType), uintptr(dimensions), uintptr(unsafe.Pointer(&safearray)))) return } // safeArrayCopy returns copy of SafeArray. // // AKA: SafeArrayCopy in Windows API. func safeArrayCopy(original *SafeArray) (safearray *SafeArray, err error) { err = convertHresultToError( procSafeArrayCopy.Call( uintptr(unsafe.Pointer(original)), uintptr(unsafe.Pointer(&safearray)))) return } // safeArrayCopyData duplicates SafeArray into another SafeArray object. // // AKA: SafeArrayCopyData in Windows API. func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) (err error) { err = convertHresultToError( procSafeArrayCopyData.Call( uintptr(unsafe.Pointer(original)), uintptr(unsafe.Pointer(duplicate)))) return } // safeArrayCreate creates SafeArray. // // AKA: SafeArrayCreate in Windows API. func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (safearray *SafeArray, err error) { sa, _, err := procSafeArrayCreate.Call( uintptr(variantType), uintptr(dimensions), uintptr(unsafe.Pointer(bounds))) safearray = (*SafeArray)(unsafe.Pointer(&sa)) return } // safeArrayCreateEx creates SafeArray. // // AKA: SafeArrayCreateEx in Windows API. func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (safearray *SafeArray, err error) { sa, _, err := procSafeArrayCreateEx.Call( uintptr(variantType), uintptr(dimensions), uintptr(unsafe.Pointer(bounds)), extra) safearray = (*SafeArray)(unsafe.Pointer(sa)) return } // safeArrayCreateVector creates SafeArray. // // AKA: SafeArrayCreateVector in Windows API. func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (safearray *SafeArray, err error) { sa, _, err := procSafeArrayCreateVector.Call( uintptr(variantType), uintptr(lowerBound), uintptr(length)) safearray = (*SafeArray)(unsafe.Pointer(sa)) return } // safeArrayCreateVectorEx creates SafeArray. // // AKA: SafeArrayCreateVectorEx in Windows API. func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (safearray *SafeArray, err error) { sa, _, err := procSafeArrayCreateVectorEx.Call( uintptr(variantType), uintptr(lowerBound), uintptr(length), extra) safearray = (*SafeArray)(unsafe.Pointer(sa)) return } // safeArrayDestroy destroys SafeArray object. // // AKA: SafeArrayDestroy in Windows API. func safeArrayDestroy(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayDestroy.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayDestroyData destroys SafeArray object. // // AKA: SafeArrayDestroyData in Windows API. func safeArrayDestroyData(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayDestroyData.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayDestroyDescriptor destroys SafeArray object. // // AKA: SafeArrayDestroyDescriptor in Windows API. func safeArrayDestroyDescriptor(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayDestroyDescriptor.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayGetDim is the amount of dimensions in the SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetDim in Windows API. func safeArrayGetDim(safearray *SafeArray) (dimensions *uint32, err error) { l, _, err := procSafeArrayGetDim.Call(uintptr(unsafe.Pointer(safearray))) dimensions = (*uint32)(unsafe.Pointer(l)) return } // safeArrayGetElementSize is the element size in bytes. // // AKA: SafeArrayGetElemsize in Windows API. func safeArrayGetElementSize(safearray *SafeArray) (length *uint32, err error) { l, _, err := procSafeArrayGetElemsize.Call(uintptr(unsafe.Pointer(safearray))) length = (*uint32)(unsafe.Pointer(l)) return } // safeArrayGetElement retrieves element at given index. func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error { return convertHresultToError( procSafeArrayGetElement.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&index)), uintptr(pv))) } // safeArrayGetElementString retrieves element at given index and converts to string. func safeArrayGetElementString(safearray *SafeArray, index int64) (str string, err error) { var element *int16 err = convertHresultToError( procSafeArrayGetElement.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&index)), uintptr(unsafe.Pointer(&element)))) str = BstrToString(*(**uint16)(unsafe.Pointer(&element))) SysFreeString(element) return } // safeArrayGetIID is the InterfaceID of the elements in the SafeArray. // // AKA: SafeArrayGetIID in Windows API. func safeArrayGetIID(safearray *SafeArray) (guid *GUID, err error) { err = convertHresultToError( procSafeArrayGetIID.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&guid)))) return } // safeArrayGetLBound returns lower bounds of SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetLBound in Windows API. func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (lowerBound int64, err error) { err = convertHresultToError( procSafeArrayGetLBound.Call( uintptr(unsafe.Pointer(safearray)), uintptr(dimension), uintptr(unsafe.Pointer(&lowerBound)))) return } // safeArrayGetUBound returns upper bounds of SafeArray. // // SafeArrays may have multiple dimensions. Meaning, it could be // multidimensional array. // // AKA: SafeArrayGetUBound in Windows API. func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (upperBound int64, err error) { err = convertHresultToError( procSafeArrayGetUBound.Call( uintptr(unsafe.Pointer(safearray)), uintptr(dimension), uintptr(unsafe.Pointer(&upperBound)))) return } // safeArrayGetVartype returns data type of SafeArray. // // AKA: SafeArrayGetVartype in Windows API. func safeArrayGetVartype(safearray *SafeArray) (varType uint16, err error) { err = convertHresultToError( procSafeArrayGetVartype.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&varType)))) return } // safeArrayLock locks SafeArray for reading to modify SafeArray. // // This must be called during some calls to ensure that another process does not // read or write to the SafeArray during editing. // // AKA: SafeArrayLock in Windows API. func safeArrayLock(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayLock.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayUnlock unlocks SafeArray for reading. // // AKA: SafeArrayUnlock in Windows API. func safeArrayUnlock(safearray *SafeArray) (err error) { err = convertHresultToError(procSafeArrayUnlock.Call(uintptr(unsafe.Pointer(safearray)))) return } // safeArrayPutElement stores the data element at the specified location in the // array. // // AKA: SafeArrayPutElement in Windows API. func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) (err error) { err = convertHresultToError( procSafeArrayPutElement.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&index)), uintptr(unsafe.Pointer(element)))) return } // safeArrayGetRecordInfo accesses IRecordInfo info for custom types. // // AKA: SafeArrayGetRecordInfo in Windows API. // // XXX: Must implement IRecordInfo interface for this to return. func safeArrayGetRecordInfo(safearray *SafeArray) (recordInfo interface{}, err error) { err = convertHresultToError( procSafeArrayGetRecordInfo.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&recordInfo)))) return } // safeArraySetRecordInfo mutates IRecordInfo info for custom types. // // AKA: SafeArraySetRecordInfo in Windows API. // // XXX: Must implement IRecordInfo interface for this to return. func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) (err error) { err = convertHresultToError( procSafeArraySetRecordInfo.Call( uintptr(unsafe.Pointer(safearray)), uintptr(unsafe.Pointer(&recordInfo)))) return } ================================================ FILE: vendor/github.com/go-ole/go-ole/safearrayconversion.go ================================================ // Helper for converting SafeArray to array of objects. package ole import ( "unsafe" ) type SafeArrayConversion struct { Array *SafeArray } func (sac *SafeArrayConversion) ToStringArray() (strings []string) { totalElements, _ := sac.TotalElements(0) strings = make([]string, totalElements) for i := int64(0); i < totalElements; i++ { strings[int32(i)], _ = safeArrayGetElementString(sac.Array, i) } return } func (sac *SafeArrayConversion) ToByteArray() (bytes []byte) { totalElements, _ := sac.TotalElements(0) bytes = make([]byte, totalElements) for i := int64(0); i < totalElements; i++ { safeArrayGetElement(sac.Array, i, unsafe.Pointer(&bytes[int32(i)])) } return } func (sac *SafeArrayConversion) ToValueArray() (values []interface{}) { totalElements, _ := sac.TotalElements(0) values = make([]interface{}, totalElements) vt, _ := safeArrayGetVartype(sac.Array) for i := 0; i < int(totalElements); i++ { switch VT(vt) { case VT_BOOL: var v bool safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_I1: var v int8 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_I2: var v int16 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_I4: var v int32 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_I8: var v int64 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_UI1: var v uint8 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_UI2: var v uint16 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_UI4: var v uint32 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_UI8: var v uint64 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_R4: var v float32 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_R8: var v float64 safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_BSTR: var v string safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_VARIANT: var v VARIANT safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v.Value() default: // TODO } } return } func (sac *SafeArrayConversion) GetType() (varType uint16, err error) { return safeArrayGetVartype(sac.Array) } func (sac *SafeArrayConversion) GetDimensions() (dimensions *uint32, err error) { return safeArrayGetDim(sac.Array) } func (sac *SafeArrayConversion) GetSize() (length *uint32, err error) { return safeArrayGetElementSize(sac.Array) } func (sac *SafeArrayConversion) TotalElements(index uint32) (totalElements int64, err error) { if index < 1 { index = 1 } // Get array bounds var LowerBounds int64 var UpperBounds int64 LowerBounds, err = safeArrayGetLBound(sac.Array, index) if err != nil { return } UpperBounds, err = safeArrayGetUBound(sac.Array, index) if err != nil { return } totalElements = UpperBounds - LowerBounds + 1 return } // Release Safe Array memory func (sac *SafeArrayConversion) Release() { safeArrayDestroy(sac.Array) } ================================================ FILE: vendor/github.com/go-ole/go-ole/safearrayslices.go ================================================ // +build windows package ole import ( "unsafe" ) func safeArrayFromByteSlice(slice []byte) *SafeArray { array, _ := safeArrayCreateVector(VT_UI1, 0, uint32(len(slice))) if array == nil { panic("Could not convert []byte to SAFEARRAY") } for i, v := range slice { safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(&v))) } return array } func safeArrayFromStringSlice(slice []string) *SafeArray { array, _ := safeArrayCreateVector(VT_BSTR, 0, uint32(len(slice))) if array == nil { panic("Could not convert []string to SAFEARRAY") } // SysAllocStringLen(s) for i, v := range slice { safeArrayPutElement(array, int64(i), uintptr(unsafe.Pointer(SysAllocStringLen(v)))) } return array } ================================================ FILE: vendor/github.com/go-ole/go-ole/utility.go ================================================ package ole import ( "unicode/utf16" "unsafe" ) // ClassIDFrom retrieves class ID whether given is program ID or application string. // // Helper that provides check against both Class ID from Program ID and Class ID from string. It is // faster, if you know which you are using, to use the individual functions, but this will check // against available functions for you. func ClassIDFrom(programID string) (classID *GUID, err error) { classID, err = CLSIDFromProgID(programID) if err != nil { classID, err = CLSIDFromString(programID) if err != nil { return } } return } // BytePtrToString converts byte pointer to a Go string. func BytePtrToString(p *byte) string { a := (*[10000]uint8)(unsafe.Pointer(p)) i := 0 for a[i] != 0 { i++ } return string(a[:i]) } // UTF16PtrToString is alias for LpOleStrToString. // // Kept for compatibility reasons. func UTF16PtrToString(p *uint16) string { return LpOleStrToString(p) } // LpOleStrToString converts COM Unicode to Go string. func LpOleStrToString(p *uint16) string { if p == nil { return "" } length := lpOleStrLen(p) a := make([]uint16, length) ptr := unsafe.Pointer(p) for i := 0; i < int(length); i++ { a[i] = *(*uint16)(ptr) ptr = unsafe.Pointer(uintptr(ptr) + 2) } return string(utf16.Decode(a)) } // BstrToString converts COM binary string to Go string. func BstrToString(p *uint16) string { if p == nil { return "" } length := SysStringLen((*int16)(unsafe.Pointer(p))) a := make([]uint16, length) ptr := unsafe.Pointer(p) for i := 0; i < int(length); i++ { a[i] = *(*uint16)(ptr) ptr = unsafe.Pointer(uintptr(ptr) + 2) } return string(utf16.Decode(a)) } // lpOleStrLen returns the length of Unicode string. func lpOleStrLen(p *uint16) (length int64) { if p == nil { return 0 } ptr := unsafe.Pointer(p) for i := 0; ; i++ { if 0 == *(*uint16)(ptr) { length = int64(i) break } ptr = unsafe.Pointer(uintptr(ptr) + 2) } return } // convertHresultToError converts syscall to error, if call is unsuccessful. func convertHresultToError(hr uintptr, r2 uintptr, ignore error) (err error) { if hr != 0 { err = NewError(hr) } return } ================================================ FILE: vendor/github.com/go-ole/go-ole/variables.go ================================================ // +build windows package ole import ( "syscall" ) var ( modcombase = syscall.NewLazyDLL("combase.dll") modkernel32, _ = syscall.LoadDLL("kernel32.dll") modole32, _ = syscall.LoadDLL("ole32.dll") modoleaut32, _ = syscall.LoadDLL("oleaut32.dll") modmsvcrt, _ = syscall.LoadDLL("msvcrt.dll") moduser32, _ = syscall.LoadDLL("user32.dll") ) ================================================ FILE: vendor/github.com/go-ole/go-ole/variant.go ================================================ package ole import "unsafe" // NewVariant returns new variant based on type and value. func NewVariant(vt VT, val int64) VARIANT { return VARIANT{VT: vt, Val: val} } // ToIUnknown converts Variant to Unknown object. func (v *VARIANT) ToIUnknown() *IUnknown { if v.VT != VT_UNKNOWN { return nil } return (*IUnknown)(unsafe.Pointer(uintptr(v.Val))) } // ToIDispatch converts variant to dispatch object. func (v *VARIANT) ToIDispatch() *IDispatch { if v.VT != VT_DISPATCH { return nil } return (*IDispatch)(unsafe.Pointer(uintptr(v.Val))) } // ToArray converts variant to SafeArray helper. func (v *VARIANT) ToArray() *SafeArrayConversion { if v.VT != VT_SAFEARRAY { if v.VT&VT_ARRAY == 0 { return nil } } var safeArray *SafeArray = (*SafeArray)(unsafe.Pointer(uintptr(v.Val))) return &SafeArrayConversion{safeArray} } // ToString converts variant to Go string. func (v *VARIANT) ToString() string { if v.VT != VT_BSTR { return "" } return BstrToString(*(**uint16)(unsafe.Pointer(&v.Val))) } // Clear the memory of variant object. func (v *VARIANT) Clear() error { return VariantClear(v) } // Value returns variant value based on its type. // // Currently supported types: 2- and 4-byte integers, strings, bools. // Note that 64-bit integers, datetimes, and other types are stored as strings // and will be returned as strings. // // Needs to be further converted, because this returns an interface{}. func (v *VARIANT) Value() interface{} { switch v.VT { case VT_I1: return int8(v.Val) case VT_UI1: return uint8(v.Val) case VT_I2: return int16(v.Val) case VT_UI2: return uint16(v.Val) case VT_I4: return int32(v.Val) case VT_UI4: return uint32(v.Val) case VT_I8: return int64(v.Val) case VT_UI8: return uint64(v.Val) case VT_INT: return int(v.Val) case VT_UINT: return uint(v.Val) case VT_INT_PTR: return uintptr(v.Val) // TODO case VT_UINT_PTR: return uintptr(v.Val) case VT_R4: return *(*float32)(unsafe.Pointer(&v.Val)) case VT_R8: return *(*float64)(unsafe.Pointer(&v.Val)) case VT_BSTR: return v.ToString() case VT_DATE: // VT_DATE type will either return float64 or time.Time. d := float64(v.Val) date, err := GetVariantDate(d) if err != nil { return d } return date case VT_UNKNOWN: return v.ToIUnknown() case VT_DISPATCH: return v.ToIDispatch() case VT_BOOL: return v.Val != 0 } return nil } ================================================ FILE: vendor/github.com/go-ole/go-ole/variant_386.go ================================================ // +build 386 package ole type VARIANT struct { VT VT // 2 wReserved1 uint16 // 4 wReserved2 uint16 // 6 wReserved3 uint16 // 8 Val int64 // 16 } ================================================ FILE: vendor/github.com/go-ole/go-ole/variant_amd64.go ================================================ // +build amd64 package ole type VARIANT struct { VT VT // 2 wReserved1 uint16 // 4 wReserved2 uint16 // 6 wReserved3 uint16 // 8 Val int64 // 16 _ [8]byte // 24 } ================================================ FILE: vendor/github.com/go-ole/go-ole/vt_string.go ================================================ // generated by stringer -output vt_string.go -type VT; DO NOT EDIT package ole import "fmt" const ( _VT_name_0 = "VT_EMPTYVT_NULLVT_I2VT_I4VT_R4VT_R8VT_CYVT_DATEVT_BSTRVT_DISPATCHVT_ERRORVT_BOOLVT_VARIANTVT_UNKNOWNVT_DECIMAL" _VT_name_1 = "VT_I1VT_UI1VT_UI2VT_UI4VT_I8VT_UI8VT_INTVT_UINTVT_VOIDVT_HRESULTVT_PTRVT_SAFEARRAYVT_CARRAYVT_USERDEFINEDVT_LPSTRVT_LPWSTR" _VT_name_2 = "VT_RECORDVT_INT_PTRVT_UINT_PTR" _VT_name_3 = "VT_FILETIMEVT_BLOBVT_STREAMVT_STORAGEVT_STREAMED_OBJECTVT_STORED_OBJECTVT_BLOB_OBJECTVT_CFVT_CLSID" _VT_name_4 = "VT_BSTR_BLOBVT_VECTOR" _VT_name_5 = "VT_ARRAY" _VT_name_6 = "VT_BYREF" _VT_name_7 = "VT_RESERVED" _VT_name_8 = "VT_ILLEGAL" ) var ( _VT_index_0 = [...]uint8{0, 8, 15, 20, 25, 30, 35, 40, 47, 54, 65, 73, 80, 90, 100, 110} _VT_index_1 = [...]uint8{0, 5, 11, 17, 23, 28, 34, 40, 47, 54, 64, 70, 82, 91, 105, 113, 122} _VT_index_2 = [...]uint8{0, 9, 19, 30} _VT_index_3 = [...]uint8{0, 11, 18, 27, 37, 55, 71, 85, 90, 98} _VT_index_4 = [...]uint8{0, 12, 21} _VT_index_5 = [...]uint8{0, 8} _VT_index_6 = [...]uint8{0, 8} _VT_index_7 = [...]uint8{0, 11} _VT_index_8 = [...]uint8{0, 10} ) func (i VT) String() string { switch { case 0 <= i && i <= 14: return _VT_name_0[_VT_index_0[i]:_VT_index_0[i+1]] case 16 <= i && i <= 31: i -= 16 return _VT_name_1[_VT_index_1[i]:_VT_index_1[i+1]] case 36 <= i && i <= 38: i -= 36 return _VT_name_2[_VT_index_2[i]:_VT_index_2[i+1]] case 64 <= i && i <= 72: i -= 64 return _VT_name_3[_VT_index_3[i]:_VT_index_3[i+1]] case 4095 <= i && i <= 4096: i -= 4095 return _VT_name_4[_VT_index_4[i]:_VT_index_4[i+1]] case i == 8192: return _VT_name_5 case i == 16384: return _VT_name_6 case i == 32768: return _VT_name_7 case i == 65535: return _VT_name_8 default: return fmt.Sprintf("VT(%d)", i) } } ================================================ FILE: vendor/github.com/go-ole/go-ole/winrt.go ================================================ // +build windows package ole import ( "reflect" "syscall" "unicode/utf8" "unsafe" ) var ( procRoInitialize = modcombase.NewProc("RoInitialize") procRoActivateInstance = modcombase.NewProc("RoActivateInstance") procRoGetActivationFactory = modcombase.NewProc("RoGetActivationFactory") procWindowsCreateString = modcombase.NewProc("WindowsCreateString") procWindowsDeleteString = modcombase.NewProc("WindowsDeleteString") procWindowsGetStringRawBuffer = modcombase.NewProc("WindowsGetStringRawBuffer") ) func RoInitialize(thread_type uint32) (err error) { hr, _, _ := procRoInitialize.Call(uintptr(thread_type)) if hr != 0 { err = NewError(hr) } return } func RoActivateInstance(clsid string) (ins *IInspectable, err error) { hClsid, err := NewHString(clsid) if err != nil { return nil, err } defer DeleteHString(hClsid) hr, _, _ := procRoActivateInstance.Call( uintptr(unsafe.Pointer(hClsid)), uintptr(unsafe.Pointer(&ins))) if hr != 0 { err = NewError(hr) } return } func RoGetActivationFactory(clsid string, iid *GUID) (ins *IInspectable, err error) { hClsid, err := NewHString(clsid) if err != nil { return nil, err } defer DeleteHString(hClsid) hr, _, _ := procRoGetActivationFactory.Call( uintptr(unsafe.Pointer(hClsid)), uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&ins))) if hr != 0 { err = NewError(hr) } return } // HString is handle string for pointers. type HString uintptr // NewHString returns a new HString for Go string. func NewHString(s string) (hstring HString, err error) { u16 := syscall.StringToUTF16Ptr(s) len := uint32(utf8.RuneCountInString(s)) hr, _, _ := procWindowsCreateString.Call( uintptr(unsafe.Pointer(u16)), uintptr(len), uintptr(unsafe.Pointer(&hstring))) if hr != 0 { err = NewError(hr) } return } // DeleteHString deletes HString. func DeleteHString(hstring HString) (err error) { hr, _, _ := procWindowsDeleteString.Call(uintptr(hstring)) if hr != 0 { err = NewError(hr) } return } // String returns Go string value of HString. func (h HString) String() string { var u16buf uintptr var u16len uint32 u16buf, _, _ = procWindowsGetStringRawBuffer.Call( uintptr(h), uintptr(unsafe.Pointer(&u16len))) u16hdr := reflect.SliceHeader{Data: u16buf, Len: int(u16len), Cap: int(u16len)} u16 := *(*[]uint16)(unsafe.Pointer(&u16hdr)) return syscall.UTF16ToString(u16) } ================================================ FILE: vendor/github.com/go-ole/go-ole/winrt_doc.go ================================================ // +build !windows package ole // RoInitialize func RoInitialize(thread_type uint32) (err error) { return NewError(E_NOTIMPL) } // RoActivateInstance func RoActivateInstance(clsid string) (ins *IInspectable, err error) { return nil, NewError(E_NOTIMPL) } // RoGetActivationFactory func RoGetActivationFactory(clsid string, iid *GUID) (ins *IInspectable, err error) { return nil, NewError(E_NOTIMPL) } // HString is handle string for pointers. type HString uintptr // NewHString returns a new HString for Go string. func NewHString(s string) (hstring HString, err error) { return HString(uintptr(0)), NewError(E_NOTIMPL) } // DeleteHString deletes HString. func DeleteHString(hstring HString) (err error) { return NewError(E_NOTIMPL) } // String returns Go string value of HString. func (h HString) String() string { return "" } ================================================ FILE: vendor/github.com/shirou/gopsutil/LICENSE ================================================ gopsutil is distributed under BSD license reproduced below. Copyright (c) 2014, WAKAYAMA Shirou All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. * Neither the name of the gopsutil authors nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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. ================================================ FILE: vendor/github.com/shirou/gopsutil/README.rst ================================================ 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:: Package Structure Changed! Package (a.k.a. directory) structure has been changed!! see `issue 24 `_ .. highlights:: golang 1.4 will become REQUIRED! Since syscall package becomes frozen, we should use golang/x/sys of golang 1.4 as soon as possible. Available Architectures ------------------------------------ - FreeBSD i386/amd64 - Linux i386/amd64/arm(raspberry pi) - Windows/amd64 - Darwin/amd64 All works are implemented without cgo by porting c struct to golang struct. Usage --------- .. code:: go 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 /proc by setting the HOST_PROC environment variable. You can set an alternative location to /sys by setting the HOST_SYS environment variable. Documentation ------------------------ see http://godoc.org/github.com/shirou/gopsutil 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 work but something broken ================= ====== ======= ====== ======= name Linux FreeBSD MacOSX Windows cpu_times x x x x cpu_count x x x x cpu_percent x x x x cpu_times_percent x x x x virtual_memory x x x x swap_memory x x x disk_partitions x x x x disk_io_counters x x disk_usage x x x x net_io_counters x x b x boot_time x x x x users x x x x pids x x x x pid_exists 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 MacOSX Windows pid x x x x ppid x x x x name x x x x cmdline x x x create_time x status x x x cwd x exe x x x uids x x x gids x x x terminal x x x io_counters x nice x x x num_fds x num_ctx_switches x num_threads x x x x cpu_times x memory_info x x x memory_info_ex x memory_maps x open_files x send_signal x x x suspend x x x resume x x x terminate x x x kill x x x username x ionice rlimit num_handlres threads cpu_percent x x cpu_affinity memory_percent parent x x children x x x connections x x is_running ================ ===== ======= ====== ======= Original Metrics ^^^^^^^^^^^^^^^^^^^ ================== ===== ======= ====== ======= item Linux FreeBSD MacOSX Windows **HostInfo** hostname x x x x uptime x x x proces x x os x x x x platform x x x platformfamiliy x x x virtualization x **CPU** VendorID x x x x Family x x x x Model x x x x Stepping x x x x PhysicalID x CoreID x Cores x x ModelName x x x x **LoadAvg** Load1 x x x Load5 x x x Load15 x x x **GetDockerID** container id x no no no **CgroupsCPU** user x no no no system x no no no **CgroupsMem** various x 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. ================================================ FILE: vendor/github.com/shirou/gopsutil/circle.yml ================================================ machine: timezone: Asia/Tokyo test: override: - GOOS=linux GOARCH=amd64 go test -v ./... - GOOS=linux GOARCH=386 go get -v ./... - GOOS=linux GOARCH=arm GOARM=7 go get -v ./... - GOOS=freebsd GOARCH=amd64 go get -v ./... - GOOS=windows GOARCH=amd64 go get -v ./... - GOOS=darwin GOARCH=amd64 go get -v ./... ================================================ FILE: vendor/github.com/shirou/gopsutil/coverall.sh ================================================ #/bin/sh # see http://www.songmu.jp/riji/entry/2015-01-15-goveralls-multi-package.html set -e # cleanup cleanup() { if [ $tmpprof != "" ] && [ -f $tmpprof ]; then rm -f $tmpprof fi exit } trap cleanup INT QUIT TERM EXIT # メインの処理 prof=${1:-".profile.cov"} echo "mode: count" > $prof gopath1=$(echo $GOPATH | cut -d: -f1) for pkg in $(go list ./...); do tmpprof=$gopath1/src/$pkg/profile.tmp go test -covermode=count -coverprofile=$tmpprof $pkg if [ -f $tmpprof ]; then cat $tmpprof | tail -n +2 >> $prof rm $tmpprof fi done ================================================ FILE: vendor/github.com/shirou/gopsutil/cpu/cpu.go ================================================ package cpu import ( "encoding/json" "runtime" "strconv" "strings" ) type CPUTimesStat struct { CPU string `json:"cpu"` User float64 `json:"user"` System float64 `json:"system"` Idle float64 `json:"idle"` Nice float64 `json:"nice"` Iowait float64 `json:"iowait"` Irq float64 `json:"irq"` Softirq float64 `json:"softirq"` Steal float64 `json:"steal"` Guest float64 `json:"guest"` GuestNice float64 `json:"guest_nice"` Stolen float64 `json:"stolen"` } type CPUInfoStat struct { CPU int32 `json:"cpu"` VendorID string `json:"vendor_id"` Family string `json:"family"` Model string `json:"model"` Stepping int32 `json:"stepping"` PhysicalID string `json:"physical_id"` CoreID string `json:"core_id"` Cores int32 `json:"cores"` ModelName string `json:"model_name"` Mhz float64 `json:"mhz"` CacheSize int32 `json:"cache_size"` Flags []string `json:"flags"` } var lastCPUTimes []CPUTimesStat var lastPerCPUTimes []CPUTimesStat func CPUCounts(logical bool) (int, error) { return runtime.NumCPU(), nil } func (c CPUTimesStat) String() string { v := []string{ `"cpu":"` + c.CPU + `"`, `"user":` + strconv.FormatFloat(c.User, 'f', 1, 64), `"system":` + strconv.FormatFloat(c.System, 'f', 1, 64), `"idle":` + strconv.FormatFloat(c.Idle, 'f', 1, 64), `"nice":` + strconv.FormatFloat(c.Nice, 'f', 1, 64), `"iowait":` + strconv.FormatFloat(c.Iowait, 'f', 1, 64), `"irq":` + strconv.FormatFloat(c.Irq, 'f', 1, 64), `"softirq":` + strconv.FormatFloat(c.Softirq, 'f', 1, 64), `"steal":` + strconv.FormatFloat(c.Steal, 'f', 1, 64), `"guest":` + strconv.FormatFloat(c.Guest, 'f', 1, 64), `"guest_nice":` + strconv.FormatFloat(c.GuestNice, 'f', 1, 64), `"stolen":` + strconv.FormatFloat(c.Stolen, 'f', 1, 64), } return `{` + strings.Join(v, ",") + `}` } // Total returns the total number of seconds in a CPUTimesStat func (c CPUTimesStat) Total() float64 { total := c.User + c.System + c.Nice + c.Iowait + c.Irq + c.Softirq + c.Steal + c.Guest + c.GuestNice + c.Idle + c.Stolen return total } func (c CPUInfoStat) String() string { s, _ := json.Marshal(c) return string(s) } ================================================ FILE: vendor/github.com/shirou/gopsutil/cpu/cpu_darwin.go ================================================ // +build darwin package cpu import ( "os/exec" "strconv" "strings" ) // sys/resource.h const ( CPUser = 0 CPNice = 1 CPSys = 2 CPIntr = 3 CPIdle = 4 CPUStates = 5 ) // default value. from time.h var ClocksPerSec = float64(128) func CPUTimes(percpu bool) ([]CPUTimesStat, error) { if percpu { return perCPUTimes() } return allCPUTimes() } // Returns only one CPUInfoStat on FreeBSD func CPUInfo() ([]CPUInfoStat, error) { var ret []CPUInfoStat out, err := exec.Command("/usr/sbin/sysctl", "machdep.cpu").Output() if err != nil { return ret, err } c := CPUInfoStat{} for _, line := range strings.Split(string(out), "\n") { values := strings.Fields(line) if len(values) < 1 { continue } t, err := strconv.ParseInt(values[1], 10, 64) // err is not checked here because some value is string. if strings.HasPrefix(line, "machdep.cpu.brand_string") { c.ModelName = strings.Join(values[1:], " ") } else if strings.HasPrefix(line, "machdep.cpu.family") { c.Family = values[1] } else if strings.HasPrefix(line, "machdep.cpu.model") { c.Model = values[1] } else if strings.HasPrefix(line, "machdep.cpu.stepping") { if err != nil { return ret, err } c.Stepping = int32(t) } else if strings.HasPrefix(line, "machdep.cpu.features") { for _, v := range values[1:] { c.Flags = append(c.Flags, strings.ToLower(v)) } } else if strings.HasPrefix(line, "machdep.cpu.leaf7_features") { for _, v := range values[1:] { c.Flags = append(c.Flags, strings.ToLower(v)) } } else if strings.HasPrefix(line, "machdep.cpu.extfeatures") { for _, v := range values[1:] { c.Flags = append(c.Flags, strings.ToLower(v)) } } else if strings.HasPrefix(line, "machdep.cpu.core_count") { if err != nil { return ret, err } c.Cores = int32(t) } else if strings.HasPrefix(line, "machdep.cpu.cache.size") { if err != nil { return ret, err } c.CacheSize = int32(t) } else if strings.HasPrefix(line, "machdep.cpu.vendor") { c.VendorID = values[1] } } // Use the rated frequency of the CPU. This is a static value and does not // account for low power or Turbo Boost modes. out, err = exec.Command("/usr/sbin/sysctl", "hw.cpufrequency").Output() if err != nil { return ret, err } values := strings.Fields(string(out)) mhz, err := strconv.ParseFloat(values[1], 64) if err != nil { return ret, err } c.Mhz = mhz / 1000000.0 return append(ret, c), nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/cpu/cpu_darwin_cgo.go ================================================ // +build darwin // +build cgo package cpu /* #include #include #include #include #include #include #include #include #include */ import "C" import ( "bytes" "encoding/binary" "fmt" "unsafe" ) // these CPU times for darwin is borrowed from influxdb/telegraf. func perCPUTimes() ([]CPUTimesStat, error) { var ( count C.mach_msg_type_number_t cpuload *C.processor_cpu_load_info_data_t ncpu C.natural_t ) status := C.host_processor_info(C.host_t(C.mach_host_self()), C.PROCESSOR_CPU_LOAD_INFO, &ncpu, (*C.processor_info_array_t)(unsafe.Pointer(&cpuload)), &count) if status != C.KERN_SUCCESS { return nil, fmt.Errorf("host_processor_info error=%d", status) } // jump through some cgo casting hoops and ensure we properly free // the memory that cpuload points to target := C.vm_map_t(C.mach_task_self_) address := C.vm_address_t(uintptr(unsafe.Pointer(cpuload))) defer C.vm_deallocate(target, address, C.vm_size_t(ncpu)) // the body of struct processor_cpu_load_info // aka processor_cpu_load_info_data_t var cpu_ticks [C.CPU_STATE_MAX]uint32 // copy the cpuload array to a []byte buffer // where we can binary.Read the data size := int(ncpu) * binary.Size(cpu_ticks) buf := C.GoBytes(unsafe.Pointer(cpuload), C.int(size)) bbuf := bytes.NewBuffer(buf) var ret []CPUTimesStat for i := 0; i < int(ncpu); i++ { err := binary.Read(bbuf, binary.LittleEndian, &cpu_ticks) if err != nil { return nil, err } c := CPUTimesStat{ CPU: fmt.Sprintf("cpu%d", i), User: float64(cpu_ticks[C.CPU_STATE_USER]) / ClocksPerSec, System: float64(cpu_ticks[C.CPU_STATE_SYSTEM]) / ClocksPerSec, Nice: float64(cpu_ticks[C.CPU_STATE_NICE]) / ClocksPerSec, Idle: float64(cpu_ticks[C.CPU_STATE_IDLE]) / ClocksPerSec, } ret = append(ret, c) } return ret, nil } func allCPUTimes() ([]CPUTimesStat, error) { var count C.mach_msg_type_number_t = C.HOST_CPU_LOAD_INFO_COUNT var cpuload C.host_cpu_load_info_data_t status := C.host_statistics(C.host_t(C.mach_host_self()), C.HOST_CPU_LOAD_INFO, C.host_info_t(unsafe.Pointer(&cpuload)), &count) if status != C.KERN_SUCCESS { return nil, fmt.Errorf("host_statistics error=%d", status) } c := CPUTimesStat{ CPU: "cpu-total", User: float64(cpuload.cpu_ticks[C.CPU_STATE_USER]) / ClocksPerSec, System: float64(cpuload.cpu_ticks[C.CPU_STATE_SYSTEM]) / ClocksPerSec, Nice: float64(cpuload.cpu_ticks[C.CPU_STATE_NICE]) / ClocksPerSec, Idle: float64(cpuload.cpu_ticks[C.CPU_STATE_IDLE]) / ClocksPerSec, } return []CPUTimesStat{c}, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/cpu/cpu_darwin_nocgo.go ================================================ // +build darwin // +build !cgo package cpu import "github.com/shirou/gopsutil/internal/common" func perCPUTimes() ([]CPUTimesStat, error) { return []CPUTimesStat{}, common.NotImplementedError } func allCPUTimes() ([]CPUTimesStat, error) { return []CPUTimesStat{}, common.NotImplementedError } ================================================ FILE: vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd.go ================================================ // +build freebsd package cpu import ( "fmt" "os/exec" "regexp" "strconv" "strings" "github.com/shirou/gopsutil/internal/common" ) // sys/resource.h const ( CPUser = 0 CPNice = 1 CPSys = 2 CPIntr = 3 CPIdle = 4 CPUStates = 5 ) var ClocksPerSec = float64(128) func init() { out, err := exec.Command("/usr/bin/getconf", "CLK_TCK").Output() // ignore errors if err == nil { i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64) if err == nil { ClocksPerSec = float64(i) } } } func CPUTimes(percpu bool) ([]CPUTimesStat, error) { var ret []CPUTimesStat var sysctlCall string var ncpu int if percpu { sysctlCall = "kern.cp_times" ncpu, _ = CPUCounts(true) } else { sysctlCall = "kern.cp_time" ncpu = 1 } cpuTimes, err := common.DoSysctrl(sysctlCall) if err != nil { return ret, err } for i := 0; i < ncpu; i++ { offset := CPUStates * i user, err := strconv.ParseFloat(cpuTimes[CPUser+offset], 64) if err != nil { return ret, err } nice, err := strconv.ParseFloat(cpuTimes[CPNice+offset], 64) if err != nil { return ret, err } sys, err := strconv.ParseFloat(cpuTimes[CPSys+offset], 64) if err != nil { return ret, err } idle, err := strconv.ParseFloat(cpuTimes[CPIdle+offset], 64) if err != nil { return ret, err } intr, err := strconv.ParseFloat(cpuTimes[CPIntr+offset], 64) if err != nil { return ret, err } c := CPUTimesStat{ User: float64(user / ClocksPerSec), Nice: float64(nice / ClocksPerSec), System: float64(sys / ClocksPerSec), Idle: float64(idle / ClocksPerSec), Irq: float64(intr / ClocksPerSec), } if !percpu { c.CPU = "cpu-total" } else { c.CPU = fmt.Sprintf("cpu%d", i) } ret = append(ret, c) } return ret, nil } // Returns only one CPUInfoStat on FreeBSD func CPUInfo() ([]CPUInfoStat, error) { filename := "/var/run/dmesg.boot" lines, _ := common.ReadLines(filename) var ret []CPUInfoStat c := CPUInfoStat{} for _, line := range lines { if matches := regexp.MustCompile(`CPU:\s+(.+) \(([\d.]+).+\)`).FindStringSubmatch(line); matches != nil { c.ModelName = matches[1] t, err := strconv.ParseFloat(matches[2], 64) if err != nil { return ret, nil } c.Mhz = t } else if matches := regexp.MustCompile(`Origin = "(.+)" Id = (.+) Family = (.+) Model = (.+) Stepping = (.+)`).FindStringSubmatch(line); matches != nil { c.VendorID = matches[1] c.Family = matches[3] c.Model = matches[4] t, err := strconv.ParseInt(matches[5], 10, 32) if err != nil { return ret, nil } c.Stepping = int32(t) } else if matches := regexp.MustCompile(`Features=.+<(.+)>`).FindStringSubmatch(line); matches != nil { for _, v := range strings.Split(matches[1], ",") { c.Flags = append(c.Flags, strings.ToLower(v)) } } else if matches := regexp.MustCompile(`Features2=[a-f\dx]+<(.+)>`).FindStringSubmatch(line); matches != nil { for _, v := range strings.Split(matches[1], ",") { c.Flags = append(c.Flags, strings.ToLower(v)) } } else if matches := regexp.MustCompile(`Logical CPUs per core: (\d+)`).FindStringSubmatch(line); matches != nil { // FIXME: no this line? t, err := strconv.ParseInt(matches[1], 10, 32) if err != nil { return ret, nil } c.Cores = int32(t) } } return append(ret, c), nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/cpu/cpu_linux.go ================================================ // +build linux package cpu import ( "errors" "fmt" "os/exec" "strconv" "strings" "github.com/shirou/gopsutil/internal/common" ) var cpu_tick = float64(100) func init() { out, err := exec.Command("/usr/bin/getconf", "CLK_TCK").Output() // ignore errors if err == nil { i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64) if err == nil { cpu_tick = float64(i) } } } func CPUTimes(percpu bool) ([]CPUTimesStat, error) { filename := common.HostProc("stat") var lines = []string{} if percpu { var startIdx uint = 1 for { linen, _ := common.ReadLinesOffsetN(filename, startIdx, 1) line := linen[0] if !strings.HasPrefix(line, "cpu") { break } lines = append(lines, line) startIdx += 1 } } else { lines, _ = common.ReadLinesOffsetN(filename, 0, 1) } ret := make([]CPUTimesStat, 0, len(lines)) for _, line := range lines { ct, err := parseStatLine(line) if err != nil { continue } ret = append(ret, *ct) } return ret, nil } func sysCpuPath(cpu int32, relPath string) string { return common.HostSys(fmt.Sprintf("devices/system/cpu/cpu%d", cpu), relPath) } func finishCPUInfo(c *CPUInfoStat) error { if c.Mhz == 0 { lines, err := common.ReadLines(sysCpuPath(c.CPU, "cpufreq/cpuinfo_max_freq")) if err == nil { value, err := strconv.ParseFloat(lines[0], 64) if err != nil { return err } c.Mhz = value } } if len(c.CoreID) == 0 { lines, err := common.ReadLines(sysCpuPath(c.CPU, "topology/core_id")) if err == nil { c.CoreID = lines[0] } } return nil } // CPUInfo on linux will return 1 item per physical thread. // // CPUs have three levels of counting: sockets, cores, threads. // Cores with HyperThreading count as having 2 threads per core. // Sockets often come with many physical CPU cores. // For example a single socket board with two cores each with HT will // return 4 CPUInfoStat structs on Linux and the "Cores" field set to 1. func CPUInfo() ([]CPUInfoStat, error) { filename := common.HostProc("cpuinfo") lines, _ := common.ReadLines(filename) var ret []CPUInfoStat c := CPUInfoStat{CPU: -1, Cores: 1} for _, line := range lines { fields := strings.Split(line, ":") if len(fields) < 2 { continue } key := strings.TrimSpace(fields[0]) value := strings.TrimSpace(fields[1]) switch key { case "processor": if c.CPU >= 0 { err := finishCPUInfo(&c) if err != nil { return ret, err } ret = append(ret, c) } c = CPUInfoStat{Cores: 1} t, err := strconv.ParseInt(value, 10, 64) if err != nil { return ret, err } c.CPU = int32(t) case "vendor_id": c.VendorID = value case "cpu family": c.Family = value case "model": c.Model = value case "model name": c.ModelName = value case "stepping": t, err := strconv.ParseInt(value, 10, 64) if err != nil { return ret, err } c.Stepping = int32(t) case "cpu MHz": t, err := strconv.ParseFloat(value, 64) if err != nil { return ret, err } c.Mhz = t case "cache size": t, err := strconv.ParseInt(strings.Replace(value, " KB", "", 1), 10, 64) if err != nil { return ret, err } c.CacheSize = int32(t) case "physical id": c.PhysicalID = value case "core id": c.CoreID = value case "flags", "Features": c.Flags = strings.FieldsFunc(value, func(r rune) bool { return r == ',' || r == ' ' }) } } if c.CPU >= 0 { err := finishCPUInfo(&c) if err != nil { return ret, err } ret = append(ret, c) } return ret, nil } func parseStatLine(line string) (*CPUTimesStat, error) { fields := strings.Fields(line) if strings.HasPrefix(fields[0], "cpu") == false { // return CPUTimesStat{}, e return nil, errors.New("not contain cpu") } cpu := fields[0] if cpu == "cpu" { cpu = "cpu-total" } user, err := strconv.ParseFloat(fields[1], 64) if err != nil { return nil, err } nice, err := strconv.ParseFloat(fields[2], 64) if err != nil { return nil, err } system, err := strconv.ParseFloat(fields[3], 64) if err != nil { return nil, err } idle, err := strconv.ParseFloat(fields[4], 64) if err != nil { return nil, err } iowait, err := strconv.ParseFloat(fields[5], 64) if err != nil { return nil, err } irq, err := strconv.ParseFloat(fields[6], 64) if err != nil { return nil, err } softirq, err := strconv.ParseFloat(fields[7], 64) if err != nil { return nil, err } ct := &CPUTimesStat{ CPU: cpu, User: float64(user) / cpu_tick, Nice: float64(nice) / cpu_tick, System: float64(system) / cpu_tick, Idle: float64(idle) / cpu_tick, Iowait: float64(iowait) / cpu_tick, Irq: float64(irq) / cpu_tick, Softirq: float64(softirq) / cpu_tick, } if len(fields) > 8 { // Linux >= 2.6.11 steal, err := strconv.ParseFloat(fields[8], 64) if err != nil { return nil, err } ct.Steal = float64(steal) / cpu_tick } if len(fields) > 9 { // Linux >= 2.6.24 guest, err := strconv.ParseFloat(fields[9], 64) if err != nil { return nil, err } ct.Guest = float64(guest) / cpu_tick } if len(fields) > 10 { // Linux >= 3.2.0 guestNice, err := strconv.ParseFloat(fields[10], 64) if err != nil { return nil, err } ct.GuestNice = float64(guestNice) / cpu_tick } return ct, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/cpu/cpu_unix.go ================================================ // +build linux freebsd darwin package cpu import ( "fmt" "time" ) func CPUPercent(interval time.Duration, percpu bool) ([]float64, error) { getAllBusy := func(t CPUTimesStat) (float64, float64) { busy := t.User + t.System + t.Nice + t.Iowait + t.Irq + t.Softirq + t.Steal + t.Guest + t.GuestNice + t.Stolen return busy + t.Idle, busy } calculate := func(t1, t2 CPUTimesStat) float64 { t1All, t1Busy := getAllBusy(t1) t2All, t2Busy := getAllBusy(t2) if t2Busy <= t1Busy { return 0 } if t2All <= t1All { return 1 } return (t2Busy - t1Busy) / (t2All - t1All) * 100 } // Get CPU usage at the start of the interval. cpuTimes1, err := CPUTimes(percpu) if err != nil { return nil, err } if interval > 0 { time.Sleep(interval) } // And at the end of the interval. cpuTimes2, err := CPUTimes(percpu) if err != nil { return nil, err } // Make sure the CPU measurements have the same length. if len(cpuTimes1) != len(cpuTimes2) { return nil, fmt.Errorf( "received two CPU counts: %d != %d", len(cpuTimes1), len(cpuTimes2), ) } ret := make([]float64, len(cpuTimes1)) for i, t := range cpuTimes2 { ret[i] = calculate(cpuTimes1[i], t) } return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/cpu/cpu_windows.go ================================================ // +build windows package cpu import ( "fmt" "syscall" "time" "unsafe" "github.com/StackExchange/wmi" "github.com/shirou/gopsutil/internal/common" ) type Win32_Processor struct { LoadPercentage *uint16 Family uint16 Manufacturer string Name string NumberOfLogicalProcessors uint32 ProcessorId *string Stepping *string MaxClockSpeed uint32 } // TODO: Get percpu func CPUTimes(percpu bool) ([]CPUTimesStat, error) { var ret []CPUTimesStat var lpIdleTime common.FILETIME var lpKernelTime common.FILETIME var lpUserTime common.FILETIME r, _, _ := common.ProcGetSystemTimes.Call( uintptr(unsafe.Pointer(&lpIdleTime)), uintptr(unsafe.Pointer(&lpKernelTime)), uintptr(unsafe.Pointer(&lpUserTime))) if r == 0 { return ret, syscall.GetLastError() } LOT := float64(0.0000001) HIT := (LOT * 4294967296.0) idle := ((HIT * float64(lpIdleTime.DwHighDateTime)) + (LOT * float64(lpIdleTime.DwLowDateTime))) user := ((HIT * float64(lpUserTime.DwHighDateTime)) + (LOT * float64(lpUserTime.DwLowDateTime))) kernel := ((HIT * float64(lpKernelTime.DwHighDateTime)) + (LOT * float64(lpKernelTime.DwLowDateTime))) system := (kernel - idle) ret = append(ret, CPUTimesStat{ Idle: float64(idle), User: float64(user), System: float64(system), }) return ret, nil } func CPUInfo() ([]CPUInfoStat, error) { var ret []CPUInfoStat var dst []Win32_Processor q := wmi.CreateQuery(&dst, "") err := wmi.Query(q, &dst) if err != nil { return ret, err } var procID string for i, l := range dst { procID = "" if l.ProcessorId != nil { procID = *l.ProcessorId } cpu := CPUInfoStat{ CPU: int32(i), Family: fmt.Sprintf("%d", l.Family), VendorID: l.Manufacturer, ModelName: l.Name, Cores: int32(l.NumberOfLogicalProcessors), PhysicalID: procID, Mhz: float64(l.MaxClockSpeed), Flags: []string{}, } ret = append(ret, cpu) } return ret, nil } func CPUPercent(interval time.Duration, percpu bool) ([]float64, error) { var ret []float64 var dst []Win32_Processor q := wmi.CreateQuery(&dst, "") err := wmi.Query(q, &dst) if err != nil { return ret, err } for _, l := range dst { // use range but windows can only get one percent. if l.LoadPercentage == nil { continue } ret = append(ret, float64(*l.LoadPercentage)) } return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/doc.go ================================================ package gopsutil ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host.go ================================================ package host import ( "encoding/json" ) // A HostInfoStat describes the host status. // This is not in the psutil but it useful. type HostInfoStat struct { Hostname string `json:"hostname"` Uptime uint64 `json:"uptime"` BootTime uint64 `json:"boot_time"` Procs uint64 `json:"procs"` // number of processes OS string `json:"os"` // ex: freebsd, linux Platform string `json:"platform"` // ex: ubuntu, linuxmint PlatformFamily string `json:"platform_family"` // ex: debian, rhel PlatformVersion string `json:"platform_version"` VirtualizationSystem string `json:"virtualization_system"` VirtualizationRole string `json:"virtualization_role"` // guest or host } type UserStat struct { User string `json:"user"` Terminal string `json:"terminal"` Host string `json:"host"` Started int `json:"started"` } func (h HostInfoStat) String() string { s, _ := json.Marshal(h) return string(s) } func (u UserStat) String() string { s, _ := json.Marshal(u) return string(s) } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host_darwin.go ================================================ // +build darwin package host import ( "bytes" "encoding/binary" "io/ioutil" "os" "os/exec" "runtime" "strconv" "strings" "time" "unsafe" "github.com/shirou/gopsutil/internal/common" ) // from utmpx.h const USER_PROCESS = 7 func HostInfo() (*HostInfoStat, error) { ret := &HostInfoStat{ OS: runtime.GOOS, PlatformFamily: "darwin", } hostname, err := os.Hostname() if err == nil { ret.Hostname = hostname } platform, family, version, err := GetPlatformInformation() if err == nil { ret.Platform = platform ret.PlatformFamily = family ret.PlatformVersion = version } system, role, err := GetVirtualization() if err == nil { ret.VirtualizationSystem = system ret.VirtualizationRole = role } boot, err := BootTime() if err == nil { ret.BootTime = boot ret.Uptime = uptime(boot) } return ret, nil } func BootTime() (uint64, error) { values, err := common.DoSysctrl("kern.boottime") if err != nil { return 0, err } // ex: { sec = 1392261637, usec = 627534 } Thu Feb 13 12:20:37 2014 v := strings.Replace(values[2], ",", "", 1) boottime, err := strconv.ParseInt(v, 10, 64) if err != nil { return 0, err } return uint64(boottime), nil } func uptime(boot uint64) uint64 { return uint64(time.Now().Unix()) - boot } func Uptime() (uint64, error) { boot, err := BootTime() if err != nil { return 0, err } return uptime(boot), nil } func Users() ([]UserStat, error) { utmpfile := "/var/run/utmpx" var ret []UserStat file, err := os.Open(utmpfile) if err != nil { return ret, err } buf, err := ioutil.ReadAll(file) if err != nil { return ret, err } u := Utmpx{} entrySize := int(unsafe.Sizeof(u)) count := len(buf) / entrySize for i := 0; i < count; i++ { b := buf[i*entrySize : i*entrySize+entrySize] var u Utmpx br := bytes.NewReader(b) err := binary.Read(br, binary.LittleEndian, &u) if err != nil { continue } if u.Type != USER_PROCESS { continue } user := UserStat{ User: common.IntToString(u.User[:]), Terminal: common.IntToString(u.Line[:]), Host: common.IntToString(u.Host[:]), Started: int(u.Tv.Sec), } ret = append(ret, user) } return ret, nil } func GetPlatformInformation() (string, string, string, error) { platform := "" family := "" version := "" out, err := exec.Command("uname", "-s").Output() if err == nil { platform = strings.ToLower(strings.TrimSpace(string(out))) } out, err = exec.Command("uname", "-r").Output() if err == nil { version = strings.ToLower(strings.TrimSpace(string(out))) } return platform, family, version, nil } func GetVirtualization() (string, string, error) { system := "" role := "" return system, role, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host_darwin_amd64.go ================================================ // 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 } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host_freebsd.go ================================================ // +build freebsd package host import ( "bytes" "encoding/binary" "io/ioutil" "os" "os/exec" "runtime" "strconv" "strings" "time" "unsafe" "github.com/shirou/gopsutil/internal/common" ) const ( UTNameSize = 16 /* see MAXLOGNAME in */ UTLineSize = 8 UTHostSize = 16 ) func HostInfo() (*HostInfoStat, error) { ret := &HostInfoStat{ OS: runtime.GOOS, PlatformFamily: "freebsd", } hostname, err := os.Hostname() if err == nil { ret.Hostname = hostname } platform, family, version, err := GetPlatformInformation() if err == nil { ret.Platform = platform ret.PlatformFamily = family ret.PlatformVersion = version } system, role, err := GetVirtualization() if err == nil { ret.VirtualizationSystem = system ret.VirtualizationRole = role } boot, err := BootTime() if err == nil { ret.BootTime = boot ret.Uptime = uptime(boot) } return ret, nil } func BootTime() (uint64, error) { values, err := common.DoSysctrl("kern.boottime") if err != nil { return 0, err } // ex: { sec = 1392261637, usec = 627534 } Thu Feb 13 12:20:37 2014 v := strings.Replace(values[2], ",", "", 1) boottime, err := strconv.ParseUint(v, 10, 64) if err != nil { return 0, err } return boottime, nil } func uptime(boot uint64) uint64 { return uint64(time.Now().Unix()) - boot } func Uptime() (uint64, error) { boot, err := BootTime() if err != nil { return 0, err } return uptime(boot), nil } func Users() ([]UserStat, error) { utmpfile := "/var/run/utx.active" if !common.PathExists(utmpfile) { utmpfile = "/var/run/utmp" // before 9.0 return getUsersFromUtmp(utmpfile) } var ret []UserStat file, err := os.Open(utmpfile) if err != nil { return ret, err } buf, err := ioutil.ReadAll(file) if err != nil { return ret, err } u := Utmpx{} entrySize := int(unsafe.Sizeof(u)) - 3 entrySize = 197 // TODO: why should 197 count := len(buf) / entrySize for i := 0; i < count; i++ { b := buf[i*entrySize : i*entrySize+entrySize] var u Utmpx br := bytes.NewReader(b) err := binary.Read(br, binary.LittleEndian, &u) if err != nil || u.Type != 4 { continue } sec := (binary.LittleEndian.Uint32(u.Tv.Sec[:])) / 2 // TODO: user := UserStat{ User: common.IntToString(u.User[:]), Terminal: common.IntToString(u.Line[:]), Host: common.IntToString(u.Host[:]), Started: int(sec), } ret = append(ret, user) } return ret, nil } func GetPlatformInformation() (string, string, string, error) { platform := "" family := "" version := "" out, err := exec.Command("uname", "-s").Output() if err == nil { platform = strings.ToLower(strings.TrimSpace(string(out))) } out, err = exec.Command("uname", "-r").Output() if err == nil { version = strings.ToLower(strings.TrimSpace(string(out))) } return platform, family, version, nil } func GetVirtualization() (string, string, error) { system := "" role := "" return system, role, nil } // before 9.0 func getUsersFromUtmp(utmpfile string) ([]UserStat, error) { var ret []UserStat file, err := os.Open(utmpfile) if err != nil { return ret, err } buf, err := ioutil.ReadAll(file) if err != nil { return ret, err } u := Utmp{} entrySize := int(unsafe.Sizeof(u)) count := len(buf) / entrySize for i := 0; i < count; i++ { b := buf[i*entrySize : i*entrySize+entrySize] var u Utmp br := bytes.NewReader(b) err := binary.Read(br, binary.LittleEndian, &u) if err != nil || u.Time == 0 { continue } user := UserStat{ User: common.IntToString(u.Name[:]), Terminal: common.IntToString(u.Line[:]), Host: common.IntToString(u.Host[:]), Started: int(u.Time), } ret = append(ret, user) } return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host_freebsd_amd64.go ================================================ // Created by cgo -godefs - DO NOT EDIT // cgo -godefs types_freebsd.go package host 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 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 } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host_linux.go ================================================ // +build linux package host import ( "bytes" "encoding/binary" "fmt" "io/ioutil" "os" "os/exec" "regexp" "runtime" "strconv" "strings" "time" "unsafe" "github.com/shirou/gopsutil/internal/common" ) type LSB struct { ID string Release string Codename string Description string } // from utmp.h const USER_PROCESS = 7 func HostInfo() (*HostInfoStat, error) { ret := &HostInfoStat{ OS: runtime.GOOS, } hostname, err := os.Hostname() if err == nil { ret.Hostname = hostname } platform, family, version, err := GetPlatformInformation() if err == nil { ret.Platform = platform ret.PlatformFamily = family ret.PlatformVersion = version } system, role, err := GetVirtualization() if err == nil { ret.VirtualizationSystem = system ret.VirtualizationRole = role } boot, err := BootTime() if err == nil { ret.BootTime = boot ret.Uptime = uptime(boot) } return ret, nil } // BootTime returns the system boot time expressed in seconds since the epoch. func BootTime() (uint64, error) { filename := common.HostProc("stat") lines, err := common.ReadLines(filename) if err != nil { return 0, err } for _, line := range lines { if strings.HasPrefix(line, "btime") { f := strings.Fields(line) if len(f) != 2 { return 0, fmt.Errorf("wrong btime format") } b, err := strconv.ParseInt(f[1], 10, 64) if err != nil { return 0, err } return uint64(b), nil } } return 0, fmt.Errorf("could not find btime") } func uptime(boot uint64) uint64 { return uint64(time.Now().Unix()) - boot } func Uptime() (uint64, error) { boot, err := BootTime() if err != nil { return 0, err } return uptime(boot), nil } func Users() ([]UserStat, error) { utmpfile := "/var/run/utmp" file, err := os.Open(utmpfile) if err != nil { return nil, err } buf, err := ioutil.ReadAll(file) if err != nil { return nil, err } u := utmp{} entrySize := int(unsafe.Sizeof(u)) count := len(buf) / entrySize ret := make([]UserStat, 0, count) for i := 0; i < count; i++ { b := buf[i*entrySize : i*entrySize+entrySize] var u utmp br := bytes.NewReader(b) err := binary.Read(br, binary.LittleEndian, &u) if err != nil { continue } if u.Type != USER_PROCESS { continue } user := UserStat{ User: common.IntToString(u.User[:]), Terminal: common.IntToString(u.Line[:]), Host: common.IntToString(u.Host[:]), Started: int(u.Tv.TvSec), } ret = append(ret, user) } return ret, nil } func getLSB() (*LSB, error) { ret := &LSB{} if common.PathExists("/etc/lsb-release") { contents, err := common.ReadLines("/etc/lsb-release") if err != nil { return ret, err // return empty } for _, line := range contents { field := strings.Split(line, "=") if len(field) < 2 { continue } switch field[0] { case "DISTRIB_ID": ret.ID = field[1] case "DISTRIB_RELEASE": ret.Release = field[1] case "DISTRIB_CODENAME": ret.Codename = field[1] case "DISTRIB_DESCRIPTION": ret.Description = field[1] } } } else if common.PathExists("/usr/bin/lsb_release") { out, err := exec.Command("/usr/bin/lsb_release").Output() if err != nil { return ret, err } for _, line := range strings.Split(string(out), "\n") { field := strings.Split(line, ":") if len(field) < 2 { continue } switch field[0] { case "Distributor ID": ret.ID = field[1] case "Release": ret.Release = field[1] case "Codename": ret.Codename = field[1] case "Description": ret.Description = field[1] } } } return ret, nil } func GetPlatformInformation() (platform string, family string, version string, err error) { lsb, err := getLSB() if err != nil { lsb = &LSB{} } if common.PathExists("/etc/oracle-release") { platform = "oracle" contents, err := common.ReadLines("/etc/oracle-release") if err == nil { version = getRedhatishVersion(contents) } } else if common.PathExists("/etc/enterprise-release") { platform = "oracle" contents, err := common.ReadLines("/etc/enterprise-release") if err == nil { version = getRedhatishVersion(contents) } } else if common.PathExists("/etc/debian_version") { if lsb.ID == "Ubuntu" { platform = "ubuntu" version = lsb.Release } else if lsb.ID == "LinuxMint" { platform = "linuxmint" version = lsb.Release } else { if common.PathExists("/usr/bin/raspi-config") { platform = "raspbian" } else { platform = "debian" } contents, err := common.ReadLines("/etc/debian_version") if err == nil { version = contents[0] } } } else if common.PathExists("/etc/redhat-release") { contents, err := common.ReadLines("/etc/redhat-release") if err == nil { version = getRedhatishVersion(contents) platform = getRedhatishPlatform(contents) } } else if common.PathExists("/etc/system-release") { contents, err := common.ReadLines("/etc/system-release") if err == nil { version = getRedhatishVersion(contents) platform = getRedhatishPlatform(contents) } } else if common.PathExists("/etc/gentoo-release") { platform = "gentoo" contents, err := common.ReadLines("/etc/gentoo-release") if err == nil { version = getRedhatishVersion(contents) } } else if common.PathExists("/etc/SuSE-release") { contents, err := common.ReadLines("/etc/SuSE-release") if err == nil { version = getSuseVersion(contents) platform = getSusePlatform(contents) } // TODO: slackware detecion } else if common.PathExists("/etc/arch-release") { platform = "arch" version = lsb.Release } else if lsb.ID == "RedHat" { platform = "redhat" version = lsb.Release } else if lsb.ID == "Amazon" { platform = "amazon" version = lsb.Release } else if lsb.ID == "ScientificSL" { platform = "scientific" version = lsb.Release } else if lsb.ID == "XenServer" { platform = "xenserver" version = lsb.Release } else if lsb.ID != "" { platform = strings.ToLower(lsb.ID) version = lsb.Release } switch platform { case "debian", "ubuntu", "linuxmint", "raspbian": family = "debian" case "fedora": family = "fedora" case "oracle", "centos", "redhat", "scientific", "enterpriseenterprise", "amazon", "xenserver", "cloudlinux", "ibm_powerkvm": family = "rhel" case "suse", "opensuse": family = "suse" case "gentoo": family = "gentoo" case "slackware": family = "slackware" case "arch": family = "arch" case "exherbo": family = "exherbo" } return platform, family, version, nil } func getRedhatishVersion(contents []string) string { c := strings.ToLower(strings.Join(contents, "")) if strings.Contains(c, "rawhide") { return "rawhide" } if matches := regexp.MustCompile(`release (\d[\d.]*)`).FindStringSubmatch(c); matches != nil { return matches[1] } return "" } func getRedhatishPlatform(contents []string) string { c := strings.ToLower(strings.Join(contents, "")) if strings.Contains(c, "red hat") { return "redhat" } f := strings.Split(c, " ") return f[0] } func getSuseVersion(contents []string) string { version := "" for _, line := range contents { if matches := regexp.MustCompile(`VERSION = ([\d.]+)`).FindStringSubmatch(line); matches != nil { version = matches[1] } else if matches := regexp.MustCompile(`PATCHLEVEL = ([\d]+)`).FindStringSubmatch(line); matches != nil { version = version + "." + matches[1] } } return version } func getSusePlatform(contents []string) string { c := strings.ToLower(strings.Join(contents, "")) if strings.Contains(c, "opensuse") { return "opensuse" } return "suse" } func GetVirtualization() (string, string, error) { var system string var role string filename := common.HostProc("xen") if common.PathExists(filename) { system = "xen" role = "guest" // assume guest if common.PathExists(filename + "/capabilities") { contents, err := common.ReadLines(filename + "/capabilities") if err == nil { if common.StringsHas(contents, "control_d") { role = "host" } } } } filename = common.HostProc("modules") if common.PathExists(filename) { contents, err := common.ReadLines(filename) if err == nil { if common.StringsContains(contents, "kvm") { system = "kvm" role = "host" } else if common.StringsContains(contents, "vboxdrv") { system = "vbox" role = "host" } else if common.StringsContains(contents, "vboxguest") { system = "vbox" role = "guest" } } } filename = common.HostProc("cpuinfo") if common.PathExists(filename) { contents, err := common.ReadLines(filename) if err == nil { if common.StringsHas(contents, "QEMU Virtual CPU") || common.StringsHas(contents, "Common KVM processor") || common.StringsHas(contents, "Common 32-bit KVM processor") { system = "kvm" role = "guest" } } } filename = common.HostProc() if common.PathExists(filename + "/bc/0") { system = "openvz" role = "host" } else if common.PathExists(filename + "/vz") { system = "openvz" role = "guest" } // not use dmidecode because it requires root if common.PathExists(filename + "/self/status") { contents, err := common.ReadLines(filename + "/self/status") if err == nil { if common.StringsHas(contents, "s_context:") || common.StringsHas(contents, "VxID:") { system = "linux-vserver" } // TODO: guest or host } } if common.PathExists(filename + "/self/cgroup") { contents, err := common.ReadLines(filename + "/self/cgroup") if err == nil { if common.StringsHas(contents, "lxc") || common.StringsHas(contents, "docker") { system = "lxc" role = "guest" } else if common.PathExists("/usr/bin/lxc-version") { // TODO: which system = "lxc" role = "host" } } } return system, role, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host_linux_386.go ================================================ // ATTENTION - FILE MANUAL FIXED AFTER CGO. // Fixed line: Tv _Ctype_struct_timeval -> Tv UtTv // Created by cgo -godefs, MANUAL FIXED // cgo -godefs types_linux.go package host const ( sizeofPtr = 0x4 sizeofShort = 0x2 sizeofInt = 0x4 sizeofLong = 0x4 sizeofLongLong = 0x8 ) type ( _C_short int16 _C_int int32 _C_long int32 _C_long_long int64 ) type utmp struct { Type int16 Pad_cgo_0 [2]byte Pid int32 Line [32]int8 Id [4]int8 User [32]int8 Host [256]int8 Exit exit_status Session int32 Tv UtTv Addr_v6 [4]int32 X__unused [20]int8 } type exit_status struct { Termination int16 Exit int16 } type UtTv struct { TvSec int32 TvUsec int32 } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host_linux_amd64.go ================================================ // Created by cgo -godefs - DO NOT EDIT // cgo -godefs types_linux.go package host 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 utmp struct { Type int16 Pad_cgo_0 [2]byte Pid int32 Line [32]int8 Id [4]int8 User [32]int8 Host [256]int8 Exit exit_status Session int32 Tv UtTv Addr_v6 [4]int32 X__glibc_reserved [20]int8 } type exit_status struct { Termination int16 Exit int16 } type UtTv struct { TvSec int32 TvUsec int32 } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host_linux_arm.go ================================================ // +build linux // +build arm package host 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 utmp struct { Type int16 Pad_cgo_0 [2]byte Pid int32 Line [32]int8 Id [4]int8 User [32]int8 Host [256]int8 Exit exit_status Session int32 Tv UtTv Addr_v6 [4]int32 X__glibc_reserved [20]int8 } type exit_status struct { Termination int16 Exit int16 } type UtTv struct { TvSec int32 TvUsec int32 } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/host_windows.go ================================================ // +build windows package host import ( "fmt" "os" "runtime" "strings" "time" "github.com/StackExchange/wmi" "github.com/shirou/gopsutil/internal/common" process "github.com/shirou/gopsutil/process" ) var ( procGetSystemTimeAsFileTime = common.Modkernel32.NewProc("GetSystemTimeAsFileTime") osInfo *Win32_OperatingSystem ) type Win32_OperatingSystem struct { Version string Caption string ProductType uint32 BuildNumber string LastBootUpTime time.Time } func HostInfo() (*HostInfoStat, error) { ret := &HostInfoStat{ OS: runtime.GOOS, } hostname, err := os.Hostname() if err == nil { ret.Hostname = hostname } platform, family, version, err := GetPlatformInformation() if err == nil { ret.Platform = platform ret.PlatformFamily = family ret.PlatformVersion = version } else { return ret, err } boot, err := BootTime() if err == nil { ret.BootTime = boot ret.Uptime = uptime(boot) } procs, err := process.Pids() if err != nil { return ret, err } ret.Procs = uint64(len(procs)) return ret, nil } func GetOSInfo() (Win32_OperatingSystem, error) { var dst []Win32_OperatingSystem q := wmi.CreateQuery(&dst, "") err := wmi.Query(q, &dst) if err != nil { return Win32_OperatingSystem{}, err } osInfo = &dst[0] return dst[0], nil } func BootTime() (uint64, error) { if osInfo == nil { _, err := GetOSInfo() if err != nil { return 0, err } } now := time.Now() t := osInfo.LastBootUpTime.Local() return uint64(now.Sub(t).Seconds()), nil } func uptime(boot uint64) uint64 { return uint64(time.Now().Unix()) - boot } func Uptime() (uint64, error) { boot, err := BootTime() if err != nil { return 0, err } return uptime(boot), nil } func GetPlatformInformation() (platform string, family string, version string, err error) { if osInfo == nil { _, err = GetOSInfo() if err != nil { return } } // Platform platform = strings.Trim(osInfo.Caption, " ") // PlatformFamily switch osInfo.ProductType { case 1: family = "Standalone Workstation" case 2: family = "Server (Domain Controller)" case 3: family = "Server" } // Platform Version version = fmt.Sprintf("%s Build %s", osInfo.Version, osInfo.BuildNumber) return } func Users() ([]UserStat, error) { var ret []UserStat return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/host/types_darwin.go ================================================ // +build ignore // plus hand editing about timeval /* Input to cgo -godefs. */ package host /* #include #include */ import "C" type Utmpx C.struct_utmpx type Timeval C.struct_timeval ================================================ FILE: vendor/github.com/shirou/gopsutil/host/types_freebsd.go ================================================ // +build ignore /* Input to cgo -godefs. */ package host /* #define KERNEL #include #include #include enum { sizeofPtr = sizeof(void*), }; */ 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 ) type Utmp C.struct_utmp type Utmpx C.struct_utmpx type Timeval C.struct_timeval ================================================ FILE: vendor/github.com/shirou/gopsutil/host/types_linux.go ================================================ // +build ignore /* Input to cgo -godefs. */ package host /* #define KERNEL #include #include enum { sizeofPtr = sizeof(void*), }; */ 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 ) type utmp C.struct_utmp type exit_status C.struct_exit_status type UtTv struct { TvSec int32 TvUsec int32 } ================================================ FILE: vendor/github.com/shirou/gopsutil/internal/common/binary.go ================================================ // 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. // Package binary implements simple translation between numbers and byte // sequences and encoding and decoding of varints. // // Numbers are translated by reading and writing fixed-size values. // A fixed-size value is either a fixed-size arithmetic // type (int8, uint8, int16, float32, complex64, ...) // or an array or struct containing only fixed-size values. // // The varint functions encode and decode single integer values using // a variable-length encoding; smaller values require fewer bytes. // For a specification, see // http://code.google.com/apis/protocolbuffers/docs/encoding.html. // // This package favors simplicity over efficiency. Clients that require // high-performance serialization, especially for large data structures, // should look at more advanced solutions such as the encoding/gob // package or protocol buffers. package common import ( "errors" "io" "math" "reflect" ) // A ByteOrder specifies how to convert byte sequences into // 16-, 32-, or 64-bit unsigned integers. type ByteOrder interface { Uint16([]byte) uint16 Uint32([]byte) uint32 Uint64([]byte) uint64 PutUint16([]byte, uint16) PutUint32([]byte, uint32) PutUint64([]byte, uint64) String() string } // LittleEndian is the little-endian implementation of ByteOrder. var LittleEndian littleEndian // BigEndian is the big-endian implementation of ByteOrder. var BigEndian bigEndian type littleEndian struct{} func (littleEndian) Uint16(b []byte) uint16 { return uint16(b[0]) | uint16(b[1])<<8 } func (littleEndian) PutUint16(b []byte, v uint16) { b[0] = byte(v) b[1] = byte(v >> 8) } func (littleEndian) Uint32(b []byte) uint32 { return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 } func (littleEndian) PutUint32(b []byte, v uint32) { b[0] = byte(v) b[1] = byte(v >> 8) b[2] = byte(v >> 16) b[3] = byte(v >> 24) } func (littleEndian) Uint64(b []byte) uint64 { return uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56 } func (littleEndian) PutUint64(b []byte, v uint64) { b[0] = byte(v) b[1] = byte(v >> 8) b[2] = byte(v >> 16) b[3] = byte(v >> 24) b[4] = byte(v >> 32) b[5] = byte(v >> 40) b[6] = byte(v >> 48) b[7] = byte(v >> 56) } func (littleEndian) String() string { return "LittleEndian" } func (littleEndian) GoString() string { return "binary.LittleEndian" } type bigEndian struct{} func (bigEndian) Uint16(b []byte) uint16 { return uint16(b[1]) | uint16(b[0])<<8 } func (bigEndian) PutUint16(b []byte, v uint16) { b[0] = byte(v >> 8) b[1] = byte(v) } func (bigEndian) Uint32(b []byte) uint32 { return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24 } func (bigEndian) PutUint32(b []byte, v uint32) { b[0] = byte(v >> 24) b[1] = byte(v >> 16) b[2] = byte(v >> 8) b[3] = byte(v) } func (bigEndian) Uint64(b []byte) uint64 { return uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 | uint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56 } func (bigEndian) PutUint64(b []byte, v uint64) { b[0] = byte(v >> 56) b[1] = byte(v >> 48) b[2] = byte(v >> 40) b[3] = byte(v >> 32) b[4] = byte(v >> 24) b[5] = byte(v >> 16) b[6] = byte(v >> 8) b[7] = byte(v) } func (bigEndian) String() string { return "BigEndian" } func (bigEndian) GoString() string { return "binary.BigEndian" } // Read reads structured binary data from r into data. // Data must be a pointer to a fixed-size value or a slice // of fixed-size values. // Bytes read from r are decoded using the specified byte order // and written to successive fields of the data. // When reading into structs, the field data for fields with // blank (_) field names is skipped; i.e., blank field names // may be used for padding. // When reading into a struct, all non-blank fields must be exported. func Read(r io.Reader, order ByteOrder, data interface{}) error { // Fast path for basic types and slices. if n := intDataSize(data); n != 0 { var b [8]byte var bs []byte if n > len(b) { bs = make([]byte, n) } else { bs = b[:n] } if _, err := io.ReadFull(r, bs); err != nil { return err } switch data := data.(type) { case *int8: *data = int8(b[0]) case *uint8: *data = b[0] case *int16: *data = int16(order.Uint16(bs)) case *uint16: *data = order.Uint16(bs) case *int32: *data = int32(order.Uint32(bs)) case *uint32: *data = order.Uint32(bs) case *int64: *data = int64(order.Uint64(bs)) case *uint64: *data = order.Uint64(bs) case []int8: for i, x := range bs { // Easier to loop over the input for 8-bit values. data[i] = int8(x) } case []uint8: copy(data, bs) case []int16: for i := range data { data[i] = int16(order.Uint16(bs[2*i:])) } case []uint16: for i := range data { data[i] = order.Uint16(bs[2*i:]) } case []int32: for i := range data { data[i] = int32(order.Uint32(bs[4*i:])) } case []uint32: for i := range data { data[i] = order.Uint32(bs[4*i:]) } case []int64: for i := range data { data[i] = int64(order.Uint64(bs[8*i:])) } case []uint64: for i := range data { data[i] = order.Uint64(bs[8*i:]) } } return nil } // Fallback to reflect-based decoding. v := reflect.ValueOf(data) size := -1 switch v.Kind() { case reflect.Ptr: v = v.Elem() size = dataSize(v) case reflect.Slice: size = dataSize(v) } if size < 0 { return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String()) } d := &decoder{order: order, buf: make([]byte, size)} if _, err := io.ReadFull(r, d.buf); err != nil { return err } d.value(v) return nil } // Write writes the binary representation of data into w. // Data must be a fixed-size value or a slice of fixed-size // values, or a pointer to such data. // Bytes written to w are encoded using the specified byte order // and read from successive fields of the data. // When writing structs, zero values are written for fields // with blank (_) field names. func Write(w io.Writer, order ByteOrder, data interface{}) error { // Fast path for basic types and slices. if n := intDataSize(data); n != 0 { var b [8]byte var bs []byte if n > len(b) { bs = make([]byte, n) } else { bs = b[:n] } switch v := data.(type) { case *int8: bs = b[:1] b[0] = byte(*v) case int8: bs = b[:1] b[0] = byte(v) case []int8: for i, x := range v { bs[i] = byte(x) } case *uint8: bs = b[:1] b[0] = *v case uint8: bs = b[:1] b[0] = byte(v) case []uint8: bs = v case *int16: bs = b[:2] order.PutUint16(bs, uint16(*v)) case int16: bs = b[:2] order.PutUint16(bs, uint16(v)) case []int16: for i, x := range v { order.PutUint16(bs[2*i:], uint16(x)) } case *uint16: bs = b[:2] order.PutUint16(bs, *v) case uint16: bs = b[:2] order.PutUint16(bs, v) case []uint16: for i, x := range v { order.PutUint16(bs[2*i:], x) } case *int32: bs = b[:4] order.PutUint32(bs, uint32(*v)) case int32: bs = b[:4] order.PutUint32(bs, uint32(v)) case []int32: for i, x := range v { order.PutUint32(bs[4*i:], uint32(x)) } case *uint32: bs = b[:4] order.PutUint32(bs, *v) case uint32: bs = b[:4] order.PutUint32(bs, v) case []uint32: for i, x := range v { order.PutUint32(bs[4*i:], x) } case *int64: bs = b[:8] order.PutUint64(bs, uint64(*v)) case int64: bs = b[:8] order.PutUint64(bs, uint64(v)) case []int64: for i, x := range v { order.PutUint64(bs[8*i:], uint64(x)) } case *uint64: bs = b[:8] order.PutUint64(bs, *v) case uint64: bs = b[:8] order.PutUint64(bs, v) case []uint64: for i, x := range v { order.PutUint64(bs[8*i:], x) } } _, err := w.Write(bs) return err } // Fallback to reflect-based encoding. v := reflect.Indirect(reflect.ValueOf(data)) size := dataSize(v) if size < 0 { return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String()) } buf := make([]byte, size) e := &encoder{order: order, buf: buf} e.value(v) _, err := w.Write(buf) return err } // Size returns how many bytes Write would generate to encode the value v, which // must be a fixed-size value or a slice of fixed-size values, or a pointer to such data. // If v is neither of these, Size returns -1. func Size(v interface{}) int { return dataSize(reflect.Indirect(reflect.ValueOf(v))) } // dataSize returns the number of bytes the actual data represented by v occupies in memory. // For compound structures, it sums the sizes of the elements. Thus, for instance, for a slice // it returns the length of the slice times the element size and does not count the memory // occupied by the header. If the type of v is not acceptable, dataSize returns -1. func dataSize(v reflect.Value) int { if v.Kind() == reflect.Slice { if s := sizeof(v.Type().Elem()); s >= 0 { return s * v.Len() } return -1 } return sizeof(v.Type()) } // sizeof returns the size >= 0 of variables for the given type or -1 if the type is not acceptable. func sizeof(t reflect.Type) int { switch t.Kind() { case reflect.Array: if s := sizeof(t.Elem()); s >= 0 { return s * t.Len() } case reflect.Struct: sum := 0 for i, n := 0, t.NumField(); i < n; i++ { s := sizeof(t.Field(i).Type) if s < 0 { return -1 } sum += s } return sum case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128, reflect.Ptr: return int(t.Size()) } return -1 } type coder struct { order ByteOrder buf []byte } type decoder coder type encoder coder func (d *decoder) uint8() uint8 { x := d.buf[0] d.buf = d.buf[1:] return x } func (e *encoder) uint8(x uint8) { e.buf[0] = x e.buf = e.buf[1:] } func (d *decoder) uint16() uint16 { x := d.order.Uint16(d.buf[0:2]) d.buf = d.buf[2:] return x } func (e *encoder) uint16(x uint16) { e.order.PutUint16(e.buf[0:2], x) e.buf = e.buf[2:] } func (d *decoder) uint32() uint32 { x := d.order.Uint32(d.buf[0:4]) d.buf = d.buf[4:] return x } func (e *encoder) uint32(x uint32) { e.order.PutUint32(e.buf[0:4], x) e.buf = e.buf[4:] } func (d *decoder) uint64() uint64 { x := d.order.Uint64(d.buf[0:8]) d.buf = d.buf[8:] return x } func (e *encoder) uint64(x uint64) { e.order.PutUint64(e.buf[0:8], x) e.buf = e.buf[8:] } func (d *decoder) int8() int8 { return int8(d.uint8()) } func (e *encoder) int8(x int8) { e.uint8(uint8(x)) } func (d *decoder) int16() int16 { return int16(d.uint16()) } func (e *encoder) int16(x int16) { e.uint16(uint16(x)) } func (d *decoder) int32() int32 { return int32(d.uint32()) } func (e *encoder) int32(x int32) { e.uint32(uint32(x)) } func (d *decoder) int64() int64 { return int64(d.uint64()) } func (e *encoder) int64(x int64) { e.uint64(uint64(x)) } func (d *decoder) value(v reflect.Value) { switch v.Kind() { case reflect.Array: l := v.Len() for i := 0; i < l; i++ { d.value(v.Index(i)) } case reflect.Struct: t := v.Type() l := v.NumField() for i := 0; i < l; i++ { // Note: Calling v.CanSet() below is an optimization. // It would be sufficient to check the field name, // but creating the StructField info for each field is // costly (run "go test -bench=ReadStruct" and compare // results when making changes to this code). if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" { d.value(v) } else { d.skip(v) } } case reflect.Slice: l := v.Len() for i := 0; i < l; i++ { d.value(v.Index(i)) } case reflect.Int8: v.SetInt(int64(d.int8())) case reflect.Int16: v.SetInt(int64(d.int16())) case reflect.Int32: v.SetInt(int64(d.int32())) case reflect.Int64: v.SetInt(d.int64()) case reflect.Uint8: v.SetUint(uint64(d.uint8())) case reflect.Uint16: v.SetUint(uint64(d.uint16())) case reflect.Uint32: v.SetUint(uint64(d.uint32())) case reflect.Uint64: v.SetUint(d.uint64()) case reflect.Float32: v.SetFloat(float64(math.Float32frombits(d.uint32()))) case reflect.Float64: v.SetFloat(math.Float64frombits(d.uint64())) case reflect.Complex64: v.SetComplex(complex( float64(math.Float32frombits(d.uint32())), float64(math.Float32frombits(d.uint32())), )) case reflect.Complex128: v.SetComplex(complex( math.Float64frombits(d.uint64()), math.Float64frombits(d.uint64()), )) } } func (e *encoder) value(v reflect.Value) { switch v.Kind() { case reflect.Array: l := v.Len() for i := 0; i < l; i++ { e.value(v.Index(i)) } case reflect.Struct: t := v.Type() l := v.NumField() for i := 0; i < l; i++ { // see comment for corresponding code in decoder.value() if v := v.Field(i); v.CanSet() || t.Field(i).Name != "_" { e.value(v) } else { e.skip(v) } } case reflect.Slice: l := v.Len() for i := 0; i < l; i++ { e.value(v.Index(i)) } case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: switch v.Type().Kind() { case reflect.Int8: e.int8(int8(v.Int())) case reflect.Int16: e.int16(int16(v.Int())) case reflect.Int32: e.int32(int32(v.Int())) case reflect.Int64: e.int64(v.Int()) } case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: switch v.Type().Kind() { case reflect.Uint8: e.uint8(uint8(v.Uint())) case reflect.Uint16: e.uint16(uint16(v.Uint())) case reflect.Uint32: e.uint32(uint32(v.Uint())) case reflect.Uint64: e.uint64(v.Uint()) } case reflect.Float32, reflect.Float64: switch v.Type().Kind() { case reflect.Float32: e.uint32(math.Float32bits(float32(v.Float()))) case reflect.Float64: e.uint64(math.Float64bits(v.Float())) } case reflect.Complex64, reflect.Complex128: switch v.Type().Kind() { case reflect.Complex64: x := v.Complex() e.uint32(math.Float32bits(float32(real(x)))) e.uint32(math.Float32bits(float32(imag(x)))) case reflect.Complex128: x := v.Complex() e.uint64(math.Float64bits(real(x))) e.uint64(math.Float64bits(imag(x))) } } } func (d *decoder) skip(v reflect.Value) { d.buf = d.buf[dataSize(v):] } func (e *encoder) skip(v reflect.Value) { n := dataSize(v) for i := range e.buf[0:n] { e.buf[i] = 0 } e.buf = e.buf[n:] } // intDataSize returns the size of the data required to represent the data when encoded. // It returns zero if the type cannot be implemented by the fast path in Read or Write. func intDataSize(data interface{}) int { switch data := data.(type) { case int8, *int8, *uint8: return 1 case []int8: return len(data) case []uint8: return len(data) case int16, *int16, *uint16: return 2 case []int16: return 2 * len(data) case []uint16: return 2 * len(data) case int32, *int32, *uint32: return 4 case []int32: return 4 * len(data) case []uint32: return 4 * len(data) case int64, *int64, *uint64: return 8 case []int64: return 8 * len(data) case []uint64: return 8 * len(data) } return 0 } ================================================ FILE: vendor/github.com/shirou/gopsutil/internal/common/common.go ================================================ // // gopsutil is a port of psutil(http://pythonhosted.org/psutil/). // This covers these architectures. // - linux (amd64, arm) // - freebsd (amd64) // - windows (amd64) package common import ( "bufio" "errors" "io/ioutil" "net/url" "os" "os/exec" "path" "path/filepath" "reflect" "runtime" "strconv" "strings" ) type Invoker interface { Command(string, ...string) ([]byte, error) } type Invoke struct{} func (i Invoke) Command(name string, arg ...string) ([]byte, error) { return exec.Command(name, arg...).Output() } type FakeInvoke struct { CommandExpectedDir string // CommandExpectedDir specifies dir which includes expected outputs. Suffix string // Suffix species expected file name suffix such as "fail" Error error // If Error specfied, return the error. } // Command in FakeInvoke returns from expected file if exists. func (i FakeInvoke) Command(name string, arg ...string) ([]byte, error) { if i.Error != nil { return []byte{}, i.Error } arch := runtime.GOOS fname := strings.Join(append([]string{name}, arg...), "") fname = url.QueryEscape(fname) var dir string if i.CommandExpectedDir == "" { dir = "expected" } else { dir = i.CommandExpectedDir } fpath := path.Join(dir, arch, fname) if i.Suffix != "" { fpath += "_" + i.Suffix } if PathExists(fpath) { return ioutil.ReadFile(fpath) } else { return exec.Command(name, arg...).Output() } } var NotImplementedError = errors.New("not implemented yet") // ReadLines reads contents from a file and splits them by new lines. // A convenience wrapper to ReadLinesOffsetN(filename, 0, -1). func ReadLines(filename string) ([]string, error) { return ReadLinesOffsetN(filename, 0, -1) } // ReadLines reads contents from file and splits them by new line. // The offset tells at which line number to start. // The count determines the number of lines to read (starting from offset): // n >= 0: at most n lines // n < 0: whole file func ReadLinesOffsetN(filename string, offset uint, n int) ([]string, error) { f, err := os.Open(filename) if err != nil { return []string{""}, err } defer f.Close() var ret []string r := bufio.NewReader(f) for i := 0; i < n+int(offset) || n < 0; i++ { line, err := r.ReadString('\n') if err != nil { break } if i < int(offset) { continue } ret = append(ret, strings.Trim(line, "\n")) } return ret, nil } func IntToString(orig []int8) string { ret := make([]byte, len(orig)) size := -1 for i, o := range orig { if o == 0 { size = i break } ret[i] = byte(o) } if size == -1 { size = len(orig) } return string(ret[0:size]) } func ByteToString(orig []byte) string { n := -1 l := -1 for i, b := range orig { // skip left side null if l == -1 && b == 0 { continue } if l == -1 { l = i } if b == 0 { break } n = i + 1 } if n == -1 { return string(orig) } return string(orig[l:n]) } // ReadInts reads contents from single line file and returns them as []int32. func ReadInts(filename string) ([]int64, error) { f, err := os.Open(filename) if err != nil { return []int64{}, err } defer f.Close() var ret []int64 r := bufio.NewReader(f) // The int files that this is concerned with should only be one liners. line, err := r.ReadString('\n') if err != nil { return []int64{}, err } i, err := strconv.ParseInt(strings.Trim(line, "\n"), 10, 32) if err != nil { return []int64{}, err } ret = append(ret, i) return ret, nil } // Parse to int32 without error func mustParseInt32(val string) int32 { vv, _ := strconv.ParseInt(val, 10, 32) return int32(vv) } // Parse to uint64 without error func mustParseUint64(val string) uint64 { vv, _ := strconv.ParseInt(val, 10, 64) return uint64(vv) } // Parse to Float64 without error func mustParseFloat64(val string) float64 { vv, _ := strconv.ParseFloat(val, 64) return vv } // StringsHas checks the target string slice contains src or not func StringsHas(target []string, src string) bool { for _, t := range target { if strings.TrimSpace(t) == src { return true } } return false } // StringsContains checks the src in any string of the target string slice func StringsContains(target []string, src string) bool { for _, t := range target { if strings.Contains(t, src) { return true } } return false } // get struct attributes. // This method is used only for debugging platform dependent code. func attributes(m interface{}) map[string]reflect.Type { typ := reflect.TypeOf(m) if typ.Kind() == reflect.Ptr { typ = typ.Elem() } attrs := make(map[string]reflect.Type) if typ.Kind() != reflect.Struct { return nil } for i := 0; i < typ.NumField(); i++ { p := typ.Field(i) if !p.Anonymous { attrs[p.Name] = p.Type } } return attrs } func PathExists(filename string) bool { if _, err := os.Stat(filename); err == nil { return true } return false } //GetEnv retrieves the environment variable key. If it does not exist it returns the default. func GetEnv(key string, dfault string, combineWith ...string) string { value := os.Getenv(key) if value == "" { value = dfault } switch len(combineWith) { case 0: return value case 1: return filepath.Join(value, combineWith[0]) default: all := make([]string, len(combineWith)+1) all[0] = value copy(all[1:], combineWith) return filepath.Join(all...) } panic("invalid switch case") } func HostProc(combineWith ...string) string { return GetEnv("HOST_PROC", "/proc", combineWith...) } func HostSys(combineWith ...string) string { return GetEnv("HOST_SYS", "/sys", combineWith...) } ================================================ FILE: vendor/github.com/shirou/gopsutil/internal/common/common_darwin.go ================================================ // +build darwin package common import ( "os" "os/exec" "strings" "syscall" "unsafe" ) func DoSysctrl(mib string) ([]string, error) { os.Setenv("LC_ALL", "C") out, err := exec.Command("/usr/sbin/sysctl", "-n", mib).Output() if err != nil { return []string{}, err } v := strings.Replace(string(out), "{ ", "", 1) v = strings.Replace(string(v), " }", "", 1) values := strings.Fields(string(v)) return values, nil } func CallSyscall(mib []int32) ([]byte, uint64, error) { miblen := uint64(len(mib)) // get required buffer size length := uint64(0) _, _, err := syscall.Syscall6( syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), uintptr(miblen), 0, uintptr(unsafe.Pointer(&length)), 0, 0) if err != 0 { var b []byte return b, length, err } if length == 0 { var b []byte return b, length, err } // get proc info itself buf := make([]byte, length) _, _, err = syscall.Syscall6( syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), uintptr(miblen), uintptr(unsafe.Pointer(&buf[0])), uintptr(unsafe.Pointer(&length)), 0, 0) if err != 0 { return buf, length, err } return buf, length, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/internal/common/common_freebsd.go ================================================ // +build freebsd package common import ( "os" "os/exec" "strings" "syscall" "unsafe" ) func DoSysctrl(mib string) ([]string, error) { os.Setenv("LC_ALL", "C") out, err := exec.Command("/sbin/sysctl", "-n", mib).Output() if err != nil { return []string{}, err } v := strings.Replace(string(out), "{ ", "", 1) v = strings.Replace(string(v), " }", "", 1) values := strings.Fields(string(v)) return values, nil } func CallSyscall(mib []int32) ([]byte, uint64, error) { mibptr := unsafe.Pointer(&mib[0]) miblen := uint64(len(mib)) // get required buffer size length := uint64(0) _, _, err := syscall.Syscall6( syscall.SYS___SYSCTL, uintptr(mibptr), uintptr(miblen), 0, uintptr(unsafe.Pointer(&length)), 0, 0) if err != 0 { var b []byte return b, length, err } if length == 0 { var b []byte return b, length, err } // 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 } ================================================ FILE: vendor/github.com/shirou/gopsutil/internal/common/common_linux.go ================================================ // +build linux package common ================================================ FILE: vendor/github.com/shirou/gopsutil/internal/common/common_unix.go ================================================ // +build linux freebsd darwin package common import ( "os/exec" "strconv" "strings" ) func CallLsof(invoke Invoker, pid int32, args ...string) ([]string, error) { var cmd []string if pid == 0 { // will get from all processes. cmd = []string{"-a", "-n", "-P"} } else { cmd = []string{"-a", "-n", "-P", "-p", strconv.Itoa(int(pid))} } cmd = append(cmd, args...) lsof, err := exec.LookPath("lsof") if err != nil { return []string{}, err } out, err := invoke.Command(lsof, cmd...) if err != nil { // if no pid found, lsof returnes code 1. if err.Error() == "exit status 1" && len(out) == 0 { return []string{}, nil } } lines := strings.Split(string(out), "\n") var ret []string for _, l := range lines[1:] { if len(l) == 0 { continue } ret = append(ret, l) } return ret, nil } func CallPgrep(invoke Invoker, pid int32) ([]int32, error) { var cmd []string cmd = []string{"-P", strconv.Itoa(int(pid))} pgrep, err := exec.LookPath("pgrep") if err != nil { return []int32{}, err } out, err := invoke.Command(pgrep, cmd...) if err != nil { return []int32{}, err } lines := strings.Split(string(out), "\n") ret := make([]int32, 0, len(lines)) for _, l := range lines { if len(l) == 0 { continue } i, err := strconv.Atoi(l) if err != nil { continue } ret = append(ret, int32(i)) } return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/internal/common/common_windows.go ================================================ // +build windows package common import ( "syscall" "unsafe" ) // for double values type PDH_FMT_COUNTERVALUE_DOUBLE struct { CStatus uint32 DoubleValue float64 } // for 64 bit integer values type PDH_FMT_COUNTERVALUE_LARGE struct { CStatus uint32 LargeValue int64 } // for long values type PDH_FMT_COUNTERVALUE_LONG struct { CStatus uint32 LongValue int32 padding [4]byte } // windows system const const ( ERROR_SUCCESS = 0 ERROR_FILE_NOT_FOUND = 2 DRIVE_REMOVABLE = 2 DRIVE_FIXED = 3 HKEY_LOCAL_MACHINE = 0x80000002 RRF_RT_REG_SZ = 0x00000002 RRF_RT_REG_DWORD = 0x00000010 PDH_FMT_LONG = 0x00000100 PDH_FMT_DOUBLE = 0x00000200 PDH_FMT_LARGE = 0x00000400 PDH_INVALID_DATA = 0xc0000bc6 PDH_INVALID_HANDLE = 0xC0000bbc PDH_NO_DATA = 0x800007d5 ) var ( Modkernel32 = syscall.NewLazyDLL("kernel32.dll") ModNt = syscall.NewLazyDLL("ntdll.dll") ModPdh = syscall.NewLazyDLL("pdh.dll") ProcGetSystemTimes = Modkernel32.NewProc("GetSystemTimes") ProcNtQuerySystemInformation = ModNt.NewProc("NtQuerySystemInformation") PdhOpenQuery = ModPdh.NewProc("PdhOpenQuery") PdhAddCounter = ModPdh.NewProc("PdhAddCounterW") PdhCollectQueryData = ModPdh.NewProc("PdhCollectQueryData") PdhGetFormattedCounterValue = ModPdh.NewProc("PdhGetFormattedCounterValue") PdhCloseQuery = ModPdh.NewProc("PdhCloseQuery") ) type FILETIME struct { DwLowDateTime uint32 DwHighDateTime uint32 } // borrowed from net/interface_windows.go func BytePtrToString(p *uint8) string { a := (*[10000]uint8)(unsafe.Pointer(p)) i := 0 for a[i] != 0 { i++ } return string(a[:i]) } // CounterInfo // copied from https://github.com/mackerelio/mackerel-agent/ type CounterInfo struct { PostName string CounterName string Counter syscall.Handle } // CreateQuery XXX // copied from https://github.com/mackerelio/mackerel-agent/ func CreateQuery() (syscall.Handle, error) { var query syscall.Handle r, _, err := PdhOpenQuery.Call(0, 0, uintptr(unsafe.Pointer(&query))) if r != 0 { return 0, err } return query, nil } // CreateCounter XXX func CreateCounter(query syscall.Handle, pname, cname string) (*CounterInfo, error) { var counter syscall.Handle r, _, err := PdhAddCounter.Call( uintptr(query), uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(cname))), 0, uintptr(unsafe.Pointer(&counter))) if r != 0 { return nil, err } return &CounterInfo{ PostName: pname, CounterName: cname, Counter: counter, }, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/mem/mem.go ================================================ package mem import ( "encoding/json" ) type VirtualMemoryStat struct { Total uint64 `json:"total"` Available uint64 `json:"available"` Used uint64 `json:"used"` UsedPercent float64 `json:"used_percent"` Free uint64 `json:"free"` Active uint64 `json:"active"` Inactive uint64 `json:"inactive"` Buffers uint64 `json:"buffers"` Cached uint64 `json:"cached"` Wired uint64 `json:"wired"` Shared uint64 `json:"shared"` } type SwapMemoryStat struct { Total uint64 `json:"total"` Used uint64 `json:"used"` Free uint64 `json:"free"` UsedPercent float64 `json:"used_percent"` Sin uint64 `json:"sin"` Sout uint64 `json:"sout"` } func (m VirtualMemoryStat) String() string { s, _ := json.Marshal(m) return string(s) } func (m SwapMemoryStat) String() string { s, _ := json.Marshal(m) return string(s) } ================================================ FILE: vendor/github.com/shirou/gopsutil/mem/mem_darwin.go ================================================ // +build darwin package mem import ( "os/exec" "strconv" "strings" "github.com/shirou/gopsutil/internal/common" ) func getPageSize() (uint64, error) { out, err := exec.Command("pagesize").Output() if err != nil { return 0, err } o := strings.TrimSpace(string(out)) p, err := strconv.ParseUint(o, 10, 64) if err != nil { return 0, err } return p, nil } // Runs vm_stat and returns Free and inactive pages func getVmStat(pagesize uint64, vms *VirtualMemoryStat) error { out, err := exec.Command("vm_stat").Output() if err != nil { return err } return parseVmStat(string(out), pagesize, vms) } func parseVmStat(out string, pagesize uint64, vms *VirtualMemoryStat) error { var err error lines := strings.Split(out, "\n") for _, line := range lines { fields := strings.Split(line, ":") if len(fields) < 2 { continue } key := strings.TrimSpace(fields[0]) value := strings.Trim(fields[1], " .") switch key { case "Pages free": free, e := strconv.ParseUint(value, 10, 64) if e != nil { err = e } vms.Free = free * pagesize case "Pages inactive": inactive, e := strconv.ParseUint(value, 10, 64) if e != nil { err = e } vms.Cached += inactive * pagesize vms.Inactive = inactive * pagesize case "Pages active": active, e := strconv.ParseUint(value, 10, 64) if e != nil { err = e } vms.Active = active * pagesize case "Pages wired down": wired, e := strconv.ParseUint(value, 10, 64) if e != nil { err = e } vms.Wired = wired * pagesize case "Pages purgeable": purgeable, e := strconv.ParseUint(value, 10, 64) if e != nil { err = e } vms.Cached += purgeable * pagesize } } return err } // VirtualMemory returns VirtualmemoryStat. func VirtualMemory() (*VirtualMemoryStat, error) { ret := &VirtualMemoryStat{} p, err := getPageSize() if err != nil { return nil, err } t, err := common.DoSysctrl("hw.memsize") if err != nil { return nil, err } total, err := strconv.ParseUint(t[0], 10, 64) if err != nil { return nil, err } err = getVmStat(p, ret) if err != nil { return nil, err } ret.Available = ret.Free + ret.Cached ret.Total = total ret.Used = ret.Total - ret.Free ret.UsedPercent = float64(ret.Total-ret.Available) / float64(ret.Total) * 100.0 return ret, nil } // SwapMemory returns swapinfo. func SwapMemory() (*SwapMemoryStat, error) { var ret *SwapMemoryStat swapUsage, err := common.DoSysctrl("vm.swapusage") if err != nil { return ret, err } total := strings.Replace(swapUsage[2], "M", "", 1) used := strings.Replace(swapUsage[5], "M", "", 1) free := strings.Replace(swapUsage[8], "M", "", 1) total_v, err := strconv.ParseFloat(total, 64) if err != nil { return nil, err } used_v, err := strconv.ParseFloat(used, 64) if err != nil { return nil, err } free_v, err := strconv.ParseFloat(free, 64) if err != nil { return nil, err } u := float64(0) if total_v != 0 { u = ((total_v - free_v) / total_v) * 100.0 } // vm.swapusage shows "M", multiply 1000 ret = &SwapMemoryStat{ Total: uint64(total_v * 1000), Used: uint64(used_v * 1000), Free: uint64(free_v * 1000), UsedPercent: u, } return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/mem/mem_freebsd.go ================================================ // +build freebsd package mem import ( "errors" "os/exec" "strconv" "strings" "github.com/shirou/gopsutil/internal/common" ) func VirtualMemory() (*VirtualMemoryStat, error) { pageSize, err := common.DoSysctrl("vm.stats.vm.v_page_size") if err != nil { return nil, err } p, err := strconv.ParseUint(pageSize[0], 10, 64) if err != nil { return nil, err } pageCount, err := common.DoSysctrl("vm.stats.vm.v_page_count") if err != nil { return nil, err } free, err := common.DoSysctrl("vm.stats.vm.v_free_count") if err != nil { return nil, err } active, err := common.DoSysctrl("vm.stats.vm.v_active_count") if err != nil { return nil, err } inactive, err := common.DoSysctrl("vm.stats.vm.v_inactive_count") if err != nil { return nil, err } cache, err := common.DoSysctrl("vm.stats.vm.v_cache_count") if err != nil { return nil, err } buffer, err := common.DoSysctrl("vfs.bufspace") if err != nil { return nil, err } wired, err := common.DoSysctrl("vm.stats.vm.v_wire_count") if err != nil { return nil, err } parsed := make([]uint64, 0, 7) vv := []string{ pageCount[0], free[0], active[0], inactive[0], cache[0], buffer[0], wired[0], } for _, target := range vv { t, err := strconv.ParseUint(target, 10, 64) if err != nil { return nil, err } parsed = append(parsed, t) } ret := &VirtualMemoryStat{ Total: parsed[0] * p, Free: parsed[1] * p, Active: parsed[2] * p, Inactive: parsed[3] * p, Cached: parsed[4] * p, Buffers: parsed[5], Wired: parsed[6] * p, } ret.Available = ret.Inactive + ret.Cached + ret.Free ret.Used = ret.Active + ret.Wired + ret.Cached ret.UsedPercent = float64(ret.Total-ret.Available) / float64(ret.Total) * 100.0 return ret, nil } // Return swapinfo // FreeBSD can have multiple swap devices. but use only first device func SwapMemory() (*SwapMemoryStat, error) { out, err := exec.Command("swapinfo").Output() if err != nil { return nil, err } for _, line := range strings.Split(string(out), "\n") { values := strings.Fields(line) // skip title line if len(values) == 0 || values[0] == "Device" { continue } u := strings.Replace(values[4], "%", "", 1) total_v, err := strconv.ParseUint(values[1], 10, 64) if err != nil { return nil, err } used_v, err := strconv.ParseUint(values[2], 10, 64) if err != nil { return nil, err } free_v, err := strconv.ParseUint(values[3], 10, 64) if err != nil { return nil, err } up_v, err := strconv.ParseFloat(u, 64) if err != nil { return nil, err } return &SwapMemoryStat{ Total: total_v, Used: used_v, Free: free_v, UsedPercent: up_v, }, nil } return nil, errors.New("no swap devices found") } ================================================ FILE: vendor/github.com/shirou/gopsutil/mem/mem_linux.go ================================================ // +build linux package mem import ( "strconv" "strings" "syscall" "github.com/shirou/gopsutil/internal/common" ) func VirtualMemory() (*VirtualMemoryStat, error) { filename := common.HostProc("meminfo") lines, _ := common.ReadLines(filename) // flag if MemAvailable is in /proc/meminfo (kernel 3.14+) memavail := false ret := &VirtualMemoryStat{} for _, line := range lines { fields := strings.Split(line, ":") if len(fields) != 2 { continue } key := strings.TrimSpace(fields[0]) value := strings.TrimSpace(fields[1]) value = strings.Replace(value, " kB", "", -1) t, err := strconv.ParseUint(value, 10, 64) if err != nil { return ret, err } switch key { case "MemTotal": ret.Total = t * 1024 case "MemFree": ret.Free = t * 1024 case "MemAvailable": memavail = true ret.Available = t * 1024 case "Buffers": ret.Buffers = t * 1024 case "Cached": ret.Cached = t * 1024 case "Active": ret.Active = t * 1024 case "Inactive": ret.Inactive = t * 1024 } } if !memavail { ret.Available = ret.Free + ret.Buffers + ret.Cached } ret.Used = ret.Total - ret.Free ret.UsedPercent = float64(ret.Total-ret.Available) / float64(ret.Total) * 100.0 return ret, nil } func SwapMemory() (*SwapMemoryStat, error) { sysinfo := &syscall.Sysinfo_t{} if err := syscall.Sysinfo(sysinfo); err != nil { return nil, err } ret := &SwapMemoryStat{ Total: uint64(sysinfo.Totalswap), Free: uint64(sysinfo.Freeswap), } ret.Used = ret.Total - ret.Free //check Infinity if ret.Total != 0 { ret.UsedPercent = float64(ret.Total-ret.Free) / float64(ret.Total) * 100.0 } else { ret.UsedPercent = 0 } filename := common.HostProc("vmstat") lines, _ := common.ReadLines(filename) for _, l := range lines { fields := strings.Fields(l) if len(fields) < 2 { continue } switch fields[0] { case "pswpin": value, err := strconv.ParseUint(fields[1], 10, 64) if err != nil { continue } ret.Sin = value * 4 * 1024 case "pswpout": value, err := strconv.ParseUint(fields[1], 10, 64) if err != nil { continue } ret.Sout = value * 4 * 1024 } } return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/mem/mem_windows.go ================================================ // +build windows package mem import ( "syscall" "unsafe" "github.com/shirou/gopsutil/internal/common" ) var ( procGlobalMemoryStatusEx = common.Modkernel32.NewProc("GlobalMemoryStatusEx") ) type MEMORYSTATUSEX struct { cbSize uint32 dwMemoryLoad uint32 ullTotalPhys uint64 // in bytes ullAvailPhys uint64 ullTotalPageFile uint64 ullAvailPageFile uint64 ullTotalVirtual uint64 ullAvailVirtual uint64 ullAvailExtendedVirtual uint64 } func VirtualMemory() (*VirtualMemoryStat, error) { var memInfo MEMORYSTATUSEX memInfo.cbSize = uint32(unsafe.Sizeof(memInfo)) mem, _, _ := procGlobalMemoryStatusEx.Call(uintptr(unsafe.Pointer(&memInfo))) if mem == 0 { return nil, syscall.GetLastError() } ret := &VirtualMemoryStat{ Total: memInfo.ullTotalPhys, Available: memInfo.ullAvailPhys, UsedPercent: float64(memInfo.dwMemoryLoad), } ret.Used = ret.Total - ret.Available return ret, nil } func SwapMemory() (*SwapMemoryStat, error) { ret := &SwapMemoryStat{} return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/mktypes.sh ================================================ DIRS="cpu disk docker host load mem net process" GOOS=`uname | tr '[:upper:]' '[:lower:]'` ARCH=`uname -m` case $ARCH in amd64) GOARCH="amd64" ;; x86_64) GOARCH="amd64" ;; i386) GOARCH="386" ;; i686) GOARCH="386" ;; arm) GOARCH="arm" ;; *) echo "unknown arch: $ARCH" exit 1 esac for DIR in $DIRS do if [ -e ${DIR}/types_${GOOS}.go ]; then echo "// +build $GOOS" > ${DIR}/${DIR}_${GOOS}_${GOARCH}.go echo "// +build $GOARCH" >> ${DIR}/${DIR}_${GOOS}_${GOARCH}.go go tool cgo -godefs ${DIR}/types_${GOOS}.go >> ${DIR}/${DIR}_${GOOS}_${GOARCH}.go fi done ================================================ FILE: vendor/github.com/shirou/gopsutil/net/net.go ================================================ package net import ( "encoding/json" "fmt" "net" "strconv" "strings" "syscall" "github.com/shirou/gopsutil/internal/common" ) var invoke common.Invoker func init() { invoke = common.Invoke{} } type NetIOCountersStat struct { Name string `json:"name"` // interface name BytesSent uint64 `json:"bytes_sent"` // number of bytes sent BytesRecv uint64 `json:"bytes_recv"` // number of bytes received PacketsSent uint64 `json:"packets_sent"` // number of packets sent PacketsRecv uint64 `json:"packets_recv"` // number of packets received Errin uint64 `json:"errin"` // total number of errors while receiving Errout uint64 `json:"errout"` // total number of errors while sending Dropin uint64 `json:"dropin"` // total number of incoming packets which were dropped Dropout uint64 `json:"dropout"` // total number of outgoing packets which were dropped (always 0 on OSX and BSD) } // Addr is implemented compatibility to psutil type Addr struct { IP string `json:"ip"` Port uint32 `json:"port"` } type NetConnectionStat struct { Fd uint32 `json:"fd"` Family uint32 `json:"family"` Type uint32 `json:"type"` Laddr Addr `json:"localaddr"` Raddr Addr `json:"remoteaddr"` Status string `json:"status"` Pid int32 `json:"pid"` } // System wide stats about different network protocols type NetProtoCountersStat struct { Protocol string `json:"protocol"` Stats map[string]int64 `json:"stats"` } // NetInterfaceAddr is designed for represent interface addresses type NetInterfaceAddr struct { Addr string `json:"addr"` } type NetInterfaceStat struct { MTU int `json:"mtu"` // maximum transmission unit Name string `json:"name"` // e.g., "en0", "lo0", "eth0.100" HardwareAddr string `json:"hardwareaddr"` // IEEE MAC-48, EUI-48 and EUI-64 form Flags []string `json:"flags"` // e.g., FlagUp, FlagLoopback, FlagMulticast Addrs []NetInterfaceAddr `json:"addrs"` } type NetFilterStat struct { ConnTrackCount int64 `json:"conntrack_count"` ConnTrackMax int64 `json:"conntrack_max"` } var constMap = map[string]int{ "TCP": syscall.SOCK_STREAM, "UDP": syscall.SOCK_DGRAM, "IPv4": syscall.AF_INET, "IPv6": syscall.AF_INET6, } func (n NetIOCountersStat) String() string { s, _ := json.Marshal(n) return string(s) } func (n NetConnectionStat) String() string { s, _ := json.Marshal(n) return string(s) } func (n NetProtoCountersStat) String() string { s, _ := json.Marshal(n) return string(s) } func (a Addr) String() string { s, _ := json.Marshal(a) return string(s) } func (n NetInterfaceStat) String() string { s, _ := json.Marshal(n) return string(s) } func (n NetInterfaceAddr) String() string { s, _ := json.Marshal(n) return string(s) } func NetInterfaces() ([]NetInterfaceStat, error) { is, err := net.Interfaces() if err != nil { return nil, err } ret := make([]NetInterfaceStat, 0, len(is)) for _, ifi := range is { var flags []string if ifi.Flags&net.FlagUp != 0 { flags = append(flags, "up") } if ifi.Flags&net.FlagBroadcast != 0 { flags = append(flags, "broadcast") } if ifi.Flags&net.FlagLoopback != 0 { flags = append(flags, "loopback") } if ifi.Flags&net.FlagPointToPoint != 0 { flags = append(flags, "pointtopoint") } if ifi.Flags&net.FlagMulticast != 0 { flags = append(flags, "multicast") } r := NetInterfaceStat{ Name: ifi.Name, MTU: ifi.MTU, HardwareAddr: ifi.HardwareAddr.String(), Flags: flags, } addrs, err := ifi.Addrs() if err == nil { r.Addrs = make([]NetInterfaceAddr, 0, len(addrs)) for _, addr := range addrs { r.Addrs = append(r.Addrs, NetInterfaceAddr{ Addr: addr.String(), }) } } ret = append(ret, r) } return ret, nil } func getNetIOCountersAll(n []NetIOCountersStat) ([]NetIOCountersStat, error) { r := NetIOCountersStat{ Name: "all", } for _, nic := range n { r.BytesRecv += nic.BytesRecv r.PacketsRecv += nic.PacketsRecv r.Errin += nic.Errin r.Dropin += nic.Dropin r.BytesSent += nic.BytesSent r.PacketsSent += nic.PacketsSent r.Errout += nic.Errout r.Dropout += nic.Dropout } return []NetIOCountersStat{r}, nil } func parseNetLine(line string) (NetConnectionStat, error) { f := strings.Fields(line) if len(f) < 9 { return NetConnectionStat{}, fmt.Errorf("wrong line,%s", line) } pid, err := strconv.Atoi(f[1]) if err != nil { return NetConnectionStat{}, err } fd, err := strconv.Atoi(strings.Trim(f[3], "u")) if err != nil { return NetConnectionStat{}, fmt.Errorf("unknown fd, %s", f[3]) } netFamily, ok := constMap[f[4]] if !ok { return NetConnectionStat{}, fmt.Errorf("unknown family, %s", f[4]) } netType, ok := constMap[f[7]] if !ok { return NetConnectionStat{}, fmt.Errorf("unknown type, %s", f[7]) } laddr, raddr, err := parseNetAddr(f[8]) if err != nil { return NetConnectionStat{}, fmt.Errorf("failed to parse netaddr, %s", f[8]) } n := NetConnectionStat{ Fd: uint32(fd), Family: uint32(netFamily), Type: uint32(netType), Laddr: laddr, Raddr: raddr, Pid: int32(pid), } if len(f) == 10 { n.Status = strings.Trim(f[9], "()") } return n, nil } func parseNetAddr(line string) (laddr Addr, raddr Addr, err error) { parse := func(l string) (Addr, error) { host, port, err := net.SplitHostPort(l) if err != nil { return Addr{}, fmt.Errorf("wrong addr, %s", l) } lport, err := strconv.Atoi(port) if err != nil { return Addr{}, err } return Addr{IP: host, Port: uint32(lport)}, nil } addrs := strings.Split(line, "->") if len(addrs) == 0 { return laddr, raddr, fmt.Errorf("wrong netaddr, %s", line) } laddr, err = parse(addrs[0]) if len(addrs) == 2 { // remote addr exists raddr, err = parse(addrs[1]) if err != nil { return laddr, raddr, err } } return laddr, raddr, err } ================================================ FILE: vendor/github.com/shirou/gopsutil/net/net_darwin.go ================================================ // +build darwin package net import ( "errors" "os/exec" "strconv" "strings" "github.com/shirou/gopsutil/internal/common" ) // example of netstat -idbn output on yosemite // Name Mtu Network Address Ipkts Ierrs Ibytes Opkts Oerrs Obytes Coll Drop // lo0 16384 869107 0 169411755 869107 0 169411755 0 0 // lo0 16384 ::1/128 ::1 869107 - 169411755 869107 - 169411755 - - // lo0 16384 127 127.0.0.1 869107 - 169411755 869107 - 169411755 - - func NetIOCounters(pernic bool) ([]NetIOCountersStat, error) { out, err := exec.Command("/usr/sbin/netstat", "-ibdnW").Output() if err != nil { return nil, err } lines := strings.Split(string(out), "\n") ret := make([]NetIOCountersStat, 0, len(lines)-1) exists := make([]string, 0, len(ret)) for _, line := range lines { values := strings.Fields(line) if len(values) < 1 || values[0] == "Name" { // skip first line continue } if common.StringsHas(exists, values[0]) { // skip if already get continue } exists = append(exists, values[0]) base := 1 // sometimes Address is ommitted if len(values) < 11 { base = 0 } parsed := make([]uint64, 0, 7) vv := []string{ values[base+3], // Ipkts == PacketsRecv values[base+4], // Ierrs == Errin values[base+5], // Ibytes == BytesRecv values[base+6], // Opkts == PacketsSent values[base+7], // Oerrs == Errout values[base+8], // Obytes == BytesSent } if len(values) == 12 { vv = append(vv, values[base+10]) } for _, target := range vv { if target == "-" { parsed = append(parsed, 0) continue } t, err := strconv.ParseUint(target, 10, 64) if err != nil { return nil, err } parsed = append(parsed, t) } n := NetIOCountersStat{ Name: values[0], PacketsRecv: parsed[0], Errin: parsed[1], BytesRecv: parsed[2], PacketsSent: parsed[3], Errout: parsed[4], BytesSent: parsed[5], } if len(parsed) == 7 { n.Dropout = parsed[6] } ret = append(ret, n) } if pernic == false { return getNetIOCountersAll(ret) } return ret, nil } // NetIOCountersByFile is an method which is added just a compatibility for linux. func NetIOCountersByFile(pernic bool, filename string) ([]NetIOCountersStat, error) { return NetIOCounters(pernic) } func NetFilterCounters() ([]NetFilterStat, error) { return nil, errors.New("NetFilterCounters not implemented for darwin") } // NetProtoCounters returns network statistics for the entire system // If protocols is empty then all protocols are returned, otherwise // just the protocols in the list are returned. // Not Implemented for Darwin func NetProtoCounters(protocols []string) ([]NetProtoCountersStat, error) { return nil, errors.New("NetProtoCounters not implemented for darwin") } ================================================ FILE: vendor/github.com/shirou/gopsutil/net/net_freebsd.go ================================================ // +build freebsd package net import ( "errors" "os/exec" "strconv" "strings" "github.com/shirou/gopsutil/internal/common" ) func NetIOCounters(pernic bool) ([]NetIOCountersStat, error) { out, err := exec.Command("/usr/bin/netstat", "-ibdnW").Output() if err != nil { return nil, err } lines := strings.Split(string(out), "\n") ret := make([]NetIOCountersStat, 0, len(lines)-1) exists := make([]string, 0, len(ret)) for _, line := range lines { values := strings.Fields(line) if len(values) < 1 || values[0] == "Name" { continue } if common.StringsHas(exists, values[0]) { // skip if already get continue } exists = append(exists, values[0]) if len(values) < 12 { continue } base := 1 // sometimes Address is ommitted if len(values) < 13 { base = 0 } parsed := make([]uint64, 0, 8) vv := []string{ values[base+3], // PacketsRecv values[base+4], // Errin values[base+5], // Dropin values[base+6], // BytesRecvn values[base+7], // PacketSent values[base+8], // Errout values[base+9], // BytesSent values[base+11], // Dropout } for _, target := range vv { if target == "-" { parsed = append(parsed, 0) continue } t, err := strconv.ParseUint(target, 10, 64) if err != nil { return nil, err } parsed = append(parsed, t) } n := NetIOCountersStat{ Name: values[0], PacketsRecv: parsed[0], Errin: parsed[1], Dropin: parsed[2], BytesRecv: parsed[3], PacketsSent: parsed[4], Errout: parsed[5], BytesSent: parsed[6], Dropout: parsed[7], } ret = append(ret, n) } if pernic == false { return getNetIOCountersAll(ret) } return ret, nil } // NetIOCountersByFile is an method which is added just a compatibility for linux. func NetIOCountersByFile(pernic bool, filename string) ([]NetIOCountersStat, error) { return NetIOCounters(pernic) } func NetFilterCounters() ([]NetFilterStat, error) { return nil, errors.New("NetFilterCounters not implemented for freebsd") } // NetProtoCounters returns network statistics for the entire system // If protocols is empty then all protocols are returned, otherwise // just the protocols in the list are returned. // Not Implemented for FreeBSD func NetProtoCounters(protocols []string) ([]NetProtoCountersStat, error) { return nil, errors.New("NetProtoCounters not implemented for freebsd") } ================================================ FILE: vendor/github.com/shirou/gopsutil/net/net_linux.go ================================================ // +build linux package net import ( "errors" "strconv" "strings" "github.com/shirou/gopsutil/internal/common" ) // NetIOCounters returnes network I/O statistics for every network // interface installed on the system. If pernic argument is false, // return only sum of all information (which name is 'all'). If true, // every network interface installed on the system is returned // separately. func NetIOCounters(pernic bool) ([]NetIOCountersStat, error) { filename := common.HostProc("net/dev") return NetIOCountersByFile(pernic, filename) } func NetIOCountersByFile(pernic bool, filename string) ([]NetIOCountersStat, error) { lines, err := common.ReadLines(filename) if err != nil { return nil, err } statlen := len(lines) - 1 ret := make([]NetIOCountersStat, 0, statlen) for _, line := range lines[2:] { parts := strings.SplitN(line, ":", 2) if len(parts) != 2 { continue } interfaceName := strings.TrimSpace(parts[0]) if interfaceName == "" { continue } fields := strings.Fields(strings.TrimSpace(parts[1])) bytesRecv, err := strconv.ParseUint(fields[0], 10, 64) if err != nil { return ret, err } packetsRecv, err := strconv.ParseUint(fields[1], 10, 64) if err != nil { return ret, err } errIn, err := strconv.ParseUint(fields[2], 10, 64) if err != nil { return ret, err } dropIn, err := strconv.ParseUint(fields[3], 10, 64) if err != nil { return ret, err } bytesSent, err := strconv.ParseUint(fields[8], 10, 64) if err != nil { return ret, err } packetsSent, err := strconv.ParseUint(fields[9], 10, 64) if err != nil { return ret, err } errOut, err := strconv.ParseUint(fields[10], 10, 64) if err != nil { return ret, err } dropOut, err := strconv.ParseUint(fields[13], 10, 64) if err != nil { return ret, err } nic := NetIOCountersStat{ Name: interfaceName, BytesRecv: bytesRecv, PacketsRecv: packetsRecv, Errin: errIn, Dropin: dropIn, BytesSent: bytesSent, PacketsSent: packetsSent, Errout: errOut, Dropout: dropOut, } ret = append(ret, nic) } if pernic == false { return getNetIOCountersAll(ret) } return ret, nil } var netProtocols = []string{ "ip", "icmp", "icmpmsg", "tcp", "udp", "udplite", } // NetProtoCounters returns network statistics for the entire system // If protocols is empty then all protocols are returned, otherwise // just the protocols in the list are returned. // Available protocols: // ip,icmp,icmpmsg,tcp,udp,udplite func NetProtoCounters(protocols []string) ([]NetProtoCountersStat, error) { if len(protocols) == 0 { protocols = netProtocols } stats := make([]NetProtoCountersStat, 0, len(protocols)) protos := make(map[string]bool, len(protocols)) for _, p := range protocols { protos[p] = true } filename := common.HostProc("net/snmp") lines, err := common.ReadLines(filename) if err != nil { return nil, err } linecount := len(lines) for i := 0; i < linecount; i++ { line := lines[i] r := strings.IndexRune(line, ':') if r == -1 { return nil, errors.New(filename + " is not fomatted correctly, expected ':'.") } proto := strings.ToLower(line[:r]) if !protos[proto] { // skip protocol and data line i++ continue } // Read header line statNames := strings.Split(line[r+2:], " ") // Read data line i++ statValues := strings.Split(lines[i][r+2:], " ") if len(statNames) != len(statValues) { return nil, errors.New(filename + " is not fomatted correctly, expected same number of columns.") } stat := NetProtoCountersStat{ Protocol: proto, Stats: make(map[string]int64, len(statNames)), } for j := range statNames { value, err := strconv.ParseInt(statValues[j], 10, 64) if err != nil { return nil, err } stat.Stats[statNames[j]] = value } stats = append(stats, stat) } return stats, nil } // NetFilterCounters returns iptables conntrack statistics // the currently in use conntrack count and the max. // If the file does not exist or is invalid it will return nil. func NetFilterCounters() ([]NetFilterStat, error) { countfile := common.HostProc("sys/net/netfilter/nf_conntrack_count") maxfile := common.HostProc("sys/net/netfilter/nf_conntrack_max") count, err := common.ReadInts(countfile) if err != nil { return nil, err } stats := make([]NetFilterStat, 0, 1) max, err := common.ReadInts(maxfile) if err != nil { return nil, err } payload := NetFilterStat{ ConnTrackCount: count[0], ConnTrackMax: max[0], } stats = append(stats, payload) return stats, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/net/net_unix.go ================================================ // +build linux freebsd darwin package net import ( "strings" "github.com/shirou/gopsutil/internal/common" ) // Return a list of network connections opened. func NetConnections(kind string) ([]NetConnectionStat, error) { return NetConnectionsPid(kind, 0) } // Return a list of network connections opened by a process. func NetConnectionsPid(kind string, pid int32) ([]NetConnectionStat, error) { var ret []NetConnectionStat args := []string{"-i"} switch strings.ToLower(kind) { default: fallthrough case "": fallthrough case "all": fallthrough case "inet": args = append(args, "tcp", "-i", "udp") case "inet4": args = append(args, "4") case "inet6": args = append(args, "6") case "tcp": args = append(args, "tcp") case "tcp4": args = append(args, "4tcp") case "tcp6": args = append(args, "6tcp") case "udp": args = append(args, "udp") case "udp4": args = append(args, "6udp") case "udp6": args = append(args, "6udp") case "unix": return ret, common.NotImplementedError } r, err := common.CallLsof(invoke, pid, args...) if err != nil { return nil, err } for _, rr := range r { if strings.HasPrefix(rr, "COMMAND") { continue } n, err := parseNetLine(rr) if err != nil { continue } ret = append(ret, n) } return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/net/net_windows.go ================================================ // +build windows package net import ( "errors" "net" "os" "syscall" "unsafe" "github.com/shirou/gopsutil/internal/common" ) var ( modiphlpapi = syscall.NewLazyDLL("iphlpapi.dll") procGetExtendedTcpTable = modiphlpapi.NewProc("GetExtendedTcpTable") procGetExtendedUdpTable = modiphlpapi.NewProc("GetExtendedUdpTable") ) const ( TCPTableBasicListener = iota TCPTableBasicConnections TCPTableBasicAll TCPTableOwnerPIDListener TCPTableOwnerPIDConnections TCPTableOwnerPIDAll TCPTableOwnerModuleListener TCPTableOwnerModuleConnections TCPTableOwnerModuleAll ) func NetIOCounters(pernic bool) ([]NetIOCountersStat, error) { ifs, err := net.Interfaces() if err != nil { return nil, err } ai, err := getAdapterList() if err != nil { return nil, err } var ret []NetIOCountersStat for _, ifi := range ifs { name := ifi.Name for ; ai != nil; ai = ai.Next { name = common.BytePtrToString(&ai.Description[0]) c := NetIOCountersStat{ Name: name, } row := syscall.MibIfRow{Index: ai.Index} e := syscall.GetIfEntry(&row) if e != nil { return nil, os.NewSyscallError("GetIfEntry", e) } c.BytesSent = uint64(row.OutOctets) c.BytesRecv = uint64(row.InOctets) c.PacketsSent = uint64(row.OutUcastPkts) c.PacketsRecv = uint64(row.InUcastPkts) c.Errin = uint64(row.InErrors) c.Errout = uint64(row.OutErrors) c.Dropin = uint64(row.InDiscards) c.Dropout = uint64(row.OutDiscards) ret = append(ret, c) } } if pernic == false { return getNetIOCountersAll(ret) } return ret, nil } // NetIOCountersByFile is an method which is added just a compatibility for linux. func NetIOCountersByFile(pernic bool, filename string) ([]NetIOCountersStat, error) { return NetIOCounters(pernic) } // Return a list of network connections opened by a process func NetConnections(kind string) ([]NetConnectionStat, error) { var ret []NetConnectionStat return ret, common.NotImplementedError } // borrowed from src/pkg/net/interface_windows.go func getAdapterList() (*syscall.IpAdapterInfo, error) { b := make([]byte, 1000) l := uint32(len(b)) a := (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0])) err := syscall.GetAdaptersInfo(a, &l) if err == syscall.ERROR_BUFFER_OVERFLOW { b = make([]byte, l) a = (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0])) err = syscall.GetAdaptersInfo(a, &l) } if err != nil { return nil, os.NewSyscallError("GetAdaptersInfo", err) } return a, nil } func NetFilterCounters() ([]NetFilterStat, error) { return nil, errors.New("NetFilterCounters not implemented for windows") } // NetProtoCounters returns network statistics for the entire system // If protocols is empty then all protocols are returned, otherwise // just the protocols in the list are returned. // Not Implemented for Windows func NetProtoCounters(protocols []string) ([]NetProtoCountersStat, error) { return nil, errors.New("NetProtoCounters not implemented for windows") } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process.go ================================================ 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 numCtxSwitches *NumCtxSwitchesStat uids []int32 gids []int32 numThreads int32 memInfo *MemoryInfoStat lastCPUTimes *cpu.CPUTimesStat 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:"read_count"` WriteCount uint64 `json:"write_count"` ReadBytes uint64 `json:"read_bytes"` WriteBytes uint64 `json:"write_bytes"` } type NumCtxSwitchesStat struct { Voluntary int64 `json:"voluntary"` Involuntary int64 `json:"involuntary"` } 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) CPUPercent(interval time.Duration) (float64, error) { cpuTimes, err := p.CPUTimes() if err != nil { return 0, err } now := time.Now() if interval > 0 { p.lastCPUTimes = cpuTimes p.lastCPUTime = now time.Sleep(interval) cpuTimes, err = p.CPUTimes() 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.CPUTimesStat, 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 } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_darwin.go ================================================ // +build darwin package process import ( "bytes" "encoding/binary" "fmt" "os/exec" "strconv" "strings" "syscall" "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) { return "", common.NotImplementedError } func (p *Process) Cmdline() (string, error) { r, err := callPs("command", p.Pid, false) if err != nil { return "", err } return strings.Join(r[0], " "), err } func (p *Process) CreateTime() (int64, error) { return 0, common.NotImplementedError } func (p *Process) Cwd() (string, error) { return "", common.NotImplementedError } 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.NotImplementedError /* 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.NotImplementedError } func (p *Process) Rlimit() ([]RlimitStat, error) { var rlimit []RlimitStat return rlimit, common.NotImplementedError } func (p *Process) IOCounters() (*IOCountersStat, error) { return nil, common.NotImplementedError } func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) { return nil, common.NotImplementedError } func (p *Process) NumFDs() (int32, error) { return 0, common.NotImplementedError } 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.NotImplementedError } 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) CPUTimes() (*cpu.CPUTimesStat, 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.CPUTimesStat{ CPU: "cpu", User: utime, System: stime, } return ret, nil } func (p *Process) CPUAffinity() ([]int32, error) { return nil, common.NotImplementedError } 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.NotImplementedError } 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.NotImplementedError } func (p *Process) Connections() ([]net.NetConnectionStat, error) { return net.NetConnectionsPid("all", p.Pid) } func (p *Process) NetIOCounters(pernic bool) ([]net.NetIOCountersStat, error) { return nil, common.NotImplementedError } func (p *Process) IsRunning() (bool, error) { return true, common.NotImplementedError } func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) { var ret []MemoryMapsStat return &ret, common.NotImplementedError } func copyParams(k *KinfoProc, p *Process) error { return nil } 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 } copyParams(&k, p) 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 } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_darwin_amd64.go ================================================ // 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 } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_freebsd.go ================================================ // +build freebsd package process import ( "bytes" "encoding/binary" "strings" "syscall" "unsafe" 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.KiPpid, nil } func (p *Process) Name() (string, error) { k, err := p.getKProc() if err != nil { return "", err } return string(k.KiComm[:]), nil } func (p *Process) Exe() (string, error) { return "", common.NotImplementedError } 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) CreateTime() (int64, error) { return 0, common.NotImplementedError } func (p *Process) Cwd() (string, error) { return "", common.NotImplementedError } func (p *Process) Parent() (*Process, error) { return p, common.NotImplementedError } func (p *Process) Status() (string, error) { k, err := p.getKProc() if err != nil { return "", err } return string(k.KiStat[:]), 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.KiRuid), int32(k.KiUID), int32(k.KiSvuid)) 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.KiRgid), int32(k.KiNgroups[0]), int32(k.KiSvuid)) return gids, nil } func (p *Process) Terminal() (string, error) { k, err := p.getKProc() if err != nil { return "", err } ttyNr := uint64(k.KiTdev) termmap, err := getTerminalMap() if err != nil { return "", err } return termmap[ttyNr], nil } func (p *Process) Nice() (int32, error) { return 0, common.NotImplementedError } func (p *Process) IOnice() (int32, error) { return 0, common.NotImplementedError } func (p *Process) Rlimit() ([]RlimitStat, error) { var rlimit []RlimitStat return rlimit, common.NotImplementedError } func (p *Process) IOCounters() (*IOCountersStat, error) { k, err := p.getKProc() if err != nil { return nil, err } return &IOCountersStat{ ReadCount: uint64(k.KiRusage.Inblock), WriteCount: uint64(k.KiRusage.Oublock), }, nil } func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) { return nil, common.NotImplementedError } func (p *Process) NumFDs() (int32, error) { return 0, common.NotImplementedError } func (p *Process) NumThreads() (int32, error) { k, err := p.getKProc() if err != nil { return 0, err } return k.KiNumthreads, nil } func (p *Process) Threads() (map[string]string, error) { ret := make(map[string]string, 0) return ret, common.NotImplementedError } func (p *Process) CPUTimes() (*cpu.CPUTimesStat, error) { k, err := p.getKProc() if err != nil { return nil, err } return &cpu.CPUTimesStat{ CPU: "cpu", User: float64(k.KiRusage.Utime.Sec) + float64(k.KiRusage.Utime.Usec)/1000000, System: float64(k.KiRusage.Stime.Sec) + float64(k.KiRusage.Stime.Usec)/1000000, }, nil } func (p *Process) CPUAffinity() ([]int32, error) { return nil, common.NotImplementedError } 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.KiRssize) * uint64(pageSize), VMS: uint64(k.KiSize), }, nil } func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) { return nil, common.NotImplementedError } 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.NotImplementedError } func (p *Process) Connections() ([]net.NetConnectionStat, error) { return nil, common.NotImplementedError } func (p *Process) NetIOCounters(pernic bool) ([]net.NetIOCountersStat, error) { return nil, common.NotImplementedError } func (p *Process) IsRunning() (bool, error) { return true, common.NotImplementedError } func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) { var ret []MemoryMapsStat return &ret, common.NotImplementedError } func copyParams(k *KinfoProc, p *Process) error { return nil } 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 k := KinfoProc{} procinfoLen := int(unsafe.Sizeof(k)) count := int(length / uint64(procinfoLen)) // 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.KiPid)) if err != nil { continue } copyParams(&k, p) results = append(results, *p) } return results, nil } func parseKinfoProc(buf []byte) (KinfoProc, error) { var k KinfoProc br := bytes.NewReader(buf) err := binary.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 } procK := KinfoProc{} if length != uint64(unsafe.Sizeof(procK)) { 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 } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_freebsd_386.go ================================================ // +build freebsd // +build 386 package process // 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 KernProcPathname = 12 // path to executable KernProcArgs = 7 // get/set arguments/proctitle ) 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 } // copied from sys/user.h type KinfoProc struct { KiStructsize int32 KiLayout int32 KiArgs int32 KiPaddr int32 KiAddr int32 KiTracep int32 KiTextvp int32 KiFd int32 KiVmspace int32 KiWchan int32 KiPid int32 KiPpid int32 KiPgid int32 KiTpgid int32 KiSid int32 KiTsid int32 KiJobc [2]byte KiSpareShort1 [2]byte KiTdev int32 KiSiglist [16]byte KiSigmask [16]byte KiSigignore [16]byte KiSigcatch [16]byte KiUID int32 KiRuid int32 KiSvuid int32 KiRgid int32 KiSvgid int32 KiNgroups [2]byte KiSpareShort2 [2]byte KiGroups [64]byte KiSize int32 KiRssize int32 KiSwrss int32 KiTsize int32 KiDsize int32 KiSsize int32 KiXstat [2]byte KiAcflag [2]byte KiPctcpu int32 KiEstcpu int32 KiSlptime int32 KiSwtime int32 KiCow int32 KiRuntime int64 KiStart [8]byte KiChildtime [8]byte KiFlag int32 KiKflag int32 KiTraceflag int32 KiStat [1]byte KiNice [1]byte KiLock [1]byte KiRqindex [1]byte KiOncpu [1]byte KiLastcpu [1]byte KiOcomm [17]byte KiWmesg [9]byte KiLogin [18]byte KiLockname [9]byte KiComm [20]byte KiEmul [17]byte KiSparestrings [68]byte KiSpareints [36]byte KiCrFlags int32 KiJid int32 KiNumthreads int32 KiTid int32 KiPri int32 KiRusage Rusage KiRusageCh [72]byte KiPcb int32 KiKstack int32 KiUdata int32 KiTdaddr int32 KiSpareptrs [24]byte KiSpareint64s [48]byte KiSflag int32 KiTdflags int32 } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_freebsd_amd64.go ================================================ // +build freebsd // +build amd64 package process // 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 KernProcPathname = 12 // path to executable KernProcArgs = 7 // get/set arguments/proctitle ) 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 } // copied from sys/user.h type KinfoProc struct { KiStructsize int32 KiLayout int32 KiArgs int64 KiPaddr int64 KiAddr int64 KiTracep int64 KiTextvp int64 KiFd int64 KiVmspace int64 KiWchan int64 KiPid int32 KiPpid int32 KiPgid int32 KiTpgid int32 KiSid int32 KiTsid int32 KiJobc [2]byte KiSpareShort1 [2]byte KiTdev int32 KiSiglist [16]byte KiSigmask [16]byte KiSigignore [16]byte KiSigcatch [16]byte KiUID int32 KiRuid int32 KiSvuid int32 KiRgid int32 KiSvgid int32 KiNgroups [2]byte KiSpareShort2 [2]byte KiGroups [64]byte KiSize int64 KiRssize int64 KiSwrss int64 KiTsize int64 KiDsize int64 KiSsize int64 KiXstat [2]byte KiAcflag [2]byte KiPctcpu int32 KiEstcpu int32 KiSlptime int32 KiSwtime int32 KiCow int32 KiRuntime int64 KiStart [16]byte KiChildtime [16]byte KiFlag int64 KiKflag int64 KiTraceflag int32 KiStat [1]byte KiNice [1]byte KiLock [1]byte KiRqindex [1]byte KiOncpu [1]byte KiLastcpu [1]byte KiOcomm [17]byte KiWmesg [9]byte KiLogin [18]byte KiLockname [9]byte KiComm [20]byte KiEmul [17]byte KiSparestrings [68]byte KiSpareints [36]byte KiCrFlags int32 KiJid int32 KiNumthreads int32 KiTid int32 KiPri int32 KiRusage Rusage KiRusageCh [144]byte KiPcb int64 KiKstack int64 KiUdata int64 KiTdaddr int64 KiSpareptrs [48]byte KiSpareint64s [96]byte KiSflag int64 KiTdflags int64 } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_linux.go ================================================ // +build linux package process import ( "encoding/json" "errors" "fmt" "io/ioutil" "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") const ( PrioProcess = 0 // linux/resource.h ) // 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:"shared_clean"` SharedDirty uint64 `json:"shared_dirty"` PrivateClean uint64 `json:"private_clean"` PrivateDirty uint64 `json:"private_dirty"` Referenced uint64 `json:"referenced"` Anonymous uint64 `json:"anonymous"` Swap uint64 `json:"swap"` } func (m MemoryMapsStat) String() string { s, _ := json.Marshal(m) return string(s) } // Create new Process instance // This only stores Pid func NewProcess(pid int32) (*Process, error) { p := &Process{ Pid: int32(pid), } err := p.fillFromStatus() return p, err } func (p *Process) Ppid() (int32, error) { _, ppid, _, _, _, err := p.fillFromStat() if err != nil { return -1, err } return ppid, nil } func (p *Process) Name() (string, error) { return p.name, nil } func (p *Process) Exe() (string, error) { return p.fillFromExe() } func (p *Process) Cmdline() (string, error) { return p.fillFromCmdline() } func (p *Process) CreateTime() (int64, error) { _, _, _, createTime, _, err := p.fillFromStat() if err != nil { return 0, err } return createTime, nil } func (p *Process) Cwd() (string, error) { return p.fillFromCwd() } func (p *Process) Parent() (*Process, error) { r, err := callLsof("R", p.Pid) if err != nil { return nil, err } if len(r) != 1 { // TODO: pid 1 return nil, fmt.Errorf("wrong number of parents") } v, err := strconv.Atoi(r[0]) if err != nil { return nil, err } return NewProcess(int32(v)) } func (p *Process) Status() (string, error) { err := p.fillFromStatus() if err != nil { return "", err } return p.status, nil } func (p *Process) Uids() ([]int32, error) { err := p.fillFromStatus() if err != nil { return []int32{}, err } return p.uids, nil } func (p *Process) Gids() ([]int32, error) { err := p.fillFromStatus() if err != nil { return []int32{}, err } return p.gids, nil } func (p *Process) Terminal() (string, error) { terminal, _, _, _, _, err := p.fillFromStat() if err != nil { return "", err } return terminal, nil } func (p *Process) Nice() (int32, error) { _, _, _, _, nice, err := p.fillFromStat() if err != nil { return 0, err } return nice, nil } func (p *Process) IOnice() (int32, error) { return 0, common.NotImplementedError } func (p *Process) Rlimit() ([]RlimitStat, error) { return nil, common.NotImplementedError } func (p *Process) IOCounters() (*IOCountersStat, error) { return p.fillFromIO() } func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) { err := p.fillFromStatus() if err != nil { return nil, err } return p.numCtxSwitches, nil } func (p *Process) NumFDs() (int32, error) { numFds, _, err := p.fillFromfd() return numFds, err } func (p *Process) NumThreads() (int32, error) { err := p.fillFromStatus() if err != nil { return 0, err } return p.numThreads, nil } func (p *Process) Threads() (map[string]string, error) { ret := make(map[string]string, 0) return ret, nil } func (p *Process) CPUTimes() (*cpu.CPUTimesStat, error) { _, _, cpuTimes, _, _, err := p.fillFromStat() if err != nil { return nil, err } return cpuTimes, nil } func (p *Process) CPUAffinity() ([]int32, error) { return nil, common.NotImplementedError } func (p *Process) MemoryInfo() (*MemoryInfoStat, error) { meminfo, _, err := p.fillFromStatm() if err != nil { return nil, err } return meminfo, nil } func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) { _, memInfoEx, err := p.fillFromStatm() if err != nil { return nil, err } return memInfoEx, nil } 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 } func (p *Process) OpenFiles() ([]OpenFilesStat, error) { _, ofs, err := p.fillFromfd() if err != nil { return nil, err } ret := make([]OpenFilesStat, 0, len(ofs)) for i, o := range ofs { ret[i] = *o } return ret, nil } func (p *Process) Connections() ([]net.NetConnectionStat, error) { return net.NetConnectionsPid("all", p.Pid) } func (p *Process) NetIOCounters(pernic bool) ([]net.NetIOCountersStat, error) { filename := common.HostProc(strconv.Itoa(int(p.Pid)), "net/dev") return net.NetIOCountersByFile(pernic, filename) } func (p *Process) IsRunning() (bool, error) { return true, common.NotImplementedError } // 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 **/ // 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)) openfiles := make([]*OpenFilesStat, numFDs) 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 } // 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") case "State": // get between "(" and ")" s := strings.Index(value, "(") + 1 e := strings.Index(value, ")") p.status = value[s:e] 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.CPUTimesStat, 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.CPUTimesStat{ 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 } 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 } func callLsof(arg string, pid int32) ([]string, error) { var cmd []string if pid == 0 { // will get from all processes. cmd = []string{"-F" + arg} } else { cmd = []string{"-a", "-F" + arg, "-p", strconv.Itoa(int(pid))} } out, err := invoke.Command("/usr/bin/lsof", cmd...) if err != nil { return []string{}, err } lines := strings.Split(string(out), "\n") var ret []string for _, l := range lines[1:] { if strings.HasPrefix(l, arg) { ret = append(ret, l[1:]) // delete first char } } return ret, nil } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_linux_386.go ================================================ // +build linux // +build 386 package process const ( ClockTicks = 100 // C.sysconf(C._SC_CLK_TCK) PageSize = 4096 // C.sysconf(C._SC_PAGE_SIZE) ) ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_linux_amd64.go ================================================ // +build linux // +build amd64 package process const ( ClockTicks = 100 // C.sysconf(C._SC_CLK_TCK) PageSize = 4096 // C.sysconf(C._SC_PAGE_SIZE) ) ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_linux_arm.go ================================================ // +build linux // +build arm package process const ( ClockTicks = 100 // C.sysconf(C._SC_CLK_TCK) PageSize = 4096 // C.sysconf(C._SC_PAGE_SIZE) ) ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_posix.go ================================================ // +build linux freebsd darwin package process import ( "os" "os/exec" "os/user" "strconv" "strings" "syscall" ) // 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) } } ptsd, err := os.Open("/dev/pts") if err != nil { return nil, err } defer ptsd.Close() ptsnames, err := ptsd.Readdirnames(-1) for _, ptsname := range ptsnames { termfiles = append(termfiles, "/dev/pts/"+ptsname) } 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 } 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" } cmd := exec.Command("kill", "-s", sigAsStr, strconv.Itoa(int(p.Pid))) cmd.Stderr = os.Stderr err := cmd.Run() if err != nil { return err } return nil } func (p *Process) Suspend() error { return p.SendSignal(syscall.SIGSTOP) } func (p *Process) Resume() error { return p.SendSignal(syscall.SIGCONT) } func (p *Process) Terminate() error { return p.SendSignal(syscall.SIGTERM) } func (p *Process) Kill() error { return p.SendSignal(syscall.SIGKILL) } 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 } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/process_windows.go ================================================ // +build windows package process import ( "errors" "fmt" "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 ) 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 /* 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 ReadOperationCount uint64 ReadTransferCount uint64 Status *string TerminationDate *time.Time UserModeTime uint64 WorkingSetSize uint64 WriteOperationCount uint64 WriteTransferCount 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 } func (p *Process) CreateTime() (int64, error) { dst, err := GetWin32Proc(p.Pid) if err != nil { return 0, fmt.Errorf("could not get CreationDate: %s", err) } date := *dst[0].CreationDate return date.Unix(), nil } func (p *Process) Cwd() (string, error) { return "", common.NotImplementedError } func (p *Process) Parent() (*Process, error) { return p, common.NotImplementedError } func (p *Process) Status() (string, error) { return "", common.NotImplementedError } func (p *Process) Username() (string, error) { return "", common.NotImplementedError } func (p *Process) Uids() ([]int32, error) { var uids []int32 return uids, common.NotImplementedError } func (p *Process) Gids() ([]int32, error) { var gids []int32 return gids, common.NotImplementedError } func (p *Process) Terminal() (string, error) { return "", common.NotImplementedError } // 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.NotImplementedError } func (p *Process) Rlimit() ([]RlimitStat, error) { var rlimit []RlimitStat return rlimit, common.NotImplementedError } func (p *Process) IOCounters() (*IOCountersStat, error) { return nil, common.NotImplementedError } func (p *Process) NumCtxSwitches() (*NumCtxSwitchesStat, error) { return nil, common.NotImplementedError } func (p *Process) NumFDs() (int32, error) { return 0, common.NotImplementedError } 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.NotImplementedError } func (p *Process) CPUTimes() (*cpu.CPUTimesStat, error) { return nil, common.NotImplementedError } func (p *Process) CPUAffinity() ([]int32, error) { return nil, common.NotImplementedError } func (p *Process) MemoryInfo() (*MemoryInfoStat, error) { return nil, common.NotImplementedError } func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) { return nil, common.NotImplementedError } func (p *Process) Children() ([]*Process, error) { return nil, common.NotImplementedError } func (p *Process) OpenFiles() ([]OpenFilesStat, error) { return nil, common.NotImplementedError } func (p *Process) Connections() ([]net.NetConnectionStat, error) { return nil, common.NotImplementedError } func (p *Process) NetIOCounters(pernic bool) ([]net.NetIOCountersStat, error) { return nil, common.NotImplementedError } func (p *Process) IsRunning() (bool, error) { return true, common.NotImplementedError } func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) { ret := make([]MemoryMapsStat, 0) return &ret, common.NotImplementedError } func NewProcess(pid int32) (*Process, error) { p := &Process{Pid: pid} return p, nil } func (p *Process) SendSignal(sig syscall.Signal) error { return common.NotImplementedError } func (p *Process) Suspend() error { return common.NotImplementedError } func (p *Process) Resume() error { return common.NotImplementedError } func (p *Process) Terminate() error { return common.NotImplementedError } func (p *Process) Kill() error { return common.NotImplementedError } 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 } ================================================ FILE: vendor/github.com/shirou/gopsutil/process/types_darwin.go ================================================ // 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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 ================================================ FILE: vendor/github.com/shirou/gopsutil/windows_memo.rst ================================================ Windows memo ===================== Size ---------- DWORD 32-bit unsigned integer DWORDLONG 64-bit unsigned integer DWORD_PTR unsigned long type for pointer precision DWORD32 32-bit unsigned integer DWORD64 64-bit unsigned integer HALF_PTR _WIN64 = int, else short INT 32-bit signed integer INT_PTR _WIN64 = __int64 else int LONG 32-bit signed integer LONGLONG 64-bit signed integer LONG_PTR _WIN64 = __int64 else long SHORT 16-bit integer SIZE_T maximum number of bytes to which a pointer can point. typedef ULONG_PTR SIZE_T; SSIZE_T signed version of SIZE_T. typedef LONG_PTR SSIZE_T; WORD 16-bit unsigned integer ================================================ FILE: vendor/github.com/shirou/w32/AUTHORS ================================================ # This is the official list of 'w32' authors for copyright purposes. # Names should be added to this file as # Name or Organization # The email address is not required for organizations. # Please keep the list sorted. # Contributors # ============ Allen Dang Benny Siegert Bruno Bigras Gerald Rosenberg Michael Henke ================================================ FILE: vendor/github.com/shirou/w32/LICENSE ================================================ 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. ================================================ FILE: vendor/github.com/shirou/w32/README.md ================================================ About w32 ========== w32 is a wrapper of windows apis for the Go Programming Language. It wraps win32 apis to "Go style" to make them easier to use. Setup ===== 1. Make sure you have a working Go installation and build environment, see this go-nuts post for details: http://groups.google.com/group/golang-nuts/msg/5c87630a84f4fd0c Updated versions of the Windows Go build are available here: http://code.google.com/p/gomingw/downloads/list 2. Create a "gopath" directory if you do not have one yet and set the GOPATH variable accordingly. For example: mkdir -p go-externals/src export GOPATH=${PWD}/go-externals 3. go get github.com/AllenDang/w32 4. go install github.com/AllenDang/w32... Contribute ========== Contributions in form of design, code, documentation, bug reporting or other ways you see fit are very welcome. Thank You! ================================================ FILE: vendor/github.com/shirou/w32/advapi32.go ================================================ // 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 ( "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 } ================================================ FILE: vendor/github.com/shirou/w32/comctl32.go ================================================ // 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 ( "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 } ================================================ FILE: vendor/github.com/shirou/w32/comdlg32.go ================================================ // 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 ( "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) } ================================================ FILE: vendor/github.com/shirou/w32/constants.go ================================================ // 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 const ( FALSE = 0 TRUE = 1 ) const ( NO_ERROR = 0 ERROR_SUCCESS = 0 ERROR_FILE_NOT_FOUND = 2 ERROR_PATH_NOT_FOUND = 3 ERROR_ACCESS_DENIED = 5 ERROR_INVALID_HANDLE = 6 ERROR_BAD_FORMAT = 11 ERROR_INVALID_NAME = 123 ERROR_MORE_DATA = 234 ERROR_NO_MORE_ITEMS = 259 ERROR_INVALID_SERVICE_CONTROL = 1052 ERROR_SERVICE_REQUEST_TIMEOUT = 1053 ERROR_SERVICE_NO_THREAD = 1054 ERROR_SERVICE_DATABASE_LOCKED = 1055 ERROR_SERVICE_ALREADY_RUNNING = 1056 ERROR_SERVICE_DISABLED = 1058 ERROR_SERVICE_DOES_NOT_EXIST = 1060 ERROR_SERVICE_CANNOT_ACCEPT_CTRL = 1061 ERROR_SERVICE_NOT_ACTIVE = 1062 ERROR_DATABASE_DOES_NOT_EXIST = 1065 ERROR_SERVICE_DEPENDENCY_FAIL = 1068 ERROR_SERVICE_LOGON_FAILED = 1069 ERROR_SERVICE_MARKED_FOR_DELETE = 1072 ERROR_SERVICE_DEPENDENCY_DELETED = 1075 ) const ( SE_ERR_FNF = 2 SE_ERR_PNF = 3 SE_ERR_ACCESSDENIED = 5 SE_ERR_OOM = 8 SE_ERR_DLLNOTFOUND = 32 SE_ERR_SHARE = 26 SE_ERR_ASSOCINCOMPLETE = 27 SE_ERR_DDETIMEOUT = 28 SE_ERR_DDEFAIL = 29 SE_ERR_DDEBUSY = 30 SE_ERR_NOASSOC = 31 ) const ( CW_USEDEFAULT = ^0x7fffffff ) // ShowWindow constants const ( SW_HIDE = 0 SW_NORMAL = 1 SW_SHOWNORMAL = 1 SW_SHOWMINIMIZED = 2 SW_MAXIMIZE = 3 SW_SHOWMAXIMIZED = 3 SW_SHOWNOACTIVATE = 4 SW_SHOW = 5 SW_MINIMIZE = 6 SW_SHOWMINNOACTIVE = 7 SW_SHOWNA = 8 SW_RESTORE = 9 SW_SHOWDEFAULT = 10 SW_FORCEMINIMIZE = 11 ) // Window class styles const ( CS_VREDRAW = 0x00000001 CS_HREDRAW = 0x00000002 CS_KEYCVTWINDOW = 0x00000004 CS_DBLCLKS = 0x00000008 CS_OWNDC = 0x00000020 CS_CLASSDC = 0x00000040 CS_PARENTDC = 0x00000080 CS_NOKEYCVT = 0x00000100 CS_NOCLOSE = 0x00000200 CS_SAVEBITS = 0x00000800 CS_BYTEALIGNCLIENT = 0x00001000 CS_BYTEALIGNWINDOW = 0x00002000 CS_GLOBALCLASS = 0x00004000 CS_IME = 0x00010000 CS_DROPSHADOW = 0x00020000 ) // Predefined cursor constants const ( IDC_ARROW = 32512 IDC_IBEAM = 32513 IDC_WAIT = 32514 IDC_CROSS = 32515 IDC_UPARROW = 32516 IDC_SIZENWSE = 32642 IDC_SIZENESW = 32643 IDC_SIZEWE = 32644 IDC_SIZENS = 32645 IDC_SIZEALL = 32646 IDC_NO = 32648 IDC_HAND = 32649 IDC_APPSTARTING = 32650 IDC_HELP = 32651 IDC_ICON = 32641 IDC_SIZE = 32640 ) // Predefined icon constants const ( IDI_APPLICATION = 32512 IDI_HAND = 32513 IDI_QUESTION = 32514 IDI_EXCLAMATION = 32515 IDI_ASTERISK = 32516 IDI_WINLOGO = 32517 IDI_WARNING = IDI_EXCLAMATION IDI_ERROR = IDI_HAND IDI_INFORMATION = IDI_ASTERISK ) // Button style constants const ( BS_3STATE = 5 BS_AUTO3STATE = 6 BS_AUTOCHECKBOX = 3 BS_AUTORADIOBUTTON = 9 BS_BITMAP = 128 BS_BOTTOM = 0X800 BS_CENTER = 0X300 BS_CHECKBOX = 2 BS_DEFPUSHBUTTON = 1 BS_GROUPBOX = 7 BS_ICON = 64 BS_LEFT = 256 BS_LEFTTEXT = 32 BS_MULTILINE = 0X2000 BS_NOTIFY = 0X4000 BS_OWNERDRAW = 0XB BS_PUSHBUTTON = 0 BS_PUSHLIKE = 4096 BS_RADIOBUTTON = 4 BS_RIGHT = 512 BS_RIGHTBUTTON = 32 BS_TEXT = 0 BS_TOP = 0X400 BS_USERBUTTON = 8 BS_VCENTER = 0XC00 BS_FLAT = 0X8000 ) // Button state constants const ( BST_CHECKED = 1 BST_INDETERMINATE = 2 BST_UNCHECKED = 0 BST_FOCUS = 8 BST_PUSHED = 4 ) // Predefined brushes constants const ( COLOR_3DDKSHADOW = 21 COLOR_3DFACE = 15 COLOR_3DHILIGHT = 20 COLOR_3DHIGHLIGHT = 20 COLOR_3DLIGHT = 22 COLOR_BTNHILIGHT = 20 COLOR_3DSHADOW = 16 COLOR_ACTIVEBORDER = 10 COLOR_ACTIVECAPTION = 2 COLOR_APPWORKSPACE = 12 COLOR_BACKGROUND = 1 COLOR_DESKTOP = 1 COLOR_BTNFACE = 15 COLOR_BTNHIGHLIGHT = 20 COLOR_BTNSHADOW = 16 COLOR_BTNTEXT = 18 COLOR_CAPTIONTEXT = 9 COLOR_GRAYTEXT = 17 COLOR_HIGHLIGHT = 13 COLOR_HIGHLIGHTTEXT = 14 COLOR_INACTIVEBORDER = 11 COLOR_INACTIVECAPTION = 3 COLOR_INACTIVECAPTIONTEXT = 19 COLOR_INFOBK = 24 COLOR_INFOTEXT = 23 COLOR_MENU = 4 COLOR_MENUTEXT = 7 COLOR_SCROLLBAR = 0 COLOR_WINDOW = 5 COLOR_WINDOWFRAME = 6 COLOR_WINDOWTEXT = 8 COLOR_HOTLIGHT = 26 COLOR_GRADIENTACTIVECAPTION = 27 COLOR_GRADIENTINACTIVECAPTION = 28 ) // Button message constants const ( BM_CLICK = 245 BM_GETCHECK = 240 BM_GETIMAGE = 246 BM_GETSTATE = 242 BM_SETCHECK = 241 BM_SETIMAGE = 247 BM_SETSTATE = 243 BM_SETSTYLE = 244 ) // Button notifications const ( BN_CLICKED = 0 BN_PAINT = 1 BN_HILITE = 2 BN_PUSHED = BN_HILITE BN_UNHILITE = 3 BN_UNPUSHED = BN_UNHILITE BN_DISABLE = 4 BN_DOUBLECLICKED = 5 BN_DBLCLK = BN_DOUBLECLICKED BN_SETFOCUS = 6 BN_KILLFOCUS = 7 ) // GetWindowLong and GetWindowLongPtr constants const ( GWL_EXSTYLE = -20 GWL_STYLE = -16 GWL_WNDPROC = -4 GWLP_WNDPROC = -4 GWL_HINSTANCE = -6 GWLP_HINSTANCE = -6 GWL_HWNDPARENT = -8 GWLP_HWNDPARENT = -8 GWL_ID = -12 GWLP_ID = -12 GWL_USERDATA = -21 GWLP_USERDATA = -21 ) // Window style constants const ( WS_OVERLAPPED = 0X00000000 WS_POPUP = 0X80000000 WS_CHILD = 0X40000000 WS_MINIMIZE = 0X20000000 WS_VISIBLE = 0X10000000 WS_DISABLED = 0X08000000 WS_CLIPSIBLINGS = 0X04000000 WS_CLIPCHILDREN = 0X02000000 WS_MAXIMIZE = 0X01000000 WS_CAPTION = 0X00C00000 WS_BORDER = 0X00800000 WS_DLGFRAME = 0X00400000 WS_VSCROLL = 0X00200000 WS_HSCROLL = 0X00100000 WS_SYSMENU = 0X00080000 WS_THICKFRAME = 0X00040000 WS_GROUP = 0X00020000 WS_TABSTOP = 0X00010000 WS_MINIMIZEBOX = 0X00020000 WS_MAXIMIZEBOX = 0X00010000 WS_TILED = 0X00000000 WS_ICONIC = 0X20000000 WS_SIZEBOX = 0X00040000 WS_OVERLAPPEDWINDOW = 0X00000000 | 0X00C00000 | 0X00080000 | 0X00040000 | 0X00020000 | 0X00010000 WS_POPUPWINDOW = 0X80000000 | 0X00800000 | 0X00080000 WS_CHILDWINDOW = 0X40000000 ) // Extended window style constants const ( WS_EX_DLGMODALFRAME = 0X00000001 WS_EX_NOPARENTNOTIFY = 0X00000004 WS_EX_TOPMOST = 0X00000008 WS_EX_ACCEPTFILES = 0X00000010 WS_EX_TRANSPARENT = 0X00000020 WS_EX_MDICHILD = 0X00000040 WS_EX_TOOLWINDOW = 0X00000080 WS_EX_WINDOWEDGE = 0X00000100 WS_EX_CLIENTEDGE = 0X00000200 WS_EX_CONTEXTHELP = 0X00000400 WS_EX_RIGHT = 0X00001000 WS_EX_LEFT = 0X00000000 WS_EX_RTLREADING = 0X00002000 WS_EX_LTRREADING = 0X00000000 WS_EX_LEFTSCROLLBAR = 0X00004000 WS_EX_RIGHTSCROLLBAR = 0X00000000 WS_EX_CONTROLPARENT = 0X00010000 WS_EX_STATICEDGE = 0X00020000 WS_EX_APPWINDOW = 0X00040000 WS_EX_OVERLAPPEDWINDOW = 0X00000100 | 0X00000200 WS_EX_PALETTEWINDOW = 0X00000100 | 0X00000080 | 0X00000008 WS_EX_LAYERED = 0X00080000 WS_EX_NOINHERITLAYOUT = 0X00100000 WS_EX_LAYOUTRTL = 0X00400000 WS_EX_NOACTIVATE = 0X08000000 ) // Window message constants const ( WM_APP = 32768 WM_ACTIVATE = 6 WM_ACTIVATEAPP = 28 WM_AFXFIRST = 864 WM_AFXLAST = 895 WM_ASKCBFORMATNAME = 780 WM_CANCELJOURNAL = 75 WM_CANCELMODE = 31 WM_CAPTURECHANGED = 533 WM_CHANGECBCHAIN = 781 WM_CHAR = 258 WM_CHARTOITEM = 47 WM_CHILDACTIVATE = 34 WM_CLEAR = 771 WM_CLOSE = 16 WM_COMMAND = 273 WM_COMMNOTIFY = 68 /* OBSOLETE */ WM_COMPACTING = 65 WM_COMPAREITEM = 57 WM_CONTEXTMENU = 123 WM_COPY = 769 WM_COPYDATA = 74 WM_CREATE = 1 WM_CTLCOLORBTN = 309 WM_CTLCOLORDLG = 310 WM_CTLCOLOREDIT = 307 WM_CTLCOLORLISTBOX = 308 WM_CTLCOLORMSGBOX = 306 WM_CTLCOLORSCROLLBAR = 311 WM_CTLCOLORSTATIC = 312 WM_CUT = 768 WM_DEADCHAR = 259 WM_DELETEITEM = 45 WM_DESTROY = 2 WM_DESTROYCLIPBOARD = 775 WM_DEVICECHANGE = 537 WM_DEVMODECHANGE = 27 WM_DISPLAYCHANGE = 126 WM_DRAWCLIPBOARD = 776 WM_DRAWITEM = 43 WM_DROPFILES = 563 WM_ENABLE = 10 WM_ENDSESSION = 22 WM_ENTERIDLE = 289 WM_ENTERMENULOOP = 529 WM_ENTERSIZEMOVE = 561 WM_ERASEBKGND = 20 WM_EXITMENULOOP = 530 WM_EXITSIZEMOVE = 562 WM_FONTCHANGE = 29 WM_GETDLGCODE = 135 WM_GETFONT = 49 WM_GETHOTKEY = 51 WM_GETICON = 127 WM_GETMINMAXINFO = 36 WM_GETTEXT = 13 WM_GETTEXTLENGTH = 14 WM_HANDHELDFIRST = 856 WM_HANDHELDLAST = 863 WM_HELP = 83 WM_HOTKEY = 786 WM_HSCROLL = 276 WM_HSCROLLCLIPBOARD = 782 WM_ICONERASEBKGND = 39 WM_INITDIALOG = 272 WM_INITMENU = 278 WM_INITMENUPOPUP = 279 WM_INPUT = 0X00FF WM_INPUTLANGCHANGE = 81 WM_INPUTLANGCHANGEREQUEST = 80 WM_KEYDOWN = 256 WM_KEYUP = 257 WM_KILLFOCUS = 8 WM_MDIACTIVATE = 546 WM_MDICASCADE = 551 WM_MDICREATE = 544 WM_MDIDESTROY = 545 WM_MDIGETACTIVE = 553 WM_MDIICONARRANGE = 552 WM_MDIMAXIMIZE = 549 WM_MDINEXT = 548 WM_MDIREFRESHMENU = 564 WM_MDIRESTORE = 547 WM_MDISETMENU = 560 WM_MDITILE = 550 WM_MEASUREITEM = 44 WM_GETOBJECT = 0X003D WM_CHANGEUISTATE = 0X0127 WM_UPDATEUISTATE = 0X0128 WM_QUERYUISTATE = 0X0129 WM_UNINITMENUPOPUP = 0X0125 WM_MENURBUTTONUP = 290 WM_MENUCOMMAND = 0X0126 WM_MENUGETOBJECT = 0X0124 WM_MENUDRAG = 0X0123 WM_APPCOMMAND = 0X0319 WM_MENUCHAR = 288 WM_MENUSELECT = 287 WM_MOVE = 3 WM_MOVING = 534 WM_NCACTIVATE = 134 WM_NCCALCSIZE = 131 WM_NCCREATE = 129 WM_NCDESTROY = 130 WM_NCHITTEST = 132 WM_NCLBUTTONDBLCLK = 163 WM_NCLBUTTONDOWN = 161 WM_NCLBUTTONUP = 162 WM_NCMBUTTONDBLCLK = 169 WM_NCMBUTTONDOWN = 167 WM_NCMBUTTONUP = 168 WM_NCXBUTTONDOWN = 171 WM_NCXBUTTONUP = 172 WM_NCXBUTTONDBLCLK = 173 WM_NCMOUSEHOVER = 0X02A0 WM_NCMOUSELEAVE = 0X02A2 WM_NCMOUSEMOVE = 160 WM_NCPAINT = 133 WM_NCRBUTTONDBLCLK = 166 WM_NCRBUTTONDOWN = 164 WM_NCRBUTTONUP = 165 WM_NEXTDLGCTL = 40 WM_NEXTMENU = 531 WM_NOTIFY = 78 WM_NOTIFYFORMAT = 85 WM_NULL = 0 WM_PAINT = 15 WM_PAINTCLIPBOARD = 777 WM_PAINTICON = 38 WM_PALETTECHANGED = 785 WM_PALETTEISCHANGING = 784 WM_PARENTNOTIFY = 528 WM_PASTE = 770 WM_PENWINFIRST = 896 WM_PENWINLAST = 911 WM_POWER = 72 WM_POWERBROADCAST = 536 WM_PRINT = 791 WM_PRINTCLIENT = 792 WM_QUERYDRAGICON = 55 WM_QUERYENDSESSION = 17 WM_QUERYNEWPALETTE = 783 WM_QUERYOPEN = 19 WM_QUEUESYNC = 35 WM_QUIT = 18 WM_RENDERALLFORMATS = 774 WM_RENDERFORMAT = 773 WM_SETCURSOR = 32 WM_SETFOCUS = 7 WM_SETFONT = 48 WM_SETHOTKEY = 50 WM_SETICON = 128 WM_SETREDRAW = 11 WM_SETTEXT = 12 WM_SETTINGCHANGE = 26 WM_SHOWWINDOW = 24 WM_SIZE = 5 WM_SIZECLIPBOARD = 779 WM_SIZING = 532 WM_SPOOLERSTATUS = 42 WM_STYLECHANGED = 125 WM_STYLECHANGING = 124 WM_SYSCHAR = 262 WM_SYSCOLORCHANGE = 21 WM_SYSCOMMAND = 274 WM_SYSDEADCHAR = 263 WM_SYSKEYDOWN = 260 WM_SYSKEYUP = 261 WM_TCARD = 82 WM_THEMECHANGED = 794 WM_TIMECHANGE = 30 WM_TIMER = 275 WM_UNDO = 772 WM_USER = 1024 WM_USERCHANGED = 84 WM_VKEYTOITEM = 46 WM_VSCROLL = 277 WM_VSCROLLCLIPBOARD = 778 WM_WINDOWPOSCHANGED = 71 WM_WINDOWPOSCHANGING = 70 WM_WININICHANGE = 26 WM_KEYFIRST = 256 WM_KEYLAST = 264 WM_SYNCPAINT = 136 WM_MOUSEACTIVATE = 33 WM_MOUSEMOVE = 512 WM_LBUTTONDOWN = 513 WM_LBUTTONUP = 514 WM_LBUTTONDBLCLK = 515 WM_RBUTTONDOWN = 516 WM_RBUTTONUP = 517 WM_RBUTTONDBLCLK = 518 WM_MBUTTONDOWN = 519 WM_MBUTTONUP = 520 WM_MBUTTONDBLCLK = 521 WM_MOUSEWHEEL = 522 WM_MOUSEFIRST = 512 WM_XBUTTONDOWN = 523 WM_XBUTTONUP = 524 WM_XBUTTONDBLCLK = 525 WM_MOUSELAST = 525 WM_MOUSEHOVER = 0X2A1 WM_MOUSELEAVE = 0X2A3 WM_CLIPBOARDUPDATE = 0x031D ) // WM_ACTIVATE const ( WA_INACTIVE = 0 WA_ACTIVE = 1 WA_CLICKACTIVE = 2 ) const LF_FACESIZE = 32 // Font weight constants const ( FW_DONTCARE = 0 FW_THIN = 100 FW_EXTRALIGHT = 200 FW_ULTRALIGHT = FW_EXTRALIGHT FW_LIGHT = 300 FW_NORMAL = 400 FW_REGULAR = 400 FW_MEDIUM = 500 FW_SEMIBOLD = 600 FW_DEMIBOLD = FW_SEMIBOLD FW_BOLD = 700 FW_EXTRABOLD = 800 FW_ULTRABOLD = FW_EXTRABOLD FW_HEAVY = 900 FW_BLACK = FW_HEAVY ) // Charset constants const ( ANSI_CHARSET = 0 DEFAULT_CHARSET = 1 SYMBOL_CHARSET = 2 SHIFTJIS_CHARSET = 128 HANGEUL_CHARSET = 129 HANGUL_CHARSET = 129 GB2312_CHARSET = 134 CHINESEBIG5_CHARSET = 136 GREEK_CHARSET = 161 TURKISH_CHARSET = 162 HEBREW_CHARSET = 177 ARABIC_CHARSET = 178 BALTIC_CHARSET = 186 RUSSIAN_CHARSET = 204 THAI_CHARSET = 222 EASTEUROPE_CHARSET = 238 OEM_CHARSET = 255 JOHAB_CHARSET = 130 VIETNAMESE_CHARSET = 163 MAC_CHARSET = 77 ) // Font output precision constants const ( OUT_DEFAULT_PRECIS = 0 OUT_STRING_PRECIS = 1 OUT_CHARACTER_PRECIS = 2 OUT_STROKE_PRECIS = 3 OUT_TT_PRECIS = 4 OUT_DEVICE_PRECIS = 5 OUT_RASTER_PRECIS = 6 OUT_TT_ONLY_PRECIS = 7 OUT_OUTLINE_PRECIS = 8 OUT_PS_ONLY_PRECIS = 10 ) // Font clipping precision constants const ( CLIP_DEFAULT_PRECIS = 0 CLIP_CHARACTER_PRECIS = 1 CLIP_STROKE_PRECIS = 2 CLIP_MASK = 15 CLIP_LH_ANGLES = 16 CLIP_TT_ALWAYS = 32 CLIP_EMBEDDED = 128 ) // Font output quality constants const ( DEFAULT_QUALITY = 0 DRAFT_QUALITY = 1 PROOF_QUALITY = 2 NONANTIALIASED_QUALITY = 3 ANTIALIASED_QUALITY = 4 CLEARTYPE_QUALITY = 5 ) // Font pitch constants const ( DEFAULT_PITCH = 0 FIXED_PITCH = 1 VARIABLE_PITCH = 2 ) // Font family constants const ( FF_DECORATIVE = 80 FF_DONTCARE = 0 FF_MODERN = 48 FF_ROMAN = 16 FF_SCRIPT = 64 FF_SWISS = 32 ) // DeviceCapabilities capabilities const ( DC_FIELDS = 1 DC_PAPERS = 2 DC_PAPERSIZE = 3 DC_MINEXTENT = 4 DC_MAXEXTENT = 5 DC_BINS = 6 DC_DUPLEX = 7 DC_SIZE = 8 DC_EXTRA = 9 DC_VERSION = 10 DC_DRIVER = 11 DC_BINNAMES = 12 DC_ENUMRESOLUTIONS = 13 DC_FILEDEPENDENCIES = 14 DC_TRUETYPE = 15 DC_PAPERNAMES = 16 DC_ORIENTATION = 17 DC_COPIES = 18 DC_BINADJUST = 19 DC_EMF_COMPLIANT = 20 DC_DATATYPE_PRODUCED = 21 DC_COLLATE = 22 DC_MANUFACTURER = 23 DC_MODEL = 24 DC_PERSONALITY = 25 DC_PRINTRATE = 26 DC_PRINTRATEUNIT = 27 DC_PRINTERMEM = 28 DC_MEDIAREADY = 29 DC_STAPLE = 30 DC_PRINTRATEPPM = 31 DC_COLORDEVICE = 32 DC_NUP = 33 DC_MEDIATYPENAMES = 34 DC_MEDIATYPES = 35 ) // GetDeviceCaps index constants const ( DRIVERVERSION = 0 TECHNOLOGY = 2 HORZSIZE = 4 VERTSIZE = 6 HORZRES = 8 VERTRES = 10 LOGPIXELSX = 88 LOGPIXELSY = 90 BITSPIXEL = 12 PLANES = 14 NUMBRUSHES = 16 NUMPENS = 18 NUMFONTS = 22 NUMCOLORS = 24 NUMMARKERS = 20 ASPECTX = 40 ASPECTY = 42 ASPECTXY = 44 PDEVICESIZE = 26 CLIPCAPS = 36 SIZEPALETTE = 104 NUMRESERVED = 106 COLORRES = 108 PHYSICALWIDTH = 110 PHYSICALHEIGHT = 111 PHYSICALOFFSETX = 112 PHYSICALOFFSETY = 113 SCALINGFACTORX = 114 SCALINGFACTORY = 115 VREFRESH = 116 DESKTOPHORZRES = 118 DESKTOPVERTRES = 117 BLTALIGNMENT = 119 SHADEBLENDCAPS = 120 COLORMGMTCAPS = 121 RASTERCAPS = 38 CURVECAPS = 28 LINECAPS = 30 POLYGONALCAPS = 32 TEXTCAPS = 34 ) // GetDeviceCaps TECHNOLOGY constants const ( DT_PLOTTER = 0 DT_RASDISPLAY = 1 DT_RASPRINTER = 2 DT_RASCAMERA = 3 DT_CHARSTREAM = 4 DT_METAFILE = 5 DT_DISPFILE = 6 ) // GetDeviceCaps SHADEBLENDCAPS constants const ( SB_NONE = 0x00 SB_CONST_ALPHA = 0x01 SB_PIXEL_ALPHA = 0x02 SB_PREMULT_ALPHA = 0x04 SB_GRAD_RECT = 0x10 SB_GRAD_TRI = 0x20 ) // GetDeviceCaps COLORMGMTCAPS constants const ( CM_NONE = 0x00 CM_DEVICE_ICM = 0x01 CM_GAMMA_RAMP = 0x02 CM_CMYK_COLOR = 0x04 ) // GetDeviceCaps RASTERCAPS constants const ( RC_BANDING = 2 RC_BITBLT = 1 RC_BITMAP64 = 8 RC_DI_BITMAP = 128 RC_DIBTODEV = 512 RC_FLOODFILL = 4096 RC_GDI20_OUTPUT = 16 RC_PALETTE = 256 RC_SCALING = 4 RC_STRETCHBLT = 2048 RC_STRETCHDIB = 8192 RC_DEVBITS = 0x8000 RC_OP_DX_OUTPUT = 0x4000 ) // GetDeviceCaps CURVECAPS constants const ( CC_NONE = 0 CC_CIRCLES = 1 CC_PIE = 2 CC_CHORD = 4 CC_ELLIPSES = 8 CC_WIDE = 16 CC_STYLED = 32 CC_WIDESTYLED = 64 CC_INTERIORS = 128 CC_ROUNDRECT = 256 ) // GetDeviceCaps LINECAPS constants const ( LC_NONE = 0 LC_POLYLINE = 2 LC_MARKER = 4 LC_POLYMARKER = 8 LC_WIDE = 16 LC_STYLED = 32 LC_WIDESTYLED = 64 LC_INTERIORS = 128 ) // GetDeviceCaps POLYGONALCAPS constants const ( PC_NONE = 0 PC_POLYGON = 1 PC_POLYPOLYGON = 256 PC_PATHS = 512 PC_RECTANGLE = 2 PC_WINDPOLYGON = 4 PC_SCANLINE = 8 PC_TRAPEZOID = 4 PC_WIDE = 16 PC_STYLED = 32 PC_WIDESTYLED = 64 PC_INTERIORS = 128 ) // GetDeviceCaps TEXTCAPS constants const ( TC_OP_CHARACTER = 1 TC_OP_STROKE = 2 TC_CP_STROKE = 4 TC_CR_90 = 8 TC_CR_ANY = 16 TC_SF_X_YINDEP = 32 TC_SA_DOUBLE = 64 TC_SA_INTEGER = 128 TC_SA_CONTIN = 256 TC_EA_DOUBLE = 512 TC_IA_ABLE = 1024 TC_UA_ABLE = 2048 TC_SO_ABLE = 4096 TC_RA_ABLE = 8192 TC_VA_ABLE = 16384 TC_RESERVED = 32768 TC_SCROLLBLT = 65536 ) // Static control styles const ( SS_BITMAP = 14 SS_BLACKFRAME = 7 SS_BLACKRECT = 4 SS_CENTER = 1 SS_CENTERIMAGE = 512 SS_EDITCONTROL = 0x2000 SS_ENHMETAFILE = 15 SS_ETCHEDFRAME = 18 SS_ETCHEDHORZ = 16 SS_ETCHEDVERT = 17 SS_GRAYFRAME = 8 SS_GRAYRECT = 5 SS_ICON = 3 SS_LEFT = 0 SS_LEFTNOWORDWRAP = 0xc SS_NOPREFIX = 128 SS_NOTIFY = 256 SS_OWNERDRAW = 0xd SS_REALSIZECONTROL = 0x040 SS_REALSIZEIMAGE = 0x800 SS_RIGHT = 2 SS_RIGHTJUST = 0x400 SS_SIMPLE = 11 SS_SUNKEN = 4096 SS_WHITEFRAME = 9 SS_WHITERECT = 6 SS_USERITEM = 10 SS_TYPEMASK = 0x0000001F SS_ENDELLIPSIS = 0x00004000 SS_PATHELLIPSIS = 0x00008000 SS_WORDELLIPSIS = 0x0000C000 SS_ELLIPSISMASK = 0x0000C000 ) // Edit styles const ( ES_LEFT = 0x0000 ES_CENTER = 0x0001 ES_RIGHT = 0x0002 ES_MULTILINE = 0x0004 ES_UPPERCASE = 0x0008 ES_LOWERCASE = 0x0010 ES_PASSWORD = 0x0020 ES_AUTOVSCROLL = 0x0040 ES_AUTOHSCROLL = 0x0080 ES_NOHIDESEL = 0x0100 ES_OEMCONVERT = 0x0400 ES_READONLY = 0x0800 ES_WANTRETURN = 0x1000 ES_NUMBER = 0x2000 ) // Edit notifications const ( EN_SETFOCUS = 0x0100 EN_KILLFOCUS = 0x0200 EN_CHANGE = 0x0300 EN_UPDATE = 0x0400 EN_ERRSPACE = 0x0500 EN_MAXTEXT = 0x0501 EN_HSCROLL = 0x0601 EN_VSCROLL = 0x0602 EN_ALIGN_LTR_EC = 0x0700 EN_ALIGN_RTL_EC = 0x0701 ) // Edit messages const ( EM_GETSEL = 0x00B0 EM_SETSEL = 0x00B1 EM_GETRECT = 0x00B2 EM_SETRECT = 0x00B3 EM_SETRECTNP = 0x00B4 EM_SCROLL = 0x00B5 EM_LINESCROLL = 0x00B6 EM_SCROLLCARET = 0x00B7 EM_GETMODIFY = 0x00B8 EM_SETMODIFY = 0x00B9 EM_GETLINECOUNT = 0x00BA EM_LINEINDEX = 0x00BB EM_SETHANDLE = 0x00BC EM_GETHANDLE = 0x00BD EM_GETTHUMB = 0x00BE EM_LINELENGTH = 0x00C1 EM_REPLACESEL = 0x00C2 EM_GETLINE = 0x00C4 EM_LIMITTEXT = 0x00C5 EM_CANUNDO = 0x00C6 EM_UNDO = 0x00C7 EM_FMTLINES = 0x00C8 EM_LINEFROMCHAR = 0x00C9 EM_SETTABSTOPS = 0x00CB EM_SETPASSWORDCHAR = 0x00CC EM_EMPTYUNDOBUFFER = 0x00CD EM_GETFIRSTVISIBLELINE = 0x00CE EM_SETREADONLY = 0x00CF EM_SETWORDBREAKPROC = 0x00D0 EM_GETWORDBREAKPROC = 0x00D1 EM_GETPASSWORDCHAR = 0x00D2 EM_SETMARGINS = 0x00D3 EM_GETMARGINS = 0x00D4 EM_SETLIMITTEXT = EM_LIMITTEXT EM_GETLIMITTEXT = 0x00D5 EM_POSFROMCHAR = 0x00D6 EM_CHARFROMPOS = 0x00D7 EM_SETIMESTATUS = 0x00D8 EM_GETIMESTATUS = 0x00D9 EM_SETCUEBANNER = 0x1501 EM_GETCUEBANNER = 0x1502 ) const ( CCM_FIRST = 0x2000 CCM_LAST = CCM_FIRST + 0x200 CCM_SETBKCOLOR = 8193 CCM_SETCOLORSCHEME = 8194 CCM_GETCOLORSCHEME = 8195 CCM_GETDROPTARGET = 8196 CCM_SETUNICODEFORMAT = 8197 CCM_GETUNICODEFORMAT = 8198 CCM_SETVERSION = 0x2007 CCM_GETVERSION = 0x2008 CCM_SETNOTIFYWINDOW = 0x2009 CCM_SETWINDOWTHEME = 0x200b CCM_DPISCALE = 0x200c ) // Common controls styles const ( CCS_TOP = 1 CCS_NOMOVEY = 2 CCS_BOTTOM = 3 CCS_NORESIZE = 4 CCS_NOPARENTALIGN = 8 CCS_ADJUSTABLE = 32 CCS_NODIVIDER = 64 CCS_VERT = 128 CCS_LEFT = 129 CCS_NOMOVEX = 130 CCS_RIGHT = 131 ) // ProgressBar messages const ( PROGRESS_CLASS = "msctls_progress32" PBM_SETPOS = WM_USER + 2 PBM_DELTAPOS = WM_USER + 3 PBM_SETSTEP = WM_USER + 4 PBM_STEPIT = WM_USER + 5 PBM_SETRANGE32 = 1030 PBM_GETRANGE = 1031 PBM_GETPOS = 1032 PBM_SETBARCOLOR = 1033 PBM_SETBKCOLOR = CCM_SETBKCOLOR PBS_SMOOTH = 1 PBS_VERTICAL = 4 ) // GetOpenFileName and GetSaveFileName extended flags const ( OFN_EX_NOPLACESBAR = 0x00000001 ) // GetOpenFileName and GetSaveFileName flags const ( OFN_ALLOWMULTISELECT = 0x00000200 OFN_CREATEPROMPT = 0x00002000 OFN_DONTADDTORECENT = 0x02000000 OFN_ENABLEHOOK = 0x00000020 OFN_ENABLEINCLUDENOTIFY = 0x00400000 OFN_ENABLESIZING = 0x00800000 OFN_ENABLETEMPLATE = 0x00000040 OFN_ENABLETEMPLATEHANDLE = 0x00000080 OFN_EXPLORER = 0x00080000 OFN_EXTENSIONDIFFERENT = 0x00000400 OFN_FILEMUSTEXIST = 0x00001000 OFN_FORCESHOWHIDDEN = 0x10000000 OFN_HIDEREADONLY = 0x00000004 OFN_LONGNAMES = 0x00200000 OFN_NOCHANGEDIR = 0x00000008 OFN_NODEREFERENCELINKS = 0x00100000 OFN_NOLONGNAMES = 0x00040000 OFN_NONETWORKBUTTON = 0x00020000 OFN_NOREADONLYRETURN = 0x00008000 OFN_NOTESTFILECREATE = 0x00010000 OFN_NOVALIDATE = 0x00000100 OFN_OVERWRITEPROMPT = 0x00000002 OFN_PATHMUSTEXIST = 0x00000800 OFN_READONLY = 0x00000001 OFN_SHAREAWARE = 0x00004000 OFN_SHOWHELP = 0x00000010 ) //SHBrowseForFolder flags const ( BIF_RETURNONLYFSDIRS = 0x00000001 BIF_DONTGOBELOWDOMAIN = 0x00000002 BIF_STATUSTEXT = 0x00000004 BIF_RETURNFSANCESTORS = 0x00000008 BIF_EDITBOX = 0x00000010 BIF_VALIDATE = 0x00000020 BIF_NEWDIALOGSTYLE = 0x00000040 BIF_BROWSEINCLUDEURLS = 0x00000080 BIF_USENEWUI = BIF_EDITBOX | BIF_NEWDIALOGSTYLE BIF_UAHINT = 0x00000100 BIF_NONEWFOLDERBUTTON = 0x00000200 BIF_NOTRANSLATETARGETS = 0x00000400 BIF_BROWSEFORCOMPUTER = 0x00001000 BIF_BROWSEFORPRINTER = 0x00002000 BIF_BROWSEINCLUDEFILES = 0x00004000 BIF_SHAREABLE = 0x00008000 BIF_BROWSEFILEJUNCTIONS = 0x00010000 ) //MessageBox flags const ( MB_OK = 0x00000000 MB_OKCANCEL = 0x00000001 MB_ABORTRETRYIGNORE = 0x00000002 MB_YESNOCANCEL = 0x00000003 MB_YESNO = 0x00000004 MB_RETRYCANCEL = 0x00000005 MB_CANCELTRYCONTINUE = 0x00000006 MB_ICONHAND = 0x00000010 MB_ICONQUESTION = 0x00000020 MB_ICONEXCLAMATION = 0x00000030 MB_ICONASTERISK = 0x00000040 MB_USERICON = 0x00000080 MB_ICONWARNING = MB_ICONEXCLAMATION MB_ICONERROR = MB_ICONHAND MB_ICONINFORMATION = MB_ICONASTERISK MB_ICONSTOP = MB_ICONHAND MB_DEFBUTTON1 = 0x00000000 MB_DEFBUTTON2 = 0x00000100 MB_DEFBUTTON3 = 0x00000200 MB_DEFBUTTON4 = 0x00000300 ) //COM const ( E_INVALIDARG = 0x80070057 E_OUTOFMEMORY = 0x8007000E E_UNEXPECTED = 0x8000FFFF ) const ( S_OK = 0 S_FALSE = 0x0001 RPC_E_CHANGED_MODE = 0x80010106 ) // GetSystemMetrics constants const ( SM_CXSCREEN = 0 SM_CYSCREEN = 1 SM_CXVSCROLL = 2 SM_CYHSCROLL = 3 SM_CYCAPTION = 4 SM_CXBORDER = 5 SM_CYBORDER = 6 SM_CXDLGFRAME = 7 SM_CYDLGFRAME = 8 SM_CYVTHUMB = 9 SM_CXHTHUMB = 10 SM_CXICON = 11 SM_CYICON = 12 SM_CXCURSOR = 13 SM_CYCURSOR = 14 SM_CYMENU = 15 SM_CXFULLSCREEN = 16 SM_CYFULLSCREEN = 17 SM_CYKANJIWINDOW = 18 SM_MOUSEPRESENT = 19 SM_CYVSCROLL = 20 SM_CXHSCROLL = 21 SM_DEBUG = 22 SM_SWAPBUTTON = 23 SM_RESERVED1 = 24 SM_RESERVED2 = 25 SM_RESERVED3 = 26 SM_RESERVED4 = 27 SM_CXMIN = 28 SM_CYMIN = 29 SM_CXSIZE = 30 SM_CYSIZE = 31 SM_CXFRAME = 32 SM_CYFRAME = 33 SM_CXMINTRACK = 34 SM_CYMINTRACK = 35 SM_CXDOUBLECLK = 36 SM_CYDOUBLECLK = 37 SM_CXICONSPACING = 38 SM_CYICONSPACING = 39 SM_MENUDROPALIGNMENT = 40 SM_PENWINDOWS = 41 SM_DBCSENABLED = 42 SM_CMOUSEBUTTONS = 43 SM_CXFIXEDFRAME = SM_CXDLGFRAME SM_CYFIXEDFRAME = SM_CYDLGFRAME SM_CXSIZEFRAME = SM_CXFRAME SM_CYSIZEFRAME = SM_CYFRAME SM_SECURE = 44 SM_CXEDGE = 45 SM_CYEDGE = 46 SM_CXMINSPACING = 47 SM_CYMINSPACING = 48 SM_CXSMICON = 49 SM_CYSMICON = 50 SM_CYSMCAPTION = 51 SM_CXSMSIZE = 52 SM_CYSMSIZE = 53 SM_CXMENUSIZE = 54 SM_CYMENUSIZE = 55 SM_ARRANGE = 56 SM_CXMINIMIZED = 57 SM_CYMINIMIZED = 58 SM_CXMAXTRACK = 59 SM_CYMAXTRACK = 60 SM_CXMAXIMIZED = 61 SM_CYMAXIMIZED = 62 SM_NETWORK = 63 SM_CLEANBOOT = 67 SM_CXDRAG = 68 SM_CYDRAG = 69 SM_SHOWSOUNDS = 70 SM_CXMENUCHECK = 71 SM_CYMENUCHECK = 72 SM_SLOWMACHINE = 73 SM_MIDEASTENABLED = 74 SM_MOUSEWHEELPRESENT = 75 SM_XVIRTUALSCREEN = 76 SM_YVIRTUALSCREEN = 77 SM_CXVIRTUALSCREEN = 78 SM_CYVIRTUALSCREEN = 79 SM_CMONITORS = 80 SM_SAMEDISPLAYFORMAT = 81 SM_IMMENABLED = 82 SM_CXFOCUSBORDER = 83 SM_CYFOCUSBORDER = 84 SM_TABLETPC = 86 SM_MEDIACENTER = 87 SM_STARTER = 88 SM_SERVERR2 = 89 SM_CMETRICS = 91 SM_REMOTESESSION = 0x1000 SM_SHUTTINGDOWN = 0x2000 SM_REMOTECONTROL = 0x2001 SM_CARETBLINKINGENABLED = 0x2002 ) const ( CLSCTX_INPROC_SERVER = 1 CLSCTX_INPROC_HANDLER = 2 CLSCTX_LOCAL_SERVER = 4 CLSCTX_INPROC_SERVER16 = 8 CLSCTX_REMOTE_SERVER = 16 CLSCTX_ALL = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER ) const ( COINIT_APARTMENTTHREADED = 0x2 COINIT_MULTITHREADED = 0x0 COINIT_DISABLE_OLE1DDE = 0x4 COINIT_SPEED_OVER_MEMORY = 0x8 ) const ( DISPATCH_METHOD = 1 DISPATCH_PROPERTYGET = 2 DISPATCH_PROPERTYPUT = 4 DISPATCH_PROPERTYPUTREF = 8 ) const ( CC_FASTCALL = iota CC_CDECL CC_MSCPASCAL CC_PASCAL = CC_MSCPASCAL CC_MACPASCAL CC_STDCALL CC_FPFASTCALL CC_SYSCALL CC_MPWCDECL CC_MPWPASCAL CC_MAX = CC_MPWPASCAL ) const ( VT_EMPTY = 0x0 VT_NULL = 0x1 VT_I2 = 0x2 VT_I4 = 0x3 VT_R4 = 0x4 VT_R8 = 0x5 VT_CY = 0x6 VT_DATE = 0x7 VT_BSTR = 0x8 VT_DISPATCH = 0x9 VT_ERROR = 0xa VT_BOOL = 0xb VT_VARIANT = 0xc VT_UNKNOWN = 0xd VT_DECIMAL = 0xe VT_I1 = 0x10 VT_UI1 = 0x11 VT_UI2 = 0x12 VT_UI4 = 0x13 VT_I8 = 0x14 VT_UI8 = 0x15 VT_INT = 0x16 VT_UINT = 0x17 VT_VOID = 0x18 VT_HRESULT = 0x19 VT_PTR = 0x1a VT_SAFEARRAY = 0x1b VT_CARRAY = 0x1c VT_USERDEFINED = 0x1d VT_LPSTR = 0x1e VT_LPWSTR = 0x1f VT_RECORD = 0x24 VT_INT_PTR = 0x25 VT_UINT_PTR = 0x26 VT_FILETIME = 0x40 VT_BLOB = 0x41 VT_STREAM = 0x42 VT_STORAGE = 0x43 VT_STREAMED_OBJECT = 0x44 VT_STORED_OBJECT = 0x45 VT_BLOB_OBJECT = 0x46 VT_CF = 0x47 VT_CLSID = 0x48 VT_BSTR_BLOB = 0xfff VT_VECTOR = 0x1000 VT_ARRAY = 0x2000 VT_BYREF = 0x4000 VT_RESERVED = 0x8000 VT_ILLEGAL = 0xffff VT_ILLEGALMASKED = 0xfff VT_TYPEMASK = 0xfff ) const ( DISPID_UNKNOWN = -1 DISPID_VALUE = 0 DISPID_PROPERTYPUT = -3 DISPID_NEWENUM = -4 DISPID_EVALUATE = -5 DISPID_CONSTRUCTOR = -6 DISPID_DESTRUCTOR = -7 DISPID_COLLECT = -8 ) const ( MONITOR_DEFAULTTONULL = 0x00000000 MONITOR_DEFAULTTOPRIMARY = 0x00000001 MONITOR_DEFAULTTONEAREST = 0x00000002 MONITORINFOF_PRIMARY = 0x00000001 ) const ( CCHDEVICENAME = 32 CCHFORMNAME = 32 ) const ( IDOK = 1 IDCANCEL = 2 IDABORT = 3 IDRETRY = 4 IDIGNORE = 5 IDYES = 6 IDNO = 7 IDCLOSE = 8 IDHELP = 9 IDTRYAGAIN = 10 IDCONTINUE = 11 IDTIMEOUT = 32000 ) // Generic WM_NOTIFY notification codes const ( NM_FIRST = 0 NM_OUTOFMEMORY = NM_FIRST - 1 NM_CLICK = NM_FIRST - 2 NM_DBLCLK = NM_FIRST - 3 NM_RETURN = NM_FIRST - 4 NM_RCLICK = NM_FIRST - 5 NM_RDBLCLK = NM_FIRST - 6 NM_SETFOCUS = NM_FIRST - 7 NM_KILLFOCUS = NM_FIRST - 8 NM_CUSTOMDRAW = NM_FIRST - 12 NM_HOVER = NM_FIRST - 13 NM_NCHITTEST = NM_FIRST - 14 NM_KEYDOWN = NM_FIRST - 15 NM_RELEASEDCAPTURE = NM_FIRST - 16 NM_SETCURSOR = NM_FIRST - 17 NM_CHAR = NM_FIRST - 18 NM_TOOLTIPSCREATED = NM_FIRST - 19 NM_LAST = NM_FIRST - 99 ) // ListView messages const ( LVM_FIRST = 0x1000 LVM_GETITEMCOUNT = LVM_FIRST + 4 LVM_SETIMAGELIST = LVM_FIRST + 3 LVM_GETIMAGELIST = LVM_FIRST + 2 LVM_GETITEM = LVM_FIRST + 75 LVM_SETITEM = LVM_FIRST + 76 LVM_INSERTITEM = LVM_FIRST + 77 LVM_DELETEITEM = LVM_FIRST + 8 LVM_DELETEALLITEMS = LVM_FIRST + 9 LVM_GETCALLBACKMASK = LVM_FIRST + 10 LVM_SETCALLBACKMASK = LVM_FIRST + 11 LVM_SETUNICODEFORMAT = CCM_SETUNICODEFORMAT LVM_GETNEXTITEM = LVM_FIRST + 12 LVM_FINDITEM = LVM_FIRST + 83 LVM_GETITEMRECT = LVM_FIRST + 14 LVM_GETSTRINGWIDTH = LVM_FIRST + 87 LVM_HITTEST = LVM_FIRST + 18 LVM_ENSUREVISIBLE = LVM_FIRST + 19 LVM_SCROLL = LVM_FIRST + 20 LVM_REDRAWITEMS = LVM_FIRST + 21 LVM_ARRANGE = LVM_FIRST + 22 LVM_EDITLABEL = LVM_FIRST + 118 LVM_GETEDITCONTROL = LVM_FIRST + 24 LVM_GETCOLUMN = LVM_FIRST + 95 LVM_SETCOLUMN = LVM_FIRST + 96 LVM_INSERTCOLUMN = LVM_FIRST + 97 LVM_DELETECOLUMN = LVM_FIRST + 28 LVM_GETCOLUMNWIDTH = LVM_FIRST + 29 LVM_SETCOLUMNWIDTH = LVM_FIRST + 30 LVM_GETHEADER = LVM_FIRST + 31 LVM_CREATEDRAGIMAGE = LVM_FIRST + 33 LVM_GETVIEWRECT = LVM_FIRST + 34 LVM_GETTEXTCOLOR = LVM_FIRST + 35 LVM_SETTEXTCOLOR = LVM_FIRST + 36 LVM_GETTEXTBKCOLOR = LVM_FIRST + 37 LVM_SETTEXTBKCOLOR = LVM_FIRST + 38 LVM_GETTOPINDEX = LVM_FIRST + 39 LVM_GETCOUNTPERPAGE = LVM_FIRST + 40 LVM_GETORIGIN = LVM_FIRST + 41 LVM_UPDATE = LVM_FIRST + 42 LVM_SETITEMSTATE = LVM_FIRST + 43 LVM_GETITEMSTATE = LVM_FIRST + 44 LVM_GETITEMTEXT = LVM_FIRST + 115 LVM_SETITEMTEXT = LVM_FIRST + 116 LVM_SETITEMCOUNT = LVM_FIRST + 47 LVM_SORTITEMS = LVM_FIRST + 48 LVM_SETITEMPOSITION32 = LVM_FIRST + 49 LVM_GETSELECTEDCOUNT = LVM_FIRST + 50 LVM_GETITEMSPACING = LVM_FIRST + 51 LVM_GETISEARCHSTRING = LVM_FIRST + 117 LVM_SETICONSPACING = LVM_FIRST + 53 LVM_SETEXTENDEDLISTVIEWSTYLE = LVM_FIRST + 54 LVM_GETEXTENDEDLISTVIEWSTYLE = LVM_FIRST + 55 LVM_GETSUBITEMRECT = LVM_FIRST + 56 LVM_SUBITEMHITTEST = LVM_FIRST + 57 LVM_SETCOLUMNORDERARRAY = LVM_FIRST + 58 LVM_GETCOLUMNORDERARRAY = LVM_FIRST + 59 LVM_SETHOTITEM = LVM_FIRST + 60 LVM_GETHOTITEM = LVM_FIRST + 61 LVM_SETHOTCURSOR = LVM_FIRST + 62 LVM_GETHOTCURSOR = LVM_FIRST + 63 LVM_APPROXIMATEVIEWRECT = LVM_FIRST + 64 LVM_SETWORKAREAS = LVM_FIRST + 65 LVM_GETWORKAREAS = LVM_FIRST + 70 LVM_GETNUMBEROFWORKAREAS = LVM_FIRST + 73 LVM_GETSELECTIONMARK = LVM_FIRST + 66 LVM_SETSELECTIONMARK = LVM_FIRST + 67 LVM_SETHOVERTIME = LVM_FIRST + 71 LVM_GETHOVERTIME = LVM_FIRST + 72 LVM_SETTOOLTIPS = LVM_FIRST + 74 LVM_GETTOOLTIPS = LVM_FIRST + 78 LVM_SORTITEMSEX = LVM_FIRST + 81 LVM_SETBKIMAGE = LVM_FIRST + 138 LVM_GETBKIMAGE = LVM_FIRST + 139 LVM_SETSELECTEDCOLUMN = LVM_FIRST + 140 LVM_SETVIEW = LVM_FIRST + 142 LVM_GETVIEW = LVM_FIRST + 143 LVM_INSERTGROUP = LVM_FIRST + 145 LVM_SETGROUPINFO = LVM_FIRST + 147 LVM_GETGROUPINFO = LVM_FIRST + 149 LVM_REMOVEGROUP = LVM_FIRST + 150 LVM_MOVEGROUP = LVM_FIRST + 151 LVM_GETGROUPCOUNT = LVM_FIRST + 152 LVM_GETGROUPINFOBYINDEX = LVM_FIRST + 153 LVM_MOVEITEMTOGROUP = LVM_FIRST + 154 LVM_GETGROUPRECT = LVM_FIRST + 98 LVM_SETGROUPMETRICS = LVM_FIRST + 155 LVM_GETGROUPMETRICS = LVM_FIRST + 156 LVM_ENABLEGROUPVIEW = LVM_FIRST + 157 LVM_SORTGROUPS = LVM_FIRST + 158 LVM_INSERTGROUPSORTED = LVM_FIRST + 159 LVM_REMOVEALLGROUPS = LVM_FIRST + 160 LVM_HASGROUP = LVM_FIRST + 161 LVM_GETGROUPSTATE = LVM_FIRST + 92 LVM_GETFOCUSEDGROUP = LVM_FIRST + 93 LVM_SETTILEVIEWINFO = LVM_FIRST + 162 LVM_GETTILEVIEWINFO = LVM_FIRST + 163 LVM_SETTILEINFO = LVM_FIRST + 164 LVM_GETTILEINFO = LVM_FIRST + 165 LVM_SETINSERTMARK = LVM_FIRST + 166 LVM_GETINSERTMARK = LVM_FIRST + 167 LVM_INSERTMARKHITTEST = LVM_FIRST + 168 LVM_GETINSERTMARKRECT = LVM_FIRST + 169 LVM_SETINSERTMARKCOLOR = LVM_FIRST + 170 LVM_GETINSERTMARKCOLOR = LVM_FIRST + 171 LVM_SETINFOTIP = LVM_FIRST + 173 LVM_GETSELECTEDCOLUMN = LVM_FIRST + 174 LVM_ISGROUPVIEWENABLED = LVM_FIRST + 175 LVM_GETOUTLINECOLOR = LVM_FIRST + 176 LVM_SETOUTLINECOLOR = LVM_FIRST + 177 LVM_CANCELEDITLABEL = LVM_FIRST + 179 LVM_MAPINDEXTOID = LVM_FIRST + 180 LVM_MAPIDTOINDEX = LVM_FIRST + 181 LVM_ISITEMVISIBLE = LVM_FIRST + 182 LVM_GETNEXTITEMINDEX = LVM_FIRST + 211 ) // ListView notifications const ( LVN_FIRST = -100 LVN_ITEMCHANGING = LVN_FIRST - 0 LVN_ITEMCHANGED = LVN_FIRST - 1 LVN_INSERTITEM = LVN_FIRST - 2 LVN_DELETEITEM = LVN_FIRST - 3 LVN_DELETEALLITEMS = LVN_FIRST - 4 LVN_BEGINLABELEDITA = LVN_FIRST - 5 LVN_BEGINLABELEDITW = LVN_FIRST - 75 LVN_ENDLABELEDITA = LVN_FIRST - 6 LVN_ENDLABELEDITW = LVN_FIRST - 76 LVN_COLUMNCLICK = LVN_FIRST - 8 LVN_BEGINDRAG = LVN_FIRST - 9 LVN_BEGINRDRAG = LVN_FIRST - 11 LVN_ODCACHEHINT = LVN_FIRST - 13 LVN_ODFINDITEMA = LVN_FIRST - 52 LVN_ODFINDITEMW = LVN_FIRST - 79 LVN_ITEMACTIVATE = LVN_FIRST - 14 LVN_ODSTATECHANGED = LVN_FIRST - 15 LVN_HOTTRACK = LVN_FIRST - 21 LVN_GETDISPINFO = LVN_FIRST - 77 LVN_SETDISPINFO = LVN_FIRST - 78 LVN_KEYDOWN = LVN_FIRST - 55 LVN_MARQUEEBEGIN = LVN_FIRST - 56 LVN_GETINFOTIP = LVN_FIRST - 58 LVN_INCREMENTALSEARCH = LVN_FIRST - 63 LVN_BEGINSCROLL = LVN_FIRST - 80 LVN_ENDSCROLL = LVN_FIRST - 81 ) // ListView LVNI constants const ( LVNI_ALL = 0 LVNI_FOCUSED = 1 LVNI_SELECTED = 2 LVNI_CUT = 4 LVNI_DROPHILITED = 8 LVNI_ABOVE = 256 LVNI_BELOW = 512 LVNI_TOLEFT = 1024 LVNI_TORIGHT = 2048 ) // ListView styles const ( LVS_ICON = 0x0000 LVS_REPORT = 0x0001 LVS_SMALLICON = 0x0002 LVS_LIST = 0x0003 LVS_TYPEMASK = 0x0003 LVS_SINGLESEL = 0x0004 LVS_SHOWSELALWAYS = 0x0008 LVS_SORTASCENDING = 0x0010 LVS_SORTDESCENDING = 0x0020 LVS_SHAREIMAGELISTS = 0x0040 LVS_NOLABELWRAP = 0x0080 LVS_AUTOARRANGE = 0x0100 LVS_EDITLABELS = 0x0200 LVS_OWNERDATA = 0x1000 LVS_NOSCROLL = 0x2000 LVS_TYPESTYLEMASK = 0xfc00 LVS_ALIGNTOP = 0x0000 LVS_ALIGNLEFT = 0x0800 LVS_ALIGNMASK = 0x0c00 LVS_OWNERDRAWFIXED = 0x0400 LVS_NOCOLUMNHEADER = 0x4000 LVS_NOSORTHEADER = 0x8000 ) // ListView extended styles const ( LVS_EX_GRIDLINES = 0x00000001 LVS_EX_SUBITEMIMAGES = 0x00000002 LVS_EX_CHECKBOXES = 0x00000004 LVS_EX_TRACKSELECT = 0x00000008 LVS_EX_HEADERDRAGDROP = 0x00000010 LVS_EX_FULLROWSELECT = 0x00000020 LVS_EX_ONECLICKACTIVATE = 0x00000040 LVS_EX_TWOCLICKACTIVATE = 0x00000080 LVS_EX_FLATSB = 0x00000100 LVS_EX_REGIONAL = 0x00000200 LVS_EX_INFOTIP = 0x00000400 LVS_EX_UNDERLINEHOT = 0x00000800 LVS_EX_UNDERLINECOLD = 0x00001000 LVS_EX_MULTIWORKAREAS = 0x00002000 LVS_EX_LABELTIP = 0x00004000 LVS_EX_BORDERSELECT = 0x00008000 LVS_EX_DOUBLEBUFFER = 0x00010000 LVS_EX_HIDELABELS = 0x00020000 LVS_EX_SINGLEROW = 0x00040000 LVS_EX_SNAPTOGRID = 0x00080000 LVS_EX_SIMPLESELECT = 0x00100000 ) // ListView column flags const ( LVCF_FMT = 0x0001 LVCF_WIDTH = 0x0002 LVCF_TEXT = 0x0004 LVCF_SUBITEM = 0x0008 LVCF_IMAGE = 0x0010 LVCF_ORDER = 0x0020 ) // ListView column format constants const ( LVCFMT_LEFT = 0x0000 LVCFMT_RIGHT = 0x0001 LVCFMT_CENTER = 0x0002 LVCFMT_JUSTIFYMASK = 0x0003 LVCFMT_IMAGE = 0x0800 LVCFMT_BITMAP_ON_RIGHT = 0x1000 LVCFMT_COL_HAS_IMAGES = 0x8000 ) // ListView item flags const ( LVIF_TEXT = 0x00000001 LVIF_IMAGE = 0x00000002 LVIF_PARAM = 0x00000004 LVIF_STATE = 0x00000008 LVIF_INDENT = 0x00000010 LVIF_NORECOMPUTE = 0x00000800 LVIF_GROUPID = 0x00000100 LVIF_COLUMNS = 0x00000200 ) // ListView item states const ( LVIS_FOCUSED = 1 LVIS_SELECTED = 2 LVIS_CUT = 4 LVIS_DROPHILITED = 8 LVIS_OVERLAYMASK = 0xF00 LVIS_STATEIMAGEMASK = 0xF000 ) // ListView hit test constants const ( LVHT_NOWHERE = 0x00000001 LVHT_ONITEMICON = 0x00000002 LVHT_ONITEMLABEL = 0x00000004 LVHT_ONITEMSTATEICON = 0x00000008 LVHT_ONITEM = LVHT_ONITEMICON | LVHT_ONITEMLABEL | LVHT_ONITEMSTATEICON LVHT_ABOVE = 0x00000008 LVHT_BELOW = 0x00000010 LVHT_TORIGHT = 0x00000020 LVHT_TOLEFT = 0x00000040 ) // ListView image list types const ( LVSIL_NORMAL = 0 LVSIL_SMALL = 1 LVSIL_STATE = 2 LVSIL_GROUPHEADER = 3 ) // InitCommonControlsEx flags const ( ICC_LISTVIEW_CLASSES = 1 ICC_TREEVIEW_CLASSES = 2 ICC_BAR_CLASSES = 4 ICC_TAB_CLASSES = 8 ICC_UPDOWN_CLASS = 16 ICC_PROGRESS_CLASS = 32 ICC_HOTKEY_CLASS = 64 ICC_ANIMATE_CLASS = 128 ICC_WIN95_CLASSES = 255 ICC_DATE_CLASSES = 256 ICC_USEREX_CLASSES = 512 ICC_COOL_CLASSES = 1024 ICC_INTERNET_CLASSES = 2048 ICC_PAGESCROLLER_CLASS = 4096 ICC_NATIVEFNTCTL_CLASS = 8192 INFOTIPSIZE = 1024 ICC_STANDARD_CLASSES = 0x00004000 ICC_LINK_CLASS = 0x00008000 ) // Dialog Codes const ( DLGC_WANTARROWS = 0x0001 DLGC_WANTTAB = 0x0002 DLGC_WANTALLKEYS = 0x0004 DLGC_WANTMESSAGE = 0x0004 DLGC_HASSETSEL = 0x0008 DLGC_DEFPUSHBUTTON = 0x0010 DLGC_UNDEFPUSHBUTTON = 0x0020 DLGC_RADIOBUTTON = 0x0040 DLGC_WANTCHARS = 0x0080 DLGC_STATIC = 0x0100 DLGC_BUTTON = 0x2000 ) // Get/SetWindowWord/Long offsets for use with WC_DIALOG windows const ( DWL_MSGRESULT = 0 DWL_DLGPROC = 4 DWL_USER = 8 ) // Registry predefined keys const ( HKEY_CLASSES_ROOT HKEY = 0x80000000 HKEY_CURRENT_USER HKEY = 0x80000001 HKEY_LOCAL_MACHINE HKEY = 0x80000002 HKEY_USERS HKEY = 0x80000003 HKEY_PERFORMANCE_DATA HKEY = 0x80000004 HKEY_CURRENT_CONFIG HKEY = 0x80000005 HKEY_DYN_DATA HKEY = 0x80000006 ) // Registry Key Security and Access Rights const ( KEY_ALL_ACCESS = 0xF003F KEY_CREATE_SUB_KEY = 0x0004 KEY_ENUMERATE_SUB_KEYS = 0x0008 KEY_NOTIFY = 0x0010 KEY_QUERY_VALUE = 0x0001 KEY_SET_VALUE = 0x0002 KEY_READ = 0x20019 KEY_WRITE = 0x20006 ) const ( NFR_ANSI = 1 NFR_UNICODE = 2 NF_QUERY = 3 NF_REQUERY = 4 ) // Registry value types const ( RRF_RT_REG_NONE = 0x00000001 RRF_RT_REG_SZ = 0x00000002 RRF_RT_REG_EXPAND_SZ = 0x00000004 RRF_RT_REG_BINARY = 0x00000008 RRF_RT_REG_DWORD = 0x00000010 RRF_RT_REG_MULTI_SZ = 0x00000020 RRF_RT_REG_QWORD = 0x00000040 RRF_RT_DWORD = (RRF_RT_REG_BINARY | RRF_RT_REG_DWORD) RRF_RT_QWORD = (RRF_RT_REG_BINARY | RRF_RT_REG_QWORD) RRF_RT_ANY = 0x0000ffff RRF_NOEXPAND = 0x10000000 RRF_ZEROONFAILURE = 0x20000000 REG_PROCESS_APPKEY = 0x00000001 REG_MUI_STRING_TRUNCATE = 0x00000001 ) // PeekMessage wRemoveMsg value const ( PM_NOREMOVE = 0x000 PM_REMOVE = 0x001 PM_NOYIELD = 0x002 ) // ImageList flags const ( ILC_MASK = 0x00000001 ILC_COLOR = 0x00000000 ILC_COLORDDB = 0x000000FE ILC_COLOR4 = 0x00000004 ILC_COLOR8 = 0x00000008 ILC_COLOR16 = 0x00000010 ILC_COLOR24 = 0x00000018 ILC_COLOR32 = 0x00000020 ILC_PALETTE = 0x00000800 ILC_MIRROR = 0x00002000 ILC_PERITEMMIRROR = 0x00008000 ILC_ORIGINALSIZE = 0x00010000 ILC_HIGHQUALITYSCALE = 0x00020000 ) // Keystroke Message Flags const ( KF_EXTENDED = 0x0100 KF_DLGMODE = 0x0800 KF_MENUMODE = 0x1000 KF_ALTDOWN = 0x2000 KF_REPEAT = 0x4000 KF_UP = 0x8000 ) // Virtual-Key Codes const ( VK_LBUTTON = 0x01 VK_RBUTTON = 0x02 VK_CANCEL = 0x03 VK_MBUTTON = 0x04 VK_XBUTTON1 = 0x05 VK_XBUTTON2 = 0x06 VK_BACK = 0x08 VK_TAB = 0x09 VK_CLEAR = 0x0C VK_RETURN = 0x0D VK_SHIFT = 0x10 VK_CONTROL = 0x11 VK_MENU = 0x12 VK_PAUSE = 0x13 VK_CAPITAL = 0x14 VK_KANA = 0x15 VK_HANGEUL = 0x15 VK_HANGUL = 0x15 VK_JUNJA = 0x17 VK_FINAL = 0x18 VK_HANJA = 0x19 VK_KANJI = 0x19 VK_ESCAPE = 0x1B VK_CONVERT = 0x1C VK_NONCONVERT = 0x1D VK_ACCEPT = 0x1E VK_MODECHANGE = 0x1F VK_SPACE = 0x20 VK_PRIOR = 0x21 VK_NEXT = 0x22 VK_END = 0x23 VK_HOME = 0x24 VK_LEFT = 0x25 VK_UP = 0x26 VK_RIGHT = 0x27 VK_DOWN = 0x28 VK_SELECT = 0x29 VK_PRINT = 0x2A VK_EXECUTE = 0x2B VK_SNAPSHOT = 0x2C VK_INSERT = 0x2D VK_DELETE = 0x2E VK_HELP = 0x2F VK_LWIN = 0x5B VK_RWIN = 0x5C VK_APPS = 0x5D VK_SLEEP = 0x5F VK_NUMPAD0 = 0x60 VK_NUMPAD1 = 0x61 VK_NUMPAD2 = 0x62 VK_NUMPAD3 = 0x63 VK_NUMPAD4 = 0x64 VK_NUMPAD5 = 0x65 VK_NUMPAD6 = 0x66 VK_NUMPAD7 = 0x67 VK_NUMPAD8 = 0x68 VK_NUMPAD9 = 0x69 VK_MULTIPLY = 0x6A VK_ADD = 0x6B VK_SEPARATOR = 0x6C VK_SUBTRACT = 0x6D VK_DECIMAL = 0x6E VK_DIVIDE = 0x6F VK_F1 = 0x70 VK_F2 = 0x71 VK_F3 = 0x72 VK_F4 = 0x73 VK_F5 = 0x74 VK_F6 = 0x75 VK_F7 = 0x76 VK_F8 = 0x77 VK_F9 = 0x78 VK_F10 = 0x79 VK_F11 = 0x7A VK_F12 = 0x7B VK_F13 = 0x7C VK_F14 = 0x7D VK_F15 = 0x7E VK_F16 = 0x7F VK_F17 = 0x80 VK_F18 = 0x81 VK_F19 = 0x82 VK_F20 = 0x83 VK_F21 = 0x84 VK_F22 = 0x85 VK_F23 = 0x86 VK_F24 = 0x87 VK_NUMLOCK = 0x90 VK_SCROLL = 0x91 VK_OEM_NEC_EQUAL = 0x92 VK_OEM_FJ_JISHO = 0x92 VK_OEM_FJ_MASSHOU = 0x93 VK_OEM_FJ_TOUROKU = 0x94 VK_OEM_FJ_LOYA = 0x95 VK_OEM_FJ_ROYA = 0x96 VK_LSHIFT = 0xA0 VK_RSHIFT = 0xA1 VK_LCONTROL = 0xA2 VK_RCONTROL = 0xA3 VK_LMENU = 0xA4 VK_RMENU = 0xA5 VK_BROWSER_BACK = 0xA6 VK_BROWSER_FORWARD = 0xA7 VK_BROWSER_REFRESH = 0xA8 VK_BROWSER_STOP = 0xA9 VK_BROWSER_SEARCH = 0xAA VK_BROWSER_FAVORITES = 0xAB VK_BROWSER_HOME = 0xAC VK_VOLUME_MUTE = 0xAD VK_VOLUME_DOWN = 0xAE VK_VOLUME_UP = 0xAF VK_MEDIA_NEXT_TRACK = 0xB0 VK_MEDIA_PREV_TRACK = 0xB1 VK_MEDIA_STOP = 0xB2 VK_MEDIA_PLAY_PAUSE = 0xB3 VK_LAUNCH_MAIL = 0xB4 VK_LAUNCH_MEDIA_SELECT = 0xB5 VK_LAUNCH_APP1 = 0xB6 VK_LAUNCH_APP2 = 0xB7 VK_OEM_1 = 0xBA VK_OEM_PLUS = 0xBB VK_OEM_COMMA = 0xBC VK_OEM_MINUS = 0xBD VK_OEM_PERIOD = 0xBE VK_OEM_2 = 0xBF VK_OEM_3 = 0xC0 VK_OEM_4 = 0xDB VK_OEM_5 = 0xDC VK_OEM_6 = 0xDD VK_OEM_7 = 0xDE VK_OEM_8 = 0xDF VK_OEM_AX = 0xE1 VK_OEM_102 = 0xE2 VK_ICO_HELP = 0xE3 VK_ICO_00 = 0xE4 VK_PROCESSKEY = 0xE5 VK_ICO_CLEAR = 0xE6 VK_OEM_RESET = 0xE9 VK_OEM_JUMP = 0xEA VK_OEM_PA1 = 0xEB VK_OEM_PA2 = 0xEC VK_OEM_PA3 = 0xED VK_OEM_WSCTRL = 0xEE VK_OEM_CUSEL = 0xEF VK_OEM_ATTN = 0xF0 VK_OEM_FINISH = 0xF1 VK_OEM_COPY = 0xF2 VK_OEM_AUTO = 0xF3 VK_OEM_ENLW = 0xF4 VK_OEM_BACKTAB = 0xF5 VK_ATTN = 0xF6 VK_CRSEL = 0xF7 VK_EXSEL = 0xF8 VK_EREOF = 0xF9 VK_PLAY = 0xFA VK_ZOOM = 0xFB VK_NONAME = 0xFC VK_PA1 = 0xFD VK_OEM_CLEAR = 0xFE ) // Registry Value Types const ( REG_NONE = 0 REG_SZ = 1 REG_EXPAND_SZ = 2 REG_BINARY = 3 REG_DWORD = 4 REG_DWORD_LITTLE_ENDIAN = 4 REG_DWORD_BIG_ENDIAN = 5 REG_LINK = 6 REG_MULTI_SZ = 7 REG_RESOURCE_LIST = 8 REG_FULL_RESOURCE_DESCRIPTOR = 9 REG_RESOURCE_REQUIREMENTS_LIST = 10 REG_QWORD = 11 REG_QWORD_LITTLE_ENDIAN = 11 ) // Tooltip styles const ( TTS_ALWAYSTIP = 0x01 TTS_NOPREFIX = 0x02 TTS_NOANIMATE = 0x10 TTS_NOFADE = 0x20 TTS_BALLOON = 0x40 TTS_CLOSE = 0x80 TTS_USEVISUALSTYLE = 0x100 ) // Tooltip messages const ( TTM_ACTIVATE = (WM_USER + 1) TTM_SETDELAYTIME = (WM_USER + 3) TTM_ADDTOOL = (WM_USER + 50) TTM_DELTOOL = (WM_USER + 51) TTM_NEWTOOLRECT = (WM_USER + 52) TTM_RELAYEVENT = (WM_USER + 7) TTM_GETTOOLINFO = (WM_USER + 53) TTM_SETTOOLINFO = (WM_USER + 54) TTM_HITTEST = (WM_USER + 55) TTM_GETTEXT = (WM_USER + 56) TTM_UPDATETIPTEXT = (WM_USER + 57) TTM_GETTOOLCOUNT = (WM_USER + 13) TTM_ENUMTOOLS = (WM_USER + 58) TTM_GETCURRENTTOOL = (WM_USER + 59) TTM_WINDOWFROMPOINT = (WM_USER + 16) TTM_TRACKACTIVATE = (WM_USER + 17) TTM_TRACKPOSITION = (WM_USER + 18) TTM_SETTIPBKCOLOR = (WM_USER + 19) TTM_SETTIPTEXTCOLOR = (WM_USER + 20) TTM_GETDELAYTIME = (WM_USER + 21) TTM_GETTIPBKCOLOR = (WM_USER + 22) TTM_GETTIPTEXTCOLOR = (WM_USER + 23) TTM_SETMAXTIPWIDTH = (WM_USER + 24) TTM_GETMAXTIPWIDTH = (WM_USER + 25) TTM_SETMARGIN = (WM_USER + 26) TTM_GETMARGIN = (WM_USER + 27) TTM_POP = (WM_USER + 28) TTM_UPDATE = (WM_USER + 29) TTM_GETBUBBLESIZE = (WM_USER + 30) TTM_ADJUSTRECT = (WM_USER + 31) TTM_SETTITLE = (WM_USER + 33) TTM_POPUP = (WM_USER + 34) TTM_GETTITLE = (WM_USER + 35) ) // Tooltip icons const ( TTI_NONE = 0 TTI_INFO = 1 TTI_WARNING = 2 TTI_ERROR = 3 TTI_INFO_LARGE = 4 TTI_WARNING_LARGE = 5 TTI_ERROR_LARGE = 6 ) // Tooltip notifications const ( TTN_FIRST = -520 TTN_LAST = -549 TTN_GETDISPINFO = (TTN_FIRST - 10) TTN_SHOW = (TTN_FIRST - 1) TTN_POP = (TTN_FIRST - 2) TTN_LINKCLICK = (TTN_FIRST - 3) TTN_NEEDTEXT = TTN_GETDISPINFO ) const ( TTF_IDISHWND = 0x0001 TTF_CENTERTIP = 0x0002 TTF_RTLREADING = 0x0004 TTF_SUBCLASS = 0x0010 TTF_TRACK = 0x0020 TTF_ABSOLUTE = 0x0080 TTF_TRANSPARENT = 0x0100 TTF_PARSELINKS = 0x1000 TTF_DI_SETITEM = 0x8000 ) const ( SWP_NOSIZE = 0x0001 SWP_NOMOVE = 0x0002 SWP_NOZORDER = 0x0004 SWP_NOREDRAW = 0x0008 SWP_NOACTIVATE = 0x0010 SWP_FRAMECHANGED = 0x0020 SWP_SHOWWINDOW = 0x0040 SWP_HIDEWINDOW = 0x0080 SWP_NOCOPYBITS = 0x0100 SWP_NOOWNERZORDER = 0x0200 SWP_NOSENDCHANGING = 0x0400 SWP_DRAWFRAME = SWP_FRAMECHANGED SWP_NOREPOSITION = SWP_NOOWNERZORDER SWP_DEFERERASE = 0x2000 SWP_ASYNCWINDOWPOS = 0x4000 ) // Predefined window handles const ( HWND_BROADCAST = HWND(0xFFFF) HWND_BOTTOM = HWND(1) HWND_NOTOPMOST = ^HWND(1) // -2 HWND_TOP = HWND(0) HWND_TOPMOST = ^HWND(0) // -1 HWND_DESKTOP = HWND(0) HWND_MESSAGE = ^HWND(2) // -3 ) // Pen types const ( PS_COSMETIC = 0x00000000 PS_GEOMETRIC = 0x00010000 PS_TYPE_MASK = 0x000F0000 ) // Pen styles const ( PS_SOLID = 0 PS_DASH = 1 PS_DOT = 2 PS_DASHDOT = 3 PS_DASHDOTDOT = 4 PS_NULL = 5 PS_INSIDEFRAME = 6 PS_USERSTYLE = 7 PS_ALTERNATE = 8 PS_STYLE_MASK = 0x0000000F ) // Pen cap types const ( PS_ENDCAP_ROUND = 0x00000000 PS_ENDCAP_SQUARE = 0x00000100 PS_ENDCAP_FLAT = 0x00000200 PS_ENDCAP_MASK = 0x00000F00 ) // Pen join types const ( PS_JOIN_ROUND = 0x00000000 PS_JOIN_BEVEL = 0x00001000 PS_JOIN_MITER = 0x00002000 PS_JOIN_MASK = 0x0000F000 ) // Hatch styles const ( HS_HORIZONTAL = 0 HS_VERTICAL = 1 HS_FDIAGONAL = 2 HS_BDIAGONAL = 3 HS_CROSS = 4 HS_DIAGCROSS = 5 ) // Stock Logical Objects const ( WHITE_BRUSH = 0 LTGRAY_BRUSH = 1 GRAY_BRUSH = 2 DKGRAY_BRUSH = 3 BLACK_BRUSH = 4 NULL_BRUSH = 5 HOLLOW_BRUSH = NULL_BRUSH WHITE_PEN = 6 BLACK_PEN = 7 NULL_PEN = 8 OEM_FIXED_FONT = 10 ANSI_FIXED_FONT = 11 ANSI_VAR_FONT = 12 SYSTEM_FONT = 13 DEVICE_DEFAULT_FONT = 14 DEFAULT_PALETTE = 15 SYSTEM_FIXED_FONT = 16 DEFAULT_GUI_FONT = 17 DC_BRUSH = 18 DC_PEN = 19 ) // Brush styles const ( BS_SOLID = 0 BS_NULL = 1 BS_HOLLOW = BS_NULL BS_HATCHED = 2 BS_PATTERN = 3 BS_INDEXED = 4 BS_DIBPATTERN = 5 BS_DIBPATTERNPT = 6 BS_PATTERN8X8 = 7 BS_DIBPATTERN8X8 = 8 BS_MONOPATTERN = 9 ) // TRACKMOUSEEVENT flags const ( TME_HOVER = 0x00000001 TME_LEAVE = 0x00000002 TME_NONCLIENT = 0x00000010 TME_QUERY = 0x40000000 TME_CANCEL = 0x80000000 HOVER_DEFAULT = 0xFFFFFFFF ) // WM_NCHITTEST and MOUSEHOOKSTRUCT Mouse Position Codes const ( HTERROR = (-2) HTTRANSPARENT = (-1) HTNOWHERE = 0 HTCLIENT = 1 HTCAPTION = 2 HTSYSMENU = 3 HTGROWBOX = 4 HTSIZE = HTGROWBOX HTMENU = 5 HTHSCROLL = 6 HTVSCROLL = 7 HTMINBUTTON = 8 HTMAXBUTTON = 9 HTLEFT = 10 HTRIGHT = 11 HTTOP = 12 HTTOPLEFT = 13 HTTOPRIGHT = 14 HTBOTTOM = 15 HTBOTTOMLEFT = 16 HTBOTTOMRIGHT = 17 HTBORDER = 18 HTREDUCE = HTMINBUTTON HTZOOM = HTMAXBUTTON HTSIZEFIRST = HTLEFT HTSIZELAST = HTBOTTOMRIGHT HTOBJECT = 19 HTCLOSE = 20 HTHELP = 21 ) // DrawText[Ex] format flags const ( DT_TOP = 0x00000000 DT_LEFT = 0x00000000 DT_CENTER = 0x00000001 DT_RIGHT = 0x00000002 DT_VCENTER = 0x00000004 DT_BOTTOM = 0x00000008 DT_WORDBREAK = 0x00000010 DT_SINGLELINE = 0x00000020 DT_EXPANDTABS = 0x00000040 DT_TABSTOP = 0x00000080 DT_NOCLIP = 0x00000100 DT_EXTERNALLEADING = 0x00000200 DT_CALCRECT = 0x00000400 DT_NOPREFIX = 0x00000800 DT_INTERNAL = 0x00001000 DT_EDITCONTROL = 0x00002000 DT_PATH_ELLIPSIS = 0x00004000 DT_END_ELLIPSIS = 0x00008000 DT_MODIFYSTRING = 0x00010000 DT_RTLREADING = 0x00020000 DT_WORD_ELLIPSIS = 0x00040000 DT_NOFULLWIDTHCHARBREAK = 0x00080000 DT_HIDEPREFIX = 0x00100000 DT_PREFIXONLY = 0x00200000 ) const CLR_INVALID = 0xFFFFFFFF // Background Modes const ( TRANSPARENT = 1 OPAQUE = 2 BKMODE_LAST = 2 ) // Global Memory Flags const ( GMEM_FIXED = 0x0000 GMEM_MOVEABLE = 0x0002 GMEM_NOCOMPACT = 0x0010 GMEM_NODISCARD = 0x0020 GMEM_ZEROINIT = 0x0040 GMEM_MODIFY = 0x0080 GMEM_DISCARDABLE = 0x0100 GMEM_NOT_BANKED = 0x1000 GMEM_SHARE = 0x2000 GMEM_DDESHARE = 0x2000 GMEM_NOTIFY = 0x4000 GMEM_LOWER = GMEM_NOT_BANKED GMEM_VALID_FLAGS = 0x7F72 GMEM_INVALID_HANDLE = 0x8000 GHND = (GMEM_MOVEABLE | GMEM_ZEROINIT) GPTR = (GMEM_FIXED | GMEM_ZEROINIT) ) // Ternary raster operations const ( SRCCOPY = 0x00CC0020 SRCPAINT = 0x00EE0086 SRCAND = 0x008800C6 SRCINVERT = 0x00660046 SRCERASE = 0x00440328 NOTSRCCOPY = 0x00330008 NOTSRCERASE = 0x001100A6 MERGECOPY = 0x00C000CA MERGEPAINT = 0x00BB0226 PATCOPY = 0x00F00021 PATPAINT = 0x00FB0A09 PATINVERT = 0x005A0049 DSTINVERT = 0x00550009 BLACKNESS = 0x00000042 WHITENESS = 0x00FF0062 NOMIRRORBITMAP = 0x80000000 CAPTUREBLT = 0x40000000 ) // Clipboard formats const ( CF_TEXT = 1 CF_BITMAP = 2 CF_METAFILEPICT = 3 CF_SYLK = 4 CF_DIF = 5 CF_TIFF = 6 CF_OEMTEXT = 7 CF_DIB = 8 CF_PALETTE = 9 CF_PENDATA = 10 CF_RIFF = 11 CF_WAVE = 12 CF_UNICODETEXT = 13 CF_ENHMETAFILE = 14 CF_HDROP = 15 CF_LOCALE = 16 CF_DIBV5 = 17 CF_MAX = 18 CF_OWNERDISPLAY = 0x0080 CF_DSPTEXT = 0x0081 CF_DSPBITMAP = 0x0082 CF_DSPMETAFILEPICT = 0x0083 CF_DSPENHMETAFILE = 0x008E CF_PRIVATEFIRST = 0x0200 CF_PRIVATELAST = 0x02FF CF_GDIOBJFIRST = 0x0300 CF_GDIOBJLAST = 0x03FF ) // Bitmap compression formats const ( BI_RGB = 0 BI_RLE8 = 1 BI_RLE4 = 2 BI_BITFIELDS = 3 BI_JPEG = 4 BI_PNG = 5 ) // SetDIBitsToDevice fuColorUse const ( DIB_PAL_COLORS = 1 DIB_RGB_COLORS = 0 ) const ( STANDARD_RIGHTS_REQUIRED = 0x000F ) // Service Control Manager object specific access types const ( SC_MANAGER_CONNECT = 0x0001 SC_MANAGER_CREATE_SERVICE = 0x0002 SC_MANAGER_ENUMERATE_SERVICE = 0x0004 SC_MANAGER_LOCK = 0x0008 SC_MANAGER_QUERY_LOCK_STATUS = 0x0010 SC_MANAGER_MODIFY_BOOT_CONFIG = 0x0020 SC_MANAGER_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SC_MANAGER_CONNECT | SC_MANAGER_CREATE_SERVICE | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_LOCK | SC_MANAGER_QUERY_LOCK_STATUS | SC_MANAGER_MODIFY_BOOT_CONFIG ) // Service Types (Bit Mask) const ( SERVICE_KERNEL_DRIVER = 0x00000001 SERVICE_FILE_SYSTEM_DRIVER = 0x00000002 SERVICE_ADAPTER = 0x00000004 SERVICE_RECOGNIZER_DRIVER = 0x00000008 SERVICE_DRIVER = SERVICE_KERNEL_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_RECOGNIZER_DRIVER SERVICE_WIN32_OWN_PROCESS = 0x00000010 SERVICE_WIN32_SHARE_PROCESS = 0x00000020 SERVICE_WIN32 = SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS SERVICE_INTERACTIVE_PROCESS = 0x00000100 SERVICE_TYPE_ALL = SERVICE_WIN32 | SERVICE_ADAPTER | SERVICE_DRIVER | SERVICE_INTERACTIVE_PROCESS ) // Service State -- for CurrentState const ( SERVICE_STOPPED = 0x00000001 SERVICE_START_PENDING = 0x00000002 SERVICE_STOP_PENDING = 0x00000003 SERVICE_RUNNING = 0x00000004 SERVICE_CONTINUE_PENDING = 0x00000005 SERVICE_PAUSE_PENDING = 0x00000006 SERVICE_PAUSED = 0x00000007 ) // Controls Accepted (Bit Mask) const ( SERVICE_ACCEPT_STOP = 0x00000001 SERVICE_ACCEPT_PAUSE_CONTINUE = 0x00000002 SERVICE_ACCEPT_SHUTDOWN = 0x00000004 SERVICE_ACCEPT_PARAMCHANGE = 0x00000008 SERVICE_ACCEPT_NETBINDCHANGE = 0x00000010 SERVICE_ACCEPT_HARDWAREPROFILECHANGE = 0x00000020 SERVICE_ACCEPT_POWEREVENT = 0x00000040 SERVICE_ACCEPT_SESSIONCHANGE = 0x00000080 SERVICE_ACCEPT_PRESHUTDOWN = 0x00000100 SERVICE_ACCEPT_TIMECHANGE = 0x00000200 SERVICE_ACCEPT_TRIGGEREVENT = 0x00000400 ) // Service object specific access type const ( SERVICE_QUERY_CONFIG = 0x0001 SERVICE_CHANGE_CONFIG = 0x0002 SERVICE_QUERY_STATUS = 0x0004 SERVICE_ENUMERATE_DEPENDENTS = 0x0008 SERVICE_START = 0x0010 SERVICE_STOP = 0x0020 SERVICE_PAUSE_CONTINUE = 0x0040 SERVICE_INTERROGATE = 0x0080 SERVICE_USER_DEFINED_CONTROL = 0x0100 SERVICE_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_INTERROGATE | SERVICE_USER_DEFINED_CONTROL ) // MapVirtualKey maptypes const ( MAPVK_VK_TO_CHAR = 2 MAPVK_VK_TO_VSC = 0 MAPVK_VSC_TO_VK = 1 MAPVK_VSC_TO_VK_EX = 3 ) // ReadEventLog Flags const ( EVENTLOG_SEEK_READ = 0x0002 EVENTLOG_SEQUENTIAL_READ = 0x0001 EVENTLOG_FORWARDS_READ = 0x0004 EVENTLOG_BACKWARDS_READ = 0x0008 ) // CreateToolhelp32Snapshot flags const ( TH32CS_SNAPHEAPLIST = 0x00000001 TH32CS_SNAPPROCESS = 0x00000002 TH32CS_SNAPTHREAD = 0x00000004 TH32CS_SNAPMODULE = 0x00000008 TH32CS_SNAPMODULE32 = 0x00000010 TH32CS_INHERIT = 0x80000000 TH32CS_SNAPALL = TH32CS_SNAPHEAPLIST | TH32CS_SNAPMODULE | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD ) const ( MAX_MODULE_NAME32 = 255 MAX_PATH = 260 ) const ( FOREGROUND_BLUE = 0x0001 FOREGROUND_GREEN = 0x0002 FOREGROUND_RED = 0x0004 FOREGROUND_INTENSITY = 0x0008 BACKGROUND_BLUE = 0x0010 BACKGROUND_GREEN = 0x0020 BACKGROUND_RED = 0x0040 BACKGROUND_INTENSITY = 0x0080 COMMON_LVB_LEADING_BYTE = 0x0100 COMMON_LVB_TRAILING_BYTE = 0x0200 COMMON_LVB_GRID_HORIZONTAL = 0x0400 COMMON_LVB_GRID_LVERTICAL = 0x0800 COMMON_LVB_GRID_RVERTICAL = 0x1000 COMMON_LVB_REVERSE_VIDEO = 0x4000 COMMON_LVB_UNDERSCORE = 0x8000 ) // Flags used by the DWM_BLURBEHIND structure to indicate // which of its members contain valid information. const ( DWM_BB_ENABLE = 0x00000001 // A value for the fEnable member has been specified. DWM_BB_BLURREGION = 0x00000002 // A value for the hRgnBlur member has been specified. DWM_BB_TRANSITIONONMAXIMIZED = 0x00000004 // A value for the fTransitionOnMaximized member has been specified. ) // Flags used by the DwmEnableComposition function // to change the state of Desktop Window Manager (DWM) composition. const ( DWM_EC_DISABLECOMPOSITION = 0 // Disable composition DWM_EC_ENABLECOMPOSITION = 1 // Enable composition ) // enum-lite implementation for the following constant structure type DWM_SHOWCONTACT int32 const ( DWMSC_DOWN = 0x00000001 DWMSC_UP = 0x00000002 DWMSC_DRAG = 0x00000004 DWMSC_HOLD = 0x00000008 DWMSC_PENBARREL = 0x00000010 DWMSC_NONE = 0x00000000 DWMSC_ALL = 0xFFFFFFFF ) // enum-lite implementation for the following constant structure type DWM_SOURCE_FRAME_SAMPLING int32 // TODO: need to verify this construction // Flags used by the DwmSetPresentParameters function // to specify the frame sampling type const ( DWM_SOURCE_FRAME_SAMPLING_POINT = iota + 1 DWM_SOURCE_FRAME_SAMPLING_COVERAGE DWM_SOURCE_FRAME_SAMPLING_LAST ) // Flags used by the DWM_THUMBNAIL_PROPERTIES structure to // indicate which of its members contain valid information. const ( DWM_TNP_RECTDESTINATION = 0x00000001 // A value for the rcDestination member has been specified DWM_TNP_RECTSOURCE = 0x00000002 // A value for the rcSource member has been specified DWM_TNP_OPACITY = 0x00000004 // A value for the opacity member has been specified DWM_TNP_VISIBLE = 0x00000008 // A value for the fVisible member has been specified DWM_TNP_SOURCECLIENTAREAONLY = 0x00000010 // A value for the fSourceClientAreaOnly member has been specified ) // enum-lite implementation for the following constant structure type DWMFLIP3DWINDOWPOLICY int32 // TODO: need to verify this construction // Flags used by the DwmSetWindowAttribute function // to specify the Flip3D window policy const ( DWMFLIP3D_DEFAULT = iota + 1 DWMFLIP3D_EXCLUDEBELOW DWMFLIP3D_EXCLUDEABOVE DWMFLIP3D_LAST ) // enum-lite implementation for the following constant structure type DWMNCRENDERINGPOLICY int32 // TODO: need to verify this construction // Flags used by the DwmSetWindowAttribute function // to specify the non-client area rendering policy const ( DWMNCRP_USEWINDOWSTYLE = iota + 1 DWMNCRP_DISABLED DWMNCRP_ENABLED DWMNCRP_LAST ) // enum-lite implementation for the following constant structure type DWMTRANSITION_OWNEDWINDOW_TARGET int32 const ( DWMTRANSITION_OWNEDWINDOW_NULL = -1 DWMTRANSITION_OWNEDWINDOW_REPOSITION = 0 ) // enum-lite implementation for the following constant structure type DWMWINDOWATTRIBUTE int32 // TODO: need to verify this construction // Flags used by the DwmGetWindowAttribute and DwmSetWindowAttribute functions // to specify window attributes for non-client rendering const ( DWMWA_NCRENDERING_ENABLED = iota + 1 DWMWA_NCRENDERING_POLICY DWMWA_TRANSITIONS_FORCEDISABLED DWMWA_ALLOW_NCPAINT DWMWA_CAPTION_BUTTON_BOUNDS DWMWA_NONCLIENT_RTL_LAYOUT DWMWA_FORCE_ICONIC_REPRESENTATION DWMWA_FLIP3D_POLICY DWMWA_EXTENDED_FRAME_BOUNDS DWMWA_HAS_ICONIC_BITMAP DWMWA_DISALLOW_PEEK DWMWA_EXCLUDED_FROM_PEEK DWMWA_CLOAK DWMWA_CLOAKED DWMWA_FREEZE_REPRESENTATION DWMWA_LAST ) // enum-lite implementation for the following constant structure type GESTURE_TYPE int32 // TODO: use iota? // Identifies the gesture type const ( GT_PEN_TAP = 0 GT_PEN_DOUBLETAP = 1 GT_PEN_RIGHTTAP = 2 GT_PEN_PRESSANDHOLD = 3 GT_PEN_PRESSANDHOLDABORT = 4 GT_TOUCH_TAP = 5 GT_TOUCH_DOUBLETAP = 6 GT_TOUCH_RIGHTTAP = 7 GT_TOUCH_PRESSANDHOLD = 8 GT_TOUCH_PRESSANDHOLDABORT = 9 GT_TOUCH_PRESSANDTAP = 10 ) // Icons const ( ICON_SMALL = 0 ICON_BIG = 1 ICON_SMALL2 = 2 ) const ( SIZE_RESTORED = 0 SIZE_MINIMIZED = 1 SIZE_MAXIMIZED = 2 SIZE_MAXSHOW = 3 SIZE_MAXHIDE = 4 ) // XButton values const ( XBUTTON1 = 1 XBUTTON2 = 2 ) // Devmode const ( DM_SPECVERSION = 0x0401 DM_ORIENTATION = 0x00000001 DM_PAPERSIZE = 0x00000002 DM_PAPERLENGTH = 0x00000004 DM_PAPERWIDTH = 0x00000008 DM_SCALE = 0x00000010 DM_POSITION = 0x00000020 DM_NUP = 0x00000040 DM_DISPLAYORIENTATION = 0x00000080 DM_COPIES = 0x00000100 DM_DEFAULTSOURCE = 0x00000200 DM_PRINTQUALITY = 0x00000400 DM_COLOR = 0x00000800 DM_DUPLEX = 0x00001000 DM_YRESOLUTION = 0x00002000 DM_TTOPTION = 0x00004000 DM_COLLATE = 0x00008000 DM_FORMNAME = 0x00010000 DM_LOGPIXELS = 0x00020000 DM_BITSPERPEL = 0x00040000 DM_PELSWIDTH = 0x00080000 DM_PELSHEIGHT = 0x00100000 DM_DISPLAYFLAGS = 0x00200000 DM_DISPLAYFREQUENCY = 0x00400000 DM_ICMMETHOD = 0x00800000 DM_ICMINTENT = 0x01000000 DM_MEDIATYPE = 0x02000000 DM_DITHERTYPE = 0x04000000 DM_PANNINGWIDTH = 0x08000000 DM_PANNINGHEIGHT = 0x10000000 DM_DISPLAYFIXEDOUTPUT = 0x20000000 ) // ChangeDisplaySettings const ( CDS_UPDATEREGISTRY = 0x00000001 CDS_TEST = 0x00000002 CDS_FULLSCREEN = 0x00000004 CDS_GLOBAL = 0x00000008 CDS_SET_PRIMARY = 0x00000010 CDS_VIDEOPARAMETERS = 0x00000020 CDS_RESET = 0x40000000 CDS_NORESET = 0x10000000 DISP_CHANGE_SUCCESSFUL = 0 DISP_CHANGE_RESTART = 1 DISP_CHANGE_FAILED = -1 DISP_CHANGE_BADMODE = -2 DISP_CHANGE_NOTUPDATED = -3 DISP_CHANGE_BADFLAGS = -4 DISP_CHANGE_BADPARAM = -5 DISP_CHANGE_BADDUALVIEW = -6 ) const ( ENUM_CURRENT_SETTINGS = 0xFFFFFFFF ENUM_REGISTRY_SETTINGS = 0xFFFFFFFE ) // PIXELFORMATDESCRIPTOR const ( PFD_TYPE_RGBA = 0 PFD_TYPE_COLORINDEX = 1 PFD_MAIN_PLANE = 0 PFD_OVERLAY_PLANE = 1 PFD_UNDERLAY_PLANE = -1 PFD_DOUBLEBUFFER = 0x00000001 PFD_STEREO = 0x00000002 PFD_DRAW_TO_WINDOW = 0x00000004 PFD_DRAW_TO_BITMAP = 0x00000008 PFD_SUPPORT_GDI = 0x00000010 PFD_SUPPORT_OPENGL = 0x00000020 PFD_GENERIC_FORMAT = 0x00000040 PFD_NEED_PALETTE = 0x00000080 PFD_NEED_SYSTEM_PALETTE = 0x00000100 PFD_SWAP_EXCHANGE = 0x00000200 PFD_SWAP_COPY = 0x00000400 PFD_SWAP_LAYER_BUFFERS = 0x00000800 PFD_GENERIC_ACCELERATED = 0x00001000 PFD_SUPPORT_DIRECTDRAW = 0x00002000 PFD_DIRECT3D_ACCELERATED = 0x00004000 PFD_SUPPORT_COMPOSITION = 0x00008000 PFD_DEPTH_DONTCARE = 0x20000000 PFD_DOUBLEBUFFER_DONTCARE = 0x40000000 PFD_STEREO_DONTCARE = 0x80000000 ) const ( INPUT_MOUSE = 0 INPUT_KEYBOARD = 1 INPUT_HARDWARE = 2 ) const ( MOUSEEVENTF_ABSOLUTE = 0x8000 MOUSEEVENTF_HWHEEL = 0x01000 MOUSEEVENTF_MOVE = 0x0001 MOUSEEVENTF_MOVE_NOCOALESCE = 0x2000 MOUSEEVENTF_LEFTDOWN = 0x0002 MOUSEEVENTF_LEFTUP = 0x0004 MOUSEEVENTF_RIGHTDOWN = 0x0008 MOUSEEVENTF_RIGHTUP = 0x0010 MOUSEEVENTF_MIDDLEDOWN = 0x0020 MOUSEEVENTF_MIDDLEUP = 0x0040 MOUSEEVENTF_VIRTUALDESK = 0x4000 MOUSEEVENTF_WHEEL = 0x0800 MOUSEEVENTF_XDOWN = 0x0080 MOUSEEVENTF_XUP = 0x0100 ) ================================================ FILE: vendor/github.com/shirou/w32/dwmapi.go ================================================ // 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 ( "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) } ================================================ FILE: vendor/github.com/shirou/w32/gdi32.go ================================================ // 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 ( "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 } ================================================ FILE: vendor/github.com/shirou/w32/gdiplus.go ================================================ // 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 ( "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))) } } ================================================ FILE: vendor/github.com/shirou/w32/idispatch.go ================================================ // 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" ) 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...) } ================================================ FILE: vendor/github.com/shirou/w32/istream.go ================================================ // 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" ) 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))) } ================================================ FILE: vendor/github.com/shirou/w32/iunknown.go ================================================ // 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 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) } ================================================ FILE: vendor/github.com/shirou/w32/kernel32.go ================================================ // 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 ( "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 } ================================================ FILE: vendor/github.com/shirou/w32/ole32.go ================================================ // 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 ( "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 } ================================================ FILE: vendor/github.com/shirou/w32/oleaut32.go ================================================ // 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 ( "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) } ================================================ FILE: vendor/github.com/shirou/w32/opengl32.go ================================================ // 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 ( "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 } ================================================ FILE: vendor/github.com/shirou/w32/psapi.go ================================================ // 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 ( "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 } ================================================ FILE: vendor/github.com/shirou/w32/shell32.go ================================================ // 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 ( "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) } ================================================ FILE: vendor/github.com/shirou/w32/typedef.go ================================================ // 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 } ================================================ FILE: vendor/github.com/shirou/w32/user32.go ================================================ // 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 ( "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) } */ ================================================ FILE: vendor/github.com/shirou/w32/utils.go ================================================ // 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 ( "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 } ================================================ FILE: vendor/github.com/shirou/w32/vars.go ================================================ // 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}} ) ================================================ FILE: vendor.yml ================================================ vendors: - path: github.com/shirou/gopsutil rev: 3166d415382aa5bbd8bb151cc50a756730cd5ec4