vm-darwin 2.0.0

Virtualization.framework bindings for Hanzo VM
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

use std::os::unix::io::RawFd;

use objc2::rc::Retained;
use objc2::AnyThread;
use objc2_foundation::NSFileHandle;
use objc2_virtualization::{
    VZFileHandleNetworkDeviceAttachment, VZMACAddress, VZNetworkDeviceAttachment,
    VZNetworkDeviceConfiguration, VZVirtioNetworkDeviceConfiguration,
};

pub trait NetworkAttachment {
    fn as_vz_attachment(&self) -> Retained<VZNetworkDeviceAttachment>;
}

pub struct FileHandleNetworkAttachment {
    inner: Retained<VZFileHandleNetworkDeviceAttachment>,
}

impl FileHandleNetworkAttachment {
    /// Creates a network attachment from a connected datagram socket fd.
    /// The fd should be one end of `socketpair(AF_UNIX, SOCK_DGRAM)`.
    /// VZ takes ownership of this fd (closes on dealloc).
    pub fn new(fd: RawFd) -> Self {
        unsafe {
            let file_handle = NSFileHandle::initWithFileDescriptor_closeOnDealloc(
                NSFileHandle::alloc(),
                fd,
                true,
            );
            FileHandleNetworkAttachment {
                inner: VZFileHandleNetworkDeviceAttachment::initWithFileHandle(
                    VZFileHandleNetworkDeviceAttachment::alloc(),
                    &file_handle,
                ),
            }
        }
    }
}

impl NetworkAttachment for FileHandleNetworkAttachment {
    fn as_vz_attachment(&self) -> Retained<VZNetworkDeviceAttachment> {
        unsafe { Retained::cast_unchecked(self.inner.clone()) }
    }
}

pub struct MACAddress {
    inner: Retained<VZMACAddress>,
}

impl MACAddress {
    pub fn new() -> Self {
        MACAddress {
            inner: unsafe { VZMACAddress::init(VZMACAddress::alloc()) },
        }
    }

    pub fn random_local() -> Self {
        MACAddress {
            inner: unsafe { VZMACAddress::randomLocallyAdministeredAddress() },
        }
    }
}

impl Default for MACAddress {
    fn default() -> Self {
        Self::new()
    }
}

pub struct VirtioNetworkDevice {
    inner: Retained<VZVirtioNetworkDeviceConfiguration>,
}

impl VirtioNetworkDevice {
    pub fn new() -> Self {
        VirtioNetworkDevice {
            inner: unsafe {
                VZVirtioNetworkDeviceConfiguration::init(VZVirtioNetworkDeviceConfiguration::alloc())
            },
        }
    }

    pub fn new_with_attachment(attachment: &impl NetworkAttachment) -> Self {
        let config = Self::new();
        config.set_attachment(attachment);
        config
    }

    pub fn set_attachment(&self, attachment: &impl NetworkAttachment) {
        unsafe {
            self.inner
                .setAttachment(Some(&attachment.as_vz_attachment()));
        }
    }

    pub fn set_mac_address(&self, address: &MACAddress) {
        unsafe {
            self.inner.setMACAddress(&address.inner);
        }
    }

    pub(crate) fn as_network_config(&self) -> Retained<VZNetworkDeviceConfiguration> {
        unsafe { Retained::cast_unchecked(self.inner.clone()) }
    }
}

impl Default for VirtioNetworkDevice {
    fn default() -> Self {
        Self::new()
    }
}