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
100
101
102
103
104
105
106
107
108
109
110
111
112
113

//! Structural validation of QCOW headers and table offsets.

use super::{constants::QCOW_VERSION_1, header::QcowHeader};
use crate::{ByteSource, Error, Result};

pub(super) fn validate_header_layout(source: &dyn ByteSource, header: &QcowHeader) -> Result<()> {
  let file_size = source.size()?;
  let cluster_size = header.cluster_size()?;
  let l2_entry_count = header.l2_entry_count()?;

  if header.l1_entry_count == 0 {
    return Err(Error::invalid_format(
      "qcow l1 table must contain at least one entry".to_string(),
    ));
  }
  if header.header_size < 48 {
    return Err(Error::invalid_format(
      "qcow header size is smaller than the base header".to_string(),
    ));
  }
  if header.virtual_size == 0 {
    return Err(Error::invalid_format(
      "qcow virtual size must be non-zero".to_string(),
    ));
  }

  validate_range(
    file_size,
    header.l1_table_offset,
    u64::from(header.l1_entry_count) * 8,
    "qcow l1 table",
  )?;

  if header.backing_file_size != 0 {
    if header.backing_file_offset < u64::from(header.header_size) {
      return Err(Error::invalid_format(
        "qcow backing file name overlaps the header".to_string(),
      ));
    }
    validate_range(
      file_size,
      header.backing_file_offset,
      u64::from(header.backing_file_size),
      "qcow backing file name",
    )?;
  }

  if header.version != QCOW_VERSION_1 {
    if header.refcount_table_clusters == 0 {
      return Err(Error::invalid_format(
        "qcow refcount table cluster count must be non-zero".to_string(),
      ));
    }
    validate_cluster_alignment(
      header.refcount_table_offset,
      cluster_size,
      "qcow refcount table",
    )?;
    validate_range(
      file_size,
      header.refcount_table_offset,
      u64::from(header.refcount_table_clusters)
        .checked_mul(cluster_size)
        .ok_or_else(|| Error::invalid_range("qcow refcount table size overflow"))?,
      "qcow refcount table",
    )?;
  }

  if header.snapshot_count != 0 && header.snapshot_table_offset == 0 {
    return Err(Error::invalid_format(
      "qcow snapshot table offset is missing".to_string(),
    ));
  }
  if header.snapshot_count != 0 {
    validate_range(
      file_size,
      header.snapshot_table_offset,
      40,
      "qcow snapshot table",
    )?;
  }

  if l2_entry_count == 0 {
    return Err(Error::invalid_format(
      "qcow l2 table must contain at least one entry".to_string(),
    ));
  }

  Ok(())
}

pub(super) fn validate_cluster_alignment(
  offset: u64, cluster_size: u64, label: &str,
) -> Result<()> {
  if !offset.is_multiple_of(cluster_size) {
    return Err(Error::invalid_format(format!(
      "{label} offset is not cluster aligned"
    )));
  }
  Ok(())
}

pub(super) fn validate_range(file_size: u64, offset: u64, size: u64, label: &str) -> Result<()> {
  let end = offset
    .checked_add(size)
    .ok_or_else(|| Error::invalid_range(format!("{label} range overflows")))?;
  if end > file_size {
    return Err(Error::invalid_format(format!(
      "{label} exceeds the source size"
    )));
  }
  Ok(())
}