[#ISSUE-937] : Move mail server implementation to status-go repo (#942)

* [#ISSUE-937] : Move mail server implementation to status-go repo

* Applying dep-ensure

Gopkg.lock

@@ -7,12 +7,6 @@
   packages = ["."]
   revision = "2a6c4f48b49f0d5dbfe621589da4c5405157d7c9"
 
-[[projects]]
-  branch = "master"
-  name = "github.com/StackExchange/wmi"
-  packages = ["."]
-  revision = "5d049714c4a64225c3c79a7cf7d02f7fb5b96338"
-
 [[projects]]
   name = "github.com/aristanetworks/goarista"
   packages = ["monotime"]
@@ -58,15 +52,6 @@
   packages = ["."]
   revision = "935e0e8a636ca4ba70b713f3e38a19e1b77739e8"
 
-[[projects]]
-  name = "github.com/elastic/gosigar"
-  packages = [
-    ".",
-    "sys/windows"
-  ]
-  revision = "16df19fe5efee4ea2938bde5f56c02d9929dc054"
-  version = "v0.8.0"
-
 [[projects]]
   name = "github.com/ethereum/go-ethereum"
   packages = [
@@ -78,10 +63,8 @@
     "accounts/keystore",
     "accounts/usbwallet",
     "accounts/usbwallet/internal/trezor",
-    "cmd/utils",
     "common",
     "common/bitutil",
-    "common/fdlimit",
     "common/hexutil",
     "common/math",
     "common/mclock",
@@ -103,7 +86,6 @@
     "crypto/randentropy",
     "crypto/secp256k1",
     "crypto/sha3",
-    "dashboard",
     "eth",
     "eth/downloader",
     "eth/fetcher",
@@ -112,7 +94,6 @@
     "eth/tracers",
     "eth/tracers/internal/tracers",
     "ethdb",
-    "ethstats",
     "event",
     "internal/debug",
     "internal/ethapi",
@@ -134,21 +115,11 @@
     "rlp",
     "rpc",
     "trie",
-    "whisper/mailserver",
     "whisper/whisperv6"
   ]
   revision = "cbdaa0ca2a955012274bd2c47bd52b24b2beb66c"
   version = "v1.8.5"
 
-[[projects]]
-  name = "github.com/go-ole/go-ole"
-  packages = [
-    ".",
-    "oleutil"
-  ]
-  revision = "a41e3c4b706f6ae8dfbff342b06e40fa4d2d0506"
-  version = "v1.2.1"
-
 [[projects]]
   name = "github.com/go-playground/locales"
   packages = [
@@ -240,12 +211,6 @@
   packages = ["."]
   revision = "1b00554d822231195d1babd97ff4a781231955c9"
 
-[[projects]]
-  name = "github.com/pkg/errors"
-  packages = ["."]
-  revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
-  version = "v0.8.0"
-
 [[projects]]
   name = "github.com/pmezard/go-difflib"
   packages = ["difflib"]
@@ -403,10 +368,7 @@
 [[projects]]
   branch = "master"
   name = "golang.org/x/sys"
-  packages = [
+  packages = ["unix"]
-    "unix",
-    "windows"
-  ]
   revision = "2c42eef0765b9837fbdab12011af7830f55f88f0"
 
 [[projects]]
@@ -493,6 +455,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "c82f110ad74f6540b5ba89202a3e4e6cca24a7ec9eedd35248a3aa1e6d626275"
+  inputs-digest = "6aa91268824929d518de01ad02692d63f79cabded7c945fba5f700dd131dd775"
   solver-name = "gps-cdcl"
   solver-version = 1

geth/node/node.go

@@ -19,9 +19,9 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/discover"
 	"github.com/ethereum/go-ethereum/p2p/discv5"
 	"github.com/ethereum/go-ethereum/p2p/nat"
-	"github.com/ethereum/go-ethereum/whisper/mailserver"
 	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
 	"github.com/status-im/status-go/geth/params"
+	"github.com/status-im/status-go/mailserver"
 	shhmetrics "github.com/status-im/status-go/metrics/whisper"
 	"github.com/status-im/status-go/services/personal"
 	"github.com/status-im/status-go/services/shhext"
@@ -227,12 +227,15 @@ func activateShhService(stack *node.Node, config *params.NodeConfig, db *leveldb
 
 			var mailServer mailserver.WMailServer
 			whisperService.RegisterServer(&mailServer)
-			mailServer.Init(
+			err := mailServer.Init(
 				whisperService,
 				config.WhisperConfig.DataDir,
 				config.WhisperConfig.Password,
 				config.WhisperConfig.MinimumPoW,
 			)
+			if err != nil {
+				return nil, err
+			}
 		}
 
 		if config.WhisperConfig.LightClient {

mailserver/mailserver.go

@@ -0,0 +1,204 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package mailserver
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
+	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
+	"github.com/syndtr/goleveldb/leveldb"
+	"github.com/syndtr/goleveldb/leveldb/util"
+)
+
+// WMailServer whisper mailserver
+type WMailServer struct {
+	db  *leveldb.DB
+	w   *whisper.Whisper
+	pow float64
+	key []byte
+}
+
+// DBKey key to be stored on db
+type DBKey struct {
+	timestamp uint32
+	hash      common.Hash
+	raw       []byte
+}
+
+// NewDbKey creates a new DBKey with the given values
+func NewDbKey(t uint32, h common.Hash) *DBKey {
+	const sz = common.HashLength + 4
+	var k DBKey
+	k.timestamp = t
+	k.hash = h
+	k.raw = make([]byte, sz)
+	binary.BigEndian.PutUint32(k.raw, k.timestamp)
+	copy(k.raw[4:], k.hash[:])
+	return &k
+}
+
+// Init initializes mailServer
+func (s *WMailServer) Init(shh *whisper.Whisper, path string, password string, pow float64) error {
+	var err error
+	if len(path) == 0 {
+		return fmt.Errorf("DB file is not specified")
+	}
+
+	if len(password) == 0 {
+		return fmt.Errorf("password is not specified")
+	}
+
+	s.db, err = leveldb.OpenFile(path, nil)
+	if err != nil {
+		return fmt.Errorf("open DB file: %s", err)
+	}
+
+	s.w = shh
+	s.pow = pow
+
+	MailServerKeyID, err := s.w.AddSymKeyFromPassword(password)
+	if err != nil {
+		return fmt.Errorf("create symmetric key: %s", err)
+	}
+	s.key, err = s.w.GetSymKey(MailServerKeyID)
+	if err != nil {
+		return fmt.Errorf("save symmetric key: %s", err)
+	}
+	return nil
+}
+
+// Close the mailserver and its associated db connection
+func (s *WMailServer) Close() {
+	if s.db != nil {
+		func() {
+			if err := s.db.Close(); err != nil {
+				log.Error(fmt.Sprintf("s.db.Close failed: %s", err))
+			}
+		}()
+	}
+}
+
+// Archive a whisper envelope
+func (s *WMailServer) Archive(env *whisper.Envelope) {
+	key := NewDbKey(env.Expiry-env.TTL, env.Hash())
+	rawEnvelope, err := rlp.EncodeToBytes(env)
+	if err != nil {
+		log.Error(fmt.Sprintf("rlp.EncodeToBytes failed: %s", err))
+	} else {
+		err = s.db.Put(key.raw, rawEnvelope, nil)
+		if err != nil {
+			log.Error(fmt.Sprintf("Writing to DB failed: %s", err))
+		}
+	}
+}
+
+// DeliverMail sends mail to specified whisper peer
+func (s *WMailServer) DeliverMail(peer *whisper.Peer, request *whisper.Envelope) {
+	if peer == nil {
+		log.Error("Whisper peer is nil")
+		return
+	}
+
+	ok, lower, upper, bloom := s.validateRequest(peer.ID(), request)
+	if ok {
+		s.processRequest(peer, lower, upper, bloom)
+	}
+}
+
+func (s *WMailServer) processRequest(peer *whisper.Peer, lower, upper uint32, bloom []byte) []*whisper.Envelope {
+	ret := make([]*whisper.Envelope, 0)
+	var err error
+	var zero common.Hash
+	kl := NewDbKey(lower, zero)
+	ku := NewDbKey(upper, zero)
+	i := s.db.NewIterator(&util.Range{Start: kl.raw, Limit: ku.raw}, nil)
+	defer i.Release()
+
+	for i.Next() {
+		var envelope whisper.Envelope
+		err = rlp.DecodeBytes(i.Value(), &envelope)
+		if err != nil {
+			log.Error(fmt.Sprintf("RLP decoding failed: %s", err))
+		}
+
+		if whisper.BloomFilterMatch(bloom, envelope.Bloom()) {
+			if peer == nil {
+				// used for test purposes
+				ret = append(ret, &envelope)
+			} else {
+				err = s.w.SendP2PDirect(peer, &envelope)
+				if err != nil {
+					log.Error(fmt.Sprintf("Failed to send direct message to peer: %s", err))
+					return nil
+				}
+			}
+		}
+	}
+
+	err = i.Error()
+	if err != nil {
+		log.Error(fmt.Sprintf("Level DB iterator error: %s", err))
+	}
+
+	return ret
+}
+
+func (s *WMailServer) validateRequest(peerID []byte, request *whisper.Envelope) (bool, uint32, uint32, []byte) {
+	if s.pow > 0.0 && request.PoW() < s.pow {
+		return false, 0, 0, nil
+	}
+
+	f := whisper.Filter{KeySym: s.key}
+	decrypted := request.Open(&f)
+	if decrypted == nil {
+		log.Warn(fmt.Sprintf("Failed to decrypt p2p request"))
+		return false, 0, 0, nil
+	}
+
+	src := crypto.FromECDSAPub(decrypted.Src)
+	if len(src)-len(peerID) == 1 {
+		src = src[1:]
+	}
+
+	// if you want to check the signature, you can do it here. e.g.:
+	// if !bytes.Equal(peerID, src) {
+	if src == nil {
+		log.Warn(fmt.Sprintf("Wrong signature of p2p request"))
+		return false, 0, 0, nil
+	}
+
+	payloadSize := len(decrypted.Payload)
+	bloom := decrypted.Payload[8 : 8+whisper.BloomFilterSize]
+	if payloadSize < 8 {
+		log.Warn(fmt.Sprintf("Undersized p2p request"))
+		return false, 0, 0, nil
+	} else if payloadSize == 8 {
+		bloom = whisper.MakeFullNodeBloom()
+	} else if payloadSize < 8+whisper.BloomFilterSize {
+		log.Warn(fmt.Sprintf("Undersized bloom filter in p2p request"))
+		return false, 0, 0, nil
+	}
+
+	lower := binary.BigEndian.Uint32(decrypted.Payload[:4])
+	upper := binary.BigEndian.Uint32(decrypted.Payload[4:8])
+	return true, lower, upper, bloom
+}

mailserver/mailserver_test.go

@@ -0,0 +1,212 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package mailserver
+
+import (
+	"bytes"
+	"crypto/ecdsa"
+	"encoding/binary"
+	"io/ioutil"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	whisper "github.com/ethereum/go-ethereum/whisper/whisperv6"
+)
+
+const powRequirement = 0.00001
+
+var keyID string
+var shh *whisper.Whisper
+var seed = time.Now().Unix()
+
+type ServerTestParams struct {
+	topic whisper.TopicType
+	low   uint32
+	upp   uint32
+	key   *ecdsa.PrivateKey
+}
+
+func assert(statement bool, text string, t *testing.T) {
+	if !statement {
+		t.Fatal(text)
+	}
+}
+
+func TestDBKey(t *testing.T) {
+	var h common.Hash
+	i := uint32(time.Now().Unix())
+	k := NewDbKey(i, h)
+	assert(len(k.raw) == common.HashLength+4, "wrong DB key length", t)
+	assert(byte(i%0x100) == k.raw[3], "raw representation should be big endian", t)
+	assert(byte(i/0x1000000) == k.raw[0], "big endian expected", t)
+}
+
+func generateEnvelope(t *testing.T) *whisper.Envelope {
+	h := crypto.Keccak256Hash([]byte("test sample data"))
+	params := &whisper.MessageParams{
+		KeySym:   h[:],
+		Topic:    whisper.TopicType{0x1F, 0x7E, 0xA1, 0x7F},
+		Payload:  []byte("test payload"),
+		PoW:      powRequirement,
+		WorkTime: 2,
+	}
+
+	msg, err := whisper.NewSentMessage(params)
+	if err != nil {
+		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
+	}
+	env, err := msg.Wrap(params, time.Now())
+	if err != nil {
+		t.Fatalf("failed to wrap with seed %d: %s.", seed, err)
+	}
+	return env
+}
+
+func TestMailServer(t *testing.T) {
+	const password = "password_for_this_test"
+	const dbPath = "whisper-server-test"
+
+	dir, err := ioutil.TempDir("", dbPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var server WMailServer
+	shh = whisper.New(&whisper.DefaultConfig)
+	shh.RegisterServer(&server)
+
+	err = server.Init(shh, dir, password, powRequirement)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer server.Close()
+
+	keyID, err = shh.AddSymKeyFromPassword(password)
+	if err != nil {
+		t.Fatalf("Failed to create symmetric key for mail request: %s", err)
+	}
+
+	rand.Seed(seed)
+	env := generateEnvelope(t)
+	server.Archive(env)
+	deliverTest(t, &server, env)
+}
+
+func deliverTest(t *testing.T, server *WMailServer, env *whisper.Envelope) {
+	id, err := shh.NewKeyPair()
+	if err != nil {
+		t.Fatalf("failed to generate new key pair with seed %d: %s.", seed, err)
+	}
+	testPeerID, err := shh.GetPrivateKey(id)
+	if err != nil {
+		t.Fatalf("failed to retrieve new key pair with seed %d: %s.", seed, err)
+	}
+	birth := env.Expiry - env.TTL
+	p := &ServerTestParams{
+		topic: env.Topic,
+		low:   birth - 1,
+		upp:   birth + 1,
+		key:   testPeerID,
+	}
+
+	singleRequest(t, server, env, p, true)
+
+	p.low, p.upp = birth+1, 0xffffffff
+	singleRequest(t, server, env, p, false)
+
+	p.low, p.upp = 0, birth-1
+	singleRequest(t, server, env, p, false)
+
+	p.low = birth - 1
+	p.upp = birth + 1
+	p.topic[0] = 0xFF
+	singleRequest(t, server, env, p, false)
+}
+
+func singleRequest(t *testing.T, server *WMailServer, env *whisper.Envelope, p *ServerTestParams, expect bool) {
+	request := createRequest(t, p)
+	src := crypto.FromECDSAPub(&p.key.PublicKey)
+	ok, lower, upper, bloom := server.validateRequest(src, request)
+	if !ok {
+		t.Fatalf("request validation failed, seed: %d.", seed)
+	}
+	if lower != p.low {
+		t.Fatalf("request validation failed (lower bound), seed: %d.", seed)
+	}
+	if upper != p.upp {
+		t.Fatalf("request validation failed (upper bound), seed: %d.", seed)
+	}
+	expectedBloom := whisper.TopicToBloom(p.topic)
+	if !bytes.Equal(bloom, expectedBloom) {
+		t.Fatalf("request validation failed (topic), seed: %d.", seed)
+	}
+
+	var exist bool
+	mail := server.processRequest(nil, p.low, p.upp, bloom)
+	for _, msg := range mail {
+		if msg.Hash() == env.Hash() {
+			exist = true
+			break
+		}
+	}
+
+	if exist != expect {
+		t.Fatalf("error: exist = %v, seed: %d.", exist, seed)
+	}
+
+	src[0]++
+	ok, lower, upper, _ = server.validateRequest(src, request)
+	if !ok {
+		// request should be valid regardless of signature
+		t.Fatalf("request validation false negative, seed: %d (lower: %d, upper: %d).", seed, lower, upper)
+	}
+}
+
+func createRequest(t *testing.T, p *ServerTestParams) *whisper.Envelope {
+	bloom := whisper.TopicToBloom(p.topic)
+	data := make([]byte, 8)
+	binary.BigEndian.PutUint32(data, p.low)
+	binary.BigEndian.PutUint32(data[4:], p.upp)
+	data = append(data, bloom...)
+
+	key, err := shh.GetSymKey(keyID)
+	if err != nil {
+		t.Fatalf("failed to retrieve sym key with seed %d: %s.", seed, err)
+	}
+
+	params := &whisper.MessageParams{
+		KeySym:   key,
+		Topic:    p.topic,
+		Payload:  data,
+		PoW:      powRequirement * 2,
+		WorkTime: 2,
+		Src:      p.key,
+	}
+
+	msg, err := whisper.NewSentMessage(params)
+	if err != nil {
+		t.Fatalf("failed to create new message with seed %d: %s.", seed, err)
+	}
+	env, err := msg.Wrap(params, time.Now())
+	if err != nil {
+		t.Fatalf("failed to wrap with seed %d: %s.", seed, err)
+	}
+	return env
+}

vendor/github.com/StackExchange/wmi/LICENSE

@@ -1,20 +0,0 @@
-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.

vendor/github.com/StackExchange/wmi/swbemservices.go

@@ -1,260 +0,0 @@
-// +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
-}

vendor/github.com/StackExchange/wmi/wmi.go

@@ -1,486 +0,0 @@
-// +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()
-}

vendor/github.com/elastic/gosigar/LICENSE

@@ -1,201 +0,0 @@
-                              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.

vendor/github.com/elastic/gosigar/NOTICE

@@ -1,9 +0,0 @@
-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.

vendor/github.com/elastic/gosigar/concrete_sigar.go

@@ -1,83 +0,0 @@
-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
-}

vendor/github.com/elastic/gosigar/sigar_darwin.go

@@ -1,494 +0,0 @@
-// 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
-}

vendor/github.com/elastic/gosigar/sigar_format.go

@@ -1,126 +0,0 @@
-// 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)
-}

