x11rb_protocol/protocol/
shm.rs

1// This file contains generated code. Do not edit directly.
2// To regenerate this, run 'make'.
3
4//! Bindings to the `Shm` X11 extension.
5
6#![allow(clippy::too_many_arguments)]
7// The code generator is simpler if it can always use conversions
8#![allow(clippy::useless_conversion)]
9
10#[allow(unused_imports)]
11use alloc::borrow::Cow;
12#[allow(unused_imports)]
13use core::convert::TryInto;
14use alloc::vec;
15use alloc::vec::Vec;
16use core::convert::TryFrom;
17use crate::errors::ParseError;
18#[allow(unused_imports)]
19use crate::x11_utils::TryIntoUSize;
20use crate::BufWithFds;
21#[allow(unused_imports)]
22use crate::utils::{RawFdContainer, pretty_print_bitmask, pretty_print_enum};
23#[allow(unused_imports)]
24use crate::x11_utils::{Request, RequestHeader, Serialize, TryParse, TryParseFd};
25#[allow(unused_imports)]
26use super::xproto;
27
28/// The X11 name of the extension for QueryExtension
29pub const X11_EXTENSION_NAME: &str = "MIT-SHM";
30
31/// The version number of this extension that this client library supports.
32///
33/// This constant contains the version number of this extension that is supported
34/// by this build of x11rb. For most things, it does not make sense to use this
35/// information. If you need to send a `QueryVersion`, it is recommended to instead
36/// send the maximum version of the extension that you need.
37pub const X11_XML_VERSION: (u32, u32) = (1, 2);
38
39pub type Seg = u32;
40
41/// Opcode for the Completion event
42pub const COMPLETION_EVENT: u8 = 0;
43/// Report that an XCB_SHM_PUT_IMAGE request has completed.
44///
45/// This is generated by the X server to report that an XCB_SHM_PUT_IMAGE request
46/// has been successfully processed.
47///
48/// # Fields
49///
50/// * `drawable` - The drawable used in the XCB_SHM_PUT_IMAGE request.
51/// * `minor_event` - The minor opcode used in the request.  Always XCB_SHM_PUT_IMAGE.
52/// * `major_event` - The major opcode used in the request.  Always the opcode of the MIT-SHM
53/// extension.
54/// * `shmseg` - The shared memory segment used in the request.
55/// * `offset` - The offset in the shared memory segment used in the request.
56#[derive(Clone, Copy, Default)]
57#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
58#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
59pub struct CompletionEvent {
60    pub response_type: u8,
61    pub sequence: u16,
62    pub drawable: xproto::Drawable,
63    pub minor_event: u16,
64    pub major_event: u8,
65    pub shmseg: Seg,
66    pub offset: u32,
67}
68impl_debug_if_no_extra_traits!(CompletionEvent, "CompletionEvent");
69impl TryParse for CompletionEvent {
70    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
71        let remaining = initial_value;
72        let (response_type, remaining) = u8::try_parse(remaining)?;
73        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
74        let (sequence, remaining) = u16::try_parse(remaining)?;
75        let (drawable, remaining) = xproto::Drawable::try_parse(remaining)?;
76        let (minor_event, remaining) = u16::try_parse(remaining)?;
77        let (major_event, remaining) = u8::try_parse(remaining)?;
78        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
79        let (shmseg, remaining) = Seg::try_parse(remaining)?;
80        let (offset, remaining) = u32::try_parse(remaining)?;
81        let result = CompletionEvent { response_type, sequence, drawable, minor_event, major_event, shmseg, offset };
82        let _ = remaining;
83        let remaining = initial_value.get(32..)
84            .ok_or(ParseError::InsufficientData)?;
85        Ok((result, remaining))
86    }
87}
88impl Serialize for CompletionEvent {
89    type Bytes = [u8; 20];
90    fn serialize(&self) -> [u8; 20] {
91        let response_type_bytes = self.response_type.serialize();
92        let sequence_bytes = self.sequence.serialize();
93        let drawable_bytes = self.drawable.serialize();
94        let minor_event_bytes = self.minor_event.serialize();
95        let major_event_bytes = self.major_event.serialize();
96        let shmseg_bytes = self.shmseg.serialize();
97        let offset_bytes = self.offset.serialize();
98        [
99            response_type_bytes[0],
100            0,
101            sequence_bytes[0],
102            sequence_bytes[1],
103            drawable_bytes[0],
104            drawable_bytes[1],
105            drawable_bytes[2],
106            drawable_bytes[3],
107            minor_event_bytes[0],
108            minor_event_bytes[1],
109            major_event_bytes[0],
110            0,
111            shmseg_bytes[0],
112            shmseg_bytes[1],
113            shmseg_bytes[2],
114            shmseg_bytes[3],
115            offset_bytes[0],
116            offset_bytes[1],
117            offset_bytes[2],
118            offset_bytes[3],
119        ]
120    }
121    fn serialize_into(&self, bytes: &mut Vec<u8>) {
122        bytes.reserve(20);
123        self.response_type.serialize_into(bytes);
124        bytes.extend_from_slice(&[0; 1]);
125        self.sequence.serialize_into(bytes);
126        self.drawable.serialize_into(bytes);
127        self.minor_event.serialize_into(bytes);
128        self.major_event.serialize_into(bytes);
129        bytes.extend_from_slice(&[0; 1]);
130        self.shmseg.serialize_into(bytes);
131        self.offset.serialize_into(bytes);
132    }
133}
134impl From<&CompletionEvent> for [u8; 32] {
135    fn from(input: &CompletionEvent) -> Self {
136        let response_type_bytes = input.response_type.serialize();
137        let sequence_bytes = input.sequence.serialize();
138        let drawable_bytes = input.drawable.serialize();
139        let minor_event_bytes = input.minor_event.serialize();
140        let major_event_bytes = input.major_event.serialize();
141        let shmseg_bytes = input.shmseg.serialize();
142        let offset_bytes = input.offset.serialize();
143        [
144            response_type_bytes[0],
145            0,
146            sequence_bytes[0],
147            sequence_bytes[1],
148            drawable_bytes[0],
149            drawable_bytes[1],
150            drawable_bytes[2],
151            drawable_bytes[3],
152            minor_event_bytes[0],
153            minor_event_bytes[1],
154            major_event_bytes[0],
155            0,
156            shmseg_bytes[0],
157            shmseg_bytes[1],
158            shmseg_bytes[2],
159            shmseg_bytes[3],
160            offset_bytes[0],
161            offset_bytes[1],
162            offset_bytes[2],
163            offset_bytes[3],
164            // trailing padding
165            0,
166            0,
167            0,
168            0,
169            0,
170            0,
171            0,
172            0,
173            0,
174            0,
175            0,
176            0,
177        ]
178    }
179}
180impl From<CompletionEvent> for [u8; 32] {
181    fn from(input: CompletionEvent) -> Self {
182        Self::from(&input)
183    }
184}
185
186/// Opcode for the BadSeg error
187pub const BAD_SEG_ERROR: u8 = 0;
188
189/// Opcode for the QueryVersion request
190pub const QUERY_VERSION_REQUEST: u8 = 0;
191/// Query the version of the MIT-SHM extension..
192///
193/// This is used to determine the version of the MIT-SHM extension supported by the
194/// X server.  Clients MUST NOT make other requests in this extension until a reply
195/// to this requests indicates the X server supports them.
196#[derive(Clone, Copy, Default)]
197#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
198#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
199pub struct QueryVersionRequest;
200impl_debug_if_no_extra_traits!(QueryVersionRequest, "QueryVersionRequest");
201impl QueryVersionRequest {
202    /// Serialize this request into bytes for the provided connection
203    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
204        let length_so_far = 0;
205        let mut request0 = vec![
206            major_opcode,
207            QUERY_VERSION_REQUEST,
208            0,
209            0,
210        ];
211        let length_so_far = length_so_far + request0.len();
212        assert_eq!(length_so_far % 4, 0);
213        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
214        request0[2..4].copy_from_slice(&length.to_ne_bytes());
215        ([request0.into()], vec![])
216    }
217    /// Parse this request given its header, its body, and any fds that go along with it
218    #[cfg(feature = "request-parsing")]
219    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
220        if header.minor_opcode != QUERY_VERSION_REQUEST {
221            return Err(ParseError::InvalidValue);
222        }
223        let _ = value;
224        Ok(QueryVersionRequest
225        )
226    }
227}
228impl Request for QueryVersionRequest {
229    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
230
231    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
232        let (bufs, fds) = self.serialize(major_opcode);
233        // Flatten the buffers into a single vector
234        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
235        (buf, fds)
236    }
237}
238impl crate::x11_utils::ReplyRequest for QueryVersionRequest {
239    type Reply = QueryVersionReply;
240}
241
242/// The version of the MIT-SHM extension supported by the server.
243///
244/// This contains the version of the MIT-SHM extension supported by the server, as
245/// well as the server’s UID and GID.  Clients MUST obtain the version supproted by
246/// the server before making other requests from this extension.  To prevent local
247/// privilege escalation and local information leak security vulnerabilities,
248/// clients MUST ensure that System V shared memory objects they use with this
249/// extension can only be accessed by the client and the X server.  If this is not
250/// possible, the requests in this extension that use System V shared memory MUST
251/// NOT be used.  The file descriptor-passing versions provide an alternative.
252///
253/// # Fields
254///
255/// * `shared_pixmaps` - True if the server supports shared pixmaps, otherwise false.
256/// * `major_version` - The major version of the extension supported.
257/// * `minor_version` - The minor version of the extension supported.
258/// * `uid` - The UID of the server.
259/// * `gid` - The GID of the server.
260#[derive(Clone, Copy, Default)]
261#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
262#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
263pub struct QueryVersionReply {
264    pub shared_pixmaps: bool,
265    pub sequence: u16,
266    pub length: u32,
267    pub major_version: u16,
268    pub minor_version: u16,
269    pub uid: u16,
270    pub gid: u16,
271    pub pixmap_format: u8,
272}
273impl_debug_if_no_extra_traits!(QueryVersionReply, "QueryVersionReply");
274impl TryParse for QueryVersionReply {
275    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
276        let remaining = initial_value;
277        let (response_type, remaining) = u8::try_parse(remaining)?;
278        let (shared_pixmaps, remaining) = bool::try_parse(remaining)?;
279        let (sequence, remaining) = u16::try_parse(remaining)?;
280        let (length, remaining) = u32::try_parse(remaining)?;
281        let (major_version, remaining) = u16::try_parse(remaining)?;
282        let (minor_version, remaining) = u16::try_parse(remaining)?;
283        let (uid, remaining) = u16::try_parse(remaining)?;
284        let (gid, remaining) = u16::try_parse(remaining)?;
285        let (pixmap_format, remaining) = u8::try_parse(remaining)?;
286        let remaining = remaining.get(15..).ok_or(ParseError::InsufficientData)?;
287        if response_type != 1 {
288            return Err(ParseError::InvalidValue);
289        }
290        let result = QueryVersionReply { shared_pixmaps, sequence, length, major_version, minor_version, uid, gid, pixmap_format };
291        let _ = remaining;
292        let remaining = initial_value.get(32 + length as usize * 4..)
293            .ok_or(ParseError::InsufficientData)?;
294        Ok((result, remaining))
295    }
296}
297impl Serialize for QueryVersionReply {
298    type Bytes = [u8; 32];
299    fn serialize(&self) -> [u8; 32] {
300        let response_type_bytes = &[1];
301        let shared_pixmaps_bytes = self.shared_pixmaps.serialize();
302        let sequence_bytes = self.sequence.serialize();
303        let length_bytes = self.length.serialize();
304        let major_version_bytes = self.major_version.serialize();
305        let minor_version_bytes = self.minor_version.serialize();
306        let uid_bytes = self.uid.serialize();
307        let gid_bytes = self.gid.serialize();
308        let pixmap_format_bytes = self.pixmap_format.serialize();
309        [
310            response_type_bytes[0],
311            shared_pixmaps_bytes[0],
312            sequence_bytes[0],
313            sequence_bytes[1],
314            length_bytes[0],
315            length_bytes[1],
316            length_bytes[2],
317            length_bytes[3],
318            major_version_bytes[0],
319            major_version_bytes[1],
320            minor_version_bytes[0],
321            minor_version_bytes[1],
322            uid_bytes[0],
323            uid_bytes[1],
324            gid_bytes[0],
325            gid_bytes[1],
326            pixmap_format_bytes[0],
327            0,
328            0,
329            0,
330            0,
331            0,
332            0,
333            0,
334            0,
335            0,
336            0,
337            0,
338            0,
339            0,
340            0,
341            0,
342        ]
343    }
344    fn serialize_into(&self, bytes: &mut Vec<u8>) {
345        bytes.reserve(32);
346        let response_type_bytes = &[1];
347        bytes.push(response_type_bytes[0]);
348        self.shared_pixmaps.serialize_into(bytes);
349        self.sequence.serialize_into(bytes);
350        self.length.serialize_into(bytes);
351        self.major_version.serialize_into(bytes);
352        self.minor_version.serialize_into(bytes);
353        self.uid.serialize_into(bytes);
354        self.gid.serialize_into(bytes);
355        self.pixmap_format.serialize_into(bytes);
356        bytes.extend_from_slice(&[0; 15]);
357    }
358}
359
360/// Opcode for the Attach request
361pub const ATTACH_REQUEST: u8 = 1;
362/// Attach a System V shared memory segment..
363///
364/// Attach a System V shared memory segment to the server.  This will fail unless
365/// the server has permission to map the segment.  The client may destroy the segment
366/// as soon as it receives a XCB_SHM_COMPLETION event with the shmseg value in this
367/// request and with the appropriate serial number.
368///
369/// # Fields
370///
371/// * `shmseg` - A shared memory segment ID created with xcb_generate_id().
372/// * `shmid` - The System V shared memory segment the server should map.
373/// * `read_only` - True if the segment shall be mapped read only by the X11 server, otherwise false.
374#[derive(Clone, Copy, Default)]
375#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
376#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
377pub struct AttachRequest {
378    pub shmseg: Seg,
379    pub shmid: u32,
380    pub read_only: bool,
381}
382impl_debug_if_no_extra_traits!(AttachRequest, "AttachRequest");
383impl AttachRequest {
384    /// Serialize this request into bytes for the provided connection
385    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
386        let length_so_far = 0;
387        let shmseg_bytes = self.shmseg.serialize();
388        let shmid_bytes = self.shmid.serialize();
389        let read_only_bytes = self.read_only.serialize();
390        let mut request0 = vec![
391            major_opcode,
392            ATTACH_REQUEST,
393            0,
394            0,
395            shmseg_bytes[0],
396            shmseg_bytes[1],
397            shmseg_bytes[2],
398            shmseg_bytes[3],
399            shmid_bytes[0],
400            shmid_bytes[1],
401            shmid_bytes[2],
402            shmid_bytes[3],
403            read_only_bytes[0],
404            0,
405            0,
406            0,
407        ];
408        let length_so_far = length_so_far + request0.len();
409        assert_eq!(length_so_far % 4, 0);
410        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
411        request0[2..4].copy_from_slice(&length.to_ne_bytes());
412        ([request0.into()], vec![])
413    }
414    /// Parse this request given its header, its body, and any fds that go along with it
415    #[cfg(feature = "request-parsing")]
416    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
417        if header.minor_opcode != ATTACH_REQUEST {
418            return Err(ParseError::InvalidValue);
419        }
420        let (shmseg, remaining) = Seg::try_parse(value)?;
421        let (shmid, remaining) = u32::try_parse(remaining)?;
422        let (read_only, remaining) = bool::try_parse(remaining)?;
423        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
424        let _ = remaining;
425        Ok(AttachRequest {
426            shmseg,
427            shmid,
428            read_only,
429        })
430    }
431}
432impl Request for AttachRequest {
433    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
434
435    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
436        let (bufs, fds) = self.serialize(major_opcode);
437        // Flatten the buffers into a single vector
438        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
439        (buf, fds)
440    }
441}
442impl crate::x11_utils::VoidRequest for AttachRequest {
443}
444
445/// Opcode for the Detach request
446pub const DETACH_REQUEST: u8 = 2;
447/// Destroys the specified shared memory segment..
448///
449/// Destroys the specified shared memory segment.  This will never fail unless the
450/// segment number is incorrect.
451///
452/// # Fields
453///
454/// * `shmseg` - The segment to be destroyed.
455#[derive(Clone, Copy, Default)]
456#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
457#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
458pub struct DetachRequest {
459    pub shmseg: Seg,
460}
461impl_debug_if_no_extra_traits!(DetachRequest, "DetachRequest");
462impl DetachRequest {
463    /// Serialize this request into bytes for the provided connection
464    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
465        let length_so_far = 0;
466        let shmseg_bytes = self.shmseg.serialize();
467        let mut request0 = vec![
468            major_opcode,
469            DETACH_REQUEST,
470            0,
471            0,
472            shmseg_bytes[0],
473            shmseg_bytes[1],
474            shmseg_bytes[2],
475            shmseg_bytes[3],
476        ];
477        let length_so_far = length_so_far + request0.len();
478        assert_eq!(length_so_far % 4, 0);
479        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
480        request0[2..4].copy_from_slice(&length.to_ne_bytes());
481        ([request0.into()], vec![])
482    }
483    /// Parse this request given its header, its body, and any fds that go along with it
484    #[cfg(feature = "request-parsing")]
485    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
486        if header.minor_opcode != DETACH_REQUEST {
487            return Err(ParseError::InvalidValue);
488        }
489        let (shmseg, remaining) = Seg::try_parse(value)?;
490        let _ = remaining;
491        Ok(DetachRequest {
492            shmseg,
493        })
494    }
495}
496impl Request for DetachRequest {
497    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
498
499    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
500        let (bufs, fds) = self.serialize(major_opcode);
501        // Flatten the buffers into a single vector
502        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
503        (buf, fds)
504    }
505}
506impl crate::x11_utils::VoidRequest for DetachRequest {
507}
508
509/// Opcode for the PutImage request
510pub const PUT_IMAGE_REQUEST: u8 = 3;
511/// Copy data from the shared memory to the specified drawable..
512///
513/// Copy data from the shared memory to the specified drawable.  The amount of bytes
514/// written to the destination image is always equal to the number of bytes read
515/// from the shared memory segment.
516///
517/// # Fields
518///
519/// * `drawable` - The drawable to draw to.
520/// * `gc` - The graphics context to use.
521/// * `total_width` - The total width of the source image.
522/// * `total_height` - The total height of the source image.
523/// * `src_x` - The source X coordinate of the sub-image to copy.
524/// * `src_y` - The source Y coordinate of the sub-image to copy.
525/// * `src_width` - The width, in source image coordinates, of the data to copy from the source.
526/// The X server will use this to determine the amount of data to copy.  The amount
527/// of the destination image that is overwritten is determined automatically.
528/// * `src_height` - The height, in source image coordinates, of the data to copy from the source.
529/// The X server will use this to determine the amount of data to copy.  The amount
530/// of the destination image that is overwritten is determined automatically.
531/// * `dst_x` - The X coordinate on the destination drawable to copy to.
532/// * `dst_y` - The Y coordinate on the destination drawable to copy to.
533/// * `depth` - The depth to use.
534/// * `format` - The format of the image being drawn.  If it is XYBitmap, depth must be 1, or a
535/// "BadMatch" error results.  The foreground pixel in the GC determines the source
536/// for the one bits in the image, and the background pixel determines the source
537/// for the zero bits.  For XYPixmap and ZPixmap, the depth must match the depth of
538/// the drawable, or a "BadMatch" error results.
539/// * `send_event` - True if the server should send an XCB_SHM_COMPLETION event when the blit
540/// completes.
541/// * `offset` - The offset that the source image starts at.
542#[derive(Clone, Copy, Default)]
543#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
544#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
545pub struct PutImageRequest {
546    pub drawable: xproto::Drawable,
547    pub gc: xproto::Gcontext,
548    pub total_width: u16,
549    pub total_height: u16,
550    pub src_x: u16,
551    pub src_y: u16,
552    pub src_width: u16,
553    pub src_height: u16,
554    pub dst_x: i16,
555    pub dst_y: i16,
556    pub depth: u8,
557    pub format: u8,
558    pub send_event: bool,
559    pub shmseg: Seg,
560    pub offset: u32,
561}
562impl_debug_if_no_extra_traits!(PutImageRequest, "PutImageRequest");
563impl PutImageRequest {
564    /// Serialize this request into bytes for the provided connection
565    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
566        let length_so_far = 0;
567        let drawable_bytes = self.drawable.serialize();
568        let gc_bytes = self.gc.serialize();
569        let total_width_bytes = self.total_width.serialize();
570        let total_height_bytes = self.total_height.serialize();
571        let src_x_bytes = self.src_x.serialize();
572        let src_y_bytes = self.src_y.serialize();
573        let src_width_bytes = self.src_width.serialize();
574        let src_height_bytes = self.src_height.serialize();
575        let dst_x_bytes = self.dst_x.serialize();
576        let dst_y_bytes = self.dst_y.serialize();
577        let depth_bytes = self.depth.serialize();
578        let format_bytes = self.format.serialize();
579        let send_event_bytes = self.send_event.serialize();
580        let shmseg_bytes = self.shmseg.serialize();
581        let offset_bytes = self.offset.serialize();
582        let mut request0 = vec![
583            major_opcode,
584            PUT_IMAGE_REQUEST,
585            0,
586            0,
587            drawable_bytes[0],
588            drawable_bytes[1],
589            drawable_bytes[2],
590            drawable_bytes[3],
591            gc_bytes[0],
592            gc_bytes[1],
593            gc_bytes[2],
594            gc_bytes[3],
595            total_width_bytes[0],
596            total_width_bytes[1],
597            total_height_bytes[0],
598            total_height_bytes[1],
599            src_x_bytes[0],
600            src_x_bytes[1],
601            src_y_bytes[0],
602            src_y_bytes[1],
603            src_width_bytes[0],
604            src_width_bytes[1],
605            src_height_bytes[0],
606            src_height_bytes[1],
607            dst_x_bytes[0],
608            dst_x_bytes[1],
609            dst_y_bytes[0],
610            dst_y_bytes[1],
611            depth_bytes[0],
612            format_bytes[0],
613            send_event_bytes[0],
614            0,
615            shmseg_bytes[0],
616            shmseg_bytes[1],
617            shmseg_bytes[2],
618            shmseg_bytes[3],
619            offset_bytes[0],
620            offset_bytes[1],
621            offset_bytes[2],
622            offset_bytes[3],
623        ];
624        let length_so_far = length_so_far + request0.len();
625        assert_eq!(length_so_far % 4, 0);
626        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
627        request0[2..4].copy_from_slice(&length.to_ne_bytes());
628        ([request0.into()], vec![])
629    }
630    /// Parse this request given its header, its body, and any fds that go along with it
631    #[cfg(feature = "request-parsing")]
632    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
633        if header.minor_opcode != PUT_IMAGE_REQUEST {
634            return Err(ParseError::InvalidValue);
635        }
636        let (drawable, remaining) = xproto::Drawable::try_parse(value)?;
637        let (gc, remaining) = xproto::Gcontext::try_parse(remaining)?;
638        let (total_width, remaining) = u16::try_parse(remaining)?;
639        let (total_height, remaining) = u16::try_parse(remaining)?;
640        let (src_x, remaining) = u16::try_parse(remaining)?;
641        let (src_y, remaining) = u16::try_parse(remaining)?;
642        let (src_width, remaining) = u16::try_parse(remaining)?;
643        let (src_height, remaining) = u16::try_parse(remaining)?;
644        let (dst_x, remaining) = i16::try_parse(remaining)?;
645        let (dst_y, remaining) = i16::try_parse(remaining)?;
646        let (depth, remaining) = u8::try_parse(remaining)?;
647        let (format, remaining) = u8::try_parse(remaining)?;
648        let (send_event, remaining) = bool::try_parse(remaining)?;
649        let remaining = remaining.get(1..).ok_or(ParseError::InsufficientData)?;
650        let (shmseg, remaining) = Seg::try_parse(remaining)?;
651        let (offset, remaining) = u32::try_parse(remaining)?;
652        let _ = remaining;
653        Ok(PutImageRequest {
654            drawable,
655            gc,
656            total_width,
657            total_height,
658            src_x,
659            src_y,
660            src_width,
661            src_height,
662            dst_x,
663            dst_y,
664            depth,
665            format,
666            send_event,
667            shmseg,
668            offset,
669        })
670    }
671}
672impl Request for PutImageRequest {
673    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
674
675    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
676        let (bufs, fds) = self.serialize(major_opcode);
677        // Flatten the buffers into a single vector
678        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
679        (buf, fds)
680    }
681}
682impl crate::x11_utils::VoidRequest for PutImageRequest {
683}
684
685/// Opcode for the GetImage request
686pub const GET_IMAGE_REQUEST: u8 = 4;
687/// Copies data from the specified drawable to the shared memory segment..
688///
689/// Copy data from the specified drawable to the shared memory segment.  The amount
690/// of bytes written to the destination image is always equal to the number of bytes
691/// read from the shared memory segment.
692///
693/// # Fields
694///
695/// * `drawable` - The drawable to copy the image out of.
696/// * `x` - The X coordinate in the drawable to begin copying at.
697/// * `y` - The Y coordinate in the drawable to begin copying at.
698/// * `width` - The width of the image to copy.
699/// * `height` - The height of the image to copy.
700/// * `plane_mask` - A mask that determines which planes are used.
701/// * `format` - The format to use for the copy (???).
702/// * `shmseg` - The destination shared memory segment.
703/// * `offset` - The offset in the shared memory segment to copy data to.
704#[derive(Clone, Copy, Default)]
705#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
706#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
707pub struct GetImageRequest {
708    pub drawable: xproto::Drawable,
709    pub x: i16,
710    pub y: i16,
711    pub width: u16,
712    pub height: u16,
713    pub plane_mask: u32,
714    pub format: u8,
715    pub shmseg: Seg,
716    pub offset: u32,
717}
718impl_debug_if_no_extra_traits!(GetImageRequest, "GetImageRequest");
719impl GetImageRequest {
720    /// Serialize this request into bytes for the provided connection
721    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
722        let length_so_far = 0;
723        let drawable_bytes = self.drawable.serialize();
724        let x_bytes = self.x.serialize();
725        let y_bytes = self.y.serialize();
726        let width_bytes = self.width.serialize();
727        let height_bytes = self.height.serialize();
728        let plane_mask_bytes = self.plane_mask.serialize();
729        let format_bytes = self.format.serialize();
730        let shmseg_bytes = self.shmseg.serialize();
731        let offset_bytes = self.offset.serialize();
732        let mut request0 = vec![
733            major_opcode,
734            GET_IMAGE_REQUEST,
735            0,
736            0,
737            drawable_bytes[0],
738            drawable_bytes[1],
739            drawable_bytes[2],
740            drawable_bytes[3],
741            x_bytes[0],
742            x_bytes[1],
743            y_bytes[0],
744            y_bytes[1],
745            width_bytes[0],
746            width_bytes[1],
747            height_bytes[0],
748            height_bytes[1],
749            plane_mask_bytes[0],
750            plane_mask_bytes[1],
751            plane_mask_bytes[2],
752            plane_mask_bytes[3],
753            format_bytes[0],
754            0,
755            0,
756            0,
757            shmseg_bytes[0],
758            shmseg_bytes[1],
759            shmseg_bytes[2],
760            shmseg_bytes[3],
761            offset_bytes[0],
762            offset_bytes[1],
763            offset_bytes[2],
764            offset_bytes[3],
765        ];
766        let length_so_far = length_so_far + request0.len();
767        assert_eq!(length_so_far % 4, 0);
768        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
769        request0[2..4].copy_from_slice(&length.to_ne_bytes());
770        ([request0.into()], vec![])
771    }
772    /// Parse this request given its header, its body, and any fds that go along with it
773    #[cfg(feature = "request-parsing")]
774    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
775        if header.minor_opcode != GET_IMAGE_REQUEST {
776            return Err(ParseError::InvalidValue);
777        }
778        let (drawable, remaining) = xproto::Drawable::try_parse(value)?;
779        let (x, remaining) = i16::try_parse(remaining)?;
780        let (y, remaining) = i16::try_parse(remaining)?;
781        let (width, remaining) = u16::try_parse(remaining)?;
782        let (height, remaining) = u16::try_parse(remaining)?;
783        let (plane_mask, remaining) = u32::try_parse(remaining)?;
784        let (format, remaining) = u8::try_parse(remaining)?;
785        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
786        let (shmseg, remaining) = Seg::try_parse(remaining)?;
787        let (offset, remaining) = u32::try_parse(remaining)?;
788        let _ = remaining;
789        Ok(GetImageRequest {
790            drawable,
791            x,
792            y,
793            width,
794            height,
795            plane_mask,
796            format,
797            shmseg,
798            offset,
799        })
800    }
801}
802impl Request for GetImageRequest {
803    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
804
805    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
806        let (bufs, fds) = self.serialize(major_opcode);
807        // Flatten the buffers into a single vector
808        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
809        (buf, fds)
810    }
811}
812impl crate::x11_utils::ReplyRequest for GetImageRequest {
813    type Reply = GetImageReply;
814}
815
816/// Indicates the result of the copy..
817///
818/// The result of the copy.
819///
820/// # Fields
821///
822/// * `depth` - The depth of the source drawable.
823/// * `visual` - The visual ID of the source drawable.
824/// * `size` - The number of bytes copied.
825#[derive(Clone, Copy, Default)]
826#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
827#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
828pub struct GetImageReply {
829    pub depth: u8,
830    pub sequence: u16,
831    pub length: u32,
832    pub visual: xproto::Visualid,
833    pub size: u32,
834}
835impl_debug_if_no_extra_traits!(GetImageReply, "GetImageReply");
836impl TryParse for GetImageReply {
837    fn try_parse(initial_value: &[u8]) -> Result<(Self, &[u8]), ParseError> {
838        let remaining = initial_value;
839        let (response_type, remaining) = u8::try_parse(remaining)?;
840        let (depth, remaining) = u8::try_parse(remaining)?;
841        let (sequence, remaining) = u16::try_parse(remaining)?;
842        let (length, remaining) = u32::try_parse(remaining)?;
843        let (visual, remaining) = xproto::Visualid::try_parse(remaining)?;
844        let (size, remaining) = u32::try_parse(remaining)?;
845        if response_type != 1 {
846            return Err(ParseError::InvalidValue);
847        }
848        let result = GetImageReply { depth, sequence, length, visual, size };
849        let _ = remaining;
850        let remaining = initial_value.get(32 + length as usize * 4..)
851            .ok_or(ParseError::InsufficientData)?;
852        Ok((result, remaining))
853    }
854}
855impl Serialize for GetImageReply {
856    type Bytes = [u8; 16];
857    fn serialize(&self) -> [u8; 16] {
858        let response_type_bytes = &[1];
859        let depth_bytes = self.depth.serialize();
860        let sequence_bytes = self.sequence.serialize();
861        let length_bytes = self.length.serialize();
862        let visual_bytes = self.visual.serialize();
863        let size_bytes = self.size.serialize();
864        [
865            response_type_bytes[0],
866            depth_bytes[0],
867            sequence_bytes[0],
868            sequence_bytes[1],
869            length_bytes[0],
870            length_bytes[1],
871            length_bytes[2],
872            length_bytes[3],
873            visual_bytes[0],
874            visual_bytes[1],
875            visual_bytes[2],
876            visual_bytes[3],
877            size_bytes[0],
878            size_bytes[1],
879            size_bytes[2],
880            size_bytes[3],
881        ]
882    }
883    fn serialize_into(&self, bytes: &mut Vec<u8>) {
884        bytes.reserve(16);
885        let response_type_bytes = &[1];
886        bytes.push(response_type_bytes[0]);
887        self.depth.serialize_into(bytes);
888        self.sequence.serialize_into(bytes);
889        self.length.serialize_into(bytes);
890        self.visual.serialize_into(bytes);
891        self.size.serialize_into(bytes);
892    }
893}
894
895/// Opcode for the CreatePixmap request
896pub const CREATE_PIXMAP_REQUEST: u8 = 5;
897/// Create a pixmap backed by shared memory..
898///
899/// Create a pixmap backed by shared memory.  Writes to the shared memory will be
900/// reflected in the contents of the pixmap, and writes to the pixmap will be
901/// reflected in the contents of the shared memory.
902///
903/// # Fields
904///
905/// * `pid` - A pixmap ID created with xcb_generate_id().
906/// * `drawable` - The drawable to create the pixmap in.
907/// * `width` - The width of the pixmap to create.  Must be nonzero, or a Value error results.
908/// * `height` - The height of the pixmap to create.  Must be nonzero, or a Value error results.
909/// * `depth` - The depth of the pixmap to create.  Must be nonzero, or a Value error results.
910/// * `shmseg` - The shared memory segment to use to create the pixmap.
911/// * `offset` - The offset in the segment to create the pixmap at.
912#[derive(Clone, Copy, Default)]
913#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
914#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
915pub struct CreatePixmapRequest {
916    pub pid: xproto::Pixmap,
917    pub drawable: xproto::Drawable,
918    pub width: u16,
919    pub height: u16,
920    pub depth: u8,
921    pub shmseg: Seg,
922    pub offset: u32,
923}
924impl_debug_if_no_extra_traits!(CreatePixmapRequest, "CreatePixmapRequest");
925impl CreatePixmapRequest {
926    /// Serialize this request into bytes for the provided connection
927    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
928        let length_so_far = 0;
929        let pid_bytes = self.pid.serialize();
930        let drawable_bytes = self.drawable.serialize();
931        let width_bytes = self.width.serialize();
932        let height_bytes = self.height.serialize();
933        let depth_bytes = self.depth.serialize();
934        let shmseg_bytes = self.shmseg.serialize();
935        let offset_bytes = self.offset.serialize();
936        let mut request0 = vec![
937            major_opcode,
938            CREATE_PIXMAP_REQUEST,
939            0,
940            0,
941            pid_bytes[0],
942            pid_bytes[1],
943            pid_bytes[2],
944            pid_bytes[3],
945            drawable_bytes[0],
946            drawable_bytes[1],
947            drawable_bytes[2],
948            drawable_bytes[3],
949            width_bytes[0],
950            width_bytes[1],
951            height_bytes[0],
952            height_bytes[1],
953            depth_bytes[0],
954            0,
955            0,
956            0,
957            shmseg_bytes[0],
958            shmseg_bytes[1],
959            shmseg_bytes[2],
960            shmseg_bytes[3],
961            offset_bytes[0],
962            offset_bytes[1],
963            offset_bytes[2],
964            offset_bytes[3],
965        ];
966        let length_so_far = length_so_far + request0.len();
967        assert_eq!(length_so_far % 4, 0);
968        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
969        request0[2..4].copy_from_slice(&length.to_ne_bytes());
970        ([request0.into()], vec![])
971    }
972    /// Parse this request given its header, its body, and any fds that go along with it
973    #[cfg(feature = "request-parsing")]
974    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
975        if header.minor_opcode != CREATE_PIXMAP_REQUEST {
976            return Err(ParseError::InvalidValue);
977        }
978        let (pid, remaining) = xproto::Pixmap::try_parse(value)?;
979        let (drawable, remaining) = xproto::Drawable::try_parse(remaining)?;
980        let (width, remaining) = u16::try_parse(remaining)?;
981        let (height, remaining) = u16::try_parse(remaining)?;
982        let (depth, remaining) = u8::try_parse(remaining)?;
983        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
984        let (shmseg, remaining) = Seg::try_parse(remaining)?;
985        let (offset, remaining) = u32::try_parse(remaining)?;
986        let _ = remaining;
987        Ok(CreatePixmapRequest {
988            pid,
989            drawable,
990            width,
991            height,
992            depth,
993            shmseg,
994            offset,
995        })
996    }
997}
998impl Request for CreatePixmapRequest {
999    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1000
1001    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1002        let (bufs, fds) = self.serialize(major_opcode);
1003        // Flatten the buffers into a single vector
1004        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1005        (buf, fds)
1006    }
1007}
1008impl crate::x11_utils::VoidRequest for CreatePixmapRequest {
1009}
1010
1011/// Opcode for the AttachFd request
1012pub const ATTACH_FD_REQUEST: u8 = 6;
1013/// Create a shared memory segment.
1014///
1015/// Create a shared memory segment.  The file descriptor will be mapped at offset
1016/// zero, and the size will be obtained using fstat().  A zero size will result in a
1017/// Value error.
1018///
1019/// # Fields
1020///
1021/// * `shmseg` - A shared memory segment ID created with xcb_generate_id().
1022/// * `shm_fd` - The file descriptor the server should mmap().
1023/// * `read_only` - True if the segment shall be mapped read only by the X11 server, otherwise false.
1024#[cfg_attr(feature = "extra-traits", derive(Debug))]
1025pub struct AttachFdRequest {
1026    pub shmseg: Seg,
1027    pub shm_fd: RawFdContainer,
1028    pub read_only: bool,
1029}
1030impl_debug_if_no_extra_traits!(AttachFdRequest, "AttachFdRequest");
1031impl AttachFdRequest {
1032    /// Serialize this request into bytes for the provided connection
1033    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1034        let length_so_far = 0;
1035        let shmseg_bytes = self.shmseg.serialize();
1036        let read_only_bytes = self.read_only.serialize();
1037        let mut request0 = vec![
1038            major_opcode,
1039            ATTACH_FD_REQUEST,
1040            0,
1041            0,
1042            shmseg_bytes[0],
1043            shmseg_bytes[1],
1044            shmseg_bytes[2],
1045            shmseg_bytes[3],
1046            read_only_bytes[0],
1047            0,
1048            0,
1049            0,
1050        ];
1051        let length_so_far = length_so_far + request0.len();
1052        assert_eq!(length_so_far % 4, 0);
1053        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1054        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1055        ([request0.into()], vec![self.shm_fd])
1056    }
1057    /// Parse this request given its header, its body, and any fds that go along with it
1058    #[cfg(feature = "request-parsing")]
1059    pub fn try_parse_request_fd(header: RequestHeader, value: &[u8], fds: &mut Vec<RawFdContainer>) -> Result<Self, ParseError> {
1060        if header.minor_opcode != ATTACH_FD_REQUEST {
1061            return Err(ParseError::InvalidValue);
1062        }
1063        let (shmseg, remaining) = Seg::try_parse(value)?;
1064        if fds.is_empty() { return Err(ParseError::MissingFileDescriptors) }
1065        let shm_fd = fds.remove(0);
1066        let (read_only, remaining) = bool::try_parse(remaining)?;
1067        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
1068        let _ = remaining;
1069        Ok(AttachFdRequest {
1070            shmseg,
1071            shm_fd,
1072            read_only,
1073        })
1074    }
1075}
1076impl Request for AttachFdRequest {
1077    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1078
1079    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1080        let (bufs, fds) = self.serialize(major_opcode);
1081        // Flatten the buffers into a single vector
1082        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1083        (buf, fds)
1084    }
1085}
1086impl crate::x11_utils::VoidRequest for AttachFdRequest {
1087}
1088
1089/// Opcode for the CreateSegment request
1090pub const CREATE_SEGMENT_REQUEST: u8 = 7;
1091/// Asks the server to allocate a shared memory segment..
1092///
1093/// Asks the server to allocate a shared memory segment.  The server’s reply will
1094/// include a file descriptor for the client to pass to mmap().
1095///
1096/// # Fields
1097///
1098/// * `shmseg` - A shared memory segment ID created with xcb_generate_id().
1099/// * `size` - The size of the segment to create.
1100/// * `read_only` - True if the server should map the segment read-only; otherwise false.
1101#[derive(Clone, Copy, Default)]
1102#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash))]
1103#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1104pub struct CreateSegmentRequest {
1105    pub shmseg: Seg,
1106    pub size: u32,
1107    pub read_only: bool,
1108}
1109impl_debug_if_no_extra_traits!(CreateSegmentRequest, "CreateSegmentRequest");
1110impl CreateSegmentRequest {
1111    /// Serialize this request into bytes for the provided connection
1112    pub fn serialize(self, major_opcode: u8) -> BufWithFds<[Cow<'static, [u8]>; 1]> {
1113        let length_so_far = 0;
1114        let shmseg_bytes = self.shmseg.serialize();
1115        let size_bytes = self.size.serialize();
1116        let read_only_bytes = self.read_only.serialize();
1117        let mut request0 = vec![
1118            major_opcode,
1119            CREATE_SEGMENT_REQUEST,
1120            0,
1121            0,
1122            shmseg_bytes[0],
1123            shmseg_bytes[1],
1124            shmseg_bytes[2],
1125            shmseg_bytes[3],
1126            size_bytes[0],
1127            size_bytes[1],
1128            size_bytes[2],
1129            size_bytes[3],
1130            read_only_bytes[0],
1131            0,
1132            0,
1133            0,
1134        ];
1135        let length_so_far = length_so_far + request0.len();
1136        assert_eq!(length_so_far % 4, 0);
1137        let length = u16::try_from(length_so_far / 4).unwrap_or(0);
1138        request0[2..4].copy_from_slice(&length.to_ne_bytes());
1139        ([request0.into()], vec![])
1140    }
1141    /// Parse this request given its header, its body, and any fds that go along with it
1142    #[cfg(feature = "request-parsing")]
1143    pub fn try_parse_request(header: RequestHeader, value: &[u8]) -> Result<Self, ParseError> {
1144        if header.minor_opcode != CREATE_SEGMENT_REQUEST {
1145            return Err(ParseError::InvalidValue);
1146        }
1147        let (shmseg, remaining) = Seg::try_parse(value)?;
1148        let (size, remaining) = u32::try_parse(remaining)?;
1149        let (read_only, remaining) = bool::try_parse(remaining)?;
1150        let remaining = remaining.get(3..).ok_or(ParseError::InsufficientData)?;
1151        let _ = remaining;
1152        Ok(CreateSegmentRequest {
1153            shmseg,
1154            size,
1155            read_only,
1156        })
1157    }
1158}
1159impl Request for CreateSegmentRequest {
1160    const EXTENSION_NAME: Option<&'static str> = Some(X11_EXTENSION_NAME);
1161
1162    fn serialize(self, major_opcode: u8) -> BufWithFds<Vec<u8>> {
1163        let (bufs, fds) = self.serialize(major_opcode);
1164        // Flatten the buffers into a single vector
1165        let buf = bufs.iter().flat_map(|buf| buf.iter().copied()).collect();
1166        (buf, fds)
1167    }
1168}
1169impl crate::x11_utils::ReplyFDsRequest for CreateSegmentRequest {
1170    type Reply = CreateSegmentReply;
1171}
1172
1173/// The returned file descriptor..
1174///
1175/// The file descriptor returned by the server.  The client may call mmap() on it to
1176/// map the memory allocated by the server.
1177///
1178/// # Fields
1179///
1180/// * `nfd` - The number of file descriptors sent by the server.  Will always be 1.
1181#[cfg_attr(feature = "extra-traits", derive(Debug))]
1182pub struct CreateSegmentReply {
1183    pub nfd: u8,
1184    pub sequence: u16,
1185    pub length: u32,
1186    pub shm_fd: RawFdContainer,
1187}
1188impl_debug_if_no_extra_traits!(CreateSegmentReply, "CreateSegmentReply");
1189impl TryParseFd for CreateSegmentReply {
1190    fn try_parse_fd<'a>(initial_value: &'a [u8], fds: &mut Vec<RawFdContainer>) -> Result<(Self, &'a [u8]), ParseError> {
1191        let remaining = initial_value;
1192        let (response_type, remaining) = u8::try_parse(remaining)?;
1193        let (nfd, remaining) = u8::try_parse(remaining)?;
1194        let (sequence, remaining) = u16::try_parse(remaining)?;
1195        let (length, remaining) = u32::try_parse(remaining)?;
1196        if fds.is_empty() { return Err(ParseError::MissingFileDescriptors) }
1197        let shm_fd = fds.remove(0);
1198        let remaining = remaining.get(24..).ok_or(ParseError::InsufficientData)?;
1199        if response_type != 1 {
1200            return Err(ParseError::InvalidValue);
1201        }
1202        let result = CreateSegmentReply { nfd, sequence, length, shm_fd };
1203        let _ = remaining;
1204        let remaining = initial_value.get(32 + length as usize * 4..)
1205            .ok_or(ParseError::InsufficientData)?;
1206        Ok((result, remaining))
1207    }
1208}
1209impl Serialize for CreateSegmentReply {
1210    type Bytes = [u8; 32];
1211    fn serialize(&self) -> [u8; 32] {
1212        let response_type_bytes = &[1];
1213        let nfd_bytes = self.nfd.serialize();
1214        let sequence_bytes = self.sequence.serialize();
1215        let length_bytes = self.length.serialize();
1216        [
1217            response_type_bytes[0],
1218            nfd_bytes[0],
1219            sequence_bytes[0],
1220            sequence_bytes[1],
1221            length_bytes[0],
1222            length_bytes[1],
1223            length_bytes[2],
1224            length_bytes[3],
1225            0,
1226            0,
1227            0,
1228            0,
1229            0,
1230            0,
1231            0,
1232            0,
1233            0,
1234            0,
1235            0,
1236            0,
1237            0,
1238            0,
1239            0,
1240            0,
1241            0,
1242            0,
1243            0,
1244            0,
1245            0,
1246            0,
1247            0,
1248            0,
1249        ]
1250    }
1251    fn serialize_into(&self, bytes: &mut Vec<u8>) {
1252        bytes.reserve(32);
1253        let response_type_bytes = &[1];
1254        bytes.push(response_type_bytes[0]);
1255        self.nfd.serialize_into(bytes);
1256        self.sequence.serialize_into(bytes);
1257        self.length.serialize_into(bytes);
1258        bytes.extend_from_slice(&[0; 24]);
1259    }
1260}
1261
x11rb_protocol/protocol/shm.rs

x11rb_protocol/protocol/
shm.rs
