← C

Socket Programming

← Socket Programming

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

What is the socket() system call and what do AF_INET, SOCK_STREAM, and SOCK_DGRAM mean?

The socket() system call creates a communication endpoint and returns a file descriptor. It is the first step in all network programming.

Signature: int socket(int domain, int type, int protocol);

Domain (Address Family):

AF_INET -- IPv4 Internet protocols
AF_INET6 -- IPv6 Internet protocols
AF_UNIX (or AF_LOCAL) -- Local communication (same machine)

Type (Socket Type):

SOCK_STREAM -- Reliable, connection-oriented, byte stream (TCP). Guarantees in-order delivery. You must connect() before sending data.
SOCK_DGRAM -- Connectionless, unreliable datagrams (UDP). Each sendto() is independent. No connection setup needed.
SOCK_RAW -- Raw network access (requires root/CAP_NET_RAW).

Protocol: Usually 0 to auto-select the default protocol for the given domain+type pair (TCP for STREAM, UDP for DGRAM).

The returned file descriptor behaves like any other fd -- you can use read()/write(), close(), select()/poll() on it. On error, socket() returns -1 and sets errno.

Pseudo Code

1. Call socket(AF_INET, SOCK_STREAM, 0) for TCP
2. Call socket(AF_INET, SOCK_DGRAM, 0) for UDP
3. Check return value: >= 0 is valid fd, -1 is error
4. Use the fd with bind/listen/accept (server) or connect (client)
5. Close the fd when done with close()

Code

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main(void) {
    /* Create a TCP socket */
    int tcp_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (tcp_fd == -1) {
        perror("socket (TCP)");
        exit(EXIT_FAILURE);
    }
    printf("TCP socket fd: %d\n", tcp_fd);

    /* Create a UDP socket */
    int udp_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (udp_fd == -1) {
        perror("socket (UDP)");
        close(tcp_fd);
        exit(EXIT_FAILURE);
    }
    printf("UDP socket fd: %d\n", udp_fd);

    close(tcp_fd);
    close(udp_fd);
    return 0;
}

TCP socket fd: 3
UDP socket fd: 4
(File descriptor numbers may vary)

Key Points

•socket() returns a file descriptor or -1 on error
•AF_INET = IPv4, AF_INET6 = IPv6, AF_UNIX = local IPC
•SOCK_STREAM = TCP (reliable, ordered, connection-oriented)
•SOCK_DGRAM = UDP (unreliable, connectionless, message-oriented)
•Protocol 0 auto-selects the default (TCP for STREAM, UDP for DGRAM)

Gotchas

•Always check the return value -- socket() can fail if the system runs out of file descriptors
•Sockets must be closed with close() to avoid fd leaks, just like regular files
•SOCK_STREAM does not preserve message boundaries -- TCP is a byte stream, not a message stream

socket(domain, type, protocol) creates a network endpoint. AF_INET = IPv4, SOCK_STREAM = TCP, SOCK_DGRAM = UDP. Returns an fd or -1 on error.

•SOCK_STREAM = TCP, SOCK_DGRAM = UDP
•Returns fd on success, -1 on error

#include <sys/socket.h>
#include <netinet/in.h>

int tcp_fd = socket(AF_INET, SOCK_STREAM, 0); /* TCP */
int udp_fd = socket(AF_INET, SOCK_DGRAM, 0);  /* UDP */

SOCK_STREAM is a byte stream -- it does not preserve message boundaries

Question 2 / 15

How do you write a basic TCP server in C (socket/bind/listen/accept flow)?

A TCP server follows a strict sequence of system calls:

socket() -- Create a SOCK_STREAM socket.
bind() -- Assign a local address and port to the socket using struct sockaddr_in.
listen() -- Mark the socket as passive (willing to accept connections). The backlog parameter limits the queue of pending connections.
accept() -- Block until a client connects. Returns a new file descriptor for the connected client. The original socket continues listening.
read()/write() or recv()/send() -- Exchange data with the client on the new fd.
close() -- Close the client fd, then eventually the listening fd.

Key detail: accept() returns a different fd from the listening socket. The listening socket is never used directly for data transfer -- it only spawns connected sockets.

bind() address: Use INADDR_ANY (0.0.0.0) to listen on all interfaces, or a specific IP to bind to one interface.

listen() backlog: Typically 5-128. The kernel may silently cap this value. On Linux, SOMAXCONN (128 by default) is the upper limit unless changed via sysctl.

Pseudo Code

1. sockfd = socket(AF_INET, SOCK_STREAM, 0)
2. Set SO_REUSEADDR on sockfd
3. Fill sockaddr_in: family=AF_INET, addr=INADDR_ANY, port=htons(PORT)
4. bind(sockfd, addr, sizeof(addr))
5. listen(sockfd, BACKLOG)
6. Loop:
   a. connfd = accept(sockfd, client_addr, &addrlen)
   b. read/write on connfd
   c. close(connfd)
7. close(sockfd)

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 8080
#define BACKLOG 5
#define BUFSIZE 1024

int main(void) {
    int sockfd, connfd;
    struct sockaddr_in serv_addr, cli_addr;
    socklen_t cli_len = sizeof(cli_addr);
    char buf[BUFSIZE];

    /* 1. Create socket */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) { perror("socket"); exit(1); }

    /* 2. Allow address reuse */
    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    /* 3. Bind to port */
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(PORT);

    if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind"); close(sockfd); exit(1);
    }

    /* 4. Listen */
    if (listen(sockfd, BACKLOG) == -1) {
        perror("listen"); close(sockfd); exit(1);
    }
    printf("Server listening on port %d\n", PORT);

    /* 5. Accept and handle one client */
    connfd = accept(sockfd, (struct sockaddr *)&cli_addr, &cli_len);
    if (connfd == -1) { perror("accept"); close(sockfd); exit(1); }

    ssize_t n = read(connfd, buf, BUFSIZE - 1);
    if (n > 0) {
        buf[n] = '\0';
        printf("Received: %s\n", buf);
        write(connfd, "Hello from server\n", 18);
    }

    close(connfd);
    close(sockfd);
    return 0;
}

Server listening on port 8080
(Then blocks on accept() waiting for a client connection)

Key Points

•TCP server flow: socket -> bind -> listen -> accept -> read/write -> close
•accept() returns a NEW fd for the connected client; the original fd keeps listening
•INADDR_ANY binds to all available interfaces
•htons() converts port number to network byte order (big-endian)
•listen() backlog limits the pending connection queue

Gotchas

•Forgetting SO_REUSEADDR means you get 'Address already in use' for ~60 seconds after restart (TIME_WAIT)
•accept() blocks by default -- the server is stuck until a client connects
•You must close BOTH the connected fd and the listening fd to avoid fd leaks
•The backlog argument to listen() is a hint -- the kernel may ignore values above SOMAXCONN

TCP server: socket() -> bind() -> listen() -> accept() loop -> read()/write() -> close(). accept() returns a new fd for each client.

•Flow: socket -> bind -> listen -> accept -> I/O -> close
•accept() gives a new fd; original fd continues listening

int sockfd = socket(AF_INET, SOCK_STREAM, 0);
bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));
listen(sockfd, 5);
int connfd = accept(sockfd, NULL, NULL);
read(connfd, buf, sizeof(buf));
write(connfd, reply, strlen(reply));
close(connfd);
close(sockfd);

Without SO_REUSEADDR, restarting the server gives 'Address already in use' for ~60s

Question 3 / 15

How do you write a TCP client in C (socket/connect flow)?

A TCP client is simpler than a server because it does not need bind() or listen(). The kernel assigns an ephemeral port automatically.

Flow:

