src/syscall/zx/net/impl.go

// 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.
//
// GENERATED FILE: Do not edit!
//
// To rebuild this file, invoke third_party/go/regen-fidl.

// +build fuchsia

package net

import (
	_zx "syscall/zx"
	_bindings "syscall/zx/fidl"
)

const (
	MaxAddr   uint64 = 128
	MaxBuffer uint64 = 900
)

type AddrInfoStatus uint32

const (
	AddrInfoStatusOk             AddrInfoStatus = 0
	AddrInfoStatusBadFlags       AddrInfoStatus = 1
	AddrInfoStatusNoName         AddrInfoStatus = 2
	AddrInfoStatusAgain          AddrInfoStatus = 3
	AddrInfoStatusFail           AddrInfoStatus = 4
	AddrInfoStatusNoData         AddrInfoStatus = 5
	AddrInfoStatusBufferOverflow AddrInfoStatus = 6
	AddrInfoStatusSystemError    AddrInfoStatus = 7
)

func (x AddrInfoStatus) String() string {
	switch x {
	case 0:
		return "Ok"
	case 1:
		return "BadFlags"
	case 2:
		return "NoName"
	case 3:
		return "Again"
	case 4:
		return "Fail"
	case 5:
		return "NoData"
	case 6:
		return "BufferOverflow"
	case 7:
		return "SystemError"
	}
	return "Unknown"
}

type IPv4Address struct {
	_    struct{} `fidl2:"s,4,1"`
	Addr [4]uint8
}

var _mIPv4Address = _bindings.CreateLazyMarshaler(IPv4Address{})

func (msg *IPv4Address) Marshaler() _bindings.Marshaler {
	return _mIPv4Address
}

// Implements Payload.
func (_ *IPv4Address) InlineAlignment() int {
	return 1
}

// Implements Payload.
func (_ *IPv4Address) InlineSize() int {
	return 4
}

type IPv6Address struct {
	_    struct{} `fidl2:"s,16,1"`
	Addr [16]uint8
}

var _mIPv6Address = _bindings.CreateLazyMarshaler(IPv6Address{})

func (msg *IPv6Address) Marshaler() _bindings.Marshaler {
	return _mIPv6Address
}

// Implements Payload.
func (_ *IPv6Address) InlineAlignment() int {
	return 1
}

// Implements Payload.
func (_ *IPv6Address) InlineSize() int {
	return 16
}

type Subnet struct {
	_         struct{} `fidl2:"s,24,4"`
	Addr      IpAddress
	PrefixLen uint8
}

var _mSubnet = _bindings.CreateLazyMarshaler(Subnet{})

func (msg *Subnet) Marshaler() _bindings.Marshaler {
	return _mSubnet
}

// Implements Payload.
func (_ *Subnet) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *Subnet) InlineSize() int {
	return 24
}

type MacAddress struct {
	_      struct{} `fidl2:"s,6,1"`
	Octets [6]uint8
}

var _mMacAddress = _bindings.CreateLazyMarshaler(MacAddress{})

func (msg *MacAddress) Marshaler() _bindings.Marshaler {
	return _mMacAddress
}

// Implements Payload.
func (_ *MacAddress) InlineAlignment() int {
	return 1
}

// Implements Payload.
func (_ *MacAddress) InlineSize() int {
	return 6
}

type AddrInfoHints struct {
	_        struct{} `fidl2:"s,16,4"`
	Flags    int32
	Family   int32
	SockType int32
	Protocol int32
}

var _mAddrInfoHints = _bindings.CreateLazyMarshaler(AddrInfoHints{})

func (msg *AddrInfoHints) Marshaler() _bindings.Marshaler {
	return _mAddrInfoHints
}

// Implements Payload.
func (_ *AddrInfoHints) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *AddrInfoHints) InlineSize() int {
	return 16
}

type AddrStorage struct {
	_   struct{} `fidl2:"s,20,4"`
	Val [16]uint8
	Len uint32
}

var _mAddrStorage = _bindings.CreateLazyMarshaler(AddrStorage{})

func (msg *AddrStorage) Marshaler() _bindings.Marshaler {
	return _mAddrStorage
}

