// Copyright 2019 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#![cfg(not(test))]
#![no_main]

use std::io::Cursor;
use std::io::Read;
use std::io::Seek;
use std::io::SeekFrom;
use std::io::Write;
use std::mem::size_of;

use base::FileReadWriteAtVolatile;
use base::VolatileSlice;
use crosvm_fuzz::fuzz_target;
use disk::QcowFile;

// Take the first 64 bits of data as an address and the next 64 bits as data to
// store there. The rest of the data is used as a qcow image.
fuzz_target!(|bytes| {
    if bytes.len() < 16 {
        // Need an address and data, each are 8 bytes.
        return;
    }
    let mut disk_image = Cursor::new(bytes);
    let addr = read_u64(&mut disk_image);
    let value = read_u64(&mut disk_image);
    let mut disk_file = tempfile::tempfile().unwrap();
    disk_file.write_all(&bytes[16..]).unwrap();
    disk_file.seek(SeekFrom::Start(0)).unwrap();
    if let Ok(qcow) = QcowFile::from(
        disk_file,
        disk::DiskFileParams {
            path: "/foo".into(),
            is_read_only: false,
            is_sparse_file: false,
            is_overlapped: false,
            is_direct: false,
            lock: true,
            depth: 0,
        },
    ) {
        let mut mem = value.to_le_bytes().to_owned();
        let vslice = VolatileSlice::new(&mut mem);
        let _ = qcow.write_all_at_volatile(vslice, addr);
    }
});

fn read_u64<T: Read>(readable: &mut T) -> u64 {
    let mut buf = [0u8; size_of::<u64>()];
    readable.read_exact(&mut buf[..]).unwrap();
    u64::from_le_bytes(buf)
}