socket() -- Create a SOCK_STREAM socket.
Fill struct sockaddr_in -- Set the server's IP and port.
connect() -- Initiate the TCP three-way handshake with the server. This blocks until the connection is established or fails.
send()/recv() or write()/read() -- Exchange data.
close() -- Tear down the connection (sends FIN).

connect() errors:

ECONNREFUSED -- No server listening on that port.
ETIMEDOUT -- Server unreachable (after retransmission timeouts).
ENETUNREACH -- No route to the network.

The client does not call bind() unless it needs a specific source port (rare). The kernel picks an ephemeral port from the range (typically 32768-60999 on Linux).

Pseudo Code

1. sockfd = socket(AF_INET, SOCK_STREAM, 0)
2. Fill sockaddr_in: family=AF_INET, addr=server_ip, port=htons(PORT)
3. Convert IP string with inet_pton(AF_INET, ip_str, &addr.sin_addr)
4. connect(sockfd, addr, sizeof(addr))
5. write(sockfd, request, len)
6. read(sockfd, buf, bufsize)
7. close(sockfd)

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERVER_IP "127.0.0.1"
#define PORT 8080
#define BUFSIZE 1024

int main(void) {
    int sockfd;
    struct sockaddr_in serv_addr;
    char buf[BUFSIZE];

    /* 1. Create socket */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) { perror("socket"); exit(1); }

    /* 2. Set server address */
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    if (inet_pton(AF_INET, SERVER_IP, &serv_addr.sin_addr) <= 0) {
        fprintf(stderr, "Invalid address: %s\n", SERVER_IP);
        close(sockfd); exit(1);
    }

    /* 3. Connect to server */
    if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("connect"); close(sockfd); exit(1);
    }
    printf("Connected to %s:%d\n", SERVER_IP, PORT);

    /* 4. Send and receive */
    const char *msg = "Hello from client";
    write(sockfd, msg, strlen(msg));

    ssize_t n = read(sockfd, buf, BUFSIZE - 1);
    if (n > 0) {
        buf[n] = '\0';
        printf("Server replied: %s\n", buf);
    }

    close(sockfd);
    return 0;
}

Connected to 127.0.0.1:8080
Server replied: <server response>
(Requires a TCP server running on 127.0.0.1:8080)

Key Points

•TCP client flow: socket -> connect -> write/read -> close
•No bind() needed -- the kernel assigns an ephemeral source port
•connect() performs the TCP three-way handshake
•inet_pton() converts IP string to binary network format
•connect() blocks until connection succeeds or fails

Gotchas

•connect() can block for a long time if the server is unreachable (kernel retransmits SYN packets)
•ECONNREFUSED means no process is listening on the target port -- check the server is running
•After connect() fails, the socket is in an undefined state -- you must close it and create a new one

TCP client: socket() -> connect() -> write()/read() -> close(). No bind() needed. connect() performs the three-way handshake.

•Client: socket -> connect -> I/O -> close
•Kernel assigns ephemeral source port automatically

int fd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr = {.sin_family=AF_INET, .sin_port=htons(8080)};
inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
connect(fd, (struct sockaddr *)&addr, sizeof(addr));
write(fd, "hello", 5);
read(fd, buf, sizeof(buf));
close(fd);

A failed connect() leaves the socket unusable -- close it and create a new one

Question 4 / 15

What is the difference between send()/recv() and write()/read() on sockets?

Both pairs work on socket file descriptors, but send()/recv() offer an additional flags parameter for socket-specific behavior.

Signatures:

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

With flags = 0, send() is equivalent to write() and recv() is equivalent to read().

Useful flags:

MSG_WAITALL (recv) -- Block until the full len bytes are received (instead of returning a partial read).
MSG_PEEK (recv) -- Read data without removing it from the receive buffer.
MSG_DONTWAIT (both) -- Non-blocking operation for this single call.
MSG_NOSIGNAL (send, Linux) -- Suppress SIGPIPE when writing to a closed connection. Without this, writing to a broken pipe kills the process.
MSG_OOB (both) -- Send/receive out-of-band (urgent) data.

Key difference: write()/read() work on any fd (files, pipes, sockets). send()/recv() only work on sockets. For portable code that may switch between fd types, use write()/read().

Pseudo Code

1. write(fd, buf, len)  == send(fd, buf, len, 0)
2. read(fd, buf, len)   == recv(fd, buf, len, 0)
3. Use MSG_WAITALL to get exactly N bytes
4. Use MSG_PEEK to inspect without consuming
5. Use MSG_NOSIGNAL on Linux to avoid SIGPIPE death

Code

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

void demonstrate_send_recv(int sockfd) {
    const char *msg = "Hello, network!";

    /* send with flags=0 is the same as write */
    send(sockfd, msg, strlen(msg), 0);
    /* equivalent: write(sockfd, msg, strlen(msg)); */

    char buf[1024];

    /* recv with MSG_WAITALL: block until we get exactly 15 bytes */
    ssize_t n = recv(sockfd, buf, 15, MSG_WAITALL);

    /* recv with MSG_PEEK: look at data without consuming it */
    n = recv(sockfd, buf, sizeof(buf), MSG_PEEK);
    /* data is still in the buffer -- next recv/read returns it again */

    /* On Linux: avoid SIGPIPE on broken connections */
    #ifdef MSG_NOSIGNAL
    send(sockfd, msg, strlen(msg), MSG_NOSIGNAL);
    #endif

    /* MSG_DONTWAIT: non-blocking for just this call */
    n = recv(sockfd, buf, sizeof(buf), MSG_DONTWAIT);
    /* returns -1 with errno=EAGAIN if no data available */
}

Key Points

•send(fd, buf, len, 0) == write(fd, buf, len)
•recv(fd, buf, len, 0) == read(fd, buf, len)
•MSG_WAITALL blocks until exactly len bytes are received
•MSG_PEEK reads data without consuming it from the buffer
•MSG_NOSIGNAL (Linux) prevents SIGPIPE on broken connections

Gotchas

•read()/recv() may return fewer bytes than requested (partial read) -- you must loop to get all data
•write()/send() can also do short writes -- always check the return value and loop
•Without MSG_NOSIGNAL, writing to a closed TCP connection sends SIGPIPE which terminates the process by default
•MSG_WAITALL does not guarantee exactly len bytes if the connection closes or an error occurs

With flags=0, send()==write() and recv()==read(). The flags parameter adds socket-specific behavior: MSG_WAITALL, MSG_PEEK, MSG_NOSIGNAL, MSG_DONTWAIT.

•send/recv add a flags parameter; with flags=0 they equal write/read
•MSG_WAITALL, MSG_PEEK, MSG_NOSIGNAL are the most commonly used flags

/* Equivalent calls */
write(fd, buf, len);         /* same as: */
send(fd, buf, len, 0);

read(fd, buf, len);          /* same as: */
recv(fd, buf, len, 0);

/* Useful flags */
recv(fd, buf, n, MSG_WAITALL);   /* block until n bytes */
recv(fd, buf, n, MSG_PEEK);      /* peek without consuming */
send(fd, buf, n, MSG_NOSIGNAL);  /* no SIGPIPE on broken conn */

Always loop on read/recv -- partial reads are normal on TCP sockets

Question 5 / 15

How does UDP communication work with sendto() and recvfrom()?

UDP is connectionless -- there is no connect(), listen(), or accept(). Each datagram is sent independently to a specified destination.

Server flow: socket() -> bind() -> recvfrom()/sendto() loop. Client flow: socket() -> sendto()/recvfrom().

Key functions:

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
               const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                struct sockaddr *src_addr, socklen_t *addrlen);