// Implements Payload.
func (_ *AddrStorage) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *AddrStorage) InlineSize() int {
	return 20
}

type AddrInfo struct {
	_        struct{} `fidl2:"s,40,4"`
	Flags    int32
	Family   int32
	SockType int32
	Protocol int32
	Addr     AddrStorage
	Port     uint16
}

var _mAddrInfo = _bindings.CreateLazyMarshaler(AddrInfo{})

func (msg *AddrInfo) Marshaler() _bindings.Marshaler {
	return _mAddrInfo
}

// Implements Payload.
func (_ *AddrInfo) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *AddrInfo) InlineSize() int {
	return 40
}

type IpAddressTag uint32

const (
	_ IpAddressTag = iota
	IpAddressIpv4
	IpAddressIpv6
)

type IpAddress struct {
	IpAddressTag `fidl:"tag" fidl2:"u,20,4"`
	Ipv4         IPv4Address
	Ipv6         IPv6Address
}

// Implements Payload.
func (_ *IpAddress) InlineAlignment() int {
	return 4
}

// Implements Payload.
func (_ *IpAddress) InlineSize() int {
	return 20
}

func (u *IpAddress) Which() IpAddressTag {
	return u.IpAddressTag
}

func (u *IpAddress) SetIpv4(ipv4 IPv4Address) {
	u.IpAddressTag = IpAddressIpv4
	u.Ipv4 = ipv4
}

func (u *IpAddress) SetIpv6(ipv6 IPv6Address) {
	u.IpAddressTag = IpAddressIpv6
	u.Ipv6 = ipv6
}

const (
	ConnectivityOnNetworkReachableOrdinal    uint32 = 1703348424
	ConnectivityOnNetworkReachableGenOrdinal uint32 = 1703348424
)

type connectivityOnNetworkReachableResponse struct {
	_         struct{} `fidl2:"s,8,0"`
	Reachable bool
}

var _mconnectivityOnNetworkReachableResponse = _bindings.CreateLazyMarshaler(connectivityOnNetworkReachableResponse{})

func (msg *connectivityOnNetworkReachableResponse) Marshaler() _bindings.Marshaler {
	return _mconnectivityOnNetworkReachableResponse
}

// Implements Payload.
func (_ *connectivityOnNetworkReachableResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *connectivityOnNetworkReachableResponse) InlineSize() int {
	return 8
}

type ConnectivityInterface _bindings.ChannelProxy

func (p *ConnectivityInterface) ExpectOnNetworkReachable() (bool, error) {
	resp_ := &connectivityOnNetworkReachableResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Recv(ConnectivityOnNetworkReachableOrdinal, resp_)
	return resp_.Reachable, err
}

type Connectivity interface {
}

type ConnectivityTransitionalBase struct{}

type ConnectivityInterfaceRequest _bindings.InterfaceRequest

func NewConnectivityInterfaceRequest() (ConnectivityInterfaceRequest, *ConnectivityInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return ConnectivityInterfaceRequest(req), (*ConnectivityInterface)(cli), err
}

// Implements ServiceRequest.
func (_ ConnectivityInterfaceRequest) Name() string {
	return "fuchsia.net.Connectivity"
}
func (c ConnectivityInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const ConnectivityName = "fuchsia.net.Connectivity"

type ConnectivityStub struct {
	Impl Connectivity
}

func (s *ConnectivityStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	return s.DispatchNew(ord, b_, h_)
}

func (s *ConnectivityStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) {
	switch ord {
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type ConnectivityService struct {
	_bindings.BindingSet
}

func (s *ConnectivityService) Add(impl Connectivity, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&ConnectivityStub{Impl: impl}, c, onError)
}

func (s *ConnectivityService) EventProxyFor(key _bindings.BindingKey) (*ConnectivityEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*ConnectivityEventProxy)(pxy), err
}

type ConnectivityEventProxy _bindings.ChannelProxy

func (p *ConnectivityEventProxy) OnNetworkReachable(reachable bool) error {
	event_ := &connectivityOnNetworkReachableResponse{
		Reachable: reachable,
	}
	return ((*_bindings.ChannelProxy)(p)).Send(ConnectivityOnNetworkReachableOrdinal, event_)
}

const (
	SocketProviderSocketOrdinal         uint32 = 316444173
	SocketProviderSocketGenOrdinal      uint32 = 316444173
	SocketProviderGetAddrInfoOrdinal    uint32 = 498796293
	SocketProviderGetAddrInfoGenOrdinal uint32 = 498796293
)

type socketProviderSocketRequest struct {
	_        struct{} `fidl2:"s,8,0"`
	Domain   int16
	Type     int16
	Protocol int16
}

var _msocketProviderSocketRequest = _bindings.CreateLazyMarshaler(socketProviderSocketRequest{})

func (msg *socketProviderSocketRequest) Marshaler() _bindings.Marshaler {
	return _msocketProviderSocketRequest
}

// Implements Payload.
func (_ *socketProviderSocketRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketProviderSocketRequest) InlineSize() int {
	return 8
}

type socketProviderSocketResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
	S    _zx.Socket `fidl:"*" fidl2:"1"`
}

