fidl_fuchsia_tee_manager/
fidl_fuchsia_tee_manager.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_tee_manager__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct ProviderRequestPersistentStorageRequest {
16    pub dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20    for ProviderRequestPersistentStorageRequest
21{
22}
23
24#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
25pub struct ProviderMarker;
26
27impl fidl::endpoints::ProtocolMarker for ProviderMarker {
28    type Proxy = ProviderProxy;
29    type RequestStream = ProviderRequestStream;
30    #[cfg(target_os = "fuchsia")]
31    type SynchronousProxy = ProviderSynchronousProxy;
32
33    const DEBUG_NAME: &'static str = "(anonymous) Provider";
34}
35
36pub trait ProviderProxyInterface: Send + Sync {
37    fn r#request_persistent_storage(
38        &self,
39        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
40    ) -> Result<(), fidl::Error>;
41}
42#[derive(Debug)]
43#[cfg(target_os = "fuchsia")]
44pub struct ProviderSynchronousProxy {
45    client: fidl::client::sync::Client,
46}
47
48#[cfg(target_os = "fuchsia")]
49impl fidl::endpoints::SynchronousProxy for ProviderSynchronousProxy {
50    type Proxy = ProviderProxy;
51    type Protocol = ProviderMarker;
52
53    fn from_channel(inner: fidl::Channel) -> Self {
54        Self::new(inner)
55    }
56
57    fn into_channel(self) -> fidl::Channel {
58        self.client.into_channel()
59    }
60
61    fn as_channel(&self) -> &fidl::Channel {
62        self.client.as_channel()
63    }
64}
65
66#[cfg(target_os = "fuchsia")]
67impl ProviderSynchronousProxy {
68    pub fn new(channel: fidl::Channel) -> Self {
69        let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
70        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
71    }
72
73    pub fn into_channel(self) -> fidl::Channel {
74        self.client.into_channel()
75    }
76
77    /// Waits until an event arrives and returns it. It is safe for other
78    /// threads to make concurrent requests while waiting for an event.
79    pub fn wait_for_event(
80        &self,
81        deadline: zx::MonotonicInstant,
82    ) -> Result<ProviderEvent, fidl::Error> {
83        ProviderEvent::decode(self.client.wait_for_event(deadline)?)
84    }
85
86    pub fn r#request_persistent_storage(
87        &self,
88        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
89    ) -> Result<(), fidl::Error> {
90        self.client.send::<ProviderRequestPersistentStorageRequest>(
91            (dir,),
92            0x3ef6bac9b6490a0d,
93            fidl::encoding::DynamicFlags::empty(),
94        )
95    }
96}
97
98#[cfg(target_os = "fuchsia")]
99impl From<ProviderSynchronousProxy> for zx::Handle {
100    fn from(value: ProviderSynchronousProxy) -> Self {
101        value.into_channel().into()
102    }
103}
104
105#[cfg(target_os = "fuchsia")]
106impl From<fidl::Channel> for ProviderSynchronousProxy {
107    fn from(value: fidl::Channel) -> Self {
108        Self::new(value)
109    }
110}
111
112#[cfg(target_os = "fuchsia")]
113impl fidl::endpoints::FromClient for ProviderSynchronousProxy {
114    type Protocol = ProviderMarker;
115
116    fn from_client(value: fidl::endpoints::ClientEnd<ProviderMarker>) -> Self {
117        Self::new(value.into_channel())
118    }
119}
120
121#[derive(Debug, Clone)]
122pub struct ProviderProxy {
123    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
124}
125
126impl fidl::endpoints::Proxy for ProviderProxy {
127    type Protocol = ProviderMarker;
128
129    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
130        Self::new(inner)
131    }
132
133    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
134        self.client.into_channel().map_err(|client| Self { client })
135    }
136
137    fn as_channel(&self) -> &::fidl::AsyncChannel {
138        self.client.as_channel()
139    }
140}
141
142impl ProviderProxy {
143    /// Create a new Proxy for fuchsia.tee.manager/Provider.
144    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
145        let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
146        Self { client: fidl::client::Client::new(channel, protocol_name) }
147    }
148
149    /// Get a Stream of events from the remote end of the protocol.
150    ///
151    /// # Panics
152    ///
153    /// Panics if the event stream was already taken.
154    pub fn take_event_stream(&self) -> ProviderEventStream {
155        ProviderEventStream { event_receiver: self.client.take_event_receiver() }
156    }
157
158    pub fn r#request_persistent_storage(
159        &self,
160        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
161    ) -> Result<(), fidl::Error> {
162        ProviderProxyInterface::r#request_persistent_storage(self, dir)
163    }
164}
165
166impl ProviderProxyInterface for ProviderProxy {
167    fn r#request_persistent_storage(
168        &self,
169        mut dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
170    ) -> Result<(), fidl::Error> {
171        self.client.send::<ProviderRequestPersistentStorageRequest>(
172            (dir,),
173            0x3ef6bac9b6490a0d,
174            fidl::encoding::DynamicFlags::empty(),
175        )
176    }
177}
178
179pub struct ProviderEventStream {
180    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
181}
182
183impl std::marker::Unpin for ProviderEventStream {}
184
185impl futures::stream::FusedStream for ProviderEventStream {
186    fn is_terminated(&self) -> bool {
187        self.event_receiver.is_terminated()
188    }
189}
190
191impl futures::Stream for ProviderEventStream {
192    type Item = Result<ProviderEvent, fidl::Error>;
193
194    fn poll_next(
195        mut self: std::pin::Pin<&mut Self>,
196        cx: &mut std::task::Context<'_>,
197    ) -> std::task::Poll<Option<Self::Item>> {
198        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
199            &mut self.event_receiver,
200            cx
201        )?) {
202            Some(buf) => std::task::Poll::Ready(Some(ProviderEvent::decode(buf))),
203            None => std::task::Poll::Ready(None),
204        }
205    }
206}
207
208#[derive(Debug)]
209pub enum ProviderEvent {}
210
211impl ProviderEvent {
212    /// Decodes a message buffer as a [`ProviderEvent`].
213    fn decode(
214        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
215    ) -> Result<ProviderEvent, fidl::Error> {
216        let (bytes, _handles) = buf.split_mut();
217        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
218        debug_assert_eq!(tx_header.tx_id, 0);
219        match tx_header.ordinal {
220            _ => Err(fidl::Error::UnknownOrdinal {
221                ordinal: tx_header.ordinal,
222                protocol_name: <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
223            }),
224        }
225    }
226}
227
228/// A Stream of incoming requests for fuchsia.tee.manager/Provider.
229pub struct ProviderRequestStream {
230    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
231    is_terminated: bool,
232}
233
234impl std::marker::Unpin for ProviderRequestStream {}
235
236impl futures::stream::FusedStream for ProviderRequestStream {
237    fn is_terminated(&self) -> bool {
238        self.is_terminated
239    }
240}
241
242impl fidl::endpoints::RequestStream for ProviderRequestStream {
243    type Protocol = ProviderMarker;
244    type ControlHandle = ProviderControlHandle;
245
246    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
247        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
248    }
249
250    fn control_handle(&self) -> Self::ControlHandle {
251        ProviderControlHandle { inner: self.inner.clone() }
252    }
253
254    fn into_inner(
255        self,
256    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
257    {
258        (self.inner, self.is_terminated)
259    }
260
261    fn from_inner(
262        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
263        is_terminated: bool,
264    ) -> Self {
265        Self { inner, is_terminated }
266    }
267}
268
269impl futures::Stream for ProviderRequestStream {
270    type Item = Result<ProviderRequest, fidl::Error>;
271
272    fn poll_next(
273        mut self: std::pin::Pin<&mut Self>,
274        cx: &mut std::task::Context<'_>,
275    ) -> std::task::Poll<Option<Self::Item>> {
276        let this = &mut *self;
277        if this.inner.check_shutdown(cx) {
278            this.is_terminated = true;
279            return std::task::Poll::Ready(None);
280        }
281        if this.is_terminated {
282            panic!("polled ProviderRequestStream after completion");
283        }
284        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
285            |bytes, handles| {
286                match this.inner.channel().read_etc(cx, bytes, handles) {
287                    std::task::Poll::Ready(Ok(())) => {}
288                    std::task::Poll::Pending => return std::task::Poll::Pending,
289                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
290                        this.is_terminated = true;
291                        return std::task::Poll::Ready(None);
292                    }
293                    std::task::Poll::Ready(Err(e)) => {
294                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
295                            e.into(),
296                        ))))
297                    }
298                }
299
300                // A message has been received from the channel
301                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
302
303                std::task::Poll::Ready(Some(match header.ordinal {
304                    0x3ef6bac9b6490a0d => {
305                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
306                        let mut req = fidl::new_empty!(
307                            ProviderRequestPersistentStorageRequest,
308                            fidl::encoding::DefaultFuchsiaResourceDialect
309                        );
310                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderRequestPersistentStorageRequest>(&header, _body_bytes, handles, &mut req)?;
311                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
312                        Ok(ProviderRequest::RequestPersistentStorage {
313                            dir: req.dir,
314
315                            control_handle,
316                        })
317                    }
318                    _ => Err(fidl::Error::UnknownOrdinal {
319                        ordinal: header.ordinal,
320                        protocol_name:
321                            <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
322                    }),
323                }))
324            },
325        )
326    }
327}
328
329/// Provider provides service access and support to the TEE driver
330/// for things like persistent storage, since the TEE may make upward RPC-like
331/// requests to the REE.
332#[derive(Debug)]
333pub enum ProviderRequest {
334    RequestPersistentStorage {
335        dir: fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
336        control_handle: ProviderControlHandle,
337    },
338}
339
340impl ProviderRequest {
341    #[allow(irrefutable_let_patterns)]
342    pub fn into_request_persistent_storage(
343        self,
344    ) -> Option<(fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>, ProviderControlHandle)>
345    {
346        if let ProviderRequest::RequestPersistentStorage { dir, control_handle } = self {
347            Some((dir, control_handle))
348        } else {
349            None
350        }
351    }
352
353    /// Name of the method defined in FIDL
354    pub fn method_name(&self) -> &'static str {
355        match *self {
356            ProviderRequest::RequestPersistentStorage { .. } => "request_persistent_storage",
357        }
358    }
359}
360
361#[derive(Debug, Clone)]
362pub struct ProviderControlHandle {
363    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
364}
365
366impl fidl::endpoints::ControlHandle for ProviderControlHandle {
367    fn shutdown(&self) {
368        self.inner.shutdown()
369    }
370    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
371        self.inner.shutdown_with_epitaph(status)
372    }
373
374    fn is_closed(&self) -> bool {
375        self.inner.channel().is_closed()
376    }
377    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
378        self.inner.channel().on_closed()
379    }
380
381    #[cfg(target_os = "fuchsia")]
382    fn signal_peer(
383        &self,
384        clear_mask: zx::Signals,
385        set_mask: zx::Signals,
386    ) -> Result<(), zx_status::Status> {
387        use fidl::Peered;
388        self.inner.channel().signal_peer(clear_mask, set_mask)
389    }
390}
391
392impl ProviderControlHandle {}
393
394mod internal {
395    use super::*;
396
397    impl fidl::encoding::ResourceTypeMarker for ProviderRequestPersistentStorageRequest {
398        type Borrowed<'a> = &'a mut Self;
399        fn take_or_borrow<'a>(
400            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
401        ) -> Self::Borrowed<'a> {
402            value
403        }
404    }
405
406    unsafe impl fidl::encoding::TypeMarker for ProviderRequestPersistentStorageRequest {
407        type Owned = Self;
408
409        #[inline(always)]
410        fn inline_align(_context: fidl::encoding::Context) -> usize {
411            4
412        }
413
414        #[inline(always)]
415        fn inline_size(_context: fidl::encoding::Context) -> usize {
416            4
417        }
418    }
419
420    unsafe impl
421        fidl::encoding::Encode<
422            ProviderRequestPersistentStorageRequest,
423            fidl::encoding::DefaultFuchsiaResourceDialect,
424        > for &mut ProviderRequestPersistentStorageRequest
425    {
426        #[inline]
427        unsafe fn encode(
428            self,
429            encoder: &mut fidl::encoding::Encoder<
430                '_,
431                fidl::encoding::DefaultFuchsiaResourceDialect,
432            >,
433            offset: usize,
434            _depth: fidl::encoding::Depth,
435        ) -> fidl::Result<()> {
436            encoder.debug_check_bounds::<ProviderRequestPersistentStorageRequest>(offset);
437            // Delegate to tuple encoding.
438            fidl::encoding::Encode::<
439                ProviderRequestPersistentStorageRequest,
440                fidl::encoding::DefaultFuchsiaResourceDialect,
441            >::encode(
442                (<fidl::encoding::Endpoint<
443                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
444                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
445                    &mut self.dir
446                ),),
447                encoder,
448                offset,
449                _depth,
450            )
451        }
452    }
453    unsafe impl<
454            T0: fidl::encoding::Encode<
455                fidl::encoding::Endpoint<
456                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
457                >,
458                fidl::encoding::DefaultFuchsiaResourceDialect,
459            >,
460        >
461        fidl::encoding::Encode<
462            ProviderRequestPersistentStorageRequest,
463            fidl::encoding::DefaultFuchsiaResourceDialect,
464        > for (T0,)
465    {
466        #[inline]
467        unsafe fn encode(
468            self,
469            encoder: &mut fidl::encoding::Encoder<
470                '_,
471                fidl::encoding::DefaultFuchsiaResourceDialect,
472            >,
473            offset: usize,
474            depth: fidl::encoding::Depth,
475        ) -> fidl::Result<()> {
476            encoder.debug_check_bounds::<ProviderRequestPersistentStorageRequest>(offset);
477            // Zero out padding regions. There's no need to apply masks
478            // because the unmasked parts will be overwritten by fields.
479            // Write the fields.
480            self.0.encode(encoder, offset + 0, depth)?;
481            Ok(())
482        }
483    }
484
485    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
486        for ProviderRequestPersistentStorageRequest
487    {
488        #[inline(always)]
489        fn new_empty() -> Self {
490            Self {
491                dir: fidl::new_empty!(
492                    fidl::encoding::Endpoint<
493                        fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
494                    >,
495                    fidl::encoding::DefaultFuchsiaResourceDialect
496                ),
497            }
498        }
499
500        #[inline]
501        unsafe fn decode(
502            &mut self,
503            decoder: &mut fidl::encoding::Decoder<
504                '_,
505                fidl::encoding::DefaultFuchsiaResourceDialect,
506            >,
507            offset: usize,
508            _depth: fidl::encoding::Depth,
509        ) -> fidl::Result<()> {
510            decoder.debug_check_bounds::<Self>(offset);
511            // Verify that padding bytes are zero.
512            fidl::decode!(
513                fidl::encoding::Endpoint<
514                    fidl::endpoints::ServerEnd<fidl_fuchsia_io::DirectoryMarker>,
515                >,
516                fidl::encoding::DefaultFuchsiaResourceDialect,
517                &mut self.dir,
518                decoder,
519                offset + 0,
520                _depth
521            )?;
522            Ok(())
523        }
524    }
525}