| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // Code generated by third_party/go/regen-fidl; DO NOT EDIT. |
| |
| // WARNING: This file is machine generated by fidlgen. |
| |
| package socket |
| |
| import ( |
| _strings "strings" |
| _zx "syscall/zx" |
| _bindings "syscall/zx/fidl" |
| fuchsianet "syscall/zx/net" |
| fuchsiaposix "syscall/zx/posix" |
| fuchsiaunknown "syscall/zx/unknown" |
| ) |
| |
| const ( |
| DatagramSocketProtocolName_ string = "fuchsia.posix.socket/DatagramSocket" |
| // Constant bounding the number of eventpairs returned by Netstack to clients |
| // of the fast protocol. |
| // |
| // Set equal to `ZX_WAIT_MANY_MAXIMUM_ITEMS` - 1, where `ZX_WAIT_MANY_MAXIMUM_ITEMS` |
| // is defined in `//zircon/system/public/zircon/types.h` and bounds the number of eventpairs |
| // in a single call to `zx_object_wait_many`. The bias leaves room to allow clients to wait |
| // for errors on the zircon socket in the same call. |
| FastUdpWaitManyMaximumItems uint32 = 63 |
| SignalDatagramError uint32 = UserSignal2 |
| SignalDatagramIncoming uint32 = UserSignal0 |
| SignalDatagramOutgoing uint32 = UserSignal1 |
| SignalDatagramShutdownRead uint32 = UserSignal4 |
| SignalDatagramShutdownWrite uint32 = UserSignal5 |
| SignalStreamConnected uint32 = UserSignal3 |
| SignalStreamIncoming uint32 = UserSignal0 |
| StreamSocketProtocolName_ string = "fuchsia.posix.socket/StreamSocket" |
| SynchronousDatagramSocketProtocolName_ string = "fuchsia.posix.socket/SynchronousDatagramSocket" |
| UserSignal0 uint32 = 16777216 |
| UserSignal1 uint32 = 33554432 |
| UserSignal2 uint32 = 67108864 |
| UserSignal3 uint32 = 134217728 |
| UserSignal4 uint32 = 268435456 |
| UserSignal5 uint32 = 536870912 |
| ) |
| |
| var _ _bindings.Enum = DatagramSocketProtocol(0) |
| |
| // Protocols supported by [`fuchsia.posix.socket/DatagramSocket`]. |
| // |
| // `DatagramSocketProtocol` enumerates the protocols supported by the network |
| // stack over datagram sockets. |
| type DatagramSocketProtocol uint32 |
| |
| const ( |
| |
| // UDP (User Datagram Protocol). |
| // |
| // A UDP socket is equivalent to the POSIX API of `SOCK_DGRAM` with a |
| // protocol of 0 or `IPPROTO_UDP`. |
| DatagramSocketProtocolUdp DatagramSocketProtocol = 1 |
| |
| // ICMP (Internet Control Message Protocol) echo. |
| // |
| // An ICMP echo socket is equivalent to the POSIX API of `SOCK_DGRAM` with |
| // a protocol of `IPPROTO_ICMP` `IPPROTO_ICMPV6` (depending on provided |
| // domain). |
| // |
| // Datagrams sent over an ICMP echo socket *must* have a valid ICMP or |
| // ICMPv6 echo header. |
| DatagramSocketProtocolIcmpEcho DatagramSocketProtocol = 2 |
| ) |
| |
| func (_ DatagramSocketProtocol) I_EnumValues() []DatagramSocketProtocol { |
| return []DatagramSocketProtocol{ |
| DatagramSocketProtocolUdp, |
| DatagramSocketProtocolIcmpEcho, |
| } |
| } |
| |
| func (_ DatagramSocketProtocol) I_EnumIsStrict() bool { |
| return true |
| } |
| |
| func (x DatagramSocketProtocol) IsUnknown() bool { |
| switch x { |
| case 1: |
| return false |
| case 2: |
| return false |
| } |
| return true |
| } |
| |
| func (x DatagramSocketProtocol) String() string { |
| switch x { |
| case 1: |
| return "Udp" |
| case 2: |
| return "IcmpEcho" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Enum = Domain(0) |
| |
| // A socket's domain. |
| // |
| // Determines the addressing domain for a socket. |
| type Domain int16 |
| |
| const ( |
| |
| // An IPv4 socket. Equivalent to `AF_INET`. |
| DomainIpv4 Domain = 0 |
| |
| // An IPv6 socket. Equivalent to `AF_INET6`. |
| DomainIpv6 Domain = 1 |
| ) |
| |
| func (_ Domain) I_EnumValues() []Domain { |
| return []Domain{ |
| DomainIpv4, |
| DomainIpv6, |
| } |
| } |
| |
| func (_ Domain) I_EnumIsStrict() bool { |
| return true |
| } |
| |
| func (x Domain) IsUnknown() bool { |
| switch x { |
| case 0: |
| return false |
| case 1: |
| return false |
| } |
| return true |
| } |
| |
| func (x Domain) String() string { |
| switch x { |
| case 0: |
| return "Ipv4" |
| case 1: |
| return "Ipv6" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Enum = StreamSocketProtocol(0) |
| |
| // Protocols supported by [`fuchsia.posix.socket/StreamSocket`]. |
| // |
| // `StreamSocketProtocol` enumerates the protocols supported by the network |
| // stack over stream sockets. |
| type StreamSocketProtocol uint32 |
| |
| const ( |
| |
| // TCP (Transmission Control Protocol). |
| // |
| // A TCP socket is equivalent to the POSIX API of `SOCK_STREAM` with a |
| // protocol of 0 or `IPPROTO_TCP`. |
| StreamSocketProtocolTcp StreamSocketProtocol = 0 |
| ) |
| |
| func (_ StreamSocketProtocol) I_EnumValues() []StreamSocketProtocol { |
| return []StreamSocketProtocol{ |
| StreamSocketProtocolTcp, |
| } |
| } |
| |
| func (_ StreamSocketProtocol) I_EnumIsStrict() bool { |
| return true |
| } |
| |
| func (x StreamSocketProtocol) IsUnknown() bool { |
| switch x { |
| case 0: |
| return false |
| } |
| return true |
| } |
| |
| func (x StreamSocketProtocol) String() string { |
| switch x { |
| case 0: |
| return "Tcp" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Enum = TcpCongestionControl(0) |
| |
| // TCP congestion control modes. |
| type TcpCongestionControl uint32 |
| |
| const ( |
| TcpCongestionControlReno TcpCongestionControl = 1 |
| TcpCongestionControlCubic TcpCongestionControl = 2 |
| ) |
| |
| func (_ TcpCongestionControl) I_EnumValues() []TcpCongestionControl { |
| return []TcpCongestionControl{ |
| TcpCongestionControlReno, |
| TcpCongestionControlCubic, |
| } |
| } |
| |
| func (_ TcpCongestionControl) I_EnumIsStrict() bool { |
| return true |
| } |
| |
| func (x TcpCongestionControl) IsUnknown() bool { |
| switch x { |
| case 1: |
| return false |
| case 2: |
| return false |
| } |
| return true |
| } |
| |
| func (x TcpCongestionControl) String() string { |
| switch x { |
| case 1: |
| return "Reno" |
| case 2: |
| return "Cubic" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Enum = TcpCongestionControlState(0) |
| |
| // TCP congestion control state machine state. |
| type TcpCongestionControlState uint32 |
| |
| const ( |
| TcpCongestionControlStateOpen TcpCongestionControlState = 0 |
| TcpCongestionControlStateDisorder TcpCongestionControlState = 1 |
| TcpCongestionControlStateCongestionWindowReduced TcpCongestionControlState = 2 |
| TcpCongestionControlStateRecovery TcpCongestionControlState = 3 |
| TcpCongestionControlStateLoss TcpCongestionControlState = 4 |
| ) |
| |
| func (_ TcpCongestionControlState) I_EnumValues() []TcpCongestionControlState { |
| return []TcpCongestionControlState{ |
| TcpCongestionControlStateOpen, |
| TcpCongestionControlStateDisorder, |
| TcpCongestionControlStateCongestionWindowReduced, |
| TcpCongestionControlStateRecovery, |
| TcpCongestionControlStateLoss, |
| } |
| } |
| |
| func (_ TcpCongestionControlState) I_EnumIsStrict() bool { |
| return true |
| } |
| |
| func (x TcpCongestionControlState) IsUnknown() bool { |
| switch x { |
| case 0: |
| return false |
| case 1: |
| return false |
| case 2: |
| return false |
| case 3: |
| return false |
| case 4: |
| return false |
| } |
| return true |
| } |
| |
| func (x TcpCongestionControlState) String() string { |
| switch x { |
| case 0: |
| return "Open" |
| case 1: |
| return "Disorder" |
| case 2: |
| return "CongestionWindowReduced" |
| case 3: |
| return "Recovery" |
| case 4: |
| return "Loss" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Enum = TcpState(0) |
| |
| // TCP state machine state. |
| type TcpState uint32 |
| |
| const ( |
| TcpStateEstablished TcpState = 1 |
| TcpStateSynSent TcpState = 2 |
| TcpStateSynRecv TcpState = 3 |
| TcpStateFinWait1 TcpState = 4 |
| TcpStateFinWait2 TcpState = 5 |
| TcpStateTimeWait TcpState = 6 |
| TcpStateClose TcpState = 7 |
| TcpStateCloseWait TcpState = 8 |
| TcpStateLastAck TcpState = 9 |
| TcpStateListen TcpState = 10 |
| TcpStateClosing TcpState = 11 |
| ) |
| |
| func (_ TcpState) I_EnumValues() []TcpState { |
| return []TcpState{ |
| TcpStateEstablished, |
| TcpStateSynSent, |
| TcpStateSynRecv, |
| TcpStateFinWait1, |
| TcpStateFinWait2, |
| TcpStateTimeWait, |
| TcpStateClose, |
| TcpStateCloseWait, |
| TcpStateLastAck, |
| TcpStateListen, |
| TcpStateClosing, |
| } |
| } |
| |
| func (_ TcpState) I_EnumIsStrict() bool { |
| return true |
| } |
| |
| func (x TcpState) IsUnknown() bool { |
| switch x { |
| case 1: |
| return false |
| case 2: |
| return false |
| case 3: |
| return false |
| case 4: |
| return false |
| case 5: |
| return false |
| case 6: |
| return false |
| case 7: |
| return false |
| case 8: |
| return false |
| case 9: |
| return false |
| case 10: |
| return false |
| case 11: |
| return false |
| } |
| return true |
| } |
| |
| func (x TcpState) String() string { |
| switch x { |
| case 1: |
| return "Established" |
| case 2: |
| return "SynSent" |
| case 3: |
| return "SynRecv" |
| case 4: |
| return "FinWait1" |
| case 5: |
| return "FinWait2" |
| case 6: |
| return "TimeWait" |
| case 7: |
| return "Close" |
| case 8: |
| return "CloseWait" |
| case 9: |
| return "LastAck" |
| case 10: |
| return "Listen" |
| case 11: |
| return "Closing" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Enum = TimestampOption(0) |
| |
| // Packet timestamp reporting precision options. |
| type TimestampOption uint32 |
| |
| const ( |
| |
| // Do not report timestamp. |
| TimestampOptionDisabled TimestampOption = 0 |
| |
| // Report timestamp with nanosecond precision. |
| TimestampOptionNanosecond TimestampOption = 1 |
| |
| // Report timestamp with microsecond precision. |
| TimestampOptionMicrosecond TimestampOption = 2 |
| ) |
| |
| func (_ TimestampOption) I_EnumValues() []TimestampOption { |
| return []TimestampOption{ |
| TimestampOptionDisabled, |
| TimestampOptionNanosecond, |
| TimestampOptionMicrosecond, |
| } |
| } |
| |
| func (_ TimestampOption) I_EnumIsStrict() bool { |
| return true |
| } |
| |
| func (x TimestampOption) IsUnknown() bool { |
| switch x { |
| case 0: |
| return false |
| case 1: |
| return false |
| case 2: |
| return false |
| } |
| return true |
| } |
| |
| func (x TimestampOption) String() string { |
| switch x { |
| case 0: |
| return "Disabled" |
| case 1: |
| return "Nanosecond" |
| case 2: |
| return "Microsecond" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Enum = UdpMetadataEncodingProtocolVersion(0) |
| |
| type UdpMetadataEncodingProtocolVersion uint16 |
| |
| const ( |
| UdpMetadataEncodingProtocolVersionZero UdpMetadataEncodingProtocolVersion = 0 |
| |
| // UdpMetadataEncodingProtocolVersion_Unknown is the default unknown placeholder. |
| UdpMetadataEncodingProtocolVersion_Unknown UdpMetadataEncodingProtocolVersion = 0xffff |
| ) |
| |
| func (_ UdpMetadataEncodingProtocolVersion) I_EnumValues() []UdpMetadataEncodingProtocolVersion { |
| return []UdpMetadataEncodingProtocolVersion{ |
| UdpMetadataEncodingProtocolVersionZero, |
| } |
| } |
| |
| func (_ UdpMetadataEncodingProtocolVersion) I_EnumIsStrict() bool { |
| return false |
| } |
| |
| func (x UdpMetadataEncodingProtocolVersion) IsUnknown() bool { |
| switch x { |
| case 0: |
| return false |
| } |
| return true |
| } |
| |
| func (x UdpMetadataEncodingProtocolVersion) String() string { |
| switch x { |
| case 0: |
| return "Zero" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Bits = CmsgRequests(0) |
| |
| type CmsgRequests uint32 |
| |
| const ( |
| CmsgRequestsIpTos CmsgRequests = 1 |
| CmsgRequestsIpTtl CmsgRequests = 2 |
| CmsgRequestsIpv6Tclass CmsgRequests = 4 |
| CmsgRequestsIpv6Hoplimit CmsgRequests = 8 |
| CmsgRequestsIpv6Pktinfo CmsgRequests = 16 |
| CmsgRequestsIpRecvorigdstaddr CmsgRequests = 32 |
| CmsgRequests_Mask CmsgRequests = 63 |
| ) |
| |
| func (_ CmsgRequests) I_BitsMask() CmsgRequests { |
| return CmsgRequests_Mask |
| } |
| |
| func (_ CmsgRequests) I_BitsIsStrict() bool { |
| return false |
| } |
| |
| func (x CmsgRequests) HasUnknownBits() bool { |
| return x.GetUnknownBits() != 0 |
| } |
| |
| func (x CmsgRequests) GetUnknownBits() uint64 { |
| return uint64(^CmsgRequests_Mask & x) |
| } |
| |
| func (x CmsgRequests) InvertBits() CmsgRequests { |
| return CmsgRequests_Mask & ^x |
| } |
| |
| // HasBits validates that all flipped bits in the mask are set. |
| func (x CmsgRequests) HasBits(mask CmsgRequests) bool { |
| return mask|x == x |
| } |
| |
| // ClearBits ensures all flipped bits in the mask are unset. |
| func (x CmsgRequests) ClearBits(mask CmsgRequests) CmsgRequests { |
| return ^mask & x |
| } |
| |
| func (x CmsgRequests) String() string { |
| var buf _strings.Builder |
| if 1&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("IpTos") |
| } |
| if 2&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("IpTtl") |
| } |
| if 4&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Ipv6Tclass") |
| } |
| if 8&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Ipv6Hoplimit") |
| } |
| if 16&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Ipv6Pktinfo") |
| } |
| if 32&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("IpRecvorigdstaddr") |
| } |
| if buf.Len() == 0 { |
| buf.WriteString("<empty bits>") |
| } |
| return buf.String() |
| } |
| |
| var _ _bindings.Bits = InterfaceFlags(0) |
| |
| // Bits representing the interface flags as returned by the SIOCGIFFLAGS ioctl |
| // operation. These bitmasks are intended to track the C API definition. For |
| // example, `InterfaceFlags.UP` corresponds to `IFF_UP`, etc. |
| type InterfaceFlags uint16 |
| |
| const ( |
| InterfaceFlagsUp InterfaceFlags = 1 |
| InterfaceFlagsBroadcast InterfaceFlags = 2 |
| InterfaceFlagsDebug InterfaceFlags = 4 |
| InterfaceFlagsLoopback InterfaceFlags = 8 |
| InterfaceFlagsPointtopoint InterfaceFlags = 16 |
| InterfaceFlagsNotrailers InterfaceFlags = 32 |
| InterfaceFlagsRunning InterfaceFlags = 64 |
| InterfaceFlagsNoarp InterfaceFlags = 128 |
| InterfaceFlagsPromisc InterfaceFlags = 256 |
| InterfaceFlagsAllmulti InterfaceFlags = 512 |
| InterfaceFlagsLeader InterfaceFlags = 1024 |
| InterfaceFlagsFollower InterfaceFlags = 2048 |
| InterfaceFlagsMulticast InterfaceFlags = 4096 |
| InterfaceFlagsPortsel InterfaceFlags = 8192 |
| InterfaceFlagsAutomedia InterfaceFlags = 16384 |
| InterfaceFlagsDynamic InterfaceFlags = 32768 |
| InterfaceFlags_Mask InterfaceFlags = 65535 |
| ) |
| |
| func (_ InterfaceFlags) I_BitsMask() InterfaceFlags { |
| return InterfaceFlags_Mask |
| } |
| |
| func (_ InterfaceFlags) I_BitsIsStrict() bool { |
| return true |
| } |
| |
| func (x InterfaceFlags) HasUnknownBits() bool { |
| return x.GetUnknownBits() != 0 |
| } |
| |
| func (x InterfaceFlags) GetUnknownBits() uint64 { |
| return uint64(^InterfaceFlags_Mask & x) |
| } |
| |
| func (x InterfaceFlags) InvertBits() InterfaceFlags { |
| return InterfaceFlags_Mask & ^x |
| } |
| |
| // HasBits validates that all flipped bits in the mask are set. |
| func (x InterfaceFlags) HasBits(mask InterfaceFlags) bool { |
| return mask|x == x |
| } |
| |
| // ClearBits ensures all flipped bits in the mask are unset. |
| func (x InterfaceFlags) ClearBits(mask InterfaceFlags) InterfaceFlags { |
| return ^mask & x |
| } |
| |
| func (x InterfaceFlags) String() string { |
| var buf _strings.Builder |
| if 1&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Up") |
| } |
| if 2&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Broadcast") |
| } |
| if 4&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Debug") |
| } |
| if 8&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Loopback") |
| } |
| if 16&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Pointtopoint") |
| } |
| if 32&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Notrailers") |
| } |
| if 64&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Running") |
| } |
| if 128&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Noarp") |
| } |
| if 256&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Promisc") |
| } |
| if 512&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Allmulti") |
| } |
| if 1024&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Leader") |
| } |
| if 2048&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Follower") |
| } |
| if 4096&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Multicast") |
| } |
| if 8192&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Portsel") |
| } |
| if 16384&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Automedia") |
| } |
| if 32768&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Dynamic") |
| } |
| if buf.Len() == 0 { |
| buf.WriteString("<empty bits>") |
| } |
| return buf.String() |
| } |
| |
| var _ _bindings.Bits = RecvMsgFlags(0) |
| |
| // Flags controlling RecvMsg behavior. |
| type RecvMsgFlags uint16 |
| |
| const ( |
| RecvMsgFlagsPeek RecvMsgFlags = 2 |
| RecvMsgFlags_Mask RecvMsgFlags = 2 |
| ) |
| |
| func (_ RecvMsgFlags) I_BitsMask() RecvMsgFlags { |
| return RecvMsgFlags_Mask |
| } |
| |
| func (_ RecvMsgFlags) I_BitsIsStrict() bool { |
| return true |
| } |
| |
| func (x RecvMsgFlags) HasUnknownBits() bool { |
| return x.GetUnknownBits() != 0 |
| } |
| |
| func (x RecvMsgFlags) GetUnknownBits() uint64 { |
| return uint64(^RecvMsgFlags_Mask & x) |
| } |
| |
| func (x RecvMsgFlags) InvertBits() RecvMsgFlags { |
| return RecvMsgFlags_Mask & ^x |
| } |
| |
| // HasBits validates that all flipped bits in the mask are set. |
| func (x RecvMsgFlags) HasBits(mask RecvMsgFlags) bool { |
| return mask|x == x |
| } |
| |
| // ClearBits ensures all flipped bits in the mask are unset. |
| func (x RecvMsgFlags) ClearBits(mask RecvMsgFlags) RecvMsgFlags { |
| return ^mask & x |
| } |
| |
| func (x RecvMsgFlags) String() string { |
| var buf _strings.Builder |
| if 2&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Peek") |
| } |
| if buf.Len() == 0 { |
| buf.WriteString("<empty bits>") |
| } |
| return buf.String() |
| } |
| |
| var _ _bindings.Bits = SendMsgFlags(0) |
| |
| type SendMsgFlags uint16 |
| |
| const ( |
| SendMsgFlagsReserved SendMsgFlags = 32768 |
| SendMsgFlags_Mask SendMsgFlags = 32768 |
| ) |
| |
| func (_ SendMsgFlags) I_BitsMask() SendMsgFlags { |
| return SendMsgFlags_Mask |
| } |
| |
| func (_ SendMsgFlags) I_BitsIsStrict() bool { |
| return true |
| } |
| |
| func (x SendMsgFlags) HasUnknownBits() bool { |
| return x.GetUnknownBits() != 0 |
| } |
| |
| func (x SendMsgFlags) GetUnknownBits() uint64 { |
| return uint64(^SendMsgFlags_Mask & x) |
| } |
| |
| func (x SendMsgFlags) InvertBits() SendMsgFlags { |
| return SendMsgFlags_Mask & ^x |
| } |
| |
| // HasBits validates that all flipped bits in the mask are set. |
| func (x SendMsgFlags) HasBits(mask SendMsgFlags) bool { |
| return mask|x == x |
| } |
| |
| // ClearBits ensures all flipped bits in the mask are unset. |
| func (x SendMsgFlags) ClearBits(mask SendMsgFlags) SendMsgFlags { |
| return ^mask & x |
| } |
| |
| func (x SendMsgFlags) String() string { |
| var buf _strings.Builder |
| if 32768&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Reserved") |
| } |
| if buf.Len() == 0 { |
| buf.WriteString("<empty bits>") |
| } |
| return buf.String() |
| } |
| |
| var _ _bindings.Bits = ShutdownMode(0) |
| |
| // Socket shutdown mode. |
| type ShutdownMode uint16 |
| |
| const ( |
| ShutdownModeRead ShutdownMode = 1 |
| ShutdownModeWrite ShutdownMode = 2 |
| ShutdownMode_Mask ShutdownMode = 3 |
| ) |
| |
| func (_ ShutdownMode) I_BitsMask() ShutdownMode { |
| return ShutdownMode_Mask |
| } |
| |
| func (_ ShutdownMode) I_BitsIsStrict() bool { |
| return true |
| } |
| |
| func (x ShutdownMode) HasUnknownBits() bool { |
| return x.GetUnknownBits() != 0 |
| } |
| |
| func (x ShutdownMode) GetUnknownBits() uint64 { |
| return uint64(^ShutdownMode_Mask & x) |
| } |
| |
| func (x ShutdownMode) InvertBits() ShutdownMode { |
| return ShutdownMode_Mask & ^x |
| } |
| |
| // HasBits validates that all flipped bits in the mask are set. |
| func (x ShutdownMode) HasBits(mask ShutdownMode) bool { |
| return mask|x == x |
| } |
| |
| // ClearBits ensures all flipped bits in the mask are unset. |
| func (x ShutdownMode) ClearBits(mask ShutdownMode) ShutdownMode { |
| return ^mask & x |
| } |
| |
| func (x ShutdownMode) String() string { |
| var buf _strings.Builder |
| if 1&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Read") |
| } |
| if 2&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Write") |
| } |
| if buf.Len() == 0 { |
| buf.WriteString("<empty bits>") |
| } |
| return buf.String() |
| } |
| |
| type BaseDatagramSocketGetInfoResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| Domain Domain `fidl_offset_v2:"0"` |
| Proto DatagramSocketProtocol `fidl_offset_v2:"4"` |
| } |
| |
| var _mBaseDatagramSocketGetInfoResponse = _bindings.CreateLazyMarshaler(BaseDatagramSocketGetInfoResponse{}) |
| |
| func (msg *BaseDatagramSocketGetInfoResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseDatagramSocketGetInfoResponse |
| } |
| |
| type BaseNetworkSocketAddIpMembershipRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Membership IpMulticastMembership `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketAddIpMembershipRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketAddIpMembershipRequest{}) |
| |
| func (msg *BaseNetworkSocketAddIpMembershipRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketAddIpMembershipRequest |
| } |
| |
| type BaseNetworkSocketAddIpv6MembershipRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"` |
| Membership Ipv6MulticastMembership `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketAddIpv6MembershipRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketAddIpv6MembershipRequest{}) |
| |
| func (msg *BaseNetworkSocketAddIpv6MembershipRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketAddIpv6MembershipRequest |
| } |
| |
| type BaseNetworkSocketBindRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Addr fuchsianet.SocketAddress `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketBindRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketBindRequest{}) |
| |
| func (msg *BaseNetworkSocketBindRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketBindRequest |
| } |
| |
| type BaseNetworkSocketConnectRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Addr fuchsianet.SocketAddress `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketConnectRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketConnectRequest{}) |
| |
| func (msg *BaseNetworkSocketConnectRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketConnectRequest |
| } |
| |
| type BaseNetworkSocketDropIpMembershipRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Membership IpMulticastMembership `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketDropIpMembershipRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketDropIpMembershipRequest{}) |
| |
| func (msg *BaseNetworkSocketDropIpMembershipRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketDropIpMembershipRequest |
| } |
| |
| type BaseNetworkSocketDropIpv6MembershipRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"` |
| Membership Ipv6MulticastMembership `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketDropIpv6MembershipRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketDropIpv6MembershipRequest{}) |
| |
| func (msg *BaseNetworkSocketDropIpv6MembershipRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketDropIpv6MembershipRequest |
| } |
| |
| type BaseNetworkSocketSetIpMulticastInterfaceRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Iface uint64 `fidl_offset_v2:"0"` |
| Address fuchsianet.Ipv4Address `fidl_offset_v2:"8"` |
| } |
| |
| var _mBaseNetworkSocketSetIpMulticastInterfaceRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastInterfaceRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpMulticastInterfaceRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpMulticastInterfaceRequest |
| } |
| |
| type BaseNetworkSocketSetIpMulticastLoopbackRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpMulticastLoopbackRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastLoopbackRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpMulticastLoopbackRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpMulticastLoopbackRequest |
| } |
| |
| type BaseNetworkSocketSetIpMulticastTtlRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Value OptionalUint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpMulticastTtlRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastTtlRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpMulticastTtlRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpMulticastTtlRequest |
| } |
| |
| type BaseNetworkSocketSetIpPacketInfoRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpPacketInfoRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpPacketInfoRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpPacketInfoRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpPacketInfoRequest |
| } |
| |
| type BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest |
| } |
| |
| type BaseNetworkSocketSetIpReceiveTtlRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpReceiveTtlRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveTtlRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpReceiveTtlRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpReceiveTtlRequest |
| } |
| |
| type BaseNetworkSocketSetIpReceiveTypeOfServiceRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpReceiveTypeOfServiceRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpReceiveTypeOfServiceRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpReceiveTypeOfServiceRequest |
| } |
| |
| type BaseNetworkSocketSetIpTransparentRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpTransparentRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTransparentRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpTransparentRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpTransparentRequest |
| } |
| |
| type BaseNetworkSocketSetIpTtlRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Value OptionalUint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpTtlRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTtlRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpTtlRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpTtlRequest |
| } |
| |
| type BaseNetworkSocketSetIpTypeOfServiceRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value uint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpTypeOfServiceRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTypeOfServiceRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpTypeOfServiceRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpTypeOfServiceRequest |
| } |
| |
| type BaseNetworkSocketSetIpv6MulticastHopsRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Value OptionalUint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6MulticastHopsRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastHopsRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6MulticastHopsRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6MulticastHopsRequest |
| } |
| |
| type BaseNetworkSocketSetIpv6MulticastInterfaceRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"` |
| Value uint64 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6MulticastInterfaceRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastInterfaceRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6MulticastInterfaceRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6MulticastInterfaceRequest |
| } |
| |
| type BaseNetworkSocketSetIpv6MulticastLoopbackRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6MulticastLoopbackRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastLoopbackRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6MulticastLoopbackRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6MulticastLoopbackRequest |
| } |
| |
| type BaseNetworkSocketSetIpv6OnlyRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6OnlyRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6OnlyRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6OnlyRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6OnlyRequest |
| } |
| |
| type BaseNetworkSocketSetIpv6ReceiveHopLimitRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6ReceiveHopLimitRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6ReceiveHopLimitRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6ReceiveHopLimitRequest |
| } |
| |
| type BaseNetworkSocketSetIpv6ReceivePacketInfoRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6ReceivePacketInfoRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6ReceivePacketInfoRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6ReceivePacketInfoRequest |
| } |
| |
| type BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6ReceiveTrafficClassRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6ReceiveTrafficClassRequest |
| } |
| |
| type BaseNetworkSocketSetIpv6TrafficClassRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Value OptionalUint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6TrafficClassRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6TrafficClassRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6TrafficClassRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6TrafficClassRequest |
| } |
| |
| type BaseNetworkSocketSetIpv6UnicastHopsRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Value OptionalUint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6UnicastHopsRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6UnicastHopsRequest{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6UnicastHopsRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6UnicastHopsRequest |
| } |
| |
| type BaseNetworkSocketShutdownRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"2" fidl_alignment_v2:"2"` |
| Mode ShutdownMode `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketShutdownRequest = _bindings.CreateLazyMarshaler(BaseNetworkSocketShutdownRequest{}) |
| |
| func (msg *BaseNetworkSocketShutdownRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketShutdownRequest |
| } |
| |
| type BaseNetworkSocketAddIpMembershipResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketAddIpMembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketAddIpMembershipResponse{}) |
| |
| func (msg *BaseNetworkSocketAddIpMembershipResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketAddIpMembershipResponse |
| } |
| |
| type BaseNetworkSocketAddIpv6MembershipResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketAddIpv6MembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketAddIpv6MembershipResponse{}) |
| |
| func (msg *BaseNetworkSocketAddIpv6MembershipResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketAddIpv6MembershipResponse |
| } |
| |
| type BaseNetworkSocketBindResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketBindResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketBindResponse{}) |
| |
| func (msg *BaseNetworkSocketBindResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketBindResponse |
| } |
| |
| type BaseNetworkSocketConnectResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketConnectResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketConnectResponse{}) |
| |
| func (msg *BaseNetworkSocketConnectResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketConnectResponse |
| } |
| |
| type BaseNetworkSocketDisconnectResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketDisconnectResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketDisconnectResponse{}) |
| |
| func (msg *BaseNetworkSocketDisconnectResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketDisconnectResponse |
| } |
| |
| type BaseNetworkSocketDropIpMembershipResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketDropIpMembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketDropIpMembershipResponse{}) |
| |
| func (msg *BaseNetworkSocketDropIpMembershipResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketDropIpMembershipResponse |
| } |
| |
| type BaseNetworkSocketDropIpv6MembershipResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketDropIpv6MembershipResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketDropIpv6MembershipResponse{}) |
| |
| func (msg *BaseNetworkSocketDropIpv6MembershipResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketDropIpv6MembershipResponse |
| } |
| |
| type BaseNetworkSocketGetIpMulticastInterfaceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"1"` |
| Value fuchsianet.Ipv4Address `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpMulticastInterfaceResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpMulticastInterfaceResponse |
| } |
| |
| type BaseNetworkSocketGetIpMulticastLoopbackResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpMulticastLoopbackResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpMulticastLoopbackResponse |
| } |
| |
| type BaseNetworkSocketGetIpMulticastTtlResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value uint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpMulticastTtlResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpMulticastTtlResponse |
| } |
| |
| type BaseNetworkSocketGetIpPacketInfoResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpPacketInfoResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpPacketInfoResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpPacketInfoResponse |
| } |
| |
| type BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse |
| } |
| |
| type BaseNetworkSocketGetIpReceiveTtlResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpReceiveTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpReceiveTtlResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpReceiveTtlResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpReceiveTtlResponse |
| } |
| |
| type BaseNetworkSocketGetIpReceiveTypeOfServiceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpReceiveTypeOfServiceResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpReceiveTypeOfServiceResponse |
| } |
| |
| type BaseNetworkSocketGetIpTransparentResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpTransparentResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpTransparentResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpTransparentResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpTransparentResponse |
| } |
| |
| type BaseNetworkSocketGetIpTtlResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value uint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpTtlResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpTtlResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpTtlResponse |
| } |
| |
| type BaseNetworkSocketGetIpTypeOfServiceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value uint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpTypeOfServiceResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpTypeOfServiceResponse |
| } |
| |
| type BaseNetworkSocketGetIpv6MulticastHopsResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value uint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6MulticastHopsResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6MulticastHopsResponse |
| } |
| |
| type BaseNetworkSocketGetIpv6MulticastInterfaceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"` |
| Value uint64 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6MulticastInterfaceResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6MulticastInterfaceResponse |
| } |
| |
| type BaseNetworkSocketGetIpv6MulticastLoopbackResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6MulticastLoopbackResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6MulticastLoopbackResponse |
| } |
| |
| type BaseNetworkSocketGetIpv6OnlyResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6OnlyResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6OnlyResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6OnlyResponse |
| } |
| |
| type BaseNetworkSocketGetIpv6ReceiveHopLimitResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6ReceiveHopLimitResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6ReceiveHopLimitResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6ReceiveHopLimitResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6ReceiveHopLimitResponse |
| } |
| |
| type BaseNetworkSocketGetIpv6ReceivePacketInfoResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6ReceivePacketInfoResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6ReceivePacketInfoResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6ReceivePacketInfoResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6ReceivePacketInfoResponse |
| } |
| |
| type BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6ReceiveTrafficClassResponse |
| } |
| |
| type BaseNetworkSocketGetIpv6TrafficClassResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value uint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6TrafficClassResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6TrafficClassResponse |
| } |
| |
| type BaseNetworkSocketGetIpv6UnicastHopsResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value uint8 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6UnicastHopsResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6UnicastHopsResponse{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6UnicastHopsResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6UnicastHopsResponse |
| } |
| |
| type BaseNetworkSocketGetOriginalDestinationResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Value fuchsianet.SocketAddress `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetOriginalDestinationResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetOriginalDestinationResponse{}) |
| |
| func (msg *BaseNetworkSocketGetOriginalDestinationResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetOriginalDestinationResponse |
| } |
| |
| type BaseNetworkSocketGetPeerNameResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Addr fuchsianet.SocketAddress `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetPeerNameResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetPeerNameResponse{}) |
| |
| func (msg *BaseNetworkSocketGetPeerNameResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetPeerNameResponse |
| } |
| |
| type BaseNetworkSocketGetSockNameResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Addr fuchsianet.SocketAddress `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseNetworkSocketGetSockNameResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetSockNameResponse{}) |
| |
| func (msg *BaseNetworkSocketGetSockNameResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetSockNameResponse |
| } |
| |
| type BaseNetworkSocketSetIpMulticastInterfaceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpMulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastInterfaceResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpMulticastInterfaceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpMulticastInterfaceResponse |
| } |
| |
| type BaseNetworkSocketSetIpMulticastLoopbackResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpMulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastLoopbackResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpMulticastLoopbackResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpMulticastLoopbackResponse |
| } |
| |
| type BaseNetworkSocketSetIpMulticastTtlResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpMulticastTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastTtlResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpMulticastTtlResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpMulticastTtlResponse |
| } |
| |
| type BaseNetworkSocketSetIpPacketInfoResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpPacketInfoResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpPacketInfoResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpPacketInfoResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpPacketInfoResponse |
| } |
| |
| type BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponse |
| } |
| |
| type BaseNetworkSocketSetIpReceiveTtlResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpReceiveTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveTtlResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpReceiveTtlResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpReceiveTtlResponse |
| } |
| |
| type BaseNetworkSocketSetIpReceiveTypeOfServiceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpReceiveTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveTypeOfServiceResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpReceiveTypeOfServiceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpReceiveTypeOfServiceResponse |
| } |
| |
| type BaseNetworkSocketSetIpTransparentResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpTransparentResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTransparentResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpTransparentResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpTransparentResponse |
| } |
| |
| type BaseNetworkSocketSetIpTtlResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpTtlResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTtlResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpTtlResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpTtlResponse |
| } |
| |
| type BaseNetworkSocketSetIpTypeOfServiceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpTypeOfServiceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTypeOfServiceResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpTypeOfServiceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpTypeOfServiceResponse |
| } |
| |
| type BaseNetworkSocketSetIpv6MulticastHopsResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6MulticastHopsResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastHopsResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6MulticastHopsResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6MulticastHopsResponse |
| } |
| |
| type BaseNetworkSocketSetIpv6MulticastInterfaceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6MulticastInterfaceResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastInterfaceResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6MulticastInterfaceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6MulticastInterfaceResponse |
| } |
| |
| type BaseNetworkSocketSetIpv6MulticastLoopbackResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6MulticastLoopbackResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastLoopbackResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6MulticastLoopbackResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6MulticastLoopbackResponse |
| } |
| |
| type BaseNetworkSocketSetIpv6OnlyResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6OnlyResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6OnlyResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6OnlyResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6OnlyResponse |
| } |
| |
| type BaseNetworkSocketSetIpv6ReceiveHopLimitResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6ReceiveHopLimitResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceiveHopLimitResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6ReceiveHopLimitResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6ReceiveHopLimitResponse |
| } |
| |
| type BaseNetworkSocketSetIpv6ReceivePacketInfoResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6ReceivePacketInfoResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceivePacketInfoResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6ReceivePacketInfoResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6ReceivePacketInfoResponse |
| } |
| |
| type BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6ReceiveTrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6ReceiveTrafficClassResponse |
| } |
| |
| type BaseNetworkSocketSetIpv6TrafficClassResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6TrafficClassResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6TrafficClassResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6TrafficClassResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6TrafficClassResponse |
| } |
| |
| type BaseNetworkSocketSetIpv6UnicastHopsResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6UnicastHopsResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6UnicastHopsResponse{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6UnicastHopsResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6UnicastHopsResponse |
| } |
| |
| type BaseNetworkSocketShutdownResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseNetworkSocketShutdownResponse = _bindings.CreateLazyMarshaler(BaseNetworkSocketShutdownResponse{}) |
| |
| func (msg *BaseNetworkSocketShutdownResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketShutdownResponse |
| } |
| |
| type BaseSocketSetBindToDeviceRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Value string `fidl_offset_v2:"0" fidl_bounds:"15"` |
| } |
| |
| var _mBaseSocketSetBindToDeviceRequest = _bindings.CreateLazyMarshaler(BaseSocketSetBindToDeviceRequest{}) |
| |
| func (msg *BaseSocketSetBindToDeviceRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetBindToDeviceRequest |
| } |
| |
| type BaseSocketSetBroadcastRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketSetBroadcastRequest = _bindings.CreateLazyMarshaler(BaseSocketSetBroadcastRequest{}) |
| |
| func (msg *BaseSocketSetBroadcastRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetBroadcastRequest |
| } |
| |
| type BaseSocketSetKeepAliveRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketSetKeepAliveRequest = _bindings.CreateLazyMarshaler(BaseSocketSetKeepAliveRequest{}) |
| |
| func (msg *BaseSocketSetKeepAliveRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetKeepAliveRequest |
| } |
| |
| type BaseSocketSetLingerRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| Linger bool `fidl_offset_v2:"0"` |
| LengthSecs uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mBaseSocketSetLingerRequest = _bindings.CreateLazyMarshaler(BaseSocketSetLingerRequest{}) |
| |
| func (msg *BaseSocketSetLingerRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetLingerRequest |
| } |
| |
| type BaseSocketSetNoCheckRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketSetNoCheckRequest = _bindings.CreateLazyMarshaler(BaseSocketSetNoCheckRequest{}) |
| |
| func (msg *BaseSocketSetNoCheckRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetNoCheckRequest |
| } |
| |
| type BaseSocketSetOutOfBandInlineRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketSetOutOfBandInlineRequest = _bindings.CreateLazyMarshaler(BaseSocketSetOutOfBandInlineRequest{}) |
| |
| func (msg *BaseSocketSetOutOfBandInlineRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetOutOfBandInlineRequest |
| } |
| |
| type BaseSocketSetReceiveBufferRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"` |
| ValueBytes uint64 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketSetReceiveBufferRequest = _bindings.CreateLazyMarshaler(BaseSocketSetReceiveBufferRequest{}) |
| |
| func (msg *BaseSocketSetReceiveBufferRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetReceiveBufferRequest |
| } |
| |
| type BaseSocketSetReuseAddressRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketSetReuseAddressRequest = _bindings.CreateLazyMarshaler(BaseSocketSetReuseAddressRequest{}) |
| |
| func (msg *BaseSocketSetReuseAddressRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetReuseAddressRequest |
| } |
| |
| type BaseSocketSetReusePortRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketSetReusePortRequest = _bindings.CreateLazyMarshaler(BaseSocketSetReusePortRequest{}) |
| |
| func (msg *BaseSocketSetReusePortRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetReusePortRequest |
| } |
| |
| type BaseSocketSetSendBufferRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"` |
| ValueBytes uint64 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketSetSendBufferRequest = _bindings.CreateLazyMarshaler(BaseSocketSetSendBufferRequest{}) |
| |
| func (msg *BaseSocketSetSendBufferRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetSendBufferRequest |
| } |
| |
| type BaseSocketSetTimestampRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value TimestampOption `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketSetTimestampRequest = _bindings.CreateLazyMarshaler(BaseSocketSetTimestampRequest{}) |
| |
| func (msg *BaseSocketSetTimestampRequest) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetTimestampRequest |
| } |
| |
| type BaseSocketGetAcceptConnResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetAcceptConnResponse = _bindings.CreateLazyMarshaler(BaseSocketGetAcceptConnResponse{}) |
| |
| func (msg *BaseSocketGetAcceptConnResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetAcceptConnResponse |
| } |
| |
| type BaseSocketGetBindToDeviceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Value string `fidl_offset_v2:"0" fidl_bounds:"15"` |
| } |
| |
| var _mBaseSocketGetBindToDeviceResponse = _bindings.CreateLazyMarshaler(BaseSocketGetBindToDeviceResponse{}) |
| |
| func (msg *BaseSocketGetBindToDeviceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetBindToDeviceResponse |
| } |
| |
| type BaseSocketGetBroadcastResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetBroadcastResponse = _bindings.CreateLazyMarshaler(BaseSocketGetBroadcastResponse{}) |
| |
| func (msg *BaseSocketGetBroadcastResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetBroadcastResponse |
| } |
| |
| type BaseSocketGetErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketGetErrorResponse = _bindings.CreateLazyMarshaler(BaseSocketGetErrorResponse{}) |
| |
| func (msg *BaseSocketGetErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetErrorResponse |
| } |
| |
| type BaseSocketGetKeepAliveResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetKeepAliveResponse = _bindings.CreateLazyMarshaler(BaseSocketGetKeepAliveResponse{}) |
| |
| func (msg *BaseSocketGetKeepAliveResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetKeepAliveResponse |
| } |
| |
| type BaseSocketGetLingerResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| Linger bool `fidl_offset_v2:"0"` |
| LengthSecs uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mBaseSocketGetLingerResponse = _bindings.CreateLazyMarshaler(BaseSocketGetLingerResponse{}) |
| |
| func (msg *BaseSocketGetLingerResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetLingerResponse |
| } |
| |
| type BaseSocketGetNoCheckResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetNoCheckResponse = _bindings.CreateLazyMarshaler(BaseSocketGetNoCheckResponse{}) |
| |
| func (msg *BaseSocketGetNoCheckResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetNoCheckResponse |
| } |
| |
| type BaseSocketGetOutOfBandInlineResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(BaseSocketGetOutOfBandInlineResponse{}) |
| |
| func (msg *BaseSocketGetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetOutOfBandInlineResponse |
| } |
| |
| type BaseSocketGetReceiveBufferResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"` |
| ValueBytes uint64 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetReceiveBufferResponse = _bindings.CreateLazyMarshaler(BaseSocketGetReceiveBufferResponse{}) |
| |
| func (msg *BaseSocketGetReceiveBufferResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetReceiveBufferResponse |
| } |
| |
| type BaseSocketGetReuseAddressResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetReuseAddressResponse = _bindings.CreateLazyMarshaler(BaseSocketGetReuseAddressResponse{}) |
| |
| func (msg *BaseSocketGetReuseAddressResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetReuseAddressResponse |
| } |
| |
| type BaseSocketGetReusePortResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetReusePortResponse = _bindings.CreateLazyMarshaler(BaseSocketGetReusePortResponse{}) |
| |
| func (msg *BaseSocketGetReusePortResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetReusePortResponse |
| } |
| |
| type BaseSocketGetSendBufferResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"` |
| ValueBytes uint64 `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetSendBufferResponse = _bindings.CreateLazyMarshaler(BaseSocketGetSendBufferResponse{}) |
| |
| func (msg *BaseSocketGetSendBufferResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetSendBufferResponse |
| } |
| |
| type BaseSocketGetTimestampResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value TimestampOption `fidl_offset_v2:"0"` |
| } |
| |
| var _mBaseSocketGetTimestampResponse = _bindings.CreateLazyMarshaler(BaseSocketGetTimestampResponse{}) |
| |
| func (msg *BaseSocketGetTimestampResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetTimestampResponse |
| } |
| |
| type BaseSocketSetBindToDeviceResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetBindToDeviceResponse = _bindings.CreateLazyMarshaler(BaseSocketSetBindToDeviceResponse{}) |
| |
| func (msg *BaseSocketSetBindToDeviceResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetBindToDeviceResponse |
| } |
| |
| type BaseSocketSetBroadcastResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetBroadcastResponse = _bindings.CreateLazyMarshaler(BaseSocketSetBroadcastResponse{}) |
| |
| func (msg *BaseSocketSetBroadcastResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetBroadcastResponse |
| } |
| |
| type BaseSocketSetKeepAliveResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetKeepAliveResponse = _bindings.CreateLazyMarshaler(BaseSocketSetKeepAliveResponse{}) |
| |
| func (msg *BaseSocketSetKeepAliveResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetKeepAliveResponse |
| } |
| |
| type BaseSocketSetLingerResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetLingerResponse = _bindings.CreateLazyMarshaler(BaseSocketSetLingerResponse{}) |
| |
| func (msg *BaseSocketSetLingerResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetLingerResponse |
| } |
| |
| type BaseSocketSetNoCheckResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetNoCheckResponse = _bindings.CreateLazyMarshaler(BaseSocketSetNoCheckResponse{}) |
| |
| func (msg *BaseSocketSetNoCheckResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetNoCheckResponse |
| } |
| |
| type BaseSocketSetOutOfBandInlineResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetOutOfBandInlineResponse = _bindings.CreateLazyMarshaler(BaseSocketSetOutOfBandInlineResponse{}) |
| |
| func (msg *BaseSocketSetOutOfBandInlineResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetOutOfBandInlineResponse |
| } |
| |
| type BaseSocketSetReceiveBufferResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetReceiveBufferResponse = _bindings.CreateLazyMarshaler(BaseSocketSetReceiveBufferResponse{}) |
| |
| func (msg *BaseSocketSetReceiveBufferResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetReceiveBufferResponse |
| } |
| |
| type BaseSocketSetReuseAddressResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetReuseAddressResponse = _bindings.CreateLazyMarshaler(BaseSocketSetReuseAddressResponse{}) |
| |
| func (msg *BaseSocketSetReuseAddressResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetReuseAddressResponse |
| } |
| |
| type BaseSocketSetReusePortResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetReusePortResponse = _bindings.CreateLazyMarshaler(BaseSocketSetReusePortResponse{}) |
| |
| func (msg *BaseSocketSetReusePortResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetReusePortResponse |
| } |
| |
| type BaseSocketSetSendBufferResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetSendBufferResponse = _bindings.CreateLazyMarshaler(BaseSocketSetSendBufferResponse{}) |
| |
| func (msg *BaseSocketSetSendBufferResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetSendBufferResponse |
| } |
| |
| type BaseSocketSetTimestampResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mBaseSocketSetTimestampResponse = _bindings.CreateLazyMarshaler(BaseSocketSetTimestampResponse{}) |
| |
| func (msg *BaseSocketSetTimestampResponse) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetTimestampResponse |
| } |
| |
| type Empty struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mEmpty = _bindings.CreateLazyMarshaler(Empty{}) |
| |
| func (msg *Empty) Marshaler() _bindings.Marshaler { |
| return _mEmpty |
| } |
| |
| // IPv4 multicast membership options. |
| type IpMulticastMembership struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| // Interface index for membership. |
| Iface uint64 `fidl_offset_v2:"0"` |
| // Local interface address requesting or relinquishing ownership. |
| LocalAddr fuchsianet.Ipv4Address `fidl_offset_v2:"8"` |
| // Address of the multicast group the membership refers to. |
| McastAddr fuchsianet.Ipv4Address `fidl_offset_v2:"12"` |
| } |
| |
| var _mIpMulticastMembership = _bindings.CreateLazyMarshaler(IpMulticastMembership{}) |
| |
| func (msg *IpMulticastMembership) Marshaler() _bindings.Marshaler { |
| return _mIpMulticastMembership |
| } |
| |
| // IPv6 multicast membership options. |
| type Ipv6MulticastMembership struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"` |
| // Interface index for membership. |
| Iface uint64 `fidl_offset_v2:"0"` |
| // Address of the multicast group the membership refers to. |
| McastAddr fuchsianet.Ipv6Address `fidl_offset_v2:"8"` |
| } |
| |
| var _mIpv6MulticastMembership = _bindings.CreateLazyMarshaler(Ipv6MulticastMembership{}) |
| |
| func (msg *Ipv6MulticastMembership) Marshaler() _bindings.Marshaler { |
| return _mIpv6MulticastMembership |
| } |
| |
| type Ipv6PktInfoRecvControlData struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"` |
| // The index of the interface on which the IP packet was received. |
| Iface uint64 `fidl_offset_v2:"0"` |
| // The destination address specified in the received packet's IP |
| // header. |
| HeaderDestinationAddr fuchsianet.Ipv6Address `fidl_offset_v2:"8"` |
| } |
| |
| var _mIpv6PktInfoRecvControlData = _bindings.CreateLazyMarshaler(Ipv6PktInfoRecvControlData{}) |
| |
| func (msg *Ipv6PktInfoRecvControlData) Marshaler() _bindings.Marshaler { |
| return _mIpv6PktInfoRecvControlData |
| } |
| |
| // IPv6-specific disposition of sent data. |
| // |
| // This is currently a struct instead of a table as it is meant to match |
| // `in6_pktinfo` which is not expected to grow. |
| type Ipv6PktInfoSendControlData struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"` |
| // The interface index from which the IPv6 packet should be sent. |
| // |
| // 0 indicates that the local interface is unspecified and the |
| // stack may choose an appropriate interface. |
| Iface uint64 `fidl_offset_v2:"0"` |
| // The source address from which the IPv6 packet should be sent. |
| // |
| // All zeroes indicates that the local address is unspecified and |
| // the stack may choose an appropriate address (i.e. the local |
| // address to which the socket is bound). |
| LocalAddr fuchsianet.Ipv6Address `fidl_offset_v2:"8"` |
| } |
| |
| var _mIpv6PktInfoSendControlData = _bindings.CreateLazyMarshaler(Ipv6PktInfoSendControlData{}) |
| |
| func (msg *Ipv6PktInfoSendControlData) Marshaler() _bindings.Marshaler { |
| return _mIpv6PktInfoSendControlData |
| } |
| |
| type ProviderDatagramSocketDeprecatedRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| Domain Domain `fidl_offset_v2:"0"` |
| Proto DatagramSocketProtocol `fidl_offset_v2:"4"` |
| } |
| |
| var _mProviderDatagramSocketDeprecatedRequest = _bindings.CreateLazyMarshaler(ProviderDatagramSocketDeprecatedRequest{}) |
| |
| func (msg *ProviderDatagramSocketDeprecatedRequest) Marshaler() _bindings.Marshaler { |
| return _mProviderDatagramSocketDeprecatedRequest |
| } |
| |
| type ProviderDatagramSocketRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| Domain Domain `fidl_offset_v2:"0"` |
| Proto DatagramSocketProtocol `fidl_offset_v2:"4"` |
| } |
| |
| var _mProviderDatagramSocketRequest = _bindings.CreateLazyMarshaler(ProviderDatagramSocketRequest{}) |
| |
| func (msg *ProviderDatagramSocketRequest) Marshaler() _bindings.Marshaler { |
| return _mProviderDatagramSocketRequest |
| } |
| |
| type ProviderGetInterfaceAddressesResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Interfaces []InterfaceAddresses `fidl_offset_v2:"0" fidl_bounds:""` |
| } |
| |
| var _mProviderGetInterfaceAddressesResponse = _bindings.CreateLazyMarshaler(ProviderGetInterfaceAddressesResponse{}) |
| |
| func (msg *ProviderGetInterfaceAddressesResponse) Marshaler() _bindings.Marshaler { |
| return _mProviderGetInterfaceAddressesResponse |
| } |
| |
| type ProviderInterfaceIndexToNameRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"` |
| Index uint64 `fidl_offset_v2:"0"` |
| } |
| |
| var _mProviderInterfaceIndexToNameRequest = _bindings.CreateLazyMarshaler(ProviderInterfaceIndexToNameRequest{}) |
| |
| func (msg *ProviderInterfaceIndexToNameRequest) Marshaler() _bindings.Marshaler { |
| return _mProviderInterfaceIndexToNameRequest |
| } |
| |
| type ProviderInterfaceNameToFlagsRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Name string `fidl_offset_v2:"0" fidl_bounds:"15"` |
| } |
| |
| var _mProviderInterfaceNameToFlagsRequest = _bindings.CreateLazyMarshaler(ProviderInterfaceNameToFlagsRequest{}) |
| |
| func (msg *ProviderInterfaceNameToFlagsRequest) Marshaler() _bindings.Marshaler { |
| return _mProviderInterfaceNameToFlagsRequest |
| } |
| |
| type ProviderInterfaceNameToIndexRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Name string `fidl_offset_v2:"0" fidl_bounds:"15"` |
| } |
| |
| var _mProviderInterfaceNameToIndexRequest = _bindings.CreateLazyMarshaler(ProviderInterfaceNameToIndexRequest{}) |
| |
| func (msg *ProviderInterfaceNameToIndexRequest) Marshaler() _bindings.Marshaler { |
| return _mProviderInterfaceNameToIndexRequest |
| } |
| |
| type ProviderStreamSocketRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| Domain Domain `fidl_offset_v2:"0"` |
| Proto StreamSocketProtocol `fidl_offset_v2:"4"` |
| } |
| |
| var _mProviderStreamSocketRequest = _bindings.CreateLazyMarshaler(ProviderStreamSocketRequest{}) |
| |
| func (msg *ProviderStreamSocketRequest) Marshaler() _bindings.Marshaler { |
| return _mProviderStreamSocketRequest |
| } |
| |
| type ProviderDatagramSocketDeprecatedResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| S SynchronousDatagramSocketWithCtxInterface `fidl_offset_v2:"0" fidl_handle_subtype:"4"` |
| } |
| |
| var _mProviderDatagramSocketDeprecatedResponse = _bindings.CreateLazyMarshaler(ProviderDatagramSocketDeprecatedResponse{}) |
| |
| func (msg *ProviderDatagramSocketDeprecatedResponse) Marshaler() _bindings.Marshaler { |
| return _mProviderDatagramSocketDeprecatedResponse |
| } |
| |
| type ProviderInterfaceIndexToNameResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Name string `fidl_offset_v2:"0" fidl_bounds:"15"` |
| } |
| |
| var _mProviderInterfaceIndexToNameResponse = _bindings.CreateLazyMarshaler(ProviderInterfaceIndexToNameResponse{}) |
| |
| func (msg *ProviderInterfaceIndexToNameResponse) Marshaler() _bindings.Marshaler { |
| return _mProviderInterfaceIndexToNameResponse |
| } |
| |
| type ProviderInterfaceNameToFlagsResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"2" fidl_alignment_v2:"2"` |
| Flags InterfaceFlags `fidl_offset_v2:"0"` |
| } |
| |
| var _mProviderInterfaceNameToFlagsResponse = _bindings.CreateLazyMarshaler(ProviderInterfaceNameToFlagsResponse{}) |
| |
| func (msg *ProviderInterfaceNameToFlagsResponse) Marshaler() _bindings.Marshaler { |
| return _mProviderInterfaceNameToFlagsResponse |
| } |
| |
| type ProviderInterfaceNameToIndexResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"` |
| Index uint64 `fidl_offset_v2:"0"` |
| } |
| |
| var _mProviderInterfaceNameToIndexResponse = _bindings.CreateLazyMarshaler(ProviderInterfaceNameToIndexResponse{}) |
| |
| func (msg *ProviderInterfaceNameToIndexResponse) Marshaler() _bindings.Marshaler { |
| return _mProviderInterfaceNameToIndexResponse |
| } |
| |
| type ProviderStreamSocketResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| S StreamSocketWithCtxInterface `fidl_offset_v2:"0" fidl_handle_subtype:"4"` |
| } |
| |
| var _mProviderStreamSocketResponse = _bindings.CreateLazyMarshaler(ProviderStreamSocketResponse{}) |
| |
| func (msg *ProviderStreamSocketResponse) Marshaler() _bindings.Marshaler { |
| return _mProviderStreamSocketResponse |
| } |
| |
| type StreamSocketAcceptRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| WantAddr bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketAcceptRequest = _bindings.CreateLazyMarshaler(StreamSocketAcceptRequest{}) |
| |
| func (msg *StreamSocketAcceptRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketAcceptRequest |
| } |
| |
| type StreamSocketListenRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"2" fidl_alignment_v2:"2"` |
| Backlog int16 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketListenRequest = _bindings.CreateLazyMarshaler(StreamSocketListenRequest{}) |
| |
| func (msg *StreamSocketListenRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketListenRequest |
| } |
| |
| type StreamSocketSetTcpCongestionRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value TcpCongestionControl `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpCongestionRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpCongestionRequest{}) |
| |
| func (msg *StreamSocketSetTcpCongestionRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpCongestionRequest |
| } |
| |
| type StreamSocketSetTcpCorkRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpCorkRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpCorkRequest{}) |
| |
| func (msg *StreamSocketSetTcpCorkRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpCorkRequest |
| } |
| |
| type StreamSocketSetTcpDeferAcceptRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueSecs uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpDeferAcceptRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpDeferAcceptRequest{}) |
| |
| func (msg *StreamSocketSetTcpDeferAcceptRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpDeferAcceptRequest |
| } |
| |
| type StreamSocketSetTcpKeepAliveCountRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpKeepAliveCountRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveCountRequest{}) |
| |
| func (msg *StreamSocketSetTcpKeepAliveCountRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpKeepAliveCountRequest |
| } |
| |
| type StreamSocketSetTcpKeepAliveIdleRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueSecs uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpKeepAliveIdleRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveIdleRequest{}) |
| |
| func (msg *StreamSocketSetTcpKeepAliveIdleRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpKeepAliveIdleRequest |
| } |
| |
| type StreamSocketSetTcpKeepAliveIntervalRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueSecs uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpKeepAliveIntervalRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveIntervalRequest{}) |
| |
| func (msg *StreamSocketSetTcpKeepAliveIntervalRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpKeepAliveIntervalRequest |
| } |
| |
| type StreamSocketSetTcpLingerRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| ValueSecs OptionalUint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpLingerRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpLingerRequest{}) |
| |
| func (msg *StreamSocketSetTcpLingerRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpLingerRequest |
| } |
| |
| type StreamSocketSetTcpMaxSegmentRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueBytes uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpMaxSegmentRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpMaxSegmentRequest{}) |
| |
| func (msg *StreamSocketSetTcpMaxSegmentRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpMaxSegmentRequest |
| } |
| |
| type StreamSocketSetTcpNoDelayRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpNoDelayRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpNoDelayRequest{}) |
| |
| func (msg *StreamSocketSetTcpNoDelayRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpNoDelayRequest |
| } |
| |
| type StreamSocketSetTcpQuickAckRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpQuickAckRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpQuickAckRequest{}) |
| |
| func (msg *StreamSocketSetTcpQuickAckRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpQuickAckRequest |
| } |
| |
| type StreamSocketSetTcpSynCountRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpSynCountRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpSynCountRequest{}) |
| |
| func (msg *StreamSocketSetTcpSynCountRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpSynCountRequest |
| } |
| |
| type StreamSocketSetTcpUserTimeoutRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueMillis uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpUserTimeoutRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpUserTimeoutRequest{}) |
| |
| func (msg *StreamSocketSetTcpUserTimeoutRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpUserTimeoutRequest |
| } |
| |
| type StreamSocketSetTcpWindowClampRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketSetTcpWindowClampRequest = _bindings.CreateLazyMarshaler(StreamSocketSetTcpWindowClampRequest{}) |
| |
| func (msg *StreamSocketSetTcpWindowClampRequest) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpWindowClampRequest |
| } |
| |
| type StreamSocketAcceptResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"` |
| Addr *fuchsianet.SocketAddress `fidl_offset_v2:"0"` |
| S StreamSocketWithCtxInterface `fidl_offset_v2:"16" fidl_handle_subtype:"4"` |
| } |
| |
| var _mStreamSocketAcceptResponse = _bindings.CreateLazyMarshaler(StreamSocketAcceptResponse{}) |
| |
| func (msg *StreamSocketAcceptResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketAcceptResponse |
| } |
| |
| type StreamSocketGetInfoResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| Domain Domain `fidl_offset_v2:"0"` |
| Proto StreamSocketProtocol `fidl_offset_v2:"4"` |
| } |
| |
| var _mStreamSocketGetInfoResponse = _bindings.CreateLazyMarshaler(StreamSocketGetInfoResponse{}) |
| |
| func (msg *StreamSocketGetInfoResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetInfoResponse |
| } |
| |
| type StreamSocketGetTcpCongestionResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value TcpCongestionControl `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpCongestionResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpCongestionResponse{}) |
| |
| func (msg *StreamSocketGetTcpCongestionResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpCongestionResponse |
| } |
| |
| type StreamSocketGetTcpCorkResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpCorkResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpCorkResponse{}) |
| |
| func (msg *StreamSocketGetTcpCorkResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpCorkResponse |
| } |
| |
| type StreamSocketGetTcpDeferAcceptResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueSecs uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpDeferAcceptResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpDeferAcceptResponse{}) |
| |
| func (msg *StreamSocketGetTcpDeferAcceptResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpDeferAcceptResponse |
| } |
| |
| type StreamSocketGetTcpInfoResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Info TcpInfo `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpInfoResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpInfoResponse{}) |
| |
| func (msg *StreamSocketGetTcpInfoResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpInfoResponse |
| } |
| |
| type StreamSocketGetTcpKeepAliveCountResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpKeepAliveCountResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpKeepAliveCountResponse{}) |
| |
| func (msg *StreamSocketGetTcpKeepAliveCountResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpKeepAliveCountResponse |
| } |
| |
| type StreamSocketGetTcpKeepAliveIdleResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueSecs uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpKeepAliveIdleResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpKeepAliveIdleResponse{}) |
| |
| func (msg *StreamSocketGetTcpKeepAliveIdleResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpKeepAliveIdleResponse |
| } |
| |
| type StreamSocketGetTcpKeepAliveIntervalResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueSecs uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpKeepAliveIntervalResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpKeepAliveIntervalResponse{}) |
| |
| func (msg *StreamSocketGetTcpKeepAliveIntervalResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpKeepAliveIntervalResponse |
| } |
| |
| type StreamSocketGetTcpLingerResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| ValueSecs OptionalUint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpLingerResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpLingerResponse{}) |
| |
| func (msg *StreamSocketGetTcpLingerResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpLingerResponse |
| } |
| |
| type StreamSocketGetTcpMaxSegmentResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueBytes uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpMaxSegmentResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpMaxSegmentResponse{}) |
| |
| func (msg *StreamSocketGetTcpMaxSegmentResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpMaxSegmentResponse |
| } |
| |
| type StreamSocketGetTcpNoDelayResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpNoDelayResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpNoDelayResponse{}) |
| |
| func (msg *StreamSocketGetTcpNoDelayResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpNoDelayResponse |
| } |
| |
| type StreamSocketGetTcpQuickAckResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| Value bool `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpQuickAckResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpQuickAckResponse{}) |
| |
| func (msg *StreamSocketGetTcpQuickAckResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpQuickAckResponse |
| } |
| |
| type StreamSocketGetTcpSynCountResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpSynCountResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpSynCountResponse{}) |
| |
| func (msg *StreamSocketGetTcpSynCountResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpSynCountResponse |
| } |
| |
| type StreamSocketGetTcpUserTimeoutResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| ValueMillis uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpUserTimeoutResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpUserTimeoutResponse{}) |
| |
| func (msg *StreamSocketGetTcpUserTimeoutResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpUserTimeoutResponse |
| } |
| |
| type StreamSocketGetTcpWindowClampResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"` |
| Value uint32 `fidl_offset_v2:"0"` |
| } |
| |
| var _mStreamSocketGetTcpWindowClampResponse = _bindings.CreateLazyMarshaler(StreamSocketGetTcpWindowClampResponse{}) |
| |
| func (msg *StreamSocketGetTcpWindowClampResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpWindowClampResponse |
| } |
| |
| type StreamSocketListenResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketListenResponse = _bindings.CreateLazyMarshaler(StreamSocketListenResponse{}) |
| |
| func (msg *StreamSocketListenResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketListenResponse |
| } |
| |
| type StreamSocketSetTcpCongestionResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpCongestionResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpCongestionResponse{}) |
| |
| func (msg *StreamSocketSetTcpCongestionResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpCongestionResponse |
| } |
| |
| type StreamSocketSetTcpCorkResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpCorkResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpCorkResponse{}) |
| |
| func (msg *StreamSocketSetTcpCorkResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpCorkResponse |
| } |
| |
| type StreamSocketSetTcpDeferAcceptResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpDeferAcceptResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpDeferAcceptResponse{}) |
| |
| func (msg *StreamSocketSetTcpDeferAcceptResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpDeferAcceptResponse |
| } |
| |
| type StreamSocketSetTcpKeepAliveCountResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpKeepAliveCountResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveCountResponse{}) |
| |
| func (msg *StreamSocketSetTcpKeepAliveCountResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpKeepAliveCountResponse |
| } |
| |
| type StreamSocketSetTcpKeepAliveIdleResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpKeepAliveIdleResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveIdleResponse{}) |
| |
| func (msg *StreamSocketSetTcpKeepAliveIdleResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpKeepAliveIdleResponse |
| } |
| |
| type StreamSocketSetTcpKeepAliveIntervalResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpKeepAliveIntervalResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveIntervalResponse{}) |
| |
| func (msg *StreamSocketSetTcpKeepAliveIntervalResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpKeepAliveIntervalResponse |
| } |
| |
| type StreamSocketSetTcpLingerResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpLingerResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpLingerResponse{}) |
| |
| func (msg *StreamSocketSetTcpLingerResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpLingerResponse |
| } |
| |
| type StreamSocketSetTcpMaxSegmentResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpMaxSegmentResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpMaxSegmentResponse{}) |
| |
| func (msg *StreamSocketSetTcpMaxSegmentResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpMaxSegmentResponse |
| } |
| |
| type StreamSocketSetTcpNoDelayResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpNoDelayResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpNoDelayResponse{}) |
| |
| func (msg *StreamSocketSetTcpNoDelayResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpNoDelayResponse |
| } |
| |
| type StreamSocketSetTcpQuickAckResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpQuickAckResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpQuickAckResponse{}) |
| |
| func (msg *StreamSocketSetTcpQuickAckResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpQuickAckResponse |
| } |
| |
| type StreamSocketSetTcpSynCountResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpSynCountResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpSynCountResponse{}) |
| |
| func (msg *StreamSocketSetTcpSynCountResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpSynCountResponse |
| } |
| |
| type StreamSocketSetTcpUserTimeoutResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpUserTimeoutResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpUserTimeoutResponse{}) |
| |
| func (msg *StreamSocketSetTcpUserTimeoutResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpUserTimeoutResponse |
| } |
| |
| type StreamSocketSetTcpWindowClampResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStreamSocketSetTcpWindowClampResponse = _bindings.CreateLazyMarshaler(StreamSocketSetTcpWindowClampResponse{}) |
| |
| func (msg *StreamSocketSetTcpWindowClampResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpWindowClampResponse |
| } |
| |
| type SynchronousDatagramSocketRecvMsgRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"12" fidl_alignment_v2:"4"` |
| WantAddr bool `fidl_offset_v2:"0"` |
| DataLen uint32 `fidl_offset_v2:"4"` |
| WantControl bool `fidl_offset_v2:"8"` |
| Flags RecvMsgFlags `fidl_offset_v2:"10"` |
| } |
| |
| var _mSynchronousDatagramSocketRecvMsgRequest = _bindings.CreateLazyMarshaler(SynchronousDatagramSocketRecvMsgRequest{}) |
| |
| func (msg *SynchronousDatagramSocketRecvMsgRequest) Marshaler() _bindings.Marshaler { |
| return _mSynchronousDatagramSocketRecvMsgRequest |
| } |
| |
| type SynchronousDatagramSocketSendMsgRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"56" fidl_alignment_v2:"8"` |
| Addr *fuchsianet.SocketAddress `fidl_offset_v2:"0"` |
| Data []uint8 `fidl_offset_v2:"16" fidl_bounds:""` |
| Control DatagramSocketSendControlData `fidl_offset_v2:"32"` |
| Flags SendMsgFlags `fidl_offset_v2:"48"` |
| } |
| |
| var _mSynchronousDatagramSocketSendMsgRequest = _bindings.CreateLazyMarshaler(SynchronousDatagramSocketSendMsgRequest{}) |
| |
| func (msg *SynchronousDatagramSocketSendMsgRequest) Marshaler() _bindings.Marshaler { |
| return _mSynchronousDatagramSocketSendMsgRequest |
| } |
| |
| type SynchronousDatagramSocketRecvMsgResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"56" fidl_alignment_v2:"8"` |
| Addr *fuchsianet.SocketAddress `fidl_offset_v2:"0"` |
| Data []uint8 `fidl_offset_v2:"16" fidl_bounds:""` |
| Control DatagramSocketRecvControlData `fidl_offset_v2:"32"` |
| Truncated uint32 `fidl_offset_v2:"48"` |
| } |
| |
| var _mSynchronousDatagramSocketRecvMsgResponse = _bindings.CreateLazyMarshaler(SynchronousDatagramSocketRecvMsgResponse{}) |
| |
| func (msg *SynchronousDatagramSocketRecvMsgResponse) Marshaler() _bindings.Marshaler { |
| return _mSynchronousDatagramSocketRecvMsgResponse |
| } |
| |
| type SynchronousDatagramSocketSendMsgResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"` |
| Len int64 `fidl_offset_v2:"0"` |
| } |
| |
| var _mSynchronousDatagramSocketSendMsgResponse = _bindings.CreateLazyMarshaler(SynchronousDatagramSocketSendMsgResponse{}) |
| |
| func (msg *SynchronousDatagramSocketSendMsgResponse) Marshaler() _bindings.Marshaler { |
| return _mSynchronousDatagramSocketSendMsgResponse |
| } |
| |
| type Timestamp struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| // Time in nanoseconds since epoch (January 1 1970 GMT). |
| Nanoseconds int64 `fidl_offset_v2:"0"` |
| // Identifies whether/how the timestamp should be returned to the user. |
| // Ignored in the DatagramSocket protocol. |
| Requested TimestampOption `fidl_offset_v2:"8"` |
| } |
| |
| var _mTimestamp = _bindings.CreateLazyMarshaler(Timestamp{}) |
| |
| func (msg *Timestamp) Marshaler() _bindings.Marshaler { |
| return _mTimestamp |
| } |
| |
| type I_baseDatagramSocketGetInfoResultTag uint64 |
| |
| const ( |
| BaseDatagramSocketGetInfoResultResponse = 1 // 0x00000001 |
| BaseDatagramSocketGetInfoResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseDatagramSocketGetInfoResult struct { |
| I_baseDatagramSocketGetInfoResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseDatagramSocketGetInfoResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseDatagramSocketGetInfoResult = _bindings.CreateLazyMarshaler(BaseDatagramSocketGetInfoResult{}) |
| |
| func (msg *BaseDatagramSocketGetInfoResult) Marshaler() _bindings.Marshaler { |
| return _mBaseDatagramSocketGetInfoResult |
| } |
| |
| func (_m *BaseDatagramSocketGetInfoResult) reset() { |
| switch _m.I_baseDatagramSocketGetInfoResultTag { |
| case 1: |
| var _zeroed BaseDatagramSocketGetInfoResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseDatagramSocketGetInfoResult) Which() I_baseDatagramSocketGetInfoResultTag { |
| return _m.I_baseDatagramSocketGetInfoResultTag |
| } |
| |
| func (_m *BaseDatagramSocketGetInfoResult) Ordinal() uint64 { |
| return uint64(_m.I_baseDatagramSocketGetInfoResultTag) |
| } |
| |
| func (_m *BaseDatagramSocketGetInfoResult) SetResponse(response BaseDatagramSocketGetInfoResponse) { |
| _m.reset() |
| _m.I_baseDatagramSocketGetInfoResultTag = BaseDatagramSocketGetInfoResultResponse |
| _m.Response = response |
| } |
| |
| func BaseDatagramSocketGetInfoResultWithResponse(response BaseDatagramSocketGetInfoResponse) BaseDatagramSocketGetInfoResult { |
| var _u BaseDatagramSocketGetInfoResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseDatagramSocketGetInfoResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseDatagramSocketGetInfoResultTag = BaseDatagramSocketGetInfoResultErr |
| _m.Err = err |
| } |
| |
| func BaseDatagramSocketGetInfoResultWithErr(err fuchsiaposix.Errno) BaseDatagramSocketGetInfoResult { |
| var _u BaseDatagramSocketGetInfoResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketAddIpMembershipResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketAddIpMembershipResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketAddIpMembershipResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketAddIpMembershipResult struct { |
| I_baseNetworkSocketAddIpMembershipResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketAddIpMembershipResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketAddIpMembershipResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketAddIpMembershipResult{}) |
| |
| func (msg *BaseNetworkSocketAddIpMembershipResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketAddIpMembershipResult |
| } |
| |
| func (_m *BaseNetworkSocketAddIpMembershipResult) reset() { |
| switch _m.I_baseNetworkSocketAddIpMembershipResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketAddIpMembershipResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketAddIpMembershipResult) Which() I_baseNetworkSocketAddIpMembershipResultTag { |
| return _m.I_baseNetworkSocketAddIpMembershipResultTag |
| } |
| |
| func (_m *BaseNetworkSocketAddIpMembershipResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketAddIpMembershipResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketAddIpMembershipResult) SetResponse(response BaseNetworkSocketAddIpMembershipResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketAddIpMembershipResultTag = BaseNetworkSocketAddIpMembershipResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketAddIpMembershipResultWithResponse(response BaseNetworkSocketAddIpMembershipResponse) BaseNetworkSocketAddIpMembershipResult { |
| var _u BaseNetworkSocketAddIpMembershipResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketAddIpMembershipResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketAddIpMembershipResultTag = BaseNetworkSocketAddIpMembershipResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketAddIpMembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketAddIpMembershipResult { |
| var _u BaseNetworkSocketAddIpMembershipResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketAddIpv6MembershipResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketAddIpv6MembershipResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketAddIpv6MembershipResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketAddIpv6MembershipResult struct { |
| I_baseNetworkSocketAddIpv6MembershipResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketAddIpv6MembershipResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketAddIpv6MembershipResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketAddIpv6MembershipResult{}) |
| |
| func (msg *BaseNetworkSocketAddIpv6MembershipResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketAddIpv6MembershipResult |
| } |
| |
| func (_m *BaseNetworkSocketAddIpv6MembershipResult) reset() { |
| switch _m.I_baseNetworkSocketAddIpv6MembershipResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketAddIpv6MembershipResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketAddIpv6MembershipResult) Which() I_baseNetworkSocketAddIpv6MembershipResultTag { |
| return _m.I_baseNetworkSocketAddIpv6MembershipResultTag |
| } |
| |
| func (_m *BaseNetworkSocketAddIpv6MembershipResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketAddIpv6MembershipResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketAddIpv6MembershipResult) SetResponse(response BaseNetworkSocketAddIpv6MembershipResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketAddIpv6MembershipResultTag = BaseNetworkSocketAddIpv6MembershipResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketAddIpv6MembershipResultWithResponse(response BaseNetworkSocketAddIpv6MembershipResponse) BaseNetworkSocketAddIpv6MembershipResult { |
| var _u BaseNetworkSocketAddIpv6MembershipResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketAddIpv6MembershipResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketAddIpv6MembershipResultTag = BaseNetworkSocketAddIpv6MembershipResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketAddIpv6MembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketAddIpv6MembershipResult { |
| var _u BaseNetworkSocketAddIpv6MembershipResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketBindResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketBindResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketBindResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketBindResult struct { |
| I_baseNetworkSocketBindResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketBindResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketBindResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketBindResult{}) |
| |
| func (msg *BaseNetworkSocketBindResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketBindResult |
| } |
| |
| func (_m *BaseNetworkSocketBindResult) reset() { |
| switch _m.I_baseNetworkSocketBindResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketBindResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketBindResult) Which() I_baseNetworkSocketBindResultTag { |
| return _m.I_baseNetworkSocketBindResultTag |
| } |
| |
| func (_m *BaseNetworkSocketBindResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketBindResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketBindResult) SetResponse(response BaseNetworkSocketBindResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketBindResultTag = BaseNetworkSocketBindResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketBindResultWithResponse(response BaseNetworkSocketBindResponse) BaseNetworkSocketBindResult { |
| var _u BaseNetworkSocketBindResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketBindResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketBindResultTag = BaseNetworkSocketBindResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketBindResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketBindResult { |
| var _u BaseNetworkSocketBindResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketConnectResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketConnectResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketConnectResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketConnectResult struct { |
| I_baseNetworkSocketConnectResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketConnectResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketConnectResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketConnectResult{}) |
| |
| func (msg *BaseNetworkSocketConnectResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketConnectResult |
| } |
| |
| func (_m *BaseNetworkSocketConnectResult) reset() { |
| switch _m.I_baseNetworkSocketConnectResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketConnectResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketConnectResult) Which() I_baseNetworkSocketConnectResultTag { |
| return _m.I_baseNetworkSocketConnectResultTag |
| } |
| |
| func (_m *BaseNetworkSocketConnectResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketConnectResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketConnectResult) SetResponse(response BaseNetworkSocketConnectResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketConnectResultTag = BaseNetworkSocketConnectResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketConnectResultWithResponse(response BaseNetworkSocketConnectResponse) BaseNetworkSocketConnectResult { |
| var _u BaseNetworkSocketConnectResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketConnectResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketConnectResultTag = BaseNetworkSocketConnectResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketConnectResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketConnectResult { |
| var _u BaseNetworkSocketConnectResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketDisconnectResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketDisconnectResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketDisconnectResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketDisconnectResult struct { |
| I_baseNetworkSocketDisconnectResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketDisconnectResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketDisconnectResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketDisconnectResult{}) |
| |
| func (msg *BaseNetworkSocketDisconnectResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketDisconnectResult |
| } |
| |
| func (_m *BaseNetworkSocketDisconnectResult) reset() { |
| switch _m.I_baseNetworkSocketDisconnectResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketDisconnectResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketDisconnectResult) Which() I_baseNetworkSocketDisconnectResultTag { |
| return _m.I_baseNetworkSocketDisconnectResultTag |
| } |
| |
| func (_m *BaseNetworkSocketDisconnectResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketDisconnectResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketDisconnectResult) SetResponse(response BaseNetworkSocketDisconnectResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketDisconnectResultTag = BaseNetworkSocketDisconnectResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketDisconnectResultWithResponse(response BaseNetworkSocketDisconnectResponse) BaseNetworkSocketDisconnectResult { |
| var _u BaseNetworkSocketDisconnectResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketDisconnectResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketDisconnectResultTag = BaseNetworkSocketDisconnectResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketDisconnectResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketDisconnectResult { |
| var _u BaseNetworkSocketDisconnectResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketDropIpMembershipResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketDropIpMembershipResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketDropIpMembershipResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketDropIpMembershipResult struct { |
| I_baseNetworkSocketDropIpMembershipResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketDropIpMembershipResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketDropIpMembershipResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketDropIpMembershipResult{}) |
| |
| func (msg *BaseNetworkSocketDropIpMembershipResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketDropIpMembershipResult |
| } |
| |
| func (_m *BaseNetworkSocketDropIpMembershipResult) reset() { |
| switch _m.I_baseNetworkSocketDropIpMembershipResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketDropIpMembershipResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketDropIpMembershipResult) Which() I_baseNetworkSocketDropIpMembershipResultTag { |
| return _m.I_baseNetworkSocketDropIpMembershipResultTag |
| } |
| |
| func (_m *BaseNetworkSocketDropIpMembershipResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketDropIpMembershipResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketDropIpMembershipResult) SetResponse(response BaseNetworkSocketDropIpMembershipResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketDropIpMembershipResultTag = BaseNetworkSocketDropIpMembershipResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketDropIpMembershipResultWithResponse(response BaseNetworkSocketDropIpMembershipResponse) BaseNetworkSocketDropIpMembershipResult { |
| var _u BaseNetworkSocketDropIpMembershipResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketDropIpMembershipResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketDropIpMembershipResultTag = BaseNetworkSocketDropIpMembershipResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketDropIpMembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketDropIpMembershipResult { |
| var _u BaseNetworkSocketDropIpMembershipResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketDropIpv6MembershipResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketDropIpv6MembershipResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketDropIpv6MembershipResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketDropIpv6MembershipResult struct { |
| I_baseNetworkSocketDropIpv6MembershipResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketDropIpv6MembershipResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketDropIpv6MembershipResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketDropIpv6MembershipResult{}) |
| |
| func (msg *BaseNetworkSocketDropIpv6MembershipResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketDropIpv6MembershipResult |
| } |
| |
| func (_m *BaseNetworkSocketDropIpv6MembershipResult) reset() { |
| switch _m.I_baseNetworkSocketDropIpv6MembershipResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketDropIpv6MembershipResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketDropIpv6MembershipResult) Which() I_baseNetworkSocketDropIpv6MembershipResultTag { |
| return _m.I_baseNetworkSocketDropIpv6MembershipResultTag |
| } |
| |
| func (_m *BaseNetworkSocketDropIpv6MembershipResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketDropIpv6MembershipResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketDropIpv6MembershipResult) SetResponse(response BaseNetworkSocketDropIpv6MembershipResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketDropIpv6MembershipResultTag = BaseNetworkSocketDropIpv6MembershipResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketDropIpv6MembershipResultWithResponse(response BaseNetworkSocketDropIpv6MembershipResponse) BaseNetworkSocketDropIpv6MembershipResult { |
| var _u BaseNetworkSocketDropIpv6MembershipResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketDropIpv6MembershipResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketDropIpv6MembershipResultTag = BaseNetworkSocketDropIpv6MembershipResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketDropIpv6MembershipResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketDropIpv6MembershipResult { |
| var _u BaseNetworkSocketDropIpv6MembershipResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpMulticastInterfaceResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpMulticastInterfaceResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpMulticastInterfaceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpMulticastInterfaceResult struct { |
| I_baseNetworkSocketGetIpMulticastInterfaceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpMulticastInterfaceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpMulticastInterfaceResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpMulticastInterfaceResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpMulticastInterfaceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpMulticastInterfaceResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpMulticastInterfaceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) Which() I_baseNetworkSocketGetIpMulticastInterfaceResultTag { |
| return _m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) SetResponse(response BaseNetworkSocketGetIpMulticastInterfaceResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag = BaseNetworkSocketGetIpMulticastInterfaceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpMulticastInterfaceResultWithResponse(response BaseNetworkSocketGetIpMulticastInterfaceResponse) BaseNetworkSocketGetIpMulticastInterfaceResult { |
| var _u BaseNetworkSocketGetIpMulticastInterfaceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpMulticastInterfaceResultTag = BaseNetworkSocketGetIpMulticastInterfaceResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpMulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpMulticastInterfaceResult { |
| var _u BaseNetworkSocketGetIpMulticastInterfaceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpMulticastLoopbackResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpMulticastLoopbackResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpMulticastLoopbackResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpMulticastLoopbackResult struct { |
| I_baseNetworkSocketGetIpMulticastLoopbackResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpMulticastLoopbackResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpMulticastLoopbackResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpMulticastLoopbackResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpMulticastLoopbackResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpMulticastLoopbackResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpMulticastLoopbackResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) Which() I_baseNetworkSocketGetIpMulticastLoopbackResultTag { |
| return _m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) SetResponse(response BaseNetworkSocketGetIpMulticastLoopbackResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag = BaseNetworkSocketGetIpMulticastLoopbackResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpMulticastLoopbackResultWithResponse(response BaseNetworkSocketGetIpMulticastLoopbackResponse) BaseNetworkSocketGetIpMulticastLoopbackResult { |
| var _u BaseNetworkSocketGetIpMulticastLoopbackResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpMulticastLoopbackResultTag = BaseNetworkSocketGetIpMulticastLoopbackResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpMulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpMulticastLoopbackResult { |
| var _u BaseNetworkSocketGetIpMulticastLoopbackResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpMulticastTtlResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpMulticastTtlResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpMulticastTtlResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpMulticastTtlResult struct { |
| I_baseNetworkSocketGetIpMulticastTtlResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpMulticastTtlResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpMulticastTtlResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpMulticastTtlResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpMulticastTtlResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpMulticastTtlResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastTtlResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpMulticastTtlResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpMulticastTtlResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastTtlResult) Which() I_baseNetworkSocketGetIpMulticastTtlResultTag { |
| return _m.I_baseNetworkSocketGetIpMulticastTtlResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastTtlResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpMulticastTtlResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastTtlResult) SetResponse(response BaseNetworkSocketGetIpMulticastTtlResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpMulticastTtlResultTag = BaseNetworkSocketGetIpMulticastTtlResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpMulticastTtlResultWithResponse(response BaseNetworkSocketGetIpMulticastTtlResponse) BaseNetworkSocketGetIpMulticastTtlResult { |
| var _u BaseNetworkSocketGetIpMulticastTtlResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpMulticastTtlResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpMulticastTtlResultTag = BaseNetworkSocketGetIpMulticastTtlResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpMulticastTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpMulticastTtlResult { |
| var _u BaseNetworkSocketGetIpMulticastTtlResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpPacketInfoResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpPacketInfoResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpPacketInfoResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpPacketInfoResult struct { |
| I_baseNetworkSocketGetIpPacketInfoResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpPacketInfoResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpPacketInfoResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpPacketInfoResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpPacketInfoResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpPacketInfoResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpPacketInfoResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpPacketInfoResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpPacketInfoResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpPacketInfoResult) Which() I_baseNetworkSocketGetIpPacketInfoResultTag { |
| return _m.I_baseNetworkSocketGetIpPacketInfoResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpPacketInfoResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpPacketInfoResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpPacketInfoResult) SetResponse(response BaseNetworkSocketGetIpPacketInfoResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpPacketInfoResultTag = BaseNetworkSocketGetIpPacketInfoResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpPacketInfoResultWithResponse(response BaseNetworkSocketGetIpPacketInfoResponse) BaseNetworkSocketGetIpPacketInfoResult { |
| var _u BaseNetworkSocketGetIpPacketInfoResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpPacketInfoResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpPacketInfoResultTag = BaseNetworkSocketGetIpPacketInfoResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpPacketInfoResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpPacketInfoResult { |
| var _u BaseNetworkSocketGetIpPacketInfoResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpReceiveOriginalDestinationAddressResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult struct { |
| I_baseNetworkSocketGetIpReceiveOriginalDestinationAddressResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpReceiveOriginalDestinationAddressResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult) Which() I_baseNetworkSocketGetIpReceiveOriginalDestinationAddressResultTag { |
| return _m.I_baseNetworkSocketGetIpReceiveOriginalDestinationAddressResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpReceiveOriginalDestinationAddressResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult) SetResponse(response BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpReceiveOriginalDestinationAddressResultTag = BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResultWithResponse(response BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse) BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult { |
| var _u BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpReceiveOriginalDestinationAddressResultTag = BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult { |
| var _u BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpReceiveTtlResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpReceiveTtlResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpReceiveTtlResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpReceiveTtlResult struct { |
| I_baseNetworkSocketGetIpReceiveTtlResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpReceiveTtlResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpReceiveTtlResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpReceiveTtlResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpReceiveTtlResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpReceiveTtlResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTtlResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpReceiveTtlResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpReceiveTtlResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTtlResult) Which() I_baseNetworkSocketGetIpReceiveTtlResultTag { |
| return _m.I_baseNetworkSocketGetIpReceiveTtlResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTtlResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpReceiveTtlResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTtlResult) SetResponse(response BaseNetworkSocketGetIpReceiveTtlResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpReceiveTtlResultTag = BaseNetworkSocketGetIpReceiveTtlResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpReceiveTtlResultWithResponse(response BaseNetworkSocketGetIpReceiveTtlResponse) BaseNetworkSocketGetIpReceiveTtlResult { |
| var _u BaseNetworkSocketGetIpReceiveTtlResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTtlResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpReceiveTtlResultTag = BaseNetworkSocketGetIpReceiveTtlResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpReceiveTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpReceiveTtlResult { |
| var _u BaseNetworkSocketGetIpReceiveTtlResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpReceiveTypeOfServiceResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpReceiveTypeOfServiceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpReceiveTypeOfServiceResult struct { |
| I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpReceiveTypeOfServiceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpReceiveTypeOfServiceResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpReceiveTypeOfServiceResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpReceiveTypeOfServiceResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpReceiveTypeOfServiceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) Which() I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag { |
| return _m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) SetResponse(response BaseNetworkSocketGetIpReceiveTypeOfServiceResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketGetIpReceiveTypeOfServiceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpReceiveTypeOfServiceResultWithResponse(response BaseNetworkSocketGetIpReceiveTypeOfServiceResponse) BaseNetworkSocketGetIpReceiveTypeOfServiceResult { |
| var _u BaseNetworkSocketGetIpReceiveTypeOfServiceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpReceiveTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketGetIpReceiveTypeOfServiceResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpReceiveTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpReceiveTypeOfServiceResult { |
| var _u BaseNetworkSocketGetIpReceiveTypeOfServiceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpTransparentResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpTransparentResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpTransparentResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpTransparentResult struct { |
| I_baseNetworkSocketGetIpTransparentResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpTransparentResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpTransparentResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpTransparentResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpTransparentResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpTransparentResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTransparentResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpTransparentResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpTransparentResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTransparentResult) Which() I_baseNetworkSocketGetIpTransparentResultTag { |
| return _m.I_baseNetworkSocketGetIpTransparentResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTransparentResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpTransparentResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTransparentResult) SetResponse(response BaseNetworkSocketGetIpTransparentResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpTransparentResultTag = BaseNetworkSocketGetIpTransparentResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpTransparentResultWithResponse(response BaseNetworkSocketGetIpTransparentResponse) BaseNetworkSocketGetIpTransparentResult { |
| var _u BaseNetworkSocketGetIpTransparentResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTransparentResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpTransparentResultTag = BaseNetworkSocketGetIpTransparentResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpTransparentResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpTransparentResult { |
| var _u BaseNetworkSocketGetIpTransparentResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpTtlResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpTtlResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpTtlResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpTtlResult struct { |
| I_baseNetworkSocketGetIpTtlResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpTtlResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpTtlResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpTtlResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpTtlResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpTtlResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTtlResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpTtlResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpTtlResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTtlResult) Which() I_baseNetworkSocketGetIpTtlResultTag { |
| return _m.I_baseNetworkSocketGetIpTtlResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTtlResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpTtlResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTtlResult) SetResponse(response BaseNetworkSocketGetIpTtlResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpTtlResultTag = BaseNetworkSocketGetIpTtlResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpTtlResultWithResponse(response BaseNetworkSocketGetIpTtlResponse) BaseNetworkSocketGetIpTtlResult { |
| var _u BaseNetworkSocketGetIpTtlResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTtlResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpTtlResultTag = BaseNetworkSocketGetIpTtlResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpTtlResult { |
| var _u BaseNetworkSocketGetIpTtlResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpTypeOfServiceResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpTypeOfServiceResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpTypeOfServiceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpTypeOfServiceResult struct { |
| I_baseNetworkSocketGetIpTypeOfServiceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpTypeOfServiceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpTypeOfServiceResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpTypeOfServiceResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpTypeOfServiceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpTypeOfServiceResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpTypeOfServiceResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpTypeOfServiceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) Which() I_baseNetworkSocketGetIpTypeOfServiceResultTag { |
| return _m.I_baseNetworkSocketGetIpTypeOfServiceResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpTypeOfServiceResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) SetResponse(response BaseNetworkSocketGetIpTypeOfServiceResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpTypeOfServiceResultTag = BaseNetworkSocketGetIpTypeOfServiceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpTypeOfServiceResultWithResponse(response BaseNetworkSocketGetIpTypeOfServiceResponse) BaseNetworkSocketGetIpTypeOfServiceResult { |
| var _u BaseNetworkSocketGetIpTypeOfServiceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpTypeOfServiceResultTag = BaseNetworkSocketGetIpTypeOfServiceResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpTypeOfServiceResult { |
| var _u BaseNetworkSocketGetIpTypeOfServiceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpv6MulticastHopsResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpv6MulticastHopsResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpv6MulticastHopsResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpv6MulticastHopsResult struct { |
| I_baseNetworkSocketGetIpv6MulticastHopsResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpv6MulticastHopsResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6MulticastHopsResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6MulticastHopsResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6MulticastHopsResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6MulticastHopsResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpv6MulticastHopsResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) Which() I_baseNetworkSocketGetIpv6MulticastHopsResultTag { |
| return _m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) SetResponse(response BaseNetworkSocketGetIpv6MulticastHopsResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag = BaseNetworkSocketGetIpv6MulticastHopsResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpv6MulticastHopsResultWithResponse(response BaseNetworkSocketGetIpv6MulticastHopsResponse) BaseNetworkSocketGetIpv6MulticastHopsResult { |
| var _u BaseNetworkSocketGetIpv6MulticastHopsResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastHopsResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6MulticastHopsResultTag = BaseNetworkSocketGetIpv6MulticastHopsResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpv6MulticastHopsResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6MulticastHopsResult { |
| var _u BaseNetworkSocketGetIpv6MulticastHopsResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpv6MulticastInterfaceResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpv6MulticastInterfaceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpv6MulticastInterfaceResult struct { |
| I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpv6MulticastInterfaceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6MulticastInterfaceResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6MulticastInterfaceResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6MulticastInterfaceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6MulticastInterfaceResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpv6MulticastInterfaceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) Which() I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag { |
| return _m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) SetResponse(response BaseNetworkSocketGetIpv6MulticastInterfaceResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag = BaseNetworkSocketGetIpv6MulticastInterfaceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpv6MulticastInterfaceResultWithResponse(response BaseNetworkSocketGetIpv6MulticastInterfaceResponse) BaseNetworkSocketGetIpv6MulticastInterfaceResult { |
| var _u BaseNetworkSocketGetIpv6MulticastInterfaceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6MulticastInterfaceResultTag = BaseNetworkSocketGetIpv6MulticastInterfaceResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpv6MulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6MulticastInterfaceResult { |
| var _u BaseNetworkSocketGetIpv6MulticastInterfaceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpv6MulticastLoopbackResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpv6MulticastLoopbackResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpv6MulticastLoopbackResult struct { |
| I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpv6MulticastLoopbackResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6MulticastLoopbackResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6MulticastLoopbackResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6MulticastLoopbackResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6MulticastLoopbackResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpv6MulticastLoopbackResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) Which() I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag { |
| return _m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) SetResponse(response BaseNetworkSocketGetIpv6MulticastLoopbackResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag = BaseNetworkSocketGetIpv6MulticastLoopbackResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpv6MulticastLoopbackResultWithResponse(response BaseNetworkSocketGetIpv6MulticastLoopbackResponse) BaseNetworkSocketGetIpv6MulticastLoopbackResult { |
| var _u BaseNetworkSocketGetIpv6MulticastLoopbackResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6MulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6MulticastLoopbackResultTag = BaseNetworkSocketGetIpv6MulticastLoopbackResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpv6MulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6MulticastLoopbackResult { |
| var _u BaseNetworkSocketGetIpv6MulticastLoopbackResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpv6OnlyResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpv6OnlyResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpv6OnlyResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpv6OnlyResult struct { |
| I_baseNetworkSocketGetIpv6OnlyResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpv6OnlyResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6OnlyResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6OnlyResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6OnlyResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6OnlyResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6OnlyResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpv6OnlyResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpv6OnlyResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6OnlyResult) Which() I_baseNetworkSocketGetIpv6OnlyResultTag { |
| return _m.I_baseNetworkSocketGetIpv6OnlyResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6OnlyResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpv6OnlyResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6OnlyResult) SetResponse(response BaseNetworkSocketGetIpv6OnlyResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6OnlyResultTag = BaseNetworkSocketGetIpv6OnlyResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpv6OnlyResultWithResponse(response BaseNetworkSocketGetIpv6OnlyResponse) BaseNetworkSocketGetIpv6OnlyResult { |
| var _u BaseNetworkSocketGetIpv6OnlyResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6OnlyResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6OnlyResultTag = BaseNetworkSocketGetIpv6OnlyResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpv6OnlyResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6OnlyResult { |
| var _u BaseNetworkSocketGetIpv6OnlyResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpv6ReceiveHopLimitResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpv6ReceiveHopLimitResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpv6ReceiveHopLimitResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpv6ReceiveHopLimitResult struct { |
| I_baseNetworkSocketGetIpv6ReceiveHopLimitResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpv6ReceiveHopLimitResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6ReceiveHopLimitResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6ReceiveHopLimitResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6ReceiveHopLimitResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6ReceiveHopLimitResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveHopLimitResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpv6ReceiveHopLimitResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpv6ReceiveHopLimitResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveHopLimitResult) Which() I_baseNetworkSocketGetIpv6ReceiveHopLimitResultTag { |
| return _m.I_baseNetworkSocketGetIpv6ReceiveHopLimitResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveHopLimitResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpv6ReceiveHopLimitResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveHopLimitResult) SetResponse(response BaseNetworkSocketGetIpv6ReceiveHopLimitResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6ReceiveHopLimitResultTag = BaseNetworkSocketGetIpv6ReceiveHopLimitResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpv6ReceiveHopLimitResultWithResponse(response BaseNetworkSocketGetIpv6ReceiveHopLimitResponse) BaseNetworkSocketGetIpv6ReceiveHopLimitResult { |
| var _u BaseNetworkSocketGetIpv6ReceiveHopLimitResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveHopLimitResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6ReceiveHopLimitResultTag = BaseNetworkSocketGetIpv6ReceiveHopLimitResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpv6ReceiveHopLimitResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6ReceiveHopLimitResult { |
| var _u BaseNetworkSocketGetIpv6ReceiveHopLimitResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpv6ReceivePacketInfoResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpv6ReceivePacketInfoResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpv6ReceivePacketInfoResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpv6ReceivePacketInfoResult struct { |
| I_baseNetworkSocketGetIpv6ReceivePacketInfoResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpv6ReceivePacketInfoResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6ReceivePacketInfoResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6ReceivePacketInfoResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6ReceivePacketInfoResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6ReceivePacketInfoResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceivePacketInfoResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpv6ReceivePacketInfoResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpv6ReceivePacketInfoResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceivePacketInfoResult) Which() I_baseNetworkSocketGetIpv6ReceivePacketInfoResultTag { |
| return _m.I_baseNetworkSocketGetIpv6ReceivePacketInfoResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceivePacketInfoResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpv6ReceivePacketInfoResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceivePacketInfoResult) SetResponse(response BaseNetworkSocketGetIpv6ReceivePacketInfoResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6ReceivePacketInfoResultTag = BaseNetworkSocketGetIpv6ReceivePacketInfoResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpv6ReceivePacketInfoResultWithResponse(response BaseNetworkSocketGetIpv6ReceivePacketInfoResponse) BaseNetworkSocketGetIpv6ReceivePacketInfoResult { |
| var _u BaseNetworkSocketGetIpv6ReceivePacketInfoResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceivePacketInfoResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6ReceivePacketInfoResultTag = BaseNetworkSocketGetIpv6ReceivePacketInfoResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpv6ReceivePacketInfoResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6ReceivePacketInfoResult { |
| var _u BaseNetworkSocketGetIpv6ReceivePacketInfoResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpv6ReceiveTrafficClassResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpv6ReceiveTrafficClassResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpv6ReceiveTrafficClassResult struct { |
| I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6ReceiveTrafficClassResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6ReceiveTrafficClassResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6ReceiveTrafficClassResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) Which() I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag { |
| return _m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) SetResponse(response BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketGetIpv6ReceiveTrafficClassResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpv6ReceiveTrafficClassResultWithResponse(response BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse) BaseNetworkSocketGetIpv6ReceiveTrafficClassResult { |
| var _u BaseNetworkSocketGetIpv6ReceiveTrafficClassResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6ReceiveTrafficClassResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketGetIpv6ReceiveTrafficClassResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpv6ReceiveTrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6ReceiveTrafficClassResult { |
| var _u BaseNetworkSocketGetIpv6ReceiveTrafficClassResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpv6TrafficClassResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpv6TrafficClassResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpv6TrafficClassResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpv6TrafficClassResult struct { |
| I_baseNetworkSocketGetIpv6TrafficClassResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpv6TrafficClassResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6TrafficClassResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6TrafficClassResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6TrafficClassResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6TrafficClassResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpv6TrafficClassResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpv6TrafficClassResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) Which() I_baseNetworkSocketGetIpv6TrafficClassResultTag { |
| return _m.I_baseNetworkSocketGetIpv6TrafficClassResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpv6TrafficClassResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) SetResponse(response BaseNetworkSocketGetIpv6TrafficClassResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6TrafficClassResultTag = BaseNetworkSocketGetIpv6TrafficClassResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpv6TrafficClassResultWithResponse(response BaseNetworkSocketGetIpv6TrafficClassResponse) BaseNetworkSocketGetIpv6TrafficClassResult { |
| var _u BaseNetworkSocketGetIpv6TrafficClassResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6TrafficClassResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6TrafficClassResultTag = BaseNetworkSocketGetIpv6TrafficClassResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpv6TrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6TrafficClassResult { |
| var _u BaseNetworkSocketGetIpv6TrafficClassResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetIpv6UnicastHopsResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetIpv6UnicastHopsResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetIpv6UnicastHopsResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetIpv6UnicastHopsResult struct { |
| I_baseNetworkSocketGetIpv6UnicastHopsResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetIpv6UnicastHopsResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetIpv6UnicastHopsResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetIpv6UnicastHopsResult{}) |
| |
| func (msg *BaseNetworkSocketGetIpv6UnicastHopsResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetIpv6UnicastHopsResult |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6UnicastHopsResult) reset() { |
| switch _m.I_baseNetworkSocketGetIpv6UnicastHopsResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetIpv6UnicastHopsResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6UnicastHopsResult) Which() I_baseNetworkSocketGetIpv6UnicastHopsResultTag { |
| return _m.I_baseNetworkSocketGetIpv6UnicastHopsResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6UnicastHopsResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetIpv6UnicastHopsResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6UnicastHopsResult) SetResponse(response BaseNetworkSocketGetIpv6UnicastHopsResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6UnicastHopsResultTag = BaseNetworkSocketGetIpv6UnicastHopsResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetIpv6UnicastHopsResultWithResponse(response BaseNetworkSocketGetIpv6UnicastHopsResponse) BaseNetworkSocketGetIpv6UnicastHopsResult { |
| var _u BaseNetworkSocketGetIpv6UnicastHopsResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetIpv6UnicastHopsResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetIpv6UnicastHopsResultTag = BaseNetworkSocketGetIpv6UnicastHopsResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetIpv6UnicastHopsResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetIpv6UnicastHopsResult { |
| var _u BaseNetworkSocketGetIpv6UnicastHopsResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetOriginalDestinationResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetOriginalDestinationResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetOriginalDestinationResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetOriginalDestinationResult struct { |
| I_baseNetworkSocketGetOriginalDestinationResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetOriginalDestinationResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetOriginalDestinationResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetOriginalDestinationResult{}) |
| |
| func (msg *BaseNetworkSocketGetOriginalDestinationResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetOriginalDestinationResult |
| } |
| |
| func (_m *BaseNetworkSocketGetOriginalDestinationResult) reset() { |
| switch _m.I_baseNetworkSocketGetOriginalDestinationResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetOriginalDestinationResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetOriginalDestinationResult) Which() I_baseNetworkSocketGetOriginalDestinationResultTag { |
| return _m.I_baseNetworkSocketGetOriginalDestinationResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetOriginalDestinationResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetOriginalDestinationResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetOriginalDestinationResult) SetResponse(response BaseNetworkSocketGetOriginalDestinationResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetOriginalDestinationResultTag = BaseNetworkSocketGetOriginalDestinationResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetOriginalDestinationResultWithResponse(response BaseNetworkSocketGetOriginalDestinationResponse) BaseNetworkSocketGetOriginalDestinationResult { |
| var _u BaseNetworkSocketGetOriginalDestinationResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetOriginalDestinationResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetOriginalDestinationResultTag = BaseNetworkSocketGetOriginalDestinationResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetOriginalDestinationResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetOriginalDestinationResult { |
| var _u BaseNetworkSocketGetOriginalDestinationResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetPeerNameResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetPeerNameResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetPeerNameResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetPeerNameResult struct { |
| I_baseNetworkSocketGetPeerNameResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetPeerNameResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetPeerNameResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetPeerNameResult{}) |
| |
| func (msg *BaseNetworkSocketGetPeerNameResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetPeerNameResult |
| } |
| |
| func (_m *BaseNetworkSocketGetPeerNameResult) reset() { |
| switch _m.I_baseNetworkSocketGetPeerNameResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetPeerNameResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetPeerNameResult) Which() I_baseNetworkSocketGetPeerNameResultTag { |
| return _m.I_baseNetworkSocketGetPeerNameResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetPeerNameResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetPeerNameResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetPeerNameResult) SetResponse(response BaseNetworkSocketGetPeerNameResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetPeerNameResultTag = BaseNetworkSocketGetPeerNameResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetPeerNameResultWithResponse(response BaseNetworkSocketGetPeerNameResponse) BaseNetworkSocketGetPeerNameResult { |
| var _u BaseNetworkSocketGetPeerNameResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetPeerNameResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetPeerNameResultTag = BaseNetworkSocketGetPeerNameResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetPeerNameResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetPeerNameResult { |
| var _u BaseNetworkSocketGetPeerNameResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketGetSockNameResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketGetSockNameResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketGetSockNameResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketGetSockNameResult struct { |
| I_baseNetworkSocketGetSockNameResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketGetSockNameResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketGetSockNameResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketGetSockNameResult{}) |
| |
| func (msg *BaseNetworkSocketGetSockNameResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketGetSockNameResult |
| } |
| |
| func (_m *BaseNetworkSocketGetSockNameResult) reset() { |
| switch _m.I_baseNetworkSocketGetSockNameResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketGetSockNameResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketGetSockNameResult) Which() I_baseNetworkSocketGetSockNameResultTag { |
| return _m.I_baseNetworkSocketGetSockNameResultTag |
| } |
| |
| func (_m *BaseNetworkSocketGetSockNameResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketGetSockNameResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketGetSockNameResult) SetResponse(response BaseNetworkSocketGetSockNameResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetSockNameResultTag = BaseNetworkSocketGetSockNameResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketGetSockNameResultWithResponse(response BaseNetworkSocketGetSockNameResponse) BaseNetworkSocketGetSockNameResult { |
| var _u BaseNetworkSocketGetSockNameResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketGetSockNameResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketGetSockNameResultTag = BaseNetworkSocketGetSockNameResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketGetSockNameResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketGetSockNameResult { |
| var _u BaseNetworkSocketGetSockNameResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpMulticastInterfaceResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpMulticastInterfaceResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpMulticastInterfaceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpMulticastInterfaceResult struct { |
| I_baseNetworkSocketSetIpMulticastInterfaceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpMulticastInterfaceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpMulticastInterfaceResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastInterfaceResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpMulticastInterfaceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpMulticastInterfaceResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpMulticastInterfaceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) Which() I_baseNetworkSocketSetIpMulticastInterfaceResultTag { |
| return _m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) SetResponse(response BaseNetworkSocketSetIpMulticastInterfaceResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag = BaseNetworkSocketSetIpMulticastInterfaceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpMulticastInterfaceResultWithResponse(response BaseNetworkSocketSetIpMulticastInterfaceResponse) BaseNetworkSocketSetIpMulticastInterfaceResult { |
| var _u BaseNetworkSocketSetIpMulticastInterfaceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpMulticastInterfaceResultTag = BaseNetworkSocketSetIpMulticastInterfaceResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpMulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpMulticastInterfaceResult { |
| var _u BaseNetworkSocketSetIpMulticastInterfaceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpMulticastLoopbackResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpMulticastLoopbackResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpMulticastLoopbackResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpMulticastLoopbackResult struct { |
| I_baseNetworkSocketSetIpMulticastLoopbackResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpMulticastLoopbackResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpMulticastLoopbackResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastLoopbackResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpMulticastLoopbackResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpMulticastLoopbackResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpMulticastLoopbackResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) Which() I_baseNetworkSocketSetIpMulticastLoopbackResultTag { |
| return _m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) SetResponse(response BaseNetworkSocketSetIpMulticastLoopbackResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag = BaseNetworkSocketSetIpMulticastLoopbackResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpMulticastLoopbackResultWithResponse(response BaseNetworkSocketSetIpMulticastLoopbackResponse) BaseNetworkSocketSetIpMulticastLoopbackResult { |
| var _u BaseNetworkSocketSetIpMulticastLoopbackResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpMulticastLoopbackResultTag = BaseNetworkSocketSetIpMulticastLoopbackResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpMulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpMulticastLoopbackResult { |
| var _u BaseNetworkSocketSetIpMulticastLoopbackResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpMulticastTtlResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpMulticastTtlResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpMulticastTtlResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpMulticastTtlResult struct { |
| I_baseNetworkSocketSetIpMulticastTtlResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpMulticastTtlResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpMulticastTtlResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpMulticastTtlResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpMulticastTtlResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpMulticastTtlResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastTtlResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpMulticastTtlResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpMulticastTtlResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastTtlResult) Which() I_baseNetworkSocketSetIpMulticastTtlResultTag { |
| return _m.I_baseNetworkSocketSetIpMulticastTtlResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastTtlResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpMulticastTtlResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastTtlResult) SetResponse(response BaseNetworkSocketSetIpMulticastTtlResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpMulticastTtlResultTag = BaseNetworkSocketSetIpMulticastTtlResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpMulticastTtlResultWithResponse(response BaseNetworkSocketSetIpMulticastTtlResponse) BaseNetworkSocketSetIpMulticastTtlResult { |
| var _u BaseNetworkSocketSetIpMulticastTtlResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpMulticastTtlResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpMulticastTtlResultTag = BaseNetworkSocketSetIpMulticastTtlResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpMulticastTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpMulticastTtlResult { |
| var _u BaseNetworkSocketSetIpMulticastTtlResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpPacketInfoResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpPacketInfoResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpPacketInfoResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpPacketInfoResult struct { |
| I_baseNetworkSocketSetIpPacketInfoResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpPacketInfoResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpPacketInfoResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpPacketInfoResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpPacketInfoResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpPacketInfoResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpPacketInfoResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpPacketInfoResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpPacketInfoResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpPacketInfoResult) Which() I_baseNetworkSocketSetIpPacketInfoResultTag { |
| return _m.I_baseNetworkSocketSetIpPacketInfoResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpPacketInfoResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpPacketInfoResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpPacketInfoResult) SetResponse(response BaseNetworkSocketSetIpPacketInfoResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpPacketInfoResultTag = BaseNetworkSocketSetIpPacketInfoResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpPacketInfoResultWithResponse(response BaseNetworkSocketSetIpPacketInfoResponse) BaseNetworkSocketSetIpPacketInfoResult { |
| var _u BaseNetworkSocketSetIpPacketInfoResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpPacketInfoResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpPacketInfoResultTag = BaseNetworkSocketSetIpPacketInfoResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpPacketInfoResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpPacketInfoResult { |
| var _u BaseNetworkSocketSetIpPacketInfoResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpReceiveOriginalDestinationAddressResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult struct { |
| I_baseNetworkSocketSetIpReceiveOriginalDestinationAddressResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpReceiveOriginalDestinationAddressResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult) Which() I_baseNetworkSocketSetIpReceiveOriginalDestinationAddressResultTag { |
| return _m.I_baseNetworkSocketSetIpReceiveOriginalDestinationAddressResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpReceiveOriginalDestinationAddressResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult) SetResponse(response BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpReceiveOriginalDestinationAddressResultTag = BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResultWithResponse(response BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponse) BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult { |
| var _u BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpReceiveOriginalDestinationAddressResultTag = BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult { |
| var _u BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpReceiveTtlResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpReceiveTtlResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpReceiveTtlResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpReceiveTtlResult struct { |
| I_baseNetworkSocketSetIpReceiveTtlResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpReceiveTtlResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpReceiveTtlResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveTtlResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpReceiveTtlResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpReceiveTtlResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTtlResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpReceiveTtlResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpReceiveTtlResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTtlResult) Which() I_baseNetworkSocketSetIpReceiveTtlResultTag { |
| return _m.I_baseNetworkSocketSetIpReceiveTtlResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTtlResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpReceiveTtlResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTtlResult) SetResponse(response BaseNetworkSocketSetIpReceiveTtlResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpReceiveTtlResultTag = BaseNetworkSocketSetIpReceiveTtlResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpReceiveTtlResultWithResponse(response BaseNetworkSocketSetIpReceiveTtlResponse) BaseNetworkSocketSetIpReceiveTtlResult { |
| var _u BaseNetworkSocketSetIpReceiveTtlResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTtlResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpReceiveTtlResultTag = BaseNetworkSocketSetIpReceiveTtlResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpReceiveTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpReceiveTtlResult { |
| var _u BaseNetworkSocketSetIpReceiveTtlResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpReceiveTypeOfServiceResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpReceiveTypeOfServiceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpReceiveTypeOfServiceResult struct { |
| I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpReceiveTypeOfServiceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpReceiveTypeOfServiceResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpReceiveTypeOfServiceResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpReceiveTypeOfServiceResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpReceiveTypeOfServiceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) Which() I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag { |
| return _m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) SetResponse(response BaseNetworkSocketSetIpReceiveTypeOfServiceResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketSetIpReceiveTypeOfServiceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpReceiveTypeOfServiceResultWithResponse(response BaseNetworkSocketSetIpReceiveTypeOfServiceResponse) BaseNetworkSocketSetIpReceiveTypeOfServiceResult { |
| var _u BaseNetworkSocketSetIpReceiveTypeOfServiceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpReceiveTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpReceiveTypeOfServiceResultTag = BaseNetworkSocketSetIpReceiveTypeOfServiceResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpReceiveTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpReceiveTypeOfServiceResult { |
| var _u BaseNetworkSocketSetIpReceiveTypeOfServiceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpTransparentResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpTransparentResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpTransparentResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpTransparentResult struct { |
| I_baseNetworkSocketSetIpTransparentResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpTransparentResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpTransparentResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTransparentResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpTransparentResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpTransparentResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTransparentResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpTransparentResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpTransparentResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTransparentResult) Which() I_baseNetworkSocketSetIpTransparentResultTag { |
| return _m.I_baseNetworkSocketSetIpTransparentResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTransparentResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpTransparentResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTransparentResult) SetResponse(response BaseNetworkSocketSetIpTransparentResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpTransparentResultTag = BaseNetworkSocketSetIpTransparentResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpTransparentResultWithResponse(response BaseNetworkSocketSetIpTransparentResponse) BaseNetworkSocketSetIpTransparentResult { |
| var _u BaseNetworkSocketSetIpTransparentResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTransparentResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpTransparentResultTag = BaseNetworkSocketSetIpTransparentResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpTransparentResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpTransparentResult { |
| var _u BaseNetworkSocketSetIpTransparentResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpTtlResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpTtlResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpTtlResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpTtlResult struct { |
| I_baseNetworkSocketSetIpTtlResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpTtlResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpTtlResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTtlResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpTtlResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpTtlResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTtlResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpTtlResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpTtlResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTtlResult) Which() I_baseNetworkSocketSetIpTtlResultTag { |
| return _m.I_baseNetworkSocketSetIpTtlResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTtlResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpTtlResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTtlResult) SetResponse(response BaseNetworkSocketSetIpTtlResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpTtlResultTag = BaseNetworkSocketSetIpTtlResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpTtlResultWithResponse(response BaseNetworkSocketSetIpTtlResponse) BaseNetworkSocketSetIpTtlResult { |
| var _u BaseNetworkSocketSetIpTtlResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTtlResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpTtlResultTag = BaseNetworkSocketSetIpTtlResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpTtlResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpTtlResult { |
| var _u BaseNetworkSocketSetIpTtlResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpTypeOfServiceResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpTypeOfServiceResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpTypeOfServiceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpTypeOfServiceResult struct { |
| I_baseNetworkSocketSetIpTypeOfServiceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpTypeOfServiceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpTypeOfServiceResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpTypeOfServiceResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpTypeOfServiceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpTypeOfServiceResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpTypeOfServiceResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpTypeOfServiceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) Which() I_baseNetworkSocketSetIpTypeOfServiceResultTag { |
| return _m.I_baseNetworkSocketSetIpTypeOfServiceResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpTypeOfServiceResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) SetResponse(response BaseNetworkSocketSetIpTypeOfServiceResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpTypeOfServiceResultTag = BaseNetworkSocketSetIpTypeOfServiceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpTypeOfServiceResultWithResponse(response BaseNetworkSocketSetIpTypeOfServiceResponse) BaseNetworkSocketSetIpTypeOfServiceResult { |
| var _u BaseNetworkSocketSetIpTypeOfServiceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpTypeOfServiceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpTypeOfServiceResultTag = BaseNetworkSocketSetIpTypeOfServiceResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpTypeOfServiceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpTypeOfServiceResult { |
| var _u BaseNetworkSocketSetIpTypeOfServiceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpv6MulticastHopsResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpv6MulticastHopsResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpv6MulticastHopsResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpv6MulticastHopsResult struct { |
| I_baseNetworkSocketSetIpv6MulticastHopsResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpv6MulticastHopsResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6MulticastHopsResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastHopsResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6MulticastHopsResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6MulticastHopsResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpv6MulticastHopsResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) Which() I_baseNetworkSocketSetIpv6MulticastHopsResultTag { |
| return _m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) SetResponse(response BaseNetworkSocketSetIpv6MulticastHopsResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag = BaseNetworkSocketSetIpv6MulticastHopsResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpv6MulticastHopsResultWithResponse(response BaseNetworkSocketSetIpv6MulticastHopsResponse) BaseNetworkSocketSetIpv6MulticastHopsResult { |
| var _u BaseNetworkSocketSetIpv6MulticastHopsResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastHopsResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6MulticastHopsResultTag = BaseNetworkSocketSetIpv6MulticastHopsResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpv6MulticastHopsResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6MulticastHopsResult { |
| var _u BaseNetworkSocketSetIpv6MulticastHopsResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpv6MulticastInterfaceResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpv6MulticastInterfaceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpv6MulticastInterfaceResult struct { |
| I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpv6MulticastInterfaceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6MulticastInterfaceResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastInterfaceResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6MulticastInterfaceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6MulticastInterfaceResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpv6MulticastInterfaceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) Which() I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag { |
| return _m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) SetResponse(response BaseNetworkSocketSetIpv6MulticastInterfaceResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag = BaseNetworkSocketSetIpv6MulticastInterfaceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpv6MulticastInterfaceResultWithResponse(response BaseNetworkSocketSetIpv6MulticastInterfaceResponse) BaseNetworkSocketSetIpv6MulticastInterfaceResult { |
| var _u BaseNetworkSocketSetIpv6MulticastInterfaceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastInterfaceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6MulticastInterfaceResultTag = BaseNetworkSocketSetIpv6MulticastInterfaceResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpv6MulticastInterfaceResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6MulticastInterfaceResult { |
| var _u BaseNetworkSocketSetIpv6MulticastInterfaceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpv6MulticastLoopbackResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpv6MulticastLoopbackResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpv6MulticastLoopbackResult struct { |
| I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpv6MulticastLoopbackResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6MulticastLoopbackResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6MulticastLoopbackResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6MulticastLoopbackResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6MulticastLoopbackResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpv6MulticastLoopbackResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) Which() I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag { |
| return _m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) SetResponse(response BaseNetworkSocketSetIpv6MulticastLoopbackResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag = BaseNetworkSocketSetIpv6MulticastLoopbackResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpv6MulticastLoopbackResultWithResponse(response BaseNetworkSocketSetIpv6MulticastLoopbackResponse) BaseNetworkSocketSetIpv6MulticastLoopbackResult { |
| var _u BaseNetworkSocketSetIpv6MulticastLoopbackResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6MulticastLoopbackResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6MulticastLoopbackResultTag = BaseNetworkSocketSetIpv6MulticastLoopbackResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpv6MulticastLoopbackResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6MulticastLoopbackResult { |
| var _u BaseNetworkSocketSetIpv6MulticastLoopbackResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpv6OnlyResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpv6OnlyResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpv6OnlyResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpv6OnlyResult struct { |
| I_baseNetworkSocketSetIpv6OnlyResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpv6OnlyResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6OnlyResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6OnlyResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6OnlyResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6OnlyResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6OnlyResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpv6OnlyResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpv6OnlyResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6OnlyResult) Which() I_baseNetworkSocketSetIpv6OnlyResultTag { |
| return _m.I_baseNetworkSocketSetIpv6OnlyResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6OnlyResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpv6OnlyResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6OnlyResult) SetResponse(response BaseNetworkSocketSetIpv6OnlyResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6OnlyResultTag = BaseNetworkSocketSetIpv6OnlyResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpv6OnlyResultWithResponse(response BaseNetworkSocketSetIpv6OnlyResponse) BaseNetworkSocketSetIpv6OnlyResult { |
| var _u BaseNetworkSocketSetIpv6OnlyResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6OnlyResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6OnlyResultTag = BaseNetworkSocketSetIpv6OnlyResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpv6OnlyResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6OnlyResult { |
| var _u BaseNetworkSocketSetIpv6OnlyResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpv6ReceiveHopLimitResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpv6ReceiveHopLimitResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpv6ReceiveHopLimitResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpv6ReceiveHopLimitResult struct { |
| I_baseNetworkSocketSetIpv6ReceiveHopLimitResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpv6ReceiveHopLimitResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6ReceiveHopLimitResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceiveHopLimitResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6ReceiveHopLimitResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6ReceiveHopLimitResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveHopLimitResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpv6ReceiveHopLimitResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpv6ReceiveHopLimitResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveHopLimitResult) Which() I_baseNetworkSocketSetIpv6ReceiveHopLimitResultTag { |
| return _m.I_baseNetworkSocketSetIpv6ReceiveHopLimitResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveHopLimitResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpv6ReceiveHopLimitResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveHopLimitResult) SetResponse(response BaseNetworkSocketSetIpv6ReceiveHopLimitResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6ReceiveHopLimitResultTag = BaseNetworkSocketSetIpv6ReceiveHopLimitResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpv6ReceiveHopLimitResultWithResponse(response BaseNetworkSocketSetIpv6ReceiveHopLimitResponse) BaseNetworkSocketSetIpv6ReceiveHopLimitResult { |
| var _u BaseNetworkSocketSetIpv6ReceiveHopLimitResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveHopLimitResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6ReceiveHopLimitResultTag = BaseNetworkSocketSetIpv6ReceiveHopLimitResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpv6ReceiveHopLimitResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6ReceiveHopLimitResult { |
| var _u BaseNetworkSocketSetIpv6ReceiveHopLimitResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpv6ReceivePacketInfoResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpv6ReceivePacketInfoResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpv6ReceivePacketInfoResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpv6ReceivePacketInfoResult struct { |
| I_baseNetworkSocketSetIpv6ReceivePacketInfoResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpv6ReceivePacketInfoResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6ReceivePacketInfoResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceivePacketInfoResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6ReceivePacketInfoResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6ReceivePacketInfoResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceivePacketInfoResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpv6ReceivePacketInfoResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpv6ReceivePacketInfoResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceivePacketInfoResult) Which() I_baseNetworkSocketSetIpv6ReceivePacketInfoResultTag { |
| return _m.I_baseNetworkSocketSetIpv6ReceivePacketInfoResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceivePacketInfoResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpv6ReceivePacketInfoResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceivePacketInfoResult) SetResponse(response BaseNetworkSocketSetIpv6ReceivePacketInfoResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6ReceivePacketInfoResultTag = BaseNetworkSocketSetIpv6ReceivePacketInfoResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpv6ReceivePacketInfoResultWithResponse(response BaseNetworkSocketSetIpv6ReceivePacketInfoResponse) BaseNetworkSocketSetIpv6ReceivePacketInfoResult { |
| var _u BaseNetworkSocketSetIpv6ReceivePacketInfoResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceivePacketInfoResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6ReceivePacketInfoResultTag = BaseNetworkSocketSetIpv6ReceivePacketInfoResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpv6ReceivePacketInfoResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6ReceivePacketInfoResult { |
| var _u BaseNetworkSocketSetIpv6ReceivePacketInfoResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpv6ReceiveTrafficClassResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpv6ReceiveTrafficClassResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpv6ReceiveTrafficClassResult struct { |
| I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6ReceiveTrafficClassResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6ReceiveTrafficClassResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6ReceiveTrafficClassResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) Which() I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag { |
| return _m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) SetResponse(response BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketSetIpv6ReceiveTrafficClassResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpv6ReceiveTrafficClassResultWithResponse(response BaseNetworkSocketSetIpv6ReceiveTrafficClassResponse) BaseNetworkSocketSetIpv6ReceiveTrafficClassResult { |
| var _u BaseNetworkSocketSetIpv6ReceiveTrafficClassResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6ReceiveTrafficClassResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6ReceiveTrafficClassResultTag = BaseNetworkSocketSetIpv6ReceiveTrafficClassResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpv6ReceiveTrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6ReceiveTrafficClassResult { |
| var _u BaseNetworkSocketSetIpv6ReceiveTrafficClassResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpv6TrafficClassResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpv6TrafficClassResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpv6TrafficClassResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpv6TrafficClassResult struct { |
| I_baseNetworkSocketSetIpv6TrafficClassResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpv6TrafficClassResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6TrafficClassResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6TrafficClassResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6TrafficClassResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6TrafficClassResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpv6TrafficClassResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpv6TrafficClassResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) Which() I_baseNetworkSocketSetIpv6TrafficClassResultTag { |
| return _m.I_baseNetworkSocketSetIpv6TrafficClassResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpv6TrafficClassResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) SetResponse(response BaseNetworkSocketSetIpv6TrafficClassResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6TrafficClassResultTag = BaseNetworkSocketSetIpv6TrafficClassResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpv6TrafficClassResultWithResponse(response BaseNetworkSocketSetIpv6TrafficClassResponse) BaseNetworkSocketSetIpv6TrafficClassResult { |
| var _u BaseNetworkSocketSetIpv6TrafficClassResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6TrafficClassResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6TrafficClassResultTag = BaseNetworkSocketSetIpv6TrafficClassResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpv6TrafficClassResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6TrafficClassResult { |
| var _u BaseNetworkSocketSetIpv6TrafficClassResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketSetIpv6UnicastHopsResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketSetIpv6UnicastHopsResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketSetIpv6UnicastHopsResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketSetIpv6UnicastHopsResult struct { |
| I_baseNetworkSocketSetIpv6UnicastHopsResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketSetIpv6UnicastHopsResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketSetIpv6UnicastHopsResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketSetIpv6UnicastHopsResult{}) |
| |
| func (msg *BaseNetworkSocketSetIpv6UnicastHopsResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketSetIpv6UnicastHopsResult |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6UnicastHopsResult) reset() { |
| switch _m.I_baseNetworkSocketSetIpv6UnicastHopsResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketSetIpv6UnicastHopsResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6UnicastHopsResult) Which() I_baseNetworkSocketSetIpv6UnicastHopsResultTag { |
| return _m.I_baseNetworkSocketSetIpv6UnicastHopsResultTag |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6UnicastHopsResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketSetIpv6UnicastHopsResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6UnicastHopsResult) SetResponse(response BaseNetworkSocketSetIpv6UnicastHopsResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6UnicastHopsResultTag = BaseNetworkSocketSetIpv6UnicastHopsResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketSetIpv6UnicastHopsResultWithResponse(response BaseNetworkSocketSetIpv6UnicastHopsResponse) BaseNetworkSocketSetIpv6UnicastHopsResult { |
| var _u BaseNetworkSocketSetIpv6UnicastHopsResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketSetIpv6UnicastHopsResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketSetIpv6UnicastHopsResultTag = BaseNetworkSocketSetIpv6UnicastHopsResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketSetIpv6UnicastHopsResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketSetIpv6UnicastHopsResult { |
| var _u BaseNetworkSocketSetIpv6UnicastHopsResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseNetworkSocketShutdownResultTag uint64 |
| |
| const ( |
| BaseNetworkSocketShutdownResultResponse = 1 // 0x00000001 |
| BaseNetworkSocketShutdownResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseNetworkSocketShutdownResult struct { |
| I_baseNetworkSocketShutdownResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseNetworkSocketShutdownResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseNetworkSocketShutdownResult = _bindings.CreateLazyMarshaler(BaseNetworkSocketShutdownResult{}) |
| |
| func (msg *BaseNetworkSocketShutdownResult) Marshaler() _bindings.Marshaler { |
| return _mBaseNetworkSocketShutdownResult |
| } |
| |
| func (_m *BaseNetworkSocketShutdownResult) reset() { |
| switch _m.I_baseNetworkSocketShutdownResultTag { |
| case 1: |
| var _zeroed BaseNetworkSocketShutdownResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseNetworkSocketShutdownResult) Which() I_baseNetworkSocketShutdownResultTag { |
| return _m.I_baseNetworkSocketShutdownResultTag |
| } |
| |
| func (_m *BaseNetworkSocketShutdownResult) Ordinal() uint64 { |
| return uint64(_m.I_baseNetworkSocketShutdownResultTag) |
| } |
| |
| func (_m *BaseNetworkSocketShutdownResult) SetResponse(response BaseNetworkSocketShutdownResponse) { |
| _m.reset() |
| _m.I_baseNetworkSocketShutdownResultTag = BaseNetworkSocketShutdownResultResponse |
| _m.Response = response |
| } |
| |
| func BaseNetworkSocketShutdownResultWithResponse(response BaseNetworkSocketShutdownResponse) BaseNetworkSocketShutdownResult { |
| var _u BaseNetworkSocketShutdownResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseNetworkSocketShutdownResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseNetworkSocketShutdownResultTag = BaseNetworkSocketShutdownResultErr |
| _m.Err = err |
| } |
| |
| func BaseNetworkSocketShutdownResultWithErr(err fuchsiaposix.Errno) BaseNetworkSocketShutdownResult { |
| var _u BaseNetworkSocketShutdownResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetAcceptConnResultTag uint64 |
| |
| const ( |
| BaseSocketGetAcceptConnResultResponse = 1 // 0x00000001 |
| BaseSocketGetAcceptConnResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetAcceptConnResult struct { |
| I_baseSocketGetAcceptConnResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetAcceptConnResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetAcceptConnResult = _bindings.CreateLazyMarshaler(BaseSocketGetAcceptConnResult{}) |
| |
| func (msg *BaseSocketGetAcceptConnResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetAcceptConnResult |
| } |
| |
| func (_m *BaseSocketGetAcceptConnResult) reset() { |
| switch _m.I_baseSocketGetAcceptConnResultTag { |
| case 1: |
| var _zeroed BaseSocketGetAcceptConnResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetAcceptConnResult) Which() I_baseSocketGetAcceptConnResultTag { |
| return _m.I_baseSocketGetAcceptConnResultTag |
| } |
| |
| func (_m *BaseSocketGetAcceptConnResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetAcceptConnResultTag) |
| } |
| |
| func (_m *BaseSocketGetAcceptConnResult) SetResponse(response BaseSocketGetAcceptConnResponse) { |
| _m.reset() |
| _m.I_baseSocketGetAcceptConnResultTag = BaseSocketGetAcceptConnResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetAcceptConnResultWithResponse(response BaseSocketGetAcceptConnResponse) BaseSocketGetAcceptConnResult { |
| var _u BaseSocketGetAcceptConnResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetAcceptConnResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetAcceptConnResultTag = BaseSocketGetAcceptConnResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetAcceptConnResultWithErr(err fuchsiaposix.Errno) BaseSocketGetAcceptConnResult { |
| var _u BaseSocketGetAcceptConnResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetBindToDeviceResultTag uint64 |
| |
| const ( |
| BaseSocketGetBindToDeviceResultResponse = 1 // 0x00000001 |
| BaseSocketGetBindToDeviceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetBindToDeviceResult struct { |
| I_baseSocketGetBindToDeviceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetBindToDeviceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetBindToDeviceResult = _bindings.CreateLazyMarshaler(BaseSocketGetBindToDeviceResult{}) |
| |
| func (msg *BaseSocketGetBindToDeviceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetBindToDeviceResult |
| } |
| |
| func (_m *BaseSocketGetBindToDeviceResult) reset() { |
| switch _m.I_baseSocketGetBindToDeviceResultTag { |
| case 1: |
| var _zeroed BaseSocketGetBindToDeviceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetBindToDeviceResult) Which() I_baseSocketGetBindToDeviceResultTag { |
| return _m.I_baseSocketGetBindToDeviceResultTag |
| } |
| |
| func (_m *BaseSocketGetBindToDeviceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetBindToDeviceResultTag) |
| } |
| |
| func (_m *BaseSocketGetBindToDeviceResult) SetResponse(response BaseSocketGetBindToDeviceResponse) { |
| _m.reset() |
| _m.I_baseSocketGetBindToDeviceResultTag = BaseSocketGetBindToDeviceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetBindToDeviceResultWithResponse(response BaseSocketGetBindToDeviceResponse) BaseSocketGetBindToDeviceResult { |
| var _u BaseSocketGetBindToDeviceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetBindToDeviceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetBindToDeviceResultTag = BaseSocketGetBindToDeviceResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetBindToDeviceResultWithErr(err fuchsiaposix.Errno) BaseSocketGetBindToDeviceResult { |
| var _u BaseSocketGetBindToDeviceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetBroadcastResultTag uint64 |
| |
| const ( |
| BaseSocketGetBroadcastResultResponse = 1 // 0x00000001 |
| BaseSocketGetBroadcastResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetBroadcastResult struct { |
| I_baseSocketGetBroadcastResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetBroadcastResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetBroadcastResult = _bindings.CreateLazyMarshaler(BaseSocketGetBroadcastResult{}) |
| |
| func (msg *BaseSocketGetBroadcastResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetBroadcastResult |
| } |
| |
| func (_m *BaseSocketGetBroadcastResult) reset() { |
| switch _m.I_baseSocketGetBroadcastResultTag { |
| case 1: |
| var _zeroed BaseSocketGetBroadcastResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetBroadcastResult) Which() I_baseSocketGetBroadcastResultTag { |
| return _m.I_baseSocketGetBroadcastResultTag |
| } |
| |
| func (_m *BaseSocketGetBroadcastResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetBroadcastResultTag) |
| } |
| |
| func (_m *BaseSocketGetBroadcastResult) SetResponse(response BaseSocketGetBroadcastResponse) { |
| _m.reset() |
| _m.I_baseSocketGetBroadcastResultTag = BaseSocketGetBroadcastResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetBroadcastResultWithResponse(response BaseSocketGetBroadcastResponse) BaseSocketGetBroadcastResult { |
| var _u BaseSocketGetBroadcastResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetBroadcastResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetBroadcastResultTag = BaseSocketGetBroadcastResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetBroadcastResultWithErr(err fuchsiaposix.Errno) BaseSocketGetBroadcastResult { |
| var _u BaseSocketGetBroadcastResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetErrorResultTag uint64 |
| |
| const ( |
| BaseSocketGetErrorResultResponse = 1 // 0x00000001 |
| BaseSocketGetErrorResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetErrorResult struct { |
| I_baseSocketGetErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetErrorResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetErrorResult = _bindings.CreateLazyMarshaler(BaseSocketGetErrorResult{}) |
| |
| func (msg *BaseSocketGetErrorResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetErrorResult |
| } |
| |
| func (_m *BaseSocketGetErrorResult) reset() { |
| switch _m.I_baseSocketGetErrorResultTag { |
| case 1: |
| var _zeroed BaseSocketGetErrorResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetErrorResult) Which() I_baseSocketGetErrorResultTag { |
| return _m.I_baseSocketGetErrorResultTag |
| } |
| |
| func (_m *BaseSocketGetErrorResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetErrorResultTag) |
| } |
| |
| func (_m *BaseSocketGetErrorResult) SetResponse(response BaseSocketGetErrorResponse) { |
| _m.reset() |
| _m.I_baseSocketGetErrorResultTag = BaseSocketGetErrorResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetErrorResultWithResponse(response BaseSocketGetErrorResponse) BaseSocketGetErrorResult { |
| var _u BaseSocketGetErrorResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetErrorResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetErrorResultTag = BaseSocketGetErrorResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetErrorResultWithErr(err fuchsiaposix.Errno) BaseSocketGetErrorResult { |
| var _u BaseSocketGetErrorResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetKeepAliveResultTag uint64 |
| |
| const ( |
| BaseSocketGetKeepAliveResultResponse = 1 // 0x00000001 |
| BaseSocketGetKeepAliveResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetKeepAliveResult struct { |
| I_baseSocketGetKeepAliveResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetKeepAliveResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetKeepAliveResult = _bindings.CreateLazyMarshaler(BaseSocketGetKeepAliveResult{}) |
| |
| func (msg *BaseSocketGetKeepAliveResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetKeepAliveResult |
| } |
| |
| func (_m *BaseSocketGetKeepAliveResult) reset() { |
| switch _m.I_baseSocketGetKeepAliveResultTag { |
| case 1: |
| var _zeroed BaseSocketGetKeepAliveResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetKeepAliveResult) Which() I_baseSocketGetKeepAliveResultTag { |
| return _m.I_baseSocketGetKeepAliveResultTag |
| } |
| |
| func (_m *BaseSocketGetKeepAliveResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetKeepAliveResultTag) |
| } |
| |
| func (_m *BaseSocketGetKeepAliveResult) SetResponse(response BaseSocketGetKeepAliveResponse) { |
| _m.reset() |
| _m.I_baseSocketGetKeepAliveResultTag = BaseSocketGetKeepAliveResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetKeepAliveResultWithResponse(response BaseSocketGetKeepAliveResponse) BaseSocketGetKeepAliveResult { |
| var _u BaseSocketGetKeepAliveResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetKeepAliveResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetKeepAliveResultTag = BaseSocketGetKeepAliveResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetKeepAliveResultWithErr(err fuchsiaposix.Errno) BaseSocketGetKeepAliveResult { |
| var _u BaseSocketGetKeepAliveResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetLingerResultTag uint64 |
| |
| const ( |
| BaseSocketGetLingerResultResponse = 1 // 0x00000001 |
| BaseSocketGetLingerResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetLingerResult struct { |
| I_baseSocketGetLingerResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetLingerResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetLingerResult = _bindings.CreateLazyMarshaler(BaseSocketGetLingerResult{}) |
| |
| func (msg *BaseSocketGetLingerResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetLingerResult |
| } |
| |
| func (_m *BaseSocketGetLingerResult) reset() { |
| switch _m.I_baseSocketGetLingerResultTag { |
| case 1: |
| var _zeroed BaseSocketGetLingerResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetLingerResult) Which() I_baseSocketGetLingerResultTag { |
| return _m.I_baseSocketGetLingerResultTag |
| } |
| |
| func (_m *BaseSocketGetLingerResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetLingerResultTag) |
| } |
| |
| func (_m *BaseSocketGetLingerResult) SetResponse(response BaseSocketGetLingerResponse) { |
| _m.reset() |
| _m.I_baseSocketGetLingerResultTag = BaseSocketGetLingerResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetLingerResultWithResponse(response BaseSocketGetLingerResponse) BaseSocketGetLingerResult { |
| var _u BaseSocketGetLingerResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetLingerResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetLingerResultTag = BaseSocketGetLingerResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetLingerResultWithErr(err fuchsiaposix.Errno) BaseSocketGetLingerResult { |
| var _u BaseSocketGetLingerResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetNoCheckResultTag uint64 |
| |
| const ( |
| BaseSocketGetNoCheckResultResponse = 1 // 0x00000001 |
| BaseSocketGetNoCheckResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetNoCheckResult struct { |
| I_baseSocketGetNoCheckResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetNoCheckResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetNoCheckResult = _bindings.CreateLazyMarshaler(BaseSocketGetNoCheckResult{}) |
| |
| func (msg *BaseSocketGetNoCheckResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetNoCheckResult |
| } |
| |
| func (_m *BaseSocketGetNoCheckResult) reset() { |
| switch _m.I_baseSocketGetNoCheckResultTag { |
| case 1: |
| var _zeroed BaseSocketGetNoCheckResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetNoCheckResult) Which() I_baseSocketGetNoCheckResultTag { |
| return _m.I_baseSocketGetNoCheckResultTag |
| } |
| |
| func (_m *BaseSocketGetNoCheckResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetNoCheckResultTag) |
| } |
| |
| func (_m *BaseSocketGetNoCheckResult) SetResponse(response BaseSocketGetNoCheckResponse) { |
| _m.reset() |
| _m.I_baseSocketGetNoCheckResultTag = BaseSocketGetNoCheckResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetNoCheckResultWithResponse(response BaseSocketGetNoCheckResponse) BaseSocketGetNoCheckResult { |
| var _u BaseSocketGetNoCheckResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetNoCheckResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetNoCheckResultTag = BaseSocketGetNoCheckResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetNoCheckResultWithErr(err fuchsiaposix.Errno) BaseSocketGetNoCheckResult { |
| var _u BaseSocketGetNoCheckResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetOutOfBandInlineResultTag uint64 |
| |
| const ( |
| BaseSocketGetOutOfBandInlineResultResponse = 1 // 0x00000001 |
| BaseSocketGetOutOfBandInlineResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetOutOfBandInlineResult struct { |
| I_baseSocketGetOutOfBandInlineResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetOutOfBandInlineResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetOutOfBandInlineResult = _bindings.CreateLazyMarshaler(BaseSocketGetOutOfBandInlineResult{}) |
| |
| func (msg *BaseSocketGetOutOfBandInlineResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetOutOfBandInlineResult |
| } |
| |
| func (_m *BaseSocketGetOutOfBandInlineResult) reset() { |
| switch _m.I_baseSocketGetOutOfBandInlineResultTag { |
| case 1: |
| var _zeroed BaseSocketGetOutOfBandInlineResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetOutOfBandInlineResult) Which() I_baseSocketGetOutOfBandInlineResultTag { |
| return _m.I_baseSocketGetOutOfBandInlineResultTag |
| } |
| |
| func (_m *BaseSocketGetOutOfBandInlineResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetOutOfBandInlineResultTag) |
| } |
| |
| func (_m *BaseSocketGetOutOfBandInlineResult) SetResponse(response BaseSocketGetOutOfBandInlineResponse) { |
| _m.reset() |
| _m.I_baseSocketGetOutOfBandInlineResultTag = BaseSocketGetOutOfBandInlineResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetOutOfBandInlineResultWithResponse(response BaseSocketGetOutOfBandInlineResponse) BaseSocketGetOutOfBandInlineResult { |
| var _u BaseSocketGetOutOfBandInlineResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetOutOfBandInlineResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetOutOfBandInlineResultTag = BaseSocketGetOutOfBandInlineResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetOutOfBandInlineResultWithErr(err fuchsiaposix.Errno) BaseSocketGetOutOfBandInlineResult { |
| var _u BaseSocketGetOutOfBandInlineResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetReceiveBufferResultTag uint64 |
| |
| const ( |
| BaseSocketGetReceiveBufferResultResponse = 1 // 0x00000001 |
| BaseSocketGetReceiveBufferResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetReceiveBufferResult struct { |
| I_baseSocketGetReceiveBufferResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetReceiveBufferResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetReceiveBufferResult = _bindings.CreateLazyMarshaler(BaseSocketGetReceiveBufferResult{}) |
| |
| func (msg *BaseSocketGetReceiveBufferResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetReceiveBufferResult |
| } |
| |
| func (_m *BaseSocketGetReceiveBufferResult) reset() { |
| switch _m.I_baseSocketGetReceiveBufferResultTag { |
| case 1: |
| var _zeroed BaseSocketGetReceiveBufferResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetReceiveBufferResult) Which() I_baseSocketGetReceiveBufferResultTag { |
| return _m.I_baseSocketGetReceiveBufferResultTag |
| } |
| |
| func (_m *BaseSocketGetReceiveBufferResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetReceiveBufferResultTag) |
| } |
| |
| func (_m *BaseSocketGetReceiveBufferResult) SetResponse(response BaseSocketGetReceiveBufferResponse) { |
| _m.reset() |
| _m.I_baseSocketGetReceiveBufferResultTag = BaseSocketGetReceiveBufferResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetReceiveBufferResultWithResponse(response BaseSocketGetReceiveBufferResponse) BaseSocketGetReceiveBufferResult { |
| var _u BaseSocketGetReceiveBufferResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetReceiveBufferResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetReceiveBufferResultTag = BaseSocketGetReceiveBufferResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetReceiveBufferResultWithErr(err fuchsiaposix.Errno) BaseSocketGetReceiveBufferResult { |
| var _u BaseSocketGetReceiveBufferResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetReuseAddressResultTag uint64 |
| |
| const ( |
| BaseSocketGetReuseAddressResultResponse = 1 // 0x00000001 |
| BaseSocketGetReuseAddressResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetReuseAddressResult struct { |
| I_baseSocketGetReuseAddressResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetReuseAddressResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetReuseAddressResult = _bindings.CreateLazyMarshaler(BaseSocketGetReuseAddressResult{}) |
| |
| func (msg *BaseSocketGetReuseAddressResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetReuseAddressResult |
| } |
| |
| func (_m *BaseSocketGetReuseAddressResult) reset() { |
| switch _m.I_baseSocketGetReuseAddressResultTag { |
| case 1: |
| var _zeroed BaseSocketGetReuseAddressResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetReuseAddressResult) Which() I_baseSocketGetReuseAddressResultTag { |
| return _m.I_baseSocketGetReuseAddressResultTag |
| } |
| |
| func (_m *BaseSocketGetReuseAddressResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetReuseAddressResultTag) |
| } |
| |
| func (_m *BaseSocketGetReuseAddressResult) SetResponse(response BaseSocketGetReuseAddressResponse) { |
| _m.reset() |
| _m.I_baseSocketGetReuseAddressResultTag = BaseSocketGetReuseAddressResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetReuseAddressResultWithResponse(response BaseSocketGetReuseAddressResponse) BaseSocketGetReuseAddressResult { |
| var _u BaseSocketGetReuseAddressResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetReuseAddressResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetReuseAddressResultTag = BaseSocketGetReuseAddressResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetReuseAddressResultWithErr(err fuchsiaposix.Errno) BaseSocketGetReuseAddressResult { |
| var _u BaseSocketGetReuseAddressResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetReusePortResultTag uint64 |
| |
| const ( |
| BaseSocketGetReusePortResultResponse = 1 // 0x00000001 |
| BaseSocketGetReusePortResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetReusePortResult struct { |
| I_baseSocketGetReusePortResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetReusePortResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetReusePortResult = _bindings.CreateLazyMarshaler(BaseSocketGetReusePortResult{}) |
| |
| func (msg *BaseSocketGetReusePortResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetReusePortResult |
| } |
| |
| func (_m *BaseSocketGetReusePortResult) reset() { |
| switch _m.I_baseSocketGetReusePortResultTag { |
| case 1: |
| var _zeroed BaseSocketGetReusePortResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetReusePortResult) Which() I_baseSocketGetReusePortResultTag { |
| return _m.I_baseSocketGetReusePortResultTag |
| } |
| |
| func (_m *BaseSocketGetReusePortResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetReusePortResultTag) |
| } |
| |
| func (_m *BaseSocketGetReusePortResult) SetResponse(response BaseSocketGetReusePortResponse) { |
| _m.reset() |
| _m.I_baseSocketGetReusePortResultTag = BaseSocketGetReusePortResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetReusePortResultWithResponse(response BaseSocketGetReusePortResponse) BaseSocketGetReusePortResult { |
| var _u BaseSocketGetReusePortResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetReusePortResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetReusePortResultTag = BaseSocketGetReusePortResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetReusePortResultWithErr(err fuchsiaposix.Errno) BaseSocketGetReusePortResult { |
| var _u BaseSocketGetReusePortResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetSendBufferResultTag uint64 |
| |
| const ( |
| BaseSocketGetSendBufferResultResponse = 1 // 0x00000001 |
| BaseSocketGetSendBufferResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetSendBufferResult struct { |
| I_baseSocketGetSendBufferResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetSendBufferResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetSendBufferResult = _bindings.CreateLazyMarshaler(BaseSocketGetSendBufferResult{}) |
| |
| func (msg *BaseSocketGetSendBufferResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetSendBufferResult |
| } |
| |
| func (_m *BaseSocketGetSendBufferResult) reset() { |
| switch _m.I_baseSocketGetSendBufferResultTag { |
| case 1: |
| var _zeroed BaseSocketGetSendBufferResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetSendBufferResult) Which() I_baseSocketGetSendBufferResultTag { |
| return _m.I_baseSocketGetSendBufferResultTag |
| } |
| |
| func (_m *BaseSocketGetSendBufferResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetSendBufferResultTag) |
| } |
| |
| func (_m *BaseSocketGetSendBufferResult) SetResponse(response BaseSocketGetSendBufferResponse) { |
| _m.reset() |
| _m.I_baseSocketGetSendBufferResultTag = BaseSocketGetSendBufferResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetSendBufferResultWithResponse(response BaseSocketGetSendBufferResponse) BaseSocketGetSendBufferResult { |
| var _u BaseSocketGetSendBufferResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetSendBufferResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetSendBufferResultTag = BaseSocketGetSendBufferResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetSendBufferResultWithErr(err fuchsiaposix.Errno) BaseSocketGetSendBufferResult { |
| var _u BaseSocketGetSendBufferResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketGetTimestampResultTag uint64 |
| |
| const ( |
| BaseSocketGetTimestampResultResponse = 1 // 0x00000001 |
| BaseSocketGetTimestampResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketGetTimestampResult struct { |
| I_baseSocketGetTimestampResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketGetTimestampResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketGetTimestampResult = _bindings.CreateLazyMarshaler(BaseSocketGetTimestampResult{}) |
| |
| func (msg *BaseSocketGetTimestampResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketGetTimestampResult |
| } |
| |
| func (_m *BaseSocketGetTimestampResult) reset() { |
| switch _m.I_baseSocketGetTimestampResultTag { |
| case 1: |
| var _zeroed BaseSocketGetTimestampResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketGetTimestampResult) Which() I_baseSocketGetTimestampResultTag { |
| return _m.I_baseSocketGetTimestampResultTag |
| } |
| |
| func (_m *BaseSocketGetTimestampResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketGetTimestampResultTag) |
| } |
| |
| func (_m *BaseSocketGetTimestampResult) SetResponse(response BaseSocketGetTimestampResponse) { |
| _m.reset() |
| _m.I_baseSocketGetTimestampResultTag = BaseSocketGetTimestampResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketGetTimestampResultWithResponse(response BaseSocketGetTimestampResponse) BaseSocketGetTimestampResult { |
| var _u BaseSocketGetTimestampResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketGetTimestampResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketGetTimestampResultTag = BaseSocketGetTimestampResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketGetTimestampResultWithErr(err fuchsiaposix.Errno) BaseSocketGetTimestampResult { |
| var _u BaseSocketGetTimestampResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetBindToDeviceResultTag uint64 |
| |
| const ( |
| BaseSocketSetBindToDeviceResultResponse = 1 // 0x00000001 |
| BaseSocketSetBindToDeviceResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetBindToDeviceResult struct { |
| I_baseSocketSetBindToDeviceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetBindToDeviceResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetBindToDeviceResult = _bindings.CreateLazyMarshaler(BaseSocketSetBindToDeviceResult{}) |
| |
| func (msg *BaseSocketSetBindToDeviceResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetBindToDeviceResult |
| } |
| |
| func (_m *BaseSocketSetBindToDeviceResult) reset() { |
| switch _m.I_baseSocketSetBindToDeviceResultTag { |
| case 1: |
| var _zeroed BaseSocketSetBindToDeviceResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetBindToDeviceResult) Which() I_baseSocketSetBindToDeviceResultTag { |
| return _m.I_baseSocketSetBindToDeviceResultTag |
| } |
| |
| func (_m *BaseSocketSetBindToDeviceResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetBindToDeviceResultTag) |
| } |
| |
| func (_m *BaseSocketSetBindToDeviceResult) SetResponse(response BaseSocketSetBindToDeviceResponse) { |
| _m.reset() |
| _m.I_baseSocketSetBindToDeviceResultTag = BaseSocketSetBindToDeviceResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetBindToDeviceResultWithResponse(response BaseSocketSetBindToDeviceResponse) BaseSocketSetBindToDeviceResult { |
| var _u BaseSocketSetBindToDeviceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetBindToDeviceResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetBindToDeviceResultTag = BaseSocketSetBindToDeviceResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetBindToDeviceResultWithErr(err fuchsiaposix.Errno) BaseSocketSetBindToDeviceResult { |
| var _u BaseSocketSetBindToDeviceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetBroadcastResultTag uint64 |
| |
| const ( |
| BaseSocketSetBroadcastResultResponse = 1 // 0x00000001 |
| BaseSocketSetBroadcastResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetBroadcastResult struct { |
| I_baseSocketSetBroadcastResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetBroadcastResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetBroadcastResult = _bindings.CreateLazyMarshaler(BaseSocketSetBroadcastResult{}) |
| |
| func (msg *BaseSocketSetBroadcastResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetBroadcastResult |
| } |
| |
| func (_m *BaseSocketSetBroadcastResult) reset() { |
| switch _m.I_baseSocketSetBroadcastResultTag { |
| case 1: |
| var _zeroed BaseSocketSetBroadcastResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetBroadcastResult) Which() I_baseSocketSetBroadcastResultTag { |
| return _m.I_baseSocketSetBroadcastResultTag |
| } |
| |
| func (_m *BaseSocketSetBroadcastResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetBroadcastResultTag) |
| } |
| |
| func (_m *BaseSocketSetBroadcastResult) SetResponse(response BaseSocketSetBroadcastResponse) { |
| _m.reset() |
| _m.I_baseSocketSetBroadcastResultTag = BaseSocketSetBroadcastResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetBroadcastResultWithResponse(response BaseSocketSetBroadcastResponse) BaseSocketSetBroadcastResult { |
| var _u BaseSocketSetBroadcastResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetBroadcastResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetBroadcastResultTag = BaseSocketSetBroadcastResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetBroadcastResultWithErr(err fuchsiaposix.Errno) BaseSocketSetBroadcastResult { |
| var _u BaseSocketSetBroadcastResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetKeepAliveResultTag uint64 |
| |
| const ( |
| BaseSocketSetKeepAliveResultResponse = 1 // 0x00000001 |
| BaseSocketSetKeepAliveResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetKeepAliveResult struct { |
| I_baseSocketSetKeepAliveResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetKeepAliveResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetKeepAliveResult = _bindings.CreateLazyMarshaler(BaseSocketSetKeepAliveResult{}) |
| |
| func (msg *BaseSocketSetKeepAliveResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetKeepAliveResult |
| } |
| |
| func (_m *BaseSocketSetKeepAliveResult) reset() { |
| switch _m.I_baseSocketSetKeepAliveResultTag { |
| case 1: |
| var _zeroed BaseSocketSetKeepAliveResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetKeepAliveResult) Which() I_baseSocketSetKeepAliveResultTag { |
| return _m.I_baseSocketSetKeepAliveResultTag |
| } |
| |
| func (_m *BaseSocketSetKeepAliveResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetKeepAliveResultTag) |
| } |
| |
| func (_m *BaseSocketSetKeepAliveResult) SetResponse(response BaseSocketSetKeepAliveResponse) { |
| _m.reset() |
| _m.I_baseSocketSetKeepAliveResultTag = BaseSocketSetKeepAliveResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetKeepAliveResultWithResponse(response BaseSocketSetKeepAliveResponse) BaseSocketSetKeepAliveResult { |
| var _u BaseSocketSetKeepAliveResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetKeepAliveResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetKeepAliveResultTag = BaseSocketSetKeepAliveResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetKeepAliveResultWithErr(err fuchsiaposix.Errno) BaseSocketSetKeepAliveResult { |
| var _u BaseSocketSetKeepAliveResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetLingerResultTag uint64 |
| |
| const ( |
| BaseSocketSetLingerResultResponse = 1 // 0x00000001 |
| BaseSocketSetLingerResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetLingerResult struct { |
| I_baseSocketSetLingerResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetLingerResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetLingerResult = _bindings.CreateLazyMarshaler(BaseSocketSetLingerResult{}) |
| |
| func (msg *BaseSocketSetLingerResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetLingerResult |
| } |
| |
| func (_m *BaseSocketSetLingerResult) reset() { |
| switch _m.I_baseSocketSetLingerResultTag { |
| case 1: |
| var _zeroed BaseSocketSetLingerResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetLingerResult) Which() I_baseSocketSetLingerResultTag { |
| return _m.I_baseSocketSetLingerResultTag |
| } |
| |
| func (_m *BaseSocketSetLingerResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetLingerResultTag) |
| } |
| |
| func (_m *BaseSocketSetLingerResult) SetResponse(response BaseSocketSetLingerResponse) { |
| _m.reset() |
| _m.I_baseSocketSetLingerResultTag = BaseSocketSetLingerResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetLingerResultWithResponse(response BaseSocketSetLingerResponse) BaseSocketSetLingerResult { |
| var _u BaseSocketSetLingerResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetLingerResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetLingerResultTag = BaseSocketSetLingerResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetLingerResultWithErr(err fuchsiaposix.Errno) BaseSocketSetLingerResult { |
| var _u BaseSocketSetLingerResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetNoCheckResultTag uint64 |
| |
| const ( |
| BaseSocketSetNoCheckResultResponse = 1 // 0x00000001 |
| BaseSocketSetNoCheckResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetNoCheckResult struct { |
| I_baseSocketSetNoCheckResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetNoCheckResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetNoCheckResult = _bindings.CreateLazyMarshaler(BaseSocketSetNoCheckResult{}) |
| |
| func (msg *BaseSocketSetNoCheckResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetNoCheckResult |
| } |
| |
| func (_m *BaseSocketSetNoCheckResult) reset() { |
| switch _m.I_baseSocketSetNoCheckResultTag { |
| case 1: |
| var _zeroed BaseSocketSetNoCheckResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetNoCheckResult) Which() I_baseSocketSetNoCheckResultTag { |
| return _m.I_baseSocketSetNoCheckResultTag |
| } |
| |
| func (_m *BaseSocketSetNoCheckResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetNoCheckResultTag) |
| } |
| |
| func (_m *BaseSocketSetNoCheckResult) SetResponse(response BaseSocketSetNoCheckResponse) { |
| _m.reset() |
| _m.I_baseSocketSetNoCheckResultTag = BaseSocketSetNoCheckResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetNoCheckResultWithResponse(response BaseSocketSetNoCheckResponse) BaseSocketSetNoCheckResult { |
| var _u BaseSocketSetNoCheckResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetNoCheckResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetNoCheckResultTag = BaseSocketSetNoCheckResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetNoCheckResultWithErr(err fuchsiaposix.Errno) BaseSocketSetNoCheckResult { |
| var _u BaseSocketSetNoCheckResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetOutOfBandInlineResultTag uint64 |
| |
| const ( |
| BaseSocketSetOutOfBandInlineResultResponse = 1 // 0x00000001 |
| BaseSocketSetOutOfBandInlineResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetOutOfBandInlineResult struct { |
| I_baseSocketSetOutOfBandInlineResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetOutOfBandInlineResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetOutOfBandInlineResult = _bindings.CreateLazyMarshaler(BaseSocketSetOutOfBandInlineResult{}) |
| |
| func (msg *BaseSocketSetOutOfBandInlineResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetOutOfBandInlineResult |
| } |
| |
| func (_m *BaseSocketSetOutOfBandInlineResult) reset() { |
| switch _m.I_baseSocketSetOutOfBandInlineResultTag { |
| case 1: |
| var _zeroed BaseSocketSetOutOfBandInlineResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetOutOfBandInlineResult) Which() I_baseSocketSetOutOfBandInlineResultTag { |
| return _m.I_baseSocketSetOutOfBandInlineResultTag |
| } |
| |
| func (_m *BaseSocketSetOutOfBandInlineResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetOutOfBandInlineResultTag) |
| } |
| |
| func (_m *BaseSocketSetOutOfBandInlineResult) SetResponse(response BaseSocketSetOutOfBandInlineResponse) { |
| _m.reset() |
| _m.I_baseSocketSetOutOfBandInlineResultTag = BaseSocketSetOutOfBandInlineResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetOutOfBandInlineResultWithResponse(response BaseSocketSetOutOfBandInlineResponse) BaseSocketSetOutOfBandInlineResult { |
| var _u BaseSocketSetOutOfBandInlineResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetOutOfBandInlineResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetOutOfBandInlineResultTag = BaseSocketSetOutOfBandInlineResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetOutOfBandInlineResultWithErr(err fuchsiaposix.Errno) BaseSocketSetOutOfBandInlineResult { |
| var _u BaseSocketSetOutOfBandInlineResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetReceiveBufferResultTag uint64 |
| |
| const ( |
| BaseSocketSetReceiveBufferResultResponse = 1 // 0x00000001 |
| BaseSocketSetReceiveBufferResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetReceiveBufferResult struct { |
| I_baseSocketSetReceiveBufferResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetReceiveBufferResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetReceiveBufferResult = _bindings.CreateLazyMarshaler(BaseSocketSetReceiveBufferResult{}) |
| |
| func (msg *BaseSocketSetReceiveBufferResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetReceiveBufferResult |
| } |
| |
| func (_m *BaseSocketSetReceiveBufferResult) reset() { |
| switch _m.I_baseSocketSetReceiveBufferResultTag { |
| case 1: |
| var _zeroed BaseSocketSetReceiveBufferResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetReceiveBufferResult) Which() I_baseSocketSetReceiveBufferResultTag { |
| return _m.I_baseSocketSetReceiveBufferResultTag |
| } |
| |
| func (_m *BaseSocketSetReceiveBufferResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetReceiveBufferResultTag) |
| } |
| |
| func (_m *BaseSocketSetReceiveBufferResult) SetResponse(response BaseSocketSetReceiveBufferResponse) { |
| _m.reset() |
| _m.I_baseSocketSetReceiveBufferResultTag = BaseSocketSetReceiveBufferResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetReceiveBufferResultWithResponse(response BaseSocketSetReceiveBufferResponse) BaseSocketSetReceiveBufferResult { |
| var _u BaseSocketSetReceiveBufferResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetReceiveBufferResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetReceiveBufferResultTag = BaseSocketSetReceiveBufferResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetReceiveBufferResultWithErr(err fuchsiaposix.Errno) BaseSocketSetReceiveBufferResult { |
| var _u BaseSocketSetReceiveBufferResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetReuseAddressResultTag uint64 |
| |
| const ( |
| BaseSocketSetReuseAddressResultResponse = 1 // 0x00000001 |
| BaseSocketSetReuseAddressResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetReuseAddressResult struct { |
| I_baseSocketSetReuseAddressResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetReuseAddressResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetReuseAddressResult = _bindings.CreateLazyMarshaler(BaseSocketSetReuseAddressResult{}) |
| |
| func (msg *BaseSocketSetReuseAddressResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetReuseAddressResult |
| } |
| |
| func (_m *BaseSocketSetReuseAddressResult) reset() { |
| switch _m.I_baseSocketSetReuseAddressResultTag { |
| case 1: |
| var _zeroed BaseSocketSetReuseAddressResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetReuseAddressResult) Which() I_baseSocketSetReuseAddressResultTag { |
| return _m.I_baseSocketSetReuseAddressResultTag |
| } |
| |
| func (_m *BaseSocketSetReuseAddressResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetReuseAddressResultTag) |
| } |
| |
| func (_m *BaseSocketSetReuseAddressResult) SetResponse(response BaseSocketSetReuseAddressResponse) { |
| _m.reset() |
| _m.I_baseSocketSetReuseAddressResultTag = BaseSocketSetReuseAddressResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetReuseAddressResultWithResponse(response BaseSocketSetReuseAddressResponse) BaseSocketSetReuseAddressResult { |
| var _u BaseSocketSetReuseAddressResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetReuseAddressResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetReuseAddressResultTag = BaseSocketSetReuseAddressResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetReuseAddressResultWithErr(err fuchsiaposix.Errno) BaseSocketSetReuseAddressResult { |
| var _u BaseSocketSetReuseAddressResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetReusePortResultTag uint64 |
| |
| const ( |
| BaseSocketSetReusePortResultResponse = 1 // 0x00000001 |
| BaseSocketSetReusePortResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetReusePortResult struct { |
| I_baseSocketSetReusePortResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetReusePortResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetReusePortResult = _bindings.CreateLazyMarshaler(BaseSocketSetReusePortResult{}) |
| |
| func (msg *BaseSocketSetReusePortResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetReusePortResult |
| } |
| |
| func (_m *BaseSocketSetReusePortResult) reset() { |
| switch _m.I_baseSocketSetReusePortResultTag { |
| case 1: |
| var _zeroed BaseSocketSetReusePortResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetReusePortResult) Which() I_baseSocketSetReusePortResultTag { |
| return _m.I_baseSocketSetReusePortResultTag |
| } |
| |
| func (_m *BaseSocketSetReusePortResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetReusePortResultTag) |
| } |
| |
| func (_m *BaseSocketSetReusePortResult) SetResponse(response BaseSocketSetReusePortResponse) { |
| _m.reset() |
| _m.I_baseSocketSetReusePortResultTag = BaseSocketSetReusePortResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetReusePortResultWithResponse(response BaseSocketSetReusePortResponse) BaseSocketSetReusePortResult { |
| var _u BaseSocketSetReusePortResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetReusePortResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetReusePortResultTag = BaseSocketSetReusePortResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetReusePortResultWithErr(err fuchsiaposix.Errno) BaseSocketSetReusePortResult { |
| var _u BaseSocketSetReusePortResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetSendBufferResultTag uint64 |
| |
| const ( |
| BaseSocketSetSendBufferResultResponse = 1 // 0x00000001 |
| BaseSocketSetSendBufferResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetSendBufferResult struct { |
| I_baseSocketSetSendBufferResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetSendBufferResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetSendBufferResult = _bindings.CreateLazyMarshaler(BaseSocketSetSendBufferResult{}) |
| |
| func (msg *BaseSocketSetSendBufferResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetSendBufferResult |
| } |
| |
| func (_m *BaseSocketSetSendBufferResult) reset() { |
| switch _m.I_baseSocketSetSendBufferResultTag { |
| case 1: |
| var _zeroed BaseSocketSetSendBufferResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetSendBufferResult) Which() I_baseSocketSetSendBufferResultTag { |
| return _m.I_baseSocketSetSendBufferResultTag |
| } |
| |
| func (_m *BaseSocketSetSendBufferResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetSendBufferResultTag) |
| } |
| |
| func (_m *BaseSocketSetSendBufferResult) SetResponse(response BaseSocketSetSendBufferResponse) { |
| _m.reset() |
| _m.I_baseSocketSetSendBufferResultTag = BaseSocketSetSendBufferResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetSendBufferResultWithResponse(response BaseSocketSetSendBufferResponse) BaseSocketSetSendBufferResult { |
| var _u BaseSocketSetSendBufferResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetSendBufferResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetSendBufferResultTag = BaseSocketSetSendBufferResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetSendBufferResultWithErr(err fuchsiaposix.Errno) BaseSocketSetSendBufferResult { |
| var _u BaseSocketSetSendBufferResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_baseSocketSetTimestampResultTag uint64 |
| |
| const ( |
| BaseSocketSetTimestampResultResponse = 1 // 0x00000001 |
| BaseSocketSetTimestampResultErr = 2 // 0x00000002 |
| ) |
| |
| type BaseSocketSetTimestampResult struct { |
| I_baseSocketSetTimestampResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response BaseSocketSetTimestampResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mBaseSocketSetTimestampResult = _bindings.CreateLazyMarshaler(BaseSocketSetTimestampResult{}) |
| |
| func (msg *BaseSocketSetTimestampResult) Marshaler() _bindings.Marshaler { |
| return _mBaseSocketSetTimestampResult |
| } |
| |
| func (_m *BaseSocketSetTimestampResult) reset() { |
| switch _m.I_baseSocketSetTimestampResultTag { |
| case 1: |
| var _zeroed BaseSocketSetTimestampResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *BaseSocketSetTimestampResult) Which() I_baseSocketSetTimestampResultTag { |
| return _m.I_baseSocketSetTimestampResultTag |
| } |
| |
| func (_m *BaseSocketSetTimestampResult) Ordinal() uint64 { |
| return uint64(_m.I_baseSocketSetTimestampResultTag) |
| } |
| |
| func (_m *BaseSocketSetTimestampResult) SetResponse(response BaseSocketSetTimestampResponse) { |
| _m.reset() |
| _m.I_baseSocketSetTimestampResultTag = BaseSocketSetTimestampResultResponse |
| _m.Response = response |
| } |
| |
| func BaseSocketSetTimestampResultWithResponse(response BaseSocketSetTimestampResponse) BaseSocketSetTimestampResult { |
| var _u BaseSocketSetTimestampResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *BaseSocketSetTimestampResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_baseSocketSetTimestampResultTag = BaseSocketSetTimestampResultErr |
| _m.Err = err |
| } |
| |
| func BaseSocketSetTimestampResultWithErr(err fuchsiaposix.Errno) BaseSocketSetTimestampResult { |
| var _u BaseSocketSetTimestampResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_datagramSocketRecvMsgPostflightResultTag uint64 |
| |
| const ( |
| DatagramSocketRecvMsgPostflightResultResponse = 1 // 0x00000001 |
| DatagramSocketRecvMsgPostflightResultErr = 2 // 0x00000002 |
| ) |
| |
| type DatagramSocketRecvMsgPostflightResult struct { |
| I_datagramSocketRecvMsgPostflightResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| Response DatagramSocketRecvMsgPostflightResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mDatagramSocketRecvMsgPostflightResult = _bindings.CreateLazyMarshaler(DatagramSocketRecvMsgPostflightResult{}) |
| |
| func (msg *DatagramSocketRecvMsgPostflightResult) Marshaler() _bindings.Marshaler { |
| return _mDatagramSocketRecvMsgPostflightResult |
| } |
| |
| func (_m *DatagramSocketRecvMsgPostflightResult) reset() { |
| switch _m.I_datagramSocketRecvMsgPostflightResultTag { |
| case 1: |
| var _zeroed DatagramSocketRecvMsgPostflightResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *DatagramSocketRecvMsgPostflightResult) Which() I_datagramSocketRecvMsgPostflightResultTag { |
| return _m.I_datagramSocketRecvMsgPostflightResultTag |
| } |
| |
| func (_m *DatagramSocketRecvMsgPostflightResult) Ordinal() uint64 { |
| return uint64(_m.I_datagramSocketRecvMsgPostflightResultTag) |
| } |
| |
| func (_m *DatagramSocketRecvMsgPostflightResult) SetResponse(response DatagramSocketRecvMsgPostflightResponse) { |
| _m.reset() |
| _m.I_datagramSocketRecvMsgPostflightResultTag = DatagramSocketRecvMsgPostflightResultResponse |
| _m.Response = response |
| } |
| |
| func DatagramSocketRecvMsgPostflightResultWithResponse(response DatagramSocketRecvMsgPostflightResponse) DatagramSocketRecvMsgPostflightResult { |
| var _u DatagramSocketRecvMsgPostflightResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *DatagramSocketRecvMsgPostflightResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_datagramSocketRecvMsgPostflightResultTag = DatagramSocketRecvMsgPostflightResultErr |
| _m.Err = err |
| } |
| |
| func DatagramSocketRecvMsgPostflightResultWithErr(err fuchsiaposix.Errno) DatagramSocketRecvMsgPostflightResult { |
| var _u DatagramSocketRecvMsgPostflightResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_datagramSocketSendMsgPreflightResultTag uint64 |
| |
| const ( |
| DatagramSocketSendMsgPreflightResultResponse = 1 // 0x00000001 |
| DatagramSocketSendMsgPreflightResultErr = 2 // 0x00000002 |
| ) |
| |
| type DatagramSocketSendMsgPreflightResult struct { |
| I_datagramSocketSendMsgPreflightResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| Response DatagramSocketSendMsgPreflightResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mDatagramSocketSendMsgPreflightResult = _bindings.CreateLazyMarshaler(DatagramSocketSendMsgPreflightResult{}) |
| |
| func (msg *DatagramSocketSendMsgPreflightResult) Marshaler() _bindings.Marshaler { |
| return _mDatagramSocketSendMsgPreflightResult |
| } |
| |
| func (_m *DatagramSocketSendMsgPreflightResult) reset() { |
| switch _m.I_datagramSocketSendMsgPreflightResultTag { |
| case 1: |
| var _zeroed DatagramSocketSendMsgPreflightResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *DatagramSocketSendMsgPreflightResult) Which() I_datagramSocketSendMsgPreflightResultTag { |
| return _m.I_datagramSocketSendMsgPreflightResultTag |
| } |
| |
| func (_m *DatagramSocketSendMsgPreflightResult) Ordinal() uint64 { |
| return uint64(_m.I_datagramSocketSendMsgPreflightResultTag) |
| } |
| |
| func (_m *DatagramSocketSendMsgPreflightResult) SetResponse(response DatagramSocketSendMsgPreflightResponse) { |
| _m.reset() |
| _m.I_datagramSocketSendMsgPreflightResultTag = DatagramSocketSendMsgPreflightResultResponse |
| _m.Response = response |
| } |
| |
| func DatagramSocketSendMsgPreflightResultWithResponse(response DatagramSocketSendMsgPreflightResponse) DatagramSocketSendMsgPreflightResult { |
| var _u DatagramSocketSendMsgPreflightResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *DatagramSocketSendMsgPreflightResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_datagramSocketSendMsgPreflightResultTag = DatagramSocketSendMsgPreflightResultErr |
| _m.Err = err |
| } |
| |
| func DatagramSocketSendMsgPreflightResultWithErr(err fuchsiaposix.Errno) DatagramSocketSendMsgPreflightResult { |
| var _u DatagramSocketSendMsgPreflightResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_optionalUint32Tag uint64 |
| |
| const ( |
| OptionalUint32Value = 1 // 0x00000001 |
| OptionalUint32Unset = 2 // 0x00000002 |
| ) |
| |
| // An optional uint32 value. |
| type OptionalUint32 struct { |
| I_optionalUint32Tag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Value uint32 `fidl_ordinal:"1"` |
| Unset Empty `fidl_ordinal:"2"` |
| } |
| |
| var _mOptionalUint32 = _bindings.CreateLazyMarshaler(OptionalUint32{}) |
| |
| func (msg *OptionalUint32) Marshaler() _bindings.Marshaler { |
| return _mOptionalUint32 |
| } |
| |
| func (_m *OptionalUint32) reset() { |
| switch _m.I_optionalUint32Tag { |
| case 1: |
| var _zeroed uint32 |
| _m.Value = _zeroed |
| case 2: |
| var _zeroed Empty |
| _m.Unset = _zeroed |
| } |
| } |
| |
| func (_m *OptionalUint32) Which() I_optionalUint32Tag { |
| return _m.I_optionalUint32Tag |
| } |
| |
| func (_m *OptionalUint32) Ordinal() uint64 { |
| return uint64(_m.I_optionalUint32Tag) |
| } |
| |
| func (_m *OptionalUint32) SetValue(value uint32) { |
| _m.reset() |
| _m.I_optionalUint32Tag = OptionalUint32Value |
| _m.Value = value |
| } |
| |
| func OptionalUint32WithValue(value uint32) OptionalUint32 { |
| var _u OptionalUint32 |
| _u.SetValue(value) |
| return _u |
| } |
| |
| func (_m *OptionalUint32) SetUnset(unset Empty) { |
| _m.reset() |
| _m.I_optionalUint32Tag = OptionalUint32Unset |
| _m.Unset = unset |
| } |
| |
| func OptionalUint32WithUnset(unset Empty) OptionalUint32 { |
| var _u OptionalUint32 |
| _u.SetUnset(unset) |
| return _u |
| } |
| |
| type I_optionalUint8Tag uint64 |
| |
| const ( |
| OptionalUint8Value = 1 // 0x00000001 |
| OptionalUint8Unset = 2 // 0x00000002 |
| ) |
| |
| // An optional byte value. |
| type OptionalUint8 struct { |
| I_optionalUint8Tag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Value uint8 `fidl_ordinal:"1"` |
| Unset Empty `fidl_ordinal:"2"` |
| } |
| |
| var _mOptionalUint8 = _bindings.CreateLazyMarshaler(OptionalUint8{}) |
| |
| func (msg *OptionalUint8) Marshaler() _bindings.Marshaler { |
| return _mOptionalUint8 |
| } |
| |
| func (_m *OptionalUint8) reset() { |
| switch _m.I_optionalUint8Tag { |
| case 1: |
| var _zeroed uint8 |
| _m.Value = _zeroed |
| case 2: |
| var _zeroed Empty |
| _m.Unset = _zeroed |
| } |
| } |
| |
| func (_m *OptionalUint8) Which() I_optionalUint8Tag { |
| return _m.I_optionalUint8Tag |
| } |
| |
| func (_m *OptionalUint8) Ordinal() uint64 { |
| return uint64(_m.I_optionalUint8Tag) |
| } |
| |
| func (_m *OptionalUint8) SetValue(value uint8) { |
| _m.reset() |
| _m.I_optionalUint8Tag = OptionalUint8Value |
| _m.Value = value |
| } |
| |
| func OptionalUint8WithValue(value uint8) OptionalUint8 { |
| var _u OptionalUint8 |
| _u.SetValue(value) |
| return _u |
| } |
| |
| func (_m *OptionalUint8) SetUnset(unset Empty) { |
| _m.reset() |
| _m.I_optionalUint8Tag = OptionalUint8Unset |
| _m.Unset = unset |
| } |
| |
| func OptionalUint8WithUnset(unset Empty) OptionalUint8 { |
| var _u OptionalUint8 |
| _u.SetUnset(unset) |
| return _u |
| } |
| |
| type I_providerDatagramSocketDeprecatedResultTag uint64 |
| |
| const ( |
| ProviderDatagramSocketDeprecatedResultResponse = 1 // 0x00000001 |
| ProviderDatagramSocketDeprecatedResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProviderDatagramSocketDeprecatedResult struct { |
| I_providerDatagramSocketDeprecatedResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| Response ProviderDatagramSocketDeprecatedResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mProviderDatagramSocketDeprecatedResult = _bindings.CreateLazyMarshaler(ProviderDatagramSocketDeprecatedResult{}) |
| |
| func (msg *ProviderDatagramSocketDeprecatedResult) Marshaler() _bindings.Marshaler { |
| return _mProviderDatagramSocketDeprecatedResult |
| } |
| |
| func (_m *ProviderDatagramSocketDeprecatedResult) reset() { |
| switch _m.I_providerDatagramSocketDeprecatedResultTag { |
| case 1: |
| var _zeroed ProviderDatagramSocketDeprecatedResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProviderDatagramSocketDeprecatedResult) Which() I_providerDatagramSocketDeprecatedResultTag { |
| return _m.I_providerDatagramSocketDeprecatedResultTag |
| } |
| |
| func (_m *ProviderDatagramSocketDeprecatedResult) Ordinal() uint64 { |
| return uint64(_m.I_providerDatagramSocketDeprecatedResultTag) |
| } |
| |
| func (_m *ProviderDatagramSocketDeprecatedResult) SetResponse(response ProviderDatagramSocketDeprecatedResponse) { |
| _m.reset() |
| _m.I_providerDatagramSocketDeprecatedResultTag = ProviderDatagramSocketDeprecatedResultResponse |
| _m.Response = response |
| } |
| |
| func ProviderDatagramSocketDeprecatedResultWithResponse(response ProviderDatagramSocketDeprecatedResponse) ProviderDatagramSocketDeprecatedResult { |
| var _u ProviderDatagramSocketDeprecatedResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProviderDatagramSocketDeprecatedResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_providerDatagramSocketDeprecatedResultTag = ProviderDatagramSocketDeprecatedResultErr |
| _m.Err = err |
| } |
| |
| func ProviderDatagramSocketDeprecatedResultWithErr(err fuchsiaposix.Errno) ProviderDatagramSocketDeprecatedResult { |
| var _u ProviderDatagramSocketDeprecatedResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_providerDatagramSocketResponseTag uint64 |
| |
| const ( |
| ProviderDatagramSocketResponseDatagramSocket = 1 // 0x00000001 |
| ProviderDatagramSocketResponseSynchronousDatagramSocket = 2 // 0x00000002 |
| ) |
| |
| type ProviderDatagramSocketResponse struct { |
| I_providerDatagramSocketResponseTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| DatagramSocket DatagramSocketWithCtxInterface `fidl_handle_subtype:"4" fidl_ordinal:"1"` |
| SynchronousDatagramSocket SynchronousDatagramSocketWithCtxInterface `fidl_handle_subtype:"4" fidl_ordinal:"2"` |
| } |
| |
| var _mProviderDatagramSocketResponse = _bindings.CreateLazyMarshaler(ProviderDatagramSocketResponse{}) |
| |
| func (msg *ProviderDatagramSocketResponse) Marshaler() _bindings.Marshaler { |
| return _mProviderDatagramSocketResponse |
| } |
| |
| func (_m *ProviderDatagramSocketResponse) reset() { |
| switch _m.I_providerDatagramSocketResponseTag { |
| case 1: |
| var _zeroed DatagramSocketWithCtxInterface |
| _m.DatagramSocket = _zeroed |
| case 2: |
| var _zeroed SynchronousDatagramSocketWithCtxInterface |
| _m.SynchronousDatagramSocket = _zeroed |
| } |
| } |
| |
| func (_m *ProviderDatagramSocketResponse) Which() I_providerDatagramSocketResponseTag { |
| return _m.I_providerDatagramSocketResponseTag |
| } |
| |
| func (_m *ProviderDatagramSocketResponse) Ordinal() uint64 { |
| return uint64(_m.I_providerDatagramSocketResponseTag) |
| } |
| |
| func (_m *ProviderDatagramSocketResponse) SetDatagramSocket(datagramSocket DatagramSocketWithCtxInterface) { |
| _m.reset() |
| _m.I_providerDatagramSocketResponseTag = ProviderDatagramSocketResponseDatagramSocket |
| _m.DatagramSocket = datagramSocket |
| } |
| |
| func ProviderDatagramSocketResponseWithDatagramSocket(datagramSocket DatagramSocketWithCtxInterface) ProviderDatagramSocketResponse { |
| var _u ProviderDatagramSocketResponse |
| _u.SetDatagramSocket(datagramSocket) |
| return _u |
| } |
| |
| func (_m *ProviderDatagramSocketResponse) SetSynchronousDatagramSocket(synchronousDatagramSocket SynchronousDatagramSocketWithCtxInterface) { |
| _m.reset() |
| _m.I_providerDatagramSocketResponseTag = ProviderDatagramSocketResponseSynchronousDatagramSocket |
| _m.SynchronousDatagramSocket = synchronousDatagramSocket |
| } |
| |
| func ProviderDatagramSocketResponseWithSynchronousDatagramSocket(synchronousDatagramSocket SynchronousDatagramSocketWithCtxInterface) ProviderDatagramSocketResponse { |
| var _u ProviderDatagramSocketResponse |
| _u.SetSynchronousDatagramSocket(synchronousDatagramSocket) |
| return _u |
| } |
| |
| type I_providerDatagramSocketResultTag uint64 |
| |
| const ( |
| ProviderDatagramSocketResultResponse = 1 // 0x00000001 |
| ProviderDatagramSocketResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProviderDatagramSocketResult struct { |
| I_providerDatagramSocketResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| Response ProviderDatagramSocketResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mProviderDatagramSocketResult = _bindings.CreateLazyMarshaler(ProviderDatagramSocketResult{}) |
| |
| func (msg *ProviderDatagramSocketResult) Marshaler() _bindings.Marshaler { |
| return _mProviderDatagramSocketResult |
| } |
| |
| func (_m *ProviderDatagramSocketResult) reset() { |
| switch _m.I_providerDatagramSocketResultTag { |
| case 1: |
| var _zeroed ProviderDatagramSocketResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProviderDatagramSocketResult) Which() I_providerDatagramSocketResultTag { |
| return _m.I_providerDatagramSocketResultTag |
| } |
| |
| func (_m *ProviderDatagramSocketResult) Ordinal() uint64 { |
| return uint64(_m.I_providerDatagramSocketResultTag) |
| } |
| |
| func (_m *ProviderDatagramSocketResult) SetResponse(response ProviderDatagramSocketResponse) { |
| _m.reset() |
| _m.I_providerDatagramSocketResultTag = ProviderDatagramSocketResultResponse |
| _m.Response = response |
| } |
| |
| func ProviderDatagramSocketResultWithResponse(response ProviderDatagramSocketResponse) ProviderDatagramSocketResult { |
| var _u ProviderDatagramSocketResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProviderDatagramSocketResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_providerDatagramSocketResultTag = ProviderDatagramSocketResultErr |
| _m.Err = err |
| } |
| |
| func ProviderDatagramSocketResultWithErr(err fuchsiaposix.Errno) ProviderDatagramSocketResult { |
| var _u ProviderDatagramSocketResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_providerInterfaceIndexToNameResultTag uint64 |
| |
| const ( |
| ProviderInterfaceIndexToNameResultResponse = 1 // 0x00000001 |
| ProviderInterfaceIndexToNameResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProviderInterfaceIndexToNameResult struct { |
| I_providerInterfaceIndexToNameResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response ProviderInterfaceIndexToNameResponse `fidl_ordinal:"1"` |
| Err int32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProviderInterfaceIndexToNameResult = _bindings.CreateLazyMarshaler(ProviderInterfaceIndexToNameResult{}) |
| |
| func (msg *ProviderInterfaceIndexToNameResult) Marshaler() _bindings.Marshaler { |
| return _mProviderInterfaceIndexToNameResult |
| } |
| |
| func (_m *ProviderInterfaceIndexToNameResult) reset() { |
| switch _m.I_providerInterfaceIndexToNameResultTag { |
| case 1: |
| var _zeroed ProviderInterfaceIndexToNameResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed int32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProviderInterfaceIndexToNameResult) Which() I_providerInterfaceIndexToNameResultTag { |
| return _m.I_providerInterfaceIndexToNameResultTag |
| } |
| |
| func (_m *ProviderInterfaceIndexToNameResult) Ordinal() uint64 { |
| return uint64(_m.I_providerInterfaceIndexToNameResultTag) |
| } |
| |
| func (_m *ProviderInterfaceIndexToNameResult) SetResponse(response ProviderInterfaceIndexToNameResponse) { |
| _m.reset() |
| _m.I_providerInterfaceIndexToNameResultTag = ProviderInterfaceIndexToNameResultResponse |
| _m.Response = response |
| } |
| |
| func ProviderInterfaceIndexToNameResultWithResponse(response ProviderInterfaceIndexToNameResponse) ProviderInterfaceIndexToNameResult { |
| var _u ProviderInterfaceIndexToNameResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProviderInterfaceIndexToNameResult) SetErr(err int32) { |
| _m.reset() |
| _m.I_providerInterfaceIndexToNameResultTag = ProviderInterfaceIndexToNameResultErr |
| _m.Err = err |
| } |
| |
| func ProviderInterfaceIndexToNameResultWithErr(err int32) ProviderInterfaceIndexToNameResult { |
| var _u ProviderInterfaceIndexToNameResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_providerInterfaceNameToFlagsResultTag uint64 |
| |
| const ( |
| ProviderInterfaceNameToFlagsResultResponse = 1 // 0x00000001 |
| ProviderInterfaceNameToFlagsResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProviderInterfaceNameToFlagsResult struct { |
| I_providerInterfaceNameToFlagsResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response ProviderInterfaceNameToFlagsResponse `fidl_ordinal:"1"` |
| Err int32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProviderInterfaceNameToFlagsResult = _bindings.CreateLazyMarshaler(ProviderInterfaceNameToFlagsResult{}) |
| |
| func (msg *ProviderInterfaceNameToFlagsResult) Marshaler() _bindings.Marshaler { |
| return _mProviderInterfaceNameToFlagsResult |
| } |
| |
| func (_m *ProviderInterfaceNameToFlagsResult) reset() { |
| switch _m.I_providerInterfaceNameToFlagsResultTag { |
| case 1: |
| var _zeroed ProviderInterfaceNameToFlagsResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed int32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProviderInterfaceNameToFlagsResult) Which() I_providerInterfaceNameToFlagsResultTag { |
| return _m.I_providerInterfaceNameToFlagsResultTag |
| } |
| |
| func (_m *ProviderInterfaceNameToFlagsResult) Ordinal() uint64 { |
| return uint64(_m.I_providerInterfaceNameToFlagsResultTag) |
| } |
| |
| func (_m *ProviderInterfaceNameToFlagsResult) SetResponse(response ProviderInterfaceNameToFlagsResponse) { |
| _m.reset() |
| _m.I_providerInterfaceNameToFlagsResultTag = ProviderInterfaceNameToFlagsResultResponse |
| _m.Response = response |
| } |
| |
| func ProviderInterfaceNameToFlagsResultWithResponse(response ProviderInterfaceNameToFlagsResponse) ProviderInterfaceNameToFlagsResult { |
| var _u ProviderInterfaceNameToFlagsResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProviderInterfaceNameToFlagsResult) SetErr(err int32) { |
| _m.reset() |
| _m.I_providerInterfaceNameToFlagsResultTag = ProviderInterfaceNameToFlagsResultErr |
| _m.Err = err |
| } |
| |
| func ProviderInterfaceNameToFlagsResultWithErr(err int32) ProviderInterfaceNameToFlagsResult { |
| var _u ProviderInterfaceNameToFlagsResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_providerInterfaceNameToIndexResultTag uint64 |
| |
| const ( |
| ProviderInterfaceNameToIndexResultResponse = 1 // 0x00000001 |
| ProviderInterfaceNameToIndexResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProviderInterfaceNameToIndexResult struct { |
| I_providerInterfaceNameToIndexResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response ProviderInterfaceNameToIndexResponse `fidl_ordinal:"1"` |
| Err int32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProviderInterfaceNameToIndexResult = _bindings.CreateLazyMarshaler(ProviderInterfaceNameToIndexResult{}) |
| |
| func (msg *ProviderInterfaceNameToIndexResult) Marshaler() _bindings.Marshaler { |
| return _mProviderInterfaceNameToIndexResult |
| } |
| |
| func (_m *ProviderInterfaceNameToIndexResult) reset() { |
| switch _m.I_providerInterfaceNameToIndexResultTag { |
| case 1: |
| var _zeroed ProviderInterfaceNameToIndexResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed int32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProviderInterfaceNameToIndexResult) Which() I_providerInterfaceNameToIndexResultTag { |
| return _m.I_providerInterfaceNameToIndexResultTag |
| } |
| |
| func (_m *ProviderInterfaceNameToIndexResult) Ordinal() uint64 { |
| return uint64(_m.I_providerInterfaceNameToIndexResultTag) |
| } |
| |
| func (_m *ProviderInterfaceNameToIndexResult) SetResponse(response ProviderInterfaceNameToIndexResponse) { |
| _m.reset() |
| _m.I_providerInterfaceNameToIndexResultTag = ProviderInterfaceNameToIndexResultResponse |
| _m.Response = response |
| } |
| |
| func ProviderInterfaceNameToIndexResultWithResponse(response ProviderInterfaceNameToIndexResponse) ProviderInterfaceNameToIndexResult { |
| var _u ProviderInterfaceNameToIndexResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProviderInterfaceNameToIndexResult) SetErr(err int32) { |
| _m.reset() |
| _m.I_providerInterfaceNameToIndexResultTag = ProviderInterfaceNameToIndexResultErr |
| _m.Err = err |
| } |
| |
| func ProviderInterfaceNameToIndexResultWithErr(err int32) ProviderInterfaceNameToIndexResult { |
| var _u ProviderInterfaceNameToIndexResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_providerStreamSocketResultTag uint64 |
| |
| const ( |
| ProviderStreamSocketResultResponse = 1 // 0x00000001 |
| ProviderStreamSocketResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProviderStreamSocketResult struct { |
| I_providerStreamSocketResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| Response ProviderStreamSocketResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mProviderStreamSocketResult = _bindings.CreateLazyMarshaler(ProviderStreamSocketResult{}) |
| |
| func (msg *ProviderStreamSocketResult) Marshaler() _bindings.Marshaler { |
| return _mProviderStreamSocketResult |
| } |
| |
| func (_m *ProviderStreamSocketResult) reset() { |
| switch _m.I_providerStreamSocketResultTag { |
| case 1: |
| var _zeroed ProviderStreamSocketResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProviderStreamSocketResult) Which() I_providerStreamSocketResultTag { |
| return _m.I_providerStreamSocketResultTag |
| } |
| |
| func (_m *ProviderStreamSocketResult) Ordinal() uint64 { |
| return uint64(_m.I_providerStreamSocketResultTag) |
| } |
| |
| func (_m *ProviderStreamSocketResult) SetResponse(response ProviderStreamSocketResponse) { |
| _m.reset() |
| _m.I_providerStreamSocketResultTag = ProviderStreamSocketResultResponse |
| _m.Response = response |
| } |
| |
| func ProviderStreamSocketResultWithResponse(response ProviderStreamSocketResponse) ProviderStreamSocketResult { |
| var _u ProviderStreamSocketResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProviderStreamSocketResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_providerStreamSocketResultTag = ProviderStreamSocketResultErr |
| _m.Err = err |
| } |
| |
| func ProviderStreamSocketResultWithErr(err fuchsiaposix.Errno) ProviderStreamSocketResult { |
| var _u ProviderStreamSocketResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketAcceptResultTag uint64 |
| |
| const ( |
| StreamSocketAcceptResultResponse = 1 // 0x00000001 |
| StreamSocketAcceptResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketAcceptResult struct { |
| I_streamSocketAcceptResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| Response StreamSocketAcceptResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketAcceptResult = _bindings.CreateLazyMarshaler(StreamSocketAcceptResult{}) |
| |
| func (msg *StreamSocketAcceptResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketAcceptResult |
| } |
| |
| func (_m *StreamSocketAcceptResult) reset() { |
| switch _m.I_streamSocketAcceptResultTag { |
| case 1: |
| var _zeroed StreamSocketAcceptResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketAcceptResult) Which() I_streamSocketAcceptResultTag { |
| return _m.I_streamSocketAcceptResultTag |
| } |
| |
| func (_m *StreamSocketAcceptResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketAcceptResultTag) |
| } |
| |
| func (_m *StreamSocketAcceptResult) SetResponse(response StreamSocketAcceptResponse) { |
| _m.reset() |
| _m.I_streamSocketAcceptResultTag = StreamSocketAcceptResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketAcceptResultWithResponse(response StreamSocketAcceptResponse) StreamSocketAcceptResult { |
| var _u StreamSocketAcceptResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketAcceptResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketAcceptResultTag = StreamSocketAcceptResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketAcceptResultWithErr(err fuchsiaposix.Errno) StreamSocketAcceptResult { |
| var _u StreamSocketAcceptResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetInfoResultTag uint64 |
| |
| const ( |
| StreamSocketGetInfoResultResponse = 1 // 0x00000001 |
| StreamSocketGetInfoResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetInfoResult struct { |
| I_streamSocketGetInfoResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetInfoResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetInfoResult = _bindings.CreateLazyMarshaler(StreamSocketGetInfoResult{}) |
| |
| func (msg *StreamSocketGetInfoResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetInfoResult |
| } |
| |
| func (_m *StreamSocketGetInfoResult) reset() { |
| switch _m.I_streamSocketGetInfoResultTag { |
| case 1: |
| var _zeroed StreamSocketGetInfoResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetInfoResult) Which() I_streamSocketGetInfoResultTag { |
| return _m.I_streamSocketGetInfoResultTag |
| } |
| |
| func (_m *StreamSocketGetInfoResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetInfoResultTag) |
| } |
| |
| func (_m *StreamSocketGetInfoResult) SetResponse(response StreamSocketGetInfoResponse) { |
| _m.reset() |
| _m.I_streamSocketGetInfoResultTag = StreamSocketGetInfoResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetInfoResultWithResponse(response StreamSocketGetInfoResponse) StreamSocketGetInfoResult { |
| var _u StreamSocketGetInfoResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetInfoResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetInfoResultTag = StreamSocketGetInfoResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetInfoResultWithErr(err fuchsiaposix.Errno) StreamSocketGetInfoResult { |
| var _u StreamSocketGetInfoResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpCongestionResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpCongestionResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpCongestionResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpCongestionResult struct { |
| I_streamSocketGetTcpCongestionResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpCongestionResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpCongestionResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpCongestionResult{}) |
| |
| func (msg *StreamSocketGetTcpCongestionResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpCongestionResult |
| } |
| |
| func (_m *StreamSocketGetTcpCongestionResult) reset() { |
| switch _m.I_streamSocketGetTcpCongestionResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpCongestionResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpCongestionResult) Which() I_streamSocketGetTcpCongestionResultTag { |
| return _m.I_streamSocketGetTcpCongestionResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpCongestionResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpCongestionResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpCongestionResult) SetResponse(response StreamSocketGetTcpCongestionResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpCongestionResultTag = StreamSocketGetTcpCongestionResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpCongestionResultWithResponse(response StreamSocketGetTcpCongestionResponse) StreamSocketGetTcpCongestionResult { |
| var _u StreamSocketGetTcpCongestionResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpCongestionResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpCongestionResultTag = StreamSocketGetTcpCongestionResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpCongestionResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpCongestionResult { |
| var _u StreamSocketGetTcpCongestionResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpCorkResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpCorkResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpCorkResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpCorkResult struct { |
| I_streamSocketGetTcpCorkResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpCorkResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpCorkResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpCorkResult{}) |
| |
| func (msg *StreamSocketGetTcpCorkResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpCorkResult |
| } |
| |
| func (_m *StreamSocketGetTcpCorkResult) reset() { |
| switch _m.I_streamSocketGetTcpCorkResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpCorkResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpCorkResult) Which() I_streamSocketGetTcpCorkResultTag { |
| return _m.I_streamSocketGetTcpCorkResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpCorkResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpCorkResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpCorkResult) SetResponse(response StreamSocketGetTcpCorkResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpCorkResultTag = StreamSocketGetTcpCorkResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpCorkResultWithResponse(response StreamSocketGetTcpCorkResponse) StreamSocketGetTcpCorkResult { |
| var _u StreamSocketGetTcpCorkResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpCorkResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpCorkResultTag = StreamSocketGetTcpCorkResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpCorkResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpCorkResult { |
| var _u StreamSocketGetTcpCorkResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpDeferAcceptResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpDeferAcceptResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpDeferAcceptResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpDeferAcceptResult struct { |
| I_streamSocketGetTcpDeferAcceptResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpDeferAcceptResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpDeferAcceptResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpDeferAcceptResult{}) |
| |
| func (msg *StreamSocketGetTcpDeferAcceptResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpDeferAcceptResult |
| } |
| |
| func (_m *StreamSocketGetTcpDeferAcceptResult) reset() { |
| switch _m.I_streamSocketGetTcpDeferAcceptResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpDeferAcceptResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpDeferAcceptResult) Which() I_streamSocketGetTcpDeferAcceptResultTag { |
| return _m.I_streamSocketGetTcpDeferAcceptResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpDeferAcceptResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpDeferAcceptResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpDeferAcceptResult) SetResponse(response StreamSocketGetTcpDeferAcceptResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpDeferAcceptResultTag = StreamSocketGetTcpDeferAcceptResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpDeferAcceptResultWithResponse(response StreamSocketGetTcpDeferAcceptResponse) StreamSocketGetTcpDeferAcceptResult { |
| var _u StreamSocketGetTcpDeferAcceptResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpDeferAcceptResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpDeferAcceptResultTag = StreamSocketGetTcpDeferAcceptResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpDeferAcceptResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpDeferAcceptResult { |
| var _u StreamSocketGetTcpDeferAcceptResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpInfoResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpInfoResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpInfoResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpInfoResult struct { |
| I_streamSocketGetTcpInfoResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpInfoResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpInfoResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpInfoResult{}) |
| |
| func (msg *StreamSocketGetTcpInfoResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpInfoResult |
| } |
| |
| func (_m *StreamSocketGetTcpInfoResult) reset() { |
| switch _m.I_streamSocketGetTcpInfoResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpInfoResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpInfoResult) Which() I_streamSocketGetTcpInfoResultTag { |
| return _m.I_streamSocketGetTcpInfoResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpInfoResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpInfoResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpInfoResult) SetResponse(response StreamSocketGetTcpInfoResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpInfoResultTag = StreamSocketGetTcpInfoResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpInfoResultWithResponse(response StreamSocketGetTcpInfoResponse) StreamSocketGetTcpInfoResult { |
| var _u StreamSocketGetTcpInfoResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpInfoResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpInfoResultTag = StreamSocketGetTcpInfoResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpInfoResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpInfoResult { |
| var _u StreamSocketGetTcpInfoResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpKeepAliveCountResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpKeepAliveCountResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpKeepAliveCountResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpKeepAliveCountResult struct { |
| I_streamSocketGetTcpKeepAliveCountResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpKeepAliveCountResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpKeepAliveCountResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpKeepAliveCountResult{}) |
| |
| func (msg *StreamSocketGetTcpKeepAliveCountResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpKeepAliveCountResult |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveCountResult) reset() { |
| switch _m.I_streamSocketGetTcpKeepAliveCountResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpKeepAliveCountResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveCountResult) Which() I_streamSocketGetTcpKeepAliveCountResultTag { |
| return _m.I_streamSocketGetTcpKeepAliveCountResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveCountResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpKeepAliveCountResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveCountResult) SetResponse(response StreamSocketGetTcpKeepAliveCountResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpKeepAliveCountResultTag = StreamSocketGetTcpKeepAliveCountResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpKeepAliveCountResultWithResponse(response StreamSocketGetTcpKeepAliveCountResponse) StreamSocketGetTcpKeepAliveCountResult { |
| var _u StreamSocketGetTcpKeepAliveCountResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveCountResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpKeepAliveCountResultTag = StreamSocketGetTcpKeepAliveCountResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpKeepAliveCountResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpKeepAliveCountResult { |
| var _u StreamSocketGetTcpKeepAliveCountResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpKeepAliveIdleResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpKeepAliveIdleResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpKeepAliveIdleResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpKeepAliveIdleResult struct { |
| I_streamSocketGetTcpKeepAliveIdleResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpKeepAliveIdleResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpKeepAliveIdleResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpKeepAliveIdleResult{}) |
| |
| func (msg *StreamSocketGetTcpKeepAliveIdleResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpKeepAliveIdleResult |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIdleResult) reset() { |
| switch _m.I_streamSocketGetTcpKeepAliveIdleResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpKeepAliveIdleResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIdleResult) Which() I_streamSocketGetTcpKeepAliveIdleResultTag { |
| return _m.I_streamSocketGetTcpKeepAliveIdleResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIdleResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpKeepAliveIdleResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIdleResult) SetResponse(response StreamSocketGetTcpKeepAliveIdleResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpKeepAliveIdleResultTag = StreamSocketGetTcpKeepAliveIdleResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpKeepAliveIdleResultWithResponse(response StreamSocketGetTcpKeepAliveIdleResponse) StreamSocketGetTcpKeepAliveIdleResult { |
| var _u StreamSocketGetTcpKeepAliveIdleResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIdleResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpKeepAliveIdleResultTag = StreamSocketGetTcpKeepAliveIdleResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpKeepAliveIdleResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpKeepAliveIdleResult { |
| var _u StreamSocketGetTcpKeepAliveIdleResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpKeepAliveIntervalResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpKeepAliveIntervalResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpKeepAliveIntervalResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpKeepAliveIntervalResult struct { |
| I_streamSocketGetTcpKeepAliveIntervalResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpKeepAliveIntervalResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpKeepAliveIntervalResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpKeepAliveIntervalResult{}) |
| |
| func (msg *StreamSocketGetTcpKeepAliveIntervalResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpKeepAliveIntervalResult |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIntervalResult) reset() { |
| switch _m.I_streamSocketGetTcpKeepAliveIntervalResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpKeepAliveIntervalResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIntervalResult) Which() I_streamSocketGetTcpKeepAliveIntervalResultTag { |
| return _m.I_streamSocketGetTcpKeepAliveIntervalResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIntervalResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpKeepAliveIntervalResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIntervalResult) SetResponse(response StreamSocketGetTcpKeepAliveIntervalResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpKeepAliveIntervalResultTag = StreamSocketGetTcpKeepAliveIntervalResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpKeepAliveIntervalResultWithResponse(response StreamSocketGetTcpKeepAliveIntervalResponse) StreamSocketGetTcpKeepAliveIntervalResult { |
| var _u StreamSocketGetTcpKeepAliveIntervalResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpKeepAliveIntervalResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpKeepAliveIntervalResultTag = StreamSocketGetTcpKeepAliveIntervalResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpKeepAliveIntervalResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpKeepAliveIntervalResult { |
| var _u StreamSocketGetTcpKeepAliveIntervalResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpLingerResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpLingerResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpLingerResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpLingerResult struct { |
| I_streamSocketGetTcpLingerResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpLingerResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpLingerResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpLingerResult{}) |
| |
| func (msg *StreamSocketGetTcpLingerResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpLingerResult |
| } |
| |
| func (_m *StreamSocketGetTcpLingerResult) reset() { |
| switch _m.I_streamSocketGetTcpLingerResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpLingerResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpLingerResult) Which() I_streamSocketGetTcpLingerResultTag { |
| return _m.I_streamSocketGetTcpLingerResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpLingerResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpLingerResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpLingerResult) SetResponse(response StreamSocketGetTcpLingerResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpLingerResultTag = StreamSocketGetTcpLingerResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpLingerResultWithResponse(response StreamSocketGetTcpLingerResponse) StreamSocketGetTcpLingerResult { |
| var _u StreamSocketGetTcpLingerResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpLingerResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpLingerResultTag = StreamSocketGetTcpLingerResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpLingerResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpLingerResult { |
| var _u StreamSocketGetTcpLingerResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpMaxSegmentResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpMaxSegmentResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpMaxSegmentResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpMaxSegmentResult struct { |
| I_streamSocketGetTcpMaxSegmentResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpMaxSegmentResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpMaxSegmentResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpMaxSegmentResult{}) |
| |
| func (msg *StreamSocketGetTcpMaxSegmentResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpMaxSegmentResult |
| } |
| |
| func (_m *StreamSocketGetTcpMaxSegmentResult) reset() { |
| switch _m.I_streamSocketGetTcpMaxSegmentResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpMaxSegmentResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpMaxSegmentResult) Which() I_streamSocketGetTcpMaxSegmentResultTag { |
| return _m.I_streamSocketGetTcpMaxSegmentResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpMaxSegmentResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpMaxSegmentResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpMaxSegmentResult) SetResponse(response StreamSocketGetTcpMaxSegmentResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpMaxSegmentResultTag = StreamSocketGetTcpMaxSegmentResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpMaxSegmentResultWithResponse(response StreamSocketGetTcpMaxSegmentResponse) StreamSocketGetTcpMaxSegmentResult { |
| var _u StreamSocketGetTcpMaxSegmentResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpMaxSegmentResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpMaxSegmentResultTag = StreamSocketGetTcpMaxSegmentResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpMaxSegmentResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpMaxSegmentResult { |
| var _u StreamSocketGetTcpMaxSegmentResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpNoDelayResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpNoDelayResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpNoDelayResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpNoDelayResult struct { |
| I_streamSocketGetTcpNoDelayResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpNoDelayResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpNoDelayResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpNoDelayResult{}) |
| |
| func (msg *StreamSocketGetTcpNoDelayResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpNoDelayResult |
| } |
| |
| func (_m *StreamSocketGetTcpNoDelayResult) reset() { |
| switch _m.I_streamSocketGetTcpNoDelayResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpNoDelayResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpNoDelayResult) Which() I_streamSocketGetTcpNoDelayResultTag { |
| return _m.I_streamSocketGetTcpNoDelayResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpNoDelayResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpNoDelayResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpNoDelayResult) SetResponse(response StreamSocketGetTcpNoDelayResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpNoDelayResultTag = StreamSocketGetTcpNoDelayResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpNoDelayResultWithResponse(response StreamSocketGetTcpNoDelayResponse) StreamSocketGetTcpNoDelayResult { |
| var _u StreamSocketGetTcpNoDelayResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpNoDelayResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpNoDelayResultTag = StreamSocketGetTcpNoDelayResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpNoDelayResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpNoDelayResult { |
| var _u StreamSocketGetTcpNoDelayResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpQuickAckResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpQuickAckResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpQuickAckResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpQuickAckResult struct { |
| I_streamSocketGetTcpQuickAckResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpQuickAckResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpQuickAckResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpQuickAckResult{}) |
| |
| func (msg *StreamSocketGetTcpQuickAckResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpQuickAckResult |
| } |
| |
| func (_m *StreamSocketGetTcpQuickAckResult) reset() { |
| switch _m.I_streamSocketGetTcpQuickAckResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpQuickAckResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpQuickAckResult) Which() I_streamSocketGetTcpQuickAckResultTag { |
| return _m.I_streamSocketGetTcpQuickAckResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpQuickAckResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpQuickAckResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpQuickAckResult) SetResponse(response StreamSocketGetTcpQuickAckResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpQuickAckResultTag = StreamSocketGetTcpQuickAckResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpQuickAckResultWithResponse(response StreamSocketGetTcpQuickAckResponse) StreamSocketGetTcpQuickAckResult { |
| var _u StreamSocketGetTcpQuickAckResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpQuickAckResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpQuickAckResultTag = StreamSocketGetTcpQuickAckResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpQuickAckResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpQuickAckResult { |
| var _u StreamSocketGetTcpQuickAckResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpSynCountResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpSynCountResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpSynCountResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpSynCountResult struct { |
| I_streamSocketGetTcpSynCountResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpSynCountResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpSynCountResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpSynCountResult{}) |
| |
| func (msg *StreamSocketGetTcpSynCountResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpSynCountResult |
| } |
| |
| func (_m *StreamSocketGetTcpSynCountResult) reset() { |
| switch _m.I_streamSocketGetTcpSynCountResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpSynCountResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpSynCountResult) Which() I_streamSocketGetTcpSynCountResultTag { |
| return _m.I_streamSocketGetTcpSynCountResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpSynCountResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpSynCountResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpSynCountResult) SetResponse(response StreamSocketGetTcpSynCountResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpSynCountResultTag = StreamSocketGetTcpSynCountResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpSynCountResultWithResponse(response StreamSocketGetTcpSynCountResponse) StreamSocketGetTcpSynCountResult { |
| var _u StreamSocketGetTcpSynCountResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpSynCountResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpSynCountResultTag = StreamSocketGetTcpSynCountResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpSynCountResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpSynCountResult { |
| var _u StreamSocketGetTcpSynCountResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpUserTimeoutResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpUserTimeoutResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpUserTimeoutResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpUserTimeoutResult struct { |
| I_streamSocketGetTcpUserTimeoutResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpUserTimeoutResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpUserTimeoutResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpUserTimeoutResult{}) |
| |
| func (msg *StreamSocketGetTcpUserTimeoutResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpUserTimeoutResult |
| } |
| |
| func (_m *StreamSocketGetTcpUserTimeoutResult) reset() { |
| switch _m.I_streamSocketGetTcpUserTimeoutResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpUserTimeoutResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpUserTimeoutResult) Which() I_streamSocketGetTcpUserTimeoutResultTag { |
| return _m.I_streamSocketGetTcpUserTimeoutResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpUserTimeoutResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpUserTimeoutResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpUserTimeoutResult) SetResponse(response StreamSocketGetTcpUserTimeoutResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpUserTimeoutResultTag = StreamSocketGetTcpUserTimeoutResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpUserTimeoutResultWithResponse(response StreamSocketGetTcpUserTimeoutResponse) StreamSocketGetTcpUserTimeoutResult { |
| var _u StreamSocketGetTcpUserTimeoutResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpUserTimeoutResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpUserTimeoutResultTag = StreamSocketGetTcpUserTimeoutResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpUserTimeoutResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpUserTimeoutResult { |
| var _u StreamSocketGetTcpUserTimeoutResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketGetTcpWindowClampResultTag uint64 |
| |
| const ( |
| StreamSocketGetTcpWindowClampResultResponse = 1 // 0x00000001 |
| StreamSocketGetTcpWindowClampResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketGetTcpWindowClampResult struct { |
| I_streamSocketGetTcpWindowClampResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketGetTcpWindowClampResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketGetTcpWindowClampResult = _bindings.CreateLazyMarshaler(StreamSocketGetTcpWindowClampResult{}) |
| |
| func (msg *StreamSocketGetTcpWindowClampResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketGetTcpWindowClampResult |
| } |
| |
| func (_m *StreamSocketGetTcpWindowClampResult) reset() { |
| switch _m.I_streamSocketGetTcpWindowClampResultTag { |
| case 1: |
| var _zeroed StreamSocketGetTcpWindowClampResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketGetTcpWindowClampResult) Which() I_streamSocketGetTcpWindowClampResultTag { |
| return _m.I_streamSocketGetTcpWindowClampResultTag |
| } |
| |
| func (_m *StreamSocketGetTcpWindowClampResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketGetTcpWindowClampResultTag) |
| } |
| |
| func (_m *StreamSocketGetTcpWindowClampResult) SetResponse(response StreamSocketGetTcpWindowClampResponse) { |
| _m.reset() |
| _m.I_streamSocketGetTcpWindowClampResultTag = StreamSocketGetTcpWindowClampResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketGetTcpWindowClampResultWithResponse(response StreamSocketGetTcpWindowClampResponse) StreamSocketGetTcpWindowClampResult { |
| var _u StreamSocketGetTcpWindowClampResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketGetTcpWindowClampResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketGetTcpWindowClampResultTag = StreamSocketGetTcpWindowClampResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketGetTcpWindowClampResultWithErr(err fuchsiaposix.Errno) StreamSocketGetTcpWindowClampResult { |
| var _u StreamSocketGetTcpWindowClampResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketListenResultTag uint64 |
| |
| const ( |
| StreamSocketListenResultResponse = 1 // 0x00000001 |
| StreamSocketListenResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketListenResult struct { |
| I_streamSocketListenResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketListenResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketListenResult = _bindings.CreateLazyMarshaler(StreamSocketListenResult{}) |
| |
| func (msg *StreamSocketListenResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketListenResult |
| } |
| |
| func (_m *StreamSocketListenResult) reset() { |
| switch _m.I_streamSocketListenResultTag { |
| case 1: |
| var _zeroed StreamSocketListenResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketListenResult) Which() I_streamSocketListenResultTag { |
| return _m.I_streamSocketListenResultTag |
| } |
| |
| func (_m *StreamSocketListenResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketListenResultTag) |
| } |
| |
| func (_m *StreamSocketListenResult) SetResponse(response StreamSocketListenResponse) { |
| _m.reset() |
| _m.I_streamSocketListenResultTag = StreamSocketListenResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketListenResultWithResponse(response StreamSocketListenResponse) StreamSocketListenResult { |
| var _u StreamSocketListenResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketListenResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketListenResultTag = StreamSocketListenResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketListenResultWithErr(err fuchsiaposix.Errno) StreamSocketListenResult { |
| var _u StreamSocketListenResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpCongestionResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpCongestionResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpCongestionResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpCongestionResult struct { |
| I_streamSocketSetTcpCongestionResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpCongestionResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpCongestionResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpCongestionResult{}) |
| |
| func (msg *StreamSocketSetTcpCongestionResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpCongestionResult |
| } |
| |
| func (_m *StreamSocketSetTcpCongestionResult) reset() { |
| switch _m.I_streamSocketSetTcpCongestionResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpCongestionResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpCongestionResult) Which() I_streamSocketSetTcpCongestionResultTag { |
| return _m.I_streamSocketSetTcpCongestionResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpCongestionResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpCongestionResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpCongestionResult) SetResponse(response StreamSocketSetTcpCongestionResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpCongestionResultTag = StreamSocketSetTcpCongestionResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpCongestionResultWithResponse(response StreamSocketSetTcpCongestionResponse) StreamSocketSetTcpCongestionResult { |
| var _u StreamSocketSetTcpCongestionResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpCongestionResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpCongestionResultTag = StreamSocketSetTcpCongestionResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpCongestionResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpCongestionResult { |
| var _u StreamSocketSetTcpCongestionResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpCorkResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpCorkResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpCorkResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpCorkResult struct { |
| I_streamSocketSetTcpCorkResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpCorkResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpCorkResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpCorkResult{}) |
| |
| func (msg *StreamSocketSetTcpCorkResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpCorkResult |
| } |
| |
| func (_m *StreamSocketSetTcpCorkResult) reset() { |
| switch _m.I_streamSocketSetTcpCorkResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpCorkResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpCorkResult) Which() I_streamSocketSetTcpCorkResultTag { |
| return _m.I_streamSocketSetTcpCorkResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpCorkResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpCorkResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpCorkResult) SetResponse(response StreamSocketSetTcpCorkResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpCorkResultTag = StreamSocketSetTcpCorkResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpCorkResultWithResponse(response StreamSocketSetTcpCorkResponse) StreamSocketSetTcpCorkResult { |
| var _u StreamSocketSetTcpCorkResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpCorkResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpCorkResultTag = StreamSocketSetTcpCorkResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpCorkResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpCorkResult { |
| var _u StreamSocketSetTcpCorkResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpDeferAcceptResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpDeferAcceptResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpDeferAcceptResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpDeferAcceptResult struct { |
| I_streamSocketSetTcpDeferAcceptResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpDeferAcceptResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpDeferAcceptResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpDeferAcceptResult{}) |
| |
| func (msg *StreamSocketSetTcpDeferAcceptResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpDeferAcceptResult |
| } |
| |
| func (_m *StreamSocketSetTcpDeferAcceptResult) reset() { |
| switch _m.I_streamSocketSetTcpDeferAcceptResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpDeferAcceptResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpDeferAcceptResult) Which() I_streamSocketSetTcpDeferAcceptResultTag { |
| return _m.I_streamSocketSetTcpDeferAcceptResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpDeferAcceptResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpDeferAcceptResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpDeferAcceptResult) SetResponse(response StreamSocketSetTcpDeferAcceptResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpDeferAcceptResultTag = StreamSocketSetTcpDeferAcceptResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpDeferAcceptResultWithResponse(response StreamSocketSetTcpDeferAcceptResponse) StreamSocketSetTcpDeferAcceptResult { |
| var _u StreamSocketSetTcpDeferAcceptResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpDeferAcceptResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpDeferAcceptResultTag = StreamSocketSetTcpDeferAcceptResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpDeferAcceptResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpDeferAcceptResult { |
| var _u StreamSocketSetTcpDeferAcceptResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpKeepAliveCountResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpKeepAliveCountResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpKeepAliveCountResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpKeepAliveCountResult struct { |
| I_streamSocketSetTcpKeepAliveCountResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpKeepAliveCountResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpKeepAliveCountResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveCountResult{}) |
| |
| func (msg *StreamSocketSetTcpKeepAliveCountResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpKeepAliveCountResult |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveCountResult) reset() { |
| switch _m.I_streamSocketSetTcpKeepAliveCountResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpKeepAliveCountResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveCountResult) Which() I_streamSocketSetTcpKeepAliveCountResultTag { |
| return _m.I_streamSocketSetTcpKeepAliveCountResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveCountResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpKeepAliveCountResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveCountResult) SetResponse(response StreamSocketSetTcpKeepAliveCountResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpKeepAliveCountResultTag = StreamSocketSetTcpKeepAliveCountResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpKeepAliveCountResultWithResponse(response StreamSocketSetTcpKeepAliveCountResponse) StreamSocketSetTcpKeepAliveCountResult { |
| var _u StreamSocketSetTcpKeepAliveCountResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveCountResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpKeepAliveCountResultTag = StreamSocketSetTcpKeepAliveCountResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpKeepAliveCountResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpKeepAliveCountResult { |
| var _u StreamSocketSetTcpKeepAliveCountResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpKeepAliveIdleResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpKeepAliveIdleResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpKeepAliveIdleResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpKeepAliveIdleResult struct { |
| I_streamSocketSetTcpKeepAliveIdleResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpKeepAliveIdleResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpKeepAliveIdleResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveIdleResult{}) |
| |
| func (msg *StreamSocketSetTcpKeepAliveIdleResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpKeepAliveIdleResult |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIdleResult) reset() { |
| switch _m.I_streamSocketSetTcpKeepAliveIdleResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpKeepAliveIdleResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIdleResult) Which() I_streamSocketSetTcpKeepAliveIdleResultTag { |
| return _m.I_streamSocketSetTcpKeepAliveIdleResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIdleResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpKeepAliveIdleResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIdleResult) SetResponse(response StreamSocketSetTcpKeepAliveIdleResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpKeepAliveIdleResultTag = StreamSocketSetTcpKeepAliveIdleResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpKeepAliveIdleResultWithResponse(response StreamSocketSetTcpKeepAliveIdleResponse) StreamSocketSetTcpKeepAliveIdleResult { |
| var _u StreamSocketSetTcpKeepAliveIdleResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIdleResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpKeepAliveIdleResultTag = StreamSocketSetTcpKeepAliveIdleResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpKeepAliveIdleResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpKeepAliveIdleResult { |
| var _u StreamSocketSetTcpKeepAliveIdleResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpKeepAliveIntervalResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpKeepAliveIntervalResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpKeepAliveIntervalResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpKeepAliveIntervalResult struct { |
| I_streamSocketSetTcpKeepAliveIntervalResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpKeepAliveIntervalResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpKeepAliveIntervalResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpKeepAliveIntervalResult{}) |
| |
| func (msg *StreamSocketSetTcpKeepAliveIntervalResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpKeepAliveIntervalResult |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIntervalResult) reset() { |
| switch _m.I_streamSocketSetTcpKeepAliveIntervalResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpKeepAliveIntervalResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIntervalResult) Which() I_streamSocketSetTcpKeepAliveIntervalResultTag { |
| return _m.I_streamSocketSetTcpKeepAliveIntervalResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIntervalResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpKeepAliveIntervalResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIntervalResult) SetResponse(response StreamSocketSetTcpKeepAliveIntervalResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpKeepAliveIntervalResultTag = StreamSocketSetTcpKeepAliveIntervalResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpKeepAliveIntervalResultWithResponse(response StreamSocketSetTcpKeepAliveIntervalResponse) StreamSocketSetTcpKeepAliveIntervalResult { |
| var _u StreamSocketSetTcpKeepAliveIntervalResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpKeepAliveIntervalResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpKeepAliveIntervalResultTag = StreamSocketSetTcpKeepAliveIntervalResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpKeepAliveIntervalResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpKeepAliveIntervalResult { |
| var _u StreamSocketSetTcpKeepAliveIntervalResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpLingerResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpLingerResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpLingerResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpLingerResult struct { |
| I_streamSocketSetTcpLingerResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpLingerResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpLingerResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpLingerResult{}) |
| |
| func (msg *StreamSocketSetTcpLingerResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpLingerResult |
| } |
| |
| func (_m *StreamSocketSetTcpLingerResult) reset() { |
| switch _m.I_streamSocketSetTcpLingerResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpLingerResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpLingerResult) Which() I_streamSocketSetTcpLingerResultTag { |
| return _m.I_streamSocketSetTcpLingerResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpLingerResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpLingerResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpLingerResult) SetResponse(response StreamSocketSetTcpLingerResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpLingerResultTag = StreamSocketSetTcpLingerResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpLingerResultWithResponse(response StreamSocketSetTcpLingerResponse) StreamSocketSetTcpLingerResult { |
| var _u StreamSocketSetTcpLingerResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpLingerResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpLingerResultTag = StreamSocketSetTcpLingerResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpLingerResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpLingerResult { |
| var _u StreamSocketSetTcpLingerResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpMaxSegmentResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpMaxSegmentResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpMaxSegmentResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpMaxSegmentResult struct { |
| I_streamSocketSetTcpMaxSegmentResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpMaxSegmentResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpMaxSegmentResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpMaxSegmentResult{}) |
| |
| func (msg *StreamSocketSetTcpMaxSegmentResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpMaxSegmentResult |
| } |
| |
| func (_m *StreamSocketSetTcpMaxSegmentResult) reset() { |
| switch _m.I_streamSocketSetTcpMaxSegmentResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpMaxSegmentResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpMaxSegmentResult) Which() I_streamSocketSetTcpMaxSegmentResultTag { |
| return _m.I_streamSocketSetTcpMaxSegmentResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpMaxSegmentResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpMaxSegmentResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpMaxSegmentResult) SetResponse(response StreamSocketSetTcpMaxSegmentResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpMaxSegmentResultTag = StreamSocketSetTcpMaxSegmentResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpMaxSegmentResultWithResponse(response StreamSocketSetTcpMaxSegmentResponse) StreamSocketSetTcpMaxSegmentResult { |
| var _u StreamSocketSetTcpMaxSegmentResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpMaxSegmentResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpMaxSegmentResultTag = StreamSocketSetTcpMaxSegmentResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpMaxSegmentResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpMaxSegmentResult { |
| var _u StreamSocketSetTcpMaxSegmentResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpNoDelayResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpNoDelayResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpNoDelayResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpNoDelayResult struct { |
| I_streamSocketSetTcpNoDelayResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpNoDelayResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpNoDelayResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpNoDelayResult{}) |
| |
| func (msg *StreamSocketSetTcpNoDelayResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpNoDelayResult |
| } |
| |
| func (_m *StreamSocketSetTcpNoDelayResult) reset() { |
| switch _m.I_streamSocketSetTcpNoDelayResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpNoDelayResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpNoDelayResult) Which() I_streamSocketSetTcpNoDelayResultTag { |
| return _m.I_streamSocketSetTcpNoDelayResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpNoDelayResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpNoDelayResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpNoDelayResult) SetResponse(response StreamSocketSetTcpNoDelayResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpNoDelayResultTag = StreamSocketSetTcpNoDelayResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpNoDelayResultWithResponse(response StreamSocketSetTcpNoDelayResponse) StreamSocketSetTcpNoDelayResult { |
| var _u StreamSocketSetTcpNoDelayResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpNoDelayResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpNoDelayResultTag = StreamSocketSetTcpNoDelayResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpNoDelayResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpNoDelayResult { |
| var _u StreamSocketSetTcpNoDelayResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpQuickAckResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpQuickAckResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpQuickAckResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpQuickAckResult struct { |
| I_streamSocketSetTcpQuickAckResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpQuickAckResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpQuickAckResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpQuickAckResult{}) |
| |
| func (msg *StreamSocketSetTcpQuickAckResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpQuickAckResult |
| } |
| |
| func (_m *StreamSocketSetTcpQuickAckResult) reset() { |
| switch _m.I_streamSocketSetTcpQuickAckResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpQuickAckResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpQuickAckResult) Which() I_streamSocketSetTcpQuickAckResultTag { |
| return _m.I_streamSocketSetTcpQuickAckResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpQuickAckResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpQuickAckResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpQuickAckResult) SetResponse(response StreamSocketSetTcpQuickAckResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpQuickAckResultTag = StreamSocketSetTcpQuickAckResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpQuickAckResultWithResponse(response StreamSocketSetTcpQuickAckResponse) StreamSocketSetTcpQuickAckResult { |
| var _u StreamSocketSetTcpQuickAckResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpQuickAckResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpQuickAckResultTag = StreamSocketSetTcpQuickAckResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpQuickAckResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpQuickAckResult { |
| var _u StreamSocketSetTcpQuickAckResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpSynCountResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpSynCountResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpSynCountResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpSynCountResult struct { |
| I_streamSocketSetTcpSynCountResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpSynCountResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpSynCountResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpSynCountResult{}) |
| |
| func (msg *StreamSocketSetTcpSynCountResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpSynCountResult |
| } |
| |
| func (_m *StreamSocketSetTcpSynCountResult) reset() { |
| switch _m.I_streamSocketSetTcpSynCountResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpSynCountResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpSynCountResult) Which() I_streamSocketSetTcpSynCountResultTag { |
| return _m.I_streamSocketSetTcpSynCountResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpSynCountResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpSynCountResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpSynCountResult) SetResponse(response StreamSocketSetTcpSynCountResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpSynCountResultTag = StreamSocketSetTcpSynCountResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpSynCountResultWithResponse(response StreamSocketSetTcpSynCountResponse) StreamSocketSetTcpSynCountResult { |
| var _u StreamSocketSetTcpSynCountResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpSynCountResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpSynCountResultTag = StreamSocketSetTcpSynCountResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpSynCountResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpSynCountResult { |
| var _u StreamSocketSetTcpSynCountResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpUserTimeoutResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpUserTimeoutResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpUserTimeoutResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpUserTimeoutResult struct { |
| I_streamSocketSetTcpUserTimeoutResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpUserTimeoutResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpUserTimeoutResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpUserTimeoutResult{}) |
| |
| func (msg *StreamSocketSetTcpUserTimeoutResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpUserTimeoutResult |
| } |
| |
| func (_m *StreamSocketSetTcpUserTimeoutResult) reset() { |
| switch _m.I_streamSocketSetTcpUserTimeoutResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpUserTimeoutResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpUserTimeoutResult) Which() I_streamSocketSetTcpUserTimeoutResultTag { |
| return _m.I_streamSocketSetTcpUserTimeoutResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpUserTimeoutResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpUserTimeoutResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpUserTimeoutResult) SetResponse(response StreamSocketSetTcpUserTimeoutResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpUserTimeoutResultTag = StreamSocketSetTcpUserTimeoutResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpUserTimeoutResultWithResponse(response StreamSocketSetTcpUserTimeoutResponse) StreamSocketSetTcpUserTimeoutResult { |
| var _u StreamSocketSetTcpUserTimeoutResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpUserTimeoutResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpUserTimeoutResultTag = StreamSocketSetTcpUserTimeoutResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpUserTimeoutResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpUserTimeoutResult { |
| var _u StreamSocketSetTcpUserTimeoutResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_streamSocketSetTcpWindowClampResultTag uint64 |
| |
| const ( |
| StreamSocketSetTcpWindowClampResultResponse = 1 // 0x00000001 |
| StreamSocketSetTcpWindowClampResultErr = 2 // 0x00000002 |
| ) |
| |
| type StreamSocketSetTcpWindowClampResult struct { |
| I_streamSocketSetTcpWindowClampResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response StreamSocketSetTcpWindowClampResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mStreamSocketSetTcpWindowClampResult = _bindings.CreateLazyMarshaler(StreamSocketSetTcpWindowClampResult{}) |
| |
| func (msg *StreamSocketSetTcpWindowClampResult) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketSetTcpWindowClampResult |
| } |
| |
| func (_m *StreamSocketSetTcpWindowClampResult) reset() { |
| switch _m.I_streamSocketSetTcpWindowClampResultTag { |
| case 1: |
| var _zeroed StreamSocketSetTcpWindowClampResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *StreamSocketSetTcpWindowClampResult) Which() I_streamSocketSetTcpWindowClampResultTag { |
| return _m.I_streamSocketSetTcpWindowClampResultTag |
| } |
| |
| func (_m *StreamSocketSetTcpWindowClampResult) Ordinal() uint64 { |
| return uint64(_m.I_streamSocketSetTcpWindowClampResultTag) |
| } |
| |
| func (_m *StreamSocketSetTcpWindowClampResult) SetResponse(response StreamSocketSetTcpWindowClampResponse) { |
| _m.reset() |
| _m.I_streamSocketSetTcpWindowClampResultTag = StreamSocketSetTcpWindowClampResultResponse |
| _m.Response = response |
| } |
| |
| func StreamSocketSetTcpWindowClampResultWithResponse(response StreamSocketSetTcpWindowClampResponse) StreamSocketSetTcpWindowClampResult { |
| var _u StreamSocketSetTcpWindowClampResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *StreamSocketSetTcpWindowClampResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_streamSocketSetTcpWindowClampResultTag = StreamSocketSetTcpWindowClampResultErr |
| _m.Err = err |
| } |
| |
| func StreamSocketSetTcpWindowClampResultWithErr(err fuchsiaposix.Errno) StreamSocketSetTcpWindowClampResult { |
| var _u StreamSocketSetTcpWindowClampResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_synchronousDatagramSocketRecvMsgResultTag uint64 |
| |
| const ( |
| SynchronousDatagramSocketRecvMsgResultResponse = 1 // 0x00000001 |
| SynchronousDatagramSocketRecvMsgResultErr = 2 // 0x00000002 |
| ) |
| |
| type SynchronousDatagramSocketRecvMsgResult struct { |
| I_synchronousDatagramSocketRecvMsgResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response SynchronousDatagramSocketRecvMsgResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mSynchronousDatagramSocketRecvMsgResult = _bindings.CreateLazyMarshaler(SynchronousDatagramSocketRecvMsgResult{}) |
| |
| func (msg *SynchronousDatagramSocketRecvMsgResult) Marshaler() _bindings.Marshaler { |
| return _mSynchronousDatagramSocketRecvMsgResult |
| } |
| |
| func (_m *SynchronousDatagramSocketRecvMsgResult) reset() { |
| switch _m.I_synchronousDatagramSocketRecvMsgResultTag { |
| case 1: |
| var _zeroed SynchronousDatagramSocketRecvMsgResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *SynchronousDatagramSocketRecvMsgResult) Which() I_synchronousDatagramSocketRecvMsgResultTag { |
| return _m.I_synchronousDatagramSocketRecvMsgResultTag |
| } |
| |
| func (_m *SynchronousDatagramSocketRecvMsgResult) Ordinal() uint64 { |
| return uint64(_m.I_synchronousDatagramSocketRecvMsgResultTag) |
| } |
| |
| func (_m *SynchronousDatagramSocketRecvMsgResult) SetResponse(response SynchronousDatagramSocketRecvMsgResponse) { |
| _m.reset() |
| _m.I_synchronousDatagramSocketRecvMsgResultTag = SynchronousDatagramSocketRecvMsgResultResponse |
| _m.Response = response |
| } |
| |
| func SynchronousDatagramSocketRecvMsgResultWithResponse(response SynchronousDatagramSocketRecvMsgResponse) SynchronousDatagramSocketRecvMsgResult { |
| var _u SynchronousDatagramSocketRecvMsgResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *SynchronousDatagramSocketRecvMsgResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_synchronousDatagramSocketRecvMsgResultTag = SynchronousDatagramSocketRecvMsgResultErr |
| _m.Err = err |
| } |
| |
| func SynchronousDatagramSocketRecvMsgResultWithErr(err fuchsiaposix.Errno) SynchronousDatagramSocketRecvMsgResult { |
| var _u SynchronousDatagramSocketRecvMsgResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_synchronousDatagramSocketSendMsgResultTag uint64 |
| |
| const ( |
| SynchronousDatagramSocketSendMsgResultResponse = 1 // 0x00000001 |
| SynchronousDatagramSocketSendMsgResultErr = 2 // 0x00000002 |
| ) |
| |
| type SynchronousDatagramSocketSendMsgResult struct { |
| I_synchronousDatagramSocketSendMsgResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response SynchronousDatagramSocketSendMsgResponse `fidl_ordinal:"1"` |
| Err fuchsiaposix.Errno `fidl_ordinal:"2"` |
| } |
| |
| var _mSynchronousDatagramSocketSendMsgResult = _bindings.CreateLazyMarshaler(SynchronousDatagramSocketSendMsgResult{}) |
| |
| func (msg *SynchronousDatagramSocketSendMsgResult) Marshaler() _bindings.Marshaler { |
| return _mSynchronousDatagramSocketSendMsgResult |
| } |
| |
| func (_m *SynchronousDatagramSocketSendMsgResult) reset() { |
| switch _m.I_synchronousDatagramSocketSendMsgResultTag { |
| case 1: |
| var _zeroed SynchronousDatagramSocketSendMsgResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed fuchsiaposix.Errno |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *SynchronousDatagramSocketSendMsgResult) Which() I_synchronousDatagramSocketSendMsgResultTag { |
| return _m.I_synchronousDatagramSocketSendMsgResultTag |
| } |
| |
| func (_m *SynchronousDatagramSocketSendMsgResult) Ordinal() uint64 { |
| return uint64(_m.I_synchronousDatagramSocketSendMsgResultTag) |
| } |
| |
| func (_m *SynchronousDatagramSocketSendMsgResult) SetResponse(response SynchronousDatagramSocketSendMsgResponse) { |
| _m.reset() |
| _m.I_synchronousDatagramSocketSendMsgResultTag = SynchronousDatagramSocketSendMsgResultResponse |
| _m.Response = response |
| } |
| |
| func SynchronousDatagramSocketSendMsgResultWithResponse(response SynchronousDatagramSocketSendMsgResponse) SynchronousDatagramSocketSendMsgResult { |
| var _u SynchronousDatagramSocketSendMsgResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *SynchronousDatagramSocketSendMsgResult) SetErr(err fuchsiaposix.Errno) { |
| _m.reset() |
| _m.I_synchronousDatagramSocketSendMsgResultTag = SynchronousDatagramSocketSendMsgResultErr |
| _m.Err = err |
| } |
| |
| func SynchronousDatagramSocketSendMsgResultWithErr(err fuchsiaposix.Errno) SynchronousDatagramSocketSendMsgResult { |
| var _u SynchronousDatagramSocketSendMsgResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type DatagramSocketDescribeResponse struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| I_unknownData interface{} |
| // `ZX_SOCKET_DATAGRAM` on which data is sent and received. |
| Socket _zx.Socket `fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0" fidl_ordinal:"1"` |
| SocketPresent bool |
| // Size of the buffer used to receive Tx metadata. |
| TxMetaBufSize uint64 `fidl_ordinal:"2"` |
| TxMetaBufSizePresent bool |
| // Size of the buffer used to receive Rx metadata. |
| RxMetaBufSize uint64 `fidl_ordinal:"3"` |
| RxMetaBufSizePresent bool |
| // Identifies the version of the protocol used to encode and decode |
| // metadata sent alongside payloads over the socket. |
| MetadataEncodingProtocolVersion UdpMetadataEncodingProtocolVersion `fidl_ordinal:"4"` |
| MetadataEncodingProtocolVersionPresent bool |
| } |
| |
| var _mDatagramSocketDescribeResponse = _bindings.CreateLazyMarshaler(DatagramSocketDescribeResponse{}) |
| |
| func (msg *DatagramSocketDescribeResponse) Marshaler() _bindings.Marshaler { |
| return _mDatagramSocketDescribeResponse |
| } |
| |
| func (u *DatagramSocketDescribeResponse) SetSocket(socket _zx.Socket) { |
| u.Socket = socket |
| u.SocketPresent = true |
| } |
| |
| func (u *DatagramSocketDescribeResponse) GetSocket() _zx.Socket { |
| return u.Socket |
| } |
| |
| func (u *DatagramSocketDescribeResponse) GetSocketWithDefault(_default _zx.Socket) _zx.Socket { |
| if !u.HasSocket() { |
| return _default |
| } |
| return u.Socket |
| } |
| |
| func (u *DatagramSocketDescribeResponse) HasSocket() bool { |
| return u.SocketPresent |
| } |
| |
| func (u *DatagramSocketDescribeResponse) ClearSocket() { |
| u.SocketPresent = false |
| } |
| |
| func (u *DatagramSocketDescribeResponse) SetTxMetaBufSize(txMetaBufSize uint64) { |
| u.TxMetaBufSize = txMetaBufSize |
| u.TxMetaBufSizePresent = true |
| } |
| |
| func (u *DatagramSocketDescribeResponse) GetTxMetaBufSize() uint64 { |
| return u.TxMetaBufSize |
| } |
| |
| func (u *DatagramSocketDescribeResponse) GetTxMetaBufSizeWithDefault(_default uint64) uint64 { |
| if !u.HasTxMetaBufSize() { |
| return _default |
| } |
| return u.TxMetaBufSize |
| } |
| |
| func (u *DatagramSocketDescribeResponse) HasTxMetaBufSize() bool { |
| return u.TxMetaBufSizePresent |
| } |
| |
| func (u *DatagramSocketDescribeResponse) ClearTxMetaBufSize() { |
| u.TxMetaBufSizePresent = false |
| } |
| |
| func (u *DatagramSocketDescribeResponse) SetRxMetaBufSize(rxMetaBufSize uint64) { |
| u.RxMetaBufSize = rxMetaBufSize |
| u.RxMetaBufSizePresent = true |
| } |
| |
| func (u *DatagramSocketDescribeResponse) GetRxMetaBufSize() uint64 { |
| return u.RxMetaBufSize |
| } |
| |
| func (u *DatagramSocketDescribeResponse) GetRxMetaBufSizeWithDefault(_default uint64) uint64 { |
| if !u.HasRxMetaBufSize() { |
| return _default |
| } |
| return u.RxMetaBufSize |
| } |
| |
| func (u *DatagramSocketDescribeResponse) HasRxMetaBufSize() bool { |
| return u.RxMetaBufSizePresent |
| } |
| |
| func (u *DatagramSocketDescribeResponse) ClearRxMetaBufSize() { |
| u.RxMetaBufSizePresent = false |
| } |
| |
| func (u *DatagramSocketDescribeResponse) SetMetadataEncodingProtocolVersion(metadataEncodingProtocolVersion UdpMetadataEncodingProtocolVersion) { |
| u.MetadataEncodingProtocolVersion = metadataEncodingProtocolVersion |
| u.MetadataEncodingProtocolVersionPresent = true |
| } |
| |
| func (u *DatagramSocketDescribeResponse) GetMetadataEncodingProtocolVersion() UdpMetadataEncodingProtocolVersion { |
| return u.MetadataEncodingProtocolVersion |
| } |
| |
| func (u *DatagramSocketDescribeResponse) GetMetadataEncodingProtocolVersionWithDefault(_default UdpMetadataEncodingProtocolVersion) UdpMetadataEncodingProtocolVersion { |
| if !u.HasMetadataEncodingProtocolVersion() { |
| return _default |
| } |
| return u.MetadataEncodingProtocolVersion |
| } |
| |
| func (u *DatagramSocketDescribeResponse) HasMetadataEncodingProtocolVersion() bool { |
| return u.MetadataEncodingProtocolVersionPresent |
| } |
| |
| func (u *DatagramSocketDescribeResponse) ClearMetadataEncodingProtocolVersion() { |
| u.MetadataEncodingProtocolVersionPresent = false |
| } |
| |
| func (u *DatagramSocketDescribeResponse) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *DatagramSocketDescribeResponse) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type DatagramSocketRecvControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // Network socket ancillary data. |
| Network NetworkSocketRecvControlData `fidl_ordinal:"1"` |
| NetworkPresent bool |
| } |
| |
| var _mDatagramSocketRecvControlData = _bindings.CreateLazyMarshaler(DatagramSocketRecvControlData{}) |
| |
| func (msg *DatagramSocketRecvControlData) Marshaler() _bindings.Marshaler { |
| return _mDatagramSocketRecvControlData |
| } |
| |
| func (u *DatagramSocketRecvControlData) SetNetwork(network NetworkSocketRecvControlData) { |
| u.Network = network |
| u.NetworkPresent = true |
| } |
| |
| func (u *DatagramSocketRecvControlData) GetNetwork() NetworkSocketRecvControlData { |
| return u.Network |
| } |
| |
| func (u *DatagramSocketRecvControlData) GetNetworkWithDefault(_default NetworkSocketRecvControlData) NetworkSocketRecvControlData { |
| if !u.HasNetwork() { |
| return _default |
| } |
| return u.Network |
| } |
| |
| func (u *DatagramSocketRecvControlData) HasNetwork() bool { |
| return u.NetworkPresent |
| } |
| |
| func (u *DatagramSocketRecvControlData) ClearNetwork() { |
| u.NetworkPresent = false |
| } |
| |
| func (u *DatagramSocketRecvControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *DatagramSocketRecvControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type DatagramSocketSendControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // Network socket ancillary data. |
| Network NetworkSocketSendControlData `fidl_ordinal:"1"` |
| NetworkPresent bool |
| } |
| |
| var _mDatagramSocketSendControlData = _bindings.CreateLazyMarshaler(DatagramSocketSendControlData{}) |
| |
| func (msg *DatagramSocketSendControlData) Marshaler() _bindings.Marshaler { |
| return _mDatagramSocketSendControlData |
| } |
| |
| func (u *DatagramSocketSendControlData) SetNetwork(network NetworkSocketSendControlData) { |
| u.Network = network |
| u.NetworkPresent = true |
| } |
| |
| func (u *DatagramSocketSendControlData) GetNetwork() NetworkSocketSendControlData { |
| return u.Network |
| } |
| |
| func (u *DatagramSocketSendControlData) GetNetworkWithDefault(_default NetworkSocketSendControlData) NetworkSocketSendControlData { |
| if !u.HasNetwork() { |
| return _default |
| } |
| return u.Network |
| } |
| |
| func (u *DatagramSocketSendControlData) HasNetwork() bool { |
| return u.NetworkPresent |
| } |
| |
| func (u *DatagramSocketSendControlData) ClearNetwork() { |
| u.NetworkPresent = false |
| } |
| |
| func (u *DatagramSocketSendControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *DatagramSocketSendControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type DatagramSocketSendMsgPreflightRequest struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // The destination address. |
| // |
| // If absent, interpreted as the method receiver's connected address and |
| // causes the connected address to be returned. |
| // |
| // Required if the method receiver is not connected. |
| To fuchsianet.SocketAddress `fidl_ordinal:"1"` |
| ToPresent bool |
| // Information controlling the local interface and/or address used when |
| // sending an IPv6 packet. |
| // |
| // If absent, indicates that the stack is free to choose an appropriate |
| // outgoing route. |
| Ipv6Pktinfo Ipv6PktInfoSendControlData `fidl_ordinal:"2"` |
| Ipv6PktinfoPresent bool |
| } |
| |
| var _mDatagramSocketSendMsgPreflightRequest = _bindings.CreateLazyMarshaler(DatagramSocketSendMsgPreflightRequest{}) |
| |
| func (msg *DatagramSocketSendMsgPreflightRequest) Marshaler() _bindings.Marshaler { |
| return _mDatagramSocketSendMsgPreflightRequest |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) SetTo(to fuchsianet.SocketAddress) { |
| u.To = to |
| u.ToPresent = true |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) GetTo() fuchsianet.SocketAddress { |
| return u.To |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) GetToWithDefault(_default fuchsianet.SocketAddress) fuchsianet.SocketAddress { |
| if !u.HasTo() { |
| return _default |
| } |
| return u.To |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) HasTo() bool { |
| return u.ToPresent |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) ClearTo() { |
| u.ToPresent = false |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) SetIpv6Pktinfo(ipv6Pktinfo Ipv6PktInfoSendControlData) { |
| u.Ipv6Pktinfo = ipv6Pktinfo |
| u.Ipv6PktinfoPresent = true |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) GetIpv6Pktinfo() Ipv6PktInfoSendControlData { |
| return u.Ipv6Pktinfo |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) GetIpv6PktinfoWithDefault(_default Ipv6PktInfoSendControlData) Ipv6PktInfoSendControlData { |
| if !u.HasIpv6Pktinfo() { |
| return _default |
| } |
| return u.Ipv6Pktinfo |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) HasIpv6Pktinfo() bool { |
| return u.Ipv6PktinfoPresent |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) ClearIpv6Pktinfo() { |
| u.Ipv6PktinfoPresent = false |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightRequest) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type DatagramSocketRecvMsgPostflightResponse struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| I_unknownData interface{} |
| // Represents the validity of this structure. |
| // |
| // The structure is invalid if the peer is closed. |
| Validity _zx.Handle `fidl_handle_subtype:"16" fidl_handle_rights:"49155" fidl_bounds:"0" fidl_ordinal:"1"` |
| ValidityPresent bool |
| // Identifies whether the `SO_TIMESTAMP` or `SO_TIMESTAMPNS` control messages are |
| // requested. |
| Timestamp TimestampOption `fidl_ordinal:"2"` |
| TimestampPresent bool |
| // Identifies the status (requested or not) of up to 32 control messages. |
| // This set size should be large enough to signal the status of all cmsgs supported |
| // by POSIX systems as of 2022. If that changes, the set can be extended by adding |
| // additional bits fields. |
| Requests CmsgRequests `fidl_ordinal:"3"` |
| RequestsPresent bool |
| } |
| |
| var _mDatagramSocketRecvMsgPostflightResponse = _bindings.CreateLazyMarshaler(DatagramSocketRecvMsgPostflightResponse{}) |
| |
| func (msg *DatagramSocketRecvMsgPostflightResponse) Marshaler() _bindings.Marshaler { |
| return _mDatagramSocketRecvMsgPostflightResponse |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) SetValidity(validity _zx.Handle) { |
| u.Validity = validity |
| u.ValidityPresent = true |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) GetValidity() _zx.Handle { |
| return u.Validity |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) GetValidityWithDefault(_default _zx.Handle) _zx.Handle { |
| if !u.HasValidity() { |
| return _default |
| } |
| return u.Validity |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) HasValidity() bool { |
| return u.ValidityPresent |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) ClearValidity() { |
| u.ValidityPresent = false |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) SetTimestamp(timestamp TimestampOption) { |
| u.Timestamp = timestamp |
| u.TimestampPresent = true |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) GetTimestamp() TimestampOption { |
| return u.Timestamp |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) GetTimestampWithDefault(_default TimestampOption) TimestampOption { |
| if !u.HasTimestamp() { |
| return _default |
| } |
| return u.Timestamp |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) HasTimestamp() bool { |
| return u.TimestampPresent |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) ClearTimestamp() { |
| u.TimestampPresent = false |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) SetRequests(requests CmsgRequests) { |
| u.Requests = requests |
| u.RequestsPresent = true |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) GetRequests() CmsgRequests { |
| return u.Requests |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) GetRequestsWithDefault(_default CmsgRequests) CmsgRequests { |
| if !u.HasRequests() { |
| return _default |
| } |
| return u.Requests |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) HasRequests() bool { |
| return u.RequestsPresent |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) ClearRequests() { |
| u.RequestsPresent = false |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *DatagramSocketRecvMsgPostflightResponse) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type DatagramSocketSendMsgPreflightResponse struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| I_unknownData interface{} |
| // The validated destination address. |
| // |
| // Present only in response to an unset `to` addreess. |
| To fuchsianet.SocketAddress `fidl_ordinal:"1"` |
| ToPresent bool |
| // Represents the validity of this structure. |
| // |
| // The structure is invalid if any of the elements' peer is closed. |
| // Datagrams sent with the associated metadata after invalidation will be |
| // silently dropped. |
| Validity []_zx.Handle `fidl_handle_subtype:"16" fidl_handle_rights:"49155" fidl_bounds:"63,0" fidl_ordinal:"2"` |
| ValidityPresent bool |
| // The maximum datagram size that can be sent. |
| // |
| // Datagrams exceeding this will be silently dropped. |
| MaximumSize uint32 `fidl_ordinal:"3"` |
| MaximumSizePresent bool |
| } |
| |
| var _mDatagramSocketSendMsgPreflightResponse = _bindings.CreateLazyMarshaler(DatagramSocketSendMsgPreflightResponse{}) |
| |
| func (msg *DatagramSocketSendMsgPreflightResponse) Marshaler() _bindings.Marshaler { |
| return _mDatagramSocketSendMsgPreflightResponse |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) SetTo(to fuchsianet.SocketAddress) { |
| u.To = to |
| u.ToPresent = true |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) GetTo() fuchsianet.SocketAddress { |
| return u.To |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) GetToWithDefault(_default fuchsianet.SocketAddress) fuchsianet.SocketAddress { |
| if !u.HasTo() { |
| return _default |
| } |
| return u.To |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) HasTo() bool { |
| return u.ToPresent |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) ClearTo() { |
| u.ToPresent = false |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) SetValidity(validity []_zx.Handle) { |
| u.Validity = validity |
| u.ValidityPresent = true |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) GetValidity() []_zx.Handle { |
| return u.Validity |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) GetValidityWithDefault(_default []_zx.Handle) []_zx.Handle { |
| if !u.HasValidity() { |
| return _default |
| } |
| return u.Validity |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) HasValidity() bool { |
| return u.ValidityPresent |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) ClearValidity() { |
| u.ValidityPresent = false |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) SetMaximumSize(maximumSize uint32) { |
| u.MaximumSize = maximumSize |
| u.MaximumSizePresent = true |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) GetMaximumSize() uint32 { |
| return u.MaximumSize |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) GetMaximumSizeWithDefault(_default uint32) uint32 { |
| if !u.HasMaximumSize() { |
| return _default |
| } |
| return u.MaximumSize |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) HasMaximumSize() bool { |
| return u.MaximumSizePresent |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) ClearMaximumSize() { |
| u.MaximumSizePresent = false |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *DatagramSocketSendMsgPreflightResponse) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| // Holds information about an interface and its addresses. |
| type InterfaceAddresses struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // ID of the interface. |
| Id uint64 `fidl_ordinal:"1"` |
| IdPresent bool |
| // Name of the interface. |
| Name string `fidl_bounds:"15" fidl_ordinal:"2"` |
| NamePresent bool |
| // All addresses currently assigned to the interface. |
| Addresses []fuchsianet.Subnet `fidl_bounds:"" fidl_ordinal:"4"` |
| AddressesPresent bool |
| // Contains the interface flags, as returned by the SIOCGIFFLAGS ioctl |
| // operation. |
| InterfaceFlags InterfaceFlags `fidl_ordinal:"5"` |
| InterfaceFlagsPresent bool |
| } |
| |
| var _mInterfaceAddresses = _bindings.CreateLazyMarshaler(InterfaceAddresses{}) |
| |
| func (msg *InterfaceAddresses) Marshaler() _bindings.Marshaler { |
| return _mInterfaceAddresses |
| } |
| |
| func (u *InterfaceAddresses) SetId(id uint64) { |
| u.Id = id |
| u.IdPresent = true |
| } |
| |
| func (u *InterfaceAddresses) GetId() uint64 { |
| return u.Id |
| } |
| |
| func (u *InterfaceAddresses) GetIdWithDefault(_default uint64) uint64 { |
| if !u.HasId() { |
| return _default |
| } |
| return u.Id |
| } |
| |
| func (u *InterfaceAddresses) HasId() bool { |
| return u.IdPresent |
| } |
| |
| func (u *InterfaceAddresses) ClearId() { |
| u.IdPresent = false |
| } |
| |
| func (u *InterfaceAddresses) SetName(name string) { |
| u.Name = name |
| u.NamePresent = true |
| } |
| |
| func (u *InterfaceAddresses) GetName() string { |
| return u.Name |
| } |
| |
| func (u *InterfaceAddresses) GetNameWithDefault(_default string) string { |
| if !u.HasName() { |
| return _default |
| } |
| return u.Name |
| } |
| |
| func (u *InterfaceAddresses) HasName() bool { |
| return u.NamePresent |
| } |
| |
| func (u *InterfaceAddresses) ClearName() { |
| u.NamePresent = false |
| } |
| |
| func (u *InterfaceAddresses) SetAddresses(addresses []fuchsianet.Subnet) { |
| u.Addresses = addresses |
| u.AddressesPresent = true |
| } |
| |
| func (u *InterfaceAddresses) GetAddresses() []fuchsianet.Subnet { |
| return u.Addresses |
| } |
| |
| func (u *InterfaceAddresses) GetAddressesWithDefault(_default []fuchsianet.Subnet) []fuchsianet.Subnet { |
| if !u.HasAddresses() { |
| return _default |
| } |
| return u.Addresses |
| } |
| |
| func (u *InterfaceAddresses) HasAddresses() bool { |
| return u.AddressesPresent |
| } |
| |
| func (u *InterfaceAddresses) ClearAddresses() { |
| u.AddressesPresent = false |
| } |
| |
| func (u *InterfaceAddresses) SetInterfaceFlags(interfaceFlags InterfaceFlags) { |
| u.InterfaceFlags = interfaceFlags |
| u.InterfaceFlagsPresent = true |
| } |
| |
| func (u *InterfaceAddresses) GetInterfaceFlags() InterfaceFlags { |
| return u.InterfaceFlags |
| } |
| |
| func (u *InterfaceAddresses) GetInterfaceFlagsWithDefault(_default InterfaceFlags) InterfaceFlags { |
| if !u.HasInterfaceFlags() { |
| return _default |
| } |
| return u.InterfaceFlags |
| } |
| |
| func (u *InterfaceAddresses) HasInterfaceFlags() bool { |
| return u.InterfaceFlagsPresent |
| } |
| |
| func (u *InterfaceAddresses) ClearInterfaceFlags() { |
| u.InterfaceFlagsPresent = false |
| } |
| |
| func (u *InterfaceAddresses) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *InterfaceAddresses) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type IpRecvControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // The Type of Service value found in a received packet's IPv4 header. |
| // |
| // Present if the `SOL_IP` -> `IP_RECVTOS` option is enabled. |
| Tos uint8 `fidl_ordinal:"1"` |
| TosPresent bool |
| // The Time to Live value found in a received packet's IPv4 header. |
| // |
| // Present if the `SOL_IP` -> `IP_RECVTTL` option is enabled. |
| Ttl uint8 `fidl_ordinal:"2"` |
| TtlPresent bool |
| // The original destination address. |
| // |
| // Present if the `SOL_IP` -> `IP_RECVORIGDSTADDR` option is enabled. |
| OriginalDestinationAddress fuchsianet.SocketAddress `fidl_ordinal:"3"` |
| OriginalDestinationAddressPresent bool |
| } |
| |
| var _mIpRecvControlData = _bindings.CreateLazyMarshaler(IpRecvControlData{}) |
| |
| func (msg *IpRecvControlData) Marshaler() _bindings.Marshaler { |
| return _mIpRecvControlData |
| } |
| |
| func (u *IpRecvControlData) SetTos(tos uint8) { |
| u.Tos = tos |
| u.TosPresent = true |
| } |
| |
| func (u *IpRecvControlData) GetTos() uint8 { |
| return u.Tos |
| } |
| |
| func (u *IpRecvControlData) GetTosWithDefault(_default uint8) uint8 { |
| if !u.HasTos() { |
| return _default |
| } |
| return u.Tos |
| } |
| |
| func (u *IpRecvControlData) HasTos() bool { |
| return u.TosPresent |
| } |
| |
| func (u *IpRecvControlData) ClearTos() { |
| u.TosPresent = false |
| } |
| |
| func (u *IpRecvControlData) SetTtl(ttl uint8) { |
| u.Ttl = ttl |
| u.TtlPresent = true |
| } |
| |
| func (u *IpRecvControlData) GetTtl() uint8 { |
| return u.Ttl |
| } |
| |
| func (u *IpRecvControlData) GetTtlWithDefault(_default uint8) uint8 { |
| if !u.HasTtl() { |
| return _default |
| } |
| return u.Ttl |
| } |
| |
| func (u *IpRecvControlData) HasTtl() bool { |
| return u.TtlPresent |
| } |
| |
| func (u *IpRecvControlData) ClearTtl() { |
| u.TtlPresent = false |
| } |
| |
| func (u *IpRecvControlData) SetOriginalDestinationAddress(originalDestinationAddress fuchsianet.SocketAddress) { |
| u.OriginalDestinationAddress = originalDestinationAddress |
| u.OriginalDestinationAddressPresent = true |
| } |
| |
| func (u *IpRecvControlData) GetOriginalDestinationAddress() fuchsianet.SocketAddress { |
| return u.OriginalDestinationAddress |
| } |
| |
| func (u *IpRecvControlData) GetOriginalDestinationAddressWithDefault(_default fuchsianet.SocketAddress) fuchsianet.SocketAddress { |
| if !u.HasOriginalDestinationAddress() { |
| return _default |
| } |
| return u.OriginalDestinationAddress |
| } |
| |
| func (u *IpRecvControlData) HasOriginalDestinationAddress() bool { |
| return u.OriginalDestinationAddressPresent |
| } |
| |
| func (u *IpRecvControlData) ClearOriginalDestinationAddress() { |
| u.OriginalDestinationAddressPresent = false |
| } |
| |
| func (u *IpRecvControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *IpRecvControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type IpSendControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // The Time to Live value to set in the IPv4 header of an outgoing |
| // packet. |
| Ttl uint8 `fidl_ordinal:"2"` |
| TtlPresent bool |
| } |
| |
| var _mIpSendControlData = _bindings.CreateLazyMarshaler(IpSendControlData{}) |
| |
| func (msg *IpSendControlData) Marshaler() _bindings.Marshaler { |
| return _mIpSendControlData |
| } |
| |
| func (u *IpSendControlData) SetTtl(ttl uint8) { |
| u.Ttl = ttl |
| u.TtlPresent = true |
| } |
| |
| func (u *IpSendControlData) GetTtl() uint8 { |
| return u.Ttl |
| } |
| |
| func (u *IpSendControlData) GetTtlWithDefault(_default uint8) uint8 { |
| if !u.HasTtl() { |
| return _default |
| } |
| return u.Ttl |
| } |
| |
| func (u *IpSendControlData) HasTtl() bool { |
| return u.TtlPresent |
| } |
| |
| func (u *IpSendControlData) ClearTtl() { |
| u.TtlPresent = false |
| } |
| |
| func (u *IpSendControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *IpSendControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type Ipv6RecvControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // The Traffic Class of a packet that was received. |
| // |
| // Present if the `SOL_IPV6` -> `IPV6_RECVTCLASS` option is enabled. |
| Tclass uint8 `fidl_ordinal:"1"` |
| TclassPresent bool |
| // The Hop Limit of a packet that was received. |
| // |
| // Present if the `SOL_IPV6` -> `IPV6_RECVHOPLIMIT` option is enabled. |
| Hoplimit uint8 `fidl_ordinal:"2"` |
| HoplimitPresent bool |
| // The packet information of a packet that was received. |
| // |
| // Present if the `SOL_IPV6` -> `IPV6_RECVPKTINFO` option is enabled. |
| Pktinfo Ipv6PktInfoRecvControlData `fidl_ordinal:"3"` |
| PktinfoPresent bool |
| } |
| |
| var _mIpv6RecvControlData = _bindings.CreateLazyMarshaler(Ipv6RecvControlData{}) |
| |
| func (msg *Ipv6RecvControlData) Marshaler() _bindings.Marshaler { |
| return _mIpv6RecvControlData |
| } |
| |
| func (u *Ipv6RecvControlData) SetTclass(tclass uint8) { |
| u.Tclass = tclass |
| u.TclassPresent = true |
| } |
| |
| func (u *Ipv6RecvControlData) GetTclass() uint8 { |
| return u.Tclass |
| } |
| |
| func (u *Ipv6RecvControlData) GetTclassWithDefault(_default uint8) uint8 { |
| if !u.HasTclass() { |
| return _default |
| } |
| return u.Tclass |
| } |
| |
| func (u *Ipv6RecvControlData) HasTclass() bool { |
| return u.TclassPresent |
| } |
| |
| func (u *Ipv6RecvControlData) ClearTclass() { |
| u.TclassPresent = false |
| } |
| |
| func (u *Ipv6RecvControlData) SetHoplimit(hoplimit uint8) { |
| u.Hoplimit = hoplimit |
| u.HoplimitPresent = true |
| } |
| |
| func (u *Ipv6RecvControlData) GetHoplimit() uint8 { |
| return u.Hoplimit |
| } |
| |
| func (u *Ipv6RecvControlData) GetHoplimitWithDefault(_default uint8) uint8 { |
| if !u.HasHoplimit() { |
| return _default |
| } |
| return u.Hoplimit |
| } |
| |
| func (u *Ipv6RecvControlData) HasHoplimit() bool { |
| return u.HoplimitPresent |
| } |
| |
| func (u *Ipv6RecvControlData) ClearHoplimit() { |
| u.HoplimitPresent = false |
| } |
| |
| func (u *Ipv6RecvControlData) SetPktinfo(pktinfo Ipv6PktInfoRecvControlData) { |
| u.Pktinfo = pktinfo |
| u.PktinfoPresent = true |
| } |
| |
| func (u *Ipv6RecvControlData) GetPktinfo() Ipv6PktInfoRecvControlData { |
| return u.Pktinfo |
| } |
| |
| func (u *Ipv6RecvControlData) GetPktinfoWithDefault(_default Ipv6PktInfoRecvControlData) Ipv6PktInfoRecvControlData { |
| if !u.HasPktinfo() { |
| return _default |
| } |
| return u.Pktinfo |
| } |
| |
| func (u *Ipv6RecvControlData) HasPktinfo() bool { |
| return u.PktinfoPresent |
| } |
| |
| func (u *Ipv6RecvControlData) ClearPktinfo() { |
| u.PktinfoPresent = false |
| } |
| |
| func (u *Ipv6RecvControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *Ipv6RecvControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type Ipv6SendControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // The Hop Limit value to set in the IPv6 header of an outgoing |
| // packet. |
| Hoplimit uint8 `fidl_ordinal:"2"` |
| HoplimitPresent bool |
| // Information controlling the local interface and/or address used when |
| // sending an IPv6 packet. |
| Pktinfo Ipv6PktInfoSendControlData `fidl_ordinal:"3"` |
| PktinfoPresent bool |
| } |
| |
| var _mIpv6SendControlData = _bindings.CreateLazyMarshaler(Ipv6SendControlData{}) |
| |
| func (msg *Ipv6SendControlData) Marshaler() _bindings.Marshaler { |
| return _mIpv6SendControlData |
| } |
| |
| func (u *Ipv6SendControlData) SetHoplimit(hoplimit uint8) { |
| u.Hoplimit = hoplimit |
| u.HoplimitPresent = true |
| } |
| |
| func (u *Ipv6SendControlData) GetHoplimit() uint8 { |
| return u.Hoplimit |
| } |
| |
| func (u *Ipv6SendControlData) GetHoplimitWithDefault(_default uint8) uint8 { |
| if !u.HasHoplimit() { |
| return _default |
| } |
| return u.Hoplimit |
| } |
| |
| func (u *Ipv6SendControlData) HasHoplimit() bool { |
| return u.HoplimitPresent |
| } |
| |
| func (u *Ipv6SendControlData) ClearHoplimit() { |
| u.HoplimitPresent = false |
| } |
| |
| func (u *Ipv6SendControlData) SetPktinfo(pktinfo Ipv6PktInfoSendControlData) { |
| u.Pktinfo = pktinfo |
| u.PktinfoPresent = true |
| } |
| |
| func (u *Ipv6SendControlData) GetPktinfo() Ipv6PktInfoSendControlData { |
| return u.Pktinfo |
| } |
| |
| func (u *Ipv6SendControlData) GetPktinfoWithDefault(_default Ipv6PktInfoSendControlData) Ipv6PktInfoSendControlData { |
| if !u.HasPktinfo() { |
| return _default |
| } |
| return u.Pktinfo |
| } |
| |
| func (u *Ipv6SendControlData) HasPktinfo() bool { |
| return u.PktinfoPresent |
| } |
| |
| func (u *Ipv6SendControlData) ClearPktinfo() { |
| u.PktinfoPresent = false |
| } |
| |
| func (u *Ipv6SendControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *Ipv6SendControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| // Network socket (L3) ancillary data that can be received. |
| type NetworkSocketRecvControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // Socket level ancillary data. |
| Socket SocketRecvControlData `fidl_ordinal:"1"` |
| SocketPresent bool |
| // IPv4 level ancillary data. |
| // |
| // These match POSIX `SOL_IP` control messages. |
| Ip IpRecvControlData `fidl_ordinal:"2"` |
| IpPresent bool |
| // IPv6 level ancillary data. |
| // |
| // These match POSIX `SOL_IPV6` control messages. |
| Ipv6 Ipv6RecvControlData `fidl_ordinal:"3"` |
| Ipv6Present bool |
| } |
| |
| var _mNetworkSocketRecvControlData = _bindings.CreateLazyMarshaler(NetworkSocketRecvControlData{}) |
| |
| func (msg *NetworkSocketRecvControlData) Marshaler() _bindings.Marshaler { |
| return _mNetworkSocketRecvControlData |
| } |
| |
| func (u *NetworkSocketRecvControlData) SetSocket(socket SocketRecvControlData) { |
| u.Socket = socket |
| u.SocketPresent = true |
| } |
| |
| func (u *NetworkSocketRecvControlData) GetSocket() SocketRecvControlData { |
| return u.Socket |
| } |
| |
| func (u *NetworkSocketRecvControlData) GetSocketWithDefault(_default SocketRecvControlData) SocketRecvControlData { |
| if !u.HasSocket() { |
| return _default |
| } |
| return u.Socket |
| } |
| |
| func (u *NetworkSocketRecvControlData) HasSocket() bool { |
| return u.SocketPresent |
| } |
| |
| func (u *NetworkSocketRecvControlData) ClearSocket() { |
| u.SocketPresent = false |
| } |
| |
| func (u *NetworkSocketRecvControlData) SetIp(ip IpRecvControlData) { |
| u.Ip = ip |
| u.IpPresent = true |
| } |
| |
| func (u *NetworkSocketRecvControlData) GetIp() IpRecvControlData { |
| return u.Ip |
| } |
| |
| func (u *NetworkSocketRecvControlData) GetIpWithDefault(_default IpRecvControlData) IpRecvControlData { |
| if !u.HasIp() { |
| return _default |
| } |
| return u.Ip |
| } |
| |
| func (u *NetworkSocketRecvControlData) HasIp() bool { |
| return u.IpPresent |
| } |
| |
| func (u *NetworkSocketRecvControlData) ClearIp() { |
| u.IpPresent = false |
| } |
| |
| func (u *NetworkSocketRecvControlData) SetIpv6(ipv6 Ipv6RecvControlData) { |
| u.Ipv6 = ipv6 |
| u.Ipv6Present = true |
| } |
| |
| func (u *NetworkSocketRecvControlData) GetIpv6() Ipv6RecvControlData { |
| return u.Ipv6 |
| } |
| |
| func (u *NetworkSocketRecvControlData) GetIpv6WithDefault(_default Ipv6RecvControlData) Ipv6RecvControlData { |
| if !u.HasIpv6() { |
| return _default |
| } |
| return u.Ipv6 |
| } |
| |
| func (u *NetworkSocketRecvControlData) HasIpv6() bool { |
| return u.Ipv6Present |
| } |
| |
| func (u *NetworkSocketRecvControlData) ClearIpv6() { |
| u.Ipv6Present = false |
| } |
| |
| func (u *NetworkSocketRecvControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *NetworkSocketRecvControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| // Network socket (L3) ancillary data that can be sent. |
| type NetworkSocketSendControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // Socket level ancillary data. |
| Socket SocketSendControlData `fidl_ordinal:"1"` |
| SocketPresent bool |
| // IPv4 level ancillary data. |
| // |
| // These match POSIX `SOL_IP` control messages. |
| Ip IpSendControlData `fidl_ordinal:"2"` |
| IpPresent bool |
| // IPv6 level ancillary data. |
| // |
| // These match POSIX `SOL_IPV6` control messages. |
| Ipv6 Ipv6SendControlData `fidl_ordinal:"3"` |
| Ipv6Present bool |
| } |
| |
| var _mNetworkSocketSendControlData = _bindings.CreateLazyMarshaler(NetworkSocketSendControlData{}) |
| |
| func (msg *NetworkSocketSendControlData) Marshaler() _bindings.Marshaler { |
| return _mNetworkSocketSendControlData |
| } |
| |
| func (u *NetworkSocketSendControlData) SetSocket(socket SocketSendControlData) { |
| u.Socket = socket |
| u.SocketPresent = true |
| } |
| |
| func (u *NetworkSocketSendControlData) GetSocket() SocketSendControlData { |
| return u.Socket |
| } |
| |
| func (u *NetworkSocketSendControlData) GetSocketWithDefault(_default SocketSendControlData) SocketSendControlData { |
| if !u.HasSocket() { |
| return _default |
| } |
| return u.Socket |
| } |
| |
| func (u *NetworkSocketSendControlData) HasSocket() bool { |
| return u.SocketPresent |
| } |
| |
| func (u *NetworkSocketSendControlData) ClearSocket() { |
| u.SocketPresent = false |
| } |
| |
| func (u *NetworkSocketSendControlData) SetIp(ip IpSendControlData) { |
| u.Ip = ip |
| u.IpPresent = true |
| } |
| |
| func (u *NetworkSocketSendControlData) GetIp() IpSendControlData { |
| return u.Ip |
| } |
| |
| func (u *NetworkSocketSendControlData) GetIpWithDefault(_default IpSendControlData) IpSendControlData { |
| if !u.HasIp() { |
| return _default |
| } |
| return u.Ip |
| } |
| |
| func (u *NetworkSocketSendControlData) HasIp() bool { |
| return u.IpPresent |
| } |
| |
| func (u *NetworkSocketSendControlData) ClearIp() { |
| u.IpPresent = false |
| } |
| |
| func (u *NetworkSocketSendControlData) SetIpv6(ipv6 Ipv6SendControlData) { |
| u.Ipv6 = ipv6 |
| u.Ipv6Present = true |
| } |
| |
| func (u *NetworkSocketSendControlData) GetIpv6() Ipv6SendControlData { |
| return u.Ipv6 |
| } |
| |
| func (u *NetworkSocketSendControlData) GetIpv6WithDefault(_default Ipv6SendControlData) Ipv6SendControlData { |
| if !u.HasIpv6() { |
| return _default |
| } |
| return u.Ipv6 |
| } |
| |
| func (u *NetworkSocketSendControlData) HasIpv6() bool { |
| return u.Ipv6Present |
| } |
| |
| func (u *NetworkSocketSendControlData) ClearIpv6() { |
| u.Ipv6Present = false |
| } |
| |
| func (u *NetworkSocketSendControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *NetworkSocketSendControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| // Metadata of a received datagram. |
| type RecvMsgMeta struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // The from address of the datagram. |
| From fuchsianet.SocketAddress `fidl_ordinal:"1"` |
| FromPresent bool |
| // Ancillary control message data describing the datagram. |
| Control DatagramSocketRecvControlData `fidl_ordinal:"2"` |
| ControlPresent bool |
| // The length of the payload, in bytes. |
| PayloadLen uint16 `fidl_ordinal:"3"` |
| PayloadLenPresent bool |
| } |
| |
| var _mRecvMsgMeta = _bindings.CreateLazyMarshaler(RecvMsgMeta{}) |
| |
| func (msg *RecvMsgMeta) Marshaler() _bindings.Marshaler { |
| return _mRecvMsgMeta |
| } |
| |
| func (u *RecvMsgMeta) SetFrom(from fuchsianet.SocketAddress) { |
| u.From = from |
| u.FromPresent = true |
| } |
| |
| func (u *RecvMsgMeta) GetFrom() fuchsianet.SocketAddress { |
| return u.From |
| } |
| |
| func (u *RecvMsgMeta) GetFromWithDefault(_default fuchsianet.SocketAddress) fuchsianet.SocketAddress { |
| if !u.HasFrom() { |
| return _default |
| } |
| return u.From |
| } |
| |
| func (u *RecvMsgMeta) HasFrom() bool { |
| return u.FromPresent |
| } |
| |
| func (u *RecvMsgMeta) ClearFrom() { |
| u.FromPresent = false |
| } |
| |
| func (u *RecvMsgMeta) SetControl(control DatagramSocketRecvControlData) { |
| u.Control = control |
| u.ControlPresent = true |
| } |
| |
| func (u *RecvMsgMeta) GetControl() DatagramSocketRecvControlData { |
| return u.Control |
| } |
| |
| func (u *RecvMsgMeta) GetControlWithDefault(_default DatagramSocketRecvControlData) DatagramSocketRecvControlData { |
| if !u.HasControl() { |
| return _default |
| } |
| return u.Control |
| } |
| |
| func (u *RecvMsgMeta) HasControl() bool { |
| return u.ControlPresent |
| } |
| |
| func (u *RecvMsgMeta) ClearControl() { |
| u.ControlPresent = false |
| } |
| |
| func (u *RecvMsgMeta) SetPayloadLen(payloadLen uint16) { |
| u.PayloadLen = payloadLen |
| u.PayloadLenPresent = true |
| } |
| |
| func (u *RecvMsgMeta) GetPayloadLen() uint16 { |
| return u.PayloadLen |
| } |
| |
| func (u *RecvMsgMeta) GetPayloadLenWithDefault(_default uint16) uint16 { |
| if !u.HasPayloadLen() { |
| return _default |
| } |
| return u.PayloadLen |
| } |
| |
| func (u *RecvMsgMeta) HasPayloadLen() bool { |
| return u.PayloadLenPresent |
| } |
| |
| func (u *RecvMsgMeta) ClearPayloadLen() { |
| u.PayloadLenPresent = false |
| } |
| |
| func (u *RecvMsgMeta) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *RecvMsgMeta) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| // Metadata of a sent datagram. |
| type SendMsgMeta struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // The destination address, if specified. |
| To fuchsianet.SocketAddress `fidl_ordinal:"1"` |
| ToPresent bool |
| // Ancillary control message data used for sending the payload. |
| Control DatagramSocketSendControlData `fidl_ordinal:"2"` |
| ControlPresent bool |
| } |
| |
| var _mSendMsgMeta = _bindings.CreateLazyMarshaler(SendMsgMeta{}) |
| |
| func (msg *SendMsgMeta) Marshaler() _bindings.Marshaler { |
| return _mSendMsgMeta |
| } |
| |
| func (u *SendMsgMeta) SetTo(to fuchsianet.SocketAddress) { |
| u.To = to |
| u.ToPresent = true |
| } |
| |
| func (u *SendMsgMeta) GetTo() fuchsianet.SocketAddress { |
| return u.To |
| } |
| |
| func (u *SendMsgMeta) GetToWithDefault(_default fuchsianet.SocketAddress) fuchsianet.SocketAddress { |
| if !u.HasTo() { |
| return _default |
| } |
| return u.To |
| } |
| |
| func (u *SendMsgMeta) HasTo() bool { |
| return u.ToPresent |
| } |
| |
| func (u *SendMsgMeta) ClearTo() { |
| u.ToPresent = false |
| } |
| |
| func (u *SendMsgMeta) SetControl(control DatagramSocketSendControlData) { |
| u.Control = control |
| u.ControlPresent = true |
| } |
| |
| func (u *SendMsgMeta) GetControl() DatagramSocketSendControlData { |
| return u.Control |
| } |
| |
| func (u *SendMsgMeta) GetControlWithDefault(_default DatagramSocketSendControlData) DatagramSocketSendControlData { |
| if !u.HasControl() { |
| return _default |
| } |
| return u.Control |
| } |
| |
| func (u *SendMsgMeta) HasControl() bool { |
| return u.ControlPresent |
| } |
| |
| func (u *SendMsgMeta) ClearControl() { |
| u.ControlPresent = false |
| } |
| |
| func (u *SendMsgMeta) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *SendMsgMeta) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| // Socket level ancillary data that can be received. |
| // |
| // These match control messages with a `SOL_SOCKET` level. |
| type SocketRecvControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // Data about the time at which the packet was received. |
| Timestamp Timestamp `fidl_ordinal:"3"` |
| TimestampPresent bool |
| } |
| |
| var _mSocketRecvControlData = _bindings.CreateLazyMarshaler(SocketRecvControlData{}) |
| |
| func (msg *SocketRecvControlData) Marshaler() _bindings.Marshaler { |
| return _mSocketRecvControlData |
| } |
| |
| func (u *SocketRecvControlData) SetTimestamp(timestamp Timestamp) { |
| u.Timestamp = timestamp |
| u.TimestampPresent = true |
| } |
| |
| func (u *SocketRecvControlData) GetTimestamp() Timestamp { |
| return u.Timestamp |
| } |
| |
| func (u *SocketRecvControlData) GetTimestampWithDefault(_default Timestamp) Timestamp { |
| if !u.HasTimestamp() { |
| return _default |
| } |
| return u.Timestamp |
| } |
| |
| func (u *SocketRecvControlData) HasTimestamp() bool { |
| return u.TimestampPresent |
| } |
| |
| func (u *SocketRecvControlData) ClearTimestamp() { |
| u.TimestampPresent = false |
| } |
| |
| func (u *SocketRecvControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *SocketRecvControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| // Socket level ancillary data that can be sent. |
| // |
| // These match the POSIX `SOL_SOCKET` control messages. |
| type SocketSendControlData struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| } |
| |
| var _mSocketSendControlData = _bindings.CreateLazyMarshaler(SocketSendControlData{}) |
| |
| func (msg *SocketSendControlData) Marshaler() _bindings.Marshaler { |
| return _mSocketSendControlData |
| } |
| |
| func (u *SocketSendControlData) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *SocketSendControlData) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type StreamSocketDescribeResponse struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| I_unknownData interface{} |
| // `ZX_SOCKET_STREAM` on which data is sent and received. |
| Socket _zx.Socket `fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0" fidl_ordinal:"1"` |
| SocketPresent bool |
| } |
| |
| var _mStreamSocketDescribeResponse = _bindings.CreateLazyMarshaler(StreamSocketDescribeResponse{}) |
| |
| func (msg *StreamSocketDescribeResponse) Marshaler() _bindings.Marshaler { |
| return _mStreamSocketDescribeResponse |
| } |
| |
| func (u *StreamSocketDescribeResponse) SetSocket(socket _zx.Socket) { |
| u.Socket = socket |
| u.SocketPresent = true |
| } |
| |
| func (u *StreamSocketDescribeResponse) GetSocket() _zx.Socket { |
| return u.Socket |
| } |
| |
| func (u *StreamSocketDescribeResponse) GetSocketWithDefault(_default _zx.Socket) _zx.Socket { |
| if !u.HasSocket() { |
| return _default |
| } |
| return u.Socket |
| } |
| |
| func (u *StreamSocketDescribeResponse) HasSocket() bool { |
| return u.SocketPresent |
| } |
| |
| func (u *StreamSocketDescribeResponse) ClearSocket() { |
| u.SocketPresent = false |
| } |
| |
| func (u *StreamSocketDescribeResponse) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *StreamSocketDescribeResponse) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type SynchronousDatagramSocketDescribeResponse struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| I_unknownData interface{} |
| // Signals additional information about the state of the socket such as |
| // readiness or shutdown-ness. |
| Event _zx.Handle `fidl_handle_subtype:"16" fidl_handle_rights:"2147483648" fidl_bounds:"0" fidl_ordinal:"1"` |
| EventPresent bool |
| } |
| |
| var _mSynchronousDatagramSocketDescribeResponse = _bindings.CreateLazyMarshaler(SynchronousDatagramSocketDescribeResponse{}) |
| |
| func (msg *SynchronousDatagramSocketDescribeResponse) Marshaler() _bindings.Marshaler { |
| return _mSynchronousDatagramSocketDescribeResponse |
| } |
| |
| func (u *SynchronousDatagramSocketDescribeResponse) SetEvent(event _zx.Handle) { |
| u.Event = event |
| u.EventPresent = true |
| } |
| |
| func (u *SynchronousDatagramSocketDescribeResponse) GetEvent() _zx.Handle { |
| return u.Event |
| } |
| |
| func (u *SynchronousDatagramSocketDescribeResponse) GetEventWithDefault(_default _zx.Handle) _zx.Handle { |
| if !u.HasEvent() { |
| return _default |
| } |
| return u.Event |
| } |
| |
| func (u *SynchronousDatagramSocketDescribeResponse) HasEvent() bool { |
| return u.EventPresent |
| } |
| |
| func (u *SynchronousDatagramSocketDescribeResponse) ClearEvent() { |
| u.EventPresent = false |
| } |
| |
| func (u *SynchronousDatagramSocketDescribeResponse) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *SynchronousDatagramSocketDescribeResponse) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| // TCP protocol state. |
| type TcpInfo struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| State TcpState `fidl_ordinal:"1"` |
| StatePresent bool |
| CaState TcpCongestionControlState `fidl_ordinal:"2"` |
| CaStatePresent bool |
| RtoUsec uint32 `fidl_ordinal:"11"` |
| RtoUsecPresent bool |
| RttUsec uint32 `fidl_ordinal:"26"` |
| RttUsecPresent bool |
| RttVarUsec uint32 `fidl_ordinal:"27"` |
| RttVarUsecPresent bool |
| SndSsthresh uint32 `fidl_ordinal:"28"` |
| SndSsthreshPresent bool |
| SndCwnd uint32 `fidl_ordinal:"29"` |
| SndCwndPresent bool |
| ReorderSeen bool `fidl_ordinal:"54"` |
| ReorderSeenPresent bool |
| } |
| |
| var _mTcpInfo = _bindings.CreateLazyMarshaler(TcpInfo{}) |
| |
| func (msg *TcpInfo) Marshaler() _bindings.Marshaler { |
| return _mTcpInfo |
| } |
| |
| func (u *TcpInfo) SetState(state TcpState) { |
| u.State = state |
| u.StatePresent = true |
| } |
| |
| func (u *TcpInfo) GetState() TcpState { |
| return u.State |
| } |
| |
| func (u *TcpInfo) GetStateWithDefault(_default TcpState) TcpState { |
| if !u.HasState() { |
| return _default |
| } |
| return u.State |
| } |
| |
| func (u *TcpInfo) HasState() bool { |
| return u.StatePresent |
| } |
| |
| func (u *TcpInfo) ClearState() { |
| u.StatePresent = false |
| } |
| |
| func (u *TcpInfo) SetCaState(caState TcpCongestionControlState) { |
| u.CaState = caState |
| u.CaStatePresent = true |
| } |
| |
| func (u *TcpInfo) GetCaState() TcpCongestionControlState { |
| return u.CaState |
| } |
| |
| func (u *TcpInfo) GetCaStateWithDefault(_default TcpCongestionControlState) TcpCongestionControlState { |
| if !u.HasCaState() { |
| return _default |
| } |
| return u.CaState |
| } |
| |
| func (u *TcpInfo) HasCaState() bool { |
| return u.CaStatePresent |
| } |
| |
| func (u *TcpInfo) ClearCaState() { |
| u.CaStatePresent = false |
| } |
| |
| func (u *TcpInfo) SetRtoUsec(rtoUsec uint32) { |
| u.RtoUsec = rtoUsec |
| u.RtoUsecPresent = true |
| } |
| |
| func (u *TcpInfo) GetRtoUsec() uint32 { |
| return u.RtoUsec |
| } |
| |
| func (u *TcpInfo) GetRtoUsecWithDefault(_default uint32) uint32 { |
| if !u.HasRtoUsec() { |
| return _default |
| } |
| return u.RtoUsec |
| } |
| |
| func (u *TcpInfo) HasRtoUsec() bool { |
| return u.RtoUsecPresent |
| } |
| |
| func (u *TcpInfo) ClearRtoUsec() { |
| u.RtoUsecPresent = false |
| } |
| |
| func (u *TcpInfo) SetRttUsec(rttUsec uint32) { |
| u.RttUsec = rttUsec |
| u.RttUsecPresent = true |
| } |
| |
| func (u *TcpInfo) GetRttUsec() uint32 { |
| return u.RttUsec |
| } |
| |
| func (u *TcpInfo) GetRttUsecWithDefault(_default uint32) uint32 { |
| if !u.HasRttUsec() { |
| return _default |
| } |
| return u.RttUsec |
| } |
| |
| func (u *TcpInfo) HasRttUsec() bool { |
| return u.RttUsecPresent |
| } |
| |
| func (u *TcpInfo) ClearRttUsec() { |
| u.RttUsecPresent = false |
| } |
| |
| func (u *TcpInfo) SetRttVarUsec(rttVarUsec uint32) { |
| u.RttVarUsec = rttVarUsec |
| u.RttVarUsecPresent = true |
| } |
| |
| func (u *TcpInfo) GetRttVarUsec() uint32 { |
| return u.RttVarUsec |
| } |
| |
| func (u *TcpInfo) GetRttVarUsecWithDefault(_default uint32) uint32 { |
| if !u.HasRttVarUsec() { |
| return _default |
| } |
| return u.RttVarUsec |
| } |
| |
| func (u *TcpInfo) HasRttVarUsec() bool { |
| return u.RttVarUsecPresent |
| } |
| |
| func (u *TcpInfo) ClearRttVarUsec() { |
| u.RttVarUsecPresent = false |
| } |
| |
| func (u *TcpInfo) SetSndSsthresh(sndSsthresh uint32) { |
| u.SndSsthresh = sndSsthresh |
| u.SndSsthreshPresent = true |
| } |
| |
| func (u *TcpInfo) GetSndSsthresh() uint32 { |
| return u.SndSsthresh |
| } |
| |
| func (u *TcpInfo) GetSndSsthreshWithDefault(_default uint32) uint32 { |
| if !u.HasSndSsthresh() { |
| return _default |
| } |
| return u.SndSsthresh |
| } |
| |
| func (u *TcpInfo) HasSndSsthresh() bool { |
| return u.SndSsthreshPresent |
| } |
| |
| func (u *TcpInfo) ClearSndSsthresh() { |
| u.SndSsthreshPresent = false |
| } |
| |
| func (u *TcpInfo) SetSndCwnd(sndCwnd uint32) { |
| u.SndCwnd = sndCwnd |
| u.SndCwndPresent = true |
| } |
| |
| func (u *TcpInfo) GetSndCwnd() uint32 { |
| return u.SndCwnd |
| } |
| |
| func (u *TcpInfo) GetSndCwndWithDefault(_default uint32) uint32 { |
| if !u.HasSndCwnd() { |
| return _default |
| } |
| return u.SndCwnd |
| } |
| |
| func (u *TcpInfo) HasSndCwnd() bool { |
| return u.SndCwndPresent |
| } |
| |
| func (u *TcpInfo) ClearSndCwnd() { |
| u.SndCwndPresent = false |
| } |
| |
| func (u *TcpInfo) SetReorderSeen(reorderSeen bool) { |
| u.ReorderSeen = reorderSeen |
| u.ReorderSeenPresent = true |
| } |
| |
| func (u *TcpInfo) GetReorderSeen() bool { |
| return u.ReorderSeen |
| } |
| |
| func (u *TcpInfo) GetReorderSeenWithDefault(_default bool) bool { |
| if !u.HasReorderSeen() { |
| return _default |
| } |
| return u.ReorderSeen |
| } |
| |
| func (u *TcpInfo) HasReorderSeen() bool { |
| return u.ReorderSeenPresent |
| } |
| |
| func (u *TcpInfo) ClearReorderSeen() { |
| u.ReorderSeenPresent = false |
| } |
| |
| func (u *TcpInfo) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *TcpInfo) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| const ( |
| BaseDatagramSocketClone2Ordinal uint64 = 0x20d8a7aba2168a79 |
| BaseDatagramSocketCloseOrdinal uint64 = 0x5ac5d459ad7f657e |
| BaseDatagramSocketQueryOrdinal uint64 = 0x2658edee9decfc06 |
| BaseDatagramSocketSetReuseAddressOrdinal uint64 = 0x1fd74ee8b9a4a876 |
| BaseDatagramSocketGetReuseAddressOrdinal uint64 = 0x67b7206b8d1bc0a5 |
| BaseDatagramSocketGetErrorOrdinal uint64 = 0x5aad39b33e5f6ebb |
| BaseDatagramSocketSetBroadcastOrdinal uint64 = 0x6023e081ce3cd947 |
| BaseDatagramSocketGetBroadcastOrdinal uint64 = 0x68796fc556f9780d |
| BaseDatagramSocketSetSendBufferOrdinal uint64 = 0x756eac32d73a7a70 |
| BaseDatagramSocketGetSendBufferOrdinal uint64 = 0x78a52fd9c7b2410b |
| BaseDatagramSocketSetReceiveBufferOrdinal uint64 = 0x6b0cf2f1919c7001 |
| BaseDatagramSocketGetReceiveBufferOrdinal uint64 = 0x14c1a4b64f709e5c |
| BaseDatagramSocketSetKeepAliveOrdinal uint64 = 0x572df8f0b920d2c7 |
| BaseDatagramSocketGetKeepAliveOrdinal uint64 = 0x2dd29d3215f2c9d2 |
| BaseDatagramSocketSetOutOfBandInlineOrdinal uint64 = 0x3ecb49968bee439 |
| BaseDatagramSocketGetOutOfBandInlineOrdinal uint64 = 0x348c1ab3aeca1745 |
| BaseDatagramSocketSetNoCheckOrdinal uint64 = 0x6bbf00c53a4c78c2 |
| BaseDatagramSocketGetNoCheckOrdinal uint64 = 0x2cd4249286417694 |
| BaseDatagramSocketSetLingerOrdinal uint64 = 0x45386351246e998e |
| BaseDatagramSocketGetLingerOrdinal uint64 = 0x48eb20fc5ccb0e45 |
| BaseDatagramSocketSetReusePortOrdinal uint64 = 0x24dd3e5cb36d9ccb |
| BaseDatagramSocketGetReusePortOrdinal uint64 = 0x7a112c1ab54ff828 |
| BaseDatagramSocketGetAcceptConnOrdinal uint64 = 0x67ce6db6c2ec8966 |
| BaseDatagramSocketSetBindToDeviceOrdinal uint64 = 0x2118b483f28aafc4 |
| BaseDatagramSocketGetBindToDeviceOrdinal uint64 = 0x1ab1fbf0ef7906c8 |
| BaseDatagramSocketSetTimestampOrdinal uint64 = 0x285d6516c263d839 |
| BaseDatagramSocketGetTimestampOrdinal uint64 = 0x49f2fffbbcc2bd27 |
| BaseDatagramSocketBindOrdinal uint64 = 0x4bc6400ae92125d |
| BaseDatagramSocketConnectOrdinal uint64 = 0x5f05f19bfdd38871 |
| BaseDatagramSocketDisconnectOrdinal uint64 = 0x74e63b91f7b29b2 |
| BaseDatagramSocketGetSockNameOrdinal uint64 = 0x475f23f84a1a4f85 |
| BaseDatagramSocketGetPeerNameOrdinal uint64 = 0x1ffecf4bd5b6432e |
| BaseDatagramSocketShutdownOrdinal uint64 = 0x247f38b6db68c336 |
| BaseDatagramSocketSetIpTypeOfServiceOrdinal uint64 = 0x995c600475b6d46 |
| BaseDatagramSocketGetIpTypeOfServiceOrdinal uint64 = 0x3814a04259f75fcb |
| BaseDatagramSocketSetIpTtlOrdinal uint64 = 0x29e2424b433ae1ef |
| BaseDatagramSocketGetIpTtlOrdinal uint64 = 0x47e47fa1f24da471 |
| BaseDatagramSocketSetIpPacketInfoOrdinal uint64 = 0x392d16bee20c0e16 |
| BaseDatagramSocketGetIpPacketInfoOrdinal uint64 = 0x54b505f242280740 |
| BaseDatagramSocketSetIpReceiveTypeOfServiceOrdinal uint64 = 0x6c4f6714995f84ef |
| BaseDatagramSocketGetIpReceiveTypeOfServiceOrdinal uint64 = 0x4158ba7dc2795960 |
| BaseDatagramSocketSetIpReceiveTtlOrdinal uint64 = 0x46f15be0ce0ab82b |
| BaseDatagramSocketGetIpReceiveTtlOrdinal uint64 = 0x678ddd5a5dfa2eb5 |
| BaseDatagramSocketSetIpMulticastInterfaceOrdinal uint64 = 0x752fbfa9b12befe |
| BaseDatagramSocketGetIpMulticastInterfaceOrdinal uint64 = 0x320bd14c4df046c4 |
| BaseDatagramSocketSetIpMulticastTtlOrdinal uint64 = 0x63134d53772916a1 |
| BaseDatagramSocketGetIpMulticastTtlOrdinal uint64 = 0x4665cd378f39e1a |
| BaseDatagramSocketSetIpMulticastLoopbackOrdinal uint64 = 0x20c55c11f00943ea |
| BaseDatagramSocketGetIpMulticastLoopbackOrdinal uint64 = 0x3b6b26ff558298f2 |
| BaseDatagramSocketAddIpMembershipOrdinal uint64 = 0x76bc7df115a3b4d0 |
| BaseDatagramSocketDropIpMembershipOrdinal uint64 = 0x2888f3099188d03 |
| BaseDatagramSocketSetIpTransparentOrdinal uint64 = 0x1ae532b0c066e3a0 |
| BaseDatagramSocketGetIpTransparentOrdinal uint64 = 0x51d43695962ebfb5 |
| BaseDatagramSocketSetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x4722b4ce52f7840 |
| BaseDatagramSocketGetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x2a0e7dc5d6bfdfe9 |
| BaseDatagramSocketAddIpv6MembershipOrdinal uint64 = 0x7c94727acb4ea4b3 |
| BaseDatagramSocketDropIpv6MembershipOrdinal uint64 = 0x42104c70ccaba304 |
| BaseDatagramSocketSetIpv6MulticastInterfaceOrdinal uint64 = 0x135f76db3774ab3b |
| BaseDatagramSocketGetIpv6MulticastInterfaceOrdinal uint64 = 0x1f26fcdd348f1882 |
| BaseDatagramSocketSetIpv6UnicastHopsOrdinal uint64 = 0x157d51e98f462859 |
| BaseDatagramSocketGetIpv6UnicastHopsOrdinal uint64 = 0x21f4641cad8bd8d2 |
| BaseDatagramSocketSetIpv6ReceiveHopLimitOrdinal uint64 = 0x5c24808ed2e84a1e |
| BaseDatagramSocketGetIpv6ReceiveHopLimitOrdinal uint64 = 0x341e06689885b4c0 |
| BaseDatagramSocketSetIpv6MulticastHopsOrdinal uint64 = 0x25b9cd4d181f82c1 |
| BaseDatagramSocketGetIpv6MulticastHopsOrdinal uint64 = 0x52916948a365012a |
| BaseDatagramSocketSetIpv6MulticastLoopbackOrdinal uint64 = 0x55701c409ff41b40 |
| BaseDatagramSocketGetIpv6MulticastLoopbackOrdinal uint64 = 0x4415b701fde319c3 |
| BaseDatagramSocketSetIpv6OnlyOrdinal uint64 = 0x4873f1364758cbba |
| BaseDatagramSocketGetIpv6OnlyOrdinal uint64 = 0x4aa3340a1a26b89c |
| BaseDatagramSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x58f07c8788d099a0 |
| BaseDatagramSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x2e334df1da553ffa |
| BaseDatagramSocketSetIpv6TrafficClassOrdinal uint64 = 0x6af077800c5a0b4f |
| BaseDatagramSocketGetIpv6TrafficClassOrdinal uint64 = 0x6baf6eed8fc2f04 |
| BaseDatagramSocketSetIpv6ReceivePacketInfoOrdinal uint64 = 0x19259775b1a92768 |
| BaseDatagramSocketGetIpv6ReceivePacketInfoOrdinal uint64 = 0x7acd4a2775baec75 |
| BaseDatagramSocketGetOriginalDestinationOrdinal uint64 = 0x38bf28f0dafdbac0 |
| BaseDatagramSocketGetInfoOrdinal uint64 = 0x48aa0a1f6a32d2ed |
| ) |
| |
| type BaseDatagramSocketWithCtxInterface _bindings.ChannelProxy |
| |
| func (p *BaseDatagramSocketWithCtxInterface) Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error { |
| req_ := &fuchsiaunknown.CloneableClone2Request{Request: request} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(BaseDatagramSocketClone2Ordinal, req_) |
| return err_ |
| } |
| |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| func (p *BaseDatagramSocketWithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.CloseableCloseResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketCloseOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *BaseDatagramSocketWithCtxInterface) Query(ctx_ _bindings.Context) ([]uint8, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.QueryableQueryResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketQueryOrdinal, req_, resp_) |
| return (*resp_).Protocol, err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) { |
| req_ := &BaseSocketSetReuseAddressRequest{Value: value} |
| resp_ := &BaseSocketSetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| func (p *BaseDatagramSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetErrorResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetErrorOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) { |
| req_ := &BaseSocketSetBroadcastRequest{Value: value} |
| resp_ := &BaseSocketSetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) { |
| req_ := &BaseSocketSetSendBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) { |
| req_ := &BaseSocketSetReceiveBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) { |
| req_ := &BaseSocketSetKeepAliveRequest{Value: value} |
| resp_ := &BaseSocketSetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) { |
| req_ := &BaseSocketSetOutOfBandInlineRequest{Value: value} |
| resp_ := &BaseSocketSetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) { |
| req_ := &BaseSocketSetNoCheckRequest{Value: value} |
| resp_ := &BaseSocketSetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) { |
| req_ := &BaseSocketSetLingerRequest{Linger: linger, LengthSecs: lengthSecs} |
| resp_ := &BaseSocketSetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) { |
| req_ := &BaseSocketSetReusePortRequest{Value: value} |
| resp_ := &BaseSocketSetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetAcceptConnResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetAcceptConnOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) { |
| req_ := &BaseSocketSetBindToDeviceRequest{Value: value} |
| resp_ := &BaseSocketSetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) { |
| req_ := &BaseSocketSetTimestampRequest{Value: value} |
| resp_ := &BaseSocketSetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Sets the local address used for the socket. |
| func (p *BaseDatagramSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) { |
| req_ := &BaseNetworkSocketBindRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketBindResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketBindOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Initiates a connection to a remote address. |
| func (p *BaseDatagramSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) { |
| req_ := &BaseNetworkSocketConnectRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketConnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketConnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Clears connection information from this socket. |
| func (p *BaseDatagramSocketWithCtxInterface) Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketDisconnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketDisconnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the local socket address. |
| func (p *BaseDatagramSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetSockNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetSockNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the remote socket address. |
| func (p *BaseDatagramSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetPeerNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetPeerNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Shuts down part of the socket. |
| func (p *BaseDatagramSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) { |
| req_ := &BaseNetworkSocketShutdownRequest{Mode: mode} |
| resp_ := &BaseNetworkSocketShutdownResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketShutdownOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TOS`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TOS`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TTL`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TTL`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpPacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{Iface: iface, Address: address} |
| resp_ := &BaseNetworkSocketSetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| func (p *BaseDatagramSocketWithCtxInterface) AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketAddIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| func (p *BaseDatagramSocketWithCtxInterface) DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketDropIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) { |
| req_ := &BaseNetworkSocketSetIpTransparentRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| func (p *BaseDatagramSocketWithCtxInterface) AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketAddIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| func (p *BaseDatagramSocketWithCtxInterface) DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketDropIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6OnlyRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6TrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *BaseDatagramSocketWithCtxInterface) SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketSetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| func (p *BaseDatagramSocketWithCtxInterface) GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetOriginalDestinationResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetOriginalDestinationOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves creation information from the socket. |
| // |
| // - response `domain` the socket's associated domain. |
| // - response `proto` the socket's associated protocol. |
| func (p *BaseDatagramSocketWithCtxInterface) GetInfo(ctx_ _bindings.Context) (BaseDatagramSocketGetInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseDatagramSocketGetInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseDatagramSocketGetInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Base protocol shared by all datagram sockets. |
| // |
| // Complete implementations of a datagram socket should compose this protocol. |
| type BaseDatagramSocketWithCtx interface { |
| Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) |
| Query(ctx_ _bindings.Context) ([]uint8, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) |
| // Sets the local address used for the socket. |
| Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) |
| // Initiates a connection to a remote address. |
| Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) |
| // Clears connection information from this socket. |
| Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) |
| // Retrieves the local socket address. |
| GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) |
| // Retrieves the remote socket address. |
| GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) |
| // Shuts down part of the socket. |
| Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) |
| // Set `SOL_IP` -> `IP_TOS`. |
| SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_TOS`. |
| GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_TTL`. |
| SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) |
| // Get `SOL_IP` -> `IP_TTL`. |
| GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) |
| // Retrieves creation information from the socket. |
| // |
| // - response `domain` the socket's associated domain. |
| // - response `proto` the socket's associated protocol. |
| GetInfo(ctx_ _bindings.Context) (BaseDatagramSocketGetInfoResult, error) |
| } |
| |
| type BaseDatagramSocketWithCtxTransitionalBase struct{} |
| |
| type BaseDatagramSocketWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewBaseDatagramSocketWithCtxInterfaceRequest() (BaseDatagramSocketWithCtxInterfaceRequest, *BaseDatagramSocketWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return BaseDatagramSocketWithCtxInterfaceRequest(req), (*BaseDatagramSocketWithCtxInterface)(cli), err |
| } |
| |
| type BaseDatagramSocketWithCtxStub struct { |
| Impl BaseDatagramSocketWithCtx |
| } |
| |
| func (s_ *BaseDatagramSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case BaseDatagramSocketClone2Ordinal: |
| in_ := &fuchsiaunknown.CloneableClone2Request{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.Clone2(args_.Ctx, (*in_).Request) |
| return nil, false, err_ |
| case BaseDatagramSocketCloseOrdinal: |
| payload, err_ := s_.Impl.Close(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketQueryOrdinal: |
| protocol, err_ := s_.Impl.Query(args_.Ctx) |
| out_ := &fuchsiaunknown.QueryableQueryResponse{Protocol: protocol} |
| return out_, true, err_ |
| case BaseDatagramSocketSetReuseAddressOrdinal: |
| in_ := &BaseSocketSetReuseAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReuseAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetReuseAddressOrdinal: |
| payload, err_ := s_.Impl.GetReuseAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetErrorOrdinal: |
| payload, err_ := s_.Impl.GetError(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetBroadcastOrdinal: |
| in_ := &BaseSocketSetBroadcastRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBroadcast(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetBroadcastOrdinal: |
| payload, err_ := s_.Impl.GetBroadcast(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetSendBufferOrdinal: |
| in_ := &BaseSocketSetSendBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetSendBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetSendBufferOrdinal: |
| payload, err_ := s_.Impl.GetSendBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetReceiveBufferOrdinal: |
| in_ := &BaseSocketSetReceiveBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReceiveBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetReceiveBufferOrdinal: |
| payload, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetKeepAliveOrdinal: |
| in_ := &BaseSocketSetKeepAliveRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetKeepAlive(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetKeepAliveOrdinal: |
| payload, err_ := s_.Impl.GetKeepAlive(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetOutOfBandInlineOrdinal: |
| in_ := &BaseSocketSetOutOfBandInlineRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetOutOfBandInline(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetOutOfBandInlineOrdinal: |
| payload, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetNoCheckOrdinal: |
| in_ := &BaseSocketSetNoCheckRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetNoCheck(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetNoCheckOrdinal: |
| payload, err_ := s_.Impl.GetNoCheck(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetLingerOrdinal: |
| in_ := &BaseSocketSetLingerRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetLinger(args_.Ctx, (*in_).Linger, (*in_).LengthSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetLingerOrdinal: |
| payload, err_ := s_.Impl.GetLinger(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetReusePortOrdinal: |
| in_ := &BaseSocketSetReusePortRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReusePort(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetReusePortOrdinal: |
| payload, err_ := s_.Impl.GetReusePort(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetAcceptConnOrdinal: |
| payload, err_ := s_.Impl.GetAcceptConn(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetBindToDeviceOrdinal: |
| in_ := &BaseSocketSetBindToDeviceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBindToDevice(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetBindToDeviceOrdinal: |
| payload, err_ := s_.Impl.GetBindToDevice(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetTimestampOrdinal: |
| in_ := &BaseSocketSetTimestampRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTimestamp(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetTimestampOrdinal: |
| payload, err_ := s_.Impl.GetTimestamp(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketBindOrdinal: |
| in_ := &BaseNetworkSocketBindRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Bind(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketConnectOrdinal: |
| in_ := &BaseNetworkSocketConnectRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Connect(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketDisconnectOrdinal: |
| payload, err_ := s_.Impl.Disconnect(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetSockNameOrdinal: |
| payload, err_ := s_.Impl.GetSockName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetPeerNameOrdinal: |
| payload, err_ := s_.Impl.GetPeerName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketShutdownOrdinal: |
| in_ := &BaseNetworkSocketShutdownRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Shutdown(args_.Ctx, (*in_).Mode) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpPacketInfoOrdinal: |
| in_ := &BaseNetworkSocketSetIpPacketInfoRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpPacketInfo(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpPacketInfoOrdinal: |
| payload, err_ := s_.Impl.GetIpPacketInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpReceiveTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpReceiveTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpReceiveTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpReceiveTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpMulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastInterface(args_.Ctx, (*in_).Iface, (*in_).Address) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpMulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpMulticastTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpMulticastTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpMulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpMulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketAddIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketDropIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpTransparentOrdinal: |
| in_ := &BaseNetworkSocketSetIpTransparentRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTransparent(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpTransparentOrdinal: |
| payload, err_ := s_.Impl.GetIpTransparent(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpReceiveOriginalDestinationAddressOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveOriginalDestinationAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpReceiveOriginalDestinationAddressOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveOriginalDestinationAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketAddIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketDropIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpv6MulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastInterface(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpv6MulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpv6UnicastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6UnicastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpv6UnicastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6UnicastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpv6ReceiveHopLimitOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceiveHopLimit(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpv6ReceiveHopLimitOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceiveHopLimit(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpv6MulticastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpv6MulticastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpv6MulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpv6MulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpv6OnlyOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6OnlyRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6Only(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpv6OnlyOrdinal: |
| payload, err_ := s_.Impl.GetIpv6Only(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpv6ReceiveTrafficClassOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceiveTrafficClass(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpv6ReceiveTrafficClassOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceiveTrafficClass(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpv6TrafficClassOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6TrafficClassRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6TrafficClass(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpv6TrafficClassOrdinal: |
| payload, err_ := s_.Impl.GetIpv6TrafficClass(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketSetIpv6ReceivePacketInfoOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceivePacketInfo(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetIpv6ReceivePacketInfoOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceivePacketInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetOriginalDestinationOrdinal: |
| payload, err_ := s_.Impl.GetOriginalDestination(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseDatagramSocketGetInfoOrdinal: |
| payload, err_ := s_.Impl.GetInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| } |
| return nil, false, _bindings.ErrUnknownOrdinal |
| } |
| |
| type BaseDatagramSocketEventProxy _bindings.ChannelProxy |
| |
| const ( |
| BaseNetworkSocketClone2Ordinal uint64 = 0x20d8a7aba2168a79 |
| BaseNetworkSocketCloseOrdinal uint64 = 0x5ac5d459ad7f657e |
| BaseNetworkSocketQueryOrdinal uint64 = 0x2658edee9decfc06 |
| BaseNetworkSocketSetReuseAddressOrdinal uint64 = 0x1fd74ee8b9a4a876 |
| BaseNetworkSocketGetReuseAddressOrdinal uint64 = 0x67b7206b8d1bc0a5 |
| BaseNetworkSocketGetErrorOrdinal uint64 = 0x5aad39b33e5f6ebb |
| BaseNetworkSocketSetBroadcastOrdinal uint64 = 0x6023e081ce3cd947 |
| BaseNetworkSocketGetBroadcastOrdinal uint64 = 0x68796fc556f9780d |
| BaseNetworkSocketSetSendBufferOrdinal uint64 = 0x756eac32d73a7a70 |
| BaseNetworkSocketGetSendBufferOrdinal uint64 = 0x78a52fd9c7b2410b |
| BaseNetworkSocketSetReceiveBufferOrdinal uint64 = 0x6b0cf2f1919c7001 |
| BaseNetworkSocketGetReceiveBufferOrdinal uint64 = 0x14c1a4b64f709e5c |
| BaseNetworkSocketSetKeepAliveOrdinal uint64 = 0x572df8f0b920d2c7 |
| BaseNetworkSocketGetKeepAliveOrdinal uint64 = 0x2dd29d3215f2c9d2 |
| BaseNetworkSocketSetOutOfBandInlineOrdinal uint64 = 0x3ecb49968bee439 |
| BaseNetworkSocketGetOutOfBandInlineOrdinal uint64 = 0x348c1ab3aeca1745 |
| BaseNetworkSocketSetNoCheckOrdinal uint64 = 0x6bbf00c53a4c78c2 |
| BaseNetworkSocketGetNoCheckOrdinal uint64 = 0x2cd4249286417694 |
| BaseNetworkSocketSetLingerOrdinal uint64 = 0x45386351246e998e |
| BaseNetworkSocketGetLingerOrdinal uint64 = 0x48eb20fc5ccb0e45 |
| BaseNetworkSocketSetReusePortOrdinal uint64 = 0x24dd3e5cb36d9ccb |
| BaseNetworkSocketGetReusePortOrdinal uint64 = 0x7a112c1ab54ff828 |
| BaseNetworkSocketGetAcceptConnOrdinal uint64 = 0x67ce6db6c2ec8966 |
| BaseNetworkSocketSetBindToDeviceOrdinal uint64 = 0x2118b483f28aafc4 |
| BaseNetworkSocketGetBindToDeviceOrdinal uint64 = 0x1ab1fbf0ef7906c8 |
| BaseNetworkSocketSetTimestampOrdinal uint64 = 0x285d6516c263d839 |
| BaseNetworkSocketGetTimestampOrdinal uint64 = 0x49f2fffbbcc2bd27 |
| BaseNetworkSocketBindOrdinal uint64 = 0x4bc6400ae92125d |
| BaseNetworkSocketConnectOrdinal uint64 = 0x5f05f19bfdd38871 |
| BaseNetworkSocketDisconnectOrdinal uint64 = 0x74e63b91f7b29b2 |
| BaseNetworkSocketGetSockNameOrdinal uint64 = 0x475f23f84a1a4f85 |
| BaseNetworkSocketGetPeerNameOrdinal uint64 = 0x1ffecf4bd5b6432e |
| BaseNetworkSocketShutdownOrdinal uint64 = 0x247f38b6db68c336 |
| BaseNetworkSocketSetIpTypeOfServiceOrdinal uint64 = 0x995c600475b6d46 |
| BaseNetworkSocketGetIpTypeOfServiceOrdinal uint64 = 0x3814a04259f75fcb |
| BaseNetworkSocketSetIpTtlOrdinal uint64 = 0x29e2424b433ae1ef |
| BaseNetworkSocketGetIpTtlOrdinal uint64 = 0x47e47fa1f24da471 |
| BaseNetworkSocketSetIpPacketInfoOrdinal uint64 = 0x392d16bee20c0e16 |
| BaseNetworkSocketGetIpPacketInfoOrdinal uint64 = 0x54b505f242280740 |
| BaseNetworkSocketSetIpReceiveTypeOfServiceOrdinal uint64 = 0x6c4f6714995f84ef |
| BaseNetworkSocketGetIpReceiveTypeOfServiceOrdinal uint64 = 0x4158ba7dc2795960 |
| BaseNetworkSocketSetIpReceiveTtlOrdinal uint64 = 0x46f15be0ce0ab82b |
| BaseNetworkSocketGetIpReceiveTtlOrdinal uint64 = 0x678ddd5a5dfa2eb5 |
| BaseNetworkSocketSetIpMulticastInterfaceOrdinal uint64 = 0x752fbfa9b12befe |
| BaseNetworkSocketGetIpMulticastInterfaceOrdinal uint64 = 0x320bd14c4df046c4 |
| BaseNetworkSocketSetIpMulticastTtlOrdinal uint64 = 0x63134d53772916a1 |
| BaseNetworkSocketGetIpMulticastTtlOrdinal uint64 = 0x4665cd378f39e1a |
| BaseNetworkSocketSetIpMulticastLoopbackOrdinal uint64 = 0x20c55c11f00943ea |
| BaseNetworkSocketGetIpMulticastLoopbackOrdinal uint64 = 0x3b6b26ff558298f2 |
| BaseNetworkSocketAddIpMembershipOrdinal uint64 = 0x76bc7df115a3b4d0 |
| BaseNetworkSocketDropIpMembershipOrdinal uint64 = 0x2888f3099188d03 |
| BaseNetworkSocketSetIpTransparentOrdinal uint64 = 0x1ae532b0c066e3a0 |
| BaseNetworkSocketGetIpTransparentOrdinal uint64 = 0x51d43695962ebfb5 |
| BaseNetworkSocketSetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x4722b4ce52f7840 |
| BaseNetworkSocketGetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x2a0e7dc5d6bfdfe9 |
| BaseNetworkSocketAddIpv6MembershipOrdinal uint64 = 0x7c94727acb4ea4b3 |
| BaseNetworkSocketDropIpv6MembershipOrdinal uint64 = 0x42104c70ccaba304 |
| BaseNetworkSocketSetIpv6MulticastInterfaceOrdinal uint64 = 0x135f76db3774ab3b |
| BaseNetworkSocketGetIpv6MulticastInterfaceOrdinal uint64 = 0x1f26fcdd348f1882 |
| BaseNetworkSocketSetIpv6UnicastHopsOrdinal uint64 = 0x157d51e98f462859 |
| BaseNetworkSocketGetIpv6UnicastHopsOrdinal uint64 = 0x21f4641cad8bd8d2 |
| BaseNetworkSocketSetIpv6ReceiveHopLimitOrdinal uint64 = 0x5c24808ed2e84a1e |
| BaseNetworkSocketGetIpv6ReceiveHopLimitOrdinal uint64 = 0x341e06689885b4c0 |
| BaseNetworkSocketSetIpv6MulticastHopsOrdinal uint64 = 0x25b9cd4d181f82c1 |
| BaseNetworkSocketGetIpv6MulticastHopsOrdinal uint64 = 0x52916948a365012a |
| BaseNetworkSocketSetIpv6MulticastLoopbackOrdinal uint64 = 0x55701c409ff41b40 |
| BaseNetworkSocketGetIpv6MulticastLoopbackOrdinal uint64 = 0x4415b701fde319c3 |
| BaseNetworkSocketSetIpv6OnlyOrdinal uint64 = 0x4873f1364758cbba |
| BaseNetworkSocketGetIpv6OnlyOrdinal uint64 = 0x4aa3340a1a26b89c |
| BaseNetworkSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x58f07c8788d099a0 |
| BaseNetworkSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x2e334df1da553ffa |
| BaseNetworkSocketSetIpv6TrafficClassOrdinal uint64 = 0x6af077800c5a0b4f |
| BaseNetworkSocketGetIpv6TrafficClassOrdinal uint64 = 0x6baf6eed8fc2f04 |
| BaseNetworkSocketSetIpv6ReceivePacketInfoOrdinal uint64 = 0x19259775b1a92768 |
| BaseNetworkSocketGetIpv6ReceivePacketInfoOrdinal uint64 = 0x7acd4a2775baec75 |
| BaseNetworkSocketGetOriginalDestinationOrdinal uint64 = 0x38bf28f0dafdbac0 |
| ) |
| |
| type BaseNetworkSocketWithCtxInterface _bindings.ChannelProxy |
| |
| func (p *BaseNetworkSocketWithCtxInterface) Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error { |
| req_ := &fuchsiaunknown.CloneableClone2Request{Request: request} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(BaseNetworkSocketClone2Ordinal, req_) |
| return err_ |
| } |
| |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| func (p *BaseNetworkSocketWithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.CloseableCloseResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketCloseOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *BaseNetworkSocketWithCtxInterface) Query(ctx_ _bindings.Context) ([]uint8, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.QueryableQueryResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketQueryOrdinal, req_, resp_) |
| return (*resp_).Protocol, err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) { |
| req_ := &BaseSocketSetReuseAddressRequest{Value: value} |
| resp_ := &BaseSocketSetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| func (p *BaseNetworkSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetErrorResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetErrorOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) { |
| req_ := &BaseSocketSetBroadcastRequest{Value: value} |
| resp_ := &BaseSocketSetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) { |
| req_ := &BaseSocketSetSendBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) { |
| req_ := &BaseSocketSetReceiveBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) { |
| req_ := &BaseSocketSetKeepAliveRequest{Value: value} |
| resp_ := &BaseSocketSetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) { |
| req_ := &BaseSocketSetOutOfBandInlineRequest{Value: value} |
| resp_ := &BaseSocketSetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) { |
| req_ := &BaseSocketSetNoCheckRequest{Value: value} |
| resp_ := &BaseSocketSetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) { |
| req_ := &BaseSocketSetLingerRequest{Linger: linger, LengthSecs: lengthSecs} |
| resp_ := &BaseSocketSetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) { |
| req_ := &BaseSocketSetReusePortRequest{Value: value} |
| resp_ := &BaseSocketSetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetAcceptConnResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetAcceptConnOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) { |
| req_ := &BaseSocketSetBindToDeviceRequest{Value: value} |
| resp_ := &BaseSocketSetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) { |
| req_ := &BaseSocketSetTimestampRequest{Value: value} |
| resp_ := &BaseSocketSetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Sets the local address used for the socket. |
| func (p *BaseNetworkSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) { |
| req_ := &BaseNetworkSocketBindRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketBindResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketBindOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Initiates a connection to a remote address. |
| func (p *BaseNetworkSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) { |
| req_ := &BaseNetworkSocketConnectRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketConnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketConnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Clears connection information from this socket. |
| func (p *BaseNetworkSocketWithCtxInterface) Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketDisconnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketDisconnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the local socket address. |
| func (p *BaseNetworkSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetSockNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetSockNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the remote socket address. |
| func (p *BaseNetworkSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetPeerNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetPeerNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Shuts down part of the socket. |
| func (p *BaseNetworkSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) { |
| req_ := &BaseNetworkSocketShutdownRequest{Mode: mode} |
| resp_ := &BaseNetworkSocketShutdownResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketShutdownOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TOS`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TOS`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TTL`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TTL`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpPacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{Iface: iface, Address: address} |
| resp_ := &BaseNetworkSocketSetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| func (p *BaseNetworkSocketWithCtxInterface) AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketAddIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| func (p *BaseNetworkSocketWithCtxInterface) DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketDropIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) { |
| req_ := &BaseNetworkSocketSetIpTransparentRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| func (p *BaseNetworkSocketWithCtxInterface) AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketAddIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| func (p *BaseNetworkSocketWithCtxInterface) DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketDropIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6OnlyRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6TrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *BaseNetworkSocketWithCtxInterface) SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketSetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| func (p *BaseNetworkSocketWithCtxInterface) GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetOriginalDestinationResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseNetworkSocketGetOriginalDestinationOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // A network socket. |
| type BaseNetworkSocketWithCtx interface { |
| Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) |
| Query(ctx_ _bindings.Context) ([]uint8, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) |
| // Sets the local address used for the socket. |
| Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) |
| // Initiates a connection to a remote address. |
| Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) |
| // Clears connection information from this socket. |
| Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) |
| // Retrieves the local socket address. |
| GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) |
| // Retrieves the remote socket address. |
| GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) |
| // Shuts down part of the socket. |
| Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) |
| // Set `SOL_IP` -> `IP_TOS`. |
| SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_TOS`. |
| GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_TTL`. |
| SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) |
| // Get `SOL_IP` -> `IP_TTL`. |
| GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) |
| } |
| |
| type BaseNetworkSocketWithCtxTransitionalBase struct{} |
| |
| type BaseNetworkSocketWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewBaseNetworkSocketWithCtxInterfaceRequest() (BaseNetworkSocketWithCtxInterfaceRequest, *BaseNetworkSocketWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return BaseNetworkSocketWithCtxInterfaceRequest(req), (*BaseNetworkSocketWithCtxInterface)(cli), err |
| } |
| |
| type BaseNetworkSocketWithCtxStub struct { |
| Impl BaseNetworkSocketWithCtx |
| } |
| |
| func (s_ *BaseNetworkSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case BaseNetworkSocketClone2Ordinal: |
| in_ := &fuchsiaunknown.CloneableClone2Request{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.Clone2(args_.Ctx, (*in_).Request) |
| return nil, false, err_ |
| case BaseNetworkSocketCloseOrdinal: |
| payload, err_ := s_.Impl.Close(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketQueryOrdinal: |
| protocol, err_ := s_.Impl.Query(args_.Ctx) |
| out_ := &fuchsiaunknown.QueryableQueryResponse{Protocol: protocol} |
| return out_, true, err_ |
| case BaseNetworkSocketSetReuseAddressOrdinal: |
| in_ := &BaseSocketSetReuseAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReuseAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetReuseAddressOrdinal: |
| payload, err_ := s_.Impl.GetReuseAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetErrorOrdinal: |
| payload, err_ := s_.Impl.GetError(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetBroadcastOrdinal: |
| in_ := &BaseSocketSetBroadcastRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBroadcast(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetBroadcastOrdinal: |
| payload, err_ := s_.Impl.GetBroadcast(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetSendBufferOrdinal: |
| in_ := &BaseSocketSetSendBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetSendBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetSendBufferOrdinal: |
| payload, err_ := s_.Impl.GetSendBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetReceiveBufferOrdinal: |
| in_ := &BaseSocketSetReceiveBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReceiveBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetReceiveBufferOrdinal: |
| payload, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetKeepAliveOrdinal: |
| in_ := &BaseSocketSetKeepAliveRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetKeepAlive(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetKeepAliveOrdinal: |
| payload, err_ := s_.Impl.GetKeepAlive(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetOutOfBandInlineOrdinal: |
| in_ := &BaseSocketSetOutOfBandInlineRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetOutOfBandInline(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetOutOfBandInlineOrdinal: |
| payload, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetNoCheckOrdinal: |
| in_ := &BaseSocketSetNoCheckRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetNoCheck(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetNoCheckOrdinal: |
| payload, err_ := s_.Impl.GetNoCheck(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetLingerOrdinal: |
| in_ := &BaseSocketSetLingerRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetLinger(args_.Ctx, (*in_).Linger, (*in_).LengthSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetLingerOrdinal: |
| payload, err_ := s_.Impl.GetLinger(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetReusePortOrdinal: |
| in_ := &BaseSocketSetReusePortRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReusePort(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetReusePortOrdinal: |
| payload, err_ := s_.Impl.GetReusePort(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetAcceptConnOrdinal: |
| payload, err_ := s_.Impl.GetAcceptConn(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetBindToDeviceOrdinal: |
| in_ := &BaseSocketSetBindToDeviceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBindToDevice(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetBindToDeviceOrdinal: |
| payload, err_ := s_.Impl.GetBindToDevice(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetTimestampOrdinal: |
| in_ := &BaseSocketSetTimestampRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTimestamp(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetTimestampOrdinal: |
| payload, err_ := s_.Impl.GetTimestamp(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketBindOrdinal: |
| in_ := &BaseNetworkSocketBindRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Bind(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketConnectOrdinal: |
| in_ := &BaseNetworkSocketConnectRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Connect(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketDisconnectOrdinal: |
| payload, err_ := s_.Impl.Disconnect(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetSockNameOrdinal: |
| payload, err_ := s_.Impl.GetSockName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetPeerNameOrdinal: |
| payload, err_ := s_.Impl.GetPeerName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketShutdownOrdinal: |
| in_ := &BaseNetworkSocketShutdownRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Shutdown(args_.Ctx, (*in_).Mode) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpPacketInfoOrdinal: |
| in_ := &BaseNetworkSocketSetIpPacketInfoRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpPacketInfo(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpPacketInfoOrdinal: |
| payload, err_ := s_.Impl.GetIpPacketInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpReceiveTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpReceiveTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpReceiveTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpReceiveTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpMulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastInterface(args_.Ctx, (*in_).Iface, (*in_).Address) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpMulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpMulticastTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpMulticastTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpMulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpMulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketAddIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketDropIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpTransparentOrdinal: |
| in_ := &BaseNetworkSocketSetIpTransparentRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTransparent(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpTransparentOrdinal: |
| payload, err_ := s_.Impl.GetIpTransparent(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpReceiveOriginalDestinationAddressOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveOriginalDestinationAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpReceiveOriginalDestinationAddressOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveOriginalDestinationAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketAddIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketDropIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpv6MulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastInterface(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpv6MulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpv6UnicastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6UnicastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpv6UnicastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6UnicastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpv6ReceiveHopLimitOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceiveHopLimit(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpv6ReceiveHopLimitOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceiveHopLimit(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpv6MulticastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpv6MulticastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpv6MulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpv6MulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpv6OnlyOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6OnlyRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6Only(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpv6OnlyOrdinal: |
| payload, err_ := s_.Impl.GetIpv6Only(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpv6ReceiveTrafficClassOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceiveTrafficClass(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpv6ReceiveTrafficClassOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceiveTrafficClass(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpv6TrafficClassOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6TrafficClassRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6TrafficClass(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpv6TrafficClassOrdinal: |
| payload, err_ := s_.Impl.GetIpv6TrafficClass(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketSetIpv6ReceivePacketInfoOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceivePacketInfo(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetIpv6ReceivePacketInfoOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceivePacketInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseNetworkSocketGetOriginalDestinationOrdinal: |
| payload, err_ := s_.Impl.GetOriginalDestination(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| } |
| return nil, false, _bindings.ErrUnknownOrdinal |
| } |
| |
| type BaseNetworkSocketEventProxy _bindings.ChannelProxy |
| |
| const ( |
| BaseSocketClone2Ordinal uint64 = 0x20d8a7aba2168a79 |
| BaseSocketCloseOrdinal uint64 = 0x5ac5d459ad7f657e |
| BaseSocketQueryOrdinal uint64 = 0x2658edee9decfc06 |
| BaseSocketSetReuseAddressOrdinal uint64 = 0x1fd74ee8b9a4a876 |
| BaseSocketGetReuseAddressOrdinal uint64 = 0x67b7206b8d1bc0a5 |
| BaseSocketGetErrorOrdinal uint64 = 0x5aad39b33e5f6ebb |
| BaseSocketSetBroadcastOrdinal uint64 = 0x6023e081ce3cd947 |
| BaseSocketGetBroadcastOrdinal uint64 = 0x68796fc556f9780d |
| BaseSocketSetSendBufferOrdinal uint64 = 0x756eac32d73a7a70 |
| BaseSocketGetSendBufferOrdinal uint64 = 0x78a52fd9c7b2410b |
| BaseSocketSetReceiveBufferOrdinal uint64 = 0x6b0cf2f1919c7001 |
| BaseSocketGetReceiveBufferOrdinal uint64 = 0x14c1a4b64f709e5c |
| BaseSocketSetKeepAliveOrdinal uint64 = 0x572df8f0b920d2c7 |
| BaseSocketGetKeepAliveOrdinal uint64 = 0x2dd29d3215f2c9d2 |
| BaseSocketSetOutOfBandInlineOrdinal uint64 = 0x3ecb49968bee439 |
| BaseSocketGetOutOfBandInlineOrdinal uint64 = 0x348c1ab3aeca1745 |
| BaseSocketSetNoCheckOrdinal uint64 = 0x6bbf00c53a4c78c2 |
| BaseSocketGetNoCheckOrdinal uint64 = 0x2cd4249286417694 |
| BaseSocketSetLingerOrdinal uint64 = 0x45386351246e998e |
| BaseSocketGetLingerOrdinal uint64 = 0x48eb20fc5ccb0e45 |
| BaseSocketSetReusePortOrdinal uint64 = 0x24dd3e5cb36d9ccb |
| BaseSocketGetReusePortOrdinal uint64 = 0x7a112c1ab54ff828 |
| BaseSocketGetAcceptConnOrdinal uint64 = 0x67ce6db6c2ec8966 |
| BaseSocketSetBindToDeviceOrdinal uint64 = 0x2118b483f28aafc4 |
| BaseSocketGetBindToDeviceOrdinal uint64 = 0x1ab1fbf0ef7906c8 |
| BaseSocketSetTimestampOrdinal uint64 = 0x285d6516c263d839 |
| BaseSocketGetTimestampOrdinal uint64 = 0x49f2fffbbcc2bd27 |
| ) |
| |
| type BaseSocketWithCtxInterface _bindings.ChannelProxy |
| |
| func (p *BaseSocketWithCtxInterface) Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error { |
| req_ := &fuchsiaunknown.CloneableClone2Request{Request: request} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(BaseSocketClone2Ordinal, req_) |
| return err_ |
| } |
| |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| func (p *BaseSocketWithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.CloseableCloseResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketCloseOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *BaseSocketWithCtxInterface) Query(ctx_ _bindings.Context) ([]uint8, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.QueryableQueryResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketQueryOrdinal, req_, resp_) |
| return (*resp_).Protocol, err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *BaseSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) { |
| req_ := &BaseSocketSetReuseAddressRequest{Value: value} |
| resp_ := &BaseSocketSetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *BaseSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| func (p *BaseSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetErrorResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetErrorOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *BaseSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) { |
| req_ := &BaseSocketSetBroadcastRequest{Value: value} |
| resp_ := &BaseSocketSetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *BaseSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *BaseSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) { |
| req_ := &BaseSocketSetSendBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *BaseSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *BaseSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) { |
| req_ := &BaseSocketSetReceiveBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *BaseSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *BaseSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) { |
| req_ := &BaseSocketSetKeepAliveRequest{Value: value} |
| resp_ := &BaseSocketSetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *BaseSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *BaseSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) { |
| req_ := &BaseSocketSetOutOfBandInlineRequest{Value: value} |
| resp_ := &BaseSocketSetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *BaseSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *BaseSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) { |
| req_ := &BaseSocketSetNoCheckRequest{Value: value} |
| resp_ := &BaseSocketSetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *BaseSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *BaseSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) { |
| req_ := &BaseSocketSetLingerRequest{Linger: linger, LengthSecs: lengthSecs} |
| resp_ := &BaseSocketSetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *BaseSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *BaseSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) { |
| req_ := &BaseSocketSetReusePortRequest{Value: value} |
| resp_ := &BaseSocketSetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *BaseSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| func (p *BaseSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetAcceptConnResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetAcceptConnOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *BaseSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) { |
| req_ := &BaseSocketSetBindToDeviceRequest{Value: value} |
| resp_ := &BaseSocketSetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *BaseSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *BaseSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) { |
| req_ := &BaseSocketSetTimestampRequest{Value: value} |
| resp_ := &BaseSocketSetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketSetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *BaseSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(BaseSocketGetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // A socket. |
| type BaseSocketWithCtx interface { |
| Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) |
| Query(ctx_ _bindings.Context) ([]uint8, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) |
| } |
| |
| type BaseSocketWithCtxTransitionalBase struct{} |
| |
| type BaseSocketWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewBaseSocketWithCtxInterfaceRequest() (BaseSocketWithCtxInterfaceRequest, *BaseSocketWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return BaseSocketWithCtxInterfaceRequest(req), (*BaseSocketWithCtxInterface)(cli), err |
| } |
| |
| type BaseSocketWithCtxStub struct { |
| Impl BaseSocketWithCtx |
| } |
| |
| func (s_ *BaseSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case BaseSocketClone2Ordinal: |
| in_ := &fuchsiaunknown.CloneableClone2Request{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.Clone2(args_.Ctx, (*in_).Request) |
| return nil, false, err_ |
| case BaseSocketCloseOrdinal: |
| payload, err_ := s_.Impl.Close(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketQueryOrdinal: |
| protocol, err_ := s_.Impl.Query(args_.Ctx) |
| out_ := &fuchsiaunknown.QueryableQueryResponse{Protocol: protocol} |
| return out_, true, err_ |
| case BaseSocketSetReuseAddressOrdinal: |
| in_ := &BaseSocketSetReuseAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReuseAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetReuseAddressOrdinal: |
| payload, err_ := s_.Impl.GetReuseAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetErrorOrdinal: |
| payload, err_ := s_.Impl.GetError(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetBroadcastOrdinal: |
| in_ := &BaseSocketSetBroadcastRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBroadcast(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetBroadcastOrdinal: |
| payload, err_ := s_.Impl.GetBroadcast(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetSendBufferOrdinal: |
| in_ := &BaseSocketSetSendBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetSendBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetSendBufferOrdinal: |
| payload, err_ := s_.Impl.GetSendBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetReceiveBufferOrdinal: |
| in_ := &BaseSocketSetReceiveBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReceiveBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetReceiveBufferOrdinal: |
| payload, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetKeepAliveOrdinal: |
| in_ := &BaseSocketSetKeepAliveRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetKeepAlive(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetKeepAliveOrdinal: |
| payload, err_ := s_.Impl.GetKeepAlive(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetOutOfBandInlineOrdinal: |
| in_ := &BaseSocketSetOutOfBandInlineRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetOutOfBandInline(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetOutOfBandInlineOrdinal: |
| payload, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetNoCheckOrdinal: |
| in_ := &BaseSocketSetNoCheckRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetNoCheck(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetNoCheckOrdinal: |
| payload, err_ := s_.Impl.GetNoCheck(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetLingerOrdinal: |
| in_ := &BaseSocketSetLingerRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetLinger(args_.Ctx, (*in_).Linger, (*in_).LengthSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetLingerOrdinal: |
| payload, err_ := s_.Impl.GetLinger(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetReusePortOrdinal: |
| in_ := &BaseSocketSetReusePortRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReusePort(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetReusePortOrdinal: |
| payload, err_ := s_.Impl.GetReusePort(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetAcceptConnOrdinal: |
| payload, err_ := s_.Impl.GetAcceptConn(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetBindToDeviceOrdinal: |
| in_ := &BaseSocketSetBindToDeviceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBindToDevice(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetBindToDeviceOrdinal: |
| payload, err_ := s_.Impl.GetBindToDevice(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketSetTimestampOrdinal: |
| in_ := &BaseSocketSetTimestampRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTimestamp(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case BaseSocketGetTimestampOrdinal: |
| payload, err_ := s_.Impl.GetTimestamp(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| } |
| return nil, false, _bindings.ErrUnknownOrdinal |
| } |
| |
| type BaseSocketEventProxy _bindings.ChannelProxy |
| |
| const ( |
| DatagramSocketClone2Ordinal uint64 = 0x20d8a7aba2168a79 |
| DatagramSocketCloseOrdinal uint64 = 0x5ac5d459ad7f657e |
| DatagramSocketQueryOrdinal uint64 = 0x2658edee9decfc06 |
| DatagramSocketSetReuseAddressOrdinal uint64 = 0x1fd74ee8b9a4a876 |
| DatagramSocketGetReuseAddressOrdinal uint64 = 0x67b7206b8d1bc0a5 |
| DatagramSocketGetErrorOrdinal uint64 = 0x5aad39b33e5f6ebb |
| DatagramSocketSetBroadcastOrdinal uint64 = 0x6023e081ce3cd947 |
| DatagramSocketGetBroadcastOrdinal uint64 = 0x68796fc556f9780d |
| DatagramSocketSetSendBufferOrdinal uint64 = 0x756eac32d73a7a70 |
| DatagramSocketGetSendBufferOrdinal uint64 = 0x78a52fd9c7b2410b |
| DatagramSocketSetReceiveBufferOrdinal uint64 = 0x6b0cf2f1919c7001 |
| DatagramSocketGetReceiveBufferOrdinal uint64 = 0x14c1a4b64f709e5c |
| DatagramSocketSetKeepAliveOrdinal uint64 = 0x572df8f0b920d2c7 |
| DatagramSocketGetKeepAliveOrdinal uint64 = 0x2dd29d3215f2c9d2 |
| DatagramSocketSetOutOfBandInlineOrdinal uint64 = 0x3ecb49968bee439 |
| DatagramSocketGetOutOfBandInlineOrdinal uint64 = 0x348c1ab3aeca1745 |
| DatagramSocketSetNoCheckOrdinal uint64 = 0x6bbf00c53a4c78c2 |
| DatagramSocketGetNoCheckOrdinal uint64 = 0x2cd4249286417694 |
| DatagramSocketSetLingerOrdinal uint64 = 0x45386351246e998e |
| DatagramSocketGetLingerOrdinal uint64 = 0x48eb20fc5ccb0e45 |
| DatagramSocketSetReusePortOrdinal uint64 = 0x24dd3e5cb36d9ccb |
| DatagramSocketGetReusePortOrdinal uint64 = 0x7a112c1ab54ff828 |
| DatagramSocketGetAcceptConnOrdinal uint64 = 0x67ce6db6c2ec8966 |
| DatagramSocketSetBindToDeviceOrdinal uint64 = 0x2118b483f28aafc4 |
| DatagramSocketGetBindToDeviceOrdinal uint64 = 0x1ab1fbf0ef7906c8 |
| DatagramSocketSetTimestampOrdinal uint64 = 0x285d6516c263d839 |
| DatagramSocketGetTimestampOrdinal uint64 = 0x49f2fffbbcc2bd27 |
| DatagramSocketBindOrdinal uint64 = 0x4bc6400ae92125d |
| DatagramSocketConnectOrdinal uint64 = 0x5f05f19bfdd38871 |
| DatagramSocketDisconnectOrdinal uint64 = 0x74e63b91f7b29b2 |
| DatagramSocketGetSockNameOrdinal uint64 = 0x475f23f84a1a4f85 |
| DatagramSocketGetPeerNameOrdinal uint64 = 0x1ffecf4bd5b6432e |
| DatagramSocketShutdownOrdinal uint64 = 0x247f38b6db68c336 |
| DatagramSocketSetIpTypeOfServiceOrdinal uint64 = 0x995c600475b6d46 |
| DatagramSocketGetIpTypeOfServiceOrdinal uint64 = 0x3814a04259f75fcb |
| DatagramSocketSetIpTtlOrdinal uint64 = 0x29e2424b433ae1ef |
| DatagramSocketGetIpTtlOrdinal uint64 = 0x47e47fa1f24da471 |
| DatagramSocketSetIpPacketInfoOrdinal uint64 = 0x392d16bee20c0e16 |
| DatagramSocketGetIpPacketInfoOrdinal uint64 = 0x54b505f242280740 |
| DatagramSocketSetIpReceiveTypeOfServiceOrdinal uint64 = 0x6c4f6714995f84ef |
| DatagramSocketGetIpReceiveTypeOfServiceOrdinal uint64 = 0x4158ba7dc2795960 |
| DatagramSocketSetIpReceiveTtlOrdinal uint64 = 0x46f15be0ce0ab82b |
| DatagramSocketGetIpReceiveTtlOrdinal uint64 = 0x678ddd5a5dfa2eb5 |
| DatagramSocketSetIpMulticastInterfaceOrdinal uint64 = 0x752fbfa9b12befe |
| DatagramSocketGetIpMulticastInterfaceOrdinal uint64 = 0x320bd14c4df046c4 |
| DatagramSocketSetIpMulticastTtlOrdinal uint64 = 0x63134d53772916a1 |
| DatagramSocketGetIpMulticastTtlOrdinal uint64 = 0x4665cd378f39e1a |
| DatagramSocketSetIpMulticastLoopbackOrdinal uint64 = 0x20c55c11f00943ea |
| DatagramSocketGetIpMulticastLoopbackOrdinal uint64 = 0x3b6b26ff558298f2 |
| DatagramSocketAddIpMembershipOrdinal uint64 = 0x76bc7df115a3b4d0 |
| DatagramSocketDropIpMembershipOrdinal uint64 = 0x2888f3099188d03 |
| DatagramSocketSetIpTransparentOrdinal uint64 = 0x1ae532b0c066e3a0 |
| DatagramSocketGetIpTransparentOrdinal uint64 = 0x51d43695962ebfb5 |
| DatagramSocketSetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x4722b4ce52f7840 |
| DatagramSocketGetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x2a0e7dc5d6bfdfe9 |
| DatagramSocketAddIpv6MembershipOrdinal uint64 = 0x7c94727acb4ea4b3 |
| DatagramSocketDropIpv6MembershipOrdinal uint64 = 0x42104c70ccaba304 |
| DatagramSocketSetIpv6MulticastInterfaceOrdinal uint64 = 0x135f76db3774ab3b |
| DatagramSocketGetIpv6MulticastInterfaceOrdinal uint64 = 0x1f26fcdd348f1882 |
| DatagramSocketSetIpv6UnicastHopsOrdinal uint64 = 0x157d51e98f462859 |
| DatagramSocketGetIpv6UnicastHopsOrdinal uint64 = 0x21f4641cad8bd8d2 |
| DatagramSocketSetIpv6ReceiveHopLimitOrdinal uint64 = 0x5c24808ed2e84a1e |
| DatagramSocketGetIpv6ReceiveHopLimitOrdinal uint64 = 0x341e06689885b4c0 |
| DatagramSocketSetIpv6MulticastHopsOrdinal uint64 = 0x25b9cd4d181f82c1 |
| DatagramSocketGetIpv6MulticastHopsOrdinal uint64 = 0x52916948a365012a |
| DatagramSocketSetIpv6MulticastLoopbackOrdinal uint64 = 0x55701c409ff41b40 |
| DatagramSocketGetIpv6MulticastLoopbackOrdinal uint64 = 0x4415b701fde319c3 |
| DatagramSocketSetIpv6OnlyOrdinal uint64 = 0x4873f1364758cbba |
| DatagramSocketGetIpv6OnlyOrdinal uint64 = 0x4aa3340a1a26b89c |
| DatagramSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x58f07c8788d099a0 |
| DatagramSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x2e334df1da553ffa |
| DatagramSocketSetIpv6TrafficClassOrdinal uint64 = 0x6af077800c5a0b4f |
| DatagramSocketGetIpv6TrafficClassOrdinal uint64 = 0x6baf6eed8fc2f04 |
| DatagramSocketSetIpv6ReceivePacketInfoOrdinal uint64 = 0x19259775b1a92768 |
| DatagramSocketGetIpv6ReceivePacketInfoOrdinal uint64 = 0x7acd4a2775baec75 |
| DatagramSocketGetOriginalDestinationOrdinal uint64 = 0x38bf28f0dafdbac0 |
| DatagramSocketGetInfoOrdinal uint64 = 0x48aa0a1f6a32d2ed |
| DatagramSocketDescribeOrdinal uint64 = 0xbf1e2f0a86601f3 |
| DatagramSocketSendMsgPreflightOrdinal uint64 = 0x5362e668e777248a |
| DatagramSocketRecvMsgPostflightOrdinal uint64 = 0x1a7cdeca5f3eb8e2 |
| ) |
| |
| type DatagramSocketWithCtxInterface _bindings.ChannelProxy |
| |
| func (p *DatagramSocketWithCtxInterface) Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error { |
| req_ := &fuchsiaunknown.CloneableClone2Request{Request: request} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(DatagramSocketClone2Ordinal, req_) |
| return err_ |
| } |
| |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| func (p *DatagramSocketWithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.CloseableCloseResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketCloseOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *DatagramSocketWithCtxInterface) Query(ctx_ _bindings.Context) ([]uint8, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.QueryableQueryResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketQueryOrdinal, req_, resp_) |
| return (*resp_).Protocol, err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *DatagramSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) { |
| req_ := &BaseSocketSetReuseAddressRequest{Value: value} |
| resp_ := &BaseSocketSetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *DatagramSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| func (p *DatagramSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetErrorResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetErrorOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *DatagramSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) { |
| req_ := &BaseSocketSetBroadcastRequest{Value: value} |
| resp_ := &BaseSocketSetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *DatagramSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *DatagramSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) { |
| req_ := &BaseSocketSetSendBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *DatagramSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *DatagramSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) { |
| req_ := &BaseSocketSetReceiveBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *DatagramSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *DatagramSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) { |
| req_ := &BaseSocketSetKeepAliveRequest{Value: value} |
| resp_ := &BaseSocketSetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *DatagramSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *DatagramSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) { |
| req_ := &BaseSocketSetOutOfBandInlineRequest{Value: value} |
| resp_ := &BaseSocketSetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *DatagramSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *DatagramSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) { |
| req_ := &BaseSocketSetNoCheckRequest{Value: value} |
| resp_ := &BaseSocketSetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *DatagramSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *DatagramSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) { |
| req_ := &BaseSocketSetLingerRequest{Linger: linger, LengthSecs: lengthSecs} |
| resp_ := &BaseSocketSetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *DatagramSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *DatagramSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) { |
| req_ := &BaseSocketSetReusePortRequest{Value: value} |
| resp_ := &BaseSocketSetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *DatagramSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| func (p *DatagramSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetAcceptConnResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetAcceptConnOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *DatagramSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) { |
| req_ := &BaseSocketSetBindToDeviceRequest{Value: value} |
| resp_ := &BaseSocketSetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *DatagramSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *DatagramSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) { |
| req_ := &BaseSocketSetTimestampRequest{Value: value} |
| resp_ := &BaseSocketSetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *DatagramSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Sets the local address used for the socket. |
| func (p *DatagramSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) { |
| req_ := &BaseNetworkSocketBindRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketBindResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketBindOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Initiates a connection to a remote address. |
| func (p *DatagramSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) { |
| req_ := &BaseNetworkSocketConnectRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketConnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketConnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Clears connection information from this socket. |
| func (p *DatagramSocketWithCtxInterface) Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketDisconnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketDisconnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the local socket address. |
| func (p *DatagramSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetSockNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetSockNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the remote socket address. |
| func (p *DatagramSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetPeerNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetPeerNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Shuts down part of the socket. |
| func (p *DatagramSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) { |
| req_ := &BaseNetworkSocketShutdownRequest{Mode: mode} |
| resp_ := &BaseNetworkSocketShutdownResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketShutdownOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TOS`. |
| func (p *DatagramSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TOS`. |
| func (p *DatagramSocketWithCtxInterface) GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TTL`. |
| func (p *DatagramSocketWithCtxInterface) SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TTL`. |
| func (p *DatagramSocketWithCtxInterface) GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| func (p *DatagramSocketWithCtxInterface) SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpPacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| func (p *DatagramSocketWithCtxInterface) GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| func (p *DatagramSocketWithCtxInterface) SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| func (p *DatagramSocketWithCtxInterface) GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| func (p *DatagramSocketWithCtxInterface) SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| func (p *DatagramSocketWithCtxInterface) GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *DatagramSocketWithCtxInterface) SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{Iface: iface, Address: address} |
| resp_ := &BaseNetworkSocketSetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *DatagramSocketWithCtxInterface) GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *DatagramSocketWithCtxInterface) SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *DatagramSocketWithCtxInterface) GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *DatagramSocketWithCtxInterface) SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *DatagramSocketWithCtxInterface) GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| func (p *DatagramSocketWithCtxInterface) AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketAddIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| func (p *DatagramSocketWithCtxInterface) DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketDropIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *DatagramSocketWithCtxInterface) SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) { |
| req_ := &BaseNetworkSocketSetIpTransparentRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *DatagramSocketWithCtxInterface) GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *DatagramSocketWithCtxInterface) SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *DatagramSocketWithCtxInterface) GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| func (p *DatagramSocketWithCtxInterface) AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketAddIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| func (p *DatagramSocketWithCtxInterface) DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketDropIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *DatagramSocketWithCtxInterface) SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *DatagramSocketWithCtxInterface) GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *DatagramSocketWithCtxInterface) SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *DatagramSocketWithCtxInterface) GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *DatagramSocketWithCtxInterface) SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *DatagramSocketWithCtxInterface) GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *DatagramSocketWithCtxInterface) SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *DatagramSocketWithCtxInterface) GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *DatagramSocketWithCtxInterface) SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *DatagramSocketWithCtxInterface) GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *DatagramSocketWithCtxInterface) SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6OnlyRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *DatagramSocketWithCtxInterface) GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *DatagramSocketWithCtxInterface) SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *DatagramSocketWithCtxInterface) GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| func (p *DatagramSocketWithCtxInterface) SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6TrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| func (p *DatagramSocketWithCtxInterface) GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *DatagramSocketWithCtxInterface) SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *DatagramSocketWithCtxInterface) GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| func (p *DatagramSocketWithCtxInterface) GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetOriginalDestinationResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetOriginalDestinationOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves creation information from the socket. |
| // |
| // - response `domain` the socket's associated domain. |
| // - response `proto` the socket's associated protocol. |
| func (p *DatagramSocketWithCtxInterface) GetInfo(ctx_ _bindings.Context) (BaseDatagramSocketGetInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseDatagramSocketGetInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketGetInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *DatagramSocketWithCtxInterface) Describe(ctx_ _bindings.Context) (DatagramSocketDescribeResponse, error) { |
| var req_ _bindings.Message |
| resp_ := &DatagramSocketDescribeResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketDescribeOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Validates that data can be sent. |
| // |
| // + request `args` the requested disposition of data to be sent. |
| // - response the constraints sent data must satisfy. |
| // * error the error code indicating the reason for validation failure. |
| func (p *DatagramSocketWithCtxInterface) SendMsgPreflight(ctx_ _bindings.Context, payload DatagramSocketSendMsgPreflightRequest) (DatagramSocketSendMsgPreflightResult, error) { |
| req_ := &payload |
| resp_ := &DatagramSocketSendMsgPreflightResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketSendMsgPreflightOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Returns the set of requested control messages. |
| // |
| // - response the set of currently requested control messages. |
| func (p *DatagramSocketWithCtxInterface) RecvMsgPostflight(ctx_ _bindings.Context) (DatagramSocketRecvMsgPostflightResult, error) { |
| var req_ _bindings.Message |
| resp_ := &DatagramSocketRecvMsgPostflightResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(DatagramSocketRecvMsgPostflightOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // A datagram socket. |
| type DatagramSocketWithCtx interface { |
| Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) |
| Query(ctx_ _bindings.Context) ([]uint8, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) |
| // Sets the local address used for the socket. |
| Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) |
| // Initiates a connection to a remote address. |
| Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) |
| // Clears connection information from this socket. |
| Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) |
| // Retrieves the local socket address. |
| GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) |
| // Retrieves the remote socket address. |
| GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) |
| // Shuts down part of the socket. |
| Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) |
| // Set `SOL_IP` -> `IP_TOS`. |
| SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_TOS`. |
| GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_TTL`. |
| SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) |
| // Get `SOL_IP` -> `IP_TTL`. |
| GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) |
| // Retrieves creation information from the socket. |
| // |
| // - response `domain` the socket's associated domain. |
| // - response `proto` the socket's associated protocol. |
| GetInfo(ctx_ _bindings.Context) (BaseDatagramSocketGetInfoResult, error) |
| Describe(ctx_ _bindings.Context) (DatagramSocketDescribeResponse, error) |
| // Validates that data can be sent. |
| // |
| // + request `args` the requested disposition of data to be sent. |
| // - response the constraints sent data must satisfy. |
| // * error the error code indicating the reason for validation failure. |
| SendMsgPreflight(ctx_ _bindings.Context, payload DatagramSocketSendMsgPreflightRequest) (DatagramSocketSendMsgPreflightResult, error) |
| // Returns the set of requested control messages. |
| // |
| // - response the set of currently requested control messages. |
| RecvMsgPostflight(ctx_ _bindings.Context) (DatagramSocketRecvMsgPostflightResult, error) |
| } |
| |
| type DatagramSocketWithCtxTransitionalBase struct{} |
| |
| type DatagramSocketWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewDatagramSocketWithCtxInterfaceRequest() (DatagramSocketWithCtxInterfaceRequest, *DatagramSocketWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return DatagramSocketWithCtxInterfaceRequest(req), (*DatagramSocketWithCtxInterface)(cli), err |
| } |
| |
| type DatagramSocketWithCtxStub struct { |
| Impl DatagramSocketWithCtx |
| } |
| |
| func (s_ *DatagramSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case DatagramSocketClone2Ordinal: |
| in_ := &fuchsiaunknown.CloneableClone2Request{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.Clone2(args_.Ctx, (*in_).Request) |
| return nil, false, err_ |
| case DatagramSocketCloseOrdinal: |
| payload, err_ := s_.Impl.Close(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketQueryOrdinal: |
| protocol, err_ := s_.Impl.Query(args_.Ctx) |
| out_ := &fuchsiaunknown.QueryableQueryResponse{Protocol: protocol} |
| return out_, true, err_ |
| case DatagramSocketSetReuseAddressOrdinal: |
| in_ := &BaseSocketSetReuseAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReuseAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetReuseAddressOrdinal: |
| payload, err_ := s_.Impl.GetReuseAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetErrorOrdinal: |
| payload, err_ := s_.Impl.GetError(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetBroadcastOrdinal: |
| in_ := &BaseSocketSetBroadcastRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBroadcast(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetBroadcastOrdinal: |
| payload, err_ := s_.Impl.GetBroadcast(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetSendBufferOrdinal: |
| in_ := &BaseSocketSetSendBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetSendBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetSendBufferOrdinal: |
| payload, err_ := s_.Impl.GetSendBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetReceiveBufferOrdinal: |
| in_ := &BaseSocketSetReceiveBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReceiveBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetReceiveBufferOrdinal: |
| payload, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetKeepAliveOrdinal: |
| in_ := &BaseSocketSetKeepAliveRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetKeepAlive(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetKeepAliveOrdinal: |
| payload, err_ := s_.Impl.GetKeepAlive(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetOutOfBandInlineOrdinal: |
| in_ := &BaseSocketSetOutOfBandInlineRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetOutOfBandInline(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetOutOfBandInlineOrdinal: |
| payload, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetNoCheckOrdinal: |
| in_ := &BaseSocketSetNoCheckRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetNoCheck(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetNoCheckOrdinal: |
| payload, err_ := s_.Impl.GetNoCheck(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetLingerOrdinal: |
| in_ := &BaseSocketSetLingerRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetLinger(args_.Ctx, (*in_).Linger, (*in_).LengthSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetLingerOrdinal: |
| payload, err_ := s_.Impl.GetLinger(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetReusePortOrdinal: |
| in_ := &BaseSocketSetReusePortRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReusePort(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetReusePortOrdinal: |
| payload, err_ := s_.Impl.GetReusePort(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetAcceptConnOrdinal: |
| payload, err_ := s_.Impl.GetAcceptConn(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetBindToDeviceOrdinal: |
| in_ := &BaseSocketSetBindToDeviceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBindToDevice(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetBindToDeviceOrdinal: |
| payload, err_ := s_.Impl.GetBindToDevice(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetTimestampOrdinal: |
| in_ := &BaseSocketSetTimestampRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTimestamp(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetTimestampOrdinal: |
| payload, err_ := s_.Impl.GetTimestamp(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketBindOrdinal: |
| in_ := &BaseNetworkSocketBindRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Bind(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketConnectOrdinal: |
| in_ := &BaseNetworkSocketConnectRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Connect(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketDisconnectOrdinal: |
| payload, err_ := s_.Impl.Disconnect(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetSockNameOrdinal: |
| payload, err_ := s_.Impl.GetSockName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetPeerNameOrdinal: |
| payload, err_ := s_.Impl.GetPeerName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketShutdownOrdinal: |
| in_ := &BaseNetworkSocketShutdownRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Shutdown(args_.Ctx, (*in_).Mode) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpPacketInfoOrdinal: |
| in_ := &BaseNetworkSocketSetIpPacketInfoRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpPacketInfo(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpPacketInfoOrdinal: |
| payload, err_ := s_.Impl.GetIpPacketInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpReceiveTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpReceiveTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpReceiveTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpReceiveTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpMulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastInterface(args_.Ctx, (*in_).Iface, (*in_).Address) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpMulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpMulticastTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpMulticastTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpMulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpMulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketAddIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketDropIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpTransparentOrdinal: |
| in_ := &BaseNetworkSocketSetIpTransparentRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTransparent(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpTransparentOrdinal: |
| payload, err_ := s_.Impl.GetIpTransparent(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpReceiveOriginalDestinationAddressOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveOriginalDestinationAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpReceiveOriginalDestinationAddressOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveOriginalDestinationAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketAddIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketDropIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpv6MulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastInterface(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpv6MulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpv6UnicastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6UnicastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpv6UnicastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6UnicastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpv6ReceiveHopLimitOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceiveHopLimit(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpv6ReceiveHopLimitOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceiveHopLimit(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpv6MulticastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpv6MulticastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpv6MulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpv6MulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpv6OnlyOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6OnlyRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6Only(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpv6OnlyOrdinal: |
| payload, err_ := s_.Impl.GetIpv6Only(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpv6ReceiveTrafficClassOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceiveTrafficClass(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpv6ReceiveTrafficClassOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceiveTrafficClass(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpv6TrafficClassOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6TrafficClassRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6TrafficClass(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpv6TrafficClassOrdinal: |
| payload, err_ := s_.Impl.GetIpv6TrafficClass(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSetIpv6ReceivePacketInfoOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceivePacketInfo(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetIpv6ReceivePacketInfoOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceivePacketInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetOriginalDestinationOrdinal: |
| payload, err_ := s_.Impl.GetOriginalDestination(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketGetInfoOrdinal: |
| payload, err_ := s_.Impl.GetInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketDescribeOrdinal: |
| payload, err_ := s_.Impl.Describe(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketSendMsgPreflightOrdinal: |
| in_ := &DatagramSocketSendMsgPreflightRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SendMsgPreflight(args_.Ctx, (*in_)) |
| out_ := &payload |
| return out_, true, err_ |
| case DatagramSocketRecvMsgPostflightOrdinal: |
| payload, err_ := s_.Impl.RecvMsgPostflight(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| } |
| return nil, false, _bindings.ErrUnknownOrdinal |
| } |
| |
| type DatagramSocketEventProxy _bindings.ChannelProxy |
| |
| const ( |
| ProviderStreamSocketOrdinal uint64 = 0x27c3581da2155545 |
| ProviderDatagramSocketDeprecatedOrdinal uint64 = 0x38876c87cf031cb1 |
| ProviderDatagramSocketOrdinal uint64 = 0x4021b4fa1b6452f2 |
| ProviderInterfaceIndexToNameOrdinal uint64 = 0x4d59a64fce98272f |
| ProviderInterfaceNameToIndexOrdinal uint64 = 0x690cd8d2f2d650f8 |
| ProviderInterfaceNameToFlagsOrdinal uint64 = 0x25d0efcdb6671a0b |
| ProviderGetInterfaceAddressesOrdinal uint64 = 0x2e7b9aaf327c870 |
| ) |
| |
| type ProviderWithCtxInterface _bindings.ChannelProxy |
| |
| // Requests a stream socket with the specified parameters. |
| func (p *ProviderWithCtxInterface) StreamSocket(ctx_ _bindings.Context, domain Domain, proto StreamSocketProtocol) (ProviderStreamSocketResult, error) { |
| req_ := &ProviderStreamSocketRequest{Domain: domain, Proto: proto} |
| resp_ := &ProviderStreamSocketResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderStreamSocketOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Requests a datagram socket with the specified parameters. |
| // TODO(https://fxbug.dev/85027): Remove this method once no more callers rely on it. |
| func (p *ProviderWithCtxInterface) DatagramSocketDeprecated(ctx_ _bindings.Context, domain Domain, proto DatagramSocketProtocol) (ProviderDatagramSocketDeprecatedResult, error) { |
| req_ := &ProviderDatagramSocketDeprecatedRequest{Domain: domain, Proto: proto} |
| resp_ := &ProviderDatagramSocketDeprecatedResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderDatagramSocketDeprecatedOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Requests a datagram socket with the specified parameters. |
| func (p *ProviderWithCtxInterface) DatagramSocket(ctx_ _bindings.Context, domain Domain, proto DatagramSocketProtocol) (ProviderDatagramSocketResult, error) { |
| req_ := &ProviderDatagramSocketRequest{Domain: domain, Proto: proto} |
| resp_ := &ProviderDatagramSocketResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderDatagramSocketOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Looks up an interface by its index and returns its name. Returns |
| // `ZX_ERR_NOT_FOUND` if the specified index doesn't exist. |
| func (p *ProviderWithCtxInterface) InterfaceIndexToName(ctx_ _bindings.Context, index uint64) (ProviderInterfaceIndexToNameResult, error) { |
| req_ := &ProviderInterfaceIndexToNameRequest{Index: index} |
| resp_ := &ProviderInterfaceIndexToNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderInterfaceIndexToNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Looks up an interface by its name and returns its index. Returns |
| // `ZX_ERR_NOT_FOUND` if the specified name doesn't exist. |
| func (p *ProviderWithCtxInterface) InterfaceNameToIndex(ctx_ _bindings.Context, name string) (ProviderInterfaceNameToIndexResult, error) { |
| req_ := &ProviderInterfaceNameToIndexRequest{Name: name} |
| resp_ := &ProviderInterfaceNameToIndexResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderInterfaceNameToIndexOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Looks up an interface by its name and returns its flags. Returns |
| // `ZX_ERR_NOT_FOUND` if the specified name doesn't exist. |
| func (p *ProviderWithCtxInterface) InterfaceNameToFlags(ctx_ _bindings.Context, name string) (ProviderInterfaceNameToFlagsResult, error) { |
| req_ := &ProviderInterfaceNameToFlagsRequest{Name: name} |
| resp_ := &ProviderInterfaceNameToFlagsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderInterfaceNameToFlagsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`] |
| // describing the network interfaces on the system. |
| func (p *ProviderWithCtxInterface) GetInterfaceAddresses(ctx_ _bindings.Context) ([]InterfaceAddresses, error) { |
| var req_ _bindings.Message |
| resp_ := &ProviderGetInterfaceAddressesResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProviderGetInterfaceAddressesOrdinal, req_, resp_) |
| return (*resp_).Interfaces, err_ |
| } |
| |
| // Provider implements the POSIX sockets API. |
| // |
| // *Warning:* This protocol is not yet ready for direct use by clients. |
| // Instead, clients should use the BSD sockets API to interact with sockets. |
| // We plan to change this protocol substantially and clients that couple |
| // directly to this protocol will make those changes more difficult. |
| type ProviderWithCtx interface { |
| // Requests a stream socket with the specified parameters. |
| StreamSocket(ctx_ _bindings.Context, domain Domain, proto StreamSocketProtocol) (ProviderStreamSocketResult, error) |
| // Requests a datagram socket with the specified parameters. |
| // TODO(https://fxbug.dev/85027): Remove this method once no more callers rely on it. |
| DatagramSocketDeprecated(ctx_ _bindings.Context, domain Domain, proto DatagramSocketProtocol) (ProviderDatagramSocketDeprecatedResult, error) |
| // Requests a datagram socket with the specified parameters. |
| DatagramSocket(ctx_ _bindings.Context, domain Domain, proto DatagramSocketProtocol) (ProviderDatagramSocketResult, error) |
| // Looks up an interface by its index and returns its name. Returns |
| // `ZX_ERR_NOT_FOUND` if the specified index doesn't exist. |
| InterfaceIndexToName(ctx_ _bindings.Context, index uint64) (ProviderInterfaceIndexToNameResult, error) |
| // Looks up an interface by its name and returns its index. Returns |
| // `ZX_ERR_NOT_FOUND` if the specified name doesn't exist. |
| InterfaceNameToIndex(ctx_ _bindings.Context, name string) (ProviderInterfaceNameToIndexResult, error) |
| // Looks up an interface by its name and returns its flags. Returns |
| // `ZX_ERR_NOT_FOUND` if the specified name doesn't exist. |
| InterfaceNameToFlags(ctx_ _bindings.Context, name string) (ProviderInterfaceNameToFlagsResult, error) |
| // Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`] |
| // describing the network interfaces on the system. |
| GetInterfaceAddresses(ctx_ _bindings.Context) ([]InterfaceAddresses, error) |
| } |
| |
| type ProviderWithCtxTransitionalBase struct{} |
| |
| type ProviderWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewProviderWithCtxInterfaceRequest() (ProviderWithCtxInterfaceRequest, *ProviderWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return ProviderWithCtxInterfaceRequest(req), (*ProviderWithCtxInterface)(cli), err |
| } |
| |
| // Implements ServiceRequest. |
| func (_ ProviderWithCtxInterfaceRequest) Name() string { |
| return "fuchsia.posix.socket.Provider" |
| } |
| func (c ProviderWithCtxInterfaceRequest) ToChannel() _zx.Channel { |
| return c.Channel |
| } |
| |
| const ProviderName = "fuchsia.posix.socket.Provider" |
| |
| type ProviderWithCtxStub struct { |
| Impl ProviderWithCtx |
| } |
| |
| func (s_ *ProviderWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case ProviderStreamSocketOrdinal: |
| in_ := &ProviderStreamSocketRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.StreamSocket(args_.Ctx, (*in_).Domain, (*in_).Proto) |
| out_ := &payload |
| return out_, true, err_ |
| case ProviderDatagramSocketDeprecatedOrdinal: |
| in_ := &ProviderDatagramSocketDeprecatedRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DatagramSocketDeprecated(args_.Ctx, (*in_).Domain, (*in_).Proto) |
| out_ := &payload |
| return out_, true, err_ |
| case ProviderDatagramSocketOrdinal: |
| in_ := &ProviderDatagramSocketRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DatagramSocket(args_.Ctx, (*in_).Domain, (*in_).Proto) |
| out_ := &payload |
| return out_, true, err_ |
| case ProviderInterfaceIndexToNameOrdinal: |
| in_ := &ProviderInterfaceIndexToNameRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.InterfaceIndexToName(args_.Ctx, (*in_).Index) |
| out_ := &payload |
| return out_, true, err_ |
| case ProviderInterfaceNameToIndexOrdinal: |
| in_ := &ProviderInterfaceNameToIndexRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.InterfaceNameToIndex(args_.Ctx, (*in_).Name) |
| out_ := &payload |
| return out_, true, err_ |
| case ProviderInterfaceNameToFlagsOrdinal: |
| in_ := &ProviderInterfaceNameToFlagsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.InterfaceNameToFlags(args_.Ctx, (*in_).Name) |
| out_ := &payload |
| return out_, true, err_ |
| case ProviderGetInterfaceAddressesOrdinal: |
| interfaces, err_ := s_.Impl.GetInterfaceAddresses(args_.Ctx) |
| out_ := &ProviderGetInterfaceAddressesResponse{Interfaces: interfaces} |
| return out_, true, err_ |
| } |
| return nil, false, _bindings.ErrUnknownOrdinal |
| } |
| |
| type ProviderEventProxy _bindings.ChannelProxy |
| |
| const ( |
| StreamSocketClone2Ordinal uint64 = 0x20d8a7aba2168a79 |
| StreamSocketCloseOrdinal uint64 = 0x5ac5d459ad7f657e |
| StreamSocketQueryOrdinal uint64 = 0x2658edee9decfc06 |
| StreamSocketSetReuseAddressOrdinal uint64 = 0x1fd74ee8b9a4a876 |
| StreamSocketGetReuseAddressOrdinal uint64 = 0x67b7206b8d1bc0a5 |
| StreamSocketGetErrorOrdinal uint64 = 0x5aad39b33e5f6ebb |
| StreamSocketSetBroadcastOrdinal uint64 = 0x6023e081ce3cd947 |
| StreamSocketGetBroadcastOrdinal uint64 = 0x68796fc556f9780d |
| StreamSocketSetSendBufferOrdinal uint64 = 0x756eac32d73a7a70 |
| StreamSocketGetSendBufferOrdinal uint64 = 0x78a52fd9c7b2410b |
| StreamSocketSetReceiveBufferOrdinal uint64 = 0x6b0cf2f1919c7001 |
| StreamSocketGetReceiveBufferOrdinal uint64 = 0x14c1a4b64f709e5c |
| StreamSocketSetKeepAliveOrdinal uint64 = 0x572df8f0b920d2c7 |
| StreamSocketGetKeepAliveOrdinal uint64 = 0x2dd29d3215f2c9d2 |
| StreamSocketSetOutOfBandInlineOrdinal uint64 = 0x3ecb49968bee439 |
| StreamSocketGetOutOfBandInlineOrdinal uint64 = 0x348c1ab3aeca1745 |
| StreamSocketSetNoCheckOrdinal uint64 = 0x6bbf00c53a4c78c2 |
| StreamSocketGetNoCheckOrdinal uint64 = 0x2cd4249286417694 |
| StreamSocketSetLingerOrdinal uint64 = 0x45386351246e998e |
| StreamSocketGetLingerOrdinal uint64 = 0x48eb20fc5ccb0e45 |
| StreamSocketSetReusePortOrdinal uint64 = 0x24dd3e5cb36d9ccb |
| StreamSocketGetReusePortOrdinal uint64 = 0x7a112c1ab54ff828 |
| StreamSocketGetAcceptConnOrdinal uint64 = 0x67ce6db6c2ec8966 |
| StreamSocketSetBindToDeviceOrdinal uint64 = 0x2118b483f28aafc4 |
| StreamSocketGetBindToDeviceOrdinal uint64 = 0x1ab1fbf0ef7906c8 |
| StreamSocketSetTimestampOrdinal uint64 = 0x285d6516c263d839 |
| StreamSocketGetTimestampOrdinal uint64 = 0x49f2fffbbcc2bd27 |
| StreamSocketBindOrdinal uint64 = 0x4bc6400ae92125d |
| StreamSocketConnectOrdinal uint64 = 0x5f05f19bfdd38871 |
| StreamSocketDisconnectOrdinal uint64 = 0x74e63b91f7b29b2 |
| StreamSocketGetSockNameOrdinal uint64 = 0x475f23f84a1a4f85 |
| StreamSocketGetPeerNameOrdinal uint64 = 0x1ffecf4bd5b6432e |
| StreamSocketShutdownOrdinal uint64 = 0x247f38b6db68c336 |
| StreamSocketSetIpTypeOfServiceOrdinal uint64 = 0x995c600475b6d46 |
| StreamSocketGetIpTypeOfServiceOrdinal uint64 = 0x3814a04259f75fcb |
| StreamSocketSetIpTtlOrdinal uint64 = 0x29e2424b433ae1ef |
| StreamSocketGetIpTtlOrdinal uint64 = 0x47e47fa1f24da471 |
| StreamSocketSetIpPacketInfoOrdinal uint64 = 0x392d16bee20c0e16 |
| StreamSocketGetIpPacketInfoOrdinal uint64 = 0x54b505f242280740 |
| StreamSocketSetIpReceiveTypeOfServiceOrdinal uint64 = 0x6c4f6714995f84ef |
| StreamSocketGetIpReceiveTypeOfServiceOrdinal uint64 = 0x4158ba7dc2795960 |
| StreamSocketSetIpReceiveTtlOrdinal uint64 = 0x46f15be0ce0ab82b |
| StreamSocketGetIpReceiveTtlOrdinal uint64 = 0x678ddd5a5dfa2eb5 |
| StreamSocketSetIpMulticastInterfaceOrdinal uint64 = 0x752fbfa9b12befe |
| StreamSocketGetIpMulticastInterfaceOrdinal uint64 = 0x320bd14c4df046c4 |
| StreamSocketSetIpMulticastTtlOrdinal uint64 = 0x63134d53772916a1 |
| StreamSocketGetIpMulticastTtlOrdinal uint64 = 0x4665cd378f39e1a |
| StreamSocketSetIpMulticastLoopbackOrdinal uint64 = 0x20c55c11f00943ea |
| StreamSocketGetIpMulticastLoopbackOrdinal uint64 = 0x3b6b26ff558298f2 |
| StreamSocketAddIpMembershipOrdinal uint64 = 0x76bc7df115a3b4d0 |
| StreamSocketDropIpMembershipOrdinal uint64 = 0x2888f3099188d03 |
| StreamSocketSetIpTransparentOrdinal uint64 = 0x1ae532b0c066e3a0 |
| StreamSocketGetIpTransparentOrdinal uint64 = 0x51d43695962ebfb5 |
| StreamSocketSetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x4722b4ce52f7840 |
| StreamSocketGetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x2a0e7dc5d6bfdfe9 |
| StreamSocketAddIpv6MembershipOrdinal uint64 = 0x7c94727acb4ea4b3 |
| StreamSocketDropIpv6MembershipOrdinal uint64 = 0x42104c70ccaba304 |
| StreamSocketSetIpv6MulticastInterfaceOrdinal uint64 = 0x135f76db3774ab3b |
| StreamSocketGetIpv6MulticastInterfaceOrdinal uint64 = 0x1f26fcdd348f1882 |
| StreamSocketSetIpv6UnicastHopsOrdinal uint64 = 0x157d51e98f462859 |
| StreamSocketGetIpv6UnicastHopsOrdinal uint64 = 0x21f4641cad8bd8d2 |
| StreamSocketSetIpv6ReceiveHopLimitOrdinal uint64 = 0x5c24808ed2e84a1e |
| StreamSocketGetIpv6ReceiveHopLimitOrdinal uint64 = 0x341e06689885b4c0 |
| StreamSocketSetIpv6MulticastHopsOrdinal uint64 = 0x25b9cd4d181f82c1 |
| StreamSocketGetIpv6MulticastHopsOrdinal uint64 = 0x52916948a365012a |
| StreamSocketSetIpv6MulticastLoopbackOrdinal uint64 = 0x55701c409ff41b40 |
| StreamSocketGetIpv6MulticastLoopbackOrdinal uint64 = 0x4415b701fde319c3 |
| StreamSocketSetIpv6OnlyOrdinal uint64 = 0x4873f1364758cbba |
| StreamSocketGetIpv6OnlyOrdinal uint64 = 0x4aa3340a1a26b89c |
| StreamSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x58f07c8788d099a0 |
| StreamSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x2e334df1da553ffa |
| StreamSocketSetIpv6TrafficClassOrdinal uint64 = 0x6af077800c5a0b4f |
| StreamSocketGetIpv6TrafficClassOrdinal uint64 = 0x6baf6eed8fc2f04 |
| StreamSocketSetIpv6ReceivePacketInfoOrdinal uint64 = 0x19259775b1a92768 |
| StreamSocketGetIpv6ReceivePacketInfoOrdinal uint64 = 0x7acd4a2775baec75 |
| StreamSocketGetOriginalDestinationOrdinal uint64 = 0x38bf28f0dafdbac0 |
| StreamSocketDescribeOrdinal uint64 = 0x29e22969a7dadc32 |
| StreamSocketListenOrdinal uint64 = 0x3d0a65ced3d10108 |
| StreamSocketAcceptOrdinal uint64 = 0x5ab7ad620424c163 |
| StreamSocketGetInfoOrdinal uint64 = 0x87cfa55d19f878f |
| StreamSocketSetTcpNoDelayOrdinal uint64 = 0x5a59b778f7333ada |
| StreamSocketGetTcpNoDelayOrdinal uint64 = 0xac219a3218b0799 |
| StreamSocketSetTcpMaxSegmentOrdinal uint64 = 0xb3d30c498266d18 |
| StreamSocketGetTcpMaxSegmentOrdinal uint64 = 0x637404d1b4b9982c |
| StreamSocketSetTcpCorkOrdinal uint64 = 0x62e26891541143a0 |
| StreamSocketGetTcpCorkOrdinal uint64 = 0x435bb232e0e74f32 |
| StreamSocketSetTcpKeepAliveIdleOrdinal uint64 = 0x196d053d8363c42 |
| StreamSocketGetTcpKeepAliveIdleOrdinal uint64 = 0x35ec58564879dac |
| StreamSocketSetTcpKeepAliveIntervalOrdinal uint64 = 0x485ffbc2da1243f2 |
| StreamSocketGetTcpKeepAliveIntervalOrdinal uint64 = 0x264eaf46306b284 |
| StreamSocketSetTcpKeepAliveCountOrdinal uint64 = 0x2ab2e8c111708421 |
| StreamSocketGetTcpKeepAliveCountOrdinal uint64 = 0x2f176ae271fe7a09 |
| StreamSocketSetTcpSynCountOrdinal uint64 = 0x4dcd6ab5573c1eb3 |
| StreamSocketGetTcpSynCountOrdinal uint64 = 0x7d457cba8f5f3ee6 |
| StreamSocketSetTcpLingerOrdinal uint64 = 0xd5cc1e8654d36e4 |
| StreamSocketGetTcpLingerOrdinal uint64 = 0xad870d311cf30eb |
| StreamSocketSetTcpDeferAcceptOrdinal uint64 = 0x15092f181e57c404 |
| StreamSocketGetTcpDeferAcceptOrdinal uint64 = 0x64589790842cb7c6 |
| StreamSocketSetTcpWindowClampOrdinal uint64 = 0x4a26ce07d847f1c6 |
| StreamSocketGetTcpWindowClampOrdinal uint64 = 0x2df6b636bf0a6a4e |
| StreamSocketGetTcpInfoOrdinal uint64 = 0x1ffb123d9f03ead2 |
| StreamSocketSetTcpQuickAckOrdinal uint64 = 0x6fa811be8fde7457 |
| StreamSocketGetTcpQuickAckOrdinal uint64 = 0x7356a949bef2df32 |
| StreamSocketSetTcpCongestionOrdinal uint64 = 0x7924c6eabde7819e |
| StreamSocketGetTcpCongestionOrdinal uint64 = 0x11e16397e1b72a47 |
| StreamSocketSetTcpUserTimeoutOrdinal uint64 = 0x6b459e81c3741a60 |
| StreamSocketGetTcpUserTimeoutOrdinal uint64 = 0x24bbd5858ad8c380 |
| ) |
| |
| type StreamSocketWithCtxInterface _bindings.ChannelProxy |
| |
| func (p *StreamSocketWithCtxInterface) Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error { |
| req_ := &fuchsiaunknown.CloneableClone2Request{Request: request} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(StreamSocketClone2Ordinal, req_) |
| return err_ |
| } |
| |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| func (p *StreamSocketWithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.CloseableCloseResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketCloseOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *StreamSocketWithCtxInterface) Query(ctx_ _bindings.Context) ([]uint8, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.QueryableQueryResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketQueryOrdinal, req_, resp_) |
| return (*resp_).Protocol, err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *StreamSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) { |
| req_ := &BaseSocketSetReuseAddressRequest{Value: value} |
| resp_ := &BaseSocketSetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *StreamSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| func (p *StreamSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetErrorResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetErrorOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *StreamSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) { |
| req_ := &BaseSocketSetBroadcastRequest{Value: value} |
| resp_ := &BaseSocketSetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *StreamSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *StreamSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) { |
| req_ := &BaseSocketSetSendBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *StreamSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *StreamSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) { |
| req_ := &BaseSocketSetReceiveBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *StreamSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *StreamSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) { |
| req_ := &BaseSocketSetKeepAliveRequest{Value: value} |
| resp_ := &BaseSocketSetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *StreamSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *StreamSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) { |
| req_ := &BaseSocketSetOutOfBandInlineRequest{Value: value} |
| resp_ := &BaseSocketSetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *StreamSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *StreamSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) { |
| req_ := &BaseSocketSetNoCheckRequest{Value: value} |
| resp_ := &BaseSocketSetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *StreamSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *StreamSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) { |
| req_ := &BaseSocketSetLingerRequest{Linger: linger, LengthSecs: lengthSecs} |
| resp_ := &BaseSocketSetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *StreamSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *StreamSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) { |
| req_ := &BaseSocketSetReusePortRequest{Value: value} |
| resp_ := &BaseSocketSetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *StreamSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| func (p *StreamSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetAcceptConnResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetAcceptConnOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *StreamSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) { |
| req_ := &BaseSocketSetBindToDeviceRequest{Value: value} |
| resp_ := &BaseSocketSetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *StreamSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *StreamSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) { |
| req_ := &BaseSocketSetTimestampRequest{Value: value} |
| resp_ := &BaseSocketSetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *StreamSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Sets the local address used for the socket. |
| func (p *StreamSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) { |
| req_ := &BaseNetworkSocketBindRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketBindResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketBindOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Initiates a connection to a remote address. |
| func (p *StreamSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) { |
| req_ := &BaseNetworkSocketConnectRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketConnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketConnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Clears connection information from this socket. |
| func (p *StreamSocketWithCtxInterface) Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketDisconnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketDisconnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the local socket address. |
| func (p *StreamSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetSockNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetSockNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the remote socket address. |
| func (p *StreamSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetPeerNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetPeerNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Shuts down part of the socket. |
| func (p *StreamSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) { |
| req_ := &BaseNetworkSocketShutdownRequest{Mode: mode} |
| resp_ := &BaseNetworkSocketShutdownResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketShutdownOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TOS`. |
| func (p *StreamSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TOS`. |
| func (p *StreamSocketWithCtxInterface) GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TTL`. |
| func (p *StreamSocketWithCtxInterface) SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TTL`. |
| func (p *StreamSocketWithCtxInterface) GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| func (p *StreamSocketWithCtxInterface) SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpPacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| func (p *StreamSocketWithCtxInterface) GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| func (p *StreamSocketWithCtxInterface) SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| func (p *StreamSocketWithCtxInterface) GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| func (p *StreamSocketWithCtxInterface) SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| func (p *StreamSocketWithCtxInterface) GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *StreamSocketWithCtxInterface) SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{Iface: iface, Address: address} |
| resp_ := &BaseNetworkSocketSetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *StreamSocketWithCtxInterface) GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *StreamSocketWithCtxInterface) SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *StreamSocketWithCtxInterface) GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *StreamSocketWithCtxInterface) SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *StreamSocketWithCtxInterface) GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| func (p *StreamSocketWithCtxInterface) AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketAddIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| func (p *StreamSocketWithCtxInterface) DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketDropIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *StreamSocketWithCtxInterface) SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) { |
| req_ := &BaseNetworkSocketSetIpTransparentRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *StreamSocketWithCtxInterface) GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *StreamSocketWithCtxInterface) SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *StreamSocketWithCtxInterface) GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| func (p *StreamSocketWithCtxInterface) AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketAddIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| func (p *StreamSocketWithCtxInterface) DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketDropIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *StreamSocketWithCtxInterface) SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *StreamSocketWithCtxInterface) GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *StreamSocketWithCtxInterface) SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *StreamSocketWithCtxInterface) GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *StreamSocketWithCtxInterface) SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *StreamSocketWithCtxInterface) GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *StreamSocketWithCtxInterface) SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *StreamSocketWithCtxInterface) GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *StreamSocketWithCtxInterface) SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *StreamSocketWithCtxInterface) GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *StreamSocketWithCtxInterface) SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6OnlyRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *StreamSocketWithCtxInterface) GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *StreamSocketWithCtxInterface) SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *StreamSocketWithCtxInterface) GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| func (p *StreamSocketWithCtxInterface) SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6TrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| func (p *StreamSocketWithCtxInterface) GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *StreamSocketWithCtxInterface) SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *StreamSocketWithCtxInterface) GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| func (p *StreamSocketWithCtxInterface) GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetOriginalDestinationResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetOriginalDestinationOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *StreamSocketWithCtxInterface) Describe(ctx_ _bindings.Context) (StreamSocketDescribeResponse, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketDescribeResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketDescribeOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Begins listening for new incoming connections. At most `backlog` |
| // connections will be buffered. |
| func (p *StreamSocketWithCtxInterface) Listen(ctx_ _bindings.Context, backlog int16) (StreamSocketListenResult, error) { |
| req_ := &StreamSocketListenRequest{Backlog: backlog} |
| resp_ := &StreamSocketListenResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketListenOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Accepts a buffered incoming connection. |
| func (p *StreamSocketWithCtxInterface) Accept(ctx_ _bindings.Context, wantAddr bool) (StreamSocketAcceptResult, error) { |
| req_ := &StreamSocketAcceptRequest{WantAddr: wantAddr} |
| resp_ := &StreamSocketAcceptResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketAcceptOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves creation information from the socket. |
| func (p *StreamSocketWithCtxInterface) GetInfo(ctx_ _bindings.Context) (StreamSocketGetInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_NODELAY`. |
| func (p *StreamSocketWithCtxInterface) SetTcpNoDelay(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpNoDelayResult, error) { |
| req_ := &StreamSocketSetTcpNoDelayRequest{Value: value} |
| resp_ := &StreamSocketSetTcpNoDelayResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpNoDelayOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_NODELAY`. |
| func (p *StreamSocketWithCtxInterface) GetTcpNoDelay(ctx_ _bindings.Context) (StreamSocketGetTcpNoDelayResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpNoDelayResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpNoDelayOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_MAXSEG`. |
| func (p *StreamSocketWithCtxInterface) SetTcpMaxSegment(ctx_ _bindings.Context, valueBytes uint32) (StreamSocketSetTcpMaxSegmentResult, error) { |
| req_ := &StreamSocketSetTcpMaxSegmentRequest{ValueBytes: valueBytes} |
| resp_ := &StreamSocketSetTcpMaxSegmentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpMaxSegmentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_MAXSEG`. |
| func (p *StreamSocketWithCtxInterface) GetTcpMaxSegment(ctx_ _bindings.Context) (StreamSocketGetTcpMaxSegmentResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpMaxSegmentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpMaxSegmentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_CORK`. |
| func (p *StreamSocketWithCtxInterface) SetTcpCork(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpCorkResult, error) { |
| req_ := &StreamSocketSetTcpCorkRequest{Value: value} |
| resp_ := &StreamSocketSetTcpCorkResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpCorkOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_CORK`. |
| func (p *StreamSocketWithCtxInterface) GetTcpCork(ctx_ _bindings.Context) (StreamSocketGetTcpCorkResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpCorkResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpCorkOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_KEEPIDLE`. |
| func (p *StreamSocketWithCtxInterface) SetTcpKeepAliveIdle(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpKeepAliveIdleResult, error) { |
| req_ := &StreamSocketSetTcpKeepAliveIdleRequest{ValueSecs: valueSecs} |
| resp_ := &StreamSocketSetTcpKeepAliveIdleResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpKeepAliveIdleOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_KEEPIDLE`. |
| func (p *StreamSocketWithCtxInterface) GetTcpKeepAliveIdle(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveIdleResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpKeepAliveIdleResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpKeepAliveIdleOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_KEEPINTVL`. |
| func (p *StreamSocketWithCtxInterface) SetTcpKeepAliveInterval(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpKeepAliveIntervalResult, error) { |
| req_ := &StreamSocketSetTcpKeepAliveIntervalRequest{ValueSecs: valueSecs} |
| resp_ := &StreamSocketSetTcpKeepAliveIntervalResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpKeepAliveIntervalOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_KEEPINTVL`. |
| func (p *StreamSocketWithCtxInterface) GetTcpKeepAliveInterval(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveIntervalResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpKeepAliveIntervalResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpKeepAliveIntervalOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_KEEPCNT`. |
| func (p *StreamSocketWithCtxInterface) SetTcpKeepAliveCount(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpKeepAliveCountResult, error) { |
| req_ := &StreamSocketSetTcpKeepAliveCountRequest{Value: value} |
| resp_ := &StreamSocketSetTcpKeepAliveCountResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpKeepAliveCountOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_KEEPCNT`. |
| func (p *StreamSocketWithCtxInterface) GetTcpKeepAliveCount(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveCountResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpKeepAliveCountResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpKeepAliveCountOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_SYNCNT`. |
| func (p *StreamSocketWithCtxInterface) SetTcpSynCount(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpSynCountResult, error) { |
| req_ := &StreamSocketSetTcpSynCountRequest{Value: value} |
| resp_ := &StreamSocketSetTcpSynCountResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpSynCountOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_SYNCNT`. |
| func (p *StreamSocketWithCtxInterface) GetTcpSynCount(ctx_ _bindings.Context) (StreamSocketGetTcpSynCountResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpSynCountResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpSynCountOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_LINGER2`. |
| func (p *StreamSocketWithCtxInterface) SetTcpLinger(ctx_ _bindings.Context, valueSecs OptionalUint32) (StreamSocketSetTcpLingerResult, error) { |
| req_ := &StreamSocketSetTcpLingerRequest{ValueSecs: valueSecs} |
| resp_ := &StreamSocketSetTcpLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_LINGER2`. |
| func (p *StreamSocketWithCtxInterface) GetTcpLinger(ctx_ _bindings.Context) (StreamSocketGetTcpLingerResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`. |
| func (p *StreamSocketWithCtxInterface) SetTcpDeferAccept(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpDeferAcceptResult, error) { |
| req_ := &StreamSocketSetTcpDeferAcceptRequest{ValueSecs: valueSecs} |
| resp_ := &StreamSocketSetTcpDeferAcceptResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpDeferAcceptOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`. |
| func (p *StreamSocketWithCtxInterface) GetTcpDeferAccept(ctx_ _bindings.Context) (StreamSocketGetTcpDeferAcceptResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpDeferAcceptResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpDeferAcceptOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`. |
| func (p *StreamSocketWithCtxInterface) SetTcpWindowClamp(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpWindowClampResult, error) { |
| req_ := &StreamSocketSetTcpWindowClampRequest{Value: value} |
| resp_ := &StreamSocketSetTcpWindowClampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpWindowClampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`. |
| func (p *StreamSocketWithCtxInterface) GetTcpWindowClamp(ctx_ _bindings.Context) (StreamSocketGetTcpWindowClampResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpWindowClampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpWindowClampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_INFO`. |
| func (p *StreamSocketWithCtxInterface) GetTcpInfo(ctx_ _bindings.Context) (StreamSocketGetTcpInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_QUICKACK`. |
| func (p *StreamSocketWithCtxInterface) SetTcpQuickAck(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpQuickAckResult, error) { |
| req_ := &StreamSocketSetTcpQuickAckRequest{Value: value} |
| resp_ := &StreamSocketSetTcpQuickAckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpQuickAckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_QUICKACK`. |
| func (p *StreamSocketWithCtxInterface) GetTcpQuickAck(ctx_ _bindings.Context) (StreamSocketGetTcpQuickAckResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpQuickAckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpQuickAckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_CONGESTION`. |
| func (p *StreamSocketWithCtxInterface) SetTcpCongestion(ctx_ _bindings.Context, value TcpCongestionControl) (StreamSocketSetTcpCongestionResult, error) { |
| req_ := &StreamSocketSetTcpCongestionRequest{Value: value} |
| resp_ := &StreamSocketSetTcpCongestionResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpCongestionOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_CONGESTION`. |
| func (p *StreamSocketWithCtxInterface) GetTcpCongestion(ctx_ _bindings.Context) (StreamSocketGetTcpCongestionResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpCongestionResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpCongestionOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_TCP` -> `TCP_USER_TIMEOUT`. |
| func (p *StreamSocketWithCtxInterface) SetTcpUserTimeout(ctx_ _bindings.Context, valueMillis uint32) (StreamSocketSetTcpUserTimeoutResult, error) { |
| req_ := &StreamSocketSetTcpUserTimeoutRequest{ValueMillis: valueMillis} |
| resp_ := &StreamSocketSetTcpUserTimeoutResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketSetTcpUserTimeoutOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_TCP` -> `TCP_USER_TIMEOUT`. |
| func (p *StreamSocketWithCtxInterface) GetTcpUserTimeout(ctx_ _bindings.Context) (StreamSocketGetTcpUserTimeoutResult, error) { |
| var req_ _bindings.Message |
| resp_ := &StreamSocketGetTcpUserTimeoutResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(StreamSocketGetTcpUserTimeoutOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // A stream socket. |
| // |
| // All methods on this type are nonblocking; their exact behaviors match their |
| // Linux counterparts. |
| // |
| // *Warning:* This protocol is not yet ready for direct use by clients. |
| // Instead, clients should use the BSD sockets API to interact with sockets. |
| // We plan to change this protocol substantially and clients that couple |
| // directly to this protocol will make those changes more difficult. |
| type StreamSocketWithCtx interface { |
| Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) |
| Query(ctx_ _bindings.Context) ([]uint8, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) |
| // Sets the local address used for the socket. |
| Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) |
| // Initiates a connection to a remote address. |
| Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) |
| // Clears connection information from this socket. |
| Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) |
| // Retrieves the local socket address. |
| GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) |
| // Retrieves the remote socket address. |
| GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) |
| // Shuts down part of the socket. |
| Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) |
| // Set `SOL_IP` -> `IP_TOS`. |
| SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_TOS`. |
| GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_TTL`. |
| SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) |
| // Get `SOL_IP` -> `IP_TTL`. |
| GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) |
| Describe(ctx_ _bindings.Context) (StreamSocketDescribeResponse, error) |
| // Begins listening for new incoming connections. At most `backlog` |
| // connections will be buffered. |
| Listen(ctx_ _bindings.Context, backlog int16) (StreamSocketListenResult, error) |
| // Accepts a buffered incoming connection. |
| Accept(ctx_ _bindings.Context, wantAddr bool) (StreamSocketAcceptResult, error) |
| // Retrieves creation information from the socket. |
| GetInfo(ctx_ _bindings.Context) (StreamSocketGetInfoResult, error) |
| // Set `SOL_TCP` -> `TCP_NODELAY`. |
| SetTcpNoDelay(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpNoDelayResult, error) |
| // Get `SOL_TCP` -> `TCP_NODELAY`. |
| GetTcpNoDelay(ctx_ _bindings.Context) (StreamSocketGetTcpNoDelayResult, error) |
| // Set `SOL_TCP` -> `TCP_MAXSEG`. |
| SetTcpMaxSegment(ctx_ _bindings.Context, valueBytes uint32) (StreamSocketSetTcpMaxSegmentResult, error) |
| // Get `SOL_TCP` -> `TCP_MAXSEG`. |
| GetTcpMaxSegment(ctx_ _bindings.Context) (StreamSocketGetTcpMaxSegmentResult, error) |
| // Set `SOL_TCP` -> `TCP_CORK`. |
| SetTcpCork(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpCorkResult, error) |
| // Get `SOL_TCP` -> `TCP_CORK`. |
| GetTcpCork(ctx_ _bindings.Context) (StreamSocketGetTcpCorkResult, error) |
| // Set `SOL_TCP` -> `TCP_KEEPIDLE`. |
| SetTcpKeepAliveIdle(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpKeepAliveIdleResult, error) |
| // Get `SOL_TCP` -> `TCP_KEEPIDLE`. |
| GetTcpKeepAliveIdle(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveIdleResult, error) |
| // Set `SOL_TCP` -> `TCP_KEEPINTVL`. |
| SetTcpKeepAliveInterval(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpKeepAliveIntervalResult, error) |
| // Get `SOL_TCP` -> `TCP_KEEPINTVL`. |
| GetTcpKeepAliveInterval(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveIntervalResult, error) |
| // Set `SOL_TCP` -> `TCP_KEEPCNT`. |
| SetTcpKeepAliveCount(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpKeepAliveCountResult, error) |
| // Get `SOL_TCP` -> `TCP_KEEPCNT`. |
| GetTcpKeepAliveCount(ctx_ _bindings.Context) (StreamSocketGetTcpKeepAliveCountResult, error) |
| // Set `SOL_TCP` -> `TCP_SYNCNT`. |
| SetTcpSynCount(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpSynCountResult, error) |
| // Get `SOL_TCP` -> `TCP_SYNCNT`. |
| GetTcpSynCount(ctx_ _bindings.Context) (StreamSocketGetTcpSynCountResult, error) |
| // Set `SOL_TCP` -> `TCP_LINGER2`. |
| SetTcpLinger(ctx_ _bindings.Context, valueSecs OptionalUint32) (StreamSocketSetTcpLingerResult, error) |
| // Get `SOL_TCP` -> `TCP_LINGER2`. |
| GetTcpLinger(ctx_ _bindings.Context) (StreamSocketGetTcpLingerResult, error) |
| // Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`. |
| SetTcpDeferAccept(ctx_ _bindings.Context, valueSecs uint32) (StreamSocketSetTcpDeferAcceptResult, error) |
| // Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`. |
| GetTcpDeferAccept(ctx_ _bindings.Context) (StreamSocketGetTcpDeferAcceptResult, error) |
| // Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`. |
| SetTcpWindowClamp(ctx_ _bindings.Context, value uint32) (StreamSocketSetTcpWindowClampResult, error) |
| // Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`. |
| GetTcpWindowClamp(ctx_ _bindings.Context) (StreamSocketGetTcpWindowClampResult, error) |
| // Get `SOL_TCP` -> `TCP_INFO`. |
| GetTcpInfo(ctx_ _bindings.Context) (StreamSocketGetTcpInfoResult, error) |
| // Set `SOL_TCP` -> `TCP_QUICKACK`. |
| SetTcpQuickAck(ctx_ _bindings.Context, value bool) (StreamSocketSetTcpQuickAckResult, error) |
| // Get `SOL_TCP` -> `TCP_QUICKACK`. |
| GetTcpQuickAck(ctx_ _bindings.Context) (StreamSocketGetTcpQuickAckResult, error) |
| // Set `SOL_TCP` -> `TCP_CONGESTION`. |
| SetTcpCongestion(ctx_ _bindings.Context, value TcpCongestionControl) (StreamSocketSetTcpCongestionResult, error) |
| // Get `SOL_TCP` -> `TCP_CONGESTION`. |
| GetTcpCongestion(ctx_ _bindings.Context) (StreamSocketGetTcpCongestionResult, error) |
| // Set `SOL_TCP` -> `TCP_USER_TIMEOUT`. |
| SetTcpUserTimeout(ctx_ _bindings.Context, valueMillis uint32) (StreamSocketSetTcpUserTimeoutResult, error) |
| // Get `SOL_TCP` -> `TCP_USER_TIMEOUT`. |
| GetTcpUserTimeout(ctx_ _bindings.Context) (StreamSocketGetTcpUserTimeoutResult, error) |
| } |
| |
| type StreamSocketWithCtxTransitionalBase struct{} |
| |
| type StreamSocketWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewStreamSocketWithCtxInterfaceRequest() (StreamSocketWithCtxInterfaceRequest, *StreamSocketWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return StreamSocketWithCtxInterfaceRequest(req), (*StreamSocketWithCtxInterface)(cli), err |
| } |
| |
| type StreamSocketWithCtxStub struct { |
| Impl StreamSocketWithCtx |
| } |
| |
| func (s_ *StreamSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case StreamSocketClone2Ordinal: |
| in_ := &fuchsiaunknown.CloneableClone2Request{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.Clone2(args_.Ctx, (*in_).Request) |
| return nil, false, err_ |
| case StreamSocketCloseOrdinal: |
| payload, err_ := s_.Impl.Close(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketQueryOrdinal: |
| protocol, err_ := s_.Impl.Query(args_.Ctx) |
| out_ := &fuchsiaunknown.QueryableQueryResponse{Protocol: protocol} |
| return out_, true, err_ |
| case StreamSocketSetReuseAddressOrdinal: |
| in_ := &BaseSocketSetReuseAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReuseAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetReuseAddressOrdinal: |
| payload, err_ := s_.Impl.GetReuseAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetErrorOrdinal: |
| payload, err_ := s_.Impl.GetError(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetBroadcastOrdinal: |
| in_ := &BaseSocketSetBroadcastRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBroadcast(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetBroadcastOrdinal: |
| payload, err_ := s_.Impl.GetBroadcast(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetSendBufferOrdinal: |
| in_ := &BaseSocketSetSendBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetSendBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetSendBufferOrdinal: |
| payload, err_ := s_.Impl.GetSendBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetReceiveBufferOrdinal: |
| in_ := &BaseSocketSetReceiveBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReceiveBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetReceiveBufferOrdinal: |
| payload, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetKeepAliveOrdinal: |
| in_ := &BaseSocketSetKeepAliveRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetKeepAlive(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetKeepAliveOrdinal: |
| payload, err_ := s_.Impl.GetKeepAlive(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetOutOfBandInlineOrdinal: |
| in_ := &BaseSocketSetOutOfBandInlineRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetOutOfBandInline(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetOutOfBandInlineOrdinal: |
| payload, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetNoCheckOrdinal: |
| in_ := &BaseSocketSetNoCheckRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetNoCheck(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetNoCheckOrdinal: |
| payload, err_ := s_.Impl.GetNoCheck(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetLingerOrdinal: |
| in_ := &BaseSocketSetLingerRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetLinger(args_.Ctx, (*in_).Linger, (*in_).LengthSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetLingerOrdinal: |
| payload, err_ := s_.Impl.GetLinger(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetReusePortOrdinal: |
| in_ := &BaseSocketSetReusePortRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReusePort(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetReusePortOrdinal: |
| payload, err_ := s_.Impl.GetReusePort(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetAcceptConnOrdinal: |
| payload, err_ := s_.Impl.GetAcceptConn(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetBindToDeviceOrdinal: |
| in_ := &BaseSocketSetBindToDeviceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBindToDevice(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetBindToDeviceOrdinal: |
| payload, err_ := s_.Impl.GetBindToDevice(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTimestampOrdinal: |
| in_ := &BaseSocketSetTimestampRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTimestamp(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTimestampOrdinal: |
| payload, err_ := s_.Impl.GetTimestamp(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketBindOrdinal: |
| in_ := &BaseNetworkSocketBindRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Bind(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketConnectOrdinal: |
| in_ := &BaseNetworkSocketConnectRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Connect(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketDisconnectOrdinal: |
| payload, err_ := s_.Impl.Disconnect(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetSockNameOrdinal: |
| payload, err_ := s_.Impl.GetSockName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetPeerNameOrdinal: |
| payload, err_ := s_.Impl.GetPeerName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketShutdownOrdinal: |
| in_ := &BaseNetworkSocketShutdownRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Shutdown(args_.Ctx, (*in_).Mode) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpPacketInfoOrdinal: |
| in_ := &BaseNetworkSocketSetIpPacketInfoRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpPacketInfo(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpPacketInfoOrdinal: |
| payload, err_ := s_.Impl.GetIpPacketInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpReceiveTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpReceiveTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpReceiveTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpReceiveTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpMulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastInterface(args_.Ctx, (*in_).Iface, (*in_).Address) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpMulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpMulticastTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpMulticastTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpMulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpMulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketAddIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketDropIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpTransparentOrdinal: |
| in_ := &BaseNetworkSocketSetIpTransparentRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTransparent(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpTransparentOrdinal: |
| payload, err_ := s_.Impl.GetIpTransparent(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpReceiveOriginalDestinationAddressOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveOriginalDestinationAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpReceiveOriginalDestinationAddressOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveOriginalDestinationAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketAddIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketDropIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpv6MulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastInterface(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpv6MulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpv6UnicastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6UnicastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpv6UnicastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6UnicastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpv6ReceiveHopLimitOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceiveHopLimit(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpv6ReceiveHopLimitOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceiveHopLimit(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpv6MulticastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpv6MulticastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpv6MulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpv6MulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpv6OnlyOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6OnlyRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6Only(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpv6OnlyOrdinal: |
| payload, err_ := s_.Impl.GetIpv6Only(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpv6ReceiveTrafficClassOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceiveTrafficClass(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpv6ReceiveTrafficClassOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceiveTrafficClass(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpv6TrafficClassOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6TrafficClassRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6TrafficClass(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpv6TrafficClassOrdinal: |
| payload, err_ := s_.Impl.GetIpv6TrafficClass(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetIpv6ReceivePacketInfoOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceivePacketInfo(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetIpv6ReceivePacketInfoOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceivePacketInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetOriginalDestinationOrdinal: |
| payload, err_ := s_.Impl.GetOriginalDestination(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketDescribeOrdinal: |
| payload, err_ := s_.Impl.Describe(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketListenOrdinal: |
| in_ := &StreamSocketListenRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Listen(args_.Ctx, (*in_).Backlog) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketAcceptOrdinal: |
| in_ := &StreamSocketAcceptRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Accept(args_.Ctx, (*in_).WantAddr) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetInfoOrdinal: |
| payload, err_ := s_.Impl.GetInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpNoDelayOrdinal: |
| in_ := &StreamSocketSetTcpNoDelayRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpNoDelay(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpNoDelayOrdinal: |
| payload, err_ := s_.Impl.GetTcpNoDelay(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpMaxSegmentOrdinal: |
| in_ := &StreamSocketSetTcpMaxSegmentRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpMaxSegment(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpMaxSegmentOrdinal: |
| payload, err_ := s_.Impl.GetTcpMaxSegment(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpCorkOrdinal: |
| in_ := &StreamSocketSetTcpCorkRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpCork(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpCorkOrdinal: |
| payload, err_ := s_.Impl.GetTcpCork(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpKeepAliveIdleOrdinal: |
| in_ := &StreamSocketSetTcpKeepAliveIdleRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpKeepAliveIdle(args_.Ctx, (*in_).ValueSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpKeepAliveIdleOrdinal: |
| payload, err_ := s_.Impl.GetTcpKeepAliveIdle(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpKeepAliveIntervalOrdinal: |
| in_ := &StreamSocketSetTcpKeepAliveIntervalRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpKeepAliveInterval(args_.Ctx, (*in_).ValueSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpKeepAliveIntervalOrdinal: |
| payload, err_ := s_.Impl.GetTcpKeepAliveInterval(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpKeepAliveCountOrdinal: |
| in_ := &StreamSocketSetTcpKeepAliveCountRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpKeepAliveCount(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpKeepAliveCountOrdinal: |
| payload, err_ := s_.Impl.GetTcpKeepAliveCount(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpSynCountOrdinal: |
| in_ := &StreamSocketSetTcpSynCountRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpSynCount(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpSynCountOrdinal: |
| payload, err_ := s_.Impl.GetTcpSynCount(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpLingerOrdinal: |
| in_ := &StreamSocketSetTcpLingerRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpLinger(args_.Ctx, (*in_).ValueSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpLingerOrdinal: |
| payload, err_ := s_.Impl.GetTcpLinger(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpDeferAcceptOrdinal: |
| in_ := &StreamSocketSetTcpDeferAcceptRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpDeferAccept(args_.Ctx, (*in_).ValueSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpDeferAcceptOrdinal: |
| payload, err_ := s_.Impl.GetTcpDeferAccept(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpWindowClampOrdinal: |
| in_ := &StreamSocketSetTcpWindowClampRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpWindowClamp(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpWindowClampOrdinal: |
| payload, err_ := s_.Impl.GetTcpWindowClamp(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpInfoOrdinal: |
| payload, err_ := s_.Impl.GetTcpInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpQuickAckOrdinal: |
| in_ := &StreamSocketSetTcpQuickAckRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpQuickAck(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpQuickAckOrdinal: |
| payload, err_ := s_.Impl.GetTcpQuickAck(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpCongestionOrdinal: |
| in_ := &StreamSocketSetTcpCongestionRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpCongestion(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpCongestionOrdinal: |
| payload, err_ := s_.Impl.GetTcpCongestion(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketSetTcpUserTimeoutOrdinal: |
| in_ := &StreamSocketSetTcpUserTimeoutRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTcpUserTimeout(args_.Ctx, (*in_).ValueMillis) |
| out_ := &payload |
| return out_, true, err_ |
| case StreamSocketGetTcpUserTimeoutOrdinal: |
| payload, err_ := s_.Impl.GetTcpUserTimeout(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| } |
| return nil, false, _bindings.ErrUnknownOrdinal |
| } |
| |
| type StreamSocketEventProxy _bindings.ChannelProxy |
| |
| const ( |
| SynchronousDatagramSocketClone2Ordinal uint64 = 0x20d8a7aba2168a79 |
| SynchronousDatagramSocketCloseOrdinal uint64 = 0x5ac5d459ad7f657e |
| SynchronousDatagramSocketQueryOrdinal uint64 = 0x2658edee9decfc06 |
| SynchronousDatagramSocketSetReuseAddressOrdinal uint64 = 0x1fd74ee8b9a4a876 |
| SynchronousDatagramSocketGetReuseAddressOrdinal uint64 = 0x67b7206b8d1bc0a5 |
| SynchronousDatagramSocketGetErrorOrdinal uint64 = 0x5aad39b33e5f6ebb |
| SynchronousDatagramSocketSetBroadcastOrdinal uint64 = 0x6023e081ce3cd947 |
| SynchronousDatagramSocketGetBroadcastOrdinal uint64 = 0x68796fc556f9780d |
| SynchronousDatagramSocketSetSendBufferOrdinal uint64 = 0x756eac32d73a7a70 |
| SynchronousDatagramSocketGetSendBufferOrdinal uint64 = 0x78a52fd9c7b2410b |
| SynchronousDatagramSocketSetReceiveBufferOrdinal uint64 = 0x6b0cf2f1919c7001 |
| SynchronousDatagramSocketGetReceiveBufferOrdinal uint64 = 0x14c1a4b64f709e5c |
| SynchronousDatagramSocketSetKeepAliveOrdinal uint64 = 0x572df8f0b920d2c7 |
| SynchronousDatagramSocketGetKeepAliveOrdinal uint64 = 0x2dd29d3215f2c9d2 |
| SynchronousDatagramSocketSetOutOfBandInlineOrdinal uint64 = 0x3ecb49968bee439 |
| SynchronousDatagramSocketGetOutOfBandInlineOrdinal uint64 = 0x348c1ab3aeca1745 |
| SynchronousDatagramSocketSetNoCheckOrdinal uint64 = 0x6bbf00c53a4c78c2 |
| SynchronousDatagramSocketGetNoCheckOrdinal uint64 = 0x2cd4249286417694 |
| SynchronousDatagramSocketSetLingerOrdinal uint64 = 0x45386351246e998e |
| SynchronousDatagramSocketGetLingerOrdinal uint64 = 0x48eb20fc5ccb0e45 |
| SynchronousDatagramSocketSetReusePortOrdinal uint64 = 0x24dd3e5cb36d9ccb |
| SynchronousDatagramSocketGetReusePortOrdinal uint64 = 0x7a112c1ab54ff828 |
| SynchronousDatagramSocketGetAcceptConnOrdinal uint64 = 0x67ce6db6c2ec8966 |
| SynchronousDatagramSocketSetBindToDeviceOrdinal uint64 = 0x2118b483f28aafc4 |
| SynchronousDatagramSocketGetBindToDeviceOrdinal uint64 = 0x1ab1fbf0ef7906c8 |
| SynchronousDatagramSocketSetTimestampOrdinal uint64 = 0x285d6516c263d839 |
| SynchronousDatagramSocketGetTimestampOrdinal uint64 = 0x49f2fffbbcc2bd27 |
| SynchronousDatagramSocketBindOrdinal uint64 = 0x4bc6400ae92125d |
| SynchronousDatagramSocketConnectOrdinal uint64 = 0x5f05f19bfdd38871 |
| SynchronousDatagramSocketDisconnectOrdinal uint64 = 0x74e63b91f7b29b2 |
| SynchronousDatagramSocketGetSockNameOrdinal uint64 = 0x475f23f84a1a4f85 |
| SynchronousDatagramSocketGetPeerNameOrdinal uint64 = 0x1ffecf4bd5b6432e |
| SynchronousDatagramSocketShutdownOrdinal uint64 = 0x247f38b6db68c336 |
| SynchronousDatagramSocketSetIpTypeOfServiceOrdinal uint64 = 0x995c600475b6d46 |
| SynchronousDatagramSocketGetIpTypeOfServiceOrdinal uint64 = 0x3814a04259f75fcb |
| SynchronousDatagramSocketSetIpTtlOrdinal uint64 = 0x29e2424b433ae1ef |
| SynchronousDatagramSocketGetIpTtlOrdinal uint64 = 0x47e47fa1f24da471 |
| SynchronousDatagramSocketSetIpPacketInfoOrdinal uint64 = 0x392d16bee20c0e16 |
| SynchronousDatagramSocketGetIpPacketInfoOrdinal uint64 = 0x54b505f242280740 |
| SynchronousDatagramSocketSetIpReceiveTypeOfServiceOrdinal uint64 = 0x6c4f6714995f84ef |
| SynchronousDatagramSocketGetIpReceiveTypeOfServiceOrdinal uint64 = 0x4158ba7dc2795960 |
| SynchronousDatagramSocketSetIpReceiveTtlOrdinal uint64 = 0x46f15be0ce0ab82b |
| SynchronousDatagramSocketGetIpReceiveTtlOrdinal uint64 = 0x678ddd5a5dfa2eb5 |
| SynchronousDatagramSocketSetIpMulticastInterfaceOrdinal uint64 = 0x752fbfa9b12befe |
| SynchronousDatagramSocketGetIpMulticastInterfaceOrdinal uint64 = 0x320bd14c4df046c4 |
| SynchronousDatagramSocketSetIpMulticastTtlOrdinal uint64 = 0x63134d53772916a1 |
| SynchronousDatagramSocketGetIpMulticastTtlOrdinal uint64 = 0x4665cd378f39e1a |
| SynchronousDatagramSocketSetIpMulticastLoopbackOrdinal uint64 = 0x20c55c11f00943ea |
| SynchronousDatagramSocketGetIpMulticastLoopbackOrdinal uint64 = 0x3b6b26ff558298f2 |
| SynchronousDatagramSocketAddIpMembershipOrdinal uint64 = 0x76bc7df115a3b4d0 |
| SynchronousDatagramSocketDropIpMembershipOrdinal uint64 = 0x2888f3099188d03 |
| SynchronousDatagramSocketSetIpTransparentOrdinal uint64 = 0x1ae532b0c066e3a0 |
| SynchronousDatagramSocketGetIpTransparentOrdinal uint64 = 0x51d43695962ebfb5 |
| SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x4722b4ce52f7840 |
| SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressOrdinal uint64 = 0x2a0e7dc5d6bfdfe9 |
| SynchronousDatagramSocketAddIpv6MembershipOrdinal uint64 = 0x7c94727acb4ea4b3 |
| SynchronousDatagramSocketDropIpv6MembershipOrdinal uint64 = 0x42104c70ccaba304 |
| SynchronousDatagramSocketSetIpv6MulticastInterfaceOrdinal uint64 = 0x135f76db3774ab3b |
| SynchronousDatagramSocketGetIpv6MulticastInterfaceOrdinal uint64 = 0x1f26fcdd348f1882 |
| SynchronousDatagramSocketSetIpv6UnicastHopsOrdinal uint64 = 0x157d51e98f462859 |
| SynchronousDatagramSocketGetIpv6UnicastHopsOrdinal uint64 = 0x21f4641cad8bd8d2 |
| SynchronousDatagramSocketSetIpv6ReceiveHopLimitOrdinal uint64 = 0x5c24808ed2e84a1e |
| SynchronousDatagramSocketGetIpv6ReceiveHopLimitOrdinal uint64 = 0x341e06689885b4c0 |
| SynchronousDatagramSocketSetIpv6MulticastHopsOrdinal uint64 = 0x25b9cd4d181f82c1 |
| SynchronousDatagramSocketGetIpv6MulticastHopsOrdinal uint64 = 0x52916948a365012a |
| SynchronousDatagramSocketSetIpv6MulticastLoopbackOrdinal uint64 = 0x55701c409ff41b40 |
| SynchronousDatagramSocketGetIpv6MulticastLoopbackOrdinal uint64 = 0x4415b701fde319c3 |
| SynchronousDatagramSocketSetIpv6OnlyOrdinal uint64 = 0x4873f1364758cbba |
| SynchronousDatagramSocketGetIpv6OnlyOrdinal uint64 = 0x4aa3340a1a26b89c |
| SynchronousDatagramSocketSetIpv6ReceiveTrafficClassOrdinal uint64 = 0x58f07c8788d099a0 |
| SynchronousDatagramSocketGetIpv6ReceiveTrafficClassOrdinal uint64 = 0x2e334df1da553ffa |
| SynchronousDatagramSocketSetIpv6TrafficClassOrdinal uint64 = 0x6af077800c5a0b4f |
| SynchronousDatagramSocketGetIpv6TrafficClassOrdinal uint64 = 0x6baf6eed8fc2f04 |
| SynchronousDatagramSocketSetIpv6ReceivePacketInfoOrdinal uint64 = 0x19259775b1a92768 |
| SynchronousDatagramSocketGetIpv6ReceivePacketInfoOrdinal uint64 = 0x7acd4a2775baec75 |
| SynchronousDatagramSocketGetOriginalDestinationOrdinal uint64 = 0x38bf28f0dafdbac0 |
| SynchronousDatagramSocketGetInfoOrdinal uint64 = 0x48aa0a1f6a32d2ed |
| SynchronousDatagramSocketDescribeOrdinal uint64 = 0x585f20b73631070d |
| SynchronousDatagramSocketRecvMsgOrdinal uint64 = 0x28e494e48fb5dbf3 |
| SynchronousDatagramSocketSendMsgOrdinal uint64 = 0x12dc2fceab6cefaa |
| ) |
| |
| type SynchronousDatagramSocketWithCtxInterface _bindings.ChannelProxy |
| |
| func (p *SynchronousDatagramSocketWithCtxInterface) Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error { |
| req_ := &fuchsiaunknown.CloneableClone2Request{Request: request} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(SynchronousDatagramSocketClone2Ordinal, req_) |
| return err_ |
| } |
| |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| func (p *SynchronousDatagramSocketWithCtxInterface) Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.CloseableCloseResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketCloseOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *SynchronousDatagramSocketWithCtxInterface) Query(ctx_ _bindings.Context) ([]uint8, error) { |
| var req_ _bindings.Message |
| resp_ := &fuchsiaunknown.QueryableQueryResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketQueryOrdinal, req_, resp_) |
| return (*resp_).Protocol, err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) { |
| req_ := &BaseSocketSetReuseAddressRequest{Value: value} |
| resp_ := &BaseSocketSetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReuseAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetReuseAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetErrorResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetErrorOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) { |
| req_ := &BaseSocketSetBroadcastRequest{Value: value} |
| resp_ := &BaseSocketSetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBroadcastResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetBroadcastOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) { |
| req_ := &BaseSocketSetSendBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetSendBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetSendBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) { |
| req_ := &BaseSocketSetReceiveBufferRequest{ValueBytes: valueBytes} |
| resp_ := &BaseSocketSetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReceiveBufferResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetReceiveBufferOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) { |
| req_ := &BaseSocketSetKeepAliveRequest{Value: value} |
| resp_ := &BaseSocketSetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetKeepAliveResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetKeepAliveOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) { |
| req_ := &BaseSocketSetOutOfBandInlineRequest{Value: value} |
| resp_ := &BaseSocketSetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetOutOfBandInlineResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetOutOfBandInlineOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) { |
| req_ := &BaseSocketSetNoCheckRequest{Value: value} |
| resp_ := &BaseSocketSetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetNoCheckResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetNoCheckOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) { |
| req_ := &BaseSocketSetLingerRequest{Linger: linger, LengthSecs: lengthSecs} |
| resp_ := &BaseSocketSetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetLingerResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetLingerOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) { |
| req_ := &BaseSocketSetReusePortRequest{Value: value} |
| resp_ := &BaseSocketSetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetReusePortResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetReusePortOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetAcceptConnResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetAcceptConnOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) { |
| req_ := &BaseSocketSetBindToDeviceRequest{Value: value} |
| resp_ := &BaseSocketSetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetBindToDeviceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetBindToDeviceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) { |
| req_ := &BaseSocketSetTimestampRequest{Value: value} |
| resp_ := &BaseSocketSetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseSocketGetTimestampResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetTimestampOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Sets the local address used for the socket. |
| func (p *SynchronousDatagramSocketWithCtxInterface) Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) { |
| req_ := &BaseNetworkSocketBindRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketBindResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketBindOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Initiates a connection to a remote address. |
| func (p *SynchronousDatagramSocketWithCtxInterface) Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) { |
| req_ := &BaseNetworkSocketConnectRequest{Addr: addr} |
| resp_ := &BaseNetworkSocketConnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketConnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Clears connection information from this socket. |
| func (p *SynchronousDatagramSocketWithCtxInterface) Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketDisconnectResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketDisconnectOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the local socket address. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetSockNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetSockNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves the remote socket address. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetPeerNameResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetPeerNameOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Shuts down part of the socket. |
| func (p *SynchronousDatagramSocketWithCtxInterface) Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) { |
| req_ := &BaseNetworkSocketShutdownRequest{Mode: mode} |
| resp_ := &BaseNetworkSocketShutdownResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketShutdownOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TOS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TOS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TTL`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TTL`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpPacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpPacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpPacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTypeOfServiceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpReceiveTypeOfServiceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpReceiveTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{Iface: iface, Address: address} |
| resp_ := &BaseNetworkSocketSetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpMulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastTtlRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastTtlResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpMulticastTtlOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpMulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpMulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| func (p *SynchronousDatagramSocketWithCtxInterface) AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketAddIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| func (p *SynchronousDatagramSocketWithCtxInterface) DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpMembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpMembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketDropIpMembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) { |
| req_ := &BaseNetworkSocketSetIpTransparentRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpTransparentResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpTransparentOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) { |
| req_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketAddIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketAddIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketAddIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) { |
| req_ := &BaseNetworkSocketDropIpv6MembershipRequest{Membership: membership} |
| resp_ := &BaseNetworkSocketDropIpv6MembershipResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketDropIpv6MembershipOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastInterfaceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpv6MulticastInterfaceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6UnicastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpv6UnicastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveHopLimitResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpv6ReceiveHopLimitOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastHopsResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpv6MulticastHopsOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6MulticastLoopbackResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpv6MulticastLoopbackOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6OnlyRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6OnlyResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpv6OnlyOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceiveTrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpv6ReceiveTrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6TrafficClassRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6TrafficClassResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpv6TrafficClassOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) { |
| req_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoRequest{Value: value} |
| resp_ := &BaseNetworkSocketSetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetIpv6ReceivePacketInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetIpv6ReceivePacketInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseNetworkSocketGetOriginalDestinationResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetOriginalDestinationOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Retrieves creation information from the socket. |
| // |
| // - response `domain` the socket's associated domain. |
| // - response `proto` the socket's associated protocol. |
| func (p *SynchronousDatagramSocketWithCtxInterface) GetInfo(ctx_ _bindings.Context) (BaseDatagramSocketGetInfoResult, error) { |
| var req_ _bindings.Message |
| resp_ := &BaseDatagramSocketGetInfoResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketGetInfoOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *SynchronousDatagramSocketWithCtxInterface) Describe(ctx_ _bindings.Context) (SynchronousDatagramSocketDescribeResponse, error) { |
| var req_ _bindings.Message |
| resp_ := &SynchronousDatagramSocketDescribeResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketDescribeOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Receives a message from the socket. |
| // |
| // - request `want_addr` request message's source address information to |
| // be returned. |
| // - request `data_len` the maximum allowed length of the response data |
| // buffer. |
| // - request `want_control` request ancillary data to be returned. |
| // - request `flags` flags for the receive request. |
| // - response `addr` the message's source address information, if |
| // requested. |
| // - response `data` the message. |
| // - response `control` control messages, if requested. |
| // - response `truncated` indicates whether or not the returned message |
| // was truncated. |
| func (p *SynchronousDatagramSocketWithCtxInterface) RecvMsg(ctx_ _bindings.Context, wantAddr bool, dataLen uint32, wantControl bool, flags RecvMsgFlags) (SynchronousDatagramSocketRecvMsgResult, error) { |
| req_ := &SynchronousDatagramSocketRecvMsgRequest{WantAddr: wantAddr, DataLen: dataLen, WantControl: wantControl, Flags: flags} |
| resp_ := &SynchronousDatagramSocketRecvMsgResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketRecvMsgOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // Sends a message on the socket. |
| // |
| // - request `addr` the address to send the message to. If unset, will send |
| // to the connected peer. |
| // - request `data` the message. |
| // - request `control` ancillary data. |
| // - request `flags` flags for the send request. |
| // - response `len` the number of bytes sent. |
| func (p *SynchronousDatagramSocketWithCtxInterface) SendMsg(ctx_ _bindings.Context, addr *fuchsianet.SocketAddress, data []uint8, control DatagramSocketSendControlData, flags SendMsgFlags) (SynchronousDatagramSocketSendMsgResult, error) { |
| req_ := &SynchronousDatagramSocketSendMsgRequest{Addr: addr, Data: data, Control: control, Flags: flags} |
| resp_ := &SynchronousDatagramSocketSendMsgResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(SynchronousDatagramSocketSendMsgOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| // A synchronous datagram socket. |
| // |
| // This protocol defines synchronous methods for sending and receiving datagram |
| // payloads over a channel. All methods are nonblocking; their behavior roughly |
| // matches their Linux counterparts. |
| // |
| // *Warning:* This protocol is not yet ready for direct use by clients. |
| // Instead, clients should use the BSD sockets API to interact with sockets. |
| // We plan to change this protocol substantially and clients that couple |
| // directly to this protocol will make those changes more difficult. |
| type SynchronousDatagramSocketWithCtx interface { |
| Clone2(ctx_ _bindings.Context, request fuchsiaunknown.CloneableWithCtxInterfaceRequest) error |
| // Terminates the connection. |
| // |
| // After calling `Close`, the client must not send any other requests. |
| // |
| // Servers, after sending the status response, should close the connection |
| // regardless of status and without sending an epitaph. |
| // |
| // Closing the client end of the channel should be semantically equivalent |
| // to calling `Close` without knowing when the close has completed or its |
| // status. |
| Close(ctx_ _bindings.Context) (fuchsiaunknown.CloseableCloseResult, error) |
| Query(ctx_ _bindings.Context) ([]uint8, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEADDR`. |
| SetReuseAddress(ctx_ _bindings.Context, value bool) (BaseSocketSetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEADDR`. |
| GetReuseAddress(ctx_ _bindings.Context) (BaseSocketGetReuseAddressResult, error) |
| // Get `SOL_SOCKET` -> `SO_ERROR`. |
| // Returns the last error if there is an error set on the socket. |
| GetError(ctx_ _bindings.Context) (BaseSocketGetErrorResult, error) |
| // Set `SOL_SOCKET` -> `SO_BROADCAST`. |
| SetBroadcast(ctx_ _bindings.Context, value bool) (BaseSocketSetBroadcastResult, error) |
| // Get `SOL_SOCKET` -> `SO_BROADCAST`. |
| GetBroadcast(ctx_ _bindings.Context) (BaseSocketGetBroadcastResult, error) |
| // Set `SOL_SOCKET` -> `SO_SNDBUF`. |
| SetSendBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetSendBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_SNDBUF`. |
| GetSendBuffer(ctx_ _bindings.Context) (BaseSocketGetSendBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_RCVBUF`. |
| SetReceiveBuffer(ctx_ _bindings.Context, valueBytes uint64) (BaseSocketSetReceiveBufferResult, error) |
| // Get `SOL_SOCKET` -> `SO_RCVBUF`. |
| GetReceiveBuffer(ctx_ _bindings.Context) (BaseSocketGetReceiveBufferResult, error) |
| // Set `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| SetKeepAlive(ctx_ _bindings.Context, value bool) (BaseSocketSetKeepAliveResult, error) |
| // Get `SOL_SOCKET` -> `SO_KEEPALIVE`. |
| GetKeepAlive(ctx_ _bindings.Context) (BaseSocketGetKeepAliveResult, error) |
| // Set `SOL_SOCKET` -> `SO_OOBINLINE`. |
| SetOutOfBandInline(ctx_ _bindings.Context, value bool) (BaseSocketSetOutOfBandInlineResult, error) |
| // Get `SOL_SOCKET` -> `SO_OOBINLINE`. |
| GetOutOfBandInline(ctx_ _bindings.Context) (BaseSocketGetOutOfBandInlineResult, error) |
| // Set `SOL_SOCKET` -> `SO_NO_CHECK`. |
| SetNoCheck(ctx_ _bindings.Context, value bool) (BaseSocketSetNoCheckResult, error) |
| // Get `SOL_SOCKET` -> `SO_NO_CHECK`. |
| GetNoCheck(ctx_ _bindings.Context) (BaseSocketGetNoCheckResult, error) |
| // Set `SOL_SOCKET` -> `SO_LINGER`. |
| SetLinger(ctx_ _bindings.Context, linger bool, lengthSecs uint32) (BaseSocketSetLingerResult, error) |
| // Get `SOL_SOCKET` -> `SO_LINGER`. |
| GetLinger(ctx_ _bindings.Context) (BaseSocketGetLingerResult, error) |
| // Set `SOL_SOCKET` -> `SO_REUSEPORT`. |
| SetReusePort(ctx_ _bindings.Context, value bool) (BaseSocketSetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_REUSEPORT`. |
| GetReusePort(ctx_ _bindings.Context) (BaseSocketGetReusePortResult, error) |
| // Get `SOL_SOCKET` -> `SO_ACCEPTCONN`. |
| GetAcceptConn(ctx_ _bindings.Context) (BaseSocketGetAcceptConnResult, error) |
| // Set `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| SetBindToDevice(ctx_ _bindings.Context, value string) (BaseSocketSetBindToDeviceResult, error) |
| // Get `SOL_SOCKET` -> `SO_BINDTODEVICE`. |
| GetBindToDevice(ctx_ _bindings.Context) (BaseSocketGetBindToDeviceResult, error) |
| // Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| SetTimestamp(ctx_ _bindings.Context, value TimestampOption) (BaseSocketSetTimestampResult, error) |
| // Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`. |
| GetTimestamp(ctx_ _bindings.Context) (BaseSocketGetTimestampResult, error) |
| // Sets the local address used for the socket. |
| Bind(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketBindResult, error) |
| // Initiates a connection to a remote address. |
| Connect(ctx_ _bindings.Context, addr fuchsianet.SocketAddress) (BaseNetworkSocketConnectResult, error) |
| // Clears connection information from this socket. |
| Disconnect(ctx_ _bindings.Context) (BaseNetworkSocketDisconnectResult, error) |
| // Retrieves the local socket address. |
| GetSockName(ctx_ _bindings.Context) (BaseNetworkSocketGetSockNameResult, error) |
| // Retrieves the remote socket address. |
| GetPeerName(ctx_ _bindings.Context) (BaseNetworkSocketGetPeerNameResult, error) |
| // Shuts down part of the socket. |
| Shutdown(ctx_ _bindings.Context, mode ShutdownMode) (BaseNetworkSocketShutdownResult, error) |
| // Set `SOL_IP` -> `IP_TOS`. |
| SetIpTypeOfService(ctx_ _bindings.Context, value uint8) (BaseNetworkSocketSetIpTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_TOS`. |
| GetIpTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_TTL`. |
| SetIpTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpTtlResult, error) |
| // Get `SOL_IP` -> `IP_TTL`. |
| GetIpTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTtlResult, error) |
| // Set `SOL_IP` -> `IP_PKTINFO`. |
| SetIpPacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpPacketInfoResult, error) |
| // Get `SOL_IP` -> `IP_PKTINFO`. |
| GetIpPacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpPacketInfoResult, error) |
| // Set `SOL_IP` -> `IP_RECVTOS`. |
| SetIpReceiveTypeOfService(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTypeOfServiceResult, error) |
| // Get `SOL_IP` -> `IP_RECVTOS`. |
| GetIpReceiveTypeOfService(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTypeOfServiceResult, error) |
| // Set `SOL_IP` -> `IP_RECVTTL`. |
| SetIpReceiveTtl(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveTtlResult, error) |
| // Get `SOL_IP` -> `IP_RECVTTL`. |
| GetIpReceiveTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_IF`. |
| SetIpMulticastInterface(ctx_ _bindings.Context, iface uint64, address fuchsianet.Ipv4Address) (BaseNetworkSocketSetIpMulticastInterfaceResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_IF`. |
| GetIpMulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastInterfaceResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_TTL`. |
| SetIpMulticastTtl(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpMulticastTtlResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_TTL`. |
| GetIpMulticastTtl(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastTtlResult, error) |
| // Set `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| SetIpMulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpMulticastLoopbackResult, error) |
| // Get `SOL_IP` -> `IP_MULTICAST_LOOP`. |
| GetIpMulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpMulticastLoopbackResult, error) |
| // Set `SOL_IP` -> `IP_ADD_MEMBERSHIP` |
| AddIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketAddIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_DROP_MEMBERSHIP` |
| DropIpMembership(ctx_ _bindings.Context, membership IpMulticastMembership) (BaseNetworkSocketDropIpMembershipResult, error) |
| // Set `SOL_IP` -> `IP_TRANSPARENT` |
| SetIpTransparent(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpTransparentResult, error) |
| // Get `SOL_IP` -> `IP_TRANSPARENT` |
| GetIpTransparent(ctx_ _bindings.Context) (BaseNetworkSocketGetIpTransparentResult, error) |
| // Set `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| SetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, error) |
| // Get `SOL_IP` -> `IP_RECVORIGDSTADDR` |
| GetIpReceiveOriginalDestinationAddress(ctx_ _bindings.Context) (BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, error) |
| // Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`. |
| AddIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketAddIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`. |
| DropIpv6Membership(ctx_ _bindings.Context, membership Ipv6MulticastMembership) (BaseNetworkSocketDropIpv6MembershipResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| SetIpv6MulticastInterface(ctx_ _bindings.Context, value uint64) (BaseNetworkSocketSetIpv6MulticastInterfaceResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`. |
| GetIpv6MulticastInterface(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastInterfaceResult, error) |
| // Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| SetIpv6UnicastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6UnicastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`. |
| GetIpv6UnicastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6UnicastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| SetIpv6ReceiveHopLimit(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveHopLimitResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`. |
| GetIpv6ReceiveHopLimit(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveHopLimitResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| SetIpv6MulticastHops(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6MulticastHopsResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`. |
| GetIpv6MulticastHops(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastHopsResult, error) |
| // Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| SetIpv6MulticastLoopback(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6MulticastLoopbackResult, error) |
| // Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`. |
| GetIpv6MulticastLoopback(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6MulticastLoopbackResult, error) |
| // Set `SOL_IPV6` -> `IPV6_V6ONLY`. |
| SetIpv6Only(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6OnlyResult, error) |
| // Get `SOL_IPV6` -> `IPV6_V6ONLY`. |
| GetIpv6Only(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6OnlyResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| SetIpv6ReceiveTrafficClass(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVTCLASS`. |
| GetIpv6ReceiveTrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_TCLASS` |
| SetIpv6TrafficClass(ctx_ _bindings.Context, value OptionalUint8) (BaseNetworkSocketSetIpv6TrafficClassResult, error) |
| // Get `SOL_IPV6` -> `IPV6_TCLASS`. |
| GetIpv6TrafficClass(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6TrafficClassResult, error) |
| // Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| SetIpv6ReceivePacketInfo(ctx_ _bindings.Context, value bool) (BaseNetworkSocketSetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`. |
| GetIpv6ReceivePacketInfo(ctx_ _bindings.Context) (BaseNetworkSocketGetIpv6ReceivePacketInfoResult, error) |
| // Get `SOL_IP` -> `SO_ORIGINAL_DST`. |
| GetOriginalDestination(ctx_ _bindings.Context) (BaseNetworkSocketGetOriginalDestinationResult, error) |
| // Retrieves creation information from the socket. |
| // |
| // - response `domain` the socket's associated domain. |
| // - response `proto` the socket's associated protocol. |
| GetInfo(ctx_ _bindings.Context) (BaseDatagramSocketGetInfoResult, error) |
| Describe(ctx_ _bindings.Context) (SynchronousDatagramSocketDescribeResponse, error) |
| // Receives a message from the socket. |
| // |
| // + request `want_addr` request message's source address information to |
| // be returned. |
| // + request `data_len` the maximum allowed length of the response data |
| // buffer. |
| // + request `want_control` request ancillary data to be returned. |
| // + request `flags` flags for the receive request. |
| // - response `addr` the message's source address information, if |
| // requested. |
| // - response `data` the message. |
| // - response `control` control messages, if requested. |
| // - response `truncated` indicates whether or not the returned message |
| // was truncated. |
| RecvMsg(ctx_ _bindings.Context, wantAddr bool, dataLen uint32, wantControl bool, flags RecvMsgFlags) (SynchronousDatagramSocketRecvMsgResult, error) |
| // Sends a message on the socket. |
| // |
| // + request `addr` the address to send the message to. If unset, will send |
| // to the connected peer. |
| // + request `data` the message. |
| // + request `control` ancillary data. |
| // + request `flags` flags for the send request. |
| // - response `len` the number of bytes sent. |
| SendMsg(ctx_ _bindings.Context, addr *fuchsianet.SocketAddress, data []uint8, control DatagramSocketSendControlData, flags SendMsgFlags) (SynchronousDatagramSocketSendMsgResult, error) |
| } |
| |
| type SynchronousDatagramSocketWithCtxTransitionalBase struct{} |
| |
| type SynchronousDatagramSocketWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewSynchronousDatagramSocketWithCtxInterfaceRequest() (SynchronousDatagramSocketWithCtxInterfaceRequest, *SynchronousDatagramSocketWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return SynchronousDatagramSocketWithCtxInterfaceRequest(req), (*SynchronousDatagramSocketWithCtxInterface)(cli), err |
| } |
| |
| type SynchronousDatagramSocketWithCtxStub struct { |
| Impl SynchronousDatagramSocketWithCtx |
| } |
| |
| func (s_ *SynchronousDatagramSocketWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case SynchronousDatagramSocketClone2Ordinal: |
| in_ := &fuchsiaunknown.CloneableClone2Request{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.Clone2(args_.Ctx, (*in_).Request) |
| return nil, false, err_ |
| case SynchronousDatagramSocketCloseOrdinal: |
| payload, err_ := s_.Impl.Close(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketQueryOrdinal: |
| protocol, err_ := s_.Impl.Query(args_.Ctx) |
| out_ := &fuchsiaunknown.QueryableQueryResponse{Protocol: protocol} |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetReuseAddressOrdinal: |
| in_ := &BaseSocketSetReuseAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReuseAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetReuseAddressOrdinal: |
| payload, err_ := s_.Impl.GetReuseAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetErrorOrdinal: |
| payload, err_ := s_.Impl.GetError(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetBroadcastOrdinal: |
| in_ := &BaseSocketSetBroadcastRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBroadcast(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetBroadcastOrdinal: |
| payload, err_ := s_.Impl.GetBroadcast(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetSendBufferOrdinal: |
| in_ := &BaseSocketSetSendBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetSendBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetSendBufferOrdinal: |
| payload, err_ := s_.Impl.GetSendBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetReceiveBufferOrdinal: |
| in_ := &BaseSocketSetReceiveBufferRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReceiveBuffer(args_.Ctx, (*in_).ValueBytes) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetReceiveBufferOrdinal: |
| payload, err_ := s_.Impl.GetReceiveBuffer(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetKeepAliveOrdinal: |
| in_ := &BaseSocketSetKeepAliveRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetKeepAlive(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetKeepAliveOrdinal: |
| payload, err_ := s_.Impl.GetKeepAlive(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetOutOfBandInlineOrdinal: |
| in_ := &BaseSocketSetOutOfBandInlineRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetOutOfBandInline(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetOutOfBandInlineOrdinal: |
| payload, err_ := s_.Impl.GetOutOfBandInline(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetNoCheckOrdinal: |
| in_ := &BaseSocketSetNoCheckRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetNoCheck(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetNoCheckOrdinal: |
| payload, err_ := s_.Impl.GetNoCheck(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetLingerOrdinal: |
| in_ := &BaseSocketSetLingerRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetLinger(args_.Ctx, (*in_).Linger, (*in_).LengthSecs) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetLingerOrdinal: |
| payload, err_ := s_.Impl.GetLinger(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetReusePortOrdinal: |
| in_ := &BaseSocketSetReusePortRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetReusePort(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetReusePortOrdinal: |
| payload, err_ := s_.Impl.GetReusePort(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetAcceptConnOrdinal: |
| payload, err_ := s_.Impl.GetAcceptConn(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetBindToDeviceOrdinal: |
| in_ := &BaseSocketSetBindToDeviceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetBindToDevice(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetBindToDeviceOrdinal: |
| payload, err_ := s_.Impl.GetBindToDevice(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetTimestampOrdinal: |
| in_ := &BaseSocketSetTimestampRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetTimestamp(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetTimestampOrdinal: |
| payload, err_ := s_.Impl.GetTimestamp(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketBindOrdinal: |
| in_ := &BaseNetworkSocketBindRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Bind(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketConnectOrdinal: |
| in_ := &BaseNetworkSocketConnectRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Connect(args_.Ctx, (*in_).Addr) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketDisconnectOrdinal: |
| payload, err_ := s_.Impl.Disconnect(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetSockNameOrdinal: |
| payload, err_ := s_.Impl.GetSockName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetPeerNameOrdinal: |
| payload, err_ := s_.Impl.GetPeerName(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketShutdownOrdinal: |
| in_ := &BaseNetworkSocketShutdownRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.Shutdown(args_.Ctx, (*in_).Mode) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpPacketInfoOrdinal: |
| in_ := &BaseNetworkSocketSetIpPacketInfoRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpPacketInfo(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpPacketInfoOrdinal: |
| payload, err_ := s_.Impl.GetIpPacketInfo(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpReceiveTypeOfServiceOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTypeOfServiceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTypeOfService(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpReceiveTypeOfServiceOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTypeOfService(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpReceiveTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpReceiveTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpMulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastInterface(args_.Ctx, (*in_).Iface, (*in_).Address) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpMulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpMulticastTtlOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastTtlRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastTtl(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpMulticastTtlOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastTtl(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpMulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpMulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpMulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpMulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpMulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketAddIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketDropIpMembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpMembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpMembership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpTransparentOrdinal: |
| in_ := &BaseNetworkSocketSetIpTransparentRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpTransparent(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpTransparentOrdinal: |
| payload, err_ := s_.Impl.GetIpTransparent(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressOrdinal: |
| in_ := &BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpReceiveOriginalDestinationAddress(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressOrdinal: |
| payload, err_ := s_.Impl.GetIpReceiveOriginalDestinationAddress(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketAddIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketAddIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.AddIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketDropIpv6MembershipOrdinal: |
| in_ := &BaseNetworkSocketDropIpv6MembershipRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.DropIpv6Membership(args_.Ctx, (*in_).Membership) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpv6MulticastInterfaceOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastInterfaceRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastInterface(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpv6MulticastInterfaceOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastInterface(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpv6UnicastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6UnicastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6UnicastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpv6UnicastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6UnicastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpv6ReceiveHopLimitOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveHopLimitRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6ReceiveHopLimit(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpv6ReceiveHopLimitOrdinal: |
| payload, err_ := s_.Impl.GetIpv6ReceiveHopLimit(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpv6MulticastHopsOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastHopsRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastHops(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpv6MulticastHopsOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastHops(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpv6MulticastLoopbackOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6MulticastLoopbackRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6MulticastLoopback(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpv6MulticastLoopbackOrdinal: |
| payload, err_ := s_.Impl.GetIpv6MulticastLoopback(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpv6OnlyOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6OnlyRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| payload, err_ := s_.Impl.SetIpv6Only(args_.Ctx, (*in_).Value) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketGetIpv6OnlyOrdinal: |
| payload, err_ := s_.Impl.GetIpv6Only(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case SynchronousDatagramSocketSetIpv6ReceiveTrafficClassOrdinal: |
| in_ := &BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
|
