//Zad2b Klient
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

#define SERVER_ADDRESS "localhost"
#define PORT_NUMBER 12345
#define BUFFER_SIZE 256

int main()
{
    int client_socket, result;
    struct sockaddr_in server_address;
    struct hostent *server;
    char buffer[BUFFER_SIZE];

    // sprawdzenie nazwy hosta serwera
    server = gethostbyname(SERVER_ADDRESS);
    if (server == NULL) {
        fprintf(stderr, "Blad: brak takiego hosta: %s\n", SERVER_ADDRESS);
        exit(EXIT_FAILURE);
    }

    // tworzenie gniazda klienta
    client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (client_socket == -1) {
        perror("gniazdo");
        exit(EXIT_FAILURE);
    }

    // ustawienie adresu serwera
    memset(&server_address, 0, sizeof(server_address));
    server_address.sin_family = AF_INET;
    memcpy(&server_address.sin_addr.s_addr, server->h_addr, server->h_length);
    server_address.sin_port = htons(PORT_NUMBER);

    // polaczenie z serwerem
    result = connect(client_socket, (struct sockaddr *)&server_address, sizeof(server_address));
    if (result == -1) {
        perror("polaczono");
        exit(EXIT_FAILURE);
    }

    // wyslanie wiadomosci do serwera
    if (write(client_socket, "Witam, serwer", 14) == -1) {
        perror("zapis");
        exit(EXIT_FAILURE);
    }

    // Odczyt odpowiedzi serwera
    memset(buffer, 0, BUFFER_SIZE);
    if (read(client_socket, buffer, BUFFER_SIZE) == -1) {
        perror("odczyt");
        exit(EXIT_FAILURE);
    }
    printf("Otrzymana odpowiedz: %s\n", buffer);

    // zamkniecie gniazda
    close(client_socket);

    return 0;
}
//Zad2b Serwer
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT_NUMBER 12345
#define BUFFER_SIZE 256

int main()
{
    int server_socket, client_socket, address_length, pid;
    struct sockaddr_in server_address, client_address;
    char buffer[BUFFER_SIZE];

    // tworzenie gniazda serwera
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("gniazdo");
        exit(EXIT_FAILURE);
    }

    // ustawienie adresu serwera
    memset(&server_address, 0, sizeof(server_address));
    server_address.sin_family = AF_INET;
    server_address.sin_port = htons(PORT_NUMBER);
    server_address.sin_addr.s_addr = INADDR_ANY;

    // polaczenie gniazda serwera z adresem
    if (bind(server_socket, (struct sockaddr *)&server_address, sizeof(server_address)) == -1) {
        perror("polaczono");
        exit(EXIT_FAILURE);
    }

    // nasluchiwanie przychodzacych polaczen
    if (listen(server_socket, 5) == -1) {
        perror("nasluchiwanie");
        exit(EXIT_FAILURE);
    }

    printf("Serwer nasluchuje na porcie: %d...\n", PORT_NUMBER);

    while (1) {
        // zaakceptowanie przychodzacego polaczenia
        address_length = sizeof(client_address);
        client_socket = accept(server_socket, (struct sockaddr *)&client_address, &address_length);
        if (client_socket == -1) {
            perror("zaakceptowano");
            continue;
        }

        // stworznie nowego procesu fork dla przetrzymania zadania klienta
        pid = fork();
        if (pid == -1) {
            perror("fork");
            exit(EXIT_FAILURE);
        } else if (pid == 0) { // dziecko procesu
            // zamkniecie gniazda serwera w procesie dziecka
            close(server_socket);

            // odczyt wiadomosci od klienta
            memset(buffer, 0, BUFFER_SIZE);
            if (read(client_socket, buffer, BUFFER_SIZE) == -1) {
                perror("odczyt");
                exit(EXIT_FAILURE);
            }
            printf("Odebrano wiadomosc: %s\n", buffer);

            // Wyslanie odpowiedzi do klienta
            if (write(client_socket, "Wiadomosc odtrzymana", 16) == -1) {
                perror("zapis");
                exit(EXIT_FAILURE);
            }

            // zamkniecie gniazda klienta w procesie dziecka
            close(client_socket);

            // wyjscie z procesu dziecka 
            exit(EXIT_SUCCESS);
        } else { // proces rodzica
            // zamkniecie gniazda klienta dla procesu rodzica
            close(client_socket);
        }
    }

    // zamkniecie gniazda serwera
    close(server_socket);

    return 0;
}