var _msocketProviderSocketResponse = _bindings.CreateLazyMarshaler(socketProviderSocketResponse{})

func (msg *socketProviderSocketResponse) Marshaler() _bindings.Marshaler {
	return _msocketProviderSocketResponse
}

// Implements Payload.
func (_ *socketProviderSocketResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketProviderSocketResponse) InlineSize() int {
	return 8
}

type socketProviderGetAddrInfoRequest struct {
	_       struct{} `fidl2:"s,40,0"`
	Node    *string  `fidl:"256" fidl2:"256"`
	Service *string  `fidl:"256" fidl2:"256"`
	Hints   *AddrInfoHints
}

var _msocketProviderGetAddrInfoRequest = _bindings.CreateLazyMarshaler(socketProviderGetAddrInfoRequest{})

func (msg *socketProviderGetAddrInfoRequest) Marshaler() _bindings.Marshaler {
	return _msocketProviderGetAddrInfoRequest
}

// Implements Payload.
func (_ *socketProviderGetAddrInfoRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketProviderGetAddrInfoRequest) InlineSize() int {
	return 40
}

type socketProviderGetAddrInfoResponse struct {
	_      struct{} `fidl2:"s,168,0"`
	Status AddrInfoStatus
	Nres   uint32
	Res    [4]AddrInfo
}

var _msocketProviderGetAddrInfoResponse = _bindings.CreateLazyMarshaler(socketProviderGetAddrInfoResponse{})

func (msg *socketProviderGetAddrInfoResponse) Marshaler() _bindings.Marshaler {
	return _msocketProviderGetAddrInfoResponse
}

// Implements Payload.
func (_ *socketProviderGetAddrInfoResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketProviderGetAddrInfoResponse) InlineSize() int {
	return 168
}

type SocketProviderInterface _bindings.ChannelProxy

func (p *SocketProviderInterface) Socket(domain int16, type_ int16, protocol int16) (int16, _zx.Socket, error) {
	req_ := &socketProviderSocketRequest{
		Domain:   domain,
		Type:     type_,
		Protocol: protocol,
	}
	resp_ := &socketProviderSocketResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(SocketProviderSocketOrdinal, req_, resp_)
	return resp_.Code, resp_.S, err
}

func (p *SocketProviderInterface) GetAddrInfo(node *string, service *string, hints *AddrInfoHints) (AddrInfoStatus, uint32, [4]AddrInfo, error) {
	req_ := &socketProviderGetAddrInfoRequest{
		Node:    node,
		Service: service,
		Hints:   hints,
	}
	resp_ := &socketProviderGetAddrInfoResponse{}
	err := ((*_bindings.ChannelProxy)(p)).Call(SocketProviderGetAddrInfoOrdinal, req_, resp_)
	return resp_.Status, resp_.Nres, resp_.Res, err
}

// POSIX, as much as possible. |code| values are defined in errno.h.
type SocketProvider interface {
	Socket(domain int16, type_ int16, protocol int16) (int16, _zx.Socket, error)
	GetAddrInfo(node *string, service *string, hints *AddrInfoHints) (AddrInfoStatus, uint32, [4]AddrInfo, error)
}

type SocketProviderTransitionalBase struct{}

type SocketProviderInterfaceRequest _bindings.InterfaceRequest

