fidl_next/decode/
error.rs

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
// Copyright 2024 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.

use thiserror::Error;

/// Errors that can be produced when decoding FIDL messages.
#[derive(Error, Debug)]
pub enum DecodeError {
    /// A required handle was absent
    #[error("required handle is absent")]
    RequiredHandleAbsent,

    /// A required value was absent
    #[error("required value is absent")]
    RequiredValueAbsent,

    /// A boolean was set to a value other than 0 or 1
    #[error("`bool` field has an invalid value; expected 0 or 1, found {0}")]
    InvalidBool(u8),

    /// A handle was set to a value other than 0 or u32::MAX
    #[error("handle has an invalid presence marker; expected 0 or u32::MAX, found {0}")]
    InvalidHandlePresence(u32),

    /// A pointer was set to a value other than 0 or u64::MAX
    #[error("pointer has an invalid presence marker; expected 0 or u64::MAX, found {0}.")]
    InvalidPointerPresence(u64),

    /// An envelope had an invalid size
    #[error("invalid envelope size; expected a multiple of 8, found {0}")]
    InvalidEnvelopeSize(u32),

    /// An enum had an invalid ordinal
    #[error("invalid enum ordinal; expected a valid ordinal, found {0}")]
    InvalidEnumOrdinal(i128),

    /// A union had an invalid ordinal
    #[error("invalid union ordinal; expected a valid ordinal, found {0}")]
    InvalidUnionOrdinal(usize),

    /// A bit set had an invalid set of bits
    #[error("invalid bits; expected a subset of {expected:b}, found {actual:b}")]
    InvalidBits {
        /// The expected set of bits
        expected: usize,
        /// The actual set of bits
        actual: usize,
    },

    /// An envelope was out-of-line, but the out-of-line data was too small
    #[error(
        "envelope has out-of-line data which is too small; expected more than 4 bytes out-of-line, \
        found {0} bytes"
    )]
    OutOfLineValueTooSmall(u32),

    /// An envelope had inline data that was too big
    #[error(
        "envelope has inline data which is too big; expected 4 bytes or fewer, found {0} bytes"
    )]
    InlineValueTooBig(usize),

    /// An envelope should always be inline, but it contained out-of-line data
    #[error("envelope should always be inline, but it contained {0} out-of-line bytes")]
    ExpectedInline(usize),

    /// An envelope consumed a different number of handles than it indicated in its metadata
    #[error(
        "envelope consumed a different number of handles than it claimed that it would; expected \
        {expected} to be consumed, found {actual} were consumed"
    )]
    IncorrectNumberOfHandlesConsumed {
        /// The number of handles the envelope was expected to consume
        expected: usize,
        /// The number of handles actually consumed by the envelope
        actual: usize,
    },

    /// An optional value was marked absent but its size was non-zero
    #[error("optional value is absent but has a non-zero size; expected 0, found {0}")]
    InvalidOptionalSize(u64),

    /// A vector had a length greater than its allowed limit
    #[error(
        "vector has a length greater than the allowed limit; expected no more than {limit} \
        elements, found {size} elements"
    )]
    VectorTooLong {
        /// The actual size of the vector
        size: u64,
        /// The maximum allowed size of the vector
        limit: u64,
    },

    /// A string contained non-UTF8 data
    #[error("string has non-UTF8 content; {0}")]
    InvalidUtf8(#[from] core::str::Utf8Error),

    /// A union was marked absent, but its envelope was not set to zero
    #[error("union is absent but has a non-zero envelope")]
    InvalidUnionEnvelope,

    /// A framework error contained an unrecognized error code.
    #[error("framework error has an unrecognized error code")]
    InvalidFrameworkError(i32),

    /// The decoder ran out of data before decoding finished
    #[error("reached the end of the buffer before decoding finished")]
    InsufficientData,

    /// The decoder ran out of handles before decoding finished
    #[error("consumed all handles before decoding finished")]
    InsufficientHandles,

    /// Decoding finished without consuming all of the bytes
    #[error(
        "finished decoding before all bytes were consumed; completed with {num_extra} bytes left \
        over"
    )]
    ExtraBytes {
        /// The number of bytes left over after decoding finished
        num_extra: usize,
    },

    /// Decoding finished without consuming all of the handles
    #[error(
        "finished decoding before all handles were consumed; completed with {num_extra} handles \
        left over"
    )]
    ExtraHandles {
        /// The number of handles left over after decoding finished
        num_extra: usize,
    },
}