src/Semaphore.cpp

/* Ported to SPL, original attribution below. */
/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2009  Mark A Lindner

   This file was ported from commonc++.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/
#include <spl/io/Directory.h>
#include <spl/threading/Semaphore.h>
#include <spl/io/WinPerm.h>

#ifdef HAVE_SEMAPHORE_H
#include <semaphore.h>
#endif

#ifdef WIN32
extern bool EncodePermissions(const Permissions& perm, _WinPerms &wperm);
#else
extern void EncodePermissions(const Permissions& perm, mode_t& mode);
#endif

#ifndef WIN32
static bool VerifyIPCName(const String& name)
{
  return((name.Length() <= 14) && (name.IndexOf(Directory::SeperatorChar(), 0) < 0));
}
#endif

Semaphore::Semaphore
(
        const String &name, 
        uint32 value /* = 1 */,
    const Permissions& perm
                     /* = Permissions::USER_READ_WRITE */
)
{
        if (value < 1)
        {
                throw new InvalidArgumentException("Invalid value");
        }

#ifdef WIN32

        _name = name;

        SECURITY_ATTRIBUTES sa;
        _WinPerms wperm;

        EncodePermissions(perm, wperm);

        sa.nLength = sizeof(SECURITY_ATTRIBUTES);
        sa.lpSecurityDescriptor = wperm.pdesc;
        sa.bInheritHandle = FALSE;

        _sem = ::CreateSemaphore(&sa, 0, value, _name.GetChars());
        if(_sem == NULL)
        {
                throw new Exception("CreateSemaphore");
        }

        // make all instances immediately available
        ::ReleaseSemaphore(_sem, value, NULL);

#else

        if(! VerifyIPCName(name))
        {
                throw new InvalidArgumentException("Invalid IPC name");
        }

        _name = name;

        mode_t mode;
        EncodePermissions(perm, mode);
        _sem = ::sem_open(_name.GetChars(), (O_CREAT | O_RDWR), mode, value);
        if(_sem == reinterpret_cast<sem_t *>(SEM_FAILED))
        {
                throw new Exception("sem_open");
        }

#endif
}

Semaphore::~Semaphore()
{
#ifdef WIN32

  if(_sem != NULL)
    ::CloseHandle(_sem);

#else

  if(_sem != reinterpret_cast<sem_t *>(SEM_FAILED))
  {
    sem_close(_sem);
#ifndef __CYGWIN__
    sem_unlink(_name.GetChars());
#endif
  }

#endif
}

void Semaphore::Lock()
{
#ifdef WIN32

  if(::WaitForSingleObjectEx(_sem, INFINITE, TRUE) != WAIT_OBJECT_0)
  {
          throw new StateException("Error locking semaphore");
  }

#else

  if(::sem_wait(_sem) != 0)
  {
          throw new StateException("Error locking semaphore");
  }

#endif
}

bool Semaphore::TryWait()
{
#ifdef WIN32

  return(::WaitForSingleObjectEx(_sem, 0, TRUE) == WAIT_OBJECT_0);

#else

  return(::sem_trywait(_sem) == 0);

#endif
}

void Semaphore::Unlock()
{
#ifdef WIN32

  if(::ReleaseSemaphore(_sem, 1, NULL) != TRUE)
  {
          throw new StateException("Error unlocking semaphore");
  }

#else

  if(::sem_post(_sem) != 0)
  {
          throw new StateException("Error unlocking semaphore")  ; 
  }

#endif
}

int Semaphore::GetValue() const 
{
#ifdef WIN32

  return(-1); // not supported

#else

  int val = 0;
  int e = ::sem_getvalue(_sem, &val);

  return((e == 0) ? val : -1);

#endif
}

#if defined(DEBUG) || defined(_DEBUG)
void Semaphore::CheckMem() const 
{
}

void Semaphore::ValidateMem() const 
{
}
#endif