func NewSocketProviderInterfaceRequest() (SocketProviderInterfaceRequest, *SocketProviderInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return SocketProviderInterfaceRequest(req), (*SocketProviderInterface)(cli), err
}

// Implements ServiceRequest.
func (_ SocketProviderInterfaceRequest) Name() string {
	return "fuchsia.net.SocketProvider"
}
func (c SocketProviderInterfaceRequest) ToChannel() _zx.Channel {
	return c.Channel
}

const SocketProviderName = "fuchsia.net.SocketProvider"

type SocketProviderStub struct {
	Impl SocketProvider
}

func (s *SocketProviderStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	return s.DispatchNew(ord, b_, h_)
}

func (s *SocketProviderStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) {
	switch ord {
	case SocketProviderSocketOrdinal:
		in_ := socketProviderSocketRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, s, err_ := s.Impl.Socket(in_.Domain, in_.Type, in_.Protocol)
		out_ := socketProviderSocketResponse{}
		out_.Code = code
		out_.S = s
		return &out_, err_
	case SocketProviderGetAddrInfoOrdinal:
		in_ := socketProviderGetAddrInfoRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		status, nres, res, err_ := s.Impl.GetAddrInfo(in_.Node, in_.Service, in_.Hints)
		out_ := socketProviderGetAddrInfoResponse{}
		out_.Status = status
		out_.Nres = nres
		out_.Res = res
		return &out_, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type SocketProviderService struct {
	_bindings.BindingSet
}

func (s *SocketProviderService) Add(impl SocketProvider, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&SocketProviderStub{Impl: impl}, c, onError)
}

func (s *SocketProviderService) EventProxyFor(key _bindings.BindingKey) (*SocketProviderEventProxy, bool) {
	pxy, err := s.BindingSet.ProxyFor(key)
	return (*SocketProviderEventProxy)(pxy), err
}

type SocketProviderEventProxy _bindings.ChannelProxy

const (
	SocketControlCloseOrdinal          uint32 = 506040350
	SocketControlCloseGenOrdinal       uint32 = 506040350
	SocketControlIoctlOrdinal          uint32 = 1157859964
	SocketControlIoctlGenOrdinal       uint32 = 1157859964
	SocketControlConnectOrdinal        uint32 = 345505709
	SocketControlConnectGenOrdinal     uint32 = 345505709
	SocketControlAcceptOrdinal         uint32 = 796734679
	SocketControlAcceptGenOrdinal      uint32 = 796734679
	SocketControlBindOrdinal           uint32 = 2092731140
	SocketControlBindGenOrdinal        uint32 = 2092731140
	SocketControlListenOrdinal         uint32 = 1117818704
	SocketControlListenGenOrdinal      uint32 = 1117818704
	SocketControlGetSockNameOrdinal    uint32 = 764939941
	SocketControlGetSockNameGenOrdinal uint32 = 764939941
	SocketControlGetPeerNameOrdinal    uint32 = 472396488
	SocketControlGetPeerNameGenOrdinal uint32 = 472396488
	SocketControlSetSockOptOrdinal     uint32 = 1365685084
	SocketControlSetSockOptGenOrdinal  uint32 = 1365685084
	SocketControlGetSockOptOrdinal     uint32 = 2132650507
	SocketControlGetSockOptGenOrdinal  uint32 = 2132650507
)

type socketControlCloseResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _msocketControlCloseResponse = _bindings.CreateLazyMarshaler(socketControlCloseResponse{})

func (msg *socketControlCloseResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlCloseResponse
}

// Implements Payload.
func (_ *socketControlCloseResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlCloseResponse) InlineSize() int {
	return 8
}

type socketControlIoctlRequest struct {
	_   struct{} `fidl2:"s,24,0"`
	Req int16
	In  []uint8 `fidl:"900" fidl2:"900"`
}

var _msocketControlIoctlRequest = _bindings.CreateLazyMarshaler(socketControlIoctlRequest{})

func (msg *socketControlIoctlRequest) Marshaler() _bindings.Marshaler {
	return _msocketControlIoctlRequest
}

// Implements Payload.
func (_ *socketControlIoctlRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlIoctlRequest) InlineSize() int {
	return 24
}

type socketControlIoctlResponse struct {
	_    struct{} `fidl2:"s,24,0"`
	Code int16
	Out  []uint8 `fidl:"900" fidl2:"900"`
}

var _msocketControlIoctlResponse = _bindings.CreateLazyMarshaler(socketControlIoctlResponse{})

func (msg *socketControlIoctlResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlIoctlResponse
}

// Implements Payload.
func (_ *socketControlIoctlResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlIoctlResponse) InlineSize() int {
	return 24
}

type socketControlConnectRequest struct {
	_    struct{} `fidl2:"s,16,0"`
	Addr []uint8  `fidl:"128" fidl2:"128"`
}

var _msocketControlConnectRequest = _bindings.CreateLazyMarshaler(socketControlConnectRequest{})

func (msg *socketControlConnectRequest) Marshaler() _bindings.Marshaler {
	return _msocketControlConnectRequest
}

// Implements Payload.
func (_ *socketControlConnectRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlConnectRequest) InlineSize() int {
	return 16
}

type socketControlConnectResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _msocketControlConnectResponse = _bindings.CreateLazyMarshaler(socketControlConnectResponse{})

func (msg *socketControlConnectResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlConnectResponse
}

// Implements Payload.
func (_ *socketControlConnectResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlConnectResponse) InlineSize() int {
	return 8
}

type socketControlAcceptRequest struct {
	_     struct{} `fidl2:"s,8,0"`
	Flags int16
}

var _msocketControlAcceptRequest = _bindings.CreateLazyMarshaler(socketControlAcceptRequest{})

func (msg *socketControlAcceptRequest) Marshaler() _bindings.Marshaler {
	return _msocketControlAcceptRequest
}

// Implements Payload.
func (_ *socketControlAcceptRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlAcceptRequest) InlineSize() int {
	return 8
}

type socketControlAcceptResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _msocketControlAcceptResponse = _bindings.CreateLazyMarshaler(socketControlAcceptResponse{})

func (msg *socketControlAcceptResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlAcceptResponse
}

// Implements Payload.
func (_ *socketControlAcceptResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlAcceptResponse) InlineSize() int {
	return 8
}

type socketControlBindRequest struct {
	_    struct{} `fidl2:"s,16,0"`
	Addr []uint8  `fidl:"128" fidl2:"128"`
}

var _msocketControlBindRequest = _bindings.CreateLazyMarshaler(socketControlBindRequest{})

func (msg *socketControlBindRequest) Marshaler() _bindings.Marshaler {
	return _msocketControlBindRequest
}

// Implements Payload.
func (_ *socketControlBindRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlBindRequest) InlineSize() int {
	return 16
}

type socketControlBindResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _msocketControlBindResponse = _bindings.CreateLazyMarshaler(socketControlBindResponse{})

func (msg *socketControlBindResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlBindResponse
}

// Implements Payload.
func (_ *socketControlBindResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlBindResponse) InlineSize() int {
	return 8
}

type socketControlListenRequest struct {
	_       struct{} `fidl2:"s,8,0"`
	Backlog int16
}

var _msocketControlListenRequest = _bindings.CreateLazyMarshaler(socketControlListenRequest{})

func (msg *socketControlListenRequest) Marshaler() _bindings.Marshaler {
	return _msocketControlListenRequest
}

// Implements Payload.
func (_ *socketControlListenRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlListenRequest) InlineSize() int {
	return 8
}

type socketControlListenResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _msocketControlListenResponse = _bindings.CreateLazyMarshaler(socketControlListenResponse{})

func (msg *socketControlListenResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlListenResponse
}

// Implements Payload.
func (_ *socketControlListenResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlListenResponse) InlineSize() int {
	return 8
}

type socketControlGetSockNameResponse struct {
	_    struct{} `fidl2:"s,24,0"`
	Code int16
	Addr []uint8 `fidl:"128" fidl2:"128"`
}

var _msocketControlGetSockNameResponse = _bindings.CreateLazyMarshaler(socketControlGetSockNameResponse{})

func (msg *socketControlGetSockNameResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlGetSockNameResponse
}

// Implements Payload.
func (_ *socketControlGetSockNameResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlGetSockNameResponse) InlineSize() int {
	return 24
}

type socketControlGetPeerNameResponse struct {
	_    struct{} `fidl2:"s,24,0"`
	Code int16
	Addr []uint8 `fidl:"128" fidl2:"128"`
}

var _msocketControlGetPeerNameResponse = _bindings.CreateLazyMarshaler(socketControlGetPeerNameResponse{})

func (msg *socketControlGetPeerNameResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlGetPeerNameResponse
}

// Implements Payload.
func (_ *socketControlGetPeerNameResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlGetPeerNameResponse) InlineSize() int {
	return 24
}

type socketControlSetSockOptRequest struct {
	_       struct{} `fidl2:"s,24,0"`
	Level   int16
	Optname int16
	Optval  []uint8 `fidl:"900" fidl2:"900"`
}

var _msocketControlSetSockOptRequest = _bindings.CreateLazyMarshaler(socketControlSetSockOptRequest{})

func (msg *socketControlSetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _msocketControlSetSockOptRequest
}

// Implements Payload.
func (_ *socketControlSetSockOptRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlSetSockOptRequest) InlineSize() int {
	return 24
}

type socketControlSetSockOptResponse struct {
	_    struct{} `fidl2:"s,8,0"`
	Code int16
}

var _msocketControlSetSockOptResponse = _bindings.CreateLazyMarshaler(socketControlSetSockOptResponse{})

func (msg *socketControlSetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlSetSockOptResponse
}

// Implements Payload.
func (_ *socketControlSetSockOptResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlSetSockOptResponse) InlineSize() int {
	return 8
}

type socketControlGetSockOptRequest struct {
	_       struct{} `fidl2:"s,8,0"`
	Level   int16
	Optname int16
}

var _msocketControlGetSockOptRequest = _bindings.CreateLazyMarshaler(socketControlGetSockOptRequest{})

func (msg *socketControlGetSockOptRequest) Marshaler() _bindings.Marshaler {
	return _msocketControlGetSockOptRequest
}

// Implements Payload.
func (_ *socketControlGetSockOptRequest) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlGetSockOptRequest) InlineSize() int {
	return 8
}

