Verteilte Systeme

Probeklausur SoSe 2023

Gegeben sei die folgende C++-Implementierung eines Clients in einer Server-Client-Anwendung, die via Sockets Daten in Form eines Strings vom Client zum Server sendet.


#include <iostream >
#include <cstring > // Needed for memset
#include <sys/socket.h>
#include <arpa/inet.h> // For inet_addr
#include <unistd.h>
 
#define MAX_BUFFER_SIZE 1024
#define PORT 8081
 
int main() {
    int sock;
    struct sockaddr_in server;
    char message[MAX_BUFFER_SIZE];
 
    // Create socket
    sock = socket(AF_INET , SOCK_STREAM , 0);
    if (sock == -1) {
        std::cerr << "Could not create socket\n";
        return 1;
    }
 
    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    server.sin_family = AF_INET;
    server.sin_port = htons(PORT);
 
    // Connect to server
    if (connect(sock , (struct sockaddr*)&server , sizeof(server)) < 0) {
        std::cerr << "Connect failed\n";
        return 1;
    }
 
    std::cout << "Connected\n";
 
    // Communicate with the server
    std::cout << "Enter a message: ";
    std::cin.getline(message , MAX_BUFFER_SIZE);
    if (send(sock , message , strlen(message), 0) < 0) {
        std::cerr << "Send failed\n";
        return 1;
    }
 
    std::cout << "Closing connection ...\n";
    close(sock);
 
    return 0;
}

Teilaufgabe 1:

Wir wollen zur Steigerung der Effizienz der Kommunikation nun nicht mehr ASCII-Zeichen sondern ganze Zahlen (Integer) im Binärformat versenden. Passen Sie den Client entsprechend an, dass nun ein Integer-Wert anstelle eines Strings versendet wird. Hinweis: Sie müssen nicht den bestehend Quellcode abschreiben. Geben Sie Zeilennummern an, um kenntlich zu machen, wo Sie welche Änderungen vornehmen.

Antwort:


char message[MAX_BUFFER_SIZE]; -> int message;
 
std::cout << "Enter a number: ";
std::cin >> number;
 
if(send(sock , &number , sizeof(number), 0) < 0) {
    std::cerr << "Send failed\n";
    return 1;
}

Teilaufgabe 2:

Erläutern Sie kurz, welche Änderungen auf Seiten des Servers notwendig sind und welche Aspekte beim Versand von Binärdaten noch zu beachten sind, um die gewünschte Funktionalität zu realisieren.

Antwort:

Der Server muss anstelle eines char-Arrays einen int-Puffer verwenden.
Ersetze recv(sock, buffer, MAX_BUFFER_SIZE, 0) durch recv(sock, &number, sizeof(number), 0).
Beim Senden sollte sichergestellt werden, dass die Daten in Network Byte Order gesendet werden.
Senden: htonl(number)
Empfangen: ntohl(number)

PE2 SoSe 2023

Gegeben sei die folgende C++-Implementierung eines Servers in einer Server-Client-Anwendung, die via Sockets Daten in Form eines Strings vom Client zum Server sendet


#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h> // For inet_addr
#include <unistd.h>
 
#define MAX_BUFFER_SIZE 1024
#define PORT 8081
 
int main() {
    int sock, client_sock;
    struct sockaddr_in server, client;
    char buffer[MAX_BUFFER_SIZE];
 
    // Create socket
    sock = socket(AF_INET, SOCK_STREAM , 0);
    if (sock == -1) {
        std::cerr << "Could not create socket\n";
        return 1;
    }
 
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons(PORT);
 
    // Bind
    if (bind(sock, (struct sockaddr*)&server , sizeof(server)) < 0) {
        std::cerr << "Bind failed\n";
        return 1;
    }
 
    // Listen
    listen(sock , 3);
 
    // Accept incoming connections
    std::cout << "Waiting for incoming connections ...\n";
    socklen_t c = sizeof(struct sockaddr_in);
    client_sock = accept(sock, (struct sockaddr*)&client , &c);
    if (client_sock < 0) {
        std::cerr << "Accept failed\n";
        return 1;
    }
 
    std::cout << "Connection accepted\n";
 
    // Receive a message from the client
    while (true) {
        ssize_t received = recv(client_sock, buffer, MAX_BUFFER_SIZE, 0);
        if (received <= 0) {
            break;
        }
        std::cout << "Received message: " << buffer << "\n";
    }
 
    std::cout << "Closing connection ...\n";
    close(client_sock);
    close(sock);
 
    return 0;
}

