// 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.

#ifndef LIB_ZXIO_NULL_H_
#define LIB_ZXIO_NULL_H_

#include <lib/zxio/ops.h>
#include <zircon/compiler.h>

__BEGIN_CDECLS

// Default ---------------------------------------------------------------------

// Default implementations of the ZXIO operations.
//
// These default implementations generally do nothing an return an error. They
// return |ZX_ERR_WRONG_TYPE| or I/O operations (e.g., read, read_at, write,
// write_at, seek) and |ZX_ERR_NOT_SUPPORTED| for other operations.
//
// * |zxio_default_close| does succeed, but does nothing.
// * |zxio_default_wait_begin| returns an invalid handle and no signals.
// * |zxio_default_wait_end| returns no signals.

zx_status_t zxio_default_release(zxio_t* io, zx_handle_t* out_handle);
zx_status_t zxio_default_close(zxio_t* io);
zx_status_t zxio_default_clone(zxio_t* io, zx_handle_t* out_handle);
void zxio_default_wait_begin(zxio_t* io, zxio_signals_t zxio_signals,
                             zx_handle_t* out_handle, zx_signals_t*
                             out_zx_signals);
void zxio_default_wait_end(zxio_t* io, zx_signals_t zx_signals,
                           zxio_signals_t* out_zxio_signals);
zx_status_t zxio_default_sync(zxio_t* io);
zx_status_t zxio_default_attr_get(zxio_t* io, zxio_node_attr_t* out_attr);
zx_status_t zxio_default_attr_set(zxio_t* io, uint32_t flags,
                                  const zxio_node_attr_t* attr);
zx_status_t zxio_default_read(zxio_t* io, void* buffer, size_t capacity,
                              size_t* out_actual);
zx_status_t zxio_default_read_at(zxio_t* io, size_t offset, void* buffer,
                                 size_t capacity, size_t* out_actual);
zx_status_t zxio_default_write(zxio_t* io, const void* buffer, size_t capacity,
                               size_t* out_actual);
zx_status_t zxio_default_write_at(zxio_t* io, size_t offset, const void* buffer,
                                  size_t capacity, size_t* out_actual);
zx_status_t zxio_default_seek(zxio_t* io, size_t offset, zxio_seek_origin_t start,
                              size_t* out_offset);
zx_status_t zxio_default_truncate(zxio_t* io, size_t length);
zx_status_t zxio_default_flags_get(zxio_t* io, uint32_t* out_flags);
zx_status_t zxio_default_flags_set(zxio_t* io, uint32_t flags);
zx_status_t zxio_default_vmo_get(zxio_t* io, uint32_t flags, zx_handle_t* out_vmo,
                                 size_t* out_size);
zx_status_t zxio_default_open(zxio_t* io, uint32_t flags, uint32_t mode,
                              const char* path, zxio_t** out_io);
zx_status_t zxio_default_open_async(zxio_t* io, uint32_t flags, uint32_t mode,
                                    const char* path, zx_handle_t request);
zx_status_t zxio_default_unlink(zxio_t* io, const char* path);
zx_status_t zxio_default_token_get(zxio_t* io, zx_handle_t* out_token);
zx_status_t zxio_default_rename(zxio_t* io, const char* src_path,
                                zx_handle_t dst_token, const char* dst_path);
zx_status_t zxio_default_link(zxio_t* io, const char* src_path,
                              zx_handle_t dst_token, const char* dst_path);
zx_status_t zxio_default_readdir(zxio_t* io, void* buffer, size_t capacity,
                                 size_t* out_actual);
zx_status_t zxio_default_rewind(zxio_t* io);
zx_status_t zxio_default_isatty(zxio_t* io, bool* tty);

// An ops table filled with the default implementations.
//
// This ops table is a good starting point for building other ops tables to that
// the default implementations of unimplemented operations is consistent across
// ops tables.
static __CONSTEXPR const zxio_ops_t zxio_default_ops = {
    .close = zxio_default_close,
    .release = zxio_default_release,
    .clone = zxio_default_clone,
    .wait_begin = zxio_default_wait_begin,
    .wait_end = zxio_default_wait_end,
    .sync = zxio_default_sync,
    .attr_get = zxio_default_attr_get,
    .attr_set = zxio_default_attr_set,
    .read = zxio_default_read,
    .read_at = zxio_default_read_at,
    .write = zxio_default_write,
    .write_at = zxio_default_write_at,
    .seek = zxio_default_seek,
    .truncate = zxio_default_truncate,
    .flags_get = zxio_default_flags_get,
    .flags_set = zxio_default_flags_set,
    .vmo_get = zxio_default_vmo_get,
    .open = zxio_default_open,
    .open_async = zxio_default_open_async,
    .unlink = zxio_default_unlink,
    .token_get = zxio_default_token_get,
    .rename = zxio_default_rename,
    .link = zxio_default_link,
    .readdir = zxio_default_readdir,
    .rewind = zxio_default_rewind,
    .isatty = zxio_default_isatty
};

// Null ------------------------------------------------------------------------

// Null implementations of the ZXIO operations.
//
// These default implementations coorespond to how a null I/O object (e.g., what
// you might get from /dev/null) behaves.
//
// The null implementation is similar to the default implementation, except the
// read, write, and close operations succeed with null effects.

zx_status_t zxio_null_read(zxio_t* io, void* buffer, size_t capacity,
                           size_t* out_actual);
zx_status_t zxio_null_write(zxio_t* io, const void* buffer, size_t capacity,
                            size_t* out_actual);

// Initializes a |zxio_t| object with a null ops table.
zx_status_t zxio_null_init(zxio_t* io);

__END_CDECLS

#endif // LIB_ZXIO_NULL_H_