f177b557f5afc33ede2d9d09a95bf58db69d04a6 to 3801d61c1544c836e8e1b004d1fa92c25e0983f5 · OSS / Utilities / Requirements Manager

Some changes are not shown.

For a faster browsing experience, only 46 of 1000 files are shown. Download one of the files below to see all changes.

flake.nix

+1 −1

Original line number	Diff line number	Diff line
		@@ -54,7 +54,7 @@
		];

		#vendorHash = pkgs.lib.fakeHash;
		vendorHash = goPkgVendorHash;
		vendorHash = null; #goPkgVendorHash;

		meta = with nixpkgs.legacyPackages.${system}.lib; {
		description = goPkgDescription;

source/go.mod

+27 −36

Original line number	Diff line number	Diff line
		module gitlab.schukai.com/oss/utilities/requirements-manager

		go 1.18
		go 1.23.3

		require (
		github.com/go-git/go-git/v5 v5.11.0
		github.com/go-git/go-git/v5 v5.13.1
		github.com/gookit/color v1.5.4
		github.com/jessevdk/go-flags v1.5.0
		github.com/jessevdk/go-flags v1.6.1
		github.com/olekukonko/tablewriter v0.0.5
		github.com/xanzy/go-gitlab v0.100.0
		golang.org/x/text v0.14.0
		github.com/xanzy/go-gitlab v0.115.0
		golang.org/x/text v0.21.0
		gopkg.in/yaml.v2 v2.4.0
		gopkg.in/yaml.v3 v3.0.1
		)

		require (
		dario.cat/mergo v1.0.0 // indirect
		github.com/Microsoft/go-winio v0.6.1 // indirect
		github.com/ProtonMail/go-crypto v1.0.0 // indirect
		github.com/acomagu/bufpipe v1.0.4 // indirect
		github.com/cloudflare/circl v1.3.7 // indirect
		github.com/cyphar/filepath-securejoin v0.2.4 // indirect
		github.com/davecgh/go-spew v1.1.1 // indirect
		dario.cat/mergo v1.0.1 // indirect
		github.com/Microsoft/go-winio v0.6.2 // indirect
		github.com/ProtonMail/go-crypto v1.1.4 // indirect
		github.com/cloudflare/circl v1.5.0 // indirect
		github.com/cyphar/filepath-securejoin v0.3.6 // indirect
		github.com/emirpasic/gods v1.18.1 // indirect
		github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
		github.com/go-git/go-billy/v5 v5.5.0 // indirect
		github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
		github.com/golang/protobuf v1.5.4 // indirect
		github.com/go-git/go-billy/v5 v5.6.1 // indirect
		github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
		github.com/google/go-querystring v1.1.0 // indirect
		github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
		github.com/hashicorp/go-retryablehttp v0.7.5 // indirect
		github.com/imdario/mergo v0.3.16 // indirect
		github.com/hashicorp/go-retryablehttp v0.7.7 // indirect
		github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
		github.com/kevinburke/ssh_config v1.2.0 // indirect
		github.com/kr/pretty v0.3.1 // indirect
		github.com/mattn/go-runewidth v0.0.15 // indirect
		github.com/mitchellh/go-homedir v1.1.0 // indirect
		github.com/pjbgf/sha1cd v0.3.0 // indirect
		github.com/mattn/go-runewidth v0.0.16 // indirect
		github.com/mmcloughlin/avo v0.6.0 // indirect
		github.com/pjbgf/sha1cd v0.3.1 // indirect
		github.com/rivo/uniseg v0.4.7 // indirect
		github.com/sergi/go-diff v1.3.1 // indirect
		github.com/skeema/knownhosts v1.2.2 // indirect
		github.com/src-d/gcfg v1.4.0 // indirect
		github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect
		github.com/skeema/knownhosts v1.3.0 // indirect
		github.com/xanzy/ssh-agent v0.3.3 // indirect
		github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
		golang.org/x/crypto v0.21.0 // indirect
		golang.org/x/mod v0.16.0 // indirect
		golang.org/x/net v0.22.0 // indirect
		golang.org/x/oauth2 v0.18.0 // indirect
		golang.org/x/sys v0.18.0 // indirect
		golang.org/x/time v0.5.0 // indirect
		golang.org/x/tools v0.19.0 // indirect
		google.golang.org/appengine v1.6.8 // indirect
		google.golang.org/protobuf v1.33.0 // indirect
		gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
		gopkg.in/src-d/go-billy.v4 v4.3.2 // indirect
		golang.org/x/crypto v0.32.0 // indirect
		golang.org/x/mod v0.22.0 // indirect
		golang.org/x/net v0.34.0 // indirect
		golang.org/x/oauth2 v0.25.0 // indirect
		golang.org/x/sync v0.10.0 // indirect
		golang.org/x/sys v0.29.0 // indirect
		golang.org/x/time v0.9.0 // indirect
		golang.org/x/tools v0.29.0 // indirect
		gopkg.in/warnings.v0 v0.1.2 // indirect
		)

source/go.sum

+81 −580

File changed.

Preview size limit exceeded, changes collapsed.

source/vendor/dario.cat/mergo/.deepsource.toml

0 → 100644

+12 −0

Original line number	Diff line number	Diff line
		version = 1

		test_patterns = [
		"*_test.go"
		]

		[[analyzers]]
		name = "go"
		enabled = true

		[analyzers.meta]
		import_path = "dario.cat/mergo"
		No newline at end of file

source/vendor/dario.cat/mergo/.gitignore

0 → 100644

+36 −0

Original line number	Diff line number	Diff line
		#### joe made this: http://goel.io/joe

		#### go ####
		# Binaries for programs and plugins
		*.exe
		*.dll
		*.so
		*.dylib

		# Test binary, build with `go test -c`
		*.test

		# Output of the go coverage tool, specifically when used with LiteIDE
		*.out

		# Golang/Intellij
		.idea

		# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
		.glide/

		#### vim ####
		# Swap
		[._]*.s[a-v][a-z]
		[._]*.sw[a-p]
		[._]s[a-v][a-z]
		[._]sw[a-p]

		# Session
		Session.vim

		# Temporary
		.netrwhist
		*~
		# Auto-generated tag files
		tags

source/vendor/dario.cat/mergo/.travis.yml

0 → 100644

+12 −0

Original line number	Diff line number	Diff line
		language: go
		arch:
		- amd64
		- ppc64le
		install:
		- go get -t
		- go get golang.org/x/tools/cmd/cover
		- go get github.com/mattn/goveralls
		script:
		- go test -race -v ./...
		after_script:
		- $HOME/gopath/bin/goveralls -service=travis-ci -repotoken $COVERALLS_TOKEN

source/vendor/dario.cat/mergo/CODE_OF_CONDUCT.md

0 → 100644

+46 −0

Original line number	Diff line number	Diff line
		# Contributor Covenant Code of Conduct

		## Our Pledge

		In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.

		## Our Standards

		Examples of behavior that contributes to creating a positive environment include:

		* Using welcoming and inclusive language
		* Being respectful of differing viewpoints and experiences
		* Gracefully accepting constructive criticism
		* Focusing on what is best for the community
		* Showing empathy towards other community members

		Examples of unacceptable behavior by participants include:

		* The use of sexualized language or imagery and unwelcome sexual attention or advances
		* Trolling, insulting/derogatory comments, and personal or political attacks
		* Public or private harassment
		* Publishing others' private information, such as a physical or electronic address, without explicit permission
		* Other conduct which could reasonably be considered inappropriate in a professional setting

		## Our Responsibilities

		Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.

		Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.

		## Scope

		This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.

		## Enforcement

		Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at i@dario.im. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.

		Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.

		## Attribution

		This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]

		[homepage]: http://contributor-covenant.org
		[version]: http://contributor-covenant.org/version/1/4/

