Switch to go modules

vendor/github.com/Microsoft/go-winio/pkg/etwlogrus/hook.go

@@ -1,192 +0,0 @@
-package etwlogrus
-
-import (
-	"fmt"
-	"reflect"
-
-	"github.com/Microsoft/go-winio/internal/etw"
-	"github.com/sirupsen/logrus"
-)
-
-// Hook is a Logrus hook which logs received events to ETW.
-type Hook struct {
-	provider *etw.Provider
-}
-
-// NewHook registers a new ETW provider and returns a hook to log from it.
-func NewHook(providerName string) (*Hook, error) {
-	hook := Hook{}
-
-	provider, err := etw.NewProvider(providerName, nil)
-	if err != nil {
-		return nil, err
-	}
-	hook.provider = provider
-
-	return &hook, nil
-}
-
-// Levels returns the set of levels that this hook wants to receive log entries
-// for.
-func (h *Hook) Levels() []logrus.Level {
-	return []logrus.Level{
-		logrus.TraceLevel,
-		logrus.DebugLevel,
-		logrus.InfoLevel,
-		logrus.WarnLevel,
-		logrus.ErrorLevel,
-		logrus.FatalLevel,
-		logrus.PanicLevel,
-	}
-}
-
-// Fire receives each Logrus entry as it is logged, and logs it to ETW.
-func (h *Hook) Fire(e *logrus.Entry) error {
-	level := etw.Level(e.Level)
-	if !h.provider.IsEnabledForLevel(level) {
-		return nil
-	}
-
-	// Reserve extra space for the message field.
-	fields := make([]etw.FieldOpt, 0, len(e.Data)+1)
-
-	fields = append(fields, etw.StringField("Message", e.Message))
-
-	for k, v := range e.Data {
-		fields = append(fields, getFieldOpt(k, v))
-	}
-
-	// We could try to map Logrus levels to ETW levels, but we would lose some
-	// fidelity as there are fewer ETW levels. So instead we use the level
-	// directly.
-	return h.provider.WriteEvent(
-		"LogrusEntry",
-		etw.WithEventOpts(etw.WithLevel(level)),
-		fields)
-}
-
-// Currently, we support logging basic builtin types (int, string, etc), slices
-// of basic builtin types, error, types derived from the basic types (e.g. "type
-// foo int"), and structs (recursively logging their fields). We do not support
-// slices of derived types (e.g. "[]foo").
-//
-// For types that we don't support, the value is formatted via fmt.Sprint, and
-// we also log a message that the type is unsupported along with the formatted
-// type. The intent of this is to make it easier to see which types are not
-// supported in traces, so we can evaluate adding support for more types in the
-// future.
-func getFieldOpt(k string, v interface{}) etw.FieldOpt {
-	switch v := v.(type) {
-	case bool:
-		return etw.BoolField(k, v)
-	case []bool:
-		return etw.BoolArray(k, v)
-	case string:
-		return etw.StringField(k, v)
-	case []string:
-		return etw.StringArray(k, v)
-	case int:
-		return etw.IntField(k, v)
-	case []int:
-		return etw.IntArray(k, v)
-	case int8:
-		return etw.Int8Field(k, v)
-	case []int8:
-		return etw.Int8Array(k, v)
-	case int16:
-		return etw.Int16Field(k, v)
-	case []int16:
-		return etw.Int16Array(k, v)
-	case int32:
-		return etw.Int32Field(k, v)
-	case []int32:
-		return etw.Int32Array(k, v)
-	case int64:
-		return etw.Int64Field(k, v)
-	case []int64:
-		return etw.Int64Array(k, v)
-	case uint:
-		return etw.UintField(k, v)
-	case []uint:
-		return etw.UintArray(k, v)
-	case uint8:
-		return etw.Uint8Field(k, v)
-	case []uint8:
-		return etw.Uint8Array(k, v)
-	case uint16:
-		return etw.Uint16Field(k, v)
-	case []uint16:
-		return etw.Uint16Array(k, v)
-	case uint32:
-		return etw.Uint32Field(k, v)
-	case []uint32:
-		return etw.Uint32Array(k, v)
-	case uint64:
-		return etw.Uint64Field(k, v)
-	case []uint64:
-		return etw.Uint64Array(k, v)
-	case uintptr:
-		return etw.UintptrField(k, v)
-	case []uintptr:
-		return etw.UintptrArray(k, v)
-	case float32:
-		return etw.Float32Field(k, v)
-	case []float32:
-		return etw.Float32Array(k, v)
-	case float64:
-		return etw.Float64Field(k, v)
-	case []float64:
-		return etw.Float64Array(k, v)
-	case error:
-		return etw.StringField(k, v.Error())
-	default:
-		switch rv := reflect.ValueOf(v); rv.Kind() {
-		case reflect.Bool:
-			return getFieldOpt(k, rv.Bool())
-		case reflect.Int:
-			return getFieldOpt(k, int(rv.Int()))
-		case reflect.Int8:
-			return getFieldOpt(k, int8(rv.Int()))
-		case reflect.Int16:
-			return getFieldOpt(k, int16(rv.Int()))
-		case reflect.Int32:
-			return getFieldOpt(k, int32(rv.Int()))
-		case reflect.Int64:
-			return getFieldOpt(k, int64(rv.Int()))
-		case reflect.Uint:
-			return getFieldOpt(k, uint(rv.Uint()))
-		case reflect.Uint8:
-			return getFieldOpt(k, uint8(rv.Uint()))
-		case reflect.Uint16:
-			return getFieldOpt(k, uint16(rv.Uint()))
-		case reflect.Uint32:
-			return getFieldOpt(k, uint32(rv.Uint()))
-		case reflect.Uint64:
-			return getFieldOpt(k, uint64(rv.Uint()))
-		case reflect.Uintptr:
-			return getFieldOpt(k, uintptr(rv.Uint()))
-		case reflect.Float32:
-			return getFieldOpt(k, float32(rv.Float()))
-		case reflect.Float64:
-			return getFieldOpt(k, float64(rv.Float()))
-		case reflect.String:
-			return getFieldOpt(k, rv.String())
-		case reflect.Struct:
-			fields := make([]etw.FieldOpt, 0, rv.NumField())
-			for i := 0; i < rv.NumField(); i++ {
-				field := rv.Field(i)
-				if field.CanInterface() {
-					fields = append(fields, getFieldOpt(k, field.Interface()))
-				}
-			}
-			return etw.Struct(k, fields...)
-		}
-	}
-
-	return etw.StringField(k, fmt.Sprintf("(Unsupported: %T) %v", v, v))
-}
-
-// Close cleans up the hook and closes the ETW provider.
-func (h *Hook) Close() error {
-	return h.provider.Close()
-}

