Struct esp_idf_svc::http::server::EspHttpConnection

pub struct EspHttpConnection<'a> { /* private fields */ }

Implementations

impl<'a> EspHttpConnection<'a>

Represents the two-way connection between an HTTP request and its response.

pub fn uri(&self) -> &str

pub fn method(&self) -> Method

pub fn header(&self, name: &str) -> Option<&str>

pub fn split(&mut self) -> (&EspHttpConnection<'a>, &mut Self)

pub fn initiate_response( &mut self, status: u16, message: Option<&str>, headers: &[(&str, &str)], ) -> Result<(), EspError>

Sends the HTTP status (e.g. “200 OK”) and the response headers to the HTTP client.

pub fn is_response_initiated(&self) -> bool

Returns true if the response headers have been sent to the HTTP client.

pub fn read(&mut self, buf: &mut [u8]) -> Result<usize, EspError>

Reads bytes from the body of the HTTP request.

This is typically used whenever the HTTP server has to parse the body of an HTTP POST request.

server.fn_handler("/foo", Method::Post, move |mut request| {
    let (_headers, connection) = request.split();
    let mut buffer: [u8; 1024] = [0; 1024];
    let bytes_read = connection.read(&mut buffer)?;

    let my_data = MyDataStruct::from_bytes(&buffer[0..bytes_read]);
    // etc

pub fn write(&mut self, buf: &[u8]) -> Result<usize, EspError>

Sends bytes back to the HTTP client; returns the number of bytes sent.

pub fn write_all(&mut self, buf: &[u8]) -> Result<(), EspError>

pub fn raw_connection( &mut self, ) -> Result<&mut EspHttpRawConnection<'a>, EspError>

Trait Implementations

impl<'b> Connection for EspHttpConnection<'b>

type Headers = EspHttpConnection<'b>

type Read = EspHttpConnection<'b>

type RawConnectionError = EspIOError

type RawConnection = EspHttpRawConnection<'b>

fn split(&mut self) -> (&Self::Headers, &mut Self::Read)

fn initiate_response<'a>( &'a mut self, status: u16, message: Option<&'a str>, headers: &'a [(&'a str, &'a str)], ) -> Result<(), Self::Error>

fn is_response_initiated(&self) -> bool

fn raw_connection(&mut self) -> Result<&mut Self::RawConnection, Self::Error>

impl<'a> ErrorType for EspHttpConnection<'a>

type Error = EspIOError

Error type of all the IO operations on this type.

impl<'a> Headers for EspHttpConnection<'a>

fn header(&self, name: &str) -> Option<&str>

fn content_type(&self) -> Option<&str>

fn content_len(&self) -> Option<u64>

fn content_encoding(&self) -> Option<&str>

fn transfer_encoding(&self) -> Option<&str>

fn host(&self) -> Option<&str>

fn connection(&self) -> Option<&str>

fn cache_control(&self) -> Option<&str>

fn upgrade(&self) -> Option<&str>

impl<'a> Query for EspHttpConnection<'a>

fn uri(&self) -> &str

fn method(&self) -> Method

impl<'a> RawHandle for EspHttpConnection<'a>

type Handle = *mut httpd_req

fn handle(&self) -> Self::Handle

Care should be taken to use the returned ESP-IDF driver raw handle only while the driver is still alive, so as to avoid use-after-free errors.

impl<'a> Read for EspHttpConnection<'a>

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<'a> Write for EspHttpConnection<'a>

fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, blocking until all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.

fn write_fmt( &mut self, fmt: Arguments<'_>, ) -> Result<(), WriteFmtError<Self::Error>>

Write a formatted string into this writer, returning any error encountered.