| // 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 <fuchsia/device/c/fidl.h> |
| #include <fuchsia/io/c/fidl.h> |
| #include <lib/fdio/io.h> |
| #include <lib/fdio/namespace.h> |
| #include <lib/fdio/fd.h> |
| #include <lib/fdio/fdio.h> |
| #include <lib/fdio/directory.h> |
| #include <string.h> |
| #include <zircon/device/vfs.h> |
| #include <zircon/syscalls.h> |
| |
| #include "private.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) == fuchsia_device_DEVICE_SIGNAL_READABLE, ""); |
| static_assert((POLLPRI << POLL_SHIFT) == fuchsia_device_DEVICE_SIGNAL_OOB, ""); |
| static_assert((POLLOUT << POLL_SHIFT) == fuchsia_device_DEVICE_SIGNAL_WRITABLE, ""); |
| static_assert((POLLERR << POLL_SHIFT) == fuchsia_device_DEVICE_SIGNAL_ERROR, ""); |
| static_assert((POLLHUP << POLL_SHIFT) == fuchsia_device_DEVICE_SIGNAL_HANGUP, ""); |
| |
| // The |mode| argument used for |fuchsia.io.Directory/Open| calls. |
| #define FDIO_CONNECT_MODE ((uint32_t)0755) |
| |
| // Closes the |zx_handle_t| in |info|, if one exists. |
| static void zxrio_object_close_handle_if_present(const fuchsia_io_NodeInfo* info) { |
| switch (info->tag) { |
| case fuchsia_io_NodeInfoTag_file: |
| if (info->file.event != ZX_HANDLE_INVALID) { |
| zx_handle_close(info->file.event); |
| } |
| break; |
| case fuchsia_io_NodeInfoTag_pipe: |
| if (info->pipe.socket != ZX_HANDLE_INVALID) { |
| zx_handle_close(info->pipe.socket); |
| } |
| break; |
| case fuchsia_io_NodeInfoTag_vmofile: |
| if (info->vmofile.vmo != ZX_HANDLE_INVALID) { |
| zx_handle_close(info->vmofile.vmo); |
| } |
| break; |
| case fuchsia_io_NodeInfoTag_device: |
| if (info->device.event != ZX_HANDLE_INVALID) { |
| zx_handle_close(info->device.event); |
| } |
| break; |
| case fuchsia_io_NodeInfoTag_tty: |
| if (info->tty.event != ZX_HANDLE_INVALID) { |
| zx_handle_close(info->tty.event); |
| } |
| break; |
| } |
| } |
| |
| // Validates a |path| argument. |
| // |
| // Returns ZX_OK if |path| is non-null and less than |PATH_MAX| in length |
| // (excluding the null terminator). Upon success, the length of the path is |
| // returned via |out_length|. |
| // |
| // Otherwise, returns |ZX_ERR_INVALID_ARGS|. |
| static zx_status_t fdio_validate_path(const char* path, size_t* out_length) { |
| if (path == NULL) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| size_t length = strlen(path); |
| if (length >= PATH_MAX) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| *out_length = length; |
| return ZX_OK; |
| } |
| |
| // A |fuchsia.io.Node/OnOpen| event and accompanying secondary object. |
| // |
| // Used to manually read and decode |OnOpen| events. |
| // |
| // In principle, the code for dealing with the |OnOpen| event should be |
| // generated by the FIDL compiler as part of the C bindings. |
| typedef struct { |
| fuchsia_io_NodeOnOpenEvent primary; |
| fuchsia_io_NodeInfo extra; |
| } fdio_on_open_msg_t; |
| |
| // Decodes an |fuchsia.io.Node/OnOpen| event. |
| // |
| // Decodes the handle into |info|, if it exists and should be decoded. |
| // |
| // Takes ownership of |extra_handle|, if provided. |
| static zx_status_t zxrio_decode_on_open_event(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; |
| case fuchsia_io_NodeInfoTag_tty: |
| handle_target = &info->extra.tty.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; |
| } |
| |
| // Waits for, and then decodes, an |fuchsia.io.Node/OnOpen| event. |
| // |
| // The content of the event are written into |info|. |
| static zx_status_t zxrio_process_on_open_event(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_on_open_event(info, extra_handle); |
| } |
| |
| __EXPORT |
| zx_status_t fdio_service_connect(const char* path, zx_handle_t h) { |
| // TODO: fdio_validate_path? |
| 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, 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 request) { |
| size_t length = 0u; |
| zx_status_t status = fdio_validate_path(path, &length); |
| if (status != ZX_OK) { |
| zx_handle_close(request); |
| return status; |
| } |
| |
| if (dir == ZX_HANDLE_INVALID) { |
| zx_handle_close(request); |
| return ZX_ERR_UNAVAILABLE; |
| } |
| uint32_t flags = ZX_FS_RIGHT_READABLE | ZX_FS_RIGHT_WRITABLE; |
| return fuchsia_io_DirectoryOpen(dir, flags, FDIO_CONNECT_MODE, path, length, request); |
| } |
| |
| __EXPORT |
| zx_status_t fdio_open(const char* path, uint32_t flags, zx_handle_t request) { |
| // TODO: fdio_validate_path? |
| if (path == NULL) { |
| zx_handle_close(request); |
| 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, request); |
| } |
| // Otherwise we fail |
| zx_handle_close(request); |
| 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 request) { |
| size_t length = 0u; |
| zx_status_t status = fdio_validate_path(path, &length); |
| if (status != ZX_OK) { |
| zx_handle_close(request); |
| return status; |
| } |
| |
| if (flags & ZX_FS_FLAG_DESCRIBE) { |
| zx_handle_close(request); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| return fuchsia_io_DirectoryOpen(dir, flags, FDIO_CONNECT_MODE, path, length, request); |
| } |
| |
| __EXPORT |
| zx_handle_t fdio_service_clone(zx_handle_t handle) { |
| if (handle == ZX_HANDLE_INVALID) { |
| return ZX_HANDLE_INVALID; |
| } |
| zx_handle_t clone, request; |
| zx_status_t status = zx_channel_create(0, &clone, &request); |
| if (status != ZX_OK) { |
| return ZX_HANDLE_INVALID; |
| } |
| // TODO(yifeit): Switch to ZX_FS_FLAG_CLONE_SAME_RIGHTS |
| // once all vfs implementations speak the hierarchical concepts. |
| uint32_t flags = ZX_FS_RIGHT_READABLE | ZX_FS_RIGHT_WRITABLE | ZX_FS_FLAG_CLONE_SAME_RIGHTS; |
| status = fuchsia_io_NodeClone(handle, flags, request); |
| if (status != ZX_OK) { |
| zx_handle_close(clone); |
| return ZX_HANDLE_INVALID; |
| } |
| return clone; |
| } |
| |
| __EXPORT |
| zx_status_t fdio_service_clone_to(zx_handle_t handle, zx_handle_t request) { |
| if (handle == ZX_HANDLE_INVALID) { |
| zx_handle_close(request); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| // TODO(yifeit): Switch to ZX_FS_FLAG_CLONE_SAME_RIGHTS |
| // once all vfs implementations speak the hierarchical concepts. |
| uint32_t flags = ZX_FS_RIGHT_READABLE | ZX_FS_RIGHT_WRITABLE | ZX_FS_FLAG_CLONE_SAME_RIGHTS; |
| return fuchsia_io_NodeClone(handle, flags, request); |
| } |
| |
| // Creates an |fdio_t| from a Zircon socket object. |
| // |
| // Examines |socket| and determines whether to create a pipe, stream socket, or |
| // datagram socket. |
| // |
| // Always consumes |socket|. |
| static 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 an |fdio_t| from a |handle| and an |info|. |
| // |
| // Uses |info| to determine what kind of |fdio_t| to create. |
| // |
| // Upon successs, |out_io| receives ownership of all handles. |
| // |
| // Upon failure, consumes all handles. |
| static zx_status_t fdio_from_node_info(zx_handle_t handle, |
| fuchsia_io_NodeInfo* info, |
| fdio_t** out_io) { |
| zx_status_t status = ZX_OK; |
| if (handle == ZX_HANDLE_INVALID) { |
| status = ZX_ERR_INVALID_ARGS; |
| goto failure; |
| } |
| |
| fdio_t* io = NULL; |
| switch (info->tag) { |
| case fuchsia_io_NodeInfoTag_directory: |
| io = fdio_dir_create(handle); |
| break; |
| case fuchsia_io_NodeInfoTag_service: |
| io = fdio_remote_create(handle, 0); |
| break; |
| case fuchsia_io_NodeInfoTag_file: |
| io = fdio_file_create(handle, info->file.event); |
| break; |
| case fuchsia_io_NodeInfoTag_device: |
| io = fdio_remote_create(handle, info->device.event); |
| break; |
| case fuchsia_io_NodeInfoTag_tty: |
| io = fdio_remote_create(handle, info->tty.event); |
| break; |
| case fuchsia_io_NodeInfoTag_vmofile: { |
| uint64_t seek = 0u; |
| zx_status_t io_status = fuchsia_io_FileSeek( |
| handle, 0, fuchsia_io_SeekOrigin_START, &status, &seek); |
| if (io_status != ZX_OK) { |
| status = io_status; |
| } |
| if (status != ZX_OK) { |
| goto failure; |
| } |
| io = fdio_vmofile_create(handle, info->vmofile.vmo, info->vmofile.offset, |
| info->vmofile.length, seek); |
| break; |
| } |
| case fuchsia_io_NodeInfoTag_pipe: { |
| zx_handle_close(handle); |
| return fdio_from_socket(info->pipe.socket, out_io); |
| } |
| default: |
| status = ZX_ERR_NOT_SUPPORTED; |
| goto failure; |
| } |
| |
| if (io == NULL) { |
| return ZX_ERR_NO_RESOURCES; |
| } |
| |
| *out_io = io; |
| return ZX_OK; |
| |
| failure: |
| zxrio_object_close_handle_if_present(info); |
| zx_handle_close(handle); |
| return status; |
| } |
| |
| // Creates an |fdio_t| from a Zircon channel object. |
| // |
| // The |channel| must implement the |fuchsia.io.Node| protocol. Uses the |
| // |Describe| method from the |fuchsia.io.Node| protocol to determine the type |
| // of |fdio_t| object to create. |
| // |
| // Always consumes |channel|. |
| static 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; |
| } |
| return fdio_from_node_info(channel, &info, out_io); |
| } |
| |
| __EXPORT |
| zx_status_t fdio_create(zx_handle_t handle, fdio_t** out_io) { |
| zx_info_handle_basic_t info; |
| zx_status_t status = zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, &info, |
| sizeof(info), NULL, NULL); |
| if (status != ZX_OK) |
| return status; |
| fdio_t* io = NULL; |
| switch (info.type) { |
| case ZX_OBJ_TYPE_CHANNEL: |
| return fdio_from_channel(handle, out_io); |
| case ZX_OBJ_TYPE_SOCKET: |
| return fdio_from_socket(handle, out_io); |
| case ZX_OBJ_TYPE_VMO: |
| io = fdio_vmo_create(handle, 0u); |
| break; |
| case ZX_OBJ_TYPE_LOG: |
| io = fdio_logger_create(handle); |
| break; |
| default: { |
| zx_handle_close(handle); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| } |
| if (io == NULL) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| *out_io = io; |
| return ZX_OK; |
| } |
| |
| zx_status_t fdio_remote_open_at(zx_handle_t dir, const char* path, uint32_t flags, |
| uint32_t mode, fdio_t** out_io) { |
| size_t length = 0u; |
| zx_status_t status = fdio_validate_path(path, &length); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| zx_handle_t handle, request; |
| status = zx_channel_create(0, &handle, &request); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| status = fuchsia_io_DirectoryOpen(dir, flags, mode, path, length, request); |
| if (status != ZX_OK) { |
| zx_handle_close(handle); |
| return status; |
| } |
| |
| if (flags & ZX_FS_FLAG_DESCRIBE) { |
| fdio_on_open_msg_t info; |
| memset(&info, 0, sizeof(info)); |
| |
| status = zxrio_process_on_open_event(handle, &info); |
| if (status != ZX_OK) { |
| zx_handle_close(handle); |
| return status; |
| } |
| return fdio_from_node_info(handle, &info.extra, out_io); |
| } |
| |
| fdio_t* io = fdio_remote_create(handle, 0); |
| if (io == NULL) { |
| return ZX_ERR_NO_RESOURCES; |
| } |
| *out_io = io; |
| return ZX_OK; |
| } |
