fidl_fuchsia_tee_manager/
fidl_fuchsia_tee_manager.rs1#![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 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 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 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 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
228pub 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 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#[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 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 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 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 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}