1 // Copyright 2018 The Fuchsia Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef LIB_ZXIO_NULL_H_ 6 #define LIB_ZXIO_NULL_H_ 7 8 #include <lib/zxio/ops.h> 9 #include <zircon/compiler.h> 10 11 __BEGIN_CDECLS 12 13 // Default --------------------------------------------------------------------- 14 15 // Default implementations of the ZXIO operations. 16 // 17 // These default implementations generally do nothing an return an error. They 18 // return |ZX_ERR_WRONG_TYPE| or I/O operations (e.g., read, read_at, write, 19 // write_at, seek) and |ZX_ERR_NOT_SUPPORTED| for other operations. 20 // 21 // * |zxio_default_close| does succeed, but does nothing. 22 // * |zxio_default_wait_begin| returns an invalid handle and no signals. 23 // * |zxio_default_wait_end| returns no signals. 24 25 zx_status_t zxio_default_release(zxio_t* io, zx_handle_t* out_handle); 26 zx_status_t zxio_default_close(zxio_t* io); 27 void zxio_default_wait_begin(zxio_t* io, zxio_signals_t zxio_signals, 28 zx_handle_t* out_handle, zx_signals_t* 29 out_zx_signals); 30 void zxio_default_wait_end(zxio_t* io, zx_signals_t zx_signals, 31 zxio_signals_t* out_zxio_signals); 32 zx_status_t zxio_default_clone_async(zxio_t* io, uint32_t flags, 33 zx_handle_t request); 34 zx_status_t zxio_default_sync(zxio_t* io); 35 zx_status_t zxio_default_attr_get(zxio_t* io, zxio_node_attr_t* out_attr); 36 zx_status_t zxio_default_attr_set(zxio_t* io, uint32_t flags, 37 const zxio_node_attr_t* attr); 38 zx_status_t zxio_default_read(zxio_t* io, void* buffer, size_t capacity, 39 size_t* out_actual); 40 zx_status_t zxio_default_read_at(zxio_t* io, size_t offset, void* buffer, 41 size_t capacity, size_t* out_actual); 42 zx_status_t zxio_default_write(zxio_t* io, const void* buffer, size_t capacity, 43 size_t* out_actual); 44 zx_status_t zxio_default_write_at(zxio_t* io, size_t offset, const void* buffer, 45 size_t capacity, size_t* out_actual); 46 zx_status_t zxio_default_seek(zxio_t* io, size_t offset, zxio_seek_origin_t start, 47 size_t* out_offset); 48 zx_status_t zxio_default_truncate(zxio_t* io, size_t length); 49 zx_status_t zxio_default_flags_get(zxio_t* io, uint32_t* out_flags); 50 zx_status_t zxio_default_flags_set(zxio_t* io, uint32_t flags); 51 zx_status_t zxio_default_vmo_get(zxio_t* io, uint32_t flags, zx_handle_t* out_vmo, 52 size_t* out_size); 53 zx_status_t zxio_default_open(zxio_t* io, uint32_t flags, uint32_t mode, 54 const char* path, zxio_t** out_io); 55 zx_status_t zxio_default_open_async(zxio_t* io, uint32_t flags, uint32_t mode, 56 const char* path, zx_handle_t request); 57 zx_status_t zxio_default_unlink(zxio_t* io, const char* path); 58 zx_status_t zxio_default_token_get(zxio_t* io, zx_handle_t* out_token); 59 zx_status_t zxio_default_rename(zxio_t* io, const char* src_path, 60 zx_handle_t dst_token, const char* dst_path); 61 zx_status_t zxio_default_link(zxio_t* io, const char* src_path, 62 zx_handle_t dst_token, const char* dst_path); 63 zx_status_t zxio_default_readdir(zxio_t* io, void* buffer, size_t capacity, 64 size_t* out_actual); 65 zx_status_t zxio_default_rewind(zxio_t* io); 66 67 // An ops table filled with the default implementations. 68 // 69 // This ops table is a good starting point for building other ops tables to that 70 // the default implementations of unimplemented operations is consistent across 71 // ops tables. 72 __CONSTEXPR const zxio_ops_t zxio_default_ops = { 73 .release = zxio_default_release, 74 .close = zxio_default_close, 75 .wait_begin = zxio_default_wait_begin, 76 .wait_end = zxio_default_wait_end, 77 .clone_async = zxio_default_clone_async, 78 .sync = zxio_default_sync, 79 .attr_get = zxio_default_attr_get, 80 .attr_set = zxio_default_attr_set, 81 .read = zxio_default_read, 82 .read_at = zxio_default_read_at, 83 .write = zxio_default_write, 84 .write_at = zxio_default_write_at, 85 .seek = zxio_default_seek, 86 .truncate = zxio_default_truncate, 87 .flags_get = zxio_default_flags_get, 88 .flags_set = zxio_default_flags_set, 89 .vmo_get = zxio_default_vmo_get, 90 .open = zxio_default_open, 91 .open_async = zxio_default_open_async, 92 .unlink = zxio_default_unlink, 93 .token_get = zxio_default_token_get, 94 .rename = zxio_default_rename, 95 .link = zxio_default_link, 96 .readdir = zxio_default_readdir, 97 .rewind = zxio_default_rewind, 98 }; 99 100 // Null ------------------------------------------------------------------------ 101 102 // Null implementations of the ZXIO operations. 103 // 104 // These default implementations coorespond to how a null I/O object (e.g., what 105 // you might get from /dev/null) behaves. 106 // 107 // The null implementation is similar to the default implementation, except the 108 // read, write, and close operations succeed with null effects. 109 110 zx_status_t zxio_null_read(zxio_t* io, void* buffer, size_t capacity, 111 size_t* out_actual); 112 zx_status_t zxio_null_write(zxio_t* io, const void* buffer, size_t capacity, 113 size_t* out_actual); 114 115 // Initializes a |zxio_t| object with a null ops table. 116 zx_status_t zxio_null_init(zxio_t* io); 117 118 __END_CDECLS 119 120 #endif // LIB_ZXIO_NULL_H_ 121