vendor/github.com/elastic/gosigar/sigar_freebsd.go

@@ -1,108 +0,0 @@
-// 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
-}

vendor/github.com/elastic/gosigar/sigar_interface.go

@@ -1,197 +0,0 @@
-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
-}

vendor/github.com/elastic/gosigar/sigar_linux.go

@@ -1,84 +0,0 @@
-// 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
-}

vendor/github.com/elastic/gosigar/sigar_linux_common.go

@@ -1,468 +0,0 @@
-// 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
-}

vendor/github.com/elastic/gosigar/sigar_openbsd.go

@@ -1,418 +0,0 @@
-// 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
-}

vendor/github.com/elastic/gosigar/sigar_stub.go

@@ -1,71 +0,0 @@
-// +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}
-}

vendor/github.com/elastic/gosigar/sigar_unix.go

@@ -1,69 +0,0 @@
-// 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())
-}

vendor/github.com/elastic/gosigar/sigar_util.go

@@ -1,22 +0,0 @@
-// 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]
-}

vendor/github.com/elastic/gosigar/sigar_windows.go

@@ -1,437 +0,0 @@
-// 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
-}

vendor/github.com/elastic/gosigar/sys/windows/doc.go

@@ -1,2 +0,0 @@
-// Package windows contains various Windows system call.
-package windows

