| // Copyright 2016 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. |
| |
| #include <assert.h> |
| #include <fcntl.h> |
| #include <limits.h> |
| #include <poll.h> |
| #include <pthread.h> |
| #include <stdatomic.h> |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/ioctl.h> |
| #include <threads.h> |
| |
| #include <zircon/assert.h> |
| #include <zircon/device/device.h> |
| #include <zircon/device/ioctl.h> |
| #include <zircon/device/vfs.h> |
| #include <zircon/processargs.h> |
| #include <zircon/syscalls.h> |
| |
| #include <fuchsia/io/c/fidl.h> |
| #include <lib/fdio/debug.h> |
| #include <lib/fdio/io.h> |
| #include <lib/fdio/namespace.h> |
| #include <lib/fdio/util.h> |
| #include <lib/fdio/vfs.h> |
| |
| #include "private-remoteio.h" |
| |
| #define ZXDEBUG 0 |
| |
| // POLL_MASK and POLL_SHIFT intend to convert the lower five POLL events into |
| // ZX_USER_SIGNALs and vice-versa. Other events need to be manually converted to |
| // a zx_signals_t, if they are desired. |
| #define POLL_SHIFT 24 |
| #define POLL_MASK 0x1F |
| |
| static_assert(FDIO_CHUNK_SIZE >= PATH_MAX, |
| "FDIO_CHUNK_SIZE must be large enough to contain paths"); |
| |
| static_assert(fuchsia_io_VMO_FLAG_READ == ZX_VM_PERM_READ, |
| "Vmar / Vmo flags should be aligned"); |
| static_assert(fuchsia_io_VMO_FLAG_WRITE == ZX_VM_PERM_WRITE, |
| "Vmar / Vmo flags should be aligned"); |
| static_assert(fuchsia_io_VMO_FLAG_EXEC == ZX_VM_PERM_EXECUTE, |
| "Vmar / Vmo flags should be aligned"); |
| |
| static_assert(ZX_USER_SIGNAL_0 == (1 << POLL_SHIFT), ""); |
| static_assert((POLLIN << POLL_SHIFT) == DEVICE_SIGNAL_READABLE, ""); |
| static_assert((POLLPRI << POLL_SHIFT) == DEVICE_SIGNAL_OOB, ""); |
| static_assert((POLLOUT << POLL_SHIFT) == DEVICE_SIGNAL_WRITABLE, ""); |
| static_assert((POLLERR << POLL_SHIFT) == DEVICE_SIGNAL_ERROR, ""); |
| static_assert((POLLHUP << POLL_SHIFT) == DEVICE_SIGNAL_HANGUP, ""); |
| |
| // Acquire the additional handle from |info|. |
| // |
| // Returns |ZX_OK| if a handle was returned. |
| // Returns |ZX_ERR_NOT_FOUND| if no handle can be returned. |
| static zx_status_t zxrio_object_extract_handle(const fuchsia_io_NodeInfo* info, |
| zx_handle_t* out) { |
| switch (info->tag) { |
| case fuchsia_io_NodeInfoTag_file: |
| if (info->file.event != ZX_HANDLE_INVALID) { |
| *out = info->file.event; |
| return ZX_OK; |
| } |
| break; |
| case fuchsia_io_NodeInfoTag_pipe: |
| if (info->pipe.socket != ZX_HANDLE_INVALID) { |
| *out = info->pipe.socket; |
| return ZX_OK; |
| } |
| break; |
| case fuchsia_io_NodeInfoTag_vmofile: |
| if (info->vmofile.vmo != ZX_HANDLE_INVALID) { |
| *out = info->vmofile.vmo; |
| return ZX_OK; |
| } |
| break; |
| case fuchsia_io_NodeInfoTag_device: |
| if (info->device.event != ZX_HANDLE_INVALID) { |
| *out = info->device.event; |
| return ZX_OK; |
| } |
| break; |
| } |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| // Open an object without waiting for the response. |
| // This function always consumes the cnxn handle |
| // The svc handle is only used to send a message |
| static zx_status_t zxrio_connect(zx_handle_t svc, zx_handle_t cnxn, |
| uint32_t op, uint32_t flags, uint32_t mode, |
| const char* name) { |
| size_t len = strlen(name); |
| if (len >= PATH_MAX) { |
| zx_handle_close(cnxn); |
| return ZX_ERR_BAD_PATH; |
| } |
| if (flags & ZX_FS_FLAG_DESCRIBE) { |
| zx_handle_close(cnxn); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| zx_status_t r; |
| switch (op) { |
| case fuchsia_io_NodeCloneOrdinal: |
| r = fuchsia_io_NodeClone(svc, flags, cnxn); |
| break; |
| case fuchsia_io_DirectoryOpenOrdinal: |
| r = fuchsia_io_DirectoryOpen(svc, flags, mode, name, len, cnxn); |
| break; |
| default: |
| zx_handle_close(cnxn); |
| r = ZX_ERR_NOT_SUPPORTED; |
| } |
| return r; |
| } |
| |
| // A one-way message which may be emitted by the server without an |
| // accompanying request. Optionally used as a part of the Open handshake. |
| typedef struct { |
| fuchsia_io_NodeOnOpenEvent primary; |
| fuchsia_io_NodeInfo extra; |
| } fdio_on_open_msg_t; |
| |
| // Takes ownership of the optional |extra_handle|. |
| // |
| // Decodes the handle into |info|, if it exists and should |
| // be decoded. |
| static zx_status_t zxrio_decode_describe_handle(fdio_on_open_msg_t* info, |
| zx_handle_t extra_handle) { |
| bool have_handle = (extra_handle != ZX_HANDLE_INVALID); |
| bool want_handle = false; |
| zx_handle_t* handle_target = NULL; |
| |
| switch (info->extra.tag) { |
| // Case: No extra handles expected |
| case fuchsia_io_NodeInfoTag_service: |
| case fuchsia_io_NodeInfoTag_directory: |
| break; |
| // Case: Extra handles optional |
| case fuchsia_io_NodeInfoTag_file: |
| handle_target = &info->extra.file.event; |
| goto handle_optional; |
| case fuchsia_io_NodeInfoTag_device: |
| handle_target = &info->extra.device.event; |
| goto handle_optional; |
| handle_optional: |
| want_handle = *handle_target == FIDL_HANDLE_PRESENT; |
| break; |
| // Case: Extra handles required |
| case fuchsia_io_NodeInfoTag_pipe: |
| handle_target = &info->extra.pipe.socket; |
| goto handle_required; |
| case fuchsia_io_NodeInfoTag_vmofile: |
| handle_target = &info->extra.vmofile.vmo; |
| goto handle_required; |
| handle_required: |
| want_handle = *handle_target == FIDL_HANDLE_PRESENT; |
| if (!want_handle) { |
| goto fail; |
| } |
| break; |
| default: |
| printf("Unexpected protocol type opening connection\n"); |
| goto fail; |
| } |
| |
| if (have_handle != want_handle) { |
| goto fail; |
| } |
| if (have_handle) { |
| *handle_target = extra_handle; |
| } |
| return ZX_OK; |
| |
| fail: |
| if (have_handle) { |
| zx_handle_close(extra_handle); |
| } |
| return ZX_ERR_IO; |
| } |
| |
| // Wait/Read from a new client connection, with the expectation of |
| // acquiring an Open response. |
| // |
| // Shared implementation between RemoteIO and FIDL, since the response |
| // message is aligned. |
| // |
| // Does not close |h|, even on error. |
| static zx_status_t zxrio_process_open_response(zx_handle_t h, fdio_on_open_msg_t* info) { |
| zx_object_wait_one(h, ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, |
| ZX_TIME_INFINITE, NULL); |
| |
| // Attempt to read the description from open |
| uint32_t dsize = sizeof(*info); |
| zx_handle_t extra_handle = ZX_HANDLE_INVALID; |
| uint32_t actual_handles; |
| zx_status_t r = zx_channel_read(h, 0, info, &extra_handle, dsize, 1, &dsize, |
| &actual_handles); |
| if (r != ZX_OK) { |
| return r; |
| } |
| if (dsize < sizeof(fuchsia_io_NodeOnOpenEvent) || |
| info->primary.hdr.ordinal != fuchsia_io_NodeOnOpenOrdinal) { |
| r = ZX_ERR_IO; |
| } else { |
| r = info->primary.s; |
| } |
| |
| if (dsize != sizeof(fdio_on_open_msg_t)) { |
| r = (r != ZX_OK) ? r : ZX_ERR_IO; |
| } |
| |
| if (r != ZX_OK) { |
| if (extra_handle != ZX_HANDLE_INVALID) { |
| zx_handle_close(extra_handle); |
| } |
| return r; |
| } |
| |
| // Confirm that the objects "fdio_on_open_msg_t" and "fuchsia_io_NodeOnOpenEvent" |
| // are aligned enough to be compatible. |
| // |
| // This is somewhat complicated by the fact that the "fuchsia_io_NodeOnOpenEvent" |
| // object has an optional "fuchsia_io_NodeInfo" secondary which exists immediately |
| // following the struct. |
| static_assert(__builtin_offsetof(fdio_on_open_msg_t, extra) == |
| FIDL_ALIGN(sizeof(fuchsia_io_NodeOnOpenEvent)), |
| "RIO Description message doesn't align with FIDL response secondary"); |
| // Connection::NodeDescribe also relies on these static_asserts. |
| // fidl_describe also relies on these static_asserts. |
| |
| return zxrio_decode_describe_handle(info, extra_handle); |
| } |
| |
| __EXPORT |
| zx_status_t fdio_service_connect(const char* svcpath, zx_handle_t h) { |
| if (svcpath == NULL) { |
| zx_handle_close(h); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| // Otherwise attempt to connect through the root namespace |
| if (fdio_root_ns != NULL) { |
| return fdio_ns_connect(fdio_root_ns, svcpath, |
| ZX_FS_RIGHT_READABLE | ZX_FS_RIGHT_WRITABLE, h); |
| } |
| // Otherwise we fail |
| zx_handle_close(h); |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| __EXPORT |
| zx_status_t fdio_service_connect_at(zx_handle_t dir, const char* path, zx_handle_t h) { |
| if (path == NULL) { |
| zx_handle_close(h); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| if (dir == ZX_HANDLE_INVALID) { |
| zx_handle_close(h); |
| return ZX_ERR_UNAVAILABLE; |
| } |
| return zxrio_connect(dir, h, fuchsia_io_DirectoryOpenOrdinal, ZX_FS_RIGHT_READABLE | |
| ZX_FS_RIGHT_WRITABLE, 0755, path); |
| } |
| |
| __EXPORT |
| zx_status_t fdio_open(const char* path, uint32_t flags, zx_handle_t h) { |
| if (path == NULL) { |
| zx_handle_close(h); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| // Otherwise attempt to connect through the root namespace |
| if (fdio_root_ns != NULL) { |
| return fdio_ns_connect(fdio_root_ns, path, flags, h); |
| } |
| // Otherwise we fail |
| zx_handle_close(h); |
| return ZX_ERR_NOT_FOUND; |
| } |
| |
| __EXPORT |
| zx_status_t fdio_open_at(zx_handle_t dir, const char* path, uint32_t flags, zx_handle_t h) { |
| if (path == NULL) { |
| zx_handle_close(h); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| if (dir == ZX_HANDLE_INVALID) { |
| zx_handle_close(h); |
| return ZX_ERR_UNAVAILABLE; |
| } |
| return zxrio_connect(dir, h, fuchsia_io_DirectoryOpenOrdinal, flags, 0755, path); |
| } |
| |
| __EXPORT |
| zx_handle_t fdio_service_clone(zx_handle_t svc) { |
| zx_handle_t cli, srv; |
| zx_status_t r; |
| if (svc == ZX_HANDLE_INVALID) { |
| return ZX_HANDLE_INVALID; |
| } |
| if ((r = zx_channel_create(0, &cli, &srv)) < 0) { |
| return ZX_HANDLE_INVALID; |
| } |
| if ((r = zxrio_connect(svc, srv, fuchsia_io_NodeCloneOrdinal, ZX_FS_RIGHT_READABLE | |
| ZX_FS_RIGHT_WRITABLE, 0755, "")) < 0) { |
| zx_handle_close(cli); |
| return ZX_HANDLE_INVALID; |
| } |
| return cli; |
| } |
| |
| __EXPORT |
| zx_status_t fdio_service_clone_to(zx_handle_t svc, zx_handle_t srv) { |
| if (srv == ZX_HANDLE_INVALID) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| if (svc == ZX_HANDLE_INVALID) { |
| zx_handle_close(srv); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| return zxrio_connect(svc, srv, fuchsia_io_NodeCloneOrdinal, ZX_FS_RIGHT_READABLE | |
| ZX_FS_RIGHT_WRITABLE, 0755, ""); |
| } |
| |
| zx_status_t fdio_from_channel(zx_handle_t channel, fdio_t** out_io) { |
| fuchsia_io_NodeInfo info; |
| memset(&info, 0, sizeof(info)); |
| zx_status_t status = fuchsia_io_NodeDescribe(channel, &info); |
| if (status != ZX_OK) { |
| zx_handle_close(channel); |
| return status; |
| } |
| |
| zx_handle_t event = ZX_HANDLE_INVALID; |
| switch (info.tag) { |
| case fuchsia_io_NodeInfoTag_file: |
| event = info.file.event; |
| break; |
| case fuchsia_io_NodeInfoTag_device: |
| event = info.device.event; |
| break; |
| case fuchsia_io_NodeInfoTag_vmofile: { |
| uint64_t seek = 0u; |
| zx_status_t io_status = fuchsia_io_FileSeek( |
| channel, 0, fuchsia_io_SeekOrigin_START, &status, &seek); |
| if (io_status != ZX_OK) { |
| status = io_status; |
| } |
| if (status != ZX_OK) { |
| zx_handle_close(channel); |
| zx_handle_close(info.vmofile.vmo); |
| return status; |
| } |
| *out_io = fdio_vmofile_create(channel, info.vmofile.vmo, |
| info.vmofile.offset, info.vmofile.length, |
| seek); |
| return ZX_OK; |
| } |
| default: |
| event = ZX_HANDLE_INVALID; |
| break; |
| } |
| |
| *out_io = fdio_remote_create(channel, event); |
| return ZX_OK; |
| } |
| |
| zx_status_t fdio_from_socket(zx_handle_t socket, fdio_t** out_io) { |
| zx_info_socket_t info; |
| memset(&info, 0, sizeof(info)); |
| zx_status_t status = zx_object_get_info(socket, ZX_INFO_SOCKET, &info, sizeof(info), NULL, NULL); |
| if (status != ZX_OK) { |
| zx_handle_close(socket); |
| return status; |
| } |
| fdio_t* io = NULL; |
| if ((info.options & ZX_SOCKET_HAS_CONTROL) != 0) { |
| // If the socket has a control plane, then the socket is either |
| // a stream or a datagram socket. |
| if ((info.options & ZX_SOCKET_DATAGRAM) != 0) { |
| io = fdio_socket_create_datagram(socket, IOFLAG_SOCKET_CONNECTED); |
| } else { |
| io = fdio_socket_create_stream(socket, IOFLAG_SOCKET_CONNECTED); |
| } |
| } else { |
| // Without a control plane, the socket is a pipe. |
| io = fdio_pipe_create(socket); |
| } |
| if (!io) { |
| return ZX_ERR_NO_RESOURCES; |
| } |
| *out_io = io; |
| return ZX_OK; |
| } |
| |
| // Create a fdio (if possible) from handles and info. |
| // |
| // The Control channel is provided in |handle|, and auxiliary |
| // handles may be provided in the |info| object. |
| // |
| // This function always takes control of all handles. |
| // They are transferred into the |out| object on success, |
| // or closed on failure. |
| static zx_status_t fdio_from_handles(zx_handle_t handle, fuchsia_io_NodeInfo* info, |
| fdio_t** out) { |
| // All failure cases which discard handles set r and break |
| // to the end. All other cases in which handle ownership is moved |
| // on return locally. |
| zx_status_t r; |
| fdio_t* io; |
| switch (info->tag) { |
| case fuchsia_io_NodeInfoTag_directory: |
| if (handle == ZX_HANDLE_INVALID) { |
| r = ZX_ERR_INVALID_ARGS; |
| break; |
| } |
| io = fdio_dir_create(handle); |
| xprintf("rio (%x,%x) -> %p\n", handle, 0, io); |
| if (io == NULL) { |
| return ZX_ERR_NO_RESOURCES; |
| } |
| *out = io; |
| return ZX_OK; |
| case fuchsia_io_NodeInfoTag_service: |
| if (handle == ZX_HANDLE_INVALID) { |
| r = ZX_ERR_INVALID_ARGS; |
| break; |
| } |
| io = fdio_remote_create(handle, 0); |
| xprintf("rio (%x,%x) -> %p\n", handle, 0, io); |
| if (io == NULL) { |
| return ZX_ERR_NO_RESOURCES; |
| } |
| *out = io; |
| return ZX_OK; |
| case fuchsia_io_NodeInfoTag_file: |
| if (info->file.event == ZX_HANDLE_INVALID) { |
| io = fdio_remote_create(handle, 0); |
| xprintf("rio (%x,%x) -> %p\n", handle, 0, io); |
| } else { |
| io = fdio_remote_create(handle, info->file.event); |
| xprintf("rio (%x,%x) -> %p\n", handle, info->file.event, io); |
| } |
| if (io == NULL) { |
| return ZX_ERR_NO_RESOURCES; |
| } |
| *out = io; |
| return ZX_OK; |
| case fuchsia_io_NodeInfoTag_device: |
| if (info->device.event == ZX_HANDLE_INVALID) { |
| io = fdio_remote_create(handle, 0); |
| xprintf("rio (%x,%x) -> %p\n", handle, 0, io); |
| } else { |
| io = fdio_remote_create(handle, info->device.event); |
| xprintf("rio (%x,%x) -> %p\n", handle, info->device.event, io); |
| } |
| if (io == NULL) { |
| return ZX_ERR_NO_RESOURCES; |
| } |
| *out = io; |
| return ZX_OK; |
| case fuchsia_io_NodeInfoTag_vmofile: { |
| if (info->vmofile.vmo == ZX_HANDLE_INVALID) { |
| r = ZX_ERR_INVALID_ARGS; |
| break; |
| } |
| *out = fdio_vmofile_create(handle, info->vmofile.vmo, info->vmofile.offset, |
| info->vmofile.length, 0u); |
| if (*out == NULL) { |
| return ZX_ERR_NO_RESOURCES; |
| } |
| return ZX_OK; |
| } |
| case fuchsia_io_NodeInfoTag_pipe: { |
| if (info->pipe.socket == ZX_HANDLE_INVALID) { |
| r = ZX_ERR_INVALID_ARGS; |
| break; |
| } |
| zx_handle_close(handle); |
| return fdio_from_socket(info->pipe.socket, out); |
| } |
| default: |
| printf("fdio_from_handles: Not supported\n"); |
| r = ZX_ERR_NOT_SUPPORTED; |
| break; |
| } |
| zx_handle_t extra; |
| if (zxrio_object_extract_handle(info, &extra) == ZX_OK) { |
| zx_handle_close(extra); |
| } |
| zx_handle_close(handle); |
| return r; |
| } |
| |
| __EXPORT |
| zx_status_t fdio_create_fd(zx_handle_t* handles, uint32_t* types, size_t hcount, |
| int* fd_out) { |
| fdio_t* io; |
| zx_status_t r; |
| int fd; |
| fuchsia_io_NodeInfo info; |
| |
| // Pack additional handles into |info|, if possible. |
| switch (PA_HND_TYPE(types[0])) { |
| case PA_FDIO_REMOTE: |
| switch (hcount) { |
| case 1: |
| io = fdio_remote_create(handles[0], 0); |
| goto bind; |
| case 2: |
| io = fdio_remote_create(handles[0], handles[1]); |
| goto bind; |
| default: |
| r = ZX_ERR_INVALID_ARGS; |
| goto fail; |
| } |
| case PA_FDIO_SOCKET: |
| info.tag = fuchsia_io_NodeInfoTag_pipe; |
| // Expected: Single socket handle |
| if (hcount != 1) { |
| r = ZX_ERR_INVALID_ARGS; |
| goto fail; |
| } |
| info.pipe.socket = handles[0]; |
| break; |
| default: |
| r = ZX_ERR_IO; |
| goto fail; |
| } |
| |
| if ((r = fdio_from_handles(ZX_HANDLE_INVALID, &info, &io)) != ZX_OK) { |
| return r; |
| } |
| |
| bind: |
| fd = fdio_bind_to_fd(io, -1, 0); |
| if (fd < 0) { |
| fdio_close(io); |
| fdio_release(io); |
| return ZX_ERR_BAD_STATE; |
| } |
| |
| *fd_out = fd; |
| return ZX_OK; |
| fail: |
| zx_handle_close_many(handles, hcount); |
| return r; |
| } |
| |
| // Synchronously (non-pipelined) open an object |
| // The svc handle is only used to send a message |
| static zx_status_t zxrio_sync_open_connection(zx_handle_t svc, uint32_t op, |
| uint32_t flags, uint32_t mode, |
| const char* path, size_t pathlen, |
| fdio_on_open_msg_t* info, |
| zx_handle_t* out) { |
| if (!(flags & ZX_FS_FLAG_DESCRIBE)) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| zx_status_t r; |
| zx_handle_t h; |
| zx_handle_t cnxn; |
| if ((r = zx_channel_create(0, &h, &cnxn)) != ZX_OK) { |
| return r; |
| } |
| |
| switch (op) { |
| case fuchsia_io_NodeCloneOrdinal: |
| r = fuchsia_io_NodeClone(svc, flags, cnxn); |
| break; |
| case fuchsia_io_DirectoryOpenOrdinal: |
| r = fuchsia_io_DirectoryOpen(svc, flags, mode, path, pathlen, cnxn); |
| break; |
| default: |
| zx_handle_close(cnxn); |
| r = ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| if (r != ZX_OK) { |
| zx_handle_close(h); |
| return r; |
| } |
| |
| if ((r = zxrio_process_open_response(h, info)) != ZX_OK) { |
| zx_handle_close(h); |
| return r; |
| } |
| *out = h; |
| return ZX_OK; |
| } |
| |
| // Acquires a new connection to an object. |
| // |
| // Returns a description of the opened object in |info|, and |
| // the control channel to the object in |out|. |
| // |
| // |info| may contain an additional handle. |
| static zx_status_t zxrio_getobject(zx_handle_t rio_h, uint32_t op, const char* name, |
| uint32_t flags, uint32_t mode, |
| fdio_on_open_msg_t* info, zx_handle_t* out) { |
| if (name == NULL) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| size_t len = strlen(name); |
| if (len >= PATH_MAX) { |
| return ZX_ERR_BAD_PATH; |
| } |
| |
| if (flags & ZX_FS_FLAG_DESCRIBE) { |
| return zxrio_sync_open_connection(rio_h, op, flags, mode, name, len, info, out); |
| } else { |
| zx_handle_t h0, h1; |
| zx_status_t r; |
| if ((r = zx_channel_create(0, &h0, &h1)) < 0) { |
| return r; |
| } |
| if ((r = zxrio_connect(rio_h, h1, op, flags, mode, name)) < 0) { |
| zx_handle_close(h0); |
| return r; |
| } |
| // fake up a reply message since pipelined opens don't generate one |
| info->primary.s = ZX_OK; |
| info->extra.tag = fuchsia_io_NodeInfoTag_service; |
| *out = h0; |
| return ZX_OK; |
| } |
| } |
| |
| zx_status_t zxrio_open_handle(zx_handle_t h, const char* path, uint32_t flags, |
| uint32_t mode, fdio_t** out) { |
| zx_handle_t control_channel = ZX_HANDLE_INVALID; |
| fdio_on_open_msg_t info; |
| zx_status_t r = zxrio_getobject(h, fuchsia_io_DirectoryOpenOrdinal, path, flags, mode, &info, &control_channel); |
| if (r < 0) { |
| return r; |
| } |
| return fdio_from_handles(control_channel, &info.extra, out); |
| } |