type socketControlGetSockOptResponse struct {
	_      struct{} `fidl2:"s,24,0"`
	Code   int16
	Optval []uint8 `fidl:"900" fidl2:"900"`
}

var _msocketControlGetSockOptResponse = _bindings.CreateLazyMarshaler(socketControlGetSockOptResponse{})

func (msg *socketControlGetSockOptResponse) Marshaler() _bindings.Marshaler {
	return _msocketControlGetSockOptResponse
}

// Implements Payload.
func (_ *socketControlGetSockOptResponse) InlineAlignment() int {
	return 0
}

// Implements Payload.
func (_ *socketControlGetSockOptResponse) InlineSize() int {
	return 24
}

type SocketControlInterface _bindings.SocketControlProxy

func (p *SocketControlInterface) Close() (int16, error) {
	var req_ _bindings.Payload
	resp_ := &socketControlCloseResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlCloseOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) Ioctl(req int16, in []uint8) (int16, []uint8, error) {
	req_ := &socketControlIoctlRequest{
		Req: req,
		In:  in,
	}
	resp_ := &socketControlIoctlResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlIoctlOrdinal, req_, resp_)
	return resp_.Code, resp_.Out, err
}

func (p *SocketControlInterface) Connect(addr []uint8) (int16, error) {
	req_ := &socketControlConnectRequest{
		Addr: addr,
	}
	resp_ := &socketControlConnectResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlConnectOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) Accept(flags int16) (int16, error) {
	req_ := &socketControlAcceptRequest{
		Flags: flags,
	}
	resp_ := &socketControlAcceptResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlAcceptOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) Bind(addr []uint8) (int16, error) {
	req_ := &socketControlBindRequest{
		Addr: addr,
	}
	resp_ := &socketControlBindResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlBindOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) Listen(backlog int16) (int16, error) {
	req_ := &socketControlListenRequest{
		Backlog: backlog,
	}
	resp_ := &socketControlListenResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlListenOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) GetSockName() (int16, []uint8, error) {
	var req_ _bindings.Payload
	resp_ := &socketControlGetSockNameResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlGetSockNameOrdinal, req_, resp_)
	return resp_.Code, resp_.Addr, err
}