vendor/github.com/elastic/gosigar/sys/windows/ntquery.go

@@ -1,132 +0,0 @@
-// +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
-}

vendor/github.com/elastic/gosigar/sys/windows/privileges.go

@@ -1,272 +0,0 @@
-// +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
-}

vendor/github.com/elastic/gosigar/sys/windows/syscall_windows.go

@@ -1,385 +0,0 @@
-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

vendor/github.com/elastic/gosigar/sys/windows/version.go

@@ -1,43 +0,0 @@
-// +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
-}

vendor/github.com/elastic/gosigar/sys/windows/zsyscall_windows.go

@@ -1,260 +0,0 @@
-// 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
-}

vendor/github.com/go-ole/go-ole/LICENSE

@@ -1,21 +0,0 @@
-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.

vendor/github.com/go-ole/go-ole/com.go

@@ -1,329 +0,0 @@
-// +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.")
-}

vendor/github.com/go-ole/go-ole/com_func.go

@@ -1,174 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/connect.go

@@ -1,192 +0,0 @@
-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
-}

vendor/github.com/go-ole/go-ole/constants.go

@@ -1,153 +0,0 @@
-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
-)

vendor/github.com/go-ole/go-ole/error.go

@@ -1,51 +0,0 @@
-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
-}

vendor/github.com/go-ole/go-ole/error_func.go

@@ -1,8 +0,0 @@
-// +build !windows
-
-package ole
-
-// errstr converts error code to string.
-func errstr(errno int) string {
-	return ""
-}

vendor/github.com/go-ole/go-ole/error_windows.go

@@ -1,24 +0,0 @@
-// +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]))
-}

vendor/github.com/go-ole/go-ole/guid.go

@@ -1,284 +0,0 @@
-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]
-}

vendor/github.com/go-ole/go-ole/iconnectionpoint.go

@@ -1,20 +0,0 @@
-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))
-}

vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go

@@ -1,21 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go

@@ -1,43 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go

@@ -1,17 +0,0 @@
-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))
-}

vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go

@@ -1,11 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go

@@ -1,25 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/idispatch.go

@@ -1,94 +0,0 @@
-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)
-}

vendor/github.com/go-ole/go-ole/idispatch_func.go

@@ -1,19 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/idispatch_windows.go

@@ -1,197 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/ienumvariant.go

@@ -1,19 +0,0 @@
-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))
-}

vendor/github.com/go-ole/go-ole/ienumvariant_func.go

@@ -1,19 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/ienumvariant_windows.go

@@ -1,63 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/iinspectable.go

@@ -1,18 +0,0 @@
-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))
-}

vendor/github.com/go-ole/go-ole/iinspectable_func.go

@@ -1,15 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/iinspectable_windows.go

@@ -1,72 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/iprovideclassinfo.go

@@ -1,21 +0,0 @@
-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
-}

vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go

@@ -1,7 +0,0 @@
-// +build !windows
-
-package ole
-
-func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
-	return nil, NewError(E_NOTIMPL)
-}

vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go

@@ -1,21 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/itypeinfo.go

@@ -1,34 +0,0 @@
-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))
-}

vendor/github.com/go-ole/go-ole/itypeinfo_func.go

@@ -1,7 +0,0 @@
-// +build !windows
-
-package ole
-
-func (v *ITypeInfo) GetTypeAttr() (*TYPEATTR, error) {
-	return nil, NewError(E_NOTIMPL)
-}

vendor/github.com/go-ole/go-ole/itypeinfo_windows.go

@@ -1,21 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/iunknown.go

@@ -1,57 +0,0 @@
-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)
-}

vendor/github.com/go-ole/go-ole/iunknown_func.go

@@ -1,19 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/iunknown_windows.go

@@ -1,58 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/ole.go

@@ -1,157 +0,0 @@
-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
-}

vendor/github.com/go-ole/go-ole/oleutil/connection.go

@@ -1,100 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/oleutil/connection_func.go

@@ -1,10 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go

@@ -1,58 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/oleutil/go-get.go

@@ -1,6 +0,0 @@
-// This file is here so go get succeeds as without it errors with:
-// no buildable Go source files in ...
-//
-// +build !windows
-
-package oleutil

vendor/github.com/go-ole/go-ole/oleutil/oleutil.go

@@ -1,127 +0,0 @@
-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
-}

vendor/github.com/go-ole/go-ole/safearray.go

@@ -1,27 +0,0 @@
-// 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

vendor/github.com/go-ole/go-ole/safearray_func.go

@@ -1,211 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/safearray_windows.go

@@ -1,337 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/safearrayconversion.go

@@ -1,140 +0,0 @@
-// 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)
-}

vendor/github.com/go-ole/go-ole/safearrayslices.go

@@ -1,33 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/utility.go

@@ -1,101 +0,0 @@
-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
-}

vendor/github.com/go-ole/go-ole/variables.go

@@ -1,16 +0,0 @@
-// +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")
-)

vendor/github.com/go-ole/go-ole/variant.go

@@ -1,105 +0,0 @@
-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
-}

vendor/github.com/go-ole/go-ole/variant_386.go

@@ -1,11 +0,0 @@
-// +build 386
-
-package ole
-
-type VARIANT struct {
-	VT         VT     //  2
-	wReserved1 uint16 //  4
-	wReserved2 uint16 //  6
-	wReserved3 uint16 //  8
-	Val        int64  // 16
-}

vendor/github.com/go-ole/go-ole/variant_amd64.go

@@ -1,12 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/variant_s390x.go

@@ -1,12 +0,0 @@
-// +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
-}

vendor/github.com/go-ole/go-ole/vt_string.go

@@ -1,58 +0,0 @@
-// 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)
-	}
-}

vendor/github.com/go-ole/go-ole/winrt.go

@@ -1,99 +0,0 @@
-// +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)
-}

vendor/github.com/go-ole/go-ole/winrt_doc.go

@@ -1,36 +0,0 @@
-// +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 ""
-}

vendor/github.com/pkg/errors/LICENSE

@@ -1,23 +0,0 @@
-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.

vendor/github.com/pkg/errors/errors.go

@@ -1,269 +0,0 @@
-// 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
-}

vendor/github.com/pkg/errors/stack.go

@@ -1,178 +0,0 @@
-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   path of source file relative to the compile time GOPATH
-//    %+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
-
-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
-}

vendor/golang.org/x/sys/windows/asm_windows_386.s

@@ -1,13 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//
-// System calls for 386, Windows are implemented in runtime/syscall_windows.goc
-//
-
-TEXT ·getprocaddress(SB), 7, $0-8
-	JMP	syscall·getprocaddress(SB)
-
-TEXT ·loadlibrary(SB), 7, $0-4
-	JMP	syscall·loadlibrary(SB)

vendor/golang.org/x/sys/windows/asm_windows_amd64.s

@@ -1,13 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//
-// System calls for amd64, Windows are implemented in runtime/syscall_windows.goc
-//
-
-TEXT ·getprocaddress(SB), 7, $0-32
-	JMP	syscall·getprocaddress(SB)
-
-TEXT ·loadlibrary(SB), 7, $0-8
-	JMP	syscall·loadlibrary(SB)

vendor/golang.org/x/sys/windows/dll_windows.go