recvfrom() fills in the source address of the sender, which you can then use to reply with sendto(). This is how a UDP server knows who to respond to.

UDP preserves message boundaries: Unlike TCP, each sendto() produces exactly one datagram, and each recvfrom() reads exactly one complete datagram. If the buffer is too small, excess bytes are discarded.

Optional: You can call connect() on a UDP socket to set a default destination. After that, you can use send()/recv() instead of sendto()/recvfrom(). This does not create a real connection -- it just sets the default address and filters incoming datagrams.

Pseudo Code

UDP Server:
1. sockfd = socket(AF_INET, SOCK_DGRAM, 0)
2. bind(sockfd, server_addr, addrlen)
3. Loop:
   a. n = recvfrom(sockfd, buf, BUFSIZE, 0, &client_addr, &addrlen)
   b. Process buf
   c. sendto(sockfd, reply, reply_len, 0, &client_addr, addrlen)
4. close(sockfd)

UDP Client:
1. sockfd = socket(AF_INET, SOCK_DGRAM, 0)
2. sendto(sockfd, msg, len, 0, &server_addr, addrlen)
3. recvfrom(sockfd, buf, BUFSIZE, 0, NULL, NULL)
4. close(sockfd)

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 9090
#define BUFSIZE 1024

/* --- UDP Server --- */
void udp_server(void) {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) { perror("socket"); exit(1); }

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(PORT);

    if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind"); close(sockfd); exit(1);
    }

    char buf[BUFSIZE];
    struct sockaddr_in cli_addr;
    socklen_t cli_len = sizeof(cli_addr);

    printf("UDP server listening on port %d\n", PORT);
    ssize_t n = recvfrom(sockfd, buf, BUFSIZE - 1, 0,
                         (struct sockaddr *)&cli_addr, &cli_len);
    if (n > 0) {
        buf[n] = '\0';
        printf("Received: %s\n", buf);
        const char *reply = "ACK";
        sendto(sockfd, reply, strlen(reply), 0,
               (struct sockaddr *)&cli_addr, cli_len);
    }
    close(sockfd);
}

/* --- UDP Client --- */
void udp_client(void) {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) { perror("socket"); exit(1); }

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);

    const char *msg = "Hello UDP";
    sendto(sockfd, msg, strlen(msg), 0,
           (struct sockaddr *)&serv_addr, sizeof(serv_addr));

    char buf[BUFSIZE];
    ssize_t n = recvfrom(sockfd, buf, BUFSIZE - 1, 0, NULL, NULL);
    if (n > 0) {
        buf[n] = '\0';
        printf("Reply: %s\n", buf);
    }
    close(sockfd);
}

Key Points

•UDP uses sendto()/recvfrom() instead of send()/recv()
•No connect/listen/accept needed -- each datagram is independent
•recvfrom() tells you who sent the datagram (fills src_addr)
•UDP preserves message boundaries -- one sendto = one recvfrom
•connect() on UDP just sets a default destination (no real connection)

Gotchas

•UDP datagrams can be lost, duplicated, or arrive out of order -- your application must handle this
•If recvfrom() buffer is smaller than the datagram, excess bytes are silently discarded
•UDP has no flow control -- a fast sender can overwhelm a slow receiver
•Maximum UDP payload is ~65507 bytes (65535 - 8 byte UDP header - 20 byte IP header)

UDP: sendto() sends a datagram to a specified address, recvfrom() receives and tells you who sent it. No connection setup. Message boundaries are preserved.

•sendto/recvfrom specify the address per datagram
•No connect/listen/accept for UDP

/* UDP server */
int fd = socket(AF_INET, SOCK_DGRAM, 0);
bind(fd, (struct sockaddr *)&addr, sizeof(addr));
recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *)&cli, &cli_len);
sendto(fd, reply, len, 0, (struct sockaddr *)&cli, cli_len);

/* UDP client -- no bind needed */
sendto(fd, msg, len, 0, (struct sockaddr *)&srv, sizeof(srv));
recvfrom(fd, buf, sizeof(buf), 0, NULL, NULL);

Datagrams can be lost or arrive out of order -- UDP provides no reliability guarantees

Question 6 / 15

How do struct sockaddr_in and byte order functions (htons/htonl/ntohs/ntohl) work?

struct sockaddr_in is the IPv4 socket address structure used by bind(), connect(), accept(), sendto(), and recvfrom().

Structure:

struct sockaddr_in {
    sa_family_t    sin_family;  /* AF_INET */
    in_port_t      sin_port;    /* port in NETWORK byte order */
    struct in_addr sin_addr;    /* IPv4 address in NETWORK byte order */
    char           sin_zero[8]; /* padding (zeroed) */
};

Network byte order is big-endian. Most x86/x86_64 CPUs are little-endian. You must convert between host and network byte order:

htons(x) -- Host TO Network Short (16-bit, for ports)
htonl(x) -- Host TO Network Long (32-bit, for addresses)
ntohs(x) -- Network TO Host Short
ntohl(x) -- Network TO Host Long

Why cast to struct sockaddr *? The socket API uses a generic struct sockaddr as the parameter type. You fill in a struct sockaddr_in (or sockaddr_in6 for IPv6) and cast it. This is the C way of achieving polymorphism.

Always zero the struct before filling it -- sin_zero must be zero, and uninitialized padding can cause issues.

Pseudo Code

1. memset(&addr, 0, sizeof(addr))
2. addr.sin_family = AF_INET
3. addr.sin_port = htons(PORT)     /* convert port to network order */
4. addr.sin_addr.s_addr = htonl(INADDR_ANY)  /* or use inet_pton */
5. Cast: (struct sockaddr *)&addr when passing to bind/connect/etc.

Code

#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>

int main(void) {
    /* Byte order conversion */
    uint16_t port = 8080;
    uint16_t net_port = htons(port);
    printf("Host port: 0x%04x, Network port: 0x%04x\n", port, net_port);
    printf("Back to host: %d\n", ntohs(net_port));

    uint32_t addr = 0x7f000001; /* 127.0.0.1 in host order */
    uint32_t net_addr = htonl(addr);
    printf("Host addr: 0x%08x, Network addr: 0x%08x\n", addr, net_addr);

    /* Fill sockaddr_in */
    struct sockaddr_in serv;
    memset(&serv, 0, sizeof(serv));           /* Zero the struct */
    serv.sin_family = AF_INET;
    serv.sin_port = htons(8080);              /* Port in network order */
    serv.sin_addr.s_addr = htonl(INADDR_ANY); /* 0.0.0.0 */

    /* Or use inet_pton for a specific IP */
    inet_pton(AF_INET, "192.168.1.1", &serv.sin_addr);

    /* Print back */
    char ip_str[INET_ADDRSTRLEN];
    inet_ntop(AF_INET, &serv.sin_addr, ip_str, sizeof(ip_str));
    printf("Address: %s, Port: %d\n", ip_str, ntohs(serv.sin_port));

    return 0;
}

Host port: 0x1f90, Network port: 0x901f
Back to host: 8080
Host addr: 0x7f000001, Network addr: 0x0100007f
Address: 192.168.1.1, Port: 8080
(Byte order values shown for little-endian systems;
 on big-endian systems, host and network values are identical)

Key Points

•Network byte order is big-endian; x86 is little-endian -- conversion is mandatory
•htons/htonl convert host-to-network; ntohs/ntohl convert network-to-host
•sin_port and sin_addr must be in network byte order
•Always memset the sockaddr_in to zero before filling it
•Cast sockaddr_in* to sockaddr* when passing to socket functions

Gotchas

