---

win32_sem.c

Go to the documentation of this file.

// Semaphore functions for WIN32  (Windows NT/95/98 and CE)

#include "rcs_defs.hh"

#if defined(WIN32) && !defined(USE_OLD_WINSOCK)
// Lame problem if windows.h is included before winsock2.h many redefined
// compiler errors result.
#include <winsock2.h>
#endif

#include <windows.h>
#include <winbase.h>

#ifndef NO_STDIO
#include <stdio.h>              /* sprintf() */
#endif

#include "dbg_mem.h"

#ifdef UNDER_CE
#include "rcs_ce.h"
#endif

int
rcs_sem_clear (rcs_sem_t * sem)
{
  /* Un implimented. */
  return (0);
}

rcs_sem_t *
rcs_sem_open (const char *name, int oflag, /*  mode ... */ ...)
{
#if defined(WIN32) && defined(UNICODE)
  wchar_t wname[64];
#endif
  unsigned long int id = (unsigned long int) name;
  rcs_sem_t *sem;
  sem = (rcs_sem_t *) DEBUG_MALLOC (sizeof (rcs_sem_t));
  if (NULL == sem)
    {
      rcs_print_error ("Out of memory. (Error = %d\n)", GetLastError ());
      return NULL;
    }

#ifndef NO_STDIO
  sprintf (sem->name, "sem%d", (int) id);
#else
  strcpy (sem->name, "sem");
  _itoa (id, sem->name + 3, 10);
#endif

#ifdef UNDER_CE
#ifdef UNICODE
  RCS_CE_ASCII_TO_UNICODE (wname, sem->name, 64);
  sem->handle = CreateMutex (NULL, FALSE, wname);
#else
  sem->handle = CreateMutex (NULL, FALSE, sem->name);
#endif
  if (NULL == sem->handle)
    {
      rcs_print_error ("Can not create semaphore. (Error = %d)\n",
                       GetLastError ());
      free (sem);
      return NULL;
    }
#else
  sem->handle = OpenMutex (MUTEX_ALL_ACCESS, TRUE, sem->name);
  if (NULL == sem->handle)
    {
      rcs_print_error ("Can not create semaphore. (Error = %d)\n",
                       GetLastError ());
      free (sem);
      return NULL;
    }
#endif
  return sem;
}

rcs_sem_t *
rcs_sem_create (unsigned long int id, int mode, int state)
{
#ifdef UNICODE
  wchar_t wname[64];
#endif
  rcs_sem_t *sem;
#ifndef UNDER_CE
  SECURITY_ATTRIBUTES sa;
  SECURITY_DESCRIPTOR sd;
  if (FALSE ==
      InitializeSecurityDescriptor (&sd, SECURITY_DESCRIPTOR_REVISION))
    {
      rcs_print_error
        ("Can not initailize security descriptor.(Error = %d)\n",
         GetLastError ());
      return NULL;
    }
  sa.nLength = sizeof (SECURITY_ATTRIBUTES);
  sa.lpSecurityDescriptor = &sd;
  sa.bInheritHandle = TRUE;
#endif
  sem = (rcs_sem_t *) DEBUG_MALLOC (sizeof (rcs_sem_t));
  if (NULL == sem)
    {
      rcs_print_error ("Out of memory. (Error = %d\n)", GetLastError ());
      return NULL;
    }
#ifndef NO_STDIO
  sprintf (sem->name, "sem%d", (int) id);
#else
  strcpy (sem->name, "sem");
  _itoa (id, sem->name + 3, 10);
#endif
#ifdef UNDER_CE
#ifdef UNICODE
  RCS_CE_ASCII_TO_UNICODE (wname, sem->name, 64);
  sem->handle = CreateMutex (NULL, FALSE, wname);
#else
  sem->handle = CreateMutex (NULL, FALSE, sem->name);
#endif
#else
  sem->handle = CreateMutex (&sa, FALSE, sem->name);
#endif

  if (NULL == sem->handle)
    {
      rcs_print_error ("Can not create semaphore. (Error = %d)\n",
                       GetLastError ());
      free (sem);
      return NULL;
    }
  return sem;
}

int
rcs_sem_init (rcs_sem_t * sem, int pshared, unsigned int value)
{
  return 0;
}

int
rcs_sem_destroy (rcs_sem_t * sem)
{
  return rcs_sem_close (sem);
}

int
rcs_sem_close (rcs_sem_t * sem)
{
  if (NULL != sem)
    {
      if (NULL != sem->handle)
        {
          CloseHandle (sem->handle);
          sem->handle = NULL;
        }
    }
  return 0;
}

int
rcs_sem_unlink (const char *name)
{
  rcs_sem_t *sem = (rcs_sem_t *) name;
  return rcs_sem_close (sem);
}

int
rcs_sem_wait (rcs_sem_t * sem, double timeout)
{
  int error;
  if (sem == NULL)
    {
      return -1;
    }
  if (sem->handle == NULL)
    {
      return -1;
    }
  if (WAIT_FAILED == WaitForSingleObject (sem->handle,
                                          ((unsigned long) (timeout * 1000))))
    {
      if (WAIT_TIMEOUT == (error = GetLastError ()))
        {
          return -2;
        }
      rcs_print_error ("WaitForSingleObject failed. (Error = %d)\n", error);
      return -1;
    }
  return 0;
}


int
rcs_sem_trywait (rcs_sem_t * sem)
{
  return rcs_sem_wait (sem, 0);
}

int
rcs_sem_post (rcs_sem_t * sem)
{
  if (FALSE == ReleaseMutex (sem->handle))
    {
      rcs_print_error ("ReleaseMutex failed. (Error = %d)\n",
                       GetLastError ());
      return -1;
    }
  return 0;
}

int
rcs_sem_flush (rcs_sem_t * sem)
{
  if (FALSE == ReleaseMutex (sem->handle))
    {
      rcs_print_error ("ReleaseMutex failed. (Error = %d)\n",
                       GetLastError ());
      return -1;
    }
  return 0;
}


int
rcs_sem_getvalue (rcs_sem_t * sem, unsigned int *sval)
{
  if (WAIT_FAILED == WaitForSingleObject (sem->handle, 0))
    {
      return 1;
    }
  return 0;
}

---