Unit 1 · Chapter 3 · Book pp. 67–94

Sockets Introduction

Three of last year's eight questions came from this chapter alone. It is about one thing: how an address gets from something a person typed into something the kernel will accept — and how the length of that address travels alongside it.

Socket address structures

Most socket functions need a pointer to a socket address structure. Each protocol suite defines its own, and they all begin with sockaddr_ and end with a suffix naming the suite.

Click any field below to see what it is for. Switch structures with the buttons, and note the sizes: 16 bytes for IPv4, 28 for IPv6.

Why the generic structure exists

bind, connect and the rest were defined before ANSI C, so there was no void *. The problem: one function has to accept an IPv4 address, an IPv6 address or a Unix-domain address. The 4.2BSD solution was to define a generic socket address structure and declare every socket function to take a pointer to that.

struct sockaddr {
    uint8_t       sa_len;
    sa_family_t   sa_family;    /* address family: AF_xxx value */
    char          sa_data[14];  /* protocol-specific address */
};

The consequence you meet on every single call:

struct sockaddr_in  serv;

/* fill in serv{} */

connect(sockfd, (struct sockaddr *) &serv, sizeof(serv));

The book abbreviates that cast to SA, defined in unp.h:

#define SA struct sockaddr

connect(sockfd, (SA *) &serv, sizeof(serv));

The new generic structure

struct sockaddr is 16 bytes — too small for the 28-byte sockaddr_in6. So IPv6 brought struct sockaddr_storage, which differs from struct sockaddr in exactly two ways. Both are quotable:

The sin_len field

Value-result arguments

When a socket address structure is passed to any socket function it is always passed by reference — a pointer. The length of the structure is passed too. But how the length is passed depends on which direction the structure is travelling.

Switch direction below and step through. Watch what happens to len.

Direction 1 — process to kernel

struct sockaddr_in  serv;

/* fill in serv{} */

connect(sockfd, (SA *) &serv, sizeof(serv));
                                  ^^^^^^^^^^^^^ an integer, by value

Since the kernel is passed both the pointer and the size of what the pointer points to, it knows exactly how much data to copy from the process into the kernel. Nothing comes back. The size is a plain value argument.

Direction 2 — kernel to process

struct sockaddr_un  cli;     /* Unix domain */
socklen_t  len;

len = sizeof(cli);            /* len is a value */

getpeername(unixfd, (SA *) &cli, &len);
                                 ^^^^ a POINTER to an integer

/* len may have changed */

Fixed-length versus variable-length

Byte ordering functions

A 16-bit integer is two bytes. There are two ways to put those two bytes in memory, and there is no standard between them — you will meet systems that use each.

Change the value and the width below, and watch the same number take two different shapes in memory.

The four conversion functions

#include <netinet/in.h>

uint16_t  htons(uint16_t  host16bitvalue);
uint32_t  htonl(uint32_t  host32bitvalue);
                              Both return: value in network byte order

uint16_t  ntohs(uint16_t  net16bitvalue);
uint32_t  ntohl(uint32_t  net32bitvalue);
                              Both return: value in host byte order

Bit ordering in RFCs

An important convention in Internet standards, and a different thing from byte order. When an RFC draws a protocol header it shows the four bytes in the order in which they appear on the wire, with the leftmost bit the most significant. So reading an RFC diagram left-to-right, top-to-bottom gives you the exact order of bits on the cable.

Byte manipulation functions

Two groups of functions that operate on multi-byte fields without interpreting the data and without assuming it is a null-terminated C string. They are needed because an IP address can perfectly well contain a zero byte — 10.0.0.1 contains three — so the str functions from <string.h> would stop halfway through it.

#include <strings.h>

void bzero(void *dest, size_t n);
void bcopy(const void *src,
           void *dest, size_t n);
int  bcmp(const void *p1,
          const void *p2, size_t n);

#include <string.h>

void *memset(void *dest,
             int c, size_t n);
void *memcpy(void *dest,
             const void *src, size_t n);
int   memcmp(const void *p1,
             const void *p2, size_t n);

Address conversion functions

Two groups of functions convert between the two representations of an Internet address: the ASCII string a human prefers, and the network byte ordered binary value stored in a socket address structure.

The three IPv4-only functions

#include <arpa/inet.h>

int inet_aton(const char *strptr, struct in_addr *addrptr);
                         Returns: 1 if string was valid, 0 on error

in_addr_t inet_addr(const char *strptr);
       Returns: 32-bit binary network byte ordered IPv4 address;
                INADDR_NONE if error

char *inet_ntoa(struct in_addr inaddr);
       Returns: pointer to dotted-decimal string

The two that handle both protocols

#include <arpa/inet.h>

int inet_pton(int family, const char *strptr, void *addrptr);
       Returns: 1 if OK, 0 if input not a valid presentation format,
                -1 on error

const char *inet_ntop(int family, const void *addrptr,
                      char *strptr, size_t len);
       Returns: pointer to result if OK, NULL on error

Migrating old code

Even on a system with no IPv6 support you can start using the newer functions.

foo.sin_addr.s_addr = inet_addr(cp);

inet_pton(AF_INET, cp, &foo.sin_addr);

ptr = inet_ntoa(foo.sin_addr);

char str[INET_ADDRSTRLEN];
ptr = inet_ntop(AF_INET, &foo.sin_addr,
                str, sizeof(str));

sock_ntop and the readn/writen family

Two sets of helpers the book defines for itself. They are not standard, but the examples use them constantly, so you need to know what they do.