•Forgetting htons() on the port leads to binding to the wrong port (e.g., 8080 becomes port 36895 on little-endian)
•INADDR_ANY is 0 so htonl(INADDR_ANY) == 0, but using htonl is still correct practice
•On big-endian machines, htons/htonl are no-ops but you must still call them for portability
•sin_zero must be zeroed -- some systems check it

sockaddr_in holds IP+port in network byte order (big-endian). Use htons() for ports, htonl() for addresses, and their ntoh* inverses to convert back.

•htons for ports (16-bit), htonl for addresses (32-bit)
•Always zero the struct with memset before use

struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(8080);              /* port -> network order */
addr.sin_addr.s_addr = htonl(INADDR_ANY); /* bind all interfaces */

/* Read back */
printf("Port: %d\n", ntohs(addr.sin_port));

Forgetting htons() on ports causes binding to the wrong port number

Question 7 / 15

How do inet_pton() and inet_ntop() work for address conversion?

These are the modern, protocol-independent functions for converting between human-readable IP strings and binary network addresses. They replace the deprecated inet_aton()/inet_ntoa().

inet_pton() -- Presentation TO Network:

int inet_pton(int af, const char *src, void *dst);

Converts an IP string ("192.168.1.1" or "::1") to binary form.

Returns 1 on success, 0 if the string is not valid, -1 on error (with errno).

inet_ntop() -- Network TO Presentation:

const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

Converts binary address to a human-readable string.

Returns pointer to dst on success, NULL on error.
Use INET_ADDRSTRLEN (16) for IPv4 buffer size, INET6_ADDRSTRLEN (46) for IPv6.

Why not inet_ntoa()? inet_ntoa() returns a pointer to a static buffer, making it non-thread-safe and non-reentrant. Calling it twice in the same printf() gives the same string for both calls. inet_ntop() writes to a caller-supplied buffer, avoiding this problem.

Pseudo Code

String to binary:
1. inet_pton(AF_INET, "192.168.1.1", &addr.sin_addr)
2. Check return: 1=success, 0=invalid string, -1=error

Binary to string:
1. char str[INET_ADDRSTRLEN]
2. inet_ntop(AF_INET, &addr.sin_addr, str, sizeof(str))
3. Check return: non-NULL=success

Code

#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>

int main(void) {
    /* --- inet_pton: string -> binary --- */
    struct in_addr ipv4_addr;
    int ret = inet_pton(AF_INET, "192.168.1.100", &ipv4_addr);
    if (ret == 1) {
        printf("Converted OK. Binary: 0x%08x\n", ntohl(ipv4_addr.s_addr));
    } else if (ret == 0) {
        printf("Invalid address string\n");
    } else {
        perror("inet_pton");
    }

    /* --- inet_ntop: binary -> string --- */
    char str[INET_ADDRSTRLEN];
    if (inet_ntop(AF_INET, &ipv4_addr, str, sizeof(str)) != NULL) {
        printf("String: %s\n", str); /* 192.168.1.100 */
    }

    /* --- IPv6 example --- */
    struct in6_addr ipv6_addr;
    inet_pton(AF_INET6, "::1", &ipv6_addr);
    char str6[INET6_ADDRSTRLEN];
    inet_ntop(AF_INET6, &ipv6_addr, str6, sizeof(str6));
    printf("IPv6: %s\n", str6); /* ::1 */

    /* --- Why inet_ntoa is dangerous --- */
    /* inet_ntoa uses a static buffer: */
    /* printf("%s %s", inet_ntoa(a), inet_ntoa(b)); */
    /* Both %s print the SAME string (b's address)! */

    return 0;
}

Converted OK. Binary: 0xc0a80164
String: 192.168.1.100
IPv6: ::1

Key Points

•inet_pton converts IP string to binary (presentation-to-network)
•inet_ntop converts binary to IP string (network-to-presentation)
•Both support AF_INET (IPv4) and AF_INET6 (IPv6)
•Use INET_ADDRSTRLEN (16) for IPv4 and INET6_ADDRSTRLEN (46) for IPv6 buffers
•These replace the deprecated inet_aton/inet_ntoa functions

Gotchas

•inet_ntoa() uses a static buffer -- it is not thread-safe and breaks with multiple calls in one expression
•inet_pton returns 0 (not -1) for invalid address strings -- check for both 0 and -1
•The buffer passed to inet_ntop must be large enough or you get an error

inet_pton(AF_INET, str, &addr) converts string to binary. inet_ntop(AF_INET, &addr, str, len) converts binary to string. Both work with IPv4 and IPv6. They replace the non-thread-safe inet_ntoa().

•pton = presentation-to-network, ntop = network-to-presentation
•Thread-safe replacements for inet_aton/inet_ntoa

struct in_addr addr;
inet_pton(AF_INET, "10.0.0.1", &addr);  /* string -> binary */

char buf[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &addr, buf, sizeof(buf));  /* binary -> string */
printf("%s\n", buf);  /* 10.0.0.1 */

inet_ntoa uses a static buffer and is not thread-safe -- always use inet_ntop instead

Question 8 / 15

What is SO_REUSEADDR and why is it important for server sockets?

SO_REUSEADDR is a socket option that allows a socket to bind to an address that is already in the TIME_WAIT state.

The problem: When a TCP connection closes, the side that sends the final FIN enters the TIME_WAIT state for 2*MSL (Maximum Segment Lifetime, typically 60 seconds). During this period, the address:port pair is considered "in use." If you restart a server, bind() fails with EADDRINUSE because the old socket is still in TIME_WAIT.

The solution: Set SO_REUSEADDR before bind(). This tells the kernel to allow binding even if the address is in TIME_WAIT.

What SO_REUSEADDR does NOT do:

It does NOT allow two active sockets to bind to the same port simultaneously (that requires SO_REUSEPORT).
It does NOT skip the TIME_WAIT state -- it just allows binding over it.

SO_REUSEPORT (Linux 3.9+): Allows multiple sockets to bind to the same address:port pair. Used for load balancing across multiple server processes. Each incoming connection is distributed to one of the bound sockets.

Best practice: Almost every TCP server should set SO_REUSEADDR. There is virtually no downside.

Pseudo Code

1. sockfd = socket(AF_INET, SOCK_STREAM, 0)
2. int opt = 1
3. setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))
4. bind(sockfd, ...)  /* Now succeeds even if port is in TIME_WAIT */

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main(void) {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) { perror("socket"); exit(1); }

    /* Set SO_REUSEADDR -- MUST be done before bind() */
    int opt = 1;
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
        perror("setsockopt");
        close(sockfd);
        exit(1);
    }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(8080);

    /* This bind succeeds even if port 8080 is in TIME_WAIT */
    if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("bind");
        close(sockfd);
        exit(1);
    }

    printf("Bound successfully with SO_REUSEADDR\n");

    /* Check current value */
    int val;
    socklen_t len = sizeof(val);
    getsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &val, &len);
    printf("SO_REUSEADDR = %d\n", val); /* 1 */

    close(sockfd);
    return 0;
}

Bound successfully with SO_REUSEADDR
SO_REUSEADDR = 1

Key Points

•SO_REUSEADDR allows binding to a port that is in TIME_WAIT state
•Must be set before bind() using setsockopt()
•Prevents 'Address already in use' errors when restarting a server
•TIME_WAIT lasts ~60 seconds after TCP connection close
•Almost every TCP server should enable SO_REUSEADDR

Gotchas

•SO_REUSEADDR must be set BEFORE bind() -- setting it after has no effect
•SO_REUSEADDR does not allow two active listeners on the same port -- that needs SO_REUSEPORT
•On some systems, SO_REUSEADDR has subtly different semantics (Windows allows port hijacking with it)
•TIME_WAIT exists for a reason (preventing delayed packets from old connections) -- do not try to disable it

