Kraa · prs

#include <stdio.h>

#include <stdlib.h>

#include <sys/un.h>

#include <sys/socket.h>

#include <unistd.h>d

#include <string.h>

#define SERWER "/tmp/SERWER_SOCKET.sock"

int main(){

//tworzenie socketu

int network_socket = socket(AF_UNIX, SOCK_STREAM, 0);

//wizytowka

struct sockaddr_un serwer;

unlink(SERWER);

serwer.sun_family = AF_UNIX;

strcpy(serwer.sun_path, SERWER);

//otwieranie okna dla klienta

int socc_bind = bind(network_socket, (struct sockaddr *)&serwer, sizeof(serwer));

if(socc_bind == -1){

printf("Nie udalo sie przylaczyc do socketu\n");

close(network_socket);

return -1;

}

//nasluchiwanie

int nasluchiwanie = listen(network_socket, 5);

if(nasluchiwanie == -1){

printf("Blad nasluchiwania\n");

return -1;

}

//petla sekwencyjna

for(;;){

// int liczba;

// int klient = accept(network_socket, NULL, NULL);

// int czytaj = read(klient, &liczba, sizeof(liczba));

// if(czytaj == sizeof(liczba)){

// int wynik = liczba * liczba;

// int wyslij = write(klient, &wynik, sizeof(wynik));

// }

// close(klient);

char wiadomosc[256];

int klient = accept(network_socket, NULL, NULL);

int czytaj = read(klient, wiadomosc, sizeof(wiadomosc));

printf("Serwer otrzymal slowo: %s\n", wiadomosc);

char slowo1[256] = " siema";

strcat(slowo1, wiadomosc);

printf("Slowo po zlepieniu: %s\n: ", slowo1);

write(klient, slowo1, strlen(slowo1) + 1);

close(klient);

}

return 0;

}

#include <stdio.h>

#include <stdlib.h>

#include <sys/un.h>

#include <sys/socket.h>

#include <unistd.h>

#define SERWER "/tmp/SERWER_SOCKET.sock"

int main(){

//socket

int network_socket = socket(AF_UNIX, SOCK_STREAM, 0);

//wizytowka

struct sockaddr_un serwer;

serwer.sun_family = AF_UNIX;

strcpy(serwer.sun_path, SERWER);

//laczenie z socketem

int soc_connect = connect(network_socket, (struct sockaddr *)&serwer, sizeof(serwer));

if(soc_connect == -1){

printf("Nie udalo sie polaczyc z serwerem\n");

}

char slowo[256];

scanf("%s", slowo);

write(network_socket, slowo, strlen(slowo) + 1);

read(network_socket, slowo, sizeof(slowo));

printf("Otrzymalem od serwera wiadomosc: %s\n", slowo);

return 0;

}

//to byl gniazdowy unixowy

//teraz datagram

#include <sys/socket.h>

#include <sys/un.h>

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#define SERWER "/tmp/SOCKET-SERWER.sock"

#define KLIENT "/tmp/SOCKET-KLIENT.sock"

int main(void)

{

// interfejs serwera gniazdowego

struct sockaddr_un serwer;

struct sockaddr_un klient;

socklen_t serwer_len = sizeof(serwer);

// stworzenie gniazda datagramowego

int sock = socket(AF_UNIX, SOCK_DGRAM, 0);

if (sock < 0) {

perror("socket");

return -1;

}

// na wszelki usuwamy istniejacy socket klienta (jak jest)

unlink(KLIENT);

// adres klienta (musi miec wlasny!)

klient.sun_family = AF_UNIX;

strcpy(klient.sun_path, KLIENT);

// przypinamy gniazdo klienta

int soc_bind = bind(sock, (struct sockaddr *)&klient, sizeof(klient));

if(soc_bind == -1){

fprintf("Blad przypiecia");

return -1;

}

// adres serwera

serwer.sun_family = AF_UNIX;

strcpy(serwer.sun_path, SERWER);

int liczba, wynik;

printf("Podaj liczbe: ");

scanf("%d", &liczba);

// wysylamy liczbe do serwera

sendto(sock, &liczba, sizeof(int), 0,

(struct sockaddr *)&serwer, serwer_len);

// czekamy na odpowiedz serwera

recvfrom(sock, &wynik, sizeof(int), 0, NULL, NULL);

printf("Wynik: %d * %d = %d\n", liczba, liczba, wynik);

close(sock);

unlink(KLIENT);

}

