POSIX无缓冲文件I/O及可变参数小玩

这段以前写的测试程序包含了对POSIX无缓冲文件I/O、文件加解锁、进程分叉、可变参数的综合运用。没什么技术含量，纯粹记述一下，不想有一天弄丢了。

C真是又小巧又灵活，在语言的犄角旮旯还是存在一些之前完全想不到会有的特性，呵呵～不过，现在可能会从事的这个工作是不是只能用C不能用C++呢？难道真的得告别自己的最爱？

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. }