SO_REUSEADDR lets a server socket bind to a port still in TIME_WAIT (the ~60s state after TCP close). Set it with setsockopt() before bind(). Almost every server should use it.

•Prevents 'Address already in use' on server restart
•Must be called before bind()

int opt = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
bind(sockfd, ...); /* succeeds even if port in TIME_WAIT */

SO_REUSEADDR must be set before bind(), not after

Question 9 / 15

How do you build a concurrent TCP server using fork() per client?

A simple iterative server handles one client at a time. To serve multiple clients concurrently, the classic Unix approach is to fork() a child process for each accepted connection.

Pattern:

Parent process loops on accept().
After accept() returns a new fd, fork().
Child process: closes the listening socket (not needed), handles the client, then exit().
Parent process: closes the connected fd (child owns it), continues accepting.

Zombie prevention: When a child exits, it becomes a zombie until the parent calls wait(). To avoid zombie accumulation:

Install a SIGCHLD handler that calls waitpid(-1, NULL, WNOHANG) in a loop.
Or set signal(SIGCHLD, SIG_IGN) (on Linux, this auto-reaps children).

Why close fds in both processes? After fork(), both parent and child have copies of both fds. The listening socket has refcount=2. The connected socket has refcount=2. Each process must close the fd it does not need, so the refcount drops to 1 and the fd is properly cleaned up when the owning process closes it.

Pseudo Code

1. Install SIGCHLD handler to reap zombies
2. sockfd = socket + bind + listen
3. Loop:
   a. connfd = accept(sockfd, ...)
   b. pid = fork()
   c. If child (pid==0):
      - close(sockfd)     /* child doesn't need listener */
      - handle_client(connfd)
      - close(connfd)
      - exit(0)
   d. If parent (pid>0):
      - close(connfd)     /* parent doesn't need this client */
      - continue loop

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>

#define PORT 8080
#define BUFSIZE 1024

void sigchld_handler(int sig) {
    (void)sig;
    /* Reap all dead children (non-blocking) */
    while (waitpid(-1, NULL, WNOHANG) > 0)
        ;
}

void handle_client(int connfd) {
    char buf[BUFSIZE];
    ssize_t n;
    while ((n = read(connfd, buf, BUFSIZE - 1)) > 0) {
        buf[n] = '\0';
        write(connfd, buf, n); /* echo back */
    }
}

int main(void) {
    /* Install SIGCHLD handler to prevent zombies */
    struct sigaction sa;
    sa.sa_handler = sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART; /* restart accept() after signal */
    sigaction(SIGCHLD, &sa, NULL);

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr = {0};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(PORT);
    bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));
    listen(sockfd, 128);

    printf("Concurrent server on port %d\n", PORT);

    for (;;) {
        int connfd = accept(sockfd, NULL, NULL);
        if (connfd == -1) continue; /* interrupted by signal */

        pid_t pid = fork();
        if (pid == 0) {
            /* Child */
            close(sockfd);
            handle_client(connfd);
            close(connfd);
            exit(0);
        } else if (pid > 0) {
            /* Parent */
            close(connfd); /* parent doesn't need client fd */
        } else {
            perror("fork");
            close(connfd);
        }
    }
}

Concurrent server on port 8080
(Then blocks on accept() waiting for client connections)

Key Points

•fork() after accept() creates one child process per client
•Child closes listening socket; parent closes connected socket
•SIGCHLD handler with waitpid(WNOHANG) prevents zombie processes
•SA_RESTART flag prevents accept() from failing with EINTR on signal delivery
•Each client gets a dedicated process with its own address space

Gotchas

•Without SIGCHLD handling, zombie processes accumulate and exhaust the process table
•Both parent and child must close the fd they don't use, or the TCP connection stays open (refcount > 0)
•fork() per client is expensive for high concurrency -- use thread pools or event loops (select/epoll) for thousands of clients
•accept() can return EINTR when a signal is delivered -- use SA_RESTART or loop on EINTR

After accept(), fork(). Child closes listener and handles client. Parent closes client fd and loops. Install SIGCHLD handler with waitpid(WNOHANG) to reap zombies.

•fork() per client; child handles, parent continues accepting
•Reap zombies via SIGCHLD handler

for (;;) {
    int connfd = accept(sockfd, NULL, NULL);
    if (fork() == 0) {
        close(sockfd);         /* child: close listener */
        handle_client(connfd);
        close(connfd);
        exit(0);
    }
    close(connfd);             /* parent: close client fd */
}

Without zombie reaping, dead child processes accumulate and exhaust the process table

Question 10 / 15

How does select() work for I/O multiplexing on sockets?

select() monitors multiple file descriptors to see if any are ready for reading, writing, or have exceptional conditions.

Signature:

int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);

nfds -- highest fd + 1 (not the count of fds).
readfds -- set of fds to watch for readability.
writefds -- set of fds to watch for writability.
exceptfds -- set of fds to watch for exceptions.
timeout -- NULL blocks forever, {0,0} returns immediately (poll), or a specific duration.

fd_set macros:

FD_ZERO(&set) -- Clear the set.
FD_SET(fd, &set) -- Add fd to the set.
FD_CLR(fd, &set) -- Remove fd from the set.
FD_ISSET(fd, &set) -- Test if fd is in the set (use after select returns).

Return value: Number of ready fds, 0 on timeout, -1 on error.

Critical detail: select() modifies the fd_sets. You must re-initialize them before each call. This is a common bug.

Typical server pattern: Put the listening socket and all connected sockets in readfds. When select returns, if the listening socket is readable, call accept(). If a client socket is readable, call read().

Pseudo Code

1. FD_ZERO all sets
2. FD_SET(listenfd, &readfds)
3. For each active client fd: FD_SET(clientfd, &readfds)
4. maxfd = highest fd among all
5. select(maxfd + 1, &readfds, NULL, NULL, timeout)
6. If FD_ISSET(listenfd, &readfds): accept new client
7. For each client: if FD_ISSET(clientfd, &readfds): read data
8. Re-initialize fd_sets and repeat

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <netinet/in.h>

#define PORT 8080
#define MAX_CLIENTS 10
#define BUFSIZE 1024

int main(void) {
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr = {0};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(PORT);
    bind(listenfd, (struct sockaddr *)&addr, sizeof(addr));
    listen(listenfd, 5);

    int clients[MAX_CLIENTS];
    int ncli = 0;

    for (;;) {
        fd_set readfds;
        FD_ZERO(&readfds);
        FD_SET(listenfd, &readfds);
        int maxfd = listenfd;

        for (int i = 0; i < ncli; i++) {
            FD_SET(clients[i], &readfds);
            if (clients[i] > maxfd) maxfd = clients[i];
        }

        int ready = select(maxfd + 1, &readfds, NULL, NULL, NULL);
        if (ready == -1) { perror("select"); break; }

        /* New connection? */
        if (FD_ISSET(listenfd, &readfds)) {
            int connfd = accept(listenfd, NULL, NULL);
            if (connfd >= 0 && ncli < MAX_CLIENTS) {
                clients[ncli++] = connfd;
                printf("New client (fd=%d)\n", connfd);
            }
        }

        /* Data from existing clients? */
        for (int i = 0; i < ncli; i++) {
            if (FD_ISSET(clients[i], &readfds)) {
                char buf[BUFSIZE];
                ssize_t n = read(clients[i], buf, BUFSIZE - 1);
                if (n <= 0) {
                    close(clients[i]);
                    clients[i] = clients[--ncli]; /* remove */
                    i--;
                } else {
                    buf[n] = '\0';
                    write(clients[i], buf, n); /* echo */
                }
            }
        }
    }
    close(listenfd);
    return 0;
}