// Serwer sekwencyjny uzywajacy gniazd datagramowych, ale lokalnie

// Wysyla pakiety datagramowe bez tworzenia polaczenia (dlatego nie ma listen i accept)

#include <sys/socket.h>

#include <sys/un.h>

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#define SERWER "/tmp/SOCKET-SERWER.sock"

int main(void)

{

// inicjalizujemy adresy serwera i klienta

struct sockaddr_un serwer;

struct sockaddr_un klient;

socklen_t klient_len = sizeof(klient);

// stworzenie gniazda datagramowego

// (zamiast SOCK_STREAM to SOCK_DGRAM)

// AF_UNIX - komunikacja lokalna (ale datagramami)

int sock = socket(AF_UNIX, SOCK_DGRAM, 0);

if (sock < 0) {

perror("socket");

return -1;

}

// na wszelki usuwamy istniejacy socket serwera (jak jest)

unlink(SERWER);

// AF_UNIX - komunikacja lokalna (ale datagramami)

serwer.sun_family = AF_UNIX;

// skopiowanie sciezki do serwera

strcpy(serwer.sun_path, SERWER);

// przypiecie gniazda do adresu

// bind zwraca -1 jak bedzie blad

if (bind(sock, (struct sockaddr *)&serwer, sizeof(serwer)) == -1) {

perror("bind");

close(sock);

return -1;

}

printf("Serwer gniazdowy uruchomiony...\n");

for (;;) {

int liczba;

// czekamy na liczbe od klienta

// nie ma listen i accept

// recvfrom = read, sendto = write

if (recvfrom(sock,

&liczba,

sizeof(liczba),

(struct sockaddr *)&klient,

&klient_len) == sizeof(liczba)) {

int wynik = liczba * liczba;

printf("dostalem liczbe, wysylam\n");

// zamiast write

sendto(sock,

&wynik,

sizeof(wynik),

(struct sockaddr *)&klient,

klient_len);

// tutaj mozna wyslac kolejny datagram od klienta

}

Serwer sekwencyjny oparty na kolejkach komunikatów.

Kazdy komunikat musi byc wczesniej zdefiniowany jako struktura zaczynajaca

sie polem long mtype, ktore sluzy do "filtrowania" wiadomosci przez msgrcv()

w polu msgtyp i jego wartosci to:

1 - zgloszenie klienta do serwera

2 - dane wysylane przez klienta

3 - wynik wyslany przez serwer

#include <unistd.h>

#include <stdio.h>

#include <sys/ipc.h>

#include <sys/msg.h>

#include <fcntl.h>

typedef struct {

long mtype;

pid_t pid;

} paczka1;

typedef struct {

long mtype;

int liczba;

} paczka2;

char sciezka = "/tmp/serwer.ipc"; // musi byc char

int main(void)

{

// usun istniejacy plik serwera (na wszelki)

unlink(sciezka);

// tworzymy plik serwera

int plik = open(sciezka, O_CREAT);

if (plik == -1) {

perror("Serwer: Blad utworzenia pliku");

return 1;

}

// tworzymy klucz kolejki dla serwera

key_t klucz_serwera = klucz_serwera = ftok(sciezka, 0);

if (klucz_serwera == -1) {

perror("Serwer: ftok");

return 1;

}

// tworzenie kolejki serwera z uprawnieniami 0600

int kolejka_serwera = msgget(klucz_serwera, IPC_CREAT | 0600);

if (kolejka_serwera == -1) {

perror("Serwer: msgget");

return 1;

}

printf("Serwer sekwencyjny uruchomiony.\n");

for (;;) {

paczka1 handshake;

// odbior zgloszenia klienta (mtype = 1)

// po to robimy strukture paczek

ssize_t liczba_bajtow = msgrcv(kolejka_serwera, &handshake, sizeof(paczka1) - sizeof(long), 1, 0);

if (liczba_bajtow == -1) {

perror("Serwer: msgrcv (glowna kolejka)");

continue;

}

printf("Serwer: klient %d\n", handshake.pid);

// tworzymy klucz klienta uzywajac PID klienta jako ID projektu

key_t klucz_klienta = ftok(sciezka, handshake.pid);

if (klucz_klienta == -1) {

perror("Serwer: ftok pid");

return 1;

}

// otwieramy kolejke klienta

int kolejka_klienta = msgget(klucz_klienta, 0600);

if (kolejka_klienta == -1) {

perror("Serwer: msgget klienta");

continue;

}

paczka2 pakiet;

// odbieramy dane od klienta (mtype = 2)

liczba_bajtow = msgrcv(kolejka_klienta, &pakiet, sizeof(paczka2) - sizeof(long), 2, 0);

if (liczba_bajtow == -1) {

perror("Serwer: msgrcv klient");

continue;

}

printf("Serwer: otrzymano %d\n", pakiet.liczba);

// przetwarzamy liczbe w tym pakiecie i nadajemy mtype 3 (do odeslania)

pakiet.liczba *= pakiet.liczba;

pakiet.mtype = 3;

// odsylamy wynik jako ten sam pakiet

if (msgsnd(kolejka_klienta, &pakiet, sizeof(paczka2) - sizeof(long), 0) == -1) {

perror("Serwer: msgsnd");

}

printf("Serwer: wynik odeslany\n");

}

Klient dla serwera sekwencyjnego opartego na kolejkach komunikatów.

praktycznie to samo co w serwerze, ale tutaj nie tworzymy serwera,

laczymy sie do niego, tworzymy kolejke klienta i wysylamy najpierw PID

przez kolejke serwera a potem liczbe przez kolejke klienta i czekamy na

wynik od serwera

#include <unistd.h>

#include <stdio.h>

#include <sys/ipc.h>

#include <sys/msg.h>

#include <string.h>

typedef struct {

long mtype;

pid_t pid;

} paczka1;

typedef struct {

long mtype;

int liczba;

} paczka2;

char sciezka = "/tmp/serwer.ipc"; // musi byc char

int main(void)

{

pid_t pid = getpid(); // PID tego klienta

// kolejka serwera

key_t klucz_serwera = ftok(sciezka, 0);

if (klucz_serwera == -1) {

perror("Klient: ftok");

return 1;

}

int kolejka_serwera = msgget(klucz_serwera, 0600);

if (kolejka_serwera == -1) {

perror("Klient: msgget (serwer)");

return 1;

}

// kolejka klienta

key_t klucz_klienta = ftok(sciezka, pid);

if (klucz_klienta == -1) {

perror("Klient: ftok klient");

return 1;

}

int kolejka_klienta = msgget(klucz_klienta, 0600 | IPC_CREAT);

if (kolejka_klienta == -1) {

perror("Klient: msgget (klient)");

return 1;

}

/* Zgłoszenie do serwera */

paczka1 handshake;

handshake.mtype = 1;

handshake.pid = pid;

if (msgsnd(kolejka_serwera, &handshake, sizeof(paczka1) - sizeof(long), 0) == -1) {

perror("Klient: msgsnd");

return 1;

}

/* Dane do przetworzenia */

paczka2 pakiet;

printf("Klient: Podaj liczbe: ");

scanf("%d", &pakiet.liczba);

pakiet.mtype = 2;

if (msgsnd(kolejka_klienta, &pakiet, sizeof(paczka2) - sizeof(long), 0) == -1) {

perror("Klient: msgsnd (dane)");

msgctl(kolejka_klienta, IPC_RMID, NULL);

return 1;

}

/* Odbiór wyniku */

if (msgrcv(kolejka_klienta, &pakiet, sizeof(paczka2) - sizeof(long), 3, 0) == -1) {

perror("Klient: msgrcv");

msgctl(kolejka_klienta, IPC_RMID, NULL);

return 1;

}

printf("Klient: Wynik = %d\n", pakiet.liczba);

return 0;

}

Serwer sekwencyjny oparty na kolejkach FIFO

Obsluguje jednego klienta na raz ktory wysyla najpierw PID, potem liczbe calkowita,

potem serwer przetwarza ta liczbe i wysyla wynik z powrotem do klienta

Kolejki:

Serwer Klient

2 (pisze) -----> 1 (czyta)

1 (czyta) <----- 2 (pisze)

FIFO - jednokierunkowy strumien w ktory wrzuca sie dane i nie ma jak sprawdzic czy dotarly

deskryptor - alias numeryczny do pliku

Dzialanie:

1. tworzymy ogarnianie ctrl+c i kill (signal)

2. na wszelki zamykamy stary serwer

3. tworzymy kolejke serwerowa

4. czekamy na PID od klienta

5. tworzymy kolejke do czytania i pisania

6. czekamy na liczbe i wysylamy wynik klientowi

7. konczymy

#include <unistd.h>

#include <stdio.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <signal.h>

#include <stdlib.h>

const char *nazwa_serwera = "/tmp/FIFO-SERWER";

int deskryptor_serwera;

char bufor[256]; // bufor na nazwy klienta

void sigint_handler(int sig) {

printf("\nSerwer: zamykanie...\n");

close(deskryptor_serwera);

unlink(nazwa_serwera);

exit(0);

}

int main(void)

{

int kolejka_czytania, kolejka_pisania; // deskryptory kolejek FIFO

pid_t pid_klienta;

// zamkniecie starego serwera (na wszelki)

unlink(nazwa_serwera);

// tworzenie kolejki FIFO o nazwie 'FIFO-SERWER' z prawami dostepu tylko wlasciciela (0600),

// mknod zwaraca -1 przy bledzie

if (mknod(nazwa_serwera, S_IFIFO | 0600, 0) == -1) {

perror("Serwer: blad tworzenia kolejki FIFO");

return -1;

}

// probujemy otworzyc serwer jako tylko do czytania w trybie blokowanym,

// co oznacza ze serwer jest zablokowany do czasu az klient otworzy FIFO

// do zapisu (w kliencie jest taka sama linijka tylko z O_WRONLY),

deskryptor_serwera = open(nazwa_serwera, O_RDONLY);

// open zwaraca -1 przy bledzie

if (deskryptor_serwera == -1) {

perror("Serwer: blad otwarcia FIFO");

return -1;

}

printf("Serwer FIFO uruchomiony...\n");

// przechwycamy SIGINT (Ctrl+C)

signal(SIGINT, sigint_handler);

// nieskonczona petla, po to przechwycamy SIGTERM i SIGINT

for (;;) {

// serwer blokuje sie na read, az klient nie przesle swojego PID,

// jesli przeslal niepelny PID (albo nieprawidlowy), to ignorujemy tego klienta i

// idziemy do nastepnej iteracji tj. czekania na PID od klienta

// warto zauwazyc ze oczekujemy na PID ktore klient przesle na FIFO-SERWER, bo

// bez tego nie utworzymy kolejek specjalnie dla tego numeru PID

if (read(deskryptor_serwera, &pid_klienta, sizeof(pid_t)) != sizeof(pid_t))

continue;

printf("Serwer: obsluga klienta %d\n", pid_klienta);

// nadpisujemy bufor nazwa kolejki do czytania (ma forme np. FIFO-1-5032)

sprintf(bufor, "/tmp/FIFO-1-%d", pid_klienta);

// tworzymy kolejke tylko do czytania

kolejka_czytania = open(bufor, O_RDONLY);

if (kolejka_czytania == -1) {

perror("Serwer: błąd otwarcia FIFO klienta (read)");

continue;

}

// nadpisujemy bufor nazwa kolejki do pisania (ma forme np. FIFO-2-5032)

sprintf(bufor, "/tmp/FIFO-2-%d", pid_klienta);

// tworzymy kolejke tylko do pisania

kolejka_pisania = open(bufor, O_WRONLY);

if (kolejka_pisania == -1) {

perror("Serwer: blad otwarcia FIFO klienta (write)");

close(kolejka_czytania);

continue;

}

int liczba, wynik;

// serwer blokuje sie na read, az klient nie przesle liczby,

// jesli przeslal cala liczbe to obliczamy wynik i przesylamy mu go

// (wypisujac do kolejki do pisania)

if (read(kolejka_czytania, &liczba, sizeof(int)) == sizeof(int)) {

wynik = liczba * liczba;

write(kolejka_pisania, &wynik, sizeof(int));

printf("Serwer: %d -> %d\n", liczba, wynik);

}

// zamykamy kolejki

close(kolejka_czytania);

close(kolejka_pisania);

}

Klient FIFO – wersja do serwera sekwencyjnego

Kolejki:

Serwer Klient

2 (pisze) -----> 1 (czyta)

1 (czyta) <----- 2 (pisze)

Dzialanie:

1. nadpisujemy bufory nazwami kolejek

2. na wszelki zamykamy stare kolejki

3. tworzymy kolejki z mknod()

4. probujemy otworzyc kolejke serwera

5. wysylamy mu PID

6. otwieramy kolejki

7. wysylamy liczbe i czekamy na wynik

8. konczymy

#include <unistd.h>

#include <stdio.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdlib.h>

const char *nazwa_serwera = "/tmp/FIFO-SERWER";

int deskryptor_serwera;

char bufor1[256], bufor2[256]; // bufor na nazwy klienta

void cleanup() {

unlink(bufor1);

unlink(bufor2);

exit(0);

}

int main(void)

{

int kolejka_czytania, kolejka_pisania; // deskryptory

pid_t pid = getpid(); // PID naszego klienta

// zamykamy stare kolejki klientow (na wszelki)

unlink(bufor2);

unlink(bufor1);

// nadpisujemy bufor nazwa kolejki do pisania (ma forme np. FIFO-1-5032)

sprintf(bufor1, "/tmp/FIFO-1-%d", pid);

// nadpisujemy bufor nazwa kolejki do czytania (ma forme np. FIFO-1-5032)

sprintf(bufor2, "/tmp/FIFO-2-%d", pid);

// tworzenie kolejki FIFO z prawami dostepu tylko wlasciciela (0600),

// mknod zwaraca -1 przy bledzie

if (mknod(bufor1, S_IFIFO | 0600, 0) == -1) {

perror("Klient: blad tworzenia FIFO 1");

return -1;

}

// tworzenie kolejki FIFO z prawami dostepu tylko wlasciciela (0600),

// mknod zwaraca -1 przy bledzie

if (mknod(bufor2, S_IFIFO | 0600, 0) == -1) {

perror("Klient: blad tworzenia FIFO 2");

return -1;

}

// probujemy polaczyc sie z serwerem tylko do pisania

// (w serwerze jest taka sama linijka tylko z O_RDONLY)

deskryptor_serwera = open(nazwa_serwera, O_WRONLY);

if (deskryptor_serwera == -1) {

perror("Klient: nie moge połaczyc sie z serwerem");

return -1;

}

// wyslamy PID do serwera, zeby mogl utworzyc kolejki dla naszego PIDu

write(deskryptor_serwera, &pid, sizeof(pid_t));

// zamykamy polaczenie z kolejka serwera (FIFO-SERWER)

// i przy okazji zamykami inne

close(deskryptor_serwera);

// otwieramy kolejke tylko do pisania

kolejka_pisania = open(bufor1, O_WRONLY);

if (kolejka_pisania == -1) {

perror("Klient: blad otwarcia FIFO do pisania");

cleanup();

}

// otwieramy kolejke tylko do czytania

kolejka_czytania = open(bufor2, O_RDONLY);

if (kolejka_czytania == -1) {

perror("Klient: blad otwarcia FIFO do czytania");

cleanup();

}

int liczba, wynik;

printf("Podaj liczbe: ");

scanf("%d", &liczba);

// klient wysyla liczbe

write(kolejka_pisania, &liczba, sizeof(int));

// i czeka na wynik od serwera

read(kolejka_czytania, &wynik, sizeof(int));

printf("Wynik: %d * %d = %d\n", liczba, liczba, wynik);

// zamykamy kolejki

close(kolejka_pisania);

close(kolejka_czytania);

cleanup();

return 0;

}

//IPC przerobiony na wysylanie charow

#include <unistd.h>

#include <stdio.h>

#include <sys/ipc.h>

#include <sys/msg.h>

#include <fcntl.h>

#include <string.h>

#include <ctype.h> // Potrzebne do toupper()

typedef struct {

long mtype;

pid_t pid;

} paczka1;

typedef struct {

long mtype;

char tekst[256]; // Zmieniono z int na tablicę char

} paczka2;

char *sciezka = "/tmp/serwer.ipc";

int main(void) {

unlink(sciezka);

int plik = open(sciezka, O_CREAT, 0600);

if (plik == -1) {

perror("Serwer: Blad utworzenia pliku");

return 1;

}

key_t klucz_serwera = ftok(sciezka, 0);

int kolejka_serwera = msgget(klucz_serwera, IPC_CREAT | 0600);

if (kolejka_serwera == -1) {

perror("Serwer: msgget");

return 1;

}

printf("Serwer tekstowy uruchomiony.\n");

for (;;) {

paczka1 handshake;

// Odbiór zgłoszenia (mtype 1)

if (msgrcv(kolejka_serwera, &handshake, sizeof(paczka1) - sizeof(long), 1, 0) == -1) {

continue;

}

printf("Serwer: Obsluga klienta o PID %d\n", handshake.pid);

key_t klucz_klienta = ftok(sciezka, handshake.pid);

int kolejka_klienta = msgget(klucz_klienta, 0600);

paczka2 pakiet;

// Odbiór tekstu od klienta (mtype 2)

msgrcv(kolejka_klienta, &pakiet, sizeof(paczka2) - sizeof(long), 2, 0);

printf("Serwer: otrzymano tekst: %s\n", pakiet.tekst);

// MODYFIKACJA: Zamiana na wielkie litery

for (int i = 0; pakiet.tekst[i] != '\0'; i++) {

pakiet.tekst[i] = (char)toupper(pakiet.tekst[i]);

}

pakiet.mtype = 3; // Odsyłamy jako wynik (mtype 3)

msgsnd(kolejka_klienta, &pakiet, sizeof(paczka2) - sizeof(long), 0);

printf("Serwer: zmodyfikowany tekst odeslany.\n");

}

#include <unistd.h>

#include <stdio.h>

#include <sys/ipc.h>

#include <sys/msg.h>

#include <string.h>

typedef struct {

long mtype;

pid_t pid;

} paczka1;

typedef struct {

long mtype;

char tekst[256]; // Zgodność z serwerem

} paczka2;

char *sciezka = "/tmp/serwer.ipc";

int main(void) {

pid_t pid = getpid();

key_t klucz_serwera = ftok(sciezka, 0);

int kolejka_serwera = msgget(klucz_serwera, 0600);

key_t klucz_klienta = ftok(sciezka, pid);

int kolejka_klienta = msgget(klucz_klienta, 0600 | IPC_CREAT);

/* Zgłoszenie do serwera (handshake) */

paczka1 handshake;

handshake.mtype = 1;

handshake.pid = pid;

msgsnd(kolejka_serwera, &handshake, sizeof(paczka1) - sizeof(long), 0);

/* Pobieranie tekstu od użytkownika */

paczka2 pakiet;

printf("Klient: Wpisz wiadomosc do serwera: ");

// Używamy fgets dla bezpiecznego pobrania tekstu

fgets(pakiet.tekst, sizeof(pakiet.tekst), stdin);

// Usunięcie znaku nowej linii '\n' dodanego przez fgets

pakiet.tekst[strcspn(pakiet.tekst, "\n")] = 0;

pakiet.mtype = 2; // mtype dla danych wysyłanych

msgsnd(kolejka_klienta, &pakiet, sizeof(paczka2) - sizeof(long), 0);

/* Odbiór wyniku od serwera (mtype 3) */

msgrcv(kolejka_klienta, &pakiet, sizeof(paczka2) - sizeof(long), 3, 0);

printf("Klient: Wynik z serwera: %s\n", pakiet.tekst);

// Sprzątanie kolejki klienta po zakończeniu

msgctl(kolejka_klienta, IPC_RMID, NULL);

return 0;

}