mineeeee

#include <iostream>
#include <map>
#include <vector>
#include <string>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <thread>

#define PORT 4444
#define BUFFER_SIZE 1024

using namespace std;

static map<string, vector<string>> fileDatabase;

// Function to send IP addresses of peers with the requested file
void sendIPAddress(int clientSocket, const string &filename)
{
    using namespace std;
    if (fileDatabase.find(filename) == fileDatabase.end())
    {
        string errorMsg = "File not found";
        send(clientSocket, errorMsg.c_str(), errorMsg.size(), 0);
        cerr << "Error: File not found - " << filename << "\n";
        return;
    }

    char buffer[BUFFER_SIZE];
    string fileIPAddresses = "";
    for (auto &k : fileDatabase[filename])
    {
        fileIPAddresses += k + ' ';
    }

    strcpy(buffer, fileIPAddresses.c_str());
    send(clientSocket, buffer, sizeof(buffer), 0);
    cout << "IP address sent successfully: " << filename << "\n";
}

// Function to handle communication with a client
void handleClient(int clientSocket)
{
    using namespace std;
    char buffer[BUFFER_SIZE] = {0};

    while (true)
    {
        memset(buffer, 0, BUFFER_SIZE); // Clear buffer before reading
        int bytesRead = read(clientSocket, buffer, BUFFER_SIZE);

        if (bytesRead <= 0)
        { // Client disconnected or error occurred
            close(clientSocket);
            return;
        }

        string command(buffer);

        if (command == "exit")
        {
            cout << "Client disconnected.\n";
            close(clientSocket);
            return;
        }

        if (command.rfind("Send ", 0) == 0)
        {                                        // Command starts with "Send"
            string filename = command.substr(5); // Extract filename
            sendIPAddress(clientSocket, filename);
        }
    }
}

// Function to handle client connections in a separate thread
void handleClientConnection(int clientSocket)
{
    handleClient(clientSocket);
}

int main()
{
    using namespace std;
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == -1)
    {
        cerr << "Failed to create socket.\n";
        return -1;
    }

    sockaddr_in serverAddr{};
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);
    serverAddr.sin_addr.s_addr = INADDR_ANY;

    if (bind(serverSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) == -1)
    {
        cerr << "Failed to bind socket.\n";
        close(serverSocket);
        return -1;
    }

    if (listen(serverSocket, 5) == -1)
    {
        cerr << "Failed to listen on socket.\n";
        close(serverSocket);
        return -1;
    }

    cout << "Server is listening on port " << PORT << "...\n";
    while (true)
    {
        sockaddr_in clientAddr{};
        socklen_t clientLen = sizeof(clientAddr);
        int clientSocket = accept(serverSocket, (struct sockaddr *)&clientAddr, &clientLen);

        if (clientSocket == -1)
        {
            cerr << "Failed to accept connection.\n";
            continue;
        }

        char buffer[2048] = {0};
        read(clientSocket, buffer, sizeof(buffer));
        string filesJson = string(buffer);

        std::string::size_type start = 0;
        std::string::size_type end = 0;

        while ((end = filesJson.find(':', start)) != std::string::npos)
        {
            string file = filesJson.substr(start, end - start);
            start = end + 1;

            std::string::size_type fileNameIndex = file.find(' ', 0);
            fileDatabase[file.substr(0, fileNameIndex)].push_back(file.substr(fileNameIndex + 1));
        }

        cout << "Client connected.\n";

        // Create a new thread to handle the client connection
        thread clientThread(handleClientConnection, clientSocket);
        clientThread.detach();
    }

    close(serverSocket);
    return 0;
}