wxtla 0.3.1

Wired eXploring Target Layer Accessor
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Open MBR volume-system state.

use std::sync::Arc;

use super::{DESCRIPTOR, entry::MbrPartitionInfo};
use crate::{
  ByteSourceHandle, Error, Result, SliceDataSource,
  volumes::{VolumeRecord, VolumeSystem},
};

/// Open MBR volume system.
pub struct MbrVolumeSystem {
  source: ByteSourceHandle,
  bytes_per_sector: u32,
  disk_signature: u32,
  volumes: Vec<VolumeRecord>,
  partitions: Vec<MbrPartitionInfo>,
}

impl MbrVolumeSystem {
  /// Create a new open MBR volume system.
  pub fn new(
    source: ByteSourceHandle, bytes_per_sector: u32, disk_signature: u32,
    partitions: Vec<MbrPartitionInfo>,
  ) -> Self {
    let volumes = partitions
      .iter()
      .map(|partition| partition.record.clone())
      .collect();

    Self {
      source,
      bytes_per_sector,
      disk_signature,
      volumes,
      partitions,
    }
  }

  /// Return the MBR disk signature.
  pub fn disk_signature(&self) -> u32 {
    self.disk_signature
  }

  /// Return the parsed MBR partition metadata.
  pub fn partitions(&self) -> &[MbrPartitionInfo] {
    &self.partitions
  }

  /// Return the bytes-per-sector value used to map LBAs.
  pub fn bytes_per_sector(&self) -> u32 {
    self.bytes_per_sector
  }

  /// Return the volume-system block size in bytes.
  pub fn block_size(&self) -> u32 {
    self.bytes_per_sector
  }

  /// Return the discovered volume records.
  pub fn volumes(&self) -> &[VolumeRecord] {
    &self.volumes
  }

  /// Open the logical byte range corresponding to a volume.
  pub fn open_volume(&self, index: usize) -> Result<ByteSourceHandle> {
    let volume = self
      .volumes
      .get(index)
      .ok_or_else(|| Error::not_found(format!("mbr volume index {index} is out of bounds")))?;
    let slice: ByteSourceHandle = Arc::new(SliceDataSource::new(
      self.source.clone(),
      volume.span.byte_offset,
      volume.span.byte_size,
    ));

    Ok(slice)
  }
}

impl VolumeSystem for MbrVolumeSystem {
  fn descriptor(&self) -> crate::FormatDescriptor {
    DESCRIPTOR
  }

  fn block_size(&self) -> u32 {
    self.block_size()
  }

  fn volumes(&self) -> &[VolumeRecord] {
    self.volumes()
  }

  fn open_volume(&self, index: usize) -> Result<ByteSourceHandle> {
    self.open_volume(index)
  }
}

crate::volumes::driver::impl_volume_system_data_source!(MbrVolumeSystem);