Skip to content

std.os.uefi.protocol.udp6

Standard libraryZig 0.17.0Official documentation
Sourcestd/os/uefi/protocol/udp6.zig

Source line 1

std.os.uefi.protocol.udp6.cc

alias

Source line 10

Alias of std.os.uefi.cc

std.os.uefi.protocol.udp6.Event

alias

Source line 4

Alias of std.os.uefi.Event

std.os.uefi.protocol.udp6.Guid

alias

Source line 3

Alias of std.os.uefi.Guid

std.os.uefi.protocol.udp6.Ip6

alias

Source line 7

Alias of std.os.uefi.protocol.Ip6

std.os.uefi.protocol.udp6.ManagedNetworkConfigData

alias

Source line 8

Alias of std.os.uefi.protocol.managed_network.ManagedNetwork.Config

std.os.uefi.protocol.udp6.SimpleNetwork

alias

Source line 9

Alias of std.os.uefi.protocol.SimpleNetwork

std.os.uefi.protocol.udp6.Status

alias

Source line 5

Alias of std.os.uefi.Status

std.os.uefi.protocol.udp6.std

alias

Source line 1

Alias of std

std.os.uefi.protocol.udp6.Time

alias

Source line 6

Alias of std.os.uefi.Time

std.os.uefi.protocol.udp6.Udp6

container

Source line 12

Fields

_get_mode_data: *const fn (*const Udp6, ?*Config, ?*Ip6.Mode, ?*ManagedNetworkConfigData, ?*SimpleNetwork) callconv(cc) Status
_configure: *const fn (*const Udp6, ?*const Config) callconv(cc) Status
_groups: *const fn (*const Udp6, bool, ?*const Ip6.Address) callconv(cc) Status
_transmit: *const fn (*const Udp6, *CompletionToken) callconv(cc) Status
_receive: *const fn (*const Udp6, *CompletionToken) callconv(cc) Status
_cancel: *const fn (*const Udp6, ?*CompletionToken) callconv(cc) Status
_poll: *const fn (*const Udp6) callconv(cc) Status

std.os.uefi.protocol.udp6.Udp6.cancel

function

Source line 155

pub fn cancel(self: *Udp6, token: ?*CompletionToken) CancelError!void

Parameters

self: *Udp6
token: ?*CompletionToken

Errors

InvalidParameter
NotFound
NotStarted
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.CancelError

error-set

Source line 62

Errors

InvalidParameter
NotFound
NotStarted
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.CompletionToken

container

Source line 210

Fields

event: Event
status: usize
packet: extern union {
    rx_data: *ReceiveData,
    tx_data: *TransmitData,
}

std.os.uefi.protocol.udp6.Udp6.Config

container

Source line 196

Fields

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: Ip6.Address
station_port: u16
remote_address: Ip6.Address
remote_port: u16

std.os.uefi.protocol.udp6.Udp6.configure

function

Source line 89

pub fn configure(self: *Udp6, udp6_config_data: ?*const Config) ConfigureError!void

Parameters

self: *Udp6
udp6_config_data: ?*const Config

Errors

AccessDenied
AlreadyStarted
DeviceError
InvalidParameter
NoMapping
OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.ConfigureError

error-set

Source line 25

Errors

AccessDenied
AlreadyStarted
DeviceError
InvalidParameter
NoMapping
OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.Fragment

container

Source line 248

Fields

fragment_length: u32
fragment_buffer: [*]u8

std.os.uefi.protocol.udp6.Udp6.getModeData

function

Source line 73

pub fn getModeData(self: *const Udp6) GetModeDataError!ModeData

Parameters

self: *const Udp6

Errors

InvalidParameter
NotStarted
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.GetModeDataError

error-set

Source line 21

Errors

InvalidParameter
NotStarted
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.groups

function

Source line 102

pub fn groups( self: *Udp6, join_flag: JoinFlag, multicast_address: ?*const Ip6.Address, ) GroupsError!void

Parameters

self: *Udp6
join_flag: JoinFlag
multicast_address: ?*const Ip6.Address

Errors

AlreadyStarted
DeviceError
InvalidParameter
NotFound
NotStarted
OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.GroupsError

error-set

Source line 33

Errors

AlreadyStarted
DeviceError
InvalidParameter
NotFound
NotStarted
OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.guid

constant

Source line 175

std.os.uefi.protocol.udp6.Udp6.JoinFlag

container

Source line 184

Fields

join
leave

std.os.uefi.protocol.udp6.Udp6.ModeData

container

Source line 189

Fields

udp6_config_data: Config
ip6_mode_data: Ip6.Mode
mnp_config_data: ManagedNetworkConfigData
snp_mode_data: SimpleNetwork

std.os.uefi.protocol.udp6.Udp6.poll

function

Source line 165

pub fn poll(self: *Udp6) PollError!void