Teilaufgabe 1:

Erweitern Sie die Anwendung in der Art, dass der Server eine Antwort mit dem Inhalt ACK an den Client zurücksendet. Hinweis: Sie müssen nicht den bestehend Quellcode abschreiben. Geben Sie Zeilennummern an, um kenntlich zu machen, wo Sie welche Änderungen vornehmen.

Antwort:


const char* ackMessage = "ACK";
send(client_sock, ackMessage, strlen(ackMessage), 0);

Teilaufgabe 2:

Erläutern Sie kurz, welche Änderungen auf Seiten des Clients notwendig sind, um die gewünschte Funktionalität zu realisieren.

Der Client muss auf die Antwort des Servers warten.
Eine recv-Funktion muss verwendet werden, um die Antwort des Servers zu empfangen.


if(recv(sock, server_reply, MAX_BUFFER_SIZE, 0) < 0) {
    std::cerr << "Recv failed\n";
    return 1;
} else {
    std::cout << "Server reply: " << server_reply << "\n";
}

PE2 WiSe 2023

Gegeben ist im Folgenden die C++-Implementierung eines Servers und eines Clients in einer Server-Client-Anwendung, die via Sockets Daten in Form eines Strings vom Client zum Server sendet.

Die Anwendung soll im Folgenden um eine primitive Authentifizierungslogik erweitert werden. Vor dem Senden der Daten soll der Client einen vordefinierten User-Token an den Server senden. Der Server soll überprüfen, ob der Token korrekt ist und nur in diesem Fall die weiteren Daten empfangen. Falls der Token inkorrekt ist, soll der Server auf einen neuen Authentifizierungsversuch warten.

Sowohl Server als auch Client ist der korrekte Token bekannt, bspw. als const char* validUserToken = "123456abcefg".

Client


#include <iostream >
#include <cstring > // Needed for memset
#include <sys/socket.h>
#include <arpa/inet.h> // For inet_addr
#include <unistd.h>
 
#define MAX_BUFFER_SIZE 1024
#define PORT 8081
 
int main() {
    int sock;
    struct sockaddr_in server;
    char message[MAX_BUFFER_SIZE];
 
    // Create socket
    sock = socket(AF_INET , SOCK_STREAM , 0);
    if (sock == -1) {
        std::cerr << "Could not create socket\n";
        return 1;
    }
 
    server.sin_addr.s_addr = inet_addr("127.0.0.1");
    server.sin_family = AF_INET;
    server.sin_port = htons(PORT);
 
    // Connect to server
    if (connect(sock , (struct sockaddr*)&server , sizeof(server)) < 0) {
        std::cerr << "Connect failed\n";
        return 1;
    }
 
    std::cout << "Connected\n";
 
    // Communicate with the server
    std::cout << "Enter a message: ";
    std::cin.getline(message , MAX_BUFFER_SIZE);
    if (send(sock , message , strlen(message) + 1, 0) < 0) {
        std::cerr << "Send failed\n";
        return 1;
    }
 
    std::cout << "Closing connection ...\n";
    close(sock);
 
    return 0;
}

Teilaufgabe 1:

Erweitern Sie den Client, sodass der Token an den Server gesendet wird.

Antwort:


const char* token = "123456abcefg";
if(send(sock, token, strlen(token) + 1, 0) < 0) {
    std::cerr << "Send failed\n";
    return 1;
}
 
// Receive server response
char response[MAX_BUFFER_SIZE];
ssize_t received = recv(sock, response, MAX_BUFFER_SIZE, 0);
if (received <= 0) {
    std::cerr << "No response from server\n";
    close(sock);
    return 1;
}
 
if (strcmp(response, "AUTH_SUCCESS") != 0) {
    std::cerr << "Authentication failed\n";
    close(sock);
    return 1;
}

Teilaufgabe 2:

Erweitern Sie den Server, sodass der Token empfangen und die oben beschriebene Authentifizierungslogik realisiert wird.

Antwort:


const char* token = "123456abcefg";
 
while (true) {
    ssize_t received = recv(client_sock, buffer, MAX_BUFFER_SIZE, 0);
    if (received <= 0) {
        std::cerr << "Client disconnected during authentication.\n";
        close(client_sock);
        close(sock);
        return 1;
    }
 
    if (strcmp(buffer, validUserToken) == 0) {
        send(client_sock, "AUTH_SUCCESS", strlen("AUTH_SUCCESS") + 1, 0);
        std::cout << "Client authenticated successfully.\n";
        break;
    } else {
        send(client_sock, "AUTH_FAILED", strlen("AUTH_FAILED") + 1, 0);
        std::cerr << "Authentication failed. Waiting for another attempt...\n";
    }
}