@@ -1,378 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package windows
-
-import (
-	"sync"
-	"sync/atomic"
-	"syscall"
-	"unsafe"
-)
-
-// DLLError describes reasons for DLL load failures.
-type DLLError struct {
-	Err     error
-	ObjName string
-	Msg     string
-}
-
-func (e *DLLError) Error() string { return e.Msg }
-
-// Implemented in runtime/syscall_windows.goc; we provide jumps to them in our assembly file.
-func loadlibrary(filename *uint16) (handle uintptr, err syscall.Errno)
-func getprocaddress(handle uintptr, procname *uint8) (proc uintptr, err syscall.Errno)
-
-// A DLL implements access to a single DLL.
-type DLL struct {
-	Name   string
-	Handle Handle
-}
-
-// LoadDLL loads DLL file into memory.
-//
-// Warning: using LoadDLL without an absolute path name is subject to
-// DLL preloading attacks. To safely load a system DLL, use LazyDLL
-// with System set to true, or use LoadLibraryEx directly.
-func LoadDLL(name string) (dll *DLL, err error) {
-	namep, err := UTF16PtrFromString(name)
-	if err != nil {
-		return nil, err
-	}
-	h, e := loadlibrary(namep)
-	if e != 0 {
-		return nil, &DLLError{
-			Err:     e,
-			ObjName: name,
-			Msg:     "Failed to load " + name + ": " + e.Error(),
-		}
-	}
-	d := &DLL{
-		Name:   name,
-		Handle: Handle(h),
-	}
-	return d, nil
-}
-
-// MustLoadDLL is like LoadDLL but panics if load operation failes.
-func MustLoadDLL(name string) *DLL {
-	d, e := LoadDLL(name)
-	if e != nil {
-		panic(e)
-	}
-	return d
-}
-
-// FindProc searches DLL d for procedure named name and returns *Proc
-// if found. It returns an error if search fails.
-func (d *DLL) FindProc(name string) (proc *Proc, err error) {
-	namep, err := BytePtrFromString(name)
-	if err != nil {
-		return nil, err
-	}
-	a, e := getprocaddress(uintptr(d.Handle), namep)
-	if e != 0 {
-		return nil, &DLLError{
-			Err:     e,
-			ObjName: name,
-			Msg:     "Failed to find " + name + " procedure in " + d.Name + ": " + e.Error(),
-		}
-	}
-	p := &Proc{
-		Dll:  d,
-		Name: name,
-		addr: a,
-	}
-	return p, nil
-}
-
-// MustFindProc is like FindProc but panics if search fails.
-func (d *DLL) MustFindProc(name string) *Proc {
-	p, e := d.FindProc(name)
-	if e != nil {
-		panic(e)
-	}
-	return p
-}
-
-// Release unloads DLL d from memory.
-func (d *DLL) Release() (err error) {
-	return FreeLibrary(d.Handle)
-}
-
-// A Proc implements access to a procedure inside a DLL.
-type Proc struct {
-	Dll  *DLL
-	Name string
-	addr uintptr
-}
-
-// Addr returns the address of the procedure represented by p.
-// The return value can be passed to Syscall to run the procedure.
-func (p *Proc) Addr() uintptr {
-	return p.addr
-}
-
-//go:uintptrescapes
-
-// Call executes procedure p with arguments a. It will panic, if more than 15 arguments
-// are supplied.
-//
-// The returned error is always non-nil, constructed from the result of GetLastError.
-// Callers must inspect the primary return value to decide whether an error occurred
-// (according to the semantics of the specific function being called) before consulting
-// the error. The error will be guaranteed to contain windows.Errno.
-func (p *Proc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) {
-	switch len(a) {
-	case 0:
-		return syscall.Syscall(p.Addr(), uintptr(len(a)), 0, 0, 0)
-	case 1:
-		return syscall.Syscall(p.Addr(), uintptr(len(a)), a[0], 0, 0)
-	case 2:
-		return syscall.Syscall(p.Addr(), uintptr(len(a)), a[0], a[1], 0)
-	case 3:
-		return syscall.Syscall(p.Addr(), uintptr(len(a)), a[0], a[1], a[2])
-	case 4:
-		return syscall.Syscall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], 0, 0)
-	case 5:
-		return syscall.Syscall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], 0)
-	case 6:
-		return syscall.Syscall6(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5])
-	case 7:
-		return syscall.Syscall9(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], 0, 0)
-	case 8:
-		return syscall.Syscall9(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], 0)
-	case 9:
-		return syscall.Syscall9(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8])
-	case 10:
-		return syscall.Syscall12(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], 0, 0)
-	case 11:
-		return syscall.Syscall12(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], 0)
-	case 12:
-		return syscall.Syscall12(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11])
-	case 13:
-		return syscall.Syscall15(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], 0, 0)
-	case 14:
-		return syscall.Syscall15(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], 0)
-	case 15:
-		return syscall.Syscall15(p.Addr(), uintptr(len(a)), a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14])
-	default:
-		panic("Call " + p.Name + " with too many arguments " + itoa(len(a)) + ".")
-	}
-}
-
-// A LazyDLL implements access to a single DLL.
-// It will delay the load of the DLL until the first
-// call to its Handle method or to one of its
-// LazyProc's Addr method.
-type LazyDLL struct {
-	Name string
-
-	// System determines whether the DLL must be loaded from the
-	// Windows System directory, bypassing the normal DLL search
-	// path.
-	System bool
-
-	mu  sync.Mutex
-	dll *DLL // non nil once DLL is loaded
-}
-
-// Load loads DLL file d.Name into memory. It returns an error if fails.
-// Load will not try to load DLL, if it is already loaded into memory.
-func (d *LazyDLL) Load() error {
-	// Non-racy version of:
-	// if d.dll != nil {
-	if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&d.dll))) != nil {
-		return nil
-	}
-	d.mu.Lock()
-	defer d.mu.Unlock()
-	if d.dll != nil {
-		return nil
-	}
-
-	// kernel32.dll is special, since it's where LoadLibraryEx comes from.
-	// The kernel already special-cases its name, so it's always
-	// loaded from system32.
-	var dll *DLL
-	var err error
-	if d.Name == "kernel32.dll" {
-		dll, err = LoadDLL(d.Name)
-	} else {
-		dll, err = loadLibraryEx(d.Name, d.System)
-	}
-	if err != nil {
-		return err
-	}
-
-	// Non-racy version of:
-	// d.dll = dll
-	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&d.dll)), unsafe.Pointer(dll))
-	return nil
-}
-
-// mustLoad is like Load but panics if search fails.
-func (d *LazyDLL) mustLoad() {
-	e := d.Load()
-	if e != nil {
-		panic(e)
-	}
-}
-
-// Handle returns d's module handle.
-func (d *LazyDLL) Handle() uintptr {
-	d.mustLoad()
-	return uintptr(d.dll.Handle)
-}
-
-// NewProc returns a LazyProc for accessing the named procedure in the DLL d.
-func (d *LazyDLL) NewProc(name string) *LazyProc {
-	return &LazyProc{l: d, Name: name}
-}
-
-// NewLazyDLL creates new LazyDLL associated with DLL file.
-func NewLazyDLL(name string) *LazyDLL {
-	return &LazyDLL{Name: name}
-}
-
-// NewLazySystemDLL is like NewLazyDLL, but will only
-// search Windows System directory for the DLL if name is
-// a base name (like "advapi32.dll").
-func NewLazySystemDLL(name string) *LazyDLL {
-	return &LazyDLL{Name: name, System: true}
-}
-
-// A LazyProc implements access to a procedure inside a LazyDLL.
-// It delays the lookup until the Addr method is called.
-type LazyProc struct {
-	Name string
-
-	mu   sync.Mutex
-	l    *LazyDLL
-	proc *Proc
-}
-
-// Find searches DLL for procedure named p.Name. It returns
-// an error if search fails. Find will not search procedure,
-// if it is already found and loaded into memory.
-func (p *LazyProc) Find() error {
-	// Non-racy version of:
-	// if p.proc == nil {
-	if atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&p.proc))) == nil {
-		p.mu.Lock()
-		defer p.mu.Unlock()
-		if p.proc == nil {
-			e := p.l.Load()
-			if e != nil {
-				return e
-			}
-			proc, e := p.l.dll.FindProc(p.Name)
-			if e != nil {
-				return e
-			}
-			// Non-racy version of:
-			// p.proc = proc
-			atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&p.proc)), unsafe.Pointer(proc))
-		}
-	}
-	return nil
-}
-
-// mustFind is like Find but panics if search fails.
-func (p *LazyProc) mustFind() {
-	e := p.Find()
-	if e != nil {
-		panic(e)
-	}
-}
-
-// Addr returns the address of the procedure represented by p.
-// The return value can be passed to Syscall to run the procedure.
-// It will panic if the procedure cannot be found.
-func (p *LazyProc) Addr() uintptr {
-	p.mustFind()
-	return p.proc.Addr()
-}
-
-//go:uintptrescapes
-
-// Call executes procedure p with arguments a. It will panic, if more than 15 arguments
-// are supplied. It will also panic if the procedure cannot be found.
-//
-// The returned error is always non-nil, constructed from the result of GetLastError.
-// Callers must inspect the primary return value to decide whether an error occurred
-// (according to the semantics of the specific function being called) before consulting
-// the error. The error will be guaranteed to contain windows.Errno.
-func (p *LazyProc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) {
-	p.mustFind()
-	return p.proc.Call(a...)
-}
-
-var canDoSearchSystem32Once struct {
-	sync.Once
-	v bool
-}
-
-func initCanDoSearchSystem32() {
-	// https://msdn.microsoft.com/en-us/library/ms684179(v=vs.85).aspx says:
-	// "Windows 7, Windows Server 2008 R2, Windows Vista, and Windows
-	// Server 2008: The LOAD_LIBRARY_SEARCH_* flags are available on
-	// systems that have KB2533623 installed. To determine whether the
-	// flags are available, use GetProcAddress to get the address of the
-	// AddDllDirectory, RemoveDllDirectory, or SetDefaultDllDirectories
-	// function. If GetProcAddress succeeds, the LOAD_LIBRARY_SEARCH_*
-	// flags can be used with LoadLibraryEx."
-	canDoSearchSystem32Once.v = (modkernel32.NewProc("AddDllDirectory").Find() == nil)
-}
-
-func canDoSearchSystem32() bool {
-	canDoSearchSystem32Once.Do(initCanDoSearchSystem32)
-	return canDoSearchSystem32Once.v
-}
-
-func isBaseName(name string) bool {
-	for _, c := range name {
-		if c == ':' || c == '/' || c == '\\' {
-			return false
-		}
-	}
-	return true
-}
-
-// loadLibraryEx wraps the Windows LoadLibraryEx function.
-//
-// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms684179(v=vs.85).aspx
-//
-// If name is not an absolute path, LoadLibraryEx searches for the DLL
-// in a variety of automatic locations unless constrained by flags.
-// See: https://msdn.microsoft.com/en-us/library/ff919712%28VS.85%29.aspx
-func loadLibraryEx(name string, system bool) (*DLL, error) {
-	loadDLL := name
-	var flags uintptr
-	if system {
-		if canDoSearchSystem32() {
-			const LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800
-			flags = LOAD_LIBRARY_SEARCH_SYSTEM32
-		} else if isBaseName(name) {
-			// WindowsXP or unpatched Windows machine
-			// trying to load "foo.dll" out of the system
-			// folder, but LoadLibraryEx doesn't support
-			// that yet on their system, so emulate it.
-			windir, _ := Getenv("WINDIR") // old var; apparently works on XP
-			if windir == "" {
-				return nil, errString("%WINDIR% not defined")
-			}
-			loadDLL = windir + "\\System32\\" + name
-		}
-	}
-	h, err := LoadLibraryEx(loadDLL, 0, flags)
-	if err != nil {
-		return nil, err
-	}
-	return &DLL{Name: name, Handle: h}, nil
-}
-
-type errString string
-
-func (s errString) Error() string { return string(s) }

