| // Copyright 2019 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. |
| |
| //go:build !build_with_native_toolchain |
| |
| package component |
| |
| import ( |
| "bytes" |
| "context" |
| "encoding/binary" |
| "fmt" |
| stdio "io" |
| "log" |
| "runtime" |
| "runtime/pprof" |
| "strings" |
| "syscall" |
| "syscall/zx" |
| "syscall/zx/fdio" |
| "syscall/zx/fidl" |
| "unsafe" |
| |
| "fidl/fuchsia/io" |
| "fidl/fuchsia/unknown" |
| ) |
| |
| func respond(ctx fidl.Context, flags io.OpenFlags, req io.NodeWithCtxInterfaceRequest, err error, node Node) error { |
| if err != nil { |
| defer func() { |
| _ = req.Close() |
| }() |
| } |
| if flags&io.OpenFlagsDescribe != 0 { |
| proxy := io.NodeEventProxy{Channel: req.Channel} |
| switch err := err.(type) { |
| case nil: |
| info, err := node.DescribeDeprecated(ctx) |
| if err != nil { |
| panic(err) |
| } |
| return proxy.OnOpen(int32(zx.ErrOk), &info) |
| case *zx.Error: |
| return proxy.OnOpen(int32(err.Status), nil) |
| default: |
| panic(err) |
| } |
| } |
| return nil |
| } |
| |
| func logError(err error) { |
| log.Print(err) |
| } |
| |
| type Node interface { |
| getIO() (io.NodeWithCtx, func() error, error) |
| addConnection(ctx fidl.Context, flags io.OpenFlags, mode io.ModeType, req io.NodeWithCtxInterfaceRequest) error |
| DescribeDeprecated(fidl.Context) (io.NodeInfoDeprecated, error) |
| } |
| |
| func noop() error { |
| return nil |
| } |
| |
| type Service struct { |
| // AddFn is called serially with an incoming request. It must not block, and |
| // is expected to handle incoming calls on the request. |
| AddFn func(context.Context, zx.Channel) error |
| } |
| |
| var _ Node = (*Service)(nil) |
| var _ io.NodeWithCtx = (*Service)(nil) |
| |
| func (s *Service) getIO() (io.NodeWithCtx, func() error, error) { |
| return s, noop, nil |
| } |
| |
| func (s *Service) addConnection(ctx fidl.Context, flags io.OpenFlags, mode io.ModeType, req io.NodeWithCtxInterfaceRequest) error { |
| // TODO(https://fxbug.dev/42108808): this does not implement the node protocol correctly, |
| // but matches the behaviour of SDK VFS. |
| if flags&io.OpenFlagsNodeReference != 0 { |
| stub := io.NodeWithCtxStub{Impl: s} |
| go Serve(context.Background(), &stub, req.Channel, ServeOptions{ |
| OnError: logError, |
| }) |
| return respond(ctx, flags, req, nil, s) |
| } |
| return respond(ctx, flags, req, s.AddFn(context.Background(), req.Channel), s) |
| } |
| |
| func (s *Service) Clone(ctx fidl.Context, flags io.OpenFlags, req io.NodeWithCtxInterfaceRequest) error { |
| return s.addConnection(ctx, flags, 0, req) |
| } |
| |
| func (s *Service) Reopen(ctx fidl.Context, rights io.RightsRequest, req io.NodeWithCtxInterfaceRequest) error { |
| // TODO(https://fxbug.dev/42157659): implement. |
| _ = req.Close() |
| return nil |
| } |
| |
| func (*Service) Close(fidl.Context) (unknown.CloseableCloseResult, error) { |
| return unknown.CloseableCloseResultWithResponse(unknown.CloseableCloseResponse{}), nil |
| } |
| |
| func (*Service) DescribeDeprecated(fidl.Context) (io.NodeInfoDeprecated, error) { |
| var nodeInfo io.NodeInfoDeprecated |
| nodeInfo.SetService(io.Service{}) |
| return nodeInfo, nil |
| } |
| |
| func (*Service) GetConnectionInfo(fidl.Context) (io.ConnectionInfo, error) { |
| var connectionInfo io.ConnectionInfo |
| // TODO(https://fxbug.dev/42157659): Populate the rights requested by the client at connection. |
| // This might require separating Service from the VFS implementation so that the latter can |
| // hold these rights. |
| connectionInfo.SetRights(io.OperationsConnect) |
| return connectionInfo, nil |
| } |
| |
| func (*Service) Sync(fidl.Context) (io.Node2SyncResult, error) { |
| return io.Node2SyncResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*Service) GetAttr(fidl.Context) (int32, io.NodeAttributes, error) { |
| return int32(zx.ErrOk), io.NodeAttributes{ |
| Mode: uint32(io.ModeTypeService), |
| Id: io.InoUnknown, |
| LinkCount: 1, |
| }, nil |
| } |
| |
| func (*Service) SetAttr(fidl.Context, io.NodeAttributeFlags, io.NodeAttributes) (int32, error) { |
| return int32(zx.ErrNotSupported), nil |
| } |
| |
| func (*Service) GetAttributes(fidl.Context, io.NodeAttributesQuery) (io.Node2GetAttributesResult, error) { |
| // TODO(https://fxbug.dev/42157659): implement. |
| return io.Node2GetAttributesResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*Service) UpdateAttributes(fidl.Context, io.MutableNodeAttributes) (io.Node2UpdateAttributesResult, error) { |
| // TODO(https://fxbug.dev/42157659): implement. |
| return io.Node2UpdateAttributesResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*Service) ListExtendedAttributes(_ fidl.Context, request io.ExtendedAttributeIteratorWithCtxInterfaceRequest) error { |
| _ = request.Close() |
| return nil |
| } |
| |
| func (*Service) GetExtendedAttribute(fidl.Context, []uint8) (io.Node2GetExtendedAttributeResult, error) { |
| return io.Node2GetExtendedAttributeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*Service) SetExtendedAttribute(fidl.Context, []uint8, io.ExtendedAttributeValue, io.SetExtendedAttributeMode) (io.Node2SetExtendedAttributeResult, error) { |
| return io.Node2SetExtendedAttributeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*Service) RemoveExtendedAttribute(fidl.Context, []uint8) (io.Node2RemoveExtendedAttributeResult, error) { |
| return io.Node2RemoveExtendedAttributeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*Service) GetFlags(fidl.Context) (int32, io.OpenFlags, error) { |
| return int32(zx.ErrNotSupported), 0, nil |
| } |
| |
| func (*Service) SetFlags(fidl.Context, io.OpenFlags) (int32, error) { |
| return int32(zx.ErrNotSupported), nil |
| } |
| |
| func (*Service) QueryFilesystem(fidl.Context) (int32, *io.FilesystemInfo, error) { |
| return int32(zx.ErrNotSupported), nil, nil |
| } |
| |
| func (*Service) Query(fidl.Context) ([]uint8, error) { |
| return []byte(io.NodeProtocolName_), nil |
| } |
| |
| type Directory interface { |
| Get(string) (Node, bool) |
| ForEach(func(string, Node) error) error |
| } |
| |
| var _ Directory = mapDirectory(nil) |
| |
| type mapDirectory map[string]Node |
| |
| func (md mapDirectory) Get(name string) (Node, bool) { |
| node, ok := md[name] |
| return node, ok |
| } |
| |
| func (md mapDirectory) ForEach(fn func(string, Node) error) error { |
| for name, node := range md { |
| if err := fn(name, node); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| var _ Directory = (*pprofDirectory)(nil) |
| |
| type pprofDirectory struct{} |
| |
| func (*pprofDirectory) Get(name string) (Node, bool) { |
| if p := pprof.Lookup(name); p != nil { |
| return &FileWrapper{ |
| File: &pprofFile{ |
| p: p, |
| }, |
| }, true |
| } |
| return nil, false |
| } |
| |
| func (*pprofDirectory) ForEach(fn func(string, Node) error) error { |
| for _, p := range pprof.Profiles() { |
| if err := fn(p.Name(), &FileWrapper{ |
| File: &pprofFile{ |
| p: p, |
| }, |
| }); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| type DirectoryWrapper struct { |
| Directory Directory |
| } |
| |
| var _ Node = (*DirectoryWrapper)(nil) |
| |
| func (dir *DirectoryWrapper) GetDirectory() io.DirectoryWithCtx { |
| return &directoryState{DirectoryWrapper: dir} |
| } |
| |
| func (dir *DirectoryWrapper) getIO() (io.NodeWithCtx, func() error, error) { |
| return dir.GetDirectory(), noop, nil |
| } |
| |
| func (dir *DirectoryWrapper) addConnection(ctx fidl.Context, flags io.OpenFlags, mode io.ModeType, req io.NodeWithCtxInterfaceRequest) error { |
| ioDir := dir.GetDirectory() |
| stub := io.DirectoryWithCtxStub{Impl: ioDir} |
| go Serve(context.Background(), &stub, req.Channel, ServeOptions{ |
| OnError: logError, |
| }) |
| return respond(ctx, flags, req, nil, dir) |
| } |
| |
| var _ io.DirectoryWithCtx = (*directoryState)(nil) |
| |
| type directoryState struct { |
| *DirectoryWrapper |
| |
| reading bool |
| dirents bytes.Buffer |
| } |
| |
| func (dirState *directoryState) Clone(ctx fidl.Context, flags io.OpenFlags, req io.NodeWithCtxInterfaceRequest) error { |
| return dirState.addConnection(ctx, flags, 0, req) |
| } |
| |
| func (dirState *directoryState) Reopen(ctx fidl.Context, rights io.RightsRequest, req io.NodeWithCtxInterfaceRequest) error { |
| // TODO(https://fxbug.dev/42157659): implement. |
| _ = req.Close() |
| return nil |
| } |
| |
| func (*directoryState) Close(fidl.Context) (unknown.CloseableCloseResult, error) { |
| return unknown.CloseableCloseResultWithResponse(unknown.CloseableCloseResponse{}), nil |
| } |
| |
| func (*DirectoryWrapper) DescribeDeprecated(fidl.Context) (io.NodeInfoDeprecated, error) { |
| var nodeInfo io.NodeInfoDeprecated |
| nodeInfo.SetDirectory(io.DirectoryObject{}) |
| return nodeInfo, nil |
| } |
| |
| func (*directoryState) GetConnectionInfo(fidl.Context) (io.ConnectionInfo, error) { |
| var connectionInfo io.ConnectionInfo |
| // TODO(https://fxbug.dev/42157659): Populate the rights requested by the client at connection. |
| rights := io.RStarDir |
| connectionInfo.SetRights(rights) |
| return connectionInfo, nil |
| } |
| |
| func (*directoryState) Sync(fidl.Context) (io.Node2SyncResult, error) { |
| return io.Node2SyncResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*directoryState) GetAttr(fidl.Context) (int32, io.NodeAttributes, error) { |
| return int32(zx.ErrOk), io.NodeAttributes{ |
| Mode: uint32(io.ModeTypeDirectory) | uint32(fdio.VtypeIRUSR), |
| Id: io.InoUnknown, |
| LinkCount: 1, |
| }, nil |
| } |
| |
| func (*directoryState) SetAttr(fidl.Context, io.NodeAttributeFlags, io.NodeAttributes) (int32, error) { |
| return int32(zx.ErrNotSupported), nil |
| } |
| |
| func (*directoryState) GetAttributes(fidl.Context, io.NodeAttributesQuery) (io.Node2GetAttributesResult, error) { |
| // TODO(https://fxbug.dev/42157659): implement. |
| return io.Node2GetAttributesResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*directoryState) UpdateAttributes(fidl.Context, io.MutableNodeAttributes) (io.Node2UpdateAttributesResult, error) { |
| // TODO(https://fxbug.dev/42157659): implement. |
| return io.Node2UpdateAttributesResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*directoryState) ListExtendedAttributes(_ fidl.Context, request io.ExtendedAttributeIteratorWithCtxInterfaceRequest) error { |
| _ = request.Close() |
| return nil |
| } |
| |
| func (*directoryState) GetExtendedAttribute(fidl.Context, []uint8) (io.Node2GetExtendedAttributeResult, error) { |
| return io.Node2GetExtendedAttributeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*directoryState) SetExtendedAttribute(fidl.Context, []uint8, io.ExtendedAttributeValue, io.SetExtendedAttributeMode) (io.Node2SetExtendedAttributeResult, error) { |
| return io.Node2SetExtendedAttributeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*directoryState) RemoveExtendedAttribute(fidl.Context, []uint8) (io.Node2RemoveExtendedAttributeResult, error) { |
| return io.Node2RemoveExtendedAttributeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| const dot = "." |
| |
| func (dirState *directoryState) Open(ctx fidl.Context, flags io.OpenFlags, mode io.ModeType, path string, req io.NodeWithCtxInterfaceRequest) error { |
| if path == dot { |
| return dirState.addConnection(ctx, flags, mode, req) |
| } |
| const slash = "/" |
| if strings.HasSuffix(path, slash) { |
| path = path[:len(path)-len(slash)] |
| } |
| |
| if i := strings.Index(path, slash); i != -1 { |
| if node, ok := dirState.Directory.Get(path[:i]); ok { |
| proxy, cleanup, err := node.getIO() |
| if err != nil { |
| return err |
| } |
| defer cleanup() |
| if dir, ok := proxy.(io.DirectoryWithCtx); ok { |
| return dir.Open(ctx, flags, mode, path[i+len(slash):], req) |
| } |
| return respond(ctx, flags, req, &zx.Error{Status: zx.ErrNotDir}, node) |
| } |
| } else if node, ok := dirState.Directory.Get(path); ok { |
| return node.addConnection(ctx, flags, mode, req) |
| } |
| |
| return respond(ctx, flags, req, &zx.Error{Status: zx.ErrNotFound}, dirState) |
| } |
| |
| func (dirState *directoryState) Open2(ctx fidl.Context, path string, protocols io.ConnectionProtocols, channel zx.Channel) error { |
| // TODO(https://fxbug.dev/42157659): implement. |
| _ = channel.Close() |
| return nil |
| } |
| |
| func (*directoryState) Unlink(fidl.Context, string, io.UnlinkOptions) (io.Directory2UnlinkResult, error) { |
| return io.Directory2UnlinkResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (dirState *directoryState) Enumerate(ctx fidl.Context, options io.DirectoryEnumerateOptions, req io.DirectoryIteratorWithCtxInterfaceRequest) error { |
| // TODO(https://fxbug.dev/42157659): implement. |
| _ = req.Close() |
| return nil |
| } |
| |
| func (*directoryState) CreateSymlink(fidl.Context, string, []uint8, io.SymlinkWithCtxInterfaceRequest) (io.Directory2CreateSymlinkResult, error) { |
| return io.Directory2CreateSymlinkResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (dirState *directoryState) ReadDirents(ctx fidl.Context, maxOut uint64) (int32, []uint8, error) { |
| if !dirState.reading { |
| writeFn := func(name string, node Node) error { |
| ioNode, cleanup, err := node.getIO() |
| if err != nil { |
| return err |
| } |
| defer cleanup() |
| status, attr, err := ioNode.GetAttr(ctx) |
| if err != nil { |
| return err |
| } |
| if status := zx.Status(status); status != zx.ErrOk { |
| return fmt.Errorf("io.Node.GetAttr returned non-ok zx.Status %s", status) |
| } |
| dirent := syscall.Dirent{ |
| Ino: attr.Id, |
| Size: uint8(len(name)), |
| Type: uint8(func() io.DirentType { |
| switch modeType := attr.Mode & io.ModeTypeMask; modeType { |
| case io.ModeTypeDirectory: |
| return io.DirentTypeDirectory |
| case io.ModeTypeFile: |
| return io.DirentTypeFile |
| case io.ModeTypeService: |
| return io.DirentTypeService |
| default: |
| panic(fmt.Sprintf("unknown mode type: %b", modeType)) |
| } |
| }()), |
| } |
| if err := binary.Write(&dirState.dirents, binary.LittleEndian, dirent); err != nil { |
| return err |
| } |
| dirState.dirents.Truncate(dirState.dirents.Len() - int(unsafe.Sizeof(syscall.Dirent{}.Name))) |
| if _, err := dirState.dirents.WriteString(name); err != nil { |
| return err |
| } |
| return nil |
| } |
| if err := writeFn(dot, dirState); err != nil { |
| return 0, nil, err |
| } |
| if err := dirState.Directory.ForEach(writeFn); err != nil { |
| return 0, nil, err |
| } |
| dirState.reading = true |
| } else if dirState.dirents.Len() == 0 { |
| status, err := dirState.Rewind(ctx) |
| if err != nil { |
| return 0, nil, err |
| } |
| if status := zx.Status(status); status != zx.ErrOk { |
| return 0, nil, fmt.Errorf("dirState.Rewind(_) = %s", status) |
| } |
| } |
| return int32(zx.ErrOk), dirState.dirents.Next(int(maxOut)), nil |
| } |
| |
| func (dirState *directoryState) Rewind(fidl.Context) (int32, error) { |
| dirState.reading = false |
| dirState.dirents.Reset() |
| return int32(zx.ErrOk), nil |
| } |
| |
| func (*directoryState) GetToken(fidl.Context) (int32, zx.Handle, error) { |
| return int32(zx.ErrNotSupported), zx.HandleInvalid, nil |
| } |
| |
| func (*directoryState) Rename(fidl.Context, string, zx.Event, string) (io.Directory2RenameResult, error) { |
| return io.Directory2RenameResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*directoryState) Link(fidl.Context, string, zx.Handle, string) (int32, error) { |
| return int32(zx.ErrNotSupported), nil |
| } |
| |
| func (*directoryState) Watch(_ fidl.Context, _ io.WatchMask, _ uint32, watcher io.DirectoryWatcherWithCtxInterfaceRequest) (int32, error) { |
| if err := watcher.Close(); err != nil { |
| logError(err) |
| } |
| return int32(zx.ErrNotSupported), nil |
| } |
| |
| func (*directoryState) GetFlags(fidl.Context) (int32, io.OpenFlags, error) { |
| return int32(zx.ErrNotSupported), 0, nil |
| } |
| |
| func (*directoryState) SetFlags(fidl.Context, io.OpenFlags) (int32, error) { |
| return int32(zx.ErrNotSupported), nil |
| } |
| |
| func (dirState *directoryState) AdvisoryLock(fidl.Context, io.AdvisoryLockRequest) (io.AdvisoryLockingAdvisoryLockResult, error) { |
| return io.AdvisoryLockingAdvisoryLockResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*directoryState) QueryFilesystem(fidl.Context) (int32, *io.FilesystemInfo, error) { |
| return int32(zx.ErrNotSupported), nil, nil |
| } |
| |
| func (*directoryState) Query(fidl.Context) ([]uint8, error) { |
| return []byte(io.DirectoryProtocolName_), nil |
| } |
| |
| type File interface { |
| // If error is non-nil, GetReader returns a component.Reader for the file |
| // contents, and the length of the file contents. |
| GetReader() (Reader, uint64, error) |
| } |
| |
| var _ File = (*pprofFile)(nil) |
| |
| type pprofFile struct { |
| p *pprof.Profile |
| } |
| |
| func (p *pprofFile) GetReader() (Reader, uint64, error) { |
| var b bytes.Buffer |
| if err := p.p.WriteTo(&b, 0); err != nil { |
| return nil, 0, err |
| } |
| return NoVMO(NopCloser(bytes.NewReader(b.Bytes()))), uint64(b.Len()), nil |
| } |
| |
| var _ File = (*stackTraceFile)(nil) |
| |
| // stackTraceFile provides a File implementation to expose goroutine |
| // stacks. |
| type stackTraceFile struct{} |
| |
| func (f *stackTraceFile) GetReader() (Reader, uint64, error) { |
| buf := make([]byte, 4096) |
| for { |
| n := runtime.Stack(buf, true) |
| if n < len(buf) { |
| return NoVMO(NopCloser(bytes.NewReader(buf[:n]))), uint64(n), nil |
| } |
| buf = make([]byte, 2*len(buf)) |
| } |
| } |
| |
| var _ Node = (*FileWrapper)(nil) |
| |
| type FileWrapper struct { |
| File File |
| } |
| |
| func (file *FileWrapper) getFileState() (*fileState, error) { |
| reader, size, err := file.File.GetReader() |
| if err != nil { |
| return nil, err |
| } |
| return &fileState{ |
| FileWrapper: file, |
| reader: reader, |
| size: size, |
| }, nil |
| } |
| |
| func (file *FileWrapper) GetFile() (io.FileWithCtx, error) { |
| return file.getFileState() |
| } |
| |
| func (file *FileWrapper) getIO() (io.NodeWithCtx, func() error, error) { |
| state, err := file.getFileState() |
| if err != nil { |
| return nil, noop, err |
| } |
| return state, state.reader.Close, nil |
| } |
| |
| func (file *FileWrapper) addConnection(ctx fidl.Context, flags io.OpenFlags, mode io.ModeType, req io.NodeWithCtxInterfaceRequest) error { |
| ioFile, err := file.getFileState() |
| if err != nil { |
| return err |
| } |
| stub := io.FileWithCtxStub{Impl: ioFile} |
| go func() { |
| defer ioFile.reader.Close() |
| Serve(context.Background(), &stub, req.Channel, ServeOptions{ |
| OnError: logError, |
| }) |
| }() |
| return respond(ctx, flags, req, nil, ioFile) |
| } |
| |
| var _ io.FileWithCtx = (*fileState)(nil) |
| |
| type ReaderWithoutCloser interface { |
| stdio.Reader |
| stdio.ReaderAt |
| stdio.Seeker |
| } |
| |
| type ReaderWithoutGetVMO interface { |
| ReaderWithoutCloser |
| stdio.Closer |
| } |
| |
| type Reader interface { |
| ReaderWithoutGetVMO |
| // GetVMO returns a pointer to the Reader's handle to its backing VMO, if the |
| // Reader is backed by a VMO. |
| GetVMO() *zx.VMO |
| } |
| |
| type nopCloser struct { |
| ReaderWithoutCloser |
| } |
| |
| func (nopCloser) Close() error { return nil } |
| |
| // NopCloser implements Closer for Readers that don't need closing. We can't just use io.NopCloser() |
| // because it doesn't compose with stdio.ReaderAt. |
| func NopCloser(r ReaderWithoutCloser) ReaderWithoutGetVMO { |
| return nopCloser{ReaderWithoutCloser: r} |
| } |
| |
| type noVMO struct { |
| ReaderWithoutGetVMO |
| } |
| |
| func (*noVMO) GetVMO() *zx.VMO { |
| return nil |
| } |
| |
| // NoVMO implements GetVMO for Readers that don't have a backing VMO. |
| func NoVMO(r ReaderWithoutGetVMO) Reader { |
| return &noVMO{ReaderWithoutGetVMO: r} |
| } |
| |
| type fileState struct { |
| *FileWrapper |
| reader Reader |
| size uint64 |
| } |
| |
| func (fState *fileState) Clone(ctx fidl.Context, flags io.OpenFlags, req io.NodeWithCtxInterfaceRequest) error { |
| return fState.addConnection(ctx, flags, 0, req) |
| } |
| |
| func (fState *fileState) Reopen(ctx fidl.Context, rights io.RightsRequest, req io.NodeWithCtxInterfaceRequest) error { |
| // TODO(https://fxbug.dev/42157659): implement. |
| _ = req.Close() |
| return nil |
| } |
| |
| func (fState *fileState) Close(fidl.Context) (unknown.CloseableCloseResult, error) { |
| return unknown.CloseableCloseResultWithResponse(unknown.CloseableCloseResponse{}), fState.reader.Close() |
| } |
| |
| func (*FileWrapper) DescribeDeprecated(fidl.Context) (io.NodeInfoDeprecated, error) { |
| var nodeInfo io.NodeInfoDeprecated |
| nodeInfo.SetFile(io.FileObject{}) |
| return nodeInfo, nil |
| } |
| |
| func (fState *fileState) Describe(fidl.Context) (io.FileInfo, error) { |
| var fileInfo io.FileInfo |
| return fileInfo, nil |
| } |
| |
| func (*fileState) LinkInto(fidl.Context, zx.Event, string) (io.LinkableLinkIntoResult, error) { |
| return io.LinkableLinkIntoResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (fState *fileState) GetConnectionInfo(fidl.Context) (io.ConnectionInfo, error) { |
| var connectionInfo io.ConnectionInfo |
| // TODO(https://fxbug.dev/42157659): Populate the rights requested by the client at connection. |
| rights := io.RStarDir |
| connectionInfo.SetRights(rights) |
| return connectionInfo, nil |
| } |
| |
| func (*fileState) Sync(fidl.Context) (io.Node2SyncResult, error) { |
| return io.Node2SyncResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (fState *fileState) GetAttr(fidl.Context) (int32, io.NodeAttributes, error) { |
| return int32(zx.ErrOk), io.NodeAttributes{ |
| Mode: uint32(io.ModeTypeFile) | uint32(fdio.VtypeIRUSR), |
| Id: io.InoUnknown, |
| ContentSize: fState.size, |
| LinkCount: 1, |
| }, nil |
| } |
| |
| func (*fileState) SetAttr(fidl.Context, io.NodeAttributeFlags, io.NodeAttributes) (int32, error) { |
| return int32(zx.ErrNotSupported), nil |
| } |
| |
| func (*fileState) GetAttributes(fidl.Context, io.NodeAttributesQuery) (io.Node2GetAttributesResult, error) { |
| // TODO(https://fxbug.dev/42157659): implement. |
| return io.Node2GetAttributesResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*fileState) UpdateAttributes(fidl.Context, io.MutableNodeAttributes) (io.Node2UpdateAttributesResult, error) { |
| // TODO(https://fxbug.dev/42157659): implement. |
| return io.Node2UpdateAttributesResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*fileState) ListExtendedAttributes(_ fidl.Context, request io.ExtendedAttributeIteratorWithCtxInterfaceRequest) error { |
| _ = request.Close() |
| return nil |
| } |
| |
| func (*fileState) GetExtendedAttribute(fidl.Context, []uint8) (io.Node2GetExtendedAttributeResult, error) { |
| return io.Node2GetExtendedAttributeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*fileState) SetExtendedAttribute(fidl.Context, []uint8, io.ExtendedAttributeValue, io.SetExtendedAttributeMode) (io.Node2SetExtendedAttributeResult, error) { |
| return io.Node2SetExtendedAttributeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*fileState) RemoveExtendedAttribute(fidl.Context, []uint8) (io.Node2RemoveExtendedAttributeResult, error) { |
| return io.Node2RemoveExtendedAttributeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*fileState) Allocate(fidl.Context, uint64, uint64, io.AllocateMode) (io.FileAllocateResult, error) { |
| return io.FileAllocateResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*fileState) EnableVerity(fidl.Context, io.VerificationOptions) (io.FileEnableVerityResult, error) { |
| return io.FileEnableVerityResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (fState *fileState) Read(_ fidl.Context, count uint64) (io.ReadableReadResult, error) { |
| if l := fState.size; l < count { |
| count = l |
| } |
| b := make([]byte, count) |
| n, err := fState.reader.Read(b) |
| if err != nil && err != stdio.EOF { |
| return io.ReadableReadResult{}, err |
| } |
| b = b[:n] |
| return io.ReadableReadResultWithResponse(io.ReadableReadResponse{ |
| Data: b, |
| }), nil |
| } |
| |
| func (fState *fileState) ReadAt(_ fidl.Context, count uint64, offset uint64) (io.FileReadAtResult, error) { |
| if l := fState.size - offset; l < count { |
| count = l |
| } |
| b := make([]byte, count) |
| n, err := fState.reader.ReadAt(b, int64(offset)) |
| if err != nil && err != stdio.EOF { |
| return io.FileReadAtResult{}, err |
| } |
| b = b[:n] |
| return io.FileReadAtResultWithResponse(io.FileReadAtResponse{ |
| Data: b, |
| }), nil |
| } |
| |
| func (*fileState) Write(fidl.Context, []uint8) (io.WritableWriteResult, error) { |
| return io.WritableWriteResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*fileState) WriteAt(fidl.Context, []uint8, uint64) (io.FileWriteAtResult, error) { |
| return io.FileWriteAtResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (fState *fileState) Seek(_ fidl.Context, origin io.SeekOrigin, offset int64) (io.FileSeekResult, error) { |
| n, err := fState.reader.Seek(offset, int(origin)) |
| return io.FileSeekResultWithResponse( |
| io.FileSeekResponse{ |
| OffsetFromStart: uint64(n), |
| }), err |
| } |
| |
| func (*fileState) Resize(fidl.Context, uint64) (io.FileResizeResult, error) { |
| return io.FileResizeResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
| |
| func (*fileState) GetFlags(fidl.Context) (int32, io.OpenFlags, error) { |
| return int32(zx.ErrNotSupported), 0, nil |
| } |
| |
| func (*fileState) SetFlags(fidl.Context, io.OpenFlags) (int32, error) { |
| return int32(zx.ErrNotSupported), nil |
| } |
| |
| func (*fileState) QueryFilesystem(fidl.Context) (int32, *io.FilesystemInfo, error) { |
| return int32(zx.ErrNotSupported), nil, nil |
| } |
| |
| func (*fileState) Query(fidl.Context) ([]byte, error) { |
| return []byte(io.FileProtocolName_), nil |
| } |
| |
| func (fState *fileState) AdvisoryLock(fidl.Context, io.AdvisoryLockRequest) (io.AdvisoryLockingAdvisoryLockResult, error) { |
| return io.AdvisoryLockingAdvisoryLockResult{}, &zx.Error{Status: zx.ErrNotSupported, Text: fmt.Sprintf("%T", fState)} |
| } |
| |
| func (fState *fileState) GetBackingMemory(fidl.Context, io.VmoFlags) (io.FileGetBackingMemoryResult, error) { |
| if vmo := fState.reader.GetVMO(); vmo != nil { |
| // TODO(https://fxbug.dev/42157659): The rights on this VMO should be capped at the connection's. |
| h, err := vmo.Handle().Duplicate(zx.RightSameRights) |
| switch err := err.(type) { |
| case nil: |
| return io.FileGetBackingMemoryResultWithResponse(io.FileGetBackingMemoryResponse{ |
| Vmo: zx.VMO(h), |
| }), nil |
| case *zx.Error: |
| return io.FileGetBackingMemoryResultWithErr(int32(err.Status)), nil |
| default: |
| return io.FileGetBackingMemoryResult{}, err |
| } |
| } |
| return io.FileGetBackingMemoryResultWithErr(int32(zx.ErrNotSupported)), nil |
| } |
