POSIX unbuffered file I/O and Variable Parameter play

The previously written test program includes the comprehensive application of POSIX unbuffered file I/O, file addition and unlocking, process forks, and variable parameters. There is no technical content. I just want to describe it and don't want to lose it one day.

C is really small and flexible, and there are still some features that I could not think of before in terms of language ~ However, can I only use C and not c ++ for this job? Do you really have to say goodbye to your favorites?

1. // POSIX
2. # Include <unistd. h>
3. # Include <sys/types. h> // For pid_t
4. # Include <sys/STAT. h>
5. # Include <sys/file. h>
6. # Include <fcntl. h>
8. // Randoming
9. # Include <stdlib. h> // for random
10. # Include <time. h> // For srand with time
12. // Variable Parameter List
13. # Include <stdarg. h>
15. // Common
16. # Include <stdio. h>
17. # Include <string. h>
19. Void my_read ();
20. Void my_write ();
22. Void lock_set (int fd, int type );
23. Void my_lock_test (INT n_tests ,...);
25. Int main ()
26. {
27. My_read ();
28. My_write ();
30. Srand (unsigned INT) time (0 ));
32. Fork ();
34. My_lock_test (4, f_wrlck, f_unlck, f_rdlck, f_unlck );
36. Exit (0 );
37. }
39. Void my_read ()
40. {
41. Int FD;
43. If (FD = open ("/tmp/Hello. c", o_creat | o_trunc | o_wronly, 0600) <0)
44. {
45. Perror ("open :");
46. Exit (1 );
47. }
48. Else
49. Printf ("Open File: Hello. C % d/N", FD );
51. If (close (FD) <0)
52. {
53. Perror ("close :");
54. Exit (1 );
55. }
56. Else
57. Printf ("Close hello. C/N ");
58. }
60. Void my_write ()
61. {
62. Int FD, size, Len;
63. Char * Buf = "Hello! I'm writing to this file ";
64. Char buf_r [10];
65. Len = strlen (BUF );
67. If (FD = open ("/tmp/Hello. c", o_creat | o_trunc | o_rdwr, 0666) <0)
68. {
69. Perror ("open :");
70. Exit (1 );
71. }
72. Else
73. Printf ("Open File: Hello. C % d/N", FD );
76. If (size = write (FD, Buf, Len) <0)
77. {
78. Perror ("write :");
79. Exit (1 );
80. }
81. Else
82. Printf ("writes: % s/n", Buf );
84. Lseek (FD, 0, seek_set );
86. If (size = read (FD, buf_r, 10) <0)
87. {
88. Perror ("read :");
89. Exit (1 );
90. }
91. Else
92. Printf ("read first 10 characters from file: % s/n", buf_r );
94. If (close (FD) <0)
95. {
96. Perror ("close :");
97. Exit (1 );
98. }
99. Else
100. Printf ("Close hello. C/N ");
102. }
104. Void lock_set (int fd, int type)
105. {
106. Struct flock lock;
107. Lock. l_whence = seek_set;
108. Lock. l_start = 0;
109. Lock. l_len = 0;
111. While (1)
112. {
113. Lock. l_type = type;
115. If (fcntl (FD, f_setlk, & lock) = 0)
116. {
117. If (lock. l_type = f_rdlck)
118. Printf ("read lock set by % d/N", getpid ());
119. Else if (lock. l_type = f_wrlck)
120. Printf ("Write lock set by % d/N", getpid ());
121. Else if (lock. l_type = f_unlck)
122. Printf ("Release lock by % d/N", getpid ());
124. Return;
125. }
127. Fcntl (FD, f_getlk, & lock );
129. If (lock. l_type! = F_unlck)
130. {
131. If (lock. l_type = f_rdlck)
132. Printf ("% d: Read lock already set by % d/N", getpid (), lock. l_pid );
133. Else if (lock. l_type = f_wrlck)
134. Printf ("% d: Write lock already set by % d/N", getpid (), lock. l_pid );
136. Sleep (random () % 3 );
137. }
139. }
140. }
142. Void my_lock_test (INT n_tests ,...)
143. {
144. Va_list test_cases;
145. Int cur;
147. Int FD;
148. FD = open ("/tmp/Hello. c", o_rdwr | o_creat, 0666 );
150. If (FD <0)
151. {
152. Perror ("lock test open :");
153. Exit (1 );
154. }
156. Va_start (test_cases, n_tests );
157. For (cur = 0; cur <n_tests; ++ cur)
158. {
159. Lock_set (FD, va_arg (test_cases, INT ));
161. Sleep (random () % 5 );
162. }
163. Va_end (test_cases );
165. }