vendor/golang.org/x/sys/windows/env_windows.go

@@ -1,29 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Windows environment variables.
-
-package windows
-
-import "syscall"
-
-func Getenv(key string) (value string, found bool) {
-	return syscall.Getenv(key)
-}
-
-func Setenv(key, value string) error {
-	return syscall.Setenv(key, value)
-}
-
-func Clearenv() {
-	syscall.Clearenv()
-}
-
-func Environ() []string {
-	return syscall.Environ()
-}
-
-func Unsetenv(key string) error {
-	return syscall.Unsetenv(key)
-}

vendor/golang.org/x/sys/windows/eventlog.go

@@ -1,20 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build windows
-
-package windows
-
-const (
-	EVENTLOG_SUCCESS          = 0
-	EVENTLOG_ERROR_TYPE       = 1
-	EVENTLOG_WARNING_TYPE     = 2
-	EVENTLOG_INFORMATION_TYPE = 4
-	EVENTLOG_AUDIT_SUCCESS    = 8
-	EVENTLOG_AUDIT_FAILURE    = 16
-)
-
-//sys	RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW
-//sys	DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource
-//sys	ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW

vendor/golang.org/x/sys/windows/exec_windows.go

@@ -1,97 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Fork, exec, wait, etc.
-
-package windows
-
-// EscapeArg rewrites command line argument s as prescribed
-// in http://msdn.microsoft.com/en-us/library/ms880421.
-// This function returns "" (2 double quotes) if s is empty.
-// Alternatively, these transformations are done:
-// - every back slash (\) is doubled, but only if immediately
-//   followed by double quote (");
-// - every double quote (") is escaped by back slash (\);
-// - finally, s is wrapped with double quotes (arg -> "arg"),
-//   but only if there is space or tab inside s.
-func EscapeArg(s string) string {
-	if len(s) == 0 {
-		return "\"\""
-	}
-	n := len(s)
-	hasSpace := false
-	for i := 0; i < len(s); i++ {
-		switch s[i] {
-		case '"', '\\':
-			n++
-		case ' ', '\t':
-			hasSpace = true
-		}
-	}
-	if hasSpace {
-		n += 2
-	}
-	if n == len(s) {
-		return s
-	}
-
-	qs := make([]byte, n)
-	j := 0
-	if hasSpace {
-		qs[j] = '"'
-		j++
-	}
-	slashes := 0
-	for i := 0; i < len(s); i++ {
-		switch s[i] {
-		default:
-			slashes = 0
-			qs[j] = s[i]
-		case '\\':
-			slashes++
-			qs[j] = s[i]
-		case '"':
-			for ; slashes > 0; slashes-- {
-				qs[j] = '\\'
-				j++
-			}
-			qs[j] = '\\'
-			j++
-			qs[j] = s[i]
-		}
-		j++
-	}
-	if hasSpace {
-		for ; slashes > 0; slashes-- {
-			qs[j] = '\\'
-			j++
-		}
-		qs[j] = '"'
-		j++
-	}
-	return string(qs[:j])
-}
-
-func CloseOnExec(fd Handle) {
-	SetHandleInformation(Handle(fd), HANDLE_FLAG_INHERIT, 0)
-}
-
-// FullPath retrieves the full path of the specified file.
-func FullPath(name string) (path string, err error) {
-	p, err := UTF16PtrFromString(name)
-	if err != nil {
-		return "", err
-	}
-	n := uint32(100)
-	for {
-		buf := make([]uint16, n)
-		n, err = GetFullPathName(p, uint32(len(buf)), &buf[0], nil)
-		if err != nil {
-			return "", err
-		}
-		if n <= uint32(len(buf)) {
-			return UTF16ToString(buf[:n]), nil
-		}
-	}
-}

vendor/golang.org/x/sys/windows/memory_windows.go

@@ -1,26 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package windows
-
-const (
-	MEM_COMMIT      = 0x00001000
-	MEM_RESERVE     = 0x00002000
-	MEM_DECOMMIT    = 0x00004000
-	MEM_RELEASE     = 0x00008000
-	MEM_RESET       = 0x00080000
-	MEM_TOP_DOWN    = 0x00100000
-	MEM_WRITE_WATCH = 0x00200000
-	MEM_PHYSICAL    = 0x00400000
-	MEM_RESET_UNDO  = 0x01000000
-	MEM_LARGE_PAGES = 0x20000000
-
-	PAGE_NOACCESS          = 0x01
-	PAGE_READONLY          = 0x02
-	PAGE_READWRITE         = 0x04
-	PAGE_WRITECOPY         = 0x08
-	PAGE_EXECUTE_READ      = 0x20
-	PAGE_EXECUTE_READWRITE = 0x40
-	PAGE_EXECUTE_WRITECOPY = 0x80
-)

vendor/golang.org/x/sys/windows/mksyscall.go

@@ -1,7 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package windows
-
-//go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go

vendor/golang.org/x/sys/windows/race.go

@@ -1,30 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build windows,race
-
-package windows
-
-import (
-	"runtime"
-	"unsafe"
-)
-
-const raceenabled = true
-
-func raceAcquire(addr unsafe.Pointer) {
-	runtime.RaceAcquire(addr)
-}
-
-func raceReleaseMerge(addr unsafe.Pointer) {
-	runtime.RaceReleaseMerge(addr)
-}
-
-func raceReadRange(addr unsafe.Pointer, len int) {
-	runtime.RaceReadRange(addr, len)
-}
-
-func raceWriteRange(addr unsafe.Pointer, len int) {
-	runtime.RaceWriteRange(addr, len)
-}

vendor/golang.org/x/sys/windows/race0.go

@@ -1,25 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build windows,!race
-
-package windows
-
-import (
-	"unsafe"
-)
-
-const raceenabled = false
-
-func raceAcquire(addr unsafe.Pointer) {
-}
-
-func raceReleaseMerge(addr unsafe.Pointer) {
-}
-
-func raceReadRange(addr unsafe.Pointer, len int) {
-}
-
-func raceWriteRange(addr unsafe.Pointer, len int) {
-}

vendor/golang.org/x/sys/windows/security_windows.go

