containerization-framework 0.4.0

Rust bindings for Apple's Containerization framework: Linux containers in lightweight VMs, in-process and without a daemon.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//===----------------------------------------------------------------------===//
// `VmnetNetwork` and its `Interface`, from Containerization, and the
// `Network?` the manager's inits take.
//===----------------------------------------------------------------------===//

import Containerization
import ContainerizationExtras
import vmnet

/// A `Network?`.
final class CzNetwork: Sendable {
  let network: (any Network)?

  init(_ network: (any Network)?) {
    self.network = network
  }
}

func noNetwork() -> CzNetwork {
  CzNetwork(nil)
}

/// Unchecked: the interface methods mutate `network`, and Rust's `&mut self`
/// lets only one run at a time.
final class CzVmnetNetwork: @unchecked Sendable {
  var network: VmnetNetwork

  init(_ network: VmnetNetwork) {
    self.network = network
  }

  /// A copy, as Swift passes it to the manager.
  func asNetwork() -> CzNetwork {
    CzNetwork(network)
  }

  func subnet() -> CzOutcome {
    CzOutcome.holding(network.subnet)
  }

  func prefixV6() -> CzOutcome {
    CzOutcome.holding(network.prefixV6)
  }

  func ipv4Gateway() -> CzOutcome {
    CzOutcome.holding(network.ipv4Gateway)
  }

  func ipv6Gateway() -> CzOutcome {
    CzOutcome.holding(network.ipv6Gateway)
  }

  func createInterface(id: RustStr) -> CzOutcome {
    let id = id.toString()

    return CzOutcome { absent(try vmnetInterface(network.createInterface(id))) }
  }

  func createInterface(id: RustStr, mtu: UInt32) -> CzOutcome {
    let id = id.toString()

    return CzOutcome { absent(try vmnetInterface(network.createInterface(id, mtu: mtu))) }
  }

  func createInterfaceWithoutGateway(id: RustStr) -> CzOutcome {
    let id = id.toString()

    return CzOutcome { absent(try vmnetInterface(network.createInterfaceWithoutGateway(id))) }
  }

  func releaseInterface(id: RustStr) -> CzOutcome {
    let id = id.toString()

    return CzOutcome { try network.releaseInterface(id) }
  }
}

/// What `VmnetNetwork`'s `create` methods return, which is always one of its
/// own interfaces.
private func vmnetInterface(_ interface: (any Interface)?) -> CzVmnetInterface? {
  interface.map { interface in
    guard let interface = interface as? VmnetNetwork.Interface else {
      preconditionFailure("VmnetNetwork made a \(type(of: interface))")
    }
    return CzVmnetInterface(interface)
  }
}

/// Public because swift-bridge's glue for a Rust method that takes one is.
public final class CzVmnetInterface: Sendable {
  let interface: VmnetNetwork.Interface

  init(_ interface: VmnetNetwork.Interface) {
    self.interface = interface
  }

  func duplicate() -> CzVmnetInterface {
    CzVmnetInterface(interface)
  }

  func ipv4Address() -> CzOutcome {
    CzOutcome.holding(interface.ipv4Address)
  }

  func ipv4Gateway() -> CzOutcome {
    CzOutcome.holding(interface.ipv4Gateway)
  }

  func ipv6Address() -> CzOutcome {
    CzOutcome.holding(interface.ipv6Address)
  }

  func ipv6Gateway() -> CzOutcome {
    CzOutcome.holding(interface.ipv6Gateway)
  }

  func macAddress() -> CzOutcome {
    CzOutcome.holding(interface.macAddress)
  }

  func mtu() -> UInt32 {
    interface.mtu
  }
}

func vmnetNetwork(
  mode: VmnetMode,
  subnetAddress: UInt32?,
  subnetPrefix: UInt8,
  hasPrefixV6: Bool,
  prefixV6Address: RustIPv6Address,
  prefixV6Length: UInt8
) -> CzOutcome {
  let mode: operating_modes_t =
    switch mode {
    case .Shared: .VMNET_SHARED_MODE
    case .Host: .VMNET_HOST_MODE
    case .Bridged: .VMNET_BRIDGED_MODE
    }

  return CzOutcome {
    let subnet = try subnetAddress.map { try CIDRv4(bridged: $0, prefix: subnetPrefix) }
    let prefixV6 = hasPrefixV6 ? try CIDRv6(bridged: prefixV6Address, prefix: prefixV6Length) : nil

    return CzVmnetNetwork(try VmnetNetwork(mode: mode, subnet: subnet, prefixV6: prefixV6))
  }
}