regina/regutil/regsem.c

   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: /opt/cvs/Regina/regutil/regsem.c,v 1.1 2009/10/07 07:51:59 mark Exp $
  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) */
  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) */
  51 rxfunc(sysclosemutexsem)
  52 {
  53    return syscloseeventsem(fname, argc, argv, pSomething, result);
  54 }
  55
  56 /* syscreateeventsem([name],[manual_reset]) */
  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]) */
  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) */
 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) */
 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) */
 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) */
 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) */
 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]) */
 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) */
 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]) */
 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 }