Networking in libuv is not much different from directly using the BSD socket interface, some things are easier, all are non-blocking, but the concepts stay the same. In addition libuv offers utility functions to abstract the annoying, repetitive and low-level tasks like setting up sockets using the BSD socket structures, DNS lookup, and tweaking various socket parameters.

The uv_tcp_t and uv_udp_t structures are used for network I/O.


The code samples in this chapter exist to show certain libuv APIs. They are not examples of good quality code. They leak memory and don’t always close connections properly.


TCP is a connection oriented, stream protocol and is therefore based on the libuv streams infrastructure.


Server sockets proceed by:

  1. uv_tcp_init the TCP handle.

  2. uv_tcp_bind it.

  3. Call uv_listen on the handle to have a callback invoked whenever a new connection is established by a client.

  4. Use uv_accept to accept the connection.

  5. Use stream operations to communicate with the client.

Here is a simple echo server

tcp-echo-server/main.c - The listen socket

 1        uv_close((uv_handle_t*) client, on_close);
 2    }
 5int main() {
 6    loop = uv_default_loop();
 8    uv_tcp_t server;
 9    uv_tcp_init(loop, &server);
11    uv_ip4_addr("", DEFAULT_PORT, &addr);
13    uv_tcp_bind(&server, (const struct sockaddr*)&addr, 0);
14    int r = uv_listen((uv_stream_t*) &server, DEFAULT_BACKLOG, on_new_connection);
15    if (r) {
16        fprintf(stderr, "Listen error %s\n", uv_strerror(r));
17        return 1;
18    }
19    return uv_run(loop, UV_RUN_DEFAULT);

You can see the utility function uv_ip4_addr being used to convert from a human readable IP address, port pair to the sockaddr_in structure required by the BSD socket APIs. The reverse can be obtained using uv_ip4_name.


There are uv_ip6_* analogues for the ip4 functions.

Most of the setup functions are synchronous since they are CPU-bound. uv_listen is where we return to libuv’s callback style. The second arguments is the backlog queue – the maximum length of queued connections.

When a connection is initiated by clients, the callback is required to set up a handle for the client socket and associate the handle using uv_accept. In this case we also establish interest in reading from this stream.

tcp-echo-server/main.c - Accepting the client

 2    free(buf->base);
 5void on_new_connection(uv_stream_t *server, int status) {
 6    if (status < 0) {
 7        fprintf(stderr, "New connection error %s\n", uv_strerror(status));
 8        // error!
 9        return;
10    }
12    uv_tcp_t *client = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));
13    uv_tcp_init(loop, client);
14    if (uv_accept(server, (uv_stream_t*) client) == 0) {
15        uv_read_start((uv_stream_t*) client, alloc_buffer, echo_read);
16    }

The remaining set of functions is very similar to the streams example and can be found in the code. Just remember to call uv_close when the socket isn’t required. This can be done even in the uv_listen callback if you are not interested in accepting the connection.


Where you do bind/listen/accept on the server, on the client side it’s simply a matter of calling uv_tcp_connect. The same uv_connect_cb style callback of uv_listen is used by uv_tcp_connect. Try:

uv_tcp_t* socket = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
uv_tcp_init(loop, socket);

uv_connect_t* connect = (uv_connect_t*)malloc(sizeof(uv_connect_t));

struct sockaddr_in dest;
uv_ip4_addr("", 80, &dest);

uv_tcp_connect(connect, socket, (const struct sockaddr*)&dest, on_connect);

where on_connect will be called after the connection is established. The callback receives the uv_connect_t struct, which has a member .handle pointing to the socket.


The User Datagram Protocol offers connectionless, unreliable network communication. Hence libuv doesn’t offer a stream. Instead libuv provides non-blocking UDP support via the uv_udp_t handle (for receiving) and uv_udp_send_t request (for sending) and related functions. That said, the actual API for reading/writing is very similar to normal stream reads. To look at how UDP can be used, the example shows the first stage of obtaining an IP address from a DHCP server – DHCP Discover.


You will have to run udp-dhcp as root since it uses well known port numbers below 1024.

