Komunikator sieciowy typu IRC

Opis

Komunikacja między klientem a serwerem odbywa się za pomocą protokołu TCP. Jest on połączeniowy, co oznacza, że przed przesłaniem danych nawiązuje sesję pomiędzy serwerem, a klientem. Gwarantuje dostarczenie pakietów, retransmitując te, które zaginą. Każda transmisja kończy się procedurą zamknięcia połączenia. Jest wykorzystywany w aplikacjach wymagających stabilnej komunikacji. Struktura komunikacji obejmuje następujące komendy:

• USERS username1 username2 … – Serwer wysyła listę aktywnych użytkowników do klienta,
• exit – klient wysyła tę wiadomość do serwera przed rozłączeniem,
• /pm <username> <message> – wiadomość prywatna wysyłana do konkretnego użytkownika,
• dowolny inny ciąg znaków – traktowany jako wiadomość publiczna

Serwer odbiera wiadomości od klientów i przekazuje je do wszystkich podłączonych użytkowników lub do konkretnego odbiorcy w przypadku wiadomości prywatnej.

Opis implementacji

1. client.c (klient GTK uruchamiany w systemie Windows) – implementuje interfejs użytkownika oraz obsługuje komunikację sieciową
   • GUI: GTK jest używane do stworzenia interfejsu, który zawiera pole czatu, listę użytkowników oraz pola do wpisywania wiadomości i połączenia z serwerem
   • połączenie z serwerem jest realizowane za pomocą gniazd TCP
2. server.c (serwer uruchamiany w systemie Linux) – odpowiada za zarządzanie połączeniami klientów oraz przekazywanie wiadomości
   • każdy klient jest obsługiwany w osobnym wątku
   • serwer prowadzi listę aktywnych użytkowników
   • serwer przekazuje wiadomości do odpowiednich odbiorców

Kompilacja serwera: gcc -Wall server.c -o server -lpthread

Kompilacja klienta: gcc client.c -o client.exe $(pkg-config –cflags –libs gtk+-3.0) -pthread -lws2_32

Uruchomienie: ./server dla serwera w systemie Linux oraz uruchomienie aplikacji client.exe dla Windows

Obsługa aplikacji klienta:

• Po uruchomieniu klienta należy wprowadzić adres IP serwera, numer portu oraz nazwę użytkownika, a następnie kliknąć „Connect”
• Użytkownik może wysyłać wiadomości publiczne oraz prywatne, zaznaczając opcję „Private Message” i wybierając odbiorcę
• Aby zakończyć połączenie wystarczy, że użytkownik zamknie okno aplikacji

Prezentacja działania

Diagram

Implementacja

Kod serwera

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <signal.h>
#include <errno.h>

#define PORT 12345
#define MAX_CLIENTS 100
#define BUFFER_SIZE 1024
#define USERNAME_LEN 32

// Struktura klienta
typedef struct {
    int sockfd;
    char username[USERNAME_LEN];
} client_t;

client_t *clients[MAX_CLIENTS];
pthread_mutex_t clients_mutex = PTHREAD_MUTEX_INITIALIZER;

// ... (funkcje add_client, remove_client, broadcast_message, send_user_list, send_private_message, trim_newline)

// Główna funkcja obsługująca klienta
void *handle_client(void *arg) {
    char buffer[BUFFER_SIZE];
    char message[BUFFER_SIZE + USERNAME_LEN + 10];
    int leave_flag = 0;
    client_t *cli = (client_t *)arg;

    // Obsługa logowania klienta (pobranie nazwy użytkownika)
    // ...

    while(1) {
        if (leave_flag) break;
        
        // Odbieranie i przetwarzanie wiadomości
        int receive = recv(cli->sockfd, buffer, BUFFER_SIZE - 1, 0);
        if (receive > 0) {
            // Obsługa komend (/pm) i zwykłych wiadomości
            // ...
        } else if (receive == 0 || (errno != EWOULDBLOCK && errno != EAGAIN)) {
            leave_flag = 1;
        }
    }

    // Czyszczenie po kliencie (usunięcie z listy, powiadomienie innych, zamknięcie połączenia)
    // ...

    return NULL;
}

int main() {
    int sockfd, new_sock;
    struct sockaddr_in server_addr, client_addr;
    pthread_t tid;

    // Inicjalizacja serwera (socket, bind, listen)
    // ...

    printf("=== WITAJ W CHATROOMIE ===\n");

    while(1) {
        // Akceptowanie nowych połączeń
        new_sock = accept(sockfd, (struct sockaddr*)&client_addr, &clilen);
        if(new_sock < 0) continue;

        // Sprawdzenie limitu klientów
        // ...

        // Inicjalizacja struktury klienta
        client_t *cli = malloc(sizeof(client_t));
        cli->sockfd = new_sock;
        strcpy(cli->username, "Anonymous");

        // Dodanie klienta i utworzenie wątku obsługi
        add_client(cli);
        pthread_create(&tid, NULL, &handle_client, (void*)cli);
        pthread_detach(tid);
    }

    close(sockfd);
    return 0;
}