Key Points

•select() monitors multiple fds for readability/writability/exceptions
•nfds must be highest_fd + 1, not the count of fds
•select() modifies the fd_sets -- re-initialize before each call
•FD_ZERO, FD_SET, FD_CLR, FD_ISSET are the four fd_set macros
•Single-threaded server can handle many clients with select()

Gotchas

•fd_sets are modified by select() -- forgetting to reinitialize them before each call is the #1 bug
•FD_SETSIZE (typically 1024) limits the maximum fd number -- select cannot handle fds >= 1024
•select() uses a linear scan internally -- O(n) per call, poor for thousands of fds
•On Linux, the timeout is modified by select() to reflect time remaining -- on other systems it is not

select(nfds, &readfds, &writefds, &exceptfds, &timeout) monitors multiple fds. Use FD_ZERO/FD_SET/FD_ISSET macros. Re-initialize fd_sets before each call.

•nfds = highest fd + 1
•Must reinitialize fd_sets before every select() call

fd_set readfds;
FD_ZERO(&readfds);
FD_SET(listenfd, &readfds);
FD_SET(clientfd, &readfds);
int maxfd = (listenfd > clientfd) ? listenfd : clientfd;

select(maxfd + 1, &readfds, NULL, NULL, NULL);

if (FD_ISSET(listenfd, &readfds))  /* new connection */
if (FD_ISSET(clientfd, &readfds))  /* data from client */

select() modifies the fd_sets in-place -- reinitialize them every iteration

Question 11 / 15

What are the differences between poll() and select(), and when should you use each?

poll() was designed to fix the shortcomings of select().

Signature:

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd {
    int   fd;       /* file descriptor */
    short events;   /* requested events (input) */
    short revents;  /* returned events (output) */
};

Key differences:

Feature	select()	poll()
fd limit	FD_SETSIZE (1024)	No limit (array-based)
fd_set mutation	Modifies input sets	Separate events/revents fields
Interface	Bitmask (FD_SET/FD_ISSET)	Array of structs
Sparse fds	Scans 0..nfds-1	Only scans provided fds
Portability	POSIX + Windows	POSIX (not native Windows)
Timeout	struct timeval (microseconds)	int milliseconds

poll() events:

POLLIN -- Ready to read (equivalent to select readfds)
POLLOUT -- Ready to write
POLLERR -- Error condition (always checked, even if not set)
POLLHUP -- Hang up (peer closed connection)
POLLNVAL -- Invalid fd

Neither is ideal for high concurrency (10K+ connections). Both are O(n) per call. Use epoll (Linux), kqueue (BSD/macOS), or io_uring (Linux 5.1+) for high-performance servers.

Pseudo Code

1. Create array: struct pollfd fds[MAX]
2. fds[0].fd = listenfd, fds[0].events = POLLIN
3. For each client: fds[i].fd = clientfd, fds[i].events = POLLIN
4. poll(fds, nfds, timeout_ms)
5. Check fds[i].revents & POLLIN for each i
6. No need to reinitialize -- events field is not modified

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <poll.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 8080
#define MAX_FDS 100
#define BUFSIZE 1024

int main(void) {
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr = {0};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(PORT);
    bind(listenfd, (struct sockaddr *)&addr, sizeof(addr));
    listen(listenfd, 5);

    struct pollfd fds[MAX_FDS];
    int nfds = 1;
    fds[0].fd = listenfd;
    fds[0].events = POLLIN;

    for (;;) {
        int ready = poll(fds, nfds, -1); /* -1 = block forever */
        if (ready == -1) { perror("poll"); break; }

        /* Check listener */
        if (fds[0].revents & POLLIN) {
            int connfd = accept(listenfd, NULL, NULL);
            if (connfd >= 0 && nfds < MAX_FDS) {
                fds[nfds].fd = connfd;
                fds[nfds].events = POLLIN;
                nfds++;
            }
        }

        /* Check clients */
        for (int i = 1; i < nfds; i++) {
            if (fds[i].revents & (POLLIN | POLLHUP | POLLERR)) {
                char buf[BUFSIZE];
                ssize_t n = read(fds[i].fd, buf, BUFSIZE - 1);
                if (n <= 0) {
                    close(fds[i].fd);
                    fds[i] = fds[--nfds]; /* remove */
                    i--;
                } else {
                    write(fds[i].fd, buf, n); /* echo */
                }
            }
        }
    }
    close(listenfd);
    return 0;
}

Key Points

•poll() has no FD_SETSIZE limit -- handles any number of fds
•Separate events (input) and revents (output) fields -- no need to reinitialize
•POLLIN, POLLOUT, POLLERR, POLLHUP, POLLNVAL are the key event flags
•Both select() and poll() are O(n) -- use epoll/kqueue for 10K+ connections
•poll() timeout is in milliseconds; -1 blocks forever, 0 returns immediately

Gotchas

•poll() is not available natively on Windows -- select() is more portable
•POLLERR and POLLHUP are always reported even if not requested in events
•Both poll() and select() copy the entire fd array to/from kernel on every call -- this is the O(n) cost
•For high-performance servers, use epoll (Linux) or kqueue (macOS/BSD) instead

poll() fixes select()'s limits: no FD_SETSIZE cap, separate input/output event fields, cleaner API. Both are O(n). Use epoll/kqueue for high concurrency.

•No FD_SETSIZE limit; events/revents separation
•Both poll and select are O(n) -- use epoll/kqueue for scale

struct pollfd fds[2];
fds[0].fd = listenfd; fds[0].events = POLLIN;
fds[1].fd = clientfd; fds[1].events = POLLIN;

poll(fds, 2, -1); /* block until event */

if (fds[0].revents & POLLIN)  /* new connection */
if (fds[1].revents & POLLIN)  /* client data ready */

poll() is not natively available on Windows

Question 12 / 15

How do you make a socket non-blocking and handle EAGAIN/EWOULDBLOCK?

By default, socket operations (accept, read, write, connect) block until they complete. A non-blocking socket returns immediately with an error if the operation cannot be completed right away.

How to set non-blocking: Use fcntl() to add the O_NONBLOCK flag to the socket's file status flags.

Behavior changes:

read()/recv(): Returns -1 with errno = EAGAIN (or EWOULDBLOCK) if no data is available.
write()/send(): Returns -1 with errno = EAGAIN if the send buffer is full.
accept(): Returns -1 with errno = EAGAIN if no pending connections.
connect(): Returns -1 with errno = EINPROGRESS. The connection continues in the background. Use select()/poll() on the socket for writability to detect completion, then check SO_ERROR with getsockopt().

EAGAIN vs EWOULDBLOCK: On Linux, they are the same value (11). POSIX allows them to differ. Always check for both:

if (errno == EAGAIN || errno == EWOULDBLOCK)

Use case: Non-blocking sockets are essential for event-driven servers (with select/poll/epoll) that handle many connections in a single thread without any blocking.

Pseudo Code

1. flags = fcntl(fd, F_GETFL, 0)
2. fcntl(fd, F_SETFL, flags | O_NONBLOCK)
3. On read: if returns -1 and errno==EAGAIN, no data yet
4. On write: if returns -1 and errno==EAGAIN, buffer full
5. On connect: if returns -1 and errno==EINPROGRESS, still connecting
6. Use select/poll to wait for readiness, then retry

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>

/* Make a socket non-blocking */
int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) return -1;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

