Struct libuv::handles::streams::pipe::PipeHandle

pub struct PipeHandle { /* fields omitted */ }

Pipe handles provide an abstraction over streaming files on Unix (including local domain sockets, pipes, and FIFOs) and named pipes on Windows.

Implementations

impl PipeHandle

pub fn new(r#loop: &Loop, ipc: bool) -> Result<PipeHandle>

Create and initialize a pipe handle. The ipc argument is a boolean to indicate if this pipe will be used for handle passing between processes (which may change the bytes on the wire). Only a connected pipe that will be passing the handles should have this flag set, not the listening pipe that accept() is called on.

pub fn open(&mut self, file: File) -> Result<()>

Open an existing file descriptor or HANDLE as a pipe. The file descriptor is set to non-blocking mode.

Note: The passed file descriptor or HANDLE is not checked for its type, but it’s required that it represents a valid pipe.

pub fn bind(&mut self, name: &str) -> Result<(), Box<dyn Error>>

Bind the pipe to a file path (Unix) or a name (Windows).

Note: Paths on Unix get truncated to sizeof(sockaddr_un.sun_path) bytes, typically between 92 and 108 bytes.

pub fn connect<CB: Into<ConnectCB<'static>>>(
    &mut self,
    name: &str,
    cb: CB
) -> Result<ConnectReq, Box<dyn Error>>

Connect to the Unix domain socket or the named pipe.

Note: Paths on Unix get truncated to sizeof(sockaddr_un.sun_path) bytes, typically between 92 and 108 bytes.

pub fn getsockname(&self) -> Result<SocketAddr, Box<dyn Error>>

Get the name of the Unix domain socket or the named pipe.

pub fn getpeername(&self) -> Result<SocketAddr, Box<dyn Error>>

Get the name of the Unix domain socket or the named pipe to which the handle is connected.

pub fn pending_instances(&mut self, count: i32)

Set the number of pending pipe instance handles when the pipe server is waiting for connections.

Note: This setting applies to Windows only.

pub fn pending_count(&self) -> i32

pub fn pending_type(&self) -> HandleType

Used to receive handles over IPC pipes.

First - call pending_count(), if it’s > 0 then initialize a handle of the given type, returned by pending_type() and call uv_accept(pipe, handle).

pub fn chmod(&mut self, flags: ChmodFlags) -> Result<()>

Alters pipe permissions, allowing it to be accessed from processes run by different users. Makes the pipe writable or readable by all users. Mode can be WRITABLE, READABLE or WRITABLE | READABLE. This function is blocking.

pub fn ipc(&self) -> bool

Whether this pipe is suitable for handle passing between processes. Only a connected pipe that will be passing the handles should have this flag set, not the listening pipe that accept() is called on

Trait Implementations

impl Clone for PipeHandle

fn clone(&self) -> PipeHandle

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for PipeHandle

impl From<PipeHandle> for StreamHandle

fn from(pipe: PipeHandle) -> StreamHandle

Performs the conversion.

impl From<PipeHandle> for Handle

fn from(pipe: PipeHandle) -> Handle

Performs the conversion.

impl HandleTrait for PipeHandle

fn is_active(&self) -> bool

Returns non-zero if the handle is active, zero if it’s inactive. What “active” means depends on the type of handle: * An AsyncHandle is always active and cannot be deactivated, except by closing it with close(). * A PipeHandle, TcpHandle, UdpHandle, etc. - basically any handle that deals with i/o - is active when it is doing something that involves i/o, like reading, writing, connecting, accepting new connections, etc. * A CheckHandle, IdleHandle, TimerHandle, etc. is active when it has been started with a call to start().

fn is_closing(&self) -> bool

Returns non-zero if the handle is closing or closed, zero otherwise.

fn close<CB: Into<CloseCB<'static>>>(&mut self, cb: CB)

Request handle to be closed. close_cb will be called asynchronously after this call. This MUST be called on each handle before memory is released. Moreover, the memory can only be released in close_cb or after it has returned.

fn ref(&mut self)

Reference the given handle. References are idempotent, that is, if a handle is already referenced calling this function again will have no effect.

fn unref(&mut self)

Un-reference the given handle. References are idempotent, that is, if a handle is not referenced calling this function again will have no effect.

fn has_ref(&self) -> bool

Returns true if the handle referenced, zero otherwise.

fn send_buffer_size(&mut self, value: i32) -> Result<i32>

Gets or sets the size of the send buffer that the operating system uses for the socket.

fn recv_buffer_size(&mut self, value: i32) -> Result<i32>

Gets or sets the size of the receive buffer that the operating system uses for the socket.

fn get_fileno(&self) -> Result<OsFile>

Gets the platform dependent file descriptor equivalent.

fn get_loop(&self) -> Loop

Returns the Loop associated with this handle.

fn get_type(&self) -> HandleType

Returns the type of the handle.

impl StreamTrait for PipeHandle

fn shutdown<CB: Into<ShutdownCB<'static>>>(
    &mut self,
    cb: CB
) -> Result<ShutdownReq>

Shutdown the outgoing (write) side of a duplex stream. It waits for pending write requests to complete. The handle should refer to a initialized stream. The cb is called after shutdown is complete at which point the returned ShutdownReq is automatically destroy()'d.

fn listen<CB: Into<ConnectionCB<'static>>>(
    &mut self,
    backlog: i32,
    cb: CB
) -> Result<()>

Start listening for incoming connections. backlog indicates the number of connections the kernel might queue, same as listen(2). When a new incoming connection is received the uv_connection_cb callback is called.

fn accept(&mut self, client: &mut StreamHandle) -> Result<()>

This call is used in conjunction with listen() to accept incoming connections. Call this function after receiving the connection callback to accept the connection. Before calling this function the client handle must be initialized.

fn read_start<ACB: Into<AllocCB<'static>>, RCB: Into<ReadCB<'static>>>(
    &mut self,
    alloc_cb: ACB,
    read_cb: RCB
) -> Result<()>

Read data from an incoming stream. The read_cb callback will be made several times until there is no more data to read or read_stop() is called.

fn read_stop(&mut self) -> Result<()>

Stop reading data from the stream. The uv_read_cb callback will no longer be called.

fn write<CB: Into<WriteCB<'static>>>(
    &mut self,
    bufs: &[impl BufTrait],
    cb: CB
) -> Result<WriteReq>

Write data to stream. Buffers are written in order.

fn write2<CB: Into<WriteCB<'static>>>(
    &mut self,
    send_handle: &StreamHandle,
    bufs: &[impl BufTrait],
    cb: CB
) -> Result<WriteReq>

Extended write function for sending handles over a pipe. The pipe must be initialized with ipc == 1.

fn try_write(&mut self, bufs: &[impl BufTrait]) -> Result<i32>

Same as write(), but won’t queue a write request if it can’t be completed immediately.

fn is_readable(&self) -> bool

Returns true if the stream is readable, false otherwise.

fn is_writable(&self) -> bool

Returns true if the stream is writable, false otherwise.

fn set_blocking(&mut self, blocking: bool) -> Result<()>

Enable or disable blocking mode for a stream.

fn get_write_queue_size(&self) -> usize

Returns the size of the write queue.

impl ToHandle for PipeHandle

fn to_handle(&self) -> Handle

impl ToStream for PipeHandle

fn to_stream(&self) -> StreamHandle

impl TryFrom<Handle> for PipeHandle

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(handle: Handle) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<StreamHandle> for PipeHandle

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(stream: StreamHandle) -> Result<Self, Self::Error>

Performs the conversion.