Kod klienta

#include <gtk/gtk.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
// ... (nagłówki systemowe i definicje dla Windows/Unix)

#define BUFFER_SIZE 1024
#define USERNAME_LEN 32

// Główne widgety aplikacji i stan połączenia
typedef struct {
    GtkWidget *window, *ip_entry, *port_entry, *username_entry, *connect_button;
    GtkWidget *chat_view, *message_entry, *send_button, *user_list;
    GtkWidget *private_toggle;
    
    SOCKET sockfd;              // Deskryptor gniazda
    pthread_t recv_thread;      // Wątek odbierający wiadomości
    gboolean connected;         // Flaga połączenia
} AppWidgets;

// Funkcje pomocnicze do obsługi tekstu
void trim_newline(char *s) { ... }  // Usuwa znaki nowej linii

// Mechanizm wyświetlania wiadomości w interfejsie GTK (wykonywane w wątku GUI)
typedef struct {
    AppWidgets *widgets;
    char *message;
} ChatMessage;

gboolean append_chat_text(gpointer data) { ... }  // Dodaje tekst do widoku czatu
void add_chat_message(AppWidgets *widgets, const char *message) { ... }  // Kolejkuje wiadomość do wyświetlenia

// Aktualizacja listy użytkowników (format: "USERS user1 user2...")
void update_user_list(AppWidgets *widgets, char *buffer) {
    // Parsowanie listy użytkowników z wiadomości
    // Aktualizacja widoku listy użytkowników przez g_idle_add()
}

// Główny wątek odbierający wiadomości z serwera
void *recv_handler(void *arg) {
    AppWidgets *widgets = (AppWidgets *)arg;
    char buffer[BUFFER_SIZE];
    
    while(widgets->connected) {
        int receive = recv(widgets->sockfd, buffer, BUFFER_SIZE, 0);
        if(receive > 0) {
            buffer[receive] = '\0';
            // Obsługa zwykłych wiadomości i aktualizacji listy użytkowników
            if(strncmp(buffer, "USERS ", 6) == 0) {
                update_user_list(widgets, buffer);
            } else {
                add_chat_message(widgets, buffer);
            }
        } else { // Błąd lub rozłączenie
            widgets->connected = FALSE;
        }
    }
    return NULL;
}

// Nawiązanie połączenia z serwerem
void on_connect_clicked(GtkButton *button, AppWidgets *widgets) {
    // Pobranie danych z pól wejściowych
    const char *ip = gtk_entry_get_text(GTK_ENTRY(widgets->ip_entry));
    const char *port_str = gtk_entry_get_text(GTK_ENTRY(widgets->port_entry));
    const char *username = gtk_entry_get_text(GTK_ENTRY(widgets->username_entry));
    
    // Inicjalizacja gniazda i połączenie
    widgets->sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in server_addr = {
        .sin_family = AF_INET,
        .sin_port = htons(atoi(port_str)),
        .sin_addr.s_addr = inet_addr(ip)
    };
    
    if(connect(widgets->sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == 0) {
        // Wysłanie nazwy użytkownika
        char user_msg[USERNAME_LEN];
        snprintf(user_msg, sizeof(user_msg), "%s\n", username);
        send(widgets->sockfd, user_msg, strlen(user_msg), 0);
        
        // Uruchomienie wątku odbierającego
        widgets->connected = TRUE;
        pthread_create(&widgets->recv_thread, NULL, recv_handler, (void*)widgets);
    }
}

// Wysyłanie wiadomości do serwera
void on_send_clicked(GtkButton *button, AppWidgets *widgets) {
    const char *message = gtk_entry_get_text(GTK_ENTRY(widgets->message_entry));
    
    if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->private_toggle))) {
        // Wysyłanie prywatnej wiadomości (/pm odbiorca treść)
        char send_buffer[BUFFER_SIZE];
        snprintf(send_buffer, sizeof(send_buffer), "/pm %s %s\n", wybrany_uzytkownik, message);
        send(widgets->sockfd, send_buffer, strlen(send_buffer), 0);
    } else {
        // Wysyłanie publicznej wiadomości
        send(widgets->sockfd, message, strlen(message), 0);
    }
}

// Zamknięcie aplikacji
void on_window_destroy(GtkWidget *widget, AppWidgets *widgets) {
    if(widgets->connected) {
        send(widgets->sockfd, "exit\n", 5, 0);  // Powiadomienie serwera
        close(widgets->sockfd);
    }
    gtk_main_quit();
}

int main(int argc, char *argv[]) {
    // Inicjalizacja GTK i tworzenie interfejsu
    gtk_init(&argc, &argv);
    AppWidgets *widgets = g_slice_new(AppWidgets);
    
    // Tworzenie okna głównego i wszystkich widgetów
    widgets->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    // (tworzenie interfejsu użytkownika)
    
    gtk_widget_show_all(widgets->window);
    gtk_main();
    return 0;
}