void non_blocking_read_example(int sockfd) {
    char buf[1024];

    set_nonblocking(sockfd);

    for (;;) {
        ssize_t n = read(sockfd, buf, sizeof(buf) - 1);
        if (n > 0) {
            buf[n] = '\0';
            printf("Got: %s\n", buf);
        } else if (n == 0) {
            printf("Connection closed\n");
            break;
        } else { /* n == -1 */
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                /* No data available right now -- do other work */
                printf("Would block, try later\n");
                break; /* or use select/poll to wait */
            } else {
                perror("read");
                break;
            }
        }
    }
}

/* Non-blocking connect */
int nonblocking_connect(const char *ip, int port) {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    set_nonblocking(fd);

    struct sockaddr_in addr = {0};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_pton(AF_INET, ip, &addr.sin_addr);

    int ret = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
    if (ret == -1 && errno == EINPROGRESS) {
        /* Connection in progress -- use select/poll to wait */
        fd_set wfds;
        FD_ZERO(&wfds);
        FD_SET(fd, &wfds);
        struct timeval tv = {5, 0}; /* 5 second timeout */
        select(fd + 1, NULL, &wfds, NULL, &tv);

        int err;
        socklen_t len = sizeof(err);
        getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len);
        if (err != 0) {
            fprintf(stderr, "Connect failed: %s\n", strerror(err));
            close(fd);
            return -1;
        }
    }
    return fd;
}

Key Points

•fcntl(fd, F_SETFL, flags | O_NONBLOCK) makes a socket non-blocking
•Non-blocking read returns -1 with EAGAIN when no data is available
•Non-blocking connect returns -1 with EINPROGRESS -- use select for writability to detect completion
•Check both EAGAIN and EWOULDBLOCK for portability
•Essential for event-driven single-threaded servers

Gotchas

•EAGAIN and EWOULDBLOCK may have different values on some platforms -- check both
•Non-blocking connect requires checking SO_ERROR with getsockopt after select reports writable
•Forgetting to handle partial writes on non-blocking sockets leads to data loss
•O_NONBLOCK affects ALL operations on the fd, not just read/write

Use fcntl(fd, F_SETFL, flags | O_NONBLOCK) to make a socket non-blocking. Operations return -1 with EAGAIN/EWOULDBLOCK instead of blocking. Use with select/poll for event-driven I/O.

•O_NONBLOCK via fcntl makes all operations non-blocking
•EAGAIN/EWOULDBLOCK means 'try again later'

int flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);

ssize_t n = read(fd, buf, sizeof(buf));
if (n == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
    /* No data right now -- try again later */
}

Always check for both EAGAIN and EWOULDBLOCK -- they can differ on some platforms

Question 13 / 15

How does getaddrinfo() work for DNS resolution and protocol-independent addressing?

getaddrinfo() is the modern, protocol-independent way to resolve hostnames and service names to socket addresses. It replaces the deprecated gethostbyname().

Signature:

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

node -- Hostname ("example.com") or IP string ("1.2.3.4").
service -- Port number ("80") or service name ("http").
hints -- Filter criteria (address family, socket type, etc.).
res -- Output: linked list of results.

The hints struct filters results:

ai_family = AF_UNSPEC -- Return both IPv4 and IPv6 results.
ai_socktype = SOCK_STREAM -- Only TCP results.
ai_flags = AI_PASSIVE -- For servers: fill in wildcard address (use with node = NULL).

Each result in the linked list contains a ready-to-use struct sockaddr and its length. You can pass them directly to socket(), bind(), and connect().

Memory: You must call freeaddrinfo(res) when done.

Error handling: Returns 0 on success, non-zero error code. Use gai_strerror() to convert the error code to a string (not perror() or strerror()).

Pseudo Code

1. Set hints: family=AF_UNSPEC, socktype=SOCK_STREAM
2. getaddrinfo(hostname, port_str, &hints, &results)
3. Loop through results linked list:
   a. fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol)
   b. connect(fd, res->ai_addr, res->ai_addrlen)
   c. If success, break
4. freeaddrinfo(results)

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netdb.h>

int connect_to_host(const char *host, const char *port) {
    struct addrinfo hints, *res, *p;
    int sockfd;

    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;     /* IPv4 or IPv6 */
    hints.ai_socktype = SOCK_STREAM; /* TCP */

    int status = getaddrinfo(host, port, &hints, &res);
    if (status != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(status));
        return -1;
    }

    /* Try each result until one works */
    for (p = res; p != NULL; p = p->ai_next) {
        sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
        if (sockfd == -1) continue;

        if (connect(sockfd, p->ai_addr, p->ai_addrlen) == 0) {
            break; /* Success */
        }
        close(sockfd);
    }

    freeaddrinfo(res); /* Free the linked list */

    if (p == NULL) {
        fprintf(stderr, "Failed to connect to %s:%s\n", host, port);
        return -1;
    }

    return sockfd;
}

int main(void) {
    int fd = connect_to_host("example.com", "80");
    if (fd >= 0) {
        printf("Connected!\n");
        close(fd);
    }
    return 0;
}

Connected!
(Requires network access to resolve and connect to example.com:80)

Key Points

•getaddrinfo replaces gethostbyname -- it is thread-safe and protocol-independent
•Returns a linked list of results; try each until one works
•Use AI_PASSIVE flag with node=NULL for server bind addresses
•Must call freeaddrinfo() to free the result linked list
•Use gai_strerror() for error messages, not strerror()

Gotchas

•getaddrinfo can block for DNS resolution -- consider using it in a separate thread for non-blocking servers
•Forgetting freeaddrinfo() causes a memory leak
•gethostbyname is deprecated, not thread-safe, and IPv4-only -- always use getaddrinfo
•Error codes from getaddrinfo are NOT errno values -- use gai_strerror(), not perror()

getaddrinfo(host, port, &hints, &res) resolves hostnames to socket addresses. Returns a linked list of results. Use gai_strerror() for errors. Free with freeaddrinfo().

•Protocol-independent replacement for gethostbyname
•Must call freeaddrinfo() when done

struct addrinfo hints = {0}, *res;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
getaddrinfo("example.com", "80", &hints, &res);

int fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
connect(fd, res->ai_addr, res->ai_addrlen);
freeaddrinfo(res);

Use gai_strerror() for errors, not perror() -- getaddrinfo does not set errno

Question 14 / 15

How do you implement a simple HTTP client in C using sockets?

HTTP/1.1 is a text-based protocol over TCP. A minimal HTTP client:

Resolves the hostname and connects to port 80.
Sends an HTTP request (text).
Reads the HTTP response.

HTTP GET request format:

GET /path HTTP/1.1\r\n
Host: hostname\r\n
Connection: close\r\n
\r\n

Key details:

Lines are terminated by \r\n (CRLF).
The Host header is mandatory in HTTP/1.1.
Connection: close tells the server to close after the response (simplifies our read loop).
An empty line (\r\n) marks the end of headers.

Reading the response: Since we set Connection: close, we read until read() returns 0 (server closed connection). The response contains headers followed by a blank line, then the body.

Limitations: This does not handle HTTPS (needs TLS via OpenSSL/mbedTLS), chunked transfer encoding, redirects, or HTTP/2.

Pseudo Code

1. getaddrinfo(hostname, "80", &hints, &res)
2. socket + connect to the resolved address
3. snprintf the HTTP GET request into a buffer
4. send the request
5. Loop: read response until read returns 0
6. Print response
7. close + freeaddrinfo

Code

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netdb.h>

#define BUFSIZE 4096

