Initializes the netcode.io library runtime. This should be called before any additional functions in this library. Throws an IOException on failure.

Terminates the netcode.io library runtime. This should be called only after all other library functions terminate.

An opaque type that encapsulates an address that can be used with netcode.io. The address may be stored in memory in different ways (for example with encryption), and therefore needs the IO monad to interact with it.

TODO: Use a high-level representation here to enable a more pure interface.

The address mode based on how the address is represented. Usually a consequence of how it was parsed.

Returns the address mode for the given address. Note, this address may be stored in memory in different ways, so we must inspect the memory contents in order to retreive the addressing mode.

Returns the port associated with this address.

Returns the address as a sequence of values in its human readable format. For example:

>>> parseAddress "123.231.132.213" >>= addressValues
[123, 231, 132, 213]

The length of the list is either 4 or 8 depending on the address mode. If the address mode is unknown, addressValues returns the empty list.

Returns an address with the given values interpreted using the given mode. For IPv4 addresses, only the bottom 8 bits of each 16-bit word will be used. The list will be zero padded to contain enough values to fill the address as needed.

Takes a String and parses it to create an Address. The string should be formatted as either a valid IPv4 or IPv6 address. It does not, however, support dual address modes.

Returns a string that represents the given Address.

Returns True if two addresses are equal by examining their memory contents.

Override that sends a packet to the given address. This can be used by both clients and servers. This is invoked after netcode.io processes and encrypts the packet.

Override that receives a packet from the given address. This can be used by both clients and servers. This is invoked before netcode.io processes and decrypts the packet data.

Implementations of this callback are meant to fill the memory at the given pointer with the data from a packet received from the Address. The maximum size of the buffer pointed to is also passed and the implementation is expected to return the actual size of the packet. In the event that there is no packet (or equivalently, no packet data), then the implementation should return zero.

A packet is a basic unit of data that is transferred between client and server. Sequence numbers indicate the order in which the packets were sent, and this library contains no guarantee that they will be received in a monotonically increasing order.

The maximum size, in bytes, of a packet. In other words, this is the maximum value that packetSize can take.

A client-specific callback that gets invoked each time the underlying state of the client changes.

A ClientConfig is a type that specifies the behavior of a Client. Client configs are pretty spartan: the only options available at this time are setting callbacks.

A ClientConfig with no callback overrides.

Creates a config that removes the existing ClientStateChangeCallback and instead uses the given callback.

Clears the ClientStateChangeCallback for the given config.

Removes the existing send and receive overrides for the given config, if set, and instead uses the ones given.

Changes the config to use the default send and receive packet functions.

A client object. This is an opaque type meant to be used in conjunction with this library.

A Client is generally meant to connect to one of potentially many servers through a ConnectToken. The main loop of the application that manages the lifetime of the client is expected to maintain a running timer with a resolution of at least seconds. This main loop is also expected to call updateClient on a regular basis to allow the library to process incoming packets and send outgoing packets.

Creates a client at the given address using the provided config. Throws an IOException on failure.

Note, the address used here can be either formatted as an IPv4 address or an IPv6 address, similar to the arguments passed to parseAddress. In the common case, you will likely want to use INADDR_ANY to bind to the underlying socket, which is represented by the address "0.0.0.0"

The time passed to this create function should be a measurement in seconds, such that when connecting in the future using updateClient, the same resolution timer is being passed. That allows the library to properly timeout in cases where connections are taking too long to establish.

Destroys the client and frees all of the Haskell-side function pointers that were registered as callbacks.

Generates a random 64-bit client ID to be used with generateConnectToken

Begin the process to connect the client to a server stored in the given ConnectToken. This does not connect the client immediately, but rather resets the client object and sets the state to ClientState'SendingConnectionRequest. The client will attempt to connect on the next call to updateClient.

Disconnects the client from anything it might be connected to.

Main processing call for clients with the current time in seconds (in the same domain as the time passed to createClient). This flushes packet queues at the appropriate rate and updates connection statuses among other things. It is expected to be called in the main loop of the application.

Enqueues a packet to be sent during the next call to updateClient.

Dequeues a received packet from the Server. This function returns a Just until the queue is empty, upon which it will return Nothing.

Returns the sequence number of the next packet that the Client will send.

Returns the port assigned to this Client.

Performs an action with the address of the server to which the given Client is connected to. This is meant to minimize the chances that the Address value will be used in a manner that outlives the given Client. Callers should avoid storing the Address value or returning it as a result of this function.

In the event that the client is not connected to a server, the address passed to the action will be 0.0.0.0.

The possible connection states of a Client. The default state is ClientState'Disconnected.

Returns the current state of the Client.

Returns true if the Client is in a state considered to be disconnected, as opposed to connected or connecting.

A ConnectToken represents an encrypted set of data fields that describe both the client requesting to make a connection and the available servers to which that connection can be made. It is generated solely via the

