chore: downgrade client-go version to support older cloud auth clients
George Tobia
2 years ago
parent
687feca9e8
commit
fe0a7335e7
@ -1 +1,2 @@
|
|||||||
/bin
|
/bin
|
||||||
|
/.idea
|
||||||
|
|||||||
@ -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.
|
|
||||||
@ -1,93 +0,0 @@
|
|||||||
# go-fuzz-headers
|
|
||||||
This repository contains various helper functions for go fuzzing. It is mostly used in combination with [go-fuzz](https://github.com/dvyukov/go-fuzz), but compatibility with fuzzing in the standard library will also be supported. Any coverage guided fuzzing engine that provides an array or slice of bytes can be used with go-fuzz-headers.
|
|
||||||
|
|
||||||
|
|
||||||
## Usage
|
|
||||||
Using go-fuzz-headers is easy. First create a new consumer with the bytes provided by the fuzzing engine:
|
|
||||||
|
|
||||||
```go
|
|
||||||
import (
|
|
||||||
fuzz "github.com/AdaLogics/go-fuzz-headers"
|
|
||||||
)
|
|
||||||
data := []byte{'R', 'a', 'n', 'd', 'o', 'm'}
|
|
||||||
f := fuzz.NewConsumer(data)
|
|
||||||
|
|
||||||
```
|
|
||||||
|
|
||||||
This creates a `Consumer` that consumes the bytes of the input as it uses them to fuzz different types.
|
|
||||||
|
|
||||||
After that, `f` can be used to easily create fuzzed instances of different types. Below are some examples:
|
|
||||||
|
|
||||||
### Structs
|
|
||||||
One of the most useful features of go-fuzz-headers is its ability to fill structs with the data provided by the fuzzing engine. This is done with a single line:
|
|
||||||
```go
|
|
||||||
type Person struct {
|
|
||||||
Name string
|
|
||||||
Age int
|
|
||||||
}
|
|
||||||
p := Person{}
|
|
||||||
// Fill p with values based on the data provided by the fuzzing engine:
|
|
||||||
err := f.GenerateStruct(&p)
|
|
||||||
```
|
|
||||||
|
|
||||||
This includes nested structs too. In this example, the fuzz Consumer will also insert values in `p.BestFriend`:
|
|
||||||
```go
|
|
||||||
type PersonI struct {
|
|
||||||
Name string
|
|
||||||
Age int
|
|
||||||
BestFriend PersonII
|
|
||||||
}
|
|
||||||
type PersonII struct {
|
|
||||||
Name string
|
|
||||||
Age int
|
|
||||||
}
|
|
||||||
p := PersonI{}
|
|
||||||
err := f.GenerateStruct(&p)
|
|
||||||
```
|
|
||||||
|
|
||||||
If the consumer should insert values for unexported fields as well as exported, this can be enabled with:
|
|
||||||
|
|
||||||
```go
|
|
||||||
f.AllowUnexportedFields()
|
|
||||||
```
|
|
||||||
|
|
||||||
...and disabled with:
|
|
||||||
|
|
||||||
```go
|
|
||||||
f.DisallowUnexportedFields()
|
|
||||||
```
|
|
||||||
|
|
||||||
### Other types:
|
|
||||||
|
|
||||||
Other useful APIs:
|
|
||||||
|
|
||||||
```go
|
|
||||||
createdString, err := f.GetString() // Gets a string
|
|
||||||
createdInt, err := f.GetInt() // Gets an integer
|
|
||||||
createdByte, err := f.GetByte() // Gets a byte
|
|
||||||
createdBytes, err := f.GetBytes() // Gets a byte slice
|
|
||||||
createdBool, err := f.GetBool() // Gets a boolean
|
|
||||||
err := f.FuzzMap(target_map) // Fills a map
|
|
||||||
createdTarBytes, err := f.TarBytes() // Gets bytes of a valid tar archive
|
|
||||||
err := f.CreateFiles(inThisDir) // Fills inThisDir with files
|
|
||||||
createdString, err := f.GetStringFrom("anyCharInThisString", ofThisLength) // Gets a string that consists of chars from "anyCharInThisString" and has the exact length "ofThisLength"
|
|
||||||
```
|
|
||||||
|
|
||||||
Most APIs are added as they are needed.
|
|
||||||
|
|
||||||
## Projects that use go-fuzz-headers
|
|
||||||
- [runC](https://github.com/opencontainers/runc)
|
|
||||||
- [Istio](https://github.com/istio/istio)
|
|
||||||
- [Vitess](https://github.com/vitessio/vitess)
|
|
||||||
- [Containerd](https://github.com/containerd/containerd)
|
|
||||||
|
|
||||||
Feel free to add your own project to the list, if you use go-fuzz-headers to fuzz it.
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
## Status
|
|
||||||
The project is under development and will be updated regularly.
|
|
||||||
|
|
||||||
## References
|
|
||||||
go-fuzz-headers' approach to fuzzing structs is strongly inspired by [gofuzz](https://github.com/google/gofuzz).
|
|
||||||
@ -1,899 +0,0 @@
|
|||||||
// Copyright 2023 The go-fuzz-headers Authors.
|
|
||||||
//
|
|
||||||
// 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.
|
|
||||||
|
|
||||||
package gofuzzheaders
|
|
||||||
|
|
||||||
import (
|
|
||||||
"archive/tar"
|
|
||||||
"bytes"
|
|
||||||
"encoding/binary"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"math"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"reflect"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
securejoin "github.com/cyphar/filepath-securejoin"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
MaxTotalLen uint32 = 2000000
|
|
||||||
maxDepth = 100
|
|
||||||
)
|
|
||||||
|
|
||||||
func SetMaxTotalLen(newLen uint32) {
|
|
||||||
MaxTotalLen = newLen
|
|
||||||
}
|
|
||||||
|
|
||||||
type ConsumeFuzzer struct {
|
|
||||||
data []byte
|
|
||||||
dataTotal uint32
|
|
||||||
CommandPart []byte
|
|
||||||
RestOfArray []byte
|
|
||||||
NumberOfCalls int
|
|
||||||
position uint32
|
|
||||||
fuzzUnexportedFields bool
|
|
||||||
curDepth int
|
|
||||||
Funcs map[reflect.Type]reflect.Value
|
|
||||||
}
|
|
||||||
|
|
||||||
func IsDivisibleBy(n int, divisibleby int) bool {
|
|
||||||
return (n % divisibleby) == 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewConsumer(fuzzData []byte) *ConsumeFuzzer {
|
|
||||||
return &ConsumeFuzzer{
|
|
||||||
data: fuzzData,
|
|
||||||
dataTotal: uint32(len(fuzzData)),
|
|
||||||
Funcs: make(map[reflect.Type]reflect.Value),
|
|
||||||
curDepth: 0,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) Split(minCalls, maxCalls int) error {
|
|
||||||
if f.dataTotal == 0 {
|
|
||||||
return errors.New("could not split")
|
|
||||||
}
|
|
||||||
numberOfCalls := int(f.data[0])
|
|
||||||
if numberOfCalls < minCalls || numberOfCalls > maxCalls {
|
|
||||||
return errors.New("bad number of calls")
|
|
||||||
}
|
|
||||||
if int(f.dataTotal) < numberOfCalls+numberOfCalls+1 {
|
|
||||||
return errors.New("length of data does not match required parameters")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Define part 2 and 3 of the data array
|
|
||||||
commandPart := f.data[1 : numberOfCalls+1]
|
|
||||||
restOfArray := f.data[numberOfCalls+1:]
|
|
||||||
|
|
||||||
// Just a small check. It is necessary
|
|
||||||
if len(commandPart) != numberOfCalls {
|
|
||||||
return errors.New("length of commandPart does not match number of calls")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if restOfArray is divisible by numberOfCalls
|
|
||||||
if !IsDivisibleBy(len(restOfArray), numberOfCalls) {
|
|
||||||
return errors.New("length of commandPart does not match number of calls")
|
|
||||||
}
|
|
||||||
f.CommandPart = commandPart
|
|
||||||
f.RestOfArray = restOfArray
|
|
||||||
f.NumberOfCalls = numberOfCalls
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) AllowUnexportedFields() {
|
|
||||||
f.fuzzUnexportedFields = true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) DisallowUnexportedFields() {
|
|
||||||
f.fuzzUnexportedFields = false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GenerateStruct(targetStruct interface{}) error {
|
|
||||||
e := reflect.ValueOf(targetStruct).Elem()
|
|
||||||
return f.fuzzStruct(e, false)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) setCustom(v reflect.Value) error {
|
|
||||||
// First: see if we have a fuzz function for it.
|
|
||||||
doCustom, ok := f.Funcs[v.Type()]
|
|
||||||
if !ok {
|
|
||||||
return fmt.Errorf("could not find a custom function")
|
|
||||||
}
|
|
||||||
|
|
||||||
switch v.Kind() {
|
|
||||||
case reflect.Ptr:
|
|
||||||
if v.IsNil() {
|
|
||||||
if !v.CanSet() {
|
|
||||||
return fmt.Errorf("could not use a custom function")
|
|
||||||
}
|
|
||||||
v.Set(reflect.New(v.Type().Elem()))
|
|
||||||
}
|
|
||||||
case reflect.Map:
|
|
||||||
if v.IsNil() {
|
|
||||||
if !v.CanSet() {
|
|
||||||
return fmt.Errorf("could not use a custom function")
|
|
||||||
}
|
|
||||||
v.Set(reflect.MakeMap(v.Type()))
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
return fmt.Errorf("could not use a custom function")
|
|
||||||
}
|
|
||||||
|
|
||||||
verr := doCustom.Call([]reflect.Value{v, reflect.ValueOf(Continue{
|
|
||||||
F: f,
|
|
||||||
})})
|
|
||||||
|
|
||||||
// check if we return an error
|
|
||||||
if verr[0].IsNil() {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return fmt.Errorf("could not use a custom function")
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) fuzzStruct(e reflect.Value, customFunctions bool) error {
|
|
||||||
if f.curDepth >= maxDepth {
|
|
||||||
// return err or nil here?
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
f.curDepth++
|
|
||||||
defer func() { f.curDepth-- }()
|
|
||||||
|
|
||||||
// We check if we should check for custom functions
|
|
||||||
if customFunctions && e.IsValid() && e.CanAddr() {
|
|
||||||
err := f.setCustom(e.Addr())
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
switch e.Kind() {
|
|
||||||
case reflect.Struct:
|
|
||||||
for i := 0; i < e.NumField(); i++ {
|
|
||||||
var v reflect.Value
|
|
||||||
if !e.Field(i).CanSet() {
|
|
||||||
if f.fuzzUnexportedFields {
|
|
||||||
v = reflect.NewAt(e.Field(i).Type(), unsafe.Pointer(e.Field(i).UnsafeAddr())).Elem()
|
|
||||||
}
|
|
||||||
if err := f.fuzzStruct(v, customFunctions); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
v = e.Field(i)
|
|
||||||
if err := f.fuzzStruct(v, customFunctions); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case reflect.String:
|
|
||||||
str, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if e.CanSet() {
|
|
||||||
e.SetString(str)
|
|
||||||
}
|
|
||||||
case reflect.Slice:
|
|
||||||
var maxElements uint32
|
|
||||||
// Byte slices should not be restricted
|
|
||||||
if e.Type().String() == "[]uint8" {
|
|
||||||
maxElements = 10000000
|
|
||||||
} else {
|
|
||||||
maxElements = 50
|
|
||||||
}
|
|
||||||
|
|
||||||
randQty, err := f.GetUint32()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
numOfElements := randQty % maxElements
|
|
||||||
if (f.dataTotal - f.position) < numOfElements {
|
|
||||||
numOfElements = f.dataTotal - f.position
|
|
||||||
}
|
|
||||||
|
|
||||||
uu := reflect.MakeSlice(e.Type(), int(numOfElements), int(numOfElements))
|
|
||||||
|
|
||||||
for i := 0; i < int(numOfElements); i++ {
|
|
||||||
// If we have more than 10, then we can proceed with that.
|
|
||||||
if err := f.fuzzStruct(uu.Index(i), customFunctions); err != nil {
|
|
||||||
if i >= 10 {
|
|
||||||
if e.CanSet() {
|
|
||||||
e.Set(uu)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
} else {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if e.CanSet() {
|
|
||||||
e.Set(uu)
|
|
||||||
}
|
|
||||||
case reflect.Uint16:
|
|
||||||
newInt, err := f.GetUint16()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if e.CanSet() {
|
|
||||||
e.SetUint(uint64(newInt))
|
|
||||||
}
|
|
||||||
case reflect.Uint32:
|
|
||||||
newInt, err := f.GetUint32()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if e.CanSet() {
|
|
||||||
e.SetUint(uint64(newInt))
|
|
||||||
}
|
|
||||||
case reflect.Uint64:
|
|
||||||
newInt, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if e.CanSet() {
|
|
||||||
e.SetUint(uint64(newInt))
|
|
||||||
}
|
|
||||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
||||||
newInt, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if e.CanSet() {
|
|
||||||
e.SetInt(int64(newInt))
|
|
||||||
}
|
|
||||||
case reflect.Float32:
|
|
||||||
newFloat, err := f.GetFloat32()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if e.CanSet() {
|
|
||||||
e.SetFloat(float64(newFloat))
|
|
||||||
}
|
|
||||||
case reflect.Float64:
|
|
||||||
newFloat, err := f.GetFloat64()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if e.CanSet() {
|
|
||||||
e.SetFloat(float64(newFloat))
|
|
||||||
}
|
|
||||||
case reflect.Map:
|
|
||||||
if e.CanSet() {
|
|
||||||
e.Set(reflect.MakeMap(e.Type()))
|
|
||||||
const maxElements = 50
|
|
||||||
randQty, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
numOfElements := randQty % maxElements
|
|
||||||
for i := 0; i < numOfElements; i++ {
|
|
||||||
key := reflect.New(e.Type().Key()).Elem()
|
|
||||||
if err := f.fuzzStruct(key, customFunctions); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
val := reflect.New(e.Type().Elem()).Elem()
|
|
||||||
if err = f.fuzzStruct(val, customFunctions); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
e.SetMapIndex(key, val)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case reflect.Ptr:
|
|
||||||
if e.CanSet() {
|
|
||||||
e.Set(reflect.New(e.Type().Elem()))
|
|
||||||
if err := f.fuzzStruct(e.Elem(), customFunctions); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
case reflect.Uint8:
|
|
||||||
b, err := f.GetByte()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if e.CanSet() {
|
|
||||||
e.SetUint(uint64(b))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetStringArray() (reflect.Value, error) {
|
|
||||||
// The max size of the array:
|
|
||||||
const max uint32 = 20
|
|
||||||
|
|
||||||
arraySize := f.position
|
|
||||||
if arraySize > max {
|
|
||||||
arraySize = max
|
|
||||||
}
|
|
||||||
stringArray := reflect.MakeSlice(reflect.SliceOf(reflect.TypeOf("string")), int(arraySize), int(arraySize))
|
|
||||||
if f.position+arraySize >= f.dataTotal {
|
|
||||||
return stringArray, errors.New("could not make string array")
|
|
||||||
}
|
|
||||||
|
|
||||||
for i := 0; i < int(arraySize); i++ {
|
|
||||||
stringSize := uint32(f.data[f.position])
|
|
||||||
if f.position+stringSize >= f.dataTotal {
|
|
||||||
return stringArray, nil
|
|
||||||
}
|
|
||||||
stringToAppend := string(f.data[f.position : f.position+stringSize])
|
|
||||||
strVal := reflect.ValueOf(stringToAppend)
|
|
||||||
stringArray = reflect.Append(stringArray, strVal)
|
|
||||||
f.position += stringSize
|
|
||||||
}
|
|
||||||
return stringArray, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetInt() (int, error) {
|
|
||||||
if f.position >= f.dataTotal {
|
|
||||||
return 0, errors.New("not enough bytes to create int")
|
|
||||||
}
|
|
||||||
returnInt := int(f.data[f.position])
|
|
||||||
f.position++
|
|
||||||
return returnInt, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetByte() (byte, error) {
|
|
||||||
if f.position >= f.dataTotal {
|
|
||||||
return 0x00, errors.New("not enough bytes to get byte")
|
|
||||||
}
|
|
||||||
returnByte := f.data[f.position]
|
|
||||||
f.position++
|
|
||||||
return returnByte, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetNBytes(numberOfBytes int) ([]byte, error) {
|
|
||||||
if f.position >= f.dataTotal {
|
|
||||||
return nil, errors.New("not enough bytes to get byte")
|
|
||||||
}
|
|
||||||
returnBytes := make([]byte, 0, numberOfBytes)
|
|
||||||
for i := 0; i < numberOfBytes; i++ {
|
|
||||||
newByte, err := f.GetByte()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
returnBytes = append(returnBytes, newByte)
|
|
||||||
}
|
|
||||||
return returnBytes, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetUint16() (uint16, error) {
|
|
||||||
u16, err := f.GetNBytes(2)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
littleEndian, err := f.GetBool()
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
if littleEndian {
|
|
||||||
return binary.LittleEndian.Uint16(u16), nil
|
|
||||||
}
|
|
||||||
return binary.BigEndian.Uint16(u16), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetUint32() (uint32, error) {
|
|
||||||
i, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return uint32(0), err
|
|
||||||
}
|
|
||||||
return uint32(i), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetUint64() (uint64, error) {
|
|
||||||
u64, err := f.GetNBytes(8)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
littleEndian, err := f.GetBool()
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
if littleEndian {
|
|
||||||
return binary.LittleEndian.Uint64(u64), nil
|
|
||||||
}
|
|
||||||
return binary.BigEndian.Uint64(u64), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetBytes() ([]byte, error) {
|
|
||||||
if f.position >= f.dataTotal {
|
|
||||||
return nil, errors.New("not enough bytes to create byte array")
|
|
||||||
}
|
|
||||||
length, err := f.GetUint32()
|
|
||||||
if err != nil {
|
|
||||||
return nil, errors.New("not enough bytes to create byte array")
|
|
||||||
}
|
|
||||||
if f.position+length > MaxTotalLen {
|
|
||||||
return nil, errors.New("created too large a string")
|
|
||||||
}
|
|
||||||
byteBegin := f.position - 1
|
|
||||||
if byteBegin >= f.dataTotal {
|
|
||||||
return nil, errors.New("not enough bytes to create byte array")
|
|
||||||
}
|
|
||||||
if length == 0 {
|
|
||||||
return nil, errors.New("zero-length is not supported")
|
|
||||||
}
|
|
||||||
if byteBegin+length >= f.dataTotal {
|
|
||||||
return nil, errors.New("not enough bytes to create byte array")
|
|
||||||
}
|
|
||||||
if byteBegin+length < byteBegin {
|
|
||||||
return nil, errors.New("numbers overflow")
|
|
||||||
}
|
|
||||||
f.position = byteBegin + length
|
|
||||||
return f.data[byteBegin:f.position], nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetString() (string, error) {
|
|
||||||
if f.position >= f.dataTotal {
|
|
||||||
return "nil", errors.New("not enough bytes to create string")
|
|
||||||
}
|
|
||||||
length, err := f.GetUint32()
|
|
||||||
if err != nil {
|
|
||||||
return "nil", errors.New("not enough bytes to create string")
|
|
||||||
}
|
|
||||||
if f.position > MaxTotalLen {
|
|
||||||
return "nil", errors.New("created too large a string")
|
|
||||||
}
|
|
||||||
byteBegin := f.position
|
|
||||||
if byteBegin >= f.dataTotal {
|
|
||||||
return "nil", errors.New("not enough bytes to create string")
|
|
||||||
}
|
|
||||||
if byteBegin+length > f.dataTotal {
|
|
||||||
return "nil", errors.New("not enough bytes to create string")
|
|
||||||
}
|
|
||||||
if byteBegin > byteBegin+length {
|
|
||||||
return "nil", errors.New("numbers overflow")
|
|
||||||
}
|
|
||||||
f.position = byteBegin + length
|
|
||||||
return string(f.data[byteBegin:f.position]), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetBool() (bool, error) {
|
|
||||||
if f.position >= f.dataTotal {
|
|
||||||
return false, errors.New("not enough bytes to create bool")
|
|
||||||
}
|
|
||||||
if IsDivisibleBy(int(f.data[f.position]), 2) {
|
|
||||||
f.position++
|
|
||||||
return true, nil
|
|
||||||
} else {
|
|
||||||
f.position++
|
|
||||||
return false, nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) FuzzMap(m interface{}) error {
|
|
||||||
return f.GenerateStruct(m)
|
|
||||||
}
|
|
||||||
|
|
||||||
func returnTarBytes(buf []byte) ([]byte, error) {
|
|
||||||
// Count files
|
|
||||||
var fileCounter int
|
|
||||||
tr := tar.NewReader(bytes.NewReader(buf))
|
|
||||||
for {
|
|
||||||
_, err := tr.Next()
|
|
||||||
if err == io.EOF {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
fileCounter++
|
|
||||||
}
|
|
||||||
if fileCounter >= 1 {
|
|
||||||
return buf, nil
|
|
||||||
}
|
|
||||||
return nil, fmt.Errorf("not enough files were created\n")
|
|
||||||
}
|
|
||||||
|
|
||||||
func setTarHeaderFormat(hdr *tar.Header, f *ConsumeFuzzer) error {
|
|
||||||
ind, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
switch ind % 4 {
|
|
||||||
case 0:
|
|
||||||
hdr.Format = tar.FormatUnknown
|
|
||||||
case 1:
|
|
||||||
hdr.Format = tar.FormatUSTAR
|
|
||||||
case 2:
|
|
||||||
hdr.Format = tar.FormatPAX
|
|
||||||
case 3:
|
|
||||||
hdr.Format = tar.FormatGNU
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func setTarHeaderTypeflag(hdr *tar.Header, f *ConsumeFuzzer) error {
|
|
||||||
ind, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
switch ind % 13 {
|
|
||||||
case 0:
|
|
||||||
hdr.Typeflag = tar.TypeReg
|
|
||||||
case 1:
|
|
||||||
hdr.Typeflag = tar.TypeLink
|
|
||||||
linkname, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
hdr.Linkname = linkname
|
|
||||||
case 2:
|
|
||||||
hdr.Typeflag = tar.TypeSymlink
|
|
||||||
linkname, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
hdr.Linkname = linkname
|
|
||||||
case 3:
|
|
||||||
hdr.Typeflag = tar.TypeChar
|
|
||||||
case 4:
|
|
||||||
hdr.Typeflag = tar.TypeBlock
|
|
||||||
case 5:
|
|
||||||
hdr.Typeflag = tar.TypeDir
|
|
||||||
case 6:
|
|
||||||
hdr.Typeflag = tar.TypeFifo
|
|
||||||
case 7:
|
|
||||||
hdr.Typeflag = tar.TypeCont
|
|
||||||
case 8:
|
|
||||||
hdr.Typeflag = tar.TypeXHeader
|
|
||||||
case 9:
|
|
||||||
hdr.Typeflag = tar.TypeXGlobalHeader
|
|
||||||
case 10:
|
|
||||||
hdr.Typeflag = tar.TypeGNUSparse
|
|
||||||
case 11:
|
|
||||||
hdr.Typeflag = tar.TypeGNULongName
|
|
||||||
case 12:
|
|
||||||
hdr.Typeflag = tar.TypeGNULongLink
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func tooSmallFileBody(length uint32) bool {
|
|
||||||
if length < 2 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 4 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 10 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 100 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 500 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 1000 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 2000 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 4000 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 8000 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 16000 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 32000 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 64000 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 128000 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
if length < 264000 {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) createTarFileBody() ([]byte, error) {
|
|
||||||
length, err := f.GetUint32()
|
|
||||||
if err != nil {
|
|
||||||
return nil, errors.New("not enough bytes to create byte array")
|
|
||||||
}
|
|
||||||
|
|
||||||
shouldUseLargeFileBody, err := f.GetBool()
|
|
||||||
if err != nil {
|
|
||||||
return nil, errors.New("not enough bytes to check long file body")
|
|
||||||
}
|
|
||||||
|
|
||||||
if shouldUseLargeFileBody && tooSmallFileBody(length) {
|
|
||||||
return nil, errors.New("File body was too small")
|
|
||||||
}
|
|
||||||
|
|
||||||
// A bit of optimization to attempt to create a file body
|
|
||||||
// when we don't have as many bytes left as "length"
|
|
||||||
remainingBytes := f.dataTotal - f.position
|
|
||||||
if remainingBytes == 0 {
|
|
||||||
return nil, errors.New("created too large a string")
|
|
||||||
}
|
|
||||||
if f.position+length > MaxTotalLen {
|
|
||||||
return nil, errors.New("created too large a string")
|
|
||||||
}
|
|
||||||
byteBegin := f.position
|
|
||||||
if byteBegin >= f.dataTotal {
|
|
||||||
return nil, errors.New("not enough bytes to create byte array")
|
|
||||||
}
|
|
||||||
if length == 0 {
|
|
||||||
return nil, errors.New("zero-length is not supported")
|
|
||||||
}
|
|
||||||
if byteBegin+length >= f.dataTotal {
|
|
||||||
return nil, errors.New("not enough bytes to create byte array")
|
|
||||||
}
|
|
||||||
if byteBegin+length < byteBegin {
|
|
||||||
return nil, errors.New("numbers overflow")
|
|
||||||
}
|
|
||||||
f.position = byteBegin + length
|
|
||||||
return f.data[byteBegin:f.position], nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// getTarFileName is similar to GetString(), but creates string based
|
|
||||||
// on the length of f.data to reduce the likelihood of overflowing
|
|
||||||
// f.data.
|
|
||||||
func (f *ConsumeFuzzer) getTarFilename() (string, error) {
|
|
||||||
length, err := f.GetUint32()
|
|
||||||
if err != nil {
|
|
||||||
return "nil", errors.New("not enough bytes to create string")
|
|
||||||
}
|
|
||||||
|
|
||||||
// A bit of optimization to attempt to create a file name
|
|
||||||
// when we don't have as many bytes left as "length"
|
|
||||||
remainingBytes := f.dataTotal - f.position
|
|
||||||
if remainingBytes == 0 {
|
|
||||||
return "nil", errors.New("created too large a string")
|
|
||||||
}
|
|
||||||
if remainingBytes < 50 {
|
|
||||||
length = length % remainingBytes
|
|
||||||
} else if f.dataTotal < 500 {
|
|
||||||
length = length % f.dataTotal
|
|
||||||
}
|
|
||||||
if f.position > MaxTotalLen {
|
|
||||||
return "nil", errors.New("created too large a string")
|
|
||||||
}
|
|
||||||
byteBegin := f.position
|
|
||||||
if byteBegin >= f.dataTotal {
|
|
||||||
return "nil", errors.New("not enough bytes to create string")
|
|
||||||
}
|
|
||||||
if byteBegin+length > f.dataTotal {
|
|
||||||
return "nil", errors.New("not enough bytes to create string")
|
|
||||||
}
|
|
||||||
if byteBegin > byteBegin+length {
|
|
||||||
return "nil", errors.New("numbers overflow")
|
|
||||||
}
|
|
||||||
f.position = byteBegin + length
|
|
||||||
return string(f.data[byteBegin:f.position]), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// TarBytes returns valid bytes for a tar archive
|
|
||||||
func (f *ConsumeFuzzer) TarBytes() ([]byte, error) {
|
|
||||||
numberOfFiles, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
var buf bytes.Buffer
|
|
||||||
tw := tar.NewWriter(&buf)
|
|
||||||
defer tw.Close()
|
|
||||||
|
|
||||||
const maxNoOfFiles = 1000
|
|
||||||
for i := 0; i < numberOfFiles%maxNoOfFiles; i++ {
|
|
||||||
filename, err := f.getTarFilename()
|
|
||||||
if err != nil {
|
|
||||||
return returnTarBytes(buf.Bytes())
|
|
||||||
}
|
|
||||||
filebody, err := f.createTarFileBody()
|
|
||||||
if err != nil {
|
|
||||||
return returnTarBytes(buf.Bytes())
|
|
||||||
}
|
|
||||||
sec, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return returnTarBytes(buf.Bytes())
|
|
||||||
}
|
|
||||||
nsec, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return returnTarBytes(buf.Bytes())
|
|
||||||
}
|
|
||||||
|
|
||||||
hdr := &tar.Header{
|
|
||||||
Name: filename,
|
|
||||||
Size: int64(len(filebody)),
|
|
||||||
Mode: 0o600,
|
|
||||||
ModTime: time.Unix(int64(sec), int64(nsec)),
|
|
||||||
}
|
|
||||||
if err := setTarHeaderTypeflag(hdr, f); err != nil {
|
|
||||||
return returnTarBytes(buf.Bytes())
|
|
||||||
}
|
|
||||||
if err := setTarHeaderFormat(hdr, f); err != nil {
|
|
||||||
return returnTarBytes(buf.Bytes())
|
|
||||||
}
|
|
||||||
if err := tw.WriteHeader(hdr); err != nil {
|
|
||||||
return returnTarBytes(buf.Bytes())
|
|
||||||
}
|
|
||||||
if _, err := tw.Write(filebody); err != nil {
|
|
||||||
return returnTarBytes(buf.Bytes())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return buf.Bytes(), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// CreateFiles creates pseudo-random files in rootDir.
|
|
||||||
// It creates subdirs and places the files there.
|
|
||||||
// It is the callers responsibility to ensure that
|
|
||||||
// rootDir exists.
|
|
||||||
func (f *ConsumeFuzzer) CreateFiles(rootDir string) error {
|
|
||||||
numberOfFiles, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
maxNumberOfFiles := numberOfFiles % 4000 // This is completely arbitrary
|
|
||||||
if maxNumberOfFiles == 0 {
|
|
||||||
return errors.New("maxNumberOfFiles is nil")
|
|
||||||
}
|
|
||||||
|
|
||||||
var noOfCreatedFiles int
|
|
||||||
for i := 0; i < maxNumberOfFiles; i++ {
|
|
||||||
// The file to create:
|
|
||||||
fileName, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
if noOfCreatedFiles > 0 {
|
|
||||||
// If files have been created, we don't return an error.
|
|
||||||
break
|
|
||||||
} else {
|
|
||||||
return errors.New("could not get fileName")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fullFilePath, err := securejoin.SecureJoin(rootDir, fileName)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Find the subdirectory of the file
|
|
||||||
if subDir := filepath.Dir(fileName); subDir != "" && subDir != "." {
|
|
||||||
// create the dir first; avoid going outside the root dir
|
|
||||||
if strings.Contains(subDir, "../") || (len(subDir) > 0 && subDir[0] == 47) || strings.Contains(subDir, "\\") {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
dirPath, err := securejoin.SecureJoin(rootDir, subDir)
|
|
||||||
if err != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if _, err := os.Stat(dirPath); os.IsNotExist(err) {
|
|
||||||
err2 := os.MkdirAll(dirPath, 0o777)
|
|
||||||
if err2 != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fullFilePath, err = securejoin.SecureJoin(dirPath, fileName)
|
|
||||||
if err != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// Create symlink
|
|
||||||
createSymlink, err := f.GetBool()
|
|
||||||
if err != nil {
|
|
||||||
if noOfCreatedFiles > 0 {
|
|
||||||
break
|
|
||||||
} else {
|
|
||||||
return errors.New("could not create the symlink")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if createSymlink {
|
|
||||||
symlinkTarget, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
err = os.Symlink(symlinkTarget, fullFilePath)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
// stop loop here, since a symlink needs no further action
|
|
||||||
noOfCreatedFiles++
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
// We create a normal file
|
|
||||||
fileContents, err := f.GetBytes()
|
|
||||||
if err != nil {
|
|
||||||
if noOfCreatedFiles > 0 {
|
|
||||||
break
|
|
||||||
} else {
|
|
||||||
return errors.New("could not create the file")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
err = os.WriteFile(fullFilePath, fileContents, 0o666)
|
|
||||||
if err != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
noOfCreatedFiles++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetStringFrom returns a string that can only consist of characters
|
|
||||||
// included in possibleChars. It returns an error if the created string
|
|
||||||
// does not have the specified length.
|
|
||||||
func (f *ConsumeFuzzer) GetStringFrom(possibleChars string, length int) (string, error) {
|
|
||||||
if (f.dataTotal - f.position) < uint32(length) {
|
|
||||||
return "", errors.New("not enough bytes to create a string")
|
|
||||||
}
|
|
||||||
output := make([]byte, 0, length)
|
|
||||||
for i := 0; i < length; i++ {
|
|
||||||
charIndex, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return string(output), err
|
|
||||||
}
|
|
||||||
output = append(output, possibleChars[charIndex%len(possibleChars)])
|
|
||||||
}
|
|
||||||
return string(output), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetRune() ([]rune, error) {
|
|
||||||
stringToConvert, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return []rune("nil"), err
|
|
||||||
}
|
|
||||||
return []rune(stringToConvert), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetFloat32() (float32, error) {
|
|
||||||
u32, err := f.GetNBytes(4)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
littleEndian, err := f.GetBool()
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
if littleEndian {
|
|
||||||
u32LE := binary.LittleEndian.Uint32(u32)
|
|
||||||
return math.Float32frombits(u32LE), nil
|
|
||||||
}
|
|
||||||
u32BE := binary.BigEndian.Uint32(u32)
|
|
||||||
return math.Float32frombits(u32BE), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GetFloat64() (float64, error) {
|
|
||||||
u64, err := f.GetNBytes(8)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
littleEndian, err := f.GetBool()
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
if littleEndian {
|
|
||||||
u64LE := binary.LittleEndian.Uint64(u64)
|
|
||||||
return math.Float64frombits(u64LE), nil
|
|
||||||
}
|
|
||||||
u64BE := binary.BigEndian.Uint64(u64)
|
|
||||||
return math.Float64frombits(u64BE), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) CreateSlice(targetSlice interface{}) error {
|
|
||||||
return f.GenerateStruct(targetSlice)
|
|
||||||
}
|
|
||||||
@ -1,62 +0,0 @@
|
|||||||
// Copyright 2023 The go-fuzz-headers Authors.
|
|
||||||
//
|
|
||||||
// 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.
|
|
||||||
|
|
||||||
package gofuzzheaders
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"reflect"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Continue struct {
|
|
||||||
F *ConsumeFuzzer
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) AddFuncs(fuzzFuncs []interface{}) {
|
|
||||||
for i := range fuzzFuncs {
|
|
||||||
v := reflect.ValueOf(fuzzFuncs[i])
|
|
||||||
if v.Kind() != reflect.Func {
|
|
||||||
panic("Need only funcs!")
|
|
||||||
}
|
|
||||||
t := v.Type()
|
|
||||||
if t.NumIn() != 2 || t.NumOut() != 1 {
|
|
||||||
fmt.Println(t.NumIn(), t.NumOut())
|
|
||||||
|
|
||||||
panic("Need 2 in and 1 out params. In must be the type. Out must be an error")
|
|
||||||
}
|
|
||||||
argT := t.In(0)
|
|
||||||
switch argT.Kind() {
|
|
||||||
case reflect.Ptr, reflect.Map:
|
|
||||||
default:
|
|
||||||
panic("fuzzFunc must take pointer or map type")
|
|
||||||
}
|
|
||||||
if t.In(1) != reflect.TypeOf(Continue{}) {
|
|
||||||
panic("fuzzFunc's second parameter must be type Continue")
|
|
||||||
}
|
|
||||||
f.Funcs[argT] = v
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *ConsumeFuzzer) GenerateWithCustom(targetStruct interface{}) error {
|
|
||||||
e := reflect.ValueOf(targetStruct).Elem()
|
|
||||||
return f.fuzzStruct(e, true)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c Continue) GenerateStruct(targetStruct interface{}) error {
|
|
||||||
return c.F.GenerateStruct(targetStruct)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c Continue) GenerateStructWithCustom(targetStruct interface{}) error {
|
|
||||||
return c.F.GenerateWithCustom(targetStruct)
|
|
||||||
}
|
|
||||||
@ -1,556 +0,0 @@
|
|||||||
// Copyright 2023 The go-fuzz-headers Authors.
|
|
||||||
//
|
|
||||||
// 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.
|
|
||||||
|
|
||||||
package gofuzzheaders
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
// returns a keyword by index
|
|
||||||
func getKeyword(f *ConsumeFuzzer) (string, error) {
|
|
||||||
index, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return keywords[0], err
|
|
||||||
}
|
|
||||||
for i, k := range keywords {
|
|
||||||
if i == index {
|
|
||||||
return k, nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return keywords[0], fmt.Errorf("could not get a kw")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Simple utility function to check if a string
|
|
||||||
// slice contains a string.
|
|
||||||
func containsString(s []string, e string) bool {
|
|
||||||
for _, a := range s {
|
|
||||||
if a == e {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// These keywords are used specifically for fuzzing Vitess
|
|
||||||
var keywords = []string{
|
|
||||||
"accessible", "action", "add", "after", "against", "algorithm",
|
|
||||||
"all", "alter", "always", "analyze", "and", "as", "asc", "asensitive",
|
|
||||||
"auto_increment", "avg_row_length", "before", "begin", "between",
|
|
||||||
"bigint", "binary", "_binary", "_utf8mb4", "_utf8", "_latin1", "bit",
|
|
||||||
"blob", "bool", "boolean", "both", "by", "call", "cancel", "cascade",
|
|
||||||
"cascaded", "case", "cast", "channel", "change", "char", "character",
|
|
||||||
"charset", "check", "checksum", "coalesce", "code", "collate", "collation",
|
|
||||||
"column", "columns", "comment", "committed", "commit", "compact", "complete",
|
|
||||||
"compressed", "compression", "condition", "connection", "constraint", "continue",
|
|
||||||
"convert", "copy", "cume_dist", "substr", "substring", "create", "cross",
|
|
||||||
"csv", "current_date", "current_time", "current_timestamp", "current_user",
|
|
||||||
"cursor", "data", "database", "databases", "day", "day_hour", "day_microsecond",
|
|
||||||
"day_minute", "day_second", "date", "datetime", "dec", "decimal", "declare",
|
|
||||||
"default", "definer", "delay_key_write", "delayed", "delete", "dense_rank",
|
|
||||||
"desc", "describe", "deterministic", "directory", "disable", "discard",
|
|
||||||
"disk", "distinct", "distinctrow", "div", "double", "do", "drop", "dumpfile",
|
|
||||||
"duplicate", "dynamic", "each", "else", "elseif", "empty", "enable",
|
|
||||||
"enclosed", "encryption", "end", "enforced", "engine", "engines", "enum",
|
|
||||||
"error", "escape", "escaped", "event", "exchange", "exclusive", "exists",
|
|
||||||
"exit", "explain", "expansion", "export", "extended", "extract", "false",
|
|
||||||
"fetch", "fields", "first", "first_value", "fixed", "float", "float4",
|
|
||||||
"float8", "flush", "for", "force", "foreign", "format", "from", "full",
|
|
||||||
"fulltext", "function", "general", "generated", "geometry", "geometrycollection",
|
|
||||||
"get", "global", "gtid_executed", "grant", "group", "grouping", "groups",
|
|
||||||
"group_concat", "having", "header", "high_priority", "hosts", "hour", "hour_microsecond",
|
|
||||||
"hour_minute", "hour_second", "if", "ignore", "import", "in", "index", "indexes",
|
|
||||||
"infile", "inout", "inner", "inplace", "insensitive", "insert", "insert_method",
|
|
||||||
"int", "int1", "int2", "int3", "int4", "int8", "integer", "interval",
|
|
||||||
"into", "io_after_gtids", "is", "isolation", "iterate", "invoker", "join",
|
|
||||||
"json", "json_table", "key", "keys", "keyspaces", "key_block_size", "kill", "lag",
|
|
||||||
"language", "last", "last_value", "last_insert_id", "lateral", "lead", "leading",
|
|
||||||
"leave", "left", "less", "level", "like", "limit", "linear", "lines",
|
|
||||||
"linestring", "load", "local", "localtime", "localtimestamp", "lock", "logs",
|
|
||||||
"long", "longblob", "longtext", "loop", "low_priority", "manifest",
|
|
||||||
"master_bind", "match", "max_rows", "maxvalue", "mediumblob", "mediumint",
|
|
||||||
"mediumtext", "memory", "merge", "microsecond", "middleint", "min_rows", "minute",
|
|
||||||
"minute_microsecond", "minute_second", "mod", "mode", "modify", "modifies",
|
|
||||||
"multilinestring", "multipoint", "multipolygon", "month", "name",
|
|
||||||
"names", "natural", "nchar", "next", "no", "none", "not", "no_write_to_binlog",
|
|
||||||
"nth_value", "ntile", "null", "numeric", "of", "off", "offset", "on",
|
|
||||||
"only", "open", "optimize", "optimizer_costs", "option", "optionally",
|
|
||||||
"or", "order", "out", "outer", "outfile", "over", "overwrite", "pack_keys",
|
|
||||||
"parser", "partition", "partitioning", "password", "percent_rank", "plugins",
|
|
||||||
"point", "polygon", "precision", "primary", "privileges", "processlist",
|
|
||||||
"procedure", "query", "quarter", "range", "rank", "read", "reads", "read_write",
|
|
||||||
"real", "rebuild", "recursive", "redundant", "references", "regexp", "relay",
|
|
||||||
"release", "remove", "rename", "reorganize", "repair", "repeat", "repeatable",
|
|
||||||
"replace", "require", "resignal", "restrict", "return", "retry", "revert",
|
|
||||||
"revoke", "right", "rlike", "rollback", "row", "row_format", "row_number",
|
|
||||||
"rows", "s3", "savepoint", "schema", "schemas", "second", "second_microsecond",
|
|
||||||
"security", "select", "sensitive", "separator", "sequence", "serializable",
|
|
||||||
"session", "set", "share", "shared", "show", "signal", "signed", "slow",
|
|
||||||
"smallint", "spatial", "specific", "sql", "sqlexception", "sqlstate",
|
|
||||||
"sqlwarning", "sql_big_result", "sql_cache", "sql_calc_found_rows",
|
|
||||||
"sql_no_cache", "sql_small_result", "ssl", "start", "starting",
|
|
||||||
"stats_auto_recalc", "stats_persistent", "stats_sample_pages", "status",
|
|
||||||
"storage", "stored", "straight_join", "stream", "system", "vstream",
|
|
||||||
"table", "tables", "tablespace", "temporary", "temptable", "terminated",
|
|
||||||
"text", "than", "then", "time", "timestamp", "timestampadd", "timestampdiff",
|
|
||||||
"tinyblob", "tinyint", "tinytext", "to", "trailing", "transaction", "tree",
|
|
||||||
"traditional", "trigger", "triggers", "true", "truncate", "uncommitted",
|
|
||||||
"undefined", "undo", "union", "unique", "unlock", "unsigned", "update",
|
|
||||||
"upgrade", "usage", "use", "user", "user_resources", "using", "utc_date",
|
|
||||||
"utc_time", "utc_timestamp", "validation", "values", "variables", "varbinary",
|
|
||||||
"varchar", "varcharacter", "varying", "vgtid_executed", "virtual", "vindex",
|
|
||||||
"vindexes", "view", "vitess", "vitess_keyspaces", "vitess_metadata",
|
|
||||||
"vitess_migration", "vitess_migrations", "vitess_replication_status",
|
|
||||||
"vitess_shards", "vitess_tablets", "vschema", "warnings", "when",
|
|
||||||
"where", "while", "window", "with", "without", "work", "write", "xor",
|
|
||||||
"year", "year_month", "zerofill",
|
|
||||||
}
|
|
||||||
|
|
||||||
// Keywords that could get an additional keyword
|
|
||||||
var needCustomString = []string{
|
|
||||||
"DISTINCTROW", "FROM", // Select keywords:
|
|
||||||
"GROUP BY", "HAVING", "WINDOW",
|
|
||||||
"FOR",
|
|
||||||
"ORDER BY", "LIMIT",
|
|
||||||
"INTO", "PARTITION", "AS", // Insert Keywords:
|
|
||||||
"ON DUPLICATE KEY UPDATE",
|
|
||||||
"WHERE", "LIMIT", // Delete keywords
|
|
||||||
"INFILE", "INTO TABLE", "CHARACTER SET", // Load keywords
|
|
||||||
"TERMINATED BY", "ENCLOSED BY",
|
|
||||||
"ESCAPED BY", "STARTING BY",
|
|
||||||
"TERMINATED BY", "STARTING BY",
|
|
||||||
"IGNORE",
|
|
||||||
"VALUE", "VALUES", // Replace tokens
|
|
||||||
"SET", // Update tokens
|
|
||||||
"ENGINE =", // Drop tokens
|
|
||||||
"DEFINER =", "ON SCHEDULE", "RENAME TO", // Alter tokens
|
|
||||||
"COMMENT", "DO", "INITIAL_SIZE = ", "OPTIONS",
|
|
||||||
}
|
|
||||||
|
|
||||||
var alterTableTokens = [][]string{
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
{"CUSTOM_ALTTER_TABLE_OPTIONS"},
|
|
||||||
{"PARTITION_OPTIONS_FOR_ALTER_TABLE"},
|
|
||||||
}
|
|
||||||
|
|
||||||
var alterTokens = [][]string{
|
|
||||||
{
|
|
||||||
"DATABASE", "SCHEMA", "DEFINER = ", "EVENT", "FUNCTION", "INSTANCE",
|
|
||||||
"LOGFILE GROUP", "PROCEDURE", "SERVER",
|
|
||||||
},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
{
|
|
||||||
"ON SCHEDULE", "ON COMPLETION PRESERVE", "ON COMPLETION NOT PRESERVE",
|
|
||||||
"ADD UNDOFILE", "OPTIONS",
|
|
||||||
},
|
|
||||||
{"RENAME TO", "INITIAL_SIZE = "},
|
|
||||||
{"ENABLE", "DISABLE", "DISABLE ON SLAVE", "ENGINE"},
|
|
||||||
{"COMMENT"},
|
|
||||||
{"DO"},
|
|
||||||
}
|
|
||||||
|
|
||||||
var setTokens = [][]string{
|
|
||||||
{"CHARACTER SET", "CHARSET", "CUSTOM_FUZZ_STRING", "NAMES"},
|
|
||||||
{"CUSTOM_FUZZ_STRING", "DEFAULT", "="},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
}
|
|
||||||
|
|
||||||
var dropTokens = [][]string{
|
|
||||||
{"TEMPORARY", "UNDO"},
|
|
||||||
{
|
|
||||||
"DATABASE", "SCHEMA", "EVENT", "INDEX", "LOGFILE GROUP",
|
|
||||||
"PROCEDURE", "FUNCTION", "SERVER", "SPATIAL REFERENCE SYSTEM",
|
|
||||||
"TABLE", "TABLESPACE", "TRIGGER", "VIEW",
|
|
||||||
},
|
|
||||||
{"IF EXISTS"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
{"ON", "ENGINE = ", "RESTRICT", "CASCADE"},
|
|
||||||
}
|
|
||||||
|
|
||||||
var renameTokens = [][]string{
|
|
||||||
{"TABLE"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
{"TO"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
}
|
|
||||||
|
|
||||||
var truncateTokens = [][]string{
|
|
||||||
{"TABLE"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
}
|
|
||||||
|
|
||||||
var createTokens = [][]string{
|
|
||||||
{"OR REPLACE", "TEMPORARY", "UNDO"}, // For create spatial reference system
|
|
||||||
{
|
|
||||||
"UNIQUE", "FULLTEXT", "SPATIAL", "ALGORITHM = UNDEFINED", "ALGORITHM = MERGE",
|
|
||||||
"ALGORITHM = TEMPTABLE",
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"DATABASE", "SCHEMA", "EVENT", "FUNCTION", "INDEX", "LOGFILE GROUP",
|
|
||||||
"PROCEDURE", "SERVER", "SPATIAL REFERENCE SYSTEM", "TABLE", "TABLESPACE",
|
|
||||||
"TRIGGER", "VIEW",
|
|
||||||
},
|
|
||||||
{"IF NOT EXISTS"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
// For future use.
|
|
||||||
var updateTokens = [][]string{
|
|
||||||
{"LOW_PRIORITY"},
|
|
||||||
{"IGNORE"},
|
|
||||||
{"SET"},
|
|
||||||
{"WHERE"},
|
|
||||||
{"ORDER BY"},
|
|
||||||
{"LIMIT"},
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
|
|
||||||
var replaceTokens = [][]string{
|
|
||||||
{"LOW_PRIORITY", "DELAYED"},
|
|
||||||
{"INTO"},
|
|
||||||
{"PARTITION"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
{"VALUES", "VALUE"},
|
|
||||||
}
|
|
||||||
|
|
||||||
var loadTokens = [][]string{
|
|
||||||
{"DATA"},
|
|
||||||
{"LOW_PRIORITY", "CONCURRENT", "LOCAL"},
|
|
||||||
{"INFILE"},
|
|
||||||
{"REPLACE", "IGNORE"},
|
|
||||||
{"INTO TABLE"},
|
|
||||||
{"PARTITION"},
|
|
||||||
{"CHARACTER SET"},
|
|
||||||
{"FIELDS", "COLUMNS"},
|
|
||||||
{"TERMINATED BY"},
|
|
||||||
{"OPTIONALLY"},
|
|
||||||
{"ENCLOSED BY"},
|
|
||||||
{"ESCAPED BY"},
|
|
||||||
{"LINES"},
|
|
||||||
{"STARTING BY"},
|
|
||||||
{"TERMINATED BY"},
|
|
||||||
{"IGNORE"},
|
|
||||||
{"LINES", "ROWS"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
}
|
|
||||||
|
|
||||||
// These Are everything that comes after "INSERT"
|
|
||||||
var insertTokens = [][]string{
|
|
||||||
{"LOW_PRIORITY", "DELAYED", "HIGH_PRIORITY", "IGNORE"},
|
|
||||||
{"INTO"},
|
|
||||||
{"PARTITION"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
{"AS"},
|
|
||||||
{"ON DUPLICATE KEY UPDATE"},
|
|
||||||
}
|
|
||||||
|
|
||||||
// These are everything that comes after "SELECT"
|
|
||||||
var selectTokens = [][]string{
|
|
||||||
{"*", "CUSTOM_FUZZ_STRING", "DISTINCTROW"},
|
|
||||||
{"HIGH_PRIORITY"},
|
|
||||||
{"STRAIGHT_JOIN"},
|
|
||||||
{"SQL_SMALL_RESULT", "SQL_BIG_RESULT", "SQL_BUFFER_RESULT"},
|
|
||||||
{"SQL_NO_CACHE", "SQL_CALC_FOUND_ROWS"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
{"FROM"},
|
|
||||||
{"WHERE"},
|
|
||||||
{"GROUP BY"},
|
|
||||||
{"HAVING"},
|
|
||||||
{"WINDOW"},
|
|
||||||
{"ORDER BY"},
|
|
||||||
{"LIMIT"},
|
|
||||||
{"CUSTOM_FUZZ_STRING"},
|
|
||||||
{"FOR"},
|
|
||||||
}
|
|
||||||
|
|
||||||
// These are everything that comes after "DELETE"
|
|
||||||
var deleteTokens = [][]string{
|
|
||||||
{"LOW_PRIORITY", "QUICK", "IGNORE", "FROM", "AS"},
|
|
||||||
{"PARTITION"},
|
|
||||||
{"WHERE"},
|
|
||||||
{"ORDER BY"},
|
|
||||||
{"LIMIT"},
|
|
||||||
}
|
|
||||||
|
|
||||||
var alter_table_options = []string{
|
|
||||||
"ADD", "COLUMN", "FIRST", "AFTER", "INDEX", "KEY", "FULLTEXT", "SPATIAL",
|
|
||||||
"CONSTRAINT", "UNIQUE", "FOREIGN KEY", "CHECK", "ENFORCED", "DROP", "ALTER",
|
|
||||||
"NOT", "INPLACE", "COPY", "SET", "VISIBLE", "INVISIBLE", "DEFAULT", "CHANGE",
|
|
||||||
"CHARACTER SET", "COLLATE", "DISABLE", "ENABLE", "KEYS", "TABLESPACE", "LOCK",
|
|
||||||
"FORCE", "MODIFY", "SHARED", "EXCLUSIVE", "NONE", "ORDER BY", "RENAME COLUMN",
|
|
||||||
"AS", "=", "ASC", "DESC", "WITH", "WITHOUT", "VALIDATION", "ADD PARTITION",
|
|
||||||
"DROP PARTITION", "DISCARD PARTITION", "IMPORT PARTITION", "TRUNCATE PARTITION",
|
|
||||||
"COALESCE PARTITION", "REORGANIZE PARTITION", "EXCHANGE PARTITION",
|
|
||||||
"ANALYZE PARTITION", "CHECK PARTITION", "OPTIMIZE PARTITION", "REBUILD PARTITION",
|
|
||||||
"REPAIR PARTITION", "REMOVE PARTITIONING", "USING", "BTREE", "HASH", "COMMENT",
|
|
||||||
"KEY_BLOCK_SIZE", "WITH PARSER", "AUTOEXTEND_SIZE", "AUTO_INCREMENT", "AVG_ROW_LENGTH",
|
|
||||||
"CHECKSUM", "INSERT_METHOD", "ROW_FORMAT", "DYNAMIC", "FIXED", "COMPRESSED", "REDUNDANT",
|
|
||||||
"COMPACT", "SECONDARY_ENGINE_ATTRIBUTE", "STATS_AUTO_RECALC", "STATS_PERSISTENT",
|
|
||||||
"STATS_SAMPLE_PAGES", "ZLIB", "LZ4", "ENGINE_ATTRIBUTE", "KEY_BLOCK_SIZE", "MAX_ROWS",
|
|
||||||
"MIN_ROWS", "PACK_KEYS", "PASSWORD", "COMPRESSION", "CONNECTION", "DIRECTORY",
|
|
||||||
"DELAY_KEY_WRITE", "ENCRYPTION", "STORAGE", "DISK", "MEMORY", "UNION",
|
|
||||||
}
|
|
||||||
|
|
||||||
// Creates an 'alter table' statement. 'alter table' is an exception
|
|
||||||
// in that it has its own function. The majority of statements
|
|
||||||
// are created by 'createStmt()'.
|
|
||||||
func createAlterTableStmt(f *ConsumeFuzzer) (string, error) {
|
|
||||||
maxArgs, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
maxArgs = maxArgs % 30
|
|
||||||
if maxArgs == 0 {
|
|
||||||
return "", fmt.Errorf("could not create alter table stmt")
|
|
||||||
}
|
|
||||||
|
|
||||||
var stmt strings.Builder
|
|
||||||
stmt.WriteString("ALTER TABLE ")
|
|
||||||
for i := 0; i < maxArgs; i++ {
|
|
||||||
// Calculate if we get existing token or custom string
|
|
||||||
tokenType, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
if tokenType%4 == 1 {
|
|
||||||
customString, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
stmt.WriteString(" " + customString)
|
|
||||||
} else {
|
|
||||||
tokenIndex, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
stmt.WriteString(" " + alter_table_options[tokenIndex%len(alter_table_options)])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return stmt.String(), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func chooseToken(tokens []string, f *ConsumeFuzzer) (string, error) {
|
|
||||||
index, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
var token strings.Builder
|
|
||||||
token.WriteString(tokens[index%len(tokens)])
|
|
||||||
if token.String() == "CUSTOM_FUZZ_STRING" {
|
|
||||||
customFuzzString, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
return customFuzzString, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if token requires an argument
|
|
||||||
if containsString(needCustomString, token.String()) {
|
|
||||||
customFuzzString, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
token.WriteString(" " + customFuzzString)
|
|
||||||
}
|
|
||||||
return token.String(), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
var stmtTypes = map[string][][]string{
|
|
||||||
"DELETE": deleteTokens,
|
|
||||||
"INSERT": insertTokens,
|
|
||||||
"SELECT": selectTokens,
|
|
||||||
"LOAD": loadTokens,
|
|
||||||
"REPLACE": replaceTokens,
|
|
||||||
"CREATE": createTokens,
|
|
||||||
"DROP": dropTokens,
|
|
||||||
"RENAME": renameTokens,
|
|
||||||
"TRUNCATE": truncateTokens,
|
|
||||||
"SET": setTokens,
|
|
||||||
"ALTER": alterTokens,
|
|
||||||
"ALTER TABLE": alterTableTokens, // ALTER TABLE has its own set of tokens
|
|
||||||
}
|
|
||||||
|
|
||||||
var stmtTypeEnum = map[int]string{
|
|
||||||
0: "DELETE",
|
|
||||||
1: "INSERT",
|
|
||||||
2: "SELECT",
|
|
||||||
3: "LOAD",
|
|
||||||
4: "REPLACE",
|
|
||||||
5: "CREATE",
|
|
||||||
6: "DROP",
|
|
||||||
7: "RENAME",
|
|
||||||
8: "TRUNCATE",
|
|
||||||
9: "SET",
|
|
||||||
10: "ALTER",
|
|
||||||
11: "ALTER TABLE",
|
|
||||||
}
|
|
||||||
|
|
||||||
func createStmt(f *ConsumeFuzzer) (string, error) {
|
|
||||||
stmtIndex, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
stmtIndex = stmtIndex % len(stmtTypes)
|
|
||||||
|
|
||||||
queryType := stmtTypeEnum[stmtIndex]
|
|
||||||
tokens := stmtTypes[queryType]
|
|
||||||
|
|
||||||
// We have custom creator for ALTER TABLE
|
|
||||||
if queryType == "ALTER TABLE" {
|
|
||||||
query, err := createAlterTableStmt(f)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
return query, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Here we are creating a query that is not
|
|
||||||
// an 'alter table' query. For available
|
|
||||||
// queries, see "stmtTypes"
|
|
||||||
|
|
||||||
// First specify the first query keyword:
|
|
||||||
var query strings.Builder
|
|
||||||
query.WriteString(queryType)
|
|
||||||
|
|
||||||
// Next create the args for the
|
|
||||||
queryArgs, err := createStmtArgs(tokens, f)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
query.WriteString(" " + queryArgs)
|
|
||||||
return query.String(), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Creates the arguments of a statements. In a select statement
|
|
||||||
// that would be everything after "select".
|
|
||||||
func createStmtArgs(tokenslice [][]string, f *ConsumeFuzzer) (string, error) {
|
|
||||||
var query, token strings.Builder
|
|
||||||
|
|
||||||
// We go through the tokens in the tokenslice,
|
|
||||||
// create the respective token and add it to
|
|
||||||
// "query"
|
|
||||||
for _, tokens := range tokenslice {
|
|
||||||
// For extra randomization, the fuzzer can
|
|
||||||
// choose to not include this token.
|
|
||||||
includeThisToken, err := f.GetBool()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
if !includeThisToken {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
// There may be several tokens to choose from:
|
|
||||||
if len(tokens) > 1 {
|
|
||||||
chosenToken, err := chooseToken(tokens, f)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
query.WriteString(" " + chosenToken)
|
|
||||||
} else {
|
|
||||||
token.WriteString(tokens[0])
|
|
||||||
|
|
||||||
// In case the token is "CUSTOM_FUZZ_STRING"
|
|
||||||
// we will then create a non-structured string
|
|
||||||
if token.String() == "CUSTOM_FUZZ_STRING" {
|
|
||||||
customFuzzString, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
query.WriteString(" " + customFuzzString)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if token requires an argument.
|
|
||||||
// Tokens that take an argument can be found
|
|
||||||
// in 'needCustomString'. If so, we add a
|
|
||||||
// non-structured string to the token.
|
|
||||||
if containsString(needCustomString, token.String()) {
|
|
||||||
customFuzzString, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
token.WriteString(fmt.Sprintf(" %s", customFuzzString))
|
|
||||||
}
|
|
||||||
query.WriteString(fmt.Sprintf(" %s", token.String()))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return query.String(), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Creates a semi-structured query. It creates a string
|
|
||||||
// that is a combination of the keywords and random strings.
|
|
||||||
func createQuery(f *ConsumeFuzzer) (string, error) {
|
|
||||||
queryLen, err := f.GetInt()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
maxLen := queryLen % 60
|
|
||||||
if maxLen == 0 {
|
|
||||||
return "", fmt.Errorf("could not create a query")
|
|
||||||
}
|
|
||||||
var query strings.Builder
|
|
||||||
for i := 0; i < maxLen; i++ {
|
|
||||||
// Get a new token:
|
|
||||||
useKeyword, err := f.GetBool()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
if useKeyword {
|
|
||||||
keyword, err := getKeyword(f)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
query.WriteString(" " + keyword)
|
|
||||||
} else {
|
|
||||||
customString, err := f.GetString()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
query.WriteString(" " + customString)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if query.String() == "" {
|
|
||||||
return "", fmt.Errorf("could not create a query")
|
|
||||||
}
|
|
||||||
return query.String(), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetSQLString is the API that users interact with.
|
|
||||||
//
|
|
||||||
// Usage:
|
|
||||||
//
|
|
||||||
// f := NewConsumer(data)
|
|
||||||
// sqlString, err := f.GetSQLString()
|
|
||||||
func (f *ConsumeFuzzer) GetSQLString() (string, error) {
|
|
||||||
var query string
|
|
||||||
veryStructured, err := f.GetBool()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
if veryStructured {
|
|
||||||
query, err = createStmt(f)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
query, err = createQuery(f)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return query, nil
|
|
||||||
}
|
|
||||||
@ -1,21 +0,0 @@
|
|||||||
The MIT License (MIT)
|
|
||||||
|
|
||||||
Copyright (c) 2015 Microsoft Corporation
|
|
||||||
|
|
||||||
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.
|
|
||||||
@ -1,12 +0,0 @@
|
|||||||
# go-ansiterm
|
|
||||||
|
|
||||||
This is a cross platform Ansi Terminal Emulation library. It reads a stream of Ansi characters and produces the appropriate function calls. The results of the function calls are platform dependent.
|
|
||||||
|
|
||||||
For example the parser might receive "ESC, [, A" as a stream of three characters. This is the code for Cursor Up (http://www.vt100.net/docs/vt510-rm/CUU). The parser then calls the cursor up function (CUU()) on an event handler. The event handler determines what platform specific work must be done to cause the cursor to move up one position.
|
|
||||||
|
|
||||||
The parser (parser.go) is a partial implementation of this state machine (http://vt100.net/emu/vt500_parser.png). There are also two event handler implementations, one for tests (test_event_handler.go) to validate that the expected events are being produced and called, the other is a Windows implementation (winterm/win_event_handler.go).
|
|
||||||
|
|
||||||
See parser_test.go for examples exercising the state machine and generating appropriate function calls.
|
|
||||||
|
|
||||||
-----
|
|
||||||
This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
|
|
||||||
@ -1,188 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
const LogEnv = "DEBUG_TERMINAL"
|
|
||||||
|
|
||||||
// ANSI constants
|
|
||||||
// References:
|
|
||||||
// -- http://www.ecma-international.org/publications/standards/Ecma-048.htm
|
|
||||||
// -- http://man7.org/linux/man-pages/man4/console_codes.4.html
|
|
||||||
// -- http://manpages.ubuntu.com/manpages/intrepid/man4/console_codes.4.html
|
|
||||||
// -- http://en.wikipedia.org/wiki/ANSI_escape_code
|
|
||||||
// -- http://vt100.net/emu/dec_ansi_parser
|
|
||||||
// -- http://vt100.net/emu/vt500_parser.svg
|
|
||||||
// -- http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
|
|
||||||
// -- http://www.inwap.com/pdp10/ansicode.txt
|
|
||||||
const (
|
|
||||||
// ECMA-48 Set Graphics Rendition
|
|
||||||
// Note:
|
|
||||||
// -- Constants leading with an underscore (e.g., _ANSI_xxx) are unsupported or reserved
|
|
||||||
// -- Fonts could possibly be supported via SetCurrentConsoleFontEx
|
|
||||||
// -- Windows does not expose the per-window cursor (i.e., caret) blink times
|
|
||||||
ANSI_SGR_RESET = 0
|
|
||||||
ANSI_SGR_BOLD = 1
|
|
||||||
ANSI_SGR_DIM = 2
|
|
||||||
_ANSI_SGR_ITALIC = 3
|
|
||||||
ANSI_SGR_UNDERLINE = 4
|
|
||||||
_ANSI_SGR_BLINKSLOW = 5
|
|
||||||
_ANSI_SGR_BLINKFAST = 6
|
|
||||||
ANSI_SGR_REVERSE = 7
|
|
||||||
_ANSI_SGR_INVISIBLE = 8
|
|
||||||
_ANSI_SGR_LINETHROUGH = 9
|
|
||||||
_ANSI_SGR_FONT_00 = 10
|
|
||||||
_ANSI_SGR_FONT_01 = 11
|
|
||||||
_ANSI_SGR_FONT_02 = 12
|
|
||||||
_ANSI_SGR_FONT_03 = 13
|
|
||||||
_ANSI_SGR_FONT_04 = 14
|
|
||||||
_ANSI_SGR_FONT_05 = 15
|
|
||||||
_ANSI_SGR_FONT_06 = 16
|
|
||||||
_ANSI_SGR_FONT_07 = 17
|
|
||||||
_ANSI_SGR_FONT_08 = 18
|
|
||||||
_ANSI_SGR_FONT_09 = 19
|
|
||||||
_ANSI_SGR_FONT_10 = 20
|
|
||||||
_ANSI_SGR_DOUBLEUNDERLINE = 21
|
|
||||||
ANSI_SGR_BOLD_DIM_OFF = 22
|
|
||||||
_ANSI_SGR_ITALIC_OFF = 23
|
|
||||||
ANSI_SGR_UNDERLINE_OFF = 24
|
|
||||||
_ANSI_SGR_BLINK_OFF = 25
|
|
||||||
_ANSI_SGR_RESERVED_00 = 26
|
|
||||||
ANSI_SGR_REVERSE_OFF = 27
|
|
||||||
_ANSI_SGR_INVISIBLE_OFF = 28
|
|
||||||
_ANSI_SGR_LINETHROUGH_OFF = 29
|
|
||||||
ANSI_SGR_FOREGROUND_BLACK = 30
|
|
||||||
ANSI_SGR_FOREGROUND_RED = 31
|
|
||||||
ANSI_SGR_FOREGROUND_GREEN = 32
|
|
||||||
ANSI_SGR_FOREGROUND_YELLOW = 33
|
|
||||||
ANSI_SGR_FOREGROUND_BLUE = 34
|
|
||||||
ANSI_SGR_FOREGROUND_MAGENTA = 35
|
|
||||||
ANSI_SGR_FOREGROUND_CYAN = 36
|
|
||||||
ANSI_SGR_FOREGROUND_WHITE = 37
|
|
||||||
_ANSI_SGR_RESERVED_01 = 38
|
|
||||||
ANSI_SGR_FOREGROUND_DEFAULT = 39
|
|
||||||
ANSI_SGR_BACKGROUND_BLACK = 40
|
|
||||||
ANSI_SGR_BACKGROUND_RED = 41
|
|
||||||
ANSI_SGR_BACKGROUND_GREEN = 42
|
|
||||||
ANSI_SGR_BACKGROUND_YELLOW = 43
|
|
||||||
ANSI_SGR_BACKGROUND_BLUE = 44
|
|
||||||
ANSI_SGR_BACKGROUND_MAGENTA = 45
|
|
||||||
ANSI_SGR_BACKGROUND_CYAN = 46
|
|
||||||
ANSI_SGR_BACKGROUND_WHITE = 47
|
|
||||||
_ANSI_SGR_RESERVED_02 = 48
|
|
||||||
ANSI_SGR_BACKGROUND_DEFAULT = 49
|
|
||||||
// 50 - 65: Unsupported
|
|
||||||
|
|
||||||
ANSI_MAX_CMD_LENGTH = 4096
|
|
||||||
|
|
||||||
MAX_INPUT_EVENTS = 128
|
|
||||||
DEFAULT_WIDTH = 80
|
|
||||||
DEFAULT_HEIGHT = 24
|
|
||||||
|
|
||||||
ANSI_BEL = 0x07
|
|
||||||
ANSI_BACKSPACE = 0x08
|
|
||||||
ANSI_TAB = 0x09
|
|
||||||
ANSI_LINE_FEED = 0x0A
|
|
||||||
ANSI_VERTICAL_TAB = 0x0B
|
|
||||||
ANSI_FORM_FEED = 0x0C
|
|
||||||
ANSI_CARRIAGE_RETURN = 0x0D
|
|
||||||
ANSI_ESCAPE_PRIMARY = 0x1B
|
|
||||||
ANSI_ESCAPE_SECONDARY = 0x5B
|
|
||||||
ANSI_OSC_STRING_ENTRY = 0x5D
|
|
||||||
ANSI_COMMAND_FIRST = 0x40
|
|
||||||
ANSI_COMMAND_LAST = 0x7E
|
|
||||||
DCS_ENTRY = 0x90
|
|
||||||
CSI_ENTRY = 0x9B
|
|
||||||
OSC_STRING = 0x9D
|
|
||||||
ANSI_PARAMETER_SEP = ";"
|
|
||||||
ANSI_CMD_G0 = '('
|
|
||||||
ANSI_CMD_G1 = ')'
|
|
||||||
ANSI_CMD_G2 = '*'
|
|
||||||
ANSI_CMD_G3 = '+'
|
|
||||||
ANSI_CMD_DECPNM = '>'
|
|
||||||
ANSI_CMD_DECPAM = '='
|
|
||||||
ANSI_CMD_OSC = ']'
|
|
||||||
ANSI_CMD_STR_TERM = '\\'
|
|
||||||
|
|
||||||
KEY_CONTROL_PARAM_2 = ";2"
|
|
||||||
KEY_CONTROL_PARAM_3 = ";3"
|
|
||||||
KEY_CONTROL_PARAM_4 = ";4"
|
|
||||||
KEY_CONTROL_PARAM_5 = ";5"
|
|
||||||
KEY_CONTROL_PARAM_6 = ";6"
|
|
||||||
KEY_CONTROL_PARAM_7 = ";7"
|
|
||||||
KEY_CONTROL_PARAM_8 = ";8"
|
|
||||||
KEY_ESC_CSI = "\x1B["
|
|
||||||
KEY_ESC_N = "\x1BN"
|
|
||||||
KEY_ESC_O = "\x1BO"
|
|
||||||
|
|
||||||
FILL_CHARACTER = ' '
|
|
||||||
)
|
|
||||||
|
|
||||||
func getByteRange(start byte, end byte) []byte {
|
|
||||||
bytes := make([]byte, 0, 32)
|
|
||||||
for i := start; i <= end; i++ {
|
|
||||||
bytes = append(bytes, byte(i))
|
|
||||||
}
|
|
||||||
|
|
||||||
return bytes
|
|
||||||
}
|
|
||||||
|
|
||||||
var toGroundBytes = getToGroundBytes()
|
|
||||||
var executors = getExecuteBytes()
|
|
||||||
|
|
||||||
// SPACE 20+A0 hex Always and everywhere a blank space
|
|
||||||
// Intermediate 20-2F hex !"#$%&'()*+,-./
|
|
||||||
var intermeds = getByteRange(0x20, 0x2F)
|
|
||||||
|
|
||||||
// Parameters 30-3F hex 0123456789:;<=>?
|
|
||||||
// CSI Parameters 30-39, 3B hex 0123456789;
|
|
||||||
var csiParams = getByteRange(0x30, 0x3F)
|
|
||||||
|
|
||||||
var csiCollectables = append(getByteRange(0x30, 0x39), getByteRange(0x3B, 0x3F)...)
|
|
||||||
|
|
||||||
// Uppercase 40-5F hex @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
|
|
||||||
var upperCase = getByteRange(0x40, 0x5F)
|
|
||||||
|
|
||||||
// Lowercase 60-7E hex `abcdefghijlkmnopqrstuvwxyz{|}~
|
|
||||||
var lowerCase = getByteRange(0x60, 0x7E)
|
|
||||||
|
|
||||||
// Alphabetics 40-7E hex (all of upper and lower case)
|
|
||||||
var alphabetics = append(upperCase, lowerCase...)
|
|
||||||
|
|
||||||
var printables = getByteRange(0x20, 0x7F)
|
|
||||||
|
|
||||||
var escapeIntermediateToGroundBytes = getByteRange(0x30, 0x7E)
|
|
||||||
var escapeToGroundBytes = getEscapeToGroundBytes()
|
|
||||||
|
|
||||||
// See http://www.vt100.net/emu/vt500_parser.png for description of the complex
|
|
||||||
// byte ranges below
|
|
||||||
|
|
||||||
func getEscapeToGroundBytes() []byte {
|
|
||||||
escapeToGroundBytes := getByteRange(0x30, 0x4F)
|
|
||||||
escapeToGroundBytes = append(escapeToGroundBytes, getByteRange(0x51, 0x57)...)
|
|
||||||
escapeToGroundBytes = append(escapeToGroundBytes, 0x59)
|
|
||||||
escapeToGroundBytes = append(escapeToGroundBytes, 0x5A)
|
|
||||||
escapeToGroundBytes = append(escapeToGroundBytes, 0x5C)
|
|
||||||
escapeToGroundBytes = append(escapeToGroundBytes, getByteRange(0x60, 0x7E)...)
|
|
||||||
return escapeToGroundBytes
|
|
||||||
}
|
|
||||||
|
|
||||||
func getExecuteBytes() []byte {
|
|
||||||
executeBytes := getByteRange(0x00, 0x17)
|
|
||||||
executeBytes = append(executeBytes, 0x19)
|
|
||||||
executeBytes = append(executeBytes, getByteRange(0x1C, 0x1F)...)
|
|
||||||
return executeBytes
|
|
||||||
}
|
|
||||||
|
|
||||||
func getToGroundBytes() []byte {
|
|
||||||
groundBytes := []byte{0x18}
|
|
||||||
groundBytes = append(groundBytes, 0x1A)
|
|
||||||
groundBytes = append(groundBytes, getByteRange(0x80, 0x8F)...)
|
|
||||||
groundBytes = append(groundBytes, getByteRange(0x91, 0x97)...)
|
|
||||||
groundBytes = append(groundBytes, 0x99)
|
|
||||||
groundBytes = append(groundBytes, 0x9A)
|
|
||||||
groundBytes = append(groundBytes, 0x9C)
|
|
||||||
return groundBytes
|
|
||||||
}
|
|
||||||
|
|
||||||
// Delete 7F hex Always and everywhere ignored
|
|
||||||
// C1 Control 80-9F hex 32 additional control characters
|
|
||||||
// G1 Displayable A1-FE hex 94 additional displayable characters
|
|
||||||
// Special A0+FF hex Same as SPACE and DELETE
|
|
||||||
@ -1,7 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
type ansiContext struct {
|
|
||||||
currentChar byte
|
|
||||||
paramBuffer []byte
|
|
||||||
interBuffer []byte
|
|
||||||
}
|
|
||||||
@ -1,49 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
type csiEntryState struct {
|
|
||||||
baseState
|
|
||||||
}
|
|
||||||
|
|
||||||
func (csiState csiEntryState) Handle(b byte) (s state, e error) {
|
|
||||||
csiState.parser.logf("CsiEntry::Handle %#x", b)
|
|
||||||
|
|
||||||
nextState, err := csiState.baseState.Handle(b)
|
|
||||||
if nextState != nil || err != nil {
|
|
||||||
return nextState, err
|
|
||||||
}
|
|
||||||
|
|
||||||
switch {
|
|
||||||
case sliceContains(alphabetics, b):
|
|
||||||
return csiState.parser.ground, nil
|
|
||||||
case sliceContains(csiCollectables, b):
|
|
||||||
return csiState.parser.csiParam, nil
|
|
||||||
case sliceContains(executors, b):
|
|
||||||
return csiState, csiState.parser.execute()
|
|
||||||
}
|
|
||||||
|
|
||||||
return csiState, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (csiState csiEntryState) Transition(s state) error {
|
|
||||||
csiState.parser.logf("CsiEntry::Transition %s --> %s", csiState.Name(), s.Name())
|
|
||||||
csiState.baseState.Transition(s)
|
|
||||||
|
|
||||||
switch s {
|
|
||||||
case csiState.parser.ground:
|
|
||||||
return csiState.parser.csiDispatch()
|
|
||||||
case csiState.parser.csiParam:
|
|
||||||
switch {
|
|
||||||
case sliceContains(csiParams, csiState.parser.context.currentChar):
|
|
||||||
csiState.parser.collectParam()
|
|
||||||
case sliceContains(intermeds, csiState.parser.context.currentChar):
|
|
||||||
csiState.parser.collectInter()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (csiState csiEntryState) Enter() error {
|
|
||||||
csiState.parser.clear()
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,38 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
type csiParamState struct {
|
|
||||||
baseState
|
|
||||||
}
|
|
||||||
|
|
||||||
func (csiState csiParamState) Handle(b byte) (s state, e error) {
|
|
||||||
csiState.parser.logf("CsiParam::Handle %#x", b)
|
|
||||||
|
|
||||||
nextState, err := csiState.baseState.Handle(b)
|
|
||||||
if nextState != nil || err != nil {
|
|
||||||
return nextState, err
|
|
||||||
}
|
|
||||||
|
|
||||||
switch {
|
|
||||||
case sliceContains(alphabetics, b):
|
|
||||||
return csiState.parser.ground, nil
|
|
||||||
case sliceContains(csiCollectables, b):
|
|
||||||
csiState.parser.collectParam()
|
|
||||||
return csiState, nil
|
|
||||||
case sliceContains(executors, b):
|
|
||||||
return csiState, csiState.parser.execute()
|
|
||||||
}
|
|
||||||
|
|
||||||
return csiState, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (csiState csiParamState) Transition(s state) error {
|
|
||||||
csiState.parser.logf("CsiParam::Transition %s --> %s", csiState.Name(), s.Name())
|
|
||||||
csiState.baseState.Transition(s)
|
|
||||||
|
|
||||||
switch s {
|
|
||||||
case csiState.parser.ground:
|
|
||||||
return csiState.parser.csiDispatch()
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,36 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
type escapeIntermediateState struct {
|
|
||||||
baseState
|
|
||||||
}
|
|
||||||
|
|
||||||
func (escState escapeIntermediateState) Handle(b byte) (s state, e error) {
|
|
||||||
escState.parser.logf("escapeIntermediateState::Handle %#x", b)
|
|
||||||
nextState, err := escState.baseState.Handle(b)
|
|
||||||
if nextState != nil || err != nil {
|
|
||||||
return nextState, err
|
|
||||||
}
|
|
||||||
|
|
||||||
switch {
|
|
||||||
case sliceContains(intermeds, b):
|
|
||||||
return escState, escState.parser.collectInter()
|
|
||||||
case sliceContains(executors, b):
|
|
||||||
return escState, escState.parser.execute()
|
|
||||||
case sliceContains(escapeIntermediateToGroundBytes, b):
|
|
||||||
return escState.parser.ground, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return escState, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (escState escapeIntermediateState) Transition(s state) error {
|
|
||||||
escState.parser.logf("escapeIntermediateState::Transition %s --> %s", escState.Name(), s.Name())
|
|
||||||
escState.baseState.Transition(s)
|
|
||||||
|
|
||||||
switch s {
|
|
||||||
case escState.parser.ground:
|
|
||||||
return escState.parser.escDispatch()
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,47 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
type escapeState struct {
|
|
||||||
baseState
|
|
||||||
}
|
|
||||||
|
|
||||||
func (escState escapeState) Handle(b byte) (s state, e error) {
|
|
||||||
escState.parser.logf("escapeState::Handle %#x", b)
|
|
||||||
nextState, err := escState.baseState.Handle(b)
|
|
||||||
if nextState != nil || err != nil {
|
|
||||||
return nextState, err
|
|
||||||
}
|
|
||||||
|
|
||||||
switch {
|
|
||||||
case b == ANSI_ESCAPE_SECONDARY:
|
|
||||||
return escState.parser.csiEntry, nil
|
|
||||||
case b == ANSI_OSC_STRING_ENTRY:
|
|
||||||
return escState.parser.oscString, nil
|
|
||||||
case sliceContains(executors, b):
|
|
||||||
return escState, escState.parser.execute()
|
|
||||||
case sliceContains(escapeToGroundBytes, b):
|
|
||||||
return escState.parser.ground, nil
|
|
||||||
case sliceContains(intermeds, b):
|
|
||||||
return escState.parser.escapeIntermediate, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return escState, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (escState escapeState) Transition(s state) error {
|
|
||||||
escState.parser.logf("Escape::Transition %s --> %s", escState.Name(), s.Name())
|
|
||||||
escState.baseState.Transition(s)
|
|
||||||
|
|
||||||
switch s {
|
|
||||||
case escState.parser.ground:
|
|
||||||
return escState.parser.escDispatch()
|
|
||||||
case escState.parser.escapeIntermediate:
|
|
||||||
return escState.parser.collectInter()
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (escState escapeState) Enter() error {
|
|
||||||
escState.parser.clear()
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,90 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
type AnsiEventHandler interface {
|
|
||||||
// Print
|
|
||||||
Print(b byte) error
|
|
||||||
|
|
||||||
// Execute C0 commands
|
|
||||||
Execute(b byte) error
|
|
||||||
|
|
||||||
// CUrsor Up
|
|
||||||
CUU(int) error
|
|
||||||
|
|
||||||
// CUrsor Down
|
|
||||||
CUD(int) error
|
|
||||||
|
|
||||||
// CUrsor Forward
|
|
||||||
CUF(int) error
|
|
||||||
|
|
||||||
// CUrsor Backward
|
|
||||||
CUB(int) error
|
|
||||||
|
|
||||||
// Cursor to Next Line
|
|
||||||
CNL(int) error
|
|
||||||
|
|
||||||
// Cursor to Previous Line
|
|
||||||
CPL(int) error
|
|
||||||
|
|
||||||
// Cursor Horizontal position Absolute
|
|
||||||
CHA(int) error
|
|
||||||
|
|
||||||
// Vertical line Position Absolute
|
|
||||||
VPA(int) error
|
|
||||||
|
|
||||||
// CUrsor Position
|
|
||||||
CUP(int, int) error
|
|
||||||
|
|
||||||
// Horizontal and Vertical Position (depends on PUM)
|
|
||||||
HVP(int, int) error
|
|
||||||
|
|
||||||
// Text Cursor Enable Mode
|
|
||||||
DECTCEM(bool) error
|
|
||||||
|
|
||||||
// Origin Mode
|
|
||||||
DECOM(bool) error
|
|
||||||
|
|
||||||
// 132 Column Mode
|
|
||||||
DECCOLM(bool) error
|
|
||||||
|
|
||||||
// Erase in Display
|
|
||||||
ED(int) error
|
|
||||||
|
|
||||||
// Erase in Line
|
|
||||||
EL(int) error
|
|
||||||
|
|
||||||
// Insert Line
|
|
||||||
IL(int) error
|
|
||||||
|
|
||||||
// Delete Line
|
|
||||||
DL(int) error
|
|
||||||
|
|
||||||
// Insert Character
|
|
||||||
ICH(int) error
|
|
||||||
|
|
||||||
// Delete Character
|
|
||||||
DCH(int) error
|
|
||||||
|
|
||||||
// Set Graphics Rendition
|
|
||||||
SGR([]int) error
|
|
||||||
|
|
||||||
// Pan Down
|
|
||||||
SU(int) error
|
|
||||||
|
|
||||||
// Pan Up
|
|
||||||
SD(int) error
|
|
||||||
|
|
||||||
// Device Attributes
|
|
||||||
DA([]string) error
|
|
||||||
|
|
||||||
// Set Top and Bottom Margins
|
|
||||||
DECSTBM(int, int) error
|
|
||||||
|
|
||||||
// Index
|
|
||||||
IND() error
|
|
||||||
|
|
||||||
// Reverse Index
|
|
||||||
RI() error
|
|
||||||
|
|
||||||
// Flush updates from previous commands
|
|
||||||
Flush() error
|
|
||||||
}
|
|
||||||
@ -1,24 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
type groundState struct {
|
|
||||||
baseState
|
|
||||||
}
|
|
||||||
|
|
||||||
func (gs groundState) Handle(b byte) (s state, e error) {
|
|
||||||
gs.parser.context.currentChar = b
|
|
||||||
|
|
||||||
nextState, err := gs.baseState.Handle(b)
|
|
||||||
if nextState != nil || err != nil {
|
|
||||||
return nextState, err
|
|
||||||
}
|
|
||||||
|
|
||||||
switch {
|
|
||||||
case sliceContains(printables, b):
|
|
||||||
return gs, gs.parser.print()
|
|
||||||
|
|
||||||
case sliceContains(executors, b):
|
|
||||||
return gs, gs.parser.execute()
|
|
||||||
}
|
|
||||||
|
|
||||||
return gs, nil
|
|
||||||
}
|
|
||||||
@ -1,31 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
type oscStringState struct {
|
|
||||||
baseState
|
|
||||||
}
|
|
||||||
|
|
||||||
func (oscState oscStringState) Handle(b byte) (s state, e error) {
|
|
||||||
oscState.parser.logf("OscString::Handle %#x", b)
|
|
||||||
nextState, err := oscState.baseState.Handle(b)
|
|
||||||
if nextState != nil || err != nil {
|
|
||||||
return nextState, err
|
|
||||||
}
|
|
||||||
|
|
||||||
switch {
|
|
||||||
case isOscStringTerminator(b):
|
|
||||||
return oscState.parser.ground, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return oscState, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// See below for OSC string terminators for linux
|
|
||||||
// http://man7.org/linux/man-pages/man4/console_codes.4.html
|
|
||||||
func isOscStringTerminator(b byte) bool {
|
|
||||||
|
|
||||||
if b == ANSI_BEL || b == 0x5C {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
@ -1,151 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"log"
|
|
||||||
"os"
|
|
||||||
)
|
|
||||||
|
|
||||||
type AnsiParser struct {
|
|
||||||
currState state
|
|
||||||
eventHandler AnsiEventHandler
|
|
||||||
context *ansiContext
|
|
||||||
csiEntry state
|
|
||||||
csiParam state
|
|
||||||
dcsEntry state
|
|
||||||
escape state
|
|
||||||
escapeIntermediate state
|
|
||||||
error state
|
|
||||||
ground state
|
|
||||||
oscString state
|
|
||||||
stateMap []state
|
|
||||||
|
|
||||||
logf func(string, ...interface{})
|
|
||||||
}
|
|
||||||
|
|
||||||
type Option func(*AnsiParser)
|
|
||||||
|
|
||||||
func WithLogf(f func(string, ...interface{})) Option {
|
|
||||||
return func(ap *AnsiParser) {
|
|
||||||
ap.logf = f
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func CreateParser(initialState string, evtHandler AnsiEventHandler, opts ...Option) *AnsiParser {
|
|
||||||
ap := &AnsiParser{
|
|
||||||
eventHandler: evtHandler,
|
|
||||||
context: &ansiContext{},
|
|
||||||
}
|
|
||||||
for _, o := range opts {
|
|
||||||
o(ap)
|
|
||||||
}
|
|
||||||
|
|
||||||
if isDebugEnv := os.Getenv(LogEnv); isDebugEnv == "1" {
|
|
||||||
logFile, _ := os.Create("ansiParser.log")
|
|
||||||
logger := log.New(logFile, "", log.LstdFlags)
|
|
||||||
if ap.logf != nil {
|
|
||||||
l := ap.logf
|
|
||||||
ap.logf = func(s string, v ...interface{}) {
|
|
||||||
l(s, v...)
|
|
||||||
logger.Printf(s, v...)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
ap.logf = logger.Printf
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if ap.logf == nil {
|
|
||||||
ap.logf = func(string, ...interface{}) {}
|
|
||||||
}
|
|
||||||
|
|
||||||
ap.csiEntry = csiEntryState{baseState{name: "CsiEntry", parser: ap}}
|
|
||||||
ap.csiParam = csiParamState{baseState{name: "CsiParam", parser: ap}}
|
|
||||||
ap.dcsEntry = dcsEntryState{baseState{name: "DcsEntry", parser: ap}}
|
|
||||||
ap.escape = escapeState{baseState{name: "Escape", parser: ap}}
|
|
||||||
ap.escapeIntermediate = escapeIntermediateState{baseState{name: "EscapeIntermediate", parser: ap}}
|
|
||||||
ap.error = errorState{baseState{name: "Error", parser: ap}}
|
|
||||||
ap.ground = groundState{baseState{name: "Ground", parser: ap}}
|
|
||||||
ap.oscString = oscStringState{baseState{name: "OscString", parser: ap}}
|
|
||||||
|
|
||||||
ap.stateMap = []state{
|
|
||||||
ap.csiEntry,
|
|
||||||
ap.csiParam,
|
|
||||||
ap.dcsEntry,
|
|
||||||
ap.escape,
|
|
||||||
ap.escapeIntermediate,
|
|
||||||
ap.error,
|
|
||||||
ap.ground,
|
|
||||||
ap.oscString,
|
|
||||||
}
|
|
||||||
|
|
||||||
ap.currState = getState(initialState, ap.stateMap)
|
|
||||||
|
|
||||||
ap.logf("CreateParser: parser %p", ap)
|
|
||||||
return ap
|
|
||||||
}
|
|
||||||
|
|
||||||
func getState(name string, states []state) state {
|
|
||||||
for _, el := range states {
|
|
||||||
if el.Name() == name {
|
|
||||||
return el
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) Parse(bytes []byte) (int, error) {
|
|
||||||
for i, b := range bytes {
|
|
||||||
if err := ap.handle(b); err != nil {
|
|
||||||
return i, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return len(bytes), ap.eventHandler.Flush()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) handle(b byte) error {
|
|
||||||
ap.context.currentChar = b
|
|
||||||
newState, err := ap.currState.Handle(b)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if newState == nil {
|
|
||||||
ap.logf("WARNING: newState is nil")
|
|
||||||
return errors.New("New state of 'nil' is invalid.")
|
|
||||||
}
|
|
||||||
|
|
||||||
if newState != ap.currState {
|
|
||||||
if err := ap.changeState(newState); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) changeState(newState state) error {
|
|
||||||
ap.logf("ChangeState %s --> %s", ap.currState.Name(), newState.Name())
|
|
||||||
|
|
||||||
// Exit old state
|
|
||||||
if err := ap.currState.Exit(); err != nil {
|
|
||||||
ap.logf("Exit state '%s' failed with : '%v'", ap.currState.Name(), err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Perform transition action
|
|
||||||
if err := ap.currState.Transition(newState); err != nil {
|
|
||||||
ap.logf("Transition from '%s' to '%s' failed with: '%v'", ap.currState.Name(), newState.Name, err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Enter new state
|
|
||||||
if err := newState.Enter(); err != nil {
|
|
||||||
ap.logf("Enter state '%s' failed with: '%v'", newState.Name(), err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
ap.currState = newState
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,99 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strconv"
|
|
||||||
)
|
|
||||||
|
|
||||||
func parseParams(bytes []byte) ([]string, error) {
|
|
||||||
paramBuff := make([]byte, 0, 0)
|
|
||||||
params := []string{}
|
|
||||||
|
|
||||||
for _, v := range bytes {
|
|
||||||
if v == ';' {
|
|
||||||
if len(paramBuff) > 0 {
|
|
||||||
// Completed parameter, append it to the list
|
|
||||||
s := string(paramBuff)
|
|
||||||
params = append(params, s)
|
|
||||||
paramBuff = make([]byte, 0, 0)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
paramBuff = append(paramBuff, v)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Last parameter may not be terminated with ';'
|
|
||||||
if len(paramBuff) > 0 {
|
|
||||||
s := string(paramBuff)
|
|
||||||
params = append(params, s)
|
|
||||||
}
|
|
||||||
|
|
||||||
return params, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func parseCmd(context ansiContext) (string, error) {
|
|
||||||
return string(context.currentChar), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func getInt(params []string, dflt int) int {
|
|
||||||
i := getInts(params, 1, dflt)[0]
|
|
||||||
return i
|
|
||||||
}
|
|
||||||
|
|
||||||
func getInts(params []string, minCount int, dflt int) []int {
|
|
||||||
ints := []int{}
|
|
||||||
|
|
||||||
for _, v := range params {
|
|
||||||
i, _ := strconv.Atoi(v)
|
|
||||||
// Zero is mapped to the default value in VT100.
|
|
||||||
if i == 0 {
|
|
||||||
i = dflt
|
|
||||||
}
|
|
||||||
ints = append(ints, i)
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(ints) < minCount {
|
|
||||||
remaining := minCount - len(ints)
|
|
||||||
for i := 0; i < remaining; i++ {
|
|
||||||
ints = append(ints, dflt)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return ints
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) modeDispatch(param string, set bool) error {
|
|
||||||
switch param {
|
|
||||||
case "?3":
|
|
||||||
return ap.eventHandler.DECCOLM(set)
|
|
||||||
case "?6":
|
|
||||||
return ap.eventHandler.DECOM(set)
|
|
||||||
case "?25":
|
|
||||||
return ap.eventHandler.DECTCEM(set)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) hDispatch(params []string) error {
|
|
||||||
if len(params) == 1 {
|
|
||||||
return ap.modeDispatch(params[0], true)
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) lDispatch(params []string) error {
|
|
||||||
if len(params) == 1 {
|
|
||||||
return ap.modeDispatch(params[0], false)
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func getEraseParam(params []string) int {
|
|
||||||
param := getInt(params, 0)
|
|
||||||
if param < 0 || 3 < param {
|
|
||||||
param = 0
|
|
||||||
}
|
|
||||||
|
|
||||||
return param
|
|
||||||
}
|
|
||||||
@ -1,119 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
func (ap *AnsiParser) collectParam() error {
|
|
||||||
currChar := ap.context.currentChar
|
|
||||||
ap.logf("collectParam %#x", currChar)
|
|
||||||
ap.context.paramBuffer = append(ap.context.paramBuffer, currChar)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) collectInter() error {
|
|
||||||
currChar := ap.context.currentChar
|
|
||||||
ap.logf("collectInter %#x", currChar)
|
|
||||||
ap.context.paramBuffer = append(ap.context.interBuffer, currChar)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) escDispatch() error {
|
|
||||||
cmd, _ := parseCmd(*ap.context)
|
|
||||||
intermeds := ap.context.interBuffer
|
|
||||||
ap.logf("escDispatch currentChar: %#x", ap.context.currentChar)
|
|
||||||
ap.logf("escDispatch: %v(%v)", cmd, intermeds)
|
|
||||||
|
|
||||||
switch cmd {
|
|
||||||
case "D": // IND
|
|
||||||
return ap.eventHandler.IND()
|
|
||||||
case "E": // NEL, equivalent to CRLF
|
|
||||||
err := ap.eventHandler.Execute(ANSI_CARRIAGE_RETURN)
|
|
||||||
if err == nil {
|
|
||||||
err = ap.eventHandler.Execute(ANSI_LINE_FEED)
|
|
||||||
}
|
|
||||||
return err
|
|
||||||
case "M": // RI
|
|
||||||
return ap.eventHandler.RI()
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) csiDispatch() error {
|
|
||||||
cmd, _ := parseCmd(*ap.context)
|
|
||||||
params, _ := parseParams(ap.context.paramBuffer)
|
|
||||||
ap.logf("Parsed params: %v with length: %d", params, len(params))
|
|
||||||
|
|
||||||
ap.logf("csiDispatch: %v(%v)", cmd, params)
|
|
||||||
|
|
||||||
switch cmd {
|
|
||||||
case "@":
|
|
||||||
return ap.eventHandler.ICH(getInt(params, 1))
|
|
||||||
case "A":
|
|
||||||
return ap.eventHandler.CUU(getInt(params, 1))
|
|
||||||
case "B":
|
|
||||||
return ap.eventHandler.CUD(getInt(params, 1))
|
|
||||||
case "C":
|
|
||||||
return ap.eventHandler.CUF(getInt(params, 1))
|
|
||||||
case "D":
|
|
||||||
return ap.eventHandler.CUB(getInt(params, 1))
|
|
||||||
case "E":
|
|
||||||
return ap.eventHandler.CNL(getInt(params, 1))
|
|
||||||
case "F":
|
|
||||||
return ap.eventHandler.CPL(getInt(params, 1))
|
|
||||||
case "G":
|
|
||||||
return ap.eventHandler.CHA(getInt(params, 1))
|
|
||||||
case "H":
|
|
||||||
ints := getInts(params, 2, 1)
|
|
||||||
x, y := ints[0], ints[1]
|
|
||||||
return ap.eventHandler.CUP(x, y)
|
|
||||||
case "J":
|
|
||||||
param := getEraseParam(params)
|
|
||||||
return ap.eventHandler.ED(param)
|
|
||||||
case "K":
|
|
||||||
param := getEraseParam(params)
|
|
||||||
return ap.eventHandler.EL(param)
|
|
||||||
case "L":
|
|
||||||
return ap.eventHandler.IL(getInt(params, 1))
|
|
||||||
case "M":
|
|
||||||
return ap.eventHandler.DL(getInt(params, 1))
|
|
||||||
case "P":
|
|
||||||
return ap.eventHandler.DCH(getInt(params, 1))
|
|
||||||
case "S":
|
|
||||||
return ap.eventHandler.SU(getInt(params, 1))
|
|
||||||
case "T":
|
|
||||||
return ap.eventHandler.SD(getInt(params, 1))
|
|
||||||
case "c":
|
|
||||||
return ap.eventHandler.DA(params)
|
|
||||||
case "d":
|
|
||||||
return ap.eventHandler.VPA(getInt(params, 1))
|
|
||||||
case "f":
|
|
||||||
ints := getInts(params, 2, 1)
|
|
||||||
x, y := ints[0], ints[1]
|
|
||||||
return ap.eventHandler.HVP(x, y)
|
|
||||||
case "h":
|
|
||||||
return ap.hDispatch(params)
|
|
||||||
case "l":
|
|
||||||
return ap.lDispatch(params)
|
|
||||||
case "m":
|
|
||||||
return ap.eventHandler.SGR(getInts(params, 1, 0))
|
|
||||||
case "r":
|
|
||||||
ints := getInts(params, 2, 1)
|
|
||||||
top, bottom := ints[0], ints[1]
|
|
||||||
return ap.eventHandler.DECSTBM(top, bottom)
|
|
||||||
default:
|
|
||||||
ap.logf("ERROR: Unsupported CSI command: '%s', with full context: %v", cmd, ap.context)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) print() error {
|
|
||||||
return ap.eventHandler.Print(ap.context.currentChar)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) clear() error {
|
|
||||||
ap.context = &ansiContext{}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ap *AnsiParser) execute() error {
|
|
||||||
return ap.eventHandler.Execute(ap.context.currentChar)
|
|
||||||
}
|
|
||||||
@ -1,71 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
type stateID int
|
|
||||||
|
|
||||||
type state interface {
|
|
||||||
Enter() error
|
|
||||||
Exit() error
|
|
||||||
Handle(byte) (state, error)
|
|
||||||
Name() string
|
|
||||||
Transition(state) error
|
|
||||||
}
|
|
||||||
|
|
||||||
type baseState struct {
|
|
||||||
name string
|
|
||||||
parser *AnsiParser
|
|
||||||
}
|
|
||||||
|
|
||||||
func (base baseState) Enter() error {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (base baseState) Exit() error {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (base baseState) Handle(b byte) (s state, e error) {
|
|
||||||
|
|
||||||
switch {
|
|
||||||
case b == CSI_ENTRY:
|
|
||||||
return base.parser.csiEntry, nil
|
|
||||||
case b == DCS_ENTRY:
|
|
||||||
return base.parser.dcsEntry, nil
|
|
||||||
case b == ANSI_ESCAPE_PRIMARY:
|
|
||||||
return base.parser.escape, nil
|
|
||||||
case b == OSC_STRING:
|
|
||||||
return base.parser.oscString, nil
|
|
||||||
case sliceContains(toGroundBytes, b):
|
|
||||||
return base.parser.ground, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (base baseState) Name() string {
|
|
||||||
return base.name
|
|
||||||
}
|
|
||||||
|
|
||||||
func (base baseState) Transition(s state) error {
|
|
||||||
if s == base.parser.ground {
|
|
||||||
execBytes := []byte{0x18}
|
|
||||||
execBytes = append(execBytes, 0x1A)
|
|
||||||
execBytes = append(execBytes, getByteRange(0x80, 0x8F)...)
|
|
||||||
execBytes = append(execBytes, getByteRange(0x91, 0x97)...)
|
|
||||||
execBytes = append(execBytes, 0x99)
|
|
||||||
execBytes = append(execBytes, 0x9A)
|
|
||||||
|
|
||||||
if sliceContains(execBytes, base.parser.context.currentChar) {
|
|
||||||
return base.parser.execute()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
type dcsEntryState struct {
|
|
||||||
baseState
|
|
||||||
}
|
|
||||||
|
|
||||||
type errorState struct {
|
|
||||||
baseState
|
|
||||||
}
|
|
||||||
@ -1,21 +0,0 @@
|
|||||||
package ansiterm
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strconv"
|
|
||||||
)
|
|
||||||
|
|
||||||
func sliceContains(bytes []byte, b byte) bool {
|
|
||||||
for _, v := range bytes {
|
|
||||||
if v == b {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func convertBytesToInteger(bytes []byte) int {
|
|
||||||
s := string(bytes)
|
|
||||||
i, _ := strconv.Atoi(s)
|
|
||||||
return i
|
|
||||||
}
|
|
||||||
@ -1,196 +0,0 @@
|
|||||||
// +build windows
|
|
||||||
|
|
||||||
package winterm
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"syscall"
|
|
||||||
|
|
||||||
"github.com/Azure/go-ansiterm"
|
|
||||||
windows "golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Windows keyboard constants
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx.
|
|
||||||
const (
|
|
||||||
VK_PRIOR = 0x21 // PAGE UP key
|
|
||||||
VK_NEXT = 0x22 // PAGE DOWN key
|
|
||||||
VK_END = 0x23 // END key
|
|
||||||
VK_HOME = 0x24 // HOME key
|
|
||||||
VK_LEFT = 0x25 // LEFT ARROW key
|
|
||||||
VK_UP = 0x26 // UP ARROW key
|
|
||||||
VK_RIGHT = 0x27 // RIGHT ARROW key
|
|
||||||
VK_DOWN = 0x28 // DOWN ARROW key
|
|
||||||
VK_SELECT = 0x29 // SELECT key
|
|
||||||
VK_PRINT = 0x2A // PRINT key
|
|
||||||
VK_EXECUTE = 0x2B // EXECUTE key
|
|
||||||
VK_SNAPSHOT = 0x2C // PRINT SCREEN key
|
|
||||||
VK_INSERT = 0x2D // INS key
|
|
||||||
VK_DELETE = 0x2E // DEL key
|
|
||||||
VK_HELP = 0x2F // HELP key
|
|
||||||
VK_F1 = 0x70 // F1 key
|
|
||||||
VK_F2 = 0x71 // F2 key
|
|
||||||
VK_F3 = 0x72 // F3 key
|
|
||||||
VK_F4 = 0x73 // F4 key
|
|
||||||
VK_F5 = 0x74 // F5 key
|
|
||||||
VK_F6 = 0x75 // F6 key
|
|
||||||
VK_F7 = 0x76 // F7 key
|
|
||||||
VK_F8 = 0x77 // F8 key
|
|
||||||
VK_F9 = 0x78 // F9 key
|
|
||||||
VK_F10 = 0x79 // F10 key
|
|
||||||
VK_F11 = 0x7A // F11 key
|
|
||||||
VK_F12 = 0x7B // F12 key
|
|
||||||
|
|
||||||
RIGHT_ALT_PRESSED = 0x0001
|
|
||||||
LEFT_ALT_PRESSED = 0x0002
|
|
||||||
RIGHT_CTRL_PRESSED = 0x0004
|
|
||||||
LEFT_CTRL_PRESSED = 0x0008
|
|
||||||
SHIFT_PRESSED = 0x0010
|
|
||||||
NUMLOCK_ON = 0x0020
|
|
||||||
SCROLLLOCK_ON = 0x0040
|
|
||||||
CAPSLOCK_ON = 0x0080
|
|
||||||
ENHANCED_KEY = 0x0100
|
|
||||||
)
|
|
||||||
|
|
||||||
type ansiCommand struct {
|
|
||||||
CommandBytes []byte
|
|
||||||
Command string
|
|
||||||
Parameters []string
|
|
||||||
IsSpecial bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func newAnsiCommand(command []byte) *ansiCommand {
|
|
||||||
|
|
||||||
if isCharacterSelectionCmdChar(command[1]) {
|
|
||||||
// Is Character Set Selection commands
|
|
||||||
return &ansiCommand{
|
|
||||||
CommandBytes: command,
|
|
||||||
Command: string(command),
|
|
||||||
IsSpecial: true,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// last char is command character
|
|
||||||
lastCharIndex := len(command) - 1
|
|
||||||
|
|
||||||
ac := &ansiCommand{
|
|
||||||
CommandBytes: command,
|
|
||||||
Command: string(command[lastCharIndex]),
|
|
||||||
IsSpecial: false,
|
|
||||||
}
|
|
||||||
|
|
||||||
// more than a single escape
|
|
||||||
if lastCharIndex != 0 {
|
|
||||||
start := 1
|
|
||||||
// skip if double char escape sequence
|
|
||||||
if command[0] == ansiterm.ANSI_ESCAPE_PRIMARY && command[1] == ansiterm.ANSI_ESCAPE_SECONDARY {
|
|
||||||
start++
|
|
||||||
}
|
|
||||||
// convert this to GetNextParam method
|
|
||||||
ac.Parameters = strings.Split(string(command[start:lastCharIndex]), ansiterm.ANSI_PARAMETER_SEP)
|
|
||||||
}
|
|
||||||
|
|
||||||
return ac
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ac *ansiCommand) paramAsSHORT(index int, defaultValue int16) int16 {
|
|
||||||
if index < 0 || index >= len(ac.Parameters) {
|
|
||||||
return defaultValue
|
|
||||||
}
|
|
||||||
|
|
||||||
param, err := strconv.ParseInt(ac.Parameters[index], 10, 16)
|
|
||||||
if err != nil {
|
|
||||||
return defaultValue
|
|
||||||
}
|
|
||||||
|
|
||||||
return int16(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ac *ansiCommand) String() string {
|
|
||||||
return fmt.Sprintf("0x%v \"%v\" (\"%v\")",
|
|
||||||
bytesToHex(ac.CommandBytes),
|
|
||||||
ac.Command,
|
|
||||||
strings.Join(ac.Parameters, "\",\""))
|
|
||||||
}
|
|
||||||
|
|
||||||
// isAnsiCommandChar returns true if the passed byte falls within the range of ANSI commands.
|
|
||||||
// See http://manpages.ubuntu.com/manpages/intrepid/man4/console_codes.4.html.
|
|
||||||
func isAnsiCommandChar(b byte) bool {
|
|
||||||
switch {
|
|
||||||
case ansiterm.ANSI_COMMAND_FIRST <= b && b <= ansiterm.ANSI_COMMAND_LAST && b != ansiterm.ANSI_ESCAPE_SECONDARY:
|
|
||||||
return true
|
|
||||||
case b == ansiterm.ANSI_CMD_G1 || b == ansiterm.ANSI_CMD_OSC || b == ansiterm.ANSI_CMD_DECPAM || b == ansiterm.ANSI_CMD_DECPNM:
|
|
||||||
// non-CSI escape sequence terminator
|
|
||||||
return true
|
|
||||||
case b == ansiterm.ANSI_CMD_STR_TERM || b == ansiterm.ANSI_BEL:
|
|
||||||
// String escape sequence terminator
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func isXtermOscSequence(command []byte, current byte) bool {
|
|
||||||
return (len(command) >= 2 && command[0] == ansiterm.ANSI_ESCAPE_PRIMARY && command[1] == ansiterm.ANSI_CMD_OSC && current != ansiterm.ANSI_BEL)
|
|
||||||
}
|
|
||||||
|
|
||||||
func isCharacterSelectionCmdChar(b byte) bool {
|
|
||||||
return (b == ansiterm.ANSI_CMD_G0 || b == ansiterm.ANSI_CMD_G1 || b == ansiterm.ANSI_CMD_G2 || b == ansiterm.ANSI_CMD_G3)
|
|
||||||
}
|
|
||||||
|
|
||||||
// bytesToHex converts a slice of bytes to a human-readable string.
|
|
||||||
func bytesToHex(b []byte) string {
|
|
||||||
hex := make([]string, len(b))
|
|
||||||
for i, ch := range b {
|
|
||||||
hex[i] = fmt.Sprintf("%X", ch)
|
|
||||||
}
|
|
||||||
return strings.Join(hex, "")
|
|
||||||
}
|
|
||||||
|
|
||||||
// ensureInRange adjusts the passed value, if necessary, to ensure it is within
|
|
||||||
// the passed min / max range.
|
|
||||||
func ensureInRange(n int16, min int16, max int16) int16 {
|
|
||||||
if n < min {
|
|
||||||
return min
|
|
||||||
} else if n > max {
|
|
||||||
return max
|
|
||||||
} else {
|
|
||||||
return n
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func GetStdFile(nFile int) (*os.File, uintptr) {
|
|
||||||
var file *os.File
|
|
||||||
|
|
||||||
// syscall uses negative numbers
|
|
||||||
// windows package uses very big uint32
|
|
||||||
// Keep these switches split so we don't have to convert ints too much.
|
|
||||||
switch uint32(nFile) {
|
|
||||||
case windows.STD_INPUT_HANDLE:
|
|
||||||
file = os.Stdin
|
|
||||||
case windows.STD_OUTPUT_HANDLE:
|
|
||||||
file = os.Stdout
|
|
||||||
case windows.STD_ERROR_HANDLE:
|
|
||||||
file = os.Stderr
|
|
||||||
default:
|
|
||||||
switch nFile {
|
|
||||||
case syscall.STD_INPUT_HANDLE:
|
|
||||||
file = os.Stdin
|
|
||||||
case syscall.STD_OUTPUT_HANDLE:
|
|
||||||
file = os.Stdout
|
|
||||||
case syscall.STD_ERROR_HANDLE:
|
|
||||||
file = os.Stderr
|
|
||||||
default:
|
|
||||||
panic(fmt.Errorf("Invalid standard handle identifier: %v", nFile))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fd, err := syscall.GetStdHandle(nFile)
|
|
||||||
if err != nil {
|
|
||||||
panic(fmt.Errorf("Invalid standard handle identifier: %v -- %v", nFile, err))
|
|
||||||
}
|
|
||||||
|
|
||||||
return file, uintptr(fd)
|
|
||||||
}
|
|
||||||
@ -1,327 +0,0 @@
|
|||||||
// +build windows
|
|
||||||
|
|
||||||
package winterm
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"syscall"
|
|
||||||
"unsafe"
|
|
||||||
)
|
|
||||||
|
|
||||||
//===========================================================================================================
|
|
||||||
// IMPORTANT NOTE:
|
|
||||||
//
|
|
||||||
// The methods below make extensive use of the "unsafe" package to obtain the required pointers.
|
|
||||||
// Beginning in Go 1.3, the garbage collector may release local variables (e.g., incoming arguments, stack
|
|
||||||
// variables) the pointers reference *before* the API completes.
|
|
||||||
//
|
|
||||||
// As a result, in those cases, the code must hint that the variables remain in active by invoking the
|
|
||||||
// dummy method "use" (see below). Newer versions of Go are planned to change the mechanism to no longer
|
|
||||||
// require unsafe pointers.
|
|
||||||
//
|
|
||||||
// If you add or modify methods, ENSURE protection of local variables through the "use" builtin to inform
|
|
||||||
// the garbage collector the variables remain in use if:
|
|
||||||
//
|
|
||||||
// -- The value is not a pointer (e.g., int32, struct)
|
|
||||||
// -- The value is not referenced by the method after passing the pointer to Windows
|
|
||||||
//
|
|
||||||
// See http://golang.org/doc/go1.3.
|
|
||||||
//===========================================================================================================
|
|
||||||
|
|
||||||
var (
|
|
||||||
kernel32DLL = syscall.NewLazyDLL("kernel32.dll")
|
|
||||||
|
|
||||||
getConsoleCursorInfoProc = kernel32DLL.NewProc("GetConsoleCursorInfo")
|
|
||||||
setConsoleCursorInfoProc = kernel32DLL.NewProc("SetConsoleCursorInfo")
|
|
||||||
setConsoleCursorPositionProc = kernel32DLL.NewProc("SetConsoleCursorPosition")
|
|
||||||
setConsoleModeProc = kernel32DLL.NewProc("SetConsoleMode")
|
|
||||||
getConsoleScreenBufferInfoProc = kernel32DLL.NewProc("GetConsoleScreenBufferInfo")
|
|
||||||
setConsoleScreenBufferSizeProc = kernel32DLL.NewProc("SetConsoleScreenBufferSize")
|
|
||||||
scrollConsoleScreenBufferProc = kernel32DLL.NewProc("ScrollConsoleScreenBufferA")
|
|
||||||
setConsoleTextAttributeProc = kernel32DLL.NewProc("SetConsoleTextAttribute")
|
|
||||||
setConsoleWindowInfoProc = kernel32DLL.NewProc("SetConsoleWindowInfo")
|
|
||||||
writeConsoleOutputProc = kernel32DLL.NewProc("WriteConsoleOutputW")
|
|
||||||
readConsoleInputProc = kernel32DLL.NewProc("ReadConsoleInputW")
|
|
||||||
waitForSingleObjectProc = kernel32DLL.NewProc("WaitForSingleObject")
|
|
||||||
)
|
|
||||||
|
|
||||||
// Windows Console constants
|
|
||||||
const (
|
|
||||||
// Console modes
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx.
|
|
||||||
ENABLE_PROCESSED_INPUT = 0x0001
|
|
||||||
ENABLE_LINE_INPUT = 0x0002
|
|
||||||
ENABLE_ECHO_INPUT = 0x0004
|
|
||||||
ENABLE_WINDOW_INPUT = 0x0008
|
|
||||||
ENABLE_MOUSE_INPUT = 0x0010
|
|
||||||
ENABLE_INSERT_MODE = 0x0020
|
|
||||||
ENABLE_QUICK_EDIT_MODE = 0x0040
|
|
||||||
ENABLE_EXTENDED_FLAGS = 0x0080
|
|
||||||
ENABLE_AUTO_POSITION = 0x0100
|
|
||||||
ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
|
|
||||||
|
|
||||||
ENABLE_PROCESSED_OUTPUT = 0x0001
|
|
||||||
ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002
|
|
||||||
ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
|
|
||||||
DISABLE_NEWLINE_AUTO_RETURN = 0x0008
|
|
||||||
ENABLE_LVB_GRID_WORLDWIDE = 0x0010
|
|
||||||
|
|
||||||
// Character attributes
|
|
||||||
// Note:
|
|
||||||
// -- The attributes are combined to produce various colors (e.g., Blue + Green will create Cyan).
|
|
||||||
// Clearing all foreground or background colors results in black; setting all creates white.
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms682088(v=vs.85).aspx#_win32_character_attributes.
|
|
||||||
FOREGROUND_BLUE uint16 = 0x0001
|
|
||||||
FOREGROUND_GREEN uint16 = 0x0002
|
|
||||||
FOREGROUND_RED uint16 = 0x0004
|
|
||||||
FOREGROUND_INTENSITY uint16 = 0x0008
|
|
||||||
FOREGROUND_MASK uint16 = 0x000F
|
|
||||||
|
|
||||||
BACKGROUND_BLUE uint16 = 0x0010
|
|
||||||
BACKGROUND_GREEN uint16 = 0x0020
|
|
||||||
BACKGROUND_RED uint16 = 0x0040
|
|
||||||
BACKGROUND_INTENSITY uint16 = 0x0080
|
|
||||||
BACKGROUND_MASK uint16 = 0x00F0
|
|
||||||
|
|
||||||
COMMON_LVB_MASK uint16 = 0xFF00
|
|
||||||
COMMON_LVB_REVERSE_VIDEO uint16 = 0x4000
|
|
||||||
COMMON_LVB_UNDERSCORE uint16 = 0x8000
|
|
||||||
|
|
||||||
// Input event types
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683499(v=vs.85).aspx.
|
|
||||||
KEY_EVENT = 0x0001
|
|
||||||
MOUSE_EVENT = 0x0002
|
|
||||||
WINDOW_BUFFER_SIZE_EVENT = 0x0004
|
|
||||||
MENU_EVENT = 0x0008
|
|
||||||
FOCUS_EVENT = 0x0010
|
|
||||||
|
|
||||||
// WaitForSingleObject return codes
|
|
||||||
WAIT_ABANDONED = 0x00000080
|
|
||||||
WAIT_FAILED = 0xFFFFFFFF
|
|
||||||
WAIT_SIGNALED = 0x0000000
|
|
||||||
WAIT_TIMEOUT = 0x00000102
|
|
||||||
|
|
||||||
// WaitForSingleObject wait duration
|
|
||||||
WAIT_INFINITE = 0xFFFFFFFF
|
|
||||||
WAIT_ONE_SECOND = 1000
|
|
||||||
WAIT_HALF_SECOND = 500
|
|
||||||
WAIT_QUARTER_SECOND = 250
|
|
||||||
)
|
|
||||||
|
|
||||||
// Windows API Console types
|
|
||||||
// -- See https://msdn.microsoft.com/en-us/library/windows/desktop/ms682101(v=vs.85).aspx for Console specific types (e.g., COORD)
|
|
||||||
// -- See https://msdn.microsoft.com/en-us/library/aa296569(v=vs.60).aspx for comments on alignment
|
|
||||||
type (
|
|
||||||
CHAR_INFO struct {
|
|
||||||
UnicodeChar uint16
|
|
||||||
Attributes uint16
|
|
||||||
}
|
|
||||||
|
|
||||||
CONSOLE_CURSOR_INFO struct {
|
|
||||||
Size uint32
|
|
||||||
Visible int32
|
|
||||||
}
|
|
||||||
|
|
||||||
CONSOLE_SCREEN_BUFFER_INFO struct {
|
|
||||||
Size COORD
|
|
||||||
CursorPosition COORD
|
|
||||||
Attributes uint16
|
|
||||||
Window SMALL_RECT
|
|
||||||
MaximumWindowSize COORD
|
|
||||||
}
|
|
||||||
|
|
||||||
COORD struct {
|
|
||||||
X int16
|
|
||||||
Y int16
|
|
||||||
}
|
|
||||||
|
|
||||||
SMALL_RECT struct {
|
|
||||||
Left int16
|
|
||||||
Top int16
|
|
||||||
Right int16
|
|
||||||
Bottom int16
|
|
||||||
}
|
|
||||||
|
|
||||||
// INPUT_RECORD is a C/C++ union of which KEY_EVENT_RECORD is one case, it is also the largest
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683499(v=vs.85).aspx.
|
|
||||||
INPUT_RECORD struct {
|
|
||||||
EventType uint16
|
|
||||||
KeyEvent KEY_EVENT_RECORD
|
|
||||||
}
|
|
||||||
|
|
||||||
KEY_EVENT_RECORD struct {
|
|
||||||
KeyDown int32
|
|
||||||
RepeatCount uint16
|
|
||||||
VirtualKeyCode uint16
|
|
||||||
VirtualScanCode uint16
|
|
||||||
UnicodeChar uint16
|
|
||||||
ControlKeyState uint32
|
|
||||||
}
|
|
||||||
|
|
||||||
WINDOW_BUFFER_SIZE struct {
|
|
||||||
Size COORD
|
|
||||||
}
|
|
||||||
)
|
|
||||||
|
|
||||||
// boolToBOOL converts a Go bool into a Windows int32.
|
|
||||||
func boolToBOOL(f bool) int32 {
|
|
||||||
if f {
|
|
||||||
return int32(1)
|
|
||||||
} else {
|
|
||||||
return int32(0)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetConsoleCursorInfo retrieves information about the size and visiblity of the console cursor.
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms683163(v=vs.85).aspx.
|
|
||||||
func GetConsoleCursorInfo(handle uintptr, cursorInfo *CONSOLE_CURSOR_INFO) error {
|
|
||||||
r1, r2, err := getConsoleCursorInfoProc.Call(handle, uintptr(unsafe.Pointer(cursorInfo)), 0)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetConsoleCursorInfo sets the size and visiblity of the console cursor.
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686019(v=vs.85).aspx.
|
|
||||||
func SetConsoleCursorInfo(handle uintptr, cursorInfo *CONSOLE_CURSOR_INFO) error {
|
|
||||||
r1, r2, err := setConsoleCursorInfoProc.Call(handle, uintptr(unsafe.Pointer(cursorInfo)), 0)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetConsoleCursorPosition location of the console cursor.
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686025(v=vs.85).aspx.
|
|
||||||
func SetConsoleCursorPosition(handle uintptr, coord COORD) error {
|
|
||||||
r1, r2, err := setConsoleCursorPositionProc.Call(handle, coordToPointer(coord))
|
|
||||||
use(coord)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetConsoleMode gets the console mode for given file descriptor
|
|
||||||
// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms683167(v=vs.85).aspx.
|
|
||||||
func GetConsoleMode(handle uintptr) (mode uint32, err error) {
|
|
||||||
err = syscall.GetConsoleMode(syscall.Handle(handle), &mode)
|
|
||||||
return mode, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetConsoleMode sets the console mode for given file descriptor
|
|
||||||
// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms686033(v=vs.85).aspx.
|
|
||||||
func SetConsoleMode(handle uintptr, mode uint32) error {
|
|
||||||
r1, r2, err := setConsoleModeProc.Call(handle, uintptr(mode), 0)
|
|
||||||
use(mode)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetConsoleScreenBufferInfo retrieves information about the specified console screen buffer.
|
|
||||||
// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms683171(v=vs.85).aspx.
|
|
||||||
func GetConsoleScreenBufferInfo(handle uintptr) (*CONSOLE_SCREEN_BUFFER_INFO, error) {
|
|
||||||
info := CONSOLE_SCREEN_BUFFER_INFO{}
|
|
||||||
err := checkError(getConsoleScreenBufferInfoProc.Call(handle, uintptr(unsafe.Pointer(&info)), 0))
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return &info, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func ScrollConsoleScreenBuffer(handle uintptr, scrollRect SMALL_RECT, clipRect SMALL_RECT, destOrigin COORD, char CHAR_INFO) error {
|
|
||||||
r1, r2, err := scrollConsoleScreenBufferProc.Call(handle, uintptr(unsafe.Pointer(&scrollRect)), uintptr(unsafe.Pointer(&clipRect)), coordToPointer(destOrigin), uintptr(unsafe.Pointer(&char)))
|
|
||||||
use(scrollRect)
|
|
||||||
use(clipRect)
|
|
||||||
use(destOrigin)
|
|
||||||
use(char)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetConsoleScreenBufferSize sets the size of the console screen buffer.
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686044(v=vs.85).aspx.
|
|
||||||
func SetConsoleScreenBufferSize(handle uintptr, coord COORD) error {
|
|
||||||
r1, r2, err := setConsoleScreenBufferSizeProc.Call(handle, coordToPointer(coord))
|
|
||||||
use(coord)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetConsoleTextAttribute sets the attributes of characters written to the
|
|
||||||
// console screen buffer by the WriteFile or WriteConsole function.
|
|
||||||
// See http://msdn.microsoft.com/en-us/library/windows/desktop/ms686047(v=vs.85).aspx.
|
|
||||||
func SetConsoleTextAttribute(handle uintptr, attribute uint16) error {
|
|
||||||
r1, r2, err := setConsoleTextAttributeProc.Call(handle, uintptr(attribute), 0)
|
|
||||||
use(attribute)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetConsoleWindowInfo sets the size and position of the console screen buffer's window.
|
|
||||||
// Note that the size and location must be within and no larger than the backing console screen buffer.
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms686125(v=vs.85).aspx.
|
|
||||||
func SetConsoleWindowInfo(handle uintptr, isAbsolute bool, rect SMALL_RECT) error {
|
|
||||||
r1, r2, err := setConsoleWindowInfoProc.Call(handle, uintptr(boolToBOOL(isAbsolute)), uintptr(unsafe.Pointer(&rect)))
|
|
||||||
use(isAbsolute)
|
|
||||||
use(rect)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// WriteConsoleOutput writes the CHAR_INFOs from the provided buffer to the active console buffer.
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms687404(v=vs.85).aspx.
|
|
||||||
func WriteConsoleOutput(handle uintptr, buffer []CHAR_INFO, bufferSize COORD, bufferCoord COORD, writeRegion *SMALL_RECT) error {
|
|
||||||
r1, r2, err := writeConsoleOutputProc.Call(handle, uintptr(unsafe.Pointer(&buffer[0])), coordToPointer(bufferSize), coordToPointer(bufferCoord), uintptr(unsafe.Pointer(writeRegion)))
|
|
||||||
use(buffer)
|
|
||||||
use(bufferSize)
|
|
||||||
use(bufferCoord)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// ReadConsoleInput reads (and removes) data from the console input buffer.
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms684961(v=vs.85).aspx.
|
|
||||||
func ReadConsoleInput(handle uintptr, buffer []INPUT_RECORD, count *uint32) error {
|
|
||||||
r1, r2, err := readConsoleInputProc.Call(handle, uintptr(unsafe.Pointer(&buffer[0])), uintptr(len(buffer)), uintptr(unsafe.Pointer(count)))
|
|
||||||
use(buffer)
|
|
||||||
return checkError(r1, r2, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// WaitForSingleObject waits for the passed handle to be signaled.
|
|
||||||
// It returns true if the handle was signaled; false otherwise.
|
|
||||||
// See https://msdn.microsoft.com/en-us/library/windows/desktop/ms687032(v=vs.85).aspx.
|
|
||||||
func WaitForSingleObject(handle uintptr, msWait uint32) (bool, error) {
|
|
||||||
r1, _, err := waitForSingleObjectProc.Call(handle, uintptr(uint32(msWait)))
|
|
||||||
switch r1 {
|
|
||||||
case WAIT_ABANDONED, WAIT_TIMEOUT:
|
|
||||||
return false, nil
|
|
||||||
case WAIT_SIGNALED:
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
use(msWait)
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// String helpers
|
|
||||||
func (info CONSOLE_SCREEN_BUFFER_INFO) String() string {
|
|
||||||
return fmt.Sprintf("Size(%v) Cursor(%v) Window(%v) Max(%v)", info.Size, info.CursorPosition, info.Window, info.MaximumWindowSize)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (coord COORD) String() string {
|
|
||||||
return fmt.Sprintf("%v,%v", coord.X, coord.Y)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (rect SMALL_RECT) String() string {
|
|
||||||
return fmt.Sprintf("(%v,%v),(%v,%v)", rect.Left, rect.Top, rect.Right, rect.Bottom)
|
|
||||||
}
|
|
||||||
|
|
||||||
// checkError evaluates the results of a Windows API call and returns the error if it failed.
|
|
||||||
func checkError(r1, r2 uintptr, err error) error {
|
|
||||||
// Windows APIs return non-zero to indicate success
|
|
||||||
if r1 != 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return the error if provided, otherwise default to EINVAL
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return syscall.EINVAL
|
|
||||||
}
|
|
||||||
|
|
||||||
// coordToPointer converts a COORD into a uintptr (by fooling the type system).
|
|
||||||
func coordToPointer(c COORD) uintptr {
|
|
||||||
// Note: This code assumes the two SHORTs are correctly laid out; the "cast" to uint32 is just to get a pointer to pass.
|
|
||||||
return uintptr(*((*uint32)(unsafe.Pointer(&c))))
|
|
||||||
}
|
|
||||||
|
|
||||||
// use is a no-op, but the compiler cannot see that it is.
|
|
||||||
// Calling use(p) ensures that p is kept live until that point.
|
|
||||||
func use(p interface{}) {}
|
|
||||||
@ -1,100 +0,0 @@
|
|||||||
// +build windows
|
|
||||||
|
|
||||||
package winterm
|
|
||||||
|
|
||||||
import "github.com/Azure/go-ansiterm"
|
|
||||||
|
|
||||||
const (
|
|
||||||
FOREGROUND_COLOR_MASK = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
|
|
||||||
BACKGROUND_COLOR_MASK = BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE
|
|
||||||
)
|
|
||||||
|
|
||||||
// collectAnsiIntoWindowsAttributes modifies the passed Windows text mode flags to reflect the
|
|
||||||
// request represented by the passed ANSI mode.
|
|
||||||
func collectAnsiIntoWindowsAttributes(windowsMode uint16, inverted bool, baseMode uint16, ansiMode int16) (uint16, bool) {
|
|
||||||
switch ansiMode {
|
|
||||||
|
|
||||||
// Mode styles
|
|
||||||
case ansiterm.ANSI_SGR_BOLD:
|
|
||||||
windowsMode = windowsMode | FOREGROUND_INTENSITY
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_DIM, ansiterm.ANSI_SGR_BOLD_DIM_OFF:
|
|
||||||
windowsMode &^= FOREGROUND_INTENSITY
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_UNDERLINE:
|
|
||||||
windowsMode = windowsMode | COMMON_LVB_UNDERSCORE
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_REVERSE:
|
|
||||||
inverted = true
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_REVERSE_OFF:
|
|
||||||
inverted = false
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_UNDERLINE_OFF:
|
|
||||||
windowsMode &^= COMMON_LVB_UNDERSCORE
|
|
||||||
|
|
||||||
// Foreground colors
|
|
||||||
case ansiterm.ANSI_SGR_FOREGROUND_DEFAULT:
|
|
||||||
windowsMode = (windowsMode &^ FOREGROUND_MASK) | (baseMode & FOREGROUND_MASK)
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_FOREGROUND_BLACK:
|
|
||||||
windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK)
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_FOREGROUND_RED:
|
|
||||||
windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_FOREGROUND_GREEN:
|
|
||||||
windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_GREEN
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_FOREGROUND_YELLOW:
|
|
||||||
windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED | FOREGROUND_GREEN
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_FOREGROUND_BLUE:
|
|
||||||
windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_BLUE
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_FOREGROUND_MAGENTA:
|
|
||||||
windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED | FOREGROUND_BLUE
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_FOREGROUND_CYAN:
|
|
||||||
windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_GREEN | FOREGROUND_BLUE
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_FOREGROUND_WHITE:
|
|
||||||
windowsMode = (windowsMode &^ FOREGROUND_COLOR_MASK) | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
|
|
||||||
|
|
||||||
// Background colors
|
|
||||||
case ansiterm.ANSI_SGR_BACKGROUND_DEFAULT:
|
|
||||||
// Black with no intensity
|
|
||||||
windowsMode = (windowsMode &^ BACKGROUND_MASK) | (baseMode & BACKGROUND_MASK)
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_BACKGROUND_BLACK:
|
|
||||||
windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK)
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_BACKGROUND_RED:
|
|
||||||
windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_BACKGROUND_GREEN:
|
|
||||||
windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_GREEN
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_BACKGROUND_YELLOW:
|
|
||||||
windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED | BACKGROUND_GREEN
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_BACKGROUND_BLUE:
|
|
||||||
windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_BLUE
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_BACKGROUND_MAGENTA:
|
|
||||||
windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED | BACKGROUND_BLUE
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_BACKGROUND_CYAN:
|
|
||||||
windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_GREEN | BACKGROUND_BLUE
|
|
||||||
|
|
||||||
case ansiterm.ANSI_SGR_BACKGROUND_WHITE:
|
|
||||||
windowsMode = (windowsMode &^ BACKGROUND_COLOR_MASK) | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE
|
|
||||||
}
|
|
||||||
|
|
||||||
return windowsMode, inverted
|
|
||||||
}
|
|
||||||
|
|
||||||
// invertAttributes inverts the foreground and background colors of a Windows attributes value
|
|
||||||
func invertAttributes(windowsMode uint16) uint16 {
|
|
||||||
return (COMMON_LVB_MASK & windowsMode) | ((FOREGROUND_MASK & windowsMode) << 4) | ((BACKGROUND_MASK & windowsMode) >> 4)
|
|
||||||
}
|
|
||||||
@ -1,101 +0,0 @@
|
|||||||
// +build windows
|
|
||||||
|
|
||||||
package winterm
|
|
||||||
|
|
||||||
const (
|
|
||||||
horizontal = iota
|
|
||||||
vertical
|
|
||||||
)
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) getCursorWindow(info *CONSOLE_SCREEN_BUFFER_INFO) SMALL_RECT {
|
|
||||||
if h.originMode {
|
|
||||||
sr := h.effectiveSr(info.Window)
|
|
||||||
return SMALL_RECT{
|
|
||||||
Top: sr.top,
|
|
||||||
Bottom: sr.bottom,
|
|
||||||
Left: 0,
|
|
||||||
Right: info.Size.X - 1,
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
return SMALL_RECT{
|
|
||||||
Top: info.Window.Top,
|
|
||||||
Bottom: info.Window.Bottom,
|
|
||||||
Left: 0,
|
|
||||||
Right: info.Size.X - 1,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// setCursorPosition sets the cursor to the specified position, bounded to the screen size
|
|
||||||
func (h *windowsAnsiEventHandler) setCursorPosition(position COORD, window SMALL_RECT) error {
|
|
||||||
position.X = ensureInRange(position.X, window.Left, window.Right)
|
|
||||||
position.Y = ensureInRange(position.Y, window.Top, window.Bottom)
|
|
||||||
err := SetConsoleCursorPosition(h.fd, position)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("Cursor position set: (%d, %d)", position.X, position.Y)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) moveCursorVertical(param int) error {
|
|
||||||
return h.moveCursor(vertical, param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) moveCursorHorizontal(param int) error {
|
|
||||||
return h.moveCursor(horizontal, param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) moveCursor(moveMode int, param int) error {
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
position := info.CursorPosition
|
|
||||||
switch moveMode {
|
|
||||||
case horizontal:
|
|
||||||
position.X += int16(param)
|
|
||||||
case vertical:
|
|
||||||
position.Y += int16(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
if err = h.setCursorPosition(position, h.getCursorWindow(info)); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) moveCursorLine(param int) error {
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
position := info.CursorPosition
|
|
||||||
position.X = 0
|
|
||||||
position.Y += int16(param)
|
|
||||||
|
|
||||||
if err = h.setCursorPosition(position, h.getCursorWindow(info)); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) moveCursorColumn(param int) error {
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
position := info.CursorPosition
|
|
||||||
position.X = int16(param) - 1
|
|
||||||
|
|
||||||
if err = h.setCursorPosition(position, h.getCursorWindow(info)); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,84 +0,0 @@
|
|||||||
// +build windows
|
|
||||||
|
|
||||||
package winterm
|
|
||||||
|
|
||||||
import "github.com/Azure/go-ansiterm"
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) clearRange(attributes uint16, fromCoord COORD, toCoord COORD) error {
|
|
||||||
// Ignore an invalid (negative area) request
|
|
||||||
if toCoord.Y < fromCoord.Y {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
var err error
|
|
||||||
|
|
||||||
var coordStart = COORD{}
|
|
||||||
var coordEnd = COORD{}
|
|
||||||
|
|
||||||
xCurrent, yCurrent := fromCoord.X, fromCoord.Y
|
|
||||||
xEnd, yEnd := toCoord.X, toCoord.Y
|
|
||||||
|
|
||||||
// Clear any partial initial line
|
|
||||||
if xCurrent > 0 {
|
|
||||||
coordStart.X, coordStart.Y = xCurrent, yCurrent
|
|
||||||
coordEnd.X, coordEnd.Y = xEnd, yCurrent
|
|
||||||
|
|
||||||
err = h.clearRect(attributes, coordStart, coordEnd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
xCurrent = 0
|
|
||||||
yCurrent += 1
|
|
||||||
}
|
|
||||||
|
|
||||||
// Clear intervening rectangular section
|
|
||||||
if yCurrent < yEnd {
|
|
||||||
coordStart.X, coordStart.Y = xCurrent, yCurrent
|
|
||||||
coordEnd.X, coordEnd.Y = xEnd, yEnd-1
|
|
||||||
|
|
||||||
err = h.clearRect(attributes, coordStart, coordEnd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
xCurrent = 0
|
|
||||||
yCurrent = yEnd
|
|
||||||
}
|
|
||||||
|
|
||||||
// Clear remaining partial ending line
|
|
||||||
coordStart.X, coordStart.Y = xCurrent, yCurrent
|
|
||||||
coordEnd.X, coordEnd.Y = xEnd, yEnd
|
|
||||||
|
|
||||||
err = h.clearRect(attributes, coordStart, coordEnd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) clearRect(attributes uint16, fromCoord COORD, toCoord COORD) error {
|
|
||||||
region := SMALL_RECT{Top: fromCoord.Y, Left: fromCoord.X, Bottom: toCoord.Y, Right: toCoord.X}
|
|
||||||
width := toCoord.X - fromCoord.X + 1
|
|
||||||
height := toCoord.Y - fromCoord.Y + 1
|
|
||||||
size := uint32(width) * uint32(height)
|
|
||||||
|
|
||||||
if size <= 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
buffer := make([]CHAR_INFO, size)
|
|
||||||
|
|
||||||
char := CHAR_INFO{ansiterm.FILL_CHARACTER, attributes}
|
|
||||||
for i := 0; i < int(size); i++ {
|
|
||||||
buffer[i] = char
|
|
||||||
}
|
|
||||||
|
|
||||||
err := WriteConsoleOutput(h.fd, buffer, COORD{X: width, Y: height}, COORD{X: 0, Y: 0}, ®ion)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,118 +0,0 @@
|
|||||||
// +build windows
|
|
||||||
|
|
||||||
package winterm
|
|
||||||
|
|
||||||
// effectiveSr gets the current effective scroll region in buffer coordinates
|
|
||||||
func (h *windowsAnsiEventHandler) effectiveSr(window SMALL_RECT) scrollRegion {
|
|
||||||
top := addInRange(window.Top, h.sr.top, window.Top, window.Bottom)
|
|
||||||
bottom := addInRange(window.Top, h.sr.bottom, window.Top, window.Bottom)
|
|
||||||
if top >= bottom {
|
|
||||||
top = window.Top
|
|
||||||
bottom = window.Bottom
|
|
||||||
}
|
|
||||||
return scrollRegion{top: top, bottom: bottom}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) scrollUp(param int) error {
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
sr := h.effectiveSr(info.Window)
|
|
||||||
return h.scroll(param, sr, info)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) scrollDown(param int) error {
|
|
||||||
return h.scrollUp(-param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) deleteLines(param int) error {
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
start := info.CursorPosition.Y
|
|
||||||
sr := h.effectiveSr(info.Window)
|
|
||||||
// Lines cannot be inserted or deleted outside the scrolling region.
|
|
||||||
if start >= sr.top && start <= sr.bottom {
|
|
||||||
sr.top = start
|
|
||||||
return h.scroll(param, sr, info)
|
|
||||||
} else {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) insertLines(param int) error {
|
|
||||||
return h.deleteLines(-param)
|
|
||||||
}
|
|
||||||
|
|
||||||
// scroll scrolls the provided scroll region by param lines. The scroll region is in buffer coordinates.
|
|
||||||
func (h *windowsAnsiEventHandler) scroll(param int, sr scrollRegion, info *CONSOLE_SCREEN_BUFFER_INFO) error {
|
|
||||||
h.logf("scroll: scrollTop: %d, scrollBottom: %d", sr.top, sr.bottom)
|
|
||||||
h.logf("scroll: windowTop: %d, windowBottom: %d", info.Window.Top, info.Window.Bottom)
|
|
||||||
|
|
||||||
// Copy from and clip to the scroll region (full buffer width)
|
|
||||||
scrollRect := SMALL_RECT{
|
|
||||||
Top: sr.top,
|
|
||||||
Bottom: sr.bottom,
|
|
||||||
Left: 0,
|
|
||||||
Right: info.Size.X - 1,
|
|
||||||
}
|
|
||||||
|
|
||||||
// Origin to which area should be copied
|
|
||||||
destOrigin := COORD{
|
|
||||||
X: 0,
|
|
||||||
Y: sr.top - int16(param),
|
|
||||||
}
|
|
||||||
|
|
||||||
char := CHAR_INFO{
|
|
||||||
UnicodeChar: ' ',
|
|
||||||
Attributes: h.attributes,
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := ScrollConsoleScreenBuffer(h.fd, scrollRect, scrollRect, destOrigin, char); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) deleteCharacters(param int) error {
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return h.scrollLine(param, info.CursorPosition, info)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) insertCharacters(param int) error {
|
|
||||||
return h.deleteCharacters(-param)
|
|
||||||
}
|
|
||||||
|
|
||||||
// scrollLine scrolls a line horizontally starting at the provided position by a number of columns.
|
|
||||||
func (h *windowsAnsiEventHandler) scrollLine(columns int, position COORD, info *CONSOLE_SCREEN_BUFFER_INFO) error {
|
|
||||||
// Copy from and clip to the scroll region (full buffer width)
|
|
||||||
scrollRect := SMALL_RECT{
|
|
||||||
Top: position.Y,
|
|
||||||
Bottom: position.Y,
|
|
||||||
Left: position.X,
|
|
||||||
Right: info.Size.X - 1,
|
|
||||||
}
|
|
||||||
|
|
||||||
// Origin to which area should be copied
|
|
||||||
destOrigin := COORD{
|
|
||||||
X: position.X - int16(columns),
|
|
||||||
Y: position.Y,
|
|
||||||
}
|
|
||||||
|
|
||||||
char := CHAR_INFO{
|
|
||||||
UnicodeChar: ' ',
|
|
||||||
Attributes: h.attributes,
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := ScrollConsoleScreenBuffer(h.fd, scrollRect, scrollRect, destOrigin, char); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,9 +0,0 @@
|
|||||||
// +build windows
|
|
||||||
|
|
||||||
package winterm
|
|
||||||
|
|
||||||
// AddInRange increments a value by the passed quantity while ensuring the values
|
|
||||||
// always remain within the supplied min / max range.
|
|
||||||
func addInRange(n int16, increment int16, min int16, max int16) int16 {
|
|
||||||
return ensureInRange(n+increment, min, max)
|
|
||||||
}
|
|
||||||
@ -1,743 +0,0 @@
|
|||||||
// +build windows
|
|
||||||
|
|
||||||
package winterm
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"log"
|
|
||||||
"os"
|
|
||||||
"strconv"
|
|
||||||
|
|
||||||
"github.com/Azure/go-ansiterm"
|
|
||||||
)
|
|
||||||
|
|
||||||
type windowsAnsiEventHandler struct {
|
|
||||||
fd uintptr
|
|
||||||
file *os.File
|
|
||||||
infoReset *CONSOLE_SCREEN_BUFFER_INFO
|
|
||||||
sr scrollRegion
|
|
||||||
buffer bytes.Buffer
|
|
||||||
attributes uint16
|
|
||||||
inverted bool
|
|
||||||
wrapNext bool
|
|
||||||
drewMarginByte bool
|
|
||||||
originMode bool
|
|
||||||
marginByte byte
|
|
||||||
curInfo *CONSOLE_SCREEN_BUFFER_INFO
|
|
||||||
curPos COORD
|
|
||||||
logf func(string, ...interface{})
|
|
||||||
}
|
|
||||||
|
|
||||||
type Option func(*windowsAnsiEventHandler)
|
|
||||||
|
|
||||||
func WithLogf(f func(string, ...interface{})) Option {
|
|
||||||
return func(w *windowsAnsiEventHandler) {
|
|
||||||
w.logf = f
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func CreateWinEventHandler(fd uintptr, file *os.File, opts ...Option) ansiterm.AnsiEventHandler {
|
|
||||||
infoReset, err := GetConsoleScreenBufferInfo(fd)
|
|
||||||
if err != nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
h := &windowsAnsiEventHandler{
|
|
||||||
fd: fd,
|
|
||||||
file: file,
|
|
||||||
infoReset: infoReset,
|
|
||||||
attributes: infoReset.Attributes,
|
|
||||||
}
|
|
||||||
for _, o := range opts {
|
|
||||||
o(h)
|
|
||||||
}
|
|
||||||
|
|
||||||
if isDebugEnv := os.Getenv(ansiterm.LogEnv); isDebugEnv == "1" {
|
|
||||||
logFile, _ := os.Create("winEventHandler.log")
|
|
||||||
logger := log.New(logFile, "", log.LstdFlags)
|
|
||||||
if h.logf != nil {
|
|
||||||
l := h.logf
|
|
||||||
h.logf = func(s string, v ...interface{}) {
|
|
||||||
l(s, v...)
|
|
||||||
logger.Printf(s, v...)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
h.logf = logger.Printf
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if h.logf == nil {
|
|
||||||
h.logf = func(string, ...interface{}) {}
|
|
||||||
}
|
|
||||||
|
|
||||||
return h
|
|
||||||
}
|
|
||||||
|
|
||||||
type scrollRegion struct {
|
|
||||||
top int16
|
|
||||||
bottom int16
|
|
||||||
}
|
|
||||||
|
|
||||||
// simulateLF simulates a LF or CR+LF by scrolling if necessary to handle the
|
|
||||||
// current cursor position and scroll region settings, in which case it returns
|
|
||||||
// true. If no special handling is necessary, then it does nothing and returns
|
|
||||||
// false.
|
|
||||||
//
|
|
||||||
// In the false case, the caller should ensure that a carriage return
|
|
||||||
// and line feed are inserted or that the text is otherwise wrapped.
|
|
||||||
func (h *windowsAnsiEventHandler) simulateLF(includeCR bool) (bool, error) {
|
|
||||||
if h.wrapNext {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
h.clearWrap()
|
|
||||||
}
|
|
||||||
pos, info, err := h.getCurrentInfo()
|
|
||||||
if err != nil {
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
sr := h.effectiveSr(info.Window)
|
|
||||||
if pos.Y == sr.bottom {
|
|
||||||
// Scrolling is necessary. Let Windows automatically scroll if the scrolling region
|
|
||||||
// is the full window.
|
|
||||||
if sr.top == info.Window.Top && sr.bottom == info.Window.Bottom {
|
|
||||||
if includeCR {
|
|
||||||
pos.X = 0
|
|
||||||
h.updatePos(pos)
|
|
||||||
}
|
|
||||||
return false, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// A custom scroll region is active. Scroll the window manually to simulate
|
|
||||||
// the LF.
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
h.logf("Simulating LF inside scroll region")
|
|
||||||
if err := h.scrollUp(1); err != nil {
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
if includeCR {
|
|
||||||
pos.X = 0
|
|
||||||
if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true, nil
|
|
||||||
|
|
||||||
} else if pos.Y < info.Window.Bottom {
|
|
||||||
// Let Windows handle the LF.
|
|
||||||
pos.Y++
|
|
||||||
if includeCR {
|
|
||||||
pos.X = 0
|
|
||||||
}
|
|
||||||
h.updatePos(pos)
|
|
||||||
return false, nil
|
|
||||||
} else {
|
|
||||||
// The cursor is at the bottom of the screen but outside the scroll
|
|
||||||
// region. Skip the LF.
|
|
||||||
h.logf("Simulating LF outside scroll region")
|
|
||||||
if includeCR {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
pos.X = 0
|
|
||||||
if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
|
|
||||||
return false, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// executeLF executes a LF without a CR.
|
|
||||||
func (h *windowsAnsiEventHandler) executeLF() error {
|
|
||||||
handled, err := h.simulateLF(false)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if !handled {
|
|
||||||
// Windows LF will reset the cursor column position. Write the LF
|
|
||||||
// and restore the cursor position.
|
|
||||||
pos, _, err := h.getCurrentInfo()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.buffer.WriteByte(ansiterm.ANSI_LINE_FEED)
|
|
||||||
if pos.X != 0 {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("Resetting cursor position for LF without CR")
|
|
||||||
if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) Print(b byte) error {
|
|
||||||
if h.wrapNext {
|
|
||||||
h.buffer.WriteByte(h.marginByte)
|
|
||||||
h.clearWrap()
|
|
||||||
if _, err := h.simulateLF(true); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
pos, info, err := h.getCurrentInfo()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if pos.X == info.Size.X-1 {
|
|
||||||
h.wrapNext = true
|
|
||||||
h.marginByte = b
|
|
||||||
} else {
|
|
||||||
pos.X++
|
|
||||||
h.updatePos(pos)
|
|
||||||
h.buffer.WriteByte(b)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) Execute(b byte) error {
|
|
||||||
switch b {
|
|
||||||
case ansiterm.ANSI_TAB:
|
|
||||||
h.logf("Execute(TAB)")
|
|
||||||
// Move to the next tab stop, but preserve auto-wrap if already set.
|
|
||||||
if !h.wrapNext {
|
|
||||||
pos, info, err := h.getCurrentInfo()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
pos.X = (pos.X + 8) - pos.X%8
|
|
||||||
if pos.X >= info.Size.X {
|
|
||||||
pos.X = info.Size.X - 1
|
|
||||||
}
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
|
|
||||||
case ansiterm.ANSI_BEL:
|
|
||||||
h.buffer.WriteByte(ansiterm.ANSI_BEL)
|
|
||||||
return nil
|
|
||||||
|
|
||||||
case ansiterm.ANSI_BACKSPACE:
|
|
||||||
if h.wrapNext {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.clearWrap()
|
|
||||||
}
|
|
||||||
pos, _, err := h.getCurrentInfo()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if pos.X > 0 {
|
|
||||||
pos.X--
|
|
||||||
h.updatePos(pos)
|
|
||||||
h.buffer.WriteByte(ansiterm.ANSI_BACKSPACE)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
|
|
||||||
case ansiterm.ANSI_VERTICAL_TAB, ansiterm.ANSI_FORM_FEED:
|
|
||||||
// Treat as true LF.
|
|
||||||
return h.executeLF()
|
|
||||||
|
|
||||||
case ansiterm.ANSI_LINE_FEED:
|
|
||||||
// Simulate a CR and LF for now since there is no way in go-ansiterm
|
|
||||||
// to tell if the LF should include CR (and more things break when it's
|
|
||||||
// missing than when it's incorrectly added).
|
|
||||||
handled, err := h.simulateLF(true)
|
|
||||||
if handled || err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return h.buffer.WriteByte(ansiterm.ANSI_LINE_FEED)
|
|
||||||
|
|
||||||
case ansiterm.ANSI_CARRIAGE_RETURN:
|
|
||||||
if h.wrapNext {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.clearWrap()
|
|
||||||
}
|
|
||||||
pos, _, err := h.getCurrentInfo()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if pos.X != 0 {
|
|
||||||
pos.X = 0
|
|
||||||
h.updatePos(pos)
|
|
||||||
h.buffer.WriteByte(ansiterm.ANSI_CARRIAGE_RETURN)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
|
|
||||||
default:
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) CUU(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("CUU: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
return h.moveCursorVertical(-param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) CUD(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("CUD: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
return h.moveCursorVertical(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) CUF(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("CUF: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
return h.moveCursorHorizontal(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) CUB(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("CUB: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
return h.moveCursorHorizontal(-param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) CNL(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("CNL: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
return h.moveCursorLine(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) CPL(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("CPL: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
return h.moveCursorLine(-param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) CHA(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("CHA: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
return h.moveCursorColumn(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) VPA(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("VPA: [[%d]]", param)
|
|
||||||
h.clearWrap()
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
window := h.getCursorWindow(info)
|
|
||||||
position := info.CursorPosition
|
|
||||||
position.Y = window.Top + int16(param) - 1
|
|
||||||
return h.setCursorPosition(position, window)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) CUP(row int, col int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("CUP: [[%d %d]]", row, col)
|
|
||||||
h.clearWrap()
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
window := h.getCursorWindow(info)
|
|
||||||
position := COORD{window.Left + int16(col) - 1, window.Top + int16(row) - 1}
|
|
||||||
return h.setCursorPosition(position, window)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) HVP(row int, col int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("HVP: [[%d %d]]", row, col)
|
|
||||||
h.clearWrap()
|
|
||||||
return h.CUP(row, col)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) DECTCEM(visible bool) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("DECTCEM: [%v]", []string{strconv.FormatBool(visible)})
|
|
||||||
h.clearWrap()
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) DECOM(enable bool) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("DECOM: [%v]", []string{strconv.FormatBool(enable)})
|
|
||||||
h.clearWrap()
|
|
||||||
h.originMode = enable
|
|
||||||
return h.CUP(1, 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) DECCOLM(use132 bool) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("DECCOLM: [%v]", []string{strconv.FormatBool(use132)})
|
|
||||||
h.clearWrap()
|
|
||||||
if err := h.ED(2); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
targetWidth := int16(80)
|
|
||||||
if use132 {
|
|
||||||
targetWidth = 132
|
|
||||||
}
|
|
||||||
if info.Size.X < targetWidth {
|
|
||||||
if err := SetConsoleScreenBufferSize(h.fd, COORD{targetWidth, info.Size.Y}); err != nil {
|
|
||||||
h.logf("set buffer failed: %v", err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
window := info.Window
|
|
||||||
window.Left = 0
|
|
||||||
window.Right = targetWidth - 1
|
|
||||||
if err := SetConsoleWindowInfo(h.fd, true, window); err != nil {
|
|
||||||
h.logf("set window failed: %v", err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if info.Size.X > targetWidth {
|
|
||||||
if err := SetConsoleScreenBufferSize(h.fd, COORD{targetWidth, info.Size.Y}); err != nil {
|
|
||||||
h.logf("set buffer failed: %v", err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return SetConsoleCursorPosition(h.fd, COORD{0, 0})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) ED(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("ED: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
|
|
||||||
// [J -- Erases from the cursor to the end of the screen, including the cursor position.
|
|
||||||
// [1J -- Erases from the beginning of the screen to the cursor, including the cursor position.
|
|
||||||
// [2J -- Erases the complete display. The cursor does not move.
|
|
||||||
// Notes:
|
|
||||||
// -- Clearing the entire buffer, versus just the Window, works best for Windows Consoles
|
|
||||||
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
var start COORD
|
|
||||||
var end COORD
|
|
||||||
|
|
||||||
switch param {
|
|
||||||
case 0:
|
|
||||||
start = info.CursorPosition
|
|
||||||
end = COORD{info.Size.X - 1, info.Size.Y - 1}
|
|
||||||
|
|
||||||
case 1:
|
|
||||||
start = COORD{0, 0}
|
|
||||||
end = info.CursorPosition
|
|
||||||
|
|
||||||
case 2:
|
|
||||||
start = COORD{0, 0}
|
|
||||||
end = COORD{info.Size.X - 1, info.Size.Y - 1}
|
|
||||||
}
|
|
||||||
|
|
||||||
err = h.clearRange(h.attributes, start, end)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the whole buffer was cleared, move the window to the top while preserving
|
|
||||||
// the window-relative cursor position.
|
|
||||||
if param == 2 {
|
|
||||||
pos := info.CursorPosition
|
|
||||||
window := info.Window
|
|
||||||
pos.Y -= window.Top
|
|
||||||
window.Bottom -= window.Top
|
|
||||||
window.Top = 0
|
|
||||||
if err := SetConsoleCursorPosition(h.fd, pos); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if err := SetConsoleWindowInfo(h.fd, true, window); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) EL(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("EL: [%v]", strconv.Itoa(param))
|
|
||||||
h.clearWrap()
|
|
||||||
|
|
||||||
// [K -- Erases from the cursor to the end of the line, including the cursor position.
|
|
||||||
// [1K -- Erases from the beginning of the line to the cursor, including the cursor position.
|
|
||||||
// [2K -- Erases the complete line.
|
|
||||||
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
var start COORD
|
|
||||||
var end COORD
|
|
||||||
|
|
||||||
switch param {
|
|
||||||
case 0:
|
|
||||||
start = info.CursorPosition
|
|
||||||
end = COORD{info.Size.X, info.CursorPosition.Y}
|
|
||||||
|
|
||||||
case 1:
|
|
||||||
start = COORD{0, info.CursorPosition.Y}
|
|
||||||
end = info.CursorPosition
|
|
||||||
|
|
||||||
case 2:
|
|
||||||
start = COORD{0, info.CursorPosition.Y}
|
|
||||||
end = COORD{info.Size.X, info.CursorPosition.Y}
|
|
||||||
}
|
|
||||||
|
|
||||||
err = h.clearRange(h.attributes, start, end)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) IL(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("IL: [%v]", strconv.Itoa(param))
|
|
||||||
h.clearWrap()
|
|
||||||
return h.insertLines(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) DL(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("DL: [%v]", strconv.Itoa(param))
|
|
||||||
h.clearWrap()
|
|
||||||
return h.deleteLines(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) ICH(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("ICH: [%v]", strconv.Itoa(param))
|
|
||||||
h.clearWrap()
|
|
||||||
return h.insertCharacters(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) DCH(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("DCH: [%v]", strconv.Itoa(param))
|
|
||||||
h.clearWrap()
|
|
||||||
return h.deleteCharacters(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) SGR(params []int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
strings := []string{}
|
|
||||||
for _, v := range params {
|
|
||||||
strings = append(strings, strconv.Itoa(v))
|
|
||||||
}
|
|
||||||
|
|
||||||
h.logf("SGR: [%v]", strings)
|
|
||||||
|
|
||||||
if len(params) <= 0 {
|
|
||||||
h.attributes = h.infoReset.Attributes
|
|
||||||
h.inverted = false
|
|
||||||
} else {
|
|
||||||
for _, attr := range params {
|
|
||||||
|
|
||||||
if attr == ansiterm.ANSI_SGR_RESET {
|
|
||||||
h.attributes = h.infoReset.Attributes
|
|
||||||
h.inverted = false
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
h.attributes, h.inverted = collectAnsiIntoWindowsAttributes(h.attributes, h.inverted, h.infoReset.Attributes, int16(attr))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
attributes := h.attributes
|
|
||||||
if h.inverted {
|
|
||||||
attributes = invertAttributes(attributes)
|
|
||||||
}
|
|
||||||
err := SetConsoleTextAttribute(h.fd, attributes)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) SU(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("SU: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
return h.scrollUp(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) SD(param int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("SD: [%v]", []string{strconv.Itoa(param)})
|
|
||||||
h.clearWrap()
|
|
||||||
return h.scrollDown(param)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) DA(params []string) error {
|
|
||||||
h.logf("DA: [%v]", params)
|
|
||||||
// DA cannot be implemented because it must send data on the VT100 input stream,
|
|
||||||
// which is not available to go-ansiterm.
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) DECSTBM(top int, bottom int) error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("DECSTBM: [%d, %d]", top, bottom)
|
|
||||||
|
|
||||||
// Windows is 0 indexed, Linux is 1 indexed
|
|
||||||
h.sr.top = int16(top - 1)
|
|
||||||
h.sr.bottom = int16(bottom - 1)
|
|
||||||
|
|
||||||
// This command also moves the cursor to the origin.
|
|
||||||
h.clearWrap()
|
|
||||||
return h.CUP(1, 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) RI() error {
|
|
||||||
if err := h.Flush(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.logf("RI: []")
|
|
||||||
h.clearWrap()
|
|
||||||
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
sr := h.effectiveSr(info.Window)
|
|
||||||
if info.CursorPosition.Y == sr.top {
|
|
||||||
return h.scrollDown(1)
|
|
||||||
}
|
|
||||||
|
|
||||||
return h.moveCursorVertical(-1)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) IND() error {
|
|
||||||
h.logf("IND: []")
|
|
||||||
return h.executeLF()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) Flush() error {
|
|
||||||
h.curInfo = nil
|
|
||||||
if h.buffer.Len() > 0 {
|
|
||||||
h.logf("Flush: [%s]", h.buffer.Bytes())
|
|
||||||
if _, err := h.buffer.WriteTo(h.file); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if h.wrapNext && !h.drewMarginByte {
|
|
||||||
h.logf("Flush: drawing margin byte '%c'", h.marginByte)
|
|
||||||
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
charInfo := []CHAR_INFO{{UnicodeChar: uint16(h.marginByte), Attributes: info.Attributes}}
|
|
||||||
size := COORD{1, 1}
|
|
||||||
position := COORD{0, 0}
|
|
||||||
region := SMALL_RECT{Left: info.CursorPosition.X, Top: info.CursorPosition.Y, Right: info.CursorPosition.X, Bottom: info.CursorPosition.Y}
|
|
||||||
if err := WriteConsoleOutput(h.fd, charInfo, size, position, ®ion); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
h.drewMarginByte = true
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// cacheConsoleInfo ensures that the current console screen information has been queried
|
|
||||||
// since the last call to Flush(). It must be called before accessing h.curInfo or h.curPos.
|
|
||||||
func (h *windowsAnsiEventHandler) getCurrentInfo() (COORD, *CONSOLE_SCREEN_BUFFER_INFO, error) {
|
|
||||||
if h.curInfo == nil {
|
|
||||||
info, err := GetConsoleScreenBufferInfo(h.fd)
|
|
||||||
if err != nil {
|
|
||||||
return COORD{}, nil, err
|
|
||||||
}
|
|
||||||
h.curInfo = info
|
|
||||||
h.curPos = info.CursorPosition
|
|
||||||
}
|
|
||||||
return h.curPos, h.curInfo, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (h *windowsAnsiEventHandler) updatePos(pos COORD) {
|
|
||||||
if h.curInfo == nil {
|
|
||||||
panic("failed to call getCurrentInfo before calling updatePos")
|
|
||||||
}
|
|
||||||
h.curPos = pos
|
|
||||||
}
|
|
||||||
|
|
||||||
// clearWrap clears the state where the cursor is in the margin
|
|
||||||
// waiting for the next character before wrapping the line. This must
|
|
||||||
// be done before most operations that act on the cursor.
|
|
||||||
func (h *windowsAnsiEventHandler) clearWrap() {
|
|
||||||
h.wrapNext = false
|
|
||||||
h.drewMarginByte = false
|
|
||||||
}
|
|
||||||
@ -1 +0,0 @@
|
|||||||
_fuzz/
|
|
||||||
@ -1,27 +0,0 @@
|
|||||||
run:
|
|
||||||
deadline: 2m
|
|
||||||
|
|
||||||
linters:
|
|
||||||
disable-all: true
|
|
||||||
enable:
|
|
||||||
- misspell
|
|
||||||
- govet
|
|
||||||
- staticcheck
|
|
||||||
- errcheck
|
|
||||||
- unparam
|
|
||||||
- ineffassign
|
|
||||||
- nakedret
|
|
||||||
- gocyclo
|
|
||||||
- dupl
|
|
||||||
- goimports
|
|
||||||
- revive
|
|
||||||
- gosec
|
|
||||||
- gosimple
|
|
||||||
- typecheck
|
|
||||||
- unused
|
|
||||||
|
|
||||||
linters-settings:
|
|
||||||
gofmt:
|
|
||||||
simplify: true
|
|
||||||
dupl:
|
|
||||||
threshold: 600
|
|
||||||
@ -1,214 +0,0 @@
|
|||||||
# Changelog
|
|
||||||
|
|
||||||
## 3.2.0 (2022-11-28)
|
|
||||||
|
|
||||||
### Added
|
|
||||||
|
|
||||||
- #190: Added text marshaling and unmarshaling
|
|
||||||
- #167: Added JSON marshalling for constraints (thanks @SimonTheLeg)
|
|
||||||
- #173: Implement encoding.TextMarshaler and encoding.TextUnmarshaler on Version (thanks @MarkRosemaker)
|
|
||||||
- #179: Added New() version constructor (thanks @kazhuravlev)
|
|
||||||
|
|
||||||
### Changed
|
|
||||||
|
|
||||||
- #182/#183: Updated CI testing setup
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #186: Fixing issue where validation of constraint section gave false positives
|
|
||||||
- #176: Fix constraints check with *-0 (thanks @mtt0)
|
|
||||||
- #181: Fixed Caret operator (^) gives unexpected results when the minor version in constraint is 0 (thanks @arshchimni)
|
|
||||||
- #161: Fixed godoc (thanks @afirth)
|
|
||||||
|
|
||||||
## 3.1.1 (2020-11-23)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #158: Fixed issue with generated regex operation order that could cause problem
|
|
||||||
|
|
||||||
## 3.1.0 (2020-04-15)
|
|
||||||
|
|
||||||
### Added
|
|
||||||
|
|
||||||
- #131: Add support for serializing/deserializing SQL (thanks @ryancurrah)
|
|
||||||
|
|
||||||
### Changed
|
|
||||||
|
|
||||||
- #148: More accurate validation messages on constraints
|
|
||||||
|
|
||||||
## 3.0.3 (2019-12-13)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #141: Fixed issue with <= comparison
|
|
||||||
|
|
||||||
## 3.0.2 (2019-11-14)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #134: Fixed broken constraint checking with ^0.0 (thanks @krmichelos)
|
|
||||||
|
|
||||||
## 3.0.1 (2019-09-13)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #125: Fixes issue with module path for v3
|
|
||||||
|
|
||||||
## 3.0.0 (2019-09-12)
|
|
||||||
|
|
||||||
This is a major release of the semver package which includes API changes. The Go
|
|
||||||
API is compatible with ^1. The Go API was not changed because many people are using
|
|
||||||
`go get` without Go modules for their applications and API breaking changes cause
|
|
||||||
errors which we have or would need to support.
|
|
||||||
|
|
||||||
The changes in this release are the handling based on the data passed into the
|
|
||||||
functions. These are described in the added and changed sections below.
|
|
||||||
|
|
||||||
### Added
|
|
||||||
|
|
||||||
- StrictNewVersion function. This is similar to NewVersion but will return an
|
|
||||||
error if the version passed in is not a strict semantic version. For example,
|
|
||||||
1.2.3 would pass but v1.2.3 or 1.2 would fail because they are not strictly
|
|
||||||
speaking semantic versions. This function is faster, performs fewer operations,
|
|
||||||
and uses fewer allocations than NewVersion.
|
|
||||||
- Fuzzing has been performed on NewVersion, StrictNewVersion, and NewConstraint.
|
|
||||||
The Makefile contains the operations used. For more information on you can start
|
|
||||||
on Wikipedia at https://en.wikipedia.org/wiki/Fuzzing
|
|
||||||
- Now using Go modules
|
|
||||||
|
|
||||||
### Changed
|
|
||||||
|
|
||||||
- NewVersion has proper prerelease and metadata validation with error messages
|
|
||||||
to signal an issue with either of them
|
|
||||||
- ^ now operates using a similar set of rules to npm/js and Rust/Cargo. If the
|
|
||||||
version is >=1 the ^ ranges works the same as v1. For major versions of 0 the
|
|
||||||
rules have changed. The minor version is treated as the stable version unless
|
|
||||||
a patch is specified and then it is equivalent to =. One difference from npm/js
|
|
||||||
is that prereleases there are only to a specific version (e.g. 1.2.3).
|
|
||||||
Prereleases here look over multiple versions and follow semantic version
|
|
||||||
ordering rules. This pattern now follows along with the expected and requested
|
|
||||||
handling of this packaged by numerous users.
|
|
||||||
|
|
||||||
## 1.5.0 (2019-09-11)
|
|
||||||
|
|
||||||
### Added
|
|
||||||
|
|
||||||
- #103: Add basic fuzzing for `NewVersion()` (thanks @jesse-c)
|
|
||||||
|
|
||||||
### Changed
|
|
||||||
|
|
||||||
- #82: Clarify wildcard meaning in range constraints and update tests for it (thanks @greysteil)
|
|
||||||
- #83: Clarify caret operator range for pre-1.0.0 dependencies (thanks @greysteil)
|
|
||||||
- #72: Adding docs comment pointing to vert for a cli
|
|
||||||
- #71: Update the docs on pre-release comparator handling
|
|
||||||
- #89: Test with new go versions (thanks @thedevsaddam)
|
|
||||||
- #87: Added $ to ValidPrerelease for better validation (thanks @jeremycarroll)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #78: Fix unchecked error in example code (thanks @ravron)
|
|
||||||
- #70: Fix the handling of pre-releases and the 0.0.0 release edge case
|
|
||||||
- #97: Fixed copyright file for proper display on GitHub
|
|
||||||
- #107: Fix handling prerelease when sorting alphanum and num
|
|
||||||
- #109: Fixed where Validate sometimes returns wrong message on error
|
|
||||||
|
|
||||||
## 1.4.2 (2018-04-10)
|
|
||||||
|
|
||||||
### Changed
|
|
||||||
|
|
||||||
- #72: Updated the docs to point to vert for a console appliaction
|
|
||||||
- #71: Update the docs on pre-release comparator handling
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #70: Fix the handling of pre-releases and the 0.0.0 release edge case
|
|
||||||
|
|
||||||
## 1.4.1 (2018-04-02)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- Fixed #64: Fix pre-release precedence issue (thanks @uudashr)
|
|
||||||
|
|
||||||
## 1.4.0 (2017-10-04)
|
|
||||||
|
|
||||||
### Changed
|
|
||||||
|
|
||||||
- #61: Update NewVersion to parse ints with a 64bit int size (thanks @zknill)
|
|
||||||
|
|
||||||
## 1.3.1 (2017-07-10)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- Fixed #57: number comparisons in prerelease sometimes inaccurate
|
|
||||||
|
|
||||||
## 1.3.0 (2017-05-02)
|
|
||||||
|
|
||||||
### Added
|
|
||||||
|
|
||||||
- #45: Added json (un)marshaling support (thanks @mh-cbon)
|
|
||||||
- Stability marker. See https://masterminds.github.io/stability/
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #51: Fix handling of single digit tilde constraint (thanks @dgodd)
|
|
||||||
|
|
||||||
### Changed
|
|
||||||
|
|
||||||
- #55: The godoc icon moved from png to svg
|
|
||||||
|
|
||||||
## 1.2.3 (2017-04-03)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #46: Fixed 0.x.x and 0.0.x in constraints being treated as *
|
|
||||||
|
|
||||||
## Release 1.2.2 (2016-12-13)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #34: Fixed issue where hyphen range was not working with pre-release parsing.
|
|
||||||
|
|
||||||
## Release 1.2.1 (2016-11-28)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- #24: Fixed edge case issue where constraint "> 0" does not handle "0.0.1-alpha"
|
|
||||||
properly.
|
|
||||||
|
|
||||||
## Release 1.2.0 (2016-11-04)
|
|
||||||
|
|
||||||
### Added
|
|
||||||
|
|
||||||
- #20: Added MustParse function for versions (thanks @adamreese)
|
|
||||||
- #15: Added increment methods on versions (thanks @mh-cbon)
|
|
||||||
|
|
||||||
### Fixed
|
|
||||||
|
|
||||||
- Issue #21: Per the SemVer spec (section 9) a pre-release is unstable and
|
|
||||||
might not satisfy the intended compatibility. The change here ignores pre-releases
|
|
||||||
on constraint checks (e.g., ~ or ^) when a pre-release is not part of the
|
|
||||||
constraint. For example, `^1.2.3` will ignore pre-releases while
|
|
||||||
`^1.2.3-alpha` will include them.
|
|
||||||
|
|
||||||
## Release 1.1.1 (2016-06-30)
|
|
||||||
|
|
||||||
### Changed
|
|
||||||
|
|
||||||
- Issue #9: Speed up version comparison performance (thanks @sdboyer)
|
|
||||||
- Issue #8: Added benchmarks (thanks @sdboyer)
|
|
||||||
- Updated Go Report Card URL to new location
|
|
||||||
- Updated Readme to add code snippet formatting (thanks @mh-cbon)
|
|
||||||
- Updating tagging to v[SemVer] structure for compatibility with other tools.
|
|
||||||
|
|
||||||
## Release 1.1.0 (2016-03-11)
|
|
||||||
|
|
||||||
- Issue #2: Implemented validation to provide reasons a versions failed a
|
|
||||||
constraint.
|
|
||||||
|
|
||||||
## Release 1.0.1 (2015-12-31)
|
|
||||||
|
|
||||||
- Fixed #1: * constraint failing on valid versions.
|
|
||||||
|
|
||||||
## Release 1.0.0 (2015-10-20)
|
|
||||||
|
|
||||||
- Initial release
|
|
||||||
@ -1,19 +0,0 @@
|
|||||||
Copyright (C) 2014-2019, Matt Butcher and Matt Farina
|
|
||||||
|
|
||||||
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.
|
|
||||||
@ -1,30 +0,0 @@
|
|||||||
GOPATH=$(shell go env GOPATH)
|
|
||||||
GOLANGCI_LINT=$(GOPATH)/bin/golangci-lint
|
|
||||||
|
|
||||||
.PHONY: lint
|
|
||||||
lint: $(GOLANGCI_LINT)
|
|
||||||
@echo "==> Linting codebase"
|
|
||||||
@$(GOLANGCI_LINT) run
|
|
||||||
|
|
||||||
.PHONY: test
|
|
||||||
test:
|
|
||||||
@echo "==> Running tests"
|
|
||||||
GO111MODULE=on go test -v
|
|
||||||
|
|
||||||
.PHONY: test-cover
|
|
||||||
test-cover:
|
|
||||||
@echo "==> Running Tests with coverage"
|
|
||||||
GO111MODULE=on go test -cover .
|
|
||||||
|
|
||||||
.PHONY: fuzz
|
|
||||||
fuzz:
|
|
||||||
@echo "==> Running Fuzz Tests"
|
|
||||||
go test -fuzz=FuzzNewVersion -fuzztime=15s .
|
|
||||||
go test -fuzz=FuzzStrictNewVersion -fuzztime=15s .
|
|
||||||
go test -fuzz=FuzzNewConstraint -fuzztime=15s .
|
|
||||||
|
|
||||||
$(GOLANGCI_LINT):
|
|
||||||
# Install golangci-lint. The configuration for it is in the .golangci.yml
|
|
||||||
# file in the root of the repository
|
|
||||||
echo ${GOPATH}
|
|
||||||
curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(GOPATH)/bin v1.17.1
|
|
||||||
@ -1,258 +0,0 @@
|
|||||||
# SemVer
|
|
||||||
|
|
||||||
The `semver` package provides the ability to work with [Semantic Versions](http://semver.org) in Go. Specifically it provides the ability to:
|
|
||||||
|
|
||||||
* Parse semantic versions
|
|
||||||
* Sort semantic versions
|
|
||||||
* Check if a semantic version fits within a set of constraints
|
|
||||||
* Optionally work with a `v` prefix
|
|
||||||
|
|
||||||
[](https://masterminds.github.io/stability/active.html)
|
|
||||||
[](https://github.com/Masterminds/semver/actions)
|
|
||||||
[](https://pkg.go.dev/github.com/Masterminds/semver/v3)
|
|
||||||
[](https://goreportcard.com/report/github.com/Masterminds/semver)
|
|
||||||
|
|
||||||
If you are looking for a command line tool for version comparisons please see
|
|
||||||
[vert](https://github.com/Masterminds/vert) which uses this library.
|
|
||||||
|
|
||||||
## Package Versions
|
|
||||||
|
|
||||||
Note, import `github.com/github.com/Masterminds/semver/v3` to use the latest version.
|
|
||||||
|
|
||||||
There are three major versions fo the `semver` package.
|
|
||||||
|
|
||||||
* 3.x.x is the stable and active version. This version is focused on constraint
|
|
||||||
compatibility for range handling in other tools from other languages. It has
|
|
||||||
a similar API to the v1 releases. The development of this version is on the master
|
|
||||||
branch. The documentation for this version is below.
|
|
||||||
* 2.x was developed primarily for [dep](https://github.com/golang/dep). There are
|
|
||||||
no tagged releases and the development was performed by [@sdboyer](https://github.com/sdboyer).
|
|
||||||
There are API breaking changes from v1. This version lives on the [2.x branch](https://github.com/Masterminds/semver/tree/2.x).
|
|
||||||
* 1.x.x is the original release. It is no longer maintained. You should use the
|
|
||||||
v3 release instead. You can read the documentation for the 1.x.x release
|
|
||||||
[here](https://github.com/Masterminds/semver/blob/release-1/README.md).
|
|
||||||
|
|
||||||
## Parsing Semantic Versions
|
|
||||||
|
|
||||||
There are two functions that can parse semantic versions. The `StrictNewVersion`
|
|
||||||
function only parses valid version 2 semantic versions as outlined in the
|
|
||||||
specification. The `NewVersion` function attempts to coerce a version into a
|
|
||||||
semantic version and parse it. For example, if there is a leading v or a version
|
|
||||||
listed without all 3 parts (e.g. `v1.2`) it will attempt to coerce it into a valid
|
|
||||||
semantic version (e.g., 1.2.0). In both cases a `Version` object is returned
|
|
||||||
that can be sorted, compared, and used in constraints.
|
|
||||||
|
|
||||||
When parsing a version an error is returned if there is an issue parsing the
|
|
||||||
version. For example,
|
|
||||||
|
|
||||||
v, err := semver.NewVersion("1.2.3-beta.1+build345")
|
|
||||||
|
|
||||||
The version object has methods to get the parts of the version, compare it to
|
|
||||||
other versions, convert the version back into a string, and get the original
|
|
||||||
string. Getting the original string is useful if the semantic version was coerced
|
|
||||||
into a valid form.
|
|
||||||
|
|
||||||
## Sorting Semantic Versions
|
|
||||||
|
|
||||||
A set of versions can be sorted using the `sort` package from the standard library.
|
|
||||||
For example,
|
|
||||||
|
|
||||||
```go
|
|
||||||
raw := []string{"1.2.3", "1.0", "1.3", "2", "0.4.2",}
|
|
||||||
vs := make([]*semver.Version, len(raw))
|
|
||||||
for i, r := range raw {
|
|
||||||
v, err := semver.NewVersion(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Errorf("Error parsing version: %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
vs[i] = v
|
|
||||||
}
|
|
||||||
|
|
||||||
sort.Sort(semver.Collection(vs))
|
|
||||||
```
|
|
||||||
|
|
||||||
## Checking Version Constraints
|
|
||||||
|
|
||||||
There are two methods for comparing versions. One uses comparison methods on
|
|
||||||
`Version` instances and the other uses `Constraints`. There are some important
|
|
||||||
differences to notes between these two methods of comparison.
|
|
||||||
|
|
||||||
1. When two versions are compared using functions such as `Compare`, `LessThan`,
|
|
||||||
and others it will follow the specification and always include prereleases
|
|
||||||
within the comparison. It will provide an answer that is valid with the
|
|
||||||
comparison section of the spec at https://semver.org/#spec-item-11
|
|
||||||
2. When constraint checking is used for checks or validation it will follow a
|
|
||||||
different set of rules that are common for ranges with tools like npm/js
|
|
||||||
and Rust/Cargo. This includes considering prereleases to be invalid if the
|
|
||||||
ranges does not include one. If you want to have it include pre-releases a
|
|
||||||
simple solution is to include `-0` in your range.
|
|
||||||
3. Constraint ranges can have some complex rules including the shorthand use of
|
|
||||||
~ and ^. For more details on those see the options below.
|
|
||||||
|
|
||||||
There are differences between the two methods or checking versions because the
|
|
||||||
comparison methods on `Version` follow the specification while comparison ranges
|
|
||||||
are not part of the specification. Different packages and tools have taken it
|
|
||||||
upon themselves to come up with range rules. This has resulted in differences.
|
|
||||||
For example, npm/js and Cargo/Rust follow similar patterns while PHP has a
|
|
||||||
different pattern for ^. The comparison features in this package follow the
|
|
||||||
npm/js and Cargo/Rust lead because applications using it have followed similar
|
|
||||||
patters with their versions.
|
|
||||||
|
|
||||||
Checking a version against version constraints is one of the most featureful
|
|
||||||
parts of the package.
|
|
||||||
|
|
||||||
```go
|
|
||||||
c, err := semver.NewConstraint(">= 1.2.3")
|
|
||||||
if err != nil {
|
|
||||||
// Handle constraint not being parsable.
|
|
||||||
}
|
|
||||||
|
|
||||||
v, err := semver.NewVersion("1.3")
|
|
||||||
if err != nil {
|
|
||||||
// Handle version not being parsable.
|
|
||||||
}
|
|
||||||
// Check if the version meets the constraints. The a variable will be true.
|
|
||||||
a := c.Check(v)
|
|
||||||
```
|
|
||||||
|
|
||||||
### Basic Comparisons
|
|
||||||
|
|
||||||
There are two elements to the comparisons. First, a comparison string is a list
|
|
||||||
of space or comma separated AND comparisons. These are then separated by || (OR)
|
|
||||||
comparisons. For example, `">= 1.2 < 3.0.0 || >= 4.2.3"` is looking for a
|
|
||||||
comparison that's greater than or equal to 1.2 and less than 3.0.0 or is
|
|
||||||
greater than or equal to 4.2.3.
|
|
||||||
|
|
||||||
The basic comparisons are:
|
|
||||||
|
|
||||||
* `=`: equal (aliased to no operator)
|
|
||||||
* `!=`: not equal
|
|
||||||
* `>`: greater than
|
|
||||||
* `<`: less than
|
|
||||||
* `>=`: greater than or equal to
|
|
||||||
* `<=`: less than or equal to
|
|
||||||
|
|
||||||
### Working With Prerelease Versions
|
|
||||||
|
|
||||||
Pre-releases, for those not familiar with them, are used for software releases
|
|
||||||
prior to stable or generally available releases. Examples of prereleases include
|
|
||||||
development, alpha, beta, and release candidate releases. A prerelease may be
|
|
||||||
a version such as `1.2.3-beta.1` while the stable release would be `1.2.3`. In the
|
|
||||||
order of precedence, prereleases come before their associated releases. In this
|
|
||||||
example `1.2.3-beta.1 < 1.2.3`.
|
|
||||||
|
|
||||||
According to the Semantic Version specification prereleases may not be
|
|
||||||
API compliant with their release counterpart. It says,
|
|
||||||
|
|
||||||
> A pre-release version indicates that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version.
|
|
||||||
|
|
||||||
SemVer comparisons using constraints without a prerelease comparator will skip
|
|
||||||
prerelease versions. For example, `>=1.2.3` will skip prereleases when looking
|
|
||||||
at a list of releases while `>=1.2.3-0` will evaluate and find prereleases.
|
|
||||||
|
|
||||||
The reason for the `0` as a pre-release version in the example comparison is
|
|
||||||
because pre-releases can only contain ASCII alphanumerics and hyphens (along with
|
|
||||||
`.` separators), per the spec. Sorting happens in ASCII sort order, again per the
|
|
||||||
spec. The lowest character is a `0` in ASCII sort order
|
|
||||||
(see an [ASCII Table](http://www.asciitable.com/))
|
|
||||||
|
|
||||||
Understanding ASCII sort ordering is important because A-Z comes before a-z. That
|
|
||||||
means `>=1.2.3-BETA` will return `1.2.3-alpha`. What you might expect from case
|
|
||||||
sensitivity doesn't apply here. This is due to ASCII sort ordering which is what
|
|
||||||
the spec specifies.
|
|
||||||
|
|
||||||
### Hyphen Range Comparisons
|
|
||||||
|
|
||||||
There are multiple methods to handle ranges and the first is hyphens ranges.
|
|
||||||
These look like:
|
|
||||||
|
|
||||||
* `1.2 - 1.4.5` which is equivalent to `>= 1.2 <= 1.4.5`
|
|
||||||
* `2.3.4 - 4.5` which is equivalent to `>= 2.3.4 <= 4.5`
|
|
||||||
|
|
||||||
### Wildcards In Comparisons
|
|
||||||
|
|
||||||
The `x`, `X`, and `*` characters can be used as a wildcard character. This works
|
|
||||||
for all comparison operators. When used on the `=` operator it falls
|
|
||||||
back to the patch level comparison (see tilde below). For example,
|
|
||||||
|
|
||||||
* `1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
|
|
||||||
* `>= 1.2.x` is equivalent to `>= 1.2.0`
|
|
||||||
* `<= 2.x` is equivalent to `< 3`
|
|
||||||
* `*` is equivalent to `>= 0.0.0`
|
|
||||||
|
|
||||||
### Tilde Range Comparisons (Patch)
|
|
||||||
|
|
||||||
The tilde (`~`) comparison operator is for patch level ranges when a minor
|
|
||||||
version is specified and major level changes when the minor number is missing.
|
|
||||||
For example,
|
|
||||||
|
|
||||||
* `~1.2.3` is equivalent to `>= 1.2.3, < 1.3.0`
|
|
||||||
* `~1` is equivalent to `>= 1, < 2`
|
|
||||||
* `~2.3` is equivalent to `>= 2.3, < 2.4`
|
|
||||||
* `~1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
|
|
||||||
* `~1.x` is equivalent to `>= 1, < 2`
|
|
||||||
|
|
||||||
### Caret Range Comparisons (Major)
|
|
||||||
|
|
||||||
The caret (`^`) comparison operator is for major level changes once a stable
|
|
||||||
(1.0.0) release has occurred. Prior to a 1.0.0 release the minor versions acts
|
|
||||||
as the API stability level. This is useful when comparisons of API versions as a
|
|
||||||
major change is API breaking. For example,
|
|
||||||
|
|
||||||
* `^1.2.3` is equivalent to `>= 1.2.3, < 2.0.0`
|
|
||||||
* `^1.2.x` is equivalent to `>= 1.2.0, < 2.0.0`
|
|
||||||
* `^2.3` is equivalent to `>= 2.3, < 3`
|
|
||||||
* `^2.x` is equivalent to `>= 2.0.0, < 3`
|
|
||||||
* `^0.2.3` is equivalent to `>=0.2.3 <0.3.0`
|
|
||||||
* `^0.2` is equivalent to `>=0.2.0 <0.3.0`
|
|
||||||
* `^0.0.3` is equivalent to `>=0.0.3 <0.0.4`
|
|
||||||
* `^0.0` is equivalent to `>=0.0.0 <0.1.0`
|
|
||||||
* `^0` is equivalent to `>=0.0.0 <1.0.0`
|
|
||||||
|
|
||||||
## Validation
|
|
||||||
|
|
||||||
In addition to testing a version against a constraint, a version can be validated
|
|
||||||
against a constraint. When validation fails a slice of errors containing why a
|
|
||||||
version didn't meet the constraint is returned. For example,
|
|
||||||
|
|
||||||
```go
|
|
||||||
c, err := semver.NewConstraint("<= 1.2.3, >= 1.4")
|
|
||||||
if err != nil {
|
|
||||||
// Handle constraint not being parseable.
|
|
||||||
}
|
|
||||||
|
|
||||||
v, err := semver.NewVersion("1.3")
|
|
||||||
if err != nil {
|
|
||||||
// Handle version not being parseable.
|
|
||||||
}
|
|
||||||
|
|
||||||
// Validate a version against a constraint.
|
|
||||||
a, msgs := c.Validate(v)
|
|
||||||
// a is false
|
|
||||||
for _, m := range msgs {
|
|
||||||
fmt.Println(m)
|
|
||||||
|
|
||||||
// Loops over the errors which would read
|
|
||||||
// "1.3 is greater than 1.2.3"
|
|
||||||
// "1.3 is less than 1.4"
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
## Contribute
|
|
||||||
|
|
||||||
If you find an issue or want to contribute please file an [issue](https://github.com/Masterminds/semver/issues)
|
|
||||||
or [create a pull request](https://github.com/Masterminds/semver/pulls).
|
|
||||||
|
|
||||||
## Security
|
|
||||||
|
|
||||||
Security is an important consideration for this project. The project currently
|
|
||||||
uses the following tools to help discover security issues:
|
|
||||||
|
|
||||||
* [CodeQL](https://github.com/Masterminds/semver)
|
|
||||||
* [gosec](https://github.com/securego/gosec)
|
|
||||||
* Daily Fuzz testing
|
|
||||||
|
|
||||||
If you believe you have found a security vulnerability you can privately disclose
|
|
||||||
it through the [GitHub security page](https://github.com/Masterminds/semver/security).
|
|
||||||
@ -1,19 +0,0 @@
|
|||||||
# Security Policy
|
|
||||||
|
|
||||||
## Supported Versions
|
|
||||||
|
|
||||||
The following versions of semver are currently supported:
|
|
||||||
|
|
||||||
| Version | Supported |
|
|
||||||
| ------- | ------------------ |
|
|
||||||
| 3.x | :white_check_mark: |
|
|
||||||
| 2.x | :x: |
|
|
||||||
| 1.x | :x: |
|
|
||||||
|
|
||||||
Fixes are only released for the latest minor version in the form of a patch release.
|
|
||||||
|
|
||||||
## Reporting a Vulnerability
|
|
||||||
|
|
||||||
You can privately disclose a vulnerability through GitHubs
|
|
||||||
[private vulnerability reporting](https://github.com/Masterminds/semver/security/advisories)
|
|
||||||
mechanism.
|
|
||||||
@ -1,24 +0,0 @@
|
|||||||
package semver
|
|
||||||
|
|
||||||
// Collection is a collection of Version instances and implements the sort
|
|
||||||
// interface. See the sort package for more details.
|
|
||||||
// https://golang.org/pkg/sort/
|
|
||||||
type Collection []*Version
|
|
||||||
|
|
||||||
// Len returns the length of a collection. The number of Version instances
|
|
||||||
// on the slice.
|
|
||||||
func (c Collection) Len() int {
|
|
||||||
return len(c)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Less is needed for the sort interface to compare two Version objects on the
|
|
||||||
// slice. If checks if one is less than the other.
|
|
||||||
func (c Collection) Less(i, j int) bool {
|
|
||||||
return c[i].LessThan(c[j])
|
|
||||||
}
|
|
||||||
|
|
||||||
// Swap is needed for the sort interface to replace the Version objects
|
|
||||||
// at two different positions in the slice.
|
|
||||||
func (c Collection) Swap(i, j int) {
|
|
||||||
c[i], c[j] = c[j], c[i]
|
|
||||||
}
|
|
||||||
@ -1,594 +0,0 @@
|
|||||||
package semver
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"regexp"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Constraints is one or more constraint that a semantic version can be
|
|
||||||
// checked against.
|
|
||||||
type Constraints struct {
|
|
||||||
constraints [][]*constraint
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewConstraint returns a Constraints instance that a Version instance can
|
|
||||||
// be checked against. If there is a parse error it will be returned.
|
|
||||||
func NewConstraint(c string) (*Constraints, error) {
|
|
||||||
|
|
||||||
// Rewrite - ranges into a comparison operation.
|
|
||||||
c = rewriteRange(c)
|
|
||||||
|
|
||||||
ors := strings.Split(c, "||")
|
|
||||||
or := make([][]*constraint, len(ors))
|
|
||||||
for k, v := range ors {
|
|
||||||
|
|
||||||
// TODO: Find a way to validate and fetch all the constraints in a simpler form
|
|
||||||
|
|
||||||
// Validate the segment
|
|
||||||
if !validConstraintRegex.MatchString(v) {
|
|
||||||
return nil, fmt.Errorf("improper constraint: %s", v)
|
|
||||||
}
|
|
||||||
|
|
||||||
cs := findConstraintRegex.FindAllString(v, -1)
|
|
||||||
if cs == nil {
|
|
||||||
cs = append(cs, v)
|
|
||||||
}
|
|
||||||
result := make([]*constraint, len(cs))
|
|
||||||
for i, s := range cs {
|
|
||||||
pc, err := parseConstraint(s)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
result[i] = pc
|
|
||||||
}
|
|
||||||
or[k] = result
|
|
||||||
}
|
|
||||||
|
|
||||||
o := &Constraints{constraints: or}
|
|
||||||
return o, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check tests if a version satisfies the constraints.
|
|
||||||
func (cs Constraints) Check(v *Version) bool {
|
|
||||||
// TODO(mattfarina): For v4 of this library consolidate the Check and Validate
|
|
||||||
// functions as the underlying functions make that possible now.
|
|
||||||
// loop over the ORs and check the inner ANDs
|
|
||||||
for _, o := range cs.constraints {
|
|
||||||
joy := true
|
|
||||||
for _, c := range o {
|
|
||||||
if check, _ := c.check(v); !check {
|
|
||||||
joy = false
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if joy {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
// Validate checks if a version satisfies a constraint. If not a slice of
|
|
||||||
// reasons for the failure are returned in addition to a bool.
|
|
||||||
func (cs Constraints) Validate(v *Version) (bool, []error) {
|
|
||||||
// loop over the ORs and check the inner ANDs
|
|
||||||
var e []error
|
|
||||||
|
|
||||||
// Capture the prerelease message only once. When it happens the first time
|
|
||||||
// this var is marked
|
|
||||||
var prerelesase bool
|
|
||||||
for _, o := range cs.constraints {
|
|
||||||
joy := true
|
|
||||||
for _, c := range o {
|
|
||||||
// Before running the check handle the case there the version is
|
|
||||||
// a prerelease and the check is not searching for prereleases.
|
|
||||||
if c.con.pre == "" && v.pre != "" {
|
|
||||||
if !prerelesase {
|
|
||||||
em := fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
|
|
||||||
e = append(e, em)
|
|
||||||
prerelesase = true
|
|
||||||
}
|
|
||||||
joy = false
|
|
||||||
|
|
||||||
} else {
|
|
||||||
|
|
||||||
if _, err := c.check(v); err != nil {
|
|
||||||
e = append(e, err)
|
|
||||||
joy = false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if joy {
|
|
||||||
return true, []error{}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return false, e
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cs Constraints) String() string {
|
|
||||||
buf := make([]string, len(cs.constraints))
|
|
||||||
var tmp bytes.Buffer
|
|
||||||
|
|
||||||
for k, v := range cs.constraints {
|
|
||||||
tmp.Reset()
|
|
||||||
vlen := len(v)
|
|
||||||
for kk, c := range v {
|
|
||||||
tmp.WriteString(c.string())
|
|
||||||
|
|
||||||
// Space separate the AND conditions
|
|
||||||
if vlen > 1 && kk < vlen-1 {
|
|
||||||
tmp.WriteString(" ")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
buf[k] = tmp.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
return strings.Join(buf, " || ")
|
|
||||||
}
|
|
||||||
|
|
||||||
// UnmarshalText implements the encoding.TextUnmarshaler interface.
|
|
||||||
func (cs *Constraints) UnmarshalText(text []byte) error {
|
|
||||||
temp, err := NewConstraint(string(text))
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
*cs = *temp
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// MarshalText implements the encoding.TextMarshaler interface.
|
|
||||||
func (cs Constraints) MarshalText() ([]byte, error) {
|
|
||||||
return []byte(cs.String()), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
var constraintOps map[string]cfunc
|
|
||||||
var constraintRegex *regexp.Regexp
|
|
||||||
var constraintRangeRegex *regexp.Regexp
|
|
||||||
|
|
||||||
// Used to find individual constraints within a multi-constraint string
|
|
||||||
var findConstraintRegex *regexp.Regexp
|
|
||||||
|
|
||||||
// Used to validate an segment of ANDs is valid
|
|
||||||
var validConstraintRegex *regexp.Regexp
|
|
||||||
|
|
||||||
const cvRegex string = `v?([0-9|x|X|\*]+)(\.[0-9|x|X|\*]+)?(\.[0-9|x|X|\*]+)?` +
|
|
||||||
`(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
|
|
||||||
`(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?`
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
constraintOps = map[string]cfunc{
|
|
||||||
"": constraintTildeOrEqual,
|
|
||||||
"=": constraintTildeOrEqual,
|
|
||||||
"!=": constraintNotEqual,
|
|
||||||
">": constraintGreaterThan,
|
|
||||||
"<": constraintLessThan,
|
|
||||||
">=": constraintGreaterThanEqual,
|
|
||||||
"=>": constraintGreaterThanEqual,
|
|
||||||
"<=": constraintLessThanEqual,
|
|
||||||
"=<": constraintLessThanEqual,
|
|
||||||
"~": constraintTilde,
|
|
||||||
"~>": constraintTilde,
|
|
||||||
"^": constraintCaret,
|
|
||||||
}
|
|
||||||
|
|
||||||
ops := `=||!=|>|<|>=|=>|<=|=<|~|~>|\^`
|
|
||||||
|
|
||||||
constraintRegex = regexp.MustCompile(fmt.Sprintf(
|
|
||||||
`^\s*(%s)\s*(%s)\s*$`,
|
|
||||||
ops,
|
|
||||||
cvRegex))
|
|
||||||
|
|
||||||
constraintRangeRegex = regexp.MustCompile(fmt.Sprintf(
|
|
||||||
`\s*(%s)\s+-\s+(%s)\s*`,
|
|
||||||
cvRegex, cvRegex))
|
|
||||||
|
|
||||||
findConstraintRegex = regexp.MustCompile(fmt.Sprintf(
|
|
||||||
`(%s)\s*(%s)`,
|
|
||||||
ops,
|
|
||||||
cvRegex))
|
|
||||||
|
|
||||||
// The first time a constraint shows up will look slightly different from
|
|
||||||
// future times it shows up due to a leading space or comma in a given
|
|
||||||
// string.
|
|
||||||
validConstraintRegex = regexp.MustCompile(fmt.Sprintf(
|
|
||||||
`^(\s*(%s)\s*(%s)\s*)((?:\s+|,\s*)(%s)\s*(%s)\s*)*$`,
|
|
||||||
ops,
|
|
||||||
cvRegex,
|
|
||||||
ops,
|
|
||||||
cvRegex))
|
|
||||||
}
|
|
||||||
|
|
||||||
// An individual constraint
|
|
||||||
type constraint struct {
|
|
||||||
// The version used in the constraint check. For example, if a constraint
|
|
||||||
// is '<= 2.0.0' the con a version instance representing 2.0.0.
|
|
||||||
con *Version
|
|
||||||
|
|
||||||
// The original parsed version (e.g., 4.x from != 4.x)
|
|
||||||
orig string
|
|
||||||
|
|
||||||
// The original operator for the constraint
|
|
||||||
origfunc string
|
|
||||||
|
|
||||||
// When an x is used as part of the version (e.g., 1.x)
|
|
||||||
minorDirty bool
|
|
||||||
dirty bool
|
|
||||||
patchDirty bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check if a version meets the constraint
|
|
||||||
func (c *constraint) check(v *Version) (bool, error) {
|
|
||||||
return constraintOps[c.origfunc](v, c)
|
|
||||||
}
|
|
||||||
|
|
||||||
// String prints an individual constraint into a string
|
|
||||||
func (c *constraint) string() string {
|
|
||||||
return c.origfunc + c.orig
|
|
||||||
}
|
|
||||||
|
|
||||||
type cfunc func(v *Version, c *constraint) (bool, error)
|
|
||||||
|
|
||||||
func parseConstraint(c string) (*constraint, error) {
|
|
||||||
if len(c) > 0 {
|
|
||||||
m := constraintRegex.FindStringSubmatch(c)
|
|
||||||
if m == nil {
|
|
||||||
return nil, fmt.Errorf("improper constraint: %s", c)
|
|
||||||
}
|
|
||||||
|
|
||||||
cs := &constraint{
|
|
||||||
orig: m[2],
|
|
||||||
origfunc: m[1],
|
|
||||||
}
|
|
||||||
|
|
||||||
ver := m[2]
|
|
||||||
minorDirty := false
|
|
||||||
patchDirty := false
|
|
||||||
dirty := false
|
|
||||||
if isX(m[3]) || m[3] == "" {
|
|
||||||
ver = fmt.Sprintf("0.0.0%s", m[6])
|
|
||||||
dirty = true
|
|
||||||
} else if isX(strings.TrimPrefix(m[4], ".")) || m[4] == "" {
|
|
||||||
minorDirty = true
|
|
||||||
dirty = true
|
|
||||||
ver = fmt.Sprintf("%s.0.0%s", m[3], m[6])
|
|
||||||
} else if isX(strings.TrimPrefix(m[5], ".")) || m[5] == "" {
|
|
||||||
dirty = true
|
|
||||||
patchDirty = true
|
|
||||||
ver = fmt.Sprintf("%s%s.0%s", m[3], m[4], m[6])
|
|
||||||
}
|
|
||||||
|
|
||||||
con, err := NewVersion(ver)
|
|
||||||
if err != nil {
|
|
||||||
|
|
||||||
// The constraintRegex should catch any regex parsing errors. So,
|
|
||||||
// we should never get here.
|
|
||||||
return nil, errors.New("constraint Parser Error")
|
|
||||||
}
|
|
||||||
|
|
||||||
cs.con = con
|
|
||||||
cs.minorDirty = minorDirty
|
|
||||||
cs.patchDirty = patchDirty
|
|
||||||
cs.dirty = dirty
|
|
||||||
|
|
||||||
return cs, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// The rest is the special case where an empty string was passed in which
|
|
||||||
// is equivalent to * or >=0.0.0
|
|
||||||
con, err := StrictNewVersion("0.0.0")
|
|
||||||
if err != nil {
|
|
||||||
|
|
||||||
// The constraintRegex should catch any regex parsing errors. So,
|
|
||||||
// we should never get here.
|
|
||||||
return nil, errors.New("constraint Parser Error")
|
|
||||||
}
|
|
||||||
|
|
||||||
cs := &constraint{
|
|
||||||
con: con,
|
|
||||||
orig: c,
|
|
||||||
origfunc: "",
|
|
||||||
minorDirty: false,
|
|
||||||
patchDirty: false,
|
|
||||||
dirty: true,
|
|
||||||
}
|
|
||||||
return cs, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Constraint functions
|
|
||||||
func constraintNotEqual(v *Version, c *constraint) (bool, error) {
|
|
||||||
if c.dirty {
|
|
||||||
|
|
||||||
// If there is a pre-release on the version but the constraint isn't looking
|
|
||||||
// for them assume that pre-releases are not compatible. See issue 21 for
|
|
||||||
// more details.
|
|
||||||
if v.Prerelease() != "" && c.con.Prerelease() == "" {
|
|
||||||
return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
|
|
||||||
}
|
|
||||||
|
|
||||||
if c.con.Major() != v.Major() {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
if c.con.Minor() != v.Minor() && !c.minorDirty {
|
|
||||||
return true, nil
|
|
||||||
} else if c.minorDirty {
|
|
||||||
return false, fmt.Errorf("%s is equal to %s", v, c.orig)
|
|
||||||
} else if c.con.Patch() != v.Patch() && !c.patchDirty {
|
|
||||||
return true, nil
|
|
||||||
} else if c.patchDirty {
|
|
||||||
// Need to handle prereleases if present
|
|
||||||
if v.Prerelease() != "" || c.con.Prerelease() != "" {
|
|
||||||
eq := comparePrerelease(v.Prerelease(), c.con.Prerelease()) != 0
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s is equal to %s", v, c.orig)
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s is equal to %s", v, c.orig)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
eq := v.Equal(c.con)
|
|
||||||
if eq {
|
|
||||||
return false, fmt.Errorf("%s is equal to %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func constraintGreaterThan(v *Version, c *constraint) (bool, error) {
|
|
||||||
|
|
||||||
// If there is a pre-release on the version but the constraint isn't looking
|
|
||||||
// for them assume that pre-releases are not compatible. See issue 21 for
|
|
||||||
// more details.
|
|
||||||
if v.Prerelease() != "" && c.con.Prerelease() == "" {
|
|
||||||
return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
|
|
||||||
}
|
|
||||||
|
|
||||||
var eq bool
|
|
||||||
|
|
||||||
if !c.dirty {
|
|
||||||
eq = v.Compare(c.con) == 1
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
if v.Major() > c.con.Major() {
|
|
||||||
return true, nil
|
|
||||||
} else if v.Major() < c.con.Major() {
|
|
||||||
return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
|
|
||||||
} else if c.minorDirty {
|
|
||||||
// This is a range case such as >11. When the version is something like
|
|
||||||
// 11.1.0 is it not > 11. For that we would need 12 or higher
|
|
||||||
return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
|
|
||||||
} else if c.patchDirty {
|
|
||||||
// This is for ranges such as >11.1. A version of 11.1.1 is not greater
|
|
||||||
// which one of 11.2.1 is greater
|
|
||||||
eq = v.Minor() > c.con.Minor()
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
// If we have gotten here we are not comparing pre-preleases and can use the
|
|
||||||
// Compare function to accomplish that.
|
|
||||||
eq = v.Compare(c.con) == 1
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
func constraintLessThan(v *Version, c *constraint) (bool, error) {
|
|
||||||
// If there is a pre-release on the version but the constraint isn't looking
|
|
||||||
// for them assume that pre-releases are not compatible. See issue 21 for
|
|
||||||
// more details.
|
|
||||||
if v.Prerelease() != "" && c.con.Prerelease() == "" {
|
|
||||||
return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
|
|
||||||
}
|
|
||||||
|
|
||||||
eq := v.Compare(c.con) < 0
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s is greater than or equal to %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
func constraintGreaterThanEqual(v *Version, c *constraint) (bool, error) {
|
|
||||||
|
|
||||||
// If there is a pre-release on the version but the constraint isn't looking
|
|
||||||
// for them assume that pre-releases are not compatible. See issue 21 for
|
|
||||||
// more details.
|
|
||||||
if v.Prerelease() != "" && c.con.Prerelease() == "" {
|
|
||||||
return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
|
|
||||||
}
|
|
||||||
|
|
||||||
eq := v.Compare(c.con) >= 0
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s is less than %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
func constraintLessThanEqual(v *Version, c *constraint) (bool, error) {
|
|
||||||
// If there is a pre-release on the version but the constraint isn't looking
|
|
||||||
// for them assume that pre-releases are not compatible. See issue 21 for
|
|
||||||
// more details.
|
|
||||||
if v.Prerelease() != "" && c.con.Prerelease() == "" {
|
|
||||||
return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
|
|
||||||
}
|
|
||||||
|
|
||||||
var eq bool
|
|
||||||
|
|
||||||
if !c.dirty {
|
|
||||||
eq = v.Compare(c.con) <= 0
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s is greater than %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
if v.Major() > c.con.Major() {
|
|
||||||
return false, fmt.Errorf("%s is greater than %s", v, c.orig)
|
|
||||||
} else if v.Major() == c.con.Major() && v.Minor() > c.con.Minor() && !c.minorDirty {
|
|
||||||
return false, fmt.Errorf("%s is greater than %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ~*, ~>* --> >= 0.0.0 (any)
|
|
||||||
// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0, <3.0.0
|
|
||||||
// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0, <2.1.0
|
|
||||||
// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0, <1.3.0
|
|
||||||
// ~1.2.3, ~>1.2.3 --> >=1.2.3, <1.3.0
|
|
||||||
// ~1.2.0, ~>1.2.0 --> >=1.2.0, <1.3.0
|
|
||||||
func constraintTilde(v *Version, c *constraint) (bool, error) {
|
|
||||||
// If there is a pre-release on the version but the constraint isn't looking
|
|
||||||
// for them assume that pre-releases are not compatible. See issue 21 for
|
|
||||||
// more details.
|
|
||||||
if v.Prerelease() != "" && c.con.Prerelease() == "" {
|
|
||||||
return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
|
|
||||||
}
|
|
||||||
|
|
||||||
if v.LessThan(c.con) {
|
|
||||||
return false, fmt.Errorf("%s is less than %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
// ~0.0.0 is a special case where all constraints are accepted. It's
|
|
||||||
// equivalent to >= 0.0.0.
|
|
||||||
if c.con.Major() == 0 && c.con.Minor() == 0 && c.con.Patch() == 0 &&
|
|
||||||
!c.minorDirty && !c.patchDirty {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if v.Major() != c.con.Major() {
|
|
||||||
return false, fmt.Errorf("%s does not have same major version as %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
if v.Minor() != c.con.Minor() && !c.minorDirty {
|
|
||||||
return false, fmt.Errorf("%s does not have same major and minor version as %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// When there is a .x (dirty) status it automatically opts in to ~. Otherwise
|
|
||||||
// it's a straight =
|
|
||||||
func constraintTildeOrEqual(v *Version, c *constraint) (bool, error) {
|
|
||||||
// If there is a pre-release on the version but the constraint isn't looking
|
|
||||||
// for them assume that pre-releases are not compatible. See issue 21 for
|
|
||||||
// more details.
|
|
||||||
if v.Prerelease() != "" && c.con.Prerelease() == "" {
|
|
||||||
return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
|
|
||||||
}
|
|
||||||
|
|
||||||
if c.dirty {
|
|
||||||
return constraintTilde(v, c)
|
|
||||||
}
|
|
||||||
|
|
||||||
eq := v.Equal(c.con)
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return false, fmt.Errorf("%s is not equal to %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
// ^* --> (any)
|
|
||||||
// ^1.2.3 --> >=1.2.3 <2.0.0
|
|
||||||
// ^1.2 --> >=1.2.0 <2.0.0
|
|
||||||
// ^1 --> >=1.0.0 <2.0.0
|
|
||||||
// ^0.2.3 --> >=0.2.3 <0.3.0
|
|
||||||
// ^0.2 --> >=0.2.0 <0.3.0
|
|
||||||
// ^0.0.3 --> >=0.0.3 <0.0.4
|
|
||||||
// ^0.0 --> >=0.0.0 <0.1.0
|
|
||||||
// ^0 --> >=0.0.0 <1.0.0
|
|
||||||
func constraintCaret(v *Version, c *constraint) (bool, error) {
|
|
||||||
// If there is a pre-release on the version but the constraint isn't looking
|
|
||||||
// for them assume that pre-releases are not compatible. See issue 21 for
|
|
||||||
// more details.
|
|
||||||
if v.Prerelease() != "" && c.con.Prerelease() == "" {
|
|
||||||
return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
|
|
||||||
}
|
|
||||||
|
|
||||||
// This less than handles prereleases
|
|
||||||
if v.LessThan(c.con) {
|
|
||||||
return false, fmt.Errorf("%s is less than %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
var eq bool
|
|
||||||
|
|
||||||
// ^ when the major > 0 is >=x.y.z < x+1
|
|
||||||
if c.con.Major() > 0 || c.minorDirty {
|
|
||||||
|
|
||||||
// ^ has to be within a major range for > 0. Everything less than was
|
|
||||||
// filtered out with the LessThan call above. This filters out those
|
|
||||||
// that greater but not within the same major range.
|
|
||||||
eq = v.Major() == c.con.Major()
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s does not have same major version as %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
// ^ when the major is 0 and minor > 0 is >=0.y.z < 0.y+1
|
|
||||||
if c.con.Major() == 0 && v.Major() > 0 {
|
|
||||||
return false, fmt.Errorf("%s does not have same major version as %s", v, c.orig)
|
|
||||||
}
|
|
||||||
// If the con Minor is > 0 it is not dirty
|
|
||||||
if c.con.Minor() > 0 || c.patchDirty {
|
|
||||||
eq = v.Minor() == c.con.Minor()
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s does not have same minor version as %s. Expected minor versions to match when constraint major version is 0", v, c.orig)
|
|
||||||
}
|
|
||||||
// ^ when the minor is 0 and minor > 0 is =0.0.z
|
|
||||||
if c.con.Minor() == 0 && v.Minor() > 0 {
|
|
||||||
return false, fmt.Errorf("%s does not have same minor version as %s", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
// At this point the major is 0 and the minor is 0 and not dirty. The patch
|
|
||||||
// is not dirty so we need to check if they are equal. If they are not equal
|
|
||||||
eq = c.con.Patch() == v.Patch()
|
|
||||||
if eq {
|
|
||||||
return true, nil
|
|
||||||
}
|
|
||||||
return false, fmt.Errorf("%s does not equal %s. Expect version and constraint to equal when major and minor versions are 0", v, c.orig)
|
|
||||||
}
|
|
||||||
|
|
||||||
func isX(x string) bool {
|
|
||||||
switch x {
|
|
||||||
case "x", "*", "X":
|
|
||||||
return true
|
|
||||||
default:
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func rewriteRange(i string) string {
|
|
||||||
m := constraintRangeRegex.FindAllStringSubmatch(i, -1)
|
|
||||||
if m == nil {
|
|
||||||
return i
|
|
||||||
}
|
|
||||||
o := i
|
|
||||||
for _, v := range m {
|
|
||||||
t := fmt.Sprintf(">= %s, <= %s ", v[1], v[11])
|
|
||||||
o = strings.Replace(o, v[0], t, 1)
|
|
||||||
}
|
|
||||||
|
|
||||||
return o
|
|
||||||
}
|
|
||||||
@ -1,184 +0,0 @@
|
|||||||
/*
|
|
||||||
Package semver provides the ability to work with Semantic Versions (http://semver.org) in Go.
|
|
||||||
|
|
||||||
Specifically it provides the ability to:
|
|
||||||
|
|
||||||
- Parse semantic versions
|
|
||||||
- Sort semantic versions
|
|
||||||
- Check if a semantic version fits within a set of constraints
|
|
||||||
- Optionally work with a `v` prefix
|
|
||||||
|
|
||||||
# Parsing Semantic Versions
|
|
||||||
|
|
||||||
There are two functions that can parse semantic versions. The `StrictNewVersion`
|
|
||||||
function only parses valid version 2 semantic versions as outlined in the
|
|
||||||
specification. The `NewVersion` function attempts to coerce a version into a
|
|
||||||
semantic version and parse it. For example, if there is a leading v or a version
|
|
||||||
listed without all 3 parts (e.g. 1.2) it will attempt to coerce it into a valid
|
|
||||||
semantic version (e.g., 1.2.0). In both cases a `Version` object is returned
|
|
||||||
that can be sorted, compared, and used in constraints.
|
|
||||||
|
|
||||||
When parsing a version an optional error can be returned if there is an issue
|
|
||||||
parsing the version. For example,
|
|
||||||
|
|
||||||
v, err := semver.NewVersion("1.2.3-beta.1+b345")
|
|
||||||
|
|
||||||
The version object has methods to get the parts of the version, compare it to
|
|
||||||
other versions, convert the version back into a string, and get the original
|
|
||||||
string. For more details please see the documentation
|
|
||||||
at https://godoc.org/github.com/Masterminds/semver.
|
|
||||||
|
|
||||||
# Sorting Semantic Versions
|
|
||||||
|
|
||||||
A set of versions can be sorted using the `sort` package from the standard library.
|
|
||||||
For example,
|
|
||||||
|
|
||||||
raw := []string{"1.2.3", "1.0", "1.3", "2", "0.4.2",}
|
|
||||||
vs := make([]*semver.Version, len(raw))
|
|
||||||
for i, r := range raw {
|
|
||||||
v, err := semver.NewVersion(r)
|
|
||||||
if err != nil {
|
|
||||||
t.Errorf("Error parsing version: %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
vs[i] = v
|
|
||||||
}
|
|
||||||
|
|
||||||
sort.Sort(semver.Collection(vs))
|
|
||||||
|
|
||||||
# Checking Version Constraints and Comparing Versions
|
|
||||||
|
|
||||||
There are two methods for comparing versions. One uses comparison methods on
|
|
||||||
`Version` instances and the other is using Constraints. There are some important
|
|
||||||
differences to notes between these two methods of comparison.
|
|
||||||
|
|
||||||
1. When two versions are compared using functions such as `Compare`, `LessThan`,
|
|
||||||
and others it will follow the specification and always include prereleases
|
|
||||||
within the comparison. It will provide an answer valid with the comparison
|
|
||||||
spec section at https://semver.org/#spec-item-11
|
|
||||||
2. When constraint checking is used for checks or validation it will follow a
|
|
||||||
different set of rules that are common for ranges with tools like npm/js
|
|
||||||
and Rust/Cargo. This includes considering prereleases to be invalid if the
|
|
||||||
ranges does not include on. If you want to have it include pre-releases a
|
|
||||||
simple solution is to include `-0` in your range.
|
|
||||||
3. Constraint ranges can have some complex rules including the shorthard use of
|
|
||||||
~ and ^. For more details on those see the options below.
|
|
||||||
|
|
||||||
There are differences between the two methods or checking versions because the
|
|
||||||
comparison methods on `Version` follow the specification while comparison ranges
|
|
||||||
are not part of the specification. Different packages and tools have taken it
|
|
||||||
upon themselves to come up with range rules. This has resulted in differences.
|
|
||||||
For example, npm/js and Cargo/Rust follow similar patterns which PHP has a
|
|
||||||
different pattern for ^. The comparison features in this package follow the
|
|
||||||
npm/js and Cargo/Rust lead because applications using it have followed similar
|
|
||||||
patters with their versions.
|
|
||||||
|
|
||||||
Checking a version against version constraints is one of the most featureful
|
|
||||||
parts of the package.
|
|
||||||
|
|
||||||
c, err := semver.NewConstraint(">= 1.2.3")
|
|
||||||
if err != nil {
|
|
||||||
// Handle constraint not being parsable.
|
|
||||||
}
|
|
||||||
|
|
||||||
v, err := semver.NewVersion("1.3")
|
|
||||||
if err != nil {
|
|
||||||
// Handle version not being parsable.
|
|
||||||
}
|
|
||||||
// Check if the version meets the constraints. The a variable will be true.
|
|
||||||
a := c.Check(v)
|
|
||||||
|
|
||||||
# Basic Comparisons
|
|
||||||
|
|
||||||
There are two elements to the comparisons. First, a comparison string is a list
|
|
||||||
of comma or space separated AND comparisons. These are then separated by || (OR)
|
|
||||||
comparisons. For example, `">= 1.2 < 3.0.0 || >= 4.2.3"` is looking for a
|
|
||||||
comparison that's greater than or equal to 1.2 and less than 3.0.0 or is
|
|
||||||
greater than or equal to 4.2.3. This can also be written as
|
|
||||||
`">= 1.2, < 3.0.0 || >= 4.2.3"`
|
|
||||||
|
|
||||||
The basic comparisons are:
|
|
||||||
|
|
||||||
- `=`: equal (aliased to no operator)
|
|
||||||
- `!=`: not equal
|
|
||||||
- `>`: greater than
|
|
||||||
- `<`: less than
|
|
||||||
- `>=`: greater than or equal to
|
|
||||||
- `<=`: less than or equal to
|
|
||||||
|
|
||||||
# Hyphen Range Comparisons
|
|
||||||
|
|
||||||
There are multiple methods to handle ranges and the first is hyphens ranges.
|
|
||||||
These look like:
|
|
||||||
|
|
||||||
- `1.2 - 1.4.5` which is equivalent to `>= 1.2, <= 1.4.5`
|
|
||||||
- `2.3.4 - 4.5` which is equivalent to `>= 2.3.4 <= 4.5`
|
|
||||||
|
|
||||||
# Wildcards In Comparisons
|
|
||||||
|
|
||||||
The `x`, `X`, and `*` characters can be used as a wildcard character. This works
|
|
||||||
for all comparison operators. When used on the `=` operator it falls
|
|
||||||
back to the tilde operation. For example,
|
|
||||||
|
|
||||||
- `1.2.x` is equivalent to `>= 1.2.0 < 1.3.0`
|
|
||||||
- `>= 1.2.x` is equivalent to `>= 1.2.0`
|
|
||||||
- `<= 2.x` is equivalent to `<= 3`
|
|
||||||
- `*` is equivalent to `>= 0.0.0`
|
|
||||||
|
|
||||||
Tilde Range Comparisons (Patch)
|
|
||||||
|
|
||||||
The tilde (`~`) comparison operator is for patch level ranges when a minor
|
|
||||||
version is specified and major level changes when the minor number is missing.
|
|
||||||
For example,
|
|
||||||
|
|
||||||
- `~1.2.3` is equivalent to `>= 1.2.3 < 1.3.0`
|
|
||||||
- `~1` is equivalent to `>= 1, < 2`
|
|
||||||
- `~2.3` is equivalent to `>= 2.3 < 2.4`
|
|
||||||
- `~1.2.x` is equivalent to `>= 1.2.0 < 1.3.0`
|
|
||||||
- `~1.x` is equivalent to `>= 1 < 2`
|
|
||||||
|
|
||||||
Caret Range Comparisons (Major)
|
|
||||||
|
|
||||||
The caret (`^`) comparison operator is for major level changes once a stable
|
|
||||||
(1.0.0) release has occurred. Prior to a 1.0.0 release the minor versions acts
|
|
||||||
as the API stability level. This is useful when comparisons of API versions as a
|
|
||||||
major change is API breaking. For example,
|
|
||||||
|
|
||||||
- `^1.2.3` is equivalent to `>= 1.2.3, < 2.0.0`
|
|
||||||
- `^1.2.x` is equivalent to `>= 1.2.0, < 2.0.0`
|
|
||||||
- `^2.3` is equivalent to `>= 2.3, < 3`
|
|
||||||
- `^2.x` is equivalent to `>= 2.0.0, < 3`
|
|
||||||
- `^0.2.3` is equivalent to `>=0.2.3 <0.3.0`
|
|
||||||
- `^0.2` is equivalent to `>=0.2.0 <0.3.0`
|
|
||||||
- `^0.0.3` is equivalent to `>=0.0.3 <0.0.4`
|
|
||||||
- `^0.0` is equivalent to `>=0.0.0 <0.1.0`
|
|
||||||
- `^0` is equivalent to `>=0.0.0 <1.0.0`
|
|
||||||
|
|
||||||
# Validation
|
|
||||||
|
|
||||||
In addition to testing a version against a constraint, a version can be validated
|
|
||||||
against a constraint. When validation fails a slice of errors containing why a
|
|
||||||
version didn't meet the constraint is returned. For example,
|
|
||||||
|
|
||||||
c, err := semver.NewConstraint("<= 1.2.3, >= 1.4")
|
|
||||||
if err != nil {
|
|
||||||
// Handle constraint not being parseable.
|
|
||||||
}
|
|
||||||
|
|
||||||
v, _ := semver.NewVersion("1.3")
|
|
||||||
if err != nil {
|
|
||||||
// Handle version not being parseable.
|
|
||||||
}
|
|
||||||
|
|
||||||
// Validate a version against a constraint.
|
|
||||||
a, msgs := c.Validate(v)
|
|
||||||
// a is false
|
|
||||||
for _, m := range msgs {
|
|
||||||
fmt.Println(m)
|
|
||||||
|
|
||||||
// Loops over the errors which would read
|
|
||||||
// "1.3 is greater than 1.2.3"
|
|
||||||
// "1.3 is less than 1.4"
|
|
||||||
}
|
|
||||||
*/
|
|
||||||
package semver
|
|
||||||
@ -1,639 +0,0 @@
|
|||||||
package semver
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"database/sql/driver"
|
|
||||||
"encoding/json"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"regexp"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
)
|
|
||||||
|
|
||||||
// The compiled version of the regex created at init() is cached here so it
|
|
||||||
// only needs to be created once.
|
|
||||||
var versionRegex *regexp.Regexp
|
|
||||||
|
|
||||||
var (
|
|
||||||
// ErrInvalidSemVer is returned a version is found to be invalid when
|
|
||||||
// being parsed.
|
|
||||||
ErrInvalidSemVer = errors.New("Invalid Semantic Version")
|
|
||||||
|
|
||||||
// ErrEmptyString is returned when an empty string is passed in for parsing.
|
|
||||||
ErrEmptyString = errors.New("Version string empty")
|
|
||||||
|
|
||||||
// ErrInvalidCharacters is returned when invalid characters are found as
|
|
||||||
// part of a version
|
|
||||||
ErrInvalidCharacters = errors.New("Invalid characters in version")
|
|
||||||
|
|
||||||
// ErrSegmentStartsZero is returned when a version segment starts with 0.
|
|
||||||
// This is invalid in SemVer.
|
|
||||||
ErrSegmentStartsZero = errors.New("Version segment starts with 0")
|
|
||||||
|
|
||||||
// ErrInvalidMetadata is returned when the metadata is an invalid format
|
|
||||||
ErrInvalidMetadata = errors.New("Invalid Metadata string")
|
|
||||||
|
|
||||||
// ErrInvalidPrerelease is returned when the pre-release is an invalid format
|
|
||||||
ErrInvalidPrerelease = errors.New("Invalid Prerelease string")
|
|
||||||
)
|
|
||||||
|
|
||||||
// semVerRegex is the regular expression used to parse a semantic version.
|
|
||||||
const semVerRegex string = `v?([0-9]+)(\.[0-9]+)?(\.[0-9]+)?` +
|
|
||||||
`(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
|
|
||||||
`(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?`
|
|
||||||
|
|
||||||
// Version represents a single semantic version.
|
|
||||||
type Version struct {
|
|
||||||
major, minor, patch uint64
|
|
||||||
pre string
|
|
||||||
metadata string
|
|
||||||
original string
|
|
||||||
}
|
|
||||||
|
|
||||||
func init() {
|
|
||||||
versionRegex = regexp.MustCompile("^" + semVerRegex + "$")
|
|
||||||
}
|
|
||||||
|
|
||||||
const (
|
|
||||||
num string = "0123456789"
|
|
||||||
allowed string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-" + num
|
|
||||||
)
|
|
||||||
|
|
||||||
// StrictNewVersion parses a given version and returns an instance of Version or
|
|
||||||
// an error if unable to parse the version. Only parses valid semantic versions.
|
|
||||||
// Performs checking that can find errors within the version.
|
|
||||||
// If you want to coerce a version such as 1 or 1.2 and parse it as the 1.x
|
|
||||||
// releases of semver did, use the NewVersion() function.
|
|
||||||
func StrictNewVersion(v string) (*Version, error) {
|
|
||||||
// Parsing here does not use RegEx in order to increase performance and reduce
|
|
||||||
// allocations.
|
|
||||||
|
|
||||||
if len(v) == 0 {
|
|
||||||
return nil, ErrEmptyString
|
|
||||||
}
|
|
||||||
|
|
||||||
// Split the parts into [0]major, [1]minor, and [2]patch,prerelease,build
|
|
||||||
parts := strings.SplitN(v, ".", 3)
|
|
||||||
if len(parts) != 3 {
|
|
||||||
return nil, ErrInvalidSemVer
|
|
||||||
}
|
|
||||||
|
|
||||||
sv := &Version{
|
|
||||||
original: v,
|
|
||||||
}
|
|
||||||
|
|
||||||
// check for prerelease or build metadata
|
|
||||||
var extra []string
|
|
||||||
if strings.ContainsAny(parts[2], "-+") {
|
|
||||||
// Start with the build metadata first as it needs to be on the right
|
|
||||||
extra = strings.SplitN(parts[2], "+", 2)
|
|
||||||
if len(extra) > 1 {
|
|
||||||
// build metadata found
|
|
||||||
sv.metadata = extra[1]
|
|
||||||
parts[2] = extra[0]
|
|
||||||
}
|
|
||||||
|
|
||||||
extra = strings.SplitN(parts[2], "-", 2)
|
|
||||||
if len(extra) > 1 {
|
|
||||||
// prerelease found
|
|
||||||
sv.pre = extra[1]
|
|
||||||
parts[2] = extra[0]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Validate the number segments are valid. This includes only having positive
|
|
||||||
// numbers and no leading 0's.
|
|
||||||
for _, p := range parts {
|
|
||||||
if !containsOnly(p, num) {
|
|
||||||
return nil, ErrInvalidCharacters
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(p) > 1 && p[0] == '0' {
|
|
||||||
return nil, ErrSegmentStartsZero
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Extract the major, minor, and patch elements onto the returned Version
|
|
||||||
var err error
|
|
||||||
sv.major, err = strconv.ParseUint(parts[0], 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
sv.minor, err = strconv.ParseUint(parts[1], 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
sv.patch, err = strconv.ParseUint(parts[2], 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// No prerelease or build metadata found so returning now as a fastpath.
|
|
||||||
if sv.pre == "" && sv.metadata == "" {
|
|
||||||
return sv, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if sv.pre != "" {
|
|
||||||
if err = validatePrerelease(sv.pre); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if sv.metadata != "" {
|
|
||||||
if err = validateMetadata(sv.metadata); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return sv, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewVersion parses a given version and returns an instance of Version or
|
|
||||||
// an error if unable to parse the version. If the version is SemVer-ish it
|
|
||||||
// attempts to convert it to SemVer. If you want to validate it was a strict
|
|
||||||
// semantic version at parse time see StrictNewVersion().
|
|
||||||
func NewVersion(v string) (*Version, error) {
|
|
||||||
m := versionRegex.FindStringSubmatch(v)
|
|
||||||
if m == nil {
|
|
||||||
return nil, ErrInvalidSemVer
|
|
||||||
}
|
|
||||||
|
|
||||||
sv := &Version{
|
|
||||||
metadata: m[8],
|
|
||||||
pre: m[5],
|
|
||||||
original: v,
|
|
||||||
}
|
|
||||||
|
|
||||||
var err error
|
|
||||||
sv.major, err = strconv.ParseUint(m[1], 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, fmt.Errorf("Error parsing version segment: %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if m[2] != "" {
|
|
||||||
sv.minor, err = strconv.ParseUint(strings.TrimPrefix(m[2], "."), 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, fmt.Errorf("Error parsing version segment: %s", err)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
sv.minor = 0
|
|
||||||
}
|
|
||||||
|
|
||||||
if m[3] != "" {
|
|
||||||
sv.patch, err = strconv.ParseUint(strings.TrimPrefix(m[3], "."), 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, fmt.Errorf("Error parsing version segment: %s", err)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
sv.patch = 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// Perform some basic due diligence on the extra parts to ensure they are
|
|
||||||
// valid.
|
|
||||||
|
|
||||||
if sv.pre != "" {
|
|
||||||
if err = validatePrerelease(sv.pre); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if sv.metadata != "" {
|
|
||||||
if err = validateMetadata(sv.metadata); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return sv, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// New creates a new instance of Version with each of the parts passed in as
|
|
||||||
// arguments instead of parsing a version string.
|
|
||||||
func New(major, minor, patch uint64, pre, metadata string) *Version {
|
|
||||||
v := Version{
|
|
||||||
major: major,
|
|
||||||
minor: minor,
|
|
||||||
patch: patch,
|
|
||||||
pre: pre,
|
|
||||||
metadata: metadata,
|
|
||||||
original: "",
|
|
||||||
}
|
|
||||||
|
|
||||||
v.original = v.String()
|
|
||||||
|
|
||||||
return &v
|
|
||||||
}
|
|
||||||
|
|
||||||
// MustParse parses a given version and panics on error.
|
|
||||||
func MustParse(v string) *Version {
|
|
||||||
sv, err := NewVersion(v)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
return sv
|
|
||||||
}
|
|
||||||
|
|
||||||
// String converts a Version object to a string.
|
|
||||||
// Note, if the original version contained a leading v this version will not.
|
|
||||||
// See the Original() method to retrieve the original value. Semantic Versions
|
|
||||||
// don't contain a leading v per the spec. Instead it's optional on
|
|
||||||
// implementation.
|
|
||||||
func (v Version) String() string {
|
|
||||||
var buf bytes.Buffer
|
|
||||||
|
|
||||||
fmt.Fprintf(&buf, "%d.%d.%d", v.major, v.minor, v.patch)
|
|
||||||
if v.pre != "" {
|
|
||||||
fmt.Fprintf(&buf, "-%s", v.pre)
|
|
||||||
}
|
|
||||||
if v.metadata != "" {
|
|
||||||
fmt.Fprintf(&buf, "+%s", v.metadata)
|
|
||||||
}
|
|
||||||
|
|
||||||
return buf.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
// Original returns the original value passed in to be parsed.
|
|
||||||
func (v *Version) Original() string {
|
|
||||||
return v.original
|
|
||||||
}
|
|
||||||
|
|
||||||
// Major returns the major version.
|
|
||||||
func (v Version) Major() uint64 {
|
|
||||||
return v.major
|
|
||||||
}
|
|
||||||
|
|
||||||
// Minor returns the minor version.
|
|
||||||
func (v Version) Minor() uint64 {
|
|
||||||
return v.minor
|
|
||||||
}
|
|
||||||
|
|
||||||
// Patch returns the patch version.
|
|
||||||
func (v Version) Patch() uint64 {
|
|
||||||
return v.patch
|
|
||||||
}
|
|
||||||
|
|
||||||
// Prerelease returns the pre-release version.
|
|
||||||
func (v Version) Prerelease() string {
|
|
||||||
return v.pre
|
|
||||||
}
|
|
||||||
|
|
||||||
// Metadata returns the metadata on the version.
|
|
||||||
func (v Version) Metadata() string {
|
|
||||||
return v.metadata
|
|
||||||
}
|
|
||||||
|
|
||||||
// originalVPrefix returns the original 'v' prefix if any.
|
|
||||||
func (v Version) originalVPrefix() string {
|
|
||||||
// Note, only lowercase v is supported as a prefix by the parser.
|
|
||||||
if v.original != "" && v.original[:1] == "v" {
|
|
||||||
return v.original[:1]
|
|
||||||
}
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
|
|
||||||
// IncPatch produces the next patch version.
|
|
||||||
// If the current version does not have prerelease/metadata information,
|
|
||||||
// it unsets metadata and prerelease values, increments patch number.
|
|
||||||
// If the current version has any of prerelease or metadata information,
|
|
||||||
// it unsets both values and keeps current patch value
|
|
||||||
func (v Version) IncPatch() Version {
|
|
||||||
vNext := v
|
|
||||||
// according to http://semver.org/#spec-item-9
|
|
||||||
// Pre-release versions have a lower precedence than the associated normal version.
|
|
||||||
// according to http://semver.org/#spec-item-10
|
|
||||||
// Build metadata SHOULD be ignored when determining version precedence.
|
|
||||||
if v.pre != "" {
|
|
||||||
vNext.metadata = ""
|
|
||||||
vNext.pre = ""
|
|
||||||
} else {
|
|
||||||
vNext.metadata = ""
|
|
||||||
vNext.pre = ""
|
|
||||||
vNext.patch = v.patch + 1
|
|
||||||
}
|
|
||||||
vNext.original = v.originalVPrefix() + "" + vNext.String()
|
|
||||||
return vNext
|
|
||||||
}
|
|
||||||
|
|
||||||
// IncMinor produces the next minor version.
|
|
||||||
// Sets patch to 0.
|
|
||||||
// Increments minor number.
|
|
||||||
// Unsets metadata.
|
|
||||||
// Unsets prerelease status.
|
|
||||||
func (v Version) IncMinor() Version {
|
|
||||||
vNext := v
|
|
||||||
vNext.metadata = ""
|
|
||||||
vNext.pre = ""
|
|
||||||
vNext.patch = 0
|
|
||||||
vNext.minor = v.minor + 1
|
|
||||||
vNext.original = v.originalVPrefix() + "" + vNext.String()
|
|
||||||
return vNext
|
|
||||||
}
|
|
||||||
|
|
||||||
// IncMajor produces the next major version.
|
|
||||||
// Sets patch to 0.
|
|
||||||
// Sets minor to 0.
|
|
||||||
// Increments major number.
|
|
||||||
// Unsets metadata.
|
|
||||||
// Unsets prerelease status.
|
|
||||||
func (v Version) IncMajor() Version {
|
|
||||||
vNext := v
|
|
||||||
vNext.metadata = ""
|
|
||||||
vNext.pre = ""
|
|
||||||
vNext.patch = 0
|
|
||||||
vNext.minor = 0
|
|
||||||
vNext.major = v.major + 1
|
|
||||||
vNext.original = v.originalVPrefix() + "" + vNext.String()
|
|
||||||
return vNext
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetPrerelease defines the prerelease value.
|
|
||||||
// Value must not include the required 'hyphen' prefix.
|
|
||||||
func (v Version) SetPrerelease(prerelease string) (Version, error) {
|
|
||||||
vNext := v
|
|
||||||
if len(prerelease) > 0 {
|
|
||||||
if err := validatePrerelease(prerelease); err != nil {
|
|
||||||
return vNext, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
vNext.pre = prerelease
|
|
||||||
vNext.original = v.originalVPrefix() + "" + vNext.String()
|
|
||||||
return vNext, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetMetadata defines metadata value.
|
|
||||||
// Value must not include the required 'plus' prefix.
|
|
||||||
func (v Version) SetMetadata(metadata string) (Version, error) {
|
|
||||||
vNext := v
|
|
||||||
if len(metadata) > 0 {
|
|
||||||
if err := validateMetadata(metadata); err != nil {
|
|
||||||
return vNext, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
vNext.metadata = metadata
|
|
||||||
vNext.original = v.originalVPrefix() + "" + vNext.String()
|
|
||||||
return vNext, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// LessThan tests if one version is less than another one.
|
|
||||||
func (v *Version) LessThan(o *Version) bool {
|
|
||||||
return v.Compare(o) < 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// GreaterThan tests if one version is greater than another one.
|
|
||||||
func (v *Version) GreaterThan(o *Version) bool {
|
|
||||||
return v.Compare(o) > 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// Equal tests if two versions are equal to each other.
|
|
||||||
// Note, versions can be equal with different metadata since metadata
|
|
||||||
// is not considered part of the comparable version.
|
|
||||||
func (v *Version) Equal(o *Version) bool {
|
|
||||||
return v.Compare(o) == 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// Compare compares this version to another one. It returns -1, 0, or 1 if
|
|
||||||
// the version smaller, equal, or larger than the other version.
|
|
||||||
//
|
|
||||||
// Versions are compared by X.Y.Z. Build metadata is ignored. Prerelease is
|
|
||||||
// lower than the version without a prerelease. Compare always takes into account
|
|
||||||
// prereleases. If you want to work with ranges using typical range syntaxes that
|
|
||||||
// skip prereleases if the range is not looking for them use constraints.
|
|
||||||
func (v *Version) Compare(o *Version) int {
|
|
||||||
// Compare the major, minor, and patch version for differences. If a
|
|
||||||
// difference is found return the comparison.
|
|
||||||
if d := compareSegment(v.Major(), o.Major()); d != 0 {
|
|
||||||
return d
|
|
||||||
}
|
|
||||||
if d := compareSegment(v.Minor(), o.Minor()); d != 0 {
|
|
||||||
return d
|
|
||||||
}
|
|
||||||
if d := compareSegment(v.Patch(), o.Patch()); d != 0 {
|
|
||||||
return d
|
|
||||||
}
|
|
||||||
|
|
||||||
// At this point the major, minor, and patch versions are the same.
|
|
||||||
ps := v.pre
|
|
||||||
po := o.Prerelease()
|
|
||||||
|
|
||||||
if ps == "" && po == "" {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
if ps == "" {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
if po == "" {
|
|
||||||
return -1
|
|
||||||
}
|
|
||||||
|
|
||||||
return comparePrerelease(ps, po)
|
|
||||||
}
|
|
||||||
|
|
||||||
// UnmarshalJSON implements JSON.Unmarshaler interface.
|
|
||||||
func (v *Version) UnmarshalJSON(b []byte) error {
|
|
||||||
var s string
|
|
||||||
if err := json.Unmarshal(b, &s); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
temp, err := NewVersion(s)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
v.major = temp.major
|
|
||||||
v.minor = temp.minor
|
|
||||||
v.patch = temp.patch
|
|
||||||
v.pre = temp.pre
|
|
||||||
v.metadata = temp.metadata
|
|
||||||
v.original = temp.original
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// MarshalJSON implements JSON.Marshaler interface.
|
|
||||||
func (v Version) MarshalJSON() ([]byte, error) {
|
|
||||||
return json.Marshal(v.String())
|
|
||||||
}
|
|
||||||
|
|
||||||
// UnmarshalText implements the encoding.TextUnmarshaler interface.
|
|
||||||
func (v *Version) UnmarshalText(text []byte) error {
|
|
||||||
temp, err := NewVersion(string(text))
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
*v = *temp
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// MarshalText implements the encoding.TextMarshaler interface.
|
|
||||||
func (v Version) MarshalText() ([]byte, error) {
|
|
||||||
return []byte(v.String()), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Scan implements the SQL.Scanner interface.
|
|
||||||
func (v *Version) Scan(value interface{}) error {
|
|
||||||
var s string
|
|
||||||
s, _ = value.(string)
|
|
||||||
temp, err := NewVersion(s)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
v.major = temp.major
|
|
||||||
v.minor = temp.minor
|
|
||||||
v.patch = temp.patch
|
|
||||||
v.pre = temp.pre
|
|
||||||
v.metadata = temp.metadata
|
|
||||||
v.original = temp.original
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Value implements the Driver.Valuer interface.
|
|
||||||
func (v Version) Value() (driver.Value, error) {
|
|
||||||
return v.String(), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func compareSegment(v, o uint64) int {
|
|
||||||
if v < o {
|
|
||||||
return -1
|
|
||||||
}
|
|
||||||
if v > o {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func comparePrerelease(v, o string) int {
|
|
||||||
// split the prelease versions by their part. The separator, per the spec,
|
|
||||||
// is a .
|
|
||||||
sparts := strings.Split(v, ".")
|
|
||||||
oparts := strings.Split(o, ".")
|
|
||||||
|
|
||||||
// Find the longer length of the parts to know how many loop iterations to
|
|
||||||
// go through.
|
|
||||||
slen := len(sparts)
|
|
||||||
olen := len(oparts)
|
|
||||||
|
|
||||||
l := slen
|
|
||||||
if olen > slen {
|
|
||||||
l = olen
|
|
||||||
}
|
|
||||||
|
|
||||||
// Iterate over each part of the prereleases to compare the differences.
|
|
||||||
for i := 0; i < l; i++ {
|
|
||||||
// Since the lentgh of the parts can be different we need to create
|
|
||||||
// a placeholder. This is to avoid out of bounds issues.
|
|
||||||
stemp := ""
|
|
||||||
if i < slen {
|
|
||||||
stemp = sparts[i]
|
|
||||||
}
|
|
||||||
|
|
||||||
otemp := ""
|
|
||||||
if i < olen {
|
|
||||||
otemp = oparts[i]
|
|
||||||
}
|
|
||||||
|
|
||||||
d := comparePrePart(stemp, otemp)
|
|
||||||
if d != 0 {
|
|
||||||
return d
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Reaching here means two versions are of equal value but have different
|
|
||||||
// metadata (the part following a +). They are not identical in string form
|
|
||||||
// but the version comparison finds them to be equal.
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
func comparePrePart(s, o string) int {
|
|
||||||
// Fastpath if they are equal
|
|
||||||
if s == o {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
// When s or o are empty we can use the other in an attempt to determine
|
|
||||||
// the response.
|
|
||||||
if s == "" {
|
|
||||||
if o != "" {
|
|
||||||
return -1
|
|
||||||
}
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
|
|
||||||
if o == "" {
|
|
||||||
if s != "" {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
return -1
|
|
||||||
}
|
|
||||||
|
|
||||||
// When comparing strings "99" is greater than "103". To handle
|
|
||||||
// cases like this we need to detect numbers and compare them. According
|
|
||||||
// to the semver spec, numbers are always positive. If there is a - at the
|
|
||||||
// start like -99 this is to be evaluated as an alphanum. numbers always
|
|
||||||
// have precedence over alphanum. Parsing as Uints because negative numbers
|
|
||||||
// are ignored.
|
|
||||||
|
|
||||||
oi, n1 := strconv.ParseUint(o, 10, 64)
|
|
||||||
si, n2 := strconv.ParseUint(s, 10, 64)
|
|
||||||
|
|
||||||
// The case where both are strings compare the strings
|
|
||||||
if n1 != nil && n2 != nil {
|
|
||||||
if s > o {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
return -1
|
|
||||||
} else if n1 != nil {
|
|
||||||
// o is a string and s is a number
|
|
||||||
return -1
|
|
||||||
} else if n2 != nil {
|
|
||||||
// s is a string and o is a number
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
// Both are numbers
|
|
||||||
if si > oi {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
return -1
|
|
||||||
}
|
|
||||||
|
|
||||||
// Like strings.ContainsAny but does an only instead of any.
|
|
||||||
func containsOnly(s string, comp string) bool {
|
|
||||||
return strings.IndexFunc(s, func(r rune) bool {
|
|
||||||
return !strings.ContainsRune(comp, r)
|
|
||||||
}) == -1
|
|
||||||
}
|
|
||||||
|
|
||||||
// From the spec, "Identifiers MUST comprise only
|
|
||||||
// ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty.
|
|
||||||
// Numeric identifiers MUST NOT include leading zeroes.". These segments can
|
|
||||||
// be dot separated.
|
|
||||||
func validatePrerelease(p string) error {
|
|
||||||
eparts := strings.Split(p, ".")
|
|
||||||
for _, p := range eparts {
|
|
||||||
if containsOnly(p, num) {
|
|
||||||
if len(p) > 1 && p[0] == '0' {
|
|
||||||
return ErrSegmentStartsZero
|
|
||||||
}
|
|
||||||
} else if !containsOnly(p, allowed) {
|
|
||||||
return ErrInvalidPrerelease
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// From the spec, "Build metadata MAY be denoted by
|
|
||||||
// appending a plus sign and a series of dot separated identifiers immediately
|
|
||||||
// following the patch or pre-release version. Identifiers MUST comprise only
|
|
||||||
// ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty."
|
|
||||||
func validateMetadata(m string) error {
|
|
||||||
eparts := strings.Split(m, ".")
|
|
||||||
for _, p := range eparts {
|
|
||||||
if !containsOnly(p, allowed) {
|
|
||||||
return ErrInvalidMetadata
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1 +0,0 @@
|
|||||||
* text=auto eol=lf
|
|
||||||
@ -1,10 +0,0 @@
|
|||||||
.vscode/
|
|
||||||
|
|
||||||
*.exe
|
|
||||||
|
|
||||||
# testing
|
|
||||||
testdata
|
|
||||||
|
|
||||||
# go workspaces
|
|
||||||
go.work
|
|
||||||
go.work.sum
|
|
||||||
@ -1,149 +0,0 @@
|
|||||||
run:
|
|
||||||
skip-dirs:
|
|
||||||
- pkg/etw/sample
|
|
||||||
|
|
||||||
linters:
|
|
||||||
enable:
|
|
||||||
# style
|
|
||||||
- containedctx # struct contains a context
|
|
||||||
- dupl # duplicate code
|
|
||||||
- errname # erorrs are named correctly
|
|
||||||
- nolintlint # "//nolint" directives are properly explained
|
|
||||||
- revive # golint replacement
|
|
||||||
- unconvert # unnecessary conversions
|
|
||||||
- wastedassign
|
|
||||||
|
|
||||||
# bugs, performance, unused, etc ...
|
|
||||||
- contextcheck # function uses a non-inherited context
|
|
||||||
- errorlint # errors not wrapped for 1.13
|
|
||||||
- exhaustive # check exhaustiveness of enum switch statements
|
|
||||||
- gofmt # files are gofmt'ed
|
|
||||||
- gosec # security
|
|
||||||
- nilerr # returns nil even with non-nil error
|
|
||||||
- unparam # unused function params
|
|
||||||
|
|
||||||
issues:
|
|
||||||
exclude-rules:
|
|
||||||
# err is very often shadowed in nested scopes
|
|
||||||
- linters:
|
|
||||||
- govet
|
|
||||||
text: '^shadow: declaration of "err" shadows declaration'
|
|
||||||
|
|
||||||
# ignore long lines for skip autogen directives
|
|
||||||
- linters:
|
|
||||||
- revive
|
|
||||||
text: "^line-length-limit: "
|
|
||||||
source: "^//(go:generate|sys) "
|
|
||||||
|
|
||||||
#TODO: remove after upgrading to go1.18
|
|
||||||
# ignore comment spacing for nolint and sys directives
|
|
||||||
- linters:
|
|
||||||
- revive
|
|
||||||
text: "^comment-spacings: no space between comment delimiter and comment text"
|
|
||||||
source: "//(cspell:|nolint:|sys |todo)"
|
|
||||||
|
|
||||||
# not on go 1.18 yet, so no any
|
|
||||||
- linters:
|
|
||||||
- revive
|
|
||||||
text: "^use-any: since GO 1.18 'interface{}' can be replaced by 'any'"
|
|
||||||
|
|
||||||
# allow unjustified ignores of error checks in defer statements
|
|
||||||
- linters:
|
|
||||||
- nolintlint
|
|
||||||
text: "^directive `//nolint:errcheck` should provide explanation"
|
|
||||||
source: '^\s*defer '
|
|
||||||
|
|
||||||
# allow unjustified ignores of error lints for io.EOF
|
|
||||||
- linters:
|
|
||||||
- nolintlint
|
|
||||||
text: "^directive `//nolint:errorlint` should provide explanation"
|
|
||||||
source: '[=|!]= io.EOF'
|
|
||||||
|
|
||||||
|
|
||||||
linters-settings:
|
|
||||||
exhaustive:
|
|
||||||
default-signifies-exhaustive: true
|
|
||||||
govet:
|
|
||||||
enable-all: true
|
|
||||||
disable:
|
|
||||||
# struct order is often for Win32 compat
|
|
||||||
# also, ignore pointer bytes/GC issues for now until performance becomes an issue
|
|
||||||
- fieldalignment
|
|
||||||
check-shadowing: true
|
|
||||||
nolintlint:
|
|
||||||
allow-leading-space: false
|
|
||||||
require-explanation: true
|
|
||||||
require-specific: true
|
|
||||||
revive:
|
|
||||||
# revive is more configurable than static check, so likely the preferred alternative to static-check
|
|
||||||
# (once the perf issue is solved: https://github.com/golangci/golangci-lint/issues/2997)
|
|
||||||
enable-all-rules:
|
|
||||||
true
|
|
||||||
# https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md
|
|
||||||
rules:
|
|
||||||
# rules with required arguments
|
|
||||||
- name: argument-limit
|
|
||||||
disabled: true
|
|
||||||
- name: banned-characters
|
|
||||||
disabled: true
|
|
||||||
- name: cognitive-complexity
|
|
||||||
disabled: true
|
|
||||||
- name: cyclomatic
|
|
||||||
disabled: true
|
|
||||||
- name: file-header
|
|
||||||
disabled: true
|
|
||||||
- name: function-length
|
|
||||||
disabled: true
|
|
||||||
- name: function-result-limit
|
|
||||||
disabled: true
|
|
||||||
- name: max-public-structs
|
|
||||||
disabled: true
|
|
||||||
# geneally annoying rules
|
|
||||||
- name: add-constant # complains about any and all strings and integers
|
|
||||||
disabled: true
|
|
||||||
- name: confusing-naming # we frequently use "Foo()" and "foo()" together
|
|
||||||
disabled: true
|
|
||||||
- name: flag-parameter # excessive, and a common idiom we use
|
|
||||||
disabled: true
|
|
||||||
- name: unhandled-error # warns over common fmt.Print* and io.Close; rely on errcheck instead
|
|
||||||
disabled: true
|
|
||||||
# general config
|
|
||||||
- name: line-length-limit
|
|
||||||
arguments:
|
|
||||||
- 140
|
|
||||||
- name: var-naming
|
|
||||||
arguments:
|
|
||||||
- []
|
|
||||||
- - CID
|
|
||||||
- CRI
|
|
||||||
- CTRD
|
|
||||||
- DACL
|
|
||||||
- DLL
|
|
||||||
- DOS
|
|
||||||
- ETW
|
|
||||||
- FSCTL
|
|
||||||
- GCS
|
|
||||||
- GMSA
|
|
||||||
- HCS
|
|
||||||
- HV
|
|
||||||
- IO
|
|
||||||
- LCOW
|
|
||||||
- LDAP
|
|
||||||
- LPAC
|
|
||||||
- LTSC
|
|
||||||
- MMIO
|
|
||||||
- NT
|
|
||||||
- OCI
|
|
||||||
- PMEM
|
|
||||||
- PWSH
|
|
||||||
- RX
|
|
||||||
- SACl
|
|
||||||
- SID
|
|
||||||
- SMB
|
|
||||||
- TX
|
|
||||||
- VHD
|
|
||||||
- VHDX
|
|
||||||
- VMID
|
|
||||||
- VPCI
|
|
||||||
- WCOW
|
|
||||||
- WIM
|
|
||||||
@ -1 +0,0 @@
|
|||||||
* @microsoft/containerplat
|
|
||||||
@ -1,22 +0,0 @@
|
|||||||
The MIT License (MIT)
|
|
||||||
|
|
||||||
Copyright (c) 2015 Microsoft
|
|
||||||
|
|
||||||
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.
|
|
||||||
|
|
||||||
@ -1,89 +0,0 @@
|
|||||||
# go-winio [](https://github.com/microsoft/go-winio/actions/workflows/ci.yml)
|
|
||||||
|
|
||||||
This repository contains utilities for efficiently performing Win32 IO operations in
|
|
||||||
Go. Currently, this is focused on accessing named pipes and other file handles, and
|
|
||||||
for using named pipes as a net transport.
|
|
||||||
|
|
||||||
This code relies on IO completion ports to avoid blocking IO on system threads, allowing Go
|
|
||||||
to reuse the thread to schedule another goroutine. This limits support to Windows Vista and
|
|
||||||
newer operating systems. This is similar to the implementation of network sockets in Go's net
|
|
||||||
package.
|
|
||||||
|
|
||||||
Please see the LICENSE file for licensing information.
|
|
||||||
|
|
||||||
## Contributing
|
|
||||||
|
|
||||||
This project welcomes contributions and suggestions.
|
|
||||||
Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that
|
|
||||||
you have the right to, and actually do, grant us the rights to use your contribution.
|
|
||||||
For details, visit [Microsoft CLA](https://cla.microsoft.com).
|
|
||||||
|
|
||||||
When you submit a pull request, a CLA-bot will automatically determine whether you need to
|
|
||||||
provide a CLA and decorate the PR appropriately (e.g., label, comment).
|
|
||||||
Simply follow the instructions provided by the bot.
|
|
||||||
You will only need to do this once across all repos using our CLA.
|
|
||||||
|
|
||||||
Additionally, the pull request pipeline requires the following steps to be performed before
|
|
||||||
mergining.
|
|
||||||
|
|
||||||
### Code Sign-Off
|
|
||||||
|
|
||||||
We require that contributors sign their commits using [`git commit --signoff`][git-commit-s]
|
|
||||||
to certify they either authored the work themselves or otherwise have permission to use it in this project.
|
|
||||||
|
|
||||||
A range of commits can be signed off using [`git rebase --signoff`][git-rebase-s].
|
|
||||||
|
|
||||||
Please see [the developer certificate](https://developercertificate.org) for more info,
|
|
||||||
as well as to make sure that you can attest to the rules listed.
|
|
||||||
Our CI uses the DCO Github app to ensure that all commits in a given PR are signed-off.
|
|
||||||
|
|
||||||
### Linting
|
|
||||||
|
|
||||||
Code must pass a linting stage, which uses [`golangci-lint`][lint].
|
|
||||||
The linting settings are stored in [`.golangci.yaml`](./.golangci.yaml), and can be run
|
|
||||||
automatically with VSCode by adding the following to your workspace or folder settings:
|
|
||||||
|
|
||||||
```json
|
|
||||||
"go.lintTool": "golangci-lint",
|
|
||||||
"go.lintOnSave": "package",
|
|
||||||
```
|
|
||||||
|
|
||||||
Additional editor [integrations options are also available][lint-ide].
|
|
||||||
|
|
||||||
Alternatively, `golangci-lint` can be [installed locally][lint-install] and run from the repo root:
|
|
||||||
|
|
||||||
```shell
|
|
||||||
# use . or specify a path to only lint a package
|
|
||||||
# to show all lint errors, use flags "--max-issues-per-linter=0 --max-same-issues=0"
|
|
||||||
> golangci-lint run ./...
|
|
||||||
```
|
|
||||||
|
|
||||||
### Go Generate
|
|
||||||
|
|
||||||
The pipeline checks that auto-generated code, via `go generate`, are up to date.
|
|
||||||
|
|
||||||
This can be done for the entire repo:
|
|
||||||
|
|
||||||
```shell
|
|
||||||
> go generate ./...
|
|
||||||
```
|
|
||||||
|
|
||||||
## Code of Conduct
|
|
||||||
|
|
||||||
This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
|
|
||||||
For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
|
|
||||||
contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
|
|
||||||
|
|
||||||
## Special Thanks
|
|
||||||
|
|
||||||
Thanks to [natefinch][natefinch] for the inspiration for this library.
|
|
||||||
See [npipe](https://github.com/natefinch/npipe) for another named pipe implementation.
|
|
||||||
|
|
||||||
[lint]: https://golangci-lint.run/
|
|
||||||
[lint-ide]: https://golangci-lint.run/usage/integrations/#editor-integration
|
|
||||||
[lint-install]: https://golangci-lint.run/usage/install/#local-installation
|
|
||||||
|
|
||||||
[git-commit-s]: https://git-scm.com/docs/git-commit#Documentation/git-commit.txt--s
|
|
||||||
[git-rebase-s]: https://git-scm.com/docs/git-rebase#Documentation/git-rebase.txt---signoff
|
|
||||||
|
|
||||||
[natefinch]: https://github.com/natefinch
|
|
||||||
@ -1,41 +0,0 @@
|
|||||||
<!-- BEGIN MICROSOFT SECURITY.MD V0.0.7 BLOCK -->
|
|
||||||
|
|
||||||
## Security
|
|
||||||
|
|
||||||
Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
|
|
||||||
|
|
||||||
If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
|
|
||||||
|
|
||||||
## Reporting Security Issues
|
|
||||||
|
|
||||||
**Please do not report security vulnerabilities through public GitHub issues.**
|
|
||||||
|
|
||||||
Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
|
|
||||||
|
|
||||||
If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com). If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
|
|
||||||
|
|
||||||
You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc).
|
|
||||||
|
|
||||||
Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
|
|
||||||
|
|
||||||
* Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
|
|
||||||
* Full paths of source file(s) related to the manifestation of the issue
|
|
||||||
* The location of the affected source code (tag/branch/commit or direct URL)
|
|
||||||
* Any special configuration required to reproduce the issue
|
|
||||||
* Step-by-step instructions to reproduce the issue
|
|
||||||
* Proof-of-concept or exploit code (if possible)
|
|
||||||
* Impact of the issue, including how an attacker might exploit the issue
|
|
||||||
|
|
||||||
This information will help us triage your report more quickly.
|
|
||||||
|
|
||||||
If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
|
|
||||||
|
|
||||||
## Preferred Languages
|
|
||||||
|
|
||||||
We prefer all communications to be in English.
|
|
||||||
|
|
||||||
## Policy
|
|
||||||
|
|
||||||
Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
|
|
||||||
|
|
||||||
<!-- END MICROSOFT SECURITY.MD BLOCK -->
|
|
||||||
@ -1,290 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/binary"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"os"
|
|
||||||
"runtime"
|
|
||||||
"syscall"
|
|
||||||
"unicode/utf16"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
//sys backupRead(h syscall.Handle, b []byte, bytesRead *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupRead
|
|
||||||
//sys backupWrite(h syscall.Handle, b []byte, bytesWritten *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupWrite
|
|
||||||
|
|
||||||
const (
|
|
||||||
BackupData = uint32(iota + 1)
|
|
||||||
BackupEaData
|
|
||||||
BackupSecurity
|
|
||||||
BackupAlternateData
|
|
||||||
BackupLink
|
|
||||||
BackupPropertyData
|
|
||||||
BackupObjectId //revive:disable-line:var-naming ID, not Id
|
|
||||||
BackupReparseData
|
|
||||||
BackupSparseBlock
|
|
||||||
BackupTxfsData
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
StreamSparseAttributes = uint32(8)
|
|
||||||
)
|
|
||||||
|
|
||||||
//nolint:revive // var-naming: ALL_CAPS
|
|
||||||
const (
|
|
||||||
WRITE_DAC = windows.WRITE_DAC
|
|
||||||
WRITE_OWNER = windows.WRITE_OWNER
|
|
||||||
ACCESS_SYSTEM_SECURITY = windows.ACCESS_SYSTEM_SECURITY
|
|
||||||
)
|
|
||||||
|
|
||||||
// BackupHeader represents a backup stream of a file.
|
|
||||||
type BackupHeader struct {
|
|
||||||
//revive:disable-next-line:var-naming ID, not Id
|
|
||||||
Id uint32 // The backup stream ID
|
|
||||||
Attributes uint32 // Stream attributes
|
|
||||||
Size int64 // The size of the stream in bytes
|
|
||||||
Name string // The name of the stream (for BackupAlternateData only).
|
|
||||||
Offset int64 // The offset of the stream in the file (for BackupSparseBlock only).
|
|
||||||
}
|
|
||||||
|
|
||||||
type win32StreamID struct {
|
|
||||||
StreamID uint32
|
|
||||||
Attributes uint32
|
|
||||||
Size uint64
|
|
||||||
NameSize uint32
|
|
||||||
}
|
|
||||||
|
|
||||||
// BackupStreamReader reads from a stream produced by the BackupRead Win32 API and produces a series
|
|
||||||
// of BackupHeader values.
|
|
||||||
type BackupStreamReader struct {
|
|
||||||
r io.Reader
|
|
||||||
bytesLeft int64
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewBackupStreamReader produces a BackupStreamReader from any io.Reader.
|
|
||||||
func NewBackupStreamReader(r io.Reader) *BackupStreamReader {
|
|
||||||
return &BackupStreamReader{r, 0}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Next returns the next backup stream and prepares for calls to Read(). It skips the remainder of the current stream if
|
|
||||||
// it was not completely read.
|
|
||||||
func (r *BackupStreamReader) Next() (*BackupHeader, error) {
|
|
||||||
if r.bytesLeft > 0 { //nolint:nestif // todo: flatten this
|
|
||||||
if s, ok := r.r.(io.Seeker); ok {
|
|
||||||
// Make sure Seek on io.SeekCurrent sometimes succeeds
|
|
||||||
// before trying the actual seek.
|
|
||||||
if _, err := s.Seek(0, io.SeekCurrent); err == nil {
|
|
||||||
if _, err = s.Seek(r.bytesLeft, io.SeekCurrent); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
r.bytesLeft = 0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if _, err := io.Copy(io.Discard, r); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
var wsi win32StreamID
|
|
||||||
if err := binary.Read(r.r, binary.LittleEndian, &wsi); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
hdr := &BackupHeader{
|
|
||||||
Id: wsi.StreamID,
|
|
||||||
Attributes: wsi.Attributes,
|
|
||||||
Size: int64(wsi.Size),
|
|
||||||
}
|
|
||||||
if wsi.NameSize != 0 {
|
|
||||||
name := make([]uint16, int(wsi.NameSize/2))
|
|
||||||
if err := binary.Read(r.r, binary.LittleEndian, name); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
hdr.Name = syscall.UTF16ToString(name)
|
|
||||||
}
|
|
||||||
if wsi.StreamID == BackupSparseBlock {
|
|
||||||
if err := binary.Read(r.r, binary.LittleEndian, &hdr.Offset); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
hdr.Size -= 8
|
|
||||||
}
|
|
||||||
r.bytesLeft = hdr.Size
|
|
||||||
return hdr, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Read reads from the current backup stream.
|
|
||||||
func (r *BackupStreamReader) Read(b []byte) (int, error) {
|
|
||||||
if r.bytesLeft == 0 {
|
|
||||||
return 0, io.EOF
|
|
||||||
}
|
|
||||||
if int64(len(b)) > r.bytesLeft {
|
|
||||||
b = b[:r.bytesLeft]
|
|
||||||
}
|
|
||||||
n, err := r.r.Read(b)
|
|
||||||
r.bytesLeft -= int64(n)
|
|
||||||
if err == io.EOF {
|
|
||||||
err = io.ErrUnexpectedEOF
|
|
||||||
} else if r.bytesLeft == 0 && err == nil {
|
|
||||||
err = io.EOF
|
|
||||||
}
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// BackupStreamWriter writes a stream compatible with the BackupWrite Win32 API.
|
|
||||||
type BackupStreamWriter struct {
|
|
||||||
w io.Writer
|
|
||||||
bytesLeft int64
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewBackupStreamWriter produces a BackupStreamWriter on top of an io.Writer.
|
|
||||||
func NewBackupStreamWriter(w io.Writer) *BackupStreamWriter {
|
|
||||||
return &BackupStreamWriter{w, 0}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WriteHeader writes the next backup stream header and prepares for calls to Write().
|
|
||||||
func (w *BackupStreamWriter) WriteHeader(hdr *BackupHeader) error {
|
|
||||||
if w.bytesLeft != 0 {
|
|
||||||
return fmt.Errorf("missing %d bytes", w.bytesLeft)
|
|
||||||
}
|
|
||||||
name := utf16.Encode([]rune(hdr.Name))
|
|
||||||
wsi := win32StreamID{
|
|
||||||
StreamID: hdr.Id,
|
|
||||||
Attributes: hdr.Attributes,
|
|
||||||
Size: uint64(hdr.Size),
|
|
||||||
NameSize: uint32(len(name) * 2),
|
|
||||||
}
|
|
||||||
if hdr.Id == BackupSparseBlock {
|
|
||||||
// Include space for the int64 block offset
|
|
||||||
wsi.Size += 8
|
|
||||||
}
|
|
||||||
if err := binary.Write(w.w, binary.LittleEndian, &wsi); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if len(name) != 0 {
|
|
||||||
if err := binary.Write(w.w, binary.LittleEndian, name); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if hdr.Id == BackupSparseBlock {
|
|
||||||
if err := binary.Write(w.w, binary.LittleEndian, hdr.Offset); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
w.bytesLeft = hdr.Size
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write writes to the current backup stream.
|
|
||||||
func (w *BackupStreamWriter) Write(b []byte) (int, error) {
|
|
||||||
if w.bytesLeft < int64(len(b)) {
|
|
||||||
return 0, fmt.Errorf("too many bytes by %d", int64(len(b))-w.bytesLeft)
|
|
||||||
}
|
|
||||||
n, err := w.w.Write(b)
|
|
||||||
w.bytesLeft -= int64(n)
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// BackupFileReader provides an io.ReadCloser interface on top of the BackupRead Win32 API.
|
|
||||||
type BackupFileReader struct {
|
|
||||||
f *os.File
|
|
||||||
includeSecurity bool
|
|
||||||
ctx uintptr
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewBackupFileReader returns a new BackupFileReader from a file handle. If includeSecurity is true,
|
|
||||||
// Read will attempt to read the security descriptor of the file.
|
|
||||||
func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
|
|
||||||
r := &BackupFileReader{f, includeSecurity, 0}
|
|
||||||
return r
|
|
||||||
}
|
|
||||||
|
|
||||||
// Read reads a backup stream from the file by calling the Win32 API BackupRead().
|
|
||||||
func (r *BackupFileReader) Read(b []byte) (int, error) {
|
|
||||||
var bytesRead uint32
|
|
||||||
err := backupRead(syscall.Handle(r.f.Fd()), b, &bytesRead, false, r.includeSecurity, &r.ctx)
|
|
||||||
if err != nil {
|
|
||||||
return 0, &os.PathError{Op: "BackupRead", Path: r.f.Name(), Err: err}
|
|
||||||
}
|
|
||||||
runtime.KeepAlive(r.f)
|
|
||||||
if bytesRead == 0 {
|
|
||||||
return 0, io.EOF
|
|
||||||
}
|
|
||||||
return int(bytesRead), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close frees Win32 resources associated with the BackupFileReader. It does not close
|
|
||||||
// the underlying file.
|
|
||||||
func (r *BackupFileReader) Close() error {
|
|
||||||
if r.ctx != 0 {
|
|
||||||
_ = backupRead(syscall.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
|
|
||||||
runtime.KeepAlive(r.f)
|
|
||||||
r.ctx = 0
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// BackupFileWriter provides an io.WriteCloser interface on top of the BackupWrite Win32 API.
|
|
||||||
type BackupFileWriter struct {
|
|
||||||
f *os.File
|
|
||||||
includeSecurity bool
|
|
||||||
ctx uintptr
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewBackupFileWriter returns a new BackupFileWriter from a file handle. If includeSecurity is true,
|
|
||||||
// Write() will attempt to restore the security descriptor from the stream.
|
|
||||||
func NewBackupFileWriter(f *os.File, includeSecurity bool) *BackupFileWriter {
|
|
||||||
w := &BackupFileWriter{f, includeSecurity, 0}
|
|
||||||
return w
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write restores a portion of the file using the provided backup stream.
|
|
||||||
func (w *BackupFileWriter) Write(b []byte) (int, error) {
|
|
||||||
var bytesWritten uint32
|
|
||||||
err := backupWrite(syscall.Handle(w.f.Fd()), b, &bytesWritten, false, w.includeSecurity, &w.ctx)
|
|
||||||
if err != nil {
|
|
||||||
return 0, &os.PathError{Op: "BackupWrite", Path: w.f.Name(), Err: err}
|
|
||||||
}
|
|
||||||
runtime.KeepAlive(w.f)
|
|
||||||
if int(bytesWritten) != len(b) {
|
|
||||||
return int(bytesWritten), errors.New("not all bytes could be written")
|
|
||||||
}
|
|
||||||
return len(b), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close frees Win32 resources associated with the BackupFileWriter. It does not
|
|
||||||
// close the underlying file.
|
|
||||||
func (w *BackupFileWriter) Close() error {
|
|
||||||
if w.ctx != 0 {
|
|
||||||
_ = backupWrite(syscall.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
|
|
||||||
runtime.KeepAlive(w.f)
|
|
||||||
w.ctx = 0
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// OpenForBackup opens a file or directory, potentially skipping access checks if the backup
|
|
||||||
// or restore privileges have been acquired.
|
|
||||||
//
|
|
||||||
// If the file opened was a directory, it cannot be used with Readdir().
|
|
||||||
func OpenForBackup(path string, access uint32, share uint32, createmode uint32) (*os.File, error) {
|
|
||||||
winPath, err := syscall.UTF16FromString(path)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
h, err := syscall.CreateFile(&winPath[0],
|
|
||||||
access,
|
|
||||||
share,
|
|
||||||
nil,
|
|
||||||
createmode,
|
|
||||||
syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OPEN_REPARSE_POINT,
|
|
||||||
0)
|
|
||||||
if err != nil {
|
|
||||||
err = &os.PathError{Op: "open", Path: path, Err: err}
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return os.NewFile(uintptr(h), path), nil
|
|
||||||
}
|
|
||||||
@ -1,22 +0,0 @@
|
|||||||
// This package provides utilities for efficiently performing Win32 IO operations in Go.
|
|
||||||
// Currently, this package is provides support for genreal IO and management of
|
|
||||||
// - named pipes
|
|
||||||
// - files
|
|
||||||
// - [Hyper-V sockets]
|
|
||||||
//
|
|
||||||
// This code is similar to Go's [net] package, and uses IO completion ports to avoid
|
|
||||||
// blocking IO on system threads, allowing Go to reuse the thread to schedule other goroutines.
|
|
||||||
//
|
|
||||||
// This limits support to Windows Vista and newer operating systems.
|
|
||||||
//
|
|
||||||
// Additionally, this package provides support for:
|
|
||||||
// - creating and managing GUIDs
|
|
||||||
// - writing to [ETW]
|
|
||||||
// - opening and manageing VHDs
|
|
||||||
// - parsing [Windows Image files]
|
|
||||||
// - auto-generating Win32 API code
|
|
||||||
//
|
|
||||||
// [Hyper-V sockets]: https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/user-guide/make-integration-service
|
|
||||||
// [ETW]: https://docs.microsoft.com/en-us/windows-hardware/drivers/devtest/event-tracing-for-windows--etw-
|
|
||||||
// [Windows Image files]: https://docs.microsoft.com/en-us/windows-hardware/manufacture/desktop/work-with-windows-images
|
|
||||||
package winio
|
|
||||||
@ -1,137 +0,0 @@
|
|||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/binary"
|
|
||||||
"errors"
|
|
||||||
)
|
|
||||||
|
|
||||||
type fileFullEaInformation struct {
|
|
||||||
NextEntryOffset uint32
|
|
||||||
Flags uint8
|
|
||||||
NameLength uint8
|
|
||||||
ValueLength uint16
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
fileFullEaInformationSize = binary.Size(&fileFullEaInformation{})
|
|
||||||
|
|
||||||
errInvalidEaBuffer = errors.New("invalid extended attribute buffer")
|
|
||||||
errEaNameTooLarge = errors.New("extended attribute name too large")
|
|
||||||
errEaValueTooLarge = errors.New("extended attribute value too large")
|
|
||||||
)
|
|
||||||
|
|
||||||
// ExtendedAttribute represents a single Windows EA.
|
|
||||||
type ExtendedAttribute struct {
|
|
||||||
Name string
|
|
||||||
Value []byte
|
|
||||||
Flags uint8
|
|
||||||
}
|
|
||||||
|
|
||||||
func parseEa(b []byte) (ea ExtendedAttribute, nb []byte, err error) {
|
|
||||||
var info fileFullEaInformation
|
|
||||||
err = binary.Read(bytes.NewReader(b), binary.LittleEndian, &info)
|
|
||||||
if err != nil {
|
|
||||||
err = errInvalidEaBuffer
|
|
||||||
return ea, nb, err
|
|
||||||
}
|
|
||||||
|
|
||||||
nameOffset := fileFullEaInformationSize
|
|
||||||
nameLen := int(info.NameLength)
|
|
||||||
valueOffset := nameOffset + int(info.NameLength) + 1
|
|
||||||
valueLen := int(info.ValueLength)
|
|
||||||
nextOffset := int(info.NextEntryOffset)
|
|
||||||
if valueLen+valueOffset > len(b) || nextOffset < 0 || nextOffset > len(b) {
|
|
||||||
err = errInvalidEaBuffer
|
|
||||||
return ea, nb, err
|
|
||||||
}
|
|
||||||
|
|
||||||
ea.Name = string(b[nameOffset : nameOffset+nameLen])
|
|
||||||
ea.Value = b[valueOffset : valueOffset+valueLen]
|
|
||||||
ea.Flags = info.Flags
|
|
||||||
if info.NextEntryOffset != 0 {
|
|
||||||
nb = b[info.NextEntryOffset:]
|
|
||||||
}
|
|
||||||
return ea, nb, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION
|
|
||||||
// buffer retrieved from BackupRead, ZwQueryEaFile, etc.
|
|
||||||
func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
|
|
||||||
for len(b) != 0 {
|
|
||||||
ea, nb, err := parseEa(b)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
eas = append(eas, ea)
|
|
||||||
b = nb
|
|
||||||
}
|
|
||||||
return eas, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func writeEa(buf *bytes.Buffer, ea *ExtendedAttribute, last bool) error {
|
|
||||||
if int(uint8(len(ea.Name))) != len(ea.Name) {
|
|
||||||
return errEaNameTooLarge
|
|
||||||
}
|
|
||||||
if int(uint16(len(ea.Value))) != len(ea.Value) {
|
|
||||||
return errEaValueTooLarge
|
|
||||||
}
|
|
||||||
entrySize := uint32(fileFullEaInformationSize + len(ea.Name) + 1 + len(ea.Value))
|
|
||||||
withPadding := (entrySize + 3) &^ 3
|
|
||||||
nextOffset := uint32(0)
|
|
||||||
if !last {
|
|
||||||
nextOffset = withPadding
|
|
||||||
}
|
|
||||||
info := fileFullEaInformation{
|
|
||||||
NextEntryOffset: nextOffset,
|
|
||||||
Flags: ea.Flags,
|
|
||||||
NameLength: uint8(len(ea.Name)),
|
|
||||||
ValueLength: uint16(len(ea.Value)),
|
|
||||||
}
|
|
||||||
|
|
||||||
err := binary.Write(buf, binary.LittleEndian, &info)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
_, err = buf.Write([]byte(ea.Name))
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
err = buf.WriteByte(0)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
_, err = buf.Write(ea.Value)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
_, err = buf.Write([]byte{0, 0, 0}[0 : withPadding-entrySize])
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION
|
|
||||||
// buffer for use with BackupWrite, ZwSetEaFile, etc.
|
|
||||||
func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
|
|
||||||
var buf bytes.Buffer
|
|
||||||
for i := range eas {
|
|
||||||
last := false
|
|
||||||
if i == len(eas)-1 {
|
|
||||||
last = true
|
|
||||||
}
|
|
||||||
|
|
||||||
err := writeEa(&buf, &eas[i], last)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return buf.Bytes(), nil
|
|
||||||
}
|
|
||||||
@ -1,331 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"io"
|
|
||||||
"runtime"
|
|
||||||
"sync"
|
|
||||||
"sync/atomic"
|
|
||||||
"syscall"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
//sys cancelIoEx(file syscall.Handle, o *syscall.Overlapped) (err error) = CancelIoEx
|
|
||||||
//sys createIoCompletionPort(file syscall.Handle, port syscall.Handle, key uintptr, threadCount uint32) (newport syscall.Handle, err error) = CreateIoCompletionPort
|
|
||||||
//sys getQueuedCompletionStatus(port syscall.Handle, bytes *uint32, key *uintptr, o **ioOperation, timeout uint32) (err error) = GetQueuedCompletionStatus
|
|
||||||
//sys setFileCompletionNotificationModes(h syscall.Handle, flags uint8) (err error) = SetFileCompletionNotificationModes
|
|
||||||
//sys wsaGetOverlappedResult(h syscall.Handle, o *syscall.Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) = ws2_32.WSAGetOverlappedResult
|
|
||||||
|
|
||||||
type atomicBool int32
|
|
||||||
|
|
||||||
func (b *atomicBool) isSet() bool { return atomic.LoadInt32((*int32)(b)) != 0 }
|
|
||||||
func (b *atomicBool) setFalse() { atomic.StoreInt32((*int32)(b), 0) }
|
|
||||||
func (b *atomicBool) setTrue() { atomic.StoreInt32((*int32)(b), 1) }
|
|
||||||
|
|
||||||
//revive:disable-next-line:predeclared Keep "new" to maintain consistency with "atomic" pkg
|
|
||||||
func (b *atomicBool) swap(new bool) bool {
|
|
||||||
var newInt int32
|
|
||||||
if new {
|
|
||||||
newInt = 1
|
|
||||||
}
|
|
||||||
return atomic.SwapInt32((*int32)(b), newInt) == 1
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
ErrFileClosed = errors.New("file has already been closed")
|
|
||||||
ErrTimeout = &timeoutError{}
|
|
||||||
)
|
|
||||||
|
|
||||||
type timeoutError struct{}
|
|
||||||
|
|
||||||
func (*timeoutError) Error() string { return "i/o timeout" }
|
|
||||||
func (*timeoutError) Timeout() bool { return true }
|
|
||||||
func (*timeoutError) Temporary() bool { return true }
|
|
||||||
|
|
||||||
type timeoutChan chan struct{}
|
|
||||||
|
|
||||||
var ioInitOnce sync.Once
|
|
||||||
var ioCompletionPort syscall.Handle
|
|
||||||
|
|
||||||
// ioResult contains the result of an asynchronous IO operation.
|
|
||||||
type ioResult struct {
|
|
||||||
bytes uint32
|
|
||||||
err error
|
|
||||||
}
|
|
||||||
|
|
||||||
// ioOperation represents an outstanding asynchronous Win32 IO.
|
|
||||||
type ioOperation struct {
|
|
||||||
o syscall.Overlapped
|
|
||||||
ch chan ioResult
|
|
||||||
}
|
|
||||||
|
|
||||||
func initIO() {
|
|
||||||
h, err := createIoCompletionPort(syscall.InvalidHandle, 0, 0, 0xffffffff)
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
ioCompletionPort = h
|
|
||||||
go ioCompletionProcessor(h)
|
|
||||||
}
|
|
||||||
|
|
||||||
// win32File implements Reader, Writer, and Closer on a Win32 handle without blocking in a syscall.
|
|
||||||
// It takes ownership of this handle and will close it if it is garbage collected.
|
|
||||||
type win32File struct {
|
|
||||||
handle syscall.Handle
|
|
||||||
wg sync.WaitGroup
|
|
||||||
wgLock sync.RWMutex
|
|
||||||
closing atomicBool
|
|
||||||
socket bool
|
|
||||||
readDeadline deadlineHandler
|
|
||||||
writeDeadline deadlineHandler
|
|
||||||
}
|
|
||||||
|
|
||||||
type deadlineHandler struct {
|
|
||||||
setLock sync.Mutex
|
|
||||||
channel timeoutChan
|
|
||||||
channelLock sync.RWMutex
|
|
||||||
timer *time.Timer
|
|
||||||
timedout atomicBool
|
|
||||||
}
|
|
||||||
|
|
||||||
// makeWin32File makes a new win32File from an existing file handle.
|
|
||||||
func makeWin32File(h syscall.Handle) (*win32File, error) {
|
|
||||||
f := &win32File{handle: h}
|
|
||||||
ioInitOnce.Do(initIO)
|
|
||||||
_, err := createIoCompletionPort(h, ioCompletionPort, 0, 0xffffffff)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
err = setFileCompletionNotificationModes(h, windows.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS|windows.FILE_SKIP_SET_EVENT_ON_HANDLE)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
f.readDeadline.channel = make(timeoutChan)
|
|
||||||
f.writeDeadline.channel = make(timeoutChan)
|
|
||||||
return f, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func MakeOpenFile(h syscall.Handle) (io.ReadWriteCloser, error) {
|
|
||||||
// If we return the result of makeWin32File directly, it can result in an
|
|
||||||
// interface-wrapped nil, rather than a nil interface value.
|
|
||||||
f, err := makeWin32File(h)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return f, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// closeHandle closes the resources associated with a Win32 handle.
|
|
||||||
func (f *win32File) closeHandle() {
|
|
||||||
f.wgLock.Lock()
|
|
||||||
// Atomically set that we are closing, releasing the resources only once.
|
|
||||||
if !f.closing.swap(true) {
|
|
||||||
f.wgLock.Unlock()
|
|
||||||
// cancel all IO and wait for it to complete
|
|
||||||
_ = cancelIoEx(f.handle, nil)
|
|
||||||
f.wg.Wait()
|
|
||||||
// at this point, no new IO can start
|
|
||||||
syscall.Close(f.handle)
|
|
||||||
f.handle = 0
|
|
||||||
} else {
|
|
||||||
f.wgLock.Unlock()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close closes a win32File.
|
|
||||||
func (f *win32File) Close() error {
|
|
||||||
f.closeHandle()
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// IsClosed checks if the file has been closed.
|
|
||||||
func (f *win32File) IsClosed() bool {
|
|
||||||
return f.closing.isSet()
|
|
||||||
}
|
|
||||||
|
|
||||||
// prepareIO prepares for a new IO operation.
|
|
||||||
// The caller must call f.wg.Done() when the IO is finished, prior to Close() returning.
|
|
||||||
func (f *win32File) prepareIO() (*ioOperation, error) {
|
|
||||||
f.wgLock.RLock()
|
|
||||||
if f.closing.isSet() {
|
|
||||||
f.wgLock.RUnlock()
|
|
||||||
return nil, ErrFileClosed
|
|
||||||
}
|
|
||||||
f.wg.Add(1)
|
|
||||||
f.wgLock.RUnlock()
|
|
||||||
c := &ioOperation{}
|
|
||||||
c.ch = make(chan ioResult)
|
|
||||||
return c, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ioCompletionProcessor processes completed async IOs forever.
|
|
||||||
func ioCompletionProcessor(h syscall.Handle) {
|
|
||||||
for {
|
|
||||||
var bytes uint32
|
|
||||||
var key uintptr
|
|
||||||
var op *ioOperation
|
|
||||||
err := getQueuedCompletionStatus(h, &bytes, &key, &op, syscall.INFINITE)
|
|
||||||
if op == nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
op.ch <- ioResult{bytes, err}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// todo: helsaawy - create an asyncIO version that takes a context
|
|
||||||
|
|
||||||
// asyncIO processes the return value from ReadFile or WriteFile, blocking until
|
|
||||||
// the operation has actually completed.
|
|
||||||
func (f *win32File) asyncIO(c *ioOperation, d *deadlineHandler, bytes uint32, err error) (int, error) {
|
|
||||||
if err != syscall.ERROR_IO_PENDING { //nolint:errorlint // err is Errno
|
|
||||||
return int(bytes), err
|
|
||||||
}
|
|
||||||
|
|
||||||
if f.closing.isSet() {
|
|
||||||
_ = cancelIoEx(f.handle, &c.o)
|
|
||||||
}
|
|
||||||
|
|
||||||
var timeout timeoutChan
|
|
||||||
if d != nil {
|
|
||||||
d.channelLock.Lock()
|
|
||||||
timeout = d.channel
|
|
||||||
d.channelLock.Unlock()
|
|
||||||
}
|
|
||||||
|
|
||||||
var r ioResult
|
|
||||||
select {
|
|
||||||
case r = <-c.ch:
|
|
||||||
err = r.err
|
|
||||||
if err == syscall.ERROR_OPERATION_ABORTED { //nolint:errorlint // err is Errno
|
|
||||||
if f.closing.isSet() {
|
|
||||||
err = ErrFileClosed
|
|
||||||
}
|
|
||||||
} else if err != nil && f.socket {
|
|
||||||
// err is from Win32. Query the overlapped structure to get the winsock error.
|
|
||||||
var bytes, flags uint32
|
|
||||||
err = wsaGetOverlappedResult(f.handle, &c.o, &bytes, false, &flags)
|
|
||||||
}
|
|
||||||
case <-timeout:
|
|
||||||
_ = cancelIoEx(f.handle, &c.o)
|
|
||||||
r = <-c.ch
|
|
||||||
err = r.err
|
|
||||||
if err == syscall.ERROR_OPERATION_ABORTED { //nolint:errorlint // err is Errno
|
|
||||||
err = ErrTimeout
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// runtime.KeepAlive is needed, as c is passed via native
|
|
||||||
// code to ioCompletionProcessor, c must remain alive
|
|
||||||
// until the channel read is complete.
|
|
||||||
// todo: (de)allocate *ioOperation via win32 heap functions, instead of needing to KeepAlive?
|
|
||||||
runtime.KeepAlive(c)
|
|
||||||
return int(r.bytes), err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Read reads from a file handle.
|
|
||||||
func (f *win32File) Read(b []byte) (int, error) {
|
|
||||||
c, err := f.prepareIO()
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
defer f.wg.Done()
|
|
||||||
|
|
||||||
if f.readDeadline.timedout.isSet() {
|
|
||||||
return 0, ErrTimeout
|
|
||||||
}
|
|
||||||
|
|
||||||
var bytes uint32
|
|
||||||
err = syscall.ReadFile(f.handle, b, &bytes, &c.o)
|
|
||||||
n, err := f.asyncIO(c, &f.readDeadline, bytes, err)
|
|
||||||
runtime.KeepAlive(b)
|
|
||||||
|
|
||||||
// Handle EOF conditions.
|
|
||||||
if err == nil && n == 0 && len(b) != 0 {
|
|
||||||
return 0, io.EOF
|
|
||||||
} else if err == syscall.ERROR_BROKEN_PIPE { //nolint:errorlint // err is Errno
|
|
||||||
return 0, io.EOF
|
|
||||||
} else {
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write writes to a file handle.
|
|
||||||
func (f *win32File) Write(b []byte) (int, error) {
|
|
||||||
c, err := f.prepareIO()
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
defer f.wg.Done()
|
|
||||||
|
|
||||||
if f.writeDeadline.timedout.isSet() {
|
|
||||||
return 0, ErrTimeout
|
|
||||||
}
|
|
||||||
|
|
||||||
var bytes uint32
|
|
||||||
err = syscall.WriteFile(f.handle, b, &bytes, &c.o)
|
|
||||||
n, err := f.asyncIO(c, &f.writeDeadline, bytes, err)
|
|
||||||
runtime.KeepAlive(b)
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *win32File) SetReadDeadline(deadline time.Time) error {
|
|
||||||
return f.readDeadline.set(deadline)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *win32File) SetWriteDeadline(deadline time.Time) error {
|
|
||||||
return f.writeDeadline.set(deadline)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *win32File) Flush() error {
|
|
||||||
return syscall.FlushFileBuffers(f.handle)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *win32File) Fd() uintptr {
|
|
||||||
return uintptr(f.handle)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *deadlineHandler) set(deadline time.Time) error {
|
|
||||||
d.setLock.Lock()
|
|
||||||
defer d.setLock.Unlock()
|
|
||||||
|
|
||||||
if d.timer != nil {
|
|
||||||
if !d.timer.Stop() {
|
|
||||||
<-d.channel
|
|
||||||
}
|
|
||||||
d.timer = nil
|
|
||||||
}
|
|
||||||
d.timedout.setFalse()
|
|
||||||
|
|
||||||
select {
|
|
||||||
case <-d.channel:
|
|
||||||
d.channelLock.Lock()
|
|
||||||
d.channel = make(chan struct{})
|
|
||||||
d.channelLock.Unlock()
|
|
||||||
default:
|
|
||||||
}
|
|
||||||
|
|
||||||
if deadline.IsZero() {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
timeoutIO := func() {
|
|
||||||
d.timedout.setTrue()
|
|
||||||
close(d.channel)
|
|
||||||
}
|
|
||||||
|
|
||||||
now := time.Now()
|
|
||||||
duration := deadline.Sub(now)
|
|
||||||
if deadline.After(now) {
|
|
||||||
// Deadline is in the future, set a timer to wait
|
|
||||||
d.timer = time.AfterFunc(duration, timeoutIO)
|
|
||||||
} else {
|
|
||||||
// Deadline is in the past. Cancel all pending IO now.
|
|
||||||
timeoutIO()
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
@ -1,92 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"os"
|
|
||||||
"runtime"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
// FileBasicInfo contains file access time and file attributes information.
|
|
||||||
type FileBasicInfo struct {
|
|
||||||
CreationTime, LastAccessTime, LastWriteTime, ChangeTime windows.Filetime
|
|
||||||
FileAttributes uint32
|
|
||||||
_ uint32 // padding
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetFileBasicInfo retrieves times and attributes for a file.
|
|
||||||
func GetFileBasicInfo(f *os.File) (*FileBasicInfo, error) {
|
|
||||||
bi := &FileBasicInfo{}
|
|
||||||
if err := windows.GetFileInformationByHandleEx(
|
|
||||||
windows.Handle(f.Fd()),
|
|
||||||
windows.FileBasicInfo,
|
|
||||||
(*byte)(unsafe.Pointer(bi)),
|
|
||||||
uint32(unsafe.Sizeof(*bi)),
|
|
||||||
); err != nil {
|
|
||||||
return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
|
|
||||||
}
|
|
||||||
runtime.KeepAlive(f)
|
|
||||||
return bi, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetFileBasicInfo sets times and attributes for a file.
|
|
||||||
func SetFileBasicInfo(f *os.File, bi *FileBasicInfo) error {
|
|
||||||
if err := windows.SetFileInformationByHandle(
|
|
||||||
windows.Handle(f.Fd()),
|
|
||||||
windows.FileBasicInfo,
|
|
||||||
(*byte)(unsafe.Pointer(bi)),
|
|
||||||
uint32(unsafe.Sizeof(*bi)),
|
|
||||||
); err != nil {
|
|
||||||
return &os.PathError{Op: "SetFileInformationByHandle", Path: f.Name(), Err: err}
|
|
||||||
}
|
|
||||||
runtime.KeepAlive(f)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// FileStandardInfo contains extended information for the file.
|
|
||||||
// FILE_STANDARD_INFO in WinBase.h
|
|
||||||
// https://docs.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-file_standard_info
|
|
||||||
type FileStandardInfo struct {
|
|
||||||
AllocationSize, EndOfFile int64
|
|
||||||
NumberOfLinks uint32
|
|
||||||
DeletePending, Directory bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetFileStandardInfo retrieves ended information for the file.
|
|
||||||
func GetFileStandardInfo(f *os.File) (*FileStandardInfo, error) {
|
|
||||||
si := &FileStandardInfo{}
|
|
||||||
if err := windows.GetFileInformationByHandleEx(windows.Handle(f.Fd()),
|
|
||||||
windows.FileStandardInfo,
|
|
||||||
(*byte)(unsafe.Pointer(si)),
|
|
||||||
uint32(unsafe.Sizeof(*si))); err != nil {
|
|
||||||
return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
|
|
||||||
}
|
|
||||||
runtime.KeepAlive(f)
|
|
||||||
return si, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// FileIDInfo contains the volume serial number and file ID for a file. This pair should be
|
|
||||||
// unique on a system.
|
|
||||||
type FileIDInfo struct {
|
|
||||||
VolumeSerialNumber uint64
|
|
||||||
FileID [16]byte
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetFileID retrieves the unique (volume, file ID) pair for a file.
|
|
||||||
func GetFileID(f *os.File) (*FileIDInfo, error) {
|
|
||||||
fileID := &FileIDInfo{}
|
|
||||||
if err := windows.GetFileInformationByHandleEx(
|
|
||||||
windows.Handle(f.Fd()),
|
|
||||||
windows.FileIdInfo,
|
|
||||||
(*byte)(unsafe.Pointer(fileID)),
|
|
||||||
uint32(unsafe.Sizeof(*fileID)),
|
|
||||||
); err != nil {
|
|
||||||
return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
|
|
||||||
}
|
|
||||||
runtime.KeepAlive(f)
|
|
||||||
return fileID, nil
|
|
||||||
}
|
|
||||||
@ -1,575 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"context"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"net"
|
|
||||||
"os"
|
|
||||||
"syscall"
|
|
||||||
"time"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
|
|
||||||
"github.com/Microsoft/go-winio/internal/socket"
|
|
||||||
"github.com/Microsoft/go-winio/pkg/guid"
|
|
||||||
)
|
|
||||||
|
|
||||||
const afHVSock = 34 // AF_HYPERV
|
|
||||||
|
|
||||||
// Well known Service and VM IDs
|
|
||||||
// https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/user-guide/make-integration-service#vmid-wildcards
|
|
||||||
|
|
||||||
// HvsockGUIDWildcard is the wildcard VmId for accepting connections from all partitions.
|
|
||||||
func HvsockGUIDWildcard() guid.GUID { // 00000000-0000-0000-0000-000000000000
|
|
||||||
return guid.GUID{}
|
|
||||||
}
|
|
||||||
|
|
||||||
// HvsockGUIDBroadcast is the wildcard VmId for broadcasting sends to all partitions.
|
|
||||||
func HvsockGUIDBroadcast() guid.GUID { // ffffffff-ffff-ffff-ffff-ffffffffffff
|
|
||||||
return guid.GUID{
|
|
||||||
Data1: 0xffffffff,
|
|
||||||
Data2: 0xffff,
|
|
||||||
Data3: 0xffff,
|
|
||||||
Data4: [8]uint8{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// HvsockGUIDLoopback is the Loopback VmId for accepting connections to the same partition as the connector.
|
|
||||||
func HvsockGUIDLoopback() guid.GUID { // e0e16197-dd56-4a10-9195-5ee7a155a838
|
|
||||||
return guid.GUID{
|
|
||||||
Data1: 0xe0e16197,
|
|
||||||
Data2: 0xdd56,
|
|
||||||
Data3: 0x4a10,
|
|
||||||
Data4: [8]uint8{0x91, 0x95, 0x5e, 0xe7, 0xa1, 0x55, 0xa8, 0x38},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// HvsockGUIDSiloHost is the address of a silo's host partition:
|
|
||||||
// - The silo host of a hosted silo is the utility VM.
|
|
||||||
// - The silo host of a silo on a physical host is the physical host.
|
|
||||||
func HvsockGUIDSiloHost() guid.GUID { // 36bd0c5c-7276-4223-88ba-7d03b654c568
|
|
||||||
return guid.GUID{
|
|
||||||
Data1: 0x36bd0c5c,
|
|
||||||
Data2: 0x7276,
|
|
||||||
Data3: 0x4223,
|
|
||||||
Data4: [8]byte{0x88, 0xba, 0x7d, 0x03, 0xb6, 0x54, 0xc5, 0x68},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// HvsockGUIDChildren is the wildcard VmId for accepting connections from the connector's child partitions.
|
|
||||||
func HvsockGUIDChildren() guid.GUID { // 90db8b89-0d35-4f79-8ce9-49ea0ac8b7cd
|
|
||||||
return guid.GUID{
|
|
||||||
Data1: 0x90db8b89,
|
|
||||||
Data2: 0xd35,
|
|
||||||
Data3: 0x4f79,
|
|
||||||
Data4: [8]uint8{0x8c, 0xe9, 0x49, 0xea, 0xa, 0xc8, 0xb7, 0xcd},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// HvsockGUIDParent is the wildcard VmId for accepting connections from the connector's parent partition.
|
|
||||||
// Listening on this VmId accepts connection from:
|
|
||||||
// - Inside silos: silo host partition.
|
|
||||||
// - Inside hosted silo: host of the VM.
|
|
||||||
// - Inside VM: VM host.
|
|
||||||
// - Physical host: Not supported.
|
|
||||||
func HvsockGUIDParent() guid.GUID { // a42e7cda-d03f-480c-9cc2-a4de20abb878
|
|
||||||
return guid.GUID{
|
|
||||||
Data1: 0xa42e7cda,
|
|
||||||
Data2: 0xd03f,
|
|
||||||
Data3: 0x480c,
|
|
||||||
Data4: [8]uint8{0x9c, 0xc2, 0xa4, 0xde, 0x20, 0xab, 0xb8, 0x78},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// hvsockVsockServiceTemplate is the Service GUID used for the VSOCK protocol.
|
|
||||||
func hvsockVsockServiceTemplate() guid.GUID { // 00000000-facb-11e6-bd58-64006a7986d3
|
|
||||||
return guid.GUID{
|
|
||||||
Data2: 0xfacb,
|
|
||||||
Data3: 0x11e6,
|
|
||||||
Data4: [8]uint8{0xbd, 0x58, 0x64, 0x00, 0x6a, 0x79, 0x86, 0xd3},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// An HvsockAddr is an address for a AF_HYPERV socket.
|
|
||||||
type HvsockAddr struct {
|
|
||||||
VMID guid.GUID
|
|
||||||
ServiceID guid.GUID
|
|
||||||
}
|
|
||||||
|
|
||||||
type rawHvsockAddr struct {
|
|
||||||
Family uint16
|
|
||||||
_ uint16
|
|
||||||
VMID guid.GUID
|
|
||||||
ServiceID guid.GUID
|
|
||||||
}
|
|
||||||
|
|
||||||
var _ socket.RawSockaddr = &rawHvsockAddr{}
|
|
||||||
|
|
||||||
// Network returns the address's network name, "hvsock".
|
|
||||||
func (*HvsockAddr) Network() string {
|
|
||||||
return "hvsock"
|
|
||||||
}
|
|
||||||
|
|
||||||
func (addr *HvsockAddr) String() string {
|
|
||||||
return fmt.Sprintf("%s:%s", &addr.VMID, &addr.ServiceID)
|
|
||||||
}
|
|
||||||
|
|
||||||
// VsockServiceID returns an hvsock service ID corresponding to the specified AF_VSOCK port.
|
|
||||||
func VsockServiceID(port uint32) guid.GUID {
|
|
||||||
g := hvsockVsockServiceTemplate() // make a copy
|
|
||||||
g.Data1 = port
|
|
||||||
return g
|
|
||||||
}
|
|
||||||
|
|
||||||
func (addr *HvsockAddr) raw() rawHvsockAddr {
|
|
||||||
return rawHvsockAddr{
|
|
||||||
Family: afHVSock,
|
|
||||||
VMID: addr.VMID,
|
|
||||||
ServiceID: addr.ServiceID,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (addr *HvsockAddr) fromRaw(raw *rawHvsockAddr) {
|
|
||||||
addr.VMID = raw.VMID
|
|
||||||
addr.ServiceID = raw.ServiceID
|
|
||||||
}
|
|
||||||
|
|
||||||
// Sockaddr returns a pointer to and the size of this struct.
|
|
||||||
//
|
|
||||||
// Implements the [socket.RawSockaddr] interface, and allows use in
|
|
||||||
// [socket.Bind] and [socket.ConnectEx].
|
|
||||||
func (r *rawHvsockAddr) Sockaddr() (unsafe.Pointer, int32, error) {
|
|
||||||
return unsafe.Pointer(r), int32(unsafe.Sizeof(rawHvsockAddr{})), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Sockaddr interface allows use with `sockets.Bind()` and `.ConnectEx()`.
|
|
||||||
func (r *rawHvsockAddr) FromBytes(b []byte) error {
|
|
||||||
n := int(unsafe.Sizeof(rawHvsockAddr{}))
|
|
||||||
|
|
||||||
if len(b) < n {
|
|
||||||
return fmt.Errorf("got %d, want %d: %w", len(b), n, socket.ErrBufferSize)
|
|
||||||
}
|
|
||||||
|
|
||||||
copy(unsafe.Slice((*byte)(unsafe.Pointer(r)), n), b[:n])
|
|
||||||
if r.Family != afHVSock {
|
|
||||||
return fmt.Errorf("got %d, want %d: %w", r.Family, afHVSock, socket.ErrAddrFamily)
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// HvsockListener is a socket listener for the AF_HYPERV address family.
|
|
||||||
type HvsockListener struct {
|
|
||||||
sock *win32File
|
|
||||||
addr HvsockAddr
|
|
||||||
}
|
|
||||||
|
|
||||||
var _ net.Listener = &HvsockListener{}
|
|
||||||
|
|
||||||
// HvsockConn is a connected socket of the AF_HYPERV address family.
|
|
||||||
type HvsockConn struct {
|
|
||||||
sock *win32File
|
|
||||||
local, remote HvsockAddr
|
|
||||||
}
|
|
||||||
|
|
||||||
var _ net.Conn = &HvsockConn{}
|
|
||||||
|
|
||||||
func newHVSocket() (*win32File, error) {
|
|
||||||
fd, err := syscall.Socket(afHVSock, syscall.SOCK_STREAM, 1)
|
|
||||||
if err != nil {
|
|
||||||
return nil, os.NewSyscallError("socket", err)
|
|
||||||
}
|
|
||||||
f, err := makeWin32File(fd)
|
|
||||||
if err != nil {
|
|
||||||
syscall.Close(fd)
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
f.socket = true
|
|
||||||
return f, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ListenHvsock listens for connections on the specified hvsock address.
|
|
||||||
func ListenHvsock(addr *HvsockAddr) (_ *HvsockListener, err error) {
|
|
||||||
l := &HvsockListener{addr: *addr}
|
|
||||||
sock, err := newHVSocket()
|
|
||||||
if err != nil {
|
|
||||||
return nil, l.opErr("listen", err)
|
|
||||||
}
|
|
||||||
sa := addr.raw()
|
|
||||||
err = socket.Bind(windows.Handle(sock.handle), &sa)
|
|
||||||
if err != nil {
|
|
||||||
return nil, l.opErr("listen", os.NewSyscallError("socket", err))
|
|
||||||
}
|
|
||||||
err = syscall.Listen(sock.handle, 16)
|
|
||||||
if err != nil {
|
|
||||||
return nil, l.opErr("listen", os.NewSyscallError("listen", err))
|
|
||||||
}
|
|
||||||
return &HvsockListener{sock: sock, addr: *addr}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *HvsockListener) opErr(op string, err error) error {
|
|
||||||
return &net.OpError{Op: op, Net: "hvsock", Addr: &l.addr, Err: err}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Addr returns the listener's network address.
|
|
||||||
func (l *HvsockListener) Addr() net.Addr {
|
|
||||||
return &l.addr
|
|
||||||
}
|
|
||||||
|
|
||||||
// Accept waits for the next connection and returns it.
|
|
||||||
func (l *HvsockListener) Accept() (_ net.Conn, err error) {
|
|
||||||
sock, err := newHVSocket()
|
|
||||||
if err != nil {
|
|
||||||
return nil, l.opErr("accept", err)
|
|
||||||
}
|
|
||||||
defer func() {
|
|
||||||
if sock != nil {
|
|
||||||
sock.Close()
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
c, err := l.sock.prepareIO()
|
|
||||||
if err != nil {
|
|
||||||
return nil, l.opErr("accept", err)
|
|
||||||
}
|
|
||||||
defer l.sock.wg.Done()
|
|
||||||
|
|
||||||
// AcceptEx, per documentation, requires an extra 16 bytes per address.
|
|
||||||
//
|
|
||||||
// https://docs.microsoft.com/en-us/windows/win32/api/mswsock/nf-mswsock-acceptex
|
|
||||||
const addrlen = uint32(16 + unsafe.Sizeof(rawHvsockAddr{}))
|
|
||||||
var addrbuf [addrlen * 2]byte
|
|
||||||
|
|
||||||
var bytes uint32
|
|
||||||
err = syscall.AcceptEx(l.sock.handle, sock.handle, &addrbuf[0], 0 /* rxdatalen */, addrlen, addrlen, &bytes, &c.o)
|
|
||||||
if _, err = l.sock.asyncIO(c, nil, bytes, err); err != nil {
|
|
||||||
return nil, l.opErr("accept", os.NewSyscallError("acceptex", err))
|
|
||||||
}
|
|
||||||
|
|
||||||
conn := &HvsockConn{
|
|
||||||
sock: sock,
|
|
||||||
}
|
|
||||||
// The local address returned in the AcceptEx buffer is the same as the Listener socket's
|
|
||||||
// address. However, the service GUID reported by GetSockName is different from the Listeners
|
|
||||||
// socket, and is sometimes the same as the local address of the socket that dialed the
|
|
||||||
// address, with the service GUID.Data1 incremented, but othertimes is different.
|
|
||||||
// todo: does the local address matter? is the listener's address or the actual address appropriate?
|
|
||||||
conn.local.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[0])))
|
|
||||||
conn.remote.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[addrlen])))
|
|
||||||
|
|
||||||
// initialize the accepted socket and update its properties with those of the listening socket
|
|
||||||
if err = windows.Setsockopt(windows.Handle(sock.handle),
|
|
||||||
windows.SOL_SOCKET, windows.SO_UPDATE_ACCEPT_CONTEXT,
|
|
||||||
(*byte)(unsafe.Pointer(&l.sock.handle)), int32(unsafe.Sizeof(l.sock.handle))); err != nil {
|
|
||||||
return nil, conn.opErr("accept", os.NewSyscallError("setsockopt", err))
|
|
||||||
}
|
|
||||||
|
|
||||||
sock = nil
|
|
||||||
return conn, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close closes the listener, causing any pending Accept calls to fail.
|
|
||||||
func (l *HvsockListener) Close() error {
|
|
||||||
return l.sock.Close()
|
|
||||||
}
|
|
||||||
|
|
||||||
// HvsockDialer configures and dials a Hyper-V Socket (ie, [HvsockConn]).
|
|
||||||
type HvsockDialer struct {
|
|
||||||
// Deadline is the time the Dial operation must connect before erroring.
|
|
||||||
Deadline time.Time
|
|
||||||
|
|
||||||
// Retries is the number of additional connects to try if the connection times out, is refused,
|
|
||||||
// or the host is unreachable
|
|
||||||
Retries uint
|
|
||||||
|
|
||||||
// RetryWait is the time to wait after a connection error to retry
|
|
||||||
RetryWait time.Duration
|
|
||||||
|
|
||||||
rt *time.Timer // redial wait timer
|
|
||||||
}
|
|
||||||
|
|
||||||
// Dial the Hyper-V socket at addr.
|
|
||||||
//
|
|
||||||
// See [HvsockDialer.Dial] for more information.
|
|
||||||
func Dial(ctx context.Context, addr *HvsockAddr) (conn *HvsockConn, err error) {
|
|
||||||
return (&HvsockDialer{}).Dial(ctx, addr)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Dial attempts to connect to the Hyper-V socket at addr, and returns a connection if successful.
|
|
||||||
// Will attempt (HvsockDialer).Retries if dialing fails, waiting (HvsockDialer).RetryWait between
|
|
||||||
// retries.
|
|
||||||
//
|
|
||||||
// Dialing can be cancelled either by providing (HvsockDialer).Deadline, or cancelling ctx.
|
|
||||||
func (d *HvsockDialer) Dial(ctx context.Context, addr *HvsockAddr) (conn *HvsockConn, err error) {
|
|
||||||
op := "dial"
|
|
||||||
// create the conn early to use opErr()
|
|
||||||
conn = &HvsockConn{
|
|
||||||
remote: *addr,
|
|
||||||
}
|
|
||||||
|
|
||||||
if !d.Deadline.IsZero() {
|
|
||||||
var cancel context.CancelFunc
|
|
||||||
ctx, cancel = context.WithDeadline(ctx, d.Deadline)
|
|
||||||
defer cancel()
|
|
||||||
}
|
|
||||||
|
|
||||||
// preemptive timeout/cancellation check
|
|
||||||
if err = ctx.Err(); err != nil {
|
|
||||||
return nil, conn.opErr(op, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
sock, err := newHVSocket()
|
|
||||||
if err != nil {
|
|
||||||
return nil, conn.opErr(op, err)
|
|
||||||
}
|
|
||||||
defer func() {
|
|
||||||
if sock != nil {
|
|
||||||
sock.Close()
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
|
|
||||||
sa := addr.raw()
|
|
||||||
err = socket.Bind(windows.Handle(sock.handle), &sa)
|
|
||||||
if err != nil {
|
|
||||||
return nil, conn.opErr(op, os.NewSyscallError("bind", err))
|
|
||||||
}
|
|
||||||
|
|
||||||
c, err := sock.prepareIO()
|
|
||||||
if err != nil {
|
|
||||||
return nil, conn.opErr(op, err)
|
|
||||||
}
|
|
||||||
defer sock.wg.Done()
|
|
||||||
var bytes uint32
|
|
||||||
for i := uint(0); i <= d.Retries; i++ {
|
|
||||||
err = socket.ConnectEx(
|
|
||||||
windows.Handle(sock.handle),
|
|
||||||
&sa,
|
|
||||||
nil, // sendBuf
|
|
||||||
0, // sendDataLen
|
|
||||||
&bytes,
|
|
||||||
(*windows.Overlapped)(unsafe.Pointer(&c.o)))
|
|
||||||
_, err = sock.asyncIO(c, nil, bytes, err)
|
|
||||||
if i < d.Retries && canRedial(err) {
|
|
||||||
if err = d.redialWait(ctx); err == nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
return nil, conn.opErr(op, os.NewSyscallError("connectex", err))
|
|
||||||
}
|
|
||||||
|
|
||||||
// update the connection properties, so shutdown can be used
|
|
||||||
if err = windows.Setsockopt(
|
|
||||||
windows.Handle(sock.handle),
|
|
||||||
windows.SOL_SOCKET,
|
|
||||||
windows.SO_UPDATE_CONNECT_CONTEXT,
|
|
||||||
nil, // optvalue
|
|
||||||
0, // optlen
|
|
||||||
); err != nil {
|
|
||||||
return nil, conn.opErr(op, os.NewSyscallError("setsockopt", err))
|
|
||||||
}
|
|
||||||
|
|
||||||
// get the local name
|
|
||||||
var sal rawHvsockAddr
|
|
||||||
err = socket.GetSockName(windows.Handle(sock.handle), &sal)
|
|
||||||
if err != nil {
|
|
||||||
return nil, conn.opErr(op, os.NewSyscallError("getsockname", err))
|
|
||||||
}
|
|
||||||
conn.local.fromRaw(&sal)
|
|
||||||
|
|
||||||
// one last check for timeout, since asyncIO doesn't check the context
|
|
||||||
if err = ctx.Err(); err != nil {
|
|
||||||
return nil, conn.opErr(op, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
conn.sock = sock
|
|
||||||
sock = nil
|
|
||||||
|
|
||||||
return conn, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// redialWait waits before attempting to redial, resetting the timer as appropriate.
|
|
||||||
func (d *HvsockDialer) redialWait(ctx context.Context) (err error) {
|
|
||||||
if d.RetryWait == 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
if d.rt == nil {
|
|
||||||
d.rt = time.NewTimer(d.RetryWait)
|
|
||||||
} else {
|
|
||||||
// should already be stopped and drained
|
|
||||||
d.rt.Reset(d.RetryWait)
|
|
||||||
}
|
|
||||||
|
|
||||||
select {
|
|
||||||
case <-ctx.Done():
|
|
||||||
case <-d.rt.C:
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// stop and drain the timer
|
|
||||||
if !d.rt.Stop() {
|
|
||||||
<-d.rt.C
|
|
||||||
}
|
|
||||||
return ctx.Err()
|
|
||||||
}
|
|
||||||
|
|
||||||
// assumes error is a plain, unwrapped syscall.Errno provided by direct syscall.
|
|
||||||
func canRedial(err error) bool {
|
|
||||||
//nolint:errorlint // guaranteed to be an Errno
|
|
||||||
switch err {
|
|
||||||
case windows.WSAECONNREFUSED, windows.WSAENETUNREACH, windows.WSAETIMEDOUT,
|
|
||||||
windows.ERROR_CONNECTION_REFUSED, windows.ERROR_CONNECTION_UNAVAIL:
|
|
||||||
return true
|
|
||||||
default:
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *HvsockConn) opErr(op string, err error) error {
|
|
||||||
// translate from "file closed" to "socket closed"
|
|
||||||
if errors.Is(err, ErrFileClosed) {
|
|
||||||
err = socket.ErrSocketClosed
|
|
||||||
}
|
|
||||||
return &net.OpError{Op: op, Net: "hvsock", Source: &conn.local, Addr: &conn.remote, Err: err}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *HvsockConn) Read(b []byte) (int, error) {
|
|
||||||
c, err := conn.sock.prepareIO()
|
|
||||||
if err != nil {
|
|
||||||
return 0, conn.opErr("read", err)
|
|
||||||
}
|
|
||||||
defer conn.sock.wg.Done()
|
|
||||||
buf := syscall.WSABuf{Buf: &b[0], Len: uint32(len(b))}
|
|
||||||
var flags, bytes uint32
|
|
||||||
err = syscall.WSARecv(conn.sock.handle, &buf, 1, &bytes, &flags, &c.o, nil)
|
|
||||||
n, err := conn.sock.asyncIO(c, &conn.sock.readDeadline, bytes, err)
|
|
||||||
if err != nil {
|
|
||||||
var eno windows.Errno
|
|
||||||
if errors.As(err, &eno) {
|
|
||||||
err = os.NewSyscallError("wsarecv", eno)
|
|
||||||
}
|
|
||||||
return 0, conn.opErr("read", err)
|
|
||||||
} else if n == 0 {
|
|
||||||
err = io.EOF
|
|
||||||
}
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *HvsockConn) Write(b []byte) (int, error) {
|
|
||||||
t := 0
|
|
||||||
for len(b) != 0 {
|
|
||||||
n, err := conn.write(b)
|
|
||||||
if err != nil {
|
|
||||||
return t + n, err
|
|
||||||
}
|
|
||||||
t += n
|
|
||||||
b = b[n:]
|
|
||||||
}
|
|
||||||
return t, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *HvsockConn) write(b []byte) (int, error) {
|
|
||||||
c, err := conn.sock.prepareIO()
|
|
||||||
if err != nil {
|
|
||||||
return 0, conn.opErr("write", err)
|
|
||||||
}
|
|
||||||
defer conn.sock.wg.Done()
|
|
||||||
buf := syscall.WSABuf{Buf: &b[0], Len: uint32(len(b))}
|
|
||||||
var bytes uint32
|
|
||||||
err = syscall.WSASend(conn.sock.handle, &buf, 1, &bytes, 0, &c.o, nil)
|
|
||||||
n, err := conn.sock.asyncIO(c, &conn.sock.writeDeadline, bytes, err)
|
|
||||||
if err != nil {
|
|
||||||
var eno windows.Errno
|
|
||||||
if errors.As(err, &eno) {
|
|
||||||
err = os.NewSyscallError("wsasend", eno)
|
|
||||||
}
|
|
||||||
return 0, conn.opErr("write", err)
|
|
||||||
}
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close closes the socket connection, failing any pending read or write calls.
|
|
||||||
func (conn *HvsockConn) Close() error {
|
|
||||||
return conn.sock.Close()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *HvsockConn) IsClosed() bool {
|
|
||||||
return conn.sock.IsClosed()
|
|
||||||
}
|
|
||||||
|
|
||||||
// shutdown disables sending or receiving on a socket.
|
|
||||||
func (conn *HvsockConn) shutdown(how int) error {
|
|
||||||
if conn.IsClosed() {
|
|
||||||
return socket.ErrSocketClosed
|
|
||||||
}
|
|
||||||
|
|
||||||
err := syscall.Shutdown(conn.sock.handle, how)
|
|
||||||
if err != nil {
|
|
||||||
// If the connection was closed, shutdowns fail with "not connected"
|
|
||||||
if errors.Is(err, windows.WSAENOTCONN) ||
|
|
||||||
errors.Is(err, windows.WSAESHUTDOWN) {
|
|
||||||
err = socket.ErrSocketClosed
|
|
||||||
}
|
|
||||||
return os.NewSyscallError("shutdown", err)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// CloseRead shuts down the read end of the socket, preventing future read operations.
|
|
||||||
func (conn *HvsockConn) CloseRead() error {
|
|
||||||
err := conn.shutdown(syscall.SHUT_RD)
|
|
||||||
if err != nil {
|
|
||||||
return conn.opErr("closeread", err)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// CloseWrite shuts down the write end of the socket, preventing future write operations and
|
|
||||||
// notifying the other endpoint that no more data will be written.
|
|
||||||
func (conn *HvsockConn) CloseWrite() error {
|
|
||||||
err := conn.shutdown(syscall.SHUT_WR)
|
|
||||||
if err != nil {
|
|
||||||
return conn.opErr("closewrite", err)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// LocalAddr returns the local address of the connection.
|
|
||||||
func (conn *HvsockConn) LocalAddr() net.Addr {
|
|
||||||
return &conn.local
|
|
||||||
}
|
|
||||||
|
|
||||||
// RemoteAddr returns the remote address of the connection.
|
|
||||||
func (conn *HvsockConn) RemoteAddr() net.Addr {
|
|
||||||
return &conn.remote
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetDeadline implements the net.Conn SetDeadline method.
|
|
||||||
func (conn *HvsockConn) SetDeadline(t time.Time) error {
|
|
||||||
// todo: implement `SetDeadline` for `win32File`
|
|
||||||
if err := conn.SetReadDeadline(t); err != nil {
|
|
||||||
return fmt.Errorf("set read deadline: %w", err)
|
|
||||||
}
|
|
||||||
if err := conn.SetWriteDeadline(t); err != nil {
|
|
||||||
return fmt.Errorf("set write deadline: %w", err)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetReadDeadline implements the net.Conn SetReadDeadline method.
|
|
||||||
func (conn *HvsockConn) SetReadDeadline(t time.Time) error {
|
|
||||||
return conn.sock.SetReadDeadline(t)
|
|
||||||
}
|
|
||||||
|
|
||||||
// SetWriteDeadline implements the net.Conn SetWriteDeadline method.
|
|
||||||
func (conn *HvsockConn) SetWriteDeadline(t time.Time) error {
|
|
||||||
return conn.sock.SetWriteDeadline(t)
|
|
||||||
}
|
|
||||||
@ -1,2 +0,0 @@
|
|||||||
// This package contains Win32 filesystem functionality.
|
|
||||||
package fs
|
|
||||||
@ -1,202 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
|
|
||||||
package fs
|
|
||||||
|
|
||||||
import (
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
|
|
||||||
"github.com/Microsoft/go-winio/internal/stringbuffer"
|
|
||||||
)
|
|
||||||
|
|
||||||
//go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go fs.go
|
|
||||||
|
|
||||||
// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
|
|
||||||
//sys CreateFile(name string, access AccessMask, mode FileShareMode, sa *syscall.SecurityAttributes, createmode FileCreationDisposition, attrs FileFlagOrAttribute, templatefile windows.Handle) (handle windows.Handle, err error) [failretval==windows.InvalidHandle] = CreateFileW
|
|
||||||
|
|
||||||
const NullHandle windows.Handle = 0
|
|
||||||
|
|
||||||
// AccessMask defines standard, specific, and generic rights.
|
|
||||||
//
|
|
||||||
// Bitmask:
|
|
||||||
// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
|
|
||||||
// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
|
|
||||||
// +---------------+---------------+-------------------------------+
|
|
||||||
// |G|G|G|G|Resvd|A| StandardRights| SpecificRights |
|
|
||||||
// |R|W|E|A| |S| | |
|
|
||||||
// +-+-------------+---------------+-------------------------------+
|
|
||||||
//
|
|
||||||
// GR Generic Read
|
|
||||||
// GW Generic Write
|
|
||||||
// GE Generic Exectue
|
|
||||||
// GA Generic All
|
|
||||||
// Resvd Reserved
|
|
||||||
// AS Access Security System
|
|
||||||
//
|
|
||||||
// https://learn.microsoft.com/en-us/windows/win32/secauthz/access-mask
|
|
||||||
//
|
|
||||||
// https://learn.microsoft.com/en-us/windows/win32/secauthz/generic-access-rights
|
|
||||||
//
|
|
||||||
// https://learn.microsoft.com/en-us/windows/win32/fileio/file-access-rights-constants
|
|
||||||
type AccessMask = windows.ACCESS_MASK
|
|
||||||
|
|
||||||
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
|
|
||||||
const (
|
|
||||||
// Not actually any.
|
|
||||||
//
|
|
||||||
// For CreateFile: "query certain metadata such as file, directory, or device attributes without accessing that file or device"
|
|
||||||
// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew#parameters
|
|
||||||
FILE_ANY_ACCESS AccessMask = 0
|
|
||||||
|
|
||||||
// Specific Object Access
|
|
||||||
// from ntioapi.h
|
|
||||||
|
|
||||||
FILE_READ_DATA AccessMask = (0x0001) // file & pipe
|
|
||||||
FILE_LIST_DIRECTORY AccessMask = (0x0001) // directory
|
|
||||||
|
|
||||||
FILE_WRITE_DATA AccessMask = (0x0002) // file & pipe
|
|
||||||
FILE_ADD_FILE AccessMask = (0x0002) // directory
|
|
||||||
|
|
||||||
FILE_APPEND_DATA AccessMask = (0x0004) // file
|
|
||||||
FILE_ADD_SUBDIRECTORY AccessMask = (0x0004) // directory
|
|
||||||
FILE_CREATE_PIPE_INSTANCE AccessMask = (0x0004) // named pipe
|
|
||||||
|
|
||||||
FILE_READ_EA AccessMask = (0x0008) // file & directory
|
|
||||||
FILE_READ_PROPERTIES AccessMask = FILE_READ_EA
|
|
||||||
|
|
||||||
FILE_WRITE_EA AccessMask = (0x0010) // file & directory
|
|
||||||
FILE_WRITE_PROPERTIES AccessMask = FILE_WRITE_EA
|
|
||||||
|
|
||||||
FILE_EXECUTE AccessMask = (0x0020) // file
|
|
||||||
FILE_TRAVERSE AccessMask = (0x0020) // directory
|
|
||||||
|
|
||||||
FILE_DELETE_CHILD AccessMask = (0x0040) // directory
|
|
||||||
|
|
||||||
FILE_READ_ATTRIBUTES AccessMask = (0x0080) // all
|
|
||||||
|
|
||||||
FILE_WRITE_ATTRIBUTES AccessMask = (0x0100) // all
|
|
||||||
|
|
||||||
FILE_ALL_ACCESS AccessMask = (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF)
|
|
||||||
FILE_GENERIC_READ AccessMask = (STANDARD_RIGHTS_READ | FILE_READ_DATA | FILE_READ_ATTRIBUTES | FILE_READ_EA | SYNCHRONIZE)
|
|
||||||
FILE_GENERIC_WRITE AccessMask = (STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE)
|
|
||||||
FILE_GENERIC_EXECUTE AccessMask = (STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES | FILE_EXECUTE | SYNCHRONIZE)
|
|
||||||
|
|
||||||
SPECIFIC_RIGHTS_ALL AccessMask = 0x0000FFFF
|
|
||||||
|
|
||||||
// Standard Access
|
|
||||||
// from ntseapi.h
|
|
||||||
|
|
||||||
DELETE AccessMask = 0x0001_0000
|
|
||||||
READ_CONTROL AccessMask = 0x0002_0000
|
|
||||||
WRITE_DAC AccessMask = 0x0004_0000
|
|
||||||
WRITE_OWNER AccessMask = 0x0008_0000
|
|
||||||
SYNCHRONIZE AccessMask = 0x0010_0000
|
|
||||||
|
|
||||||
STANDARD_RIGHTS_REQUIRED AccessMask = 0x000F_0000
|
|
||||||
|
|
||||||
STANDARD_RIGHTS_READ AccessMask = READ_CONTROL
|
|
||||||
STANDARD_RIGHTS_WRITE AccessMask = READ_CONTROL
|
|
||||||
STANDARD_RIGHTS_EXECUTE AccessMask = READ_CONTROL
|
|
||||||
|
|
||||||
STANDARD_RIGHTS_ALL AccessMask = 0x001F_0000
|
|
||||||
)
|
|
||||||
|
|
||||||
type FileShareMode uint32
|
|
||||||
|
|
||||||
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
|
|
||||||
const (
|
|
||||||
FILE_SHARE_NONE FileShareMode = 0x00
|
|
||||||
FILE_SHARE_READ FileShareMode = 0x01
|
|
||||||
FILE_SHARE_WRITE FileShareMode = 0x02
|
|
||||||
FILE_SHARE_DELETE FileShareMode = 0x04
|
|
||||||
FILE_SHARE_VALID_FLAGS FileShareMode = 0x07
|
|
||||||
)
|
|
||||||
|
|
||||||
type FileCreationDisposition uint32
|
|
||||||
|
|
||||||
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
|
|
||||||
const (
|
|
||||||
// from winbase.h
|
|
||||||
|
|
||||||
CREATE_NEW FileCreationDisposition = 0x01
|
|
||||||
CREATE_ALWAYS FileCreationDisposition = 0x02
|
|
||||||
OPEN_EXISTING FileCreationDisposition = 0x03
|
|
||||||
OPEN_ALWAYS FileCreationDisposition = 0x04
|
|
||||||
TRUNCATE_EXISTING FileCreationDisposition = 0x05
|
|
||||||
)
|
|
||||||
|
|
||||||
// CreateFile and co. take flags or attributes together as one parameter.
|
|
||||||
// Define alias until we can use generics to allow both
|
|
||||||
|
|
||||||
// https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants
|
|
||||||
type FileFlagOrAttribute uint32
|
|
||||||
|
|
||||||
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
|
|
||||||
const ( // from winnt.h
|
|
||||||
FILE_FLAG_WRITE_THROUGH FileFlagOrAttribute = 0x8000_0000
|
|
||||||
FILE_FLAG_OVERLAPPED FileFlagOrAttribute = 0x4000_0000
|
|
||||||
FILE_FLAG_NO_BUFFERING FileFlagOrAttribute = 0x2000_0000
|
|
||||||
FILE_FLAG_RANDOM_ACCESS FileFlagOrAttribute = 0x1000_0000
|
|
||||||
FILE_FLAG_SEQUENTIAL_SCAN FileFlagOrAttribute = 0x0800_0000
|
|
||||||
FILE_FLAG_DELETE_ON_CLOSE FileFlagOrAttribute = 0x0400_0000
|
|
||||||
FILE_FLAG_BACKUP_SEMANTICS FileFlagOrAttribute = 0x0200_0000
|
|
||||||
FILE_FLAG_POSIX_SEMANTICS FileFlagOrAttribute = 0x0100_0000
|
|
||||||
FILE_FLAG_OPEN_REPARSE_POINT FileFlagOrAttribute = 0x0020_0000
|
|
||||||
FILE_FLAG_OPEN_NO_RECALL FileFlagOrAttribute = 0x0010_0000
|
|
||||||
FILE_FLAG_FIRST_PIPE_INSTANCE FileFlagOrAttribute = 0x0008_0000
|
|
||||||
)
|
|
||||||
|
|
||||||
type FileSQSFlag = FileFlagOrAttribute
|
|
||||||
|
|
||||||
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
|
|
||||||
const ( // from winbase.h
|
|
||||||
SECURITY_ANONYMOUS FileSQSFlag = FileSQSFlag(SecurityAnonymous << 16)
|
|
||||||
SECURITY_IDENTIFICATION FileSQSFlag = FileSQSFlag(SecurityIdentification << 16)
|
|
||||||
SECURITY_IMPERSONATION FileSQSFlag = FileSQSFlag(SecurityImpersonation << 16)
|
|
||||||
SECURITY_DELEGATION FileSQSFlag = FileSQSFlag(SecurityDelegation << 16)
|
|
||||||
|
|
||||||
SECURITY_SQOS_PRESENT FileSQSFlag = 0x00100000
|
|
||||||
SECURITY_VALID_SQOS_FLAGS FileSQSFlag = 0x001F0000
|
|
||||||
)
|
|
||||||
|
|
||||||
// GetFinalPathNameByHandle flags
|
|
||||||
//
|
|
||||||
// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew#parameters
|
|
||||||
type GetFinalPathFlag uint32
|
|
||||||
|
|
||||||
//nolint:revive // SNAKE_CASE is not idiomatic in Go, but aligned with Win32 API.
|
|
||||||
const (
|
|
||||||
GetFinalPathDefaultFlag GetFinalPathFlag = 0x0
|
|
||||||
|
|
||||||
FILE_NAME_NORMALIZED GetFinalPathFlag = 0x0
|
|
||||||
FILE_NAME_OPENED GetFinalPathFlag = 0x8
|
|
||||||
|
|
||||||
VOLUME_NAME_DOS GetFinalPathFlag = 0x0
|
|
||||||
VOLUME_NAME_GUID GetFinalPathFlag = 0x1
|
|
||||||
VOLUME_NAME_NT GetFinalPathFlag = 0x2
|
|
||||||
VOLUME_NAME_NONE GetFinalPathFlag = 0x4
|
|
||||||
)
|
|
||||||
|
|
||||||
// getFinalPathNameByHandle facilitates calling the Windows API GetFinalPathNameByHandle
|
|
||||||
// with the given handle and flags. It transparently takes care of creating a buffer of the
|
|
||||||
// correct size for the call.
|
|
||||||
//
|
|
||||||
// https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew
|
|
||||||
func GetFinalPathNameByHandle(h windows.Handle, flags GetFinalPathFlag) (string, error) {
|
|
||||||
b := stringbuffer.NewWString()
|
|
||||||
//TODO: can loop infinitely if Win32 keeps returning the same (or a larger) n?
|
|
||||||
for {
|
|
||||||
n, err := windows.GetFinalPathNameByHandle(h, b.Pointer(), b.Cap(), uint32(flags))
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
// If the buffer wasn't large enough, n will be the total size needed (including null terminator).
|
|
||||||
// Resize and try again.
|
|
||||||
if n > b.Cap() {
|
|
||||||
b.ResizeTo(n)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
// If the buffer is large enough, n will be the size not including the null terminator.
|
|
||||||
// Convert to a Go string and return.
|
|
||||||
return b.String(), nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,12 +0,0 @@
|
|||||||
package fs
|
|
||||||
|
|
||||||
// https://learn.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level
|
|
||||||
type SecurityImpersonationLevel int32 // C default enums underlying type is `int`, which is Go `int32`
|
|
||||||
|
|
||||||
// Impersonation levels
|
|
||||||
const (
|
|
||||||
SecurityAnonymous SecurityImpersonationLevel = 0
|
|
||||||
SecurityIdentification SecurityImpersonationLevel = 1
|
|
||||||
SecurityImpersonation SecurityImpersonationLevel = 2
|
|
||||||
SecurityDelegation SecurityImpersonationLevel = 3
|
|
||||||
)
|
|
||||||
@ -1,64 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
|
|
||||||
// Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
|
|
||||||
|
|
||||||
package fs
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
var _ unsafe.Pointer
|
|
||||||
|
|
||||||
// Do the interface allocations only once for common
|
|
||||||
// Errno values.
|
|
||||||
const (
|
|
||||||
errnoERROR_IO_PENDING = 997
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
|
|
||||||
errERROR_EINVAL error = syscall.EINVAL
|
|
||||||
)
|
|
||||||
|
|
||||||
// errnoErr returns common boxed Errno values, to prevent
|
|
||||||
// allocations at runtime.
|
|
||||||
func errnoErr(e syscall.Errno) error {
|
|
||||||
switch e {
|
|
||||||
case 0:
|
|
||||||
return errERROR_EINVAL
|
|
||||||
case errnoERROR_IO_PENDING:
|
|
||||||
return errERROR_IO_PENDING
|
|
||||||
}
|
|
||||||
// TODO: add more here, after collecting data on the common
|
|
||||||
// error values see on Windows. (perhaps when running
|
|
||||||
// all.bat?)
|
|
||||||
return e
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
|
|
||||||
|
|
||||||
procCreateFileW = modkernel32.NewProc("CreateFileW")
|
|
||||||
)
|
|
||||||
|
|
||||||
func CreateFile(name string, access AccessMask, mode FileShareMode, sa *syscall.SecurityAttributes, createmode FileCreationDisposition, attrs FileFlagOrAttribute, templatefile windows.Handle) (handle windows.Handle, err error) {
|
|
||||||
var _p0 *uint16
|
|
||||||
_p0, err = syscall.UTF16PtrFromString(name)
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
return _CreateFile(_p0, access, mode, sa, createmode, attrs, templatefile)
|
|
||||||
}
|
|
||||||
|
|
||||||
func _CreateFile(name *uint16, access AccessMask, mode FileShareMode, sa *syscall.SecurityAttributes, createmode FileCreationDisposition, attrs FileFlagOrAttribute, templatefile windows.Handle) (handle windows.Handle, err error) {
|
|
||||||
r0, _, e1 := syscall.Syscall9(procCreateFileW.Addr(), 7, uintptr(unsafe.Pointer(name)), uintptr(access), uintptr(mode), uintptr(unsafe.Pointer(sa)), uintptr(createmode), uintptr(attrs), uintptr(templatefile), 0, 0)
|
|
||||||
handle = windows.Handle(r0)
|
|
||||||
if handle == windows.InvalidHandle {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
@ -1,20 +0,0 @@
|
|||||||
package socket
|
|
||||||
|
|
||||||
import (
|
|
||||||
"unsafe"
|
|
||||||
)
|
|
||||||
|
|
||||||
// RawSockaddr allows structs to be used with [Bind] and [ConnectEx]. The
|
|
||||||
// struct must meet the Win32 sockaddr requirements specified here:
|
|
||||||
// https://docs.microsoft.com/en-us/windows/win32/winsock/sockaddr-2
|
|
||||||
//
|
|
||||||
// Specifically, the struct size must be least larger than an int16 (unsigned short)
|
|
||||||
// for the address family.
|
|
||||||
type RawSockaddr interface {
|
|
||||||
// Sockaddr returns a pointer to the RawSockaddr and its struct size, allowing
|
|
||||||
// for the RawSockaddr's data to be overwritten by syscalls (if necessary).
|
|
||||||
//
|
|
||||||
// It is the callers responsibility to validate that the values are valid; invalid
|
|
||||||
// pointers or size can cause a panic.
|
|
||||||
Sockaddr() (unsafe.Pointer, int32, error)
|
|
||||||
}
|
|
||||||
@ -1,179 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
|
|
||||||
package socket
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"net"
|
|
||||||
"sync"
|
|
||||||
"syscall"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"github.com/Microsoft/go-winio/pkg/guid"
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
//go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go socket.go
|
|
||||||
|
|
||||||
//sys getsockname(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) [failretval==socketError] = ws2_32.getsockname
|
|
||||||
//sys getpeername(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) [failretval==socketError] = ws2_32.getpeername
|
|
||||||
//sys bind(s windows.Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socketError] = ws2_32.bind
|
|
||||||
|
|
||||||
const socketError = uintptr(^uint32(0))
|
|
||||||
|
|
||||||
var (
|
|
||||||
// todo(helsaawy): create custom error types to store the desired vs actual size and addr family?
|
|
||||||
|
|
||||||
ErrBufferSize = errors.New("buffer size")
|
|
||||||
ErrAddrFamily = errors.New("address family")
|
|
||||||
ErrInvalidPointer = errors.New("invalid pointer")
|
|
||||||
ErrSocketClosed = fmt.Errorf("socket closed: %w", net.ErrClosed)
|
|
||||||
)
|
|
||||||
|
|
||||||
// todo(helsaawy): replace these with generics, ie: GetSockName[S RawSockaddr](s windows.Handle) (S, error)
|
|
||||||
|
|
||||||
// GetSockName writes the local address of socket s to the [RawSockaddr] rsa.
|
|
||||||
// If rsa is not large enough, the [windows.WSAEFAULT] is returned.
|
|
||||||
func GetSockName(s windows.Handle, rsa RawSockaddr) error {
|
|
||||||
ptr, l, err := rsa.Sockaddr()
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("could not retrieve socket pointer and size: %w", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// although getsockname returns WSAEFAULT if the buffer is too small, it does not set
|
|
||||||
// &l to the correct size, so--apart from doubling the buffer repeatedly--there is no remedy
|
|
||||||
return getsockname(s, ptr, &l)
|
|
||||||
}
|
|
||||||
|
|
||||||
// GetPeerName returns the remote address the socket is connected to.
|
|
||||||
//
|
|
||||||
// See [GetSockName] for more information.
|
|
||||||
func GetPeerName(s windows.Handle, rsa RawSockaddr) error {
|
|
||||||
ptr, l, err := rsa.Sockaddr()
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("could not retrieve socket pointer and size: %w", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
return getpeername(s, ptr, &l)
|
|
||||||
}
|
|
||||||
|
|
||||||
func Bind(s windows.Handle, rsa RawSockaddr) (err error) {
|
|
||||||
ptr, l, err := rsa.Sockaddr()
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("could not retrieve socket pointer and size: %w", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
return bind(s, ptr, l)
|
|
||||||
}
|
|
||||||
|
|
||||||
// "golang.org/x/sys/windows".ConnectEx and .Bind only accept internal implementations of the
|
|
||||||
// their sockaddr interface, so they cannot be used with HvsockAddr
|
|
||||||
// Replicate functionality here from
|
|
||||||
// https://cs.opensource.google/go/x/sys/+/master:windows/syscall_windows.go
|
|
||||||
|
|
||||||
// The function pointers to `AcceptEx`, `ConnectEx` and `GetAcceptExSockaddrs` must be loaded at
|
|
||||||
// runtime via a WSAIoctl call:
|
|
||||||
// https://docs.microsoft.com/en-us/windows/win32/api/Mswsock/nc-mswsock-lpfn_connectex#remarks
|
|
||||||
|
|
||||||
type runtimeFunc struct {
|
|
||||||
id guid.GUID
|
|
||||||
once sync.Once
|
|
||||||
addr uintptr
|
|
||||||
err error
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *runtimeFunc) Load() error {
|
|
||||||
f.once.Do(func() {
|
|
||||||
var s windows.Handle
|
|
||||||
s, f.err = windows.Socket(windows.AF_INET, windows.SOCK_STREAM, windows.IPPROTO_TCP)
|
|
||||||
if f.err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
defer windows.CloseHandle(s) //nolint:errcheck
|
|
||||||
|
|
||||||
var n uint32
|
|
||||||
f.err = windows.WSAIoctl(s,
|
|
||||||
windows.SIO_GET_EXTENSION_FUNCTION_POINTER,
|
|
||||||
(*byte)(unsafe.Pointer(&f.id)),
|
|
||||||
uint32(unsafe.Sizeof(f.id)),
|
|
||||||
(*byte)(unsafe.Pointer(&f.addr)),
|
|
||||||
uint32(unsafe.Sizeof(f.addr)),
|
|
||||||
&n,
|
|
||||||
nil, // overlapped
|
|
||||||
0, // completionRoutine
|
|
||||||
)
|
|
||||||
})
|
|
||||||
return f.err
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
// todo: add `AcceptEx` and `GetAcceptExSockaddrs`
|
|
||||||
WSAID_CONNECTEX = guid.GUID{ //revive:disable-line:var-naming ALL_CAPS
|
|
||||||
Data1: 0x25a207b9,
|
|
||||||
Data2: 0xddf3,
|
|
||||||
Data3: 0x4660,
|
|
||||||
Data4: [8]byte{0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e},
|
|
||||||
}
|
|
||||||
|
|
||||||
connectExFunc = runtimeFunc{id: WSAID_CONNECTEX}
|
|
||||||
)
|
|
||||||
|
|
||||||
func ConnectEx(
|
|
||||||
fd windows.Handle,
|
|
||||||
rsa RawSockaddr,
|
|
||||||
sendBuf *byte,
|
|
||||||
sendDataLen uint32,
|
|
||||||
bytesSent *uint32,
|
|
||||||
overlapped *windows.Overlapped,
|
|
||||||
) error {
|
|
||||||
if err := connectExFunc.Load(); err != nil {
|
|
||||||
return fmt.Errorf("failed to load ConnectEx function pointer: %w", err)
|
|
||||||
}
|
|
||||||
ptr, n, err := rsa.Sockaddr()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return connectEx(fd, ptr, n, sendBuf, sendDataLen, bytesSent, overlapped)
|
|
||||||
}
|
|
||||||
|
|
||||||
// BOOL LpfnConnectex(
|
|
||||||
// [in] SOCKET s,
|
|
||||||
// [in] const sockaddr *name,
|
|
||||||
// [in] int namelen,
|
|
||||||
// [in, optional] PVOID lpSendBuffer,
|
|
||||||
// [in] DWORD dwSendDataLength,
|
|
||||||
// [out] LPDWORD lpdwBytesSent,
|
|
||||||
// [in] LPOVERLAPPED lpOverlapped
|
|
||||||
// )
|
|
||||||
|
|
||||||
func connectEx(
|
|
||||||
s windows.Handle,
|
|
||||||
name unsafe.Pointer,
|
|
||||||
namelen int32,
|
|
||||||
sendBuf *byte,
|
|
||||||
sendDataLen uint32,
|
|
||||||
bytesSent *uint32,
|
|
||||||
overlapped *windows.Overlapped,
|
|
||||||
) (err error) {
|
|
||||||
// todo: after upgrading to 1.18, switch from syscall.Syscall9 to syscall.SyscallN
|
|
||||||
r1, _, e1 := syscall.Syscall9(connectExFunc.addr,
|
|
||||||
7,
|
|
||||||
uintptr(s),
|
|
||||||
uintptr(name),
|
|
||||||
uintptr(namelen),
|
|
||||||
uintptr(unsafe.Pointer(sendBuf)),
|
|
||||||
uintptr(sendDataLen),
|
|
||||||
uintptr(unsafe.Pointer(bytesSent)),
|
|
||||||
uintptr(unsafe.Pointer(overlapped)),
|
|
||||||
0,
|
|
||||||
0)
|
|
||||||
if r1 == 0 {
|
|
||||||
if e1 != 0 {
|
|
||||||
err = error(e1)
|
|
||||||
} else {
|
|
||||||
err = syscall.EINVAL
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
@ -1,72 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
|
|
||||||
// Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
|
|
||||||
|
|
||||||
package socket
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
var _ unsafe.Pointer
|
|
||||||
|
|
||||||
// Do the interface allocations only once for common
|
|
||||||
// Errno values.
|
|
||||||
const (
|
|
||||||
errnoERROR_IO_PENDING = 997
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
|
|
||||||
errERROR_EINVAL error = syscall.EINVAL
|
|
||||||
)
|
|
||||||
|
|
||||||
// errnoErr returns common boxed Errno values, to prevent
|
|
||||||
// allocations at runtime.
|
|
||||||
func errnoErr(e syscall.Errno) error {
|
|
||||||
switch e {
|
|
||||||
case 0:
|
|
||||||
return errERROR_EINVAL
|
|
||||||
case errnoERROR_IO_PENDING:
|
|
||||||
return errERROR_IO_PENDING
|
|
||||||
}
|
|
||||||
// TODO: add more here, after collecting data on the common
|
|
||||||
// error values see on Windows. (perhaps when running
|
|
||||||
// all.bat?)
|
|
||||||
return e
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
modws2_32 = windows.NewLazySystemDLL("ws2_32.dll")
|
|
||||||
|
|
||||||
procbind = modws2_32.NewProc("bind")
|
|
||||||
procgetpeername = modws2_32.NewProc("getpeername")
|
|
||||||
procgetsockname = modws2_32.NewProc("getsockname")
|
|
||||||
)
|
|
||||||
|
|
||||||
func bind(s windows.Handle, name unsafe.Pointer, namelen int32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procbind.Addr(), 3, uintptr(s), uintptr(name), uintptr(namelen))
|
|
||||||
if r1 == socketError {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func getpeername(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procgetpeername.Addr(), 3, uintptr(s), uintptr(name), uintptr(unsafe.Pointer(namelen)))
|
|
||||||
if r1 == socketError {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func getsockname(s windows.Handle, name unsafe.Pointer, namelen *int32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procgetsockname.Addr(), 3, uintptr(s), uintptr(name), uintptr(unsafe.Pointer(namelen)))
|
|
||||||
if r1 == socketError {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
@ -1,132 +0,0 @@
|
|||||||
package stringbuffer
|
|
||||||
|
|
||||||
import (
|
|
||||||
"sync"
|
|
||||||
"unicode/utf16"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TODO: worth exporting and using in mkwinsyscall?
|
|
||||||
|
|
||||||
// Uint16BufferSize is the buffer size in the pool, chosen somewhat arbitrarily to accommodate
|
|
||||||
// large path strings:
|
|
||||||
// MAX_PATH (260) + size of volume GUID prefix (49) + null terminator = 310.
|
|
||||||
const MinWStringCap = 310
|
|
||||||
|
|
||||||
// use *[]uint16 since []uint16 creates an extra allocation where the slice header
|
|
||||||
// is copied to heap and then referenced via pointer in the interface header that sync.Pool
|
|
||||||
// stores.
|
|
||||||
var pathPool = sync.Pool{ // if go1.18+ adds Pool[T], use that to store []uint16 directly
|
|
||||||
New: func() interface{} {
|
|
||||||
b := make([]uint16, MinWStringCap)
|
|
||||||
return &b
|
|
||||||
},
|
|
||||||
}
|
|
||||||
|
|
||||||
func newBuffer() []uint16 { return *(pathPool.Get().(*[]uint16)) }
|
|
||||||
|
|
||||||
// freeBuffer copies the slice header data, and puts a pointer to that in the pool.
|
|
||||||
// This avoids taking a pointer to the slice header in WString, which can be set to nil.
|
|
||||||
func freeBuffer(b []uint16) { pathPool.Put(&b) }
|
|
||||||
|
|
||||||
// WString is a wide string buffer ([]uint16) meant for storing UTF-16 encoded strings
|
|
||||||
// for interacting with Win32 APIs.
|
|
||||||
// Sizes are specified as uint32 and not int.
|
|
||||||
//
|
|
||||||
// It is not thread safe.
|
|
||||||
type WString struct {
|
|
||||||
// type-def allows casting to []uint16 directly, use struct to prevent that and allow adding fields in the future.
|
|
||||||
|
|
||||||
// raw buffer
|
|
||||||
b []uint16
|
|
||||||
}
|
|
||||||
|
|
||||||
// NewWString returns a [WString] allocated from a shared pool with an
|
|
||||||
// initial capacity of at least [MinWStringCap].
|
|
||||||
// Since the buffer may have been previously used, its contents are not guaranteed to be empty.
|
|
||||||
//
|
|
||||||
// The buffer should be freed via [WString.Free]
|
|
||||||
func NewWString() *WString {
|
|
||||||
return &WString{
|
|
||||||
b: newBuffer(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (b *WString) Free() {
|
|
||||||
if b.empty() {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
freeBuffer(b.b)
|
|
||||||
b.b = nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ResizeTo grows the buffer to at least c and returns the new capacity, freeing the
|
|
||||||
// previous buffer back into pool.
|
|
||||||
func (b *WString) ResizeTo(c uint32) uint32 {
|
|
||||||
// allready sufficient (or n is 0)
|
|
||||||
if c <= b.Cap() {
|
|
||||||
return b.Cap()
|
|
||||||
}
|
|
||||||
|
|
||||||
if c <= MinWStringCap {
|
|
||||||
c = MinWStringCap
|
|
||||||
}
|
|
||||||
// allocate at-least double buffer size, as is done in [bytes.Buffer] and other places
|
|
||||||
if c <= 2*b.Cap() {
|
|
||||||
c = 2 * b.Cap()
|
|
||||||
}
|
|
||||||
|
|
||||||
b2 := make([]uint16, c)
|
|
||||||
if !b.empty() {
|
|
||||||
copy(b2, b.b)
|
|
||||||
freeBuffer(b.b)
|
|
||||||
}
|
|
||||||
b.b = b2
|
|
||||||
return c
|
|
||||||
}
|
|
||||||
|
|
||||||
// Buffer returns the underlying []uint16 buffer.
|
|
||||||
func (b *WString) Buffer() []uint16 {
|
|
||||||
if b.empty() {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return b.b
|
|
||||||
}
|
|
||||||
|
|
||||||
// Pointer returns a pointer to the first uint16 in the buffer.
|
|
||||||
// If the [WString.Free] has already been called, the pointer will be nil.
|
|
||||||
func (b *WString) Pointer() *uint16 {
|
|
||||||
if b.empty() {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return &b.b[0]
|
|
||||||
}
|
|
||||||
|
|
||||||
// String returns the returns the UTF-8 encoding of the UTF-16 string in the buffer.
|
|
||||||
//
|
|
||||||
// It assumes that the data is null-terminated.
|
|
||||||
func (b *WString) String() string {
|
|
||||||
// Using [windows.UTF16ToString] would require importing "golang.org/x/sys/windows"
|
|
||||||
// and would make this code Windows-only, which makes no sense.
|
|
||||||
// So copy UTF16ToString code into here.
|
|
||||||
// If other windows-specific code is added, switch to [windows.UTF16ToString]
|
|
||||||
|
|
||||||
s := b.b
|
|
||||||
for i, v := range s {
|
|
||||||
if v == 0 {
|
|
||||||
s = s[:i]
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return string(utf16.Decode(s))
|
|
||||||
}
|
|
||||||
|
|
||||||
// Cap returns the underlying buffer capacity.
|
|
||||||
func (b *WString) Cap() uint32 {
|
|
||||||
if b.empty() {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
return b.cap()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (b *WString) cap() uint32 { return uint32(cap(b.b)) }
|
|
||||||
func (b *WString) empty() bool { return b == nil || b.cap() == 0 }
|
|
||||||
@ -1,525 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"context"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"net"
|
|
||||||
"os"
|
|
||||||
"runtime"
|
|
||||||
"syscall"
|
|
||||||
"time"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
|
|
||||||
"github.com/Microsoft/go-winio/internal/fs"
|
|
||||||
)
|
|
||||||
|
|
||||||
//sys connectNamedPipe(pipe syscall.Handle, o *syscall.Overlapped) (err error) = ConnectNamedPipe
|
|
||||||
//sys createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error) [failretval==syscall.InvalidHandle] = CreateNamedPipeW
|
|
||||||
//sys getNamedPipeInfo(pipe syscall.Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) = GetNamedPipeInfo
|
|
||||||
//sys getNamedPipeHandleState(pipe syscall.Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) = GetNamedPipeHandleStateW
|
|
||||||
//sys localAlloc(uFlags uint32, length uint32) (ptr uintptr) = LocalAlloc
|
|
||||||
//sys ntCreateNamedPipeFile(pipe *syscall.Handle, access uint32, oa *objectAttributes, iosb *ioStatusBlock, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (status ntStatus) = ntdll.NtCreateNamedPipeFile
|
|
||||||
//sys rtlNtStatusToDosError(status ntStatus) (winerr error) = ntdll.RtlNtStatusToDosErrorNoTeb
|
|
||||||
//sys rtlDosPathNameToNtPathName(name *uint16, ntName *unicodeString, filePart uintptr, reserved uintptr) (status ntStatus) = ntdll.RtlDosPathNameToNtPathName_U
|
|
||||||
//sys rtlDefaultNpAcl(dacl *uintptr) (status ntStatus) = ntdll.RtlDefaultNpAcl
|
|
||||||
|
|
||||||
type ioStatusBlock struct {
|
|
||||||
Status, Information uintptr
|
|
||||||
}
|
|
||||||
|
|
||||||
type objectAttributes struct {
|
|
||||||
Length uintptr
|
|
||||||
RootDirectory uintptr
|
|
||||||
ObjectName *unicodeString
|
|
||||||
Attributes uintptr
|
|
||||||
SecurityDescriptor *securityDescriptor
|
|
||||||
SecurityQoS uintptr
|
|
||||||
}
|
|
||||||
|
|
||||||
type unicodeString struct {
|
|
||||||
Length uint16
|
|
||||||
MaximumLength uint16
|
|
||||||
Buffer uintptr
|
|
||||||
}
|
|
||||||
|
|
||||||
type securityDescriptor struct {
|
|
||||||
Revision byte
|
|
||||||
Sbz1 byte
|
|
||||||
Control uint16
|
|
||||||
Owner uintptr
|
|
||||||
Group uintptr
|
|
||||||
Sacl uintptr //revive:disable-line:var-naming SACL, not Sacl
|
|
||||||
Dacl uintptr //revive:disable-line:var-naming DACL, not Dacl
|
|
||||||
}
|
|
||||||
|
|
||||||
type ntStatus int32
|
|
||||||
|
|
||||||
func (status ntStatus) Err() error {
|
|
||||||
if status >= 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return rtlNtStatusToDosError(status)
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
// ErrPipeListenerClosed is returned for pipe operations on listeners that have been closed.
|
|
||||||
ErrPipeListenerClosed = net.ErrClosed
|
|
||||||
|
|
||||||
errPipeWriteClosed = errors.New("pipe has been closed for write")
|
|
||||||
)
|
|
||||||
|
|
||||||
type win32Pipe struct {
|
|
||||||
*win32File
|
|
||||||
path string
|
|
||||||
}
|
|
||||||
|
|
||||||
type win32MessageBytePipe struct {
|
|
||||||
win32Pipe
|
|
||||||
writeClosed bool
|
|
||||||
readEOF bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type pipeAddress string
|
|
||||||
|
|
||||||
func (f *win32Pipe) LocalAddr() net.Addr {
|
|
||||||
return pipeAddress(f.path)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *win32Pipe) RemoteAddr() net.Addr {
|
|
||||||
return pipeAddress(f.path)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *win32Pipe) SetDeadline(t time.Time) error {
|
|
||||||
if err := f.SetReadDeadline(t); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return f.SetWriteDeadline(t)
|
|
||||||
}
|
|
||||||
|
|
||||||
// CloseWrite closes the write side of a message pipe in byte mode.
|
|
||||||
func (f *win32MessageBytePipe) CloseWrite() error {
|
|
||||||
if f.writeClosed {
|
|
||||||
return errPipeWriteClosed
|
|
||||||
}
|
|
||||||
err := f.win32File.Flush()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
_, err = f.win32File.Write(nil)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
f.writeClosed = true
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write writes bytes to a message pipe in byte mode. Zero-byte writes are ignored, since
|
|
||||||
// they are used to implement CloseWrite().
|
|
||||||
func (f *win32MessageBytePipe) Write(b []byte) (int, error) {
|
|
||||||
if f.writeClosed {
|
|
||||||
return 0, errPipeWriteClosed
|
|
||||||
}
|
|
||||||
if len(b) == 0 {
|
|
||||||
return 0, nil
|
|
||||||
}
|
|
||||||
return f.win32File.Write(b)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Read reads bytes from a message pipe in byte mode. A read of a zero-byte message on a message
|
|
||||||
// mode pipe will return io.EOF, as will all subsequent reads.
|
|
||||||
func (f *win32MessageBytePipe) Read(b []byte) (int, error) {
|
|
||||||
if f.readEOF {
|
|
||||||
return 0, io.EOF
|
|
||||||
}
|
|
||||||
n, err := f.win32File.Read(b)
|
|
||||||
if err == io.EOF { //nolint:errorlint
|
|
||||||
// If this was the result of a zero-byte read, then
|
|
||||||
// it is possible that the read was due to a zero-size
|
|
||||||
// message. Since we are simulating CloseWrite with a
|
|
||||||
// zero-byte message, ensure that all future Read() calls
|
|
||||||
// also return EOF.
|
|
||||||
f.readEOF = true
|
|
||||||
} else if err == syscall.ERROR_MORE_DATA { //nolint:errorlint // err is Errno
|
|
||||||
// ERROR_MORE_DATA indicates that the pipe's read mode is message mode
|
|
||||||
// and the message still has more bytes. Treat this as a success, since
|
|
||||||
// this package presents all named pipes as byte streams.
|
|
||||||
err = nil
|
|
||||||
}
|
|
||||||
return n, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func (pipeAddress) Network() string {
|
|
||||||
return "pipe"
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s pipeAddress) String() string {
|
|
||||||
return string(s)
|
|
||||||
}
|
|
||||||
|
|
||||||
// tryDialPipe attempts to dial the pipe at `path` until `ctx` cancellation or timeout.
|
|
||||||
func tryDialPipe(ctx context.Context, path *string, access fs.AccessMask) (syscall.Handle, error) {
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case <-ctx.Done():
|
|
||||||
return syscall.Handle(0), ctx.Err()
|
|
||||||
default:
|
|
||||||
wh, err := fs.CreateFile(*path,
|
|
||||||
access,
|
|
||||||
0, // mode
|
|
||||||
nil, // security attributes
|
|
||||||
fs.OPEN_EXISTING,
|
|
||||||
fs.FILE_FLAG_OVERLAPPED|fs.SECURITY_SQOS_PRESENT|fs.SECURITY_ANONYMOUS,
|
|
||||||
0, // template file handle
|
|
||||||
)
|
|
||||||
h := syscall.Handle(wh)
|
|
||||||
if err == nil {
|
|
||||||
return h, nil
|
|
||||||
}
|
|
||||||
if err != windows.ERROR_PIPE_BUSY { //nolint:errorlint // err is Errno
|
|
||||||
return h, &os.PathError{Err: err, Op: "open", Path: *path}
|
|
||||||
}
|
|
||||||
// Wait 10 msec and try again. This is a rather simplistic
|
|
||||||
// view, as we always try each 10 milliseconds.
|
|
||||||
time.Sleep(10 * time.Millisecond)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// DialPipe connects to a named pipe by path, timing out if the connection
|
|
||||||
// takes longer than the specified duration. If timeout is nil, then we use
|
|
||||||
// a default timeout of 2 seconds. (We do not use WaitNamedPipe.)
|
|
||||||
func DialPipe(path string, timeout *time.Duration) (net.Conn, error) {
|
|
||||||
var absTimeout time.Time
|
|
||||||
if timeout != nil {
|
|
||||||
absTimeout = time.Now().Add(*timeout)
|
|
||||||
} else {
|
|
||||||
absTimeout = time.Now().Add(2 * time.Second)
|
|
||||||
}
|
|
||||||
ctx, cancel := context.WithDeadline(context.Background(), absTimeout)
|
|
||||||
defer cancel()
|
|
||||||
conn, err := DialPipeContext(ctx, path)
|
|
||||||
if errors.Is(err, context.DeadlineExceeded) {
|
|
||||||
return nil, ErrTimeout
|
|
||||||
}
|
|
||||||
return conn, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// DialPipeContext attempts to connect to a named pipe by `path` until `ctx`
|
|
||||||
// cancellation or timeout.
|
|
||||||
func DialPipeContext(ctx context.Context, path string) (net.Conn, error) {
|
|
||||||
return DialPipeAccess(ctx, path, syscall.GENERIC_READ|syscall.GENERIC_WRITE)
|
|
||||||
}
|
|
||||||
|
|
||||||
// DialPipeAccess attempts to connect to a named pipe by `path` with `access` until `ctx`
|
|
||||||
// cancellation or timeout.
|
|
||||||
func DialPipeAccess(ctx context.Context, path string, access uint32) (net.Conn, error) {
|
|
||||||
var err error
|
|
||||||
var h syscall.Handle
|
|
||||||
h, err = tryDialPipe(ctx, &path, fs.AccessMask(access))
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
var flags uint32
|
|
||||||
err = getNamedPipeInfo(h, &flags, nil, nil, nil)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
f, err := makeWin32File(h)
|
|
||||||
if err != nil {
|
|
||||||
syscall.Close(h)
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the pipe is in message mode, return a message byte pipe, which
|
|
||||||
// supports CloseWrite().
|
|
||||||
if flags&windows.PIPE_TYPE_MESSAGE != 0 {
|
|
||||||
return &win32MessageBytePipe{
|
|
||||||
win32Pipe: win32Pipe{win32File: f, path: path},
|
|
||||||
}, nil
|
|
||||||
}
|
|
||||||
return &win32Pipe{win32File: f, path: path}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
type acceptResponse struct {
|
|
||||||
f *win32File
|
|
||||||
err error
|
|
||||||
}
|
|
||||||
|
|
||||||
type win32PipeListener struct {
|
|
||||||
firstHandle syscall.Handle
|
|
||||||
path string
|
|
||||||
config PipeConfig
|
|
||||||
acceptCh chan (chan acceptResponse)
|
|
||||||
closeCh chan int
|
|
||||||
doneCh chan int
|
|
||||||
}
|
|
||||||
|
|
||||||
func makeServerPipeHandle(path string, sd []byte, c *PipeConfig, first bool) (syscall.Handle, error) {
|
|
||||||
path16, err := syscall.UTF16FromString(path)
|
|
||||||
if err != nil {
|
|
||||||
return 0, &os.PathError{Op: "open", Path: path, Err: err}
|
|
||||||
}
|
|
||||||
|
|
||||||
var oa objectAttributes
|
|
||||||
oa.Length = unsafe.Sizeof(oa)
|
|
||||||
|
|
||||||
var ntPath unicodeString
|
|
||||||
if err := rtlDosPathNameToNtPathName(&path16[0],
|
|
||||||
&ntPath,
|
|
||||||
0,
|
|
||||||
0,
|
|
||||||
).Err(); err != nil {
|
|
||||||
return 0, &os.PathError{Op: "open", Path: path, Err: err}
|
|
||||||
}
|
|
||||||
defer localFree(ntPath.Buffer)
|
|
||||||
oa.ObjectName = &ntPath
|
|
||||||
oa.Attributes = windows.OBJ_CASE_INSENSITIVE
|
|
||||||
|
|
||||||
// The security descriptor is only needed for the first pipe.
|
|
||||||
if first {
|
|
||||||
if sd != nil {
|
|
||||||
l := uint32(len(sd))
|
|
||||||
sdb := localAlloc(0, l)
|
|
||||||
defer localFree(sdb)
|
|
||||||
copy((*[0xffff]byte)(unsafe.Pointer(sdb))[:], sd)
|
|
||||||
oa.SecurityDescriptor = (*securityDescriptor)(unsafe.Pointer(sdb))
|
|
||||||
} else {
|
|
||||||
// Construct the default named pipe security descriptor.
|
|
||||||
var dacl uintptr
|
|
||||||
if err := rtlDefaultNpAcl(&dacl).Err(); err != nil {
|
|
||||||
return 0, fmt.Errorf("getting default named pipe ACL: %w", err)
|
|
||||||
}
|
|
||||||
defer localFree(dacl)
|
|
||||||
|
|
||||||
sdb := &securityDescriptor{
|
|
||||||
Revision: 1,
|
|
||||||
Control: windows.SE_DACL_PRESENT,
|
|
||||||
Dacl: dacl,
|
|
||||||
}
|
|
||||||
oa.SecurityDescriptor = sdb
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
typ := uint32(windows.FILE_PIPE_REJECT_REMOTE_CLIENTS)
|
|
||||||
if c.MessageMode {
|
|
||||||
typ |= windows.FILE_PIPE_MESSAGE_TYPE
|
|
||||||
}
|
|
||||||
|
|
||||||
disposition := uint32(windows.FILE_OPEN)
|
|
||||||
access := uint32(syscall.GENERIC_READ | syscall.GENERIC_WRITE | syscall.SYNCHRONIZE)
|
|
||||||
if first {
|
|
||||||
disposition = windows.FILE_CREATE
|
|
||||||
// By not asking for read or write access, the named pipe file system
|
|
||||||
// will put this pipe into an initially disconnected state, blocking
|
|
||||||
// client connections until the next call with first == false.
|
|
||||||
access = syscall.SYNCHRONIZE
|
|
||||||
}
|
|
||||||
|
|
||||||
timeout := int64(-50 * 10000) // 50ms
|
|
||||||
|
|
||||||
var (
|
|
||||||
h syscall.Handle
|
|
||||||
iosb ioStatusBlock
|
|
||||||
)
|
|
||||||
err = ntCreateNamedPipeFile(&h,
|
|
||||||
access,
|
|
||||||
&oa,
|
|
||||||
&iosb,
|
|
||||||
syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE,
|
|
||||||
disposition,
|
|
||||||
0,
|
|
||||||
typ,
|
|
||||||
0,
|
|
||||||
0,
|
|
||||||
0xffffffff,
|
|
||||||
uint32(c.InputBufferSize),
|
|
||||||
uint32(c.OutputBufferSize),
|
|
||||||
&timeout).Err()
|
|
||||||
if err != nil {
|
|
||||||
return 0, &os.PathError{Op: "open", Path: path, Err: err}
|
|
||||||
}
|
|
||||||
|
|
||||||
runtime.KeepAlive(ntPath)
|
|
||||||
return h, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *win32PipeListener) makeServerPipe() (*win32File, error) {
|
|
||||||
h, err := makeServerPipeHandle(l.path, nil, &l.config, false)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
f, err := makeWin32File(h)
|
|
||||||
if err != nil {
|
|
||||||
syscall.Close(h)
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return f, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *win32PipeListener) makeConnectedServerPipe() (*win32File, error) {
|
|
||||||
p, err := l.makeServerPipe()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Wait for the client to connect.
|
|
||||||
ch := make(chan error)
|
|
||||||
go func(p *win32File) {
|
|
||||||
ch <- connectPipe(p)
|
|
||||||
}(p)
|
|
||||||
|
|
||||||
select {
|
|
||||||
case err = <-ch:
|
|
||||||
if err != nil {
|
|
||||||
p.Close()
|
|
||||||
p = nil
|
|
||||||
}
|
|
||||||
case <-l.closeCh:
|
|
||||||
// Abort the connect request by closing the handle.
|
|
||||||
p.Close()
|
|
||||||
p = nil
|
|
||||||
err = <-ch
|
|
||||||
if err == nil || err == ErrFileClosed { //nolint:errorlint // err is Errno
|
|
||||||
err = ErrPipeListenerClosed
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return p, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *win32PipeListener) listenerRoutine() {
|
|
||||||
closed := false
|
|
||||||
for !closed {
|
|
||||||
select {
|
|
||||||
case <-l.closeCh:
|
|
||||||
closed = true
|
|
||||||
case responseCh := <-l.acceptCh:
|
|
||||||
var (
|
|
||||||
p *win32File
|
|
||||||
err error
|
|
||||||
)
|
|
||||||
for {
|
|
||||||
p, err = l.makeConnectedServerPipe()
|
|
||||||
// If the connection was immediately closed by the client, try
|
|
||||||
// again.
|
|
||||||
if err != windows.ERROR_NO_DATA { //nolint:errorlint // err is Errno
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
responseCh <- acceptResponse{p, err}
|
|
||||||
closed = err == ErrPipeListenerClosed //nolint:errorlint // err is Errno
|
|
||||||
}
|
|
||||||
}
|
|
||||||
syscall.Close(l.firstHandle)
|
|
||||||
l.firstHandle = 0
|
|
||||||
// Notify Close() and Accept() callers that the handle has been closed.
|
|
||||||
close(l.doneCh)
|
|
||||||
}
|
|
||||||
|
|
||||||
// PipeConfig contain configuration for the pipe listener.
|
|
||||||
type PipeConfig struct {
|
|
||||||
// SecurityDescriptor contains a Windows security descriptor in SDDL format.
|
|
||||||
SecurityDescriptor string
|
|
||||||
|
|
||||||
// MessageMode determines whether the pipe is in byte or message mode. In either
|
|
||||||
// case the pipe is read in byte mode by default. The only practical difference in
|
|
||||||
// this implementation is that CloseWrite() is only supported for message mode pipes;
|
|
||||||
// CloseWrite() is implemented as a zero-byte write, but zero-byte writes are only
|
|
||||||
// transferred to the reader (and returned as io.EOF in this implementation)
|
|
||||||
// when the pipe is in message mode.
|
|
||||||
MessageMode bool
|
|
||||||
|
|
||||||
// InputBufferSize specifies the size of the input buffer, in bytes.
|
|
||||||
InputBufferSize int32
|
|
||||||
|
|
||||||
// OutputBufferSize specifies the size of the output buffer, in bytes.
|
|
||||||
OutputBufferSize int32
|
|
||||||
}
|
|
||||||
|
|
||||||
// ListenPipe creates a listener on a Windows named pipe path, e.g. \\.\pipe\mypipe.
|
|
||||||
// The pipe must not already exist.
|
|
||||||
func ListenPipe(path string, c *PipeConfig) (net.Listener, error) {
|
|
||||||
var (
|
|
||||||
sd []byte
|
|
||||||
err error
|
|
||||||
)
|
|
||||||
if c == nil {
|
|
||||||
c = &PipeConfig{}
|
|
||||||
}
|
|
||||||
if c.SecurityDescriptor != "" {
|
|
||||||
sd, err = SddlToSecurityDescriptor(c.SecurityDescriptor)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
h, err := makeServerPipeHandle(path, sd, c, true)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
l := &win32PipeListener{
|
|
||||||
firstHandle: h,
|
|
||||||
path: path,
|
|
||||||
config: *c,
|
|
||||||
acceptCh: make(chan (chan acceptResponse)),
|
|
||||||
closeCh: make(chan int),
|
|
||||||
doneCh: make(chan int),
|
|
||||||
}
|
|
||||||
go l.listenerRoutine()
|
|
||||||
return l, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func connectPipe(p *win32File) error {
|
|
||||||
c, err := p.prepareIO()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
defer p.wg.Done()
|
|
||||||
|
|
||||||
err = connectNamedPipe(p.handle, &c.o)
|
|
||||||
_, err = p.asyncIO(c, nil, 0, err)
|
|
||||||
if err != nil && err != windows.ERROR_PIPE_CONNECTED { //nolint:errorlint // err is Errno
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *win32PipeListener) Accept() (net.Conn, error) {
|
|
||||||
ch := make(chan acceptResponse)
|
|
||||||
select {
|
|
||||||
case l.acceptCh <- ch:
|
|
||||||
response := <-ch
|
|
||||||
err := response.err
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
if l.config.MessageMode {
|
|
||||||
return &win32MessageBytePipe{
|
|
||||||
win32Pipe: win32Pipe{win32File: response.f, path: l.path},
|
|
||||||
}, nil
|
|
||||||
}
|
|
||||||
return &win32Pipe{win32File: response.f, path: l.path}, nil
|
|
||||||
case <-l.doneCh:
|
|
||||||
return nil, ErrPipeListenerClosed
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *win32PipeListener) Close() error {
|
|
||||||
select {
|
|
||||||
case l.closeCh <- 1:
|
|
||||||
<-l.doneCh
|
|
||||||
case <-l.doneCh:
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (l *win32PipeListener) Addr() net.Addr {
|
|
||||||
return pipeAddress(l.path)
|
|
||||||
}
|
|
||||||
@ -1,232 +0,0 @@
|
|||||||
// 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" //nolint:gosec // not used for secure application
|
|
||||||
"encoding"
|
|
||||||
"encoding/binary"
|
|
||||||
"fmt"
|
|
||||||
"strconv"
|
|
||||||
)
|
|
||||||
|
|
||||||
//go:generate go run golang.org/x/tools/cmd/stringer -type=Variant -trimprefix=Variant -linecomment
|
|
||||||
|
|
||||||
// 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 section 4.1.1.
|
|
||||||
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 // RFC 4122
|
|
||||||
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
|
|
||||||
|
|
||||||
func (v Version) String() string {
|
|
||||||
return strconv.FormatUint(uint64(v), 10)
|
|
||||||
}
|
|
||||||
|
|
||||||
var _ = (encoding.TextMarshaler)(GUID{})
|
|
||||||
var _ = (encoding.TextUnmarshaler)(&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() //nolint:gosec // not used for secure application
|
|
||||||
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
|
|
||||||
}
|
|
||||||
@ -1,16 +0,0 @@
|
|||||||
//go:build !windows
|
|
||||||
// +build !windows
|
|
||||||
|
|
||||||
package 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 as that is only available to builds
|
|
||||||
// targeted at `windows`. The representation matches that used by native Windows
|
|
||||||
// code.
|
|
||||||
type GUID struct {
|
|
||||||
Data1 uint32
|
|
||||||
Data2 uint16
|
|
||||||
Data3 uint16
|
|
||||||
Data4 [8]byte
|
|
||||||
}
|
|
||||||
@ -1,13 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package guid
|
|
||||||
|
|
||||||
import "golang.org/x/sys/windows"
|
|
||||||
|
|
||||||
// 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
|
|
||||||
@ -1,27 +0,0 @@
|
|||||||
// Code generated by "stringer -type=Variant -trimprefix=Variant -linecomment"; DO NOT EDIT.
|
|
||||||
|
|
||||||
package guid
|
|
||||||
|
|
||||||
import "strconv"
|
|
||||||
|
|
||||||
func _() {
|
|
||||||
// An "invalid array index" compiler error signifies that the constant values have changed.
|
|
||||||
// Re-run the stringer command to generate them again.
|
|
||||||
var x [1]struct{}
|
|
||||||
_ = x[VariantUnknown-0]
|
|
||||||
_ = x[VariantNCS-1]
|
|
||||||
_ = x[VariantRFC4122-2]
|
|
||||||
_ = x[VariantMicrosoft-3]
|
|
||||||
_ = x[VariantFuture-4]
|
|
||||||
}
|
|
||||||
|
|
||||||
const _Variant_name = "UnknownNCSRFC 4122MicrosoftFuture"
|
|
||||||
|
|
||||||
var _Variant_index = [...]uint8{0, 7, 10, 18, 27, 33}
|
|
||||||
|
|
||||||
func (i Variant) String() string {
|
|
||||||
if i >= Variant(len(_Variant_index)-1) {
|
|
||||||
return "Variant(" + strconv.FormatInt(int64(i), 10) + ")"
|
|
||||||
}
|
|
||||||
return _Variant_name[_Variant_index[i]:_Variant_index[i+1]]
|
|
||||||
}
|
|
||||||
@ -1,197 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/binary"
|
|
||||||
"fmt"
|
|
||||||
"runtime"
|
|
||||||
"sync"
|
|
||||||
"syscall"
|
|
||||||
"unicode/utf16"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
//sys adjustTokenPrivileges(token windows.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) [true] = advapi32.AdjustTokenPrivileges
|
|
||||||
//sys impersonateSelf(level uint32) (err error) = advapi32.ImpersonateSelf
|
|
||||||
//sys revertToSelf() (err error) = advapi32.RevertToSelf
|
|
||||||
//sys openThreadToken(thread syscall.Handle, accessMask uint32, openAsSelf bool, token *windows.Token) (err error) = advapi32.OpenThreadToken
|
|
||||||
//sys getCurrentThread() (h syscall.Handle) = GetCurrentThread
|
|
||||||
//sys lookupPrivilegeValue(systemName string, name string, luid *uint64) (err error) = advapi32.LookupPrivilegeValueW
|
|
||||||
//sys lookupPrivilegeName(systemName string, luid *uint64, buffer *uint16, size *uint32) (err error) = advapi32.LookupPrivilegeNameW
|
|
||||||
//sys lookupPrivilegeDisplayName(systemName string, name *uint16, buffer *uint16, size *uint32, languageId *uint32) (err error) = advapi32.LookupPrivilegeDisplayNameW
|
|
||||||
|
|
||||||
const (
|
|
||||||
//revive:disable-next-line:var-naming ALL_CAPS
|
|
||||||
SE_PRIVILEGE_ENABLED = windows.SE_PRIVILEGE_ENABLED
|
|
||||||
|
|
||||||
//revive:disable-next-line:var-naming ALL_CAPS
|
|
||||||
ERROR_NOT_ALL_ASSIGNED syscall.Errno = windows.ERROR_NOT_ALL_ASSIGNED
|
|
||||||
|
|
||||||
SeBackupPrivilege = "SeBackupPrivilege"
|
|
||||||
SeRestorePrivilege = "SeRestorePrivilege"
|
|
||||||
SeSecurityPrivilege = "SeSecurityPrivilege"
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
privNames = make(map[string]uint64)
|
|
||||||
privNameMutex sync.Mutex
|
|
||||||
)
|
|
||||||
|
|
||||||
// PrivilegeError represents an error enabling privileges.
|
|
||||||
type PrivilegeError struct {
|
|
||||||
privileges []uint64
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *PrivilegeError) Error() string {
|
|
||||||
s := "Could not enable privilege "
|
|
||||||
if len(e.privileges) > 1 {
|
|
||||||
s = "Could not enable privileges "
|
|
||||||
}
|
|
||||||
for i, p := range e.privileges {
|
|
||||||
if i != 0 {
|
|
||||||
s += ", "
|
|
||||||
}
|
|
||||||
s += `"`
|
|
||||||
s += getPrivilegeName(p)
|
|
||||||
s += `"`
|
|
||||||
}
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
// RunWithPrivilege enables a single privilege for a function call.
|
|
||||||
func RunWithPrivilege(name string, fn func() error) error {
|
|
||||||
return RunWithPrivileges([]string{name}, fn)
|
|
||||||
}
|
|
||||||
|
|
||||||
// RunWithPrivileges enables privileges for a function call.
|
|
||||||
func RunWithPrivileges(names []string, fn func() error) error {
|
|
||||||
privileges, err := mapPrivileges(names)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
runtime.LockOSThread()
|
|
||||||
defer runtime.UnlockOSThread()
|
|
||||||
token, err := newThreadToken()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
defer releaseThreadToken(token)
|
|
||||||
err = adjustPrivileges(token, privileges, SE_PRIVILEGE_ENABLED)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return fn()
|
|
||||||
}
|
|
||||||
|
|
||||||
func mapPrivileges(names []string) ([]uint64, error) {
|
|
||||||
privileges := make([]uint64, 0, len(names))
|
|
||||||
privNameMutex.Lock()
|
|
||||||
defer privNameMutex.Unlock()
|
|
||||||
for _, name := range names {
|
|
||||||
p, ok := privNames[name]
|
|
||||||
if !ok {
|
|
||||||
err := lookupPrivilegeValue("", name, &p)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
privNames[name] = p
|
|
||||||
}
|
|
||||||
privileges = append(privileges, p)
|
|
||||||
}
|
|
||||||
return privileges, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// EnableProcessPrivileges enables privileges globally for the process.
|
|
||||||
func EnableProcessPrivileges(names []string) error {
|
|
||||||
return enableDisableProcessPrivilege(names, SE_PRIVILEGE_ENABLED)
|
|
||||||
}
|
|
||||||
|
|
||||||
// DisableProcessPrivileges disables privileges globally for the process.
|
|
||||||
func DisableProcessPrivileges(names []string) error {
|
|
||||||
return enableDisableProcessPrivilege(names, 0)
|
|
||||||
}
|
|
||||||
|
|
||||||
func enableDisableProcessPrivilege(names []string, action uint32) error {
|
|
||||||
privileges, err := mapPrivileges(names)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
p := windows.CurrentProcess()
|
|
||||||
var token windows.Token
|
|
||||||
err = windows.OpenProcessToken(p, windows.TOKEN_ADJUST_PRIVILEGES|windows.TOKEN_QUERY, &token)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
defer token.Close()
|
|
||||||
return adjustPrivileges(token, privileges, action)
|
|
||||||
}
|
|
||||||
|
|
||||||
func adjustPrivileges(token windows.Token, privileges []uint64, action uint32) error {
|
|
||||||
var b bytes.Buffer
|
|
||||||
_ = binary.Write(&b, binary.LittleEndian, uint32(len(privileges)))
|
|
||||||
for _, p := range privileges {
|
|
||||||
_ = binary.Write(&b, binary.LittleEndian, p)
|
|
||||||
_ = binary.Write(&b, binary.LittleEndian, action)
|
|
||||||
}
|
|
||||||
prevState := make([]byte, b.Len())
|
|
||||||
reqSize := uint32(0)
|
|
||||||
success, err := adjustTokenPrivileges(token, false, &b.Bytes()[0], uint32(len(prevState)), &prevState[0], &reqSize)
|
|
||||||
if !success {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if err == ERROR_NOT_ALL_ASSIGNED { //nolint:errorlint // err is Errno
|
|
||||||
return &PrivilegeError{privileges}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func getPrivilegeName(luid uint64) string {
|
|
||||||
var nameBuffer [256]uint16
|
|
||||||
bufSize := uint32(len(nameBuffer))
|
|
||||||
err := lookupPrivilegeName("", &luid, &nameBuffer[0], &bufSize)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Sprintf("<unknown privilege %d>", luid)
|
|
||||||
}
|
|
||||||
|
|
||||||
var displayNameBuffer [256]uint16
|
|
||||||
displayBufSize := uint32(len(displayNameBuffer))
|
|
||||||
var langID uint32
|
|
||||||
err = lookupPrivilegeDisplayName("", &nameBuffer[0], &displayNameBuffer[0], &displayBufSize, &langID)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Sprintf("<unknown privilege %s>", string(utf16.Decode(nameBuffer[:bufSize])))
|
|
||||||
}
|
|
||||||
|
|
||||||
return string(utf16.Decode(displayNameBuffer[:displayBufSize]))
|
|
||||||
}
|
|
||||||
|
|
||||||
func newThreadToken() (windows.Token, error) {
|
|
||||||
err := impersonateSelf(windows.SecurityImpersonation)
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
|
|
||||||
var token windows.Token
|
|
||||||
err = openThreadToken(getCurrentThread(), syscall.TOKEN_ADJUST_PRIVILEGES|syscall.TOKEN_QUERY, false, &token)
|
|
||||||
if err != nil {
|
|
||||||
rerr := revertToSelf()
|
|
||||||
if rerr != nil {
|
|
||||||
panic(rerr)
|
|
||||||
}
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
return token, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func releaseThreadToken(h windows.Token) {
|
|
||||||
err := revertToSelf()
|
|
||||||
if err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
h.Close()
|
|
||||||
}
|
|
||||||
@ -1,131 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/binary"
|
|
||||||
"fmt"
|
|
||||||
"strings"
|
|
||||||
"unicode/utf16"
|
|
||||||
"unsafe"
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
reparseTagMountPoint = 0xA0000003
|
|
||||||
reparseTagSymlink = 0xA000000C
|
|
||||||
)
|
|
||||||
|
|
||||||
type reparseDataBuffer struct {
|
|
||||||
ReparseTag uint32
|
|
||||||
ReparseDataLength uint16
|
|
||||||
Reserved uint16
|
|
||||||
SubstituteNameOffset uint16
|
|
||||||
SubstituteNameLength uint16
|
|
||||||
PrintNameOffset uint16
|
|
||||||
PrintNameLength uint16
|
|
||||||
}
|
|
||||||
|
|
||||||
// ReparsePoint describes a Win32 symlink or mount point.
|
|
||||||
type ReparsePoint struct {
|
|
||||||
Target string
|
|
||||||
IsMountPoint bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// UnsupportedReparsePointError is returned when trying to decode a non-symlink or
|
|
||||||
// mount point reparse point.
|
|
||||||
type UnsupportedReparsePointError struct {
|
|
||||||
Tag uint32
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *UnsupportedReparsePointError) Error() string {
|
|
||||||
return fmt.Sprintf("unsupported reparse point %x", e.Tag)
|
|
||||||
}
|
|
||||||
|
|
||||||
// DecodeReparsePoint decodes a Win32 REPARSE_DATA_BUFFER structure containing either a symlink
|
|
||||||
// or a mount point.
|
|
||||||
func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
|
|
||||||
tag := binary.LittleEndian.Uint32(b[0:4])
|
|
||||||
return DecodeReparsePointData(tag, b[8:])
|
|
||||||
}
|
|
||||||
|
|
||||||
func DecodeReparsePointData(tag uint32, b []byte) (*ReparsePoint, error) {
|
|
||||||
isMountPoint := false
|
|
||||||
switch tag {
|
|
||||||
case reparseTagMountPoint:
|
|
||||||
isMountPoint = true
|
|
||||||
case reparseTagSymlink:
|
|
||||||
default:
|
|
||||||
return nil, &UnsupportedReparsePointError{tag}
|
|
||||||
}
|
|
||||||
nameOffset := 8 + binary.LittleEndian.Uint16(b[4:6])
|
|
||||||
if !isMountPoint {
|
|
||||||
nameOffset += 4
|
|
||||||
}
|
|
||||||
nameLength := binary.LittleEndian.Uint16(b[6:8])
|
|
||||||
name := make([]uint16, nameLength/2)
|
|
||||||
err := binary.Read(bytes.NewReader(b[nameOffset:nameOffset+nameLength]), binary.LittleEndian, &name)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return &ReparsePoint{string(utf16.Decode(name)), isMountPoint}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func isDriveLetter(c byte) bool {
|
|
||||||
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
|
|
||||||
}
|
|
||||||
|
|
||||||
// EncodeReparsePoint encodes a Win32 REPARSE_DATA_BUFFER structure describing a symlink or
|
|
||||||
// mount point.
|
|
||||||
func EncodeReparsePoint(rp *ReparsePoint) []byte {
|
|
||||||
// Generate an NT path and determine if this is a relative path.
|
|
||||||
var ntTarget string
|
|
||||||
relative := false
|
|
||||||
if strings.HasPrefix(rp.Target, `\\?\`) {
|
|
||||||
ntTarget = `\??\` + rp.Target[4:]
|
|
||||||
} else if strings.HasPrefix(rp.Target, `\\`) {
|
|
||||||
ntTarget = `\??\UNC\` + rp.Target[2:]
|
|
||||||
} else if len(rp.Target) >= 2 && isDriveLetter(rp.Target[0]) && rp.Target[1] == ':' {
|
|
||||||
ntTarget = `\??\` + rp.Target
|
|
||||||
} else {
|
|
||||||
ntTarget = rp.Target
|
|
||||||
relative = true
|
|
||||||
}
|
|
||||||
|
|
||||||
// The paths must be NUL-terminated even though they are counted strings.
|
|
||||||
target16 := utf16.Encode([]rune(rp.Target + "\x00"))
|
|
||||||
ntTarget16 := utf16.Encode([]rune(ntTarget + "\x00"))
|
|
||||||
|
|
||||||
size := int(unsafe.Sizeof(reparseDataBuffer{})) - 8
|
|
||||||
size += len(ntTarget16)*2 + len(target16)*2
|
|
||||||
|
|
||||||
tag := uint32(reparseTagMountPoint)
|
|
||||||
if !rp.IsMountPoint {
|
|
||||||
tag = reparseTagSymlink
|
|
||||||
size += 4 // Add room for symlink flags
|
|
||||||
}
|
|
||||||
|
|
||||||
data := reparseDataBuffer{
|
|
||||||
ReparseTag: tag,
|
|
||||||
ReparseDataLength: uint16(size),
|
|
||||||
SubstituteNameOffset: 0,
|
|
||||||
SubstituteNameLength: uint16((len(ntTarget16) - 1) * 2),
|
|
||||||
PrintNameOffset: uint16(len(ntTarget16) * 2),
|
|
||||||
PrintNameLength: uint16((len(target16) - 1) * 2),
|
|
||||||
}
|
|
||||||
|
|
||||||
var b bytes.Buffer
|
|
||||||
_ = binary.Write(&b, binary.LittleEndian, &data)
|
|
||||||
if !rp.IsMountPoint {
|
|
||||||
flags := uint32(0)
|
|
||||||
if relative {
|
|
||||||
flags |= 1
|
|
||||||
}
|
|
||||||
_ = binary.Write(&b, binary.LittleEndian, flags)
|
|
||||||
}
|
|
||||||
|
|
||||||
_ = binary.Write(&b, binary.LittleEndian, ntTarget16)
|
|
||||||
_ = binary.Write(&b, binary.LittleEndian, target16)
|
|
||||||
return b.Bytes()
|
|
||||||
}
|
|
||||||
@ -1,144 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
// +build windows
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"syscall"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
//sys lookupAccountName(systemName *uint16, accountName string, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) = advapi32.LookupAccountNameW
|
|
||||||
//sys lookupAccountSid(systemName *uint16, sid *byte, name *uint16, nameSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) = advapi32.LookupAccountSidW
|
|
||||||
//sys convertSidToStringSid(sid *byte, str **uint16) (err error) = advapi32.ConvertSidToStringSidW
|
|
||||||
//sys convertStringSidToSid(str *uint16, sid **byte) (err error) = advapi32.ConvertStringSidToSidW
|
|
||||||
//sys convertStringSecurityDescriptorToSecurityDescriptor(str string, revision uint32, sd *uintptr, size *uint32) (err error) = advapi32.ConvertStringSecurityDescriptorToSecurityDescriptorW
|
|
||||||
//sys convertSecurityDescriptorToStringSecurityDescriptor(sd *byte, revision uint32, secInfo uint32, sddl **uint16, sddlSize *uint32) (err error) = advapi32.ConvertSecurityDescriptorToStringSecurityDescriptorW
|
|
||||||
//sys localFree(mem uintptr) = LocalFree
|
|
||||||
//sys getSecurityDescriptorLength(sd uintptr) (len uint32) = advapi32.GetSecurityDescriptorLength
|
|
||||||
|
|
||||||
type AccountLookupError struct {
|
|
||||||
Name string
|
|
||||||
Err error
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *AccountLookupError) Error() string {
|
|
||||||
if e.Name == "" {
|
|
||||||
return "lookup account: empty account name specified"
|
|
||||||
}
|
|
||||||
var s string
|
|
||||||
switch {
|
|
||||||
case errors.Is(e.Err, windows.ERROR_INVALID_SID):
|
|
||||||
s = "the security ID structure is invalid"
|
|
||||||
case errors.Is(e.Err, windows.ERROR_NONE_MAPPED):
|
|
||||||
s = "not found"
|
|
||||||
default:
|
|
||||||
s = e.Err.Error()
|
|
||||||
}
|
|
||||||
return "lookup account " + e.Name + ": " + s
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *AccountLookupError) Unwrap() error { return e.Err }
|
|
||||||
|
|
||||||
type SddlConversionError struct {
|
|
||||||
Sddl string
|
|
||||||
Err error
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *SddlConversionError) Error() string {
|
|
||||||
return "convert " + e.Sddl + ": " + e.Err.Error()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (e *SddlConversionError) Unwrap() error { return e.Err }
|
|
||||||
|
|
||||||
// LookupSidByName looks up the SID of an account by name
|
|
||||||
//
|
|
||||||
//revive:disable-next-line:var-naming SID, not Sid
|
|
||||||
func LookupSidByName(name string) (sid string, err error) {
|
|
||||||
if name == "" {
|
|
||||||
return "", &AccountLookupError{name, windows.ERROR_NONE_MAPPED}
|
|
||||||
}
|
|
||||||
|
|
||||||
var sidSize, sidNameUse, refDomainSize uint32
|
|
||||||
err = lookupAccountName(nil, name, nil, &sidSize, nil, &refDomainSize, &sidNameUse)
|
|
||||||
if err != nil && err != syscall.ERROR_INSUFFICIENT_BUFFER { //nolint:errorlint // err is Errno
|
|
||||||
return "", &AccountLookupError{name, err}
|
|
||||||
}
|
|
||||||
sidBuffer := make([]byte, sidSize)
|
|
||||||
refDomainBuffer := make([]uint16, refDomainSize)
|
|
||||||
err = lookupAccountName(nil, name, &sidBuffer[0], &sidSize, &refDomainBuffer[0], &refDomainSize, &sidNameUse)
|
|
||||||
if err != nil {
|
|
||||||
return "", &AccountLookupError{name, err}
|
|
||||||
}
|
|
||||||
var strBuffer *uint16
|
|
||||||
err = convertSidToStringSid(&sidBuffer[0], &strBuffer)
|
|
||||||
if err != nil {
|
|
||||||
return "", &AccountLookupError{name, err}
|
|
||||||
}
|
|
||||||
sid = syscall.UTF16ToString((*[0xffff]uint16)(unsafe.Pointer(strBuffer))[:])
|
|
||||||
localFree(uintptr(unsafe.Pointer(strBuffer)))
|
|
||||||
return sid, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// LookupNameBySid looks up the name of an account by SID
|
|
||||||
//
|
|
||||||
//revive:disable-next-line:var-naming SID, not Sid
|
|
||||||
func LookupNameBySid(sid string) (name string, err error) {
|
|
||||||
if sid == "" {
|
|
||||||
return "", &AccountLookupError{sid, windows.ERROR_NONE_MAPPED}
|
|
||||||
}
|
|
||||||
|
|
||||||
sidBuffer, err := windows.UTF16PtrFromString(sid)
|
|
||||||
if err != nil {
|
|
||||||
return "", &AccountLookupError{sid, err}
|
|
||||||
}
|
|
||||||
|
|
||||||
var sidPtr *byte
|
|
||||||
if err = convertStringSidToSid(sidBuffer, &sidPtr); err != nil {
|
|
||||||
return "", &AccountLookupError{sid, err}
|
|
||||||
}
|
|
||||||
defer localFree(uintptr(unsafe.Pointer(sidPtr)))
|
|
||||||
|
|
||||||
var nameSize, refDomainSize, sidNameUse uint32
|
|
||||||
err = lookupAccountSid(nil, sidPtr, nil, &nameSize, nil, &refDomainSize, &sidNameUse)
|
|
||||||
if err != nil && err != windows.ERROR_INSUFFICIENT_BUFFER { //nolint:errorlint // err is Errno
|
|
||||||
return "", &AccountLookupError{sid, err}
|
|
||||||
}
|
|
||||||
|
|
||||||
nameBuffer := make([]uint16, nameSize)
|
|
||||||
refDomainBuffer := make([]uint16, refDomainSize)
|
|
||||||
err = lookupAccountSid(nil, sidPtr, &nameBuffer[0], &nameSize, &refDomainBuffer[0], &refDomainSize, &sidNameUse)
|
|
||||||
if err != nil {
|
|
||||||
return "", &AccountLookupError{sid, err}
|
|
||||||
}
|
|
||||||
|
|
||||||
name = windows.UTF16ToString(nameBuffer)
|
|
||||||
return name, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func SddlToSecurityDescriptor(sddl string) ([]byte, error) {
|
|
||||||
var sdBuffer uintptr
|
|
||||||
err := convertStringSecurityDescriptorToSecurityDescriptor(sddl, 1, &sdBuffer, nil)
|
|
||||||
if err != nil {
|
|
||||||
return nil, &SddlConversionError{sddl, err}
|
|
||||||
}
|
|
||||||
defer localFree(sdBuffer)
|
|
||||||
sd := make([]byte, getSecurityDescriptorLength(sdBuffer))
|
|
||||||
copy(sd, (*[0xffff]byte)(unsafe.Pointer(sdBuffer))[:len(sd)])
|
|
||||||
return sd, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func SecurityDescriptorToSddl(sd []byte) (string, error) {
|
|
||||||
var sddl *uint16
|
|
||||||
// The returned string length seems to include an arbitrary number of terminating NULs.
|
|
||||||
// Don't use it.
|
|
||||||
err := convertSecurityDescriptorToStringSecurityDescriptor(&sd[0], 1, 0xff, &sddl, nil)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
defer localFree(uintptr(unsafe.Pointer(sddl)))
|
|
||||||
return syscall.UTF16ToString((*[0xffff]uint16)(unsafe.Pointer(sddl))[:]), nil
|
|
||||||
}
|
|
||||||
@ -1,5 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
//go:generate go run github.com/Microsoft/go-winio/tools/mkwinsyscall -output zsyscall_windows.go ./*.go
|
|
||||||
@ -1,5 +0,0 @@
|
|||||||
//go:build tools
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import _ "golang.org/x/tools/cmd/stringer"
|
|
||||||
@ -1,419 +0,0 @@
|
|||||||
//go:build windows
|
|
||||||
|
|
||||||
// Code generated by 'go generate' using "github.com/Microsoft/go-winio/tools/mkwinsyscall"; DO NOT EDIT.
|
|
||||||
|
|
||||||
package winio
|
|
||||||
|
|
||||||
import (
|
|
||||||
"syscall"
|
|
||||||
"unsafe"
|
|
||||||
|
|
||||||
"golang.org/x/sys/windows"
|
|
||||||
)
|
|
||||||
|
|
||||||
var _ unsafe.Pointer
|
|
||||||
|
|
||||||
// Do the interface allocations only once for common
|
|
||||||
// Errno values.
|
|
||||||
const (
|
|
||||||
errnoERROR_IO_PENDING = 997
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
|
|
||||||
errERROR_EINVAL error = syscall.EINVAL
|
|
||||||
)
|
|
||||||
|
|
||||||
// errnoErr returns common boxed Errno values, to prevent
|
|
||||||
// allocations at runtime.
|
|
||||||
func errnoErr(e syscall.Errno) error {
|
|
||||||
switch e {
|
|
||||||
case 0:
|
|
||||||
return errERROR_EINVAL
|
|
||||||
case errnoERROR_IO_PENDING:
|
|
||||||
return errERROR_IO_PENDING
|
|
||||||
}
|
|
||||||
// TODO: add more here, after collecting data on the common
|
|
||||||
// error values see on Windows. (perhaps when running
|
|
||||||
// all.bat?)
|
|
||||||
return e
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
modadvapi32 = windows.NewLazySystemDLL("advapi32.dll")
|
|
||||||
modkernel32 = windows.NewLazySystemDLL("kernel32.dll")
|
|
||||||
modntdll = windows.NewLazySystemDLL("ntdll.dll")
|
|
||||||
modws2_32 = windows.NewLazySystemDLL("ws2_32.dll")
|
|
||||||
|
|
||||||
procAdjustTokenPrivileges = modadvapi32.NewProc("AdjustTokenPrivileges")
|
|
||||||
procConvertSecurityDescriptorToStringSecurityDescriptorW = modadvapi32.NewProc("ConvertSecurityDescriptorToStringSecurityDescriptorW")
|
|
||||||
procConvertSidToStringSidW = modadvapi32.NewProc("ConvertSidToStringSidW")
|
|
||||||
procConvertStringSecurityDescriptorToSecurityDescriptorW = modadvapi32.NewProc("ConvertStringSecurityDescriptorToSecurityDescriptorW")
|
|
||||||
procConvertStringSidToSidW = modadvapi32.NewProc("ConvertStringSidToSidW")
|
|
||||||
procGetSecurityDescriptorLength = modadvapi32.NewProc("GetSecurityDescriptorLength")
|
|
||||||
procImpersonateSelf = modadvapi32.NewProc("ImpersonateSelf")
|
|
||||||
procLookupAccountNameW = modadvapi32.NewProc("LookupAccountNameW")
|
|
||||||
procLookupAccountSidW = modadvapi32.NewProc("LookupAccountSidW")
|
|
||||||
procLookupPrivilegeDisplayNameW = modadvapi32.NewProc("LookupPrivilegeDisplayNameW")
|
|
||||||
procLookupPrivilegeNameW = modadvapi32.NewProc("LookupPrivilegeNameW")
|
|
||||||
procLookupPrivilegeValueW = modadvapi32.NewProc("LookupPrivilegeValueW")
|
|
||||||
procOpenThreadToken = modadvapi32.NewProc("OpenThreadToken")
|
|
||||||
procRevertToSelf = modadvapi32.NewProc("RevertToSelf")
|
|
||||||
procBackupRead = modkernel32.NewProc("BackupRead")
|
|
||||||
procBackupWrite = modkernel32.NewProc("BackupWrite")
|
|
||||||
procCancelIoEx = modkernel32.NewProc("CancelIoEx")
|
|
||||||
procConnectNamedPipe = modkernel32.NewProc("ConnectNamedPipe")
|
|
||||||
procCreateIoCompletionPort = modkernel32.NewProc("CreateIoCompletionPort")
|
|
||||||
procCreateNamedPipeW = modkernel32.NewProc("CreateNamedPipeW")
|
|
||||||
procGetCurrentThread = modkernel32.NewProc("GetCurrentThread")
|
|
||||||
procGetNamedPipeHandleStateW = modkernel32.NewProc("GetNamedPipeHandleStateW")
|
|
||||||
procGetNamedPipeInfo = modkernel32.NewProc("GetNamedPipeInfo")
|
|
||||||
procGetQueuedCompletionStatus = modkernel32.NewProc("GetQueuedCompletionStatus")
|
|
||||||
procLocalAlloc = modkernel32.NewProc("LocalAlloc")
|
|
||||||
procLocalFree = modkernel32.NewProc("LocalFree")
|
|
||||||
procSetFileCompletionNotificationModes = modkernel32.NewProc("SetFileCompletionNotificationModes")
|
|
||||||
procNtCreateNamedPipeFile = modntdll.NewProc("NtCreateNamedPipeFile")
|
|
||||||
procRtlDefaultNpAcl = modntdll.NewProc("RtlDefaultNpAcl")
|
|
||||||
procRtlDosPathNameToNtPathName_U = modntdll.NewProc("RtlDosPathNameToNtPathName_U")
|
|
||||||
procRtlNtStatusToDosErrorNoTeb = modntdll.NewProc("RtlNtStatusToDosErrorNoTeb")
|
|
||||||
procWSAGetOverlappedResult = modws2_32.NewProc("WSAGetOverlappedResult")
|
|
||||||
)
|
|
||||||
|
|
||||||
func adjustTokenPrivileges(token windows.Token, releaseAll bool, input *byte, outputSize uint32, output *byte, requiredSize *uint32) (success bool, err error) {
|
|
||||||
var _p0 uint32
|
|
||||||
if releaseAll {
|
|
||||||
_p0 = 1
|
|
||||||
}
|
|
||||||
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 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func convertSecurityDescriptorToStringSecurityDescriptor(sd *byte, revision uint32, secInfo uint32, sddl **uint16, sddlSize *uint32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall6(procConvertSecurityDescriptorToStringSecurityDescriptorW.Addr(), 5, uintptr(unsafe.Pointer(sd)), uintptr(revision), uintptr(secInfo), uintptr(unsafe.Pointer(sddl)), uintptr(unsafe.Pointer(sddlSize)), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func convertSidToStringSid(sid *byte, str **uint16) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procConvertSidToStringSidW.Addr(), 2, uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(str)), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func convertStringSecurityDescriptorToSecurityDescriptor(str string, revision uint32, sd *uintptr, size *uint32) (err error) {
|
|
||||||
var _p0 *uint16
|
|
||||||
_p0, err = syscall.UTF16PtrFromString(str)
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
return _convertStringSecurityDescriptorToSecurityDescriptor(_p0, revision, sd, size)
|
|
||||||
}
|
|
||||||
|
|
||||||
func _convertStringSecurityDescriptorToSecurityDescriptor(str *uint16, revision uint32, sd *uintptr, size *uint32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall6(procConvertStringSecurityDescriptorToSecurityDescriptorW.Addr(), 4, uintptr(unsafe.Pointer(str)), uintptr(revision), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(size)), 0, 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func convertStringSidToSid(str *uint16, sid **byte) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procConvertStringSidToSidW.Addr(), 2, uintptr(unsafe.Pointer(str)), uintptr(unsafe.Pointer(sid)), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func getSecurityDescriptorLength(sd uintptr) (len uint32) {
|
|
||||||
r0, _, _ := syscall.Syscall(procGetSecurityDescriptorLength.Addr(), 1, uintptr(sd), 0, 0)
|
|
||||||
len = uint32(r0)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func impersonateSelf(level uint32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procImpersonateSelf.Addr(), 1, uintptr(level), 0, 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupAccountName(systemName *uint16, accountName string, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
|
|
||||||
var _p0 *uint16
|
|
||||||
_p0, err = syscall.UTF16PtrFromString(accountName)
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
return _lookupAccountName(systemName, _p0, sid, sidSize, refDomain, refDomainSize, sidNameUse)
|
|
||||||
}
|
|
||||||
|
|
||||||
func _lookupAccountName(systemName *uint16, accountName *uint16, sid *byte, sidSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall9(procLookupAccountNameW.Addr(), 7, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(accountName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(sidSize)), uintptr(unsafe.Pointer(refDomain)), uintptr(unsafe.Pointer(refDomainSize)), uintptr(unsafe.Pointer(sidNameUse)), 0, 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupAccountSid(systemName *uint16, sid *byte, name *uint16, nameSize *uint32, refDomain *uint16, refDomainSize *uint32, sidNameUse *uint32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall9(procLookupAccountSidW.Addr(), 7, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameSize)), uintptr(unsafe.Pointer(refDomain)), uintptr(unsafe.Pointer(refDomainSize)), uintptr(unsafe.Pointer(sidNameUse)), 0, 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupPrivilegeDisplayName(systemName string, name *uint16, buffer *uint16, size *uint32, languageId *uint32) (err error) {
|
|
||||||
var _p0 *uint16
|
|
||||||
_p0, err = syscall.UTF16PtrFromString(systemName)
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
return _lookupPrivilegeDisplayName(_p0, name, buffer, size, languageId)
|
|
||||||
}
|
|
||||||
|
|
||||||
func _lookupPrivilegeDisplayName(systemName *uint16, name *uint16, buffer *uint16, size *uint32, languageId *uint32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall6(procLookupPrivilegeDisplayNameW.Addr(), 5, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buffer)), uintptr(unsafe.Pointer(size)), uintptr(unsafe.Pointer(languageId)), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupPrivilegeName(systemName string, luid *uint64, 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 *uint64, 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 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func lookupPrivilegeValue(systemName string, name string, luid *uint64) (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 *uint64) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procLookupPrivilegeValueW.Addr(), 3, uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(luid)))
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func openThreadToken(thread syscall.Handle, accessMask uint32, openAsSelf bool, token *windows.Token) (err error) {
|
|
||||||
var _p0 uint32
|
|
||||||
if openAsSelf {
|
|
||||||
_p0 = 1
|
|
||||||
}
|
|
||||||
r1, _, e1 := syscall.Syscall6(procOpenThreadToken.Addr(), 4, uintptr(thread), uintptr(accessMask), uintptr(_p0), uintptr(unsafe.Pointer(token)), 0, 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func revertToSelf() (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procRevertToSelf.Addr(), 0, 0, 0, 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func backupRead(h syscall.Handle, b []byte, bytesRead *uint32, abort bool, processSecurity bool, context *uintptr) (err error) {
|
|
||||||
var _p0 *byte
|
|
||||||
if len(b) > 0 {
|
|
||||||
_p0 = &b[0]
|
|
||||||
}
|
|
||||||
var _p1 uint32
|
|
||||||
if abort {
|
|
||||||
_p1 = 1
|
|
||||||
}
|
|
||||||
var _p2 uint32
|
|
||||||
if processSecurity {
|
|
||||||
_p2 = 1
|
|
||||||
}
|
|
||||||
r1, _, e1 := syscall.Syscall9(procBackupRead.Addr(), 7, uintptr(h), uintptr(unsafe.Pointer(_p0)), uintptr(len(b)), uintptr(unsafe.Pointer(bytesRead)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(context)), 0, 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func backupWrite(h syscall.Handle, b []byte, bytesWritten *uint32, abort bool, processSecurity bool, context *uintptr) (err error) {
|
|
||||||
var _p0 *byte
|
|
||||||
if len(b) > 0 {
|
|
||||||
_p0 = &b[0]
|
|
||||||
}
|
|
||||||
var _p1 uint32
|
|
||||||
if abort {
|
|
||||||
_p1 = 1
|
|
||||||
}
|
|
||||||
var _p2 uint32
|
|
||||||
if processSecurity {
|
|
||||||
_p2 = 1
|
|
||||||
}
|
|
||||||
r1, _, e1 := syscall.Syscall9(procBackupWrite.Addr(), 7, uintptr(h), uintptr(unsafe.Pointer(_p0)), uintptr(len(b)), uintptr(unsafe.Pointer(bytesWritten)), uintptr(_p1), uintptr(_p2), uintptr(unsafe.Pointer(context)), 0, 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func cancelIoEx(file syscall.Handle, o *syscall.Overlapped) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procCancelIoEx.Addr(), 2, uintptr(file), uintptr(unsafe.Pointer(o)), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func connectNamedPipe(pipe syscall.Handle, o *syscall.Overlapped) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procConnectNamedPipe.Addr(), 2, uintptr(pipe), uintptr(unsafe.Pointer(o)), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func createIoCompletionPort(file syscall.Handle, port syscall.Handle, key uintptr, threadCount uint32) (newport syscall.Handle, err error) {
|
|
||||||
r0, _, e1 := syscall.Syscall6(procCreateIoCompletionPort.Addr(), 4, uintptr(file), uintptr(port), uintptr(key), uintptr(threadCount), 0, 0)
|
|
||||||
newport = syscall.Handle(r0)
|
|
||||||
if newport == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func createNamedPipe(name string, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error) {
|
|
||||||
var _p0 *uint16
|
|
||||||
_p0, err = syscall.UTF16PtrFromString(name)
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
return _createNamedPipe(_p0, flags, pipeMode, maxInstances, outSize, inSize, defaultTimeout, sa)
|
|
||||||
}
|
|
||||||
|
|
||||||
func _createNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *syscall.SecurityAttributes) (handle syscall.Handle, err error) {
|
|
||||||
r0, _, e1 := syscall.Syscall9(procCreateNamedPipeW.Addr(), 8, uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(pipeMode), uintptr(maxInstances), uintptr(outSize), uintptr(inSize), uintptr(defaultTimeout), uintptr(unsafe.Pointer(sa)), 0)
|
|
||||||
handle = syscall.Handle(r0)
|
|
||||||
if handle == syscall.InvalidHandle {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func getCurrentThread() (h syscall.Handle) {
|
|
||||||
r0, _, _ := syscall.Syscall(procGetCurrentThread.Addr(), 0, 0, 0, 0)
|
|
||||||
h = syscall.Handle(r0)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func getNamedPipeHandleState(pipe syscall.Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall9(procGetNamedPipeHandleStateW.Addr(), 7, uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize), 0, 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func getNamedPipeInfo(pipe syscall.Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall6(procGetNamedPipeInfo.Addr(), 5, uintptr(pipe), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(outSize)), uintptr(unsafe.Pointer(inSize)), uintptr(unsafe.Pointer(maxInstances)), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func getQueuedCompletionStatus(port syscall.Handle, bytes *uint32, key *uintptr, o **ioOperation, timeout uint32) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall6(procGetQueuedCompletionStatus.Addr(), 5, uintptr(port), uintptr(unsafe.Pointer(bytes)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(o)), uintptr(timeout), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func localAlloc(uFlags uint32, length uint32) (ptr uintptr) {
|
|
||||||
r0, _, _ := syscall.Syscall(procLocalAlloc.Addr(), 2, uintptr(uFlags), uintptr(length), 0)
|
|
||||||
ptr = uintptr(r0)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func localFree(mem uintptr) {
|
|
||||||
syscall.Syscall(procLocalFree.Addr(), 1, uintptr(mem), 0, 0)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func setFileCompletionNotificationModes(h syscall.Handle, flags uint8) (err error) {
|
|
||||||
r1, _, e1 := syscall.Syscall(procSetFileCompletionNotificationModes.Addr(), 2, uintptr(h), uintptr(flags), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func ntCreateNamedPipeFile(pipe *syscall.Handle, access uint32, oa *objectAttributes, iosb *ioStatusBlock, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (status ntStatus) {
|
|
||||||
r0, _, _ := syscall.Syscall15(procNtCreateNamedPipeFile.Addr(), 14, uintptr(unsafe.Pointer(pipe)), uintptr(access), uintptr(unsafe.Pointer(oa)), uintptr(unsafe.Pointer(iosb)), uintptr(share), uintptr(disposition), uintptr(options), uintptr(typ), uintptr(readMode), uintptr(completionMode), uintptr(maxInstances), uintptr(inboundQuota), uintptr(outputQuota), uintptr(unsafe.Pointer(timeout)), 0)
|
|
||||||
status = ntStatus(r0)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func rtlDefaultNpAcl(dacl *uintptr) (status ntStatus) {
|
|
||||||
r0, _, _ := syscall.Syscall(procRtlDefaultNpAcl.Addr(), 1, uintptr(unsafe.Pointer(dacl)), 0, 0)
|
|
||||||
status = ntStatus(r0)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func rtlDosPathNameToNtPathName(name *uint16, ntName *unicodeString, filePart uintptr, reserved uintptr) (status ntStatus) {
|
|
||||||
r0, _, _ := syscall.Syscall6(procRtlDosPathNameToNtPathName_U.Addr(), 4, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(ntName)), uintptr(filePart), uintptr(reserved), 0, 0)
|
|
||||||
status = ntStatus(r0)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func rtlNtStatusToDosError(status ntStatus) (winerr error) {
|
|
||||||
r0, _, _ := syscall.Syscall(procRtlNtStatusToDosErrorNoTeb.Addr(), 1, uintptr(status), 0, 0)
|
|
||||||
if r0 != 0 {
|
|
||||||
winerr = syscall.Errno(r0)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func wsaGetOverlappedResult(h syscall.Handle, o *syscall.Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) {
|
|
||||||
var _p0 uint32
|
|
||||||
if wait {
|
|
||||||
_p0 = 1
|
|
||||||
}
|
|
||||||
r1, _, e1 := syscall.Syscall6(procWSAGetOverlappedResult.Addr(), 5, uintptr(h), uintptr(unsafe.Pointer(o)), uintptr(unsafe.Pointer(bytes)), uintptr(_p0), uintptr(unsafe.Pointer(flags)), 0)
|
|
||||||
if r1 == 0 {
|
|
||||||
err = errnoErr(e1)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
@ -1,53 +0,0 @@
|
|||||||
# Ignore docs files
|
|
||||||
_gh_pages
|
|
||||||
_site
|
|
||||||
|
|
||||||
# Ignore temporary files
|
|
||||||
README.html
|
|
||||||
coverage.out
|
|
||||||
.tmp
|
|
||||||
|
|
||||||
# Numerous always-ignore extensions
|
|
||||||
*.diff
|
|
||||||
*.err
|
|
||||||
*.log
|
|
||||||
*.orig
|
|
||||||
*.rej
|
|
||||||
*.swo
|
|
||||||
*.swp
|
|
||||||
*.vi
|
|
||||||
*.zip
|
|
||||||
*~
|
|
||||||
|
|
||||||
# OS or Editor folders
|
|
||||||
._*
|
|
||||||
.cache
|
|
||||||
.DS_Store
|
|
||||||
.idea
|
|
||||||
.project
|
|
||||||
.settings
|
|
||||||
.tmproj
|
|
||||||
*.esproj
|
|
||||||
*.sublime-project
|
|
||||||
*.sublime-workspace
|
|
||||||
nbproject
|
|
||||||
Thumbs.db
|
|
||||||
|
|
||||||
# Komodo
|
|
||||||
.komodotools
|
|
||||||
*.komodoproject
|
|
||||||
|
|
||||||
# SCSS-Lint
|
|
||||||
scss-lint-report.xml
|
|
||||||
|
|
||||||
# grunt-contrib-sass cache
|
|
||||||
.sass-cache
|
|
||||||
|
|
||||||
# Jekyll metadata
|
|
||||||
docs/.jekyll-metadata
|
|
||||||
|
|
||||||
# Folders to ignore
|
|
||||||
.build
|
|
||||||
.test
|
|
||||||
bower_components
|
|
||||||
node_modules
|
|
||||||
@ -1,30 +0,0 @@
|
|||||||
language: go
|
|
||||||
sudo: false
|
|
||||||
matrix:
|
|
||||||
fast_finish: true
|
|
||||||
include:
|
|
||||||
- go: 1.14.x
|
|
||||||
env: TEST_METHOD=goveralls
|
|
||||||
- go: 1.13.x
|
|
||||||
- go: 1.12.x
|
|
||||||
- go: 1.11.x
|
|
||||||
- go: 1.10.x
|
|
||||||
- go: tip
|
|
||||||
- go: 1.9.x
|
|
||||||
- go: 1.8.x
|
|
||||||
- go: 1.7.x
|
|
||||||
- go: 1.6.x
|
|
||||||
- go: 1.5.x
|
|
||||||
allow_failures:
|
|
||||||
- go: tip
|
|
||||||
- go: 1.11.x
|
|
||||||
- go: 1.10.x
|
|
||||||
- go: 1.9.x
|
|
||||||
- go: 1.8.x
|
|
||||||
- go: 1.7.x
|
|
||||||
- go: 1.6.x
|
|
||||||
- go: 1.5.x
|
|
||||||
script: ./test.sh $TEST_METHOD
|
|
||||||
notifications:
|
|
||||||
email:
|
|
||||||
on_success: never
|
|
||||||
@ -1,36 +0,0 @@
|
|||||||
Developer Certificate of Origin
|
|
||||||
Version 1.1
|
|
||||||
|
|
||||||
Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
|
|
||||||
660 York Street, Suite 102,
|
|
||||||
San Francisco, CA 94110 USA
|
|
||||||
|
|
||||||
Everyone is permitted to copy and distribute verbatim copies of this
|
|
||||||
license document, but changing it is not allowed.
|
|
||||||
|
|
||||||
|
|
||||||
Developer's Certificate of Origin 1.1
|
|
||||||
|
|
||||||
By making a contribution to this project, I certify that:
|
|
||||||
|
|
||||||
(a) The contribution was created in whole or in part by me and I
|
|
||||||
have the right to submit it under the open source license
|
|
||||||
indicated in the file; or
|
|
||||||
|
|
||||||
(b) The contribution is based upon previous work that, to the best
|
|
||||||
of my knowledge, is covered under an appropriate open source
|
|
||||||
license and I have the right under that license to submit that
|
|
||||||
work with modifications, whether created in whole or in part
|
|
||||||
by me, under the same open source license (unless I am
|
|
||||||
permitted to submit under a different license), as indicated
|
|
||||||
in the file; or
|
|
||||||
|
|
||||||
(c) The contribution was provided directly to me by some other
|
|
||||||
person who certified (a), (b) or (c) and I have not modified
|
|
||||||
it.
|
|
||||||
|
|
||||||
(d) I understand and agree that this project and the contribution
|
|
||||||
are public and that a record of the contribution (including all
|
|
||||||
personal information I submit with it, including my sign-off) is
|
|
||||||
maintained indefinitely and may be redistributed consistent with
|
|
||||||
this project or the open source license(s) involved.
|
|
||||||
@ -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.
|
|
||||||
@ -1 +0,0 @@
|
|||||||
Alex Bucataru <alex@alrux.com> (@AlexBucataru)
|
|
||||||
@ -1,5 +0,0 @@
|
|||||||
Alrux Go EXTensions (AGExt) - package levenshtein
|
|
||||||
Copyright 2016 ALRUX Inc.
|
|
||||||
|
|
||||||
This product includes software developed at ALRUX Inc.
|
|
||||||
(http://www.alrux.com/).
|
|
||||||
@ -1,290 +0,0 @@
|
|||||||
// Copyright 2016 ALRUX Inc.
|
|
||||||
//
|
|
||||||
// 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.
|
|
||||||
|
|
||||||
/*
|
|
||||||
Package levenshtein implements distance and similarity metrics for strings, based on the Levenshtein measure.
|
|
||||||
|
|
||||||
The Levenshtein `Distance` between two strings is the minimum total cost of edits that would convert the first string into the second. The allowed edit operations are insertions, deletions, and substitutions, all at character (one UTF-8 code point) level. Each operation has a default cost of 1, but each can be assigned its own cost equal to or greater than 0.
|
|
||||||
|
|
||||||
A `Distance` of 0 means the two strings are identical, and the higher the value the more different the strings. Since in practice we are interested in finding if the two strings are "close enough", it often does not make sense to continue the calculation once the result is mathematically guaranteed to exceed a desired threshold. Providing this value to the `Distance` function allows it to take a shortcut and return a lower bound instead of an exact cost when the threshold is exceeded.
|
|
||||||
|
|
||||||
The `Similarity` function calculates the distance, then converts it into a normalized metric within the range 0..1, with 1 meaning the strings are identical, and 0 that they have nothing in common. A minimum similarity threshold can be provided to speed up the calculation of the metric for strings that are far too dissimilar for the purpose at hand. All values under this threshold are rounded down to 0.
|
|
||||||
|
|
||||||
The `Match` function provides a similarity metric, with the same range and meaning as `Similarity`, but with a bonus for string pairs that share a common prefix and have a similarity above a "bonus threshold". It uses the same method as proposed by Winkler for the Jaro distance, and the reasoning behind it is that these string pairs are very likely spelling variations or errors, and they are more closely linked than the edit distance alone would suggest.
|
|
||||||
|
|
||||||
The underlying `Calculate` function is also exported, to allow the building of other derivative metrics, if needed.
|
|
||||||
*/
|
|
||||||
package levenshtein
|
|
||||||
|
|
||||||
// Calculate determines the Levenshtein distance between two strings, using
|
|
||||||
// the given costs for each edit operation. It returns the distance along with
|
|
||||||
// the lengths of the longest common prefix and suffix.
|
|
||||||
//
|
|
||||||
// If maxCost is non-zero, the calculation stops as soon as the distance is determined
|
|
||||||
// to be greater than maxCost. Therefore, any return value higher than maxCost is a
|
|
||||||
// lower bound for the actual distance.
|
|
||||||
func Calculate(str1, str2 []rune, maxCost, insCost, subCost, delCost int) (dist, prefixLen, suffixLen int) {
|
|
||||||
l1, l2 := len(str1), len(str2)
|
|
||||||
// trim common prefix, if any, as it doesn't affect the distance
|
|
||||||
for ; prefixLen < l1 && prefixLen < l2; prefixLen++ {
|
|
||||||
if str1[prefixLen] != str2[prefixLen] {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
str1, str2 = str1[prefixLen:], str2[prefixLen:]
|
|
||||||
l1 -= prefixLen
|
|
||||||
l2 -= prefixLen
|
|
||||||
// trim common suffix, if any, as it doesn't affect the distance
|
|
||||||
for 0 < l1 && 0 < l2 {
|
|
||||||
if str1[l1-1] != str2[l2-1] {
|
|
||||||
str1, str2 = str1[:l1], str2[:l2]
|
|
||||||
break
|
|
||||||
}
|
|
||||||
l1--
|
|
||||||
l2--
|
|
||||||
suffixLen++
|
|
||||||
}
|
|
||||||
// if the first string is empty, the distance is the length of the second string times the cost of insertion
|
|
||||||
if l1 == 0 {
|
|
||||||
dist = l2 * insCost
|
|
||||||
return
|
|
||||||
}
|
|
||||||
// if the second string is empty, the distance is the length of the first string times the cost of deletion
|
|
||||||
if l2 == 0 {
|
|
||||||
dist = l1 * delCost
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// variables used in inner "for" loops
|
|
||||||
var y, dy, c, l int
|
|
||||||
|
|
||||||
// if maxCost is greater than or equal to the maximum possible distance, it's equivalent to 'unlimited'
|
|
||||||
if maxCost > 0 {
|
|
||||||
if subCost < delCost+insCost {
|
|
||||||
if maxCost >= l1*subCost+(l2-l1)*insCost {
|
|
||||||
maxCost = 0
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if maxCost >= l1*delCost+l2*insCost {
|
|
||||||
maxCost = 0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if maxCost > 0 {
|
|
||||||
// prefer the longer string first, to minimize time;
|
|
||||||
// a swap also transposes the meanings of insertion and deletion.
|
|
||||||
if l1 < l2 {
|
|
||||||
str1, str2, l1, l2, insCost, delCost = str2, str1, l2, l1, delCost, insCost
|
|
||||||
}
|
|
||||||
|
|
||||||
// the length differential times cost of deletion is a lower bound for the cost;
|
|
||||||
// if it is higher than the maxCost, there is no point going into the main calculation.
|
|
||||||
if dist = (l1 - l2) * delCost; dist > maxCost {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
d := make([]int, l1+1)
|
|
||||||
|
|
||||||
// offset and length of d in the current row
|
|
||||||
doff, dlen := 0, 1
|
|
||||||
for y, dy = 1, delCost; y <= l1 && dy <= maxCost; dlen++ {
|
|
||||||
d[y] = dy
|
|
||||||
y++
|
|
||||||
dy = y * delCost
|
|
||||||
}
|
|
||||||
// fmt.Printf("%q -> %q: init doff=%d dlen=%d d[%d:%d]=%v\n", str1, str2, doff, dlen, doff, doff+dlen, d[doff:doff+dlen])
|
|
||||||
|
|
||||||
for x := 0; x < l2; x++ {
|
|
||||||
dy, d[doff] = d[doff], d[doff]+insCost
|
|
||||||
for doff < l1 && d[doff] > maxCost && dlen > 0 {
|
|
||||||
if str1[doff] != str2[x] {
|
|
||||||
dy += subCost
|
|
||||||
}
|
|
||||||
doff++
|
|
||||||
dlen--
|
|
||||||
if c = d[doff] + insCost; c < dy {
|
|
||||||
dy = c
|
|
||||||
}
|
|
||||||
dy, d[doff] = d[doff], dy
|
|
||||||
}
|
|
||||||
for y, l = doff, doff+dlen-1; y < l; dy, d[y] = d[y], dy {
|
|
||||||
if str1[y] != str2[x] {
|
|
||||||
dy += subCost
|
|
||||||
}
|
|
||||||
if c = d[y] + delCost; c < dy {
|
|
||||||
dy = c
|
|
||||||
}
|
|
||||||
y++
|
|
||||||
if c = d[y] + insCost; c < dy {
|
|
||||||
dy = c
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if y < l1 {
|
|
||||||
if str1[y] != str2[x] {
|
|
||||||
dy += subCost
|
|
||||||
}
|
|
||||||
if c = d[y] + delCost; c < dy {
|
|
||||||
dy = c
|
|
||||||
}
|
|
||||||
for ; dy <= maxCost && y < l1; dy, d[y] = dy+delCost, dy {
|
|
||||||
y++
|
|
||||||
dlen++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// fmt.Printf("%q -> %q: x=%d doff=%d dlen=%d d[%d:%d]=%v\n", str1, str2, x, doff, dlen, doff, doff+dlen, d[doff:doff+dlen])
|
|
||||||
if dlen == 0 {
|
|
||||||
dist = maxCost + 1
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if doff+dlen-1 < l1 {
|
|
||||||
dist = maxCost + 1
|
|
||||||
return
|
|
||||||
}
|
|
||||||
dist = d[l1]
|
|
||||||
} else {
|
|
||||||
// ToDo: This is O(l1*l2) time and O(min(l1,l2)) space; investigate if it is
|
|
||||||
// worth to implement diagonal approach - O(l1*(1+dist)) time, up to O(l1*l2) space
|
|
||||||
// http://www.csse.monash.edu.au/~lloyd/tildeStrings/Alignment/92.IPL.html
|
|
||||||
|
|
||||||
// prefer the shorter string first, to minimize space; time is O(l1*l2) anyway;
|
|
||||||
// a swap also transposes the meanings of insertion and deletion.
|
|
||||||
if l1 > l2 {
|
|
||||||
str1, str2, l1, l2, insCost, delCost = str2, str1, l2, l1, delCost, insCost
|
|
||||||
}
|
|
||||||
d := make([]int, l1+1)
|
|
||||||
|
|
||||||
for y = 1; y <= l1; y++ {
|
|
||||||
d[y] = y * delCost
|
|
||||||
}
|
|
||||||
for x := 0; x < l2; x++ {
|
|
||||||
dy, d[0] = d[0], d[0]+insCost
|
|
||||||
for y = 0; y < l1; dy, d[y] = d[y], dy {
|
|
||||||
if str1[y] != str2[x] {
|
|
||||||
dy += subCost
|
|
||||||
}
|
|
||||||
if c = d[y] + delCost; c < dy {
|
|
||||||
dy = c
|
|
||||||
}
|
|
||||||
y++
|
|
||||||
if c = d[y] + insCost; c < dy {
|
|
||||||
dy = c
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
dist = d[l1]
|
|
||||||
}
|
|
||||||
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Distance returns the Levenshtein distance between str1 and str2, using the
|
|
||||||
// default or provided cost values. Pass nil for the third argument to use the
|
|
||||||
// default cost of 1 for all three operations, with no maximum.
|
|
||||||
func Distance(str1, str2 string, p *Params) int {
|
|
||||||
if p == nil {
|
|
||||||
p = defaultParams
|
|
||||||
}
|
|
||||||
dist, _, _ := Calculate([]rune(str1), []rune(str2), p.maxCost, p.insCost, p.subCost, p.delCost)
|
|
||||||
return dist
|
|
||||||
}
|
|
||||||
|
|
||||||
// Similarity returns a score in the range of 0..1 for how similar the two strings are.
|
|
||||||
// A score of 1 means the strings are identical, and 0 means they have nothing in common.
|
|
||||||
//
|
|
||||||
// A nil third argument uses the default cost of 1 for all three operations.
|
|
||||||
//
|
|
||||||
// If a non-zero MinScore value is provided in the parameters, scores lower than it
|
|
||||||
// will be returned as 0.
|
|
||||||
func Similarity(str1, str2 string, p *Params) float64 {
|
|
||||||
return Match(str1, str2, p.Clone().BonusThreshold(1.1)) // guaranteed no bonus
|
|
||||||
}
|
|
||||||
|
|
||||||
// Match returns a similarity score adjusted by the same method as proposed by Winkler for
|
|
||||||
// the Jaro distance - giving a bonus to string pairs that share a common prefix, only if their
|
|
||||||
// similarity score is already over a threshold.
|
|
||||||
//
|
|
||||||
// The score is in the range of 0..1, with 1 meaning the strings are identical,
|
|
||||||
// and 0 meaning they have nothing in common.
|
|
||||||
//
|
|
||||||
// A nil third argument uses the default cost of 1 for all three operations, maximum length of
|
|
||||||
// common prefix to consider for bonus of 4, scaling factor of 0.1, and bonus threshold of 0.7.
|
|
||||||
//
|
|
||||||
// If a non-zero MinScore value is provided in the parameters, scores lower than it
|
|
||||||
// will be returned as 0.
|
|
||||||
func Match(str1, str2 string, p *Params) float64 {
|
|
||||||
s1, s2 := []rune(str1), []rune(str2)
|
|
||||||
l1, l2 := len(s1), len(s2)
|
|
||||||
// two empty strings are identical; shortcut also avoids divByZero issues later on.
|
|
||||||
if l1 == 0 && l2 == 0 {
|
|
||||||
return 1
|
|
||||||
}
|
|
||||||
|
|
||||||
if p == nil {
|
|
||||||
p = defaultParams
|
|
||||||
}
|
|
||||||
|
|
||||||
// a min over 1 can never be satisfied, so the score is 0.
|
|
||||||
if p.minScore > 1 {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
insCost, delCost, maxDist, max := p.insCost, p.delCost, 0, 0
|
|
||||||
if l1 > l2 {
|
|
||||||
l1, l2, insCost, delCost = l2, l1, delCost, insCost
|
|
||||||
}
|
|
||||||
|
|
||||||
if p.subCost < delCost+insCost {
|
|
||||||
maxDist = l1*p.subCost + (l2-l1)*insCost
|
|
||||||
} else {
|
|
||||||
maxDist = l1*delCost + l2*insCost
|
|
||||||
}
|
|
||||||
|
|
||||||
// a zero min is always satisfied, so no need to set a max cost.
|
|
||||||
if p.minScore > 0 {
|
|
||||||
// if p.minScore is lower than p.bonusThreshold, we can use a simplified formula
|
|
||||||
// for the max cost, because a sim score below min cannot receive a bonus.
|
|
||||||
if p.minScore < p.bonusThreshold {
|
|
||||||
// round down the max - a cost equal to a rounded up max would already be under min.
|
|
||||||
max = int((1 - p.minScore) * float64(maxDist))
|
|
||||||
} else {
|
|
||||||
// p.minScore <= sim + p.bonusPrefix*p.bonusScale*(1-sim)
|
|
||||||
// p.minScore <= (1-dist/maxDist) + p.bonusPrefix*p.bonusScale*(1-(1-dist/maxDist))
|
|
||||||
// p.minScore <= 1 - dist/maxDist + p.bonusPrefix*p.bonusScale*dist/maxDist
|
|
||||||
// 1 - p.minScore >= dist/maxDist - p.bonusPrefix*p.bonusScale*dist/maxDist
|
|
||||||
// (1-p.minScore)*maxDist/(1-p.bonusPrefix*p.bonusScale) >= dist
|
|
||||||
max = int((1 - p.minScore) * float64(maxDist) / (1 - float64(p.bonusPrefix)*p.bonusScale))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
dist, pl, _ := Calculate(s1, s2, max, p.insCost, p.subCost, p.delCost)
|
|
||||||
if max > 0 && dist > max {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
sim := 1 - float64(dist)/float64(maxDist)
|
|
||||||
|
|
||||||
if sim >= p.bonusThreshold && sim < 1 && p.bonusPrefix > 0 && p.bonusScale > 0 {
|
|
||||||
if pl > p.bonusPrefix {
|
|
||||||
pl = p.bonusPrefix
|
|
||||||
}
|
|
||||||
sim += float64(pl) * p.bonusScale * (1 - sim)
|
|
||||||
}
|
|
||||||
|
|
||||||
if sim < p.minScore {
|
|
||||||
return 0
|
|
||||||
}
|
|
||||||
|
|
||||||
return sim
|
|
||||||
}
|
|
||||||
@ -1,152 +0,0 @@
|
|||||||
// Copyright 2016 ALRUX Inc.
|
|
||||||
//
|
|
||||||
// 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.
|
|
||||||
|
|
||||||
package levenshtein
|
|
||||||
|
|
||||||
// Params represents a set of parameter values for the various formulas involved
|
|
||||||
// in the calculation of the Levenshtein string metrics.
|
|
||||||
type Params struct {
|
|
||||||
insCost int
|
|
||||||
subCost int
|
|
||||||
delCost int
|
|
||||||
maxCost int
|
|
||||||
minScore float64
|
|
||||||
bonusPrefix int
|
|
||||||
bonusScale float64
|
|
||||||
bonusThreshold float64
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
defaultParams = NewParams()
|
|
||||||
)
|
|
||||||
|
|
||||||
// NewParams creates a new set of parameters and initializes it with the default values.
|
|
||||||
func NewParams() *Params {
|
|
||||||
return &Params{
|
|
||||||
insCost: 1,
|
|
||||||
subCost: 1,
|
|
||||||
delCost: 1,
|
|
||||||
maxCost: 0,
|
|
||||||
minScore: 0,
|
|
||||||
bonusPrefix: 4,
|
|
||||||
bonusScale: .1,
|
|
||||||
bonusThreshold: .7,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Clone returns a pointer to a copy of the receiver parameter set, or of a new
|
|
||||||
// default parameter set if the receiver is nil.
|
|
||||||
func (p *Params) Clone() *Params {
|
|
||||||
if p == nil {
|
|
||||||
return NewParams()
|
|
||||||
}
|
|
||||||
return &Params{
|
|
||||||
insCost: p.insCost,
|
|
||||||
subCost: p.subCost,
|
|
||||||
delCost: p.delCost,
|
|
||||||
maxCost: p.maxCost,
|
|
||||||
minScore: p.minScore,
|
|
||||||
bonusPrefix: p.bonusPrefix,
|
|
||||||
bonusScale: p.bonusScale,
|
|
||||||
bonusThreshold: p.bonusThreshold,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// InsCost overrides the default value of 1 for the cost of insertion.
|
|
||||||
// The new value must be zero or positive.
|
|
||||||
func (p *Params) InsCost(v int) *Params {
|
|
||||||
if v >= 0 {
|
|
||||||
p.insCost = v
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
// SubCost overrides the default value of 1 for the cost of substitution.
|
|
||||||
// The new value must be zero or positive.
|
|
||||||
func (p *Params) SubCost(v int) *Params {
|
|
||||||
if v >= 0 {
|
|
||||||
p.subCost = v
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
// DelCost overrides the default value of 1 for the cost of deletion.
|
|
||||||
// The new value must be zero or positive.
|
|
||||||
func (p *Params) DelCost(v int) *Params {
|
|
||||||
if v >= 0 {
|
|
||||||
p.delCost = v
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
// MaxCost overrides the default value of 0 (meaning unlimited) for the maximum cost.
|
|
||||||
// The calculation of Distance() stops when the result is guaranteed to exceed
|
|
||||||
// this maximum, returning a lower-bound rather than exact value.
|
|
||||||
// The new value must be zero or positive.
|
|
||||||
func (p *Params) MaxCost(v int) *Params {
|
|
||||||
if v >= 0 {
|
|
||||||
p.maxCost = v
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
// MinScore overrides the default value of 0 for the minimum similarity score.
|
|
||||||
// Scores below this threshold are returned as 0 by Similarity() and Match().
|
|
||||||
// The new value must be zero or positive. Note that a minimum greater than 1
|
|
||||||
// can never be satisfied, resulting in a score of 0 for any pair of strings.
|
|
||||||
func (p *Params) MinScore(v float64) *Params {
|
|
||||||
if v >= 0 {
|
|
||||||
p.minScore = v
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
// BonusPrefix overrides the default value for the maximum length of
|
|
||||||
// common prefix to be considered for bonus by Match().
|
|
||||||
// The new value must be zero or positive.
|
|
||||||
func (p *Params) BonusPrefix(v int) *Params {
|
|
||||||
if v >= 0 {
|
|
||||||
p.bonusPrefix = v
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
// BonusScale overrides the default value for the scaling factor used by Match()
|
|
||||||
// in calculating the bonus.
|
|
||||||
// The new value must be zero or positive. To guarantee that the similarity score
|
|
||||||
// remains in the interval 0..1, this scaling factor is not allowed to exceed
|
|
||||||
// 1 / BonusPrefix.
|
|
||||||
func (p *Params) BonusScale(v float64) *Params {
|
|
||||||
if v >= 0 {
|
|
||||||
p.bonusScale = v
|
|
||||||
}
|
|
||||||
|
|
||||||
// the bonus cannot exceed (1-sim), or the score may become greater than 1.
|
|
||||||
if float64(p.bonusPrefix)*p.bonusScale > 1 {
|
|
||||||
p.bonusScale = 1 / float64(p.bonusPrefix)
|
|
||||||
}
|
|
||||||
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
// BonusThreshold overrides the default value for the minimum similarity score
|
|
||||||
// for which Match() can assign a bonus.
|
|
||||||
// The new value must be zero or positive. Note that a threshold greater than 1
|
|
||||||
// effectively makes Match() become the equivalent of Similarity().
|
|
||||||
func (p *Params) BonusThreshold(v float64) *Params {
|
|
||||||
if v >= 0 {
|
|
||||||
p.bonusThreshold = v
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
@ -1,10 +0,0 @@
|
|||||||
set -ev
|
|
||||||
|
|
||||||
if [[ "$1" == "goveralls" ]]; then
|
|
||||||
echo "Testing with goveralls..."
|
|
||||||
go get github.com/mattn/goveralls
|
|
||||||
$HOME/gopath/bin/goveralls -service=travis-ci
|
|
||||||
else
|
|
||||||
echo "Testing with go test..."
|
|
||||||
go test -v ./...
|
|
||||||
fi
|
|
||||||
@ -1,27 +0,0 @@
|
|||||||
Copyright (c) 2012 The Go Authors. All rights reserved.
|
|
||||||
|
|
||||||
Redistribution and use in source and binary forms, with or without
|
|
||||||
modification, are permitted provided that the following conditions are
|
|
||||||
met:
|
|
||||||
|
|
||||||
* Redistributions of source code must retain the above copyright
|
|
||||||
notice, this list of conditions and the following disclaimer.
|
|
||||||
* Redistributions in binary form must reproduce the above
|
|
||||||
copyright notice, this list of conditions and the following disclaimer
|
|
||||||
in the documentation and/or other materials provided with the
|
|
||||||
distribution.
|
|
||||||
* Neither the name of Google Inc. nor the names of its
|
|
||||||
contributors may be used to endorse or promote products derived from
|
|
||||||
this software without specific prior written permission.
|
|
||||||
|
|
||||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
||||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
||||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
||||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
||||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
||||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
||||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
||||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
||||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
||||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
||||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
||||||
@ -1,127 +0,0 @@
|
|||||||
// Copyright 2013 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 ed25519 implements the Ed25519 signature algorithm. See
|
|
||||||
// http://ed25519.cr.yp.to/.
|
|
||||||
package ed25519
|
|
||||||
|
|
||||||
// This code is a port of the public domain, "ref10" implementation of ed25519
|
|
||||||
// from SUPERCOP.
|
|
||||||
|
|
||||||
import (
|
|
||||||
"crypto/sha512"
|
|
||||||
"crypto/subtle"
|
|
||||||
"io"
|
|
||||||
|
|
||||||
"github.com/agl/ed25519/edwards25519"
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
PublicKeySize = 32
|
|
||||||
PrivateKeySize = 64
|
|
||||||
SignatureSize = 64
|
|
||||||
)
|
|
||||||
|
|
||||||
// GenerateKey generates a public/private key pair using randomness from rand.
|
|
||||||
func GenerateKey(rand io.Reader) (publicKey *[PublicKeySize]byte, privateKey *[PrivateKeySize]byte, err error) {
|
|
||||||
privateKey = new([64]byte)
|
|
||||||
publicKey = new([32]byte)
|
|
||||||
_, err = io.ReadFull(rand, privateKey[:32])
|
|
||||||
if err != nil {
|
|
||||||
return nil, nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
h := sha512.New()
|
|
||||||
h.Write(privateKey[:32])
|
|
||||||
digest := h.Sum(nil)
|
|
||||||
|
|
||||||
digest[0] &= 248
|
|
||||||
digest[31] &= 127
|
|
||||||
digest[31] |= 64
|
|
||||||
|
|
||||||
var A edwards25519.ExtendedGroupElement
|
|
||||||
var hBytes [32]byte
|
|
||||||
copy(hBytes[:], digest)
|
|
||||||
edwards25519.GeScalarMultBase(&A, &hBytes)
|
|
||||||
A.ToBytes(publicKey)
|
|
||||||
|
|
||||||
copy(privateKey[32:], publicKey[:])
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Sign signs the message with privateKey and returns a signature.
|
|
||||||
func Sign(privateKey *[PrivateKeySize]byte, message []byte) *[SignatureSize]byte {
|
|
||||||
h := sha512.New()
|
|
||||||
h.Write(privateKey[:32])
|
|
||||||
|
|
||||||
var digest1, messageDigest, hramDigest [64]byte
|
|
||||||
var expandedSecretKey [32]byte
|
|
||||||
h.Sum(digest1[:0])
|
|
||||||
copy(expandedSecretKey[:], digest1[:])
|
|
||||||
expandedSecretKey[0] &= 248
|
|
||||||
expandedSecretKey[31] &= 63
|
|
||||||
expandedSecretKey[31] |= 64
|
|
||||||
|
|
||||||
h.Reset()
|
|
||||||
h.Write(digest1[32:])
|
|
||||||
h.Write(message)
|
|
||||||
h.Sum(messageDigest[:0])
|
|
||||||
|
|
||||||
var messageDigestReduced [32]byte
|
|
||||||
edwards25519.ScReduce(&messageDigestReduced, &messageDigest)
|
|
||||||
var R edwards25519.ExtendedGroupElement
|
|
||||||
edwards25519.GeScalarMultBase(&R, &messageDigestReduced)
|
|
||||||
|
|
||||||
var encodedR [32]byte
|
|
||||||
R.ToBytes(&encodedR)
|
|
||||||
|
|
||||||
h.Reset()
|
|
||||||
h.Write(encodedR[:])
|
|
||||||
h.Write(privateKey[32:])
|
|
||||||
h.Write(message)
|
|
||||||
h.Sum(hramDigest[:0])
|
|
||||||
var hramDigestReduced [32]byte
|
|
||||||
edwards25519.ScReduce(&hramDigestReduced, &hramDigest)
|
|
||||||
|
|
||||||
var s [32]byte
|
|
||||||
edwards25519.ScMulAdd(&s, &hramDigestReduced, &expandedSecretKey, &messageDigestReduced)
|
|
||||||
|
|
||||||
signature := new([64]byte)
|
|
||||||
copy(signature[:], encodedR[:])
|
|
||||||
copy(signature[32:], s[:])
|
|
||||||
return signature
|
|
||||||
}
|
|
||||||
|
|
||||||
// Verify returns true iff sig is a valid signature of message by publicKey.
|
|
||||||
func Verify(publicKey *[PublicKeySize]byte, message []byte, sig *[SignatureSize]byte) bool {
|
|
||||||
if sig[63]&224 != 0 {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
var A edwards25519.ExtendedGroupElement
|
|
||||||
if !A.FromBytes(publicKey) {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
edwards25519.FeNeg(&A.X, &A.X)
|
|
||||||
edwards25519.FeNeg(&A.T, &A.T)
|
|
||||||
|
|
||||||
h := sha512.New()
|
|
||||||
h.Write(sig[:32])
|
|
||||||
h.Write(publicKey[:])
|
|
||||||
h.Write(message)
|
|
||||||
var digest [64]byte
|
|
||||||
h.Sum(digest[:0])
|
|
||||||
|
|
||||||
var hReduced [32]byte
|
|
||||||
edwards25519.ScReduce(&hReduced, &digest)
|
|
||||||
|
|
||||||
var R edwards25519.ProjectiveGroupElement
|
|
||||||
var b [32]byte
|
|
||||||
copy(b[:], sig[32:])
|
|
||||||
edwards25519.GeDoubleScalarMultVartime(&R, &hReduced, &A, &b)
|
|
||||||
|
|
||||||
var checkR [32]byte
|
|
||||||
R.ToBytes(&checkR)
|
|
||||||
return subtle.ConstantTimeCompare(sig[:32], checkR[:]) == 1
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,19 +0,0 @@
|
|||||||
Copyright (c) 2015 Martin Atkins
|
|
||||||
|
|
||||||
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.
|
|
||||||
@ -1,218 +0,0 @@
|
|||||||
// Package cidr is a collection of assorted utilities for computing
|
|
||||||
// network and host addresses within network ranges.
|
|
||||||
//
|
|
||||||
// It expects a CIDR-type address structure where addresses are divided into
|
|
||||||
// some number of prefix bits representing the network and then the remaining
|
|
||||||
// suffix bits represent the host.
|
|
||||||
//
|
|
||||||
// For example, it can help to calculate addresses for sub-networks of a
|
|
||||||
// parent network, or to calculate host addresses within a particular prefix.
|
|
||||||
//
|
|
||||||
// At present this package is prioritizing simplicity of implementation and
|
|
||||||
// de-prioritizing speed and memory usage. Thus caution is advised before
|
|
||||||
// using this package in performance-critical applications or hot codepaths.
|
|
||||||
// Patches to improve the speed and memory usage may be accepted as long as
|
|
||||||
// they do not result in a significant increase in code complexity.
|
|
||||||
package cidr
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"math/big"
|
|
||||||
"net"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Subnet takes a parent CIDR range and creates a subnet within it
|
|
||||||
// with the given number of additional prefix bits and the given
|
|
||||||
// network number.
|
|
||||||
//
|
|
||||||
// For example, 10.3.0.0/16, extended by 8 bits, with a network number
|
|
||||||
// of 5, becomes 10.3.5.0/24 .
|
|
||||||
func Subnet(base *net.IPNet, newBits int, num int) (*net.IPNet, error) {
|
|
||||||
ip := base.IP
|
|
||||||
mask := base.Mask
|
|
||||||
|
|
||||||
parentLen, addrLen := mask.Size()
|
|
||||||
newPrefixLen := parentLen + newBits
|
|
||||||
|
|
||||||
if newPrefixLen > addrLen {
|
|
||||||
return nil, fmt.Errorf("insufficient address space to extend prefix of %d by %d", parentLen, newBits)
|
|
||||||
}
|
|
||||||
|
|
||||||
maxNetNum := uint64(1<<uint64(newBits)) - 1
|
|
||||||
if uint64(num) > maxNetNum {
|
|
||||||
return nil, fmt.Errorf("prefix extension of %d does not accommodate a subnet numbered %d", newBits, num)
|
|
||||||
}
|
|
||||||
|
|
||||||
return &net.IPNet{
|
|
||||||
IP: insertNumIntoIP(ip, big.NewInt(int64(num)), newPrefixLen),
|
|
||||||
Mask: net.CIDRMask(newPrefixLen, addrLen),
|
|
||||||
}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Host takes a parent CIDR range and turns it into a host IP address with
|
|
||||||
// the given host number.
|
|
||||||
//
|
|
||||||
// For example, 10.3.0.0/16 with a host number of 2 gives 10.3.0.2.
|
|
||||||
func Host(base *net.IPNet, num int) (net.IP, error) {
|
|
||||||
ip := base.IP
|
|
||||||
mask := base.Mask
|
|
||||||
bigNum := big.NewInt(int64(num))
|
|
||||||
|
|
||||||
parentLen, addrLen := mask.Size()
|
|
||||||
hostLen := addrLen - parentLen
|
|
||||||
|
|
||||||
maxHostNum := big.NewInt(int64(1))
|
|
||||||
maxHostNum.Lsh(maxHostNum, uint(hostLen))
|
|
||||||
maxHostNum.Sub(maxHostNum, big.NewInt(1))
|
|
||||||
|
|
||||||
numUint64 := big.NewInt(int64(bigNum.Uint64()))
|
|
||||||
if bigNum.Cmp(big.NewInt(0)) == -1 {
|
|
||||||
numUint64.Neg(bigNum)
|
|
||||||
numUint64.Sub(numUint64, big.NewInt(int64(1)))
|
|
||||||
bigNum.Sub(maxHostNum, numUint64)
|
|
||||||
}
|
|
||||||
|
|
||||||
if numUint64.Cmp(maxHostNum) == 1 {
|
|
||||||
return nil, fmt.Errorf("prefix of %d does not accommodate a host numbered %d", parentLen, num)
|
|
||||||
}
|
|
||||||
var bitlength int
|
|
||||||
if ip.To4() != nil {
|
|
||||||
bitlength = 32
|
|
||||||
} else {
|
|
||||||
bitlength = 128
|
|
||||||
}
|
|
||||||
return insertNumIntoIP(ip, bigNum, bitlength), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// AddressRange returns the first and last addresses in the given CIDR range.
|
|
||||||
func AddressRange(network *net.IPNet) (net.IP, net.IP) {
|
|
||||||
// the first IP is easy
|
|
||||||
firstIP := network.IP
|
|
||||||
|
|
||||||
// the last IP is the network address OR NOT the mask address
|
|
||||||
prefixLen, bits := network.Mask.Size()
|
|
||||||
if prefixLen == bits {
|
|
||||||
// Easy!
|
|
||||||
// But make sure that our two slices are distinct, since they
|
|
||||||
// would be in all other cases.
|
|
||||||
lastIP := make([]byte, len(firstIP))
|
|
||||||
copy(lastIP, firstIP)
|
|
||||||
return firstIP, lastIP
|
|
||||||
}
|
|
||||||
|
|
||||||
firstIPInt, bits := ipToInt(firstIP)
|
|
||||||
hostLen := uint(bits) - uint(prefixLen)
|
|
||||||
lastIPInt := big.NewInt(1)
|
|
||||||
lastIPInt.Lsh(lastIPInt, hostLen)
|
|
||||||
lastIPInt.Sub(lastIPInt, big.NewInt(1))
|
|
||||||
lastIPInt.Or(lastIPInt, firstIPInt)
|
|
||||||
|
|
||||||
return firstIP, intToIP(lastIPInt, bits)
|
|
||||||
}
|
|
||||||
|
|
||||||
// AddressCount returns the number of distinct host addresses within the given
|
|
||||||
// CIDR range.
|
|
||||||
//
|
|
||||||
// Since the result is a uint64, this function returns meaningful information
|
|
||||||
// only for IPv4 ranges and IPv6 ranges with a prefix size of at least 65.
|
|
||||||
func AddressCount(network *net.IPNet) uint64 {
|
|
||||||
prefixLen, bits := network.Mask.Size()
|
|
||||||
return 1 << (uint64(bits) - uint64(prefixLen))
|
|
||||||
}
|
|
||||||
|
|
||||||
//VerifyNoOverlap takes a list subnets and supernet (CIDRBlock) and verifies
|
|
||||||
//none of the subnets overlap and all subnets are in the supernet
|
|
||||||
//it returns an error if any of those conditions are not satisfied
|
|
||||||
func VerifyNoOverlap(subnets []*net.IPNet, CIDRBlock *net.IPNet) error {
|
|
||||||
firstLastIP := make([][]net.IP, len(subnets))
|
|
||||||
for i, s := range subnets {
|
|
||||||
first, last := AddressRange(s)
|
|
||||||
firstLastIP[i] = []net.IP{first, last}
|
|
||||||
}
|
|
||||||
for i, s := range subnets {
|
|
||||||
if !CIDRBlock.Contains(firstLastIP[i][0]) || !CIDRBlock.Contains(firstLastIP[i][1]) {
|
|
||||||
return fmt.Errorf("%s does not fully contain %s", CIDRBlock.String(), s.String())
|
|
||||||
}
|
|
||||||
for j := 0; j < len(subnets); j++ {
|
|
||||||
if i == j {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
first := firstLastIP[j][0]
|
|
||||||
last := firstLastIP[j][1]
|
|
||||||
if s.Contains(first) || s.Contains(last) {
|
|
||||||
return fmt.Errorf("%s overlaps with %s", subnets[j].String(), s.String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// PreviousSubnet returns the subnet of the desired mask in the IP space
|
|
||||||
// just lower than the start of IPNet provided. If the IP space rolls over
|
|
||||||
// then the second return value is true
|
|
||||||
func PreviousSubnet(network *net.IPNet, prefixLen int) (*net.IPNet, bool) {
|
|
||||||
startIP := checkIPv4(network.IP)
|
|
||||||
previousIP := make(net.IP, len(startIP))
|
|
||||||
copy(previousIP, startIP)
|
|
||||||
cMask := net.CIDRMask(prefixLen, 8*len(previousIP))
|
|
||||||
previousIP = Dec(previousIP)
|
|
||||||
previous := &net.IPNet{IP: previousIP.Mask(cMask), Mask: cMask}
|
|
||||||
if startIP.Equal(net.IPv4zero) || startIP.Equal(net.IPv6zero) {
|
|
||||||
return previous, true
|
|
||||||
}
|
|
||||||
return previous, false
|
|
||||||
}
|
|
||||||
|
|
||||||
// NextSubnet returns the next available subnet of the desired mask size
|
|
||||||
// starting for the maximum IP of the offset subnet
|
|
||||||
// If the IP exceeds the maxium IP then the second return value is true
|
|
||||||
func NextSubnet(network *net.IPNet, prefixLen int) (*net.IPNet, bool) {
|
|
||||||
_, currentLast := AddressRange(network)
|
|
||||||
mask := net.CIDRMask(prefixLen, 8*len(currentLast))
|
|
||||||
currentSubnet := &net.IPNet{IP: currentLast.Mask(mask), Mask: mask}
|
|
||||||
_, last := AddressRange(currentSubnet)
|
|
||||||
last = Inc(last)
|
|
||||||
next := &net.IPNet{IP: last.Mask(mask), Mask: mask}
|
|
||||||
if last.Equal(net.IPv4zero) || last.Equal(net.IPv6zero) {
|
|
||||||
return next, true
|
|
||||||
}
|
|
||||||
return next, false
|
|
||||||
}
|
|
||||||
|
|
||||||
//Inc increases the IP by one this returns a new []byte for the IP
|
|
||||||
func Inc(IP net.IP) net.IP {
|
|
||||||
IP = checkIPv4(IP)
|
|
||||||
incIP := make([]byte, len(IP))
|
|
||||||
copy(incIP, IP)
|
|
||||||
for j := len(incIP) - 1; j >= 0; j-- {
|
|
||||||
incIP[j]++
|
|
||||||
if incIP[j] > 0 {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return incIP
|
|
||||||
}
|
|
||||||
|
|
||||||
//Dec decreases the IP by one this returns a new []byte for the IP
|
|
||||||
func Dec(IP net.IP) net.IP {
|
|
||||||
IP = checkIPv4(IP)
|
|
||||||
decIP := make([]byte, len(IP))
|
|
||||||
copy(decIP, IP)
|
|
||||||
decIP = checkIPv4(decIP)
|
|
||||||
for j := len(decIP) - 1; j >= 0; j-- {
|
|
||||||
decIP[j]--
|
|
||||||
if decIP[j] < 255 {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return decIP
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkIPv4(ip net.IP) net.IP {
|
|
||||||
// Go for some reason allocs IPv6len for IPv4 so we have to correct it
|
|
||||||
if v4 := ip.To4(); v4 != nil {
|
|
||||||
return v4
|
|
||||||
}
|
|
||||||
return ip
|
|
||||||
}
|
|
||||||
@ -1,37 +0,0 @@
|
|||||||
package cidr
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"math/big"
|
|
||||||
"net"
|
|
||||||
)
|
|
||||||
|
|
||||||
func ipToInt(ip net.IP) (*big.Int, int) {
|
|
||||||
val := &big.Int{}
|
|
||||||
val.SetBytes([]byte(ip))
|
|
||||||
if len(ip) == net.IPv4len {
|
|
||||||
return val, 32
|
|
||||||
} else if len(ip) == net.IPv6len {
|
|
||||||
return val, 128
|
|
||||||
} else {
|
|
||||||
panic(fmt.Errorf("Unsupported address length %d", len(ip)))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func intToIP(ipInt *big.Int, bits int) net.IP {
|
|
||||||
ipBytes := ipInt.Bytes()
|
|
||||||
ret := make([]byte, bits/8)
|
|
||||||
// Pack our IP bytes into the end of the return array,
|
|
||||||
// since big.Int.Bytes() removes front zero padding.
|
|
||||||
for i := 1; i <= len(ipBytes); i++ {
|
|
||||||
ret[len(ret)-i] = ipBytes[len(ipBytes)-i]
|
|
||||||
}
|
|
||||||
return net.IP(ret)
|
|
||||||
}
|
|
||||||
|
|
||||||
func insertNumIntoIP(ip net.IP, bigNum *big.Int, prefixLen int) net.IP {
|
|
||||||
ipInt, totalBits := ipToInt(ip)
|
|
||||||
bigNum.Lsh(bigNum, uint(totalBits-prefixLen))
|
|
||||||
ipInt.Or(ipInt, bigNum)
|
|
||||||
return intToIP(ipInt, totalBits)
|
|
||||||
}
|
|
||||||
@ -1,95 +0,0 @@
|
|||||||
Copyright (c) 2017 Martin Atkins
|
|
||||||
|
|
||||||
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.
|
|
||||||
|
|
||||||
---------
|
|
||||||
|
|
||||||
Unicode table generation programs are under a separate copyright and license:
|
|
||||||
|
|
||||||
Copyright (c) 2014 Couchbase, Inc.
|
|
||||||
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.
|
|
||||||
|
|
||||||
---------
|
|
||||||
|
|
||||||
Grapheme break data is provided as part of the Unicode character database,
|
|
||||||
copright 2016 Unicode, Inc, which is provided with the following license:
|
|
||||||
|
|
||||||
Unicode Data Files include all data files under the directories
|
|
||||||
http://www.unicode.org/Public/, http://www.unicode.org/reports/,
|
|
||||||
http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
|
|
||||||
http://www.unicode.org/utility/trac/browser/.
|
|
||||||
|
|
||||||
Unicode Data Files do not include PDF online code charts under the
|
|
||||||
directory http://www.unicode.org/Public/.
|
|
||||||
|
|
||||||
Software includes any source code published in the Unicode Standard
|
|
||||||
or under the directories
|
|
||||||
http://www.unicode.org/Public/, http://www.unicode.org/reports/,
|
|
||||||
http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
|
|
||||||
http://www.unicode.org/utility/trac/browser/.
|
|
||||||
|
|
||||||
NOTICE TO USER: Carefully read the following legal agreement.
|
|
||||||
BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
|
|
||||||
DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
|
|
||||||
YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
|
|
||||||
TERMS AND CONDITIONS OF THIS AGREEMENT.
|
|
||||||
IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
|
|
||||||
THE DATA FILES OR SOFTWARE.
|
|
||||||
|
|
||||||
COPYRIGHT AND PERMISSION NOTICE
|
|
||||||
|
|
||||||
Copyright © 1991-2017 Unicode, Inc. All rights reserved.
|
|
||||||
Distributed under the Terms of Use in http://www.unicode.org/copyright.html.
|
|
||||||
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining
|
|
||||||
a copy of the Unicode data files and any associated documentation
|
|
||||||
(the "Data Files") or Unicode software and any associated documentation
|
|
||||||
(the "Software") to deal in the Data Files or Software
|
|
||||||
without restriction, including without limitation the rights to use,
|
|
||||||
copy, modify, merge, publish, distribute, and/or sell copies of
|
|
||||||
the Data Files or Software, and to permit persons to whom the Data Files
|
|
||||||
or Software are furnished to do so, provided that either
|
|
||||||
(a) this copyright and permission notice appear with all copies
|
|
||||||
of the Data Files or Software, or
|
|
||||||
(b) this copyright and permission notice appear in associated
|
|
||||||
Documentation.
|
|
||||||
|
|
||||||
THE DATA FILES AND SOFTWARE ARE 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 OF THIRD PARTY RIGHTS.
|
|
||||||
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
|
|
||||||
NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
|
|
||||||
DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
||||||
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
||||||
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
||||||
PERFORMANCE OF THE DATA FILES OR SOFTWARE.
|
|
||||||
|
|
||||||
Except as contained in this notice, the name of a copyright holder
|
|
||||||
shall not be used in advertising or otherwise to promote the sale,
|
|
||||||
use or other dealings in these Data Files or Software without prior
|
|
||||||
written authorization of the copyright holder.
|
|
||||||
@ -1,30 +0,0 @@
|
|||||||
package textseg
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"bytes"
|
|
||||||
)
|
|
||||||
|
|
||||||
// AllTokens is a utility that uses a bufio.SplitFunc to produce a slice of
|
|
||||||
// all of the recognized tokens in the given buffer.
|
|
||||||
func AllTokens(buf []byte, splitFunc bufio.SplitFunc) ([][]byte, error) {
|
|
||||||
scanner := bufio.NewScanner(bytes.NewReader(buf))
|
|
||||||
scanner.Split(splitFunc)
|
|
||||||
var ret [][]byte
|
|
||||||
for scanner.Scan() {
|
|
||||||
ret = append(ret, scanner.Bytes())
|
|
||||||
}
|
|
||||||
return ret, scanner.Err()
|
|
||||||
}
|
|
||||||
|
|
||||||
// TokenCount is a utility that uses a bufio.SplitFunc to count the number of
|
|
||||||
// recognized tokens in the given buffer.
|
|
||||||
func TokenCount(buf []byte, splitFunc bufio.SplitFunc) (int, error) {
|
|
||||||
scanner := bufio.NewScanner(bytes.NewReader(buf))
|
|
||||||
scanner.Split(splitFunc)
|
|
||||||
var ret int
|
|
||||||
for scanner.Scan() {
|
|
||||||
ret++
|
|
||||||
}
|
|
||||||
return ret, scanner.Err()
|
|
||||||
}
|
|
||||||
@ -1,8 +0,0 @@
|
|||||||
package textseg
|
|
||||||
|
|
||||||
//go:generate go run make_tables.go -output tables.go
|
|
||||||
//go:generate go run make_test_tables.go -output tables_test.go
|
|
||||||
//go:generate ruby unicode2ragel.rb --url=https://www.unicode.org/Public/12.0.0/ucd/auxiliary/GraphemeBreakProperty.txt -m GraphemeCluster -p "Prepend,CR,LF,Control,Extend,Regional_Indicator,SpacingMark,L,V,T,LV,LVT,ZWJ" -o grapheme_clusters_table.rl
|
|
||||||
//go:generate ruby unicode2ragel.rb --url=https://www.unicode.org/Public/emoji/12.0/emoji-data.txt -m Emoji -p "Extended_Pictographic" -o emoji_table.rl
|
|
||||||
//go:generate ragel -Z grapheme_clusters.rl
|
|
||||||
//go:generate gofmt -w grapheme_clusters.go
|
|
||||||
4078
vendor/github.com/apparentlymart/go-textseg/v12/textseg/grapheme_clusters.go
generated
vendored
4078
vendor/github.com/apparentlymart/go-textseg/v12/textseg/grapheme_clusters.go
generated
vendored
File diff suppressed because it is too large
Load Diff
@ -1,133 +0,0 @@
|
|||||||
package textseg
|
|
||||||
|
|
||||||
import (
|
|
||||||
"errors"
|
|
||||||
"unicode/utf8"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Generated from grapheme_clusters.rl. DO NOT EDIT
|
|
||||||
%%{
|
|
||||||
# (except you are actually in grapheme_clusters.rl here, so edit away!)
|
|
||||||
|
|
||||||
machine graphclust;
|
|
||||||
write data;
|
|
||||||
}%%
|
|
||||||
|
|
||||||
var Error = errors.New("invalid UTF8 text")
|
|
||||||
|
|
||||||
// ScanGraphemeClusters is a split function for bufio.Scanner that splits
|
|
||||||
// on grapheme cluster boundaries.
|
|
||||||
func ScanGraphemeClusters(data []byte, atEOF bool) (int, []byte, error) {
|
|
||||||
if len(data) == 0 {
|
|
||||||
return 0, nil, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Ragel state
|
|
||||||
cs := 0 // Current State
|
|
||||||
p := 0 // "Pointer" into data
|
|
||||||
pe := len(data) // End-of-data "pointer"
|
|
||||||
ts := 0
|
|
||||||
te := 0
|
|
||||||
act := 0
|
|
||||||
eof := pe
|
|
||||||
|
|
||||||
// Make Go compiler happy
|
|
||||||
_ = ts
|
|
||||||
_ = te
|
|
||||||
_ = act
|
|
||||||
_ = eof
|
|
||||||
|
|
||||||
startPos := 0
|
|
||||||
endPos := 0
|
|
||||||
|
|
||||||
%%{
|
|
||||||
include GraphemeCluster "grapheme_clusters_table.rl";
|
|
||||||
include Emoji "emoji_table.rl";
|
|
||||||
|
|
||||||
action start {
|
|
||||||
startPos = p
|
|
||||||
}
|
|
||||||
|
|
||||||
action end {
|
|
||||||
endPos = p
|
|
||||||
}
|
|
||||||
|
|
||||||
action emit {
|
|
||||||
return endPos+1, data[startPos:endPos+1], nil
|
|
||||||
}
|
|
||||||
|
|
||||||
ZWJGlue = ZWJ (Extended_Pictographic Extend*)?;
|
|
||||||
AnyExtender = Extend | ZWJGlue | SpacingMark;
|
|
||||||
Extension = AnyExtender*;
|
|
||||||
ReplacementChar = (0xEF 0xBF 0xBD);
|
|
||||||
|
|
||||||
CRLFSeq = CR LF;
|
|
||||||
ControlSeq = Control | ReplacementChar;
|
|
||||||
HangulSeq = (
|
|
||||||
L+ (((LV? V+ | LVT) T*)?|LV?) |
|
|
||||||
LV V* T* |
|
|
||||||
V+ T* |
|
|
||||||
LVT T* |
|
|
||||||
T+
|
|
||||||
) Extension;
|
|
||||||
EmojiSeq = Extended_Pictographic Extend* Extension;
|
|
||||||
ZWJSeq = ZWJ (ZWJ | Extend | SpacingMark)*;
|
|
||||||
EmojiFlagSeq = Regional_Indicator Regional_Indicator? Extension;
|
|
||||||
|
|
||||||
UTF8Cont = 0x80 .. 0xBF;
|
|
||||||
AnyUTF8 = (
|
|
||||||
0x00..0x7F |
|
|
||||||
0xC0..0xDF . UTF8Cont |
|
|
||||||
0xE0..0xEF . UTF8Cont . UTF8Cont |
|
|
||||||
0xF0..0xF7 . UTF8Cont . UTF8Cont . UTF8Cont
|
|
||||||
);
|
|
||||||
|
|
||||||
# OtherSeq is any character that isn't at the start of one of the extended sequences above, followed by extension
|
|
||||||
OtherSeq = (AnyUTF8 - (CR|LF|Control|ReplacementChar|L|LV|V|LVT|T|Extended_Pictographic|ZWJ|Regional_Indicator|Prepend)) (Extend | ZWJ | SpacingMark)*;
|
|
||||||
|
|
||||||
# PrependSeq is prepend followed by any of the other patterns above, except control characters which explicitly break
|
|
||||||
PrependSeq = Prepend+ (HangulSeq|EmojiSeq|ZWJSeq|EmojiFlagSeq|OtherSeq)?;
|
|
||||||
|
|
||||||
CRLFTok = CRLFSeq >start @end;
|
|
||||||
ControlTok = ControlSeq >start @end;
|
|
||||||
HangulTok = HangulSeq >start @end;
|
|
||||||
EmojiTok = EmojiSeq >start @end;
|
|
||||||
ZWJTok = ZWJSeq >start @end;
|
|
||||||
EmojiFlagTok = EmojiFlagSeq >start @end;
|
|
||||||
OtherTok = OtherSeq >start @end;
|
|
||||||
PrependTok = PrependSeq >start @end;
|
|
||||||
|
|
||||||
main := |*
|
|
||||||
CRLFTok => emit;
|
|
||||||
ControlTok => emit;
|
|
||||||
HangulTok => emit;
|
|
||||||
EmojiTok => emit;
|
|
||||||
ZWJTok => emit;
|
|
||||||
EmojiFlagTok => emit;
|
|
||||||
PrependTok => emit;
|
|
||||||
OtherTok => emit;
|
|
||||||
|
|
||||||
# any single valid UTF-8 character would also be valid per spec,
|
|
||||||
# but we'll handle that separately after the loop so we can deal
|
|
||||||
# with requesting more bytes if we're not at EOF.
|
|
||||||
*|;
|
|
||||||
|
|
||||||
write init;
|
|
||||||
write exec;
|
|
||||||
}%%
|
|
||||||
|
|
||||||
// If we fall out here then we were unable to complete a sequence.
|
|
||||||
// If we weren't able to complete a sequence then either we've
|
|
||||||
// reached the end of a partial buffer (so there's more data to come)
|
|
||||||
// or we have an isolated symbol that would normally be part of a
|
|
||||||
// grapheme cluster but has appeared in isolation here.
|
|
||||||
|
|
||||||
if !atEOF {
|
|
||||||
// Request more
|
|
||||||
return 0, nil, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Just take the first UTF-8 sequence and return that.
|
|
||||||
_, seqLen := utf8.DecodeRune(data)
|
|
||||||
return seqLen, data[:seqLen], nil
|
|
||||||
}
|
|
||||||
1589
vendor/github.com/apparentlymart/go-textseg/v12/textseg/grapheme_clusters_table.rl
generated
vendored
1589
vendor/github.com/apparentlymart/go-textseg/v12/textseg/grapheme_clusters_table.rl
generated
vendored
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue