#include <sys/socket.h>

int shutdown(int sockfd, int how);
/* Returns 0 on success, -1 on error */

The how parameter controls which direction gets closed:

Critical difference with dup() / fork(): If you call dup(sockfd) to create a second file descriptor pointing to the same socket, then calling close() on the original does NOT send FIN — the FD count just drops from 2 to 1. The socket stays open. But shutdown() sends the FIN immediately regardless of how many FDs exist for that socket.

When you call shutdown(sockfd, SHUT_WR):

• TCP sends a FIN segment to the peer
• The peer’s read() returns 0 (EOF) — they know you are done sending
• Your local TCP moves into FIN_WAIT1, then FIN_WAIT2
• The peer moves into CLOSE_WAIT
• You can still call read() and receive data the peer sends before it also closes

shutdown(sockfd, SHUT_RD) is supposed to close only the read side of a TCP socket. In theory, after calling it, your read() calls should return EOF. But the actual behaviour is inconsistent across operating systems and the TCP spec does not define it clearly.

This is a classic pattern used in programs like netcat — read from stdin and send to server, then when stdin reaches EOF, signal the server you are done sending but still receive the server’s response.

half_close_client.c

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

#define PORT 9090
#define BUF_SIZE 1024

int main() {
    int sock_fd;
    struct sockaddr_in addr;
    char buf[BUF_SIZE];
    int n;

    sock_fd = socket(AF_INET, SOCK_STREAM, 0);

    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);

    if (connect(sock_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("connect failed");
        exit(1);
    }
    printf("Connected to server.\n");

    /* Send some data */
    const char *msg = "GET /index.html HTTP/1.0\r\n\r\n";
    write(sock_fd, msg, strlen(msg));
    printf("Sent request to server.\n");

    /*
     * HALF-CLOSE: We are done sending.
     * Sends FIN to server — server's read() returns EOF.
     * But we keep our read side open to receive the response.
     */
    if (shutdown(sock_fd, SHUT_WR) == -1) {
        perror("shutdown SHUT_WR failed");
        exit(1);
    }
    printf("Sent FIN (SHUT_WR). Still listening for server response...\n");

    /*
     * Now read whatever the server sends back.
     * This works because our read side is still open.
     */
    while ((n = read(sock_fd, buf, BUF_SIZE - 1)) > 0) {
        buf[n] = '\0';
        printf("From server: %s", buf);
    }

    if (n == 0) {
        printf("\nServer closed connection (EOF). Done.\n");
    } else {
        perror("read error");
    }

    /* Full close — both sides now */
    close(sock_fd);
    return 0;
}

What this demonstrates:

Client                          Server
------                          ------
connect() ──────────────────────> accept()
write(request) ─────────────────> read()
shutdown(SHUT_WR) ───FIN────────> read() returns 0 (EOF)
                                  Server knows client is done sending
                    <───data──── write(response)
read(response) ◄────────────────
                    <───FIN───── close()
read() returns 0 (EOF)
close()

Demonstration: close() vs shutdown() with dup()

#include <stdio.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

void demo_close_vs_shutdown(int sock_fd) {
    /* dup() creates a second file descriptor for same socket */
    int dup_fd = dup(sock_fd);
    printf("Original fd: %d, Dup fd: %d\n", sock_fd, dup_fd);

    /*
     * close(sock_fd) here:
     * - Decrements reference count from 2 to 1
     * - NO FIN is sent because dup_fd still refers to socket
     * - The peer does NOT see EOF
     */
    close(sock_fd);
    printf("close(sock_fd): FD count is now 1. No FIN sent yet.\n");

    /*
     * shutdown(dup_fd, SHUT_WR) here:
     * - Ignores reference count entirely
     * - FIN is sent immediately
     * - Peer sees EOF NOW
     */
    shutdown(dup_fd, SHUT_WR);
    printf("shutdown(dup_fd, SHUT_WR): FIN sent regardless of dup.\n");

    close(dup_fd); /* Final cleanup */
}