source/vendor/dario.cat/mergo/CONTRIBUTING.md

0 → 100644

+112 −0

Original line number	Diff line number	Diff line
		<!-- omit in toc -->
		# Contributing to mergo

		First off, thanks for taking the time to contribute! ❤️

		All types of contributions are encouraged and valued. See the [Table of Contents](#table-of-contents) for different ways to help and details about how this project handles them. Please make sure to read the relevant section before making your contribution. It will make it a lot easier for us maintainers and smooth out the experience for all involved. The community looks forward to your contributions. 🎉

		> And if you like the project, but just don't have time to contribute, that's fine. There are other easy ways to support the project and show your appreciation, which we would also be very happy about:
		> - Star the project
		> - Tweet about it
		> - Refer this project in your project's readme
		> - Mention the project at local meetups and tell your friends/colleagues

		<!-- omit in toc -->
		## Table of Contents

		- [Code of Conduct](#code-of-conduct)
		- [I Have a Question](#i-have-a-question)
		- [I Want To Contribute](#i-want-to-contribute)
		- [Reporting Bugs](#reporting-bugs)
		- [Suggesting Enhancements](#suggesting-enhancements)

		## Code of Conduct

		This project and everyone participating in it is governed by the
		[mergo Code of Conduct](https://github.com/imdario/mergoblob/master/CODE_OF_CONDUCT.md).
		By participating, you are expected to uphold this code. Please report unacceptable behavior
		to <>.


		## I Have a Question

		> If you want to ask a question, we assume that you have read the available [Documentation](https://pkg.go.dev/github.com/imdario/mergo).

		Before you ask a question, it is best to search for existing [Issues](https://github.com/imdario/mergo/issues) that might help you. In case you have found a suitable issue and still need clarification, you can write your question in this issue. It is also advisable to search the internet for answers first.

		If you then still feel the need to ask a question and need clarification, we recommend the following:

		- Open an [Issue](https://github.com/imdario/mergo/issues/new).
		- Provide as much context as you can about what you're running into.
		- Provide project and platform versions (nodejs, npm, etc), depending on what seems relevant.

		We will then take care of the issue as soon as possible.

		## I Want To Contribute

		> ### Legal Notice <!-- omit in toc -->
		> When contributing to this project, you must agree that you have authored 100% of the content, that you have the necessary rights to the content and that the content you contribute may be provided under the project license.

		### Reporting Bugs

		<!-- omit in toc -->
		#### Before Submitting a Bug Report

		A good bug report shouldn't leave others needing to chase you up for more information. Therefore, we ask you to investigate carefully, collect information and describe the issue in detail in your report. Please complete the following steps in advance to help us fix any potential bug as fast as possible.

		- Make sure that you are using the latest version.
		- Determine if your bug is really a bug and not an error on your side e.g. using incompatible environment components/versions (Make sure that you have read the [documentation](). If you are looking for support, you might want to check [this section](#i-have-a-question)).
		- To see if other users have experienced (and potentially already solved) the same issue you are having, check if there is not already a bug report existing for your bug or error in the [bug tracker](https://github.com/imdario/mergoissues?q=label%3Abug).
		- Also make sure to search the internet (including Stack Overflow) to see if users outside of the GitHub community have discussed the issue.
		- Collect information about the bug:
		- Stack trace (Traceback)
		- OS, Platform and Version (Windows, Linux, macOS, x86, ARM)
		- Version of the interpreter, compiler, SDK, runtime environment, package manager, depending on what seems relevant.
		- Possibly your input and the output
		- Can you reliably reproduce the issue? And can you also reproduce it with older versions?

		<!-- omit in toc -->
		#### How Do I Submit a Good Bug Report?

		> You must never report security related issues, vulnerabilities or bugs including sensitive information to the issue tracker, or elsewhere in public. Instead sensitive bugs must be sent by email to .
		<!-- You may add a PGP key to allow the messages to be sent encrypted as well. -->

		We use GitHub issues to track bugs and errors. If you run into an issue with the project:

		- Open an [Issue](https://github.com/imdario/mergo/issues/new). (Since we can't be sure at this point whether it is a bug or not, we ask you not to talk about a bug yet and not to label the issue.)
		- Explain the behavior you would expect and the actual behavior.
		- Please provide as much context as possible and describe the reproduction steps that someone else can follow to recreate the issue on their own. This usually includes your code. For good bug reports you should isolate the problem and create a reduced test case.
		- Provide the information you collected in the previous section.

		Once it's filed:

		- The project team will label the issue accordingly.
		- A team member will try to reproduce the issue with your provided steps. If there are no reproduction steps or no obvious way to reproduce the issue, the team will ask you for those steps and mark the issue as `needs-repro`. Bugs with the `needs-repro` tag will not be addressed until they are reproduced.
		- If the team is able to reproduce the issue, it will be marked `needs-fix`, as well as possibly other tags (such as `critical`), and the issue will be left to be implemented by someone.

		### Suggesting Enhancements

		This section guides you through submitting an enhancement suggestion for mergo, including completely new features and minor improvements to existing functionality. Following these guidelines will help maintainers and the community to understand your suggestion and find related suggestions.

		<!-- omit in toc -->
		#### Before Submitting an Enhancement

		- Make sure that you are using the latest version.
		- Read the [documentation]() carefully and find out if the functionality is already covered, maybe by an individual configuration.
		- Perform a [search](https://github.com/imdario/mergo/issues) to see if the enhancement has already been suggested. If it has, add a comment to the existing issue instead of opening a new one.
		- Find out whether your idea fits with the scope and aims of the project. It's up to you to make a strong case to convince the project's developers of the merits of this feature. Keep in mind that we want features that will be useful to the majority of our users and not just a small subset. If you're just targeting a minority of users, consider writing an add-on/plugin library.

		<!-- omit in toc -->
		#### How Do I Submit a Good Enhancement Suggestion?

		Enhancement suggestions are tracked as [GitHub issues](https://github.com/imdario/mergo/issues).

		- Use a clear and descriptive title for the issue to identify the suggestion.
		- Provide a step-by-step description of the suggested enhancement in as many details as possible.
		- Describe the current behavior and explain which behavior you expected to see instead and why. At this point you can also tell which alternatives do not work for you.
		- You may want to include screenshots and animated GIFs which help you demonstrate the steps or point out the part which the suggestion is related to. You can use [this tool](https://www.cockos.com/licecap/) to record GIFs on macOS and Windows, and [this tool](https://github.com/colinkeenan/silentcast) or [this tool](https://github.com/GNOME/byzanz) on Linux. <!-- this should only be included if the project has a GUI -->
		- Explain why this enhancement would be useful to most mergo users. You may also want to point out the other projects that solved it better and which could serve as inspiration.

		<!-- omit in toc -->
		## Attribution
		This guide is based on the contributing-gen. [Make your own](https://github.com/bttger/contributing-gen)!

source/vendor/dario.cat/mergo/LICENSE

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		Copyright (c) 2013 Dario Castañé. All rights reserved.
		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.

source/vendor/dario.cat/mergo/README.md

0 → 100644

+258 −0

Original line number	Diff line number	Diff line
		# Mergo

		[![GitHub release][5]][6]
		[![GoCard][7]][8]
		[![Test status][1]][2]
		[![OpenSSF Scorecard][21]][22]
		[![OpenSSF Best Practices][19]][20]
		[![Coverage status][9]][10]
		[![Sourcegraph][11]][12]
		[![FOSSA status][13]][14]

		[![GoDoc][3]][4]
		[![Become my sponsor][15]][16]
		[![Tidelift][17]][18]

		[1]: https://github.com/imdario/mergo/workflows/tests/badge.svg?branch=master
		[2]: https://github.com/imdario/mergo/actions/workflows/tests.yml
		[3]: https://godoc.org/github.com/imdario/mergo?status.svg
		[4]: https://godoc.org/github.com/imdario/mergo
		[5]: https://img.shields.io/github/release/imdario/mergo.svg
		[6]: https://github.com/imdario/mergo/releases
		[7]: https://goreportcard.com/badge/imdario/mergo
		[8]: https://goreportcard.com/report/github.com/imdario/mergo
		[9]: https://coveralls.io/repos/github/imdario/mergo/badge.svg?branch=master
		[10]: https://coveralls.io/github/imdario/mergo?branch=master
		[11]: https://sourcegraph.com/github.com/imdario/mergo/-/badge.svg
		[12]: https://sourcegraph.com/github.com/imdario/mergo?badge
		[13]: https://app.fossa.io/api/projects/git%2Bgithub.com%2Fimdario%2Fmergo.svg?type=shield
		[14]: https://app.fossa.io/projects/git%2Bgithub.com%2Fimdario%2Fmergo?ref=badge_shield
		[15]: https://img.shields.io/github/sponsors/imdario
		[16]: https://github.com/sponsors/imdario
		[17]: https://tidelift.com/badges/package/go/github.com%2Fimdario%2Fmergo
		[18]: https://tidelift.com/subscription/pkg/go-github.com-imdario-mergo
		[19]: https://bestpractices.coreinfrastructure.org/projects/7177/badge
		[20]: https://bestpractices.coreinfrastructure.org/projects/7177
		[21]: https://api.securityscorecards.dev/projects/github.com/imdario/mergo/badge
		[22]: https://api.securityscorecards.dev/projects/github.com/imdario/mergo

		A helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements.

		Mergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).

		Also a lovely [comune](http://en.wikipedia.org/wiki/Mergo) (municipality) in the Province of Ancona in the Italian region of Marche.

		## Status

		Mergo is stable and frozen, ready for production. Check a short list of the projects using at large scale it [here](https://github.com/imdario/mergo#mergo-in-the-wild).

		No new features are accepted. They will be considered for a future v2 that improves the implementation and fixes bugs for corner cases.

		### Important notes

		#### 1.0.0

		In [1.0.0](//github.com/imdario/mergo/releases/tag/1.0.0) Mergo moves to a vanity URL `dario.cat/mergo`. No more v1 versions will be released.

		If the vanity URL is causing issues in your project due to a dependency pulling Mergo - it isn't a direct dependency in your project - it is recommended to use [replace](https://github.com/golang/go/wiki/Modules#when-should-i-use-the-replace-directive) to pin the version to the last one with the old import URL:

		```
		replace github.com/imdario/mergo => github.com/imdario/mergo v0.3.16
		```

		#### 0.3.9

		Please keep in mind that a problematic PR broke [0.3.9](//github.com/imdario/mergo/releases/tag/0.3.9). I reverted it in [0.3.10](//github.com/imdario/mergo/releases/tag/0.3.10), and I consider it stable but not bug-free. Also, this version adds support for go modules.

		Keep in mind that in [0.3.2](//github.com/imdario/mergo/releases/tag/0.3.2), Mergo changed `Merge()`and `Map()` signatures to support [transformers](#transformers). I added an optional/variadic argument so that it won't break the existing code.

		If you were using Mergo before April 6th, 2015, please check your project works as intended after updating your local copy with ```go get -u dario.cat/mergo```. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause in existing projects after the change (release 0.2.0).

		### Donations

		If Mergo is useful to you, consider buying me a coffee, a beer, or making a monthly donation to allow me to keep building great free software. :heart_eyes:

		<a href="https://liberapay.com/dario/donate"><img alt="Donate using Liberapay" src="https://liberapay.com/assets/widgets/donate.svg"></a>
		<a href='https://github.com/sponsors/imdario' target='_blank'><img alt="Become my sponsor" src="https://img.shields.io/github/sponsors/imdario?style=for-the-badge" /></a>

		### Mergo in the wild

		Mergo is used by [thousands](https://deps.dev/go/dario.cat%2Fmergo/v1.0.0/dependents) [of](https://deps.dev/go/github.com%2Fimdario%2Fmergo/v0.3.16/dependents) [projects](https://deps.dev/go/github.com%2Fimdario%2Fmergo/v0.3.12), including:

		* [containerd/containerd](https://github.com/containerd/containerd)
		* [datadog/datadog-agent](https://github.com/datadog/datadog-agent)
		* [docker/cli/](https://github.com/docker/cli/)
		* [goreleaser/goreleaser](https://github.com/goreleaser/goreleaser)
		* [go-micro/go-micro](https://github.com/go-micro/go-micro)
		* [grafana/loki](https://github.com/grafana/loki)
		* [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes)
		* [masterminds/sprig](github.com/Masterminds/sprig)
		* [moby/moby](https://github.com/moby/moby)
		* [slackhq/nebula](https://github.com/slackhq/nebula)
		* [volcano-sh/volcano](https://github.com/volcano-sh/volcano)

		## Install

		go get dario.cat/mergo

		// use in your .go code
		import (
		"dario.cat/mergo"
		)

		## Usage

		You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as [they are zero values](https://golang.org/ref/spec#The_zero_value) too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection).

		```go
		if err := mergo.Merge(&dst, src); err != nil {
		// ...
		}
		```

		Also, you can merge overwriting values using the transformer `WithOverride`.

		```go
		if err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil {
		// ...
		}
		```

		If you need to override pointers, so the source pointer's value is assigned to the destination's pointer, you must use `WithoutDereference`:

		```go
		package main

		import (
		"fmt"

		"dario.cat/mergo"
		)

		type Foo struct {
		A *string
		B int64
		}

		func main() {
		first := "first"
		second := "second"
		src := Foo{
		A: &first,
		B: 2,
		}

		dest := Foo{
		A: &second,
		B: 1,
		}

		mergo.Merge(&dest, src, mergo.WithOverride, mergo.WithoutDereference)
		}
		```

		Additionally, you can map a `map[string]interface{}` to a struct (and otherwise, from struct to map), following the same restrictions as in `Merge()`. Keys are capitalized to find each corresponding exported field.

		```go
		if err := mergo.Map(&dst, srcMap); err != nil {
		// ...
		}
		```

		Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as `map[string]interface{}`. They will be just assigned as values.

		Here is a nice example:

		```go
		package main

		import (
		"fmt"
		"dario.cat/mergo"
		)

		type Foo struct {
		A string
		B int64
		}

		func main() {
		src := Foo{
		A: "one",
		B: 2,
		}
		dest := Foo{
		A: "two",
		}
		mergo.Merge(&dest, src)
		fmt.Println(dest)
		// Will print
		// {two 2}
		}
		```

		Note: if test are failing due missing package, please execute:

		go get gopkg.in/yaml.v3

		### Transformers

		Transformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, `time.Time` is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero `time.Time`?

		```go
		package main

		import (
		"fmt"
		"dario.cat/mergo"
		"reflect"
		"time"
		)

		type timeTransformer struct {
		}

		func (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {
		if typ == reflect.TypeOf(time.Time{}) {
		return func(dst, src reflect.Value) error {
		if dst.CanSet() {
		isZero := dst.MethodByName("IsZero")
		result := isZero.Call([]reflect.Value{})
		if result[0].Bool() {
		dst.Set(src)
		}
		}
		return nil
		}
		}
		return nil
		}

		type Snapshot struct {
		Time time.Time
		// ...
		}

		func main() {
		src := Snapshot{time.Now()}
		dest := Snapshot{}
		mergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{}))
		fmt.Println(dest)
		// Will print
		// { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 }
		}
		```

		## Contact me

		If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): [@im_dario](https://twitter.com/im_dario)

		## About

		Written by [Dario Castañé](http://dario.im).

		## License

		[BSD 3-Clause](http://opensource.org/licenses/BSD-3-Clause) license, as [Go language](http://golang.org/LICENSE).

		[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fimdario%2Fmergo.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fimdario%2Fmergo?ref=badge_large)

source/vendor/dario.cat/mergo/SECURITY.md

0 → 100644

+14 −0

Original line number	Diff line number	Diff line
		# Security Policy

		## Supported Versions

		\| Version \| Supported \|
		\| ------- \| ------------------ \|
		\| 0.3.x \| :white_check_mark: \|
		\| < 0.3 \| :x: \|

		## Security contact information

		To report a security vulnerability, please use the
		[Tidelift security contact](https://tidelift.com/security).
		Tidelift will coordinate the fix and disclosure.

source/vendor/dario.cat/mergo/doc.go

0 → 100644

+148 −0

Original line number	Diff line number	Diff line
		// Copyright 2013 Dario Castañé. All rights reserved.
		// Copyright 2009 The Go Authors. All rights reserved.
		// Use of this source code is governed by a BSD-style
		// license that can be found in the LICENSE file.

		/*
		A helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements.

		Mergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).

		# Status

		It is ready for production use. It is used in several projects by Docker, Google, The Linux Foundation, VMWare, Shopify, etc.

		# Important notes

		1.0.0

		In 1.0.0 Mergo moves to a vanity URL `dario.cat/mergo`.

		0.3.9

		Please keep in mind that a problematic PR broke 0.3.9. We reverted it in 0.3.10. We consider 0.3.10 as stable but not bug-free. . Also, this version adds suppot for go modules.

		Keep in mind that in 0.3.2, Mergo changed Merge() and Map() signatures to support transformers. We added an optional/variadic argument so that it won't break the existing code.

		If you were using Mergo before April 6th, 2015, please check your project works as intended after updating your local copy with go get -u dario.cat/mergo. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause in existing projects after the change (release 0.2.0).

		# Install

		Do your usual installation procedure:

		go get dario.cat/mergo

		// use in your .go code
		import (
		"dario.cat/mergo"
		)

		# Usage

		You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as they are zero values too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection).

		if err := mergo.Merge(&dst, src); err != nil {
		// ...
		}

		Also, you can merge overwriting values using the transformer WithOverride.

		if err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil {
		// ...
		}

		Additionally, you can map a map[string]interface{} to a struct (and otherwise, from struct to map), following the same restrictions as in Merge(). Keys are capitalized to find each corresponding exported field.

		if err := mergo.Map(&dst, srcMap); err != nil {
		// ...
		}

		Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as map[string]interface{}. They will be just assigned as values.

		Here is a nice example:

		package main

		import (
		"fmt"
		"dario.cat/mergo"
		)

		type Foo struct {
		A string
		B int64
		}

		func main() {
		src := Foo{
		A: "one",
		B: 2,
		}
		dest := Foo{
		A: "two",
		}
		mergo.Merge(&dest, src)
		fmt.Println(dest)
		// Will print
		// {two 2}
		}

		# Transformers

		Transformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, time.Time is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero time.Time?

		package main

		import (
		"fmt"
		"dario.cat/mergo"
		"reflect"
		"time"
		)

		type timeTransformer struct {
		}

		func (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {
		if typ == reflect.TypeOf(time.Time{}) {
		return func(dst, src reflect.Value) error {
		if dst.CanSet() {
		isZero := dst.MethodByName("IsZero")
		result := isZero.Call([]reflect.Value{})
		if result[0].Bool() {
		dst.Set(src)
		}
		}
		return nil
		}
		}
		return nil
		}

		type Snapshot struct {
		Time time.Time
		// ...
		}

		func main() {
		src := Snapshot{time.Now()}
		dest := Snapshot{}
		mergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{}))
		fmt.Println(dest)
		// Will print
		// { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 }
		}

		# Contact me

		If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): https://twitter.com/im_dario

		# About

		Written by Dario Castañé: https://da.rio.hn

		# License

		BSD 3-Clause license, as Go language.
		*/
		package mergo

source/vendor/dario.cat/mergo/map.go

0 → 100644

+178 −0

Original line number	Diff line number	Diff line
		// Copyright 2014 Dario Castañé. All rights reserved.
		// Copyright 2009 The Go Authors. All rights reserved.
		// Use of this source code is governed by a BSD-style
		// license that can be found in the LICENSE file.

		// Based on src/pkg/reflect/deepequal.go from official
		// golang's stdlib.

		package mergo

		import (
		"fmt"
		"reflect"
		"unicode"
		"unicode/utf8"
		)

		func changeInitialCase(s string, mapper func(rune) rune) string {
		if s == "" {
		return s
		}
		r, n := utf8.DecodeRuneInString(s)
		return string(mapper(r)) + s[n:]
		}

		func isExported(field reflect.StructField) bool {
		r, _ := utf8.DecodeRuneInString(field.Name)
		return r >= 'A' && r <= 'Z'
		}

		// Traverses recursively both values, assigning src's fields values to dst.
		// The map argument tracks comparisons that have already been seen, which allows
		// short circuiting on recursive types.
		func deepMap(dst, src reflect.Value, visited map[uintptr]visit, depth int, config Config) (err error) {
		overwrite := config.Overwrite
		if dst.CanAddr() {
		addr := dst.UnsafeAddr()
		h := 17 * addr
		seen := visited[h]
		typ := dst.Type()
		for p := seen; p != nil; p = p.next {
		if p.ptr == addr && p.typ == typ {
		return nil
		}
		}
		// Remember, remember...
		visited[h] = &visit{typ, seen, addr}
		}
		zeroValue := reflect.Value{}
		switch dst.Kind() {
		case reflect.Map:
		dstMap := dst.Interface().(map[string]interface{})
		for i, n := 0, src.NumField(); i < n; i++ {
		srcType := src.Type()
		field := srcType.Field(i)
		if !isExported(field) {
		continue
		}
		fieldName := field.Name
		fieldName = changeInitialCase(fieldName, unicode.ToLower)
		if _, ok := dstMap[fieldName]; !ok \|\| (!isEmptyValue(reflect.ValueOf(src.Field(i).Interface()), !config.ShouldNotDereference) && overwrite) \|\| config.overwriteWithEmptyValue {
		dstMap[fieldName] = src.Field(i).Interface()
		}
		}
		case reflect.Ptr:
		if dst.IsNil() {
		v := reflect.New(dst.Type().Elem())
		dst.Set(v)
		}
		dst = dst.Elem()
		fallthrough
		case reflect.Struct:
		srcMap := src.Interface().(map[string]interface{})
		for key := range srcMap {
		config.overwriteWithEmptyValue = true
		srcValue := srcMap[key]
		fieldName := changeInitialCase(key, unicode.ToUpper)
		dstElement := dst.FieldByName(fieldName)
		if dstElement == zeroValue {
		// We discard it because the field doesn't exist.
		continue
		}
		srcElement := reflect.ValueOf(srcValue)
		dstKind := dstElement.Kind()
		srcKind := srcElement.Kind()
		if srcKind == reflect.Ptr && dstKind != reflect.Ptr {
		srcElement = srcElement.Elem()
		srcKind = reflect.TypeOf(srcElement.Interface()).Kind()
		} else if dstKind == reflect.Ptr {
		// Can this work? I guess it can't.
		if srcKind != reflect.Ptr && srcElement.CanAddr() {
		srcPtr := srcElement.Addr()
		srcElement = reflect.ValueOf(srcPtr)
		srcKind = reflect.Ptr
		}
		}

		if !srcElement.IsValid() {
		continue
		}
		if srcKind == dstKind {
		if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
		return
		}
		} else if dstKind == reflect.Interface && dstElement.Kind() == reflect.Interface {
		if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
		return
		}
		} else if srcKind == reflect.Map {
		if err = deepMap(dstElement, srcElement, visited, depth+1, config); err != nil {
		return
		}
		} else {
		return fmt.Errorf("type mismatch on %s field: found %v, expected %v", fieldName, srcKind, dstKind)
		}
		}
		}
		return
		}

		// Map sets fields' values in dst from src.
		// src can be a map with string keys or a struct. dst must be the opposite:
		// if src is a map, dst must be a valid pointer to struct. If src is a struct,
		// dst must be map[string]interface{}.
		// It won't merge unexported (private) fields and will do recursively
		// any exported field.
		// If dst is a map, keys will be src fields' names in lower camel case.
		// Missing key in src that doesn't match a field in dst will be skipped. This
		// doesn't apply if dst is a map.
		// This is separated method from Merge because it is cleaner and it keeps sane
		// semantics: merging equal types, mapping different (restricted) types.
		func Map(dst, src interface{}, opts ...func(*Config)) error {
		return _map(dst, src, opts...)
		}

		// MapWithOverwrite will do the same as Map except that non-empty dst attributes will be overridden by
		// non-empty src attribute values.
		// Deprecated: Use Map(…) with WithOverride
		func MapWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {
		return _map(dst, src, append(opts, WithOverride)...)
		}

		func _map(dst, src interface{}, opts ...func(*Config)) error {
		if dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr {
		return ErrNonPointerArgument
		}
		var (
		vDst, vSrc reflect.Value
		err error
		)
		config := &Config{}

		for _, opt := range opts {
		opt(config)
		}

		if vDst, vSrc, err = resolveValues(dst, src); err != nil {
		return err
		}
		// To be friction-less, we redirect equal-type arguments
		// to deepMerge. Only because arguments can be anything.
		if vSrc.Kind() == vDst.Kind() {
		return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)
		}
		switch vSrc.Kind() {
		case reflect.Struct:
		if vDst.Kind() != reflect.Map {
		return ErrExpectedMapAsDestination
		}
		case reflect.Map:
		if vDst.Kind() != reflect.Struct {
		return ErrExpectedStructAsDestination
		}
		default:
		return ErrNotSupported
		}
		return deepMap(vDst, vSrc, make(map[uintptr]*visit), 0, config)
		}

source/vendor/dario.cat/mergo/merge.go

0 → 100644

+409 −0

Original line number	Diff line number	Diff line
		// Copyright 2013 Dario Castañé. All rights reserved.
		// Copyright 2009 The Go Authors. All rights reserved.
		// Use of this source code is governed by a BSD-style
		// license that can be found in the LICENSE file.

		// Based on src/pkg/reflect/deepequal.go from official
		// golang's stdlib.

		package mergo

		import (
		"fmt"
		"reflect"
		)

		func hasMergeableFields(dst reflect.Value) (exported bool) {
		for i, n := 0, dst.NumField(); i < n; i++ {
		field := dst.Type().Field(i)
		if field.Anonymous && dst.Field(i).Kind() == reflect.Struct {
		exported = exported \|\| hasMergeableFields(dst.Field(i))
		} else if isExportedComponent(&field) {
		exported = exported \|\| len(field.PkgPath) == 0
		}
		}
		return
		}

		func isExportedComponent(field *reflect.StructField) bool {
		pkgPath := field.PkgPath
		if len(pkgPath) > 0 {
		return false
		}
		c := field.Name[0]
		if 'a' <= c && c <= 'z' \|\| c == '_' {
		return false
		}
		return true
		}

		type Config struct {
		Transformers Transformers
		Overwrite bool
		ShouldNotDereference bool
		AppendSlice bool
		TypeCheck bool
		overwriteWithEmptyValue bool
		overwriteSliceWithEmptyValue bool
		sliceDeepCopy bool
		debug bool
		}

		type Transformers interface {
		Transformer(reflect.Type) func(dst, src reflect.Value) error
		}

		// Traverses recursively both values, assigning src's fields values to dst.
		// The map argument tracks comparisons that have already been seen, which allows
		// short circuiting on recursive types.
		func deepMerge(dst, src reflect.Value, visited map[uintptr]visit, depth int, config Config) (err error) {
		overwrite := config.Overwrite
		typeCheck := config.TypeCheck
		overwriteWithEmptySrc := config.overwriteWithEmptyValue
		overwriteSliceWithEmptySrc := config.overwriteSliceWithEmptyValue
		sliceDeepCopy := config.sliceDeepCopy

		if !src.IsValid() {
		return
		}
		if dst.CanAddr() {
		addr := dst.UnsafeAddr()
		h := 17 * addr
		seen := visited[h]
		typ := dst.Type()
		for p := seen; p != nil; p = p.next {
		if p.ptr == addr && p.typ == typ {
		return nil
		}
		}
		// Remember, remember...
		visited[h] = &visit{typ, seen, addr}
		}

		if config.Transformers != nil && !isReflectNil(dst) && dst.IsValid() {
		if fn := config.Transformers.Transformer(dst.Type()); fn != nil {
		err = fn(dst, src)
		return
		}
		}

		switch dst.Kind() {
		case reflect.Struct:
		if hasMergeableFields(dst) {
		for i, n := 0, dst.NumField(); i < n; i++ {
		if err = deepMerge(dst.Field(i), src.Field(i), visited, depth+1, config); err != nil {
		return
		}
		}
		} else {
		if dst.CanSet() && (isReflectNil(dst) \|\| overwrite) && (!isEmptyValue(src, !config.ShouldNotDereference) \|\| overwriteWithEmptySrc) {
		dst.Set(src)
		}
		}
		case reflect.Map:
		if dst.IsNil() && !src.IsNil() {
		if dst.CanSet() {
		dst.Set(reflect.MakeMap(dst.Type()))
		} else {
		dst = src
		return
		}
		}

		if src.Kind() != reflect.Map {
		if overwrite && dst.CanSet() {
		dst.Set(src)
		}
		return
		}

		for _, key := range src.MapKeys() {
		srcElement := src.MapIndex(key)
		if !srcElement.IsValid() {
		continue
		}
		dstElement := dst.MapIndex(key)
		switch srcElement.Kind() {
		case reflect.Chan, reflect.Func, reflect.Map, reflect.Interface, reflect.Slice:
		if srcElement.IsNil() {
		if overwrite {
		dst.SetMapIndex(key, srcElement)
		}
		continue
		}
		fallthrough
		default:
		if !srcElement.CanInterface() {
		continue
		}
		switch reflect.TypeOf(srcElement.Interface()).Kind() {
		case reflect.Struct:
		fallthrough
		case reflect.Ptr:
		fallthrough
		case reflect.Map:
		srcMapElm := srcElement
		dstMapElm := dstElement
		if srcMapElm.CanInterface() {
		srcMapElm = reflect.ValueOf(srcMapElm.Interface())
		if dstMapElm.IsValid() {
		dstMapElm = reflect.ValueOf(dstMapElm.Interface())
		}
		}
		if err = deepMerge(dstMapElm, srcMapElm, visited, depth+1, config); err != nil {
		return
		}
		case reflect.Slice:
		srcSlice := reflect.ValueOf(srcElement.Interface())

		var dstSlice reflect.Value
		if !dstElement.IsValid() \|\| dstElement.IsNil() {
		dstSlice = reflect.MakeSlice(srcSlice.Type(), 0, srcSlice.Len())
		} else {
		dstSlice = reflect.ValueOf(dstElement.Interface())
		}

		if (!isEmptyValue(src, !config.ShouldNotDereference) \|\| overwriteWithEmptySrc \|\| overwriteSliceWithEmptySrc) && (overwrite \|\| isEmptyValue(dst, !config.ShouldNotDereference)) && !config.AppendSlice && !sliceDeepCopy {
		if typeCheck && srcSlice.Type() != dstSlice.Type() {
		return fmt.Errorf("cannot override two slices with different type (%s, %s)", srcSlice.Type(), dstSlice.Type())
		}
		dstSlice = srcSlice
		} else if config.AppendSlice {
		if srcSlice.Type() != dstSlice.Type() {
		return fmt.Errorf("cannot append two slices with different type (%s, %s)", srcSlice.Type(), dstSlice.Type())
		}
		dstSlice = reflect.AppendSlice(dstSlice, srcSlice)
		} else if sliceDeepCopy {
		i := 0
		for ; i < srcSlice.Len() && i < dstSlice.Len(); i++ {
		srcElement := srcSlice.Index(i)
		dstElement := dstSlice.Index(i)

		if srcElement.CanInterface() {
		srcElement = reflect.ValueOf(srcElement.Interface())
		}
		if dstElement.CanInterface() {
		dstElement = reflect.ValueOf(dstElement.Interface())
		}

		if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
		return
		}
		}

		}
		dst.SetMapIndex(key, dstSlice)
		}
		}

		if dstElement.IsValid() && !isEmptyValue(dstElement, !config.ShouldNotDereference) {
		if reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Slice {
		continue
		}
		if reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Map && reflect.TypeOf(dstElement.Interface()).Kind() == reflect.Map {
		continue
		}
		}

		if srcElement.IsValid() && ((srcElement.Kind() != reflect.Ptr && overwrite) \|\| !dstElement.IsValid() \|\| isEmptyValue(dstElement, !config.ShouldNotDereference)) {
		if dst.IsNil() {
		dst.Set(reflect.MakeMap(dst.Type()))
		}
		dst.SetMapIndex(key, srcElement)
		}
		}

		// Ensure that all keys in dst are deleted if they are not in src.
		if overwriteWithEmptySrc {
		for _, key := range dst.MapKeys() {
		srcElement := src.MapIndex(key)
		if !srcElement.IsValid() {
		dst.SetMapIndex(key, reflect.Value{})
		}
		}
		}
		case reflect.Slice:
		if !dst.CanSet() {
		break
		}
		if (!isEmptyValue(src, !config.ShouldNotDereference) \|\| overwriteWithEmptySrc \|\| overwriteSliceWithEmptySrc) && (overwrite \|\| isEmptyValue(dst, !config.ShouldNotDereference)) && !config.AppendSlice && !sliceDeepCopy {
		dst.Set(src)
		} else if config.AppendSlice {
		if src.Type() != dst.Type() {
		return fmt.Errorf("cannot append two slice with different type (%s, %s)", src.Type(), dst.Type())
		}
		dst.Set(reflect.AppendSlice(dst, src))
		} else if sliceDeepCopy {
		for i := 0; i < src.Len() && i < dst.Len(); i++ {
		srcElement := src.Index(i)
		dstElement := dst.Index(i)
		if srcElement.CanInterface() {
		srcElement = reflect.ValueOf(srcElement.Interface())
		}
		if dstElement.CanInterface() {
		dstElement = reflect.ValueOf(dstElement.Interface())
		}

		if err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {
		return
		}
		}
		}
		case reflect.Ptr:
		fallthrough
		case reflect.Interface:
		if isReflectNil(src) {
		if overwriteWithEmptySrc && dst.CanSet() && src.Type().AssignableTo(dst.Type()) {
		dst.Set(src)
		}
		break
		}

		if src.Kind() != reflect.Interface {
		if dst.IsNil() \|\| (src.Kind() != reflect.Ptr && overwrite) {
		if dst.CanSet() && (overwrite \|\| isEmptyValue(dst, !config.ShouldNotDereference)) {
		dst.Set(src)
		}
		} else if src.Kind() == reflect.Ptr {
		if !config.ShouldNotDereference {
		if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
		return
		}
		} else if src.Elem().Kind() != reflect.Struct {
		if overwriteWithEmptySrc \|\| (overwrite && !src.IsNil()) \|\| dst.IsNil() {
		dst.Set(src)
		}
		}
		} else if dst.Elem().Type() == src.Type() {
		if err = deepMerge(dst.Elem(), src, visited, depth+1, config); err != nil {
		return
		}
		} else {
		return ErrDifferentArgumentsTypes
		}
		break
		}

		if dst.IsNil() \|\| overwrite {
		if dst.CanSet() && (overwrite \|\| isEmptyValue(dst, !config.ShouldNotDereference)) {
		dst.Set(src)
		}
		break
		}

		if dst.Elem().Kind() == src.Elem().Kind() {
		if err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
		return
		}
		break
		}
		default:
		mustSet := (isEmptyValue(dst, !config.ShouldNotDereference) \|\| overwrite) && (!isEmptyValue(src, !config.ShouldNotDereference) \|\| overwriteWithEmptySrc)
		if mustSet {
		if dst.CanSet() {
		dst.Set(src)
		} else {
		dst = src
		}
		}
		}

		return
		}

		// Merge will fill any empty for value type attributes on the dst struct using corresponding
		// src attributes if they themselves are not empty. dst and src must be valid same-type structs
		// and dst must be a pointer to struct.
		// It won't merge unexported (private) fields and will do recursively any exported field.
		func Merge(dst, src interface{}, opts ...func(*Config)) error {
		return merge(dst, src, opts...)
		}

		// MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overridden by
		// non-empty src attribute values.
		// Deprecated: use Merge(…) with WithOverride
		func MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {
		return merge(dst, src, append(opts, WithOverride)...)
		}

		// WithTransformers adds transformers to merge, allowing to customize the merging of some types.
		func WithTransformers(transformers Transformers) func(*Config) {
		return func(config *Config) {
		config.Transformers = transformers
		}
		}

		// WithOverride will make merge override non-empty dst attributes with non-empty src attributes values.
		func WithOverride(config *Config) {
		config.Overwrite = true
		}

		// WithOverwriteWithEmptyValue will make merge override non empty dst attributes with empty src attributes values.
		func WithOverwriteWithEmptyValue(config *Config) {
		config.Overwrite = true
		config.overwriteWithEmptyValue = true
		}

		// WithOverrideEmptySlice will make merge override empty dst slice with empty src slice.
		func WithOverrideEmptySlice(config *Config) {
		config.overwriteSliceWithEmptyValue = true
		}

		// WithoutDereference prevents dereferencing pointers when evaluating whether they are empty
		// (i.e. a non-nil pointer is never considered empty).
		func WithoutDereference(config *Config) {
		config.ShouldNotDereference = true
		}

		// WithAppendSlice will make merge append slices instead of overwriting it.
		func WithAppendSlice(config *Config) {
		config.AppendSlice = true
		}

		// WithTypeCheck will make merge check types while overwriting it (must be used with WithOverride).
		func WithTypeCheck(config *Config) {
		config.TypeCheck = true
		}

		// WithSliceDeepCopy will merge slice element one by one with Overwrite flag.
		func WithSliceDeepCopy(config *Config) {
		config.sliceDeepCopy = true
		config.Overwrite = true
		}

		func merge(dst, src interface{}, opts ...func(*Config)) error {
		if dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr {
		return ErrNonPointerArgument
		}
		var (
		vDst, vSrc reflect.Value
		err error
		)

		config := &Config{}

		for _, opt := range opts {
		opt(config)
		}

		if vDst, vSrc, err = resolveValues(dst, src); err != nil {
		return err
		}
		if vDst.Type() != vSrc.Type() {
		return ErrDifferentArgumentsTypes
		}
		return deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)
		}

		// IsReflectNil is the reflect value provided nil
		func isReflectNil(v reflect.Value) bool {
		k := v.Kind()
		switch k {
		case reflect.Interface, reflect.Slice, reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr:
		// Both interface and slice are nil if first word is 0.
		// Both are always bigger than a word; assume flagIndir.
		return v.IsNil()
		default:
		return false
		}
		}

source/vendor/dario.cat/mergo/mergo.go

0 → 100644

+81 −0

Original line number	Diff line number	Diff line
		// Copyright 2013 Dario Castañé. All rights reserved.
		// Copyright 2009 The Go Authors. All rights reserved.
		// Use of this source code is governed by a BSD-style
		// license that can be found in the LICENSE file.

		// Based on src/pkg/reflect/deepequal.go from official
		// golang's stdlib.

		package mergo

		import (
		"errors"
		"reflect"
		)

		// Errors reported by Mergo when it finds invalid arguments.
		var (
		ErrNilArguments = errors.New("src and dst must not be nil")
		ErrDifferentArgumentsTypes = errors.New("src and dst must be of same type")
		ErrNotSupported = errors.New("only structs, maps, and slices are supported")
		ErrExpectedMapAsDestination = errors.New("dst was expected to be a map")
		ErrExpectedStructAsDestination = errors.New("dst was expected to be a struct")
		ErrNonPointerArgument = errors.New("dst must be a pointer")
		)

		// During deepMerge, must keep track of checks that are
		// in progress. The comparison algorithm assumes that all
		// checks in progress are true when it reencounters them.
		// Visited are stored in a map indexed by 17 * a1 + a2;
		type visit struct {
		typ reflect.Type
		next *visit
		ptr uintptr
		}

		// From src/pkg/encoding/json/encode.go.
		func isEmptyValue(v reflect.Value, shouldDereference bool) bool {
		switch v.Kind() {
		case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
		return v.Len() == 0
		case reflect.Bool:
		return !v.Bool()
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return v.Int() == 0
		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
		return v.Uint() == 0
		case reflect.Float32, reflect.Float64:
		return v.Float() == 0
		case reflect.Interface, reflect.Ptr:
		if v.IsNil() {
		return true
		}
		if shouldDereference {
		return isEmptyValue(v.Elem(), shouldDereference)
		}
		return false
		case reflect.Func:
		return v.IsNil()
		case reflect.Invalid:
		return true
		}
		return false
		}

		func resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) {
		if dst == nil \|\| src == nil {
		err = ErrNilArguments
		return
		}
		vDst = reflect.ValueOf(dst).Elem()
		if vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map && vDst.Kind() != reflect.Slice {
		err = ErrNotSupported
		return
		}
		vSrc = reflect.ValueOf(src)
		// We check if vSrc is a pointer to dereference it.
		if vSrc.Kind() == reflect.Ptr {
		vSrc = vSrc.Elem()
		}
		return
		}

source/vendor/github.com/Microsoft/go-winio/.gitattributes

0 → 100644

+1 −0

Original line number	Diff line number	Diff line
		* text=auto eol=lf
		No newline at end of file

source/vendor/github.com/Microsoft/go-winio/.gitignore

0 → 100644

+10 −0

Original line number	Diff line number	Diff line
		.vscode/

		*.exe

		# testing
		testdata

		# go workspaces
		go.work
		go.work.sum

source/vendor/github.com/Microsoft/go-winio/.golangci.yml

0 → 100644

+147 −0

Original line number	Diff line number	Diff line
		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
		- thelper # test helpers without t.Helper()
		- unparam # unused function params

		issues:
		exclude-dirs:
		- pkg/etw/sample

		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
		nolintlint:
		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

source/vendor/github.com/Microsoft/go-winio/CODEOWNERS

0 → 100644

+1 −0

Original line number	Diff line number	Diff line
		* @microsoft/containerplat

source/vendor/github.com/Microsoft/go-winio/LICENSE

0 → 100644

+22 −0

Original line number	Diff line number	Diff line
		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.

source/vendor/github.com/Microsoft/go-winio/README.md

0 → 100644

+89 −0

Original line number	Diff line number	Diff line
		# go-winio [![Build Status](https://github.com/microsoft/go-winio/actions/workflows/ci.yml/badge.svg)](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

source/vendor/github.com/Microsoft/go-winio/SECURITY.md

0 → 100644

+41 −0

Original line number	Diff line number	Diff line
		<!-- 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 -->

source/vendor/github.com/Microsoft/go-winio/backup.go

0 → 100644

+287 −0

Original line number	Diff line number	Diff line
		//go:build windows
		// +build windows

		package winio

		import (
		"encoding/binary"
		"errors"
		"fmt"
		"io"
		"os"
		"runtime"
		"unicode/utf16"

		"github.com/Microsoft/go-winio/internal/fs"
		"golang.org/x/sys/windows"
		)

		//sys backupRead(h windows.Handle, b []byte, bytesRead uint32, abort bool, processSecurity bool, context uintptr) (err error) = BackupRead
		//sys backupWrite(h windows.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 = windows.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(windows.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(windows.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(windows.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(windows.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) {
		h, err := fs.CreateFile(path,
		fs.AccessMask(access),
		fs.FileShareMode(share),
		nil,
		fs.FileCreationDisposition(createmode),
		fs.FILE_FLAG_BACKUP_SEMANTICS\|fs.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
		}

source/vendor/github.com/Microsoft/go-winio/doc.go

0 → 100644

+22 −0

Original line number	Diff line number	Diff line
		// 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

source/vendor/github.com/Microsoft/go-winio/ea.go

0 → 100644

+137 −0

Original line number	Diff line number	Diff line
		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
		}

source/vendor/github.com/Microsoft/go-winio/file.go

0 → 100644

+320 −0

Original line number	Diff line number	Diff line
		//go:build windows
		// +build windows

		package winio

		import (
		"errors"
		"io"
		"runtime"
		"sync"
		"sync/atomic"
		"syscall"
		"time"

		"golang.org/x/sys/windows"
		)

		//sys cancelIoEx(file windows.Handle, o *windows.Overlapped) (err error) = CancelIoEx
		//sys createIoCompletionPort(file windows.Handle, port windows.Handle, key uintptr, threadCount uint32) (newport windows.Handle, err error) = CreateIoCompletionPort
		//sys getQueuedCompletionStatus(port windows.Handle, bytes uint32, key uintptr, o **ioOperation, timeout uint32) (err error) = GetQueuedCompletionStatus
		//sys setFileCompletionNotificationModes(h windows.Handle, flags uint8) (err error) = SetFileCompletionNotificationModes
		//sys wsaGetOverlappedResult(h windows.Handle, o windows.Overlapped, bytes uint32, wait bool, flags *uint32) (err error) = ws2_32.WSAGetOverlappedResult

		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 windows.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 windows.Overlapped
		ch chan ioResult
		}

		func initIO() {
		h, err := createIoCompletionPort(windows.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 windows.Handle
		wg sync.WaitGroup
		wgLock sync.RWMutex
		closing atomic.Bool
		socket bool
		readDeadline deadlineHandler
		writeDeadline deadlineHandler
		}

		type deadlineHandler struct {
		setLock sync.Mutex
		channel timeoutChan
		channelLock sync.RWMutex
		timer *time.Timer
		timedout atomic.Bool
		}

		// makeWin32File makes a new win32File from an existing file handle.
		func makeWin32File(h windows.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
		}

		// Deprecated: use NewOpenFile instead.
		func MakeOpenFile(h syscall.Handle) (io.ReadWriteCloser, error) {
		return NewOpenFile(windows.Handle(h))
		}

		func NewOpenFile(h windows.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
		windows.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.Load()
		}

		// 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.Load() {
		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 windows.Handle) {
		for {
		var bytes uint32
		var key uintptr
		var op *ioOperation
		err := getQueuedCompletionStatus(h, &bytes, &key, &op, windows.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 != windows.ERROR_IO_PENDING { //nolint:errorlint // err is Errno
		return int(bytes), err
		}

		if f.closing.Load() {
		_ = 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 == windows.ERROR_OPERATION_ABORTED { //nolint:errorlint // err is Errno
		if f.closing.Load() {
		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 == windows.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.Load() {
		return 0, ErrTimeout
		}

		var bytes uint32
		err = windows.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 == windows.ERROR_BROKEN_PIPE { //nolint:errorlint // err is Errno
		return 0, io.EOF
		}
		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.Load() {
		return 0, ErrTimeout
		}

		var bytes uint32
		err = windows.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 windows.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.Store(false)

		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.Store(true)
		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
		}

source/vendor/github.com/Microsoft/go-winio/fileinfo.go

0 → 100644

+106 −0

Original line number	Diff line number	Diff line
		//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
		}

		// alignedFileBasicInfo is a FileBasicInfo, but aligned to uint64 by containing
		// uint64 rather than windows.Filetime. Filetime contains two uint32s. uint64
		// alignment is necessary to pass this as FILE_BASIC_INFO.
		type alignedFileBasicInfo struct {
		CreationTime, LastAccessTime, LastWriteTime, ChangeTime uint64
		FileAttributes uint32
		_ uint32 // padding
		}

		// GetFileBasicInfo retrieves times and attributes for a file.
		func GetFileBasicInfo(f os.File) (FileBasicInfo, error) {
		bi := &alignedFileBasicInfo{}
		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)
		// Reinterpret the alignedFileBasicInfo as a FileBasicInfo so it matches the
		// public API of this module. The data may be unnecessarily aligned.
		return (*FileBasicInfo)(unsafe.Pointer(bi)), nil
		}

		// SetFileBasicInfo sets times and attributes for a file.
		func SetFileBasicInfo(f os.File, bi FileBasicInfo) error {
		// Create an alignedFileBasicInfo based on a FileBasicInfo. The copy is
		// suitable to pass to GetFileInformationByHandleEx.
		biAligned := (alignedFileBasicInfo)(unsafe.Pointer(bi))
		if err := windows.SetFileInformationByHandle(
		windows.Handle(f.Fd()),
		windows.FileBasicInfo,
		(*byte)(unsafe.Pointer(&biAligned)),
		uint32(unsafe.Sizeof(biAligned)),
		); 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
		}

source/vendor/github.com/Microsoft/go-winio/hvsock.go

0 → 100644

+582 −0

Original line number	Diff line number	Diff line
		//go:build windows
		// +build windows

		package winio

		import (
		"context"
		"errors"
		"fmt"
		"io"
		"net"
		"os"
		"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 := windows.Socket(afHVSock, windows.SOCK_STREAM, 1)
		if err != nil {
		return nil, os.NewSyscallError("socket", err)
		}
		f, err := makeWin32File(fd)
		if err != nil {
		windows.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}

		var sock *win32File
		sock, err = newHVSocket()
		if err != nil {
		return nil, l.opErr("listen", err)
		}
		defer func() {
		if err != nil {
		_ = sock.Close()
		}
		}()

		sa := addr.raw()
		err = socket.Bind(sock.handle, &sa)
		if err != nil {
		return nil, l.opErr("listen", os.NewSyscallError("socket", err))
		}
		err = windows.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 = windows.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(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(sock.handle, &sa)
		if err != nil {
		return nil, conn.opErr(op, os.NewSyscallError("bind", err))
		}

Compare revisions

Source

Target

Files

Some changes are not shown.

flake.nix

source/go.mod

source/go.sum

source/vendor/dario.cat/mergo/.deepsource.toml

source/vendor/dario.cat/mergo/.gitignore

source/vendor/dario.cat/mergo/.travis.yml

source/vendor/dario.cat/mergo/CODE_OF_CONDUCT.md

source/vendor/dario.cat/mergo/CONTRIBUTING.md

source/vendor/dario.cat/mergo/LICENSE

source/vendor/dario.cat/mergo/README.md

source/vendor/dario.cat/mergo/SECURITY.md

source/vendor/dario.cat/mergo/doc.go

source/vendor/dario.cat/mergo/map.go

source/vendor/dario.cat/mergo/merge.go

source/vendor/dario.cat/mergo/mergo.go

source/vendor/github.com/Microsoft/go-winio/.gitattributes

source/vendor/github.com/Microsoft/go-winio/.gitignore

source/vendor/github.com/Microsoft/go-winio/.golangci.yml

source/vendor/github.com/Microsoft/go-winio/CODEOWNERS

source/vendor/github.com/Microsoft/go-winio/LICENSE

source/vendor/github.com/Microsoft/go-winio/README.md

source/vendor/github.com/Microsoft/go-winio/SECURITY.md

source/vendor/github.com/Microsoft/go-winio/backup.go

source/vendor/github.com/Microsoft/go-winio/doc.go

source/vendor/github.com/Microsoft/go-winio/ea.go

source/vendor/github.com/Microsoft/go-winio/file.go

source/vendor/github.com/Microsoft/go-winio/fileinfo.go

source/vendor/github.com/Microsoft/go-winio/hvsock.go