SHARE
TWEET

Untitled

a guest Jan 26th, 2020 68 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include "stdio.h"
  2. #include "string.h"
  3.  
  4. #include "sys/types.h"
  5. #include "sys/stat.h"
  6. #include "sys/wait.h"
  7. #include "fcntl.h"
  8.  
  9. #include "sys/ipc.h"
  10. #include "sys/msg.h"
  11. #include "sys/shm.h"
  12. #include "sys/sem.h"
  13.  
  14. #include "unistd.h"
  15. #include "stdlib.h"
  16.  
  17. #include "signal.h"
  18. #include "errno.h"
  19.  
  20. /* Ścieżka Fifo */
  21. #define FIFO_PATH "/tmp/prusaczyk_p"
  22. /* Rozmiary poszczególnych buforów i stałych służących do wypisywania */
  23. #define ROZMIAR_BUFORA 2
  24. #define ROZMIAR_BUFORA_KONWERSJI 2*ROZMIAR_BUFORA
  25. #define ILOSC_ZNAKOW_W_LINII 15
  26. #define ROZMAIR_BUFORA_WYPISYWANIA ILOSC_ZNAKOW_W_LINII * 3 + 2
  27.  
  28. int idKolejki;
  29. int deskryptoryFifo[2];
  30. int deskryptorWejscia = -1;
  31.  
  32. /* Kod procesu 1 */
  33. void proces1();
  34. /* Kod procesu 2 */
  35. void proces2();
  36. /* Kod procesu 3 */
  37. void proces3();
  38.  
  39. /* Sygnaly 1 2 i 3 z zadnaia wydrano jako s1 sigint ponieważ można go łątwo wywołać z klawiatury czym łatwo kończymy program*/
  40. #define SYGNAL1 SIGINT
  41. #define SYGNAL2 SIGUSR1
  42. #define SYGNAL3 SIGCONT
  43.  
  44. /* Obsługa sygnałów 1-3 */
  45. void obslugaSygnalow123(int numqerSyngalu, siginfo_t* informacjeOSygnale, void* nieuzywane);
  46.  
  47. /* Pamięć dzielona zaweirająca pidy procesów p1-p3 potrzeben na potrzeby signal handlerów */
  48. int *pidyPotomkow;
  49.  
  50. /* id zasobów IPC */
  51. int idPamieciDzielonej;
  52.  
  53. int idSemafora;
  54.  
  55. int ostatniSygnal;
  56.  
  57. /* Tablica do konwersji na hex, działa tak, podstawiaamy wartość liczby 4ro bitowej jako miejsce a w tablicy znajduje
  58. się na tym miejscu znak odpowiadający tej liczbie w zapisie szesnastowkym*/
  59. char tablicaKonwersjiHEX[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  60.  
  61. /* Struktura pomocnincza dla funckji sigaction, którą ustawiam procedury obsługi sygnałów */
  62. struct sigaction strukturaSigaction;
  63.  
  64. /* Służy do odczytywania z deskryptora pliku w momencie gdy może wystąpic przerwanie */
  65. int odczytaj(int zKad, char* doKad, size_t ile) {
  66.     int doZwrotu;
  67. powtorzCzynnosc:
  68.     doZwrotu = read(zKad, doKad, ile);
  69.     if(doZwrotu == -1 && errno == EINTR)
  70.         goto powtorzCzynnosc;
  71.     return doZwrotu;
  72. }
  73.  
  74. /*Służy do odczytywania z deskrytpora plika wznawiając ten proces gdy nastąpi przerwanie */
  75. int zapisz(int doKad, char* zKad, size_t ile) {
  76.     int doZwrotu;
  77. powtorzCzynnosc:
  78.     doZwrotu = write(doKad, zKad, ile);
  79.     if(doZwrotu == -1 && errno == EINTR)
  80.         goto powtorzCzynnosc;
  81.     return doZwrotu;
  82. }
  83.  
  84. /* Ustawiamy handlery dla sygnałów */
  85. void ustawSygnaly() {
  86.     strukturaSigaction.sa_sigaction = &obslugaSygnalow123;
  87.     sigemptyset(&strukturaSigaction.sa_mask);
  88.     strukturaSigaction.sa_flags = SA_SIGINFO;
  89.     sigaction(SYGNAL1, &strukturaSigaction, NULL);
  90.     strukturaSigaction.sa_sigaction = &obslugaSygnalow123;
  91.     sigaction(SYGNAL2, &strukturaSigaction, NULL);
  92.     strukturaSigaction.sa_sigaction = &obslugaSygnalow123;
  93.     sigaction(SYGNAL3, &strukturaSigaction, NULL);
  94. }
  95.  
  96. /* Bufor operacji na semaforze */
  97. static struct sembuf buforOperacjiSem;
  98.  
  99. /* Struktura wiadomości, zastosowanie określonych pól opisane poniżej */
  100. struct msgBuf{
  101.     long mtype; /*Typ wiadomości */
  102.     short ileZnakow; /* Czy zakonczyc komunikacje */
  103.     char wiadomosc[ROZMIAR_BUFORA]; /* Tekst do przekazania z wejścia */
  104. } buforKomunikatu;
  105.  
  106. /* Wysyłamy komunikat przez kolejkę komunikatów wznawiając w przyapdku otrzymania sygnału */
  107. int wyslijKomunikat(int iloscZnakow, char* bufor)
  108. {
  109.     int wartoscDoZwrocenia;
  110.     buforKomunikatu.ileZnakow = iloscZnakow;
  111.     buforKomunikatu.mtype = 1;
  112.     strncpy(buforKomunikatu.wiadomosc, bufor, iloscZnakow);
  113. ponowCzynnosc:
  114.         wartoscDoZwrocenia = msgsnd( idKolejki, &buforKomunikatu, sizeof(buforKomunikatu) - sizeof(long), 0);
  115.         if(wartoscDoZwrocenia==-1 && errno == EINTR)
  116.             goto ponowCzynnosc;
  117.         return wartoscDoZwrocenia;
  118. }
  119.  
  120. /* Jak wyżej, odbiera wiadomość przy użyciu kolejki */
  121. int odbiezKomunikat(long typKomDoOdebrania, long *typOdebrany, int *ileZnakow, char* bufor)
  122. {
  123.     int wartoscZwracana;
  124. ponowCzynnosc:
  125.         wartoscZwracana = msgrcv(idKolejki, &buforKomunikatu, sizeof(buforKomunikatu) - sizeof(long), typKomDoOdebrania, 0);
  126.         if(wartoscZwracana==-1 && errno == EINTR)
  127.             goto ponowCzynnosc;
  128.        
  129.         *typOdebrany = buforKomunikatu.mtype;
  130.         *ileZnakow = buforKomunikatu.ileZnakow;
  131.         strncpy(bufor, buforKomunikatu.wiadomosc, *ileZnakow);
  132.         return wartoscZwracana;
  133. }
  134.  
  135. /* Konwertuje <rozmiarWejscia> znaków z ciągu wejście na 2 razy tyle znaków będacych zapisem heksadecymalnym kolejnych bajtów
  136. i zapisuje do ciągu wyjście*/
  137. size_t konwersjaNaSzesna(char* wejscie, char* wyjscie, int rozmiarWejscia);
  138.  
  139. /* Podnosi semafor o 3 sygnalizując, że proces inicjalizujący zapisał do odpowiedniej tablicy pidy procesów p1-p3 aby ich
  140. procedury obsługi sygnałów mogły przesyłać między procesami p1-p3 nawzajem sygnały */
  141. int zasygnalizujWpisaniePidow() {
  142.     int retValue = 0;
  143.     buforOperacjiSem.sem_num = 0;
  144.     buforOperacjiSem.sem_op = 3;
  145.     buforOperacjiSem.sem_flg = 0;
  146.     retValue = semop(idSemafora, &buforOperacjiSem, 1);
  147.     if(retValue == -1) {
  148.         perror("semop");
  149.     }
  150.     return retValue;
  151. }
  152.  
  153. /* Oczekujemy na semaforze aż proces inicjalizujący zapisze do pamięci dzielonej pidy wszystkich komunikujących się procesów */
  154. int oczekaujNaWpisuaniePidow() {
  155.     int retValue = 0;
  156.     buforOperacjiSem.sem_num = 0;
  157.     buforOperacjiSem.sem_op = -1;
  158.     buforOperacjiSem.sem_flg = 0;
  159.     retValue = semop(idSemafora, &buforOperacjiSem, 1);
  160.     if(retValue == -1) {
  161.         perror("semop");
  162.     }
  163.     return retValue;
  164. }
  165.  
  166. /* Maska, którą ustawiamy dla funkcji sigsuspend aby oczekiwać w procedurze obsługi sygnału S2 na albo sygnał do wznowienia lub zakończenia pracy
  167. (lub kolejny sygnał S2, po którym przechodazimy w dokładnie taki sam stan oczekiwania)*/
  168. sigset_t maskaOczekiwania;
  169.  
  170. int main(int argc, char** argv) {
  171. /*Sprawdzamy jaki tryb pracy wybrał user*/
  172.     if(argc == 1 || (argc == 2 && strlen(argv[1]) >= 2 && strncmp("-l", argv[1], 3) == 0)){
  173. /* Tryb danych losowych z pliku /dev/urandom, używany jkao tryb domyślny,
  174.    sposoby aktywacji:
  175.    - nie podawanie żadnych flag, tryb domyślny
  176.    - użycie flagi -l
  177. */
  178.         deskryptorWejscia = open("/dev/urandom", O_RDONLY);
  179.  
  180.     } else if( argc == 2 && strlen(argv[1]) >= 2 && strncmp("-i", argv[1], 3) == 0) {
  181. /* Tryb interaktywny, wczytywanie danych z klawiatury, sposoby aktywowania:
  182.    -flaga -i
  183. */
  184.         deskryptorWejscia = 0;
  185.  
  186.     } else if ( argc == 3 && strlen(argv[1]) >= 2 && strncmp("-p", argv[1], 3) == 0) {
  187. /* Tryb wczytywania danych z pliku, sposób aktywowania:
  188.    -flaga -p po której podajemy ścieżkę do pliku
  189. */
  190.         deskryptorWejscia = open(argv[2], O_RDONLY);
  191.     }
  192.     if(deskryptorWejscia == -1) {
  193.         perror("Nie moge otworzyc pliku");
  194.         exit(1);
  195.     }
  196.  
  197. /* Tworzenie kolejki komunikatów do komunikacji między procesami 1 i 2 */
  198.     umask(0);
  199.     idKolejki = msgget(IPC_PRIVATE, 0600 | IPC_CREAT);
  200.  
  201.     if(idKolejki == -1) {
  202.         close(deskryptorWejscia);
  203.         perror("Nie moge utworzyc kolejki");
  204.         exit(1);
  205.     }
  206.  
  207. /* Tworzenie łącza nazwanaego do komunikacji pomiędzy procesami 2 i 3 *
  208.    wcześniej "na wszelki wypadek" usuwam plik jeśli isnieje.*/
  209.     remove(FIFO_PATH);
  210.     if(mkfifo(FIFO_PATH, 0600) == -1) {
  211.         close(deskryptorWejscia);
  212.         msgctl(idKolejki, IPC_RMID, 0);
  213.         perror("Nie moge utworzyc fifo");
  214.         exit(1);
  215.     }
  216.  
  217. /* Tworzę pamięć dzieloną aby przekazać procesom p1-p3 pidy wszystkich procesów z tej grupy */
  218.     idPamieciDzielonej = shmget(IPC_PRIVATE, 3*sizeof(int), 0600 | IPC_CREAT);
  219.     if(idPamieciDzielonej == -1) {
  220.         remove(FIFO_PATH);
  221.         close(deskryptorWejscia);
  222.         msgctl(idKolejki, IPC_RMID, 0);
  223.         perror("Nie moge utworzyc pamieci dizelonej");
  224.         exit(1);
  225.     }
  226.  
  227. /* Pryzłączam pamięc dzieloną */
  228.     pidyPotomkow = (int*)shmat(idPamieciDzielonej, NULL, 0600 | IPC_CREAT);
  229.     if(pidyPotomkow == NULL) {
  230.         remove(FIFO_PATH);
  231.         close(deskryptorWejscia);
  232.         msgctl(idKolejki, IPC_RMID, 0);
  233.         perror("Nie moge dolaczyc pamieci dzielonej");
  234.         exit(1);
  235.     }
  236.  
  237. /* Tworzę semafor do synchornizacji dostępu do teblicy pidów */
  238.     idSemafora = semget(IPC_PRIVATE,  1, 0600 | IPC_CREAT);
  239.     if(idSemafora == -1) {
  240.         shmctl(idPamieciDzielonej, IPC_RMID, 0);
  241.         remove(FIFO_PATH);
  242.         close(deskryptorWejscia);
  243.         msgctl(idKolejki, IPC_RMID, 0);
  244.         perror("Tworzenie semaforow");
  245.         exit(1);
  246.     }
  247.  
  248. /* I ustaiwam dla niego wartość domyślną */
  249.     if (semctl(idSemafora, 0, SETVAL, 0) == -1){
  250.         semctl(idSemafora, 0, IPC_RMID, 0);
  251.         shmctl(idPamieciDzielonej, IPC_RMID, 0);
  252.         remove(FIFO_PATH);
  253.         close(deskryptorWejscia);
  254.         msgctl(idKolejki, IPC_RMID, 0);
  255.         perror("Nadanie wartosci semaforowi");
  256.         semctl(idSemafora, 0, IPC_RMID, 0);
  257.         exit(1);
  258.     }
  259. /* Przygotowuję maskę dla funkcji sigsuspend*/
  260.     sigfillset (&maskaOczekiwania);
  261.     sigdelset(&maskaOczekiwania, SYGNAL1);
  262.     sigdelset(&maskaOczekiwania, SYGNAL2);
  263.     sigdelset(&maskaOczekiwania, SYGNAL3);
  264.  
  265.     ostatniSygnal = SYGNAL3;
  266. /* Tworze procesy 1-3 */
  267.     int wartoscZwrocona = fork();
  268.     if ( wartoscZwrocona == 0 ) {
  269.         proces1();
  270.         exit(0);
  271.     }
  272.  
  273.     if ( wartoscZwrocona == -1 ) {
  274.         semctl(idSemafora, 0, IPC_RMID, 0);
  275.         shmctl(idPamieciDzielonej, IPC_RMID, 0);
  276.         remove(FIFO_PATH);
  277.         close(deskryptorWejscia);
  278.         msgctl(idKolejki, IPC_RMID, 0);
  279.         perror("Tworzenie p1");
  280.         semctl(idSemafora, 0, IPC_RMID, 0);
  281.     }
  282.     pidyPotomkow[0] = wartoscZwrocona;
  283.  
  284.     wartoscZwrocona = fork();
  285.     if ( wartoscZwrocona == 0 ) {
  286.         proces2();
  287.         exit(0);
  288.     }
  289.  
  290.     if ( wartoscZwrocona == -1 ) {
  291.         kill(SIGTERM, pidyPotomkow[0]);
  292.         semctl(idSemafora, 0, IPC_RMID, 0);
  293.         shmctl(idPamieciDzielonej, IPC_RMID, 0);
  294.         remove(FIFO_PATH);
  295.         close(deskryptorWejscia);
  296.         msgctl(idKolejki, IPC_RMID, 0);
  297.         perror("Tworzenie P2");
  298.         semctl(idSemafora, 0, IPC_RMID, 0);
  299.     }
  300.     pidyPotomkow[1] = wartoscZwrocona;
  301.  
  302.     wartoscZwrocona = fork();
  303.     if ( wartoscZwrocona == 0 ) {
  304.         proces3();
  305.         exit(0);
  306.     }
  307.  
  308.     if ( wartoscZwrocona == -1 ) {
  309.         kill(SIGTERM, pidyPotomkow[0]);
  310.         kill(SIGTERM, pidyPotomkow[1]);
  311.         semctl(idSemafora, 0, IPC_RMID, 0);
  312.         shmctl(idPamieciDzielonej, IPC_RMID, 0);
  313.         remove(FIFO_PATH);
  314.         close(deskryptorWejscia);
  315.         msgctl(idKolejki, IPC_RMID, 0);
  316.         perror("Tworzenie P2");
  317.         semctl(idSemafora, 0, IPC_RMID, 0);
  318.     }
  319.     pidyPotomkow[2] = wartoscZwrocona;
  320.     printf("Pid procesu P1:%d, pid procesu P2:%d, pid procesu P3:%d\n", pidyPotomkow[0], pidyPotomkow[1], pidyPotomkow[2]);
  321.     fflush(stdout);
  322.     zasygnalizujWpisaniePidow();
  323. /* Czekam na zakończenie procesów 1-3 */
  324.     wait(0);
  325.     wait(0);
  326.     wait(0);
  327. /* Usuwam utworzone mechanizmy komunkacji */
  328.     if(msgctl(idKolejki, IPC_RMID, 0)== -1) {
  329.         perror("Uuswanie kolejki komunikatow");
  330.     }
  331. /* Usuwanie fifo */
  332.     if(remove(FIFO_PATH) == -1) {
  333.         perror("Usuwanie fifo");
  334.     }
  335. /*Usuwam zestaw semaforów */
  336.     if(semctl(idSemafora, 0, IPC_RMID, 0) == -1) {
  337.         perror("Usuwanie semafora");
  338.     }
  339.  
  340. /*Usuwam pamieci dzielonej */
  341.     if(shmdt(pidyPotomkow) == -1) {
  342.         perror("shmdt");
  343.     }
  344.  
  345.     if(shmctl(idSemafora, IPC_RMID, 0) == -1) {
  346.         perror("Usuwanie pamieci dzielonej");
  347.     }
  348.  
  349.     close(deskryptoryFifo[0]);
  350.     close(deskryptoryFifo[1]);
  351. }
  352.  
  353. void proces1() {
  354.     size_t odczyantchZnakow;
  355.     char bufor[ROZMIAR_BUFORA];
  356. /* Oczekujemy na podniesienie semafora przez proces inicjalizujący i ustawiam procedury obsługi przerwań */
  357.     oczekaujNaWpisuaniePidow();
  358.     ustawSygnaly();
  359.     for(;1;) {
  360. /* Odczytujemy do bufora zanki z deskryptora wejścia oraz ich ilosc*/
  361.         odczyantchZnakow = odczytaj(deskryptorWejscia, bufor, ROZMIAR_BUFORA);
  362. /* I przekazujemy do prcoesu 2 przy użyciu kolejki komunikatów*/
  363.         wyslijKomunikat(odczyantchZnakow, bufor);
  364.         if(odczyantchZnakow<=0)
  365.             break;
  366.     }
  367.     exit(0);
  368. }
  369.  
  370. void proces2() {
  371.     long typ;
  372.     int ile;
  373.     char bufor[ROZMIAR_BUFORA];
  374.     char buforKonwersji[ROZMIAR_BUFORA_KONWERSJI];
  375. /* Oczekujemy na podniesienie semafora przez proces inicjalizujący i ustawiam procedury obsługi przerwań */
  376.     oczekaujNaWpisuaniePidow();
  377.     ustawSygnaly();
  378. /* Otwieramy łącze nazwane do zapisu w celu przezywania danych po konwersji ich na postać szesnastkowa*/
  379.     deskryptoryFifo[1] = open(FIFO_PATH, O_WRONLY);
  380.     if(deskryptoryFifo[1] == -1){
  381.         perror("otwieranie fifo zapis");
  382.         kill(getpid(), SYGNAL1);
  383.     }
  384.     for(;1;) {
  385. /* Odbieramy komunikat od procesu 1, zawiera dane pobrane przez ten proces oraz ilość znaków w pobrnaym ciągu */
  386.         odbiezKomunikat(1, &typ, &ile, bufor);
  387. /* Dokonujmey konwersji na zapis heksadecymalny */
  388.         ile = konwersjaNaSzesna(buforKonwersji, bufor, ile);
  389. /* I zapisuje do łącza nazwanego zapisując najpierw ilość znaków w tym ciągu a następnie same te znaki */
  390.         zapisz(deskryptoryFifo[1], (char *)(&ile), sizeof(int));
  391.         zapisz(deskryptoryFifo[1], buforKonwersji, ile);
  392.         if(ile == 0)
  393.             break;
  394.     }
  395.     exit(0);
  396. }
  397. void proces3() {
  398.     int ile;
  399.     char bufor[ROZMIAR_BUFORA_KONWERSJI];
  400.     char buforWypisywania[ILOSC_ZNAKOW_W_LINII * 3 + 2];
  401.     int ileWWypisywania = 0;
  402.     int i;
  403. /* Oczekujemy na podniesienie semafora przez proces inicjalizujący i ustawiam procedury obsługi przerwań */
  404.     oczekaujNaWpisuaniePidow();
  405.     ustawSygnaly();
  406. /* Otwieram łącze nazwane do oczytu skonwertowanych danych z procesu 2*/
  407.     deskryptoryFifo[0] = open(FIFO_PATH, O_RDONLY);
  408.     if(deskryptoryFifo[0] == -1){
  409.         perror("otwieranie fifo odczyt");
  410.         kill(getpid(), SYGNAL1);
  411.     }
  412.     for(;1;) {
  413. /* Odczytuje dname z fifo w formacie opisaym w procesie 2 przy ich zapisie */
  414.         odczytaj(deskryptoryFifo[0], (char *)(&ile), sizeof(int));
  415.         odczytaj(deskryptoryFifo[0], bufor, ile);
  416. /* Formatuje dane zgodnie z treścią polecenia i wypisuje po 15 */
  417.         for(i=0; i<ile; i+=2) {
  418.             buforWypisywania[3*ileWWypisywania] = bufor[i];
  419.             buforWypisywania[3*ileWWypisywania+1] = bufor[i + 1];
  420.             buforWypisywania[3*ileWWypisywania+2] = ' ';
  421. /* Za każdym razem dodaję znak nowej linii, potem nadpisuywany przy zapisie następnego znaku, służy to przygotwaniu
  422. bufora linii na kolejny zapis wynikający z końca pliku a nie zapełnieniea bufra linii */
  423.             buforWypisywania[3*ileWWypisywania+3] = '\n';
  424.             ileWWypisywania++;
  425. /* Wypisuje linię jeśli jest w niej 15 znaków */
  426.             if(ileWWypisywania >= ILOSC_ZNAKOW_W_LINII) {
  427.                 zapisz(1, buforWypisywania,ileWWypisywania*3+1);
  428.                 ileWWypisywania = 0;
  429.             }
  430.         }
  431. /* Lub gdy został zasygnalizowqany koniec wejścia */
  432.         if(ile <= 0) {
  433.             zapisz(1, buforWypisywania,ileWWypisywania*3+1);
  434.             ileWWypisywania = 0;          
  435.             break;
  436.         }
  437.     }
  438.     exit(0);
  439. }
  440.  
  441.  
  442. /* Prosta funkcja konwertująca ciąg znaków na zapis kolejnych bajtów w postaci heksadecymalnej opisanej przy deklarqacji */
  443. size_t konwersjaNaSzesna(char* wyjscie, char* wejscie, int rozmiarWejscia)
  444. {
  445.     int i = 0;
  446.     for(i = 0; i < rozmiarWejscia; i++)
  447.     {
  448.         wyjscie[2*i] = tablicaKonwersjiHEX[(wejscie[i] & 0xFF) >> 4];
  449.         wyjscie[2*i + 1] = tablicaKonwersjiHEX[(wejscie[i] & 0x0F)];
  450.     }
  451.     return 2*rozmiarWejscia;
  452. }
  453.  
  454. /* Procedura obsługi sygnału*/
  455. void obslugaSygnalow123(int numerSyngalu, siginfo_t* informacjeOSygnale, void* nieuzywane) {
  456.     int mojPid = getpid();
  457.     int pidNadawcy = informacjeOSygnale -> si_pid;
  458.     fprintf(stderr, "%d:Odebrano sygnal %d\n", mojPid, numerSyngalu);  
  459. /* Jeśli nadawcą nie jest proces ze zbioru p1-p3 to rozsyłamy ten sam sygnał do pozostałych procesów z tej grupy,
  460. jeśli jest to jeden z tych procesów to nie rozsyłam daleej sygnału, bo oznacza to, że ten sygnał powestał w wyniku opisanego
  461. powyżej działania */
  462.     if(!(pidNadawcy == pidyPotomkow[0] || pidNadawcy == pidyPotomkow[1] || pidNadawcy == pidyPotomkow[2])) {
  463.         if(mojPid != pidyPotomkow[0])
  464.             kill(pidyPotomkow[0], numerSyngalu);
  465.         if(mojPid != pidyPotomkow[1])
  466.             kill(pidyPotomkow[1], numerSyngalu);
  467.         if(mojPid != pidyPotomkow[2])
  468.             kill(pidyPotomkow[2], numerSyngalu);
  469.     }
  470. /* Rekcja na sygnał odpowiednia dla konkretnego sygnału */
  471.     switch (numerSyngalu)
  472.     {
  473.     case SYGNAL1:
  474.         exit(0);
  475.         break;
  476.  
  477.     case SYGNAL2:
  478.         sigsuspend(&maskaOczekiwania);
  479.         break;
  480.  
  481.     case SYGNAL3:
  482.         break;
  483.     }
  484. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top