Module net/tcp

The listener, lent.

Yield the next item, or .None once the stream is finished.

Bind to a socket address and start listening.

Accept an incoming connection, returning a new TcpStream.

The future borrows the listener until it is awaited: the descriptor is read when the accept is submitted, so the listener cannot be dropped (closing it, and freeing the number for reuse) in between.

The connections arriving at this listener, as a Stream of Result(TcpStream, NetError) — Rust's TcpListener::incoming.

conns := listener.incoming().take(usize(3));
io.await(
  conns.for_each(c => {
    handle(c);
  }, io),
  io
);

Every std/async/stream combinator applies, and a function can be generic over where(S <: Stream) instead of over this listener.

The stream takes the listener (it is moved in): read its address first, or through Incoming.listener().

Get the local address this listener is bound to.

Close the listener socket.

Get the underlying file descriptor.

Connect to a remote address, returning a new TcpStream.

Write a str to the stream. Returns the number of bytes written.

Write a String to the stream. Returns the number of bytes written.

Write raw bytes from an ArrayList(u8) to the stream. Returns the number of bytes written.

Shut down part or all of the connection.

Close the stream.

Close the socket now, without the event loop: what Drop runs, for a caller that must release the descriptor from plain code before the stream itself goes away (a TLS stream's teardown, a connection pool's eviction). A no-op once the stream is closed. The destructor itself is never called by hand (E0915).

Get the remote peer's socket address.

Get this end's socket address — Rust's TcpStream::local_addr. Read from the kernel once, when the stream was connected or accepted, because that is the only way to learn the ephemeral port and the source interface the kernel chose; neither is in the connect argument.

Get the underlying file descriptor.

Enable or disable TCP_NODELAY (disables Nagle's algorithm).

Enable or disable SO_KEEPALIVE on the socket.

Read up to size bytes from the stream into buf, resolving to the number actually read. 0 — and only 0 — means the peer closed its end; a SHORT count is ordinary on a stream socket and says nothing about end-of-stream, so a caller that needs size bytes loops. Awaiting parks this task on the event loop until the kernel has bytes; a failure throws IoExn rather than resolving to a negative count.

buf must have room for size bytes, and raw pointers are unavailable in safe code, so calling this directly needs pragma(Pragma.AllowUnsafe). Safe code uses the Reader defaults (read_to_end, read_to_string) or wraps the stream in BufReader(TcpStream).

Write up to size raw bytes from buf, resolving to the number the kernel accepted — which may be LESS than size. A caller that must deliver everything loops, or takes the Writer trait's write_all. Awaiting parks this task until the socket is writable; a failure throws IoExn. Needs pragma(Pragma.AllowUnsafe) for the raw pointer — write_bytes / write_str / write_string are the safe spellings.