PE2 SoSe 2024

Gegeben ist im Folgenden eine unvollständige C++-Implementierung einer Socket-Wrapper-Klasse. Ihre Aufgabe ist die Implementierung der fehlenden Methoden. Die geforderten Funktionssignaturen entnehmen Sie dem untenstehenden Quellcode. Verwenden Sie für Strings ausschließlich Teile der C++-Standardbibliothek!

Die send-Methode soll einen übergebenen String über den Socket der Klasse verschicken. Der String soll dabei durch die Zeichenkette $$$ terminiert werden. Verschickte Nachrichten sollen zusätzlich über die Konsole ausgegeben werden. Achten Sie auf eine angemessene Fehlerbehandlung inklusive Konsolenausgaben.

Die recv-Methode soll Strings über den Socket der Klasse, in 256 Byte Blöcken, empfangen. Eingehende Blöcke sollen, bis zum Empfang des Terminierungsstrings, zusammengesetzt werden. Leere Blöcke werden dabei ignoriert. Der empfangene String soll ohne Terminierungssymbole zurückgegeben werden. Achten Sie auf eine angemessene Fehlerbehandlung inklusive Konsolenausgaben.

socket.hpp


#include <string>
#include <netinet/in.h>
 
class Socket {
private:
    sockaddr_in _address;
    int _socket;
 
public:
    Socket(std::string ip, int port);
    Socket(int socket);
 
    void send(std::string msg);
    std::string recv(void);
    void close(void);
};

Teilaufgabe 1:

Dem Entwickler der Socket-Bibliothek ist ein kleiner Fehler bei der Socket-Konfiguration unterlaufen. Finden und korrigieren Sie den Fehler.

Antwort:

Der Port wird nicht richtig gesetzt. Mit htons wird der Port in Network Byte Order gesetzt.


_address.sin_port = htons(PORT);

Teilaufgabe 2:

Implementieren Sie eine send-Methode, welche den oben beschriebenen Anforderungen entspricht.

Antwort:

Es wird das Terminierungszeichen $$$ am Ende des Strings hinzugefügt.
::send wird verwendet, um den String über den Socket zu senden.


void Socket::send(std::string msg) {
    msg += "$$$";  // Terminierungszeichen hinzufügen
    ssize_t sentBytes = ::send(_socket, msg.c_str(), msg.size(), 0);
 
    if (sentBytes == -1) {
        std::cerr << "Fehler beim Senden: " << strerror(errno) << std::endl;
        return;
    }
 
    std::cout << "Gesendete Nachricht: " << msg << std::endl;
}

Teilaufgabe 3:

Implementieren Sie eine recv-Methode, welche den oben beschriebenen Anforderungen entspricht.

Antwort:


std::string Socket::recv(void) {
    constexpr size_t BUFFER_SIZE = 256;
    char buffer[BUFFER_SIZE];
    std::string receivedMsg;
 
    while (true) {
        memset(buffer, 0, BUFFER_SIZE);
        ssize_t receivedBytes = ::recv(_socket, buffer, BUFFER_SIZE - 1, 0);
 
        if (receivedBytes == -1) {
            std::cerr << "Fehler beim Empfangen: " << strerror(errno) << std::endl;
            return "";
        }
        if (receivedBytes == 0) {
            std::cerr << "Verbindung wurde geschlossen." << std::endl;
            return "";
        }
 
        buffer[receivedBytes] = '\0';  // Sicherstellen, dass der String terminiert ist
        receivedMsg += buffer;
 
        // Prüfen, ob die Nachricht die Terminierungszeichen enthält
        size_t pos = receivedMsg.find("$$$");
        if (pos != std::string::npos) {
            receivedMsg = receivedMsg.substr(0, pos);  // Terminierungszeichen entfernen
            break;
        }
    }
 
    std::cout << "Empfangene Nachricht: " << receivedMsg << std::endl;
    return receivedMsg;
}

Verteilte Systeme

Probeklausur SoSe 2023

PE2 SoSe 2023

PE2 WiSe 2023

Client

Server

PE2 SoSe 2024

socket.hpp

socket.cpp