Commit cef51eaffb
Changed files (9)
lib/std/os/uefi/protocols/ip6_config_protocol.zig
@@ -0,0 +1,45 @@
+const uefi = @import("std").os.uefi;
+const Guid = uefi.Guid;
+const Event = uefi.Event;
+
+pub const Ip6ConfigProtocol = extern struct {
+ _set_data: extern fn (*const Ip6ConfigProtocol, Ip6ConfigDataType, usize, *const c_void) usize,
+ _get_data: extern fn (*const Ip6ConfigProtocol, Ip6ConfigDataType, *usize, ?*const c_void) usize,
+ _register_data_notify: extern fn (*const Ip6ConfigProtocol, Ip6ConfigDataType, Event) usize,
+ _unregister_data_notify: extern fn (*const Ip6ConfigProtocol, Ip6ConfigDataType, Event) usize,
+
+ pub fn setData(self: *const Ip6ConfigProtocol, data_type: Ip6ConfigDataType, data_size: usize, data: *const c_void) usize {
+ return self._set_data(self, data_type, data_size, data);
+ }
+
+ pub fn getData(self: *const Ip6ConfigProtocol, data_type: Ip6ConfigDataType, data_size: *usize, data: ?*const c_void) usize {
+ return self._get_data(self, data_type, data_size, data);
+ }
+
+ pub fn registerDataNotify(self: *const Ip6ConfigProtocol, data_type: Ip6ConfigDataType, event: Event) usize {
+ return self._register_data_notify(self, data_type, event);
+ }
+
+ pub fn unregisterDataNotify(self: *const Ip6ConfigProtocol, data_type: Ip6ConfigDataType, event: Event) usize {
+ return self._unregister_data_notify(self, data_type, event);
+ }
+
+ pub const guid align(8) = Guid{
+ .time_low = 0x937fe521,
+ .time_mid = 0x95ae,
+ .time_high_and_version = 0x4d1a,
+ .clock_seq_high_and_reserved = 0x89,
+ .clock_seq_low = 0x29,
+ .node = [_]u8{ 0x48, 0xbc, 0xd9, 0x0a, 0xd3, 0x1a },
+ };
+};
+
+pub const Ip6ConfigDataType = extern enum(u32) {
+ InterfaceInfo,
+ AltInterfaceId,
+ Policy,
+ DupAddrDetectTransmits,
+ ManualAddress,
+ Gateway,
+ DnsServer,
+};
lib/std/os/uefi/protocols/ip6_protocol.zig
@@ -0,0 +1,143 @@
+const uefi = @import("std").os.uefi;
+const Guid = uefi.Guid;
+const Event = uefi.Event;
+const MacAddress = uefi.protocols.MacAddress;
+const ManagedNetworkConfigData = uefi.protocols.ManagedNetworkConfigData;
+const SimpleNetworkMode = uefi.protocols.SimpleNetworkMode;
+
+pub const Ip6Protocol = extern struct {
+ _get_mode_data: extern fn (*const Ip6Protocol, ?*Ip6ModeData, ?*ManagedNetworkConfigData, ?*SimpleNetworkMode) usize,
+ _configure: extern fn (*const Ip6Protocol, ?*const Ip6ConfigData) usize,
+ _groups: extern fn (*const Ip6Protocol, bool, ?*const Ip6Address) usize,
+ _routes: extern fn (*const Ip6Protocol, bool, ?*const Ip6Address, u8, ?*const Ip6Address) usize,
+ _neighbors: extern fn (*const Ip6Protocol, bool, *const Ip6Address, ?*const MacAddress, u32, bool) usize,
+ _transmit: extern fn (*const Ip6Protocol, *Ip6CompletionToken) usize,
+ _receive: extern fn (*const Ip6Protocol, *Ip6CompletionToken) usize,
+ _cancel: extern fn (*const Ip6Protocol, ?*Ip6CompletionToken) usize,
+ _poll: extern fn (*const Ip6Protocol) usize,
+
+ /// Gets the current operational settings for this instance of the EFI IPv6 Protocol driver.
+ pub fn getModeData(self: *const Ip6Protocol, ip6_mode_data: ?*Ip6ModeData, mnp_config_data: ?*ManagedNetworkConfigData, snp_mode_data: ?*SimpleNetworkMode) usize {
+ return self._get_mode_data(self, ip6_mode_data, mnp_config_data, snp_mode_data);
+ }
+
+ /// Assign IPv6 address and other configuration parameter to this EFI IPv6 Protocol driver instance.
+ pub fn configure(self: *const Ip6Protocol, ip6_config_data: ?*const Ip6ConfigData) usize {
+ return self._configure(self, ip6_config_data);
+ }
+
+ /// Joins and leaves multicast groups.
+ pub fn groups(self: *const Ip6Protocol, join_flag: bool, group_address: ?*const Ip6Address) usize {
+ return self._groups(self, join_flag, group_address);
+ }
+
+ /// Adds and deletes routing table entries.
+ pub fn routes(self: *const Ip6Protocol, delete_route: bool, destination: ?*const Ip6Address, prefix_length: u8, gateway_address: ?*const Ip6Address) usize {
+ return self._routes(self, delete_route, destination, prefix_length, gateway_address);
+ }
+
+ /// Add or delete Neighbor cache entries.
+ pub fn neighbors(self: *const Ip6Protocol, delete_flag: bool, target_ip6_address: *const Ip6Address, target_link_address: ?*const MacAddress, timeout: u32, override: bool) usize {
+ return self._neighbors(self, delete_flag, target_ip6_address, target_link_address, timeout, override);
+ }
+
+ /// Places outgoing data packets into the transmit queue.
+ pub fn transmit(self: *const Ip6Protocol, token: *Ip6CompletionToken) usize {
+ return self._transmit(self, token);
+ }
+
+ /// Places a receiving request into the receiving queue.
+ pub fn receive(self: *const Ip6Protocol, token: *Ip6CompletionToken) usize {
+ return self._receive(self, token);
+ }
+
+ /// Abort an asynchronous transmits or receive request.
+ pub fn cancel(self: *const Ip6Protocol, token: ?*Ip6CompletionToken) usize {
+ return self._cancel(self, token);
+ }
+
+ /// Polls for incoming data packets and processes outgoing data packets.
+ pub fn poll(self: *const Ip6Protocol) usize {
+ return self._poll(self);
+ }
+
+ pub const guid align(8) = Guid{
+ .time_low = 0x2c8759d5,
+ .time_mid = 0x5c2d,
+ .time_high_and_version = 0x66ef,
+ .clock_seq_high_and_reserved = 0x92,
+ .clock_seq_low = 0x5f,
+ .node = [_]u8{ 0xb6, 0x6c, 0x10, 0x19, 0x57, 0xe2 },
+ };
+};
+
+pub const Ip6ModeData = extern struct {
+ is_started: bool,
+ max_packet_size: u32,
+ config_data: Ip6ConfigData,
+ is_configured: bool,
+ address_count: u32,
+ address_list: [*]Ip6AddressInfo,
+ group_count: u32,
+ group_table: [*]Ip6Address,
+ route_count: u32,
+ route_table: [*]Ip6RouteTable,
+ neighbor_count: u32,
+ neighbor_cache: [*]Ip6NeighborCache,
+ prefix_count: u32,
+ prefix_table: [*]Ip6AddressInfo,
+ icmp_type_count: u32,
+ icmp_type_list: [*]Ip6IcmpType,
+};
+
+pub const Ip6ConfigData = extern struct {
+ default_protocol: u8,
+ accept_any_protocol: bool,
+ accept_icmp_errors: bool,
+ accept_promiscuous: bool,
+ destination_address: Ip6Address,
+ station_address: Ip6Address,
+ traffic_class: u8,
+ hop_limit: u8,
+ flow_label: u32,
+ receive_timeout: u32,
+ transmit_timeout: u32,
+};
+
+pub const Ip6Address = [16]u8;
+
+pub const Ip6AddressInfo = extern struct {
+ address: Ip6Address,
+ prefix_length: u8,
+};
+
+pub const Ip6RouteTable = extern struct {
+ gateway: Ip6Address,
+ destination: Ip6Address,
+ prefix_length: u8,
+};
+
+pub const Ip6NeighborState = extern enum(u32) {
+ Incomplete,
+ Reachable,
+ Stale,
+ Delay,
+ Probe,
+};
+
+pub const Ip6NeighborCache = extern struct {
+ neighbor: Ip6Address,
+ link_address: MacAddress,
+ state: Ip6NeighborState,
+};
+
+pub const Ip6IcmpType = extern struct {
+ type: u8,
+ code: u8,
+};
+
+pub const Ip6CompletionToken = extern struct {
+ event: Event,
+ status: usize,
+ packet: *c_void, // union TODO
+};
lib/std/os/uefi/protocols/ip6_service_binding_protocol.zig
@@ -0,0 +1,25 @@
+const uefi = @import("std").os.uefi;
+const Handle = uefi.Handle;
+const Guid = uefi.Guid;
+
+pub const Ip6ServiceBindingProtocol = extern struct {
+ _create_child: extern fn (*const Ip6ServiceBindingProtocol, *?Handle) usize,
+ _destroy_child: extern fn (*const Ip6ServiceBindingProtocol, Handle) usize,
+
+ pub fn createChild(self: *const Ip6ServiceBindingProtocol, handle: *?Handle) usize {
+ return self._create_child(self, handle);
+ }
+
+ pub fn destroyChild(self: *const Ip6ServiceBindingProtocol, handle: Handle) usize {
+ return self._destroy_child(self, handle);
+ }
+
+ pub const guid align(8) = Guid{
+ .time_low = 0xec835dd3,
+ .time_mid = 0xfe0f,
+ .time_high_and_version = 0x617b,
+ .clock_seq_high_and_reserved = 0xa6,
+ .clock_seq_low = 0x21,
+ .node = [_]u8{ 0xb3, 0x50, 0xc3, 0xe1, 0x33, 0x88 },
+ };
+};
lib/std/os/uefi/protocols/managed_network_protocol.zig
@@ -0,0 +1,126 @@
+const uefi = @import("std").os.uefi;
+const Guid = uefi.Guid;
+const Event = uefi.Event;
+const Time = uefi.Time;
+const SimpleNetworkMode = uefi.protocols.SimpleNetworkMode;
+const MacAddress = uefi.protocols.MacAddress;
+
+pub const ManagedNetworkProtocol = extern struct {
+ _get_mode_data: extern fn (*const ManagedNetworkProtocol, ?*ManagedNetworkConfigData, ?*SimpleNetworkMode) usize,
+ _configure: extern fn (*const ManagedNetworkProtocol, ?*const ManagedNetworkConfigData) usize,
+ _mcast_ip_to_mac: extern fn (*const ManagedNetworkProtocol, bool, *const c_void, *MacAddress) usize,
+ _groups: extern fn (*const ManagedNetworkProtocol, bool, ?*const MacAddress) usize,
+ _transmit: extern fn (*const ManagedNetworkProtocol, *const ManagedNetworkCompletionToken) usize,
+ _receive: extern fn (*const ManagedNetworkProtocol, *const ManagedNetworkCompletionToken) usize,
+ _cancel: extern fn (*const ManagedNetworkProtocol, ?*const ManagedNetworkCompletionToken) usize,
+ _poll: extern fn (*const ManagedNetworkProtocol) usize,
+
+ /// Returns the operational parameters for the current MNP child driver.
+ /// May also support returning the underlying SNP driver mode data.
+ pub fn getModeData(self: *const ManagedNetworkProtocol, mnp_config_data: ?*ManagedNetworkConfigData, snp_mode_data: ?*SimpleNetworkMode) usize {
+ return self._get_mode_data(self, mnp_config_data, snp_mode_data);
+ }
+
+ /// Sets or clears the operational parameters for the MNP child driver.
+ pub fn configure(self: *const ManagedNetworkProtocol, mnp_config_data: ?*const ManagedNetworkConfigData) usize {
+ return self._configure(self, mnp_config_data);
+ }
+
+ /// Translates an IP multicast address to a hardware (MAC) multicast address.
+ /// This function may be unsupported in some MNP implementations.
+ pub fn mcastIpToMac(self: *const ManagedNetworkProtocol, ipv6flag: bool, ipaddress: *const c_void, mac_address: *MacAddress) usize {
+ return self._mcast_ip_to_mac(self, ipv6flag, ipaddress);
+ }
+
+ /// Enables and disables receive filters for multicast address.
+ /// This function may be unsupported in some MNP implementations.
+ pub fn groups(self: *const ManagedNetworkProtocol, join_flag: bool, mac_address: ?*const MacAddress) usiz {
+ return self._groups(self, join_flag, mac_address);
+ }
+
+ /// Places asynchronous outgoing data packets into the transmit queue.
+ pub fn transmit(self: *const ManagedNetworkProtocol, token: *const ManagedNetworkCompletionToken) usize {
+ return self._transmit(self, token);
+ }
+
+ /// Places an asynchronous receiving request into the receiving queue.
+ pub fn receive(self: *const ManagedNetworkProtocol, token: *const ManagedNetworkCompletionToken) usize {
+ return self._receive(self, token);
+ }
+
+ /// Aborts an asynchronous transmit or receive request.
+ pub fn cancel(self: *const ManagedNetworkProtocol, token: ?*const ManagedNetworkCompletionToken) usize {
+ return self._cancel(self, token);
+ }
+
+ /// Polls for incoming data packets and processes outgoing data packets.
+ pub fn poll(self: *const ManagedNetworkProtocol) usize {
+ return self._poll(self);
+ }
+
+ pub const guid align(8) = Guid{
+ .time_low = 0x7ab33a91,
+ .time_mid = 0xace5,
+ .time_high_and_version = 0x4326,
+ .clock_seq_high_and_reserved = 0xb5,
+ .clock_seq_low = 0x72,
+ .node = [_]u8{ 0xe7, 0xee, 0x33, 0xd3, 0x9f, 0x16 },
+ };
+};
+
+pub const ManagedNetworkConfigData = extern struct {
+ received_queue_timeout_value: u32,
+ transmit_queue_timeout_value: u32,
+ protocol_type_filter: u16,
+ enable_unicast_receive: bool,
+ enable_multicast_receive: bool,
+ enable_broadcast_receive: bool,
+ enable_promiscuous_receive: bool,
+ flush_queues_on_reset: bool,
+ enable_receive_timestamps: bool,
+ disable_background_polling: bool,
+};
+
+pub const ManagedNetworkCompletionToken = extern struct {
+ event: Event,
+ status: usize,
+ packet: extern union {
+ RxData: *ManagedNetworkReceiveData,
+ TxData: *ManagedNetworkTransmitData,
+ },
+};
+
+pub const ManagedNetworkReceiveData = extern struct {
+ timestamp: Time,
+ recycle_event: Event,
+ packet_length: u32,
+ header_length: u32,
+ address_length: u32,
+ data_length: u32,
+ broadcast_flag: bool,
+ multicast_flag: bool,
+ promiscuous_flag: bool,
+ protocol_type: u16,
+ destination_address: [*]u8,
+ source_address: [*]u8,
+ media_header: [*]u8,
+ packet_data: [*]u8,
+};
+
+pub const ManagedNetworkTransmitData = extern struct {
+ destination_address: ?*MacAddress,
+ source_address: ?*MacAddress,
+ protocol_type: u16,
+ data_length: u32,
+ header_length: u16,
+ fragment_count: u16,
+
+ pub fn getFragments(self: *ManagedNetworkTransmitData) []ManagedNetworkFragmentData {
+ return @ptrCast([*]ManagedNetworkFragmentData, @ptrCast([*]u8, self) + @sizeOf(ManagedNetworkTransmitData))[0..self.fragment_count];
+ }
+};
+
+pub const ManagedNetworkFragmentData = extern struct {
+ fragment_length: u32,
+ fragment_buffer: [*]u8,
+};
lib/std/os/uefi/protocols/managed_network_service_binding_protocol.zig
@@ -0,0 +1,25 @@
+const uefi = @import("std").os.uefi;
+const Handle = uefi.Handle;
+const Guid = uefi.Guid;
+
+pub const ManagedNetworkServiceBindingProtocol = extern struct {
+ _create_child: extern fn (*const ManagedNetworkServiceBindingProtocol, *?Handle) usize,
+ _destroy_child: extern fn (*const ManagedNetworkServiceBindingProtocol, Handle) usize,
+
+ pub fn createChild(self: *const ManagedNetworkServiceBindingProtocol, handle: *?Handle) usize {
+ return self._create_child(self, handle);
+ }
+
+ pub fn destroyChild(self: *const ManagedNetworkServiceBindingProtocol, handle: Handle) usize {
+ return self._destroy_child(self, handle);
+ }
+
+ pub const guid align(8) = Guid{
+ .time_low = 0xf36ff770,
+ .time_mid = 0xa7e1,
+ .time_high_and_version = 0x42cf,
+ .clock_seq_high_and_reserved = 0x9e,
+ .clock_seq_low = 0xd2,
+ .node = [_]u8{ 0x56, 0xf0, 0xf2, 0x71, 0xf4, 0x4c },
+ };
+};
lib/std/os/uefi/protocols/simple_network_protocol.zig
@@ -0,0 +1,172 @@
+const uefi = @import("std").os.uefi;
+const Event = uefi.Event;
+const Guid = uefi.Guid;
+
+pub const SimpleNetworkProtocol = extern struct {
+ revision: u64,
+ _start: extern fn (*const SimpleNetworkProtocol) usize,
+ _stop: extern fn (*const SimpleNetworkProtocol) usize,
+ _initialize: extern fn (*const SimpleNetworkProtocol, usize, usize) usize,
+ _reset: extern fn (*const SimpleNetworkProtocol, bool) usize,
+ _shutdown: extern fn (*const SimpleNetworkProtocol) usize,
+ _receive_filters: extern fn (*const SimpleNetworkProtocol, SimpleNetworkReceiveFilter, SimpleNetworkReceiveFilter, bool, usize, ?[*]const MacAddress) usize,
+ _station_address: extern fn (*const SimpleNetworkProtocol, bool, ?*const MacAddress) usize,
+ _statistics: extern fn (*const SimpleNetworkProtocol, bool, ?*usize, ?*NetworkStatistics) usize,
+ _mcast_ip_to_mac: extern fn (*const SimpleNetworkProtocol, bool, *const c_void, *MacAddress) usize,
+ _nvdata: extern fn (*const SimpleNetworkProtocol, bool, usize, usize, [*]u8) usize,
+ _get_status: extern fn (*const SimpleNetworkProtocol, *SimpleNetworkInterruptStatus, ?*?[*]u8) usize,
+ _transmit: extern fn (*const SimpleNetworkProtocol, usize, usize, [*]const u8, ?*const MacAddress, ?*const MacAddress, ?*const u16) usize,
+ _receive: extern fn (*const SimpleNetworkProtocol, ?*usize, *usize, [*]u8, ?*MacAddress, ?*MacAddress, ?*u16) usize,
+ wait_for_packet: Event,
+ mode: *SimpleNetworkMode,
+
+ /// Changes the state of a network interface from "stopped" to "started".
+ pub fn start(self: *const SimpleNetworkProtocol) usize {
+ return self._start(self);
+ }
+
+ /// Changes the state of a network interface from "started" to "stopped".
+ pub fn stop(self: *const SimpleNetworkProtocol) usize {
+ return self._stop(self);
+ }
+
+ /// Resets a network adapter and allocates the transmit and receive buffers required by the network interface.
+ pub fn initialize(self: *const SimpleNetworkProtocol, extra_rx_buffer_size: usize, extra_tx_buffer_size: usize) usize {
+ return self._initialize(self, extra_rx_buffer_size, extra_tx_buffer_size);
+ }
+
+ /// Resets a network adapter and reinitializes it with the parameters that were provided in the previous call to initialize().
+ pub fn reset(self: *const SimpleNetworkProtocol, extended_verification: bool) usize {
+ return self._reset(self, extended_verification);
+ }
+
+ /// Resets a network adapter and leaves it in a state that is safe for another driver to initialize.
+ pub fn shutdown(self: *const SimpleNetworkProtocol) usize {
+ return self._shutdown(self);
+ }
+
+ /// Manages the multicast receive filters of a network interface.
+ pub fn receiveFilters(self: *const SimpleNetworkProtocol, enable: SimpleNetworkReceiveFilter, disable: SimpleNetworkReceiveFilter, reset_mcast_filter: bool, mcast_filter_cnt: usize, mcast_filter: ?[*]const MacAddress) usize {
+ return self._receive_filters(self, enable, disable, reset_mcast_filter, mcast_filter_cnt, mcast_filter);
+ }
+
+ /// Modifies or resets the current station address, if supported.
+ pub fn stationAddress(self: *const SimpleNetworkProtocol, reset: bool, new: ?*const MacAddress) usize {
+ return self._station_address(self, reset, new);
+ }
+
+ /// Resets or collects the statistics on a network interface.
+ pub fn statistics(self: *const SimpleNetworkProtocol, reset_: bool, statistics_size: ?*usize, statistics_table: ?*NetworkStatistics) usize {
+ return self._statistics(self, reset_, statistics_size, statistics_table);
+ }
+
+ /// Converts a multicast IP address to a multicast HW MAC address.
+ pub fn mcastIpToMac(self: *const SimpleNetworkProtocol, ipv6: bool, ip: *const c_void, mac: *MacAddress) usize {
+ return self._mcast_ip_to_mac(self, ipv6, ip, mac);
+ }
+
+ /// Performs read and write operations on the NVRAM device attached to a network interface.
+ pub fn nvdata(self: *const SimpleNetworkProtocol, read_write: bool, offset: usize, buffer_size: usize, buffer: [*]u8) usize {
+ return self._nvdata(self, read_write, offset, buffer_size, buffer);
+ }
+
+ /// Reads the current interrupt status and recycled transmit buffer status from a network interface.
+ pub fn getStatus(self: *const SimpleNetworkProtocol, interrupt_status: *SimpleNetworkInterruptStatus, tx_buf: ?*?[*]u8) usize {
+ return self._get_status(self, interrupt_status, tx_buf);
+ }
+
+ /// Places a packet in the transmit queue of a network interface.
+ pub fn transmit(self: *const SimpleNetworkProtocol, header_size: usize, buffer_size: usize, buffer: [*]const u8, src_addr: ?*const MacAddress, dest_addr: ?*const MacAddress, protocol: ?*const u16) usize {
+ return self._transmit(self, header_size, buffer_size, buffer, src_addr, dest_addr, protocol);
+ }
+
+ /// Receives a packet from a network interface.
+ pub fn receive(self: *const SimpleNetworkProtocol, header_size: ?*usize, buffer_size: *usize, buffer: [*]u8, src_addr: ?*MacAddress, dest_addr: ?*MacAddress, protocol: ?*u16) usize {
+ return self._receive(self, header_size, buffer_size, buffer, src_addr, dest_addr, protocol);
+ }
+
+ pub const guid align(8) = Guid{
+ .time_low = 0xa19832b9,
+ .time_mid = 0xac25,
+ .time_high_and_version = 0x11d3,
+ .clock_seq_high_and_reserved = 0x9a,
+ .clock_seq_low = 0x2d,
+ .node = [_]u8{ 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d },
+ };
+};
+
+pub const MacAddress = [32]u8;
+
+pub const SimpleNetworkMode = extern struct {
+ state: SimpleNetworkState,
+ hw_address_size: u32,
+ media_header_size: u32,
+ max_packet_size: u32,
+ nvram_size: u32,
+ nvram_access_size: u32,
+ receive_filter_mask: SimpleNetworkReceiveFilter,
+ receive_filter_setting: SimpleNetworkReceiveFilter,
+ max_mcast_filter_count: u32,
+ mcast_filter_count: u32,
+ mcast_filter: [16]MacAddress,
+ current_address: MacAddress,
+ broadcast_address: MacAddress,
+ permanent_address: MacAddress,
+ if_type: u8,
+ mac_address_changeable: bool,
+ multiple_tx_supported: bool,
+ media_present_supported: bool,
+ media_present: bool,
+};
+
+pub const SimpleNetworkReceiveFilter = packed struct {
+ receive_unicast: bool,
+ receive_multicast: bool,
+ receive_broadcast: bool,
+ receive_promiscuous: bool,
+ receive_promiscuous_multicast: bool,
+ _pad: u27 = undefined,
+};
+
+pub const SimpleNetworkState = extern enum(u32) {
+ Stopped,
+ Started,
+ Initialized,
+};
+
+pub const NetworkStatistics = extern struct {
+ rx_total_frames: u64,
+ rx_good_frames: u64,
+ rx_undersize_frames: u64,
+ rx_oversize_frames: u64,
+ rx_dropped_frames: u64,
+ rx_unicast_frames: u64,
+ rx_broadcast_frames: u64,
+ rx_multicast_frames: u64,
+ rx_crc_error_frames: u64,
+ rx_total_bytes: u64,
+ tx_total_frames: u64,
+ tx_good_frames: u64,
+ tx_undersize_frames: u64,
+ tx_oversize_frames: u64,
+ tx_dropped_frames: u64,
+ tx_unicast_frames: u64,
+ tx_broadcast_frames: u64,
+ tx_multicast_frames: u64,
+ tx_crc_error_frames: u64,
+ tx_total_bytes: u64,
+ collisions: u64,
+ unsupported_protocol: u64,
+ rx_duplicated_frames: u64,
+ rx_decryptError_frames: u64,
+ tx_error_frames: u64,
+ tx_retry_frames: u64,
+};
+
+pub const SimpleNetworkInterruptStatus = packed struct {
+ receive_interrupt: bool,
+ transmit_interrupt: bool,
+ command_interrupt: bool,
+ software_interrupt: bool,
+ _pad: u28,
+};
lib/std/os/uefi/protocols/udp6_protocol.zig
@@ -0,0 +1,112 @@
+const uefi = @import("std").os.uefi;
+const Guid = uefi.Guid;
+const Event = uefi.Event;
+const Time = uefi.Time;
+const Ip6ModeData = uefi.protocols.Ip6ModeData;
+const Ip6Address = uefi.protocols.Ip6Address;
+const ManagedNetworkConfigData = uefi.protocols.ManagedNetworkConfigData;
+const SimpleNetworkMode = uefi.protocols.SimpleNetworkMode;
+
+pub const Udp6Protocol = extern struct {
+ _get_mode_data: extern fn (*const Udp6Protocol, ?*Udp6ConfigData, ?*Ip6ModeData, ?*ManagedNetworkConfigData, ?*SimpleNetworkMode) usize,
+ _configure: extern fn (*const Udp6Protocol, ?*const Udp6ConfigData) usize,
+ _groups: extern fn (*const Udp6Protocol, bool, ?*const Ip6Address) usize,
+ _transmit: extern fn (*const Udp6Protocol, *Udp6CompletionToken) usize,
+ _receive: extern fn (*const Udp6Protocol, *Udp6CompletionToken) usize,
+ _cancel: extern fn (*const Udp6Protocol, ?*Udp6CompletionToken) usize,
+ _poll: extern fn (*const Udp6Protocol) usize,
+
+ pub fn getModeData(self: *const Udp6Protocol, udp6_config_data: ?*Udp6ConfigData, ip6_mode_data: ?*Ip6ModeData, mnp_config_data: ?*ManagedNetworkConfigData, snp_mode_data: ?*SimpleNetworkMode) usize {
+ return self._get_mode_data(self, udp6_config_data, ip6_mode_data, mnp_config_data, snp_mode_data);
+ }
+
+ pub fn configure(self: *const Udp6Protocol, udp6_config_data: ?*const Udp6ConfigData) usize {
+ return self._configure(self, udp6_config_data);
+ }
+
+ pub fn groups(self: *const Udp6Protocol, join_flag: bool, multicast_address: ?*const Ip6Address) usize {
+ return self._groups(self, join_flag, multicast_address);
+ }
+
+ pub fn transmit(self: *const Udp6Protocol, token: *Udp6CompletionToken) usize {
+ return self._transmit(self, token);
+ }
+
+ pub fn receive(self: *const Udp6Protocol, token: *Udp6CompletionToken) usize {
+ return self._receive(self, token);
+ }
+
+ pub fn cancel(self: *const Udp6Protocol, token: ?*Udp6CompletionToken) usize {
+ return self._cancel(self, token);
+ }
+
+ pub fn poll(self: *const Udp6Protocol) usize {
+ return self._poll(self);
+ }
+
+ pub const guid align(8) = uefi.Guid{
+ .time_low = 0x4f948815,
+ .time_mid = 0xb4b9,
+ .time_high_and_version = 0x43cb,
+ .clock_seq_high_and_reserved = 0x8a,
+ .clock_seq_low = 0x33,
+ .node = [_]u8{ 0x90, 0xe0, 0x60, 0xb3, 0x49, 0x55 },
+ };
+};
+
+pub const Udp6ConfigData = extern struct {
+ accept_promiscuous: bool,
+ accept_any_port: bool,
+ allow_duplicate_port: bool,
+ traffic_class: u8,
+ hop_limit: u8,
+ receive_timeout: u32,
+ transmit_timeout: u32,
+ station_address: Ip6Address,
+ station_port: u16,
+ remote_address: Ip6Address,
+ remote_port: u16,
+};
+
+pub const Udp6CompletionToken = extern struct {
+ event: Event,
+ status: usize,
+ packet: extern union {
+ RxData: *Udp6ReceiveData,
+ TxData: *Udp6TransmitData,
+ },
+};
+
+pub const Udp6ReceiveData = extern struct {
+ timestamp: Time,
+ recycle_signal: Event,
+ udp6_session: Udp6SessionData,
+ data_length: u32,
+ fragment_count: u32,
+
+ pub fn getFragments(self: *Udp6ReceiveData) []Udp6FragmentData {
+ return @ptrCast([*]Udp6FragmentData, @ptrCast([*]u8, self) + @sizeOf(Udp6ReceiveData))[0..self.fragment_count];
+ }
+};
+
+pub const Udp6TransmitData = extern struct {
+ udp6_session_data: ?*Udp6SessionData,
+ data_length: u32,
+ fragment_count: u32,
+
+ pub fn getFragments(self: *Udp6TransmitData) []Udp6FragmentData {
+ return @ptrCast([*]Udp6FragmentData, @ptrCast([*]u8, self) + @sizeOf(Udp6TransmitData))[0..self.fragment_count];
+ }
+};
+
+pub const Udp6SessionData = extern struct {
+ source_address: Ip6Address,
+ source_port: u16,
+ destination_address: Ip6Address,
+ destination_port: u16,
+};
+
+pub const Udp6FragmentData = extern struct {
+ fragment_length: u32,
+ fragment_buffer: [*]u8,
+};
lib/std/os/uefi/protocols/udp6_service_binding_protocol.zig
@@ -0,0 +1,25 @@
+const uefi = @import("std").os.uefi;
+const Handle = uefi.Handle;
+const Guid = uefi.Guid;
+
+pub const Udp6ServiceBindingProtocol = extern struct {
+ _create_child: extern fn (*const Udp6ServiceBindingProtocol, *?Handle) usize,
+ _destroy_child: extern fn (*const Udp6ServiceBindingProtocol, Handle) usize,
+
+ pub fn createChild(self: *const Udp6ServiceBindingProtocol, handle: *?Handle) usize {
+ return self._create_child(self, handle);
+ }
+
+ pub fn destroyChild(self: *const Udp6ServiceBindingProtocol, handle: Handle) usize {
+ return self._destroy_child(self, handle);
+ }
+
+ pub const guid align(8) = Guid{
+ .time_low = 0x66ed4721,
+ .time_mid = 0x3c98,
+ .time_high_and_version = 0x4d3e,
+ .clock_seq_high_and_reserved = 0x81,
+ .clock_seq_low = 0xe3,
+ .node = [_]u8{ 0xd0, 0x3d, 0xd3, 0x9a, 0x72, 0x54 },
+ };
+};
lib/std/os/uefi/protocols.zig
@@ -33,6 +33,46 @@ pub const EdidActiveProtocol = @import("protocols/edid_active_protocol.zig").Edi
pub const EdidOverrideProtocol = @import("protocols/edid_override_protocol.zig").EdidOverrideProtocol;
pub const EdidOverrideProtocolAttributes = @import("protocols/edid_override_protocol.zig").EdidOverrideProtocolAttributes;
+pub const SimpleNetworkProtocol = @import("protocols/simple_network_protocol.zig").SimpleNetworkProtocol;
+pub const MacAddress = @import("protocols/simple_network_protocol.zig").MacAddress;
+pub const SimpleNetworkMode = @import("protocols/simple_network_protocol.zig").SimpleNetworkMode;
+pub const SimpleNetworkReceiveFilter = @import("protocols/simple_network_protocol.zig").SimpleNetworkReceiveFilter;
+pub const SimpleNetworkState = @import("protocols/simple_network_protocol.zig").SimpleNetworkState;
+pub const NetworkStatistics = @import("protocols/simple_network_protocol.zig").NetworkStatistics;
+pub const SimpleNetworkInterruptStatus = @import("protocols/simple_network_protocol.zig").SimpleNetworkInterruptStatus;
+
+pub const ManagedNetworkServiceBindingProtocol = @import("protocols/managed_network_service_binding_protocol.zig").ManagedNetworkServiceBindingProtocol;
+pub const ManagedNetworkProtocol = @import("protocols/managed_network_protocol.zig").ManagedNetworkProtocol;
+pub const ManagedNetworkConfigData = @import("protocols/managed_network_protocol.zig").ManagedNetworkConfigData;
+pub const ManagedNetworkCompletionToken = @import("protocols/managed_network_protocol.zig").ManagedNetworkCompletionToken;
+pub const ManagedNetworkReceiveData = @import("protocols/managed_network_protocol.zig").ManagedNetworkReceiveData;
+pub const ManagedNetworkTransmitData = @import("protocols/managed_network_protocol.zig").ManagedNetworkTransmitData;
+pub const ManagedNetworkFragmentData = @import("protocols/managed_network_protocol.zig").ManagedNetworkFragmentData;
+
+pub const Ip6ServiceBindingProtocol = @import("protocols/ip6_service_binding_protocol.zig").Ip6ServiceBindingProtocol;
+pub const Ip6Protocol = @import("protocols/ip6_protocol.zig").Ip6Protocol;
+pub const Ip6ModeData = @import("protocols/ip6_protocol.zig").Ip6ModeData;
+pub const Ip6ConfigData = @import("protocols/ip6_protocol.zig").Ip6ConfigData;
+pub const Ip6Address = @import("protocols/ip6_protocol.zig").Ip6Address;
+pub const Ip6AddressInfo = @import("protocols/ip6_protocol.zig").Ip6AddressInfo;
+pub const Ip6RouteTable = @import("protocols/ip6_protocol.zig").Ip6RouteTable;
+pub const Ip6NeighborState = @import("protocols/ip6_protocol.zig").Ip6NeighborState;
+pub const Ip6NeighborCache = @import("protocols/ip6_protocol.zig").Ip6NeighborCache;
+pub const Ip6IcmpType = @import("protocols/ip6_protocol.zig").Ip6IcmpType;
+pub const Ip6CompletionToken = @import("protocols/ip6_protocol.zig").Ip6CompletionToken;
+
+pub const Ip6ConfigProtocol = @import("protocols/ip6_config_protocol.zig").Ip6ConfigProtocol;
+pub const Ip6ConfigDataType = @import("protocols/ip6_config_protocol.zig").Ip6ConfigDataType;
+
+pub const Udp6ServiceBindingProtocol = @import("protocols/udp6_service_binding_protocol.zig").Udp6ServiceBindingProtocol;
+pub const Udp6Protocol = @import("protocols/udp6_protocol.zig").Udp6Protocol;
+pub const Udp6ConfigData = @import("protocols/udp6_protocol.zig").Udp6ConfigData;
+pub const Udp6CompletionToken = @import("protocols/udp6_protocol.zig").Udp6CompletionToken;
+pub const Udp6ReceiveData = @import("protocols/udp6_protocol.zig").Udp6ReceiveData;
+pub const Udp6TransmitData = @import("protocols/udp6_protocol.zig").Udp6TransmitData;
+pub const Udp6SessionData = @import("protocols/udp6_protocol.zig").Udp6SessionData;
+pub const Udp6FragmentData = @import("protocols/udp6_protocol.zig").Udp6FragmentData;
+
pub const hii = @import("protocols/hii.zig");
pub const HIIDatabaseProtocol = @import("protocols/hii_database_protocol.zig").HIIDatabaseProtocol;
pub const HIIPopupProtocol = @import("protocols/hii_popup_protocol.zig").HIIPopupProtocol;