error

Pacer

1. 
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <string.h>
   
5. #include <fcntl.h>
   
6. #include <errno.h>
   
7. #include <sys/types.h>
   
8. #include <sys/ipc.h>
   
9. #include <sys/sem.h>
   
10. 
    
11. /*-----------------------------------*
    
12. * Delete semaphore key                     *
    
13. *-----------------------------------*/
    
14. int sem_del(key)
    
15. int key;
    
16. {
    
17.         int      semid, sysreturn;
    
18.         char     ret1[255];
    
19.         char     ret2[255];
    
20.         char     msg[255];
    
21.         extern int errno;
    
22. 
    
23.         if((semid=semget(key,1,IPC_EXCL)) != -1)
    
24.         {
    
25.                 sysreturn=semctl(semid, 0, IPC_RMID);        /* delete semaphore */
    
26.                 if(sysreturn != 0)
    
27.                 {
    
28.                         return(8);
    
29.                 }
    
30.                 return(0);
    
31.         }
    
32.         else
    
33.         {
    
34.                 return(10);
    
35.         }
    
36. }
    
37. 
    
38. /*-----------------------------------*
    
39. * Set new (or reset) process counts *
    
40. *-----------------------------------*/
    
41. int sem_set(key,cnt)
    
42. int key,cnt;
    
43. {
    
44.         int      semid, sysreturn, ret;
    
45.         struct   sembuf  sb[1];
    
46.         char     ret1[255];
    
47.         char     ret2[255];
    
48. 
    
49.         if((semid=semget(key,1,IPC_EXCL)) == -1)
    
50.         {
    
51.                 semid=semget(key,1,IPC_CREAT|0666);
    
52.                 semctl(semid,0,SETVAL,cnt);                /* set semaphore number */
    
53.                 return(0);
    
54.         }
    
55.         else
    
56.         {
    
57.                 return(1);
    
58.         }
    
59. 
    
60. }
    
61. 
    
62. /*-----------------------------------*
    
63. * Check current semaphore number    *
    
64. *-----------------------------------*/
    
65. int sem_checkval(key)
    
66. int key;
    
67. {
    
68.         int        semid;
    
69.         struct        sembuf        sb[1];
    
70.         int        ret;
    
71. 
    
72.         if((semid=semget(key,1,IPC_EXCL)) == -1)
    
73.         {
    
74.                  return(1);
    
75.         }
    
76. 
    
77.         sb[0].sem_num=0;
    
78.         sb[0].sem_flg=0;
    
79. 
    
80.         ret=semctl(semid,0,GETVAL,1);
    
81.         if(ret != -1)
    
82.         {
    
83.                 printf("%d %d\n",semid,ret);
    
84.                 return(0);
    
85.         }
    
86.         else
    
87.         {
    
88.                 return(8);
    
89.         }
    
90. 
    
91. 
    
92. }
    
93. 
    
94. /*-------------------------------------*
    
95. * Lock and unlock semaphore operation *
    
96. *-------------------------------------*/
    
97. int sem_landu(cmd,key,opt)
    
98. char        cmd[255];
    
99. char        opt[255];
    
100. int        key;
     
101. {
     
102.         int      semid, ret;
     
103.         struct   sembuf  sb[1];
     
104.         char     emesg[255];
     
105.         extern int errno;
     
106. 
     
107.         if((semid=semget(key,1,IPC_EXCL)) == -1)
     
108.         {
     
109.                 return(1);                        /* Invalid semaphore key number */
     
110.         }
     
111. 
     
112.         sb[0].sem_num=0;
     
113.         if(strcmp(cmd,"-l") == 0 && strcmp(opt,"NOWAIT") == 0)
     
114.         {
     
115.                 sb[0].sem_flg=IPC_NOWAIT;
     
116.         }
     
117.         else if(strlen(opt) == 0)
     
118.         {
     
119.                 sb[0].sem_flg=0;
     
120.         }
     
121.         else
     
122.         {
     
123.                 exit(9);
     
124.         }
     
125. 
     
126. 
     
127.         if(strcmp(cmd,"-u") == 0)
     
128.         {
     
129.                 sb[0].sem_op = 1;                /* Unlock semaphore */
     
130.         }
     
131.         else                                        /* if not "-u", it is "-l" */
     
132.         {
     
133.                 sb[0].sem_op = -1;                /* lock semaphore */
     
134.         }
     
135. 
     
136.         ret=semop(semid,sb,1);                      /* semaphore operation */
     
137.         if(ret == -1)
     
138.         {
     
139.                 ret=errno;
     
140.                 if ( ret == EAGAIN )
     
141.                 {
     
142.                         return(3);                /* Can't do lock action now */
     
143.                 }
     
144.                 else
     
145.                 {
     
146.                         return(errno);                /* Error */
     
147.                 }
     
148.         }
     
149.         else if(ret == 0)
     
150.         {
     
151.                 return(0);                        /* Success */
     
152.         }
     
153.         else
     
154.         {
     
155.                 return(8);                        /* System Error */
     
156.         }
     
157. }
     
158. 
     
159. 
     
160. /*----------------------*
     
161. *     Start main       *
     
162. *----------------------*/
     
163. int main(argc,argv)
     
164.         char *argv[];
     
165. {
     
166.         int        key,cnt,ret;
     
167.         char        cmd[255];
     
168.         char        opt[255];
     
169. 
     
170.         strcpy(cmd,argv[1]);
     
171.         key=atoi(argv[2]);
     
172.         cnt=atoi(argv[3]);
     
173. 
     
174.         if(strcmp(cmd,"-s") == 0)
     
175.         {
     
176.                 ret=sem_del(key);
     
177.                 if(ret != 0 && ret != 10)
     
178.                 {
     
179.                         exit(ret);
     
180.                 }
     
181.                 ret=sem_set(key,cnt);
     
182.         }
     
183.         else if (strcmp(cmd,"-l") == 0 || strcmp(cmd,"-u") == 0)
     
184.         {
     
185.                 strcpy(opt,argv[3]);
     
186.                 ret=sem_landu(cmd,key,opt);
     
187.         }
     
188.         else if (strcmp(cmd,"-c") ==0)
     
189.         {
     
190.                 ret=sem_checkval(key);
     
191.         }
     
192.         else if (strcmp(cmd,"-d") ==0)
     
193.         {
     
194.                 ret=sem_del(key);
     
195.                 if (ret == 10)
     
196.                 {
     
197.                         ret=1;
     
198.                 }
     
199.         }
     
200.         else
     
201.         {
     
202.                 ret=9;                        /* Unsupported command(argv1) */
     
203.         }
     
204. 
     
205.         exit(ret);
     
206. }
     
207. 
     

复制代码