particle-os/debian-forge-composer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

go.mod: bump osbuild/images to 0.55

Browse source
This commit is contained in:
Sanne Raymaekers 2024-04-13 15:47:23 +02:00
parent eab44ca8a8
commit 22140aa7c9
700 changed files with 30353 additions and 27556 deletions
Download patch file Download diff file Expand all files Collapse all files

26
vendor/github.com/vmware/govmomi/vim25/soap/client.go generated vendored
View file

@ -21,6 +21,7 @@ import (
"bytes"
"context"
"crypto/sha1"
"crypto/sha256"
"crypto/tls"
"crypto/x509"
"encoding/json"
@ -387,6 +388,20 @@ func ThumbprintSHA1(cert *x509.Certificate) string {
return strings.Join(hex, ":")
}
// ThumbprintSHA256 returns the sha256 thumbprint of the given cert.
func ThumbprintSHA256(cert *x509.Certificate) string {
sum := sha256.Sum256(cert.Raw)
hex := make([]string, len(sum))
for i, b := range sum {
hex[i] = fmt.Sprintf("%02X", b)
}
return strings.Join(hex, ":")
}
func thumbprintMatches(thumbprint string, cert *x509.Certificate) bool {
return thumbprint == ThumbprintSHA256(cert) || thumbprint == ThumbprintSHA1(cert)
}
func (c *Client) dialTLSContext(
ctx context.Context,
network, addr string) (net.Conn, error) {
@ -418,14 +433,13 @@ func (c *Client) dialTLSContext(
}
cert := conn.ConnectionState().PeerCertificates[0]
peer := ThumbprintSHA1(cert)
if thumbprint != peer {
_ = conn.Close()
return nil, fmt.Errorf("host %q thumbprint does not match %q", addr, thumbprint)
if thumbprintMatches(thumbprint, cert) {
return conn, nil
}
return conn, nil
_ = conn.Close()
return nil, fmt.Errorf("host %q thumbprint does not match %q", addr, thumbprint)
}
// splitHostPort is similar to net.SplitHostPort,

233
vendor/github.com/vmware/govmomi/vim25/types/esxi_version.go generated vendored Normal file
View file

@ -0,0 +1,233 @@
/*
Copyright (c) 2024-2024 VMware, Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package types
import (
"fmt"
"regexp"
"strconv"
)
// ESXiVersion is an ESXi version.
type ESXiVersion uint8
const (
esxiVersionBegin ESXiVersion = iota
ESXi2000
ESXi3000
ESXi4000
ESXi5000
ESXi5100
ESXi5500
ESXi6000
ESXi6500
ESXi6700
ESXi6720
ESXi7000
ESXi7010
ESXi7020
ESXi8000
ESXi8010
ESXi8020
esxiVersionEnd
)
// HardwareVersion returns the maximum hardware version supported by this
// version of ESXi, per https://kb.vmware.com/s/article/1003746.
func (ev ESXiVersion) HardwareVersion() HardwareVersion {
switch ev {
case ESXi2000:
return VMX3
case ESXi3000:
return VMX4
case ESXi4000:
return VMX7
case ESXi5000:
return VMX8
case ESXi5100:
return VMX9
case ESXi5500:
return VMX10
case ESXi6000:
return VMX11
case ESXi6500:
return VMX13
case ESXi6700:
return VMX14
case ESXi6720:
return VMX15
case ESXi7000:
return VMX17
case ESXi7010:
return VMX18
case ESXi7020:
return VMX19
case ESXi8000, ESXi8010:
return VMX20
case ESXi8020:
return VMX21
}
return 0
}
// IsHardwareVersionSupported returns true if the provided hardware version is
// supported by the given version of ESXi.
func (ev ESXiVersion) IsHardwareVersionSupported(hv HardwareVersion) bool {
return hv <= ev.HardwareVersion()
}
func (ev ESXiVersion) IsValid() bool {
return ev.String() != ""
}
func (ev ESXiVersion) String() string {
switch ev {
case ESXi2000:
return "2"
case ESXi3000:
return "3"
case ESXi4000:
return "4"
case ESXi5000:
return "5.0"
case ESXi5100:
return "5.1"
case ESXi5500:
return "5.5"
case ESXi6000:
return "6.0"
case ESXi6500:
return "6.5"
case ESXi6700:
return "6.7"
case ESXi6720:
return "6.7.2"
case ESXi7000:
return "7.0"
case ESXi7010:
return "7.0.1"
case ESXi7020:
return "7.0.2"
case ESXi8000:
return "8.0"
case ESXi8010:
return "8.0.1"
case ESXi8020:
return "8.0.2"
}
return ""
}
func (ev ESXiVersion) MarshalText() ([]byte, error) {
return []byte(ev.String()), nil
}
func (ev *ESXiVersion) UnmarshalText(text []byte) error {
v, err := ParseESXiVersion(string(text))
if err != nil {
return err
}
*ev = v
return nil
}
// MustParseESXiVersion parses the provided string into an ESXi version.
func MustParseESXiVersion(s string) ESXiVersion {
v, err := ParseESXiVersion(s)
if err != nil {
panic(err)
}
return v
}
var esxiRe = regexp.MustCompile(`(?i)^v?(\d)(?:\.(\d))?(?:\.(\d))?(?:\s*u(\d))?$`)
// ParseESXiVersion parses the provided string into an ESXi version.
func ParseESXiVersion(s string) (ESXiVersion, error) {
if m := esxiRe.FindStringSubmatch(s); len(m) > 0 {
var (
major int64
minor int64
patch int64
update int64
)
major, _ = strconv.ParseInt(m[1], 0, 0)
if len(m) > 2 {
minor, _ = strconv.ParseInt(m[2], 0, 0)
}
if len(m) > 3 {
patch, _ = strconv.ParseInt(m[3], 0, 0)
}
if len(m) > 4 {
update, _ = strconv.ParseInt(m[4], 0, 0)
}
switch {
case major == 2 && minor == 0 && patch == 0 && update == 0:
return ESXi2000, nil
case major == 3 && minor == 0 && patch == 0 && update == 0:
return ESXi3000, nil
case major == 4 && minor == 0 && patch == 0 && update == 0:
return ESXi4000, nil
case major == 5 && minor == 0 && patch == 0 && update == 0:
return ESXi5000, nil
case major == 5 && minor == 1 && patch == 0 && update == 0:
return ESXi5100, nil
case major == 5 && minor == 5 && patch == 0 && update == 0:
return ESXi5500, nil
case major == 6 && minor == 0 && patch == 0 && update == 0:
return ESXi6000, nil
case major == 6 && minor == 5 && patch == 0 && update == 0:
return ESXi6500, nil
case major == 6 && minor == 7 && patch == 0 && update == 0:
return ESXi6700, nil
case major == 6 && minor == 7 && patch == 2 && update == 0,
major == 6 && minor == 7 && patch == 0 && update == 2:
return ESXi6720, nil
case major == 7 && minor == 0 && patch == 0 && update == 0:
return ESXi7000, nil
case major == 7 && minor == 0 && patch == 1 && update == 0,
major == 7 && minor == 0 && patch == 0 && update == 1:
return ESXi7010, nil
case major == 7 && minor == 0 && patch == 2 && update == 0,
major == 7 && minor == 0 && patch == 0 && update == 2:
return ESXi7020, nil
case major == 8 && minor == 0 && patch == 0 && update == 0:
return ESXi8000, nil
case major == 8 && minor == 0 && patch == 1 && update == 0,
major == 8 && minor == 0 && patch == 0 && update == 1:
return ESXi8010, nil
case major == 8 && minor == 0 && patch == 2 && update == 0,
major == 8 && minor == 0 && patch == 0 && update == 2:
return ESXi8020, nil
}
}
return 0, fmt.Errorf("invalid version: %q", s)
}
// GetESXiVersions returns a list of ESXi versions.
func GetESXiVersions() []ESXiVersion {
dst := make([]ESXiVersion, esxiVersionEnd-1)
for i := esxiVersionBegin + 1; i < esxiVersionEnd; i++ {
dst[i-1] = i
}
return dst
}

129
vendor/github.com/vmware/govmomi/vim25/types/hardware_version.go generated vendored Normal file
View file

@ -0,0 +1,129 @@
/*
Copyright (c) 2024-2024 VMware, Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package types
import (
"fmt"
"regexp"
"strconv"
)
// HardwareVersion is a VMX hardware version.
type HardwareVersion uint8
const (
VMX3 HardwareVersion = iota + 3
VMX4
vmx5 // invalid
VMX6
VMX7
VMX8
VMX9
VMX10
VMX11
VMX12
VMX13
VMX14
VMX15
VMX16
VMX17
VMX18
VMX19
VMX20
VMX21
)
const (
// MinValidHardwareVersion is the minimum, valid hardware version supported
// by VMware hypervisors in the wild.
MinValidHardwareVersion = VMX3
// MaxValidHardwareVersion is the maximum, valid hardware version supported
// by VMware hypervisors in the wild.
MaxValidHardwareVersion = VMX21
)
func (hv HardwareVersion) IsValid() bool {
return hv != vmx5 &&
hv >= MinValidHardwareVersion &&
hv <= MaxValidHardwareVersion
}
func (hv HardwareVersion) String() string {
if hv.IsValid() {
return fmt.Sprintf("vmx-%d", hv)
}
return ""
}
func (hv HardwareVersion) MarshalText() ([]byte, error) {
return []byte(hv.String()), nil
}
func (hv *HardwareVersion) UnmarshalText(text []byte) error {
v, err := ParseHardwareVersion(string(text))
if err != nil {
return err
}
*hv = v
return nil
}
var vmxRe = regexp.MustCompile(`(?i)^vmx-(\d+)$`)
// MustParseHardwareVersion parses the provided string into a hardware version.
func MustParseHardwareVersion(s string) HardwareVersion {
v, err := ParseHardwareVersion(s)
if err != nil {
panic(err)
}
return v
}
// ParseHardwareVersion parses the provided string into a hardware version.
func ParseHardwareVersion(s string) (HardwareVersion, error) {
var u uint64
if m := vmxRe.FindStringSubmatch(s); len(m) > 0 {
u, _ = strconv.ParseUint(m[1], 10, 8)
} else {
u, _ = strconv.ParseUint(s, 10, 8)
}
v := HardwareVersion(u)
if !v.IsValid() {
return 0, fmt.Errorf("invalid version: %q", s)
}
return v, nil
}
var hardwareVersions []HardwareVersion
func init() {
for i := MinValidHardwareVersion; i <= MaxValidHardwareVersion; i++ {
if i.IsValid() {
hardwareVersions = append(hardwareVersions, i)
}
}
}
// GetHardwareVersions returns a list of hardware versions.
func GetHardwareVersions() []HardwareVersion {
dst := make([]HardwareVersion, len(hardwareVersions))
copy(dst, hardwareVersions)
return dst
}