Untitled

SUBMITTED BY: antoineh1

DATE: May 8, 2016, 10:07 p.m.

FORMAT: Text only

SIZE: 5.2 kB

Raw Download

HITS: 3601

Report
  1. //Pierwszy program
  2. #include <sys/types.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <fcntl.h>
  8. #include <sys/stat.h>
  9. #include <sys/wait.h>
  10. #include <time.h>
  12. int main(int argc,char **argv)
  13. {
  14. char bufor[50];
  15. int file_read,file_open,file_open_p,file_read_p;
  16. srand(time(0));
  18. if (argc != 3)
  19. {
  20. printf ("%s <file name>", argv[0]);
  21. return 1;
  22. }
  24. mkfifo("potok",0640);
  26. file_open=open(argv[2],O_WRONLY | O_CREAT,0640);
  27. if (file_open==-1)
  28. {
  29. perror("write_only_file error");
  30. exit(EXIT_FAILURE);
  31. }
  33. file_read=open(argv[1],O_RDONLY,0640);
  34. if (file_read==-1)
  35. {
  36. perror("read_only_file error");
  37. exit(EXIT_FAILURE);
  38. }
  40. switch (fork())
  41. {
  42. case -1:
  44. perror("fork error");
  45. exit(EXIT_FAILURE);
  47. case 0:
  49. file_open_p=open("potok",O_RDONLY,0640);
  50. if (file_open_p==-1)
  51. {
  52. perror("write_p error");
  53. exit(EXIT_FAILURE);
  54. }
  55. while(read(file_open_p,&bufor,25)>0)
  56. {
  57. write(STDOUT_FILENO, &bufor, 25);
  58. write(file_open,&bufor,25);
  59. }
  60. close(file_open);
  61. close(file_open_p);
  62. printf("\n");
  63. _exit(EXIT_SUCCESS);
  64. break;
  66. default:
  68. file_read_p=open("potok",O_WRONLY | O_CREAT,0640);
  69. if (file_read_p==-1)
  70. {
  71. perror("read_p error");
  72. exit(EXIT_FAILURE);
  73. }
  74. while(read(file_read,&bufor,50)>0)
  75. {
  76. sleep(rand()%3);
  77. write(file_read_p,&bufor,50);
  78. }
  79. close(file_read);
  80. close(file_read_p);
  81. wait(NULL);
  82. exit(EXIT_SUCCESS);
  83. break;
  85. };
  86. return 0;
  88. }
  89. //Drugi program w dwoch osobnyach plikach do uruchamiania na dwoch konsolach
  90. //producent
  91. #include <sys/types.h>
  92. #include <stdio.h>
  93. #include <stdlib.h>
  94. #include <unistd.h>
  95. #include <string.h>
  96. #include <fcntl.h>
  97. #include <sys/stat.h>
  98. #include <sys/wait.h>
  99. #include <time.h>
  101. int main(int argc,char **argv)
  102. {
  103. char bufor[50];
  104. int file_read,file_read_p;
  105. srand(time(0));
  107. if (argc != 2)
  108. {
  109. printf ("%s <file name>", argv[0]);
  110. return 1;
  111. }
  113. file_read=open(argv[1],O_RDONLY,0640);
  114. if (file_read==-1)
  115. {
  116. perror("read_only_file error");
  117. exit(EXIT_FAILURE);
  118. }
  120. switch (fork())
  121. {
  122. case -1:
  124. perror("fork error");
  125. exit(EXIT_FAILURE);
  127. case 0:
  129. file_read_p=open("potok",O_WRONLY | O_CREAT,0640);
  130. if (file_read_p==-1)
  131. {
  132. perror("read_p error");
  133. exit(EXIT_FAILURE);
  134. }
  135. while(read(file_read,&bufor,50)>0)
  136. {
  137. sleep(rand()%3);
  138. write(file_read_p,&bufor,50);
  139. }
  140. close(file_read);
  141. close(file_read_p);
  142. wait(NULL);
  143. exit(EXIT_SUCCESS);
  144. break;
  146. default:;
  148. };
  149. return 0;
  151. }
  152. //konsument
  153. #include <sys/types.h>
  154. #include <stdio.h>
  155. #include <stdlib.h>
  156. #include <unistd.h>
  157. #include <string.h>
  158. #include <fcntl.h>
  159. #include <sys/stat.h>
  160. #include <sys/wait.h>
  161. #include <time.h>
  163. int main(int argc,char **argv)
  164. {
  165. char bufor[50];
  166. int file_open,file_open_p;
  167. srand(time(0));
  169. if (argc != 2)
  170. {
  171. printf ("%s <file name>", argv[0]);
  172. return 1;
  173. }
  175. file_open=open(argv[1],O_WRONLY | O_CREAT,0640);
  176. if (file_open==-1)
  177. {
  178. perror("write_only_file error");
  179. exit(EXIT_FAILURE);
  180. }
  182. switch (fork())
  183. {
  184. case -1:
  186. perror("fork error");
  187. exit(EXIT_FAILURE);
  189. case 0:
  191. file_open_p=open("potok",O_RDONLY,0640);
  192. if (file_open_p==-1)
  193. {
  194. perror("write_p error");
  195. exit(EXIT_FAILURE);
  196. }
  197. while(read(file_open_p,&bufor,25)>0)
  198. {
  199. write(STDOUT_FILENO, &bufor, 25);
  200. write(file_open,&bufor,25);
  201. }
  202. close(file_open);
  203. close(file_open_p);
  204. printf("\n");
  205. _exit(EXIT_SUCCESS);
  206. break;
  208. default:
  209. break;
  212. };
  213. return 0;
  215. }
  216. /makefile nie wiem do konca czy dobry
  217. Fifo: zadanie5.c
  218. gcc zadanie5.c -o Fifo.o && ./Fifo.o wejscie.txt wyjscie.txt
  219. clean: potok
  220. rm potok
  221. Potok:
  222. mkfifo -m 644 potok
  223. ProdKons: producent.c
  224. gcc producent.c -o Prod.o && ./Prod.o wejscie1.txt
  225. gcc konsument.c -o Kons.o && ./Kons.o wyjscie1.txt
  226. cleano:
  227. rm -f *.o
comments powered by Disqus