# Request

> The payload of the channel request is empty; the channel carries no tag.

Canonical: https://protocol.diverge.network/2.3.0/container-proxy-endpoints/filesystem-write/server/content/request/
Specification revision: 2.3.0

```text
[]
```

- **No parameter.** The channel request carries nothing. Which write
  the content is for, the scope states.

The channel request is defined by `diverge-sdk-rs/src/container_proxy/outside/endpoints/filesystem/write/server/channel_request/frame.rs`:

```rust
//! What a server's channel request frame carries for a write.

use crate::wire::decode::Decode;
use crate::wire::encode::{Encode, Writer};

/// Send the content.
///
/// What the proxy asks the server for, and the only thing: a write
/// cannot carry its own content, because only a responder can finish
/// a channel, so the bytes have to travel as responses on a channel
/// the proxy opened. Opened once the request is read, before anything
/// is written.
///
/// # A struct, no tag, and no id
///
/// One thing to ask for is a struct; an enum of one variant would be a
/// discriminant with nothing to discriminate — and a tag byte is that
/// discriminant written on the wire, so it goes for the same reason.
/// The provider protocol's counterpart quotes a write id, because
/// there the content channel and the write share a scope with every
/// other write; here the scope IS the write, so a payload is nothing
/// at all.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct Frame;

/// Nothing at all. The frame is the whole message: which scope it
/// arrived on says which write.
impl Encode for Frame {
    /// [`Infallible`](std::convert::Infallible): no bytes.
    type Error = std::convert::Infallible;

    fn encode(&self, _out: &mut Writer<'_>) -> Result<(), Self::Error> {
        Ok(())
    }
}

impl Decode<'_> for Frame {
    /// [`Infallible`](std::convert::Infallible): there is nothing to
    /// read.
    type Error = std::convert::Infallible;

    /// Whatever bytes arrive are ignored. There are none to send, so a
    /// peer that sent some knows something this version does not, and
    /// leaving room for it is cheaper than refusing it.
    fn decode(_bytes: &[u8]) -> Result<Self, Self::Error> {
        Ok(Frame)
    }
}
```