func (p *SocketControlInterface) GetPeerName() (int16, []uint8, error) {
	var req_ _bindings.Payload
	resp_ := &socketControlGetPeerNameResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlGetPeerNameOrdinal, req_, resp_)
	return resp_.Code, resp_.Addr, err
}

func (p *SocketControlInterface) SetSockOpt(level int16, optname int16, optval []uint8) (int16, error) {
	req_ := &socketControlSetSockOptRequest{
		Level:   level,
		Optname: optname,
		Optval:  optval,
	}
	resp_ := &socketControlSetSockOptResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlSetSockOptOrdinal, req_, resp_)
	return resp_.Code, err
}

func (p *SocketControlInterface) GetSockOpt(level int16, optname int16) (int16, []uint8, error) {
	req_ := &socketControlGetSockOptRequest{
		Level:   level,
		Optname: optname,
	}
	resp_ := &socketControlGetSockOptResponse{}
	err := ((*_bindings.SocketControlProxy)(p)).Call(SocketControlGetSockOptOrdinal, req_, resp_)
	return resp_.Code, resp_.Optval, err
}

type SocketControl interface {
	Close() (int16, error)
	Ioctl(req int16, in []uint8) (int16, []uint8, error)
	Connect(addr []uint8) (int16, error)
	Accept(flags int16) (int16, error)
	Bind(addr []uint8) (int16, error)
	Listen(backlog int16) (int16, error)
	GetSockName() (int16, []uint8, error)
	GetPeerName() (int16, []uint8, error)
	SetSockOpt(level int16, optname int16, optval []uint8) (int16, error)
	GetSockOpt(level int16, optname int16) (int16, []uint8, error)
}

