J Logan
8da5f2306d
- Bindable is generally useful, so it makes sense to move it out of the netlink library. Removed Equatable conformance from Bindable as this isn't generally necessary (it's only used for unit tests in netlink). - Fix some offset checks in a couple data binding functions and improve the unit tests.
271 lines
9.2 KiB
Swift
271 lines
9.2 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
// Copyright © 2025-2026 Apple Inc. and the Containerization project authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://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.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// Represents an IPv6 network address conforming to RFC 5952 and RFC 4291.
|
|
public struct IPv6Address: Sendable, Hashable, CustomStringConvertible, Equatable, Comparable {
|
|
public let value: UInt128
|
|
|
|
public let zone: String?
|
|
|
|
/// Creates an IPv6Address by parsing a string representation.
|
|
///
|
|
/// Supports standard IPv6 formats including compressed notation (::), mixed IPv4 notation, and zone identifiers.
|
|
///
|
|
/// - Parameter address: String representation of an IPv6 address
|
|
/// - Throws: `AddressError` if the string is not a valid IPv6 address
|
|
public init(_ address: String) throws {
|
|
self = try Self.parse(address)
|
|
}
|
|
|
|
/// Creates an IPv6Address from 16 bytes.
|
|
///
|
|
/// - Parameters:
|
|
/// - bytes: 16-byte array in network byte order representing the IPv6 address
|
|
/// - zone: Optional zone identifier (e.g., "eth0")
|
|
/// - Throws: `AddressError.unableToParse` if the byte array length is not 16
|
|
@inlinable
|
|
public init(_ bytes: [UInt8], zone: String? = nil) throws {
|
|
guard bytes.count == 16 else {
|
|
throw AddressError.unableToParse
|
|
}
|
|
|
|
// Build UInt128 value in chunks to avoid compiler complexity
|
|
let hh =
|
|
(UInt128(bytes[0]) << 120) | (UInt128(bytes[1]) << 112) | (UInt128(bytes[2]) << 104)
|
|
| (UInt128(bytes[3]) << 96)
|
|
let hl =
|
|
(UInt128(bytes[4]) << 88) | (UInt128(bytes[5]) << 80) | (UInt128(bytes[6]) << 72)
|
|
| (UInt128(bytes[7]) << 64)
|
|
let lh =
|
|
(UInt128(bytes[8]) << 56) | (UInt128(bytes[9]) << 48) | (UInt128(bytes[10]) << 40)
|
|
| (UInt128(bytes[11]) << 32)
|
|
let ll =
|
|
(UInt128(bytes[12]) << 24) | (UInt128(bytes[13]) << 16) | (UInt128(bytes[14]) << 8) | UInt128(bytes[15])
|
|
|
|
self.value = hh | hl | lh | ll
|
|
self.zone = zone
|
|
}
|
|
|
|
@inlinable
|
|
public init(_ value: UInt128, zone: String? = nil) {
|
|
self.value = value
|
|
self.zone = zone
|
|
}
|
|
|
|
/// Canonical string representation following RFC 5952.
|
|
public var description: String {
|
|
// Convert UInt128 value to 16-bit groups
|
|
let groups: [UInt16] = [
|
|
UInt16((value >> 112) & 0xFFFF),
|
|
UInt16((value >> 96) & 0xFFFF),
|
|
UInt16((value >> 80) & 0xFFFF),
|
|
UInt16((value >> 64) & 0xFFFF),
|
|
UInt16((value >> 48) & 0xFFFF),
|
|
UInt16((value >> 32) & 0xFFFF),
|
|
UInt16((value >> 16) & 0xFFFF),
|
|
UInt16(value & 0xFFFF),
|
|
]
|
|
|
|
// Find the longest run of consecutive zeros for :: compression
|
|
var longestZeroStart = -1
|
|
var longestZeroLength = 0
|
|
var currentZeroStart = -1
|
|
var currentZeroLength = 0
|
|
|
|
for (index, group) in groups.enumerated() {
|
|
if group == 0 {
|
|
if currentZeroStart == -1 {
|
|
currentZeroStart = index
|
|
currentZeroLength = 1
|
|
} else {
|
|
currentZeroLength += 1
|
|
}
|
|
} else {
|
|
if currentZeroLength > longestZeroLength {
|
|
longestZeroStart = currentZeroStart
|
|
longestZeroLength = currentZeroLength
|
|
}
|
|
currentZeroStart = -1
|
|
currentZeroLength = 0
|
|
}
|
|
}
|
|
if currentZeroLength > longestZeroLength {
|
|
longestZeroStart = currentZeroStart
|
|
longestZeroLength = currentZeroLength
|
|
}
|
|
|
|
let useCompression = longestZeroLength >= 2
|
|
|
|
var result = ""
|
|
var index = 0
|
|
|
|
while index < 8 {
|
|
if useCompression && index == longestZeroStart {
|
|
if index == 0 {
|
|
result += "::"
|
|
} else {
|
|
result += ":"
|
|
}
|
|
// Skip the compressed zeros
|
|
index += longestZeroLength
|
|
|
|
// If we compressed to the end, we're done
|
|
if index >= 8 {
|
|
break
|
|
}
|
|
} else {
|
|
// Add the group in lowercase hex without leading zeros
|
|
result += String(groups[index], radix: 16, uppercase: false)
|
|
index += 1
|
|
|
|
// Add colon if not at the end
|
|
if index < 8 {
|
|
result += ":"
|
|
}
|
|
}
|
|
}
|
|
|
|
if let zone = zone {
|
|
result += "%" + zone
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
@inlinable
|
|
public var bytes: [UInt8] {
|
|
Self.bytes(self.value)
|
|
}
|
|
|
|
@usableFromInline
|
|
internal static func bytes(_ value: UInt128) -> [UInt8] {
|
|
var result = [UInt8](repeating: 0, count: 16)
|
|
result[0] = UInt8((value >> 120) & 0xff)
|
|
result[1] = UInt8((value >> 112) & 0xff)
|
|
result[2] = UInt8((value >> 104) & 0xff)
|
|
result[3] = UInt8((value >> 96) & 0xff)
|
|
result[4] = UInt8((value >> 88) & 0xff)
|
|
result[5] = UInt8((value >> 80) & 0xff)
|
|
result[6] = UInt8((value >> 72) & 0xff)
|
|
result[7] = UInt8((value >> 64) & 0xff)
|
|
result[8] = UInt8((value >> 56) & 0xff)
|
|
result[9] = UInt8((value >> 48) & 0xff)
|
|
result[10] = UInt8((value >> 40) & 0xff)
|
|
result[11] = UInt8((value >> 32) & 0xff)
|
|
result[12] = UInt8((value >> 24) & 0xff)
|
|
result[13] = UInt8((value >> 16) & 0xff)
|
|
result[14] = UInt8((value >> 8) & 0xff)
|
|
result[15] = UInt8(value & 0xff)
|
|
return result
|
|
}
|
|
|
|
@available(macOS 26.0, *)
|
|
@usableFromInline
|
|
internal static func bytes(_ value: UInt128) -> InlineArray<16, UInt8> {
|
|
let result: InlineArray<16, UInt8> = [
|
|
UInt8((value >> 120) & 0xff),
|
|
UInt8((value >> 112) & 0xff),
|
|
UInt8((value >> 104) & 0xff),
|
|
UInt8((value >> 96) & 0xff),
|
|
UInt8((value >> 88) & 0xff),
|
|
UInt8((value >> 80) & 0xff),
|
|
UInt8((value >> 72) & 0xff),
|
|
UInt8((value >> 64) & 0xff),
|
|
UInt8((value >> 56) & 0xff),
|
|
UInt8((value >> 48) & 0xff),
|
|
UInt8((value >> 40) & 0xff),
|
|
UInt8((value >> 32) & 0xff),
|
|
UInt8((value >> 24) & 0xff),
|
|
UInt8((value >> 16) & 0xff),
|
|
UInt8((value >> 8) & 0xff),
|
|
UInt8(value & 0xff),
|
|
]
|
|
return result
|
|
}
|
|
|
|
/// The unspecified IPv6 address (::)
|
|
public static let unspecified = IPv6Address(0)
|
|
|
|
/// The loopback IPv6 address (::1)
|
|
public static let loopback = IPv6Address(1)
|
|
|
|
// MARK: - Address Classification Methods
|
|
|
|
/// Returns `true` if this is the unspecified address (::).
|
|
@inlinable
|
|
public var isUnspecified: Bool {
|
|
value == 0
|
|
}
|
|
|
|
/// Returns `true` if this is the loopback address (::1).
|
|
@inlinable
|
|
public var isLoopback: Bool {
|
|
value == 1
|
|
}
|
|
|
|
/// Returns `true` if this is a multicast address (ff00::/8).
|
|
@inlinable
|
|
public var isMulticast: Bool {
|
|
(value >> 120) == 0xFF
|
|
}
|
|
|
|
/// Returns `true` if this is a link-local unicast address (fe80::/10).
|
|
@inlinable
|
|
public var isLinkLocal: Bool {
|
|
(value >> 118) == 0x3FA // fe80::/10 = top 10 bits are 1111111010
|
|
}
|
|
|
|
/// Returns `true` if this is a unique local address (fc00::/7).
|
|
@inlinable
|
|
public var isUniqueLocal: Bool {
|
|
(value >> 121) == 0x7E // fc00::/7 = top 7 bits are 1111110
|
|
}
|
|
|
|
/// Returns `true` if this is a global unicast address.
|
|
@inlinable
|
|
public var isGlobalUnicast: Bool {
|
|
!isUnspecified && !isLoopback && !isMulticast && !isLinkLocal && !isUniqueLocal
|
|
}
|
|
|
|
/// Returns `true` if this is a documentation address (2001:db8::/32).
|
|
@inlinable
|
|
public var isDocumentation: Bool {
|
|
(value >> 96) == 0x2001_0DB8 // 2001:db8::/32
|
|
}
|
|
/// Compares two IPv6 addresses numerically, then by zone if values are equal.
|
|
@inlinable
|
|
public static func < (lhs: IPv6Address, rhs: IPv6Address) -> Bool {
|
|
if lhs.value != rhs.value {
|
|
return lhs.value < rhs.value
|
|
}
|
|
// Same value, compare zones lexicographically
|
|
return (lhs.zone ?? "") < (rhs.zone ?? "")
|
|
}
|
|
}
|
|
|
|
extension IPv6Address: Codable {
|
|
public init(from decoder: Decoder) throws {
|
|
let container = try decoder.singleValueContainer()
|
|
let string = try container.decode(String.self)
|
|
try self.init(string)
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
try container.encode(description)
|
|
}
|
|
}
|