zircon/system/core/netsvc/netcp.h

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

#pragma once

#include <optional>

#include <sys/types.h>
#include <zircon/types.h>

int netcp_open(const char* filename, uint32_t arg, size_t* file_size);

ssize_t netcp_offset_read(void* data_out, off_t offset, size_t max_len);

ssize_t netcp_read(void* data_out, size_t data_sz);

ssize_t netcp_offset_write(const char* data, off_t offset, size_t length);

ssize_t netcp_write(const char* data, size_t len);

int netcp_close();

void netcp_abort_write();


namespace netsvc {

class NetCopyInterface {
public:
    virtual ~NetCopyInterface() {}
    virtual int Open(const char* filename, uint32_t arg, size_t* file_size) = 0;
    virtual ssize_t Read(void* data_out, std::optional<off_t> offset, size_t max_len) = 0;
    virtual ssize_t Write(const char* data, std::optional<off_t> offset, size_t length) = 0;
    virtual int Close() = 0;
    virtual void AbortWrite() = 0;
};

class NetCopy : public NetCopyInterface {
public:
    explicit NetCopy() {}

    int Open(const char* filename, uint32_t arg, size_t* file_size) final {
        return netcp_open(filename, arg, file_size);
    }

    ssize_t Read(void* data_out, std::optional<off_t> offset, size_t max_len) final {
        if (offset) {
            return netcp_offset_read(data_out, *offset, max_len);
        } else {
            return netcp_read(data_out, max_len);
        }
    }

    ssize_t Write(const char* data, std::optional<off_t> offset, size_t length) final {
        if (offset) {
            return netcp_offset_write(data, *offset, length);
        } else {
            return netcp_write(data, length);
        }
    }

    int Close() final {
        return netcp_close();
    }

    void AbortWrite() final {
        netcp_abort_write();
    }
};

} // namespace netsvc