API tools faq
paste
Czapek

kolos z systemow 2 chce umrzec

Czapek
Jun 5th, 2019
110
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 24.05 KB | None | 0 0
raw download clone embed print report diff
  1. KLICENT.C
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #define ROZM_BUF 2048
  6.  
  7. int main(int argc, char** argv)
  8. {
  9.     int dlugosc,x,i,j;
  10.     FILE *wynik_polecania = popen("./serwer", "r");
  11.     if(wynik_polecania)
  12.     {
  13.     char bufor[ROZM_BUF];
  14.     fgets(bufor, ROZM_BUF, wynik_polecania);
  15.     dlugosc=strlen(bufor);
  16.     while(!feof(wynik_polecania))
  17.     {
  18.         printf("Odebrano od serwera: %c\n",bufor[dlugosc-2]);
  19.         fgets(bufor, ROZM_BUF, wynik_polecania);
  20.     }
  21.     pclose(wynik_polecania);
  22.     fflush(stdout);
  23.     return EXIT_SUCCESS;
  24.     }
  25.     else
  26.     {
  27.         printf("nie udalo sie wykonac funkcji popen\n");
  28.         fflush(stdout);
  29.         return EXIT_SUCCESS;
  30.     }
  31. }
  32.  
  33. SERWER.C
  34.  
  35. #include <stdio.h>
  36. #include <stdlib.h>
  37. int main(int argc, char** argv)
  38. {
  39.     int i;
  40.     for(i=0; i<10; ++i)
  41.             printf("Linia z serwera nr %d\n", i);
  42.     fflush(stdout);
  43.     return (EXIT_SUCCESS);
  44. }
  45.  
  46.  
  47.  
  48.  
  49.  
  50.  
  51.  
  52. #include<stdio.h>
  53. #include<stdlib.h>
  54. #include<unistd.h>
  55. #include<sys/types.h>
  56. #include<string.h>
  57. #include<sys/wait.h>
  58. #define ROZM_BUF 2048
  59.  
  60. int main(int argc, char** argv)
  61. {
  62.     int fd1[2];
  63.     int fd2[2];// Used to store two ends of first pipe
  64.     pid_t p;
  65.    
  66.     if (pipe(fd1)==-1)
  67.     {
  68.         fprintf(stderr, "Pipe Failed" );
  69.         return 1;
  70.     }
  71.     if (pipe(fd2)==-1)
  72.     {
  73.         fprintf(stderr, "Pipe Failed" );
  74.         return 1;
  75.     }
  76.     p=fork();
  77.                     char komunikat[ROZM_BUF];
  78.                     char temp[ROZM_BUF];
  79.             int i;
  80.                         char bufor[ROZM_BUF];
  81.  
  82.     switch(p)
  83.     {
  84.         case -1:
  85.             printf("rozwidlenie procesu nie powiodło się\n");
  86.             exit(1);
  87.         case 0:
  88.             close(fd1[0]);
  89.             for(i=0; i<10; ++i)
  90.             {
  91.                
  92.                 snprintf(temp,ROZM_BUF,"Linia z serwera nr %d\n", i);
  93.                 strcat(komunikat, temp);
  94.             }
  95.             write(fd1[1], komunikat, strlen(komunikat)+1);
  96.              close(fd1[1]);
  97.                     exit(0);
  98.            
  99.             break;
  100.         default:
  101.             wait(NULL);
  102.             close(fd1[1]);
  103.             read(fd1[0], bufor, ROZM_BUF);
  104.                // dlugosc=strlen(bufor);
  105.  
  106.                     printf("Odebrano od serwera: %s\n",bufor);
  107.  
  108.                 close(fd1[0]);
  109.            
  110.     }
  111.  
  112. }
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120. // C program to demonstrate use of fork() and pipe()
  121. #include<stdio.h>
  122. #include<stdlib.h>
  123. #include<unistd.h>
  124. #include<sys/types.h>
  125. #include<string.h>
  126. #include<sys/wait.h>
  127.  
  128. int main()
  129. {
  130.     // We use two pipes
  131.     // First pipe to send input string from parent
  132.     // Second pipe to send concatenated string from child
  133.  
  134.     int fd1[2]; // Used to store two ends of first pipe
  135.     int fd2[2]; // Used to store two ends of second pipe
  136.  
  137.     char fixed_str[] = "forgeeks.org";
  138.     char input_str[100];
  139.     pid_t p;
  140.  
  141.     if (pipe(fd1)==-1)
  142.     {
  143.         fprintf(stderr, "Pipe Failed" );
  144.         return 1;
  145.     }
  146.     if (pipe(fd2)==-1)
  147.     {
  148.         fprintf(stderr, "Pipe Failed" );
  149.         return 1;
  150.     }
  151.  
  152.     scanf("%s", input_str);
  153.     p = fork();
  154.  
  155.     if (p < 0)
  156.     {
  157.         fprintf(stderr, "fork Failed" );
  158.         return 1;
  159.     }
  160.  
  161.     // Parent process
  162.     else if (p > 0)
  163.     {
  164.         char concat_str[100];
  165.  
  166.         close(fd1[0]); // Close reading end of first pipe
  167.  
  168.         // Write input string and close writing end of first
  169.         // pipe.
  170.         write(fd1[1], input_str, strlen(input_str)+1);
  171.         close(fd1[1]);
  172.  
  173.         // Wait for child to send a string
  174.         wait(NULL);
  175.  
  176.         close(fd2[1]); // Close writing end of second pipe
  177.  
  178.         // Read string from child, print it and close
  179.         // reading end.
  180.         read(fd2[0], concat_str, 100);
  181.         printf("Concatenated string %s\n", concat_str);
  182.         close(fd2[0]);
  183.     }
  184.  
  185.     // child process
  186.     else
  187.     {
  188.         close(fd1[1]); // Close writing end of first pipe
  189.  
  190.         // Read a string using first pipe
  191.         char concat_str[100];
  192.         read(fd1[0], concat_str, 100);
  193.  
  194.         // Concatenate a fixed string with it
  195.         int k = strlen(concat_str);
  196.         int i;
  197.         for (i=0; i<strlen(fixed_str); i++)
  198.             concat_str[k++] = fixed_str[i];
  199.  
  200.         concat_str[k] = '\0'; // string ends with '\0'
  201.  
  202.         // Close both reading ends
  203.         close(fd1[0]);
  204.         close(fd2[0]);
  205.  
  206.         // Write concatenated string and close writing end
  207.         write(fd2[1], concat_str, strlen(concat_str)+1);
  208.         close(fd2[1]);
  209.  
  210.         exit(0);
  211.     }
  212. }
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221. // C program to implement one side of FIFO
  222. // This side reads first, then reads
  223. #include <stdio.h>
  224. #include <string.h>
  225. #include <fcntl.h>
  226. #include <sys/stat.h>
  227. #include <sys/types.h>
  228. #include <unistd.h>
  229.  
  230. int main()
  231. {
  232.     int fd1;
  233.  
  234.     // FIFO file path
  235.     char * myfifo = "/tmp/myfifo";
  236.  
  237.     // Creating the named file(FIFO)
  238.     // mkfifo(<pathname>,<permission>)
  239.     mkfifo(myfifo, 0666);
  240.  
  241.     char str1[80], str2[80];
  242.     while (1)
  243.     {
  244.         // First open in read only and read
  245.         fd1 = open(myfifo,O_RDONLY);
  246.         read(fd1, str1, 80);
  247.  
  248.         // Print the read string and close
  249.         printf("User1: %s\n", str1);
  250.         close(fd1);
  251.  
  252.         // Now open in write mode and write
  253.         // string taken from user.
  254.         fd1 = open(myfifo,O_WRONLY);
  255.         fgets(str2, 80, stdin);
  256.         write(fd1, str2, strlen(str2)+1);
  257.         close(fd1);
  258.     }
  259.     return 0;
  260. }
  261.  
  262.  
  263.  
  264. #include <sys/types.h>
  265. #include <unistd.h>
  266. #include <stdio.h>
  267. #include <stdlib.h>
  268.  
  269. //odczytywanie PIDa potomka, obecnego procesu i rodzica
  270.  
  271. const int DL_NAPISU=80;
  272.  
  273. int main(int argc, char** argv)
  274. {
  275.     pid_t pid_potomka,pid_moj,pid_rodzica;
  276.     char komunikat[DL_NAPISU];
  277.     int powtorzen;
  278.     printf("Na razie dziaĹ‚a jeden proces\n");
  279.     pid_potomka = fork();
  280.     pid_rodzica=getppid();
  281.     pid_moj=getpid();
  282.     switch (pid_potomka)
  283.     {
  284.         case -1:
  285.             perror("rozwidlenie procesu nie powiodĹ‚o siÄ™");
  286.             exit(1);
  287.         case 0:
  288.             snprintf(komunikat,DL_NAPISU,"Jestem potomkiem, PID potomka = %d, moj PID=%d a PID rodzica =%d",
  289.                     pid_potomka,pid_moj,pid_rodzica);
  290.             powtorzen = 5;
  291.             break;
  292.         default:
  293.             snprintf(komunikat,DL_NAPISU,"Jestem rodzicem, PID potomka = %d, moj PID=%d a PID rodzica =%d",
  294.                     pid_potomka,pid_moj,pid_rodzica);
  295.             powtorzen = 5;
  296.             break;
  297.     }
  298.     for (; powtorzen > 0; powtorzen--)
  299.     {
  300.         puts(komunikat);
  301.         sleep(1);
  302.     }
  303. }
  304.  
  305.  
  306.  
  307.  
  308.  
  309. #include <sys/types.h>
  310. #include <unistd.h>
  311. #include <stdio.h>
  312. #include <stdlib.h>
  313.  
  314. //zombie - potomek kończy wykowanie wcześniej
  315. //sierota - rodzic kończy wykonanie wcześniej
  316.  
  317. const int DL_NAPISU=80;
  318.  
  319. int main(int argc, char** argv)
  320. {
  321.     pid_t pid_potomka,pid_moj,pid_rodzica;
  322.     char komunikat[DL_NAPISU];
  323.     int powtorzen;
  324.     printf("Na razie dziaĹ‚a jeden proces\n");
  325.     pid_potomka = fork();
  326.     pid_rodzica=getppid();
  327.     pid_moj=getpid();
  328.     switch (pid_potomka)
  329.     {
  330.         case -1:
  331.             perror("rozwidlenie procesu nie powiodĹ‚o siÄ™");
  332.             exit(1);
  333.         case 0:
  334.             snprintf(komunikat,DL_NAPISU,"Jestem potomkiem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
  335.                     pid_potomka,pid_moj,pid_rodzica);
  336.             powtorzen = 1;
  337.             break;
  338.         default:
  339.             snprintf(komunikat,DL_NAPISU,"Jestem rodzicem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
  340.                     pid_potomka,pid_moj,pid_rodzica);
  341.             powtorzen =3;
  342.             break;
  343.     }
  344.     for (; powtorzen > 0; powtorzen--)
  345.     {
  346.         puts(komunikat);
  347.         sleep(1);
  348.     }
  349.     switch (pid_potomka)
  350.     {   //wyĹ›wietlamy listy procesĂłw tuĹĽ przed zakoĹ„czeniem - dziÄ™ki temu moĹĽna zaobserwować status zombie
  351.         case 0: system("ps -ef | grep fork3 | grep -v grep");
  352.                 printf("Jestem potomkiem i koĹ„czÄ™ wykonanie\n");
  353.                 break;
  354.         default: system("ps -ef | grep fork3 | grep -v grep");
  355.                  printf("Jetem rodzicem i koĹ„czÄ™ wykonanie\n");
  356.                  break;
  357.     }
  358. }
  359. #include <sys/types.h>
  360. #include <sys/wait.h>
  361. #include <unistd.h>
  362. #include <stdio.h>
  363. #include <stdlib.h>
  364.  
  365. //zombie - potomek kończy wykowanie wcześniej
  366. //sierota - rodzic kończy wykonanie wcześniej
  367. //pasywne czekanie na zakończenie potomka - rodzic jest blokowany
  368.  
  369. const int DL_NAPISU=80;
  370.  
  371. int main(int argc, char** argv)
  372. {
  373.     pid_t pid_potomka,pid_moj,pid_rodzica;
  374.     char komunikat[DL_NAPISU];
  375.     int powtorzen;
  376.     int status=0;
  377.     printf("Na razie dziaĹ‚a jeden proces\n");
  378.     pid_potomka = fork();
  379.     pid_rodzica=getppid();
  380.     pid_moj=getpid();
  381.     switch (pid_potomka)
  382.     {
  383.         case -1:
  384.             perror("rozwidlenie procesu nie powiodĹ‚o siÄ™");
  385.             exit(1);
  386.         case 0:
  387.             snprintf(komunikat,DL_NAPISU,"Jestem potomkiem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
  388.                     pid_potomka,pid_moj,pid_rodzica);
  389.             powtorzen = 15;
  390.             break;
  391.         default:
  392.             snprintf(komunikat,DL_NAPISU,"Jestem rodzicem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
  393.                     pid_potomka,pid_moj,pid_rodzica);
  394.             powtorzen = 5;
  395.             break;
  396.     }
  397.     for (; powtorzen > 0; powtorzen--)
  398.     {
  399.         puts(komunikat);
  400.         sleep(1);
  401.     }
  402.     switch (pid_potomka)
  403.     {   //wyĹ›wietlamy listy procesĂłw tuĹĽ przed zakoĹ„czeniem - dziÄ™ki temu moĹĽna zaobserwować status zombie
  404.         case 0: system("ps aux | grep fork");
  405.                 printf("Jestem potomkiem i koĹ„czÄ™ wykonanie\n");
  406.                 break;
  407.         default: printf("Jestem rodzicem i czekam na zakoĹ„czenie potomka\n");
  408.                  //rodzic jest blokowany
  409.                  pid_potomka=wait(&status);
  410.                  printf("Jestem rodzicem, potomek o PID=%d wĹ‚aĹ›nie siÄ™ zakoĹ„czyĹ‚\n",pid_potomka);
  411.                  system("ps aux | grep fork");
  412.                  printf("Jetem rodzicem i koĹ„czÄ™ wykonanie\n");
  413.                  break;
  414.     }
  415. }
  416.  
  417.  
  418.  
  419. #include <sys/types.h>
  420. #include <sys/wait.h>
  421. #include <unistd.h>
  422. #include <stdio.h>
  423. #include <stdlib.h>
  424.  
  425. //zombie - potomek kończy wykowanie wcześniej
  426. //sierota - rodzic kończy wykonanie wcześniej
  427. //aktywne czekanie na zakończenie potomka
  428.  
  429. const int DL_NAPISU=80;
  430.  
  431. int main(int argc, char** argv)
  432. {
  433.     pid_t pid_potomka,pid_moj,pid_rodzica;
  434.     char komunikat[DL_NAPISU];
  435.     int powtorzen;
  436.     int status=0;
  437.     printf("Na razie dziaĹ‚a jeden proces\n");
  438.     pid_potomka = fork();
  439.     pid_rodzica=getppid();
  440.     pid_moj=getpid();
  441.     switch (pid_potomka)
  442.     {
  443.         case -1:
  444.             perror("rozwidlenie procesu nie powiodĹ‚o siÄ™");
  445.             exit(1);
  446.         case 0:
  447.             snprintf(komunikat,DL_NAPISU,"Jestem potomkiem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
  448.                     pid_potomka,pid_moj,pid_rodzica);
  449.             powtorzen = 4;
  450.             break;
  451.         default:
  452.             snprintf(komunikat,DL_NAPISU,"Jestem rodzicem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
  453.                     pid_potomka,pid_moj,pid_rodzica);
  454.             powtorzen = 2;
  455.             break;
  456.     }
  457.     for (; powtorzen > 0; powtorzen--)
  458.     {
  459.         puts(komunikat);
  460.         sleep(1);
  461.     }
  462.     switch (pid_potomka)
  463.     {   //wyĹ›wietlamy listy procesĂłw tuĹĽ przed zakoĹ„czeniem - dziÄ™ki temu moĹĽna zaobserwować status zombie
  464.         case 0: //system("ps aux | grep fork");
  465.                 printf("Jestem potomkiem i koĹ„czÄ™ wykonanie\n");
  466.                 break;
  467.         default: pid_potomka=0;
  468.                  //czekamy w pÄ™tli na zakoĹ„czenie potomka - rodzic teĹĽ pracować
  469.                  while (pid_potomka==0)
  470.                  {
  471.                         printf("Jestem rodzicem i czekam na zakoĹ„czenie potomka\n");
  472.                         pid_potomka=waitpid(-1,       //dowolny proces potomny
  473.                                             &status,   //status
  474.                                             WNOHANG); //nie zatrzymuje procesu wywoĹ‚ujÄ…cego
  475.                         sleep(1);
  476.                  }
  477.                  printf("Jestem rodzicem, potomek o PID=%d wĹ‚aĹ›nie siÄ™ zakoĹ„czyĹ‚\n",pid_potomka);
  478.                  //system("ps aux | grep fork");
  479.                  printf("Jestem rodzicem i koĹ„czÄ™ wykonanie\n");
  480.                  break;
  481.     }
  482. }
  483.  
  484.  
  485.  
  486.  
  487. #include <sys/types.h>
  488. #include <sys/wait.h>
  489. #include <unistd.h>
  490. #include <stdio.h>
  491. #include <stdlib.h>
  492.  
  493. //zombie - potomek kończy wykowanie wcześniej
  494. //sierota - rodzic kończy wykonanie wcześniej
  495. //aktywne czekanie na zakończenie potomka
  496.  
  497. const int DL_NAPISU=80;
  498.  
  499. int main(int argc, char** argv)
  500. {
  501.     pid_t pid_potomka,pid_moj,pid_rodzica;
  502.     char komunikat[DL_NAPISU];
  503.     int powtorzen;
  504.     int status=0;
  505.     printf("Na razie dziaĹ‚a jeden proces\n");
  506.     pid_potomka = fork();
  507.     pid_rodzica=getppid();
  508.     pid_moj=getpid();
  509.     switch (pid_potomka)
  510.     {
  511.         case -1:
  512.             perror("rozwidlenie procesu nie powiodĹ‚o siÄ™");
  513.             exit(1);
  514.         case 0:
  515.             snprintf(komunikat,DL_NAPISU,"Jestem potomkiem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
  516.                     pid_potomka,pid_moj,pid_rodzica);
  517.             powtorzen = 15;
  518.             break;
  519.         default:
  520.             snprintf(komunikat,DL_NAPISU,"Jestem rodzicem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d",
  521.                     pid_potomka,pid_moj,pid_rodzica);
  522.             powtorzen = 5;
  523.             break;
  524.     }
  525.     for (; powtorzen > 0; powtorzen--)
  526.     {
  527.         puts(komunikat);
  528.         sleep(1);
  529.     }
  530.     switch (pid_potomka)
  531.     {   //wyĹ›wietlamy listy procesĂłw tuĹĽ przed zakoĹ„czeniem - dziÄ™ki temu moĹĽna zaobserwować status zombie
  532.         case 0: system("ps aux | grep fork");
  533.                 printf("Jestem potomkiem i koĹ„czÄ™ wykonanie\n");
  534.                 break;
  535.         default: pid_potomka=0;
  536.                  //czekamy w pÄ™tli na zakoĹ„czenie potomka - rodzic teĹĽ pracować
  537.                  while (pid_potomka==0)
  538.                  {
  539.                         printf("Jestem rodzicem i czekam na zakoĹ„czenie potomka\n");
  540.                         pid_potomka=waitpid(-1,       //dowolny proces potomny
  541.                                             &status,   //status
  542.                                             WNOHANG); //nie zatrzymuje procesu wywoĹ‚ujÄ…cego
  543.                         sleep(1);
  544.                  }
  545.                  printf("Jestem rodzicem, potomek o PID=%d wĹ‚aĹ›nie siÄ™ zakoĹ„czyĹ‚\n",pid_potomka);
  546.                  system("ps aux | grep fork");
  547.                  printf("Jetem rodzicem i koĹ„czÄ™ wykonanie\n");
  548.                  break;
  549.     }
  550. }
  551.  
  552.  
  553.  
  554.  
  555. #include <sys/types.h>
  556. #include <unistd.h>
  557. #include <stdio.h>
  558. #include <stdlib.h>
  559.  
  560. //odczytywanie PID, UID i GID procesu
  561.  
  562. int main(int argc, char** argv)
  563. {
  564.     pid_t pid;
  565.     uid_t uid;
  566.     gid_t gid;
  567.     uid_t euid;
  568.     gid_t egid;
  569.     pid=getpid();
  570.     uid=getuid();
  571.     gid=getgid();
  572.     euid=geteuid();
  573.     egid=getegid();
  574.     system("id");
  575.     printf("MĂłj numer procesu to PID=%d\n",pid);
  576.     printf("Rzeczywisty identyfikator uĹĽytkownika UID=%d i grupy GID=%d\n",uid,gid);
  577.     printf(" Efektywny identyfikator uĹĽytkownika UID=%d i grupy GID=%d\n",euid,egid);
  578.     system("id");
  579.  
  580.     setuid(0);
  581.     setgid(0);
  582.     seteuid(0);
  583.     setegid(0);
  584.     uid=getuid();
  585.     gid=getgid();
  586.     euid=geteuid();
  587.     egid=getegid();
  588.     printf("Rzeczywisty identyfikator uĹĽytkownika UID=%d i grupy GID=%d\n",uid,gid);
  589.     printf(" Efektywny identyfikator uĹĽytkownika UID=%d i grupy GID=%d\n",euid,egid);
  590.     system("id");
  591.  
  592.     setuid(500);
  593.     setgid(500);
  594.     seteuid(500);
  595.     setegid(500);
  596.     uid=getuid();
  597.     gid=getgid();
  598.     euid=geteuid();
  599.     egid=getegid();
  600.     printf("Rzeczywisty identyfikator uĹĽytkownika UID=%d i grupy GID=%d\n",uid,gid);
  601.     printf(" Efektywny identyfikator uĹĽytkownika UID=%d i grupy GID=%d\n",euid,egid);
  602.     system("id");
  603. }
  604.  
  605.  
  606.  
  607.  
  608.  
  609. #include <sys/types.h>
  610. #include <stdio.h>
  611. #include <stdlib.h>
  612. #include <unistd.h>
  613. #include <iostream>
  614. #include <string.h>
  615. using namespace std;
  616.  
  617. //zombie - potomek kończy wykowanie wcześniej
  618. //sierota - rodzic kończy wykonanie wcześniej
  619.  
  620. int main(int argc, char** argv, char **envp)
  621. {
  622.     pid_t pid_potomka,pid_moj,pid_rodzica;
  623.     printf("Na razie dziaĹ‚a jeden proces\n");
  624.  
  625.     char something[40];
  626.  
  627.     char katalog[150];
  628.     getcwd(katalog, 150);
  629.     printf("katalog biezacy to %s\n",katalog);
  630.  
  631.     pid_potomka = fork();
  632.     pid_rodzica=getppid();
  633.     pid_moj=getpid();
  634.     switch (pid_potomka)
  635.     {
  636.         case -1:
  637.             perror("rozwidlenie procesu nie powiodĹ‚o siÄ™");
  638.             exit(1);
  639.         case 0:
  640.             printf("Jestem potomkiem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d\n",
  641.                     pid_potomka,pid_moj,pid_rodzica);
  642.             getcwd(katalog, sizeof(katalog));
  643.             printf("katalog biezacy potomka to %s\n",katalog);
  644.             if (argv[1] == NULL)
  645.                 {
  646.                     printf("Nie podales nazwy katalogu jako argumentu wywolania programu\n");
  647.                     exit(1);
  648.                 }
  649.             else
  650.         {
  651.                     strcpy(katalog,argv[1]);
  652.                 cout << "Enter your name: ";
  653.                 cin >> something;
  654.                 cout<<"Podales: "<<something<<"\n";
  655.                 }  
  656.             //chdir("/home/maciejp/Pulpit");
  657.             //printf("podaj nazwe katalogu: ");
  658.         //cin>>katalog;
  659.  
  660.             chdir(katalog);
  661.  
  662.             getcwd(katalog, sizeof(katalog));
  663.             printf("Nowa wartosc katlogu roboczego odczytanego przez getcwd() to: %s\n",katalog);
  664.             sleep(5);
  665.             break;
  666.         default:
  667.             printf("Jestem rodzicem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d - koncze dzialanie\n",
  668.                     pid_potomka,pid_moj,pid_rodzica);
  669.             sleep(1);
  670.             break;
  671.     }
  672. }
  673.  
  674.  
  675.  
  676. #include <sys/types.h>
  677. #include <unistd.h>
  678. #include <stdio.h>
  679. #include <stdlib.h>
  680. #include <unistd.h>
  681. #include <iostream>
  682. #include <string.h>
  683. #include <sys/stat.h>
  684. using namespace std;
  685.  
  686. //zombie - potomek kończy wykowanie wcześniej
  687. //sierota - rodzic kończy wykonanie wcześniej
  688.  
  689. int main(int argc, char** argv, char **envp)
  690. {
  691.     pid_t pid_potomka,pid_moj,pid_rodzica;
  692.     printf("Na razie dziaĹ‚a jeden proces\n");
  693.  
  694.     char katalog[150];
  695.     getcwd(katalog, 150);
  696.     printf("katalog biezacy to %s\n",katalog);
  697.  
  698.     pid_potomka = fork();
  699.     pid_rodzica=getppid();
  700.     pid_moj=getpid();
  701.     switch (pid_potomka)
  702.     {
  703.         case -1:
  704.             perror("rozwidlenie procesu nie powiodĹ‚o siÄ™");
  705.             exit(1);
  706.         case 0:
  707.             printf("Jestem potomkiem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d\n",
  708.                     pid_potomka,pid_moj,pid_rodzica);
  709.             getcwd(katalog, sizeof(katalog));
  710.             printf("katalog biezacy potomka to %s\n",katalog);
  711.             if (argv[1] == NULL)
  712.                 {
  713.                     printf("Nie podales nazwy katalogu jako argumentu wywolania programu\n");
  714.                     exit(1);
  715.                 }
  716.             else
  717.                 strcpy(katalog,argv[1]);
  718.             //chdir("/home/maciejp/Pulpit");
  719.             mkdir(katalog, 0744);//S_IRWXU | S_IRWXG | S_IRWXO);
  720.             chown(katalog, 500,500);
  721.             chdir(katalog);
  722.             getcwd(katalog, sizeof(katalog));
  723.             printf("Nowa wartosc katlogu roboczego odczytanego przez getcwd() to: %s\n",katalog);
  724.             sleep(5);
  725.             break;
  726.         default:
  727.             printf("Jestem rodzicem, PID potomka = %d, moj PID=%d a PID mojego rodzica =%d - koncze dzialanie\n",
  728.                     pid_potomka,pid_moj,pid_rodzica);
  729.             sleep(1);
  730.             break;
  731.     }
  732. }
  733.  
  734.  
  735.  
  736.  
  737. #include <sys/types.h>
  738. #include <sys/stat.h>
  739. #include <unistd.h>
  740. #include <stdio.h>
  741.  
  742. int main(int argc, char *argv[])
  743. {
  744.     struct stat sb;
  745.     int ret;
  746.  
  747.     if (argc < 2)
  748.     {
  749.         fprintf(stderr, "Uzycie programu:%s <nazwa pliku>\n", argv[0]);
  750.         return 1;
  751.     }
  752.     ret=stat(argv[1], &sb);
  753.     if (ret)
  754.     {
  755.         perror("stat");
  756.         return 1;
  757.     }
  758.     printf("%s ma rozmiar %ld bajtĂłw\n", argv[1], sb.st_size);
  759.     return 0;
  760. }
  761.  
  762.  
  763.  
  764.  
  765.  
  766. #include <signal.h>
  767. #include <stdio.h>
  768. #include <unistd.h>
  769.  
  770. //podstawowa wersja programu wyświetla cykliczne 3 napisy po naciśnięciu CTRL+C
  771. //zakończenie programu CTRL+\ (SIGQUIT)
  772.  
  773. char napisy[3][80]={"Ha! Ha! Ha! To tylko sygnał powierzchowny!\n",
  774.                     "Tylko proces %d Ĺ›mieje siÄ™ sygnaĹ‚owi %d prosto w twarz!\n",
  775.                     "Auć - to bolaĹ‚o!\n"};
  776. int nr_napisu=0;
  777.  
  778. void obsluga_sig_int(int sig)
  779. {
  780.     printf(napisy[nr_napisu],getpid(),sig);
  781.     nr_napisu=((nr_napisu + 1) % 3);
  782. }
  783.  
  784. int main(int argc, char** argv)
  785. {
  786.     signal(SIGINT,obsluga_sig_int);
  787.    
  788.     while (true)
  789.     {
  790.         printf("Cześć tu proces: %d\n",getpid());
  791.         sleep(1);
  792.     }
  793.    
  794.     return 0;
  795. }
  796.  
  797.  
  798.  
  799.  
  800.  
  801. #include <stdlib.h>
  802. #include <signal.h>
  803. #include <stdio.h>
  804. #include <unistd.h>
  805.  
  806. //podstawowy program zmodyfikowany tak aby kończył się po 4-tym naciśnięciu CTRL+C
  807.  
  808. char napisy[3][80]={"Ha! Ha! Ha! To tylko sygnał powierzchowny!\n",
  809.                     "Tylko proces %d Ĺ›mieje siÄ™ sygnaĹ‚owi %d prosto w twarz!\n",
  810.                     "Auć - to bolaĹ‚o!\n"};
  811. int nr_napisu=0;
  812.  
  813. void obsluga_sig_int(int sig)
  814. {
  815.     if (nr_napisu==3)
  816.     {
  817.         printf("Dobrze! Dobrze! JuĹĽ koĹ„czÄ™.\n");
  818.         exit(1);
  819.     }
  820.     printf(napisy[nr_napisu],getpid(),sig);
  821.     nr_napisu++;
  822. }
  823.  
  824. int main(int argc, char** argv)
  825. {
  826.     signal(SIGINT,obsluga_sig_int);
  827.    
  828.     while (true)
  829.     {
  830.         printf("Cześć tu proces: %d\n",getpid());
  831.         sleep(1);
  832.     }
  833.    
  834.     return 0;
  835. }
  836.  
  837.  
  838.  
  839.  
  840. #include <stdlib.h>
  841. #include <signal.h>
  842. #include <stdio.h>
  843. #include <unistd.h>
  844.  
  845. //przywrócenie domyślnej obsługi CTRL+C za pomocą SIGQUIT (CTRL+\)
  846.  
  847. char napisy[3][80]={"Ha! Ha! Ha! To tylko sygnał powierzchowny!\n",
  848.                     "Tylko proces %d Ĺ›mieje siÄ™ sygnaĹ‚owi %d prosto w twarz!\n",
  849.                     "Auć - to bolaĹ‚o!\n"};
  850. int nr_napisu=0;
  851.  
  852. void obsluga_sig_int(int sig)
  853. {
  854.     printf(napisy[nr_napisu],getpid(),sig);
  855.     nr_napisu=(nr_napisu + 1) % 3;
  856. }
  857.  
  858. void obsluga_sig_quit(int sig)
  859. {
  860.     printf("Przywracam domyĹ›lnÄ… obsĹ‚ugÄ™ CTRL+C\n");
  861.     //makro SIG_DFL - domyĹ›lna obsĹ‚uga sygnaĹ‚u
  862.     signal(SIGINT,SIG_DFL);
  863. }
  864.  
  865. int main(int argc, char** argv)
  866. {
  867.     signal(SIGINT,obsluga_sig_int);
  868.     signal(SIGQUIT,obsluga_sig_quit);
  869.    
  870.     while (true)
  871.     {
  872.         printf("Cześć tu proces: %d\n",getpid());
  873.         sleep(1);
  874.     }
  875.    
  876.     return 0;
  877. }
  878.  
  879.  
  880.  
  881.  
  882. #include <stdlib.h>
  883. #include <signal.h>
  884. #include <stdio.h>
  885. #include <unistd.h>
  886.  
  887. //przywrócenie domyślnej obsługi CTRL+C za pomocą alarmu
  888.  
  889. char napisy[3][80]={"Ha! Ha! Ha! To tylko sygnał powierzchowny!\n",
  890.                     "Tylko proces %d Ĺ›mieje siÄ™ sygnaĹ‚owi %d prosto w twarz!\n",
  891.                     "Auć - to bolaĹ‚o!\n"};
  892. int nr_napisu=0;
  893.  
  894. void obsluga_sig_int(int sig)
  895. {
  896.     printf(napisy[nr_napisu],getpid(),sig);
  897.     nr_napisu=(nr_napisu + 1) % 3;
  898. }
  899.  
  900. void obsluga_sig_alrm(int sig)
  901. {
  902.     printf("Ding! Ding! - Przywracam domyĹ›lnÄ… obsĹ‚ugÄ™ CTRL+C\n");
  903.     signal(SIGINT,SIG_DFL);
  904. }
  905.  
  906. int main(int argc, char** argv)
  907. {
  908.     signal(SIGINT,obsluga_sig_int);
  909.     signal(SIGALRM,obsluga_sig_alrm);
  910.    
  911.     //przywracamy domyĹ›lnÄ… obsĹ‚ugÄ™ po 15 sekundach
  912.     alarm(15);
  913.    
  914.     while (true)
  915.     {
  916.         printf("Cześć tu proces: %d\n",getpid());
  917.         sleep(1);
  918.     }
  919.    
  920.     return 0;
  921. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!