Struct async_tftp::server::TftpServerBuilder

pub struct TftpServerBuilder<H: Handler> { /* fields omitted */ }

TFTP server builder.

Methods

impl TftpServerBuilder<DirRoHandler>

pub fn with_dir_ro<P>(dir: P) -> Result<TftpServerBuilder<DirRoHandler>> where
    P: AsRef<Path>, 

Create new buidler with DirRoHandler.

impl<H: Handler> TftpServerBuilder<H>

pub fn with_handler(handler: H) -> Self

Create new builder with custom Handler.

pub fn bind(self, addr: SocketAddr) -> Self

Set listening address.

This is ignored if underling socket is set.

Default: 0.0.0.0:69

pub fn socket(self, socket: UdpSocket) -> Self

Set underling UDP socket.

pub fn timeout(self, timeout: Duration) -> Self

Set retry timeout.

Client can override this (RFC2349). If you want to enforce it you must combine it ignore_client_timeout.

This crate allows you to set non-standard timeouts (i.e. timeouts that are less than a second). However if you choose to do it make sure you test it well in your environment since client's behavior is undefined.

Default: 3 seconds

pub fn block_size_limit(self, size: u16) -> Self

Set maximum block size.

Client can request a specific block size (RFC2348). Use this option if you want to set a limit.

Real life scenario: U-Boot does not support IP fragmentation and requests block size of 1468. This works fine if your MTU is 1500 bytes, however if you are accessing client through a VPN, then transfer will never start. Use this option to workaround the problem.

pub fn ignore_client_timeout(self) -> Self

Ignore client's timeout option.

With this you enforce server's timeout by ignoring client's timeout option of RFC2349.

pub fn ignore_client_block_size(self) -> Self

Ignore client's block size option.

With this you can ignore client's blksize option of RFC2348. This will enforce 512 block size that is defined in RFC1350.

pub async fn build(__arg0: Self) -> Result<TftpServer<H>>

Build TftpServer.