@@ -1,476 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package windows
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-const (
-	STANDARD_RIGHTS_REQUIRED = 0xf0000
-	STANDARD_RIGHTS_READ     = 0x20000
-	STANDARD_RIGHTS_WRITE    = 0x20000
-	STANDARD_RIGHTS_EXECUTE  = 0x20000
-	STANDARD_RIGHTS_ALL      = 0x1F0000
-)
-
-const (
-	NameUnknown          = 0
-	NameFullyQualifiedDN = 1
-	NameSamCompatible    = 2
-	NameDisplay          = 3
-	NameUniqueId         = 6
-	NameCanonical        = 7
-	NameUserPrincipal    = 8
-	NameCanonicalEx      = 9
-	NameServicePrincipal = 10
-	NameDnsDomain        = 12
-)
-
-// This function returns 1 byte BOOLEAN rather than the 4 byte BOOL.
-// http://blogs.msdn.com/b/drnick/archive/2007/12/19/windows-and-upn-format-credentials.aspx
-//sys	TranslateName(accName *uint16, accNameFormat uint32, desiredNameFormat uint32, translatedName *uint16, nSize *uint32) (err error) [failretval&0xff==0] = secur32.TranslateNameW
-//sys	GetUserNameEx(nameFormat uint32, nameBuffre *uint16, nSize *uint32) (err error) [failretval&0xff==0] = secur32.GetUserNameExW
-
-// TranslateAccountName converts a directory service
-// object name from one format to another.
-func TranslateAccountName(username string, from, to uint32, initSize int) (string, error) {
-	u, e := UTF16PtrFromString(username)
-	if e != nil {
-		return "", e
-	}
-	n := uint32(50)
-	for {
-		b := make([]uint16, n)
-		e = TranslateName(u, from, to, &b[0], &n)
-		if e == nil {
-			return UTF16ToString(b[:n]), nil
-		}
-		if e != ERROR_INSUFFICIENT_BUFFER {
-			return "", e
-		}
-		if n <= uint32(len(b)) {
-			return "", e
-		}
-	}
-}
-
-const (
-	// do not reorder
-	NetSetupUnknownStatus = iota
-	NetSetupUnjoined
-	NetSetupWorkgroupName
-	NetSetupDomainName
-)
-
-type UserInfo10 struct {
-	Name       *uint16
-	Comment    *uint16
-	UsrComment *uint16
-	FullName   *uint16
-}
-
-//sys	NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) = netapi32.NetUserGetInfo
-//sys	NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (neterr error) = netapi32.NetGetJoinInformation
-//sys	NetApiBufferFree(buf *byte) (neterr error) = netapi32.NetApiBufferFree
-
-const (
-	// do not reorder
-	SidTypeUser = 1 + iota
-	SidTypeGroup
-	SidTypeDomain
-	SidTypeAlias
-	SidTypeWellKnownGroup
-	SidTypeDeletedAccount
-	SidTypeInvalid
-	SidTypeUnknown
-	SidTypeComputer
-	SidTypeLabel
-)
-
-type SidIdentifierAuthority struct {
-	Value [6]byte
-}
-
-var (
-	SECURITY_NULL_SID_AUTHORITY        = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 0}}
-	SECURITY_WORLD_SID_AUTHORITY       = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 1}}
-	SECURITY_LOCAL_SID_AUTHORITY       = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 2}}
-	SECURITY_CREATOR_SID_AUTHORITY     = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 3}}
-	SECURITY_NON_UNIQUE_AUTHORITY      = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 4}}
-	SECURITY_NT_AUTHORITY              = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 5}}
-	SECURITY_MANDATORY_LABEL_AUTHORITY = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 16}}
-)
-
-const (
-	SECURITY_NULL_RID                   = 0
-	SECURITY_WORLD_RID                  = 0
-	SECURITY_LOCAL_RID                  = 0
-	SECURITY_CREATOR_OWNER_RID          = 0
-	SECURITY_CREATOR_GROUP_RID          = 1
-	SECURITY_DIALUP_RID                 = 1
-	SECURITY_NETWORK_RID                = 2
-	SECURITY_BATCH_RID                  = 3
-	SECURITY_INTERACTIVE_RID            = 4
-	SECURITY_LOGON_IDS_RID              = 5
-	SECURITY_SERVICE_RID                = 6
-	SECURITY_LOCAL_SYSTEM_RID           = 18
-	SECURITY_BUILTIN_DOMAIN_RID         = 32
-	SECURITY_PRINCIPAL_SELF_RID         = 10
-	SECURITY_CREATOR_OWNER_SERVER_RID   = 0x2
-	SECURITY_CREATOR_GROUP_SERVER_RID   = 0x3
-	SECURITY_LOGON_IDS_RID_COUNT        = 0x3
-	SECURITY_ANONYMOUS_LOGON_RID        = 0x7
-	SECURITY_PROXY_RID                  = 0x8
-	SECURITY_ENTERPRISE_CONTROLLERS_RID = 0x9
-	SECURITY_SERVER_LOGON_RID           = SECURITY_ENTERPRISE_CONTROLLERS_RID
-	SECURITY_AUTHENTICATED_USER_RID     = 0xb
-	SECURITY_RESTRICTED_CODE_RID        = 0xc
-	SECURITY_NT_NON_UNIQUE_RID          = 0x15
-)
-
-// Predefined domain-relative RIDs for local groups.
-// See https://msdn.microsoft.com/en-us/library/windows/desktop/aa379649(v=vs.85).aspx
-const (
-	DOMAIN_ALIAS_RID_ADMINS                         = 0x220
-	DOMAIN_ALIAS_RID_USERS                          = 0x221
-	DOMAIN_ALIAS_RID_GUESTS                         = 0x222
-	DOMAIN_ALIAS_RID_POWER_USERS                    = 0x223
-	DOMAIN_ALIAS_RID_ACCOUNT_OPS                    = 0x224
-	DOMAIN_ALIAS_RID_SYSTEM_OPS                     = 0x225
-	DOMAIN_ALIAS_RID_PRINT_OPS                      = 0x226
-	DOMAIN_ALIAS_RID_BACKUP_OPS                     = 0x227
-	DOMAIN_ALIAS_RID_REPLICATOR                     = 0x228
-	DOMAIN_ALIAS_RID_RAS_SERVERS                    = 0x229
-	DOMAIN_ALIAS_RID_PREW2KCOMPACCESS               = 0x22a
-	DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS           = 0x22b
-	DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS      = 0x22c
-	DOMAIN_ALIAS_RID_INCOMING_FOREST_TRUST_BUILDERS = 0x22d
-	DOMAIN_ALIAS_RID_MONITORING_USERS               = 0X22e
-	DOMAIN_ALIAS_RID_LOGGING_USERS                  = 0x22f
-	DOMAIN_ALIAS_RID_AUTHORIZATIONACCESS            = 0x230
-	DOMAIN_ALIAS_RID_TS_LICENSE_SERVERS             = 0x231
-	DOMAIN_ALIAS_RID_DCOM_USERS                     = 0x232
-	DOMAIN_ALIAS_RID_IUSERS                         = 0x238
-	DOMAIN_ALIAS_RID_CRYPTO_OPERATORS               = 0x239
-	DOMAIN_ALIAS_RID_CACHEABLE_PRINCIPALS_GROUP     = 0x23b
-	DOMAIN_ALIAS_RID_NON_CACHEABLE_PRINCIPALS_GROUP = 0x23c
-	DOMAIN_ALIAS_RID_EVENT_LOG_READERS_GROUP        = 0x23d
-	DOMAIN_ALIAS_RID_CERTSVC_DCOM_ACCESS_GROUP      = 0x23e
-)
-
-//sys	LookupAccountSid(systemName *uint16, sid *SID, name *uint16, nameLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) = advapi32.LookupAccountSidW
-//sys	LookupAccountName(systemName *uint16, accountName *uint16, sid *SID, sidLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) = advapi32.LookupAccountNameW
-//sys	ConvertSidToStringSid(sid *SID, stringSid **uint16) (err error) = advapi32.ConvertSidToStringSidW
-//sys	ConvertStringSidToSid(stringSid *uint16, sid **SID) (err error) = advapi32.ConvertStringSidToSidW
-//sys	GetLengthSid(sid *SID) (len uint32) = advapi32.GetLengthSid
-//sys	CopySid(destSidLen uint32, destSid *SID, srcSid *SID) (err error) = advapi32.CopySid
-//sys	AllocateAndInitializeSid(identAuth *SidIdentifierAuthority, subAuth byte, subAuth0 uint32, subAuth1 uint32, subAuth2 uint32, subAuth3 uint32, subAuth4 uint32, subAuth5 uint32, subAuth6 uint32, subAuth7 uint32, sid **SID) (err error) = advapi32.AllocateAndInitializeSid
-//sys	FreeSid(sid *SID) (err error) [failretval!=0] = advapi32.FreeSid
-//sys	EqualSid(sid1 *SID, sid2 *SID) (isEqual bool) = advapi32.EqualSid
-
-// The security identifier (SID) structure is a variable-length
-// structure used to uniquely identify users or groups.
-type SID struct{}
-
-// StringToSid converts a string-format security identifier
-// sid into a valid, functional sid.
-func StringToSid(s string) (*SID, error) {
-	var sid *SID
-	p, e := UTF16PtrFromString(s)
-	if e != nil {
-		return nil, e
-	}
-	e = ConvertStringSidToSid(p, &sid)
-	if e != nil {
-		return nil, e
-	}
-	defer LocalFree((Handle)(unsafe.Pointer(sid)))
-	return sid.Copy()
-}
-
-// LookupSID retrieves a security identifier sid for the account
-// and the name of the domain on which the account was found.
-// System specify target computer to search.
-func LookupSID(system, account string) (sid *SID, domain string, accType uint32, err error) {
-	if len(account) == 0 {
-		return nil, "", 0, syscall.EINVAL
-	}
-	acc, e := UTF16PtrFromString(account)
-	if e != nil {
-		return nil, "", 0, e
-	}
-	var sys *uint16
-	if len(system) > 0 {
-		sys, e = UTF16PtrFromString(system)
-		if e != nil {
-			return nil, "", 0, e
-		}
-	}
-	n := uint32(50)
-	dn := uint32(50)
-	for {
-		b := make([]byte, n)
-		db := make([]uint16, dn)
-		sid = (*SID)(unsafe.Pointer(&b[0]))
-		e = LookupAccountName(sys, acc, sid, &n, &db[0], &dn, &accType)
-		if e == nil {
-			return sid, UTF16ToString(db), accType, nil
-		}
-		if e != ERROR_INSUFFICIENT_BUFFER {
-			return nil, "", 0, e
-		}
-		if n <= uint32(len(b)) {
-			return nil, "", 0, e
-		}
-	}
-}
-
-// String converts sid to a string format
-// suitable for display, storage, or transmission.
-func (sid *SID) String() (string, error) {
-	var s *uint16
-	e := ConvertSidToStringSid(sid, &s)
-	if e != nil {
-		return "", e
-	}
-	defer LocalFree((Handle)(unsafe.Pointer(s)))
-	return UTF16ToString((*[256]uint16)(unsafe.Pointer(s))[:]), nil
-}
-
-// Len returns the length, in bytes, of a valid security identifier sid.
-func (sid *SID) Len() int {
-	return int(GetLengthSid(sid))
-}
-
-// Copy creates a duplicate of security identifier sid.
-func (sid *SID) Copy() (*SID, error) {
-	b := make([]byte, sid.Len())
-	sid2 := (*SID)(unsafe.Pointer(&b[0]))
-	e := CopySid(uint32(len(b)), sid2, sid)
-	if e != nil {
-		return nil, e
-	}
-	return sid2, nil
-}
-
-// LookupAccount retrieves the name of the account for this sid
-// and the name of the first domain on which this sid is found.
-// System specify target computer to search for.
-func (sid *SID) LookupAccount(system string) (account, domain string, accType uint32, err error) {
-	var sys *uint16
-	if len(system) > 0 {
-		sys, err = UTF16PtrFromString(system)
-		if err != nil {
-			return "", "", 0, err
-		}
-	}
-	n := uint32(50)
-	dn := uint32(50)
-	for {
-		b := make([]uint16, n)
-		db := make([]uint16, dn)
-		e := LookupAccountSid(sys, sid, &b[0], &n, &db[0], &dn, &accType)
-		if e == nil {
-			return UTF16ToString(b), UTF16ToString(db), accType, nil
-		}
-		if e != ERROR_INSUFFICIENT_BUFFER {
-			return "", "", 0, e
-		}
-		if n <= uint32(len(b)) {
-			return "", "", 0, e
-		}
-	}
-}
-
-const (
-	// do not reorder
-	TOKEN_ASSIGN_PRIMARY = 1 << iota
-	TOKEN_DUPLICATE
-	TOKEN_IMPERSONATE
-	TOKEN_QUERY
-	TOKEN_QUERY_SOURCE
-	TOKEN_ADJUST_PRIVILEGES
-	TOKEN_ADJUST_GROUPS
-	TOKEN_ADJUST_DEFAULT
-
-	TOKEN_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED |
-		TOKEN_ASSIGN_PRIMARY |
-		TOKEN_DUPLICATE |
-		TOKEN_IMPERSONATE |
-		TOKEN_QUERY |
-		TOKEN_QUERY_SOURCE |
-		TOKEN_ADJUST_PRIVILEGES |
-		TOKEN_ADJUST_GROUPS |
-		TOKEN_ADJUST_DEFAULT
-	TOKEN_READ  = STANDARD_RIGHTS_READ | TOKEN_QUERY
-	TOKEN_WRITE = STANDARD_RIGHTS_WRITE |
-		TOKEN_ADJUST_PRIVILEGES |
-		TOKEN_ADJUST_GROUPS |
-		TOKEN_ADJUST_DEFAULT
-	TOKEN_EXECUTE = STANDARD_RIGHTS_EXECUTE
-)
-
-const (
-	// do not reorder
-	TokenUser = 1 + iota
-	TokenGroups
-	TokenPrivileges
-	TokenOwner
-	TokenPrimaryGroup
-	TokenDefaultDacl
-	TokenSource
-	TokenType
-	TokenImpersonationLevel
-	TokenStatistics
-	TokenRestrictedSids
-	TokenSessionId
-	TokenGroupsAndPrivileges
-	TokenSessionReference
-	TokenSandBoxInert
-	TokenAuditPolicy
-	TokenOrigin
-	TokenElevationType
-	TokenLinkedToken
-	TokenElevation
-	TokenHasRestrictions
-	TokenAccessInformation
-	TokenVirtualizationAllowed
-	TokenVirtualizationEnabled
-	TokenIntegrityLevel
-	TokenUIAccess
-	TokenMandatoryPolicy
-	TokenLogonSid
-	MaxTokenInfoClass
-)
-
-type SIDAndAttributes struct {
-	Sid        *SID
-	Attributes uint32
-}
-
-type Tokenuser struct {
-	User SIDAndAttributes
-}
-
-type Tokenprimarygroup struct {
-	PrimaryGroup *SID
-}
-
-type Tokengroups struct {
-	GroupCount uint32
-	Groups     [1]SIDAndAttributes
-}
-
-// Authorization Functions
-//sys checkTokenMembership(tokenHandle Token, sidToCheck *SID, isMember *int32) (err error) = advapi32.CheckTokenMembership
-//sys	OpenProcessToken(h Handle, access uint32, token *Token) (err error) = advapi32.OpenProcessToken
-//sys	GetTokenInformation(t Token, infoClass uint32, info *byte, infoLen uint32, returnedLen *uint32) (err error) = advapi32.GetTokenInformation
-//sys	GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) = userenv.GetUserProfileDirectoryW
-
-// An access token contains the security information for a logon session.
-// The system creates an access token when a user logs on, and every
-// process executed on behalf of the user has a copy of the token.
-// The token identifies the user, the user's groups, and the user's
-// privileges. The system uses the token to control access to securable
-// objects and to control the ability of the user to perform various
-// system-related operations on the local computer.
-type Token Handle
-
-// OpenCurrentProcessToken opens the access token
-// associated with current process.
-func OpenCurrentProcessToken() (Token, error) {
-	p, e := GetCurrentProcess()
-	if e != nil {
-		return 0, e
-	}
-	var t Token
-	e = OpenProcessToken(p, TOKEN_QUERY, &t)
-	if e != nil {
-		return 0, e
-	}
-	return t, nil
-}
-
-// Close releases access to access token.
-func (t Token) Close() error {
-	return CloseHandle(Handle(t))
-}
-
-// getInfo retrieves a specified type of information about an access token.
-func (t Token) getInfo(class uint32, initSize int) (unsafe.Pointer, error) {
-	n := uint32(initSize)
-	for {
-		b := make([]byte, n)
-		e := GetTokenInformation(t, class, &b[0], uint32(len(b)), &n)
-		if e == nil {
-			return unsafe.Pointer(&b[0]), nil
-		}
-		if e != ERROR_INSUFFICIENT_BUFFER {
-			return nil, e
-		}
-		if n <= uint32(len(b)) {
-			return nil, e
-		}
-	}
-}
-
-// GetTokenUser retrieves access token t user account information.
-func (t Token) GetTokenUser() (*Tokenuser, error) {
-	i, e := t.getInfo(TokenUser, 50)
-	if e != nil {
-		return nil, e
-	}
-	return (*Tokenuser)(i), nil
-}
-
-// GetTokenGroups retrieves group accounts associated with access token t.
-func (t Token) GetTokenGroups() (*Tokengroups, error) {
-	i, e := t.getInfo(TokenGroups, 50)
-	if e != nil {
-		return nil, e
-	}
-	return (*Tokengroups)(i), nil
-}
-
-// GetTokenPrimaryGroup retrieves access token t primary group information.
-// A pointer to a SID structure representing a group that will become
-// the primary group of any objects created by a process using this access token.
-func (t Token) GetTokenPrimaryGroup() (*Tokenprimarygroup, error) {
-	i, e := t.getInfo(TokenPrimaryGroup, 50)
-	if e != nil {
-		return nil, e
-	}
-	return (*Tokenprimarygroup)(i), nil
-}
-
-// GetUserProfileDirectory retrieves path to the
-// root directory of the access token t user's profile.
-func (t Token) GetUserProfileDirectory() (string, error) {
-	n := uint32(100)
-	for {
-		b := make([]uint16, n)
-		e := GetUserProfileDirectory(t, &b[0], &n)
-		if e == nil {
-			return UTF16ToString(b), nil
-		}
-		if e != ERROR_INSUFFICIENT_BUFFER {
-			return "", e
-		}
-		if n <= uint32(len(b)) {
-			return "", e
-		}
-	}
-}
-
-// IsMember reports whether the access token t is a member of the provided SID.
-func (t Token) IsMember(sid *SID) (bool, error) {
-	var b int32
-	if e := checkTokenMembership(t, sid, &b); e != nil {
-		return false, e
-	}
-	return b != 0, nil
-}

