1 /* NT semaphore functions for regutil
2 *
3 * The contents of this file are subject to the Mozilla Public License
4 * Version 1.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 * http://www.mozilla.org/MPL/
7 *
8 * Software distributed under the License is distributed on an "AS IS"
9 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
10 * License for the specific language governing rights and limitations
11 * under the License.
12 *
13 * The Original Code is regutil.
14 *
15 * The Initial Developer of the Original Code is Patrick TJ McPhee.
16 * Portions created by Patrick McPhee are Copyright � 1998, 2001
17 * Patrick TJ McPhee. All Rights Reserved.
18 *
19 * Contributors:
20 *
21 * $Header: C:/ptjm/rexx/regutil/RCS/regsem.c 1.6 2002/01/01 20:26:19 ptjm Rel $
22 */
23 #include "regutil.h"
24 #include <windows.h>
25
26 /* ******************************************************************** */
27 /* **************************** Semaphores **************************** */
28 /* ******************************************************************** */
29 static const char notimp[] = "not implemented";
30 #define what() memcpy(result->strptr, notimp, sizeof(notimp)-1), result->strlength = sizeof(notimp)-1
31
32 /* syscloseeventsem(handle) */
rxfunc(syscloseeventsem)33 rxfunc(syscloseeventsem)
34 {
35 HANDLE semid;
36
37 checkparam(1,1);
38
39 if (argv[0].strlength != sizeof(semid))
40 return BADGENERAL;
41
42 memcpy(&semid, argv[0].strptr, sizeof(semid));
43
44 CloseHandle(semid);
45 result->strlength = sprintf(result->strptr, "%d", GetLastError());
46
47 return 0;
48 }
49
50 /* sysclosemutexsem(handle) */
rxfunc(sysclosemutexsem)51 rxfunc(sysclosemutexsem)
52 {
53 return syscloseeventsem(fname, argc, argv, pSomething, result);
54 }
55
56 /* syscreateeventsem([name],[manual_reset]) */
rxfunc(syscreateeventsem)57 rxfunc(syscreateeventsem)
58 {
59 char *name, *manual;
60 HANDLE event;
61 BOOL bManual = FALSE;
62
63 checkparam(0,2);
64
65 if (argc > 0 && argv[0].strlength) {
66 rxstrdup(name, argv[0]);
67 }
68 else
69 name = NULL;
70
71 if (argc > 1 && argv[1].strlength)
72 rxstrdup(manual, argv[1]);
73 else
74 manual = NULL;
75
76 /* docs suggest the fact that this argument exists means the semaphore
77 * should be manual-reset */
78 if (manual && !stricmp(manual, "yes"))
79 bManual = TRUE;
80 else
81 bManual = FALSE;
82
83 event = CreateEvent(NULL, bManual, FALSE, name);
84
85 if (event) {
86 result->strlength = sizeof(event);
87 memcpy(result->strptr, &event, sizeof(event));
88 }
89
90 else {
91 result->strlength = 0;
92 }
93
94 return 0;
95 }
96
97 /* syscreatemutexsem([name]) */
rxfunc(syscreatemutexsem)98 rxfunc(syscreatemutexsem)
99 {
100 HANDLE mutex;
101 char * name;
102
103 if (argc > 0 && argv[0].strlength) {
104 rxstrdup(name, argv[0]);
105 }
106 else
107 name = NULL;
108
109 mutex = CreateMutex(NULL, FALSE, name);
110
111 if (mutex) {
112 result->strlength = sizeof(mutex);
113 memcpy(result->strptr, &mutex, sizeof(mutex));
114 }
115 else {
116 result->strlength = 0;
117 }
118
119 return 0;
120 }
121
122
123 /* sysopeneventsem(name) */
rxfunc(sysopeneventsem)124 rxfunc(sysopeneventsem)
125 {
126 HANDLE event;
127 char * name;
128
129 checkparam(1,1);
130
131 rxstrdup(name, argv[0]);
132
133 event = OpenEvent(EVENT_ALL_ACCESS, FALSE, name);
134
135 if (event) {
136 result->strlength = sizeof(event);
137 memcpy(result->strptr, &event, sizeof(event));
138 }
139 else {
140 result_zero();
141 }
142
143 return 0;
144 }
145
146
147 /* sysopenmutexsem(name) */
rxfunc(sysopenmutexsem)148 rxfunc(sysopenmutexsem)
149 {
150 HANDLE mutex;
151 char * name;
152
153 checkparam(1,1);
154
155 rxstrdup(name, argv[0]);
156
157 mutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, name);
158
159 if (mutex) {
160 result->strlength = sizeof(mutex);
161 memcpy(result->strptr, &mutex, sizeof(mutex));
162 }
163 else {
164 result_zero();
165 }
166
167 return 0;
168 }
169
170 /* sysposteventsem(handle) */
rxfunc(sysposteventsem)171 rxfunc(sysposteventsem)
172 {
173 HANDLE event;
174
175 checkparam(1,1);
176
177 memcpy(&event, argv[0].strptr, sizeof(event));
178
179 SetEvent(event);
180
181 result->strlength = sprintf(result->strptr, "%d", GetLastError());
182
183 return 0;
184 }
185
186 /* syspulseeventsem(handle) */
rxfunc(syspulseeventsem)187 rxfunc(syspulseeventsem)
188 {
189 HANDLE event;
190
191 checkparam(1,1);
192
193 memcpy(&event, argv[0].strptr, sizeof(event));
194
195 PulseEvent(event);
196
197 result->strlength = sprintf(result->strptr, "%d", GetLastError());
198
199 return 0;
200 }
201
202
203 /* sysreleasemutexsem(handle) */
rxfunc(sysreleasemutexsem)204 rxfunc(sysreleasemutexsem)
205 {
206 HANDLE mutex;
207
208 checkparam(1,1);
209
210 memcpy(&mutex, argv[0].strptr, sizeof(mutex));
211
212 ReleaseMutex(mutex);
213
214 result->strlength = sprintf(result->strptr, "%d", GetLastError());
215
216 return 0;
217 }
218
219 /* sysrequestmutexsem(handle, [timeout]) */
rxfunc(sysrequestmutexsem)220 rxfunc(sysrequestmutexsem)
221 {
222 HANDLE mutex;
223 char * timeout;
224 DWORD mtimeout;
225 int rc;
226
227 checkparam(1,2);
228
229 memcpy(&mutex, argv[0].strptr, sizeof(mutex));
230
231 if (argc > 1) {
232 rxstrdup(timeout, argv[1]);
233 mtimeout = atoi(timeout);
234 }
235 else {
236 mtimeout = INFINITE;
237 }
238
239 rc = WaitForSingleObject(mutex, mtimeout);
240
241 result->strlength = sprintf(result->strptr, "%d", rc);
242
243 return 0;
244 }
245
246 /* sysreseteventsem(handle) */
rxfunc(sysreseteventsem)247 rxfunc(sysreseteventsem)
248 {
249 HANDLE event;
250
251 checkparam(1,1);
252
253 memcpy(&event, argv[0].strptr, sizeof(event));
254
255 ResetEvent(event);
256
257 result->strlength = sprintf(result->strptr, "%d", GetLastError());
258
259 return 0;
260 }
261
262 /* syswaiteventsem(handle, [timeout]) */
rxfunc(syswaiteventsem)263 rxfunc(syswaiteventsem)
264 {
265 HANDLE event;
266 int rc, mtimeout;
267 char * timeout;
268
269 checkparam(1,2);
270
271 memcpy(&event, argv[0].strptr, sizeof(event));
272
273 if (argc > 1) {
274 rxstrdup(timeout, argv[1]);
275 mtimeout = atoi(timeout);
276 }
277 else {
278 mtimeout = INFINITE;
279 }
280
281 rc = WaitForSingleObject(event, mtimeout);
282
283 result->strlength = sprintf(result->strptr, "%d", rc);
284
285 return 0;
286 }
287