Revision control
Copy as Markdown
Other Tools
/* w32-lock.c - GPGRT lock functions for Windows
Copyright (C) 2014 g10 Code GmbH
This file is part of libgpg-error.
libgpg-error is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License
as published by the Free Software Foundation; either version 2.1 of
the License, or (at your option) any later version.
libgpg-error is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
*/
#if HAVE_CONFIG_H
#include <config.h>
#endif
#ifndef HAVE_W32_SYSTEM
# error This module may only be build for Windows.
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "gpgrt-int.h"
#include "lock.h"
#include "w32-lock-obj.h"
static _gpgrt_lock_t *
get_lock_object (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = (_gpgrt_lock_t*)lockhd;
if (lock->vers != LOCK_ABI_VERSION)
_gpgrt_abort ();
return lock;
}
gpg_err_code_t
_gpgrt_lock_init (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = (_gpgrt_lock_t*)lockhd;
/* If VERS is zero we assume that no static initialization has been
done, so we setup our ABI version right here. The caller might
have called us to test whether lock support is at all available. */
if (!lock->vers)
{
if (sizeof (gpgrt_lock_t) < sizeof (_gpgrt_lock_t))
_gpgrt_abort ();
lock->vers = LOCK_ABI_VERSION;
}
else /* Run the usual check. */
{
lock = get_lock_object (lockhd);
if (sizeof (gpgrt_lock_t) < sizeof (_gpgrt_lock_t))
_gpgrt_abort ();
}
InitializeCriticalSection (&lock->csec);
lock->initdone = 1;
return 0;
}
gpg_err_code_t
_gpgrt_lock_lock (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = get_lock_object (lockhd);
if (!lock->initdone)
{
if (!InterlockedIncrement (&lock->started))
{
/* The new value of started is 0. Because the initial value
if the variable was -1 we known that this thread is the
first who needs this lock. Thus we initialize now. All
other threads won't get 0 back from InterlockedIncrement
and thus fall into the wait loop below. We ignore that
STARTED may in theory overflow if this thread starves for
too long. */
_gpgrt_lock_init (lockhd);
}
else
{
while (!lock->initdone)
Sleep (0);
}
}
_gpgrt_pre_syscall ();
EnterCriticalSection (&lock->csec);
_gpgrt_post_syscall ();
return 0;
}
gpg_err_code_t
_gpgrt_lock_trylock (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = get_lock_object (lockhd);
if (!lock->initdone)
{
if (!InterlockedIncrement (&lock->started))
{
_gpgrt_lock_init (lockhd);
}
else
{
while (!lock->initdone)
Sleep (0);
}
}
if (!TryEnterCriticalSection (&lock->csec))
return GPG_ERR_EBUSY;
return 0;
}
gpg_err_code_t
_gpgrt_lock_unlock (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = get_lock_object (lockhd);
if (!lock->initdone)
return GPG_ERR_INV_LOCK_OBJ;
LeaveCriticalSection (&lock->csec);
return 0;
}
/* Note: Use this function only if no other thread holds or waits for
this lock. */
gpg_err_code_t
_gpgrt_lock_destroy (gpgrt_lock_t *lockhd)
{
_gpgrt_lock_t *lock = get_lock_object (lockhd);
if (!lock->initdone)
return GPG_ERR_INV_LOCK_OBJ;
DeleteCriticalSection (&lock->csec);
lock->initdone = 0;
lock->started = -1;
return 0;
}