vendor/golang.org/x/sys/windows/service.go

@@ -1,164 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build windows
-
-package windows
-
-const (
-	SC_MANAGER_CONNECT            = 1
-	SC_MANAGER_CREATE_SERVICE     = 2
-	SC_MANAGER_ENUMERATE_SERVICE  = 4
-	SC_MANAGER_LOCK               = 8
-	SC_MANAGER_QUERY_LOCK_STATUS  = 16
-	SC_MANAGER_MODIFY_BOOT_CONFIG = 32
-	SC_MANAGER_ALL_ACCESS         = 0xf003f
-)
-
-//sys	OpenSCManager(machineName *uint16, databaseName *uint16, access uint32) (handle Handle, err error) [failretval==0] = advapi32.OpenSCManagerW
-
-const (
-	SERVICE_KERNEL_DRIVER       = 1
-	SERVICE_FILE_SYSTEM_DRIVER  = 2
-	SERVICE_ADAPTER             = 4
-	SERVICE_RECOGNIZER_DRIVER   = 8
-	SERVICE_WIN32_OWN_PROCESS   = 16
-	SERVICE_WIN32_SHARE_PROCESS = 32
-	SERVICE_WIN32               = SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS
-	SERVICE_INTERACTIVE_PROCESS = 256
-	SERVICE_DRIVER              = SERVICE_KERNEL_DRIVER | SERVICE_FILE_SYSTEM_DRIVER | SERVICE_RECOGNIZER_DRIVER
-	SERVICE_TYPE_ALL            = SERVICE_WIN32 | SERVICE_ADAPTER | SERVICE_DRIVER | SERVICE_INTERACTIVE_PROCESS
-
-	SERVICE_BOOT_START   = 0
-	SERVICE_SYSTEM_START = 1
-	SERVICE_AUTO_START   = 2
-	SERVICE_DEMAND_START = 3
-	SERVICE_DISABLED     = 4
-
-	SERVICE_ERROR_IGNORE   = 0
-	SERVICE_ERROR_NORMAL   = 1
-	SERVICE_ERROR_SEVERE   = 2
-	SERVICE_ERROR_CRITICAL = 3
-
-	SC_STATUS_PROCESS_INFO = 0
-
-	SERVICE_STOPPED          = 1
-	SERVICE_START_PENDING    = 2
-	SERVICE_STOP_PENDING     = 3
-	SERVICE_RUNNING          = 4
-	SERVICE_CONTINUE_PENDING = 5
-	SERVICE_PAUSE_PENDING    = 6
-	SERVICE_PAUSED           = 7
-	SERVICE_NO_CHANGE        = 0xffffffff
-
-	SERVICE_ACCEPT_STOP                  = 1
-	SERVICE_ACCEPT_PAUSE_CONTINUE        = 2
-	SERVICE_ACCEPT_SHUTDOWN              = 4
-	SERVICE_ACCEPT_PARAMCHANGE           = 8
-	SERVICE_ACCEPT_NETBINDCHANGE         = 16
-	SERVICE_ACCEPT_HARDWAREPROFILECHANGE = 32
-	SERVICE_ACCEPT_POWEREVENT            = 64
-	SERVICE_ACCEPT_SESSIONCHANGE         = 128
-
-	SERVICE_CONTROL_STOP                  = 1
-	SERVICE_CONTROL_PAUSE                 = 2
-	SERVICE_CONTROL_CONTINUE              = 3
-	SERVICE_CONTROL_INTERROGATE           = 4
-	SERVICE_CONTROL_SHUTDOWN              = 5
-	SERVICE_CONTROL_PARAMCHANGE           = 6
-	SERVICE_CONTROL_NETBINDADD            = 7
-	SERVICE_CONTROL_NETBINDREMOVE         = 8
-	SERVICE_CONTROL_NETBINDENABLE         = 9
-	SERVICE_CONTROL_NETBINDDISABLE        = 10
-	SERVICE_CONTROL_DEVICEEVENT           = 11
-	SERVICE_CONTROL_HARDWAREPROFILECHANGE = 12
-	SERVICE_CONTROL_POWEREVENT            = 13
-	SERVICE_CONTROL_SESSIONCHANGE         = 14
-
-	SERVICE_ACTIVE    = 1
-	SERVICE_INACTIVE  = 2
-	SERVICE_STATE_ALL = 3
-
-	SERVICE_QUERY_CONFIG           = 1
-	SERVICE_CHANGE_CONFIG          = 2
-	SERVICE_QUERY_STATUS           = 4
-	SERVICE_ENUMERATE_DEPENDENTS   = 8
-	SERVICE_START                  = 16
-	SERVICE_STOP                   = 32
-	SERVICE_PAUSE_CONTINUE         = 64
-	SERVICE_INTERROGATE            = 128
-	SERVICE_USER_DEFINED_CONTROL   = 256
-	SERVICE_ALL_ACCESS             = STANDARD_RIGHTS_REQUIRED | SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_START | SERVICE_STOP | SERVICE_PAUSE_CONTINUE | SERVICE_INTERROGATE | SERVICE_USER_DEFINED_CONTROL
-	SERVICE_RUNS_IN_SYSTEM_PROCESS = 1
-	SERVICE_CONFIG_DESCRIPTION     = 1
-	SERVICE_CONFIG_FAILURE_ACTIONS = 2
-
-	NO_ERROR = 0
-
-	SC_ENUM_PROCESS_INFO = 0
-)
-
-type SERVICE_STATUS struct {
-	ServiceType             uint32
-	CurrentState            uint32
-	ControlsAccepted        uint32
-	Win32ExitCode           uint32
-	ServiceSpecificExitCode uint32
-	CheckPoint              uint32
-	WaitHint                uint32
-}
-
-type SERVICE_TABLE_ENTRY struct {
-	ServiceName *uint16
-	ServiceProc uintptr
-}
-
-type QUERY_SERVICE_CONFIG struct {
-	ServiceType      uint32
-	StartType        uint32
-	ErrorControl     uint32
-	BinaryPathName   *uint16
-	LoadOrderGroup   *uint16
-	TagId            uint32
-	Dependencies     *uint16
-	ServiceStartName *uint16
-	DisplayName      *uint16
-}
-
-type SERVICE_DESCRIPTION struct {
-	Description *uint16
-}
-
-type SERVICE_STATUS_PROCESS struct {
-	ServiceType             uint32
-	CurrentState            uint32
-	ControlsAccepted        uint32
-	Win32ExitCode           uint32
-	ServiceSpecificExitCode uint32
-	CheckPoint              uint32
-	WaitHint                uint32
-	ProcessId               uint32
-	ServiceFlags            uint32
-}
-
-type ENUM_SERVICE_STATUS_PROCESS struct {
-	ServiceName          *uint16
-	DisplayName          *uint16
-	ServiceStatusProcess SERVICE_STATUS_PROCESS
-}
-
-//sys	CloseServiceHandle(handle Handle) (err error) = advapi32.CloseServiceHandle
-//sys	CreateService(mgr Handle, serviceName *uint16, displayName *uint16, access uint32, srvType uint32, startType uint32, errCtl uint32, pathName *uint16, loadOrderGroup *uint16, tagId *uint32, dependencies *uint16, serviceStartName *uint16, password *uint16) (handle Handle, err error) [failretval==0] = advapi32.CreateServiceW
-//sys	OpenService(mgr Handle, serviceName *uint16, access uint32) (handle Handle, err error) [failretval==0] = advapi32.OpenServiceW
-//sys	DeleteService(service Handle) (err error) = advapi32.DeleteService
-//sys	StartService(service Handle, numArgs uint32, argVectors **uint16) (err error) = advapi32.StartServiceW
-//sys	QueryServiceStatus(service Handle, status *SERVICE_STATUS) (err error) = advapi32.QueryServiceStatus
-//sys	ControlService(service Handle, control uint32, status *SERVICE_STATUS) (err error) = advapi32.ControlService
-//sys	StartServiceCtrlDispatcher(serviceTable *SERVICE_TABLE_ENTRY) (err error) = advapi32.StartServiceCtrlDispatcherW
-//sys	SetServiceStatus(service Handle, serviceStatus *SERVICE_STATUS) (err error) = advapi32.SetServiceStatus
-//sys	ChangeServiceConfig(service Handle, serviceType uint32, startType uint32, errorControl uint32, binaryPathName *uint16, loadOrderGroup *uint16, tagId *uint32, dependencies *uint16, serviceStartName *uint16, password *uint16, displayName *uint16) (err error) = advapi32.ChangeServiceConfigW
-//sys	QueryServiceConfig(service Handle, serviceConfig *QUERY_SERVICE_CONFIG, bufSize uint32, bytesNeeded *uint32) (err error) = advapi32.QueryServiceConfigW
-//sys	ChangeServiceConfig2(service Handle, infoLevel uint32, info *byte) (err error) = advapi32.ChangeServiceConfig2W
-//sys	QueryServiceConfig2(service Handle, infoLevel uint32, buff *byte, buffSize uint32, bytesNeeded *uint32) (err error) = advapi32.QueryServiceConfig2W
-//sys	EnumServicesStatusEx(mgr Handle, infoLevel uint32, serviceType uint32, serviceState uint32, services *byte, bufSize uint32, bytesNeeded *uint32, servicesReturned *uint32, resumeHandle *uint32, groupName *uint16) (err error) = advapi32.EnumServicesStatusExW