udp-dhcp/main.c - Setup and send UDP packets

 2uv_loop_t *loop;
 3uv_udp_t send_socket;
 4uv_udp_t recv_socket;
 7int main() {
 8    loop = uv_default_loop();
10    uv_udp_init(loop, &recv_socket);
11    struct sockaddr_in recv_addr;
12    uv_ip4_addr("", 68, &recv_addr);
13    uv_udp_bind(&recv_socket, (const struct sockaddr *)&recv_addr, UV_UDP_REUSEADDR);
14    uv_udp_recv_start(&recv_socket, alloc_buffer, on_read);
16    uv_udp_init(loop, &send_socket);
17    struct sockaddr_in broadcast_addr;
18    uv_ip4_addr("", 0, &broadcast_addr);
19    uv_udp_bind(&send_socket, (const struct sockaddr *)&broadcast_addr, 0);
20    uv_udp_set_broadcast(&send_socket, 1);
22    uv_udp_send_t send_req;
23    uv_buf_t discover_msg = make_discover_msg();
25    struct sockaddr_in send_addr;
26    uv_ip4_addr("", 67, &send_addr);
27    uv_udp_send(&send_req, &send_socket, &discover_msg, 1, (const struct sockaddr *)&send_addr, on_send);
29    return uv_run(loop, UV_RUN_DEFAULT);


The IP address is used to bind to all interfaces. The IP address is a broadcast address meaning that packets will be sent to all interfaces on the subnet. port 0 means that the OS randomly assigns a port.

First we setup the receiving socket to bind on all interfaces on port 68 (DHCP client) and start a read on it. This will read back responses from any DHCP server that replies. We use the UV_UDP_REUSEADDR flag to play nice with any other system DHCP clients that are running on this computer on the same port. Then we setup a similar send socket and use uv_udp_send to send a broadcast message on port 67 (DHCP server).

It is necessary to set the broadcast flag, otherwise you will get an EACCES error [1]. The exact message being sent is not relevant to this book and you can study the code if you are interested. As usual the read and write callbacks will receive a status code of < 0 if something went wrong.

Since UDP sockets are not connected to a particular peer, the read callback receives an extra parameter about the sender of the packet.

nread may be zero if there is no more data to be read. If addr is NULL, it indicates there is nothing to read (the callback shouldn’t do anything), if not NULL, it indicates that an empty datagram was received from the host at addr. The flags parameter may be UV_UDP_PARTIAL if the buffer provided by your allocator was not large enough to hold the data. In this case the OS will discard the data that could not fit (That’s UDP for you!).

udp-dhcp/main.c - Reading packets

 1void on_read(uv_udp_t *req, ssize_t nread, const uv_buf_t *buf, const struct sockaddr *addr, unsigned flags) {
 2    if (nread < 0) {
 3        fprintf(stderr, "Read error %s\n", uv_err_name(nread));
 4        uv_close((uv_handle_t*) req, NULL);
 5        free(buf->base);
 6        return;
 7    }
 9    char sender[17] = { 0 };
10    uv_ip4_name((const struct sockaddr_in*) addr, sender, 16);
11    fprintf(stderr, "Recv from %s\n", sender);
13    // ... DHCP specific code
14    unsigned int *as_integer = (unsigned int*)buf->base;
15    unsigned int ipbin = ntohl(as_integer[4]);
16    unsigned char ip[4] = {0};
17    int i;
18    for (i = 0; i < 4; i++)
19        ip[i] = (ipbin >> i*8) & 0xff;
20    fprintf(stderr, "Offered IP %d.%d.%d.%d\n", ip[3], ip[2], ip[1], ip[0]);
22    free(buf->base);
23    uv_udp_recv_stop(req);

UDP Options#


The TTL of packets sent on the socket can be changed using uv_udp_set_ttl.

IPv6 stack only#

IPv6 sockets can be used for both IPv4 and IPv6 communication. If you want to restrict the socket to IPv6 only, pass the UV_UDP_IPV6ONLY flag to uv_udp_bind.


A socket can (un)subscribe to a multicast group using:

where membership is UV_JOIN_GROUP or UV_LEAVE_GROUP.

The concepts of multicasting are nicely explained in this guide.

Local loopback of multicast packets is enabled by default [2], use uv_udp_set_multicast_loop to switch it off.

The packet time-to-live for multicast packets can be changed using uv_udp_set_multicast_ttl.

Querying DNS#

libuv provides asynchronous DNS resolution. For this it provides its own getaddrinfo replacement [3]. In the callback you can perform normal socket operations on the retrieved addresses. Let’s connect to to see an example of DNS resolution.


 2int main() {
 3    loop = uv_default_loop();
 5    struct addrinfo hints;
 6    hints.ai_family = PF_INET;
 7    hints.ai_socktype = SOCK_STREAM;
 8    hints.ai_protocol = IPPROTO_TCP;
 9    hints.ai_flags = 0;
11    uv_getaddrinfo_t resolver;
12    fprintf(stderr, " is... ");
13    int r = uv_getaddrinfo(loop, &resolver, on_resolved, "", "6667", &hints);
15    if (r) {
16        fprintf(stderr, "getaddrinfo call error %s\n", uv_err_name(r));
17        return 1;
18    }
19    return uv_run(loop, UV_RUN_DEFAULT);

If uv_getaddrinfo returns non-zero, something went wrong in the setup and your callback won’t be invoked at all. All arguments can be freed immediately after uv_getaddrinfo returns. The hostname, servname and hints structures are documented in the getaddrinfo man page. The callback can be NULL in which case the function will run synchronously.

In the resolver callback, you can pick any IP from the linked list of struct addrinfo(s). This also demonstrates uv_tcp_connect. It is necessary to call uv_freeaddrinfo in the callback.


 2void on_resolved(uv_getaddrinfo_t *resolver, int status, struct addrinfo *res) {
 3    if (status < 0) {
 4        fprintf(stderr, "getaddrinfo callback error %s\n", uv_err_name(status));
 5        return;
 6    }
 8    char addr[17] = {'\0'};
 9    uv_ip4_name((struct sockaddr_in*) res->ai_addr, addr, 16);
10    fprintf(stderr, "%s\n", addr);
12    uv_connect_t *connect_req = (uv_connect_t*) malloc(sizeof(uv_connect_t));
13    uv_tcp_t *socket = (uv_tcp_t*) malloc(sizeof(uv_tcp_t));
14    uv_tcp_init(loop, socket);
16    uv_tcp_connect(connect_req, socket, (const struct sockaddr*) res->ai_addr, on_connect);
18    uv_freeaddrinfo(res);

libuv also provides the inverse uv_getnameinfo.

Network interfaces#

Information about the system’s network interfaces can be obtained through libuv using uv_interface_addresses. This simple program just prints out all the interface details so you get an idea of the fields that are available. This is useful to allow your service to bind to IP addresses when it starts.


 1#include <stdio.h>
 2#include <uv.h>
 4int main() {
 5    char buf[512];
 6    uv_interface_address_t *info;
 7    int count, i;
 9    uv_interface_addresses(&info, &count);
10    i = count;
12    printf("Number of interfaces: %d\n", count);
13    while (i--) {
14        uv_interface_address_t interface_a = info[i];
16        printf("Name: %s\n",;
17        printf("Internal? %s\n", interface_a.is_internal ? "Yes" : "No");
19        if (interface_a.address.address4.sin_family == AF_INET) {
20            uv_ip4_name(&interface_a.address.address4, buf, sizeof(buf));
21            printf("IPv4 address: %s\n", buf);
22        }
23        else if (interface_a.address.address4.sin_family == AF_INET6) {
24            uv_ip6_name(&interface_a.address.address6, buf, sizeof(buf));
25            printf("IPv6 address: %s\n", buf);
26        }
28        printf("\n");
29    }
31    uv_free_interface_addresses(info, count);
32    return 0;

is_internal is true for loopback interfaces. Note that if a physical interface has multiple IPv4/IPv6 addresses, the name will be reported multiple times, with each address being reported once.