| // 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 io |
| |
| import ( |
| _zx "syscall/zx" |
| _bindings "syscall/zx/fidl" |
| fuchsiamem "syscall/zx/mem" |
| ) |
| |
| const ( |
| OpenRightReadable uint32 = 0x00000001 |
| OpenRightWritable uint32 = 0x00000002 |
| OpenRightAdmin uint32 = 0x00000004 |
| OpenFlagCreate uint32 = 0x00010000 |
| OpenFlagCreateIfAbsent uint32 = 0x00020000 |
| OpenFlagTruncate uint32 = 0x00040000 |
| OpenFlagDirectory uint32 = 0x00080000 |
| OpenFlagAppend uint32 = 0x00100000 |
| OpenFlagNoRemote uint32 = 0x00200000 |
| OpenFlagNodeReference uint32 = 0x00400000 |
| OpenFlagDescribe uint32 = 0x00800000 |
| ModeProtectionMask uint32 = 0x00FFF |
| ModeTypeMask uint32 = 0xFF000 |
| ModeTypeDirectory uint32 = 0x04000 |
| ModeTypeBlockDevice uint32 = 0x06000 |
| ModeTypeFile uint32 = 0x08000 |
| ModeTypeSocket uint32 = 0x0C000 |
| ModeTypeService uint32 = 0x10000 |
| MaxIoctlHandles uint64 = 2 |
| MaxBuf uint64 = 8192 |
| MaxPath uint64 = 4096 |
| MaxFilename uint64 = 255 |
| NodeAttributeFlagCreationTime uint32 = 0x00000001 |
| NodeAttributeFlagModificationTime uint32 = 0x00000002 |
| VmoFlagRead uint32 = 0x00000001 |
| VmoFlagWrite uint32 = 0x00000002 |
| VmoFlagExec uint32 = 0x00000004 |
| VmoFlagPrivate uint32 = 0x00010000 |
| VmoFlagExact uint32 = 0x00020000 |
| DirentTypeUnknown uint8 = 0 |
| DirentTypeDirectory uint8 = 4 |
| DirentTypeBlockDevice uint8 = 6 |
| DirentTypeFile uint8 = 8 |
| DirentTypeSocket uint8 = 12 |
| DirentTypeService uint8 = 16 |
| InoUnknown uint64 = 0xFFFFFFFFFFFFFFFF |
| WatchEventDeleted uint8 = 0 |
| WatchEventAdded uint8 = 1 |
| WatchEventRemoved uint8 = 2 |
| WatchEventExisting uint8 = 3 |
| WatchEventIdle uint8 = 4 |
| WatchMaskDeleted uint32 = 0x00000001 |
| WatchMaskAdded uint32 = 0x00000002 |
| WatchMaskRemoved uint32 = 0x00000004 |
| WatchMaskExisting uint32 = 0x00000008 |
| WatchMaskIdle uint32 = 0x00000010 |
| WatchMaskAll uint32 = 0x0000001F |
| MountCreateFlagReplace uint32 = 0x00000001 |
| MaxFsNameBuffer uint64 = 32 |
| ) |
| |
| type SeekOrigin uint32 |
| |
| const ( |
| SeekOriginStart SeekOrigin = 0 |
| SeekOriginCurrent SeekOrigin = 1 |
| SeekOriginEnd SeekOrigin = 2 |
| ) |
| |
| func (x SeekOrigin) String() string { |
| switch x { |
| case 0: |
| return "Start" |
| case 1: |
| return "Current" |
| case 2: |
| return "End" |
| } |
| return "Unknown" |
| } |
| |
| type Service struct { |
| _ struct{} `fidl2:"s,1,1"` |
| Reserved uint8 |
| } |
| |
| var _mService = _bindings.CreateLazyMarshaler(Service{}) |
| |
| func (msg *Service) Marshaler() _bindings.Marshaler { |
| return _mService |
| } |
| |
| // Implements Payload. |
| func (_ *Service) InlineAlignment() int { |
| return 1 |
| } |
| |
| // Implements Payload. |
| func (_ *Service) InlineSize() int { |
| return 1 |
| } |
| |
| type FileObject struct { |
| _ struct{} `fidl2:"s,4,4"` |
| Event _zx.Event `fidl:"*" fidl2:"1"` |
| } |
| |
| var _mFileObject = _bindings.CreateLazyMarshaler(FileObject{}) |
| |
| func (msg *FileObject) Marshaler() _bindings.Marshaler { |
| return _mFileObject |
| } |
| |
| // Implements Payload. |
| func (_ *FileObject) InlineAlignment() int { |
| return 4 |
| } |
| |
| // Implements Payload. |
| func (_ *FileObject) InlineSize() int { |
| return 4 |
| } |
| |
| type DirectoryObject struct { |
| _ struct{} `fidl2:"s,1,1"` |
| Reserved uint8 |
| } |
| |
| var _mDirectoryObject = _bindings.CreateLazyMarshaler(DirectoryObject{}) |
| |
| func (msg *DirectoryObject) Marshaler() _bindings.Marshaler { |
| return _mDirectoryObject |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryObject) InlineAlignment() int { |
| return 1 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryObject) InlineSize() int { |
| return 1 |
| } |
| |
| type Pipe struct { |
| _ struct{} `fidl2:"s,4,4"` |
| Socket _zx.Socket `fidl2:"0"` |
| } |
| |
| var _mPipe = _bindings.CreateLazyMarshaler(Pipe{}) |
| |
| func (msg *Pipe) Marshaler() _bindings.Marshaler { |
| return _mPipe |
| } |
| |
| // Implements Payload. |
| func (_ *Pipe) InlineAlignment() int { |
| return 4 |
| } |
| |
| // Implements Payload. |
| func (_ *Pipe) InlineSize() int { |
| return 4 |
| } |
| |
| type Vmofile struct { |
| _ struct{} `fidl2:"s,24,8"` |
| Vmo _zx.VMO `fidl2:"0"` |
| Offset uint64 |
| Length uint64 |
| } |
| |
| var _mVmofile = _bindings.CreateLazyMarshaler(Vmofile{}) |
| |
| func (msg *Vmofile) Marshaler() _bindings.Marshaler { |
| return _mVmofile |
| } |
| |
| // Implements Payload. |
| func (_ *Vmofile) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *Vmofile) InlineSize() int { |
| return 24 |
| } |
| |
| type Device struct { |
| _ struct{} `fidl2:"s,4,4"` |
| Event _zx.Event `fidl:"*" fidl2:"1"` |
| } |
| |
| var _mDevice = _bindings.CreateLazyMarshaler(Device{}) |
| |
| func (msg *Device) Marshaler() _bindings.Marshaler { |
| return _mDevice |
| } |
| |
| // Implements Payload. |
| func (_ *Device) InlineAlignment() int { |
| return 4 |
| } |
| |
| // Implements Payload. |
| func (_ *Device) InlineSize() int { |
| return 4 |
| } |
| |
| type NodeAttributes struct { |
| _ struct{} `fidl2:"s,56,8"` |
| Mode uint32 |
| Id uint64 |
| ContentSize uint64 |
| StorageSize uint64 |
| LinkCount uint64 |
| CreationTime uint64 |
| ModificationTime uint64 |
| } |
| |
| var _mNodeAttributes = _bindings.CreateLazyMarshaler(NodeAttributes{}) |
| |
| func (msg *NodeAttributes) Marshaler() _bindings.Marshaler { |
| return _mNodeAttributes |
| } |
| |
| // Implements Payload. |
| func (_ *NodeAttributes) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeAttributes) InlineSize() int { |
| return 56 |
| } |
| |
| type WatchedEvent struct { |
| _ struct{} `fidl2:"s,24,8"` |
| Event uint8 |
| Len uint8 |
| Name []uint8 `fidl:"255" fidl2:"255"` |
| } |
| |
| var _mWatchedEvent = _bindings.CreateLazyMarshaler(WatchedEvent{}) |
| |
| func (msg *WatchedEvent) Marshaler() _bindings.Marshaler { |
| return _mWatchedEvent |
| } |
| |
| // Implements Payload. |
| func (_ *WatchedEvent) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *WatchedEvent) InlineSize() int { |
| return 24 |
| } |
| |
| type FilesystemInfo struct { |
| _ struct{} `fidl2:"s,96,8"` |
| TotalBytes uint64 |
| UsedBytes uint64 |
| TotalNodes uint64 |
| UsedNodes uint64 |
| FreeSharedPoolBytes uint64 |
| FsId uint64 |
| BlockSize uint32 |
| MaxFilenameSize uint32 |
| FsType uint32 |
| Padding uint32 |
| Name [32]int8 |
| } |
| |
| var _mFilesystemInfo = _bindings.CreateLazyMarshaler(FilesystemInfo{}) |
| |
| func (msg *FilesystemInfo) Marshaler() _bindings.Marshaler { |
| return _mFilesystemInfo |
| } |
| |
| // Implements Payload. |
| func (_ *FilesystemInfo) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *FilesystemInfo) InlineSize() int { |
| return 96 |
| } |
| |
| type NodeInfoTag uint32 |
| |
| const ( |
| _ NodeInfoTag = iota |
| NodeInfoService |
| NodeInfoFile |
| NodeInfoDirectory |
| NodeInfoPipe |
| NodeInfoVmofile |
| NodeInfoDevice |
| ) |
| |
| type NodeInfo struct { |
| NodeInfoTag `fidl:"tag" fidl2:"u,32,8"` |
| Service Service |
| File FileObject |
| Directory DirectoryObject |
| Pipe Pipe |
| Vmofile Vmofile |
| Device Device |
| } |
| |
| // Implements Payload. |
| func (_ *NodeInfo) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeInfo) InlineSize() int { |
| return 32 |
| } |
| |
| func (u *NodeInfo) Which() NodeInfoTag { |
| return u.NodeInfoTag |
| } |
| |
| func (u *NodeInfo) SetService(service Service) { |
| u.NodeInfoTag = NodeInfoService |
| u.Service = service |
| } |
| |
| func (u *NodeInfo) SetFile(file FileObject) { |
| u.NodeInfoTag = NodeInfoFile |
| u.File = file |
| } |
| |
| func (u *NodeInfo) SetDirectory(directory DirectoryObject) { |
| u.NodeInfoTag = NodeInfoDirectory |
| u.Directory = directory |
| } |
| |
| func (u *NodeInfo) SetPipe(pipe Pipe) { |
| u.NodeInfoTag = NodeInfoPipe |
| u.Pipe = pipe |
| } |
| |
| func (u *NodeInfo) SetVmofile(vmofile Vmofile) { |
| u.NodeInfoTag = NodeInfoVmofile |
| u.Vmofile = vmofile |
| } |
| |
| func (u *NodeInfo) SetDevice(device Device) { |
| u.NodeInfoTag = NodeInfoDevice |
| u.Device = device |
| } |
| |
| const ( |
| NodeCloneOrdinal uint32 = 402549324 |
| NodeCloneGenOrdinal uint32 = 402549324 |
| NodeCloseOrdinal uint32 = 1387878023 |
| NodeCloseGenOrdinal uint32 = 1387878023 |
| NodeDescribeOrdinal uint32 = 526573406 |
| NodeDescribeGenOrdinal uint32 = 526573406 |
| NodeOnOpenOrdinal uint32 = 1191225277 |
| NodeOnOpenGenOrdinal uint32 = 1191225277 |
| NodeSyncOrdinal uint32 = 1648508842 |
| NodeSyncGenOrdinal uint32 = 1648508842 |
| NodeGetAttrOrdinal uint32 = 1166403528 |
| NodeGetAttrGenOrdinal uint32 = 1166403528 |
| NodeSetAttrOrdinal uint32 = 198530458 |
| NodeSetAttrGenOrdinal uint32 = 198530458 |
| NodeIoctlOrdinal uint32 = 905161895 |
| NodeIoctlGenOrdinal uint32 = 905161895 |
| ) |
| |
| type NodeCloneRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Flags uint32 |
| Object NodeInterfaceRequest `fidl2:"0"` |
| } |
| |
| var _mNodeCloneRequest = _bindings.CreateLazyMarshaler(NodeCloneRequest{}) |
| |
| func (msg *NodeCloneRequest) Marshaler() _bindings.Marshaler { |
| return _mNodeCloneRequest |
| } |
| |
| // Implements Payload. |
| func (_ *NodeCloneRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeCloneRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type NodeCloseRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mNodeCloseRequest = _bindings.CreateLazyMarshaler(NodeCloseRequest{}) |
| |
| func (msg *NodeCloseRequest) Marshaler() _bindings.Marshaler { |
| return _mNodeCloseRequest |
| } |
| |
| // Implements Payload. |
| func (_ *NodeCloseRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeCloseRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type NodeCloseResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mNodeCloseResponse = _bindings.CreateLazyMarshaler(NodeCloseResponse{}) |
| |
| func (msg *NodeCloseResponse) Marshaler() _bindings.Marshaler { |
| return _mNodeCloseResponse |
| } |
| |
| // Implements Payload. |
| func (_ *NodeCloseResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeCloseResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type NodeDescribeRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mNodeDescribeRequest = _bindings.CreateLazyMarshaler(NodeDescribeRequest{}) |
| |
| func (msg *NodeDescribeRequest) Marshaler() _bindings.Marshaler { |
| return _mNodeDescribeRequest |
| } |
| |
| // Implements Payload. |
| func (_ *NodeDescribeRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeDescribeRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type NodeDescribeResponse struct { |
| _ struct{} `fidl2:"s,32,0"` |
| Info NodeInfo |
| } |
| |
| var _mNodeDescribeResponse = _bindings.CreateLazyMarshaler(NodeDescribeResponse{}) |
| |
| func (msg *NodeDescribeResponse) Marshaler() _bindings.Marshaler { |
| return _mNodeDescribeResponse |
| } |
| |
| // Implements Payload. |
| func (_ *NodeDescribeResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeDescribeResponse) InlineSize() int { |
| return 32 |
| } |
| |
| type NodeOnOpenResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| S int32 |
| Info *NodeInfo |
| } |
| |
| var _mNodeOnOpenResponse = _bindings.CreateLazyMarshaler(NodeOnOpenResponse{}) |
| |
| func (msg *NodeOnOpenResponse) Marshaler() _bindings.Marshaler { |
| return _mNodeOnOpenResponse |
| } |
| |
| // Implements Payload. |
| func (_ *NodeOnOpenResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeOnOpenResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type NodeSyncRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mNodeSyncRequest = _bindings.CreateLazyMarshaler(NodeSyncRequest{}) |
| |
| func (msg *NodeSyncRequest) Marshaler() _bindings.Marshaler { |
| return _mNodeSyncRequest |
| } |
| |
| // Implements Payload. |
| func (_ *NodeSyncRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeSyncRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type NodeSyncResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mNodeSyncResponse = _bindings.CreateLazyMarshaler(NodeSyncResponse{}) |
| |
| func (msg *NodeSyncResponse) Marshaler() _bindings.Marshaler { |
| return _mNodeSyncResponse |
| } |
| |
| // Implements Payload. |
| func (_ *NodeSyncResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeSyncResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type NodeGetAttrRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mNodeGetAttrRequest = _bindings.CreateLazyMarshaler(NodeGetAttrRequest{}) |
| |
| func (msg *NodeGetAttrRequest) Marshaler() _bindings.Marshaler { |
| return _mNodeGetAttrRequest |
| } |
| |
| // Implements Payload. |
| func (_ *NodeGetAttrRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeGetAttrRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type NodeGetAttrResponse struct { |
| _ struct{} `fidl2:"s,64,0"` |
| S int32 |
| Attributes NodeAttributes |
| } |
| |
| var _mNodeGetAttrResponse = _bindings.CreateLazyMarshaler(NodeGetAttrResponse{}) |
| |
| func (msg *NodeGetAttrResponse) Marshaler() _bindings.Marshaler { |
| return _mNodeGetAttrResponse |
| } |
| |
| // Implements Payload. |
| func (_ *NodeGetAttrResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeGetAttrResponse) InlineSize() int { |
| return 64 |
| } |
| |
| type NodeSetAttrRequest struct { |
| _ struct{} `fidl2:"s,64,0"` |
| Flags uint32 |
| Attributes NodeAttributes |
| } |
| |
| var _mNodeSetAttrRequest = _bindings.CreateLazyMarshaler(NodeSetAttrRequest{}) |
| |
| func (msg *NodeSetAttrRequest) Marshaler() _bindings.Marshaler { |
| return _mNodeSetAttrRequest |
| } |
| |
| // Implements Payload. |
| func (_ *NodeSetAttrRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeSetAttrRequest) InlineSize() int { |
| return 64 |
| } |
| |
| type NodeSetAttrResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mNodeSetAttrResponse = _bindings.CreateLazyMarshaler(NodeSetAttrResponse{}) |
| |
| func (msg *NodeSetAttrResponse) Marshaler() _bindings.Marshaler { |
| return _mNodeSetAttrResponse |
| } |
| |
| // Implements Payload. |
| func (_ *NodeSetAttrResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeSetAttrResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type NodeIoctlRequest struct { |
| _ struct{} `fidl2:"s,48,0"` |
| Opcode uint32 |
| MaxOut uint64 |
| Handles []_zx.Handle `fidl:"2" fidl2:"2,0"` |
| In []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mNodeIoctlRequest = _bindings.CreateLazyMarshaler(NodeIoctlRequest{}) |
| |
| func (msg *NodeIoctlRequest) Marshaler() _bindings.Marshaler { |
| return _mNodeIoctlRequest |
| } |
| |
| // Implements Payload. |
| func (_ *NodeIoctlRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeIoctlRequest) InlineSize() int { |
| return 48 |
| } |
| |
| type NodeIoctlResponse struct { |
| _ struct{} `fidl2:"s,40,0"` |
| S int32 |
| Handles []_zx.Handle `fidl:"2" fidl2:"2,0"` |
| Out []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mNodeIoctlResponse = _bindings.CreateLazyMarshaler(NodeIoctlResponse{}) |
| |
| func (msg *NodeIoctlResponse) Marshaler() _bindings.Marshaler { |
| return _mNodeIoctlResponse |
| } |
| |
| // Implements Payload. |
| func (_ *NodeIoctlResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *NodeIoctlResponse) InlineSize() int { |
| return 40 |
| } |
| |
| type NodeInterface _bindings.ChannelProxy |
| |
| func (p *NodeInterface) Clone(flags uint32, object NodeInterfaceRequest) error { |
| req_ := NodeCloneRequest{ |
| Flags: flags, |
| Object: object, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).Send(NodeCloneOrdinal, &req_) |
| return err |
| } |
| |
| func (p *NodeInterface) Close() (int32, error) { |
| req_ := NodeCloseRequest{} |
| resp_ := NodeCloseResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(NodeCloseOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *NodeInterface) Describe() (NodeInfo, error) { |
| req_ := NodeDescribeRequest{} |
| resp_ := NodeDescribeResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(NodeDescribeOrdinal, &req_, &resp_) |
| return resp_.Info, err |
| } |
| |
| func (p *NodeInterface) ExpectOnOpen() (int32, *NodeInfo, error) { |
| resp_ := NodeOnOpenResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Recv(NodeOnOpenOrdinal, &resp_) |
| return resp_.S, resp_.Info, err |
| } |
| |
| func (p *NodeInterface) Sync() (int32, error) { |
| req_ := NodeSyncRequest{} |
| resp_ := NodeSyncResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(NodeSyncOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *NodeInterface) GetAttr() (int32, NodeAttributes, error) { |
| req_ := NodeGetAttrRequest{} |
| resp_ := NodeGetAttrResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(NodeGetAttrOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Attributes, err |
| } |
| |
| func (p *NodeInterface) SetAttr(flags uint32, attributes NodeAttributes) (int32, error) { |
| req_ := NodeSetAttrRequest{ |
| Flags: flags, |
| Attributes: attributes, |
| } |
| resp_ := NodeSetAttrResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(NodeSetAttrOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *NodeInterface) Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) { |
| req_ := NodeIoctlRequest{ |
| Opcode: opcode, |
| MaxOut: maxOut, |
| Handles: handles, |
| In: in, |
| } |
| resp_ := NodeIoctlResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(NodeIoctlOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Handles, resp_.Out, err |
| } |
| |
| type Node interface { |
| Clone(flags uint32, object NodeInterfaceRequest) error |
| Close() (int32, error) |
| Describe() (NodeInfo, error) |
| Sync() (int32, error) |
| GetAttr() (int32, NodeAttributes, error) |
| SetAttr(flags uint32, attributes NodeAttributes) (int32, error) |
| Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) |
| } |
| |
| type NodeTransitionalBase struct{} |
| |
| type NodeInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewNodeInterfaceRequest() (NodeInterfaceRequest, *NodeInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return NodeInterfaceRequest(req), (*NodeInterface)(cli), err |
| } |
| |
| type NodeStub struct { |
| Impl Node |
| } |
| |
| func (s *NodeStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) { |
| switch ord { |
| case NodeCloneOrdinal: |
| in_ := NodeCloneRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.Clone(in_.Flags, in_.Object) |
| return nil, err_ |
| case NodeCloseOrdinal: |
| in_ := NodeCloseRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := NodeCloseResponse{} |
| s, err_ := s.Impl.Close() |
| out_.S = s |
| return &out_, err_ |
| case NodeDescribeOrdinal: |
| in_ := NodeDescribeRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := NodeDescribeResponse{} |
| info, err_ := s.Impl.Describe() |
| out_.Info = info |
| return &out_, err_ |
| case NodeSyncOrdinal: |
| in_ := NodeSyncRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := NodeSyncResponse{} |
| s, err_ := s.Impl.Sync() |
| out_.S = s |
| return &out_, err_ |
| case NodeGetAttrOrdinal: |
| in_ := NodeGetAttrRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := NodeGetAttrResponse{} |
| s, attributes, err_ := s.Impl.GetAttr() |
| out_.S = s |
| out_.Attributes = attributes |
| return &out_, err_ |
| case NodeSetAttrOrdinal: |
| in_ := NodeSetAttrRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := NodeSetAttrResponse{} |
| s, err_ := s.Impl.SetAttr(in_.Flags, in_.Attributes) |
| out_.S = s |
| return &out_, err_ |
| case NodeIoctlOrdinal: |
| in_ := NodeIoctlRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := NodeIoctlResponse{} |
| s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode, in_.MaxOut, in_.Handles, in_.In) |
| out_.S = s |
| out_.Handles = handles |
| out_.Out = out |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| |
| type NodeService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *NodeService) Add(impl Node, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&NodeStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *NodeService) EventProxyFor(key _bindings.BindingKey) (*NodeEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*NodeEventProxy)(pxy), err |
| } |
| |
| type NodeEventProxy _bindings.ChannelProxy |
| |
| func (p *NodeEventProxy) OnOpen(s int32, info *NodeInfo) error { |
| event_ := NodeOnOpenResponse{ |
| S: s, |
| Info: info, |
| } |
| return ((*_bindings.ChannelProxy)(p)).Send(NodeOnOpenOrdinal, &event_) |
| } |
| |
| const ( |
| FileCloneOrdinal uint32 = 402549324 |
| FileCloneGenOrdinal uint32 = 402549324 |
| FileCloseOrdinal uint32 = 1387878023 |
| FileCloseGenOrdinal uint32 = 1387878023 |
| FileDescribeOrdinal uint32 = 526573406 |
| FileDescribeGenOrdinal uint32 = 526573406 |
| FileOnOpenOrdinal uint32 = 1191225277 |
| FileOnOpenGenOrdinal uint32 = 1191225277 |
| FileSyncOrdinal uint32 = 1648508842 |
| FileSyncGenOrdinal uint32 = 1648508842 |
| FileGetAttrOrdinal uint32 = 1166403528 |
| FileGetAttrGenOrdinal uint32 = 1166403528 |
| FileSetAttrOrdinal uint32 = 198530458 |
| FileSetAttrGenOrdinal uint32 = 198530458 |
| FileIoctlOrdinal uint32 = 905161895 |
| FileIoctlGenOrdinal uint32 = 905161895 |
| FileReadOrdinal uint32 = 636961156 |
| FileReadGenOrdinal uint32 = 636961156 |
| FileReadAtOrdinal uint32 = 2087865796 |
| FileReadAtGenOrdinal uint32 = 2087865796 |
| FileWriteOrdinal uint32 = 85125024 |
| FileWriteGenOrdinal uint32 = 85125024 |
| FileWriteAtOrdinal uint32 = 1045766885 |
| FileWriteAtGenOrdinal uint32 = 1045766885 |
| FileSeekOrdinal uint32 = 2016048965 |
| FileSeekGenOrdinal uint32 = 2016048965 |
| FileTruncateOrdinal uint32 = 1118517818 |
| FileTruncateGenOrdinal uint32 = 1118517818 |
| FileGetFlagsOrdinal uint32 = 1679205366 |
| FileGetFlagsGenOrdinal uint32 = 1679205366 |
| FileSetFlagsOrdinal uint32 = 1059310710 |
| FileSetFlagsGenOrdinal uint32 = 1059310710 |
| FileGetBufferOrdinal uint32 = 1958938995 |
| FileGetBufferGenOrdinal uint32 = 1958938995 |
| ) |
| |
| type FileCloneRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Flags uint32 |
| Object NodeInterfaceRequest `fidl2:"0"` |
| } |
| |
| var _mFileCloneRequest = _bindings.CreateLazyMarshaler(FileCloneRequest{}) |
| |
| func (msg *FileCloneRequest) Marshaler() _bindings.Marshaler { |
| return _mFileCloneRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileCloneRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileCloneRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type FileCloseRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mFileCloseRequest = _bindings.CreateLazyMarshaler(FileCloseRequest{}) |
| |
| func (msg *FileCloseRequest) Marshaler() _bindings.Marshaler { |
| return _mFileCloseRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileCloseRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileCloseRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type FileCloseResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mFileCloseResponse = _bindings.CreateLazyMarshaler(FileCloseResponse{}) |
| |
| func (msg *FileCloseResponse) Marshaler() _bindings.Marshaler { |
| return _mFileCloseResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileCloseResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileCloseResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type FileDescribeRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mFileDescribeRequest = _bindings.CreateLazyMarshaler(FileDescribeRequest{}) |
| |
| func (msg *FileDescribeRequest) Marshaler() _bindings.Marshaler { |
| return _mFileDescribeRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileDescribeRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileDescribeRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type FileDescribeResponse struct { |
| _ struct{} `fidl2:"s,32,0"` |
| Info NodeInfo |
| } |
| |
| var _mFileDescribeResponse = _bindings.CreateLazyMarshaler(FileDescribeResponse{}) |
| |
| func (msg *FileDescribeResponse) Marshaler() _bindings.Marshaler { |
| return _mFileDescribeResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileDescribeResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileDescribeResponse) InlineSize() int { |
| return 32 |
| } |
| |
| type FileOnOpenResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| S int32 |
| Info *NodeInfo |
| } |
| |
| var _mFileOnOpenResponse = _bindings.CreateLazyMarshaler(FileOnOpenResponse{}) |
| |
| func (msg *FileOnOpenResponse) Marshaler() _bindings.Marshaler { |
| return _mFileOnOpenResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileOnOpenResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileOnOpenResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type FileSyncRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mFileSyncRequest = _bindings.CreateLazyMarshaler(FileSyncRequest{}) |
| |
| func (msg *FileSyncRequest) Marshaler() _bindings.Marshaler { |
| return _mFileSyncRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileSyncRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileSyncRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type FileSyncResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mFileSyncResponse = _bindings.CreateLazyMarshaler(FileSyncResponse{}) |
| |
| func (msg *FileSyncResponse) Marshaler() _bindings.Marshaler { |
| return _mFileSyncResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileSyncResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileSyncResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type FileGetAttrRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mFileGetAttrRequest = _bindings.CreateLazyMarshaler(FileGetAttrRequest{}) |
| |
| func (msg *FileGetAttrRequest) Marshaler() _bindings.Marshaler { |
| return _mFileGetAttrRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetAttrRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetAttrRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type FileGetAttrResponse struct { |
| _ struct{} `fidl2:"s,64,0"` |
| S int32 |
| Attributes NodeAttributes |
| } |
| |
| var _mFileGetAttrResponse = _bindings.CreateLazyMarshaler(FileGetAttrResponse{}) |
| |
| func (msg *FileGetAttrResponse) Marshaler() _bindings.Marshaler { |
| return _mFileGetAttrResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetAttrResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetAttrResponse) InlineSize() int { |
| return 64 |
| } |
| |
| type FileSetAttrRequest struct { |
| _ struct{} `fidl2:"s,64,0"` |
| Flags uint32 |
| Attributes NodeAttributes |
| } |
| |
| var _mFileSetAttrRequest = _bindings.CreateLazyMarshaler(FileSetAttrRequest{}) |
| |
| func (msg *FileSetAttrRequest) Marshaler() _bindings.Marshaler { |
| return _mFileSetAttrRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileSetAttrRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileSetAttrRequest) InlineSize() int { |
| return 64 |
| } |
| |
| type FileSetAttrResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mFileSetAttrResponse = _bindings.CreateLazyMarshaler(FileSetAttrResponse{}) |
| |
| func (msg *FileSetAttrResponse) Marshaler() _bindings.Marshaler { |
| return _mFileSetAttrResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileSetAttrResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileSetAttrResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type FileIoctlRequest struct { |
| _ struct{} `fidl2:"s,48,0"` |
| Opcode uint32 |
| MaxOut uint64 |
| Handles []_zx.Handle `fidl:"2" fidl2:"2,0"` |
| In []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mFileIoctlRequest = _bindings.CreateLazyMarshaler(FileIoctlRequest{}) |
| |
| func (msg *FileIoctlRequest) Marshaler() _bindings.Marshaler { |
| return _mFileIoctlRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileIoctlRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileIoctlRequest) InlineSize() int { |
| return 48 |
| } |
| |
| type FileIoctlResponse struct { |
| _ struct{} `fidl2:"s,40,0"` |
| S int32 |
| Handles []_zx.Handle `fidl:"2" fidl2:"2,0"` |
| Out []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mFileIoctlResponse = _bindings.CreateLazyMarshaler(FileIoctlResponse{}) |
| |
| func (msg *FileIoctlResponse) Marshaler() _bindings.Marshaler { |
| return _mFileIoctlResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileIoctlResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileIoctlResponse) InlineSize() int { |
| return 40 |
| } |
| |
| type FileReadRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Count uint64 |
| } |
| |
| var _mFileReadRequest = _bindings.CreateLazyMarshaler(FileReadRequest{}) |
| |
| func (msg *FileReadRequest) Marshaler() _bindings.Marshaler { |
| return _mFileReadRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileReadRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileReadRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type FileReadResponse struct { |
| _ struct{} `fidl2:"s,24,0"` |
| S int32 |
| Data []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mFileReadResponse = _bindings.CreateLazyMarshaler(FileReadResponse{}) |
| |
| func (msg *FileReadResponse) Marshaler() _bindings.Marshaler { |
| return _mFileReadResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileReadResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileReadResponse) InlineSize() int { |
| return 24 |
| } |
| |
| type FileReadAtRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Count uint64 |
| Offset uint64 |
| } |
| |
| var _mFileReadAtRequest = _bindings.CreateLazyMarshaler(FileReadAtRequest{}) |
| |
| func (msg *FileReadAtRequest) Marshaler() _bindings.Marshaler { |
| return _mFileReadAtRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileReadAtRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileReadAtRequest) InlineSize() int { |
| return 16 |
| } |
| |
| type FileReadAtResponse struct { |
| _ struct{} `fidl2:"s,24,0"` |
| S int32 |
| Data []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mFileReadAtResponse = _bindings.CreateLazyMarshaler(FileReadAtResponse{}) |
| |
| func (msg *FileReadAtResponse) Marshaler() _bindings.Marshaler { |
| return _mFileReadAtResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileReadAtResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileReadAtResponse) InlineSize() int { |
| return 24 |
| } |
| |
| type FileWriteRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Data []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mFileWriteRequest = _bindings.CreateLazyMarshaler(FileWriteRequest{}) |
| |
| func (msg *FileWriteRequest) Marshaler() _bindings.Marshaler { |
| return _mFileWriteRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileWriteRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileWriteRequest) InlineSize() int { |
| return 16 |
| } |
| |
| type FileWriteResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| S int32 |
| Actual uint64 |
| } |
| |
| var _mFileWriteResponse = _bindings.CreateLazyMarshaler(FileWriteResponse{}) |
| |
| func (msg *FileWriteResponse) Marshaler() _bindings.Marshaler { |
| return _mFileWriteResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileWriteResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileWriteResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type FileWriteAtRequest struct { |
| _ struct{} `fidl2:"s,24,0"` |
| Data []uint8 `fidl:"8192" fidl2:"8192"` |
| Offset uint64 |
| } |
| |
| var _mFileWriteAtRequest = _bindings.CreateLazyMarshaler(FileWriteAtRequest{}) |
| |
| func (msg *FileWriteAtRequest) Marshaler() _bindings.Marshaler { |
| return _mFileWriteAtRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileWriteAtRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileWriteAtRequest) InlineSize() int { |
| return 24 |
| } |
| |
| type FileWriteAtResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| S int32 |
| Actual uint64 |
| } |
| |
| var _mFileWriteAtResponse = _bindings.CreateLazyMarshaler(FileWriteAtResponse{}) |
| |
| func (msg *FileWriteAtResponse) Marshaler() _bindings.Marshaler { |
| return _mFileWriteAtResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileWriteAtResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileWriteAtResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type FileSeekRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Offset int64 |
| Start SeekOrigin |
| } |
| |
| var _mFileSeekRequest = _bindings.CreateLazyMarshaler(FileSeekRequest{}) |
| |
| func (msg *FileSeekRequest) Marshaler() _bindings.Marshaler { |
| return _mFileSeekRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileSeekRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileSeekRequest) InlineSize() int { |
| return 16 |
| } |
| |
| type FileSeekResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| S int32 |
| Offset uint64 |
| } |
| |
| var _mFileSeekResponse = _bindings.CreateLazyMarshaler(FileSeekResponse{}) |
| |
| func (msg *FileSeekResponse) Marshaler() _bindings.Marshaler { |
| return _mFileSeekResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileSeekResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileSeekResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type FileTruncateRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Length uint64 |
| } |
| |
| var _mFileTruncateRequest = _bindings.CreateLazyMarshaler(FileTruncateRequest{}) |
| |
| func (msg *FileTruncateRequest) Marshaler() _bindings.Marshaler { |
| return _mFileTruncateRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileTruncateRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileTruncateRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type FileTruncateResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mFileTruncateResponse = _bindings.CreateLazyMarshaler(FileTruncateResponse{}) |
| |
| func (msg *FileTruncateResponse) Marshaler() _bindings.Marshaler { |
| return _mFileTruncateResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileTruncateResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileTruncateResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type FileGetFlagsRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mFileGetFlagsRequest = _bindings.CreateLazyMarshaler(FileGetFlagsRequest{}) |
| |
| func (msg *FileGetFlagsRequest) Marshaler() _bindings.Marshaler { |
| return _mFileGetFlagsRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetFlagsRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetFlagsRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type FileGetFlagsResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| Flags uint32 |
| } |
| |
| var _mFileGetFlagsResponse = _bindings.CreateLazyMarshaler(FileGetFlagsResponse{}) |
| |
| func (msg *FileGetFlagsResponse) Marshaler() _bindings.Marshaler { |
| return _mFileGetFlagsResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetFlagsResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetFlagsResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type FileSetFlagsRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Flags uint32 |
| } |
| |
| var _mFileSetFlagsRequest = _bindings.CreateLazyMarshaler(FileSetFlagsRequest{}) |
| |
| func (msg *FileSetFlagsRequest) Marshaler() _bindings.Marshaler { |
| return _mFileSetFlagsRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileSetFlagsRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileSetFlagsRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type FileSetFlagsResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mFileSetFlagsResponse = _bindings.CreateLazyMarshaler(FileSetFlagsResponse{}) |
| |
| func (msg *FileSetFlagsResponse) Marshaler() _bindings.Marshaler { |
| return _mFileSetFlagsResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileSetFlagsResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileSetFlagsResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type FileGetBufferRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Flags uint32 |
| } |
| |
| var _mFileGetBufferRequest = _bindings.CreateLazyMarshaler(FileGetBufferRequest{}) |
| |
| func (msg *FileGetBufferRequest) Marshaler() _bindings.Marshaler { |
| return _mFileGetBufferRequest |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetBufferRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetBufferRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type FileGetBufferResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| S int32 |
| Buffer *fuchsiamem.Buffer |
| } |
| |
| var _mFileGetBufferResponse = _bindings.CreateLazyMarshaler(FileGetBufferResponse{}) |
| |
| func (msg *FileGetBufferResponse) Marshaler() _bindings.Marshaler { |
| return _mFileGetBufferResponse |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetBufferResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *FileGetBufferResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type FileInterface _bindings.ChannelProxy |
| |
| func (p *FileInterface) Clone(flags uint32, object NodeInterfaceRequest) error { |
| req_ := FileCloneRequest{ |
| Flags: flags, |
| Object: object, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).Send(FileCloneOrdinal, &req_) |
| return err |
| } |
| |
| func (p *FileInterface) Close() (int32, error) { |
| req_ := FileCloseRequest{} |
| resp_ := FileCloseResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileCloseOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *FileInterface) Describe() (NodeInfo, error) { |
| req_ := FileDescribeRequest{} |
| resp_ := FileDescribeResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileDescribeOrdinal, &req_, &resp_) |
| return resp_.Info, err |
| } |
| |
| func (p *FileInterface) ExpectOnOpen() (int32, *NodeInfo, error) { |
| resp_ := FileOnOpenResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Recv(FileOnOpenOrdinal, &resp_) |
| return resp_.S, resp_.Info, err |
| } |
| |
| func (p *FileInterface) Sync() (int32, error) { |
| req_ := FileSyncRequest{} |
| resp_ := FileSyncResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileSyncOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *FileInterface) GetAttr() (int32, NodeAttributes, error) { |
| req_ := FileGetAttrRequest{} |
| resp_ := FileGetAttrResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileGetAttrOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Attributes, err |
| } |
| |
| func (p *FileInterface) SetAttr(flags uint32, attributes NodeAttributes) (int32, error) { |
| req_ := FileSetAttrRequest{ |
| Flags: flags, |
| Attributes: attributes, |
| } |
| resp_ := FileSetAttrResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileSetAttrOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *FileInterface) Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) { |
| req_ := FileIoctlRequest{ |
| Opcode: opcode, |
| MaxOut: maxOut, |
| Handles: handles, |
| In: in, |
| } |
| resp_ := FileIoctlResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileIoctlOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Handles, resp_.Out, err |
| } |
| |
| func (p *FileInterface) Read(count uint64) (int32, []uint8, error) { |
| req_ := FileReadRequest{ |
| Count: count, |
| } |
| resp_ := FileReadResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileReadOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Data, err |
| } |
| |
| func (p *FileInterface) ReadAt(count uint64, offset uint64) (int32, []uint8, error) { |
| req_ := FileReadAtRequest{ |
| Count: count, |
| Offset: offset, |
| } |
| resp_ := FileReadAtResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileReadAtOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Data, err |
| } |
| |
| func (p *FileInterface) Write(data []uint8) (int32, uint64, error) { |
| req_ := FileWriteRequest{ |
| Data: data, |
| } |
| resp_ := FileWriteResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileWriteOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Actual, err |
| } |
| |
| func (p *FileInterface) WriteAt(data []uint8, offset uint64) (int32, uint64, error) { |
| req_ := FileWriteAtRequest{ |
| Data: data, |
| Offset: offset, |
| } |
| resp_ := FileWriteAtResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileWriteAtOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Actual, err |
| } |
| |
| func (p *FileInterface) Seek(offset int64, start SeekOrigin) (int32, uint64, error) { |
| req_ := FileSeekRequest{ |
| Offset: offset, |
| Start: start, |
| } |
| resp_ := FileSeekResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileSeekOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Offset, err |
| } |
| |
| func (p *FileInterface) Truncate(length uint64) (int32, error) { |
| req_ := FileTruncateRequest{ |
| Length: length, |
| } |
| resp_ := FileTruncateResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileTruncateOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *FileInterface) GetFlags() (int32, uint32, error) { |
| req_ := FileGetFlagsRequest{} |
| resp_ := FileGetFlagsResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileGetFlagsOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Flags, err |
| } |
| |
| func (p *FileInterface) SetFlags(flags uint32) (int32, error) { |
| req_ := FileSetFlagsRequest{ |
| Flags: flags, |
| } |
| resp_ := FileSetFlagsResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileSetFlagsOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *FileInterface) GetBuffer(flags uint32) (int32, *fuchsiamem.Buffer, error) { |
| req_ := FileGetBufferRequest{ |
| Flags: flags, |
| } |
| resp_ := FileGetBufferResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(FileGetBufferOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Buffer, err |
| } |
| |
| type File interface { |
| Clone(flags uint32, object NodeInterfaceRequest) error |
| Close() (int32, error) |
| Describe() (NodeInfo, error) |
| Sync() (int32, error) |
| GetAttr() (int32, NodeAttributes, error) |
| SetAttr(flags uint32, attributes NodeAttributes) (int32, error) |
| Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) |
| Read(count uint64) (int32, []uint8, error) |
| ReadAt(count uint64, offset uint64) (int32, []uint8, error) |
| Write(data []uint8) (int32, uint64, error) |
| WriteAt(data []uint8, offset uint64) (int32, uint64, error) |
| Seek(offset int64, start SeekOrigin) (int32, uint64, error) |
| Truncate(length uint64) (int32, error) |
| GetFlags() (int32, uint32, error) |
| SetFlags(flags uint32) (int32, error) |
| GetBuffer(flags uint32) (int32, *fuchsiamem.Buffer, error) |
| } |
| |
| type FileTransitionalBase struct{} |
| |
| type FileInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewFileInterfaceRequest() (FileInterfaceRequest, *FileInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return FileInterfaceRequest(req), (*FileInterface)(cli), err |
| } |
| |
| type FileStub struct { |
| Impl File |
| } |
| |
| func (s *FileStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) { |
| switch ord { |
| case FileCloneOrdinal: |
| in_ := FileCloneRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.Clone(in_.Flags, in_.Object) |
| return nil, err_ |
| case FileCloseOrdinal: |
| in_ := FileCloseRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileCloseResponse{} |
| s, err_ := s.Impl.Close() |
| out_.S = s |
| return &out_, err_ |
| case FileDescribeOrdinal: |
| in_ := FileDescribeRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileDescribeResponse{} |
| info, err_ := s.Impl.Describe() |
| out_.Info = info |
| return &out_, err_ |
| case FileSyncOrdinal: |
| in_ := FileSyncRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileSyncResponse{} |
| s, err_ := s.Impl.Sync() |
| out_.S = s |
| return &out_, err_ |
| case FileGetAttrOrdinal: |
| in_ := FileGetAttrRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileGetAttrResponse{} |
| s, attributes, err_ := s.Impl.GetAttr() |
| out_.S = s |
| out_.Attributes = attributes |
| return &out_, err_ |
| case FileSetAttrOrdinal: |
| in_ := FileSetAttrRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileSetAttrResponse{} |
| s, err_ := s.Impl.SetAttr(in_.Flags, in_.Attributes) |
| out_.S = s |
| return &out_, err_ |
| case FileIoctlOrdinal: |
| in_ := FileIoctlRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileIoctlResponse{} |
| s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode, in_.MaxOut, in_.Handles, in_.In) |
| out_.S = s |
| out_.Handles = handles |
| out_.Out = out |
| return &out_, err_ |
| case FileReadOrdinal: |
| in_ := FileReadRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileReadResponse{} |
| s, data, err_ := s.Impl.Read(in_.Count) |
| out_.S = s |
| out_.Data = data |
| return &out_, err_ |
| case FileReadAtOrdinal: |
| in_ := FileReadAtRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileReadAtResponse{} |
| s, data, err_ := s.Impl.ReadAt(in_.Count, in_.Offset) |
| out_.S = s |
| out_.Data = data |
| return &out_, err_ |
| case FileWriteOrdinal: |
| in_ := FileWriteRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileWriteResponse{} |
| s, actual, err_ := s.Impl.Write(in_.Data) |
| out_.S = s |
| out_.Actual = actual |
| return &out_, err_ |
| case FileWriteAtOrdinal: |
| in_ := FileWriteAtRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileWriteAtResponse{} |
| s, actual, err_ := s.Impl.WriteAt(in_.Data, in_.Offset) |
| out_.S = s |
| out_.Actual = actual |
| return &out_, err_ |
| case FileSeekOrdinal: |
| in_ := FileSeekRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileSeekResponse{} |
| s, offset, err_ := s.Impl.Seek(in_.Offset, in_.Start) |
| out_.S = s |
| out_.Offset = offset |
| return &out_, err_ |
| case FileTruncateOrdinal: |
| in_ := FileTruncateRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileTruncateResponse{} |
| s, err_ := s.Impl.Truncate(in_.Length) |
| out_.S = s |
| return &out_, err_ |
| case FileGetFlagsOrdinal: |
| in_ := FileGetFlagsRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileGetFlagsResponse{} |
| s, flags, err_ := s.Impl.GetFlags() |
| out_.S = s |
| out_.Flags = flags |
| return &out_, err_ |
| case FileSetFlagsOrdinal: |
| in_ := FileSetFlagsRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileSetFlagsResponse{} |
| s, err_ := s.Impl.SetFlags(in_.Flags) |
| out_.S = s |
| return &out_, err_ |
| case FileGetBufferOrdinal: |
| in_ := FileGetBufferRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := FileGetBufferResponse{} |
| s, buffer, err_ := s.Impl.GetBuffer(in_.Flags) |
| out_.S = s |
| out_.Buffer = buffer |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| |
| type FileService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *FileService) Add(impl File, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&FileStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *FileService) EventProxyFor(key _bindings.BindingKey) (*FileEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*FileEventProxy)(pxy), err |
| } |
| |
| type FileEventProxy _bindings.ChannelProxy |
| |
| func (p *FileEventProxy) OnOpen(s int32, info *NodeInfo) error { |
| event_ := FileOnOpenResponse{ |
| S: s, |
| Info: info, |
| } |
| return ((*_bindings.ChannelProxy)(p)).Send(FileOnOpenOrdinal, &event_) |
| } |
| |
| const ( |
| DirectoryWatcherOnEventOrdinal uint32 = 546032797 |
| DirectoryWatcherOnEventGenOrdinal uint32 = 546032797 |
| ) |
| |
| type DirectoryWatcherOnEventRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Events []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mDirectoryWatcherOnEventRequest = _bindings.CreateLazyMarshaler(DirectoryWatcherOnEventRequest{}) |
| |
| func (msg *DirectoryWatcherOnEventRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryWatcherOnEventRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryWatcherOnEventRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryWatcherOnEventRequest) InlineSize() int { |
| return 16 |
| } |
| |
| type DirectoryWatcherInterface _bindings.ChannelProxy |
| |
| func (p *DirectoryWatcherInterface) OnEvent(events []uint8) error { |
| req_ := DirectoryWatcherOnEventRequest{ |
| Events: events, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryWatcherOnEventOrdinal, &req_) |
| return err |
| } |
| |
| type DirectoryWatcher interface { |
| OnEvent(events []uint8) error |
| } |
| |
| type DirectoryWatcherTransitionalBase struct{} |
| |
| type DirectoryWatcherInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewDirectoryWatcherInterfaceRequest() (DirectoryWatcherInterfaceRequest, *DirectoryWatcherInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return DirectoryWatcherInterfaceRequest(req), (*DirectoryWatcherInterface)(cli), err |
| } |
| |
| type DirectoryWatcherStub struct { |
| Impl DirectoryWatcher |
| } |
| |
| func (s *DirectoryWatcherStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) { |
| switch ord { |
| case DirectoryWatcherOnEventOrdinal: |
| in_ := DirectoryWatcherOnEventRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.OnEvent(in_.Events) |
| return nil, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| |
| type DirectoryWatcherService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *DirectoryWatcherService) Add(impl DirectoryWatcher, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&DirectoryWatcherStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *DirectoryWatcherService) EventProxyFor(key _bindings.BindingKey) (*DirectoryWatcherEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*DirectoryWatcherEventProxy)(pxy), err |
| } |
| |
| type DirectoryWatcherEventProxy _bindings.ChannelProxy |
| |
| const ( |
| DirectoryCloneOrdinal uint32 = 402549324 |
| DirectoryCloneGenOrdinal uint32 = 402549324 |
| DirectoryCloseOrdinal uint32 = 1387878023 |
| DirectoryCloseGenOrdinal uint32 = 1387878023 |
| DirectoryDescribeOrdinal uint32 = 526573406 |
| DirectoryDescribeGenOrdinal uint32 = 526573406 |
| DirectoryOnOpenOrdinal uint32 = 1191225277 |
| DirectoryOnOpenGenOrdinal uint32 = 1191225277 |
| DirectorySyncOrdinal uint32 = 1648508842 |
| DirectorySyncGenOrdinal uint32 = 1648508842 |
| DirectoryGetAttrOrdinal uint32 = 1166403528 |
| DirectoryGetAttrGenOrdinal uint32 = 1166403528 |
| DirectorySetAttrOrdinal uint32 = 198530458 |
| DirectorySetAttrGenOrdinal uint32 = 198530458 |
| DirectoryIoctlOrdinal uint32 = 905161895 |
| DirectoryIoctlGenOrdinal uint32 = 905161895 |
| DirectoryOpenOrdinal uint32 = 2011483371 |
| DirectoryOpenGenOrdinal uint32 = 2011483371 |
| DirectoryUnlinkOrdinal uint32 = 750443289 |
| DirectoryUnlinkGenOrdinal uint32 = 750443289 |
| DirectoryReadDirentsOrdinal uint32 = 782580781 |
| DirectoryReadDirentsGenOrdinal uint32 = 782580781 |
| DirectoryRewindOrdinal uint32 = 1886584199 |
| DirectoryRewindGenOrdinal uint32 = 1886584199 |
| DirectoryGetTokenOrdinal uint32 = 840416493 |
| DirectoryGetTokenGenOrdinal uint32 = 840416493 |
| DirectoryRenameOrdinal uint32 = 1251258540 |
| DirectoryRenameGenOrdinal uint32 = 1251258540 |
| DirectoryLinkOrdinal uint32 = 462052964 |
| DirectoryLinkGenOrdinal uint32 = 462052964 |
| DirectoryWatchOrdinal uint32 = 1522700084 |
| DirectoryWatchGenOrdinal uint32 = 1522700084 |
| ) |
| |
| type DirectoryCloneRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Flags uint32 |
| Object NodeInterfaceRequest `fidl2:"0"` |
| } |
| |
| var _mDirectoryCloneRequest = _bindings.CreateLazyMarshaler(DirectoryCloneRequest{}) |
| |
| func (msg *DirectoryCloneRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryCloneRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryCloneRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryCloneRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryCloseRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryCloseRequest = _bindings.CreateLazyMarshaler(DirectoryCloseRequest{}) |
| |
| func (msg *DirectoryCloseRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryCloseRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryCloseRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryCloseRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryCloseResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryCloseResponse = _bindings.CreateLazyMarshaler(DirectoryCloseResponse{}) |
| |
| func (msg *DirectoryCloseResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryCloseResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryCloseResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryCloseResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryDescribeRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryDescribeRequest = _bindings.CreateLazyMarshaler(DirectoryDescribeRequest{}) |
| |
| func (msg *DirectoryDescribeRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryDescribeRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryDescribeRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryDescribeRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryDescribeResponse struct { |
| _ struct{} `fidl2:"s,32,0"` |
| Info NodeInfo |
| } |
| |
| var _mDirectoryDescribeResponse = _bindings.CreateLazyMarshaler(DirectoryDescribeResponse{}) |
| |
| func (msg *DirectoryDescribeResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryDescribeResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryDescribeResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryDescribeResponse) InlineSize() int { |
| return 32 |
| } |
| |
| type DirectoryOnOpenResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| S int32 |
| Info *NodeInfo |
| } |
| |
| var _mDirectoryOnOpenResponse = _bindings.CreateLazyMarshaler(DirectoryOnOpenResponse{}) |
| |
| func (msg *DirectoryOnOpenResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryOnOpenResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryOnOpenResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryOnOpenResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type DirectorySyncRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectorySyncRequest = _bindings.CreateLazyMarshaler(DirectorySyncRequest{}) |
| |
| func (msg *DirectorySyncRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectorySyncRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectorySyncRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectorySyncRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectorySyncResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectorySyncResponse = _bindings.CreateLazyMarshaler(DirectorySyncResponse{}) |
| |
| func (msg *DirectorySyncResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectorySyncResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectorySyncResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectorySyncResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryGetAttrRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryGetAttrRequest = _bindings.CreateLazyMarshaler(DirectoryGetAttrRequest{}) |
| |
| func (msg *DirectoryGetAttrRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryGetAttrRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryGetAttrRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryGetAttrRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryGetAttrResponse struct { |
| _ struct{} `fidl2:"s,64,0"` |
| S int32 |
| Attributes NodeAttributes |
| } |
| |
| var _mDirectoryGetAttrResponse = _bindings.CreateLazyMarshaler(DirectoryGetAttrResponse{}) |
| |
| func (msg *DirectoryGetAttrResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryGetAttrResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryGetAttrResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryGetAttrResponse) InlineSize() int { |
| return 64 |
| } |
| |
| type DirectorySetAttrRequest struct { |
| _ struct{} `fidl2:"s,64,0"` |
| Flags uint32 |
| Attributes NodeAttributes |
| } |
| |
| var _mDirectorySetAttrRequest = _bindings.CreateLazyMarshaler(DirectorySetAttrRequest{}) |
| |
| func (msg *DirectorySetAttrRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectorySetAttrRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectorySetAttrRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectorySetAttrRequest) InlineSize() int { |
| return 64 |
| } |
| |
| type DirectorySetAttrResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectorySetAttrResponse = _bindings.CreateLazyMarshaler(DirectorySetAttrResponse{}) |
| |
| func (msg *DirectorySetAttrResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectorySetAttrResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectorySetAttrResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectorySetAttrResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryIoctlRequest struct { |
| _ struct{} `fidl2:"s,48,0"` |
| Opcode uint32 |
| MaxOut uint64 |
| Handles []_zx.Handle `fidl:"2" fidl2:"2,0"` |
| In []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mDirectoryIoctlRequest = _bindings.CreateLazyMarshaler(DirectoryIoctlRequest{}) |
| |
| func (msg *DirectoryIoctlRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryIoctlRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryIoctlRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryIoctlRequest) InlineSize() int { |
| return 48 |
| } |
| |
| type DirectoryIoctlResponse struct { |
| _ struct{} `fidl2:"s,40,0"` |
| S int32 |
| Handles []_zx.Handle `fidl:"2" fidl2:"2,0"` |
| Out []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mDirectoryIoctlResponse = _bindings.CreateLazyMarshaler(DirectoryIoctlResponse{}) |
| |
| func (msg *DirectoryIoctlResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryIoctlResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryIoctlResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryIoctlResponse) InlineSize() int { |
| return 40 |
| } |
| |
| type DirectoryOpenRequest struct { |
| _ struct{} `fidl2:"s,32,0"` |
| Flags uint32 |
| Mode uint32 |
| Path string `fidl:"4096" fidl2:"4096"` |
| Object NodeInterfaceRequest `fidl2:"0"` |
| } |
| |
| var _mDirectoryOpenRequest = _bindings.CreateLazyMarshaler(DirectoryOpenRequest{}) |
| |
| func (msg *DirectoryOpenRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryOpenRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryOpenRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryOpenRequest) InlineSize() int { |
| return 32 |
| } |
| |
| type DirectoryUnlinkRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Path string `fidl:"4096" fidl2:"4096"` |
| } |
| |
| var _mDirectoryUnlinkRequest = _bindings.CreateLazyMarshaler(DirectoryUnlinkRequest{}) |
| |
| func (msg *DirectoryUnlinkRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryUnlinkRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryUnlinkRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryUnlinkRequest) InlineSize() int { |
| return 16 |
| } |
| |
| type DirectoryUnlinkResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryUnlinkResponse = _bindings.CreateLazyMarshaler(DirectoryUnlinkResponse{}) |
| |
| func (msg *DirectoryUnlinkResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryUnlinkResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryUnlinkResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryUnlinkResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryReadDirentsRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| MaxBytes uint64 |
| } |
| |
| var _mDirectoryReadDirentsRequest = _bindings.CreateLazyMarshaler(DirectoryReadDirentsRequest{}) |
| |
| func (msg *DirectoryReadDirentsRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryReadDirentsRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryReadDirentsRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryReadDirentsRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryReadDirentsResponse struct { |
| _ struct{} `fidl2:"s,24,0"` |
| S int32 |
| Dirents []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mDirectoryReadDirentsResponse = _bindings.CreateLazyMarshaler(DirectoryReadDirentsResponse{}) |
| |
| func (msg *DirectoryReadDirentsResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryReadDirentsResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryReadDirentsResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryReadDirentsResponse) InlineSize() int { |
| return 24 |
| } |
| |
| type DirectoryRewindRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryRewindRequest = _bindings.CreateLazyMarshaler(DirectoryRewindRequest{}) |
| |
| func (msg *DirectoryRewindRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryRewindRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryRewindRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryRewindRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryRewindResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryRewindResponse = _bindings.CreateLazyMarshaler(DirectoryRewindResponse{}) |
| |
| func (msg *DirectoryRewindResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryRewindResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryRewindResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryRewindResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryGetTokenRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryGetTokenRequest = _bindings.CreateLazyMarshaler(DirectoryGetTokenRequest{}) |
| |
| func (msg *DirectoryGetTokenRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryGetTokenRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryGetTokenRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryGetTokenRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryGetTokenResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| Token _zx.Handle `fidl:"*" fidl2:"1"` |
| } |
| |
| var _mDirectoryGetTokenResponse = _bindings.CreateLazyMarshaler(DirectoryGetTokenResponse{}) |
| |
| func (msg *DirectoryGetTokenResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryGetTokenResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryGetTokenResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryGetTokenResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryRenameRequest struct { |
| _ struct{} `fidl2:"s,40,0"` |
| Src string `fidl:"4096" fidl2:"4096"` |
| DstParentToken _zx.Handle `fidl2:"0"` |
| Dst string `fidl:"4096" fidl2:"4096"` |
| } |
| |
| var _mDirectoryRenameRequest = _bindings.CreateLazyMarshaler(DirectoryRenameRequest{}) |
| |
| func (msg *DirectoryRenameRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryRenameRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryRenameRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryRenameRequest) InlineSize() int { |
| return 40 |
| } |
| |
| type DirectoryRenameResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryRenameResponse = _bindings.CreateLazyMarshaler(DirectoryRenameResponse{}) |
| |
| func (msg *DirectoryRenameResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryRenameResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryRenameResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryRenameResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryLinkRequest struct { |
| _ struct{} `fidl2:"s,40,0"` |
| Src string `fidl:"4096" fidl2:"4096"` |
| DstParentToken _zx.Handle `fidl2:"0"` |
| Dst string `fidl:"4096" fidl2:"4096"` |
| } |
| |
| var _mDirectoryLinkRequest = _bindings.CreateLazyMarshaler(DirectoryLinkRequest{}) |
| |
| func (msg *DirectoryLinkRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryLinkRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryLinkRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryLinkRequest) InlineSize() int { |
| return 40 |
| } |
| |
| type DirectoryLinkResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryLinkResponse = _bindings.CreateLazyMarshaler(DirectoryLinkResponse{}) |
| |
| func (msg *DirectoryLinkResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryLinkResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryLinkResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryLinkResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryWatchRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Mask uint32 |
| Options uint32 |
| Watcher _zx.Channel `fidl2:"0"` |
| } |
| |
| var _mDirectoryWatchRequest = _bindings.CreateLazyMarshaler(DirectoryWatchRequest{}) |
| |
| func (msg *DirectoryWatchRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryWatchRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryWatchRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryWatchRequest) InlineSize() int { |
| return 16 |
| } |
| |
| type DirectoryWatchResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryWatchResponse = _bindings.CreateLazyMarshaler(DirectoryWatchResponse{}) |
| |
| func (msg *DirectoryWatchResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryWatchResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryWatchResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryWatchResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryInterface _bindings.ChannelProxy |
| |
| func (p *DirectoryInterface) Clone(flags uint32, object NodeInterfaceRequest) error { |
| req_ := DirectoryCloneRequest{ |
| Flags: flags, |
| Object: object, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryCloneOrdinal, &req_) |
| return err |
| } |
| |
| func (p *DirectoryInterface) Close() (int32, error) { |
| req_ := DirectoryCloseRequest{} |
| resp_ := DirectoryCloseResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryCloseOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryInterface) Describe() (NodeInfo, error) { |
| req_ := DirectoryDescribeRequest{} |
| resp_ := DirectoryDescribeResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryDescribeOrdinal, &req_, &resp_) |
| return resp_.Info, err |
| } |
| |
| func (p *DirectoryInterface) ExpectOnOpen() (int32, *NodeInfo, error) { |
| resp_ := DirectoryOnOpenResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Recv(DirectoryOnOpenOrdinal, &resp_) |
| return resp_.S, resp_.Info, err |
| } |
| |
| func (p *DirectoryInterface) Sync() (int32, error) { |
| req_ := DirectorySyncRequest{} |
| resp_ := DirectorySyncResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectorySyncOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryInterface) GetAttr() (int32, NodeAttributes, error) { |
| req_ := DirectoryGetAttrRequest{} |
| resp_ := DirectoryGetAttrResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetAttrOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Attributes, err |
| } |
| |
| func (p *DirectoryInterface) SetAttr(flags uint32, attributes NodeAttributes) (int32, error) { |
| req_ := DirectorySetAttrRequest{ |
| Flags: flags, |
| Attributes: attributes, |
| } |
| resp_ := DirectorySetAttrResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectorySetAttrOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryInterface) Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) { |
| req_ := DirectoryIoctlRequest{ |
| Opcode: opcode, |
| MaxOut: maxOut, |
| Handles: handles, |
| In: in, |
| } |
| resp_ := DirectoryIoctlResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryIoctlOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Handles, resp_.Out, err |
| } |
| |
| func (p *DirectoryInterface) Open(flags uint32, mode uint32, path string, object NodeInterfaceRequest) error { |
| req_ := DirectoryOpenRequest{ |
| Flags: flags, |
| Mode: mode, |
| Path: path, |
| Object: object, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryOpenOrdinal, &req_) |
| return err |
| } |
| |
| func (p *DirectoryInterface) Unlink(path string) (int32, error) { |
| req_ := DirectoryUnlinkRequest{ |
| Path: path, |
| } |
| resp_ := DirectoryUnlinkResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryUnlinkOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryInterface) ReadDirents(maxBytes uint64) (int32, []uint8, error) { |
| req_ := DirectoryReadDirentsRequest{ |
| MaxBytes: maxBytes, |
| } |
| resp_ := DirectoryReadDirentsResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryReadDirentsOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Dirents, err |
| } |
| |
| func (p *DirectoryInterface) Rewind() (int32, error) { |
| req_ := DirectoryRewindRequest{} |
| resp_ := DirectoryRewindResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryRewindOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryInterface) GetToken() (int32, _zx.Handle, error) { |
| req_ := DirectoryGetTokenRequest{} |
| resp_ := DirectoryGetTokenResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryGetTokenOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Token, err |
| } |
| |
| func (p *DirectoryInterface) Rename(src string, dstParentToken _zx.Handle, dst string) (int32, error) { |
| req_ := DirectoryRenameRequest{ |
| Src: src, |
| DstParentToken: dstParentToken, |
| Dst: dst, |
| } |
| resp_ := DirectoryRenameResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryRenameOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryInterface) Link(src string, dstParentToken _zx.Handle, dst string) (int32, error) { |
| req_ := DirectoryLinkRequest{ |
| Src: src, |
| DstParentToken: dstParentToken, |
| Dst: dst, |
| } |
| resp_ := DirectoryLinkResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryLinkOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryInterface) Watch(mask uint32, options uint32, watcher _zx.Channel) (int32, error) { |
| req_ := DirectoryWatchRequest{ |
| Mask: mask, |
| Options: options, |
| Watcher: watcher, |
| } |
| resp_ := DirectoryWatchResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryWatchOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| type Directory interface { |
| Clone(flags uint32, object NodeInterfaceRequest) error |
| Close() (int32, error) |
| Describe() (NodeInfo, error) |
| Sync() (int32, error) |
| GetAttr() (int32, NodeAttributes, error) |
| SetAttr(flags uint32, attributes NodeAttributes) (int32, error) |
| Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) |
| Open(flags uint32, mode uint32, path string, object NodeInterfaceRequest) error |
| Unlink(path string) (int32, error) |
| ReadDirents(maxBytes uint64) (int32, []uint8, error) |
| Rewind() (int32, error) |
| GetToken() (int32, _zx.Handle, error) |
| Rename(src string, dstParentToken _zx.Handle, dst string) (int32, error) |
| Link(src string, dstParentToken _zx.Handle, dst string) (int32, error) |
| Watch(mask uint32, options uint32, watcher _zx.Channel) (int32, error) |
| } |
| |
| type DirectoryTransitionalBase struct{} |
| |
| type DirectoryInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewDirectoryInterfaceRequest() (DirectoryInterfaceRequest, *DirectoryInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return DirectoryInterfaceRequest(req), (*DirectoryInterface)(cli), err |
| } |
| |
| type DirectoryStub struct { |
| Impl Directory |
| } |
| |
| func (s *DirectoryStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) { |
| switch ord { |
| case DirectoryCloneOrdinal: |
| in_ := DirectoryCloneRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.Clone(in_.Flags, in_.Object) |
| return nil, err_ |
| case DirectoryCloseOrdinal: |
| in_ := DirectoryCloseRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryCloseResponse{} |
| s, err_ := s.Impl.Close() |
| out_.S = s |
| return &out_, err_ |
| case DirectoryDescribeOrdinal: |
| in_ := DirectoryDescribeRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryDescribeResponse{} |
| info, err_ := s.Impl.Describe() |
| out_.Info = info |
| return &out_, err_ |
| case DirectorySyncOrdinal: |
| in_ := DirectorySyncRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectorySyncResponse{} |
| s, err_ := s.Impl.Sync() |
| out_.S = s |
| return &out_, err_ |
| case DirectoryGetAttrOrdinal: |
| in_ := DirectoryGetAttrRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryGetAttrResponse{} |
| s, attributes, err_ := s.Impl.GetAttr() |
| out_.S = s |
| out_.Attributes = attributes |
| return &out_, err_ |
| case DirectorySetAttrOrdinal: |
| in_ := DirectorySetAttrRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectorySetAttrResponse{} |
| s, err_ := s.Impl.SetAttr(in_.Flags, in_.Attributes) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryIoctlOrdinal: |
| in_ := DirectoryIoctlRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryIoctlResponse{} |
| s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode, in_.MaxOut, in_.Handles, in_.In) |
| out_.S = s |
| out_.Handles = handles |
| out_.Out = out |
| return &out_, err_ |
| case DirectoryOpenOrdinal: |
| in_ := DirectoryOpenRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.Open(in_.Flags, in_.Mode, in_.Path, in_.Object) |
| return nil, err_ |
| case DirectoryUnlinkOrdinal: |
| in_ := DirectoryUnlinkRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryUnlinkResponse{} |
| s, err_ := s.Impl.Unlink(in_.Path) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryReadDirentsOrdinal: |
| in_ := DirectoryReadDirentsRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryReadDirentsResponse{} |
| s, dirents, err_ := s.Impl.ReadDirents(in_.MaxBytes) |
| out_.S = s |
| out_.Dirents = dirents |
| return &out_, err_ |
| case DirectoryRewindOrdinal: |
| in_ := DirectoryRewindRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryRewindResponse{} |
| s, err_ := s.Impl.Rewind() |
| out_.S = s |
| return &out_, err_ |
| case DirectoryGetTokenOrdinal: |
| in_ := DirectoryGetTokenRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryGetTokenResponse{} |
| s, token, err_ := s.Impl.GetToken() |
| out_.S = s |
| out_.Token = token |
| return &out_, err_ |
| case DirectoryRenameOrdinal: |
| in_ := DirectoryRenameRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryRenameResponse{} |
| s, err_ := s.Impl.Rename(in_.Src, in_.DstParentToken, in_.Dst) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryLinkOrdinal: |
| in_ := DirectoryLinkRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryLinkResponse{} |
| s, err_ := s.Impl.Link(in_.Src, in_.DstParentToken, in_.Dst) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryWatchOrdinal: |
| in_ := DirectoryWatchRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryWatchResponse{} |
| s, err_ := s.Impl.Watch(in_.Mask, in_.Options, in_.Watcher) |
| out_.S = s |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| |
| type DirectoryService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *DirectoryService) Add(impl Directory, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&DirectoryStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *DirectoryService) EventProxyFor(key _bindings.BindingKey) (*DirectoryEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*DirectoryEventProxy)(pxy), err |
| } |
| |
| type DirectoryEventProxy _bindings.ChannelProxy |
| |
| func (p *DirectoryEventProxy) OnOpen(s int32, info *NodeInfo) error { |
| event_ := DirectoryOnOpenResponse{ |
| S: s, |
| Info: info, |
| } |
| return ((*_bindings.ChannelProxy)(p)).Send(DirectoryOnOpenOrdinal, &event_) |
| } |
| |
| const ( |
| DirectoryAdminCloneOrdinal uint32 = 402549324 |
| DirectoryAdminCloneGenOrdinal uint32 = 402549324 |
| DirectoryAdminCloseOrdinal uint32 = 1387878023 |
| DirectoryAdminCloseGenOrdinal uint32 = 1387878023 |
| DirectoryAdminDescribeOrdinal uint32 = 526573406 |
| DirectoryAdminDescribeGenOrdinal uint32 = 526573406 |
| DirectoryAdminOnOpenOrdinal uint32 = 1191225277 |
| DirectoryAdminOnOpenGenOrdinal uint32 = 1191225277 |
| DirectoryAdminSyncOrdinal uint32 = 1648508842 |
| DirectoryAdminSyncGenOrdinal uint32 = 1648508842 |
| DirectoryAdminGetAttrOrdinal uint32 = 1166403528 |
| DirectoryAdminGetAttrGenOrdinal uint32 = 1166403528 |
| DirectoryAdminSetAttrOrdinal uint32 = 198530458 |
| DirectoryAdminSetAttrGenOrdinal uint32 = 198530458 |
| DirectoryAdminIoctlOrdinal uint32 = 905161895 |
| DirectoryAdminIoctlGenOrdinal uint32 = 905161895 |
| DirectoryAdminOpenOrdinal uint32 = 2011483371 |
| DirectoryAdminOpenGenOrdinal uint32 = 2011483371 |
| DirectoryAdminUnlinkOrdinal uint32 = 750443289 |
| DirectoryAdminUnlinkGenOrdinal uint32 = 750443289 |
| DirectoryAdminReadDirentsOrdinal uint32 = 782580781 |
| DirectoryAdminReadDirentsGenOrdinal uint32 = 782580781 |
| DirectoryAdminRewindOrdinal uint32 = 1886584199 |
| DirectoryAdminRewindGenOrdinal uint32 = 1886584199 |
| DirectoryAdminGetTokenOrdinal uint32 = 840416493 |
| DirectoryAdminGetTokenGenOrdinal uint32 = 840416493 |
| DirectoryAdminRenameOrdinal uint32 = 1251258540 |
| DirectoryAdminRenameGenOrdinal uint32 = 1251258540 |
| DirectoryAdminLinkOrdinal uint32 = 462052964 |
| DirectoryAdminLinkGenOrdinal uint32 = 462052964 |
| DirectoryAdminWatchOrdinal uint32 = 1522700084 |
| DirectoryAdminWatchGenOrdinal uint32 = 1522700084 |
| DirectoryAdminMountOrdinal uint32 = 2120159974 |
| DirectoryAdminMountGenOrdinal uint32 = 2120159974 |
| DirectoryAdminMountAndCreateOrdinal uint32 = 841348753 |
| DirectoryAdminMountAndCreateGenOrdinal uint32 = 841348753 |
| DirectoryAdminUnmountOrdinal uint32 = 620898132 |
| DirectoryAdminUnmountGenOrdinal uint32 = 620898132 |
| DirectoryAdminUnmountNodeOrdinal uint32 = 383400103 |
| DirectoryAdminUnmountNodeGenOrdinal uint32 = 383400103 |
| DirectoryAdminQueryFilesystemOrdinal uint32 = 1713999250 |
| DirectoryAdminQueryFilesystemGenOrdinal uint32 = 1713999250 |
| DirectoryAdminGetDevicePathOrdinal uint32 = 787943096 |
| DirectoryAdminGetDevicePathGenOrdinal uint32 = 787943096 |
| ) |
| |
| type DirectoryAdminCloneRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Flags uint32 |
| Object NodeInterfaceRequest `fidl2:"0"` |
| } |
| |
| var _mDirectoryAdminCloneRequest = _bindings.CreateLazyMarshaler(DirectoryAdminCloneRequest{}) |
| |
| func (msg *DirectoryAdminCloneRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminCloneRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminCloneRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminCloneRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminCloseRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminCloseRequest = _bindings.CreateLazyMarshaler(DirectoryAdminCloseRequest{}) |
| |
| func (msg *DirectoryAdminCloseRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminCloseRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminCloseRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminCloseRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminCloseResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminCloseResponse = _bindings.CreateLazyMarshaler(DirectoryAdminCloseResponse{}) |
| |
| func (msg *DirectoryAdminCloseResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminCloseResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminCloseResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminCloseResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminDescribeRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminDescribeRequest = _bindings.CreateLazyMarshaler(DirectoryAdminDescribeRequest{}) |
| |
| func (msg *DirectoryAdminDescribeRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminDescribeRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminDescribeRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminDescribeRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminDescribeResponse struct { |
| _ struct{} `fidl2:"s,32,0"` |
| Info NodeInfo |
| } |
| |
| var _mDirectoryAdminDescribeResponse = _bindings.CreateLazyMarshaler(DirectoryAdminDescribeResponse{}) |
| |
| func (msg *DirectoryAdminDescribeResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminDescribeResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminDescribeResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminDescribeResponse) InlineSize() int { |
| return 32 |
| } |
| |
| type DirectoryAdminOnOpenResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| S int32 |
| Info *NodeInfo |
| } |
| |
| var _mDirectoryAdminOnOpenResponse = _bindings.CreateLazyMarshaler(DirectoryAdminOnOpenResponse{}) |
| |
| func (msg *DirectoryAdminOnOpenResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminOnOpenResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminOnOpenResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminOnOpenResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type DirectoryAdminSyncRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminSyncRequest = _bindings.CreateLazyMarshaler(DirectoryAdminSyncRequest{}) |
| |
| func (msg *DirectoryAdminSyncRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminSyncRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminSyncRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminSyncRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminSyncResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminSyncResponse = _bindings.CreateLazyMarshaler(DirectoryAdminSyncResponse{}) |
| |
| func (msg *DirectoryAdminSyncResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminSyncResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminSyncResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminSyncResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminGetAttrRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminGetAttrRequest = _bindings.CreateLazyMarshaler(DirectoryAdminGetAttrRequest{}) |
| |
| func (msg *DirectoryAdminGetAttrRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminGetAttrRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetAttrRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetAttrRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminGetAttrResponse struct { |
| _ struct{} `fidl2:"s,64,0"` |
| S int32 |
| Attributes NodeAttributes |
| } |
| |
| var _mDirectoryAdminGetAttrResponse = _bindings.CreateLazyMarshaler(DirectoryAdminGetAttrResponse{}) |
| |
| func (msg *DirectoryAdminGetAttrResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminGetAttrResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetAttrResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetAttrResponse) InlineSize() int { |
| return 64 |
| } |
| |
| type DirectoryAdminSetAttrRequest struct { |
| _ struct{} `fidl2:"s,64,0"` |
| Flags uint32 |
| Attributes NodeAttributes |
| } |
| |
| var _mDirectoryAdminSetAttrRequest = _bindings.CreateLazyMarshaler(DirectoryAdminSetAttrRequest{}) |
| |
| func (msg *DirectoryAdminSetAttrRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminSetAttrRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminSetAttrRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminSetAttrRequest) InlineSize() int { |
| return 64 |
| } |
| |
| type DirectoryAdminSetAttrResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminSetAttrResponse = _bindings.CreateLazyMarshaler(DirectoryAdminSetAttrResponse{}) |
| |
| func (msg *DirectoryAdminSetAttrResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminSetAttrResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminSetAttrResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminSetAttrResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminIoctlRequest struct { |
| _ struct{} `fidl2:"s,48,0"` |
| Opcode uint32 |
| MaxOut uint64 |
| Handles []_zx.Handle `fidl:"2" fidl2:"2,0"` |
| In []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mDirectoryAdminIoctlRequest = _bindings.CreateLazyMarshaler(DirectoryAdminIoctlRequest{}) |
| |
| func (msg *DirectoryAdminIoctlRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminIoctlRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminIoctlRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminIoctlRequest) InlineSize() int { |
| return 48 |
| } |
| |
| type DirectoryAdminIoctlResponse struct { |
| _ struct{} `fidl2:"s,40,0"` |
| S int32 |
| Handles []_zx.Handle `fidl:"2" fidl2:"2,0"` |
| Out []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mDirectoryAdminIoctlResponse = _bindings.CreateLazyMarshaler(DirectoryAdminIoctlResponse{}) |
| |
| func (msg *DirectoryAdminIoctlResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminIoctlResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminIoctlResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminIoctlResponse) InlineSize() int { |
| return 40 |
| } |
| |
| type DirectoryAdminOpenRequest struct { |
| _ struct{} `fidl2:"s,32,0"` |
| Flags uint32 |
| Mode uint32 |
| Path string `fidl:"4096" fidl2:"4096"` |
| Object NodeInterfaceRequest `fidl2:"0"` |
| } |
| |
| var _mDirectoryAdminOpenRequest = _bindings.CreateLazyMarshaler(DirectoryAdminOpenRequest{}) |
| |
| func (msg *DirectoryAdminOpenRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminOpenRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminOpenRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminOpenRequest) InlineSize() int { |
| return 32 |
| } |
| |
| type DirectoryAdminUnlinkRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Path string `fidl:"4096" fidl2:"4096"` |
| } |
| |
| var _mDirectoryAdminUnlinkRequest = _bindings.CreateLazyMarshaler(DirectoryAdminUnlinkRequest{}) |
| |
| func (msg *DirectoryAdminUnlinkRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminUnlinkRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnlinkRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnlinkRequest) InlineSize() int { |
| return 16 |
| } |
| |
| type DirectoryAdminUnlinkResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminUnlinkResponse = _bindings.CreateLazyMarshaler(DirectoryAdminUnlinkResponse{}) |
| |
| func (msg *DirectoryAdminUnlinkResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminUnlinkResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnlinkResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnlinkResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminReadDirentsRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| MaxBytes uint64 |
| } |
| |
| var _mDirectoryAdminReadDirentsRequest = _bindings.CreateLazyMarshaler(DirectoryAdminReadDirentsRequest{}) |
| |
| func (msg *DirectoryAdminReadDirentsRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminReadDirentsRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminReadDirentsRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminReadDirentsRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminReadDirentsResponse struct { |
| _ struct{} `fidl2:"s,24,0"` |
| S int32 |
| Dirents []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mDirectoryAdminReadDirentsResponse = _bindings.CreateLazyMarshaler(DirectoryAdminReadDirentsResponse{}) |
| |
| func (msg *DirectoryAdminReadDirentsResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminReadDirentsResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminReadDirentsResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminReadDirentsResponse) InlineSize() int { |
| return 24 |
| } |
| |
| type DirectoryAdminRewindRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminRewindRequest = _bindings.CreateLazyMarshaler(DirectoryAdminRewindRequest{}) |
| |
| func (msg *DirectoryAdminRewindRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminRewindRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminRewindRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminRewindRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminRewindResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminRewindResponse = _bindings.CreateLazyMarshaler(DirectoryAdminRewindResponse{}) |
| |
| func (msg *DirectoryAdminRewindResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminRewindResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminRewindResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminRewindResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminGetTokenRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminGetTokenRequest = _bindings.CreateLazyMarshaler(DirectoryAdminGetTokenRequest{}) |
| |
| func (msg *DirectoryAdminGetTokenRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminGetTokenRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetTokenRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetTokenRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminGetTokenResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| Token _zx.Handle `fidl:"*" fidl2:"1"` |
| } |
| |
| var _mDirectoryAdminGetTokenResponse = _bindings.CreateLazyMarshaler(DirectoryAdminGetTokenResponse{}) |
| |
| func (msg *DirectoryAdminGetTokenResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminGetTokenResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetTokenResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetTokenResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminRenameRequest struct { |
| _ struct{} `fidl2:"s,40,0"` |
| Src string `fidl:"4096" fidl2:"4096"` |
| DstParentToken _zx.Handle `fidl2:"0"` |
| Dst string `fidl:"4096" fidl2:"4096"` |
| } |
| |
| var _mDirectoryAdminRenameRequest = _bindings.CreateLazyMarshaler(DirectoryAdminRenameRequest{}) |
| |
| func (msg *DirectoryAdminRenameRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminRenameRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminRenameRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminRenameRequest) InlineSize() int { |
| return 40 |
| } |
| |
| type DirectoryAdminRenameResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminRenameResponse = _bindings.CreateLazyMarshaler(DirectoryAdminRenameResponse{}) |
| |
| func (msg *DirectoryAdminRenameResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminRenameResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminRenameResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminRenameResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminLinkRequest struct { |
| _ struct{} `fidl2:"s,40,0"` |
| Src string `fidl:"4096" fidl2:"4096"` |
| DstParentToken _zx.Handle `fidl2:"0"` |
| Dst string `fidl:"4096" fidl2:"4096"` |
| } |
| |
| var _mDirectoryAdminLinkRequest = _bindings.CreateLazyMarshaler(DirectoryAdminLinkRequest{}) |
| |
| func (msg *DirectoryAdminLinkRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminLinkRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminLinkRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminLinkRequest) InlineSize() int { |
| return 40 |
| } |
| |
| type DirectoryAdminLinkResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminLinkResponse = _bindings.CreateLazyMarshaler(DirectoryAdminLinkResponse{}) |
| |
| func (msg *DirectoryAdminLinkResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminLinkResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminLinkResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminLinkResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminWatchRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Mask uint32 |
| Options uint32 |
| Watcher _zx.Channel `fidl2:"0"` |
| } |
| |
| var _mDirectoryAdminWatchRequest = _bindings.CreateLazyMarshaler(DirectoryAdminWatchRequest{}) |
| |
| func (msg *DirectoryAdminWatchRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminWatchRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminWatchRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminWatchRequest) InlineSize() int { |
| return 16 |
| } |
| |
| type DirectoryAdminWatchResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminWatchResponse = _bindings.CreateLazyMarshaler(DirectoryAdminWatchResponse{}) |
| |
| func (msg *DirectoryAdminWatchResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminWatchResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminWatchResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminWatchResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminMountRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Remote DirectoryInterface |
| } |
| |
| var _mDirectoryAdminMountRequest = _bindings.CreateLazyMarshaler(DirectoryAdminMountRequest{}) |
| |
| func (msg *DirectoryAdminMountRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminMountRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminMountRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminMountRequest) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminMountResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminMountResponse = _bindings.CreateLazyMarshaler(DirectoryAdminMountResponse{}) |
| |
| func (msg *DirectoryAdminMountResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminMountResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminMountResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminMountResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminMountAndCreateRequest struct { |
| _ struct{} `fidl2:"s,32,0"` |
| Remote DirectoryInterface |
| Name string `fidl:"255" fidl2:"255"` |
| Flags uint32 |
| } |
| |
| var _mDirectoryAdminMountAndCreateRequest = _bindings.CreateLazyMarshaler(DirectoryAdminMountAndCreateRequest{}) |
| |
| func (msg *DirectoryAdminMountAndCreateRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminMountAndCreateRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminMountAndCreateRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminMountAndCreateRequest) InlineSize() int { |
| return 32 |
| } |
| |
| type DirectoryAdminMountAndCreateResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminMountAndCreateResponse = _bindings.CreateLazyMarshaler(DirectoryAdminMountAndCreateResponse{}) |
| |
| func (msg *DirectoryAdminMountAndCreateResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminMountAndCreateResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminMountAndCreateResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminMountAndCreateResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminUnmountRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminUnmountRequest = _bindings.CreateLazyMarshaler(DirectoryAdminUnmountRequest{}) |
| |
| func (msg *DirectoryAdminUnmountRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminUnmountRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnmountRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnmountRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminUnmountResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| } |
| |
| var _mDirectoryAdminUnmountResponse = _bindings.CreateLazyMarshaler(DirectoryAdminUnmountResponse{}) |
| |
| func (msg *DirectoryAdminUnmountResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminUnmountResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnmountResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnmountResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminUnmountNodeRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminUnmountNodeRequest = _bindings.CreateLazyMarshaler(DirectoryAdminUnmountNodeRequest{}) |
| |
| func (msg *DirectoryAdminUnmountNodeRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminUnmountNodeRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnmountNodeRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnmountNodeRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminUnmountNodeResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| S int32 |
| Remote DirectoryInterface `fidl:"*"` |
| } |
| |
| var _mDirectoryAdminUnmountNodeResponse = _bindings.CreateLazyMarshaler(DirectoryAdminUnmountNodeResponse{}) |
| |
| func (msg *DirectoryAdminUnmountNodeResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminUnmountNodeResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnmountNodeResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminUnmountNodeResponse) InlineSize() int { |
| return 8 |
| } |
| |
| type DirectoryAdminQueryFilesystemRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminQueryFilesystemRequest = _bindings.CreateLazyMarshaler(DirectoryAdminQueryFilesystemRequest{}) |
| |
| func (msg *DirectoryAdminQueryFilesystemRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminQueryFilesystemRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminQueryFilesystemRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminQueryFilesystemRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminQueryFilesystemResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| S int32 |
| Info *FilesystemInfo |
| } |
| |
| var _mDirectoryAdminQueryFilesystemResponse = _bindings.CreateLazyMarshaler(DirectoryAdminQueryFilesystemResponse{}) |
| |
| func (msg *DirectoryAdminQueryFilesystemResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminQueryFilesystemResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminQueryFilesystemResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminQueryFilesystemResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type DirectoryAdminGetDevicePathRequest struct { |
| _ struct{} `fidl2:"s,0,0"` |
| } |
| |
| var _mDirectoryAdminGetDevicePathRequest = _bindings.CreateLazyMarshaler(DirectoryAdminGetDevicePathRequest{}) |
| |
| func (msg *DirectoryAdminGetDevicePathRequest) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminGetDevicePathRequest |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetDevicePathRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetDevicePathRequest) InlineSize() int { |
| return 0 |
| } |
| |
| type DirectoryAdminGetDevicePathResponse struct { |
| _ struct{} `fidl2:"s,24,0"` |
| S int32 |
| Path *string `fidl:"4096" fidl2:"4096"` |
| } |
| |
| var _mDirectoryAdminGetDevicePathResponse = _bindings.CreateLazyMarshaler(DirectoryAdminGetDevicePathResponse{}) |
| |
| func (msg *DirectoryAdminGetDevicePathResponse) Marshaler() _bindings.Marshaler { |
| return _mDirectoryAdminGetDevicePathResponse |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetDevicePathResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *DirectoryAdminGetDevicePathResponse) InlineSize() int { |
| return 24 |
| } |
| |
| type DirectoryAdminInterface _bindings.ChannelProxy |
| |
| func (p *DirectoryAdminInterface) Clone(flags uint32, object NodeInterfaceRequest) error { |
| req_ := DirectoryAdminCloneRequest{ |
| Flags: flags, |
| Object: object, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryAdminCloneOrdinal, &req_) |
| return err |
| } |
| |
| func (p *DirectoryAdminInterface) Close() (int32, error) { |
| req_ := DirectoryAdminCloseRequest{} |
| resp_ := DirectoryAdminCloseResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminCloseOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) Describe() (NodeInfo, error) { |
| req_ := DirectoryAdminDescribeRequest{} |
| resp_ := DirectoryAdminDescribeResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminDescribeOrdinal, &req_, &resp_) |
| return resp_.Info, err |
| } |
| |
| func (p *DirectoryAdminInterface) ExpectOnOpen() (int32, *NodeInfo, error) { |
| resp_ := DirectoryAdminOnOpenResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Recv(DirectoryAdminOnOpenOrdinal, &resp_) |
| return resp_.S, resp_.Info, err |
| } |
| |
| func (p *DirectoryAdminInterface) Sync() (int32, error) { |
| req_ := DirectoryAdminSyncRequest{} |
| resp_ := DirectoryAdminSyncResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminSyncOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) GetAttr() (int32, NodeAttributes, error) { |
| req_ := DirectoryAdminGetAttrRequest{} |
| resp_ := DirectoryAdminGetAttrResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminGetAttrOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Attributes, err |
| } |
| |
| func (p *DirectoryAdminInterface) SetAttr(flags uint32, attributes NodeAttributes) (int32, error) { |
| req_ := DirectoryAdminSetAttrRequest{ |
| Flags: flags, |
| Attributes: attributes, |
| } |
| resp_ := DirectoryAdminSetAttrResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminSetAttrOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) { |
| req_ := DirectoryAdminIoctlRequest{ |
| Opcode: opcode, |
| MaxOut: maxOut, |
| Handles: handles, |
| In: in, |
| } |
| resp_ := DirectoryAdminIoctlResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminIoctlOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Handles, resp_.Out, err |
| } |
| |
| func (p *DirectoryAdminInterface) Open(flags uint32, mode uint32, path string, object NodeInterfaceRequest) error { |
| req_ := DirectoryAdminOpenRequest{ |
| Flags: flags, |
| Mode: mode, |
| Path: path, |
| Object: object, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).Send(DirectoryAdminOpenOrdinal, &req_) |
| return err |
| } |
| |
| func (p *DirectoryAdminInterface) Unlink(path string) (int32, error) { |
| req_ := DirectoryAdminUnlinkRequest{ |
| Path: path, |
| } |
| resp_ := DirectoryAdminUnlinkResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminUnlinkOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) ReadDirents(maxBytes uint64) (int32, []uint8, error) { |
| req_ := DirectoryAdminReadDirentsRequest{ |
| MaxBytes: maxBytes, |
| } |
| resp_ := DirectoryAdminReadDirentsResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminReadDirentsOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Dirents, err |
| } |
| |
| func (p *DirectoryAdminInterface) Rewind() (int32, error) { |
| req_ := DirectoryAdminRewindRequest{} |
| resp_ := DirectoryAdminRewindResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminRewindOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) GetToken() (int32, _zx.Handle, error) { |
| req_ := DirectoryAdminGetTokenRequest{} |
| resp_ := DirectoryAdminGetTokenResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminGetTokenOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Token, err |
| } |
| |
| func (p *DirectoryAdminInterface) Rename(src string, dstParentToken _zx.Handle, dst string) (int32, error) { |
| req_ := DirectoryAdminRenameRequest{ |
| Src: src, |
| DstParentToken: dstParentToken, |
| Dst: dst, |
| } |
| resp_ := DirectoryAdminRenameResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminRenameOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) Link(src string, dstParentToken _zx.Handle, dst string) (int32, error) { |
| req_ := DirectoryAdminLinkRequest{ |
| Src: src, |
| DstParentToken: dstParentToken, |
| Dst: dst, |
| } |
| resp_ := DirectoryAdminLinkResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminLinkOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) Watch(mask uint32, options uint32, watcher _zx.Channel) (int32, error) { |
| req_ := DirectoryAdminWatchRequest{ |
| Mask: mask, |
| Options: options, |
| Watcher: watcher, |
| } |
| resp_ := DirectoryAdminWatchResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminWatchOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) Mount(remote DirectoryInterface) (int32, error) { |
| req_ := DirectoryAdminMountRequest{ |
| Remote: remote, |
| } |
| resp_ := DirectoryAdminMountResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminMountOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) MountAndCreate(remote DirectoryInterface, name string, flags uint32) (int32, error) { |
| req_ := DirectoryAdminMountAndCreateRequest{ |
| Remote: remote, |
| Name: name, |
| Flags: flags, |
| } |
| resp_ := DirectoryAdminMountAndCreateResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminMountAndCreateOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) Unmount() (int32, error) { |
| req_ := DirectoryAdminUnmountRequest{} |
| resp_ := DirectoryAdminUnmountResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminUnmountOrdinal, &req_, &resp_) |
| return resp_.S, err |
| } |
| |
| func (p *DirectoryAdminInterface) UnmountNode() (int32, DirectoryInterface, error) { |
| req_ := DirectoryAdminUnmountNodeRequest{} |
| resp_ := DirectoryAdminUnmountNodeResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminUnmountNodeOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Remote, err |
| } |
| |
| func (p *DirectoryAdminInterface) QueryFilesystem() (int32, *FilesystemInfo, error) { |
| req_ := DirectoryAdminQueryFilesystemRequest{} |
| resp_ := DirectoryAdminQueryFilesystemResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminQueryFilesystemOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Info, err |
| } |
| |
| func (p *DirectoryAdminInterface) GetDevicePath() (int32, *string, error) { |
| req_ := DirectoryAdminGetDevicePathRequest{} |
| resp_ := DirectoryAdminGetDevicePathResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(DirectoryAdminGetDevicePathOrdinal, &req_, &resp_) |
| return resp_.S, resp_.Path, err |
| } |
| |
| type DirectoryAdmin interface { |
| Clone(flags uint32, object NodeInterfaceRequest) error |
| Close() (int32, error) |
| Describe() (NodeInfo, error) |
| Sync() (int32, error) |
| GetAttr() (int32, NodeAttributes, error) |
| SetAttr(flags uint32, attributes NodeAttributes) (int32, error) |
| Ioctl(opcode uint32, maxOut uint64, handles []_zx.Handle, in []uint8) (int32, []_zx.Handle, []uint8, error) |
| Open(flags uint32, mode uint32, path string, object NodeInterfaceRequest) error |
| Unlink(path string) (int32, error) |
| ReadDirents(maxBytes uint64) (int32, []uint8, error) |
| Rewind() (int32, error) |
| GetToken() (int32, _zx.Handle, error) |
| Rename(src string, dstParentToken _zx.Handle, dst string) (int32, error) |
| Link(src string, dstParentToken _zx.Handle, dst string) (int32, error) |
| Watch(mask uint32, options uint32, watcher _zx.Channel) (int32, error) |
| Mount(remote DirectoryInterface) (int32, error) |
| MountAndCreate(remote DirectoryInterface, name string, flags uint32) (int32, error) |
| Unmount() (int32, error) |
| UnmountNode() (int32, DirectoryInterface, error) |
| QueryFilesystem() (int32, *FilesystemInfo, error) |
| GetDevicePath() (int32, *string, error) |
| } |
| |
| type DirectoryAdminTransitionalBase struct{} |
| |
| type DirectoryAdminInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewDirectoryAdminInterfaceRequest() (DirectoryAdminInterfaceRequest, *DirectoryAdminInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return DirectoryAdminInterfaceRequest(req), (*DirectoryAdminInterface)(cli), err |
| } |
| |
| type DirectoryAdminStub struct { |
| Impl DirectoryAdmin |
| } |
| |
| func (s *DirectoryAdminStub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) { |
| switch ord { |
| case DirectoryAdminCloneOrdinal: |
| in_ := DirectoryAdminCloneRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.Clone(in_.Flags, in_.Object) |
| return nil, err_ |
| case DirectoryAdminCloseOrdinal: |
| in_ := DirectoryAdminCloseRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminCloseResponse{} |
| s, err_ := s.Impl.Close() |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminDescribeOrdinal: |
| in_ := DirectoryAdminDescribeRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminDescribeResponse{} |
| info, err_ := s.Impl.Describe() |
| out_.Info = info |
| return &out_, err_ |
| case DirectoryAdminSyncOrdinal: |
| in_ := DirectoryAdminSyncRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminSyncResponse{} |
| s, err_ := s.Impl.Sync() |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminGetAttrOrdinal: |
| in_ := DirectoryAdminGetAttrRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminGetAttrResponse{} |
| s, attributes, err_ := s.Impl.GetAttr() |
| out_.S = s |
| out_.Attributes = attributes |
| return &out_, err_ |
| case DirectoryAdminSetAttrOrdinal: |
| in_ := DirectoryAdminSetAttrRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminSetAttrResponse{} |
| s, err_ := s.Impl.SetAttr(in_.Flags, in_.Attributes) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminIoctlOrdinal: |
| in_ := DirectoryAdminIoctlRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminIoctlResponse{} |
| s, handles, out, err_ := s.Impl.Ioctl(in_.Opcode, in_.MaxOut, in_.Handles, in_.In) |
| out_.S = s |
| out_.Handles = handles |
| out_.Out = out |
| return &out_, err_ |
| case DirectoryAdminOpenOrdinal: |
| in_ := DirectoryAdminOpenRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.Open(in_.Flags, in_.Mode, in_.Path, in_.Object) |
| return nil, err_ |
| case DirectoryAdminUnlinkOrdinal: |
| in_ := DirectoryAdminUnlinkRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminUnlinkResponse{} |
| s, err_ := s.Impl.Unlink(in_.Path) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminReadDirentsOrdinal: |
| in_ := DirectoryAdminReadDirentsRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminReadDirentsResponse{} |
| s, dirents, err_ := s.Impl.ReadDirents(in_.MaxBytes) |
| out_.S = s |
| out_.Dirents = dirents |
| return &out_, err_ |
| case DirectoryAdminRewindOrdinal: |
| in_ := DirectoryAdminRewindRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminRewindResponse{} |
| s, err_ := s.Impl.Rewind() |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminGetTokenOrdinal: |
| in_ := DirectoryAdminGetTokenRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminGetTokenResponse{} |
| s, token, err_ := s.Impl.GetToken() |
| out_.S = s |
| out_.Token = token |
| return &out_, err_ |
| case DirectoryAdminRenameOrdinal: |
| in_ := DirectoryAdminRenameRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminRenameResponse{} |
| s, err_ := s.Impl.Rename(in_.Src, in_.DstParentToken, in_.Dst) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminLinkOrdinal: |
| in_ := DirectoryAdminLinkRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminLinkResponse{} |
| s, err_ := s.Impl.Link(in_.Src, in_.DstParentToken, in_.Dst) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminWatchOrdinal: |
| in_ := DirectoryAdminWatchRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminWatchResponse{} |
| s, err_ := s.Impl.Watch(in_.Mask, in_.Options, in_.Watcher) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminMountOrdinal: |
| in_ := DirectoryAdminMountRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminMountResponse{} |
| s, err_ := s.Impl.Mount(in_.Remote) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminMountAndCreateOrdinal: |
| in_ := DirectoryAdminMountAndCreateRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminMountAndCreateResponse{} |
| s, err_ := s.Impl.MountAndCreate(in_.Remote, in_.Name, in_.Flags) |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminUnmountOrdinal: |
| in_ := DirectoryAdminUnmountRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminUnmountResponse{} |
| s, err_ := s.Impl.Unmount() |
| out_.S = s |
| return &out_, err_ |
| case DirectoryAdminUnmountNodeOrdinal: |
| in_ := DirectoryAdminUnmountNodeRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminUnmountNodeResponse{} |
| s, remote, err_ := s.Impl.UnmountNode() |
| out_.S = s |
| out_.Remote = remote |
| return &out_, err_ |
| case DirectoryAdminQueryFilesystemOrdinal: |
| in_ := DirectoryAdminQueryFilesystemRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminQueryFilesystemResponse{} |
| s, info, err_ := s.Impl.QueryFilesystem() |
| out_.S = s |
| out_.Info = info |
| return &out_, err_ |
| case DirectoryAdminGetDevicePathOrdinal: |
| in_ := DirectoryAdminGetDevicePathRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := DirectoryAdminGetDevicePathResponse{} |
| s, path, err_ := s.Impl.GetDevicePath() |
| out_.S = s |
| out_.Path = path |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| |
| type DirectoryAdminService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *DirectoryAdminService) Add(impl DirectoryAdmin, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&DirectoryAdminStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *DirectoryAdminService) EventProxyFor(key _bindings.BindingKey) (*DirectoryAdminEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*DirectoryAdminEventProxy)(pxy), err |
| } |
| |
| type DirectoryAdminEventProxy _bindings.ChannelProxy |
| |
| func (p *DirectoryAdminEventProxy) OnOpen(s int32, info *NodeInfo) error { |
| event_ := DirectoryAdminOnOpenResponse{ |
| S: s, |
| Info: info, |
| } |
| return ((*_bindings.ChannelProxy)(p)).Send(DirectoryAdminOnOpenOrdinal, &event_) |
| } |