# 1.10.0[−][src]Struct std::os::unix::net::UnixDatagram

    pub struct UnixDatagram(_);

This is supported on Unix only.

A Unix datagram socket.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let socket = UnixDatagram::bind("/path/to/my/socket")?;
        socket.send_to(b"hello world", "/path/to/other/socket")?;
        let mut buf = [0; 100];
        let (count, address) = socket.recv_from(&mut buf)?;
        println!("socket {:?} sent {:?}", address, &buf[..count]);
        Ok(())
    }

Run

## Implementations

### `impl UnixDatagram`[src]

#### `pub fn bind<P: AsRef<Path>>(path: P) -> Result<UnixDatagram>`[src]

This is supported on Unix only.

Creates a Unix datagram socket bound to the given path.

# Examples

    use std::os::unix::net::UnixDatagram;

    let sock = match UnixDatagram::bind("/path/to/the/socket") {
        Ok(sock) => sock,
        Err(e) => {
            println!("Couldn't bind: {:?}", e);
            return
        }
    };

Run

#### `pub fn unbound() -> Result<UnixDatagram>`[src]

This is supported on Unix only.

Creates a Unix Datagram socket which is not bound to any address.

# Examples

    use std::os::unix::net::UnixDatagram;

    let sock = match UnixDatagram::unbound() {
        Ok(sock) => sock,
        Err(e) => {
            println!("Couldn't unbound: {:?}", e);
            return
        }
    };

Run

#### `pub fn pair() -> Result<(UnixDatagram, UnixDatagram)>`[src]

This is supported on Unix only.

Creates an unnamed pair of connected sockets.

Returns two `UnixDatagrams`s which are connected to each other.

# Examples

    use std::os::unix::net::UnixDatagram;

    let (sock1, sock2) = match UnixDatagram::pair() {
        Ok((sock1, sock2)) => (sock1, sock2),
        Err(e) => {
            println!("Couldn't unbound: {:?}", e);
            return
        }
    };

Run

#### `pub fn connect<P: AsRef<Path>>(&self, path: P) -> Result<()>`[src]

This is supported on Unix only.

Connects the socket to the specified address.

The `send` method may be used to send data to the specified address. `recv` and `recv_from` will only receive data from that address.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        match sock.connect("/path/to/the/socket") {
            Ok(sock) => sock,
            Err(e) => {
                println!("Couldn't connect: {:?}", e);
                return Err(e)
            }
        };
        Ok(())
    }

Run

#### `pub fn try_clone(&self) -> Result<UnixDatagram>`[src]

This is supported on Unix only.

Creates a new independently owned handle to the underlying socket.

The returned `UnixDatagram` is a reference to the same socket that this object references. Both handles can be used to accept incoming connections and options set on one side will affect the other.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::bind("/path/to/the/socket")?;
        let sock_copy = sock.try_clone().expect("try_clone failed");
        Ok(())
    }

Run

#### `pub fn local_addr(&self) -> Result<SocketAddr>`[src]

This is supported on Unix only.

Returns the address of this socket.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::bind("/path/to/the/socket")?;
        let addr = sock.local_addr().expect("Couldn't get local address");
        Ok(())
    }

Run

#### `pub fn peer_addr(&self) -> Result<SocketAddr>`[src]

This is supported on Unix only.

Returns the address of this socket's peer.

The `connect` method will connect the socket to a peer.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        sock.connect("/path/to/the/socket")?;

        let addr = sock.peer_addr().expect("Couldn't get peer address");
        Ok(())
    }

Run

#### `pub fn recv_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)>`[src]

This is supported on Unix only.

Receives data from the socket.

On success, returns the number of bytes read and the address from whence the data came.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        let mut buf = vec![0; 10];
        let (size, sender) = sock.recv_from(buf.as_mut_slice())?;
        println!("received {} bytes from {:?}", size, sender);
        Ok(())
    }

Run

#### `pub fn recv(&self, buf: &mut [u8]) -> Result<usize>`[src]

This is supported on Unix only.

Receives data from the socket.

On success, returns the number of bytes read.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::bind("/path/to/the/socket")?;
        let mut buf = vec![0; 10];
        sock.recv(buf.as_mut_slice()).expect("recv function failed");
        Ok(())
    }

Run

#### `pub fn send_to<P: AsRef<Path>>(&self, buf: &[u8], path: P) -> Result<usize>`[src]

This is supported on Unix only.

Sends data on the socket to the specified address.

On success, returns the number of bytes written.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        sock.send_to(b"omelette au fromage", "/some/sock").expect("send_to function failed");
        Ok(())
    }

Run

#### `pub fn send(&self, buf: &[u8]) -> Result<usize>`[src]

This is supported on Unix only.

Sends data on the socket to the socket's peer.

The peer address may be set by the `connect` method, and this method will return an error if the socket has not already been connected.

On success, returns the number of bytes written.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        sock.connect("/some/sock").expect("Couldn't connect");
        sock.send(b"omelette au fromage").expect("send_to function failed");
        Ok(())
    }

Run

#### `pub fn set_read_timeout(&self, timeout: Option<Duration>) -> Result<()>`[src]

This is supported on Unix only.

Sets the read timeout for the socket.

If the provided value is `None`, then `recv` and `recv_from` calls will block indefinitely. An `Err` is returned if the zero `Duration` is passed to this method.