Parameters

self: *Udp6

Errors

DeviceError
InvalidParameter
Timeout
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.PollError

error-set

Source line 67

Errors

DeviceError
InvalidParameter
Timeout
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.receive

function

Source line 140

pub fn receive(self: *Udp6, token: *CompletionToken) ReceiveError!void

Parameters

self: *Udp6
token: *CompletionToken

Errors

AccessDenied
DeviceError
InvalidParameter
NoMapping
NoMedia
NotReady
NotStarted
OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.ReceiveData

container

Source line 219

Fields

timestamp: Time
recycle_signal: Event
udp6_session: SessionData
data_length: u32
fragment_count: u32

std.os.uefi.protocol.udp6.Udp6.ReceiveData.getFragments

function

Source line 226

pub fn getFragments(self: *ReceiveData) []Fragment

Parameters

self: *ReceiveData

std.os.uefi.protocol.udp6.Udp6.ReceiveError

error-set

Source line 52

Errors

AccessDenied
DeviceError
InvalidParameter
NoMapping
NoMedia
NotReady
NotStarted
OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.SessionData

container

Source line 241

Fields

source_address: Ip6.Address
source_port: u16
destination_address: Ip6.Address
destination_port: u16

std.os.uefi.protocol.udp6.Udp6.transmit

function

Source line 124

pub fn transmit(self: *Udp6, token: *CompletionToken) TransmitError!void

Parameters

self: *Udp6
token: *CompletionToken

Errors

AccessDenied
BadBufferSize
InvalidParameter
NoMapping
NoMedia
NotFound
NotReady
NotStarted
OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.Udp6.TransmitData

container

Source line 231

Fields

udp6_session_data: ?*SessionData
data_length: u32
fragment_count: u32

std.os.uefi.protocol.udp6.Udp6.TransmitData.getFragments

function

Source line 236

pub fn getFragments(self: *TransmitData) []Fragment

Parameters

self: *TransmitData

std.os.uefi.protocol.udp6.Udp6.TransmitError

error-set

Source line 41

Errors

AccessDenied
BadBufferSize
InvalidParameter
NoMapping
NoMedia
NotFound
NotReady
NotStarted
OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.udp6.uefi

alias

Source line 2

Alias of std.os.uefi

Source code

std/os/uefi/protocol/udp6.zig

const std = @import("std");
const uefi = std.os.uefi;
const Guid = uefi.Guid;
const Event = uefi.Event;
const Status = uefi.Status;
const Time = uefi.Time;
const Ip6 = uefi.protocol.Ip6;
const ManagedNetworkConfigData = uefi.protocol.ManagedNetwork.Config;
const SimpleNetwork = uefi.protocol.SimpleNetwork;
const cc = uefi.cc;

