C Network Programming Reference

The transport layer protocol provides end-to-end connection between a source and a destination computer, and it is responsible for features such as reliability, flow control or multiplexing, for example. The transport layer is the 4th layer in the OSI model.

There are two¹ main transport protocols: Transmission Control Protocol (TCP)² and User Datagram Protocol (UDP)³.

TCP is connection-oriented, meaning that the sender and receiver need to establish a connection before communicating. The server must be listening for connection requests from clients before a connection is established.

UDP is a connectionless protocol, meaning that messages are sent without establishing a connection, and that UDP doesn’t keep track of what it has sent. UDP is suitable for purposes where error checking and correction are either not necessary or are performed in the application.

An Internet Protocol address is a numerical label that is assigned to a device connected to a computer network that uses the Internet Protocol for communication.

Internet Protocol version 4 (IPv4) was the first standalone specification for the IP address, and it defined the addresses as 32-bit numbers such as 192.168.2.123. As the internet grew, Internet Protocol version 6 (IPv6) started being used, which uses uses 128-bit addresses such as 2001:db8::8a2e:370:7334⁴.

In networking, a port is a number assigned to identify a connection endpoint; and usually, to identify a specific service in that endpoint. A port is always associated with a network address (such as an IP address) and the type of transport protocol used (such as TCP or UDP).

For example, when connecting to another computer through SSH, the client connects to port 22 in the server. The client uses that port number because it knows that the SSH server will be listening for connections on that specific port by convention.

A socket, more specifically a socket descriptor, is essentially a connection identifier used by the operating system for sending and receiving data. The term socket is commonly used in the networking context, but it’s also used for inter-process communication (IPC).

Sockets are created with the socket(2) function, which will be discussed bellow. The returned socket descriptor is essentially a file descriptor, just like the ones returned by open(2).

A socket address is used to externally identify sockets in other computers. The socket address contains the transport protocol, the IP address, and the port number.

The getaddrinfo function fills a linked list of addrinfo structures based on its arguments.

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

int getaddrinfo(const char* node,
                const char* service,
                const struct addrinfo* hints,
                struct addrinfo** res);

Here is a brief description of each parameter:

1. The node parameter is used to specify the target host. This is usually an IPv4 or IPv6 address⁶, but it can also be network hostname and it will be looked up and resolved. It can also be NULL, as we will see when doing a passive open below.
2. The service parameter is a string used to specify the target service. The string usually contains the target port as a decimal number, but it can also be a service name (such as “ftp” or “http”) which will be translated to the port number according to the services(5) file.
3. The hints parameter is an addrinfo structure containing some hints about the type of information we want to receive. Note that unused members this hints structure must be set to zero, so a call to memset is convenient after the definition.
4. The res parameter is a pointer to another addrinfo pointer, and the function will use it to build a linked list of addrinfo structures. The pointer that res points to should be freed by the caller with the freeaddrinfo function.

The getaddrinfo function returns 0 on success, or non-zero on error. The error codes returned by this function can be converted to a human-readable string with gai_strerror. The linked filled by getaddrinfo (the last argument) must be freed by the caller using freeaddrinfo.

Different members of the addrinfo will be used throughout this article, so here is the structure definition from <netdb.h>:

#include <sys/socket.h>

struct addrinfo {
    int ai_flags;             /* Input flags */
    int ai_family;            /* Protocol family for socket */
    int ai_socktype;          /* Socket type */
    int ai_protocol;          /* Protocol for socket */
    socklen_t ai_addrlen;     /* Length of socket address */
    struct sockaddr* ai_addr; /* Socket address for socket */
    char* ai_canonname;       /* Canonical name for service location */
    struct addrinfo* ai_next; /* Pointer to next in list */
};

The sockaddr structure is defined in <sys/socket.h, contains useful information about the socket address. However, since its members are a bit abstract, this sockaddr structure is usually casted to a sockaddr_in or sockaddr_in6 structure (depending on whether it’s an IPv4 or IPv6 address, respectively), both defined in <netinet/in.h>⁷.

#include <netinet/in.h>

struct sockaddr_in {
    sa_family_t     sin_family;     /* AF_INET */
    in_port_t       sin_port;       /* Port number */
    struct in_addr  sin_addr;       /* IPv4 address */
};

struct sockaddr_in6 {
    sa_family_t     sin6_family;    /* AF_INET6 */
    in_port_t       sin6_port;      /* Port number */
    uint32_t        sin6_flowinfo;  /* IPv6 flow info */
    struct in6_addr sin6_addr;      /* IPv6 address */
    uint32_t        sin6_scope_id;  /* Set of interfaces for a scope */
};

struct in_addr {
    in_addr_t s_addr;
};

struct in6_addr {
    uint8_t   s6_addr[16];
};

typedef uint32_t in_addr_t;
typedef uint16_t in_port_t;

The following example shows a call to getaddrinfo, although more specific examples will be shown below. Remember to check the value returned by getaddrinfo, and to free the linked list of addrinfo structures with freeaddrinfo after you are done using it.

struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family   = AF_INET;     /* IPv4 */
hints.ai_socktype = SOCK_STREAM; /* TCP */

struct addrinfo* server_info;
const int status = getaddrinfo(ip, port, &hints, &server_info);
if (status != 0) {
    fprintf(stderr, "Error: %s\n", gai_strerror(status));
    abort();
}

/* ... */

freeaddrinfo(server_info);

We can then use the members of the filled server_info to create the socket. Remember to check the value returned by socket, and to close the socket descriptor after you are done using it.

const int sockfd = socket(server_info->ai_family,
                          server_info->ai_socktype,
                          server_info->ai_protocol);
if (sockfd < 0) {
    fprintf(stderr, "Could not create socket: %s\n", strerror(errno));
    abort();
}

/* ... */

close(sockfd);

These are the general steps for establishing a connection through a passive open:

1. Obtain a socket descriptor, used for listening.
2. Bind a local port to the socket descriptor.
3. Start to listen on that socket descriptor.
4. Wait for connections, and accept them.

These are the general steps for establishing a connection through an active open:

1. Obtain a socket descriptor with the server information.
2. Connect to the server.

Once a connection has been established, we can send and receive data through its socket descriptor. Most functions that operate on file descriptors, like read(2) and write(2), can work with socket descriptors too. However, it’s better to use recv(2) and send(2), even if we don’t specify any flags.

#include <sys/types.h>
#include <sys/socket.h>

ssize_t recv(int sockfd, void* buf, size_t len, int flags);
ssize_t send(int sockfd, const void* buf, size_t len, int flags);

The recv function is used to receive data into the specified buffer of size len. The send function is used to send a buffer of the specified size len.

The recv function returns:

• The number of bytes received, when the call was successful.
• Zero, when a stream socket peer has performed an orderly shutdown (the “end-of-file” indicator).
• Negative one (-1), if an error occurred. The errno variable is also set.

The send function returns:

• The number of bytes sent, when the call was successful.
• Negative one (-1), if an error occurred. The errno variable is also set.

Note how both functions return a signed size type (ssize_t), defined in the stddef.h header.