aboutsummaryrefslogtreecommitdiffstats
path: root/vendor
diff options
context:
space:
mode:
Diffstat (limited to 'vendor')
-rw-r--r--vendor/github.com/StackExchange/wmi/LICENSE20
-rw-r--r--vendor/github.com/StackExchange/wmi/README.md6
-rw-r--r--vendor/github.com/StackExchange/wmi/swbemservices.go260
-rw-r--r--vendor/github.com/StackExchange/wmi/wmi.go486
-rw-r--r--vendor/github.com/elastic/gosigar/CHANGELOG.md102
-rw-r--r--vendor/github.com/elastic/gosigar/LICENSE201
-rw-r--r--vendor/github.com/elastic/gosigar/NOTICE9
-rw-r--r--vendor/github.com/elastic/gosigar/README.md57
-rw-r--r--vendor/github.com/elastic/gosigar/Vagrantfile25
-rw-r--r--vendor/github.com/elastic/gosigar/codecov.yml21
-rw-r--r--vendor/github.com/elastic/gosigar/concrete_sigar.go83
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_darwin.go494
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_format.go126
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_freebsd.go108
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_interface.go197
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_linux.go84
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_linux_common.go468
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_openbsd.go418
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_stub.go71
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_unix.go69
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_util.go22
-rw-r--r--vendor/github.com/elastic/gosigar/sigar_windows.go437
-rw-r--r--vendor/github.com/elastic/gosigar/sys/windows/doc.go2
-rw-r--r--vendor/github.com/elastic/gosigar/sys/windows/ntquery.go132
-rw-r--r--vendor/github.com/elastic/gosigar/sys/windows/privileges.go272
-rw-r--r--vendor/github.com/elastic/gosigar/sys/windows/syscall_windows.go385
-rw-r--r--vendor/github.com/elastic/gosigar/sys/windows/version.go43
-rw-r--r--vendor/github.com/elastic/gosigar/sys/windows/zsyscall_windows.go260
-rw-r--r--vendor/github.com/go-ole/go-ole/ChangeLog.md49
-rw-r--r--vendor/github.com/go-ole/go-ole/LICENSE21
-rw-r--r--vendor/github.com/go-ole/go-ole/README.md46
-rw-r--r--vendor/github.com/go-ole/go-ole/appveyor.yml54
-rw-r--r--vendor/github.com/go-ole/go-ole/com.go329
-rw-r--r--vendor/github.com/go-ole/go-ole/com_func.go174
-rw-r--r--vendor/github.com/go-ole/go-ole/connect.go192
-rw-r--r--vendor/github.com/go-ole/go-ole/constants.go153
-rw-r--r--vendor/github.com/go-ole/go-ole/error.go51
-rw-r--r--vendor/github.com/go-ole/go-ole/error_func.go8
-rw-r--r--vendor/github.com/go-ole/go-ole/error_windows.go24
-rw-r--r--vendor/github.com/go-ole/go-ole/guid.go284
-rw-r--r--vendor/github.com/go-ole/go-ole/iconnectionpoint.go20
-rw-r--r--vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go21
-rw-r--r--vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go43
-rw-r--r--vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go17
-rw-r--r--vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go11
-rw-r--r--vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go25
-rw-r--r--vendor/github.com/go-ole/go-ole/idispatch.go94
-rw-r--r--vendor/github.com/go-ole/go-ole/idispatch_func.go19
-rw-r--r--vendor/github.com/go-ole/go-ole/idispatch_windows.go197
-rw-r--r--vendor/github.com/go-ole/go-ole/ienumvariant.go19
-rw-r--r--vendor/github.com/go-ole/go-ole/ienumvariant_func.go19
-rw-r--r--vendor/github.com/go-ole/go-ole/ienumvariant_windows.go63
-rw-r--r--vendor/github.com/go-ole/go-ole/iinspectable.go18
-rw-r--r--vendor/github.com/go-ole/go-ole/iinspectable_func.go15
-rw-r--r--vendor/github.com/go-ole/go-ole/iinspectable_windows.go72
-rw-r--r--vendor/github.com/go-ole/go-ole/iprovideclassinfo.go21
-rw-r--r--vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go7
-rw-r--r--vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go21
-rw-r--r--vendor/github.com/go-ole/go-ole/itypeinfo.go34
-rw-r--r--vendor/github.com/go-ole/go-ole/itypeinfo_func.go7
-rw-r--r--vendor/github.com/go-ole/go-ole/itypeinfo_windows.go21
-rw-r--r--vendor/github.com/go-ole/go-ole/iunknown.go57
-rw-r--r--vendor/github.com/go-ole/go-ole/iunknown_func.go19
-rw-r--r--vendor/github.com/go-ole/go-ole/iunknown_windows.go58
-rw-r--r--vendor/github.com/go-ole/go-ole/ole.go157
-rw-r--r--vendor/github.com/go-ole/go-ole/oleutil/connection.go100
-rw-r--r--vendor/github.com/go-ole/go-ole/oleutil/connection_func.go10
-rw-r--r--vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go58
-rw-r--r--vendor/github.com/go-ole/go-ole/oleutil/go-get.go6
-rw-r--r--vendor/github.com/go-ole/go-ole/oleutil/oleutil.go127
-rw-r--r--vendor/github.com/go-ole/go-ole/safearray.go27
-rw-r--r--vendor/github.com/go-ole/go-ole/safearray_func.go211
-rw-r--r--vendor/github.com/go-ole/go-ole/safearray_windows.go337
-rw-r--r--vendor/github.com/go-ole/go-ole/safearrayconversion.go140
-rw-r--r--vendor/github.com/go-ole/go-ole/safearrayslices.go33
-rw-r--r--vendor/github.com/go-ole/go-ole/utility.go101
-rw-r--r--vendor/github.com/go-ole/go-ole/variables.go16
-rw-r--r--vendor/github.com/go-ole/go-ole/variant.go105
-rw-r--r--vendor/github.com/go-ole/go-ole/variant_386.go11
-rw-r--r--vendor/github.com/go-ole/go-ole/variant_amd64.go12
-rw-r--r--vendor/github.com/go-ole/go-ole/variant_s390x.go12
-rw-r--r--vendor/github.com/go-ole/go-ole/vt_string.go58
-rw-r--r--vendor/github.com/go-ole/go-ole/winrt.go99
-rw-r--r--vendor/github.com/go-ole/go-ole/winrt_doc.go36
-rw-r--r--vendor/github.com/pkg/errors/LICENSE23
-rw-r--r--vendor/github.com/pkg/errors/README.md52
-rw-r--r--vendor/github.com/pkg/errors/appveyor.yml32
-rw-r--r--vendor/github.com/pkg/errors/errors.go269
-rw-r--r--vendor/github.com/pkg/errors/stack.go187
-rw-r--r--vendor/vendor.json36
90 files changed, 9396 insertions, 0 deletions
diff --git a/vendor/github.com/StackExchange/wmi/LICENSE b/vendor/github.com/StackExchange/wmi/LICENSE
new file mode 100644
index 000000000..ae80b6720
--- /dev/null
+++ b/vendor/github.com/StackExchange/wmi/LICENSE
@@ -0,0 +1,20 @@
+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.
diff --git a/vendor/github.com/StackExchange/wmi/README.md b/vendor/github.com/StackExchange/wmi/README.md
new file mode 100644
index 000000000..426d1a46b
--- /dev/null
+++ b/vendor/github.com/StackExchange/wmi/README.md
@@ -0,0 +1,6 @@
+wmi
+===
+
+Package wmi provides a WQL interface to Windows WMI.
+
+Note: It interfaces with WMI on the local machine, therefore it only runs on Windows.
diff --git a/vendor/github.com/StackExchange/wmi/swbemservices.go b/vendor/github.com/StackExchange/wmi/swbemservices.go
new file mode 100644
index 000000000..9765a53f7
--- /dev/null
+++ b/vendor/github.com/StackExchange/wmi/swbemservices.go
@@ -0,0 +1,260 @@
+// +build windows
+
+package wmi
+
+import (
+ "fmt"
+ "reflect"
+ "runtime"
+ "sync"
+
+ "github.com/go-ole/go-ole"
+ "github.com/go-ole/go-ole/oleutil"
+)
+
+// SWbemServices is used to access wmi. See https://msdn.microsoft.com/en-us/library/aa393719(v=vs.85).aspx
+type SWbemServices struct {
+ //TODO: track namespace. Not sure if we can re connect to a different namespace using the same instance
+ cWMIClient *Client //This could also be an embedded struct, but then we would need to branch on Client vs SWbemServices in the Query method
+ sWbemLocatorIUnknown *ole.IUnknown
+ sWbemLocatorIDispatch *ole.IDispatch
+ queries chan *queryRequest
+ closeError chan error
+ lQueryorClose sync.Mutex
+}
+
+type queryRequest struct {
+ query string
+ dst interface{}
+ args []interface{}
+ finished chan error
+}
+
+// InitializeSWbemServices will return a new SWbemServices object that can be used to query WMI
+func InitializeSWbemServices(c *Client, connectServerArgs ...interface{}) (*SWbemServices, error) {
+ //fmt.Println("InitializeSWbemServices: Starting")
+ //TODO: implement connectServerArgs as optional argument for init with connectServer call
+ s := new(SWbemServices)
+ s.cWMIClient = c
+ s.queries = make(chan *queryRequest)
+ initError := make(chan error)
+ go s.process(initError)
+
+ err, ok := <-initError
+ if ok {
+ return nil, err //Send error to caller
+ }
+ //fmt.Println("InitializeSWbemServices: Finished")
+ return s, nil
+}
+
+// Close will clear and release all of the SWbemServices resources
+func (s *SWbemServices) Close() error {
+ s.lQueryorClose.Lock()
+ if s == nil || s.sWbemLocatorIDispatch == nil {
+ s.lQueryorClose.Unlock()
+ return fmt.Errorf("SWbemServices is not Initialized")
+ }
+ if s.queries == nil {
+ s.lQueryorClose.Unlock()
+ return fmt.Errorf("SWbemServices has been closed")
+ }
+ //fmt.Println("Close: sending close request")
+ var result error
+ ce := make(chan error)
+ s.closeError = ce //Race condition if multiple callers to close. May need to lock here
+ close(s.queries) //Tell background to shut things down
+ s.lQueryorClose.Unlock()
+ err, ok := <-ce
+ if ok {
+ result = err
+ }
+ //fmt.Println("Close: finished")
+ return result
+}
+
+func (s *SWbemServices) process(initError chan error) {
+ //fmt.Println("process: starting background thread initialization")
+ //All OLE/WMI calls must happen on the same initialized thead, so lock this goroutine
+ runtime.LockOSThread()
+ defer runtime.LockOSThread()
+
+ err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
+ if err != nil {
+ oleCode := err.(*ole.OleError).Code()
+ if oleCode != ole.S_OK && oleCode != S_FALSE {
+ initError <- fmt.Errorf("ole.CoInitializeEx error: %v", err)
+ return
+ }
+ }
+ defer ole.CoUninitialize()
+
+ unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
+ if err != nil {
+ initError <- fmt.Errorf("CreateObject SWbemLocator error: %v", err)
+ return
+ } else if unknown == nil {
+ initError <- ErrNilCreateObject
+ return
+ }
+ defer unknown.Release()
+ s.sWbemLocatorIUnknown = unknown
+
+ dispatch, err := s.sWbemLocatorIUnknown.QueryInterface(ole.IID_IDispatch)
+ if err != nil {
+ initError <- fmt.Errorf("SWbemLocator QueryInterface error: %v", err)
+ return
+ }
+ defer dispatch.Release()
+ s.sWbemLocatorIDispatch = dispatch
+
+ // we can't do the ConnectServer call outside the loop unless we find a way to track and re-init the connectServerArgs
+ //fmt.Println("process: initialized. closing initError")
+ close(initError)
+ //fmt.Println("process: waiting for queries")
+ for q := range s.queries {
+ //fmt.Printf("process: new query: len(query)=%d\n", len(q.query))
+ errQuery := s.queryBackground(q)
+ //fmt.Println("process: s.queryBackground finished")
+ if errQuery != nil {
+ q.finished <- errQuery
+ }
+ close(q.finished)
+ }
+ //fmt.Println("process: queries channel closed")
+ s.queries = nil //set channel to nil so we know it is closed
+ //TODO: I think the Release/Clear calls can panic if things are in a bad state.
+ //TODO: May need to recover from panics and send error to method caller instead.
+ close(s.closeError)
+}
+
+// Query runs the WQL query using a SWbemServices instance 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 (s *SWbemServices) Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+ s.lQueryorClose.Lock()
+ if s == nil || s.sWbemLocatorIDispatch == nil {
+ s.lQueryorClose.Unlock()
+ return fmt.Errorf("SWbemServices is not Initialized")
+ }
+ if s.queries == nil {
+ s.lQueryorClose.Unlock()
+ return fmt.Errorf("SWbemServices has been closed")
+ }
+
+ //fmt.Println("Query: Sending query request")
+ qr := queryRequest{
+ query: query,
+ dst: dst,
+ args: connectServerArgs,
+ finished: make(chan error),
+ }
+ s.queries <- &qr
+ s.lQueryorClose.Unlock()
+ err, ok := <-qr.finished
+ if ok {
+ //fmt.Println("Query: Finished with error")
+ return err //Send error to caller
+ }
+ //fmt.Println("Query: Finished")
+ return nil
+}
+
+func (s *SWbemServices) queryBackground(q *queryRequest) error {
+ if s == nil || s.sWbemLocatorIDispatch == nil {
+ return fmt.Errorf("SWbemServices is not Initialized")
+ }
+ wmi := s.sWbemLocatorIDispatch //Should just rename in the code, but this will help as we break things apart
+ //fmt.Println("queryBackground: Starting")
+
+ dv := reflect.ValueOf(q.dst)
+ if dv.Kind() != reflect.Ptr || dv.IsNil() {
+ return ErrInvalidEntityType
+ }
+ dv = dv.Elem()
+ mat, elemType := checkMultiArg(dv)
+ if mat == multiArgTypeInvalid {
+ return ErrInvalidEntityType
+ }
+
+ // service is a SWbemServices
+ serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", q.args...)
+ if err != nil {
+ return err
+ }
+ service := serviceRaw.ToIDispatch()
+ defer serviceRaw.Clear()
+
+ // result is a SWBemObjectSet
+ resultRaw, err := oleutil.CallMethod(service, "ExecQuery", q.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 = s.cWMIClient.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
+ }
+ }
+ //fmt.Println("queryBackground: Finished")
+ return errFieldMismatch
+}
diff --git a/vendor/github.com/StackExchange/wmi/wmi.go b/vendor/github.com/StackExchange/wmi/wmi.go
new file mode 100644
index 000000000..a951b1258
--- /dev/null
+++ b/vendor/github.com/StackExchange/wmi/wmi.go
@@ -0,0 +1,486 @@
+// +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 {
+ if DefaultClient.SWbemServicesClient == nil {
+ return DefaultClient.Query(query, dst, connectServerArgs...)
+ }
+ return DefaultClient.SWbemServicesClient.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
+
+ // SWbemServiceClient is an optional SWbemServices object that can be
+ // initialized and then reused across multiple queries. If it is null
+ // then the method will initialize a new temporary client each time.
+ SWbemServicesClient *SWbemServices
+}
+
+// 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:
+ if f.Kind() == reflect.Slice {
+ switch f.Type().Elem().Kind() {
+ case reflect.String:
+ safeArray := prop.ToArray()
+ if safeArray != nil {
+ arr := safeArray.ToValueArray()
+ fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
+ for i, v := range arr {
+ s := fArr.Index(i)
+ s.SetString(v.(string))
+ }
+ f.Set(fArr)
+ }
+ case reflect.Uint8:
+ safeArray := prop.ToArray()
+ if safeArray != nil {
+ arr := safeArray.ToValueArray()
+ fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
+ for i, v := range arr {
+ s := fArr.Index(i)
+ s.SetUint(reflect.ValueOf(v).Uint())
+ }
+ f.Set(fArr)
+ }
+ default:
+ return &ErrFieldMismatch{
+ StructType: of.Type(),
+ FieldName: n,
+ Reason: fmt.Sprintf("unsupported slice type (%T)", val),
+ }
+ }
+ } else {
+ 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()
+}
diff --git a/vendor/github.com/elastic/gosigar/CHANGELOG.md b/vendor/github.com/elastic/gosigar/CHANGELOG.md
new file mode 100644
index 000000000..12695e10e
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/CHANGELOG.md
@@ -0,0 +1,102 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+
+### Added
+
+### Fixed
+
+### Changed
+
+### Deprecated
+
+## [0.8.0]
+
+### Added
+- Added partial `getrusage` support for Windows to retrieve system CPU time and user CPU time. #95
+- Added full `getrusage` support for Unix. #95
+
+## [0.7.0]
+
+### Added
+- Added method stubs for process handling for operating system that are not supported
+ by gosigar. All methods return `ErrNotImplemented` on such systems. #88
+
+### Fixed
+- Fix freebsd build by using the common version of Get(pid). #91
+
+### Changed
+- Fixed issues in cgroup package by adding missing error checks and closing
+ file handles. #92
+
+## [0.6.0]
+
+### Added
+- Added method stubs to enable compilation for operating systems that are not
+ supported by gosigar. All methods return `ErrNotImplemented` on these unsupported
+ operating systems. #83
+- FreeBSD returns `ErrNotImplemented` for `ProcTime.Get`. #83
+
+### Changed
+- OpenBSD returns `ErrNotImplemented` for `ProcTime.Get` instead of `nil`. #83
+- Fixed incorrect `Mem.Used` calculation under linux. #82
+- Fixed `ProcState` on Linux and FreeBSD when process names contain parentheses. #81
+
+### Removed
+- Remove NetBSD build from sigar_unix.go as it is not supported by gosigar. #83
+
+## [0.5.0]
+
+### Changed
+- Fixed Trim environment variables when comparing values in the test suite. #79
+- Make `kern_procargs` more robust under darwin when we cannot retrieve
+ all the information about a process. #78
+
+## [0.4.0]
+
+### Changed
+- Fixed Windows issue that caused a hang during `init()` if WMI wasn't ready. #74
+
+## [0.3.0]
+
+### Added
+- Read `MemAvailable` value for kernel 3.14+ #71
+
+## [0.2.0]
+
+### Added
+- Added `ErrCgroupsMissing` to indicate that /proc/cgroups is missing which is
+ an indicator that cgroups were disabled at compile time. #64
+
+### Changed
+- Changed `cgroup.SupportedSubsystems()` to honor the "enabled" column in the
+ /proc/cgroups file. #64
+
+## [0.1.0]
+
+### Added
+- Added `CpuList` implementation for Windows that returns CPU timing information
+ on a per CPU basis. #55
+- Added `Uptime` implementation for Windows. #55
+- Added `Swap` implementation for Windows based on page file metrics. #55
+- Added support to `github.com/gosigar/sys/windows` for querying and enabling
+ privileges in a process token.
+- Added utility code for interfacing with linux NETLINK_INET_DIAG. #60
+- Added `ProcEnv` for getting a process's environment variables. #61
+
+### Changed
+- Changed several `OpenProcess` calls on Windows to request the lowest possible
+ access privileges. #50
+- Removed cgo usage from Windows code.
+- Added OS version checks to `ProcArgs.Get` on Windows because the
+ `Win32_Process` WMI query is not available prior to Windows vista. On XP and
+ Windows 2003, this method returns `ErrNotImplemented`. #55
+
+### Fixed
+- Fixed value of `Mem.ActualFree` and `Mem.ActualUsed` on Windows. #49
+- Fixed `ProcTime.StartTime` on Windows to report value in milliseconds since
+ Unix epoch. #51
+- Fixed `ProcStatus.PPID` value is wrong on Windows. #55
+- Fixed `ProcStatus.Username` error on Windows XP #56
diff --git a/vendor/github.com/elastic/gosigar/LICENSE b/vendor/github.com/elastic/gosigar/LICENSE
new file mode 100644
index 000000000..11069edd7
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/github.com/elastic/gosigar/NOTICE b/vendor/github.com/elastic/gosigar/NOTICE
new file mode 100644
index 000000000..fda553b5c
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/NOTICE
@@ -0,0 +1,9 @@
+Copyright (c) [2009-2011] VMware, Inc. All Rights Reserved.
+
+This product is licensed to you under the Apache License, Version 2.0 (the "License").
+You may not use this product except in compliance with the License.
+
+This product includes a number of subcomponents with
+separate copyright notices and license terms. Your use of these
+subcomponents is subject to the terms and conditions of the
+subcomponent's license, as noted in the LICENSE file. \ No newline at end of file
diff --git a/vendor/github.com/elastic/gosigar/README.md b/vendor/github.com/elastic/gosigar/README.md
new file mode 100644
index 000000000..2482620a8
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/README.md
@@ -0,0 +1,57 @@
+# Go sigar [![Build Status](https://travis-ci.org/elastic/gosigar.svg?branch=master)](https://travis-ci.org/elastic/gosigar) [![Build status](https://ci.appveyor.com/api/projects/status/4yh6sa7u97ek5uib/branch/master?svg=true)](https://ci.appveyor.com/project/elastic-beats/gosigar/branch/master)
+
+
+## Overview
+
+Go sigar is a golang implementation of the
+[sigar API](https://github.com/hyperic/sigar). The Go version of
+sigar has a very similar interface, but is being written from scratch
+in pure go/cgo, rather than cgo bindings for libsigar.
+
+## Test drive
+
+ $ go get github.com/elastic/gosigar
+ $ cd $GOPATH/src/github.com/elastic/gosigar/examples/ps
+ $ go build
+ $ ./ps
+
+## Supported platforms
+
+The features vary by operating system.
+
+| Feature | Linux | Darwin | Windows | OpenBSD | FreeBSD |
+|-----------------|:-----:|:------:|:-------:|:-------:|:-------:|
+| Cpu | X | X | X | X | X |
+| CpuList | X | X | | X | X |
+| FDUsage | X | | | | X |
+| FileSystemList | X | X | X | X | X |
+| FileSystemUsage | X | X | X | X | X |
+| LoadAverage | X | X | | X | X |
+| Mem | X | X | X | X | X |
+| ProcArgs | X | X | X | | X |
+| ProcEnv | X | X | | | X |
+| ProcExe | X | X | | | X |
+| ProcFDUsage | X | | | | X |
+| ProcList | X | X | X | | X |
+| ProcMem | X | X | X | | X |
+| ProcState | X | X | X | | X |
+| ProcTime | X | X | X | | X |
+| Swap | X | X | | X | X |
+| Uptime | X | X | | X | X |
+
+## OS Specific Notes
+
+### FreeBSD
+
+Mount both `linprocfs` and `procfs` for compatability. Consider adding these
+mounts to your `/etc/fstab` file so they are mounted automatically at boot.
+
+```
+sudo mount -t procfs proc /proc
+sudo mkdir -p /compat/linux/proc
+sudo mount -t linprocfs /dev/null /compat/linux/proc
+```
+
+## License
+
+Apache 2.0
diff --git a/vendor/github.com/elastic/gosigar/Vagrantfile b/vendor/github.com/elastic/gosigar/Vagrantfile
new file mode 100644
index 000000000..6fd990c14
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/Vagrantfile
@@ -0,0 +1,25 @@
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+ config.vm.box = "hashicorp/precise64"
+ config.vm.provision "shell", inline: "mkdir -p /home/vagrant/go"
+ config.vm.synced_folder ".", "/home/vagrant/go/src/github.com/cloudfoundry/gosigar"
+ config.vm.provision "shell", inline: "chown -R vagrant:vagrant /home/vagrant/go"
+ install_go = <<-BASH
+ set -e
+
+if [ ! -d "/usr/local/go" ]; then
+ cd /tmp && wget https://storage.googleapis.com/golang/go1.3.3.linux-amd64.tar.gz
+ cd /usr/local
+ tar xvzf /tmp/go1.3.3.linux-amd64.tar.gz
+ echo 'export GOPATH=/home/vagrant/go; export PATH=/usr/local/go/bin:$PATH:$GOPATH/bin' >> /home/vagrant/.bashrc
+fi
+export GOPATH=/home/vagrant/go
+export PATH=/usr/local/go/bin:$PATH:$GOPATH/bin
+/usr/local/go/bin/go get -u github.com/onsi/ginkgo/ginkgo
+/usr/local/go/bin/go get -u github.com/onsi/gomega;
+BASH
+ config.vm.provision "shell", inline: 'apt-get install -y git-core'
+ config.vm.provision "shell", inline: install_go
+end
diff --git a/vendor/github.com/elastic/gosigar/codecov.yml b/vendor/github.com/elastic/gosigar/codecov.yml
new file mode 100644
index 000000000..76ade0fdb
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/codecov.yml
@@ -0,0 +1,21 @@
+# Enable coverage report message for diff on commit
+coverage:
+ status:
+ project: off
+ patch:
+ default:
+ # basic
+ target: auto
+ threshold: null
+ base: auto
+ # advanced
+ branches: null
+ if_no_uploads: error
+ if_not_found: success
+ if_ci_failed: error
+ only_pulls: false
+ flags: null
+ paths: null
+
+# Disable comments on Pull Requests
+comment: false
diff --git a/vendor/github.com/elastic/gosigar/concrete_sigar.go b/vendor/github.com/elastic/gosigar/concrete_sigar.go
new file mode 100644
index 000000000..685aa6ded
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/concrete_sigar.go
@@ -0,0 +1,83 @@
+package gosigar
+
+import (
+ "time"
+)
+
+type ConcreteSigar struct{}
+
+func (c *ConcreteSigar) CollectCpuStats(collectionInterval time.Duration) (<-chan Cpu, chan<- struct{}) {
+ // samplesCh is buffered to 1 value to immediately return first CPU sample
+ samplesCh := make(chan Cpu, 1)
+
+ stopCh := make(chan struct{})
+
+ go func() {
+ var cpuUsage Cpu
+
+ // Immediately provide non-delta value.
+ // samplesCh is buffered to 1 value, so it will not block.
+ cpuUsage.Get()
+ samplesCh <- cpuUsage
+
+ ticker := time.NewTicker(collectionInterval)
+
+ for {
+ select {
+ case <-ticker.C:
+ previousCpuUsage := cpuUsage
+
+ cpuUsage.Get()
+
+ select {
+ case samplesCh <- cpuUsage.Delta(previousCpuUsage):
+ default:
+ // Include default to avoid channel blocking
+ }
+
+ case <-stopCh:
+ return
+ }
+ }
+ }()
+
+ return samplesCh, stopCh
+}
+
+func (c *ConcreteSigar) GetLoadAverage() (LoadAverage, error) {
+ l := LoadAverage{}
+ err := l.Get()
+ return l, err
+}
+
+func (c *ConcreteSigar) GetMem() (Mem, error) {
+ m := Mem{}
+ err := m.Get()
+ return m, err
+}
+
+func (c *ConcreteSigar) GetSwap() (Swap, error) {
+ s := Swap{}
+ err := s.Get()
+ return s, err
+}
+
+func (c *ConcreteSigar) GetFileSystemUsage(path string) (FileSystemUsage, error) {
+ f := FileSystemUsage{}
+ err := f.Get(path)
+ return f, err
+}
+
+func (c *ConcreteSigar) GetFDUsage() (FDUsage, error) {
+ fd := FDUsage{}
+ err := fd.Get()
+ return fd, err
+}
+
+// GetRusage return the resource usage of the process
+// Possible params: 0 = RUSAGE_SELF, 1 = RUSAGE_CHILDREN, 2 = RUSAGE_THREAD
+func (c *ConcreteSigar) GetRusage(who int) (Rusage, error) {
+ r := Rusage{}
+ err := r.Get(who)
+ return r, err
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_darwin.go b/vendor/github.com/elastic/gosigar/sigar_darwin.go
new file mode 100644
index 000000000..f989f5160
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_darwin.go
@@ -0,0 +1,494 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+/*
+#include <stdlib.h>
+#include <sys/sysctl.h>
+#include <sys/mount.h>
+#include <mach/mach_init.h>
+#include <mach/mach_host.h>
+#include <mach/host_info.h>
+#include <libproc.h>
+#include <mach/processor_info.h>
+#include <mach/vm_map.h>
+*/
+import "C"
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "io"
+ "os/user"
+ "runtime"
+ "strconv"
+ "syscall"
+ "time"
+ "unsafe"
+)
+
+func (self *LoadAverage) Get() error {
+ avg := []C.double{0, 0, 0}
+
+ C.getloadavg(&avg[0], C.int(len(avg)))
+
+ self.One = float64(avg[0])
+ self.Five = float64(avg[1])
+ self.Fifteen = float64(avg[2])
+
+ return nil
+}
+
+func (self *Uptime) Get() error {
+ tv := syscall.Timeval32{}
+
+ if err := sysctlbyname("kern.boottime", &tv); err != nil {
+ return err
+ }
+
+ self.Length = time.Since(time.Unix(int64(tv.Sec), int64(tv.Usec)*1000)).Seconds()
+
+ return nil
+}
+
+func (self *Mem) Get() error {
+ var vmstat C.vm_statistics_data_t
+
+ if err := sysctlbyname("hw.memsize", &self.Total); err != nil {
+ return err
+ }
+
+ if err := vm_info(&vmstat); err != nil {
+ return err
+ }
+
+ kern := uint64(vmstat.inactive_count) << 12
+ self.Free = uint64(vmstat.free_count) << 12
+
+ self.Used = self.Total - self.Free
+ self.ActualFree = self.Free + kern
+ self.ActualUsed = self.Used - kern
+
+ return nil
+}
+
+type xsw_usage struct {
+ Total, Avail, Used uint64
+}
+
+func (self *Swap) Get() error {
+ sw_usage := xsw_usage{}
+
+ if err := sysctlbyname("vm.swapusage", &sw_usage); err != nil {
+ return err
+ }
+
+ self.Total = sw_usage.Total
+ self.Used = sw_usage.Used
+ self.Free = sw_usage.Avail
+
+ return nil
+}
+
+func (self *Cpu) Get() 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 fmt.Errorf("host_statistics error=%d", status)
+ }
+
+ self.User = uint64(cpuload.cpu_ticks[C.CPU_STATE_USER])
+ self.Sys = uint64(cpuload.cpu_ticks[C.CPU_STATE_SYSTEM])
+ self.Idle = uint64(cpuload.cpu_ticks[C.CPU_STATE_IDLE])
+ self.Nice = uint64(cpuload.cpu_ticks[C.CPU_STATE_NICE])
+
+ return nil
+}
+
+func (self *CpuList) Get() error {
+ var count C.mach_msg_type_number_t
+ var cpuload *C.processor_cpu_load_info_data_t
+ var 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 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)
+
+ self.List = make([]Cpu, 0, ncpu)
+
+ for i := 0; i < int(ncpu); i++ {
+ cpu := Cpu{}
+
+ err := binary.Read(bbuf, binary.LittleEndian, &cpu_ticks)
+ if err != nil {
+ return err
+ }
+
+ cpu.User = uint64(cpu_ticks[C.CPU_STATE_USER])
+ cpu.Sys = uint64(cpu_ticks[C.CPU_STATE_SYSTEM])
+ cpu.Idle = uint64(cpu_ticks[C.CPU_STATE_IDLE])
+ cpu.Nice = uint64(cpu_ticks[C.CPU_STATE_NICE])
+
+ self.List = append(self.List, cpu)
+ }
+
+ return nil
+}
+
+func (self *FDUsage) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *FileSystemList) Get() error {
+ num, err := syscall.Getfsstat(nil, C.MNT_NOWAIT)
+ if err != nil {
+ return err
+ }
+
+ buf := make([]syscall.Statfs_t, num)
+
+ _, err = syscall.Getfsstat(buf, C.MNT_NOWAIT)
+ if err != nil {
+ return err
+ }
+
+ fslist := make([]FileSystem, 0, num)
+
+ for i := 0; i < num; i++ {
+ fs := FileSystem{}
+
+ fs.DirName = bytePtrToString(&buf[i].Mntonname[0])
+ fs.DevName = bytePtrToString(&buf[i].Mntfromname[0])
+ fs.SysTypeName = bytePtrToString(&buf[i].Fstypename[0])
+
+ fslist = append(fslist, fs)
+ }
+
+ self.List = fslist
+
+ return err
+}
+
+func (self *ProcList) Get() error {
+ n := C.proc_listpids(C.PROC_ALL_PIDS, 0, nil, 0)
+ if n <= 0 {
+ return syscall.EINVAL
+ }
+ buf := make([]byte, n)
+ n = C.proc_listpids(C.PROC_ALL_PIDS, 0, unsafe.Pointer(&buf[0]), n)
+ if n <= 0 {
+ return syscall.ENOMEM
+ }
+
+ var pid int32
+ num := int(n) / binary.Size(pid)
+ list := make([]int, 0, num)
+ bbuf := bytes.NewBuffer(buf)
+
+ for i := 0; i < num; i++ {
+ if err := binary.Read(bbuf, binary.LittleEndian, &pid); err != nil {
+ return err
+ }
+ if pid == 0 {
+ continue
+ }
+
+ list = append(list, int(pid))
+ }
+
+ self.List = list
+
+ return nil
+}
+
+func (self *ProcState) Get(pid int) error {
+ info := C.struct_proc_taskallinfo{}
+
+ if err := task_info(pid, &info); err != nil {
+ return err
+ }
+
+ self.Name = C.GoString(&info.pbsd.pbi_comm[0])
+
+ switch info.pbsd.pbi_status {
+ case C.SIDL:
+ self.State = RunStateIdle
+ case C.SRUN:
+ self.State = RunStateRun
+ case C.SSLEEP:
+ self.State = RunStateSleep
+ case C.SSTOP:
+ self.State = RunStateStop
+ case C.SZOMB:
+ self.State = RunStateZombie
+ default:
+ self.State = RunStateUnknown
+ }
+
+ self.Ppid = int(info.pbsd.pbi_ppid)
+
+ self.Pgid = int(info.pbsd.pbi_pgid)
+
+ self.Tty = int(info.pbsd.e_tdev)
+
+ self.Priority = int(info.ptinfo.pti_priority)
+
+ self.Nice = int(info.pbsd.pbi_nice)
+
+ // Get process username. Fallback to UID if username is not available.
+ uid := strconv.Itoa(int(info.pbsd.pbi_uid))
+ user, err := user.LookupId(uid)
+ if err == nil && user.Username != "" {
+ self.Username = user.Username
+ } else {
+ self.Username = uid
+ }
+
+ return nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+ info := C.struct_proc_taskallinfo{}
+
+ if err := task_info(pid, &info); err != nil {
+ return err
+ }
+
+ self.Size = uint64(info.ptinfo.pti_virtual_size)
+ self.Resident = uint64(info.ptinfo.pti_resident_size)
+ self.PageFaults = uint64(info.ptinfo.pti_faults)
+
+ return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+ info := C.struct_proc_taskallinfo{}
+
+ if err := task_info(pid, &info); err != nil {
+ return err
+ }
+
+ self.User =
+ uint64(info.ptinfo.pti_total_user) / uint64(time.Millisecond)
+
+ self.Sys =
+ uint64(info.ptinfo.pti_total_system) / uint64(time.Millisecond)
+
+ self.Total = self.User + self.Sys
+
+ self.StartTime = (uint64(info.pbsd.pbi_start_tvsec) * 1000) +
+ (uint64(info.pbsd.pbi_start_tvusec) / 1000)
+
+ return nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+ var args []string
+
+ argv := func(arg string) {
+ args = append(args, arg)
+ }
+
+ err := kern_procargs(pid, nil, argv, nil)
+
+ self.List = args
+
+ return err
+}
+
+func (self *ProcEnv) Get(pid int) error {
+ if self.Vars == nil {
+ self.Vars = map[string]string{}
+ }
+
+ env := func(k, v string) {
+ self.Vars[k] = v
+ }
+
+ return kern_procargs(pid, nil, nil, env)
+}
+
+func (self *ProcExe) Get(pid int) error {
+ exe := func(arg string) {
+ self.Name = arg
+ }
+
+ return kern_procargs(pid, exe, nil, nil)
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+// wrapper around sysctl KERN_PROCARGS2
+// callbacks params are optional,
+// up to the caller as to which pieces of data they want
+func kern_procargs(pid int,
+ exe func(string),
+ argv func(string),
+ env func(string, string)) error {
+
+ mib := []C.int{C.CTL_KERN, C.KERN_PROCARGS2, C.int(pid)}
+ argmax := uintptr(C.ARG_MAX)
+ buf := make([]byte, argmax)
+ err := sysctl(mib, &buf[0], &argmax, nil, 0)
+ if err != nil {
+ return nil
+ }
+
+ bbuf := bytes.NewBuffer(buf)
+ bbuf.Truncate(int(argmax))
+
+ var argc int32
+ binary.Read(bbuf, binary.LittleEndian, &argc)
+
+ path, err := bbuf.ReadBytes(0)
+ if err != nil {
+ return fmt.Errorf("Error reading the argv[0]: %v", err)
+ }
+ if exe != nil {
+ exe(string(chop(path)))
+ }
+
+ // skip trailing \0's
+ for {
+ c, err := bbuf.ReadByte()
+ if err != nil {
+ return fmt.Errorf("Error skipping nils: %v", err)
+ }
+ if c != 0 {
+ bbuf.UnreadByte()
+ break // start of argv[0]
+ }
+ }
+
+ for i := 0; i < int(argc); i++ {
+ arg, err := bbuf.ReadBytes(0)
+ if err == io.EOF {
+ break
+ }
+ if err != nil {
+ return fmt.Errorf("Error reading args: %v", err)
+ }
+ if argv != nil {
+ argv(string(chop(arg)))
+ }
+ }
+
+ if env == nil {
+ return nil
+ }
+
+ delim := []byte{61} // "="
+
+ for {
+ line, err := bbuf.ReadBytes(0)
+ if err == io.EOF || line[0] == 0 {
+ break
+ }
+ if err != nil {
+ return fmt.Errorf("Error reading args: %v", err)
+ }
+ pair := bytes.SplitN(chop(line), delim, 2)
+
+ if len(pair) != 2 {
+ return fmt.Errorf("Error reading process information for PID: %d", pid)
+ }
+
+ env(string(pair[0]), string(pair[1]))
+ }
+
+ return nil
+}
+
+// XXX copied from zsyscall_darwin_amd64.go
+func sysctl(mib []C.int, old *byte, oldlen *uintptr,
+ new *byte, newlen uintptr) (err error) {
+ var p0 unsafe.Pointer
+ p0 = unsafe.Pointer(&mib[0])
+ _, _, e1 := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(p0),
+ uintptr(len(mib)),
+ uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)),
+ uintptr(unsafe.Pointer(new)), uintptr(newlen))
+ if e1 != 0 {
+ err = e1
+ }
+ return
+}
+
+func vm_info(vmstat *C.vm_statistics_data_t) error {
+ var count C.mach_msg_type_number_t = C.HOST_VM_INFO_COUNT
+
+ status := C.host_statistics(
+ C.host_t(C.mach_host_self()),
+ C.HOST_VM_INFO,
+ C.host_info_t(unsafe.Pointer(vmstat)),
+ &count)
+
+ if status != C.KERN_SUCCESS {
+ return fmt.Errorf("host_statistics=%d", status)
+ }
+
+ return nil
+}
+
+// generic Sysctl buffer unmarshalling
+func sysctlbyname(name string, data interface{}) (err error) {
+ val, err := syscall.Sysctl(name)
+ if err != nil {
+ return err
+ }
+
+ buf := []byte(val)
+
+ switch v := data.(type) {
+ case *uint64:
+ *v = *(*uint64)(unsafe.Pointer(&buf[0]))
+ return
+ }
+
+ bbuf := bytes.NewBuffer([]byte(val))
+ return binary.Read(bbuf, binary.LittleEndian, data)
+}
+
+func task_info(pid int, info *C.struct_proc_taskallinfo) error {
+ size := C.int(unsafe.Sizeof(*info))
+ ptr := unsafe.Pointer(info)
+
+ n := C.proc_pidinfo(C.int(pid), C.PROC_PIDTASKALLINFO, 0, ptr, size)
+ if n != size {
+ return fmt.Errorf("Could not read process info for pid %d", pid)
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_format.go b/vendor/github.com/elastic/gosigar/sigar_format.go
new file mode 100644
index 000000000..ac56c9873
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_format.go
@@ -0,0 +1,126 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "strconv"
+ "time"
+)
+
+// Go version of apr_strfsize
+func FormatSize(size uint64) string {
+ ord := []string{"K", "M", "G", "T", "P", "E"}
+ o := 0
+ buf := new(bytes.Buffer)
+ w := bufio.NewWriter(buf)
+
+ if size < 973 {
+ fmt.Fprintf(w, "%3d ", size)
+ w.Flush()
+ return buf.String()
+ }
+
+ for {
+ remain := size & 1023
+ size >>= 10
+
+ if size >= 973 {
+ o++
+ continue
+ }
+
+ if size < 9 || (size == 9 && remain < 973) {
+ remain = ((remain * 5) + 256) / 512
+ if remain >= 10 {
+ size++
+ remain = 0
+ }
+
+ fmt.Fprintf(w, "%d.%d%s", size, remain, ord[o])
+ break
+ }
+
+ if remain >= 512 {
+ size++
+ }
+
+ fmt.Fprintf(w, "%3d%s", size, ord[o])
+ break
+ }
+
+ w.Flush()
+ return buf.String()
+}
+
+func FormatPercent(percent float64) string {
+ return strconv.FormatFloat(percent, 'f', -1, 64) + "%"
+}
+
+func (self *FileSystemUsage) UsePercent() float64 {
+ b_used := (self.Total - self.Free) / 1024
+ b_avail := self.Avail / 1024
+ utotal := b_used + b_avail
+ used := b_used
+
+ if utotal != 0 {
+ u100 := used * 100
+ pct := u100 / utotal
+ if u100%utotal != 0 {
+ pct += 1
+ }
+ return (float64(pct) / float64(100)) * 100.0
+ }
+
+ return 0.0
+}
+
+func (self *Uptime) Format() string {
+ buf := new(bytes.Buffer)
+ w := bufio.NewWriter(buf)
+ uptime := uint64(self.Length)
+
+ days := uptime / (60 * 60 * 24)
+
+ if days != 0 {
+ s := ""
+ if days > 1 {
+ s = "s"
+ }
+ fmt.Fprintf(w, "%d day%s, ", days, s)
+ }
+
+ minutes := uptime / 60
+ hours := minutes / 60
+ hours %= 24
+ minutes %= 60
+
+ fmt.Fprintf(w, "%2d:%02d", hours, minutes)
+
+ w.Flush()
+ return buf.String()
+}
+
+func (self *ProcTime) FormatStartTime() string {
+ if self.StartTime == 0 {
+ return "00:00"
+ }
+ start := time.Unix(int64(self.StartTime)/1000, 0)
+ format := "Jan02"
+ if time.Since(start).Seconds() < (60 * 60 * 24) {
+ format = "15:04"
+ }
+ return start.Format(format)
+}
+
+func (self *ProcTime) FormatTotal() string {
+ t := self.Total / 1000
+ ss := t % 60
+ t /= 60
+ mm := t % 60
+ t /= 60
+ hh := t % 24
+ return fmt.Sprintf("%02d:%02d:%02d", hh, mm, ss)
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_freebsd.go b/vendor/github.com/elastic/gosigar/sigar_freebsd.go
new file mode 100644
index 000000000..602b4a0aa
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_freebsd.go
@@ -0,0 +1,108 @@
+// Copied and modified from sigar_linux.go.
+
+package gosigar
+
+import (
+ "io/ioutil"
+ "strconv"
+ "strings"
+ "unsafe"
+)
+
+/*
+#include <sys/param.h>
+#include <sys/mount.h>
+#include <sys/ucred.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <time.h>
+*/
+import "C"
+
+func init() {
+ system.ticks = uint64(C.sysconf(C._SC_CLK_TCK))
+
+ Procd = "/compat/linux/proc"
+
+ getLinuxBootTime()
+}
+
+func getMountTableFileName() string {
+ return Procd + "/mtab"
+}
+
+func (self *Uptime) Get() error {
+ ts := C.struct_timespec{}
+
+ if _, err := C.clock_gettime(C.CLOCK_UPTIME, &ts); err != nil {
+ return err
+ }
+
+ self.Length = float64(ts.tv_sec) + 1e-9*float64(ts.tv_nsec)
+
+ return nil
+}
+
+func (self *FDUsage) Get() error {
+ val := C.uint32_t(0)
+ sc := C.size_t(4)
+
+ name := C.CString("kern.openfiles")
+ _, err := C.sysctlbyname(name, unsafe.Pointer(&val), &sc, nil, 0)
+ C.free(unsafe.Pointer(name))
+ if err != nil {
+ return err
+ }
+ self.Open = uint64(val)
+
+ name = C.CString("kern.maxfiles")
+ _, err = C.sysctlbyname(name, unsafe.Pointer(&val), &sc, nil, 0)
+ C.free(unsafe.Pointer(name))
+ if err != nil {
+ return err
+ }
+ self.Max = uint64(val)
+
+ self.Unused = self.Max - self.Open
+
+ return nil
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+ err := readFile("/proc/"+strconv.Itoa(pid)+"/rlimit", func(line string) bool {
+ if strings.HasPrefix(line, "nofile") {
+ fields := strings.Fields(line)
+ if len(fields) == 3 {
+ self.SoftLimit, _ = strconv.ParseUint(fields[1], 10, 64)
+ self.HardLimit, _ = strconv.ParseUint(fields[2], 10, 64)
+ }
+ return false
+ }
+ return true
+ })
+ if err != nil {
+ return err
+ }
+
+ // linprocfs only provides this information for this process (self).
+ fds, err := ioutil.ReadDir(procFileName(pid, "fd"))
+ if err != nil {
+ return err
+ }
+ self.Open = uint64(len(fds))
+
+ return nil
+}
+
+func parseCpuStat(self *Cpu, line string) error {
+ fields := strings.Fields(line)
+
+ self.User, _ = strtoull(fields[1])
+ self.Nice, _ = strtoull(fields[2])
+ self.Sys, _ = strtoull(fields[3])
+ self.Idle, _ = strtoull(fields[4])
+ return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_interface.go b/vendor/github.com/elastic/gosigar/sigar_interface.go
new file mode 100644
index 000000000..a956af604
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_interface.go
@@ -0,0 +1,197 @@
+package gosigar
+
+import (
+ "time"
+)
+
+type ErrNotImplemented struct {
+ OS string
+}
+
+func (e ErrNotImplemented) Error() string {
+ return "not implemented on " + e.OS
+}
+
+func IsNotImplemented(err error) bool {
+ switch err.(type) {
+ case ErrNotImplemented, *ErrNotImplemented:
+ return true
+ default:
+ return false
+ }
+}
+
+type Sigar interface {
+ CollectCpuStats(collectionInterval time.Duration) (<-chan Cpu, chan<- struct{})
+ GetLoadAverage() (LoadAverage, error)
+ GetMem() (Mem, error)
+ GetSwap() (Swap, error)
+ GetFileSystemUsage(string) (FileSystemUsage, error)
+ GetFDUsage() (FDUsage, error)
+ GetRusage(who int) (Rusage, error)
+}
+
+type Cpu struct {
+ User uint64
+ Nice uint64
+ Sys uint64
+ Idle uint64
+ Wait uint64
+ Irq uint64
+ SoftIrq uint64
+ Stolen uint64
+}
+
+func (cpu *Cpu) Total() uint64 {
+ return cpu.User + cpu.Nice + cpu.Sys + cpu.Idle +
+ cpu.Wait + cpu.Irq + cpu.SoftIrq + cpu.Stolen
+}
+
+func (cpu Cpu) Delta(other Cpu) Cpu {
+ return Cpu{
+ User: cpu.User - other.User,
+ Nice: cpu.Nice - other.Nice,
+ Sys: cpu.Sys - other.Sys,
+ Idle: cpu.Idle - other.Idle,
+ Wait: cpu.Wait - other.Wait,
+ Irq: cpu.Irq - other.Irq,
+ SoftIrq: cpu.SoftIrq - other.SoftIrq,
+ Stolen: cpu.Stolen - other.Stolen,
+ }
+}
+
+type LoadAverage struct {
+ One, Five, Fifteen float64
+}
+
+type Uptime struct {
+ Length float64
+}
+
+type Mem struct {
+ Total uint64
+ Used uint64
+ Free uint64
+ ActualFree uint64
+ ActualUsed uint64
+}
+
+type Swap struct {
+ Total uint64
+ Used uint64
+ Free uint64
+}
+
+type CpuList struct {
+ List []Cpu
+}
+
+type FDUsage struct {
+ Open uint64
+ Unused uint64
+ Max uint64
+}
+
+type FileSystem struct {
+ DirName string
+ DevName string
+ TypeName string
+ SysTypeName string
+ Options string
+ Flags uint32
+}
+
+type FileSystemList struct {
+ List []FileSystem
+}
+
+type FileSystemUsage struct {
+ Total uint64
+ Used uint64
+ Free uint64
+ Avail uint64
+ Files uint64
+ FreeFiles uint64
+}
+
+type ProcList struct {
+ List []int
+}
+
+type RunState byte
+
+const (
+ RunStateSleep = 'S'
+ RunStateRun = 'R'
+ RunStateStop = 'T'
+ RunStateZombie = 'Z'
+ RunStateIdle = 'D'
+ RunStateUnknown = '?'
+)
+
+type ProcState struct {
+ Name string
+ Username string
+ State RunState
+ Ppid int
+ Pgid int
+ Tty int
+ Priority int
+ Nice int
+ Processor int
+}
+
+type ProcMem struct {
+ Size uint64
+ Resident uint64
+ Share uint64
+ MinorFaults uint64
+ MajorFaults uint64
+ PageFaults uint64
+}
+
+type ProcTime struct {
+ StartTime uint64
+ User uint64
+ Sys uint64
+ Total uint64
+}
+
+type ProcArgs struct {
+ List []string
+}
+
+type ProcEnv struct {
+ Vars map[string]string
+}
+
+type ProcExe struct {
+ Name string
+ Cwd string
+ Root string
+}
+
+type ProcFDUsage struct {
+ Open uint64
+ SoftLimit uint64
+ HardLimit uint64
+}
+
+type Rusage struct {
+ Utime time.Duration
+ Stime time.Duration
+ 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
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_linux.go b/vendor/github.com/elastic/gosigar/sigar_linux.go
new file mode 100644
index 000000000..cb1d3525b
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_linux.go
@@ -0,0 +1,84 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+ "io/ioutil"
+ "strconv"
+ "strings"
+ "syscall"
+)
+
+func init() {
+ system.ticks = 100 // C.sysconf(C._SC_CLK_TCK)
+
+ Procd = "/proc"
+
+ getLinuxBootTime()
+}
+
+func getMountTableFileName() string {
+ return "/etc/mtab"
+}
+
+func (self *Uptime) Get() error {
+ sysinfo := syscall.Sysinfo_t{}
+
+ if err := syscall.Sysinfo(&sysinfo); err != nil {
+ return err
+ }
+
+ self.Length = float64(sysinfo.Uptime)
+
+ return nil
+}
+
+func (self *FDUsage) Get() error {
+ return readFile(Procd+"/sys/fs/file-nr", func(line string) bool {
+ fields := strings.Fields(line)
+ if len(fields) == 3 {
+ self.Open, _ = strconv.ParseUint(fields[0], 10, 64)
+ self.Unused, _ = strconv.ParseUint(fields[1], 10, 64)
+ self.Max, _ = strconv.ParseUint(fields[2], 10, 64)
+ }
+ return false
+ })
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+ err := readFile(procFileName(pid, "limits"), func(line string) bool {
+ if strings.HasPrefix(line, "Max open files") {
+ fields := strings.Fields(line)
+ if len(fields) == 6 {
+ self.SoftLimit, _ = strconv.ParseUint(fields[3], 10, 64)
+ self.HardLimit, _ = strconv.ParseUint(fields[4], 10, 64)
+ }
+ return false
+ }
+ return true
+ })
+ if err != nil {
+ return err
+ }
+ fds, err := ioutil.ReadDir(procFileName(pid, "fd"))
+ if err != nil {
+ return err
+ }
+ self.Open = uint64(len(fds))
+ return nil
+}
+
+func parseCpuStat(self *Cpu, line string) error {
+ fields := strings.Fields(line)
+
+ self.User, _ = strtoull(fields[1])
+ self.Nice, _ = strtoull(fields[2])
+ self.Sys, _ = strtoull(fields[3])
+ self.Idle, _ = strtoull(fields[4])
+ self.Wait, _ = strtoull(fields[5])
+ self.Irq, _ = strtoull(fields[6])
+ self.SoftIrq, _ = strtoull(fields[7])
+ self.Stolen, _ = strtoull(fields[8])
+
+ return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_linux_common.go b/vendor/github.com/elastic/gosigar/sigar_linux_common.go
new file mode 100644
index 000000000..8e5e7856f
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_linux_common.go
@@ -0,0 +1,468 @@
+// Copyright (c) 2012 VMware, Inc.
+
+// +build freebsd linux
+
+package gosigar
+
+import (
+ "bufio"
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "os"
+ "os/user"
+ "path/filepath"
+ "strconv"
+ "strings"
+ "syscall"
+)
+
+var system struct {
+ ticks uint64
+ btime uint64
+}
+
+var Procd string
+
+func getLinuxBootTime() {
+ // grab system boot time
+ readFile(Procd+"/stat", func(line string) bool {
+ if strings.HasPrefix(line, "btime") {
+ system.btime, _ = strtoull(line[6:])
+ return false // stop reading
+ }
+ return true
+ })
+}
+
+func (self *LoadAverage) Get() error {
+ line, err := ioutil.ReadFile(Procd + "/loadavg")
+ if err != nil {
+ return nil
+ }
+
+ fields := strings.Fields(string(line))
+
+ self.One, _ = strconv.ParseFloat(fields[0], 64)
+ self.Five, _ = strconv.ParseFloat(fields[1], 64)
+ self.Fifteen, _ = strconv.ParseFloat(fields[2], 64)
+
+ return nil
+}
+
+func (self *Mem) Get() error {
+
+ table, err := parseMeminfo()
+ if err != nil {
+ return err
+ }
+
+ self.Total, _ = table["MemTotal"]
+ self.Free, _ = table["MemFree"]
+ buffers, _ := table["Buffers"]
+ cached, _ := table["Cached"]
+
+ if available, ok := table["MemAvailable"]; ok {
+ // MemAvailable is in /proc/meminfo (kernel 3.14+)
+ self.ActualFree = available
+ } else {
+ self.ActualFree = self.Free + buffers + cached
+ }
+
+ self.Used = self.Total - self.Free
+ self.ActualUsed = self.Total - self.ActualFree
+
+ return nil
+}
+
+func (self *Swap) Get() error {
+
+ table, err := parseMeminfo()
+ if err != nil {
+ return err
+ }
+ self.Total, _ = table["SwapTotal"]
+ self.Free, _ = table["SwapFree"]
+
+ self.Used = self.Total - self.Free
+ return nil
+}
+
+func (self *Cpu) Get() error {
+ return readFile(Procd+"/stat", func(line string) bool {
+ if len(line) > 4 && line[0:4] == "cpu " {
+ parseCpuStat(self, line)
+ return false
+ }
+ return true
+
+ })
+}
+
+func (self *CpuList) Get() error {
+ capacity := len(self.List)
+ if capacity == 0 {
+ capacity = 4
+ }
+ list := make([]Cpu, 0, capacity)
+
+ err := readFile(Procd+"/stat", func(line string) bool {
+ if len(line) > 3 && line[0:3] == "cpu" && line[3] != ' ' {
+ cpu := Cpu{}
+ parseCpuStat(&cpu, line)
+ list = append(list, cpu)
+ }
+ return true
+ })
+
+ self.List = list
+
+ return err
+}
+
+func (self *FileSystemList) Get() error {
+ capacity := len(self.List)
+ if capacity == 0 {
+ capacity = 10
+ }
+ fslist := make([]FileSystem, 0, capacity)
+
+ err := readFile(getMountTableFileName(), func(line string) bool {
+ fields := strings.Fields(line)
+
+ fs := FileSystem{}
+ fs.DevName = fields[0]
+ fs.DirName = fields[1]
+ fs.SysTypeName = fields[2]
+ fs.Options = fields[3]
+
+ fslist = append(fslist, fs)
+
+ return true
+ })
+
+ self.List = fslist
+
+ return err
+}
+
+func (self *ProcList) Get() error {
+ dir, err := os.Open(Procd)
+ if err != nil {
+ return err
+ }
+ defer dir.Close()
+
+ const readAllDirnames = -1 // see os.File.Readdirnames doc
+
+ names, err := dir.Readdirnames(readAllDirnames)
+ if err != nil {
+ return err
+ }
+
+ capacity := len(names)
+ list := make([]int, 0, capacity)
+
+ for _, name := range names {
+ if name[0] < '0' || name[0] > '9' {
+ continue
+ }
+ pid, err := strconv.Atoi(name)
+ if err == nil {
+ list = append(list, pid)
+ }
+ }
+
+ self.List = list
+
+ return nil
+}
+
+func (self *ProcState) Get(pid int) error {
+ data, err := readProcFile(pid, "stat")
+ if err != nil {
+ return err
+ }
+
+ // Extract the comm value with is surrounded by parentheses.
+ lIdx := bytes.Index(data, []byte("("))
+ rIdx := bytes.LastIndex(data, []byte(")"))
+ if lIdx < 0 || rIdx < 0 || lIdx >= rIdx || rIdx+2 >= len(data) {
+ return fmt.Errorf("failed to extract comm for pid %d from '%v'", pid, string(data))
+ }
+ self.Name = string(data[lIdx+1 : rIdx])
+
+ // Extract the rest of the fields that we are interested in.
+ fields := bytes.Fields(data[rIdx+2:])
+ if len(fields) <= 36 {
+ return fmt.Errorf("expected more stat fields for pid %d from '%v'", pid, string(data))
+ }
+
+ interests := bytes.Join([][]byte{
+ fields[0], // state
+ fields[1], // ppid
+ fields[2], // pgrp
+ fields[4], // tty_nr
+ fields[15], // priority
+ fields[16], // nice
+ fields[36], // processor (last processor executed on)
+ }, []byte(" "))
+
+ var state string
+ _, err = fmt.Fscan(bytes.NewBuffer(interests),
+ &state,
+ &self.Ppid,
+ &self.Pgid,
+ &self.Tty,
+ &self.Priority,
+ &self.Nice,
+ &self.Processor,
+ )
+ if err != nil {
+ return fmt.Errorf("failed to parse stat fields for pid %d from '%v': %v", pid, string(data), err)
+ }
+ self.State = RunState(state[0])
+
+ // Read /proc/[pid]/status to get the uid, then lookup uid to get username.
+ status, err := getProcStatus(pid)
+ if err != nil {
+ return fmt.Errorf("failed to read process status for pid %d: %v", pid, err)
+ }
+ uids, err := getUIDs(status)
+ if err != nil {
+ return fmt.Errorf("failed to read process status for pid %d: %v", pid, err)
+ }
+ user, err := user.LookupId(uids[0])
+ if err == nil {
+ self.Username = user.Username
+ } else {
+ self.Username = uids[0]
+ }
+
+ return nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+ contents, err := readProcFile(pid, "statm")
+ if err != nil {
+ return err
+ }
+
+ fields := strings.Fields(string(contents))
+
+ size, _ := strtoull(fields[0])
+ self.Size = size << 12
+
+ rss, _ := strtoull(fields[1])
+ self.Resident = rss << 12
+
+ share, _ := strtoull(fields[2])
+ self.Share = share << 12
+
+ contents, err = readProcFile(pid, "stat")
+ if err != nil {
+ return err
+ }
+
+ fields = strings.Fields(string(contents))
+
+ self.MinorFaults, _ = strtoull(fields[10])
+ self.MajorFaults, _ = strtoull(fields[12])
+ self.PageFaults = self.MinorFaults + self.MajorFaults
+
+ return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+ contents, err := readProcFile(pid, "stat")
+ if err != nil {
+ return err
+ }
+
+ fields := strings.Fields(string(contents))
+
+ user, _ := strtoull(fields[13])
+ sys, _ := strtoull(fields[14])
+ // convert to millis
+ self.User = user * (1000 / system.ticks)
+ self.Sys = sys * (1000 / system.ticks)
+ self.Total = self.User + self.Sys
+
+ // convert to millis
+ self.StartTime, _ = strtoull(fields[21])
+ self.StartTime /= system.ticks
+ self.StartTime += system.btime
+ self.StartTime *= 1000
+
+ return nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+ contents, err := readProcFile(pid, "cmdline")
+ if err != nil {
+ return err
+ }
+
+ bbuf := bytes.NewBuffer(contents)
+
+ var args []string
+
+ for {
+ arg, err := bbuf.ReadBytes(0)
+ if err == io.EOF {
+ break
+ }
+ args = append(args, string(chop(arg)))
+ }
+
+ self.List = args
+
+ return nil
+}
+
+func (self *ProcEnv) Get(pid int) error {
+ contents, err := readProcFile(pid, "environ")
+ if err != nil {
+ return err
+ }
+
+ if self.Vars == nil {
+ self.Vars = map[string]string{}
+ }
+
+ pairs := bytes.Split(contents, []byte{0})
+ for _, kv := range pairs {
+ parts := bytes.SplitN(kv, []byte{'='}, 2)
+ if len(parts) != 2 {
+ continue
+ }
+
+ key := string(bytes.TrimSpace(parts[0]))
+ if key == "" {
+ continue
+ }
+
+ self.Vars[key] = string(bytes.TrimSpace(parts[1]))
+ }
+
+ return nil
+}
+
+func (self *ProcExe) Get(pid int) error {
+ fields := map[string]*string{
+ "exe": &self.Name,
+ "cwd": &self.Cwd,
+ "root": &self.Root,
+ }
+
+ for name, field := range fields {
+ val, err := os.Readlink(procFileName(pid, name))
+
+ if err != nil {
+ return err
+ }
+
+ *field = val
+ }
+
+ return nil
+}
+
+func parseMeminfo() (map[string]uint64, error) {
+ table := map[string]uint64{}
+
+ err := readFile(Procd+"/meminfo", func(line string) bool {
+ fields := strings.Split(line, ":")
+
+ if len(fields) != 2 {
+ return true // skip on errors
+ }
+
+ num := strings.TrimLeft(fields[1], " ")
+ val, err := strtoull(strings.Fields(num)[0])
+ if err != nil {
+ return true // skip on errors
+ }
+ table[fields[0]] = val * 1024 //in bytes
+
+ return true
+ })
+ return table, err
+}
+
+func readFile(file string, handler func(string) bool) error {
+ contents, err := ioutil.ReadFile(file)
+ if err != nil {
+ return err
+ }
+
+ reader := bufio.NewReader(bytes.NewBuffer(contents))
+
+ for {
+ line, _, err := reader.ReadLine()
+ if err == io.EOF {
+ break
+ }
+ if !handler(string(line)) {
+ break
+ }
+ }
+
+ return nil
+}
+
+func strtoull(val string) (uint64, error) {
+ return strconv.ParseUint(val, 10, 64)
+}
+
+func procFileName(pid int, name string) string {
+ return Procd + "/" + strconv.Itoa(pid) + "/" + name
+}
+
+func readProcFile(pid int, name string) ([]byte, error) {
+ path := procFileName(pid, name)
+ contents, err := ioutil.ReadFile(path)
+
+ if err != nil {
+ if perr, ok := err.(*os.PathError); ok {
+ if perr.Err == syscall.ENOENT {
+ return nil, syscall.ESRCH
+ }
+ }
+ }
+
+ return contents, err
+}
+
+// getProcStatus reads /proc/[pid]/status which contains process status
+// information in human readable form.
+func getProcStatus(pid int) (map[string]string, error) {
+ status := make(map[string]string, 42)
+ path := filepath.Join(Procd, strconv.Itoa(pid), "status")
+ err := readFile(path, func(line string) bool {
+ fields := strings.SplitN(line, ":", 2)
+ if len(fields) == 2 {
+ status[fields[0]] = strings.TrimSpace(fields[1])
+ }
+
+ return true
+ })
+ return status, err
+}
+
+// getUIDs reads the "Uid" value from status and splits it into four values --
+// real, effective, saved set, and file system UIDs.
+func getUIDs(status map[string]string) ([]string, error) {
+ uidLine, ok := status["Uid"]
+ if !ok {
+ return nil, fmt.Errorf("Uid not found in proc status")
+ }
+
+ uidStrs := strings.Fields(uidLine)
+ if len(uidStrs) != 4 {
+ return nil, fmt.Errorf("Uid line ('%s') did not contain four values", uidLine)
+ }
+
+ return uidStrs, nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_openbsd.go b/vendor/github.com/elastic/gosigar/sigar_openbsd.go
new file mode 100644
index 000000000..4f1383a6b
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_openbsd.go
@@ -0,0 +1,418 @@
+// Copyright (c) 2016 Jasper Lievisse Adriaanse <j@jasper.la>.
+
+// +build openbsd
+
+package gosigar
+
+/*
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/mount.h>
+#include <sys/sched.h>
+#include <sys/swap.h>
+#include <stdlib.h>
+#include <unistd.h>
+*/
+import "C"
+
+//import "github.com/davecgh/go-spew/spew"
+
+import (
+ "runtime"
+ "syscall"
+ "time"
+ "unsafe"
+)
+
+type Uvmexp struct {
+ pagesize uint32
+ pagemask uint32
+ pageshift uint32
+ npages uint32
+ free uint32
+ active uint32
+ inactive uint32
+ paging uint32
+ wired uint32
+ zeropages uint32
+ reserve_pagedaemon uint32
+ reserve_kernel uint32
+ anonpages uint32
+ vnodepages uint32
+ vtextpages uint32
+ freemin uint32
+ freetarg uint32
+ inactarg uint32
+ wiredmax uint32
+ anonmin uint32
+ vtextmin uint32
+ vnodemin uint32
+ anonminpct uint32
+ vtextmi uint32
+ npct uint32
+ vnodeminpct uint32
+ nswapdev uint32
+ swpages uint32
+ swpginuse uint32
+ swpgonly uint32
+ nswget uint32
+ nanon uint32
+ nanonneeded uint32
+ nfreeanon uint32
+ faults uint32
+ traps uint32
+ intrs uint32
+ swtch uint32
+ softs uint32
+ syscalls uint32
+ pageins uint32
+ obsolete_swapins uint32
+ obsolete_swapouts uint32
+ pgswapin uint32
+ pgswapout uint32
+ forks uint32
+ forks_ppwait uint32
+ forks_sharevm uint32
+ pga_zerohit uint32
+ pga_zeromiss uint32
+ zeroaborts uint32
+ fltnoram uint32
+ fltnoanon uint32
+ fltpgwait uint32
+ fltpgrele uint32
+ fltrelck uint32
+ fltrelckok uint32
+ fltanget uint32
+ fltanretry uint32
+ fltamcopy uint32
+ fltnamap uint32
+ fltnomap uint32
+ fltlget uint32
+ fltget uint32
+ flt_anon uint32
+ flt_acow uint32
+ flt_obj uint32
+ flt_prcopy uint32
+ flt_przero uint32
+ pdwoke uint32
+ pdrevs uint32
+ pdswout uint32
+ pdfreed uint32
+ pdscans uint32
+ pdanscan uint32
+ pdobscan uint32
+ pdreact uint32
+ pdbusy uint32
+ pdpageouts uint32
+ pdpending uint32
+ pddeact uint32
+ pdreanon uint32
+ pdrevnode uint32
+ pdrevtext uint32
+ fpswtch uint32
+ kmapent uint32
+}
+
+type Bcachestats struct {
+ numbufs uint64
+ numbufpages uint64
+ numdirtypages uint64
+ numcleanpages uint64
+ pendingwrites uint64
+ pendingreads uint64
+ numwrites uint64
+ numreads uint64
+ cachehits uint64
+ busymapped uint64
+ dmapages uint64
+ highpages uint64
+ delwribufs uint64
+ kvaslots uint64
+ kvaslots_avail uint64
+}
+
+type Swapent struct {
+ se_dev C.dev_t
+ se_flags int32
+ se_nblks int32
+ se_inuse int32
+ se_priority int32
+ sw_path []byte
+}
+
+func (self *FileSystemList) Get() error {
+ num, err := syscall.Getfsstat(nil, C.MNT_NOWAIT)
+ if err != nil {
+ return err
+ }
+
+ buf := make([]syscall.Statfs_t, num)
+
+ _, err = syscall.Getfsstat(buf, C.MNT_NOWAIT)
+ if err != nil {
+ return err
+ }
+
+ fslist := make([]FileSystem, 0, num)
+
+ for i := 0; i < num; i++ {
+ fs := FileSystem{}
+
+ fs.DirName = bytePtrToString(&buf[i].F_mntonname[0])
+ fs.DevName = bytePtrToString(&buf[i].F_mntfromname[0])
+ fs.SysTypeName = bytePtrToString(&buf[i].F_fstypename[0])
+
+ fslist = append(fslist, fs)
+ }
+
+ self.List = fslist
+
+ return err
+}
+
+func (self *FileSystemUsage) Get(path string) error {
+ stat := syscall.Statfs_t{}
+ err := syscall.Statfs(path, &stat)
+ if err != nil {
+ return err
+ }
+
+ self.Total = uint64(stat.F_blocks) * uint64(stat.F_bsize)
+ self.Free = uint64(stat.F_bfree) * uint64(stat.F_bsize)
+ self.Avail = uint64(stat.F_bavail) * uint64(stat.F_bsize)
+ self.Used = self.Total - self.Free
+ self.Files = stat.F_files
+ self.FreeFiles = stat.F_ffree
+
+ return nil
+}
+
+func (self *FDUsage) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *LoadAverage) Get() error {
+ avg := []C.double{0, 0, 0}
+
+ C.getloadavg(&avg[0], C.int(len(avg)))
+
+ self.One = float64(avg[0])
+ self.Five = float64(avg[1])
+ self.Fifteen = float64(avg[2])
+
+ return nil
+}
+
+func (self *Uptime) Get() error {
+ tv := syscall.Timeval{}
+ mib := [2]int32{C.CTL_KERN, C.KERN_BOOTTIME}
+
+ n := uintptr(0)
+ // First we determine how much memory we'll need to pass later on (via `n`)
+ _, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ // Now perform the actual sysctl(3) call, storing the result in tv
+ _, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&tv)), uintptr(unsafe.Pointer(&n)), 0, 0)
+
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ self.Length = time.Since(time.Unix(int64(tv.Sec), int64(tv.Usec)*1000)).Seconds()
+
+ return nil
+}
+
+func (self *Mem) Get() error {
+ n := uintptr(0)
+
+ var uvmexp Uvmexp
+ mib := [2]int32{C.CTL_VM, C.VM_UVMEXP}
+ n = uintptr(0)
+ // First we determine how much memory we'll need to pass later on (via `n`)
+ _, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ _, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&uvmexp)), uintptr(unsafe.Pointer(&n)), 0, 0)
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ var bcachestats Bcachestats
+ mib3 := [3]int32{C.CTL_VFS, C.VFS_GENERIC, C.VFS_BCACHESTAT}
+ n = uintptr(0)
+ _, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib3[0])), 3, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+ if errno != 0 || n == 0 {
+ return nil
+ }
+ _, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib3[0])), 3, uintptr(unsafe.Pointer(&bcachestats)), uintptr(unsafe.Pointer(&n)), 0, 0)
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ self.Total = uint64(uvmexp.npages) << uvmexp.pageshift
+ self.Used = uint64(uvmexp.npages-uvmexp.free) << uvmexp.pageshift
+ self.Free = uint64(uvmexp.free) << uvmexp.pageshift
+
+ self.ActualFree = self.Free + (uint64(bcachestats.numbufpages) << uvmexp.pageshift)
+ self.ActualUsed = self.Used - (uint64(bcachestats.numbufpages) << uvmexp.pageshift)
+
+ return nil
+}
+
+func (self *Swap) Get() error {
+ nswap := C.swapctl(C.SWAP_NSWAP, unsafe.Pointer(uintptr(0)), 0)
+
+ // If there are no swap devices, nothing to do here.
+ if nswap == 0 {
+ return nil
+ }
+
+ swdev := make([]Swapent, nswap)
+
+ rnswap := C.swapctl(C.SWAP_STATS, unsafe.Pointer(&swdev[0]), nswap)
+ if rnswap == 0 {
+ return nil
+ }
+
+ for i := 0; i < int(nswap); i++ {
+ if swdev[i].se_flags&C.SWF_ENABLE == 2 {
+ self.Used = self.Used + uint64(swdev[i].se_inuse/(1024/C.DEV_BSIZE))
+ self.Total = self.Total + uint64(swdev[i].se_nblks/(1024/C.DEV_BSIZE))
+ }
+ }
+
+ self.Free = self.Total - self.Used
+
+ return nil
+}
+
+func (self *Cpu) Get() error {
+ load := [C.CPUSTATES]C.long{C.CP_USER, C.CP_NICE, C.CP_SYS, C.CP_INTR, C.CP_IDLE}
+
+ mib := [2]int32{C.CTL_KERN, C.KERN_CPTIME}
+ n := uintptr(0)
+ // First we determine how much memory we'll need to pass later on (via `n`)
+ _, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ _, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&load)), uintptr(unsafe.Pointer(&n)), 0, 0)
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ self.User = uint64(load[0])
+ self.Nice = uint64(load[1])
+ self.Sys = uint64(load[2])
+ self.Irq = uint64(load[3])
+ self.Idle = uint64(load[4])
+
+ return nil
+}
+
+func (self *CpuList) Get() error {
+ mib := [2]int32{C.CTL_HW, C.HW_NCPU}
+ var ncpu int
+
+ n := uintptr(0)
+ // First we determine how much memory we'll need to pass later on (via `n`)
+ _, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ // Now perform the actual sysctl(3) call, storing the result in ncpu
+ _, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 2, uintptr(unsafe.Pointer(&ncpu)), uintptr(unsafe.Pointer(&n)), 0, 0)
+
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ load := [C.CPUSTATES]C.long{C.CP_USER, C.CP_NICE, C.CP_SYS, C.CP_INTR, C.CP_IDLE}
+
+ self.List = make([]Cpu, ncpu)
+ for curcpu := range self.List {
+ sysctlCptime(ncpu, curcpu, &load)
+ fillCpu(&self.List[curcpu], load)
+ }
+
+ return nil
+}
+
+func (self *ProcList) Get() error {
+ return nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+ return nil
+}
+
+func (self *ProcEnv) Get(pid int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcState) Get(pid int) error {
+ return nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+ return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcExe) Get(pid int) error {
+ return nil
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func fillCpu(cpu *Cpu, load [C.CPUSTATES]C.long) {
+ cpu.User = uint64(load[0])
+ cpu.Nice = uint64(load[1])
+ cpu.Sys = uint64(load[2])
+ cpu.Irq = uint64(load[3])
+ cpu.Idle = uint64(load[4])
+}
+
+func sysctlCptime(ncpu int, curcpu int, load *[C.CPUSTATES]C.long) error {
+ var mib []int32
+
+ // Use the correct mib based on the number of CPUs and fill out the
+ // current CPU number in case of SMP. (0 indexed cf. self.List)
+ if ncpu == 0 {
+ mib = []int32{C.CTL_KERN, C.KERN_CPTIME}
+ } else {
+ mib = []int32{C.CTL_KERN, C.KERN_CPTIME2, int32(curcpu)}
+ }
+
+ len := len(mib)
+
+ n := uintptr(0)
+ // First we determine how much memory we'll need to pass later on (via `n`)
+ _, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), uintptr(len), 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ _, _, errno = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), uintptr(len), uintptr(unsafe.Pointer(load)), uintptr(unsafe.Pointer(&n)), 0, 0)
+ if errno != 0 || n == 0 {
+ return nil
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_stub.go b/vendor/github.com/elastic/gosigar/sigar_stub.go
new file mode 100644
index 000000000..0b858f1c0
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_stub.go
@@ -0,0 +1,71 @@
+// +build !darwin,!freebsd,!linux,!openbsd,!windows
+
+package gosigar
+
+import (
+ "runtime"
+)
+
+func (c *Cpu) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (l *LoadAverage) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (m *Mem) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (s *Swap) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (f *FDUsage) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcTime) Get(int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *FileSystemUsage) Get(path string) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *CpuList) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcState) Get(int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcExe) Get(int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcMem) Get(int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcFDUsage) Get(int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcEnv) Get(int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcList) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (p *ProcArgs) Get(int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Rusage) Get(int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_unix.go b/vendor/github.com/elastic/gosigar/sigar_unix.go
new file mode 100644
index 000000000..3f3a9f7ff
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_unix.go
@@ -0,0 +1,69 @@
+// Copyright (c) 2012 VMware, Inc.
+
+// +build darwin freebsd linux
+
+package gosigar
+
+import (
+ "syscall"
+ "time"
+
+ "golang.org/x/sys/unix"
+)
+
+func (self *FileSystemUsage) Get(path string) error {
+ stat := syscall.Statfs_t{}
+ err := syscall.Statfs(path, &stat)
+ if err != nil {
+ return err
+ }
+
+ self.Total = uint64(stat.Blocks) * uint64(stat.Bsize)
+ self.Free = uint64(stat.Bfree) * uint64(stat.Bsize)
+ self.Avail = uint64(stat.Bavail) * uint64(stat.Bsize)
+ self.Used = self.Total - self.Free
+ self.Files = stat.Files
+ self.FreeFiles = uint64(stat.Ffree)
+
+ return nil
+}
+
+func (r *Rusage) Get(who int) error {
+ ru, err := getResourceUsage(who)
+ if err != nil {
+ return err
+ }
+
+ uTime := convertRtimeToDur(ru.Utime)
+ sTime := convertRtimeToDur(ru.Stime)
+
+ r.Utime = uTime
+ r.Stime = sTime
+ r.Maxrss = int64(ru.Maxrss)
+ r.Ixrss = int64(ru.Ixrss)
+ r.Idrss = int64(ru.Idrss)
+ r.Isrss = int64(ru.Isrss)
+ r.Minflt = int64(ru.Minflt)
+ r.Majflt = int64(ru.Majflt)
+ r.Nswap = int64(ru.Nswap)
+ r.Inblock = int64(ru.Inblock)
+ r.Oublock = int64(ru.Oublock)
+ r.Msgsnd = int64(ru.Msgsnd)
+ r.Msgrcv = int64(ru.Msgrcv)
+ r.Nsignals = int64(ru.Nsignals)
+ r.Nvcsw = int64(ru.Nvcsw)
+ r.Nivcsw = int64(ru.Nivcsw)
+
+ return nil
+}
+
+func getResourceUsage(who int) (unix.Rusage, error) {
+ r := unix.Rusage{}
+ err := unix.Getrusage(who, &r)
+
+ return r, err
+}
+
+func convertRtimeToDur(t unix.Timeval) time.Duration {
+ return time.Duration(t.Nano())
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_util.go b/vendor/github.com/elastic/gosigar/sigar_util.go
new file mode 100644
index 000000000..bf93b02b2
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_util.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+ "unsafe"
+)
+
+func bytePtrToString(ptr *int8) string {
+ bytes := (*[10000]byte)(unsafe.Pointer(ptr))
+
+ n := 0
+ for bytes[n] != 0 {
+ n++
+ }
+
+ return string(bytes[0:n])
+}
+
+func chop(buf []byte) []byte {
+ return buf[0 : len(buf)-1]
+}
diff --git a/vendor/github.com/elastic/gosigar/sigar_windows.go b/vendor/github.com/elastic/gosigar/sigar_windows.go
new file mode 100644
index 000000000..0cdf928d1
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sigar_windows.go
@@ -0,0 +1,437 @@
+// Copyright (c) 2012 VMware, Inc.
+
+package gosigar
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "sync"
+ "syscall"
+ "time"
+
+ "github.com/StackExchange/wmi"
+ "github.com/elastic/gosigar/sys/windows"
+ "github.com/pkg/errors"
+)
+
+// Win32_Process represents a process on the Windows operating system. If
+// additional fields are added here (that match the Windows struct) they will
+// automatically be populated when calling getWin32Process.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa394372(v=vs.85).aspx
+type Win32_Process struct {
+ CommandLine string
+}
+
+// Win32_OperatingSystem WMI class represents a Windows-based operating system
+// installed on a computer.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa394239(v=vs.85).aspx
+type Win32_OperatingSystem struct {
+ LastBootUpTime time.Time
+}
+
+var (
+ // version is Windows version of the host OS.
+ version = windows.GetWindowsVersion()
+
+ // processQueryLimitedInfoAccess is set to PROCESS_QUERY_INFORMATION for Windows
+ // 2003 and XP where PROCESS_QUERY_LIMITED_INFORMATION is unknown. For all newer
+ // OS versions it is set to PROCESS_QUERY_LIMITED_INFORMATION.
+ processQueryLimitedInfoAccess = windows.PROCESS_QUERY_LIMITED_INFORMATION
+
+ // bootTime is the time when the OS was last booted. This value may be nil
+ // on operating systems that do not support the WMI query used to obtain it.
+ bootTime *time.Time
+ bootTimeLock sync.Mutex
+)
+
+func init() {
+ if !version.IsWindowsVistaOrGreater() {
+ // PROCESS_QUERY_LIMITED_INFORMATION cannot be used on 2003 or XP.
+ processQueryLimitedInfoAccess = syscall.PROCESS_QUERY_INFORMATION
+ }
+}
+
+func (self *LoadAverage) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *FDUsage) Get() error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcEnv) Get(pid int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcExe) Get(pid int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *ProcFDUsage) Get(pid int) error {
+ return ErrNotImplemented{runtime.GOOS}
+}
+
+func (self *Uptime) Get() error {
+ // Minimum supported OS is Windows Vista.
+ if !version.IsWindowsVistaOrGreater() {
+ return ErrNotImplemented{runtime.GOOS}
+ }
+
+ bootTimeLock.Lock()
+ defer bootTimeLock.Unlock()
+ if bootTime == nil {
+ os, err := getWin32OperatingSystem()
+ if err != nil {
+ return errors.Wrap(err, "failed to get boot time using WMI")
+ }
+ bootTime = &os.LastBootUpTime
+ }
+
+ self.Length = time.Since(*bootTime).Seconds()
+ return nil
+}
+
+func (self *Mem) Get() error {
+ memoryStatusEx, err := windows.GlobalMemoryStatusEx()
+ if err != nil {
+ return errors.Wrap(err, "GlobalMemoryStatusEx failed")
+ }
+
+ self.Total = memoryStatusEx.TotalPhys
+ self.Free = memoryStatusEx.AvailPhys
+ self.Used = self.Total - self.Free
+ self.ActualFree = self.Free
+ self.ActualUsed = self.Used
+ return nil
+}
+
+func (self *Swap) Get() error {
+ memoryStatusEx, err := windows.GlobalMemoryStatusEx()
+ if err != nil {
+ return errors.Wrap(err, "GlobalMemoryStatusEx failed")
+ }
+
+ self.Total = memoryStatusEx.TotalPageFile
+ self.Free = memoryStatusEx.AvailPageFile
+ self.Used = self.Total - self.Free
+ return nil
+}
+
+func (self *Cpu) Get() error {
+ idle, kernel, user, err := windows.GetSystemTimes()
+ if err != nil {
+ return errors.Wrap(err, "GetSystemTimes failed")
+ }
+
+ // CPU times are reported in milliseconds by gosigar.
+ self.Idle = uint64(idle / time.Millisecond)
+ self.Sys = uint64(kernel / time.Millisecond)
+ self.User = uint64(user / time.Millisecond)
+ return nil
+}
+
+func (self *CpuList) Get() error {
+ cpus, err := windows.NtQuerySystemProcessorPerformanceInformation()
+ if err != nil {
+ return errors.Wrap(err, "NtQuerySystemProcessorPerformanceInformation failed")
+ }
+
+ self.List = make([]Cpu, 0, len(cpus))
+ for _, cpu := range cpus {
+ self.List = append(self.List, Cpu{
+ Idle: uint64(cpu.IdleTime / time.Millisecond),
+ Sys: uint64(cpu.KernelTime / time.Millisecond),
+ User: uint64(cpu.UserTime / time.Millisecond),
+ })
+ }
+ return nil
+}
+
+func (self *FileSystemList) Get() error {
+ drives, err := windows.GetLogicalDriveStrings()
+ if err != nil {
+ return errors.Wrap(err, "GetLogicalDriveStrings failed")
+ }
+
+ for _, drive := range drives {
+ dt, err := windows.GetDriveType(drive)
+ if err != nil {
+ return errors.Wrapf(err, "GetDriveType failed")
+ }
+
+ self.List = append(self.List, FileSystem{
+ DirName: drive,
+ DevName: drive,
+ TypeName: dt.String(),
+ })
+ }
+ return nil
+}
+
+// Get retrieves a list of all process identifiers (PIDs) in the system.
+func (self *ProcList) Get() error {
+ pids, err := windows.EnumProcesses()
+ if err != nil {
+ return errors.Wrap(err, "EnumProcesses failed")
+ }
+
+ // Convert uint32 PIDs to int.
+ self.List = make([]int, 0, len(pids))
+ for _, pid := range pids {
+ self.List = append(self.List, int(pid))
+ }
+ return nil
+}
+
+func (self *ProcState) Get(pid int) error {
+ var errs []error
+
+ var err error
+ self.Name, err = getProcName(pid)
+ if err != nil {
+ errs = append(errs, errors.Wrap(err, "getProcName failed"))
+ }
+
+ self.State, err = getProcStatus(pid)
+ if err != nil {
+ errs = append(errs, errors.Wrap(err, "getProcStatus failed"))
+ }
+
+ self.Ppid, err = getParentPid(pid)
+ if err != nil {
+ errs = append(errs, errors.Wrap(err, "getParentPid failed"))
+ }
+
+ self.Username, err = getProcCredName(pid)
+ if err != nil {
+ errs = append(errs, errors.Wrap(err, "getProcCredName failed"))
+ }
+
+ if len(errs) > 0 {
+ errStrs := make([]string, 0, len(errs))
+ for _, e := range errs {
+ errStrs = append(errStrs, e.Error())
+ }
+ return errors.New(strings.Join(errStrs, "; "))
+ }
+ return nil
+}
+
+// getProcName returns the process name associated with the PID.
+func getProcName(pid int) (string, error) {
+ handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+ if err != nil {
+ return "", errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+ }
+ defer syscall.CloseHandle(handle)
+
+ filename, err := windows.GetProcessImageFileName(handle)
+ if err != nil {
+ return "", errors.Wrapf(err, "GetProcessImageFileName failed for pid=%v", pid)
+ }
+
+ return filepath.Base(filename), nil
+}
+
+// getProcStatus returns the status of a process.
+func getProcStatus(pid int) (RunState, error) {
+ handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+ if err != nil {
+ return RunStateUnknown, errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+ }
+ defer syscall.CloseHandle(handle)
+
+ var exitCode uint32
+ err = syscall.GetExitCodeProcess(handle, &exitCode)
+ if err != nil {
+ return RunStateUnknown, errors.Wrapf(err, "GetExitCodeProcess failed for pid=%v")
+ }
+
+ if exitCode == 259 { //still active
+ return RunStateRun, nil
+ }
+ return RunStateSleep, nil
+}
+
+// getParentPid returns the parent process ID of a process.
+func getParentPid(pid int) (int, error) {
+ handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+ if err != nil {
+ return RunStateUnknown, errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+ }
+ defer syscall.CloseHandle(handle)
+
+ procInfo, err := windows.NtQueryProcessBasicInformation(handle)
+ if err != nil {
+ return 0, errors.Wrapf(err, "NtQueryProcessBasicInformation failed for pid=%v", pid)
+ }
+
+ return int(procInfo.InheritedFromUniqueProcessID), nil
+}
+
+func getProcCredName(pid int) (string, error) {
+ handle, err := syscall.OpenProcess(syscall.PROCESS_QUERY_INFORMATION, false, uint32(pid))
+ if err != nil {
+ return "", errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+ }
+ defer syscall.CloseHandle(handle)
+
+ // Find process token via win32.
+ var token syscall.Token
+ err = syscall.OpenProcessToken(handle, syscall.TOKEN_QUERY, &token)
+ if err != nil {
+ return "", errors.Wrapf(err, "OpenProcessToken failed for pid=%v", pid)
+ }
+
+ // Find the token user.
+ tokenUser, err := token.GetTokenUser()
+ if err != nil {
+ return "", errors.Wrapf(err, "GetTokenInformation failed for pid=%v", pid)
+ }
+
+ // Close token to prevent handle leaks.
+ err = token.Close()
+ if err != nil {
+ return "", errors.Wrapf(err, "failed while closing process token handle for pid=%v", pid)
+ }
+
+ // Look up domain account by SID.
+ account, domain, _, err := tokenUser.User.Sid.LookupAccount("")
+ if err != nil {
+ sid, sidErr := tokenUser.User.Sid.String()
+ if sidErr != nil {
+ return "", errors.Wrapf(err, "failed while looking up account name for pid=%v", pid)
+ }
+ return "", errors.Wrapf(err, "failed while looking up account name for SID=%v of pid=%v", sid, pid)
+ }
+
+ return fmt.Sprintf(`%s\%s`, domain, account), nil
+}
+
+func (self *ProcMem) Get(pid int) error {
+ handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess|windows.PROCESS_VM_READ, false, uint32(pid))
+ if err != nil {
+ return errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+ }
+ defer syscall.CloseHandle(handle)
+
+ counters, err := windows.GetProcessMemoryInfo(handle)
+ if err != nil {
+ return errors.Wrapf(err, "GetProcessMemoryInfo failed for pid=%v", pid)
+ }
+
+ self.Resident = uint64(counters.WorkingSetSize)
+ self.Size = uint64(counters.PrivateUsage)
+ return nil
+}
+
+func (self *ProcTime) Get(pid int) error {
+ cpu, err := getProcTimes(pid)
+ if err != nil {
+ return err
+ }
+
+ // Windows epoch times are expressed as time elapsed since midnight on
+ // January 1, 1601 at Greenwich, England. This converts the Filetime to
+ // unix epoch in milliseconds.
+ self.StartTime = uint64(cpu.CreationTime.Nanoseconds() / 1e6)
+
+ // Convert to millis.
+ self.User = uint64(windows.FiletimeToDuration(&cpu.UserTime).Nanoseconds() / 1e6)
+ self.Sys = uint64(windows.FiletimeToDuration(&cpu.KernelTime).Nanoseconds() / 1e6)
+ self.Total = self.User + self.Sys
+
+ return nil
+}
+
+func getProcTimes(pid int) (*syscall.Rusage, error) {
+ handle, err := syscall.OpenProcess(processQueryLimitedInfoAccess, false, uint32(pid))
+ if err != nil {
+ return nil, errors.Wrapf(err, "OpenProcess failed for pid=%v", pid)
+ }
+ defer syscall.CloseHandle(handle)
+
+ var cpu syscall.Rusage
+ if err := syscall.GetProcessTimes(handle, &cpu.CreationTime, &cpu.ExitTime, &cpu.KernelTime, &cpu.UserTime); err != nil {
+ return nil, errors.Wrapf(err, "GetProcessTimes failed for pid=%v", pid)
+ }
+
+ return &cpu, nil
+}
+
+func (self *ProcArgs) Get(pid int) error {
+ // The minimum supported client for Win32_Process is Windows Vista.
+ if !version.IsWindowsVistaOrGreater() {
+ return ErrNotImplemented{runtime.GOOS}
+ }
+
+ process, err := getWin32Process(int32(pid))
+ if err != nil {
+ return errors.Wrapf(err, "ProcArgs failed for pid=%v", pid)
+ }
+
+ self.List = []string{process.CommandLine}
+ return nil
+}
+
+func (self *FileSystemUsage) Get(path string) error {
+ freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes, err := windows.GetDiskFreeSpaceEx(path)
+ if err != nil {
+ return errors.Wrap(err, "GetDiskFreeSpaceEx failed")
+ }
+
+ self.Total = totalNumberOfBytes
+ self.Free = totalNumberOfFreeBytes
+ self.Used = self.Total - self.Free
+ self.Avail = freeBytesAvailable
+ return nil
+}
+
+// getWin32Process gets information about the process with the given process ID.
+// It uses a WMI query to get the information from the local system.
+func getWin32Process(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 Win32_Process %s: %v", query, err)
+ }
+ if len(dst) < 1 {
+ return Win32_Process{}, fmt.Errorf("could not get Win32_Process %s: Process not found", query)
+ }
+ return dst[0], nil
+}
+
+func getWin32OperatingSystem() (Win32_OperatingSystem, error) {
+ var dst []Win32_OperatingSystem
+ q := wmi.CreateQuery(&dst, "")
+ err := wmi.Query(q, &dst)
+ if err != nil {
+ return Win32_OperatingSystem{}, errors.Wrap(err, "wmi query for Win32_OperatingSystem failed")
+ }
+ if len(dst) != 1 {
+ return Win32_OperatingSystem{}, errors.New("wmi query for Win32_OperatingSystem failed")
+ }
+ return dst[0], nil
+}
+
+func (self *Rusage) Get(who int) error {
+ if who != 0 {
+ return ErrNotImplemented{runtime.GOOS}
+ }
+
+ pid := os.Getpid()
+ cpu, err := getProcTimes(pid)
+ if err != nil {
+ return err
+ }
+
+ self.Utime = windows.FiletimeToDuration(&cpu.UserTime)
+ self.Stime = windows.FiletimeToDuration(&cpu.KernelTime)
+
+ return nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/doc.go b/vendor/github.com/elastic/gosigar/sys/windows/doc.go
new file mode 100644
index 000000000..dda57aa83
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/doc.go
@@ -0,0 +1,2 @@
+// Package windows contains various Windows system call.
+package windows
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/ntquery.go b/vendor/github.com/elastic/gosigar/sys/windows/ntquery.go
new file mode 100644
index 000000000..85de365e1
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/ntquery.go
@@ -0,0 +1,132 @@
+// +build windows
+
+package windows
+
+import (
+ "bytes"
+ "encoding/binary"
+ "io"
+ "runtime"
+ "syscall"
+ "time"
+ "unsafe"
+
+ "github.com/pkg/errors"
+)
+
+// On both 32-bit and 64-bit systems NtQuerySystemInformation expects the
+// size of SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION to be 48.
+const sizeofSystemProcessorPerformanceInformation = 48
+
+// ProcessBasicInformation is an equivalent representation of
+// PROCESS_BASIC_INFORMATION in the Windows API.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684280(v=vs.85).aspx
+type ProcessBasicInformation struct {
+ ExitStatus uint
+ PebBaseAddress uintptr
+ AffinityMask uint
+ BasePriority uint
+ UniqueProcessID uint
+ InheritedFromUniqueProcessID uint
+}
+
+// NtQueryProcessBasicInformation queries basic information about the process
+// associated with the given handle (provided by OpenProcess). It uses the
+// NtQueryInformationProcess function to collect the data.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684280(v=vs.85).aspx
+func NtQueryProcessBasicInformation(handle syscall.Handle) (ProcessBasicInformation, error) {
+ var processBasicInfo ProcessBasicInformation
+ processBasicInfoPtr := (*byte)(unsafe.Pointer(&processBasicInfo))
+ size := uint32(unsafe.Sizeof(processBasicInfo))
+ ntStatus, _ := _NtQueryInformationProcess(handle, 0, processBasicInfoPtr, size, nil)
+ if ntStatus != 0 {
+ return ProcessBasicInformation{}, errors.Errorf("NtQueryInformationProcess failed, NTSTATUS=0x%X", ntStatus)
+ }
+
+ return processBasicInfo, nil
+}
+
+// SystemProcessorPerformanceInformation contains CPU performance information
+// for a single CPU.
+type SystemProcessorPerformanceInformation struct {
+ IdleTime time.Duration // Amount of time spent idle.
+ KernelTime time.Duration // Kernel time does NOT include time spent in idle.
+ UserTime time.Duration // Amount of time spent executing in user mode.
+}
+
+// _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION is an equivalent representation of
+// SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION in the Windows API. This struct is
+// used internally with NtQuerySystemInformation call and is not exported. The
+// exported equivalent is SystemProcessorPerformanceInformation.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx
+type _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION struct {
+ IdleTime int64
+ KernelTime int64
+ UserTime int64
+ Reserved1 [2]int64
+ Reserved2 uint32
+}
+
+// NtQuerySystemProcessorPerformanceInformation queries CPU performance
+// information for each CPU. It uses the NtQuerySystemInformation function to
+// collect the SystemProcessorPerformanceInformation.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx
+func NtQuerySystemProcessorPerformanceInformation() ([]SystemProcessorPerformanceInformation, error) {
+ // NTSTATUS code for success.
+ // https://msdn.microsoft.com/en-us/library/cc704588.aspx
+ const STATUS_SUCCESS = 0
+
+ // From the _SYSTEM_INFORMATION_CLASS enum.
+ // http://processhacker.sourceforge.net/doc/ntexapi_8h.html#ad5d815b48e8f4da1ef2eb7a2f18a54e0
+ const systemProcessorPerformanceInformation = 8
+
+ // Create a buffer large enough to hold an entry for each processor.
+ b := make([]byte, runtime.NumCPU()*sizeofSystemProcessorPerformanceInformation)
+
+ // Query the performance information. Note that this function uses 0 to
+ // indicate success. Most other Windows functions use non-zero for success.
+ var returnLength uint32
+ ntStatus, _ := _NtQuerySystemInformation(systemProcessorPerformanceInformation, &b[0], uint32(len(b)), &returnLength)
+ if ntStatus != STATUS_SUCCESS {
+ return nil, errors.Errorf("NtQuerySystemInformation failed, NTSTATUS=0x%X, bufLength=%v, returnLength=%v", ntStatus, len(b), returnLength)
+ }
+
+ return readSystemProcessorPerformanceInformationBuffer(b)
+}
+
+// readSystemProcessorPerformanceInformationBuffer reads from a buffer
+// containing SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION data. The buffer should
+// contain one entry for each CPU.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724509(v=vs.85).aspx
+func readSystemProcessorPerformanceInformationBuffer(b []byte) ([]SystemProcessorPerformanceInformation, error) {
+ n := len(b) / sizeofSystemProcessorPerformanceInformation
+ r := bytes.NewReader(b)
+
+ rtn := make([]SystemProcessorPerformanceInformation, 0, n)
+ for i := 0; i < n; i++ {
+ _, err := r.Seek(int64(i*sizeofSystemProcessorPerformanceInformation), io.SeekStart)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to seek to cpuN=%v in buffer", i)
+ }
+
+ times := make([]uint64, 3)
+ for j := range times {
+ err := binary.Read(r, binary.LittleEndian, &times[j])
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed reading cpu times for cpuN=%v", i)
+ }
+ }
+
+ idleTime := time.Duration(times[0] * 100)
+ kernelTime := time.Duration(times[1] * 100)
+ userTime := time.Duration(times[2] * 100)
+
+ rtn = append(rtn, SystemProcessorPerformanceInformation{
+ IdleTime: idleTime,
+ KernelTime: kernelTime - idleTime, // Subtract out idle time from kernel time.
+ UserTime: userTime,
+ })
+ }
+
+ return rtn, nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/privileges.go b/vendor/github.com/elastic/gosigar/sys/windows/privileges.go
new file mode 100644
index 000000000..28c78fd22
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/privileges.go
@@ -0,0 +1,272 @@
+// +build windows
+
+package windows
+
+import (
+ "bytes"
+ "encoding/binary"
+ "encoding/json"
+ "fmt"
+ "runtime"
+ "strings"
+ "sync"
+ "syscall"
+
+ "github.com/pkg/errors"
+ "golang.org/x/sys/windows"
+)
+
+// Cache of privilege names to LUIDs.
+var (
+ privNames = make(map[string]int64)
+ privNameMutex sync.Mutex
+)
+
+const (
+ // SeDebugPrivilege is the name of the privilege used to debug programs.
+ SeDebugPrivilege = "SeDebugPrivilege"
+)
+
+// Errors returned by AdjustTokenPrivileges.
+const (
+ ERROR_NOT_ALL_ASSIGNED syscall.Errno = 1300
+)
+
+// Attribute bits for privileges.
+const (
+ _SE_PRIVILEGE_ENABLED_BY_DEFAULT uint32 = 0x00000001
+ _SE_PRIVILEGE_ENABLED uint32 = 0x00000002
+ _SE_PRIVILEGE_REMOVED uint32 = 0x00000004
+ _SE_PRIVILEGE_USED_FOR_ACCESS uint32 = 0x80000000
+)
+
+// Privilege contains information about a single privilege associated with a
+// Token.
+type Privilege struct {
+ LUID int64 `json:"-"` // Locally unique identifier (guaranteed only until the system is restarted).
+ Name string `json:"-"`
+ EnabledByDefault bool `json:"enabled_by_default,omitempty"`
+ Enabled bool `json:"enabled"`
+ Removed bool `json:"removed,omitempty"`
+ Used bool `json:"used,omitempty"`
+}
+
+func (p Privilege) String() string {
+ var buf bytes.Buffer
+ buf.WriteString(p.Name)
+ buf.WriteString("=(")
+
+ opts := make([]string, 0, 4)
+ if p.EnabledByDefault {
+ opts = append(opts, "Default")
+ }
+ if p.Enabled {
+ opts = append(opts, "Enabled")
+ }
+ if !p.EnabledByDefault && !p.Enabled {
+ opts = append(opts, "Disabled")
+ }
+ if p.Removed {
+ opts = append(opts, "Removed")
+ }
+ if p.Used {
+ opts = append(opts, "Used")
+ }
+
+ buf.WriteString(strings.Join(opts, ", "))
+ buf.WriteString(")")
+
+ // Example: SeDebugPrivilege=(Default, Enabled)
+ return buf.String()
+}
+
+// User represent the information about a Windows account.
+type User struct {
+ SID string
+ Account string
+ Domain string
+ Type uint32
+}
+
+func (u User) String() string {
+ return fmt.Sprintf(`User:%v\%v, SID:%v, Type:%v`, u.Domain, u.Account, u.SID, u.Type)
+}
+
+// DebugInfo contains general debug info about the current process.
+type DebugInfo struct {
+ OSVersion Version // OS version info.
+ Arch string // Architecture of the machine.
+ NumCPU int // Number of CPUs.
+ User User // User that this process is running as.
+ ProcessPrivs map[string]Privilege // Privileges held by the process.
+}
+
+func (d DebugInfo) String() string {
+ bytes, _ := json.Marshal(d)
+ return string(bytes)
+}
+
+// LookupPrivilegeName looks up a privilege name given a LUID value.
+func LookupPrivilegeName(systemName string, luid int64) (string, error) {
+ buf := make([]uint16, 256)
+ bufSize := uint32(len(buf))
+ err := _LookupPrivilegeName(systemName, &luid, &buf[0], &bufSize)
+ if err != nil {
+ return "", errors.Wrapf(err, "LookupPrivilegeName failed for luid=%v", luid)
+ }
+
+ return syscall.UTF16ToString(buf), nil
+}
+
+// mapPrivileges maps privilege names to LUID values.
+func mapPrivileges(names []string) ([]int64, error) {
+ var privileges []int64
+ privNameMutex.Lock()
+ defer privNameMutex.Unlock()
+ for _, name := range names {
+ p, ok := privNames[name]
+ if !ok {
+ err := _LookupPrivilegeValue("", name, &p)
+ if err != nil {
+ return nil, errors.Wrapf(err, "LookupPrivilegeValue failed on '%v'", name)
+ }
+ privNames[name] = p
+ }
+ privileges = append(privileges, p)
+ }
+ return privileges, nil
+}
+
+// EnableTokenPrivileges enables the specified privileges in the given
+// Token. The token must have TOKEN_ADJUST_PRIVILEGES access. If the token
+// does not already contain the privilege it cannot be enabled.
+func EnableTokenPrivileges(token syscall.Token, privileges ...string) error {
+ privValues, err := mapPrivileges(privileges)
+ if err != nil {
+ return err
+ }
+
+ var b bytes.Buffer
+ binary.Write(&b, binary.LittleEndian, uint32(len(privValues)))
+ for _, p := range privValues {
+ binary.Write(&b, binary.LittleEndian, p)
+ binary.Write(&b, binary.LittleEndian, uint32(_SE_PRIVILEGE_ENABLED))
+ }
+
+ success, err := _AdjustTokenPrivileges(token, false, &b.Bytes()[0], uint32(b.Len()), nil, nil)
+ if !success {
+ return err
+ }
+ if err == ERROR_NOT_ALL_ASSIGNED {
+ return errors.Wrap(err, "error not all privileges were assigned")
+ }
+
+ return nil
+}
+
+// GetTokenPrivileges returns a list of privileges associated with a token.
+// The provided token must have at a minimum TOKEN_QUERY access. This is a
+// wrapper around the GetTokenInformation function.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa446671(v=vs.85).aspx
+func GetTokenPrivileges(token syscall.Token) (map[string]Privilege, error) {
+ // Determine the required buffer size.
+ var size uint32
+ syscall.GetTokenInformation(token, syscall.TokenPrivileges, nil, 0, &size)
+
+ // This buffer will receive a TOKEN_PRIVILEGE structure.
+ b := bytes.NewBuffer(make([]byte, size))
+ err := syscall.GetTokenInformation(token, syscall.TokenPrivileges, &b.Bytes()[0], uint32(b.Len()), &size)
+ if err != nil {
+ return nil, errors.Wrap(err, "GetTokenInformation failed")
+ }
+
+ var privilegeCount uint32
+ err = binary.Read(b, binary.LittleEndian, &privilegeCount)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to read PrivilegeCount")
+ }
+
+ rtn := make(map[string]Privilege, privilegeCount)
+ for i := 0; i < int(privilegeCount); i++ {
+ var luid int64
+ err = binary.Read(b, binary.LittleEndian, &luid)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to read LUID value")
+ }
+
+ var attributes uint32
+ err = binary.Read(b, binary.LittleEndian, &attributes)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to read attributes")
+ }
+
+ name, err := LookupPrivilegeName("", luid)
+ if err != nil {
+ return nil, errors.Wrapf(err, "LookupPrivilegeName failed for LUID=%v", luid)
+ }
+
+ rtn[name] = Privilege{
+ LUID: luid,
+ Name: name,
+ EnabledByDefault: (attributes & _SE_PRIVILEGE_ENABLED_BY_DEFAULT) > 0,
+ Enabled: (attributes & _SE_PRIVILEGE_ENABLED) > 0,
+ Removed: (attributes & _SE_PRIVILEGE_REMOVED) > 0,
+ Used: (attributes & _SE_PRIVILEGE_USED_FOR_ACCESS) > 0,
+ }
+ }
+
+ return rtn, nil
+}
+
+// GetTokenUser returns the User associated with the given Token.
+func GetTokenUser(token syscall.Token) (User, error) {
+ tokenUser, err := token.GetTokenUser()
+ if err != nil {
+ return User{}, errors.Wrap(err, "GetTokenUser failed")
+ }
+
+ var user User
+ user.SID, err = tokenUser.User.Sid.String()
+ if err != nil {
+ return user, errors.Wrap(err, "ConvertSidToStringSid failed")
+ }
+
+ user.Account, user.Domain, user.Type, err = tokenUser.User.Sid.LookupAccount("")
+ if err != nil {
+ return user, errors.Wrap(err, "LookupAccountSid failed")
+ }
+
+ return user, nil
+}
+
+// GetDebugInfo returns general debug info about the current process.
+func GetDebugInfo() (*DebugInfo, error) {
+ h, err := windows.GetCurrentProcess()
+ if err != nil {
+ return nil, err
+ }
+
+ var token syscall.Token
+ err = syscall.OpenProcessToken(syscall.Handle(h), syscall.TOKEN_QUERY, &token)
+ if err != nil {
+ return nil, err
+ }
+
+ privs, err := GetTokenPrivileges(token)
+ if err != nil {
+ return nil, err
+ }
+
+ user, err := GetTokenUser(token)
+ if err != nil {
+ return nil, err
+ }
+
+ return &DebugInfo{
+ User: user,
+ ProcessPrivs: privs,
+ OSVersion: GetWindowsVersion(),
+ Arch: runtime.GOARCH,
+ NumCPU: runtime.NumCPU(),
+ }, nil
+}
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/syscall_windows.go b/vendor/github.com/elastic/gosigar/sys/windows/syscall_windows.go
new file mode 100644
index 000000000..88df0febf
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/syscall_windows.go
@@ -0,0 +1,385 @@
+package windows
+
+import (
+ "fmt"
+ "syscall"
+ "time"
+ "unsafe"
+
+ "github.com/pkg/errors"
+)
+
+var (
+ sizeofUint32 = 4
+ sizeofProcessEntry32 = uint32(unsafe.Sizeof(ProcessEntry32{}))
+ sizeofProcessMemoryCountersEx = uint32(unsafe.Sizeof(ProcessMemoryCountersEx{}))
+ sizeofMemoryStatusEx = uint32(unsafe.Sizeof(MemoryStatusEx{}))
+)
+
+// Process-specific access rights. Others are declared in the syscall package.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684880(v=vs.85).aspx
+const (
+ PROCESS_QUERY_LIMITED_INFORMATION uint32 = 0x1000
+ PROCESS_VM_READ uint32 = 0x0010
+)
+
+// MAX_PATH is the maximum length for a path in Windows.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
+const MAX_PATH = 260
+
+// DriveType represents a type of drive (removable, fixed, CD-ROM, RAM disk, or
+// network drive).
+type DriveType uint32
+
+// Drive types as returned by GetDriveType.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364939(v=vs.85).aspx
+const (
+ DRIVE_UNKNOWN DriveType = iota
+ DRIVE_NO_ROOT_DIR
+ DRIVE_REMOVABLE
+ DRIVE_FIXED
+ DRIVE_REMOTE
+ DRIVE_CDROM
+ DRIVE_RAMDISK
+)
+
+func (dt DriveType) String() string {
+ names := map[DriveType]string{
+ DRIVE_UNKNOWN: "unknown",
+ DRIVE_NO_ROOT_DIR: "invalid",
+ DRIVE_REMOVABLE: "removable",
+ DRIVE_FIXED: "fixed",
+ DRIVE_REMOTE: "remote",
+ DRIVE_CDROM: "cdrom",
+ DRIVE_RAMDISK: "ramdisk",
+ }
+
+ name, found := names[dt]
+ if !found {
+ return "unknown DriveType value"
+ }
+ return name
+}
+
+// Flags that can be used with CreateToolhelp32Snapshot.
+const (
+ TH32CS_INHERIT uint32 = 0x80000000 // Indicates that the snapshot handle is to be inheritable.
+ TH32CS_SNAPHEAPLIST uint32 = 0x00000001 // Includes all heaps of the process specified in th32ProcessID in the snapshot.
+ TH32CS_SNAPMODULE uint32 = 0x00000008 // Includes all modules of the process specified in th32ProcessID in the snapshot.
+ TH32CS_SNAPMODULE32 uint32 = 0x00000010 // Includes all 32-bit modules of the process specified in th32ProcessID in the snapshot when called from a 64-bit process.
+ TH32CS_SNAPPROCESS uint32 = 0x00000002 // Includes all processes in the system in the snapshot.
+ TH32CS_SNAPTHREAD uint32 = 0x00000004 // Includes all threads in the system in the snapshot.
+)
+
+// ProcessEntry32 is an equivalent representation of PROCESSENTRY32 in the
+// Windows API. It contains a process's information. Do not modify or reorder.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684839(v=vs.85).aspx
+type ProcessEntry32 struct {
+ size uint32
+ CntUsage uint32
+ ProcessID uint32
+ DefaultHeapID uintptr
+ ModuleID uint32
+ CntThreads uint32
+ ParentProcessID uint32
+ PriorityClassBase int32
+ Flags uint32
+ exeFile [MAX_PATH]uint16
+}
+
+// ExeFile returns the name of the executable file for the process. It does
+// not contain the full path.
+func (p ProcessEntry32) ExeFile() string {
+ return syscall.UTF16ToString(p.exeFile[:])
+}
+
+func (p ProcessEntry32) String() string {
+ return fmt.Sprintf("{CntUsage:%v ProcessID:%v DefaultHeapID:%v ModuleID:%v "+
+ "CntThreads:%v ParentProcessID:%v PriorityClassBase:%v Flags:%v ExeFile:%v",
+ p.CntUsage, p.ProcessID, p.DefaultHeapID, p.ModuleID, p.CntThreads,
+ p.ParentProcessID, p.PriorityClassBase, p.Flags, p.ExeFile())
+}
+
+// MemoryStatusEx is an equivalent representation of MEMORYSTATUSEX in the
+// Windows API. It contains information about the current state of both physical
+// and virtual memory, including extended memory.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa366770
+type MemoryStatusEx struct {
+ length uint32
+ MemoryLoad uint32
+ TotalPhys uint64
+ AvailPhys uint64
+ TotalPageFile uint64
+ AvailPageFile uint64
+ TotalVirtual uint64
+ AvailVirtual uint64
+ AvailExtendedVirtual uint64
+}
+
+// ProcessMemoryCountersEx is an equivalent representation of
+// PROCESS_MEMORY_COUNTERS_EX in the Windows API.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684874(v=vs.85).aspx
+type ProcessMemoryCountersEx struct {
+ cb uint32
+ PageFaultCount uint32
+ PeakWorkingSetSize uintptr
+ WorkingSetSize uintptr
+ QuotaPeakPagedPoolUsage uintptr
+ QuotaPagedPoolUsage uintptr
+ QuotaPeakNonPagedPoolUsage uintptr
+ QuotaNonPagedPoolUsage uintptr
+ PagefileUsage uintptr
+ PeakPagefileUsage uintptr
+ PrivateUsage uintptr
+}
+
+// GetLogicalDriveStrings returns a list of drives in the system.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364975(v=vs.85).aspx
+func GetLogicalDriveStrings() ([]string, error) {
+ // Determine the size of the buffer required to receive all drives.
+ bufferLength, err := _GetLogicalDriveStringsW(0, nil)
+ if err != nil {
+ return nil, errors.Wrap(err, "GetLogicalDriveStringsW failed to get buffer length")
+ }
+ if bufferLength < 0 {
+ return nil, errors.New("GetLogicalDriveStringsW returned an invalid buffer length")
+ }
+
+ buffer := make([]uint16, bufferLength)
+ _, err = _GetLogicalDriveStringsW(uint32(len(buffer)), &buffer[0])
+ if err != nil {
+ return nil, errors.Wrap(err, "GetLogicalDriveStringsW failed")
+ }
+
+ // Split the uint16 slice at null-terminators.
+ var startIdx int
+ var drivesUTF16 [][]uint16
+ for i, value := range buffer {
+ if value == 0 {
+ drivesUTF16 = append(drivesUTF16, buffer[startIdx:i])
+ startIdx = i + 1
+ }
+ }
+
+ // Convert the utf16 slices to strings.
+ drives := make([]string, 0, len(drivesUTF16))
+ for _, driveUTF16 := range drivesUTF16 {
+ if len(driveUTF16) > 0 {
+ drives = append(drives, syscall.UTF16ToString(driveUTF16))
+ }
+ }
+
+ return drives, nil
+}
+
+// GlobalMemoryStatusEx retrieves information about the system's current usage
+// of both physical and virtual memory.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa366589(v=vs.85).aspx
+func GlobalMemoryStatusEx() (MemoryStatusEx, error) {
+ memoryStatusEx := MemoryStatusEx{length: sizeofMemoryStatusEx}
+ err := _GlobalMemoryStatusEx(&memoryStatusEx)
+ if err != nil {
+ return MemoryStatusEx{}, errors.Wrap(err, "GlobalMemoryStatusEx failed")
+ }
+
+ return memoryStatusEx, nil
+}
+
+// GetProcessMemoryInfo retrieves information about the memory usage of the
+// specified process.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683219(v=vs.85).aspx
+func GetProcessMemoryInfo(handle syscall.Handle) (ProcessMemoryCountersEx, error) {
+ processMemoryCountersEx := ProcessMemoryCountersEx{cb: sizeofProcessMemoryCountersEx}
+ err := _GetProcessMemoryInfo(handle, &processMemoryCountersEx, processMemoryCountersEx.cb)
+ if err != nil {
+ return ProcessMemoryCountersEx{}, errors.Wrap(err, "GetProcessMemoryInfo failed")
+ }
+
+ return processMemoryCountersEx, nil
+}
+
+// GetProcessImageFileName Retrieves the name of the executable file for the
+// specified process.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms683217(v=vs.85).aspx
+func GetProcessImageFileName(handle syscall.Handle) (string, error) {
+ buffer := make([]uint16, MAX_PATH)
+ _, err := _GetProcessImageFileName(handle, &buffer[0], uint32(len(buffer)))
+ if err != nil {
+ return "", errors.Wrap(err, "GetProcessImageFileName failed")
+ }
+
+ return syscall.UTF16ToString(buffer), nil
+}
+
+// GetSystemTimes retrieves system timing information. On a multiprocessor
+// system, the values returned are the sum of the designated times across all
+// processors. The returned kernel time does not include the system idle time.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724400(v=vs.85).aspx
+func GetSystemTimes() (idle, kernel, user time.Duration, err error) {
+ var idleTime, kernelTime, userTime syscall.Filetime
+ err = _GetSystemTimes(&idleTime, &kernelTime, &userTime)
+ if err != nil {
+ return 0, 0, 0, errors.Wrap(err, "GetSystemTimes failed")
+ }
+
+ idle = FiletimeToDuration(&idleTime)
+ kernel = FiletimeToDuration(&kernelTime) // Kernel time includes idle time so we subtract it out.
+ user = FiletimeToDuration(&userTime)
+
+ return idle, kernel - idle, user, nil
+}
+
+// FiletimeToDuration converts a Filetime to a time.Duration. Do not use this
+// method to convert a Filetime to an actual clock time, for that use
+// Filetime.Nanosecond().
+func FiletimeToDuration(ft *syscall.Filetime) time.Duration {
+ n := int64(ft.HighDateTime)<<32 + int64(ft.LowDateTime) // in 100-nanosecond intervals
+ return time.Duration(n * 100)
+}
+
+// GetDriveType Determines whether a disk drive is a removable, fixed, CD-ROM,
+// RAM disk, or network drive. A trailing backslash is required on the
+// rootPathName.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364939
+func GetDriveType(rootPathName string) (DriveType, error) {
+ rootPathNamePtr, err := syscall.UTF16PtrFromString(rootPathName)
+ if err != nil {
+ return DRIVE_UNKNOWN, errors.Wrapf(err, "UTF16PtrFromString failed for rootPathName=%v", rootPathName)
+ }
+
+ dt, err := _GetDriveType(rootPathNamePtr)
+ if err != nil {
+ return DRIVE_UNKNOWN, errors.Wrapf(err, "GetDriveType failed for rootPathName=%v", rootPathName)
+ }
+
+ return dt, nil
+}
+
+// EnumProcesses retrieves the process identifier for each process object in the
+// system. This function can return a max of 65536 PIDs. If there are more
+// processes than that then this will not return them all.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms682629(v=vs.85).aspx
+func EnumProcesses() ([]uint32, error) {
+ enumProcesses := func(size int) ([]uint32, error) {
+ var (
+ pids = make([]uint32, size)
+ sizeBytes = len(pids) * sizeofUint32
+ bytesWritten uint32
+ )
+
+ err := _EnumProcesses(&pids[0], uint32(sizeBytes), &bytesWritten)
+
+ pidsWritten := int(bytesWritten) / sizeofUint32
+ if int(bytesWritten)%sizeofUint32 != 0 || pidsWritten > len(pids) {
+ return nil, errors.Errorf("EnumProcesses returned an invalid bytesWritten value of %v", bytesWritten)
+ }
+ pids = pids[:pidsWritten]
+
+ return pids, err
+ }
+
+ // Retry the EnumProcesses call with larger arrays if needed.
+ size := 2048
+ var pids []uint32
+ for tries := 0; tries < 5; tries++ {
+ var err error
+ pids, err = enumProcesses(size)
+ if err != nil {
+ return nil, errors.Wrap(err, "EnumProcesses failed")
+ }
+
+ if len(pids) < size {
+ break
+ }
+
+ // Increase the size the pids array and retry the enumProcesses call
+ // because the array wasn't large enough to hold all of the processes.
+ size *= 2
+ }
+
+ return pids, nil
+}
+
+// GetDiskFreeSpaceEx retrieves information about the amount of space that is
+// available on a disk volume, which is the total amount of space, the total
+// amount of free space, and the total amount of free space available to the
+// user that is associated with the calling thread.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364937(v=vs.85).aspx
+func GetDiskFreeSpaceEx(directoryName string) (freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes uint64, err error) {
+ directoryNamePtr, err := syscall.UTF16PtrFromString(directoryName)
+ if err != nil {
+ return 0, 0, 0, errors.Wrapf(err, "UTF16PtrFromString failed for directoryName=%v", directoryName)
+ }
+
+ err = _GetDiskFreeSpaceEx(directoryNamePtr, &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes)
+ if err != nil {
+ return 0, 0, 0, err
+ }
+
+ return freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes, nil
+}
+
+// CreateToolhelp32Snapshot takes a snapshot of the specified processes, as well
+// as the heaps, modules, and threads used by these processes.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms682489(v=vs.85).aspx
+func CreateToolhelp32Snapshot(flags, pid uint32) (syscall.Handle, error) {
+ h, err := _CreateToolhelp32Snapshot(flags, pid)
+ if err != nil {
+ return syscall.InvalidHandle, err
+ }
+ if h == syscall.InvalidHandle {
+ return syscall.InvalidHandle, syscall.GetLastError()
+ }
+
+ return h, nil
+}
+
+// Process32First retrieves information about the first process encountered in a
+// system snapshot.
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684834
+func Process32First(handle syscall.Handle) (ProcessEntry32, error) {
+ processEntry32 := ProcessEntry32{size: sizeofProcessEntry32}
+ err := _Process32First(handle, &processEntry32)
+ if err != nil {
+ return ProcessEntry32{}, errors.Wrap(err, "Process32First failed")
+ }
+
+ return processEntry32, nil
+}
+
+// Process32Next retrieves information about the next process recorded in a
+// system snapshot. When there are no more processes to iterate then
+// syscall.ERROR_NO_MORE_FILES is returned (use errors.Cause() to unwrap).
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684836
+func Process32Next(handle syscall.Handle) (ProcessEntry32, error) {
+ processEntry32 := ProcessEntry32{size: sizeofProcessEntry32}
+ err := _Process32Next(handle, &processEntry32)
+ if err != nil {
+ return ProcessEntry32{}, errors.Wrap(err, "Process32Next failed")
+ }
+
+ return processEntry32, nil
+}
+
+// Use "GOOS=windows go generate -v -x ." to generate the source.
+
+// Add -trace to enable debug prints around syscalls.
+//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go syscall_windows.go
+
+// Windows API calls
+//sys _GlobalMemoryStatusEx(buffer *MemoryStatusEx) (err error) = kernel32.GlobalMemoryStatusEx
+//sys _GetLogicalDriveStringsW(bufferLength uint32, buffer *uint16) (length uint32, err error) = kernel32.GetLogicalDriveStringsW
+//sys _GetProcessMemoryInfo(handle syscall.Handle, psmemCounters *ProcessMemoryCountersEx, cb uint32) (err error) = psapi.GetProcessMemoryInfo
+//sys _GetProcessImageFileName(handle syscall.Handle, outImageFileName *uint16, size uint32) (length uint32, err error) = psapi.GetProcessImageFileNameW
+//sys _GetSystemTimes(idleTime *syscall.Filetime, kernelTime *syscall.Filetime, userTime *syscall.Filetime) (err error) = kernel32.GetSystemTimes
+//sys _GetDriveType(rootPathName *uint16) (dt DriveType, err error) = kernel32.GetDriveTypeW
+//sys _EnumProcesses(processIds *uint32, sizeBytes uint32, bytesReturned *uint32) (err error) = psapi.EnumProcesses
+//sys _GetDiskFreeSpaceEx(directoryName *uint16, freeBytesAvailable *uint64, totalNumberOfBytes *uint64, totalNumberOfFreeBytes *uint64) (err error) = kernel32.GetDiskFreeSpaceExW
+//sys _Process32First(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) = kernel32.Process32FirstW
+//sys _Process32Next(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) = kernel32.Process32NextW
+//sys _CreateToolhelp32Snapshot(flags uint32, processID uint32) (handle syscall.Handle, err error) = kernel32.CreateToolhelp32Snapshot
+//sys _NtQuerySystemInformation(systemInformationClass uint32, systemInformation *byte, systemInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) = ntdll.NtQuerySystemInformation
+//sys _NtQueryInformationProcess(processHandle syscall.Handle, processInformationClass uint32, processInformation *byte, processInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) = ntdll.NtQueryInformationProcess
+//sys _LookupPrivilegeName(systemName string, luid *int64, buffer *uint16, size *uint32) (err error) = advapi32.LookupPrivilegeNameW
+//sys _LookupPrivilegeValue(systemName string, name string, luid *int64) (err error) = advapi32.LookupPrivilegeValueW
+//sys _AdjustTokenPrivileges(token syscall.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) [true] = advapi32.AdjustTokenPrivileges
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/version.go b/vendor/github.com/elastic/gosigar/sys/windows/version.go
new file mode 100644
index 000000000..d0bca89c1
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/version.go
@@ -0,0 +1,43 @@
+// +build windows
+
+package windows
+
+import (
+ "fmt"
+ "syscall"
+)
+
+// Version identifies a Windows version by major, minor, and build number.
+type Version struct {
+ Major int
+ Minor int
+ Build int
+}
+
+// GetWindowsVersion returns the Windows version information. Applications not
+// manifested for Windows 8.1 or Windows 10 will return the Windows 8 OS version
+// value (6.2).
+//
+// For a table of version numbers see:
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms724833(v=vs.85).aspx
+func GetWindowsVersion() Version {
+ // https://msdn.microsoft.com/en-us/library/windows/desktop/ms724439(v=vs.85).aspx
+ ver, err := syscall.GetVersion()
+ if err != nil {
+ // GetVersion should never return an error.
+ panic(fmt.Errorf("GetVersion failed: %v", err))
+ }
+
+ return Version{
+ Major: int(ver & 0xFF),
+ Minor: int(ver >> 8 & 0xFF),
+ Build: int(ver >> 16),
+ }
+}
+
+// IsWindowsVistaOrGreater returns true if the Windows version is Vista or
+// greater.
+func (v Version) IsWindowsVistaOrGreater() bool {
+ // Vista is 6.0.
+ return v.Major >= 6 && v.Minor >= 0
+}
diff --git a/vendor/github.com/elastic/gosigar/sys/windows/zsyscall_windows.go b/vendor/github.com/elastic/gosigar/sys/windows/zsyscall_windows.go
new file mode 100644
index 000000000..53fae4e3b
--- /dev/null
+++ b/vendor/github.com/elastic/gosigar/sys/windows/zsyscall_windows.go
@@ -0,0 +1,260 @@
+// MACHINE GENERATED BY 'go generate' COMMAND; DO NOT EDIT
+
+package windows
+
+import "unsafe"
+import "syscall"
+
+var _ unsafe.Pointer
+
+var (
+ modkernel32 = syscall.NewLazyDLL("kernel32.dll")
+ modpsapi = syscall.NewLazyDLL("psapi.dll")
+ modntdll = syscall.NewLazyDLL("ntdll.dll")
+ modadvapi32 = syscall.NewLazyDLL("advapi32.dll")
+
+ procGlobalMemoryStatusEx = modkernel32.NewProc("GlobalMemoryStatusEx")
+ procGetLogicalDriveStringsW = modkernel32.NewProc("GetLogicalDriveStringsW")
+ procGetProcessMemoryInfo = modpsapi.NewProc("GetProcessMemoryInfo")
+ procGetProcessImageFileNameW = modpsapi.NewProc("GetProcessImageFileNameW")
+ procGetSystemTimes = modkernel32.NewProc("GetSystemTimes")
+ procGetDriveTypeW = modkernel32.NewProc("GetDriveTypeW")
+ procEnumProcesses = modpsapi.NewProc("EnumProcesses")
+ procGetDiskFreeSpaceExW = modkernel32.NewProc("GetDiskFreeSpaceExW")
+ procProcess32FirstW = modkernel32.NewProc("Process32FirstW")
+ procProcess32NextW = modkernel32.NewProc("Process32NextW")
+ procCreateToolhelp32Snapshot = modkernel32.NewProc("CreateToolhelp32Snapshot")
+ procNtQuerySystemInformation = modntdll.NewProc("NtQuerySystemInformation")
+ procNtQueryInformationProcess = modntdll.NewProc("NtQueryInformationProcess")
+ procLookupPrivilegeNameW = modadvapi32.NewProc("LookupPrivilegeNameW")
+ procLookupPrivilegeValueW = modadvapi32.NewProc("LookupPrivilegeValueW")
+ procAdjustTokenPrivileges = modadvapi32.NewProc("AdjustTokenPrivileges")
+)
+
+func _GlobalMemoryStatusEx(buffer *MemoryStatusEx) (err error) {
+ r1, _, e1 := syscall.Syscall(procGlobalMemoryStatusEx.Addr(), 1, uintptr(unsafe.Pointer(buffer)), 0, 0)
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _GetLogicalDriveStringsW(bufferLength uint32, buffer *uint16) (length uint32, err error) {
+ r0, _, e1 := syscall.Syscall(procGetLogicalDriveStringsW.Addr(), 2, uintptr(bufferLength), uintptr(unsafe.Pointer(buffer)), 0)
+ length = uint32(r0)
+ if length == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _GetProcessMemoryInfo(handle syscall.Handle, psmemCounters *ProcessMemoryCountersEx, cb uint32) (err error) {
+ r1, _, e1 := syscall.Syscall(procGetProcessMemoryInfo.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(psmemCounters)), uintptr(cb))
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _GetProcessImageFileName(handle syscall.Handle, outImageFileName *uint16, size uint32) (length uint32, err error) {
+ r0, _, e1 := syscall.Syscall(procGetProcessImageFileNameW.Addr(), 3, uintptr(handle), uintptr(unsafe.Pointer(outImageFileName)), uintptr(size))
+ length = uint32(r0)
+ if length == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _GetSystemTimes(idleTime *syscall.Filetime, kernelTime *syscall.Filetime, userTime *syscall.Filetime) (err error) {
+ r1, _, e1 := syscall.Syscall(procGetSystemTimes.Addr(), 3, uintptr(unsafe.Pointer(idleTime)), uintptr(unsafe.Pointer(kernelTime)), uintptr(unsafe.Pointer(userTime)))
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _GetDriveType(rootPathName *uint16) (dt DriveType, err error) {
+ r0, _, e1 := syscall.Syscall(procGetDriveTypeW.Addr(), 1, uintptr(unsafe.Pointer(rootPathName)), 0, 0)
+ dt = DriveType(r0)
+ if dt == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _EnumProcesses(processIds *uint32, sizeBytes uint32, bytesReturned *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall(procEnumProcesses.Addr(), 3, uintptr(unsafe.Pointer(processIds)), uintptr(sizeBytes), uintptr(unsafe.Pointer(bytesReturned)))
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _GetDiskFreeSpaceEx(directoryName *uint16, freeBytesAvailable *uint64, totalNumberOfBytes *uint64, totalNumberOfFreeBytes *uint64) (err error) {
+ r1, _, e1 := syscall.Syscall6(procGetDiskFreeSpaceExW.Addr(), 4, uintptr(unsafe.Pointer(directoryName)), uintptr(unsafe.Pointer(freeBytesAvailable)), uintptr(unsafe.Pointer(totalNumberOfBytes)), uintptr(unsafe.Pointer(totalNumberOfFreeBytes)), 0, 0)
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _Process32First(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) {
+ r1, _, e1 := syscall.Syscall(procProcess32FirstW.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(processEntry32)), 0)
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _Process32Next(handle syscall.Handle, processEntry32 *ProcessEntry32) (err error) {
+ r1, _, e1 := syscall.Syscall(procProcess32NextW.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(processEntry32)), 0)
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _CreateToolhelp32Snapshot(flags uint32, processID uint32) (handle syscall.Handle, err error) {
+ r0, _, e1 := syscall.Syscall(procCreateToolhelp32Snapshot.Addr(), 2, uintptr(flags), uintptr(processID), 0)
+ handle = syscall.Handle(r0)
+ if handle == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _NtQuerySystemInformation(systemInformationClass uint32, systemInformation *byte, systemInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) {
+ r0, _, e1 := syscall.Syscall6(procNtQuerySystemInformation.Addr(), 4, uintptr(systemInformationClass), uintptr(unsafe.Pointer(systemInformation)), uintptr(systemInformationLength), uintptr(unsafe.Pointer(returnLength)), 0, 0)
+ ntstatus = uint32(r0)
+ if ntstatus == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _NtQueryInformationProcess(processHandle syscall.Handle, processInformationClass uint32, processInformation *byte, processInformationLength uint32, returnLength *uint32) (ntstatus uint32, err error) {
+ r0, _, e1 := syscall.Syscall6(procNtQueryInformationProcess.Addr(), 5, uintptr(processHandle), uintptr(processInformationClass), uintptr(unsafe.Pointer(processInformation)), uintptr(processInformationLength), uintptr(unsafe.Pointer(returnLength)), 0)
+ ntstatus = uint32(r0)
+ if ntstatus == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _LookupPrivilegeName(systemName string, luid *int64, buffer *uint16, size *uint32) (err error) {
+ var _p0 *uint16
+ _p0, err = syscall.UTF16PtrFromString(systemName)
+ if err != nil {
+ return
+ }
+ return __LookupPrivilegeName(_p0, luid, buffer, size)
+}
+
+func __LookupPrivilegeName(systemName *uint16, luid *int64, buffer *uint16, size *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall6(procLookupPrivilegeNameW.Addr(), 4, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(luid)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)), 0, 0)
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _LookupPrivilegeValue(systemName string, name string, luid *int64) (err error) {
+ var _p0 *uint16
+ _p0, err = syscall.UTF16PtrFromString(systemName)
+ if err != nil {
+ return
+ }
+ var _p1 *uint16
+ _p1, err = syscall.UTF16PtrFromString(name)
+ if err != nil {
+ return
+ }
+ return __LookupPrivilegeValue(_p0, _p1, luid)
+}
+
+func __LookupPrivilegeValue(systemName *uint16, name *uint16, luid *int64) (err error) {
+ r1, _, e1 := syscall.Syscall(procLookupPrivilegeValueW.Addr(), 3, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(luid)))
+ if r1 == 0 {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
+
+func _AdjustTokenPrivileges(token syscall.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) {
+ var _p0 uint32
+ if releaseAll {
+ _p0 = 1
+ } else {
+ _p0 = 0
+ }
+ r0, _, e1 := syscall.Syscall6(procAdjustTokenPrivileges.Addr(), 6, uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(input)), uintptr(outputSize), uintptr(unsafe.Pointer(output)), uintptr(unsafe.Pointer(requiredSize)))
+ success = r0 != 0
+ if true {
+ if e1 != 0 {
+ err = error(e1)
+ } else {
+ err = syscall.EINVAL
+ }
+ }
+ return
+}
diff --git a/vendor/github.com/go-ole/go-ole/ChangeLog.md b/vendor/github.com/go-ole/go-ole/ChangeLog.md
new file mode 100644
index 000000000..4ba6a8c64
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ChangeLog.md
@@ -0,0 +1,49 @@
+# 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.
diff --git a/vendor/github.com/go-ole/go-ole/LICENSE b/vendor/github.com/go-ole/go-ole/LICENSE
new file mode 100644
index 000000000..623ec06f9
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2013-2017 Yasuhiro Matsumoto, <mattn.jp@gmail.com>
+
+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.
diff --git a/vendor/github.com/go-ole/go-ole/README.md b/vendor/github.com/go-ole/go-ole/README.md
new file mode 100644
index 000000000..0ea9db33c
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/README.md
@@ -0,0 +1,46 @@
+#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
diff --git a/vendor/github.com/go-ole/go-ole/appveyor.yml b/vendor/github.com/go-ole/go-ole/appveyor.yml
new file mode 100644
index 000000000..0d557ac2f
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/appveyor.yml
@@ -0,0 +1,54 @@
+# 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.5
+ 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
+ - 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
diff --git a/vendor/github.com/go-ole/go-ole/com.go b/vendor/github.com/go-ole/go-ole/com.go
new file mode 100644
index 000000000..75ebbf13f
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/com.go
@@ -0,0 +1,329 @@
+// +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(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), time.UTC), nil
+ }
+ return time.Now(), errors.New("Could not convert to time, passing current time.")
+}
diff --git a/vendor/github.com/go-ole/go-ole/com_func.go b/vendor/github.com/go-ole/go-ole/com_func.go
new file mode 100644
index 000000000..425aad323
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/com_func.go
@@ -0,0 +1,174 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/connect.go b/vendor/github.com/go-ole/go-ole/connect.go
new file mode 100644
index 000000000..b2ac2ec67
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/connect.go
@@ -0,0 +1,192 @@
+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
+}
diff --git a/vendor/github.com/go-ole/go-ole/constants.go b/vendor/github.com/go-ole/go-ole/constants.go
new file mode 100644
index 000000000..fd0c6d74b
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/constants.go
@@ -0,0 +1,153 @@
+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
+)
diff --git a/vendor/github.com/go-ole/go-ole/error.go b/vendor/github.com/go-ole/go-ole/error.go
new file mode 100644
index 000000000..096b456d3
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/error.go
@@ -0,0 +1,51 @@
+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
+}
diff --git a/vendor/github.com/go-ole/go-ole/error_func.go b/vendor/github.com/go-ole/go-ole/error_func.go
new file mode 100644
index 000000000..8a2ffaa27
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/error_func.go
@@ -0,0 +1,8 @@
+// +build !windows
+
+package ole
+
+// errstr converts error code to string.
+func errstr(errno int) string {
+ return ""
+}
diff --git a/vendor/github.com/go-ole/go-ole/error_windows.go b/vendor/github.com/go-ole/go-ole/error_windows.go
new file mode 100644
index 000000000..d0e8e6859
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/error_windows.go
@@ -0,0 +1,24 @@
+// +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]))
+}
diff --git a/vendor/github.com/go-ole/go-ole/guid.go b/vendor/github.com/go-ole/go-ole/guid.go
new file mode 100644
index 000000000..8d20f68fb
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/guid.go
@@ -0,0 +1,284 @@
+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]
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpoint.go b/vendor/github.com/go-ole/go-ole/iconnectionpoint.go
new file mode 100644
index 000000000..9e6c49f41
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpoint.go
@@ -0,0 +1,20 @@
+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))
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go b/vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go
new file mode 100644
index 000000000..5414dc3cd
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go
@@ -0,0 +1,21 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go b/vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go
new file mode 100644
index 000000000..32bc18324
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go
@@ -0,0 +1,43 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go
new file mode 100644
index 000000000..165860d19
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go
@@ -0,0 +1,17 @@
+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))
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go
new file mode 100644
index 000000000..5dfa42aae
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go
@@ -0,0 +1,11 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go
new file mode 100644
index 000000000..ad30d79ef
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go
@@ -0,0 +1,25 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/idispatch.go b/vendor/github.com/go-ole/go-ole/idispatch.go
new file mode 100644
index 000000000..d4af12409
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/idispatch.go
@@ -0,0 +1,94 @@
+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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/idispatch_func.go b/vendor/github.com/go-ole/go-ole/idispatch_func.go
new file mode 100644
index 000000000..b8fbbe319
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/idispatch_func.go
@@ -0,0 +1,19 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/idispatch_windows.go b/vendor/github.com/go-ole/go-ole/idispatch_windows.go
new file mode 100644
index 000000000..020e4f51b
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/idispatch_windows.go
@@ -0,0 +1,197 @@
+// +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
+ } else if dispatch&DISPATCH_PROPERTYPUTREF != 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
+}
diff --git a/vendor/github.com/go-ole/go-ole/ienumvariant.go b/vendor/github.com/go-ole/go-ole/ienumvariant.go
new file mode 100644
index 000000000..243389754
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ienumvariant.go
@@ -0,0 +1,19 @@
+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))
+}
diff --git a/vendor/github.com/go-ole/go-ole/ienumvariant_func.go b/vendor/github.com/go-ole/go-ole/ienumvariant_func.go
new file mode 100644
index 000000000..c14848199
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ienumvariant_func.go
@@ -0,0 +1,19 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/ienumvariant_windows.go b/vendor/github.com/go-ole/go-ole/ienumvariant_windows.go
new file mode 100644
index 000000000..4781f3b8b
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ienumvariant_windows.go
@@ -0,0 +1,63 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/iinspectable.go b/vendor/github.com/go-ole/go-ole/iinspectable.go
new file mode 100644
index 000000000..f4a19e253
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iinspectable.go
@@ -0,0 +1,18 @@
+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))
+}
diff --git a/vendor/github.com/go-ole/go-ole/iinspectable_func.go b/vendor/github.com/go-ole/go-ole/iinspectable_func.go
new file mode 100644
index 000000000..348829bf0
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iinspectable_func.go
@@ -0,0 +1,15 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iinspectable_windows.go b/vendor/github.com/go-ole/go-ole/iinspectable_windows.go
new file mode 100644
index 000000000..4519a4aa4
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iinspectable_windows.go
@@ -0,0 +1,72 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/iprovideclassinfo.go b/vendor/github.com/go-ole/go-ole/iprovideclassinfo.go
new file mode 100644
index 000000000..25f3a6f24
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iprovideclassinfo.go
@@ -0,0 +1,21 @@
+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
+}
diff --git a/vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go b/vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go
new file mode 100644
index 000000000..7e3cb63ea
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go
@@ -0,0 +1,7 @@
+// +build !windows
+
+package ole
+
+func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
+ return nil, NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go b/vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go
new file mode 100644
index 000000000..2ad016394
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go
@@ -0,0 +1,21 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/itypeinfo.go b/vendor/github.com/go-ole/go-ole/itypeinfo.go
new file mode 100644
index 000000000..dd3c5e21b
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/itypeinfo.go
@@ -0,0 +1,34 @@
+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))
+}
diff --git a/vendor/github.com/go-ole/go-ole/itypeinfo_func.go b/vendor/github.com/go-ole/go-ole/itypeinfo_func.go
new file mode 100644
index 000000000..8364a659b
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/itypeinfo_func.go
@@ -0,0 +1,7 @@
+// +build !windows
+
+package ole
+
+func (v *ITypeInfo) GetTypeAttr() (*TYPEATTR, error) {
+ return nil, NewError(E_NOTIMPL)
+}
diff --git a/vendor/github.com/go-ole/go-ole/itypeinfo_windows.go b/vendor/github.com/go-ole/go-ole/itypeinfo_windows.go
new file mode 100644
index 000000000..54782b3da
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/itypeinfo_windows.go
@@ -0,0 +1,21 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/iunknown.go b/vendor/github.com/go-ole/go-ole/iunknown.go
new file mode 100644
index 000000000..108f28ea6
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iunknown.go
@@ -0,0 +1,57 @@
+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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/iunknown_func.go b/vendor/github.com/go-ole/go-ole/iunknown_func.go
new file mode 100644
index 000000000..d0a62cfd7
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iunknown_func.go
@@ -0,0 +1,19 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/iunknown_windows.go b/vendor/github.com/go-ole/go-ole/iunknown_windows.go
new file mode 100644
index 000000000..ede5bb8c1
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/iunknown_windows.go
@@ -0,0 +1,58 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/ole.go b/vendor/github.com/go-ole/go-ole/ole.go
new file mode 100644
index 000000000..e2ae4f4bb
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/ole.go
@@ -0,0 +1,157 @@
+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
+}
+
+// WCode return wCode in EXCEPINFO.
+func (e EXCEPINFO) WCode() uint16 {
+ return e.wCode
+}
+
+// SCODE return scode in EXCEPINFO.
+func (e EXCEPINFO) SCODE() uint32 {
+ return e.scode
+}
+
+// String convert EXCEPINFO to string.
+func (e EXCEPINFO) String() string {
+ var src, desc, hlp string
+ if e.bstrSource == nil {
+ src = "<nil>"
+ } else {
+ src = BstrToString(e.bstrSource)
+ }
+
+ if e.bstrDescription == nil {
+ desc = "<nil>"
+ } else {
+ desc = BstrToString(e.bstrDescription)
+ }
+
+ if e.bstrHelpFile == nil {
+ hlp = "<nil>"
+ } 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
+}
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/connection.go b/vendor/github.com/go-ole/go-ole/oleutil/connection.go
new file mode 100644
index 000000000..60df73cda
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/connection.go
@@ -0,0 +1,100 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/connection_func.go b/vendor/github.com/go-ole/go-ole/oleutil/connection_func.go
new file mode 100644
index 000000000..8818fb827
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/connection_func.go
@@ -0,0 +1,10 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go b/vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go
new file mode 100644
index 000000000..ab9c0d8dc
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go
@@ -0,0 +1,58 @@
+// +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
+ }
+ return
+ }
+
+ container.Release()
+
+ return 0, ole.NewError(ole.E_INVALIDARG)
+}
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/go-get.go b/vendor/github.com/go-ole/go-ole/oleutil/go-get.go
new file mode 100644
index 000000000..58347628f
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/go-get.go
@@ -0,0 +1,6 @@
+// This file is here so go get succeeds as without it errors with:
+// no buildable Go source files in ...
+//
+// +build !windows
+
+package oleutil
diff --git a/vendor/github.com/go-ole/go-ole/oleutil/oleutil.go b/vendor/github.com/go-ole/go-ole/oleutil/oleutil.go
new file mode 100644
index 000000000..f7803c1e3
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/oleutil/oleutil.go
@@ -0,0 +1,127 @@
+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
+}
+
+// PutPropertyRef mutates property reference.
+func PutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+ return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUTREF, params)
+}
+
+// MustPutPropertyRef mutates property reference or panics.
+func MustPutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+ r, err := PutPropertyRef(disp, name, params...)
+ if err != nil {
+ panic(err.Error())
+ }
+ return r
+}
+
+func ForEach(disp *ole.IDispatch, f func(v *ole.VARIANT) error) error {
+ newEnum, err := disp.GetProperty("_NewEnum")
+ if err != nil {
+ return err
+ }
+ defer newEnum.Clear()
+
+ enum, err := newEnum.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+ if err != nil {
+ return err
+ }
+ defer enum.Release()
+
+ for item, length, err := enum.Next(1); length > 0; item, length, err = enum.Next(1) {
+ if err != nil {
+ return err
+ }
+ if ferr := f(&item); ferr != nil {
+ return ferr
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/go-ole/go-ole/safearray.go b/vendor/github.com/go-ole/go-ole/safearray.go
new file mode 100644
index 000000000..a5201b56c
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearray.go
@@ -0,0 +1,27 @@
+// 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
diff --git a/vendor/github.com/go-ole/go-ole/safearray_func.go b/vendor/github.com/go-ole/go-ole/safearray_func.go
new file mode 100644
index 000000000..8ff0baa41
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearray_func.go
@@ -0,0 +1,211 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/safearray_windows.go b/vendor/github.com/go-ole/go-ole/safearray_windows.go
new file mode 100644
index 000000000..b27936e24
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearray_windows.go
@@ -0,0 +1,337 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/safearrayconversion.go b/vendor/github.com/go-ole/go-ole/safearrayconversion.go
new file mode 100644
index 000000000..ffeb2b97b
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearrayconversion.go
@@ -0,0 +1,140 @@
+// 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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/safearrayslices.go b/vendor/github.com/go-ole/go-ole/safearrayslices.go
new file mode 100644
index 000000000..a9fa885f1
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/safearrayslices.go
@@ -0,0 +1,33 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/utility.go b/vendor/github.com/go-ole/go-ole/utility.go
new file mode 100644
index 000000000..99ee82dc3
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/utility.go
@@ -0,0 +1,101 @@
+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
+}
diff --git a/vendor/github.com/go-ole/go-ole/variables.go b/vendor/github.com/go-ole/go-ole/variables.go
new file mode 100644
index 000000000..ebe00f1cf
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variables.go
@@ -0,0 +1,16 @@
+// +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")
+)
diff --git a/vendor/github.com/go-ole/go-ole/variant.go b/vendor/github.com/go-ole/go-ole/variant.go
new file mode 100644
index 000000000..36969725e
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variant.go
@@ -0,0 +1,105 @@
+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
+}
diff --git a/vendor/github.com/go-ole/go-ole/variant_386.go b/vendor/github.com/go-ole/go-ole/variant_386.go
new file mode 100644
index 000000000..e73736bf3
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variant_386.go
@@ -0,0 +1,11 @@
+// +build 386
+
+package ole
+
+type VARIANT struct {
+ VT VT // 2
+ wReserved1 uint16 // 4
+ wReserved2 uint16 // 6
+ wReserved3 uint16 // 8
+ Val int64 // 16
+}
diff --git a/vendor/github.com/go-ole/go-ole/variant_amd64.go b/vendor/github.com/go-ole/go-ole/variant_amd64.go
new file mode 100644
index 000000000..dccdde132
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variant_amd64.go
@@ -0,0 +1,12 @@
+// +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
+}
diff --git a/vendor/github.com/go-ole/go-ole/variant_s390x.go b/vendor/github.com/go-ole/go-ole/variant_s390x.go
new file mode 100644
index 000000000..9874ca66b
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/variant_s390x.go
@@ -0,0 +1,12 @@
+// +build s390x
+
+package ole
+
+type VARIANT struct {
+ VT VT // 2
+ wReserved1 uint16 // 4
+ wReserved2 uint16 // 6
+ wReserved3 uint16 // 8
+ Val int64 // 16
+ _ [8]byte // 24
+}
diff --git a/vendor/github.com/go-ole/go-ole/vt_string.go b/vendor/github.com/go-ole/go-ole/vt_string.go
new file mode 100644
index 000000000..729b4a04d
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/vt_string.go
@@ -0,0 +1,58 @@
+// 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)
+ }
+}
diff --git a/vendor/github.com/go-ole/go-ole/winrt.go b/vendor/github.com/go-ole/go-ole/winrt.go
new file mode 100644
index 000000000..4e9eca732
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/winrt.go
@@ -0,0 +1,99 @@
+// +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)
+}
diff --git a/vendor/github.com/go-ole/go-ole/winrt_doc.go b/vendor/github.com/go-ole/go-ole/winrt_doc.go
new file mode 100644
index 000000000..52e6d74c9
--- /dev/null
+++ b/vendor/github.com/go-ole/go-ole/winrt_doc.go
@@ -0,0 +1,36 @@
+// +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 ""
+}
diff --git a/vendor/github.com/pkg/errors/LICENSE b/vendor/github.com/pkg/errors/LICENSE
new file mode 100644
index 000000000..835ba3e75
--- /dev/null
+++ b/vendor/github.com/pkg/errors/LICENSE
@@ -0,0 +1,23 @@
+Copyright (c) 2015, Dave Cheney <dave@cheney.net>
+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.
+
+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 HOLDER 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.
diff --git a/vendor/github.com/pkg/errors/README.md b/vendor/github.com/pkg/errors/README.md
new file mode 100644
index 000000000..6483ba2af
--- /dev/null
+++ b/vendor/github.com/pkg/errors/README.md
@@ -0,0 +1,52 @@
+# errors [![Travis-CI](https://travis-ci.org/pkg/errors.svg)](https://travis-ci.org/pkg/errors) [![AppVeyor](https://ci.appveyor.com/api/projects/status/b98mptawhudj53ep/branch/master?svg=true)](https://ci.appveyor.com/project/davecheney/errors/branch/master) [![GoDoc](https://godoc.org/github.com/pkg/errors?status.svg)](http://godoc.org/github.com/pkg/errors) [![Report card](https://goreportcard.com/badge/github.com/pkg/errors)](https://goreportcard.com/report/github.com/pkg/errors) [![Sourcegraph](https://sourcegraph.com/github.com/pkg/errors/-/badge.svg)](https://sourcegraph.com/github.com/pkg/errors?badge)
+
+Package errors provides simple error handling primitives.
+
+`go get github.com/pkg/errors`
+
+The traditional error handling idiom in Go is roughly akin to
+```go
+if err != nil {
+ return err
+}
+```
+which applied recursively up the call stack results in error reports without context or debugging information. The errors package allows programmers to add context to the failure path in their code in a way that does not destroy the original value of the error.
+
+## Adding context to an error
+
+The errors.Wrap function returns a new error that adds context to the original error. For example
+```go
+_, err := ioutil.ReadAll(r)
+if err != nil {
+ return errors.Wrap(err, "read failed")
+}
+```
+## Retrieving the cause of an error
+
+Using `errors.Wrap` constructs a stack of errors, adding context to the preceding error. Depending on the nature of the error it may be necessary to reverse the operation of errors.Wrap to retrieve the original error for inspection. Any error value which implements this interface can be inspected by `errors.Cause`.
+```go
+type causer interface {
+ Cause() error
+}
+```
+`errors.Cause` will recursively retrieve the topmost error which does not implement `causer`, which is assumed to be the original cause. For example:
+```go
+switch err := errors.Cause(err).(type) {
+case *MyError:
+ // handle specifically
+default:
+ // unknown error
+}
+```
+
+[Read the package documentation for more information](https://godoc.org/github.com/pkg/errors).
+
+## Contributing
+
+We welcome pull requests, bug fixes and issue reports. With that said, the bar for adding new symbols to this package is intentionally set high.
+
+Before proposing a change, please discuss your change by raising an issue.
+
+## License
+
+BSD-2-Clause
diff --git a/vendor/github.com/pkg/errors/appveyor.yml b/vendor/github.com/pkg/errors/appveyor.yml
new file mode 100644
index 000000000..a932eade0
--- /dev/null
+++ b/vendor/github.com/pkg/errors/appveyor.yml
@@ -0,0 +1,32 @@
+version: build-{build}.{branch}
+
+clone_folder: C:\gopath\src\github.com\pkg\errors
+shallow_clone: true # for startup speed
+
+environment:
+ GOPATH: C:\gopath
+
+platform:
+ - x64
+
+# http://www.appveyor.com/docs/installed-software
+install:
+ # some helpful output for debugging builds
+ - go version
+ - go env
+ # pre-installed MinGW at C:\MinGW is 32bit only
+ # but MSYS2 at C:\msys64 has mingw64
+ - set PATH=C:\msys64\mingw64\bin;%PATH%
+ - gcc --version
+ - g++ --version
+
+build_script:
+ - go install -v ./...
+
+test_script:
+ - set PATH=C:\gopath\bin;%PATH%
+ - go test -v ./...
+
+#artifacts:
+# - path: '%GOPATH%\bin\*.exe'
+deploy: off
diff --git a/vendor/github.com/pkg/errors/errors.go b/vendor/github.com/pkg/errors/errors.go
new file mode 100644
index 000000000..842ee8045
--- /dev/null
+++ b/vendor/github.com/pkg/errors/errors.go
@@ -0,0 +1,269 @@
+// Package errors provides simple error handling primitives.
+//
+// The traditional error handling idiom in Go is roughly akin to
+//
+// if err != nil {
+// return err
+// }
+//
+// which applied recursively up the call stack results in error reports
+// without context or debugging information. The errors package allows
+// programmers to add context to the failure path in their code in a way
+// that does not destroy the original value of the error.
+//
+// Adding context to an error
+//
+// The errors.Wrap function returns a new error that adds context to the
+// original error by recording a stack trace at the point Wrap is called,
+// and the supplied message. For example
+//
+// _, err := ioutil.ReadAll(r)
+// if err != nil {
+// return errors.Wrap(err, "read failed")
+// }
+//
+// If additional control is required the errors.WithStack and errors.WithMessage
+// functions destructure errors.Wrap into its component operations of annotating
+// an error with a stack trace and an a message, respectively.
+//
+// Retrieving the cause of an error
+//
+// Using errors.Wrap constructs a stack of errors, adding context to the
+// preceding error. Depending on the nature of the error it may be necessary
+// to reverse the operation of errors.Wrap to retrieve the original error
+// for inspection. Any error value which implements this interface
+//
+// type causer interface {
+// Cause() error
+// }
+//
+// can be inspected by errors.Cause. errors.Cause will recursively retrieve
+// the topmost error which does not implement causer, which is assumed to be
+// the original cause. For example:
+//
+// switch err := errors.Cause(err).(type) {
+// case *MyError:
+// // handle specifically
+// default:
+// // unknown error
+// }
+//
+// causer interface is not exported by this package, but is considered a part
+// of stable public API.
+//
+// Formatted printing of errors
+//
+// All error values returned from this package implement fmt.Formatter and can
+// be formatted by the fmt package. The following verbs are supported
+//
+// %s print the error. If the error has a Cause it will be
+// printed recursively
+// %v see %s
+// %+v extended format. Each Frame of the error's StackTrace will
+// be printed in detail.
+//
+// Retrieving the stack trace of an error or wrapper
+//
+// New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
+// invoked. This information can be retrieved with the following interface.
+//
+// type stackTracer interface {
+// StackTrace() errors.StackTrace
+// }
+//
+// Where errors.StackTrace is defined as
+//
+// type StackTrace []Frame
+//
+// The Frame type represents a call site in the stack trace. Frame supports
+// the fmt.Formatter interface that can be used for printing information about
+// the stack trace of this error. For example:
+//
+// if err, ok := err.(stackTracer); ok {
+// for _, f := range err.StackTrace() {
+// fmt.Printf("%+s:%d", f)
+// }
+// }
+//
+// stackTracer interface is not exported by this package, but is considered a part
+// of stable public API.
+//
+// See the documentation for Frame.Format for more details.
+package errors
+
+import (
+ "fmt"
+ "io"
+)
+
+// New returns an error with the supplied message.
+// New also records the stack trace at the point it was called.
+func New(message string) error {
+ return &fundamental{
+ msg: message,
+ stack: callers(),
+ }
+}
+
+// Errorf formats according to a format specifier and returns the string
+// as a value that satisfies error.
+// Errorf also records the stack trace at the point it was called.
+func Errorf(format string, args ...interface{}) error {
+ return &fundamental{
+ msg: fmt.Sprintf(format, args...),
+ stack: callers(),
+ }
+}
+
+// fundamental is an error that has a message and a stack, but no caller.
+type fundamental struct {
+ msg string
+ *stack
+}
+
+func (f *fundamental) Error() string { return f.msg }
+
+func (f *fundamental) Format(s fmt.State, verb rune) {
+ switch verb {
+ case 'v':
+ if s.Flag('+') {
+ io.WriteString(s, f.msg)
+ f.stack.Format(s, verb)
+ return
+ }
+ fallthrough
+ case 's':
+ io.WriteString(s, f.msg)
+ case 'q':
+ fmt.Fprintf(s, "%q", f.msg)
+ }
+}
+
+// WithStack annotates err with a stack trace at the point WithStack was called.
+// If err is nil, WithStack returns nil.
+func WithStack(err error) error {
+ if err == nil {
+ return nil
+ }
+ return &withStack{
+ err,
+ callers(),
+ }
+}
+
+type withStack struct {
+ error
+ *stack
+}
+
+func (w *withStack) Cause() error { return w.error }
+
+func (w *withStack) Format(s fmt.State, verb rune) {
+ switch verb {
+ case 'v':
+ if s.Flag('+') {
+ fmt.Fprintf(s, "%+v", w.Cause())
+ w.stack.Format(s, verb)
+ return
+ }
+ fallthrough
+ case 's':
+ io.WriteString(s, w.Error())
+ case 'q':
+ fmt.Fprintf(s, "%q", w.Error())
+ }
+}
+
+// Wrap returns an error annotating err with a stack trace
+// at the point Wrap is called, and the supplied message.
+// If err is nil, Wrap returns nil.
+func Wrap(err error, message string) error {
+ if err == nil {
+ return nil
+ }
+ err = &withMessage{
+ cause: err,
+ msg: message,
+ }
+ return &withStack{
+ err,
+ callers(),
+ }
+}
+
+// Wrapf returns an error annotating err with a stack trace
+// at the point Wrapf is call, and the format specifier.
+// If err is nil, Wrapf returns nil.
+func Wrapf(err error, format string, args ...interface{}) error {
+ if err == nil {
+ return nil
+ }
+ err = &withMessage{
+ cause: err,
+ msg: fmt.Sprintf(format, args...),
+ }
+ return &withStack{
+ err,
+ callers(),
+ }
+}
+
+// WithMessage annotates err with a new message.
+// If err is nil, WithMessage returns nil.
+func WithMessage(err error, message string) error {
+ if err == nil {
+ return nil
+ }
+ return &withMessage{
+ cause: err,
+ msg: message,
+ }
+}
+
+type withMessage struct {
+ cause error
+ msg string
+}
+
+func (w *withMessage) Error() string { return w.msg + ": " + w.cause.Error() }
+func (w *withMessage) Cause() error { return w.cause }
+
+func (w *withMessage) Format(s fmt.State, verb rune) {
+ switch verb {
+ case 'v':
+ if s.Flag('+') {
+ fmt.Fprintf(s, "%+v\n", w.Cause())
+ io.WriteString(s, w.msg)
+ return
+ }
+ fallthrough
+ case 's', 'q':
+ io.WriteString(s, w.Error())
+ }
+}
+
+// Cause returns the underlying cause of the error, if possible.
+// An error value has a cause if it implements the following
+// interface:
+//
+// type causer interface {
+// Cause() error
+// }
+//
+// If the error does not implement Cause, the original error will
+// be returned. If the error is nil, nil will be returned without further
+// investigation.
+func Cause(err error) error {
+ type causer interface {
+ Cause() error
+ }
+
+ for err != nil {
+ cause, ok := err.(causer)
+ if !ok {
+ break
+ }
+ err = cause.Cause()
+ }
+ return err
+}
diff --git a/vendor/github.com/pkg/errors/stack.go b/vendor/github.com/pkg/errors/stack.go
new file mode 100644
index 000000000..b485761a7
--- /dev/null
+++ b/vendor/github.com/pkg/errors/stack.go
@@ -0,0 +1,187 @@
+package errors
+
+import (
+ "fmt"
+ "io"
+ "path"
+ "runtime"
+ "strings"
+)
+
+// Frame represents a program counter inside a stack frame.
+type Frame uintptr
+
+// pc returns the program counter for this frame;
+// multiple frames may have the same PC value.
+func (f Frame) pc() uintptr { return uintptr(f) - 1 }
+
+// file returns the full path to the file that contains the
+// function for this Frame's pc.
+func (f Frame) file() string {
+ fn := runtime.FuncForPC(f.pc())
+ if fn == nil {
+ return "unknown"
+ }
+ file, _ := fn.FileLine(f.pc())
+ return file
+}
+
+// line returns the line number of source code of the
+// function for this Frame's pc.
+func (f Frame) line() int {
+ fn := runtime.FuncForPC(f.pc())
+ if fn == nil {
+ return 0
+ }
+ _, line := fn.FileLine(f.pc())
+ return line
+}
+
+// Format formats the frame according to the fmt.Formatter interface.
+//
+// %s source file
+// %d source line
+// %n function name
+// %v equivalent to %s:%d
+//
+// Format accepts flags that alter the printing of some verbs, as follows:
+//
+// %+s function name and path of source file relative to the compile time
+// GOPATH separated by \n\t (<funcname>\n\t<path>)
+// %+v equivalent to %+s:%d
+func (f Frame) Format(s fmt.State, verb rune) {
+ switch verb {
+ case 's':
+ switch {
+ case s.Flag('+'):
+ pc := f.pc()
+ fn := runtime.FuncForPC(pc)
+ if fn == nil {
+ io.WriteString(s, "unknown")
+ } else {
+ file, _ := fn.FileLine(pc)
+ fmt.Fprintf(s, "%s\n\t%s", fn.Name(), file)
+ }
+ default:
+ io.WriteString(s, path.Base(f.file()))
+ }
+ case 'd':
+ fmt.Fprintf(s, "%d", f.line())
+ case 'n':
+ name := runtime.FuncForPC(f.pc()).Name()
+ io.WriteString(s, funcname(name))
+ case 'v':
+ f.Format(s, 's')
+ io.WriteString(s, ":")
+ f.Format(s, 'd')
+ }
+}
+
+// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
+type StackTrace []Frame
+
+// Format formats the stack of Frames according to the fmt.Formatter interface.
+//
+// %s lists source files for each Frame in the stack
+// %v lists the source file and line number for each Frame in the stack
+//
+// Format accepts flags that alter the printing of some verbs, as follows:
+//
+// %+v Prints filename, function, and line number for each Frame in the stack.
+func (st StackTrace) Format(s fmt.State, verb rune) {
+ switch verb {
+ case 'v':
+ switch {
+ case s.Flag('+'):
+ for _, f := range st {
+ fmt.Fprintf(s, "\n%+v", f)
+ }
+ case s.Flag('#'):
+ fmt.Fprintf(s, "%#v", []Frame(st))
+ default:
+ fmt.Fprintf(s, "%v", []Frame(st))
+ }
+ case 's':
+ fmt.Fprintf(s, "%s", []Frame(st))
+ }
+}
+
+// stack represents a stack of program counters.
+type stack []uintptr
+
+func (s *stack) Format(st fmt.State, verb rune) {
+ switch verb {
+ case 'v':
+ switch {
+ case st.Flag('+'):
+ for _, pc := range *s {
+ f := Frame(pc)
+ fmt.Fprintf(st, "\n%+v", f)
+ }
+ }
+ }
+}
+
+func (s *stack) StackTrace() StackTrace {
+ f := make([]Frame, len(*s))
+ for i := 0; i < len(f); i++ {
+ f[i] = Frame((*s)[i])
+ }
+ return f
+}
+
+func callers() *stack {
+ const depth = 32
+ var pcs [depth]uintptr
+ n := runtime.Callers(3, pcs[:])
+ var st stack = pcs[0:n]
+ return &st
+}
+
+// funcname removes the path prefix component of a function's name reported by func.Name().
+func funcname(name string) string {
+ i := strings.LastIndex(name, "/")
+ name = name[i+1:]
+ i = strings.Index(name, ".")
+ return name[i+1:]
+}
+
+func trimGOPATH(name, file string) string {
+ // Here we want to get the source file path relative to the compile time
+ // GOPATH. As of Go 1.6.x there is no direct way to know the compiled
+ // GOPATH at runtime, but we can infer the number of path segments in the
+ // GOPATH. We note that fn.Name() returns the function name qualified by
+ // the import path, which does not include the GOPATH. Thus we can trim
+ // segments from the beginning of the file path until the number of path
+ // separators remaining is one more than the number of path separators in
+ // the function name. For example, given:
+ //
+ // GOPATH /home/user
+ // file /home/user/src/pkg/sub/file.go
+ // fn.Name() pkg/sub.Type.Method
+ //
+ // We want to produce:
+ //
+ // pkg/sub/file.go
+ //
+ // From this we can easily see that fn.Name() has one less path separator
+ // than our desired output. We count separators from the end of the file
+ // path until it finds two more than in the function name and then move
+ // one character forward to preserve the initial path segment without a
+ // leading separator.
+ const sep = "/"
+ goal := strings.Count(name, sep) + 2
+ i := len(file)
+ for n := 0; n < goal; n++ {
+ i = strings.LastIndex(file[:i], sep)
+ if i == -1 {
+ // not enough separators found, set i so that the slice expression
+ // below leaves file unmodified
+ i = -len(sep)
+ break
+ }
+ }
+ // get back to 0 or trim the leading separator
+ file = file[i+len(sep):]
+ return file
+}
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 979e8b34b..6962485d1 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -45,6 +45,12 @@
"revisionTime": "2017-02-15T19:58:14Z"
},
{
+ "checksumSHA1": "QC55lHNOv1+UAL2xtIHw17MJ8J8=",
+ "path": "github.com/StackExchange/wmi",
+ "revision": "5d049714c4a64225c3c79a7cf7d02f7fb5b96338",
+ "revisionTime": "2018-01-16T20:38:02Z"
+ },
+ {
"checksumSHA1": "USkefO0g1U9mr+8hagv3fpSkrxg=",
"path": "github.com/aristanetworks/goarista/monotime",
"revision": "ea17b1a17847fb6e4c0a91de0b674704693469b0",
@@ -87,6 +93,18 @@
"revisionTime": "2016-05-12T03:30:02Z"
},
{
+ "checksumSHA1": "Fc8BCxCoQ7ZmghDT6X1cASR10Ec=",
+ "path": "github.com/elastic/gosigar",
+ "revision": "a3814ce5008e612a0c6d027608b54e1d0d9a5613",
+ "revisionTime": "2018-01-22T22:25:45Z"
+ },
+ {
+ "checksumSHA1": "qDsgp2kAeI9nhj565HUScaUyjU4=",
+ "path": "github.com/elastic/gosigar/sys/windows",
+ "revision": "a3814ce5008e612a0c6d027608b54e1d0d9a5613",
+ "revisionTime": "2018-01-22T22:25:45Z"
+ },
+ {
"checksumSHA1": "7oFpbmDfGobwKsFLIf6wMUvVoKw=",
"path": "github.com/fatih/color",
"revision": "5ec5d9d3c2cf82e9688b34e9bc27a94d616a7193",
@@ -99,6 +117,18 @@
"revisionTime": "2017-01-17T22:23:42Z"
},
{
+ "checksumSHA1": "gxV/cPPLkByTdY8y172t7v4qcZA=",
+ "path": "github.com/go-ole/go-ole",
+ "revision": "a41e3c4b706f6ae8dfbff342b06e40fa4d2d0506",
+ "revisionTime": "2017-11-10T16:07:06Z"
+ },
+ {
+ "checksumSHA1": "PArleDBtadu2qO4hJwHR8a3IOTA=",
+ "path": "github.com/go-ole/go-ole/oleutil",
+ "revision": "a41e3c4b706f6ae8dfbff342b06e40fa4d2d0506",
+ "revisionTime": "2017-11-10T16:07:06Z"
+ },
+ {
"checksumSHA1": "KZ3QD2QgUS4RcoKiA3mn5pSlJxQ=",
"path": "github.com/go-stack/stack",
"revision": "54be5f394ed2c3e19dac9134a40a95ba5a017f7b",
@@ -262,6 +292,12 @@
"revisionTime": "2017-09-02T20:46:57Z"
},
{
+ "checksumSHA1": "xCv4GBFyw07vZkVtKF/XrUnkHRk=",
+ "path": "github.com/pkg/errors",
+ "revision": "e881fd58d78e04cf6d0de1217f8707c8cc2249bc",
+ "revisionTime": "2017-12-16T07:03:16Z"
+ },
+ {
"checksumSHA1": "LuFv4/jlrmFNnDb/5SCSEPAM9vU=",
"path": "github.com/pmezard/go-difflib/difflib",
"revision": "792786c7400a136282c1664665ae0a8db921c6c2",