# Examples

    use std::os::unix::net::UnixDatagram;
    use std::time::Duration;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        sock.set_read_timeout(Some(Duration::new(1, 0)))
            .expect("set_read_timeout function failed");
        Ok(())
    }

Run

An `Err` is returned if the zero `Duration` is passed to this method:

    use std::io;
    use std::os::unix::net::UnixDatagram;
    use std::time::Duration;

    fn main() -> std::io::Result<()> {
        let socket = UnixDatagram::unbound()?;
        let result = socket.set_read_timeout(Some(Duration::new(0, 0)));
        let err = result.unwrap_err();
        assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
        Ok(())
    }

Run

#### `pub fn set_write_timeout(&self, timeout: Option<Duration>) -> Result<()>`[src]

This is supported on Unix only.

Sets the write timeout for the socket.

If the provided value is `None`, then `send` and `send_to` calls will block indefinitely. An `Err` is returned if the zero `Duration` is passed to this method.

# Examples

    use std::os::unix::net::UnixDatagram;
    use std::time::Duration;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        sock.set_write_timeout(Some(Duration::new(1, 0)))
            .expect("set_write_timeout function failed");
        Ok(())
    }

Run

An `Err` is returned if the zero `Duration` is passed to this method:

    use std::io;
    use std::os::unix::net::UnixDatagram;
    use std::time::Duration;

    fn main() -> std::io::Result<()> {
        let socket = UnixDatagram::unbound()?;
        let result = socket.set_write_timeout(Some(Duration::new(0, 0)));
        let err = result.unwrap_err();
        assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
        Ok(())
    }

Run

#### `pub fn read_timeout(&self) -> Result<Option<Duration>>`[src]

This is supported on Unix only.

Returns the read timeout of this socket.

# Examples

    use std::os::unix::net::UnixDatagram;
    use std::time::Duration;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        sock.set_read_timeout(Some(Duration::new(1, 0)))
            .expect("set_read_timeout function failed");
        assert_eq!(sock.read_timeout()?, Some(Duration::new(1, 0)));
        Ok(())
    }

Run

#### `pub fn write_timeout(&self) -> Result<Option<Duration>>`[src]

This is supported on Unix only.

Returns the write timeout of this socket.

# Examples

    use std::os::unix::net::UnixDatagram;
    use std::time::Duration;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        sock.set_write_timeout(Some(Duration::new(1, 0)))
            .expect("set_write_timeout function failed");
        assert_eq!(sock.write_timeout()?, Some(Duration::new(1, 0)));
        Ok(())
    }

Run

#### `pub fn set_nonblocking(&self, nonblocking: bool) -> Result<()>`[src]

This is supported on Unix only.

Moves the socket into or out of nonblocking mode.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        sock.set_nonblocking(true).expect("set_nonblocking function failed");
        Ok(())
    }

Run

#### `pub fn take_error(&self) -> Result<Option<Error>>`[src]

This is supported on Unix only.

Returns the value of the `SO_ERROR` option.

# Examples

    use std::os::unix::net::UnixDatagram;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        if let Ok(Some(err)) = sock.take_error() {
            println!("Got error: {:?}", err);
        }
        Ok(())
    }

Run

#### `pub fn shutdown(&self, how: Shutdown) -> Result<()>`[src]

This is supported on Unix only.

Shut down the read, write, or both halves of this connection.

This function will cause all pending and future I/O calls on the specified portions to immediately return with an appropriate value (see the documentation of `Shutdown`).

    use std::os::unix::net::UnixDatagram;
    use std::net::Shutdown;

    fn main() -> std::io::Result<()> {
        let sock = UnixDatagram::unbound()?;
        sock.shutdown(Shutdown::Both).expect("shutdown function failed");
        Ok(())
    }

Run

## Trait Implementations

### `impl AsRawFd for UnixDatagram`[src]

#### `fn as_raw_fd(&self) -> RawFd`[src]

This is supported on Unix only.

Extracts the raw file descriptor. Read more

### `impl Debug for UnixDatagram`[src]

#### `fn fmt(&self, fmt: &mut Formatter<'_>) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl FromRawFd for UnixDatagram`[src]

#### `unsafe fn from_raw_fd(fd: RawFd) -> UnixDatagram`[src]

This is supported on Unix only.

Constructs a new instance of `Self` from the given raw file descriptor. Read more

### `impl IntoRawFd for UnixDatagram`[src]

#### `fn into_raw_fd(self) -> RawFd`[src]

This is supported on Unix only.

Consumes this object, returning the raw underlying file descriptor. Read more

## Auto Trait Implementations

### `impl RefUnwindSafe for UnixDatagram`

### `impl Send for UnixDatagram`

### `impl Sync for UnixDatagram`

### `impl Unpin for UnixDatagram`

### `impl UnwindSafe for UnixDatagram`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `fn borrow(&self) -> &Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized, '_> Read for &'_ mut Rimpl<W: Write + ?Sized, '_> Write for &'_ mut W`
`[src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `fn borrow_mut(&mut self) -> &mut Tⓘ

### Notable traits for &'_ mut F

`impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<R: Read + ?Sized, '_> Read for &'_ mut Rimpl<W: Write + ?Sized, '_> Write for &'_ mut W`
`[src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.