fidl_fuchsia_net_http__common/
fidl_fuchsia_net_http__common.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::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// Friendly alias for a vector of bytes containing a header name.
12pub type HeaderName = Vec<u8>;
13
14/// Friendly alias for a vector of bytes containing a header value.
15pub type HeaderValue = Vec<u8>;
16
17pub type Method = String;
18
19/// An error occurred during the HTTP transaction.
20#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21#[repr(u32)]
22pub enum Error {
23    /// Some other problem occurred that cannot be classified using one of the
24    /// more specific statuses. Retry is optional.
25    Internal = 1,
26    /// An HTTP parse error.
27    UnableToParse = 2,
28    /// Indicates a channel (client or body sender) is closed.
29    ChannelClosed = 3,
30    /// Error occurred while connecting.
31    Connect = 4,
32    /// The deadline specified in Request has passed
33    DeadlineExceeded = 5,
34}
35
36impl Error {
37    #[inline]
38    pub fn from_primitive(prim: u32) -> Option<Self> {
39        match prim {
40            1 => Some(Self::Internal),
41            2 => Some(Self::UnableToParse),
42            3 => Some(Self::ChannelClosed),
43            4 => Some(Self::Connect),
44            5 => Some(Self::DeadlineExceeded),
45            _ => None,
46        }
47    }
48
49    #[inline]
50    pub const fn into_primitive(self) -> u32 {
51        self as u32
52    }
53}
54
55/// An HTTP header field.
56#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
57pub struct Header {
58    /// The name of the header field.
59    pub name: Vec<u8>,
60    /// The value of the header field.
61    pub value: Vec<u8>,
62}
63
64impl fidl::Persistable for Header {}
65
66/// A description of the redirect the server requested.
67///
68/// The semantics of an HTTP redirect vary according to the status code use to
69/// generate the redirect. This structure ensures that the loader and its client
70/// agree on the interpretation of the redirect response from the server.
71#[derive(Clone, Debug, Default, PartialEq)]
72pub struct RedirectTarget {
73    /// The HTTP method the server suggested for the redirect.
74    pub method: Option<String>,
75    /// The URL the server suggested for the redirect.
76    pub url: Option<String>,
77    /// The referrer the server suggested for the redirect.
78    pub referrer: Option<String>,
79    #[doc(hidden)]
80    pub __source_breaking: fidl::marker::SourceBreaking,
81}
82
83impl fidl::Persistable for RedirectTarget {}
84
85mod internal {
86    use super::*;
87    unsafe impl fidl::encoding::TypeMarker for Error {
88        type Owned = Self;
89
90        #[inline(always)]
91        fn inline_align(_context: fidl::encoding::Context) -> usize {
92            std::mem::align_of::<u32>()
93        }
94
95        #[inline(always)]
96        fn inline_size(_context: fidl::encoding::Context) -> usize {
97            std::mem::size_of::<u32>()
98        }
99
100        #[inline(always)]
101        fn encode_is_copy() -> bool {
102            true
103        }
104
105        #[inline(always)]
106        fn decode_is_copy() -> bool {
107            false
108        }
109    }
110
111    impl fidl::encoding::ValueTypeMarker for Error {
112        type Borrowed<'a> = Self;
113        #[inline(always)]
114        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
115            *value
116        }
117    }
118
119    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
120        #[inline]
121        unsafe fn encode(
122            self,
123            encoder: &mut fidl::encoding::Encoder<'_, D>,
124            offset: usize,
125            _depth: fidl::encoding::Depth,
126        ) -> fidl::Result<()> {
127            encoder.debug_check_bounds::<Self>(offset);
128            encoder.write_num(self.into_primitive(), offset);
129            Ok(())
130        }
131    }
132
133    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
134        #[inline(always)]
135        fn new_empty() -> Self {
136            Self::Internal
137        }
138
139        #[inline]
140        unsafe fn decode(
141            &mut self,
142            decoder: &mut fidl::encoding::Decoder<'_, D>,
143            offset: usize,
144            _depth: fidl::encoding::Depth,
145        ) -> fidl::Result<()> {
146            decoder.debug_check_bounds::<Self>(offset);
147            let prim = decoder.read_num::<u32>(offset);
148
149            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
150            Ok(())
151        }
152    }
153
154    impl fidl::encoding::ValueTypeMarker for Header {
155        type Borrowed<'a> = &'a Self;
156        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
157            value
158        }
159    }
160
161    unsafe impl fidl::encoding::TypeMarker for Header {
162        type Owned = Self;
163
164        #[inline(always)]
165        fn inline_align(_context: fidl::encoding::Context) -> usize {
166            8
167        }
168
169        #[inline(always)]
170        fn inline_size(_context: fidl::encoding::Context) -> usize {
171            32
172        }
173    }
174
175    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Header, D> for &Header {
176        #[inline]
177        unsafe fn encode(
178            self,
179            encoder: &mut fidl::encoding::Encoder<'_, D>,
180            offset: usize,
181            _depth: fidl::encoding::Depth,
182        ) -> fidl::Result<()> {
183            encoder.debug_check_bounds::<Header>(offset);
184            // Delegate to tuple encoding.
185            fidl::encoding::Encode::<Header, D>::encode(
186                (
187                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
188                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
189                ),
190                encoder, offset, _depth
191            )
192        }
193    }
194    unsafe impl<
195            D: fidl::encoding::ResourceDialect,
196            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
197            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
198        > fidl::encoding::Encode<Header, D> for (T0, T1)
199    {
200        #[inline]
201        unsafe fn encode(
202            self,
203            encoder: &mut fidl::encoding::Encoder<'_, D>,
204            offset: usize,
205            depth: fidl::encoding::Depth,
206        ) -> fidl::Result<()> {
207            encoder.debug_check_bounds::<Header>(offset);
208            // Zero out padding regions. There's no need to apply masks
209            // because the unmasked parts will be overwritten by fields.
210            // Write the fields.
211            self.0.encode(encoder, offset + 0, depth)?;
212            self.1.encode(encoder, offset + 16, depth)?;
213            Ok(())
214        }
215    }
216
217    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Header {
218        #[inline(always)]
219        fn new_empty() -> Self {
220            Self {
221                name: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
222                value: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
223            }
224        }
225
226        #[inline]
227        unsafe fn decode(
228            &mut self,
229            decoder: &mut fidl::encoding::Decoder<'_, D>,
230            offset: usize,
231            _depth: fidl::encoding::Depth,
232        ) -> fidl::Result<()> {
233            decoder.debug_check_bounds::<Self>(offset);
234            // Verify that padding bytes are zero.
235            fidl::decode!(
236                fidl::encoding::UnboundedVector<u8>,
237                D,
238                &mut self.name,
239                decoder,
240                offset + 0,
241                _depth
242            )?;
243            fidl::decode!(
244                fidl::encoding::UnboundedVector<u8>,
245                D,
246                &mut self.value,
247                decoder,
248                offset + 16,
249                _depth
250            )?;
251            Ok(())
252        }
253    }
254
255    impl RedirectTarget {
256        #[inline(always)]
257        fn max_ordinal_present(&self) -> u64 {
258            if let Some(_) = self.referrer {
259                return 3;
260            }
261            if let Some(_) = self.url {
262                return 2;
263            }
264            if let Some(_) = self.method {
265                return 1;
266            }
267            0
268        }
269    }
270
271    impl fidl::encoding::ValueTypeMarker for RedirectTarget {
272        type Borrowed<'a> = &'a Self;
273        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
274            value
275        }
276    }
277
278    unsafe impl fidl::encoding::TypeMarker for RedirectTarget {
279        type Owned = Self;
280
281        #[inline(always)]
282        fn inline_align(_context: fidl::encoding::Context) -> usize {
283            8
284        }
285
286        #[inline(always)]
287        fn inline_size(_context: fidl::encoding::Context) -> usize {
288            16
289        }
290    }
291
292    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RedirectTarget, D>
293        for &RedirectTarget
294    {
295        unsafe fn encode(
296            self,
297            encoder: &mut fidl::encoding::Encoder<'_, D>,
298            offset: usize,
299            mut depth: fidl::encoding::Depth,
300        ) -> fidl::Result<()> {
301            encoder.debug_check_bounds::<RedirectTarget>(offset);
302            // Vector header
303            let max_ordinal: u64 = self.max_ordinal_present();
304            encoder.write_num(max_ordinal, offset);
305            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
306            // Calling encoder.out_of_line_offset(0) is not allowed.
307            if max_ordinal == 0 {
308                return Ok(());
309            }
310            depth.increment()?;
311            let envelope_size = 8;
312            let bytes_len = max_ordinal as usize * envelope_size;
313            #[allow(unused_variables)]
314            let offset = encoder.out_of_line_offset(bytes_len);
315            let mut _prev_end_offset: usize = 0;
316            if 1 > max_ordinal {
317                return Ok(());
318            }
319
320            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
321            // are envelope_size bytes.
322            let cur_offset: usize = (1 - 1) * envelope_size;
323
324            // Zero reserved fields.
325            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
326
327            // Safety:
328            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
329            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
330            //   envelope_size bytes, there is always sufficient room.
331            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
332            self.method.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
333            encoder, offset + cur_offset, depth
334        )?;
335
336            _prev_end_offset = cur_offset + envelope_size;
337            if 2 > max_ordinal {
338                return Ok(());
339            }
340
341            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
342            // are envelope_size bytes.
343            let cur_offset: usize = (2 - 1) * envelope_size;
344
345            // Zero reserved fields.
346            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
347
348            // Safety:
349            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
350            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
351            //   envelope_size bytes, there is always sufficient room.
352            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
353            self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
354            encoder, offset + cur_offset, depth
355        )?;
356
357            _prev_end_offset = cur_offset + envelope_size;
358            if 3 > max_ordinal {
359                return Ok(());
360            }
361
362            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
363            // are envelope_size bytes.
364            let cur_offset: usize = (3 - 1) * envelope_size;
365
366            // Zero reserved fields.
367            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
368
369            // Safety:
370            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
371            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
372            //   envelope_size bytes, there is always sufficient room.
373            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
374            self.referrer.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
375            encoder, offset + cur_offset, depth
376        )?;
377
378            _prev_end_offset = cur_offset + envelope_size;
379
380            Ok(())
381        }
382    }
383
384    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RedirectTarget {
385        #[inline(always)]
386        fn new_empty() -> Self {
387            Self::default()
388        }
389
390        unsafe fn decode(
391            &mut self,
392            decoder: &mut fidl::encoding::Decoder<'_, D>,
393            offset: usize,
394            mut depth: fidl::encoding::Depth,
395        ) -> fidl::Result<()> {
396            decoder.debug_check_bounds::<Self>(offset);
397            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
398                None => return Err(fidl::Error::NotNullable),
399                Some(len) => len,
400            };
401            // Calling decoder.out_of_line_offset(0) is not allowed.
402            if len == 0 {
403                return Ok(());
404            };
405            depth.increment()?;
406            let envelope_size = 8;
407            let bytes_len = len * envelope_size;
408            let offset = decoder.out_of_line_offset(bytes_len)?;
409            // Decode the envelope for each type.
410            let mut _next_ordinal_to_read = 0;
411            let mut next_offset = offset;
412            let end_offset = offset + bytes_len;
413            _next_ordinal_to_read += 1;
414            if next_offset >= end_offset {
415                return Ok(());
416            }
417
418            // Decode unknown envelopes for gaps in ordinals.
419            while _next_ordinal_to_read < 1 {
420                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
421                _next_ordinal_to_read += 1;
422                next_offset += envelope_size;
423            }
424
425            let next_out_of_line = decoder.next_out_of_line();
426            let handles_before = decoder.remaining_handles();
427            if let Some((inlined, num_bytes, num_handles)) =
428                fidl::encoding::decode_envelope_header(decoder, next_offset)?
429            {
430                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
431                if inlined != (member_inline_size <= 4) {
432                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
433                }
434                let inner_offset;
435                let mut inner_depth = depth.clone();
436                if inlined {
437                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
438                    inner_offset = next_offset;
439                } else {
440                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
441                    inner_depth.increment()?;
442                }
443                let val_ref = self.method.get_or_insert_with(|| {
444                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
445                });
446                fidl::decode!(
447                    fidl::encoding::BoundedString<1024>,
448                    D,
449                    val_ref,
450                    decoder,
451                    inner_offset,
452                    inner_depth
453                )?;
454                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
455                {
456                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
457                }
458                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
459                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
460                }
461            }
462
463            next_offset += envelope_size;
464            _next_ordinal_to_read += 1;
465            if next_offset >= end_offset {
466                return Ok(());
467            }
468
469            // Decode unknown envelopes for gaps in ordinals.
470            while _next_ordinal_to_read < 2 {
471                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
472                _next_ordinal_to_read += 1;
473                next_offset += envelope_size;
474            }
475
476            let next_out_of_line = decoder.next_out_of_line();
477            let handles_before = decoder.remaining_handles();
478            if let Some((inlined, num_bytes, num_handles)) =
479                fidl::encoding::decode_envelope_header(decoder, next_offset)?
480            {
481                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
482                if inlined != (member_inline_size <= 4) {
483                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
484                }
485                let inner_offset;
486                let mut inner_depth = depth.clone();
487                if inlined {
488                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
489                    inner_offset = next_offset;
490                } else {
491                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
492                    inner_depth.increment()?;
493                }
494                let val_ref = self.url.get_or_insert_with(|| {
495                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
496                });
497                fidl::decode!(
498                    fidl::encoding::BoundedString<4096>,
499                    D,
500                    val_ref,
501                    decoder,
502                    inner_offset,
503                    inner_depth
504                )?;
505                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
506                {
507                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
508                }
509                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
510                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
511                }
512            }
513
514            next_offset += envelope_size;
515            _next_ordinal_to_read += 1;
516            if next_offset >= end_offset {
517                return Ok(());
518            }
519
520            // Decode unknown envelopes for gaps in ordinals.
521            while _next_ordinal_to_read < 3 {
522                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
523                _next_ordinal_to_read += 1;
524                next_offset += envelope_size;
525            }
526
527            let next_out_of_line = decoder.next_out_of_line();
528            let handles_before = decoder.remaining_handles();
529            if let Some((inlined, num_bytes, num_handles)) =
530                fidl::encoding::decode_envelope_header(decoder, next_offset)?
531            {
532                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
533                if inlined != (member_inline_size <= 4) {
534                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
535                }
536                let inner_offset;
537                let mut inner_depth = depth.clone();
538                if inlined {
539                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
540                    inner_offset = next_offset;
541                } else {
542                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
543                    inner_depth.increment()?;
544                }
545                let val_ref = self.referrer.get_or_insert_with(|| {
546                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
547                });
548                fidl::decode!(
549                    fidl::encoding::BoundedString<4096>,
550                    D,
551                    val_ref,
552                    decoder,
553                    inner_offset,
554                    inner_depth
555                )?;
556                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
557                {
558                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
559                }
560                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
561                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
562                }
563            }
564
565            next_offset += envelope_size;
566
567            // Decode the remaining unknown envelopes.
568            while next_offset < end_offset {
569                _next_ordinal_to_read += 1;
570                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
571                next_offset += envelope_size;
572            }
573
574            Ok(())
575        }
576    }
577}
fidl_fuchsia_net_http__common/fidl_fuchsia_net_http__common.rs

fidl_fuchsia_net_http__common/
fidl_fuchsia_net_http__common.rs
