Multiple connections sockets c++

Question

I'm trying to implement my own server and client side which uses sockets to send and receive data. But i got some problem with realization of multi-threading. My server.cpp:

#include <iostream>
#include <netinet/in.h>
#include <cstring>
#include <arpa/inet.h>
#include <unistd.h>
#include <thread>
using namespace std;

void connection_handler(int socket) {
    char client_message[256];
    memset(&client_message, 0, 256);
    size_t message_size = 0;

    while ((message_size = recv(socket, client_message, sizeof(client_message) - 1, 0)) > 0) {
        client_message[message_size] = '\0';
        cout << "[Server] Client message accepted" << endl;
        cout << "[Server] Client message: " << client_message << endl;

        if (write(socket, client_message, message_size) == -1) {
            cout << "[Client] Message sending failed" << endl;
            return;
        }
        cout << "[Server] Message sent to client" << endl << endl;
        cout << "============================" << endl << endl;
        cout.flush();

        memset(&client_message, 0, 256);
    }
}

int main() {
    unsigned short int PORT = 8080;
    int listener, client_socket;
    socklen_t client_len;

    struct sockaddr_in server_address{};

    memset(&server_address, 0, sizeof(server_address));

    listener = socket(AF_INET, SOCK_STREAM, 0);

    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(PORT);
    if (inet_aton("127.0.0.1", &server_address.sin_addr) == 0) {
        cout << "[Server] Invalid IP address" << endl;
        return -1;
    }

    if (bind(listener, (struct sockaddr*) &server_address, sizeof(server_address)) == -1) {
        cout << "[Server] Binding failed" << endl;
        return -1;
    }
    cout << "[Server] All setting are done" << endl;
    cout << "[Server] Server enabled" << endl;

    if (listen(listener, 100) == -1) {
        cout << "[Server] Listening failed" << endl;
        return -1;
    }
    cout << "[Server] Waiting for connection..." << endl;

    for (; ;) {
        client_socket = accept(listener, (struct sockaddr*) &server_address, &client_len);
        cout << "[Server] Connection accepted" << endl << endl;
        cout << "----------------------------" << endl << endl;

        int new_socket = client_socket;

        thread handling_thread(connection_handler, new_socket);
        handling_thread.detach();
    }
}

My client.cpp:

#include <iostream>
#include <netinet/in.h>
#include <cstring>
#include <arpa/inet.h>
#include <unistd.h>
using namespace std;

int main() {
    unsigned short int PORT = 8080;
    int sockfd;
    char buffer[256] = {0};
    struct sockaddr_in server_address{};

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    memset(&server_address, '0', sizeof(server_address));
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(PORT);
    server_address.sin_addr.s_addr = INADDR_ANY;

    if (connect(sockfd, (struct sockaddr*) &server_address, sizeof(server_address)) < 0) {
        cout << "[Client] Connection failed" << endl;
        return -1;
    }
    cout << "[Client] All setting are done" << endl;
    cout << "[Client] Succefully connected to server" << endl << endl;
    cout << "----------------------------" << endl << endl;

    while (true) {
        string client_request;
        cout << "[Client] Enter a message: ";
        getline(cin, client_request);

        if (client_request == "-1") {
            write(sockfd, client_request.c_str(), client_request.size());
            close(sockfd);
            cout << endl << "[Client] Client exited" << endl;
            return 0;
        }

        if (write(sockfd, client_request.c_str(), client_request.size()) == -1) {
            cout << "[Client] Message sending failed" << endl;
        }
        cout << "[Client] Message sent to server" << endl;

        memset(&buffer, 0, 256);
        read(sockfd, buffer, 256);

        cout << "[Client] Server message: " << buffer << endl << endl;
        cout << "============================" << endl << endl;
        cout.flush();
    }
}

It's perfectly working until i create one more connection to server and after that second client cans send and receive data, but first one at this time becomes not working. I compiled my program like this: g++ server.cpp -lpthread -o server -std=c++11 And then in other console tab run my compiled client.cpp: ./client. To check multi-threading working i run client one more time (in other tab again) and trying send requests in two tabs at the same time. I want to realize multi-threading in my program. How can i do this?

UPD: I'm using Linux

UPD2: Problem solved. Fixed code there.

Answer 1

    int new_socket = client_socket;

    thread handling_thread(connection_handler, &new_socket);
    handling_thread.detach();
}

This initializes new_socket, which gets declared in local scope inside this for loop, then passes the pointer to this new_socket to a new thread that gets started, and detached. Immediately after that, this for loop iteration ends, which destroys the new_socket object, before starting the next iteration of this loop.

Meanwhile, the execution thread repeatedly attempts to dereference the int * it receives, which now points to a destroyed object. This results in undefined behavior, and the likely reason your program is "not working".

The most simple solution is to create the int socket value in dynamic scope, using new, and then pass the pointer to this newed socket value to the execution thread. The execution thread will, of course, be responsible for retrieving the socket value, then properly deleteing it, to avoid leaking memory.

This should be sufficient for this simple program. More complicated programs will likely require slightly more sophisticated socket and dynamic scoping handling logic, for reliability.