vendor/golang.org/x/sys/windows/str.go

@@ -1,22 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build windows
-
-package windows
-
-func itoa(val int) string { // do it here rather than with fmt to avoid dependency
-	if val < 0 {
-		return "-" + itoa(-val)
-	}
-	var buf [32]byte // big enough for int64
-	i := len(buf) - 1
-	for val >= 10 {
-		buf[i] = byte(val%10 + '0')
-		i--
-		val /= 10
-	}
-	buf[i] = byte(val + '0')
-	return string(buf[i:])
-}

vendor/golang.org/x/sys/windows/syscall.go

@@ -1,71 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build windows
-
-// Package windows contains an interface to the low-level operating system
-// primitives. OS details vary depending on the underlying system, and
-// by default, godoc will display the OS-specific documentation for the current
-// system. If you want godoc to display syscall documentation for another
-// system, set $GOOS and $GOARCH to the desired system. For example, if
-// you want to view documentation for freebsd/arm on linux/amd64, set $GOOS
-// to freebsd and $GOARCH to arm.
-// The primary use of this package is inside other packages that provide a more
-// portable interface to the system, such as "os", "time" and "net".  Use
-// those packages rather than this one if you can.
-// For details of the functions and data types in this package consult
-// the manuals for the appropriate operating system.
-// These calls return err == nil to indicate success; otherwise
-// err represents an operating system error describing the failure and
-// holds a value of type syscall.Errno.
-package windows // import "golang.org/x/sys/windows"
-
-import (
-	"syscall"
-)
-
-// ByteSliceFromString returns a NUL-terminated slice of bytes
-// containing the text of s. If s contains a NUL byte at any
-// location, it returns (nil, syscall.EINVAL).
-func ByteSliceFromString(s string) ([]byte, error) {
-	for i := 0; i < len(s); i++ {
-		if s[i] == 0 {
-			return nil, syscall.EINVAL
-		}
-	}
-	a := make([]byte, len(s)+1)
-	copy(a, s)
-	return a, nil
-}
-
-// BytePtrFromString returns a pointer to a NUL-terminated array of
-// bytes containing the text of s. If s contains a NUL byte at any
-// location, it returns (nil, syscall.EINVAL).
-func BytePtrFromString(s string) (*byte, error) {
-	a, err := ByteSliceFromString(s)
-	if err != nil {
-		return nil, err
-	}
-	return &a[0], nil
-}
-
-// Single-word zero for use when we need a valid pointer to 0 bytes.
-// See mksyscall.pl.
-var _zero uintptr
-
-func (ts *Timespec) Unix() (sec int64, nsec int64) {
-	return int64(ts.Sec), int64(ts.Nsec)
-}
-
-func (tv *Timeval) Unix() (sec int64, nsec int64) {
-	return int64(tv.Sec), int64(tv.Usec) * 1000
-}
-
-func (ts *Timespec) Nano() int64 {
-	return int64(ts.Sec)*1e9 + int64(ts.Nsec)
-}
-
-func (tv *Timeval) Nano() int64 {
-	return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
-}

vendor/golang.org/x/sys/windows/types_windows_386.go

@@ -1,22 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package windows
-
-type WSAData struct {
-	Version      uint16
-	HighVersion  uint16
-	Description  [WSADESCRIPTION_LEN + 1]byte
-	SystemStatus [WSASYS_STATUS_LEN + 1]byte
-	MaxSockets   uint16
-	MaxUdpDg     uint16
-	VendorInfo   *byte
-}
-
-type Servent struct {
-	Name    *byte
-	Aliases **byte
-	Port    uint16
-	Proto   *byte
-}