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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
//! This module contains the current mess that is error handling.
use crate::protocol::xproto::{SetupAuthenticate, SetupFailed};
pub use crate::id_allocator::IdsExhausted;
use core::fmt;
#[cfg(feature = "std")]
use std::error::Error;
/// An error occurred while parsing some data
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum ParseError {
/// Not enough data was provided.
InsufficientData,
/// A value did not fit.
///
/// This error can e.g. happen when a value that was received from the X11 server does not fit
/// into an `usize`.
ConversionFailed,
/// The value of an expression could not be computed.
///
/// As an example, the length of the data in `xproto`'s `GetPropertyReply` is described by
/// `value_len * (format / 8)`. The multiplication could cause an overflow, which would be
/// represented by this error.
InvalidExpression,
/// A value was outside of its valid range.
///
/// There are two kinds of situations where this error can happen:
///
/// 1. The protocol was violated and a nonsensical value was found.
/// 2. The user of the API called the wrong parsing function.
///
/// Examples for the first kind of error:
///
/// - One of a set of values should be present (a `<switch>` in xcb-proto-speak), but none of
/// the `<cases>` matched. This can e.g. happen when parsing
/// [`crate::protocol::xinput::InputInfo`].
/// - Parsing a request with a length field that is too small for the request header to fit.
///
/// Examples for the second kind of error:
///
/// - Parsing an X11 error with `response_type != 0`.
/// - Parsing an X11 reply with `response_type != 1`.
/// - Parsing an X11 request with the wrong value for its `minor_opcode`.
InvalidValue,
/// Some file descriptors were expected, but not enough were received.
MissingFileDescriptors,
}
#[cfg(feature = "std")]
impl Error for ParseError {}
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ParseError::InsufficientData => write!(f, "Insufficient data was provided"),
ParseError::ConversionFailed => {
write!(f, "A value conversion failed due to out of range data")
}
ParseError::InvalidExpression => write!(
f,
"An expression could not be computed, e.g. due to overflow"
),
ParseError::InvalidValue => {
write!(f, "A value could not be parsed into an enumeration")
}
ParseError::MissingFileDescriptors => write!(f, "Missing file descriptors"),
}
}
}
/// An error that occurred while parsing the `$DISPLAY` environment variable
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum DisplayParsingError {
/// No explicit display was provided and the `$DISPLAY` environment variable is not set.
DisplayNotSet,
/// The given value could not be parsed. The input to parsing is provided.
MalformedValue(alloc::boxed::Box<str>),
/// The value of `$DISPLAY` is not valid unicode
NotUnicode,
/// An unknown error occurred during display parsing.
///
/// This is `XCB_CONN_CLOSED_PARSE_ERR`.
Unknown,
}
#[cfg(feature = "std")]
impl Error for DisplayParsingError {}
impl fmt::Display for DisplayParsingError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
DisplayParsingError::DisplayNotSet => {
write!(
f,
"$DISPLAY variable not set and no value was provided explicitly"
)
}
DisplayParsingError::MalformedValue(dpy) => {
write!(f, "Failed to parse value '{dpy}'")
}
DisplayParsingError::NotUnicode => {
write!(f, "The value of $DISPLAY is not valid unicode")
}
DisplayParsingError::Unknown => {
write!(f, "Unknown error while parsing a $DISPLAY address")
}
}
}
}
/// An error that occurred while connecting to an X11 server
#[derive(Debug)]
#[non_exhaustive]
pub enum ConnectError {
/// An unknown error occurred.
///
/// One situation were this error is used when libxcb indicates an error that does not match
/// any of the defined error conditions. Thus, libxcb is violating its own API (or new error
/// cases were defined, but are not yet handled by x11rb).
UnknownError,
/// Error while parsing some data, see `ParseError`.
ParseError(ParseError),
/// Out of memory.
///
/// This is `XCB_CONN_CLOSED_MEM_INSUFFICIENT`.
InsufficientMemory,
/// Error during parsing of display string.
///
/// This is `XCB_CONN_CLOSED_PARSE_ERR`.
DisplayParsingError(DisplayParsingError),
/// Server does not have a screen matching the display.
///
/// This is `XCB_CONN_CLOSED_INVALID_SCREEN`.
InvalidScreen,
/// An I/O error occurred on the connection.
#[cfg(feature = "std")]
IoError(std::io::Error),
/// Invalid ID mask provided by the server.
///
/// The value of `resource_id_mask` in the `Setup` provided by the server was zero.
ZeroIdMask,
/// The server rejected the connection with a `SetupAuthenticate` message.
SetupAuthenticate(SetupAuthenticate),
/// The server rejected the connection with a `SetupFailed` message.
SetupFailed(SetupFailed),
/// The client did not receive enough data from the server to complete
/// the handshake.
Incomplete {
/// The number of bytes that were expected.
expected: usize,
/// The number of bytes that were received.
received: usize,
},
}
#[cfg(feature = "std")]
impl Error for ConnectError {}
impl fmt::Display for ConnectError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fn display(f: &mut fmt::Formatter<'_>, prefix: &str, value: &[u8]) -> fmt::Result {
match core::str::from_utf8(value).ok() {
Some(value) => write!(f, "{prefix}: '{value}'"),
None => write!(f, "{prefix}: {value:?} [message is not utf8]"),
}
}
match self {
ConnectError::UnknownError => write!(f, "Unknown connection error"),
ConnectError::InsufficientMemory => write!(f, "Insufficient memory"),
ConnectError::DisplayParsingError(err) => err.fmt(f),
ConnectError::InvalidScreen => write!(f, "Invalid screen"),
ConnectError::ParseError(err) => err.fmt(f),
#[cfg(feature = "std")]
ConnectError::IoError(err) => err.fmt(f),
ConnectError::ZeroIdMask => write!(f, "XID mask was zero"),
ConnectError::SetupFailed(err) => display(f, "X11 setup failed", &err.reason),
ConnectError::SetupAuthenticate(err) => {
display(f, "X11 authentication failed", &err.reason)
}
ConnectError::Incomplete { expected, received } => write!(
f,
"Not enough data received to complete the handshake. Expected {expected}, received {received}"
),
}
}
}
impl From<ParseError> for ConnectError {
fn from(err: ParseError) -> Self {
ConnectError::ParseError(err)
}
}
impl From<DisplayParsingError> for ConnectError {
fn from(err: DisplayParsingError) -> Self {
ConnectError::DisplayParsingError(err)
}
}
#[cfg(feature = "std")]
impl From<std::io::Error> for ConnectError {
fn from(err: std::io::Error) -> Self {
ConnectError::IoError(err)
}
}