Module net/tcp

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 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.

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.

Close the stream.

Get the underlying file descriptor.

Release the resources self owns — a file descriptor, a socket, a lock, a buffer the allocator handed out. Called automatically when the last reference to the value goes away, so an implementor never calls it directly and must tolerate being the only one who ever does.

It must be safe to run exactly once: the runtime calls it at refcount zero, and a type that also exposes an explicit close/release is responsible for making the second call a no-op.

Connect to a remote address, returning a new TcpStream.

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.

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.

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.

Release the resources self owns — a file descriptor, a socket, a lock, a buffer the allocator handed out. Called automatically when the last reference to the value goes away, so an implementor never calls it directly and must tolerate being the only one who ever does.

It must be safe to run exactly once: the runtime calls it at refcount zero, and a type that also exposes an explicit close/release is responsible for making the second call a no-op.