// 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 <stdarg.h>
#include <stdatomic.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include <magenta/types.h>
#include <mxio/io.h>

#include "private.h"

void mxio_free(mxio_t* io) {
    io->magic = 0xDEAD0123;
    io->ops = NULL;
    free(io);
}

ssize_t mxio_default_read(mxio_t* io, void* _data, size_t len) {
    return 0;
}

ssize_t mxio_default_read_at(mxio_t* io, void* _data, size_t len, off_t offset) {
    return MX_ERR_WRONG_TYPE;
}

ssize_t mxio_default_write(mxio_t* io, const void* _data, size_t len) {
    return len;
}

ssize_t mxio_default_write_at(mxio_t* io, const void* _data, size_t len, off_t offset) {
    return MX_ERR_WRONG_TYPE;
}

ssize_t mxio_default_recvfrom(mxio_t* io, void* data, size_t len, int flags, struct sockaddr* restrict addr, socklen_t* restrict addrlen) {
    return MX_ERR_WRONG_TYPE;
}

ssize_t mxio_default_sendto(mxio_t* io, const void* data, size_t len, int flags, const struct sockaddr* addr, socklen_t addrlen) {
    return MX_ERR_WRONG_TYPE;
}

ssize_t mxio_default_recvmsg(mxio_t* io, struct msghdr* msg, int flags) {
    return MX_ERR_WRONG_TYPE;
}

ssize_t mxio_default_sendmsg(mxio_t* io, const struct msghdr* msg, int flags) {
    return MX_ERR_WRONG_TYPE;
}

off_t mxio_default_seek(mxio_t* io, off_t offset, int whence) {
    return MX_ERR_WRONG_TYPE;
}

mx_status_t mxio_default_misc(mxio_t* io, uint32_t op, int64_t off, uint32_t arg, void* data, size_t len) {
    return MX_ERR_NOT_SUPPORTED;
}

mx_status_t mxio_default_open(mxio_t* io, const char* path, int32_t flags, uint32_t mode, mxio_t** out) {
    return MX_ERR_NOT_SUPPORTED;
}

mx_status_t mxio_default_clone(mxio_t* io, mx_handle_t* handles, uint32_t* types) {
    return MX_ERR_NOT_SUPPORTED;
}

mx_status_t mxio_default_unwrap(mxio_t* io, mx_handle_t* handles, uint32_t* types) {
    return MX_ERR_NOT_SUPPORTED;
}

mx_status_t mxio_default_shutdown(mxio_t* io, int how) {
    return MX_ERR_WRONG_TYPE;
}

mx_status_t mxio_default_close(mxio_t* io) {
    return MX_OK;
}

ssize_t mxio_default_ioctl(mxio_t* io, uint32_t op, const void* in_buf,
                           size_t in_len, void* out_buf, size_t out_len) {
    return MX_ERR_NOT_SUPPORTED;
}

void mxio_default_wait_begin(mxio_t* io, uint32_t events,
                             mx_handle_t* handle, mx_signals_t* _signals) {
    *handle = MX_HANDLE_INVALID;
}

void mxio_default_wait_end(mxio_t* io, mx_signals_t signals, uint32_t* _events) {
}

ssize_t mxio_default_posix_ioctl(mxio_t* io, int req, va_list va) {
    return MX_ERR_NOT_SUPPORTED;
}

mx_status_t mxio_default_get_vmo(mxio_t* io, mx_handle_t* out, size_t* off, size_t* len) {
    return MX_ERR_NOT_SUPPORTED;
}

static mxio_ops_t mx_null_ops = {
    .read = mxio_default_read,
    .read_at = mxio_default_read_at,
    .write = mxio_default_write,
    .write_at = mxio_default_write_at,
    .recvfrom = mxio_default_recvfrom,
    .sendto = mxio_default_sendto,
    .recvmsg = mxio_default_recvmsg,
    .sendmsg = mxio_default_sendmsg,
    .seek = mxio_default_seek,
    .misc = mxio_default_misc,
    .close = mxio_default_close,
    .open = mxio_default_open,
    .clone = mxio_default_clone,
    .ioctl = mxio_default_ioctl,
    .wait_begin = mxio_default_wait_begin,
    .wait_end = mxio_default_wait_end,
    .unwrap = mxio_default_unwrap,
    .shutdown = mxio_default_shutdown,
    .posix_ioctl = mxio_default_posix_ioctl,
    .get_vmo = mxio_default_get_vmo,
};

mxio_t* mxio_null_create(void) {
    mxio_t* io = calloc(1, sizeof(*io));
    if (io == NULL) {
        return NULL;
    }
    io->ops = &mx_null_ops;
    io->magic = MXIO_MAGIC;
    atomic_init(&io->refcount, 1);
    return io;
}