C++ Network Programming: Implementation of TCP/IP Protocol

In modern computer networks, the TCP/IP protocol is one of the most important communication protocols. It provides a reliable way for data transmission between different devices. In this article, we will implement a simple TCP client and server using C++ to help beginners understand the basic concepts and usage of the TCP/IP protocol.

1. Introduction to TCP/IP Protocol

1.1 TCP and UDP

• TCP (Transmission Control Protocol): Connection-oriented, providing reliable data transmission services. Data packets arrive in order, and lost packets are retransmitted.
• UDP (User Datagram Protocol): Connectionless, does not guarantee the order and integrity of packets, suitable for applications that require high real-time performance but low reliability, such as video streaming.

1.2 Socket

A socket is an abstract concept in network communication that allows programs to exchange data over the network. In C++, we can use the socket API from the POSIX standard library to create and manage sockets.

2. Environment Setup

Before we begin, please ensure that your development environment has the following tools installed:

• C++ compiler (e.g., g++, clang, etc.)
• POSIX-compatible operating system (e.g., Linux or macOS)

3. Creating a TCP Server

Below is a simple example code for a TCP server:

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[BUFFER_SIZE] = {0};

    // Create socket
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
        std::cerr << "Socket creation error" << std::endl;
        return -1;
    }

    // Set socket options to allow port reuse
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));

    // Set address structure
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // Bind socket to the specified port
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
        std::cerr << "Bind failed" << std::endl;
        return -1;
    }

    // Start listening for client requests
    if (listen(server_fd, 3) < 0) {
        std::cerr << "Listen failed" << std::endl;
        return -1;
    }

    while (true) {
        std::cout << "Waiting for connections..." << std::endl;

        // Accept new connection requests
        if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen))<0) {
            std::cerr << "Accept failed" << std::endl;
            continue;
        }

        read(new_socket , buffer, BUFFER_SIZE);
        std::cout << "Message from client: " << buffer << std::endl;

        const char *response = "Hello from server";
        send(new_socket , response , strlen(response), MSG_CONFIRM);

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

Program Explanation:

• First, we create a socket and set its options to allow port reuse.
• Then we define the <span>address</span> structure to store the IP address and port number information.
• Using the <span>bind()</span> function, we bind the socket to the specified address and call the <span>listen()</span> function to start listening for client requests.
• In the main loop, we accept new connections from clients using the <span>accept()</span> function, read the incoming message, and then reply with a message to the client.

4. Creating a TCP Client

Below is the corresponding simple example code for a TCP client:

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define PORT     8080
#define SERVER_IP "127.0.0.1"
#define BUFFER_SIZE     1024

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char *hello_message = const_cast<char*>("Hello from client");

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

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

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

    // Attempt to connect to the server
    if (connect(sock , (struct sockaddr *)&serv_addr , sizeof(serv_addr)) != -1 ) {
        send(sock , hello_message , strlen(hello_message), MSG_CONFIRM);
        char buffer[BUFFER_SIZE] ={0};
        read(sock , buffer , BUFFER_SIZE);
        printf("%s\n",buffer );
    } else {
        perror("Connection Failed");
    }
    close(sock);
    return  0;
}

Program Explanation:

• The client first creates a socket of the same type as the server.
• Then it sets the target server’s information, including the IP address and port number.
• Using the <span>connect()</span> function, it attempts to establish a connection with the server. If successful, it sends a message and waits for a response.

Conclusion

This article introduced how to implement basic TCP/IP network programming using C++, including creating a simple server and client. Through these example codes, you can learn how to use the socket API for network communication. This is just a beginner level; in practical applications, you may need to handle more complex situations, such as multithreading and exception handling, but I hope this article lays a solid foundation for you.