package eio
Install
Dune Dependency
Authors
Maintainers
Sources
sha256=807ecef337dda849b05d3dbd17a928e6f5c636e76eb15e2213667c91127718a7
sha512=8f055aec34c9347eed2cbaa4ee439399bbe3d6a546f2c2b52e27f733fe822f4acdee3e00e4e64ae3eb922c2772535952f8e81b546802fe945fd32d3fab88b7b9
doc/eio/Eio/Net/index.html
Module Eio.Net
Source
Network sockets and addresses.
Example:
let addr = `Tcp (Ipaddr.V4.loopback, 8080)
let http_get ~net ~stdout addr =
Switch.run @@ fun sw ->
let flow = Net.connect ~sw net addr in
Flow.copy_string "GET / HTTP/1.0\r\n\r\n" flow;
Flow.shutdown flow `Send;
Flow.copy flow stdout
type error =
| Connection_reset of Exn.Backend.t
(*This is a wrapper for epipe, econnreset and similar errors. It indicates that the flow has failed, and data may have been lost.
*)| Connection_failure of connection_failure
Types
type 'tag stream_socket_ty = [
| `Stream
| `Platform of 'tag
| `Shutdown
| socket_ty
| Flow.source_ty
| Flow.sink_ty
]
A _ connection_handler
handles incoming connections from a listening socket.
Out-bound Connections
connect ~sw t addr
is a new socket connected to remote address addr
.
The new socket will be closed when sw
finishes, unless closed manually first.
val with_tcp_connect :
?timeout:Time.Timeout.t ->
host:string ->
service:string ->
[> 'tag ty ] Std.r ->
('tag stream_socket_ty Std.r -> 'b) ->
'b
with_tcp_connect ~host ~service t f
creates a tcp connection conn
to host
and service
and executes f conn
.
conn
is closed after f
returns (if it isn't already closed by then).
host
is either an IP address or a domain name, eg. "www.example.org", "www.ocaml.org" or "127.0.0.1".
service
is an IANA recognized service name or port number, eg. "http", "ftp", "8080" etc. See https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml.
Addresses are tried in the order they are returned by getaddrinfo
, until one succeeds.
Incoming Connections
val listen :
?reuse_addr:bool ->
?reuse_port:bool ->
backlog:int ->
sw:Switch.t ->
[> 'tag ty ] Std.r ->
Sockaddr.stream ->
'tag listening_socket_ty Std.r
listen ~sw ~backlog t addr
is a new listening socket bound to local address addr
.
The new socket will be closed when sw
finishes, unless closed manually first.
On platforms that support this, passing port 0
will bind to a random port.
For (non-abstract) Unix domain sockets, the path will be removed afterwards.
val accept :
sw:Switch.t ->
[> 'tag listening_socket_ty ] Std.r ->
'tag stream_socket_ty Std.r * Sockaddr.stream
accept ~sw socket
waits until a new connection is ready on socket
and returns it.
The new socket will be closed automatically when sw
finishes, if not closed earlier. If you want to handle multiple connections, consider using accept_fork
instead.
val accept_fork :
sw:Switch.t ->
[> 'tag listening_socket_ty ] Std.r ->
on_error:(exn -> unit) ->
[< 'tag stream_socket_ty ] connection_handler ->
unit
accept_fork ~sw ~on_error socket fn
accepts a connection and handles it in a new fiber.
After accepting a connection to socket
, it runs fn flow client_addr
in a new fiber.
flow
will be closed when fn
returns. The new fiber is attached to sw
.
If you don't want to handle connection errors, use ~on_error:raise
to cancel the caller's context.
on_error
is not called for Cancel.Cancelled
exceptions, which do not need to be reported.
Running Servers
val run_server :
?max_connections:int ->
?additional_domains:(_ Domain_manager.t * int) ->
?stop:'a Promise.t ->
on_error:(exn -> unit) ->
[> 'tag listening_socket_ty ] Std.r ->
[< 'tag stream_socket_ty ] connection_handler ->
'a
run_server ~on_error sock connection_handler
establishes a concurrent socket server s
.
It accepts incoming client connections on socket sock
and handles them with accept_fork
(see that for the description of on_error
and connection_handler
).
Running a Parallel Server
By default s
runs on a single OCaml Domain
. However, if additional_domains:(domain_mgr, domains)
parameter is given, then s
will spawn domains
additional domains and run accept loops in those too. In such cases you must ensure that connection_handler
only accesses thread-safe values. Note that having more than Domain.recommended_domain_count
domains in total is likely to result in bad performance.
Datagram Sockets
val datagram_socket :
?reuse_addr:bool ->
?reuse_port:bool ->
sw:Switch.t ->
[> 'tag ty ] Std.r ->
[< Sockaddr.datagram | `UdpV4 | `UdpV6 ] ->
'tag datagram_socket_ty Std.r
datagram_socket ~sw t addr
creates a new datagram socket bound to addr
. The new socket will be closed when sw
finishes.
`UdpV4
and `UdpV6
represents IPv4 and IPv6 datagram client sockets where the OS assigns the next available socket address and port automatically. `Udp ..
can be used to create both listening server socket and client socket.
send sock buf
sends the data in buf
using the the datagram socket sock
.
recv sock buf
receives data from the socket sock
putting it in buf
. The number of bytes received is returned along with the sender address and port. If the buf
is too small then excess bytes may be discarded depending on the type of the socket the message is received from.
DNS queries
getaddrinfo ?service t node
returns a list of IP addresses for node
. node
is either a domain name or an IP address.
For a more thorough treatment, see getaddrinfo.
getaddrinfo_stream
is like getaddrinfo
, but filters out non-stream protocols.
getaddrinfo_datagram
is like getaddrinfo
, but filters out non-datagram protocols.
getnameinfo t sockaddr
is (hostname, service)
corresponding to sockaddr
. hostname
is the registered domain name represented by sockaddr
. service
is the IANA specified textual name of the port specified in sockaddr
, e.g. 'ftp', 'http', 'https', etc.
Closing
Alias of Resource.close
.