// 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.
//
// WARNING: This file is machine generated by fidlgen.

// +build fuchsia

package net

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

type SocketDomain uint32

const (
	SocketDomainInet  SocketDomain = 2
	SocketDomainInet6 SocketDomain = 10
)

func (x SocketDomain) String() string {
	switch x {
	case 2:
		return "Inet"
	case 10:
		return "Inet6"
	}
	return "Unknown"
}

type SocketType uint32

const (
	SocketTypeStream SocketType = 1
	SocketTypeDgram  SocketType = 2
)

func (x SocketType) String() string {
	switch x {
	case 1:
		return "Stream"
	case 2:
		return "Dgram"
	}
	return "Unknown"
}

type SocketProtocol uint32

const (
	SocketProtocolIp     SocketProtocol = 0
	SocketProtocolIcmp   SocketProtocol = 1
	SocketProtocolTcp    SocketProtocol = 6
	SocketProtocolUdp    SocketProtocol = 17
	SocketProtocolIpv6   SocketProtocol = 41
	SocketProtocolIcmpv6 SocketProtocol = 58
)

func (x SocketProtocol) String() string {
	switch x {
	case 0:
		return "Ip"
	case 1:
		return "Icmp"
	case 6:
		return "Tcp"
	case 17:
		return "Udp"
	case 41:
		return "Ipv6"
	case 58:
		return "Icmpv6"
	}
	return "Unknown"
}

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"`
	Addr [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 String struct {
	_   struct{} `fidl2:"s,260,4"`
	Val [256]uint8
	Len uint32
}

var _mString = _bindings.CreateLazyMarshaler(String{})

func (msg *String) Marshaler() _bindings.Marshaler {
	return _mString
}

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

// Implements Payload.
func (_ *String) InlineSize() int {
	return 260
}

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,24,4"`
	Val    [16]uint8
	Len    uint32
	Unused int32
}

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 24
}

type AddrInfo struct {
	_        struct{} `fidl2:"s,44,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 44
}

type IpAddressTag uint32

const (
	_ IpAddressTag = iota
	IpAddressIpv4
	IpAddressIpv6
)

// IpAddress is a FIDL union.
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 = 1
)

// Request for OnNetworkReachable.
// OnNetworkReachable has no request.
// Response for OnNetworkReachable.
type ConnectivityOnNetworkReachableResponse struct {
	_         struct{} `fidl2:"s,4,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 4
}

type ConnectivityInterface _bindings.Proxy

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

