Приложение 2 Текст программы «server222.Cpp»

#include <iostream>

#include <sys/sysinfo.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <unistd.h>

#include <cstring>

#include <ctime>

#include <thread>

#include <arpa/inet.h> // For inet_pton

// Function to send logs to the logging server

void sendLog(const std::string& message, const std::string& serverId) {

int logSocket = socket(AF_INET, SOCK_STREAM, 0);

if (logSocket < 0) {

std::cerr << "Error creating socket for logging" << std::endl;

return;

}

struct sockaddr_in logServerAddress;

logServerAddress.sin_family = AF_INET;

logServerAddress.sin_port = htons(9000); // Logging server port

inet_pton(AF_INET, "127.0.0.1", &logServerAddress.sin_addr); // Logging server IP

if (connect(logSocket, (struct sockaddr*)&logServerAddress, sizeof(logServerAddress)) < 0) {

std::cerr << "Error connecting to the logging server" << std::endl;

close(logSocket);

return;

}

// Send server identifier

send(logSocket, serverId.c_str(), serverId.size(), 0);

// Send log message

send(logSocket, message.c_str(), message.size(), 0);

close(logSocket);

}

// Function to retrieve system information

void getSystemInfo(std::string& response, const std::string& unit) {

struct sysinfo info;

if (sysinfo(&info) != 0) {

response += "Error retrieving system information.\n";

return;

}

long totalMemory = info.totalram; // Total physical memory in bytes

long freeMemory = info.freeram; // Free physical memory in bytes

// Convert to the selected unit of measurement

if (unit == "mb") {

totalMemory /= (1024 * 1024);

freeMemory /= (1024 * 1024);

response += "Total physical memory: " + std::to_string(totalMemory) + " MB\n";

response += "Free physical memory: " + std::to_string(freeMemory) + " MB\n";

} else if (unit == "gb") {

totalMemory /= (1024 * 1024 * 1024);

freeMemory /= (1024 * 1024 * 1024);

response += "Total physical memory: " + std::to_string(totalMemory) + " GB\n";

response += "Free physical memory: " + std::to_string(freeMemory) + " GB\n";

} else {

response += "Total physical memory: " + std::to_string(totalMemory) + " bytes\n";

response += "Free physical memory: " + std::to_string(freeMemory) + " bytes\n";

}

}

// Function to get the current time

std::string getCurrentTime() {

time_t now = time(0);

char buffer[80];

struct tm tstruct;

localtime_r(&now, &tstruct); // Use localtime_r for thread safety

strftime(buffer, sizeof(buffer), "%Y-%m-%d %X", &tstruct);

return std::string(buffer);

}

// Function to handle a client

void handleClient(int clientSocket) {

sendLog("Client connected", "server2");

char unitBuffer[10];

recv(clientSocket, unitBuffer, sizeof(unitBuffer) - 1, 0);

unitBuffer[sizeof(unitBuffer) - 1] = '\0'; // Null-terminate the string

std::string unit(unitBuffer);

std::string response;

getSystemInfo(response, unit);

response += "Current time: " + getCurrentTime() + "\n";

send(clientSocket, response.c_str(), response.size(), 0);

sendLog("Client request processed", "server2");

close(clientSocket);

std::cout << "Connection with the client closed." << std::endl;

sendLog("Connection with the client closed", "server2");

}

int main() {

sendLog("Server 2 started", "server2");

int serverSocket = socket(AF_INET, SOCK_STREAM, 0);

if (serverSocket < 0) {

std::cerr << "Error creating socket" << std::endl;

sendLog("Error creating socket", "server2");

return 1;

}

struct sockaddr_in serverAddress;

serverAddress.sin_family = AF_INET;

serverAddress.sin_addr.s_addr = INADDR_ANY;

serverAddress.sin_port = htons(8082);

if (bind(serverSocket, (struct sockaddr*)&serverAddress, sizeof(serverAddress)) < 0) {

std::cerr << "Error binding socket" << std::endl;

sendLog("Error binding socket", "server2");

close(serverSocket);

return 1;

}

listen(serverSocket, 5);

std::cout << "Server started and waiting for connections on port 8082..." << std::endl;

sendLog("Server waiting for connections on port 8082", "server2");

while (true) {

int clientSocket = accept(serverSocket, nullptr, nullptr);

if (clientSocket < 0) {

std::cerr << "Error accepting connection" << std::endl;

sendLog("Error accepting connection", "server2");

continue;

}

std::cout << "Client connected!" << std::endl;

// Create a new thread to handle the client

std::thread clientThread(handleClient, clientSocket);

clientThread.detach(); // Detach the thread to allow it to run independently

}

close(serverSocket);

return 0;

}