[fidl] Add proxy support for SocketControl transport
This machinery will be used once we convert sockets to use FIDL for
their control channel.
Test: None
Change-Id: I66f3fc21630acc27c3a091d87e57ce7958d8e4ae
diff --git a/src/net/ipsock_fuchsia.go b/src/net/ipsock_fuchsia.go
index 5c28ffa..d91f14b 100644
--- a/src/net/ipsock_fuchsia.go
+++ b/src/net/ipsock_fuchsia.go
@@ -96,7 +96,7 @@
for i := 0; i < 40; i++ {
c := zx.Channel(getSocketProvider())
if c.Handle().IsValid() {
- sp := zxnet.LegacySocketProviderInterface(fidl.Proxy{Channel: c})
+ sp := zxnet.LegacySocketProviderInterface(fidl.ChannelProxy{Channel: c})
s, _, err := sp.OpenSocket(zxnet.SocketDomain(family), zxnet.SocketType(sotype), zxnet.SocketProtocol(proto))
if err == nil {
sock = zxsocket.NewSocket(s)
diff --git a/src/syscall/syscall_fuchsia.go b/src/syscall/syscall_fuchsia.go
index dc5c788..95eea14 100644
--- a/src/syscall/syscall_fuchsia.go
+++ b/src/syscall/syscall_fuchsia.go
@@ -385,7 +385,7 @@
case 0:
return nil, EINVAL
case fdio.HandleTypeRemote:
- obj := (*fidlIo.NodeInterface)(&fidl.Proxy{Channel: zx.Channel(zx.StdioHandles[i])})
+ obj := (*fidlIo.NodeInterface)(&fidl.ChannelProxy{Channel: zx.Channel(zx.StdioHandles[i])})
return &fdio.File{Node: fdio.Node{obj}}, nil
case fdio.HandleTypeSocket:
return fdio.NewPipe(zx.Socket(zx.StdioHandles[i])), nil
diff --git a/src/syscall/zx/fdio/client.go b/src/syscall/zx/fdio/client.go
index 5be3cad..362e512 100644
--- a/src/syscall/zx/fdio/client.go
+++ b/src/syscall/zx/fdio/client.go
@@ -23,7 +23,7 @@
return zx.Error{Status: zx.ErrInvalidArgs, Text: "fdio.ServiceConnectAt"}
}
// Open the path on the remote.
- iface := (*io.DirectoryInterface)(&fidl.Proxy{Channel: zx.Channel(dir)})
+ iface := (*io.DirectoryInterface)(&fidl.ChannelProxy{Channel: zx.Channel(dir)})
req := io.NodeInterfaceRequest(fidl.InterfaceRequest{Channel: zx.Channel(h)})
err := iface.Open(io.OpenRightReadable|io.OpenRightWritable, 0755, path, req)
if err != nil {
diff --git a/src/syscall/zx/fdio/directory.go b/src/syscall/zx/fdio/directory.go
index 0c7b991..02f6847 100644
--- a/src/syscall/zx/fdio/directory.go
+++ b/src/syscall/zx/fdio/directory.go
@@ -36,7 +36,7 @@
// Close closes the Directory object.
func (d *Directory) Close() error {
- defer ((*fidl.Proxy)(d.Node.NodeInterface)).Close()
+ defer ((*fidl.ChannelProxy)(d.Node.NodeInterface)).Close()
if status, err := d.Node.NodeInterface.Close(); err != nil {
return err
} else if status != zx.ErrOk {
@@ -54,15 +54,15 @@
}
err = d.DirectoryInterface().Open(flags|io.OpenFlagDescribe, mode, pathname, req)
if err != nil {
- ((*fidl.Proxy)(obj)).Close()
+ ((*fidl.ChannelProxy)(obj)).Close()
return nil, err
}
status, info, err := obj.ExpectOnOpen()
if err != nil {
- ((*fidl.Proxy)(obj)).Close()
+ ((*fidl.ChannelProxy)(obj)).Close()
return nil, err
} else if status != zx.ErrOk {
- ((*fidl.Proxy)(obj)).Close()
+ ((*fidl.ChannelProxy)(obj)).Close()
return nil, zx.Error{Status: status, Text: "io.directory"}
}
return nodeFromInfo(info, obj)
diff --git a/src/syscall/zx/fdio/mxc/mxc_cgo.go b/src/syscall/zx/fdio/mxc/mxc_cgo.go
index cc60ba6..994ad03 100644
--- a/src/syscall/zx/fdio/mxc/mxc_cgo.go
+++ b/src/syscall/zx/fdio/mxc/mxc_cgo.go
@@ -36,7 +36,7 @@
}
switch zx.HandleInfo(typesC[0]).Type() {
case fdio.HandleTypeRemote:
- node := (*io.NodeInterface)(&fidl.Proxy{Channel: zx.Channel(handles[0])})
+ node := (*io.NodeInterface)(&fidl.ChannelProxy{Channel: zx.Channel(handles[0])})
if len(handles) > 1 {
for _, h := range handles[1:] {
h.Close()
diff --git a/src/syscall/zx/fdio/namespace.go b/src/syscall/zx/fdio/namespace.go
index 164cc781..dd5589d 100644
--- a/src/syscall/zx/fdio/namespace.go
+++ b/src/syscall/zx/fdio/namespace.go
@@ -81,7 +81,7 @@
if vn.remote.IsValid() {
return nil, zx.Error{Status: zx.ErrAlreadyExists, Text: "fdio.OpenRoot"}
}
- obj := (*io.NodeInterface)(&fidl.Proxy{Channel: zx.Channel(h)})
+ obj := (*io.NodeInterface)(&fidl.ChannelProxy{Channel: zx.Channel(h)})
vn.remote = Directory{Node: Node{obj}}
}
return &dir{root}, nil
diff --git a/src/syscall/zx/fdio/node.go b/src/syscall/zx/fdio/node.go
index 261d378..152e343 100644
--- a/src/syscall/zx/fdio/node.go
+++ b/src/syscall/zx/fdio/node.go
@@ -14,7 +14,7 @@
func nodeFromInfo(info *io.NodeInfo, node *io.NodeInterface) (result FDIO, err error) {
if info == nil {
- if err = ((*fidl.Proxy)(node)).Channel.Close(); err != nil {
+ if err = ((*fidl.ChannelProxy)(node)).Channel.Close(); err != nil {
return nil, err
}
return nil, zx.Error{Status: zx.ErrNotSupported, Text: "io.node"}
@@ -36,12 +36,12 @@
case io.NodeInfoDirectory:
result = &Directory{Node: Node{NodeInterface: node}}
case io.NodeInfoPipe:
- if err = ((*fidl.Proxy)(node)).Channel.Close(); err != nil {
+ if err = ((*fidl.ChannelProxy)(node)).Channel.Close(); err != nil {
return nil, err
}
result = NewPipe(info.Pipe.Socket)
case io.NodeInfoVmofile:
- if err = ((*fidl.Proxy)(node)).Channel.Close(); err != nil {
+ if err = ((*fidl.ChannelProxy)(node)).Channel.Close(); err != nil {
return nil, err
}
result, err = NewVMOFile(info.Vmofile.Vmo, info.Vmofile.Offset, info.Vmofile.Length)
@@ -49,7 +49,7 @@
return nil, err
}
default:
- if err = ((*fidl.Proxy)(node)).Channel.Close(); err != nil {
+ if err = ((*fidl.ChannelProxy)(node)).Channel.Close(); err != nil {
return nil, err
}
return nil, zx.Error{Status: zx.ErrNotSupported, Text: "io.node"}
@@ -67,14 +67,14 @@
if n.NodeInterface == nil {
return false
}
- return ((*fidl.Proxy)(n.NodeInterface)).IsValid()
+ return ((*fidl.ChannelProxy)(n.NodeInterface)).IsValid()
}
// Handles returns a slice of untyped zx handles containing the underlying
// channel of the Node.
func (n *Node) Handles() []zx.Handle {
return []zx.Handle{
- zx.Handle(((*fidl.Proxy)(n.NodeInterface)).Channel),
+ zx.Handle(((*fidl.ChannelProxy)(n.NodeInterface)).Channel),
}
}
@@ -85,15 +85,15 @@
return nil, err
}
if err := n.NodeInterface.Clone(io.OpenFlagDescribe, req); err != nil {
- ((*fidl.Proxy)(newNode)).Close()
+ ((*fidl.ChannelProxy)(newNode)).Close()
return nil, err
}
status, info, err := newNode.ExpectOnOpen()
if err != nil {
- ((*fidl.Proxy)(newNode)).Close()
+ ((*fidl.ChannelProxy)(newNode)).Close()
return nil, err
} else if status != zx.ErrOk {
- ((*fidl.Proxy)(newNode)).Close()
+ ((*fidl.ChannelProxy)(newNode)).Close()
return nil, zx.Error{Status: status, Text: "io.node"}
}
return nodeFromInfo(info, newNode)
@@ -101,7 +101,7 @@
// Close closes the node.
func (n *Node) Close() error {
- defer ((*fidl.Proxy)(n.NodeInterface)).Close()
+ defer ((*fidl.ChannelProxy)(n.NodeInterface)).Close()
if status, err := n.NodeInterface.Close(); err != nil {
return err
} else if status != zx.ErrOk {
diff --git a/src/syscall/zx/fidl/bindings.go b/src/syscall/zx/fidl/bindings.go
index 2b2ef06..0231f51 100644
--- a/src/syscall/zx/fidl/bindings.go
+++ b/src/syscall/zx/fidl/bindings.go
@@ -256,11 +256,11 @@
// ProxyFor returns an event proxy created from the channel of the binding referred
// to by key.
-func (b *BindingSet) ProxyFor(key BindingKey) (*Proxy, bool) {
+func (b *BindingSet) ProxyFor(key BindingKey) (*ChannelProxy, bool) {
b.mu.Lock()
defer b.mu.Unlock()
if binding, ok := b.Bindings[key]; ok {
- return &Proxy{Channel: binding.Channel}, true
+ return &ChannelProxy{Channel: binding.Channel}, true
}
return nil, false
}
diff --git a/src/syscall/zx/fidl/bindingstest/impl.go b/src/syscall/zx/fidl/bindingstest/impl.go
index f723e21..263b493 100644
--- a/src/syscall/zx/fidl/bindingstest/impl.go
+++ b/src/syscall/zx/fidl/bindingstest/impl.go
@@ -1117,20 +1117,20 @@
return 16
}
-type Test1Interface _bindings.Proxy
+type Test1Interface _bindings.ChannelProxy
func (p *Test1Interface) Echo(in *string) (*string, error) {
req_ := Test1EchoRequest{
In: in,
}
resp_ := Test1EchoResponse{}
- err := ((*_bindings.Proxy)(p)).Call(Test1EchoOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(Test1EchoOrdinal, &req_, &resp_)
return resp_.Out, err
}
func (p *Test1Interface) ExpectSurprise() (string, error) {
resp_ := Test1SurpriseResponse{}
- err := ((*_bindings.Proxy)(p)).Recv(Test1SurpriseOrdinal, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Recv(Test1SurpriseOrdinal, &resp_)
return resp_.Foo, err
}
@@ -1177,11 +1177,11 @@
return (*Test1EventProxy)(pxy), err
}
-type Test1EventProxy _bindings.Proxy
+type Test1EventProxy _bindings.ChannelProxy
func (p *Test1EventProxy) Surprise(foo string) error {
event_ := Test1SurpriseResponse{
Foo: foo,
}
- return ((*_bindings.Proxy)(p)).Send(Test1SurpriseOrdinal, &event_)
+ return ((*_bindings.ChannelProxy)(p)).Send(Test1SurpriseOrdinal, &event_)
}
diff --git a/src/syscall/zx/fidl/encoding.go b/src/syscall/zx/fidl/encoding.go
index a548f19..108b167 100644
--- a/src/syscall/zx/fidl/encoding.go
+++ b/src/syscall/zx/fidl/encoding.go
@@ -38,7 +38,7 @@
socketType = reflect.TypeOf(zx.Socket(0))
vmarType = reflect.TypeOf(zx.VMAR(0))
interfaceRequestType = reflect.TypeOf(InterfaceRequest{})
- proxyType = reflect.TypeOf(Proxy{})
+ proxyType = reflect.TypeOf(ChannelProxy{})
)
type structKind int
diff --git a/src/syscall/zx/fidl/fidl_test/bindings_test.go b/src/syscall/zx/fidl/fidl_test/bindings_test.go
index 6489e9d..40bf0f4 100644
--- a/src/syscall/zx/fidl/fidl_test/bindings_test.go
+++ b/src/syscall/zx/fidl/fidl_test/bindings_test.go
@@ -73,7 +73,7 @@
if err != nil {
t.Fatal(err)
}
- client := Test1Interface(Proxy{Channel: ch})
+ client := Test1Interface(ChannelProxy{Channel: ch})
server := Test1Service{}
clientKey, err := server.Add(&Test1Impl{}, sh, nil)
if err != nil {
diff --git a/src/syscall/zx/fidl/fidl_test/encoding_new_test.go b/src/syscall/zx/fidl/fidl_test/encoding_new_test.go
index c404d61..13a3e21 100644
--- a/src/syscall/zx/fidl/fidl_test/encoding_new_test.go
+++ b/src/syscall/zx/fidl/fidl_test/encoding_new_test.go
@@ -200,8 +200,8 @@
// interfaces
{"interface1", &TestInterface1{
- A: Test1Interface(Proxy{Channel: h0}),
- B: Test1Interface(Proxy{Channel: zx.Channel(zx.HandleInvalid)}),
+ A: Test1Interface(ChannelProxy{Channel: h0}),
+ B: Test1Interface(ChannelProxy{Channel: zx.Channel(zx.HandleInvalid)}),
C: Test1InterfaceRequest(InterfaceRequest{Channel: h1}),
D: Test1InterfaceRequest(InterfaceRequest{
Channel: zx.Channel(zx.HandleInvalid),
diff --git a/src/syscall/zx/fidl/fidl_test/encoding_test.go b/src/syscall/zx/fidl/fidl_test/encoding_test.go
index c045bb5..d9f03e2 100644
--- a/src/syscall/zx/fidl/fidl_test/encoding_test.go
+++ b/src/syscall/zx/fidl/fidl_test/encoding_test.go
@@ -192,8 +192,8 @@
t.Fatalf("failed to create vmo: %v", err)
}
testIdentity(t, &TestInterface1{
- A: Test1Interface(Proxy{Channel: h0}),
- B: Test1Interface(Proxy{Channel: zx.Channel(zx.HandleInvalid)}),
+ A: Test1Interface(ChannelProxy{Channel: h0}),
+ B: Test1Interface(ChannelProxy{Channel: zx.Channel(zx.HandleInvalid)}),
C: Test1InterfaceRequest(InterfaceRequest{Channel: h1}),
D: Test1InterfaceRequest(InterfaceRequest{
Channel: zx.Channel(zx.HandleInvalid),
diff --git a/src/syscall/zx/fidl/interface.go b/src/syscall/zx/fidl/interface.go
index e46f959..a3d5814 100644
--- a/src/syscall/zx/fidl/interface.go
+++ b/src/syscall/zx/fidl/interface.go
@@ -31,29 +31,55 @@
// type casts out of the way to minimize the amount of generated code. Semantically,
// the two sides of the channel represent the interface request and the client
// side of the interface (the proxy). It returns an error on failure.
-func NewInterfaceRequest() (InterfaceRequest, *Proxy, error) {
+func NewInterfaceRequest() (InterfaceRequest, *ChannelProxy, error) {
h0, h1, err := zx.NewChannel(0)
if err != nil {
return InterfaceRequest{}, nil, err
}
- return InterfaceRequest{Channel: h0}, &Proxy{Channel: h1}, nil
+ return InterfaceRequest{Channel: h0}, &ChannelProxy{Channel: h1}, nil
}
// Proxy represents the client side of a FIDL interface.
-type Proxy struct {
+type Proxy interface {
+ IsValid() bool
+ Send(ordinal uint32, req Payload) error
+ Recv(ordinal uint32, resp Payload) error
+ Call(ordinal uint32, req Payload, resp Payload) error
+}
+
+// Stub represents a generated type which wraps the server-side implementation of a
+// FIDL interface.
+//
+// It contains logic which is able to dispatch into the correct implementation given
+// the incoming message ordinal and its data.
+type Stub interface {
+ // Dispatch dispatches into the appropriate method implementation for a FIDL
+ // interface by using the ordinal.
+ //
+ // It also takes the data as bytes and transforms it into arguments usable by
+ // the method implementation. It then optionally returns a response if the
+ // method has a response.
+ Dispatch(ordinal uint32, bytes []byte, handles []zx.Handle) (Payload, error)
+}
+
+// ChannelProxy a Proxy that is backed by a channel.
+type ChannelProxy struct {
// Channel is the underlying channel endpoint for this interface.
zx.Channel
}
+// Assert that ChannelProxy implements the Proxy interface.
+var _ Proxy = &ChannelProxy{}
+
// IsValid returns true if the underlying channel is a valid handle.
-func (p Proxy) IsValid() bool {
+func (p ChannelProxy) IsValid() bool {
h := zx.Handle(p.Channel)
return h.IsValid()
}
// Send sends the request payload over the channel with the specified ordinal
// without a response.
-func (p *Proxy) Send(ordinal uint32, req Payload) error {
+func (p *ChannelProxy) Send(ordinal uint32, req Payload) error {
respb := messageBytesPool.Get().([]byte)
resph := messageHandlesPool.Get().([]zx.Handle)
@@ -75,7 +101,7 @@
}
// Recv waits for an event and writes the response into the response payload.
-func (p *Proxy) Recv(ordinal uint32, resp Payload) error {
+func (p *ChannelProxy) Recv(ordinal uint32, resp Payload) error {
respb := messageBytesPool.Get().([]byte)
resph := messageHandlesPool.Get().([]zx.Handle)
@@ -115,7 +141,7 @@
// Call sends the request payload over the channel with the specified ordinal
// and synchronously waits for a response. It then writes the response into the
// response payload.
-func (p *Proxy) Call(ordinal uint32, req Payload, resp Payload) error {
+func (p *ChannelProxy) Call(ordinal uint32, req Payload, resp Payload) error {
respb := messageBytesPool.Get().([]byte)
resph := messageHandlesPool.Get().([]zx.Handle)
@@ -147,17 +173,88 @@
return nil
}
-// Stub represents a generated type which wraps the server-side implementation of a
-// FIDL interface.
-//
-// It contains logic which is able to dispatch into the correct implementation given
-// the incoming message ordinal and its data.
-type Stub interface {
- // Dispatch dispatches into the appropriate method implementation for a FIDL
- // interface by using the ordinal.
- //
- // It also takes the data as bytes and transforms it into arguments usable by
- // the method implementation. It then optionally returns a response if the
- // method has a response.
- Dispatch(ordinal uint32, bytes []byte, handles []zx.Handle) (Payload, error)
+// SocketControlProxy is a Proxy that is backed by the control plane of a socket.
+type SocketControlProxy struct {
+ // Socket is the underlying socket transport for this interface.
+ zx.Socket
+}
+
+// Assert that SocketControlProxy implements the Proxy interface.
+var _ Proxy = &SocketControlProxy{}
+
+// IsValid returns true if the underlying channel is a valid handle.
+func (p SocketControlProxy) IsValid() bool {
+ h := zx.Handle(p.Socket)
+ return h.IsValid()
+}
+
+// Send sends the request payload over the socket control plane with the
+// specified ordinal without a response.
+func (p *SocketControlProxy) Send(ordinal uint32, req Payload) error {
+ respb := messageBytesPool.Get().([]byte)
+
+ defer messageBytesPool.Put(respb)
+
+ // Marshal the message into the buffer.
+ header := MessageHeader{
+ Txid: 0, // Txid == 0 for messages without a response.
+ Ordinal: ordinal,
+ }
+ nb, _, err := MarshalMessage(&header, req, respb[:], nil)
+ if err != nil {
+ return err
+ }
+
+ // Write the encoded bytes to the socket control plane.
+ _, err = p.Socket.Write(respb[:nb], zx.SocketControl)
+ return err
+}
+
+// Recv waits for an event and writes the response into the response payload.
+func (p *SocketControlProxy) Recv(ordinal uint32, resp Payload) error {
+ respb := messageBytesPool.Get().([]byte)
+
+ defer messageBytesPool.Put(respb)
+
+ // Wait on the socket control plane to be readable or close.
+ h := zx.Handle(p.Socket)
+ sigs, err := zxwait.Wait(h,
+ zx.SignalSocketControlReadable|zx.SignalSocketPeerClosed,
+ zx.TimensecInfinite,
+ )
+ if err != nil {
+ return err
+ }
+ // If it is closed and not readable, let's just report that and stop here.
+ if (sigs&zx.SignalSocketPeerClosed) != 0 && (sigs&zx.SignalSocketControlReadable) == 0 {
+ return &zx.Error{Status: zx.ErrPeerClosed}
+ }
+ // Otherwise, now we can read!
+ nb, err := p.Socket.Read(respb[:], zx.SocketControl)
+ if err != nil {
+ return err
+ }
+
+ // Unmarshal the message.
+ var header MessageHeader
+ if err := UnmarshalMessage(respb[:nb], nil, &header, resp); err != nil {
+ return err
+ }
+ if header.Ordinal != ordinal {
+ return newExpectError(ErrUnexpectedOrdinal, ordinal, header.Ordinal)
+ }
+ return nil
+}
+
+// Call sends the request payload over the socket control plane with the specified
+// ordinal and waits for a response. It then writes the response into the response
+// payload.
+func (p *SocketControlProxy) Call(ordinal uint32, req Payload, resp Payload) error {
+ if err := p.Send(ordinal, req); err != nil {
+ return err
+ }
+ if err := p.Recv(ordinal, resp); err != nil {
+ return err
+ }
+ return nil
}
diff --git a/src/syscall/zx/io/impl.go b/src/syscall/zx/io/impl.go
index 3725082..a6335df 100644
--- a/src/syscall/zx/io/impl.go
+++ b/src/syscall/zx/io/impl.go
@@ -671,48 +671,48 @@
return 40
}
-type NodeInterface _bindings.Proxy
+type NodeInterface _bindings.ChannelProxy
func (p *NodeInterface) Clone(flags uint32, object NodeInterfaceRequest) error {
req_ := NodeCloneRequest{
Flags: flags,
Object: object,
}
- err := ((*_bindings.Proxy)(p)).Send(NodeCloneOrdinal, &req_)
+ err := ((*_bindings.ChannelProxy)(p)).Send(NodeCloneOrdinal, &req_)
return err
}
func (p *NodeInterface) Close() (_zx.Status, error) {
req_ := NodeCloseRequest{}
resp_ := NodeCloseResponse{}
- err := ((*_bindings.Proxy)(p)).Call(NodeCloseOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(NodeCloseOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *NodeInterface) Describe() (NodeInfo, error) {
req_ := NodeDescribeRequest{}
resp_ := NodeDescribeResponse{}
- err := ((*_bindings.Proxy)(p)).Call(NodeDescribeOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(NodeDescribeOrdinal, &req_, &resp_)
return resp_.Info, err
}
func (p *NodeInterface) ExpectOnOpen() (_zx.Status, *NodeInfo, error) {
resp_ := NodeOnOpenResponse{}
- err := ((*_bindings.Proxy)(p)).Recv(NodeOnOpenOrdinal, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Recv(NodeOnOpenOrdinal, &resp_)
return resp_.S, resp_.Info, err
}
func (p *NodeInterface) Sync() (_zx.Status, error) {
req_ := NodeSyncRequest{}
resp_ := NodeSyncResponse{}
- err := ((*_bindings.Proxy)(p)).Call(NodeSyncOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(NodeSyncOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *NodeInterface) GetAttr() (_zx.Status, NodeAttributes, error) {
req_ := NodeGetAttrRequest{}
resp_ := NodeGetAttrResponse{}
- err := ((*_bindings.Proxy)(p)).Call(NodeGetAttrOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(NodeGetAttrOrdinal, &req_, &resp_)
return resp_.S, resp_.Attributes, err
}
@@ -722,7 +722,7 @@
Attributes: attributes,
}
resp_ := NodeSetAttrResponse{}
- err := ((*_bindings.Proxy)(p)).Call(NodeSetAttrOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(NodeSetAttrOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -734,7 +734,7 @@
In: in,
}
resp_ := NodeIoctlResponse{}
- err := ((*_bindings.Proxy)(p)).Call(NodeIoctlOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(NodeIoctlOrdinal, &req_, &resp_)
return resp_.S, resp_.Handles, resp_.Out, err
}
@@ -842,14 +842,14 @@
return (*NodeEventProxy)(pxy), err
}
-type NodeEventProxy _bindings.Proxy
+type NodeEventProxy _bindings.ChannelProxy
func (p *NodeEventProxy) OnOpen(s _zx.Status, info *NodeInfo) error {
event_ := NodeOnOpenResponse{
S: s,
Info: info,
}
- return ((*_bindings.Proxy)(p)).Send(NodeOnOpenOrdinal, &event_)
+ return ((*_bindings.ChannelProxy)(p)).Send(NodeOnOpenOrdinal, &event_)
}
const (
@@ -1558,48 +1558,48 @@
return 8
}
-type FileInterface _bindings.Proxy
+type FileInterface _bindings.ChannelProxy
func (p *FileInterface) Clone(flags uint32, object NodeInterfaceRequest) error {
req_ := FileCloneRequest{
Flags: flags,
Object: object,
}
- err := ((*_bindings.Proxy)(p)).Send(FileCloneOrdinal, &req_)
+ err := ((*_bindings.ChannelProxy)(p)).Send(FileCloneOrdinal, &req_)
return err
}
func (p *FileInterface) Close() (_zx.Status, error) {
req_ := FileCloseRequest{}
resp_ := FileCloseResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileCloseOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileCloseOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *FileInterface) Describe() (NodeInfo, error) {
req_ := FileDescribeRequest{}
resp_ := FileDescribeResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileDescribeOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileDescribeOrdinal, &req_, &resp_)
return resp_.Info, err
}
func (p *FileInterface) ExpectOnOpen() (_zx.Status, *NodeInfo, error) {
resp_ := FileOnOpenResponse{}
- err := ((*_bindings.Proxy)(p)).Recv(FileOnOpenOrdinal, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Recv(FileOnOpenOrdinal, &resp_)
return resp_.S, resp_.Info, err
}
func (p *FileInterface) Sync() (_zx.Status, error) {
req_ := FileSyncRequest{}
resp_ := FileSyncResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileSyncOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileSyncOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *FileInterface) GetAttr() (_zx.Status, NodeAttributes, error) {
req_ := FileGetAttrRequest{}
resp_ := FileGetAttrResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileGetAttrOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileGetAttrOrdinal, &req_, &resp_)
return resp_.S, resp_.Attributes, err
}
@@ -1609,7 +1609,7 @@
Attributes: attributes,
}
resp_ := FileSetAttrResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileSetAttrOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileSetAttrOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -1621,7 +1621,7 @@
In: in,
}
resp_ := FileIoctlResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileIoctlOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileIoctlOrdinal, &req_, &resp_)
return resp_.S, resp_.Handles, resp_.Out, err
}
@@ -1630,7 +1630,7 @@
Count: count,
}
resp_ := FileReadResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileReadOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileReadOrdinal, &req_, &resp_)
return resp_.S, resp_.Data, err
}
@@ -1640,7 +1640,7 @@
Offset: offset,
}
resp_ := FileReadAtResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileReadAtOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileReadAtOrdinal, &req_, &resp_)
return resp_.S, resp_.Data, err
}
@@ -1649,7 +1649,7 @@
Data: data,
}
resp_ := FileWriteResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileWriteOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileWriteOrdinal, &req_, &resp_)
return resp_.S, resp_.Actual, err
}
@@ -1659,7 +1659,7 @@
Offset: offset,
}
resp_ := FileWriteAtResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileWriteAtOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileWriteAtOrdinal, &req_, &resp_)
return resp_.S, resp_.Actual, err
}
@@ -1669,7 +1669,7 @@
Start: start,
}
resp_ := FileSeekResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileSeekOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileSeekOrdinal, &req_, &resp_)
return resp_.S, resp_.Offset, err
}
@@ -1678,14 +1678,14 @@
Length: length,
}
resp_ := FileTruncateResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileTruncateOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileTruncateOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *FileInterface) GetFlags() (_zx.Status, uint32, error) {
req_ := FileGetFlagsRequest{}
resp_ := FileGetFlagsResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileGetFlagsOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileGetFlagsOrdinal, &req_, &resp_)
return resp_.S, resp_.Flags, err
}
@@ -1694,7 +1694,7 @@
Flags: flags,
}
resp_ := FileSetFlagsResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileSetFlagsOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileSetFlagsOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -1703,7 +1703,7 @@
Flags: flags,
}
resp_ := FileGetVmoResponse{}
- err := ((*_bindings.Proxy)(p)).Call(FileGetVmoOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(FileGetVmoOrdinal, &req_, &resp_)
return resp_.S, resp_.Vmo, err
}
@@ -1908,14 +1908,14 @@
return (*FileEventProxy)(pxy), err
}
-type FileEventProxy _bindings.Proxy
+type FileEventProxy _bindings.ChannelProxy
func (p *FileEventProxy) OnOpen(s _zx.Status, info *NodeInfo) error {
event_ := FileOnOpenResponse{
S: s,
Info: info,
}
- return ((*_bindings.Proxy)(p)).Send(FileOnOpenOrdinal, &event_)
+ return ((*_bindings.ChannelProxy)(p)).Send(FileOnOpenOrdinal, &event_)
}
const (
@@ -1943,13 +1943,13 @@
return 16
}
-type DirectoryWatcherInterface _bindings.Proxy
+type DirectoryWatcherInterface _bindings.ChannelProxy
func (p *DirectoryWatcherInterface) OnEvent(events []uint8) error {
req_ := DirectoryWatcherOnEventRequest{
Events: events,
}
- err := ((*_bindings.Proxy)(p)).Send(DirectoryWatcherOnEventOrdinal, &req_)
+ err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryWatcherOnEventOrdinal, &req_)
return err
}
@@ -1994,7 +1994,7 @@
return (*DirectoryWatcherEventProxy)(pxy), err
}
-type DirectoryWatcherEventProxy _bindings.Proxy
+type DirectoryWatcherEventProxy _bindings.ChannelProxy
const (
DirectoryCloneOrdinal uint32 = 402549324
@@ -2638,48 +2638,48 @@
return 8
}
-type DirectoryInterface _bindings.Proxy
+type DirectoryInterface _bindings.ChannelProxy
func (p *DirectoryInterface) Clone(flags uint32, object NodeInterfaceRequest) error {
req_ := DirectoryCloneRequest{
Flags: flags,
Object: object,
}
- err := ((*_bindings.Proxy)(p)).Send(DirectoryCloneOrdinal, &req_)
+ err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryCloneOrdinal, &req_)
return err
}
func (p *DirectoryInterface) Close() (_zx.Status, error) {
req_ := DirectoryCloseRequest{}
resp_ := DirectoryCloseResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryCloseOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryCloseOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *DirectoryInterface) Describe() (NodeInfo, error) {
req_ := DirectoryDescribeRequest{}
resp_ := DirectoryDescribeResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryDescribeOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryDescribeOrdinal, &req_, &resp_)
return resp_.Info, err
}
func (p *DirectoryInterface) ExpectOnOpen() (_zx.Status, *NodeInfo, error) {
resp_ := DirectoryOnOpenResponse{}
- err := ((*_bindings.Proxy)(p)).Recv(DirectoryOnOpenOrdinal, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Recv(DirectoryOnOpenOrdinal, &resp_)
return resp_.S, resp_.Info, err
}
func (p *DirectoryInterface) Sync() (_zx.Status, error) {
req_ := DirectorySyncRequest{}
resp_ := DirectorySyncResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectorySyncOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectorySyncOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *DirectoryInterface) GetAttr() (_zx.Status, NodeAttributes, error) {
req_ := DirectoryGetAttrRequest{}
resp_ := DirectoryGetAttrResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryGetAttrOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetAttrOrdinal, &req_, &resp_)
return resp_.S, resp_.Attributes, err
}
@@ -2689,7 +2689,7 @@
Attributes: attributes,
}
resp_ := DirectorySetAttrResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectorySetAttrOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectorySetAttrOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -2701,7 +2701,7 @@
In: in,
}
resp_ := DirectoryIoctlResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryIoctlOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryIoctlOrdinal, &req_, &resp_)
return resp_.S, resp_.Handles, resp_.Out, err
}
@@ -2712,7 +2712,7 @@
Path: path,
Object: object,
}
- err := ((*_bindings.Proxy)(p)).Send(DirectoryOpenOrdinal, &req_)
+ err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryOpenOrdinal, &req_)
return err
}
@@ -2721,7 +2721,7 @@
Path: path,
}
resp_ := DirectoryUnlinkResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryUnlinkOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryUnlinkOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -2730,21 +2730,21 @@
MaxBytes: maxBytes,
}
resp_ := DirectoryReadDirentsResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryReadDirentsOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryReadDirentsOrdinal, &req_, &resp_)
return resp_.S, resp_.Dirents, err
}
func (p *DirectoryInterface) Rewind() (_zx.Status, error) {
req_ := DirectoryRewindRequest{}
resp_ := DirectoryRewindResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryRewindOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryRewindOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *DirectoryInterface) GetToken() (_zx.Status, _zx.Handle, error) {
req_ := DirectoryGetTokenRequest{}
resp_ := DirectoryGetTokenResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryGetTokenOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetTokenOrdinal, &req_, &resp_)
return resp_.S, resp_.Token, err
}
@@ -2755,7 +2755,7 @@
Dst: dst,
}
resp_ := DirectoryRenameResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryRenameOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryRenameOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -2766,7 +2766,7 @@
Dst: dst,
}
resp_ := DirectoryLinkResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryLinkOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryLinkOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -2777,7 +2777,7 @@
Watcher: watcher,
}
resp_ := DirectoryWatchResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryWatchOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryWatchOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -2965,14 +2965,14 @@
return (*DirectoryEventProxy)(pxy), err
}
-type DirectoryEventProxy _bindings.Proxy
+type DirectoryEventProxy _bindings.ChannelProxy
func (p *DirectoryEventProxy) OnOpen(s _zx.Status, info *NodeInfo) error {
event_ := DirectoryOnOpenResponse{
S: s,
Info: info,
}
- return ((*_bindings.Proxy)(p)).Send(DirectoryOnOpenOrdinal, &event_)
+ return ((*_bindings.ChannelProxy)(p)).Send(DirectoryOnOpenOrdinal, &event_)
}
const (
@@ -3876,48 +3876,48 @@
return 24
}
-type DirectoryAdminInterface _bindings.Proxy
+type DirectoryAdminInterface _bindings.ChannelProxy
func (p *DirectoryAdminInterface) Clone(flags uint32, object NodeInterfaceRequest) error {
req_ := DirectoryAdminCloneRequest{
Flags: flags,
Object: object,
}
- err := ((*_bindings.Proxy)(p)).Send(DirectoryAdminCloneOrdinal, &req_)
+ err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryAdminCloneOrdinal, &req_)
return err
}
func (p *DirectoryAdminInterface) Close() (_zx.Status, error) {
req_ := DirectoryAdminCloseRequest{}
resp_ := DirectoryAdminCloseResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminCloseOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminCloseOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *DirectoryAdminInterface) Describe() (NodeInfo, error) {
req_ := DirectoryAdminDescribeRequest{}
resp_ := DirectoryAdminDescribeResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminDescribeOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminDescribeOrdinal, &req_, &resp_)
return resp_.Info, err
}
func (p *DirectoryAdminInterface) ExpectOnOpen() (_zx.Status, *NodeInfo, error) {
resp_ := DirectoryAdminOnOpenResponse{}
- err := ((*_bindings.Proxy)(p)).Recv(DirectoryAdminOnOpenOrdinal, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Recv(DirectoryAdminOnOpenOrdinal, &resp_)
return resp_.S, resp_.Info, err
}
func (p *DirectoryAdminInterface) Sync() (_zx.Status, error) {
req_ := DirectoryAdminSyncRequest{}
resp_ := DirectoryAdminSyncResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminSyncOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminSyncOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *DirectoryAdminInterface) GetAttr() (_zx.Status, NodeAttributes, error) {
req_ := DirectoryAdminGetAttrRequest{}
resp_ := DirectoryAdminGetAttrResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminGetAttrOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminGetAttrOrdinal, &req_, &resp_)
return resp_.S, resp_.Attributes, err
}
@@ -3927,7 +3927,7 @@
Attributes: attributes,
}
resp_ := DirectoryAdminSetAttrResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminSetAttrOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminSetAttrOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -3939,7 +3939,7 @@
In: in,
}
resp_ := DirectoryAdminIoctlResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminIoctlOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminIoctlOrdinal, &req_, &resp_)
return resp_.S, resp_.Handles, resp_.Out, err
}
@@ -3950,7 +3950,7 @@
Path: path,
Object: object,
}
- err := ((*_bindings.Proxy)(p)).Send(DirectoryAdminOpenOrdinal, &req_)
+ err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryAdminOpenOrdinal, &req_)
return err
}
@@ -3959,7 +3959,7 @@
Path: path,
}
resp_ := DirectoryAdminUnlinkResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminUnlinkOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminUnlinkOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -3968,21 +3968,21 @@
MaxBytes: maxBytes,
}
resp_ := DirectoryAdminReadDirentsResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminReadDirentsOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminReadDirentsOrdinal, &req_, &resp_)
return resp_.S, resp_.Dirents, err
}
func (p *DirectoryAdminInterface) Rewind() (_zx.Status, error) {
req_ := DirectoryAdminRewindRequest{}
resp_ := DirectoryAdminRewindResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminRewindOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminRewindOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *DirectoryAdminInterface) GetToken() (_zx.Status, _zx.Handle, error) {
req_ := DirectoryAdminGetTokenRequest{}
resp_ := DirectoryAdminGetTokenResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminGetTokenOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminGetTokenOrdinal, &req_, &resp_)
return resp_.S, resp_.Token, err
}
@@ -3993,7 +3993,7 @@
Dst: dst,
}
resp_ := DirectoryAdminRenameResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminRenameOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminRenameOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -4004,7 +4004,7 @@
Dst: dst,
}
resp_ := DirectoryAdminLinkResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminLinkOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminLinkOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -4015,7 +4015,7 @@
Watcher: watcher,
}
resp_ := DirectoryAdminWatchResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminWatchOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminWatchOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -4024,7 +4024,7 @@
Remote: remote,
}
resp_ := DirectoryAdminMountResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminMountOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminMountOrdinal, &req_, &resp_)
return resp_.S, err
}
@@ -4035,35 +4035,35 @@
Flags: flags,
}
resp_ := DirectoryAdminMountAndCreateResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminMountAndCreateOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminMountAndCreateOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *DirectoryAdminInterface) Unmount() (_zx.Status, error) {
req_ := DirectoryAdminUnmountRequest{}
resp_ := DirectoryAdminUnmountResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminUnmountOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminUnmountOrdinal, &req_, &resp_)
return resp_.S, err
}
func (p *DirectoryAdminInterface) UnmountNode() (_zx.Status, DirectoryInterface, error) {
req_ := DirectoryAdminUnmountNodeRequest{}
resp_ := DirectoryAdminUnmountNodeResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminUnmountNodeOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminUnmountNodeOrdinal, &req_, &resp_)
return resp_.S, resp_.Remote, err
}
func (p *DirectoryAdminInterface) QueryFilesystem() (_zx.Status, *FilesystemInfo, error) {
req_ := DirectoryAdminQueryFilesystemRequest{}
resp_ := DirectoryAdminQueryFilesystemResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminQueryFilesystemOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminQueryFilesystemOrdinal, &req_, &resp_)
return resp_.S, resp_.Info, err
}
func (p *DirectoryAdminInterface) GetDevicePath() (_zx.Status, *string, error) {
req_ := DirectoryAdminGetDevicePathRequest{}
resp_ := DirectoryAdminGetDevicePathResponse{}
- err := ((*_bindings.Proxy)(p)).Call(DirectoryAdminGetDevicePathOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminGetDevicePathOrdinal, &req_, &resp_)
return resp_.S, resp_.Path, err
}
@@ -4314,12 +4314,12 @@
return (*DirectoryAdminEventProxy)(pxy), err
}
-type DirectoryAdminEventProxy _bindings.Proxy
+type DirectoryAdminEventProxy _bindings.ChannelProxy
func (p *DirectoryAdminEventProxy) OnOpen(s _zx.Status, info *NodeInfo) error {
event_ := DirectoryAdminOnOpenResponse{
S: s,
Info: info,
}
- return ((*_bindings.Proxy)(p)).Send(DirectoryAdminOnOpenOrdinal, &event_)
+ return ((*_bindings.ChannelProxy)(p)).Send(DirectoryAdminOnOpenOrdinal, &event_)
}
diff --git a/src/syscall/zx/net/impl.go b/src/syscall/zx/net/impl.go
index 240c8a9..f49234f 100644
--- a/src/syscall/zx/net/impl.go
+++ b/src/syscall/zx/net/impl.go
@@ -310,11 +310,11 @@
return 8
}
-type ConnectivityInterface _bindings.Proxy
+type ConnectivityInterface _bindings.ChannelProxy
func (p *ConnectivityInterface) ExpectOnNetworkReachable() (bool, error) {
resp_ := ConnectivityOnNetworkReachableResponse{}
- err := ((*_bindings.Proxy)(p)).Recv(ConnectivityOnNetworkReachableOrdinal, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Recv(ConnectivityOnNetworkReachableOrdinal, &resp_)
return resp_.Reachable, err
}
@@ -361,13 +361,13 @@
return (*ConnectivityEventProxy)(pxy), err
}
-type ConnectivityEventProxy _bindings.Proxy
+type ConnectivityEventProxy _bindings.ChannelProxy
func (p *ConnectivityEventProxy) OnNetworkReachable(reachable bool) error {
event_ := ConnectivityOnNetworkReachableResponse{
Reachable: reachable,
}
- return ((*_bindings.Proxy)(p)).Send(ConnectivityOnNetworkReachableOrdinal, &event_)
+ return ((*_bindings.ChannelProxy)(p)).Send(ConnectivityOnNetworkReachableOrdinal, &event_)
}
const (
@@ -466,7 +466,7 @@
return 168
}
-type LegacySocketProviderInterface _bindings.Proxy
+type LegacySocketProviderInterface _bindings.ChannelProxy
func (p *LegacySocketProviderInterface) OpenSocket(domain SocketDomain, type_ SocketType, protocol SocketProtocol) (_zx.Socket, int32, error) {
req_ := LegacySocketProviderOpenSocketRequest{
@@ -475,7 +475,7 @@
Protocol: protocol,
}
resp_ := LegacySocketProviderOpenSocketResponse{}
- err := ((*_bindings.Proxy)(p)).Call(LegacySocketProviderOpenSocketOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(LegacySocketProviderOpenSocketOrdinal, &req_, &resp_)
return resp_.S, resp_.Status, err
}
@@ -486,7 +486,7 @@
Hints: hints,
}
resp_ := LegacySocketProviderGetAddrInfoResponse{}
- err := ((*_bindings.Proxy)(p)).Call(LegacySocketProviderGetAddrInfoOrdinal, &req_, &resp_)
+ err := ((*_bindings.ChannelProxy)(p)).Call(LegacySocketProviderGetAddrInfoOrdinal, &req_, &resp_)
return resp_.Status, resp_.Nres, resp_.Res, err
}
@@ -556,4 +556,4 @@
return (*LegacySocketProviderEventProxy)(pxy), err
}
-type LegacySocketProviderEventProxy _bindings.Proxy
+type LegacySocketProviderEventProxy _bindings.ChannelProxy