vendor/github.com/Microsoft/go-winio/pkg/etwlogrus/hook_test.go

@@ -1,126 +0,0 @@
-package etwlogrus
-
-import (
-	"github.com/Microsoft/go-winio/internal/etw"
-	"testing"
-)
-
-func fireEvent(t *testing.T, p *etw.Provider, name string, value interface{}) {
-	if err := p.WriteEvent(
-		name,
-		nil,
-		etw.WithFields(getFieldOpt("Field", value))); err != nil {
-
-		t.Fatal(err)
-	}
-}
-
-// The purpose of this test is to log lots of different field types, to test the
-// logic that converts them to ETW. Because we don't have a way to
-// programatically validate the ETW events, this test has two main purposes: (1)
-// validate nothing causes a panic while logging (2) allow manual validation that
-// the data is logged correctly (through a tool like WPA).
-func TestFieldLogging(t *testing.T) {
-	// Sample WPRP to collect this provider:
-	//
-	// <?xml version="1.0"?>
-	// <WindowsPerformanceRecorder Version="1">
-	//   <Profiles>
-	//     <EventCollector Id="Collector" Name="MyCollector">
-	//       <BufferSize Value="256"/>
-	//       <Buffers Value="100"/>
-	//     </EventCollector>
-	//     <EventProvider Id="HookTest" Name="5e50de03-107c-5a83-74c6-998c4491e7e9"/>
-	//     <Profile Id="Test.Verbose.File" Name="Test" Description="Test" LoggingMode="File" DetailLevel="Verbose">
-	//       <Collectors>
-	//         <EventCollectorId Value="Collector">
-	//           <EventProviders>
-	//             <EventProviderId Value="HookTest"/>
-	//           </EventProviders>
-	//         </EventCollectorId>
-	//       </Collectors>
-	//     </Profile>
-	//   </Profiles>
-	// </WindowsPerformanceRecorder>
-	//
-	// Start collection:
-	// wpr -start HookTest.wprp -filemode
-	//
-	// Stop collection:
-	// wpr -stop HookTest.etl
-	p, err := etw.NewProvider("HookTest", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() {
-		if err := p.Close(); err != nil {
-			t.Fatal(err)
-		}
-	}()
-
-	fireEvent(t, p, "Bool", true)
-	fireEvent(t, p, "BoolSlice", []bool{true, false, true})
-	fireEvent(t, p, "EmptyBoolSlice", []bool{})
-	fireEvent(t, p, "String", "teststring")
-	fireEvent(t, p, "StringSlice", []string{"sstr1", "sstr2", "sstr3"})
-	fireEvent(t, p, "EmptyStringSlice", []string{})
-	fireEvent(t, p, "Int", int(1))
-	fireEvent(t, p, "IntSlice", []int{2, 3, 4})
-	fireEvent(t, p, "EmptyIntSlice", []int{})
-	fireEvent(t, p, "Int8", int8(5))
-	fireEvent(t, p, "Int8Slice", []int8{6, 7, 8})
-	fireEvent(t, p, "EmptyInt8Slice", []int8{})
-	fireEvent(t, p, "Int16", int16(9))
-	fireEvent(t, p, "Int16Slice", []int16{10, 11, 12})
-	fireEvent(t, p, "EmptyInt16Slice", []int16{})
-	fireEvent(t, p, "Int32", int32(13))
-	fireEvent(t, p, "Int32Slice", []int32{14, 15, 16})
-	fireEvent(t, p, "EmptyInt32Slice", []int32{})
-	fireEvent(t, p, "Int64", int64(17))
-	fireEvent(t, p, "Int64Slice", []int64{18, 19, 20})
-	fireEvent(t, p, "EmptyInt64Slice", []int64{})
-	fireEvent(t, p, "Uint", uint(21))
-	fireEvent(t, p, "UintSlice", []uint{22, 23, 24})
-	fireEvent(t, p, "EmptyUintSlice", []uint{})
-	fireEvent(t, p, "Uint8", uint8(25))
-	fireEvent(t, p, "Uint8Slice", []uint8{26, 27, 28})
-	fireEvent(t, p, "EmptyUint8Slice", []uint8{})
-	fireEvent(t, p, "Uint16", uint16(29))
-	fireEvent(t, p, "Uint16Slice", []uint16{30, 31, 32})
-	fireEvent(t, p, "EmptyUint16Slice", []uint16{})
-	fireEvent(t, p, "Uint32", uint32(33))
-	fireEvent(t, p, "Uint32Slice", []uint32{34, 35, 36})
-	fireEvent(t, p, "EmptyUint32Slice", []uint32{})
-	fireEvent(t, p, "Uint64", uint64(37))
-	fireEvent(t, p, "Uint64Slice", []uint64{38, 39, 40})
-	fireEvent(t, p, "EmptyUint64Slice", []uint64{})
-	fireEvent(t, p, "Uintptr", uintptr(41))
-	fireEvent(t, p, "UintptrSlice", []uintptr{42, 43, 44})
-	fireEvent(t, p, "EmptyUintptrSlice", []uintptr{})
-	fireEvent(t, p, "Float32", float32(45.46))
-	fireEvent(t, p, "Float32Slice", []float32{47.48, 49.50, 51.52})
-	fireEvent(t, p, "EmptyFloat32Slice", []float32{})
-	fireEvent(t, p, "Float64", float64(53.54))
-	fireEvent(t, p, "Float64Slice", []float64{55.56, 57.58, 59.60})
-	fireEvent(t, p, "EmptyFloat64Slice", []float64{})
-
-	type struct1 struct {
-		A    float32
-		priv int
-		B    []uint
-	}
-	type struct2 struct {
-		A int
-		B int
-	}
-	type struct3 struct {
-		struct2
-		A    int
-		B    string
-		priv string
-		C    struct1
-		D    uint16
-	}
-	// Unexported fields, and fields in embedded structs, should not log.
-	fireEvent(t, p, "Struct", struct3{struct2{-1, -2}, 1, "2s", "-3s", struct1{3.4, -4, []uint{5, 6, 7}}, 8})
-}

vendor/github.com/Microsoft/go-winio/pkg/guid/guid.go

@@ -0,0 +1,235 @@
+// Package guid provides a GUID type. The backing structure for a GUID is
+// identical to that used by the golang.org/x/sys/windows GUID type.
+// There are two main binary encodings used for a GUID, the big-endian encoding,
+// and the Windows (mixed-endian) encoding. See here for details:
+// https://en.wikipedia.org/wiki/Universally_unique_identifier#Encoding
+package guid
+
+import (
+	"crypto/rand"
+	"crypto/sha1"
+	"encoding"
+	"encoding/binary"
+	"fmt"
+	"strconv"
+
+	"golang.org/x/sys/windows"
+)
+
+// Variant specifies which GUID variant (or "type") of the GUID. It determines
+// how the entirety of the rest of the GUID is interpreted.
+type Variant uint8
+
+// The variants specified by RFC 4122.
+const (
+	// VariantUnknown specifies a GUID variant which does not conform to one of
+	// the variant encodings specified in RFC 4122.
+	VariantUnknown Variant = iota
+	VariantNCS
+	VariantRFC4122
+	VariantMicrosoft
+	VariantFuture
+)
+
+// Version specifies how the bits in the GUID were generated. For instance, a
+// version 4 GUID is randomly generated, and a version 5 is generated from the
+// hash of an input string.
+type Version uint8
+
+var _ = (encoding.TextMarshaler)(GUID{})
+var _ = (encoding.TextUnmarshaler)(&GUID{})
+
+// GUID represents a GUID/UUID. It has the same structure as
+// golang.org/x/sys/windows.GUID so that it can be used with functions expecting
+// that type. It is defined as its own type so that stringification and
+// marshaling can be supported. The representation matches that used by native
+// Windows code.
+type GUID windows.GUID
+
+// NewV4 returns a new version 4 (pseudorandom) GUID, as defined by RFC 4122.
+func NewV4() (GUID, error) {
+	var b [16]byte
+	if _, err := rand.Read(b[:]); err != nil {
+		return GUID{}, err
+	}
+
+	g := FromArray(b)
+	g.setVersion(4) // Version 4 means randomly generated.
+	g.setVariant(VariantRFC4122)
+
+	return g, nil
+}
+
+// NewV5 returns a new version 5 (generated from a string via SHA-1 hashing)
+// GUID, as defined by RFC 4122. The RFC is unclear on the encoding of the name,
+// and the sample code treats it as a series of bytes, so we do the same here.
+//
+// Some implementations, such as those found on Windows, treat the name as a
+// big-endian UTF16 stream of bytes. If that is desired, the string can be
+// encoded as such before being passed to this function.
+func NewV5(namespace GUID, name []byte) (GUID, error) {
+	b := sha1.New()
+	namespaceBytes := namespace.ToArray()
+	b.Write(namespaceBytes[:])
+	b.Write(name)
+
+	a := [16]byte{}
+	copy(a[:], b.Sum(nil))
+
+	g := FromArray(a)
+	g.setVersion(5) // Version 5 means generated from a string.
+	g.setVariant(VariantRFC4122)
+
+	return g, nil
+}
+
+func fromArray(b [16]byte, order binary.ByteOrder) GUID {
+	var g GUID
+	g.Data1 = order.Uint32(b[0:4])
+	g.Data2 = order.Uint16(b[4:6])
+	g.Data3 = order.Uint16(b[6:8])
+	copy(g.Data4[:], b[8:16])
+	return g
+}
+
+func (g GUID) toArray(order binary.ByteOrder) [16]byte {
+	b := [16]byte{}
+	order.PutUint32(b[0:4], g.Data1)
+	order.PutUint16(b[4:6], g.Data2)
+	order.PutUint16(b[6:8], g.Data3)
+	copy(b[8:16], g.Data4[:])
+	return b
+}
+
+// FromArray constructs a GUID from a big-endian encoding array of 16 bytes.
+func FromArray(b [16]byte) GUID {
+	return fromArray(b, binary.BigEndian)
+}
+
+// ToArray returns an array of 16 bytes representing the GUID in big-endian
+// encoding.
+func (g GUID) ToArray() [16]byte {
+	return g.toArray(binary.BigEndian)
+}
+
+// FromWindowsArray constructs a GUID from a Windows encoding array of bytes.
+func FromWindowsArray(b [16]byte) GUID {
+	return fromArray(b, binary.LittleEndian)
+}
+
+// ToWindowsArray returns an array of 16 bytes representing the GUID in Windows
+// encoding.
+func (g GUID) ToWindowsArray() [16]byte {
+	return g.toArray(binary.LittleEndian)
+}
+
+func (g GUID) String() string {
+	return fmt.Sprintf(
+		"%08x-%04x-%04x-%04x-%012x",
+		g.Data1,
+		g.Data2,
+		g.Data3,
+		g.Data4[:2],
+		g.Data4[2:])
+}
+
+// FromString parses a string containing a GUID and returns the GUID. The only
+// format currently supported is the `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`
+// format.
+func FromString(s string) (GUID, error) {
+	if len(s) != 36 {
+		return GUID{}, fmt.Errorf("invalid GUID %q", s)
+	}
+	if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
+		return GUID{}, fmt.Errorf("invalid GUID %q", s)
+	}
+
+	var g GUID
+
+	data1, err := strconv.ParseUint(s[0:8], 16, 32)
+	if err != nil {
+		return GUID{}, fmt.Errorf("invalid GUID %q", s)
+	}
+	g.Data1 = uint32(data1)
+
+	data2, err := strconv.ParseUint(s[9:13], 16, 16)
+	if err != nil {
+		return GUID{}, fmt.Errorf("invalid GUID %q", s)
+	}
+	g.Data2 = uint16(data2)
+
+	data3, err := strconv.ParseUint(s[14:18], 16, 16)
+	if err != nil {
+		return GUID{}, fmt.Errorf("invalid GUID %q", s)
+	}
+	g.Data3 = uint16(data3)
+
+	for i, x := range []int{19, 21, 24, 26, 28, 30, 32, 34} {
+		v, err := strconv.ParseUint(s[x:x+2], 16, 8)
+		if err != nil {
+			return GUID{}, fmt.Errorf("invalid GUID %q", s)
+		}
+		g.Data4[i] = uint8(v)
+	}
+
+	return g, nil
+}
+
+func (g *GUID) setVariant(v Variant) {
+	d := g.Data4[0]
+	switch v {
+	case VariantNCS:
+		d = (d & 0x7f)
+	case VariantRFC4122:
+		d = (d & 0x3f) | 0x80
+	case VariantMicrosoft:
+		d = (d & 0x1f) | 0xc0
+	case VariantFuture:
+		d = (d & 0x0f) | 0xe0
+	case VariantUnknown:
+		fallthrough
+	default:
+		panic(fmt.Sprintf("invalid variant: %d", v))
+	}
+	g.Data4[0] = d
+}
+
+// Variant returns the GUID variant, as defined in RFC 4122.
+func (g GUID) Variant() Variant {
+	b := g.Data4[0]
+	if b&0x80 == 0 {
+		return VariantNCS
+	} else if b&0xc0 == 0x80 {
+		return VariantRFC4122
+	} else if b&0xe0 == 0xc0 {
+		return VariantMicrosoft
+	} else if b&0xe0 == 0xe0 {
+		return VariantFuture
+	}
+	return VariantUnknown
+}
+
+func (g *GUID) setVersion(v Version) {
+	g.Data3 = (g.Data3 & 0x0fff) | (uint16(v) << 12)
+}
+
+// Version returns the GUID version, as defined in RFC 4122.
+func (g GUID) Version() Version {
+	return Version((g.Data3 & 0xF000) >> 12)
+}
+
+// MarshalText returns the textual representation of the GUID.
+func (g GUID) MarshalText() ([]byte, error) {
+	return []byte(g.String()), nil
+}
+
+// UnmarshalText takes the textual representation of a GUID, and unmarhals it
+// into this GUID.
+func (g *GUID) UnmarshalText(text []byte) error {
+	g2, err := FromString(string(text))
+	if err != nil {
+		return err
+	}
+	*g = g2
+	return nil
+}