写一个陷阱门的测试程序

1. //写一个陷阱门的测试程序
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <string.h>
   
6. #include <errno.h>
   
7. #include <signal.h>
   
8. #include <sys/types.h>
   
9. #include <sys/wait.h>
   
10. #include <fcntl.h>
    
11. #include <sys/stat.h>
    
12. #include <sys/mman.h>
    
13. #include <semaphore.h>
    
14. #include <pthread.h>
    
15. #include <sys/socket.h>
    
16. #include <netinet/in.h>
    
17. #include <arpa/inet.h>
    
18. #include <netdb.h>
    
19. #include <sys/time.h>
    
20. #include <sys/resource.h>
    
21. #include <sys/ipc.h>
    
22. #include <sys/msg.h>
    
23. #include <sys/shm.h>
    
24. #include <sys/sem.h>
    
25. #include <sys/uio.h>
    
26. #include <sys/select.h>
    
27. #include <sys/time.h>
    
28. #include <sys/un.h>
    
29. 
    
30. 
    
31. int main(int argc, char *argv[])
    
32. {
    
33.     int fd;
    
34.     int ret;
    
35.     int i;
    
36.     int count;
    
37.     int *p;
    
38.     int *q;
    
39.     int *r;
    
40.     int *s;
    
41.     int *t;
    
42.     int *u;
    
43.     int *v;
    
44.     int *w;
    
45.     int *x;
    
46.     int *y;
    
47.     int *z;
    
48.     int *aa;
    
49.     int *bb;
    
50.     int *cc;
    
51.     int *dd;
    
52. 
    
53. 
    
54.     fd = open("trapdoor", O_RDWR);
    
55.     if(fd < 0)
    
56.     {
    
57.         perror("open");
    
58.         return -1;
    
59.     }
    
60.     p = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    
61.     if(p == MAP_FAILED)
    
62.     {
    
63.         perror("mmap");
    
64.         return -1;
    
65.     }
    
66.     q = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 4096);
    
67.     if(q == MAP_FAILED)
    
68.     {
    
69.         perror("mmap");
    
70.         return -1;
    
71.         }
    
72.         r = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 8192);
    
73.         if(r == MAP_FAILED)
    
74.         {
    
75.             perror("mmap");
    
76.             return -1;
    
77.          }
    
78. 
    
79.          s = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 12288);
    
80.                  if(s== MAP_FAILED)
    
81.         {
    
82.             perror("mmap");
    
83.             return -1;
    
84.          }
    
85.          t = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 16384);
    
86.                  if(t== MAP_FAILED)
    
87.         {
    
88.             perror("mmap");
    
89.             return -1;
    
90.          }
    
91. 
    
92.          u = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 20480);
    
93.                  if(u== MAP_FAILED)
    
94.         {
    
95.             perror("mmap");
    
96.             return -1;
    
97.          }
    
98.          v = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 24576);
    
99.                  if(v == MAP_FAILED)
    
100.         {
     
101.             perror("mmap");
     
102.             return -1;
     
103.          }
     
104.          w = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 28672);
     
105.                  if(w == MAP_FAILED)
     
106.         {
     
107.             perror("mmap");
     
108.             return -1;
     
109.          }
     
110.          x = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 32768);
     
111.                  if(x == MAP_FAILED)
     
112.         {
     
113.             perror("mmap");
     
114.             return -1;   
     
115.          }
     
116.          y = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 36864);
     
117.                  if(y == MAP_FAILED)
     
118.         {
     
119.             perror("mmap");
     
120.             return -1;
     
121.          }
     
122.          z = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 40960);
     
123.                  if(z== MAP_FAILED)
     
124.         {
     
125.             perror("mmap");
     
126.             return -1;
     
127.          }
     
128.          aa = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 45056);
     
129.                  if(aa == MAP_FAILED)
     
130.         {
     
131.             perror("mmap");
     
132.             return -1;
     
133.          }
     
134.          bb = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 49152);
     
135.                  if(bb == MAP_FAILED)
     
136.         {
     
137.             perror("mmap");
     
138.             return -1;
     
139.          }
     
140.          cc = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 53248);
     
141.                  if(cc== MAP_FAILED)
     
142.         {
     
143.             perror("mmap");
     
144.             return -1;
     
145.          }
     
146.          dd = (int *)mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 57344);
     
147.                  if(dd == MAP_FAILED)
     
148.         {
     
149.             perror("mmap");
     
150.             return -1;
     
151.          }
     
152.          count = 0;
     
153.          while(1)
     
154.          {
     
155.              *p = count;
     
156.              *q = count;
     
157.              *r = count;
     
158.              *s = count;
     
159.              *t = count;
     
160.              *u = count;
     
161.              *v = count;
     
162.              *w = count;
     
163.              *x = count;
     
164.              *y = count;
     
165.              *z = count;
     
166.              *aa = count;
     
167.              *bb = count;
     
168.              *cc = count;
     
169.              *dd = count;
     
170.              count++;
     
171.              sleep(1);
     
172.              printf("count = %d\n", count);
     
173.              if(count == 1000)
     
174.              {
     
175.                  break;
     
176.                  }
     
177.                  }
     
178.                  return 0;
     
179.                  }
     
180. 
     
181. 
     
182. 
     
183. 
     
184. 
     
185. 
     
186. 
     
187. 
     
188. 
     
189. 
     
190. 
     
191. 
     

复制代码

AWS Toolkit挺好用的。免费的代码提示AI。

看看我，打赏20

开朗的盟员 发表于 2023-8-23 22:37
看看我，打赏20

谢谢啦