pub const Udp6 = extern struct {
    _get_mode_data: *const fn (*const Udp6, ?*Config, ?*Ip6.Mode, ?*ManagedNetworkConfigData, ?*SimpleNetwork) callconv(cc) Status,
    _configure: *const fn (*const Udp6, ?*const Config) callconv(cc) Status,
    _groups: *const fn (*const Udp6, bool, ?*const Ip6.Address) callconv(cc) Status,
    _transmit: *const fn (*const Udp6, *CompletionToken) callconv(cc) Status,
    _receive: *const fn (*const Udp6, *CompletionToken) callconv(cc) Status,
    _cancel: *const fn (*const Udp6, ?*CompletionToken) callconv(cc) Status,
    _poll: *const fn (*const Udp6) callconv(cc) Status,

    pub const GetModeDataError = uefi.UnexpectedError || error{
        NotStarted,
        InvalidParameter,
    };
    pub const ConfigureError = uefi.UnexpectedError || error{
        NoMapping,
        InvalidParameter,
        AlreadyStarted,
        AccessDenied,
        OutOfResources,
        DeviceError,
    };
    pub const GroupsError = uefi.UnexpectedError || error{
        NotStarted,
        OutOfResources,
        InvalidParameter,
        AlreadyStarted,
        NotFound,
        DeviceError,
    };
    pub const TransmitError = uefi.UnexpectedError || error{
        NotStarted,
        NoMapping,
        InvalidParameter,
        AccessDenied,
        NotReady,
        OutOfResources,
        NotFound,
        BadBufferSize,
        NoMedia,
    };
    pub const ReceiveError = uefi.UnexpectedError || error{
        NotStarted,
        NoMapping,
        InvalidParameter,
        OutOfResources,
        DeviceError,
        AccessDenied,
        NotReady,
        NoMedia,
    };
    pub const CancelError = uefi.UnexpectedError || error{
        InvalidParameter,
        NotStarted,
        NotFound,
    };
    pub const PollError = uefi.UnexpectedError || error{
        InvalidParameter,
        DeviceError,
        Timeout,
    };

    pub fn getModeData(self: *const Udp6) GetModeDataError!ModeData {
        var data: ModeData = undefined;
        switch (self._get_mode_data(
            self,
            &data.udp6_config_data,
            &data.ip6_mode_data,
            &data.mnp_config_data,
            &data.snp_mode_data,
        )) {
            .success => return data,
            .not_started => return error.NotStarted,
            .invalid_parameter => return error.InvalidParameter,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    pub fn configure(self: *Udp6, udp6_config_data: ?*const Config) ConfigureError!void {
        switch (self._configure(self, udp6_config_data)) {
            .success => {},
            .no_mapping => return error.NoMapping,
            .invalid_parameter => return error.InvalidParameter,
            .already_started => return error.AlreadyStarted,
            .access_denied => return error.AccessDenied,
            .out_of_resources => return error.OutOfResources,
            .device_error => return error.DeviceError,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    pub fn groups(
        self: *Udp6,
        join_flag: JoinFlag,
        multicast_address: ?*const Ip6.Address,
    ) GroupsError!void {
        switch (self._groups(
            self,
            // set to TRUE to join a multicast group
            join_flag == .join,
            multicast_address,
        )) {
            .success => {},
            .not_started => return error.NotStarted,
            .out_of_resources => return error.OutOfResources,
            .invalid_parameter => return error.InvalidParameter,
            .already_started => return error.AlreadyStarted,
            .not_found => return error.NotFound,
            .device_error => return error.DeviceError,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    pub fn transmit(self: *Udp6, token: *CompletionToken) TransmitError!void {
        switch (self._transmit(self, token)) {
            .success => {},
            .not_started => return error.NotStarted,
            .no_mapping => return error.NoMapping,
            .invalid_parameter => return error.InvalidParameter,
            .access_denied => return error.AccessDenied,
            .not_ready => return error.NotReady,
            .out_of_resources => return error.OutOfResources,
            .not_found => return error.NotFound,
            .bad_buffer_size => return error.BadBufferSize,
            .no_media => return error.NoMedia,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    pub fn receive(self: *Udp6, token: *CompletionToken) ReceiveError!void {
        switch (self._receive(self, token)) {
            .success => {},
            .not_started => return error.NotStarted,
            .no_mapping => return error.NoMapping,
            .invalid_parameter => return error.InvalidParameter,
            .out_of_resources => return error.OutOfResources,
            .device_error => return error.DeviceError,
            .access_denied => return error.AccessDenied,
            .not_ready => return error.NotReady,
            .no_media => return error.NoMedia,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    pub fn cancel(self: *Udp6, token: ?*CompletionToken) CancelError!void {
        switch (self._cancel(self, token)) {
            .success => {},
            .invalid_parameter => return error.InvalidParameter,
            .not_started => return error.NotStarted,
            .not_found => return error.NotFound,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    pub fn poll(self: *Udp6) PollError!void {
        switch (self._poll(self)) {
            .success => {},
            .invalid_parameter => return error.InvalidParameter,
            .device_error => return error.DeviceError,
            .timeout => return error.Timeout,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    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 JoinFlag = enum {
        join,
        leave,
    };

    pub const ModeData = struct {
        udp6_config_data: Config,
        ip6_mode_data: Ip6.Mode,
        mnp_config_data: ManagedNetworkConfigData,
        snp_mode_data: SimpleNetwork,
    };

    pub const Config = 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: Ip6.Address,
        station_port: u16,
        remote_address: Ip6.Address,
        remote_port: u16,
    };

    pub const CompletionToken = extern struct {
        event: Event,
        status: usize,
        packet: extern union {
            rx_data: *ReceiveData,
            tx_data: *TransmitData,
        },
    };

    pub const ReceiveData = extern struct {
        timestamp: Time,
        recycle_signal: Event,
        udp6_session: SessionData,
        data_length: u32,
        fragment_count: u32,

        pub fn getFragments(self: *ReceiveData) []Fragment {
            return @as([*]Fragment, @ptrCast(@alignCast(@as([*]u8, @ptrCast(self)) + @sizeOf(ReceiveData))))[0..self.fragment_count];
        }
    };

    pub const TransmitData = extern struct {
        udp6_session_data: ?*SessionData,
        data_length: u32,
        fragment_count: u32,

        pub fn getFragments(self: *TransmitData) []Fragment {
            return @as([*]Fragment, @ptrCast(@alignCast(@as([*]u8, @ptrCast(self)) + @sizeOf(TransmitData))))[0..self.fragment_count];
        }
    };

    pub const SessionData = extern struct {
        source_address: Ip6.Address,
        source_port: u16,
        destination_address: Ip6.Address,
        destination_port: u16,
    };

    pub const Fragment = extern struct {
        fragment_length: u32,
        fragment_buffer: [*]u8,
    };
};