# Networking

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.

Note

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

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

### Server

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    }
     3}
     4
     5int main() {
     6    loop = uv_default_loop();
     7
     8    uv_tcp_t server;
     9    uv_tcp_init(loop, &server);
    10
    11    uv_ip4_addr("0.0.0.0", DEFAULT_PORT, &addr);
    12
    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);
    20}

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

Note

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

     1
     2    free(buf->base);
     3}
     4
     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    }
    11
    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.

### Client

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("127.0.0.1", 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.

## UDP

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.

Note

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

     1
     2uv_loop_t *loop;
     3uv_udp_t send_socket;
     4uv_udp_t recv_socket;
     5
     6
     7int main() {
     8    loop = uv_default_loop();
     9
    10    uv_udp_init(loop, &recv_socket);
    11    struct sockaddr_in recv_addr;
    12    uv_ip4_addr("0.0.0.0", 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);
    15
    16    uv_udp_init(loop, &send_socket);
    17    struct sockaddr_in broadcast_addr;
    18    uv_ip4_addr("0.0.0.0", 0, &broadcast_addr);
    19    uv_udp_bind(&send_socket, (const struct sockaddr *)&broadcast_addr, 0);
    20    uv_udp_set_broadcast(&send_socket, 1);
    21
    22    uv_udp_send_t send_req;
    23    uv_buf_t discover_msg = make_discover_msg();
    24
    25    struct sockaddr_in send_addr;
    26    uv_ip4_addr("255.255.255.255", 67, &send_addr);
    27    uv_udp_send(&send_req, &send_socket, &discover_msg, 1, (const struct sockaddr *)&send_addr, on_send);
    28
    29    return uv_run(loop, UV_RUN_DEFAULT);
    30}

Note

The IP address `0.0.0.0` is used to bind to all interfaces. The IP address `255.255.255.255` 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    }
     8
     9    char sender[17] = { 0 };
    10    uv_ip4_name((const struct sockaddr_in*) addr, sender, 16);
    11    fprintf(stderr, "Recv from %s\n", sender);
    12
    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]);
    21
    22    free(buf->base);
    23    uv_udp_recv_stop(req);
    24}

### UDP Options

#### Time-to-live

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

#### Multicast

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 Libera.chat to see an example of DNS resolution.

dns/main.c

     1
     2int main() {
     3    loop = uv_default_loop();
     4
     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;
    10
    11    uv_getaddrinfo_t resolver;
    12    fprintf(stderr, "irc.libera.chat is... ");
    13    int r = uv_getaddrinfo(loop, &resolver, on_resolved, "irc.libera.chat", "6667", &hints);
    14
    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);
    20}

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.

dns/main.c

     1
     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    }
     7
     8    char addr[17] = {'\0'};
     9    uv_ip4_name((struct sockaddr_in*) res->ai_addr, addr, 16);
    10    fprintf(stderr, "%s\n", addr);
    11
    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);
    15
    16    uv_tcp_connect(connect_req, socket, (const struct sockaddr*) res->ai_addr, on_connect);
    17
    18    uv_freeaddrinfo(res);
    19}

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.

interfaces/main.c

     1#include <stdio.h>
     2#include <uv.h>
     3
     4int main() {
     5    char buf[512];
     6    uv_interface_address_t *info;
     7    int count, i;
     8
     9    uv_interface_addresses(&info, &count);
    10    i = count;
    11
    12    printf("Number of interfaces: %d\n", count);
    13    while (i--) {
    14        uv_interface_address_t interface_a = info[i];
    15
    16        printf("Name: %s\n", interface_a.name);
    17        printf("Internal? %s\n", interface_a.is_internal ? "Yes" : "No");
    18
    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        }
    27
    28        printf("\n");
    29    }
    30
    31    uv_free_interface_addresses(info, count);
    32    return 0;
    33}

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

[1]

https://beej.us/guide/bgnet/html/#broadcast-packetshello-world

[2]

https://www.tldp.org/HOWTO/Multicast-HOWTO-6.html#ss6.1

[3]

libuv use the system `getaddrinfo` in the libuv threadpool. libuv v0.8.0 and earlier also included c-ares as an alternative, but this has been removed in v0.9.0.