How to write a simple TCP client/server in C

The answer is that writing a simple TCP client and server requires the socket programming interface provided by the operating system. The server completes communication by creating sockets, binding addresses, listening to ports, accepting connections, and sending and receiving data. The client realizes interaction by creating sockets, connecting to servers, sending requests, and receiving responses. The sample code shows the basic implementation of using the Berkeley socket API on Linux or macOS, including the necessary header files, port settings, error handling and resource release. After compilation, run the server first and then run the client to achieve two-way communication. The Windows platform needs to initialize the Winsock library. This example is a blocking I/O model, suitable for learning basic socket programming.

Writing a simple TCP client and server in C involves using the socket programming interface provided by the operating system (typically the Berkeley sockets API on Unix-like systems, or Winsock on Windows). Below is a basic example that works on Linux or macOS. For Windows, slight modifications are needed (like initializing Winsock).

Basic TCP Server in C

The server listens on a port, accepts a client connection, receives a message, and sends a response.

 // server.cpp
#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int addrlen = sizeof(address);
    char buffer[1024] = {0};
    const char *hello = "Hello from server";

    // Create socket file descriptor
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // Define server address
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);

    // Bind the socket
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // Listen for incoming connections
    if (listen(server_fd, 3) < 0) {
        perror("listen");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    std::cout << "Server listening on port 8080...\n";

    // Accept a connection
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
        perror("accept");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // Read data from client
    read(new_socket, buffer, 1024);
    std::cout << "Client: " << buffer << std::endl;

    // Send response
    send(new_socket, hello, strlen(hello), 0);
    std::cout << "Hello message sent\n";

    // Cleanup
    close(new_socket);
    close(server_fd);
    return 0;
}

Basic TCP Client in C

The client connects to the server, sends a message, and reads the response.

 // client.cpp
#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    const char *hello = "Hello from client";
    char buffer[1024] = {0};

    // Create socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Socket creation error");
        return -1;
    }

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    // Convert IPv4 address from text to binary
    if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
        perror("Invalid address / Address not supported");
        close(sock);
        return -1;
    }

    // Connect to server
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        perror("Connection failed");
        close(sock);
        return -1;
    }

    // Send message to server
    send(sock, hello, strlen(hello), 0);
    std::cout << "Hello message sent\n";

    // Read response
    read(sock, buffer, 1024);
    std::cout << "Server: " << buffer << std::endl;

    // Cleanup
    close(sock);
    return 0;
}

How to Compile and Run

On Linux/macOS:

 g server.cpp -o server
g client.cpp -o client

# Terminal 1
./server

# Terminal 2 (after server is running)
./client

Expected output:

• Server prints: Server listening on port 8080... , then the client message, then Hello message sent .
• Client prints: Hello message sent , then Server: Hello from server .

Key Points

• Headers : sys/socket.h , netinet/in.h , arpa/inet.h , unistd.h are essential for socket programming on Unix.
• Port : The server binds to port 8080. Make sure it's free.
• IP Address : The client uses 127.0.0.1 (localhost). Change if connecting to a remote server.
• Blocking I/O : These examples use blocking sockets. Real applications may use non-blocking I/O or multiple threads.
• Error Handling : Always check return values of socket functions.

Notes for Windows

On Windows, you must:

• Include <winsock2.h> and link with ws2_32.lib .
• Call WSAStartup() before using sockets.
• Call WSACleanup() at the end.

Example snippet:

 WSADATA wsaData;
WSAStartup(MAKEWORD(2,2), &wsaData);
// ... socket code ...
WSACleanup();

This is a minimal working example. In production, you'd add error recovery, support for multiple clients (using fork , threads, or async I/O), and better data framing.

Basically just the essentials to get a socket pair talking.

The above is the detailed content of How to write a simple TCP client/server in C. For more information, please follow other related articles on the PHP Chinese website!