int main(int argc, char *argv[]) {
    const char *host = (argc > 1) ? argv[1] : "example.com";
    const char *path = (argc > 2) ? argv[2] : "/";

    /* Resolve and connect */
    struct addrinfo hints = {0}, *res, *p;
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;

    int status = getaddrinfo(host, "80", &hints, &res);
    if (status != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(status));
        return 1;
    }

    int sockfd = -1;
    for (p = res; p; p = p->ai_next) {
        sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
        if (sockfd == -1) continue;
        if (connect(sockfd, p->ai_addr, p->ai_addrlen) == 0) break;
        close(sockfd);
        sockfd = -1;
    }
    freeaddrinfo(res);

    if (sockfd == -1) {
        fprintf(stderr, "Could not connect to %s\n", host);
        return 1;
    }

    /* Build and send HTTP request */
    char request[1024];
    int reqlen = snprintf(request, sizeof(request),
        "GET %s HTTP/1.1\r\n"
        "Host: %s\r\n"
        "Connection: close\r\n"
        "\r\n", path, host);

    write(sockfd, request, reqlen);

    /* Read response */
    char buf[BUFSIZE];
    ssize_t n;
    while ((n = read(sockfd, buf, BUFSIZE - 1)) > 0) {
        buf[n] = '\0';
        printf("%s", buf);
    }

    close(sockfd);
    return 0;
}

Key Points

•HTTP is text over TCP: send request lines terminated by CRLF, blank line ends headers
•Host header is mandatory in HTTP/1.1
•Connection: close simplifies reading -- just read until EOF
•Use getaddrinfo for DNS resolution instead of hardcoding IPs
•This handles HTTP only -- HTTPS requires TLS (OpenSSL/mbedTLS)

Gotchas

•Forgetting \r\n line terminators produces malformed HTTP that servers reject
•Without Connection: close, HTTP/1.1 uses keep-alive by default and the server won't close the connection
•This does not handle chunked transfer encoding -- real HTTP clients need to parse Content-Length or chunk headers
•No HTTPS support -- connecting to port 443 without TLS handshake will fail

Connect to port 80, send GET / HTTP/1.1\r\nHost: ...\r\nConnection: close\r\n\r\n, then read until EOF. HTTP is just text over TCP.

•HTTP = text protocol: GET line + Host header + blank line
•Connection: close makes server close after response

/* After connecting to host:80 */
char req[512];
snprintf(req, sizeof(req),
    "GET / HTTP/1.1\r\n"
    "Host: example.com\r\n"
    "Connection: close\r\n\r\n");
write(sockfd, req, strlen(req));

char buf[4096];
ssize_t n;
while ((n = read(sockfd, buf, sizeof(buf) - 1)) > 0) {
    buf[n] = '\0';
    printf("%s", buf);
}

Lines must end with \r\n (CRLF), not just \n

Question 15 / 15

What are the key differences between TCP and UDP for socket programming interviews?

This is one of the most common interview questions on networking. Here is a thorough comparison:

Feature	TCP	UDP
Connection	Connection-oriented (3-way handshake)	Connectionless
Reliability	Guaranteed delivery (ACKs, retransmissions)	No delivery guarantee
Ordering	In-order delivery	No ordering guarantee
Flow control	Yes (sliding window)	No
Congestion control	Yes (slow start, AIMD)	No
Message boundaries	Byte stream (no boundaries)	Datagram (preserves boundaries)
Speed	Slower (overhead)	Faster (minimal overhead)
Header size	20-60 bytes	8 bytes
Socket type	SOCK_STREAM	SOCK_DGRAM
System calls	connect/accept/send/recv	sendto/recvfrom

When to use TCP:

File transfer, web (HTTP), email, SSH
Any protocol requiring reliable, ordered delivery
When data integrity matters more than latency

When to use UDP:

DNS queries, DHCP, video/audio streaming, online games
When low latency matters more than reliability
When the application can handle packet loss
Multicast/broadcast (TCP is point-to-point only)

Interview tip: TCP guarantees delivery to the receiving TCP stack, but NOT to the application. If the receiver crashes after the kernel ACKed but before the app read() the data, it is lost. Similarly, send() returning success means data is in the kernel buffer, not that the peer received it.

Pseudo Code

TCP flow:
  Server: socket -> bind -> listen -> accept -> recv/send -> close
  Client: socket -> connect -> send/recv -> close

UDP flow:
  Server: socket -> bind -> recvfrom/sendto -> close
  Client: socket -> sendto/recvfrom -> close

Code

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

/* TCP: byte stream, no message boundaries */
void tcp_example(void) {
    int fd = socket(AF_INET, SOCK_STREAM, 0); /* TCP */
    /* Must connect before sending */
    /* send(fd, data, len, 0); -- byte stream */
    /* Two send() calls may arrive as one recv() */
    close(fd);
}

/* UDP: datagram, preserves message boundaries */
void udp_example(void) {
    int fd = socket(AF_INET, SOCK_DGRAM, 0); /* UDP */
    /* No connect needed */
    struct sockaddr_in dest = {0};
    dest.sin_family = AF_INET;
    dest.sin_port = htons(9090);
    /* sendto(fd, data, len, 0, &dest, sizeof(dest)); */
    /* Each sendto = exactly one datagram received */
    close(fd);
}

/* Common interview question: message framing for TCP */
/* Since TCP is a byte stream, you need a protocol to
   delimit messages. Common approaches: */
/* 1. Length prefix: send 4-byte length, then data */
/* 2. Delimiter: use \n or \0 to mark end of message */
/* 3. Fixed-size messages */

/* Length-prefixed send */
int send_message(int fd, const char *msg, size_t len) {
    uint32_t net_len = htonl((uint32_t)len);
    write(fd, &net_len, sizeof(net_len));  /* send length */
    write(fd, msg, len);                    /* send data */
    return 0;
}

/* Length-prefixed receive */
int recv_message(int fd, char *buf, size_t bufsize) {
    uint32_t net_len;
    read(fd, &net_len, sizeof(net_len));   /* read length */
    uint32_t msg_len = ntohl(net_len);
    if (msg_len > bufsize) return -1;
    read(fd, buf, msg_len);                /* read data */
    return (int)msg_len;
}

Key Points

•TCP = reliable, ordered, byte stream; UDP = unreliable, unordered, datagrams
•TCP requires connection setup (3-way handshake); UDP is connectionless
•TCP has no message boundaries -- you must implement framing (length prefix or delimiter)
•UDP preserves message boundaries -- one sendto = one recvfrom
•TCP has flow/congestion control; UDP does not
•Use TCP for reliability (HTTP, FTP, SSH); UDP for speed (DNS, gaming, streaming)

Gotchas

•TCP send() success does NOT mean the peer received the data -- it means the kernel accepted it into the send buffer
•TCP byte stream means two 100-byte sends may arrive as one 200-byte recv or any other split
•UDP can silently drop packets -- your application must handle retransmission if needed
•UDP maximum datagram is ~65507 bytes, but practical MTU is ~1472 bytes to avoid IP fragmentation

TCP = reliable, ordered, connection-oriented byte stream (SOCK_STREAM). UDP = unreliable, connectionless datagrams (SOCK_DGRAM). TCP needs connect/accept; UDP uses sendto/recvfrom. TCP has no message boundaries; UDP preserves them.

•TCP = SOCK_STREAM (reliable); UDP = SOCK_DGRAM (fast)
•TCP is a byte stream needing framing; UDP preserves message boundaries

/* TCP: reliable byte stream */
int tcp = socket(AF_INET, SOCK_STREAM, 0);
connect(tcp, ...);  /* 3-way handshake */
send(tcp, data, len, 0);

/* UDP: unreliable datagrams */
int udp = socket(AF_INET, SOCK_DGRAM, 0);
sendto(udp, data, len, 0, &dest, sizeof(dest)); /* no connect */

TCP send() returning success only means data is in the kernel buffer, not delivered to the peer

Built by onllm.dev

Home GitHub Support awesomePrep