// Connectivity server interface.
type Connectivity interface {
}

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) {
	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.Proxy

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

const (
	LegacySocketProviderOpenSocketOrdinal  uint32 = 1
	LegacySocketProviderGetAddrInfoOrdinal uint32 = 2
)

// Request for OpenSocket.
type LegacySocketProviderOpenSocketRequest struct {
	_        struct{} `fidl2:"s,12,0"`
	Domain   SocketDomain
	Type     SocketType
	Protocol SocketProtocol
}

var _mLegacySocketProviderOpenSocketRequest = _bindings.CreateLazyMarshaler(LegacySocketProviderOpenSocketRequest{})

func (msg *LegacySocketProviderOpenSocketRequest) Marshaler() _bindings.Marshaler {
	return _mLegacySocketProviderOpenSocketRequest
}

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

// Implements Payload.
func (_ *LegacySocketProviderOpenSocketRequest) InlineSize() int {
	return 12
}

// Response for OpenSocket.
type LegacySocketProviderOpenSocketResponse struct {
	_      struct{}   `fidl2:"s,8,0"`
	S      _zx.Socket `fidl:"*" fidl2:"1"`
	Status int32
}

var _mLegacySocketProviderOpenSocketResponse = _bindings.CreateLazyMarshaler(LegacySocketProviderOpenSocketResponse{})

func (msg *LegacySocketProviderOpenSocketResponse) Marshaler() _bindings.Marshaler {
	return _mLegacySocketProviderOpenSocketResponse
}

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

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

// Request for GetAddrInfo.
type LegacySocketProviderGetAddrInfoRequest struct {
	_       struct{} `fidl2:"s,24,0"`
	Node    *String
	Service *String
	Hints   *AddrInfoHints
}

var _mLegacySocketProviderGetAddrInfoRequest = _bindings.CreateLazyMarshaler(LegacySocketProviderGetAddrInfoRequest{})

func (msg *LegacySocketProviderGetAddrInfoRequest) Marshaler() _bindings.Marshaler {
	return _mLegacySocketProviderGetAddrInfoRequest
}

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

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

// Response for GetAddrInfo.
type LegacySocketProviderGetAddrInfoResponse struct {
	_      struct{} `fidl2:"s,40,0"`
	Status AddrInfoStatus
	Nres   int32
	Ai0    *AddrInfo
	Ai1    *AddrInfo
	Ai2    *AddrInfo
	Ai3    *AddrInfo
}

var _mLegacySocketProviderGetAddrInfoResponse = _bindings.CreateLazyMarshaler(LegacySocketProviderGetAddrInfoResponse{})

func (msg *LegacySocketProviderGetAddrInfoResponse) Marshaler() _bindings.Marshaler {
	return _mLegacySocketProviderGetAddrInfoResponse
}

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

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

type LegacySocketProviderInterface _bindings.Proxy

func (p *LegacySocketProviderInterface) OpenSocket(domain SocketDomain, type_ SocketType, protocol SocketProtocol) (_zx.Socket, int32, error) {
	req_ := LegacySocketProviderOpenSocketRequest{
		Domain:   domain,
		Type:     type_,
		Protocol: protocol,
	}
	resp_ := LegacySocketProviderOpenSocketResponse{}
	err := ((*_bindings.Proxy)(p)).Call(LegacySocketProviderOpenSocketOrdinal, &req_, &resp_)
	return resp_.S, resp_.Status, err
}
func (p *LegacySocketProviderInterface) GetAddrInfo(node *String, service *String, hints *AddrInfoHints) (AddrInfoStatus, int32, *AddrInfo, *AddrInfo, *AddrInfo, *AddrInfo, error) {
	req_ := LegacySocketProviderGetAddrInfoRequest{
		Node:    node,
		Service: service,
		Hints:   hints,
	}
	resp_ := LegacySocketProviderGetAddrInfoResponse{}
	err := ((*_bindings.Proxy)(p)).Call(LegacySocketProviderGetAddrInfoOrdinal, &req_, &resp_)
	return resp_.Status, resp_.Nres, resp_.Ai0, resp_.Ai1, resp_.Ai2, resp_.Ai3, err
}

// LegacySocketProvider server interface.
type LegacySocketProvider interface {
	OpenSocket(domain SocketDomain, type_ SocketType, protocol SocketProtocol) (_zx.Socket, int32, error)
	GetAddrInfo(node *String, service *String, hints *AddrInfoHints) (AddrInfoStatus, int32, *AddrInfo, *AddrInfo, *AddrInfo, *AddrInfo, error)
}

type LegacySocketProviderInterfaceRequest _bindings.InterfaceRequest

func NewLegacySocketProviderInterfaceRequest() (LegacySocketProviderInterfaceRequest, *LegacySocketProviderInterface, error) {
	req, cli, err := _bindings.NewInterfaceRequest()
	return LegacySocketProviderInterfaceRequest(req), (*LegacySocketProviderInterface)(cli), err
}

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

const LegacySocketProviderName = "fuchsia.net.LegacySocketProvider"

type LegacySocketProviderStub struct {
	Impl LegacySocketProvider
}

func (s *LegacySocketProviderStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) {
	switch ord {
	case LegacySocketProviderOpenSocketOrdinal:
		in_ := LegacySocketProviderOpenSocketRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := LegacySocketProviderOpenSocketResponse{}
		s, status, err_ := s.Impl.OpenSocket(in_.Domain, in_.Type, in_.Protocol)
		out_.S = s
		out_.Status = status
		return &out_, err_
	case LegacySocketProviderGetAddrInfoOrdinal:
		in_ := LegacySocketProviderGetAddrInfoRequest{}
		if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil {
			return nil, err_
		}
		out_ := LegacySocketProviderGetAddrInfoResponse{}
		status, nres, ai0, ai1, ai2, ai3, err_ := s.Impl.GetAddrInfo(in_.Node, in_.Service, in_.Hints)
		out_.Status = status
		out_.Nres = nres
		out_.Ai0 = ai0
		out_.Ai1 = ai1
		out_.Ai2 = ai2
		out_.Ai3 = ai3
		return &out_, err_
	}
	return nil, _bindings.ErrUnknownOrdinal
}

type LegacySocketProviderService struct {
	_bindings.BindingSet
}

func (s *LegacySocketProviderService) Add(impl LegacySocketProvider, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) {
	return s.BindingSet.Add(&LegacySocketProviderStub{Impl: impl}, c, onError)
}

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

type LegacySocketProviderEventProxy _bindings.Proxy