/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/




#include "system.h"

#include <osl/semaphor.h>
#include <osl/diagnose.h>

#ifndef OSL_USE_SYS_V_SEMAPHORE

/* This is the (default) POSIX thread-local semaphore variant */

/*
	Implemetation notes:
	The void* represented by oslSemaphore is used
	as a pointer to an sem_t struct
*/

/*****************************************************************************/
/* osl_createSemaphore  */
/*****************************************************************************/

oslSemaphore SAL_CALL osl_createSemaphore(sal_uInt32 initialCount) 
{
	int ret = 0;
	oslSemaphore Semaphore;

	Semaphore= malloc(sizeof(sem_t));

	OSL_ASSERT(Semaphore);		/* ptr valid? */

	if ( Semaphore == 0 )
	{
		return 0;
	}
	
	/* unnamed semaphore, not shared between processes */

   	ret= sem_init((sem_t*)Semaphore, 0, initialCount);

	/* create failed? */
	if (ret != 0)
	{
	    OSL_TRACE("osl_createSemaphore failed. Errno: %d; %s\n", 
				  errno, 
				  strerror(errno));

	    free(Semaphore);
	    Semaphore = NULL;
	}
	
	return Semaphore;
}

/*****************************************************************************/
/* osl_destroySemaphore  */
/*****************************************************************************/
void SAL_CALL osl_destroySemaphore(oslSemaphore Semaphore)
{
	if(Semaphore)			/* ptr valid? */
	{
		sem_destroy((sem_t*)Semaphore);
	    free(Semaphore);
	}
}

/*****************************************************************************/
/* osl_acquireSemaphore  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_acquireSemaphore(oslSemaphore Semaphore) {
	
	OSL_ASSERT(Semaphore != 0);	/* abort in debug mode */

	if (Semaphore != 0)		/* be tolerant in release mode */
	{
	    return (sem_wait((sem_t*)Semaphore) == 0);
	}

	return sal_False;
}

/*****************************************************************************/
/* osl_tryToAcquireSemaphore  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_tryToAcquireSemaphore(oslSemaphore Semaphore) {
	
	OSL_ASSERT(Semaphore != 0);	/* abort in debug mode */
	if (Semaphore != 0)		/* be tolerant in release mode */
	{
	    return (sem_trywait((sem_t*)Semaphore) == 0);
	}

	return sal_False;
}

/*****************************************************************************/
/* osl_releaseSemaphore  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_releaseSemaphore(oslSemaphore Semaphore) {

	OSL_ASSERT(Semaphore != 0);		/* abort in debug mode */
	
	if (Semaphore != 0)			/* be tolerant in release mode */
	{
	    return (sem_post((sem_t*)Semaphore) == 0);
	}

	return sal_False;
}

#else /* OSL_USE_SYS_V_SEMAPHORE */

/*******************************************************************************/

/* This is the SYS V private semaphore variant */

/*
	Implemetation notes:
	The void* represented by oslSemaphore is used
	as a pointer to an osl_TSemImpl struct
*/


#if defined(NETBSD)
union semun {
        int     val;            /* value for SETVAL */
        struct  semid_ds *buf;  /* buffer for IPC_STAT & IPC_SET */
        u_short *array;         /* array for GETALL & SETALL */
};
#endif

typedef struct _osl_TSemImpl
{
  int m_Id;

} osl_TSemImpl;

/*****************************************************************************/
/* osl_createSemaphore  */
/*****************************************************************************/
oslSemaphore SAL_CALL osl_createSemaphore(sal_uInt32 initialCount) 
{
	union semun arg;
	
	oslSemaphore Semaphore;
	osl_TSemImpl* pSem;

	Semaphore= malloc(sizeof(osl_TSemImpl));
	OSL_POSTCOND(Semaphore, "malloc failed\n");		/* ptr valid? */

	pSem= (osl_TSemImpl*)Semaphore;


	/* unnamed (private) semaphore */

   	pSem->m_Id= semget(IPC_PRIVATE, 1, 0666 | IPC_CREAT);


	/* create failed? */
	if (pSem->m_Id < 0)
	{
	    OSL_TRACE("osl_createSemaphore failed (semget). Errno: %d; %s\n", 
			   errno, 
			   strerror(errno));

	    free(Semaphore);
	    return 0;
	}

    /* set initial count */

    arg.val= initialCount;

	if(semctl(pSem->m_Id, 0, SETVAL, arg) < 0)
	{
	    OSL_TRACE("osl_createSemaphore failed (semctl(SETVAL)). Errno: %d; %s\n", 
			   errno, 
			   strerror(errno));

		if(semctl(pSem->m_Id, 0, IPC_RMID, arg) < 0)
		{
		    OSL_TRACE("semctl(IPC_RMID) failed. Errno: %d; %s\n", errno, strerror(errno));
	    }
		
		free(Semaphore);
		return 0;
	}
    
	
	return Semaphore;
}

/*****************************************************************************/
/* osl_destroySemaphore  */
/*****************************************************************************/
void SAL_CALL osl_destroySemaphore(oslSemaphore Semaphore) {
	
	if(Semaphore)			/* ptr valid? */
	{
		union semun arg;

	    osl_TSemImpl* pSem= (osl_TSemImpl*)Semaphore;

		if(semctl(pSem->m_Id, 0, IPC_RMID, arg) < 0)

		{
		    OSL_TRACE("osl_destroySemaphore failed. (semctl(IPC_RMID)). Errno: %d; %s\n", 
				   errno, 
				   strerror(errno));			
	    }
		
	    free(Semaphore);
	}
}

/*****************************************************************************/
/* osl_acquireSemaphore  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_acquireSemaphore(oslSemaphore Semaphore) {
	
	/* abort in debug mode */
	OSL_PRECOND(Semaphore != 0, "Semaphore not created\n");	


	if (Semaphore != 0)		/* be tolerant in release mode */
	{
	    struct sembuf op;
		osl_TSemImpl* pSem= (osl_TSemImpl*)Semaphore;

		op.sem_num= 0;
		op.sem_op= -1;
		op.sem_flg= SEM_UNDO;

		return semop(pSem->m_Id, &op, 1) >= 0;

	}

	return sal_False;
}

/*****************************************************************************/
/* osl_tryToAcquireSemaphore  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_tryToAcquireSemaphore(oslSemaphore Semaphore) {
	
	/* abort in debug mode */
	OSL_PRECOND(Semaphore != 0, "Semaphore not created\n");	

	if (Semaphore != 0)		/* be tolerant in release mode */
	{
	    struct sembuf op;
		osl_TSemImpl* pSem= (osl_TSemImpl*)Semaphore;

		op.sem_num= 0;
		op.sem_op= -1;
		op.sem_flg= SEM_UNDO | IPC_NOWAIT;

		return semop(pSem->m_Id, &op, 1) >= 0;
	}

	return sal_False;
}

/*****************************************************************************/
/* osl_releaseSemaphore  */
/*****************************************************************************/
sal_Bool SAL_CALL osl_releaseSemaphore(oslSemaphore Semaphore) 
{

	/* abort in debug mode */
	OSL_PRECOND(Semaphore != 0, "Semaphore not created\n");	
	
	if (Semaphore != 0)			/* be tolerant in release mode */
	{
	    struct sembuf op;
		osl_TSemImpl* pSem= (osl_TSemImpl*)Semaphore;

		op.sem_num= 0;
		op.sem_op= 1;
		op.sem_flg= SEM_UNDO;

		return semop(pSem->m_Id, &op, 1) >= 0;
	}

	return sal_False;
}

#endif /* OSL_USE_SYS_V_SEMAPHORE */