| // 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) { |
| 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) { |
| 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) { |
| 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 |