TcpUdpKursValut

Client

#define _WINSOCK_DEPRECATED_NO_WARNINGS

#include <iostream>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <string>

#pragma comment(lib, "ws2_32.lib")

using namespace std;

class CurrencyClient {
private:
    SOCKET sock;

public:
    void connectToServer(const string& ip, int port) {
        WSADATA wsa;

        if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {
            cout << "WSAStartup failed\n";
            return;
        }

        sock = socket(AF_INET, SOCK_STREAM, 0);

        if (sock == INVALID_SOCKET) {
            cout << "Socket creation error\n";
            return;
        }

        sockaddr_in serverAddr{};
        serverAddr.sin_family = AF_INET;
        serverAddr.sin_port = htons(port);

        inet_pton(AF_INET, ip.c_str(), &serverAddr.sin_addr);

        if (connect(sock, (sockaddr*)&serverAddr, sizeof(serverAddr)) < 0) {
            cout << "Connection failed\n";
            return;
        }

        cout << "Connected to server\n";
    }

    void run() {
        string input;
        char buffer[1024];

        while (true) {
            cout << "Enter currencies (USD EUR) or EXIT: ";
            getline(cin, input);   // ✔️ тепер працює

            send(sock, input.c_str(), (int)input.size(), 0);

            if (input == "EXIT") break;

            memset(buffer, 0, sizeof(buffer));

            int bytes = recv(sock, buffer, sizeof(buffer), 0);

            if (bytes <= 0) {
                cout << "Server disconnected\n";
                break;
            }

            string response(buffer, bytes);
            cout << "Rate: " << response << endl;
        }

        closesocket(sock);
        WSACleanup();
    }
};

int main() {
    CurrencyClient client;
    client.connectToServer("127.0.0.1", 54000);
    client.run();

    return 0;
}

Server

#define _WINSOCK_DEPRECATED_NO_WARNINGS

#include <iostream>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <thread>
#include <fstream>
#include <map>
#include <vector>
#include <ctime>
#include <sstream>
#include <string>

#pragma comment(lib, "ws2_32.lib")

using namespace std;

class Logger {
private:
    ofstream file;

public:
    Logger(const string& filename) {
        file.open(filename, ios::app);
    }

    string getTime() {
        time_t now = time(0);
        char buffer[26];
        ctime_s(buffer, sizeof(buffer), &now);
        return string(buffer);
    }

    void log(const string& message) {
        file << "[" << getTime() << "] " << message << endl;
    }
};

class CurrencyService {
private:
    map<string, double> rates;

public:
    CurrencyService() {
        rates["USD"] = 1.0;
        rates["EUR"] = 0.86;
        rates["UAH"] = 38.0;
    }

    double getRate(const string& from, const string& to) {
        if (rates.count(from) && rates.count(to)) {
            return rates[to] / rates[from];
        }
        return -1;
    }
};

class ClientHandler {
private:
    SOCKET clientSocket;
    string clientIP;
    int clientPort;
    Logger& logger;
    CurrencyService& service;
    vector<string> queries;

public:
    ClientHandler(SOCKET sock, string ip, int port, Logger& log, CurrencyService& srv)
        : clientSocket(sock), clientIP(ip), clientPort(port), logger(log), service(srv) {}

    void handle() {
        logger.log("Client connected: " + clientIP + ":" + to_string(clientPort));

        char buffer[1024];

        while (true) {
            memset(buffer, 0, sizeof(buffer));

            int bytes = recv(clientSocket, buffer, sizeof(buffer), 0);
            if (bytes <= 0) break;

            string request(buffer, bytes);

            if (request == "EXIT") break;

            queries.push_back(request);

            // ✔️ Безпечний парсинг
            string from, to;
            stringstream ss(request);
            ss >> from >> to;

            double rate = service.getRate(from, to);
            string response;

            if (rate < 0)
                response = "ERROR";
            else
                response = to_string(rate);

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

        logger.log("Client disconnected: " + clientIP + ":" + to_string(clientPort));
        logger.log("Queries:");

        for (auto& q : queries)
            logger.log("  " + q);

        closesocket(clientSocket);
    }
};

class CurrencyServer {
private:
    SOCKET serverSocket;
    Logger logger;
    CurrencyService service;

public:
    CurrencyServer() : logger("log.txt") {}

    void start(int port) {
        WSADATA wsa;
        WSAStartup(MAKEWORD(2, 2), &wsa);

        serverSocket = socket(AF_INET, SOCK_STREAM, 0);

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

        bind(serverSocket, (sockaddr*)&serverAddr, sizeof(serverAddr));
        listen(serverSocket, 5);

        cout << "Server started on port " << port << "...\n";

        while (true) {
            sockaddr_in clientAddr{};
            int size = sizeof(clientAddr);

            SOCKET clientSocket = accept(serverSocket, (sockaddr*)&clientAddr, &size);

            // ✔️ Безпечне отримання IP
            char ipStr[INET_ADDRSTRLEN];
            inet_ntop(AF_INET, &clientAddr.sin_addr, ipStr, INET_ADDRSTRLEN);

            string ip(ipStr);
            int port = ntohs(clientAddr.sin_port);

            thread([=, this]() mutable {
                ClientHandler handler(clientSocket, ip, port, logger, service);
                handler.handle();
            }).detach();
        }
    }
};

int main() {
    CurrencyServer server;
    server.start(54000);
    return 0;
}