type SocketControlTransitionalBase struct{}

type SocketControlStub struct {
	Impl SocketControl
}

func (s *SocketControlStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	return s.DispatchNew(ord, b_, h_)
}

func (s *SocketControlStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) {
	switch ord {
	case SocketControlCloseOrdinal:
		code, err_ := s.Impl.Close()
		out_ := socketControlCloseResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlIoctlOrdinal:
		in_ := socketControlIoctlRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, out, err_ := s.Impl.Ioctl(in_.Req, in_.In)
		out_ := socketControlIoctlResponse{}
		out_.Code = code
		out_.Out = out
		return &out_, err_
	case SocketControlConnectOrdinal:
		in_ := socketControlConnectRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.Connect(in_.Addr)
		out_ := socketControlConnectResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlAcceptOrdinal:
		in_ := socketControlAcceptRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.Accept(in_.Flags)
		out_ := socketControlAcceptResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlBindOrdinal:
		in_ := socketControlBindRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.Bind(in_.Addr)
		out_ := socketControlBindResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlListenOrdinal:
		in_ := socketControlListenRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.Listen(in_.Backlog)
		out_ := socketControlListenResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlGetSockNameOrdinal:
		code, addr, err_ := s.Impl.GetSockName()
		out_ := socketControlGetSockNameResponse{}
		out_.Code = code
		out_.Addr = addr
		return &out_, err_
	case SocketControlGetPeerNameOrdinal:
		code, addr, err_ := s.Impl.GetPeerName()
		out_ := socketControlGetPeerNameResponse{}
		out_.Code = code
		out_.Addr = addr
		return &out_, err_
	case SocketControlSetSockOptOrdinal:
		in_ := socketControlSetSockOptRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, err_ := s.Impl.SetSockOpt(in_.Level, in_.Optname, in_.Optval)
		out_ := socketControlSetSockOptResponse{}
		out_.Code = code
		return &out_, err_
	case SocketControlGetSockOptOrdinal:
		in_ := socketControlGetSockOptRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		code, optval, err_ := s.Impl.GetSockOpt(in_.Level, in_.Optname)
		out_ := socketControlGetSockOptResponse{}
		out_.Code = code
		out_.Optval = optval
		return &out_, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type SocketControlEventProxy _bindings.SocketControlProxy