Returns the maximum number of servers that can be stored in a ConnectToken.

Gives the maximum size, in bytes, of user data stored in a ConnectToken.

Returns the number of bytes expected in the private key used to generate a ConnectToken

Creates a connect token for the given client (by clientID) with the list of associated addresses. User data may be at most maximumUserDataSize values, otherwise is truncated or zero-padded to fill. The list of public and internal servers must not be empty and may contain at most maximumServersPerConnect values, otherwise is truncated. Throws an IOException on failure.

A server-specific callback that gets invoked each time a client either connects to, or disconnects from, the server.

A ServerConfig is a type that specifies the behavior of a Server and contains associated metadata.

At a minimum, the connection protocol ID and the private key for the application should be set for each server (via setProtocolID and setPrivateKey, respectively).

The default ServerConfig contains no callbacks or overrides, and contains empty values for the required fields needed to properly have a server respond to a connecting Client.

Sets the connection protocol ID used by this Server. This is a unique ID that must match the protocol ID used in generateConnectToken

Sets the private key used by this Server. This key must match the private key used in generateConnectToken

Replaces the existing ServerConnectDisconnectCallback with the given one and frees any associated memory that may be allocated for the the existing callback.

Removes the existing ServerConnectDisconnectCallback and frees any associated memory that may be allocated for the the existing callback.

Removes the existing send and receive overrides for the given config, if set, and instead uses the ones given.

Changes the config to use the default send and receive packet functions.

A server object. This is an opaque type meant to be used in conjunction with this library.

A server is generally meant to represent and endpoint for one or more Clients to connect to. The server application is similar to that of the client in that it is expected to have a running timer with a resolution of at least seconds. The main loop of the server application is meant to call updateServer to allow the library to process incoming packets and send outgoing packets to the clients.

Creates a server at the given address using the provided config. Throws an IOException on failure.

Note, the address used here can be either formatted as an IPv4 address or an IPv6 address, similar to the arguments passed to parseAddress. In the common case, you will likely want to use INADDR_ANY to bind to the underlying socket, which is represented by the address "0.0.0.0"

The time passed to this create function should be a measurement in seconds, such that when connecting in the future using updateServer, the same resolution timer is being passed. That allows the library to properly timeout in cases where connections are taking too long to establish.

Destroys the server object and frees the associated Haskell-side callbacks and overrides

Starts the server and specifies the maximum number of clients that can connect. Emits a warning when the maximum number of clients is more than maxNumClients.

Returns the maximum number of clients that a server can support.

Stops the server.

Main processing call for a Server with the current time in seconds (in the same domain as the time passed to createServer). This flushes packet queues at the appropriate rate and updates connection statuses among other things. It is expected to be called in the main loop of the application.

Returns True if the client at the given client index is connected to the server. Returns False if not connected, if the server is not running, or if the client index is out of bounds.

Returns the client ID of the client at the given client index. Returns 0 if not connected, the server is not running, or if the client index is out of bounds.

Performs an action with the address of the client to which the given Server is connected to. This is meant to minimize the chances that the Address value will be used in a manner that outlives the given Server or the connection lifetime of the client. Callers should avoid storing the Address value or returning it as a result of this function.

In the event that the client index is out of bounds, or the client is not connected at that slot, the address passed to the action will be 0.0.0.0.

Performs an action with the user data of the client to which the given Server is connected to. This is meant to minimize the chances that the memory buffer will be used in a manner that outlives the given Server or the connection lifetime of the client. Callers should avoid storing the Ptr value or returning it as a result of this function.

In the event that the client index is out of bounds, or the client is not connected at that slot, the given action will receive nullPtr.

Returns the user data for the client connected at the given client index.

In the event that the client index is out of bounds, or the client is not connected at that slot, the result will be the empty list.

Returns the maximum number of clients that can connect to this server, or zero if the server has not been started yet (via a call to startServer).

Returns the number of currently connected clients.

Returns True if the server has been started, and is ready to accept incoming connections from clients.

Returns true if the number of connected clients matches the maximum number of possibly connected clients.

Returns the port assigned to the server's IP address.

Enqueues a packet to be sent to the client at the given index during the next call to updateServer.

Enqueues a packet with the given size and data to all connected clients.

Disconnects the client at the given index from the server.

Disconnects all clients from the server.

Dequeues a received packet from the Client at the given client index. This function returns a Just until the queue is empty, upon which it will return a Nothing.

Returns the next sequence number of a packet destined for the client at the given client index.

Sleep the current thread. This is usually only used in example programs. It's probably safer to use the built-in threadDelay.

Specifies the logging behavior of netcode.io. Note, this logging behavior is called from C calls to printf and therefore might interfere with the Haskell runtime (such as putStrLn).

Set the netcode.io LogLevel. The default is LogLevel'None.