Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· openaiHugging Face Suzhen/CodeChat

Zrealizować komunikację klient-serwer z użyciem gniazd domeny uniksowej (tworzone…

  1. User

    Zrealizować komunikację klient-serwer z użyciem gniazd domeny uniksowej (tworzone funkcjąsocket, a nie socketpair).Klient nadaje tekst (imię i nazwisko), a serwer odbiera i odsyła tekst dużymi literami do klienta.

  2. Assistant

    Poniżej przedstawiam przykładową implementację prostej komunikacji klient-serwer w języku C z użyciem gniazd domeny uniksowej (Unix domain sockets), gdzie klient wysyła tekst (imię i nazwisko), a serwer odbiera ten tekst, konwertuje go na wielkie litery i odsyła z powrotem do klienta.

    Uwaga: Do zbudowania tego przykładu potrzebne są podstawowe znajomości języka C i systemu operacyjnego Linux, a także narzędzi takich jak gcc dla kompilacji.

    Serwer:

    #include <sys/socket.h>
    #include <sys/un.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <ctype.h>
    
    #define SOCKET_NAME "/tmp/demoSocket"
    
    int main() {
        struct sockaddr_un name;
        int ret;
        int connection_socket;
        int data_socket;
        int result;
        char buffer[256];
    
        unlink(SOCKET_NAME);
    
        // Utworzenie gniazda domeny uniksowej
        connection_socket = socket(AF_UNIX, SOCK_STREAM, 0);
        if (connection_socket == -1) {
            perror("socket");
            exit(EXIT_FAILURE);
        }
    
        // Konfiguracja
        memset(&name, 0, sizeof(struct sockaddr_un));
    
        name.sun_family = AF_UNIX;
        strncpy(name.sun_path, SOCKET_NAME, sizeof(name.sun_path) - 1);
    
        // Wiązanie gniazda
        ret = bind(connection_socket, (const struct sockaddr *) &name, sizeof(struct sockaddr_un));
        if (ret == -1) {
            perror("bind");
            exit(EXIT_FAILURE);
        }
    
        // Nasłuchiwanie
        ret = listen(connection_socket, 20);
        if (ret == -1) {
            perror("listen");
            exit(EXIT_FAILURE);
        }
    
        // Akceptacja przychodzących połączeń
        data_socket = accept(connection_socket, NULL, NULL);
        if (data_socket == -1) {
            perror("accept");
            exit(EXIT_FAILURE);
        }
    
        // Przetwarzanie przychodzących danych
        while (1) {
            ret = read(data_socket, buffer, sizeof(buffer));
            if (ret == -1) {
                perror("read");
                exit(EXIT_FAILURE);
            }
    
            // Konwersja na wielkie litery
            for (int i = 0; buffer[i]; i++) {
                buffer[i] = toupper(buffer[i]);
            }
    
            // Wysłanie danych z powrotem do klienta
            ret = write(data_socket, buffer, strlen(buffer) + 1);
            if (ret == -1) {
                perror("write");
                exit(EXIT_FAILURE);
            }
    
            // Zakończenie pętli po przetworzeniu danych
            break;
        }
    
        // Zamknięcie gniazd
        close(connection_socket);
        close(data_socket);
        unlink(SOCKET_NAME);
        exit(EXIT_SUCCESS);
    }
    

    Klient:

    #include <sys/socket.h>
    #include <sys/un.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    #define SOCKET_NAME "/tmp/demoSocket"
    
    int main(void) {
        struct sockaddr_un addr;
        int ret;
        int data_socket;
        char buffer[256];
    
        // Utworzenie gniazda domeny uniksowej
        data_socket = socket(AF_UNIX, SOCK_STREAM, 0);
        if (data_socket == -1) {
            perror("socket");
            exit(EXIT_FAILURE);
        }
    
        // Konfiguracja
        memset(&addr, 0, sizeof(struct sockaddr_un));
        addr.sun_family = AF_UNIX;
        strncpy(addr.sun_path, SOCKET_NAME, sizeof(addr.sun_path) - 1);
    
        // Połączenie z serwerem
        ret = connect(data_socket, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un));
        if (ret == -1) {
            perror("connect");
            exit(EXIT_FAILURE);
        }
    
        // Wysyłanie danych do serwera
        printf("Wprowadz dane do wyslania: ");
        scanf("%[^\n]", buffer);
        ret = write(data_socket, buffer, strlen(buffer) + 1);
        if (ret == -1) {
            perror("write");
            exit(EXIT_FAILURE);
        }
    
        // Odczytanie odpowiedzi od serwera
        ret = read(data_socket, buffer, sizeof(buffer));
        if(ret == -1) {
            perror("read");
            exit(EXIT_FAILURE);
        }
    
        printf("Odebrano od serwera: %s\n", buffer);
    
        // Zamkniecie gniazda
        close(data_socket);
        exit(EXIT_SUCCESS);
    }
    

    Instrukcje:

    1. Zapisz oba fragmenty kodu w osobnych plikach, np. server.c dla serwera i client.c dla klienta.
    2. Skompiluj oba programy za pomocą GCC, używając poleceń: gcc server.c -o server oraz gcc client.c -o client.
    3. Uruchom najpierw serwer, wpisując ./server.
    4. W nowym terminalu uruchom klienta, wpisując ./client.
    5. Postępuj zgodnie z instrukcjami klienta, aby wysłać dane do serwera.

    Mam nadzieję, że te przykłady będą pomocne!

  3. User

    Zrealizować pojedynczy proces pobudzany sygnałem SIGALRM co 1 sekundę, który wyświetlanapis (imię i nazwisko).Wersja 1:Wyświetlanie napisu w obsłudze sygnału

  4. Assistant

    Aby zrealizować zadanie, w którym pojedynczy proces będzie pobudzany sygnałem SIGALRM co 1 sekundę i wyświetlał napis, np. "Jan Kowalski", stworzymy program w języku C, korzystając z funkcji alarm() do generowania sygnału alarmowego oraz signal() do obsługi sygnału. Program będzie działać w nieskończonej pętli, a napis będzie wyświetlany w funkcji obsługi sygnału.

    Oto kod realizujący opisane zadanie:

    #include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>
    #include <unistd.h>
    
    // Funkcja obsługi sygnału
    void handle_signal(int sig) {
        if (sig == SIGALRM) {
            // Wyświetlenie imienia i nazwiska
            printf("Jan Kowalski\n");
    
            // Ustawienie alarmu na kolejne 1 sekundy
            alarm(1);
        }
    }
    
    int main(void) {
        // Ustawienie funkcji obsługi sygnału SIGALRM
        if (signal(SIGALRM, handle_signal) == SIG_ERR) {
            perror("Nie można ustanowić obsługi sygnału SIGALRM");
            exit(EXIT_FAILURE);
        }
    
        // Ustawienie pierwszego alarmu na 1 sekundę
        alarm(1);
    
        // Nieskończona pętla; główna logika programu byłaby tutaj, jeśli by istniała
        while(1) {
            // Czekanie na sygnał, pusta pętla
            pause(); // Używamy pause() do oczekiwania na sygnały
        }
    
        return 0; // To miejsce nigdy nie zostanie osiągnięte
    }
    

    W jaki sposób działa ten program:

    1. Program definiuje funkcję handle_signal(), która jest funkcją obsługi sygnału. Ta funkcja jest wywoływana, kiedy proces otrzyma sygnał SIGALRM. Wewnątrz funkcji obsługi wyświetlany jest napis, a następnie za pomocą funkcji alarm() ustawiany jest kolejny alarm na 1 sekundę.

    2. W funkcji main(), program ustawia funkcję obsługi sygnału SIGALRM na handle_signal() przy pomocy funkcji signal().

    3. Program ustawia pierwszy alarm na 1 sekundę za pomocą funkcji alarm(1).

    4. Następnie program wchodzi w nieskończoną pętlę wykonywania, w której używany jest pause() aby zawiesić wykonanie programu do momentu otrzymania sygnału. Po otrzymaniu sygnału SIGALRM, funkcja handle_signal() jest wywoływana automatycznie, wyświetla napis i ustawia kolejny alarm.

    5. Cykl się powtarza, z napisem wyświetlanym co sekundę.

    Kompilacja i uruchomienie:

    Skompiluj program, używając kompilatora GCC:

    gcc program.c -o program
    

    Następnie możesz uruchomić skompilowany program:

    ./program
    

    Program będzie kontynuował wyświetlanie imienia i nazwiska co sekundę, aż do momentu przerwania go, na przykład przez naciśnięcie Ctrl+C.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.