Beej's Guide to Network Programming Errata

getpeername(s, (struct sockaddr*)&addr, &len);
getpeername(s, (struct sockaddr*)&addr, &len);

inet_ntop(AF_INET, s->sin_addr, ipstr, sizeof ipstr);
inet_ntop(AF_INET, &s->sin_addr, ipstr, sizeof ipstr);

inet_ntop(AF_INET, s->sin6_addr, ipstr, sizeof ipstr);
inet_ntop(AF_INET, &s->sin6_addr, ipstr, sizeof ipstr);

} else { // AF_INET6
    [... snip ...]
    inet_ntop(AF_INET, &s->sin6_addr, ipstr, sizeof ipstr);
    inet_ntop(AF_INET6, &s->sin6_addr, ipstr, sizeof ipstr);

bind(s, (struct sockaddr*)myaddr, sizeof myaddr);
bind(s, (struct sockaddr*)&myaddr, sizeof myaddr);

// proper way of doing things with getaddrinfo()
// modern way of doing things with getaddrinfo()

[... snip ...]

// make a socket:
// (you should actually walk the "res" linked list and error-check!)

struct addrinfo *res;
struct addrinfo hints, *res;

// do the lookup
// [pretend we already filled out the "hints" struct]
getaddrinfo("www.example.com", "http", &hints, &res);

// [again, you should do error-checking on getaddrinfo(), and walk
// the "res" linked list looking for valid entries instead of just
// assuming the first one is good (like many of these examples do.)
// See the section on client/server for real examples.]

Section 3.1, "IP Addresses, versions 4 and 6" [book v3.0.7 p. 9]:

and was common written in "dots and numbers" form
and was commonly written in "dots and numbers" form

That we need not just twice as many address, not a billion times as many
That we need not just twice as many addresses, not a billion times as many

Section 9.2, "bind()" [book v3.0.7 p. 81]:

bind(s, (struct sockaddr*)myaddr, sizeof myaddr);
bind(s, (struct sockaddr*)&myaddr, sizeof myaddr);

bind(s, (struct sockaddr*)&myaddr, sizeof myaddr);
bind(s, (struct sockaddr*)&myaddr, sizeof myaddr);

byte_count = recvfrom(sockfd, buf, sizeof buf, 0, &addr, &fromlen);
byte_count = recvfrom(sockfd, buf, sizeof buf, 0, &addr, &fromlen);

FD_ZERO(&readfds);
FD_ZERO(&readfds);

FD_SET(s1, &readfds);
FD_SET(s1, &readfds);

FD_SET(s2, &readfds);
FD_SET(s2, &readfds);

rv = select(n, &readfds, NULL, NULL, &tv);
rv = select(n, &readfds, NULL, NULL, &tv);

if (FD_ISSET(s1, &readfds)) {
if (FD_ISSET(s1, &readfds)) {

if (FD_ISSET(s2, &readfds)) {
if (FD_ISSET(s2, &readfds)) {

send(stream_socket, &temp, sizeof temp, 0);
send(stream_socket, &temp, sizeof temp, 0);

sendto(dgram_socket, secret_message, strlen(secret_message)+1, 0,
       (struct sockaddr*)&dest, sizeof dest);
sendto(dgram_socket, secret_message, strlen(secret_message)+1, 0,
       (struct sockaddr*)&dest, sizeof dest);

The global variable errno is set to the error's value (see the perror()
man page.)

The global variable errno is set to the error's value (see the errno
man page for more details, and a quick note on using errno in
multithreaded programs.)

One thing to note, for you multithreading enthusiasts, is that on most systems
errno is defined in a threadsafe manner.  (That is, it's not actually a
global variable, but it behaves just like a global variable would in a
single-threaded environment.)

Section 6.3, "Datagram Sockets" [book v3.0.7 p 41]: type change in listener.c line 38:

size_t addr_len;
socklen_t addr_len;

Section 6.3, "select(): Synchronous I/O Multiplexing" [book v3.0.7 p XX]: added text:

This being said, in modern times select(), though very
portable, is one of the slowest methods for monitoring sockets.  One
possible alternative is libevent, or something similar, that
encapsulates all the system-dependent stuff involved with getting socket
notifications.

Without any further ado, I'll offer the synopsis of select():

Section 7.4, "Serialization—How to Pack Data" [book v3.0.7 pp. 55-57]: addition and changes to ieee754.c:

#include <inttypes.h>

long long pack754(long double f, unsigned bits, unsigned expbits)
uint64_t pack754(long double f, unsigned bits, unsigned expbits)

long double unpack754(long long i, unsigned bits, unsigned expbits)
long double unpack754(uint64_t i, unsigned bits, unsigned expbits)

printf("float encoded: 0x%08X\n", fi);
printf("float encoded: 0x%08" PRIx32 "\n", fi);

printf("double encoded: 0x%016llX\n", di);
printf("double encoded: 0x%016" PRIx64 "\n", di);

Section 7.4, "Serialization—How to Pack Data" [book v3.0.7 pp. 58-62]: multitude of changes, too many to list, to pack2.c to get it to function properly on 32-bit and 64-bit machines. It now relies on C99 features, but it was the cleanest way to get it portable. Modern gcc should have no trouble. (Thanks to Bruce L. for the catch and testing.)

Section 7.4, "Serialization—How to Pack Data" [book v3.0.7 pp. XX-XX]: text added:

[THE END]

(Before I begin this section in earnest, I should tell you that there
are libraries out there for doing this, and rolling your own and
remaining portable and error-free is quite a challenge.  So hunt around
and do your homework before deciding to implement this stuff yourself.
I include the information here for those curious about how things like
this work.)

Actually all the methods, above, have their drawbacks and advantages,

Section 7.4, "Serialization—How to Pack Data" [book v3.0.7 pp. XX-XX]: text added:

But if you want your source code to be portable, that's an assumption
you can't necessarily make.  (On the other hand, if you want things to
be fast, you should optimize this out on platforms that don't need to do
it!  That's what htons() and its ilk do.)