fidl_fuchsia_driver_registrar/
fidl_fuchsia_driver_registrar.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_driver_registrar_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct DriverRegistrarMarker;
16
17impl fidl::endpoints::ProtocolMarker for DriverRegistrarMarker {
18    type Proxy = DriverRegistrarProxy;
19    type RequestStream = DriverRegistrarRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = DriverRegistrarSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.driver.registrar.DriverRegistrar";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for DriverRegistrarMarker {}
26pub type DriverRegistrarRegisterResult = Result<(), i32>;
27
28pub trait DriverRegistrarProxyInterface: Send + Sync {
29    type RegisterResponseFut: std::future::Future<Output = Result<DriverRegistrarRegisterResult, fidl::Error>>
30        + Send;
31    fn r#register(&self, driver_url: &str) -> Self::RegisterResponseFut;
32}
33#[derive(Debug)]
34#[cfg(target_os = "fuchsia")]
35pub struct DriverRegistrarSynchronousProxy {
36    client: fidl::client::sync::Client,
37}
38
39#[cfg(target_os = "fuchsia")]
40impl fidl::endpoints::SynchronousProxy for DriverRegistrarSynchronousProxy {
41    type Proxy = DriverRegistrarProxy;
42    type Protocol = DriverRegistrarMarker;
43
44    fn from_channel(inner: fidl::Channel) -> Self {
45        Self::new(inner)
46    }
47
48    fn into_channel(self) -> fidl::Channel {
49        self.client.into_channel()
50    }
51
52    fn as_channel(&self) -> &fidl::Channel {
53        self.client.as_channel()
54    }
55}
56
57#[cfg(target_os = "fuchsia")]
58impl DriverRegistrarSynchronousProxy {
59    pub fn new(channel: fidl::Channel) -> Self {
60        let protocol_name = <DriverRegistrarMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
61        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
62    }
63
64    pub fn into_channel(self) -> fidl::Channel {
65        self.client.into_channel()
66    }
67
68    /// Waits until an event arrives and returns it. It is safe for other
69    /// threads to make concurrent requests while waiting for an event.
70    pub fn wait_for_event(
71        &self,
72        deadline: zx::MonotonicInstant,
73    ) -> Result<DriverRegistrarEvent, fidl::Error> {
74        DriverRegistrarEvent::decode(self.client.wait_for_event(deadline)?)
75    }
76
77    /// Informs the driver framework of an ephemeral driver. The metadata will
78    /// be cached by the driver index to be used in future matching operations.
79    /// * error a zx_status value indicating failure. One of the following:
80    ///     * `ZX_ERR_PROTOCOL_NOT_SUPPORTED` if the ephermeral driver config
81    ///       `enable_ephemeral_drivers` is not enabled.
82    ///     * `ZX_ERR_ACCESS_DENIED` if the device does not have permissions
83    ///       to fetch the package.
84    ///     * `ZX_ERR_ALREADY_EXISTS` if the driver component being registered
85    ///       already exists in the boot or base drivers list.
86    ///     * `ZX_ERR_NOT_FOUND` if the package does not exist or it is missing
87    ///        a manifest or /pkg directory.
88    ///     * `ZX_ERR_IO` if there is some other unspecified error during I/O.
89    ///     * `ZX_ERR_ADDRESS_UNREACHABLE` if the package resolver does not
90    ///       know about the repo or the url cannot be parsed.
91    ///     * `ZX_ERR_INVALID_ARGS` if the component decl cannot be parsed.
92    ///     * `ZX_ERR_NO_SPACE` if the device is out of space.
93    ///     * `ZX_ERR_UNAVAILABLE` if the package resolver could not be reached.
94    ///     * `ZX_ERR_INTERNAL` if an unspecified error was encountered.
95    pub fn r#register(
96        &self,
97        mut driver_url: &str,
98        ___deadline: zx::MonotonicInstant,
99    ) -> Result<DriverRegistrarRegisterResult, fidl::Error> {
100        let _response = self.client.send_query::<
101            DriverRegistrarRegisterRequest,
102            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
103        >(
104            (driver_url,),
105            0x5c5f637b5f7c6a6,
106            fidl::encoding::DynamicFlags::FLEXIBLE,
107            ___deadline,
108        )?
109        .into_result::<DriverRegistrarMarker>("register")?;
110        Ok(_response.map(|x| x))
111    }
112}
113
114#[cfg(target_os = "fuchsia")]
115impl From<DriverRegistrarSynchronousProxy> for zx::Handle {
116    fn from(value: DriverRegistrarSynchronousProxy) -> Self {
117        value.into_channel().into()
118    }
119}
120
121#[cfg(target_os = "fuchsia")]
122impl From<fidl::Channel> for DriverRegistrarSynchronousProxy {
123    fn from(value: fidl::Channel) -> Self {
124        Self::new(value)
125    }
126}
127
128#[derive(Debug, Clone)]
129pub struct DriverRegistrarProxy {
130    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
131}
132
133impl fidl::endpoints::Proxy for DriverRegistrarProxy {
134    type Protocol = DriverRegistrarMarker;
135
136    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
137        Self::new(inner)
138    }
139
140    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
141        self.client.into_channel().map_err(|client| Self { client })
142    }
143
144    fn as_channel(&self) -> &::fidl::AsyncChannel {
145        self.client.as_channel()
146    }
147}
148
149impl DriverRegistrarProxy {
150    /// Create a new Proxy for fuchsia.driver.registrar/DriverRegistrar.
151    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
152        let protocol_name = <DriverRegistrarMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
153        Self { client: fidl::client::Client::new(channel, protocol_name) }
154    }
155
156    /// Get a Stream of events from the remote end of the protocol.
157    ///
158    /// # Panics
159    ///
160    /// Panics if the event stream was already taken.
161    pub fn take_event_stream(&self) -> DriverRegistrarEventStream {
162        DriverRegistrarEventStream { event_receiver: self.client.take_event_receiver() }
163    }
164
165    /// Informs the driver framework of an ephemeral driver. The metadata will
166    /// be cached by the driver index to be used in future matching operations.
167    /// * error a zx_status value indicating failure. One of the following:
168    ///     * `ZX_ERR_PROTOCOL_NOT_SUPPORTED` if the ephermeral driver config
169    ///       `enable_ephemeral_drivers` is not enabled.
170    ///     * `ZX_ERR_ACCESS_DENIED` if the device does not have permissions
171    ///       to fetch the package.
172    ///     * `ZX_ERR_ALREADY_EXISTS` if the driver component being registered
173    ///       already exists in the boot or base drivers list.
174    ///     * `ZX_ERR_NOT_FOUND` if the package does not exist or it is missing
175    ///        a manifest or /pkg directory.
176    ///     * `ZX_ERR_IO` if there is some other unspecified error during I/O.
177    ///     * `ZX_ERR_ADDRESS_UNREACHABLE` if the package resolver does not
178    ///       know about the repo or the url cannot be parsed.
179    ///     * `ZX_ERR_INVALID_ARGS` if the component decl cannot be parsed.
180    ///     * `ZX_ERR_NO_SPACE` if the device is out of space.
181    ///     * `ZX_ERR_UNAVAILABLE` if the package resolver could not be reached.
182    ///     * `ZX_ERR_INTERNAL` if an unspecified error was encountered.
183    pub fn r#register(
184        &self,
185        mut driver_url: &str,
186    ) -> fidl::client::QueryResponseFut<
187        DriverRegistrarRegisterResult,
188        fidl::encoding::DefaultFuchsiaResourceDialect,
189    > {
190        DriverRegistrarProxyInterface::r#register(self, driver_url)
191    }
192}
193
194impl DriverRegistrarProxyInterface for DriverRegistrarProxy {
195    type RegisterResponseFut = fidl::client::QueryResponseFut<
196        DriverRegistrarRegisterResult,
197        fidl::encoding::DefaultFuchsiaResourceDialect,
198    >;
199    fn r#register(&self, mut driver_url: &str) -> Self::RegisterResponseFut {
200        fn _decode(
201            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
202        ) -> Result<DriverRegistrarRegisterResult, fidl::Error> {
203            let _response = fidl::client::decode_transaction_body::<
204                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
205                fidl::encoding::DefaultFuchsiaResourceDialect,
206                0x5c5f637b5f7c6a6,
207            >(_buf?)?
208            .into_result::<DriverRegistrarMarker>("register")?;
209            Ok(_response.map(|x| x))
210        }
211        self.client
212            .send_query_and_decode::<DriverRegistrarRegisterRequest, DriverRegistrarRegisterResult>(
213                (driver_url,),
214                0x5c5f637b5f7c6a6,
215                fidl::encoding::DynamicFlags::FLEXIBLE,
216                _decode,
217            )
218    }
219}
220
221pub struct DriverRegistrarEventStream {
222    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
223}
224
225impl std::marker::Unpin for DriverRegistrarEventStream {}
226
227impl futures::stream::FusedStream for DriverRegistrarEventStream {
228    fn is_terminated(&self) -> bool {
229        self.event_receiver.is_terminated()
230    }
231}
232
233impl futures::Stream for DriverRegistrarEventStream {
234    type Item = Result<DriverRegistrarEvent, fidl::Error>;
235
236    fn poll_next(
237        mut self: std::pin::Pin<&mut Self>,
238        cx: &mut std::task::Context<'_>,
239    ) -> std::task::Poll<Option<Self::Item>> {
240        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
241            &mut self.event_receiver,
242            cx
243        )?) {
244            Some(buf) => std::task::Poll::Ready(Some(DriverRegistrarEvent::decode(buf))),
245            None => std::task::Poll::Ready(None),
246        }
247    }
248}
249
250#[derive(Debug)]
251pub enum DriverRegistrarEvent {
252    #[non_exhaustive]
253    _UnknownEvent {
254        /// Ordinal of the event that was sent.
255        ordinal: u64,
256    },
257}
258
259impl DriverRegistrarEvent {
260    /// Decodes a message buffer as a [`DriverRegistrarEvent`].
261    fn decode(
262        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
263    ) -> Result<DriverRegistrarEvent, fidl::Error> {
264        let (bytes, _handles) = buf.split_mut();
265        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
266        debug_assert_eq!(tx_header.tx_id, 0);
267        match tx_header.ordinal {
268            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
269                Ok(DriverRegistrarEvent::_UnknownEvent { ordinal: tx_header.ordinal })
270            }
271            _ => Err(fidl::Error::UnknownOrdinal {
272                ordinal: tx_header.ordinal,
273                protocol_name:
274                    <DriverRegistrarMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
275            }),
276        }
277    }
278}
279
280/// A Stream of incoming requests for fuchsia.driver.registrar/DriverRegistrar.
281pub struct DriverRegistrarRequestStream {
282    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
283    is_terminated: bool,
284}
285
286impl std::marker::Unpin for DriverRegistrarRequestStream {}
287
288impl futures::stream::FusedStream for DriverRegistrarRequestStream {
289    fn is_terminated(&self) -> bool {
290        self.is_terminated
291    }
292}
293
294impl fidl::endpoints::RequestStream for DriverRegistrarRequestStream {
295    type Protocol = DriverRegistrarMarker;
296    type ControlHandle = DriverRegistrarControlHandle;
297
298    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
299        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
300    }
301
302    fn control_handle(&self) -> Self::ControlHandle {
303        DriverRegistrarControlHandle { inner: self.inner.clone() }
304    }
305
306    fn into_inner(
307        self,
308    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
309    {
310        (self.inner, self.is_terminated)
311    }
312
313    fn from_inner(
314        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
315        is_terminated: bool,
316    ) -> Self {
317        Self { inner, is_terminated }
318    }
319}
320
321impl futures::Stream for DriverRegistrarRequestStream {
322    type Item = Result<DriverRegistrarRequest, fidl::Error>;
323
324    fn poll_next(
325        mut self: std::pin::Pin<&mut Self>,
326        cx: &mut std::task::Context<'_>,
327    ) -> std::task::Poll<Option<Self::Item>> {
328        let this = &mut *self;
329        if this.inner.check_shutdown(cx) {
330            this.is_terminated = true;
331            return std::task::Poll::Ready(None);
332        }
333        if this.is_terminated {
334            panic!("polled DriverRegistrarRequestStream after completion");
335        }
336        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
337            |bytes, handles| {
338                match this.inner.channel().read_etc(cx, bytes, handles) {
339                    std::task::Poll::Ready(Ok(())) => {}
340                    std::task::Poll::Pending => return std::task::Poll::Pending,
341                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
342                        this.is_terminated = true;
343                        return std::task::Poll::Ready(None);
344                    }
345                    std::task::Poll::Ready(Err(e)) => {
346                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
347                            e.into(),
348                        ))))
349                    }
350                }
351
352                // A message has been received from the channel
353                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
354
355                std::task::Poll::Ready(Some(match header.ordinal {
356                    0x5c5f637b5f7c6a6 => {
357                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
358                        let mut req = fidl::new_empty!(
359                            DriverRegistrarRegisterRequest,
360                            fidl::encoding::DefaultFuchsiaResourceDialect
361                        );
362                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DriverRegistrarRegisterRequest>(&header, _body_bytes, handles, &mut req)?;
363                        let control_handle =
364                            DriverRegistrarControlHandle { inner: this.inner.clone() };
365                        Ok(DriverRegistrarRequest::Register {
366                            driver_url: req.driver_url,
367
368                            responder: DriverRegistrarRegisterResponder {
369                                control_handle: std::mem::ManuallyDrop::new(control_handle),
370                                tx_id: header.tx_id,
371                            },
372                        })
373                    }
374                    _ if header.tx_id == 0
375                        && header
376                            .dynamic_flags()
377                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
378                    {
379                        Ok(DriverRegistrarRequest::_UnknownMethod {
380                            ordinal: header.ordinal,
381                            control_handle: DriverRegistrarControlHandle {
382                                inner: this.inner.clone(),
383                            },
384                            method_type: fidl::MethodType::OneWay,
385                        })
386                    }
387                    _ if header
388                        .dynamic_flags()
389                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
390                    {
391                        this.inner.send_framework_err(
392                            fidl::encoding::FrameworkErr::UnknownMethod,
393                            header.tx_id,
394                            header.ordinal,
395                            header.dynamic_flags(),
396                            (bytes, handles),
397                        )?;
398                        Ok(DriverRegistrarRequest::_UnknownMethod {
399                            ordinal: header.ordinal,
400                            control_handle: DriverRegistrarControlHandle {
401                                inner: this.inner.clone(),
402                            },
403                            method_type: fidl::MethodType::TwoWay,
404                        })
405                    }
406                    _ => Err(fidl::Error::UnknownOrdinal {
407                        ordinal: header.ordinal,
408                        protocol_name:
409                            <DriverRegistrarMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
410                    }),
411                }))
412            },
413        )
414    }
415}
416
417/// Protocol for registering ephemeral driver packages.
418#[derive(Debug)]
419pub enum DriverRegistrarRequest {
420    /// Informs the driver framework of an ephemeral driver. The metadata will
421    /// be cached by the driver index to be used in future matching operations.
422    /// * error a zx_status value indicating failure. One of the following:
423    ///     * `ZX_ERR_PROTOCOL_NOT_SUPPORTED` if the ephermeral driver config
424    ///       `enable_ephemeral_drivers` is not enabled.
425    ///     * `ZX_ERR_ACCESS_DENIED` if the device does not have permissions
426    ///       to fetch the package.
427    ///     * `ZX_ERR_ALREADY_EXISTS` if the driver component being registered
428    ///       already exists in the boot or base drivers list.
429    ///     * `ZX_ERR_NOT_FOUND` if the package does not exist or it is missing
430    ///        a manifest or /pkg directory.
431    ///     * `ZX_ERR_IO` if there is some other unspecified error during I/O.
432    ///     * `ZX_ERR_ADDRESS_UNREACHABLE` if the package resolver does not
433    ///       know about the repo or the url cannot be parsed.
434    ///     * `ZX_ERR_INVALID_ARGS` if the component decl cannot be parsed.
435    ///     * `ZX_ERR_NO_SPACE` if the device is out of space.
436    ///     * `ZX_ERR_UNAVAILABLE` if the package resolver could not be reached.
437    ///     * `ZX_ERR_INTERNAL` if an unspecified error was encountered.
438    Register { driver_url: String, responder: DriverRegistrarRegisterResponder },
439    /// An interaction was received which does not match any known method.
440    #[non_exhaustive]
441    _UnknownMethod {
442        /// Ordinal of the method that was called.
443        ordinal: u64,
444        control_handle: DriverRegistrarControlHandle,
445        method_type: fidl::MethodType,
446    },
447}
448
449impl DriverRegistrarRequest {
450    #[allow(irrefutable_let_patterns)]
451    pub fn into_register(self) -> Option<(String, DriverRegistrarRegisterResponder)> {
452        if let DriverRegistrarRequest::Register { driver_url, responder } = self {
453            Some((driver_url, responder))
454        } else {
455            None
456        }
457    }
458
459    /// Name of the method defined in FIDL
460    pub fn method_name(&self) -> &'static str {
461        match *self {
462            DriverRegistrarRequest::Register { .. } => "register",
463            DriverRegistrarRequest::_UnknownMethod {
464                method_type: fidl::MethodType::OneWay,
465                ..
466            } => "unknown one-way method",
467            DriverRegistrarRequest::_UnknownMethod {
468                method_type: fidl::MethodType::TwoWay,
469                ..
470            } => "unknown two-way method",
471        }
472    }
473}
474
475#[derive(Debug, Clone)]
476pub struct DriverRegistrarControlHandle {
477    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
478}
479
480impl fidl::endpoints::ControlHandle for DriverRegistrarControlHandle {
481    fn shutdown(&self) {
482        self.inner.shutdown()
483    }
484    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
485        self.inner.shutdown_with_epitaph(status)
486    }
487
488    fn is_closed(&self) -> bool {
489        self.inner.channel().is_closed()
490    }
491    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
492        self.inner.channel().on_closed()
493    }
494
495    #[cfg(target_os = "fuchsia")]
496    fn signal_peer(
497        &self,
498        clear_mask: zx::Signals,
499        set_mask: zx::Signals,
500    ) -> Result<(), zx_status::Status> {
501        use fidl::Peered;
502        self.inner.channel().signal_peer(clear_mask, set_mask)
503    }
504}
505
506impl DriverRegistrarControlHandle {}
507
508#[must_use = "FIDL methods require a response to be sent"]
509#[derive(Debug)]
510pub struct DriverRegistrarRegisterResponder {
511    control_handle: std::mem::ManuallyDrop<DriverRegistrarControlHandle>,
512    tx_id: u32,
513}
514
515/// Set the the channel to be shutdown (see [`DriverRegistrarControlHandle::shutdown`])
516/// if the responder is dropped without sending a response, so that the client
517/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
518impl std::ops::Drop for DriverRegistrarRegisterResponder {
519    fn drop(&mut self) {
520        self.control_handle.shutdown();
521        // Safety: drops once, never accessed again
522        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
523    }
524}
525
526impl fidl::endpoints::Responder for DriverRegistrarRegisterResponder {
527    type ControlHandle = DriverRegistrarControlHandle;
528
529    fn control_handle(&self) -> &DriverRegistrarControlHandle {
530        &self.control_handle
531    }
532
533    fn drop_without_shutdown(mut self) {
534        // Safety: drops once, never accessed again due to mem::forget
535        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
536        // Prevent Drop from running (which would shut down the channel)
537        std::mem::forget(self);
538    }
539}
540
541impl DriverRegistrarRegisterResponder {
542    /// Sends a response to the FIDL transaction.
543    ///
544    /// Sets the channel to shutdown if an error occurs.
545    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
546        let _result = self.send_raw(result);
547        if _result.is_err() {
548            self.control_handle.shutdown();
549        }
550        self.drop_without_shutdown();
551        _result
552    }
553
554    /// Similar to "send" but does not shutdown the channel if an error occurs.
555    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
556        let _result = self.send_raw(result);
557        self.drop_without_shutdown();
558        _result
559    }
560
561    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
562        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
563            fidl::encoding::EmptyStruct,
564            i32,
565        >>(
566            fidl::encoding::FlexibleResult::new(result),
567            self.tx_id,
568            0x5c5f637b5f7c6a6,
569            fidl::encoding::DynamicFlags::FLEXIBLE,
570        )
571    }
572}
573
574mod internal {
575    use super::*;
576}
fidl_fuchsia_driver_registrar/fidl_fuchsia_driver_registrar.rs

fidl_fuchsia_driver_registrar/
fidl_fuchsia_driver_registrar.rs
