path: root/drivers/staging/epl/ShbIpc-Win32.c

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

  (c) SYSTEC electronic GmbH, D-07973 Greiz, August-Bebel-Str. 29
      www.systec-electronic.com

  Project:      Project independend shared buffer (linear + circular)

  Description:  Implementation of platform specific part for the
                shared buffer
                (Implementation for Win32)

  License:

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.

    3. Neither the name of SYSTEC electronic GmbH nor the names of its
       contributors may be used to endorse or promote products derived
       from this software without prior written permission. For written
       permission, please contact info@systec-electronic.com.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.

    Severability Clause:

        If a provision of this License is or becomes illegal, invalid or
        unenforceable in any jurisdiction, that shall not affect:
        1. the validity or enforceability in that jurisdiction of any other
           provision of this License; or
        2. the validity or enforceability in other jurisdictions of that or
           any other provision of this License.

  -------------------------------------------------------------------------

  2006/06/27 -rs:   V 1.00 (initial version)

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

#define WINVER       0x0400	// #defines necessary for usage of
#define _WIN32_WINNT 0x0400	// function <SignalObjectAndWait>

#include <windows.h>
#include <stdio.h>
#include "global.h"
#include "sharedbuff.h"
#include "shbipc.h"

/***************************************************************************/
/*                                                                         */
/*                                                                         */
/*          G L O B A L   D E F I N I T I O N S                            */
/*                                                                         */
/*                                                                         */
/***************************************************************************/

#if (!defined(SHBIPC_INLINED)) || defined(SHBIPC_INLINE_ENABLED)

//---------------------------------------------------------------------------
//  Configuration
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  Constant definitions
//---------------------------------------------------------------------------

#define MAX_LEN_BUFFER_ID       MAX_PATH

#define IDX_EVENT_NEW_DATA      0
#define IDX_EVENT_TERM_REQU     1
#define IDX_EVENT_TERM_RESP     2

#define NAME_MUTEX_BUFF_ACCESS  "BuffAccess"
#define NAME_EVENT_NEW_DATA     "NewData"
#define NAME_EVENT_TERM_REQU    "TermRequ"
#define NAME_EVENT_TERM_RESP    "TermResp"
#define NAME_EVENT_JOB_READY    "JobReady"

#define TIMEOUT_ENTER_ATOMIC    1000	// for debgging: INFINITE
#define TIMEOUT_TERM_THREAD     2000

#define SBI_MAGIC_ID            0x5342492B	// magic ID ("SBI+")
#define SBH_MAGIC_ID            0x5342482A	// magic ID ("SBH*")

//---------------------------------------------------------------------------
//  Local types
//---------------------------------------------------------------------------

// This structure is the common header for the shared memory region used
// by all processes attached this shared memory. It includes common
// information to administrate/manage the shared buffer from a couple of
// separated processes (e.g. the refernce counter). This structure is
// located at the start of the shared memory region itself and exists
// consequently only one times per shared memory instance.
typedef struct {
	unsigned long m_SbhMagicID;	// magic ID ("SBH*")
	unsigned long m_ulShMemSize;
	unsigned long m_ulRefCount;
	char m_szBufferID[MAX_LEN_BUFFER_ID];

#ifndef NDEBUG
	unsigned long m_ulOwnerProcID;
#endif

} tShbMemHeader;

// This structure is the "external entry point" from a separate process
// to get access to a shared buffer. This structure includes all platform
// resp. target specific information to administrate/manage the shared
// buffer from a separate process. Every process attached to the shared
// buffer has its own runtime instance of this structure with its individual
// runtime data (e.g. the scope of an event handle is limitted to the
// owner process only). The structure member <m_pShbMemHeader> points
// to the (process specific) start address of the shared memory region
// itself.
typedef struct {
	unsigned long m_SbiMagicID;	// magic ID ("SBI+")
	HANDLE m_hSharedMem;
	HANDLE m_hMutexBuffAccess;
	HANDLE m_hThreadNewData;	// thraed to signal that new data are available
	HANDLE m_ahEventNewData[3];	// IDX_EVENT_NEW_DATA + IDX_EVENT_TERM_REQU + ID_EVENT_TERM_RESP
	tSigHndlrNewData m_pfnSigHndlrNewData;
	HANDLE m_hThreadJobReady;	// thread to signal that a job/operation is ready now (e.g. reset buffer)
	HANDLE m_hEventJobReady;
	unsigned long m_ulTimeOutJobReady;
	tSigHndlrJobReady m_pfnSigHndlrJobReady;
	tShbMemHeader *m_pShbMemHeader;

#ifndef NDEBUG
	unsigned long m_ulThreadIDNewData;
	unsigned long m_ulThreadIDJobReady;
#endif

} tShbMemInst;

//---------------------------------------------------------------------------
//  Global variables
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  Local variables
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  Prototypes of internal functions
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
//  Get pointer to process local information structure
//---------------------------------------------------------------------------

INLINE_FUNCTION tShbMemInst *ShbIpcGetShbMemInst(tShbInstance pShbInstance_p)
{

	tShbMemInst *pShbMemInst;

	pShbMemInst = (tShbMemInst *) pShbInstance_p;
	ASSERT(pShbMemInst->m_SbiMagicID == SBI_MAGIC_ID);

	return (pShbMemInst);

}

//---------------------------------------------------------------------------
//  Get pointer to shared memory header
//---------------------------------------------------------------------------

INLINE_FUNCTION tShbMemHeader *ShbIpcGetShbMemHeader(tShbInstance
						     pShbInstance_p)
{

	tShbMemInst *pShbMemInst;
	tShbMemHeader *pShbMemHeader;

	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
	pShbMemHeader = pShbMemInst->m_pShbMemHeader;
	ASSERT(pShbMemHeader->m_SbhMagicID == SBH_MAGIC_ID);

	return (pShbMemHeader);

}

// not inlined internal functions
DWORD WINAPI ShbIpcThreadSignalNewData(LPVOID pvThreadParam_p);
DWORD WINAPI ShbIpcThreadSignalJobReady(LPVOID pvThreadParam_p);
const char *ShbIpcGetUniformObjectName(const char *pszEventJobName_p,
				       const char *pszBufferID_p,
				       BOOL fGlobalObject_p);

#endif

#if !defined(SHBIPC_INLINE_ENABLED)
// true internal functions (not inlined)
static void *ShbIpcAllocPrivateMem(unsigned long ulMemSize_p);
static void ShbIpcReleasePrivateMem(void *pMem_p);
#endif

//=========================================================================//
//                                                                         //
//          P U B L I C   F U N C T I O N S                                //
//                                                                         //
//=========================================================================//

#if !defined(SHBIPC_INLINE_ENABLED)
// not inlined external functions

//---------------------------------------------------------------------------
//  Initialize IPC for Shared Buffer Module
//---------------------------------------------------------------------------

tShbError ShbIpcInit(void)
{

	return (kShbOk);

}

//---------------------------------------------------------------------------
//  Deinitialize IPC for Shared Buffer Module
//---------------------------------------------------------------------------

tShbError ShbIpcExit(void)
{

	return (kShbOk);

}

//---------------------------------------------------------------------------
//  Allocate Shared Buffer
//---------------------------------------------------------------------------

tShbError ShbIpcAllocBuffer(unsigned long ulBufferSize_p,
			    const char *pszBufferID_p,
			    tShbInstance * ppShbInstance_p,
			    unsigned int *pfShbNewCreated_p)
{

	HANDLE hSharedMem;
	LPVOID pSharedMem;
	unsigned long ulShMemSize;
	tShbMemInst *pShbMemInst;
	tShbMemHeader *pShbMemHeader;
	tShbInstance pShbInstance;
	unsigned int fShMemNewCreated;
	const char *pszObjectName;
	HANDLE hMutexBuffAccess;
	HANDLE hEventNewData;
	HANDLE hEventJobReady;
	tShbError ShbError;

	ulShMemSize = ulBufferSize_p + sizeof(tShbMemHeader);
	pSharedMem = NULL;
	pShbInstance = NULL;
	fShMemNewCreated = FALSE;
	ShbError = kShbOk;

	//---------------------------------------------------------------
	// (1) open an existing or create a new shared memory
	//---------------------------------------------------------------
	// try to open an already existing shared memory
	// (created by an another process)
	hSharedMem = OpenFileMapping(FILE_MAP_ALL_ACCESS,	// DWORD dwDesiredAccess
				     FALSE,	// BOOL bInheritHandle
				     pszBufferID_p);	// LPCTSTR lpName
	if (hSharedMem != NULL) {
		// a shared memory already exists
		fShMemNewCreated = FALSE;
	} else {
		// it seams that this process is the first who wants to use the
		// shared memory, so it has to create a new shared memory
		hSharedMem = CreateFileMapping(INVALID_HANDLE_VALUE,	// HANDLE hFile
					       NULL,	// LPSECURITY_ATTRIBUTES lpAttributes
					       PAGE_READWRITE,	// DWORD flProtect
					       0,	// DWORD dwMaximumSizeHigh
					       ulShMemSize,	// DWORD dwMaximumSizeLow
					       pszBufferID_p);	// LPCTSTR lpName

		fShMemNewCreated = TRUE;
	}

	if (hSharedMem == NULL) {
		ShbError = kShbOutOfMem;
		goto Exit;
	}

	//---------------------------------------------------------------
	// (2) get the pointer to the shared memory
	//---------------------------------------------------------------
	pSharedMem = MapViewOfFile(hSharedMem,	// HANDLE hFileMappingObject
				   FILE_MAP_ALL_ACCESS,	// DWORD dwDesiredAccess,
				   0,	// DWORD dwFileOffsetHigh,
				   0,	// DWORD dwFileOffsetLow,
				   ulShMemSize);	// SIZE_T dwNumberOfBytesToMap

	if (pSharedMem == NULL) {
		ShbError = kShbOutOfMem;
		goto Exit;
	}

	//---------------------------------------------------------------
	// (3) setup or update header and management information
	//---------------------------------------------------------------
	pShbMemHeader = (tShbMemHeader *) pSharedMem;

	// allocate a memory block from process specific mempool to save
	// process local information to administrate/manage the shared buffer
	pShbMemInst =
	    (tShbMemInst *) ShbIpcAllocPrivateMem(sizeof(tShbMemInst));
	if (pShbMemInst == NULL) {
		ShbError = kShbOutOfMem;
		goto Exit;
	}
	// reset complete header to default values
	pShbMemInst->m_SbiMagicID = SBI_MAGIC_ID;
	pShbMemInst->m_hSharedMem = hSharedMem;
	pShbMemInst->m_hMutexBuffAccess = INVALID_HANDLE_VALUE;
	pShbMemInst->m_hThreadNewData = INVALID_HANDLE_VALUE;
	pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] =
	    INVALID_HANDLE_VALUE;
	pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] =
	    INVALID_HANDLE_VALUE;
	pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] =
	    INVALID_HANDLE_VALUE;
	pShbMemInst->m_pfnSigHndlrNewData = NULL;
	pShbMemInst->m_hThreadJobReady = INVALID_HANDLE_VALUE;
	pShbMemInst->m_hEventJobReady = INVALID_HANDLE_VALUE;
	pShbMemInst->m_ulTimeOutJobReady = 0;
	pShbMemInst->m_pfnSigHndlrJobReady = NULL;
	pShbMemInst->m_pShbMemHeader = pShbMemHeader;

#ifndef NDEBUG
	{
		pShbMemInst->m_ulThreadIDNewData = 0;
		pShbMemInst->m_ulThreadIDJobReady = 0;
	}
#endif

	// create mutex for buffer access
	pszObjectName =
	    ShbIpcGetUniformObjectName(NAME_MUTEX_BUFF_ACCESS, pszBufferID_p,
				       TRUE);
	hMutexBuffAccess = CreateMutex(NULL,	// LPSECURITY_ATTRIBUTES lpMutexAttributes
				       FALSE,	// BOOL bInitialOwner
				       pszObjectName);	// LPCTSTR lpName
	pShbMemInst->m_hMutexBuffAccess = hMutexBuffAccess;
	ASSERT(pShbMemInst->m_hMutexBuffAccess != NULL);

	// The EventNewData is used for signaling of new data after a write
	// operation (SetEvent) as well as for waiting for new data on the
	// reader side (WaitForMultipleObjects). Because it's not known if
	// this process will be read or write data, the event will be
	// always created here.
	pszObjectName =
	    ShbIpcGetUniformObjectName(NAME_EVENT_NEW_DATA, pszBufferID_p,
				       TRUE);
	hEventNewData = CreateEvent(NULL,	// LPSECURITY_ATTRIBUTES lpEventAttributes
				    FALSE,	// BOOL bManualReset
				    FALSE,	// BOOL bInitialState
				    pszObjectName);	// LPCTSTR lpName
	pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] = hEventNewData;
	ASSERT(pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] != NULL);

	// The EventJobReady is used for signaling that a job is done (SetEvent)
	// as well as for waiting for finishing of a job (WaitForMultipleObjects).
	// Because it's not known if this process will signal or wait, the event
	// will be always created here.
	pszObjectName =
	    ShbIpcGetUniformObjectName(NAME_EVENT_JOB_READY, pszBufferID_p,
				       TRUE);
	hEventJobReady = CreateEvent(NULL,	// LPSECURITY_ATTRIBUTES lpEventAttributes
				     FALSE,	// BOOL bManualReset
				     FALSE,	// BOOL bInitialState
				     pszObjectName);	// LPCTSTR lpName
	pShbMemInst->m_hEventJobReady = hEventJobReady;
	ASSERT(pShbMemInst->m_hEventJobReady != NULL);

	if (fShMemNewCreated) {
		// this process was the first who wanted to use the shared memory,
		// so a new shared memory was created
		// -> setup new header information inside the shared memory region
		//    itself
		pShbMemHeader->m_SbhMagicID = SBH_MAGIC_ID;
		pShbMemHeader->m_ulShMemSize = ulShMemSize;
		pShbMemHeader->m_ulRefCount = 1;
		strncpy(pShbMemHeader->m_szBufferID, pszBufferID_p,
			sizeof(pShbMemHeader->m_szBufferID) - 1);

#ifndef NDEBUG
		{
			pShbMemHeader->m_ulOwnerProcID = GetCurrentProcessId();
		}
#endif
	} else {
		// any other process has created the shared memory and this
		// process has only attached to it
		// -> check and update existing header information inside the
		//    shared memory region itself
		if (pShbMemHeader->m_ulShMemSize != ulShMemSize) {
			ShbError = kShbOpenMismatch;
			goto Exit;
		}
#ifndef NDEBUG
		{
			if (strncmp
			    (pShbMemHeader->m_szBufferID, pszBufferID_p,
			     sizeof(pShbMemHeader->m_szBufferID) - 1)) {
				ShbError = kShbOpenMismatch;
				goto Exit;
			}
		}
#endif

		pShbMemHeader->m_ulRefCount++;
	}

	// set abstarct "handle" for returning to application
	pShbInstance = (tShbInstance *) pShbMemInst;

      Exit:

	if (ShbError != kShbOk) {
		if (pShbMemInst != NULL) {
			ShbIpcReleasePrivateMem(pShbMemInst);
		}
		if (pSharedMem != NULL) {
			UnmapViewOfFile(pSharedMem);
		}
		if (hSharedMem != NULL) {
			CloseHandle(hSharedMem);
		}
	}

	*pfShbNewCreated_p = fShMemNewCreated;
	*ppShbInstance_p = pShbInstance;

	return (ShbError);

}

//---------------------------------------------------------------------------
//  Release Shared Buffer
//---------------------------------------------------------------------------

tShbError ShbIpcReleaseBuffer(tShbInstance pShbInstance_p)
{

	tShbMemInst *pShbMemInst;
	tShbMemHeader *pShbMemHeader;
	HANDLE hEventNewData;
	HANDLE hMutexBuffAccess;
	tShbError ShbError;
	tShbError ShbError2;

	if (pShbInstance_p == NULL) {
		return (kShbOk);
	}

	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
	pShbMemHeader = ShbIpcGetShbMemHeader(pShbInstance_p);

	if (!--pShbMemHeader->m_ulRefCount) {
		ShbError = kShbOk;
	} else {
		ShbError = kShbMemUsedByOtherProcs;
	}

	ShbError2 = ShbIpcStopSignalingNewData(pShbInstance_p);
	hEventNewData = pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA];
	if (hEventNewData != INVALID_HANDLE_VALUE) {
		CloseHandle(hEventNewData);
		pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] =
		    INVALID_HANDLE_VALUE;
	}

	hMutexBuffAccess = pShbMemInst->m_hMutexBuffAccess;
	if (hMutexBuffAccess != INVALID_HANDLE_VALUE) {
		CloseHandle(hMutexBuffAccess);
		pShbMemInst->m_hMutexBuffAccess = INVALID_HANDLE_VALUE;
	}

	UnmapViewOfFile(pShbMemHeader);
	if (pShbMemInst->m_hSharedMem != INVALID_HANDLE_VALUE) {
		CloseHandle(pShbMemInst->m_hSharedMem);
		pShbMemInst->m_hSharedMem = INVALID_HANDLE_VALUE;
	}

	ShbIpcReleasePrivateMem(pShbMemInst);

	if (ShbError == kShbOk) {
		ShbError = ShbError2;
	}

	return (ShbError);

}

#endif // !defined(SHBIPC_INLINE_ENABLED)

#if (!defined(SHBIPC_INLINED)) || defined(SHBIPC_INLINE_ENABLED)

//---------------------------------------------------------------------------
//  Enter atomic section for Shared Buffer access
//---------------------------------------------------------------------------

INLINE_FUNCTION tShbError ShbIpcEnterAtomicSection(tShbInstance pShbInstance_p)
{

	tShbMemInst *pShbMemInst;
	HANDLE hMutexBuffAccess;
	DWORD dwWaitResult;
	tShbError ShbError;

	if (pShbInstance_p == NULL) {
		return (kShbInvalidArg);
	}

	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
	ShbError = kShbOk;

	hMutexBuffAccess = pShbMemInst->m_hMutexBuffAccess;
	if (hMutexBuffAccess != INVALID_HANDLE_VALUE) {
		dwWaitResult =
		    WaitForSingleObject(hMutexBuffAccess, TIMEOUT_ENTER_ATOMIC);
		switch (dwWaitResult) {
		case WAIT_OBJECT_0 + 0:
			{
				break;
			}

		case WAIT_TIMEOUT:
			{
				TRACE0
				    ("\nShbIpcEnterAtomicSection(): WAIT_TIMEOUT");
				ASSERT(0);
				ShbError = kShbBufferInvalid;
				break;
			}

		case WAIT_ABANDONED:
			{
				TRACE0
				    ("\nShbIpcEnterAtomicSection(): WAIT_ABANDONED");
				ASSERT(0);
				ShbError = kShbBufferInvalid;
				break;
			}

		case WAIT_FAILED:
			{
				TRACE1
				    ("\nShbIpcEnterAtomicSection(): WAIT_FAILED -> LastError=%ld",
				     GetLastError());
				ASSERT(0);
				ShbError = kShbBufferInvalid;
				break;
			}

		default:
			{
				TRACE1
				    ("\nShbIpcEnterAtomicSection(): unknown error -> LastError=%ld",
				     GetLastError());
				ASSERT(0);
				ShbError = kShbBufferInvalid;
				break;
			}
		}
	} else {
		ShbError = kShbBufferInvalid;
	}

	return (ShbError);

}

//---------------------------------------------------------------------------
//  Leave atomic section for Shared Buffer access
//---------------------------------------------------------------------------

INLINE_FUNCTION tShbError ShbIpcLeaveAtomicSection(tShbInstance pShbInstance_p)
{

	tShbMemInst *pShbMemInst;
	HANDLE hMutexBuffAccess;
	BOOL fRes;
	tShbError ShbError;

	if (pShbInstance_p == NULL) {
		return (kShbInvalidArg);
	}

	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
	ShbError = kShbOk;

	hMutexBuffAccess = pShbMemInst->m_hMutexBuffAccess;
	if (hMutexBuffAccess != INVALID_HANDLE_VALUE) {
		fRes = ReleaseMutex(hMutexBuffAccess);
		ASSERT(fRes);
	} else {
		ShbError = kShbBufferInvalid;
	}

	return (ShbError);

}

//---------------------------------------------------------------------------
//  Start signaling of new data (called from reading process)
//---------------------------------------------------------------------------

INLINE_FUNCTION tShbError ShbIpcStartSignalingNewData(tShbInstance
						      pShbInstance_p,
						      tSigHndlrNewData
						      pfnSignalHandlerNewData_p,
						      tShbPriority
						      ShbPriority_p)
{

	tShbMemInst *pShbMemInst;
	tShbMemHeader *pShbMemHeader;
	const char *pszObjectName;
	HANDLE hEventTermRequ;
	HANDLE hEventTermResp;
	HANDLE hThreadNewData;
	unsigned long ulThreadIDNewData;
	tShbError ShbError;
	int iPriority;

	if ((pShbInstance_p == NULL) || (pfnSignalHandlerNewData_p == NULL)) {
		return (kShbInvalidArg);
	}

	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
	pShbMemHeader = ShbIpcGetShbMemHeader(pShbInstance_p);
	ShbError = kShbOk;

	if ((pShbMemInst->m_hThreadNewData != INVALID_HANDLE_VALUE) ||
	    (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] !=
	     INVALID_HANDLE_VALUE)
	    || (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] !=
		INVALID_HANDLE_VALUE)
	    || (pShbMemInst->m_pfnSigHndlrNewData != NULL)) {
		ShbError = kShbAlreadySignaling;
		goto Exit;
	}

	pShbMemInst->m_pfnSigHndlrNewData = pfnSignalHandlerNewData_p;

	// Because the event <pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA]>
	// is used for signaling of new data after a write operation too (using
	// SetEvent), it is always created here (see <ShbIpcAllocBuffer>).

	pszObjectName =
	    ShbIpcGetUniformObjectName(NAME_EVENT_TERM_REQU,
				       pShbMemHeader->m_szBufferID, FALSE);
	hEventTermRequ = CreateEvent(NULL,	// LPSECURITY_ATTRIBUTES lpEventAttributes
				     FALSE,	// BOOL bManualReset
				     FALSE,	// BOOL bInitialState
				     pszObjectName);	// LPCTSTR lpName
	pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] = hEventTermRequ;
	ASSERT(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] != NULL);

	pszObjectName =
	    ShbIpcGetUniformObjectName(NAME_EVENT_TERM_RESP,
				       pShbMemHeader->m_szBufferID, FALSE);
	hEventTermResp = CreateEvent(NULL,	// LPSECURITY_ATTRIBUTES lpEventAttributes
				     FALSE,	// BOOL bManualReset
				     FALSE,	// BOOL bInitialState
				     pszObjectName);	// LPCTSTR lpName
	pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] = hEventTermResp;
	ASSERT(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] != NULL);

	hThreadNewData = CreateThread(NULL,	// LPSECURITY_ATTRIBUTES lpThreadAttributes
				      0,	// SIZE_T dwStackSize
				      ShbIpcThreadSignalNewData,	// LPTHREAD_START_ROUTINE lpStartAddress
				      pShbInstance_p,	// LPVOID lpParameter
				      0,	// DWORD dwCreationFlags
				      &ulThreadIDNewData);	// LPDWORD lpThreadId

	switch (ShbPriority_p) {
	case kShbPriorityLow:
		iPriority = THREAD_PRIORITY_BELOW_NORMAL;
		break;

	case kShbPriorityNormal:
		iPriority = THREAD_PRIORITY_NORMAL;
		break;

	case kshbPriorityHigh:
		iPriority = THREAD_PRIORITY_ABOVE_NORMAL;
		break;

	}

	ASSERT(pShbMemInst->m_hThreadNewData != NULL);

	SetThreadPriority(hThreadNewData, iPriority);

	pShbMemInst->m_hThreadNewData = hThreadNewData;

#ifndef NDEBUG
	{
		pShbMemInst->m_ulThreadIDNewData = ulThreadIDNewData;
	}
#endif

      Exit:

	return (ShbError);

}

//---------------------------------------------------------------------------
//  Stop signaling of new data (called from reading process)
//---------------------------------------------------------------------------

INLINE_FUNCTION tShbError ShbIpcStopSignalingNewData(tShbInstance
						     pShbInstance_p)
{

	tShbMemInst *pShbMemInst;
	HANDLE hEventTermRequ;
	HANDLE hEventTermResp;
	DWORD dwWaitResult;

	if (pShbInstance_p == NULL) {
		return (kShbInvalidArg);
	}

	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);

	// terminate new data signaling thread
	// (set event <hEventTermRequ> to wakeup the thread and dispose it
	// to exit, then wait for confirmation using event <hEventTermResp>)
	hEventTermRequ = pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU];
	hEventTermResp = pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP];
	if ((hEventTermRequ != INVALID_HANDLE_VALUE) &&
	    (hEventTermResp != INVALID_HANDLE_VALUE)) {
		TRACE0("\nShbIpcStopSignalingNewData(): enter wait state");
		dwWaitResult = SignalObjectAndWait(hEventTermRequ,	// HANDLE hObjectToSignal
						   hEventTermResp,	// HANDLE hObjectToWaitOn
						   TIMEOUT_TERM_THREAD,	// DWORD dwMilliseconds
						   FALSE);	// BOOL bAlertable
		TRACE0
		    ("\nShbIpcStopSignalingNewData(): wait state leaved: ---> ");
		switch (dwWaitResult) {
		case WAIT_OBJECT_0 + 0:	// event "new data signaling thread terminated"
			{
				TRACE0("Event = WAIT_OBJECT_0+0");
				break;
			}

		default:
			{
				TRACE0("Unhandled Event");
				ASSERT(0);
				break;
			}
		}
	}

	if (pShbMemInst->m_hThreadNewData != INVALID_HANDLE_VALUE) {
		CloseHandle(pShbMemInst->m_hThreadNewData);
		pShbMemInst->m_hThreadNewData = INVALID_HANDLE_VALUE;
	}

	if (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] !=
	    INVALID_HANDLE_VALUE) {
		CloseHandle(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU]);
		pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_REQU] =
		    INVALID_HANDLE_VALUE;
	}

	if (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] !=
	    INVALID_HANDLE_VALUE) {
		CloseHandle(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP]);
		pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] =
		    INVALID_HANDLE_VALUE;
	}

	pShbMemInst->m_pfnSigHndlrNewData = NULL;

	return (kShbOk);

}

//---------------------------------------------------------------------------
//  Signal new data (called from writing process)
//---------------------------------------------------------------------------

INLINE_FUNCTION tShbError ShbIpcSignalNewData(tShbInstance pShbInstance_p)
{

	tShbMemInst *pShbMemInst;
	HANDLE hEventNewData;
	BOOL fRes;

	// TRACE0("\nShbIpcSignalNewData(): enter\n");

	if (pShbInstance_p == NULL) {
		return (kShbInvalidArg);
	}

	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);

	ASSERT(pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA] !=
	       INVALID_HANDLE_VALUE);
	hEventNewData = pShbMemInst->m_ahEventNewData[IDX_EVENT_NEW_DATA];
	if (hEventNewData != INVALID_HANDLE_VALUE) {
		fRes = SetEvent(hEventNewData);
		// TRACE1("\nShbIpcSignalNewData(): EventNewData set (Result=%d)\n", (int)fRes);
		ASSERT(fRes);
	}
	// TRACE0("\nShbIpcSignalNewData(): leave\n");
	return (kShbOk);

}

//---------------------------------------------------------------------------
//  Start signaling for job ready (called from waiting process)
//---------------------------------------------------------------------------

INLINE_FUNCTION tShbError ShbIpcStartSignalingJobReady(tShbInstance
						       pShbInstance_p,
						       unsigned long
						       ulTimeOut_p,
						       tSigHndlrJobReady
						       pfnSignalHandlerJobReady_p)
{

	tShbMemInst *pShbMemInst;
	tShbMemHeader *pShbMemHeader;
	HANDLE hThreadJobReady;
	unsigned long ulThreadIDJobReady;
	tShbError ShbError;

	if ((pShbInstance_p == NULL) || (pfnSignalHandlerJobReady_p == NULL)) {
		return (kShbInvalidArg);
	}

	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);
	pShbMemHeader = ShbIpcGetShbMemHeader(pShbInstance_p);
	ShbError = kShbOk;

	if ((pShbMemInst->m_hThreadJobReady != INVALID_HANDLE_VALUE) ||
	    (pShbMemInst->m_pfnSigHndlrJobReady != NULL)) {
		ShbError = kShbAlreadySignaling;
		goto Exit;
	}

	pShbMemInst->m_ulTimeOutJobReady = ulTimeOut_p;
	pShbMemInst->m_pfnSigHndlrJobReady = pfnSignalHandlerJobReady_p;

	// Because the event <pShbMemInst->m_ahEventJobReady> is used for
	// signaling of a finished job too (using SetEvent), it is always
	// created here (see <ShbIpcAllocBuffer>).

	hThreadJobReady = CreateThread(NULL,	// LPSECURITY_ATTRIBUTES lpThreadAttributes
				       0,	// SIZE_T dwStackSize
				       ShbIpcThreadSignalJobReady,	// LPTHREAD_START_ROUTINE lpStartAddress
				       pShbInstance_p,	// LPVOID lpParameter
				       0,	// DWORD dwCreationFlags
				       &ulThreadIDJobReady);	// LPDWORD lpThreadId

	pShbMemInst->m_hThreadJobReady = hThreadJobReady;
	ASSERT(pShbMemInst->m_hThreadJobReady != NULL);

#ifndef NDEBUG
	{
		pShbMemInst->m_ulThreadIDJobReady = ulThreadIDJobReady;
	}
#endif

      Exit:

	return (ShbError);

}

//---------------------------------------------------------------------------
//  Signal job ready (called from executing process)
//---------------------------------------------------------------------------

INLINE_FUNCTION tShbError ShbIpcSignalJobReady(tShbInstance pShbInstance_p)
{

	tShbMemInst *pShbMemInst;
	HANDLE hEventJobReady;
	BOOL fRes;

	// TRACE0("\nShbIpcSignalJobReady(): enter\n");

	if (pShbInstance_p == NULL) {
		return (kShbInvalidArg);
	}

	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance_p);

	ASSERT(pShbMemInst->m_hEventJobReady != INVALID_HANDLE_VALUE);
	hEventJobReady = pShbMemInst->m_hEventJobReady;
	if (hEventJobReady != INVALID_HANDLE_VALUE) {
		fRes = SetEvent(hEventJobReady);
		// TRACE1("\nShbIpcSignalJobReady(): EventJobReady set (Result=%d)\n", (int)fRes);
		ASSERT(fRes);
	}
	// TRACE0("\nShbIpcSignalJobReady(): leave\n");
	return (kShbOk);

}

//---------------------------------------------------------------------------
//  Get pointer to common used share memory area
//---------------------------------------------------------------------------

INLINE_FUNCTION void *ShbIpcGetShMemPtr(tShbInstance pShbInstance_p)
{

	tShbMemHeader *pShbMemHeader;
	void *pShbShMemPtr;

	pShbMemHeader = ShbIpcGetShbMemHeader(pShbInstance_p);
	if (pShbMemHeader != NULL) {
		pShbShMemPtr = (BYTE *) pShbMemHeader + sizeof(tShbMemHeader);
	} else {
		pShbShMemPtr = NULL;
	}

	return (pShbShMemPtr);

}

#endif

//=========================================================================//
//                                                                         //
//          P R I V A T E   F U N C T I O N S                              //
//                                                                         //
//=========================================================================//

#if !defined(SHBIPC_INLINE_ENABLED)

//---------------------------------------------------------------------------
//  Allocate a memory block from process specific mempool
//---------------------------------------------------------------------------

static void *ShbIpcAllocPrivateMem(unsigned long ulMemSize_p)
{

	HGLOBAL hMem;
	void *pMem;

	hMem = GlobalAlloc(GMEM_FIXED, ulMemSize_p + sizeof(HGLOBAL));
	pMem = GlobalLock(hMem);
	if (pMem != NULL) {
		*(HGLOBAL *) pMem = hMem;
		(BYTE *) pMem += sizeof(HGLOBAL);
	}

#ifndef NDEBUG
	{
		memset(pMem, 0xaa, ulMemSize_p);
	}
#endif

	return (pMem);

}

//---------------------------------------------------------------------------
//  Release a memory block from process specific mempool
//---------------------------------------------------------------------------

static void ShbIpcReleasePrivateMem(void *pMem_p)
{

	HGLOBAL hMem;

	if (pMem_p == NULL) {
		return;
	}

	(BYTE *) pMem_p -= sizeof(HGLOBAL);
	hMem = *(HGLOBAL *) pMem_p;

	GlobalUnlock(hMem);
	GlobalFree(hMem);

	return;

}

//---------------------------------------------------------------------------
//  Create uniform object name (needed for inter-process communication)
//---------------------------------------------------------------------------

const char *ShbIpcGetUniformObjectName(const char *pszObjectJobName_p,
				       const char *pszBufferID_p,
				       BOOL fGlobalObject_p)
{

	static char szObjectName[MAX_PATH];
	char szObjectPrefix[MAX_PATH];

	if (fGlobalObject_p) {
		strncpy(szObjectPrefix, "Global\\", sizeof(szObjectPrefix));
	} else {
		_snprintf(szObjectPrefix, sizeof(szObjectPrefix), "PID%08lX_",
			  (unsigned long)GetCurrentProcessId());
	}

	_snprintf(szObjectName, sizeof(szObjectName), "%s%s#%s",
		  szObjectPrefix, pszBufferID_p, pszObjectJobName_p);

	return (szObjectName);

}

//---------------------------------------------------------------------------
//  Thread for new data signaling
//---------------------------------------------------------------------------

DWORD WINAPI ShbIpcThreadSignalNewData(LPVOID pvThreadParam_p)
{

	tShbInstance pShbInstance;
	tShbMemInst *pShbMemInst;
	DWORD dwWaitResult;
	BOOL fTermRequ;
	int fCallAgain;

	TRACE1
	    ("\nShbIpcThreadSignalNewData(): SignalThread started (pShbInstance=0x%08lX)\n",
	     (DWORD) pvThreadParam_p);

	pShbInstance = (tShbMemInst *) pvThreadParam_p;
	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance);
	fTermRequ = FALSE;

	do {
		ASSERT((pShbMemInst->m_ahEventNewData[0] !=
			INVALID_HANDLE_VALUE)
		       && (pShbMemInst->m_ahEventNewData[0] != NULL));
		ASSERT((pShbMemInst->m_ahEventNewData[1] !=
			INVALID_HANDLE_VALUE)
		       && (pShbMemInst->m_ahEventNewData[1] != NULL));

		TRACE0("\nShbIpcThreadSignalNewData(): enter wait state");
		dwWaitResult = WaitForMultipleObjects(2,	// DWORD nCount
						      pShbMemInst->m_ahEventNewData,	// const HANDLE* lpHandles
						      FALSE,	// BOOL bWaitAll
						      INFINITE);	// DWORD dwMilliseconds
		TRACE0
		    ("\nShbIpcThreadSignalNewData(): wait state leaved: ---> ");
		switch (dwWaitResult) {
		case WAIT_OBJECT_0 + 0:	// event "new data"
			{
				TRACE0("Event = WAIT_OBJECT_0+0");
				if (pShbMemInst->m_pfnSigHndlrNewData != NULL) {
					TRACE0
					    ("\nShbIpcThreadSignalNewData(): calling SignalHandlerNewData");
					do {
						fCallAgain =
						    pShbMemInst->
						    m_pfnSigHndlrNewData
						    (pShbInstance);
						// d.k.: try to run any shared buffer which has higher priority.
						//           under Windows this is not really necessary because the Windows scheduler
						//           already preempts tasks with lower priority.
					} while (fCallAgain != FALSE);
				}
				break;
			}

		case WAIT_OBJECT_0 + 1:	// event "terminate"
			{
				TRACE0("Event = WAIT_OBJECT_0+1");
				fTermRequ = TRUE;
				break;
			}

		default:
			{
				TRACE0("Unhandled Event");
				ASSERT(0);
				fTermRequ = TRUE;
				break;
			}
		}
	}
	while (!fTermRequ);

	if (pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP] !=
	    INVALID_HANDLE_VALUE) {
		SetEvent(pShbMemInst->m_ahEventNewData[IDX_EVENT_TERM_RESP]);
	}

	TRACE1
	    ("\nShbIpcThreadSignalNewData(): SignalThread terminated (pShbInstance=0x%08lX)\n",
	     (DWORD) pShbInstance);

	ExitThread(0);

}

//---------------------------------------------------------------------------
//  Thread for new data signaling
//---------------------------------------------------------------------------

DWORD WINAPI ShbIpcThreadSignalJobReady(LPVOID pvThreadParam_p)
{

	tShbInstance *pShbInstance;
	tShbMemInst *pShbMemInst;
	DWORD ulTimeOut;
	DWORD dwWaitResult;
	unsigned int fTimeOut;

	TRACE1
	    ("\nShbIpcThreadSignalJobReady(): SignalThread started (pShbInstance=0x%08lX)\n",
	     (DWORD) pvThreadParam_p);

	pShbInstance = (tShbInstance *) pvThreadParam_p;
	pShbMemInst = ShbIpcGetShbMemInst(pShbInstance);
	fTimeOut = FALSE;

	if (pShbMemInst->m_ulTimeOutJobReady != 0) {
		ulTimeOut = pShbMemInst->m_ulTimeOutJobReady;
	} else {
		ulTimeOut = INFINITE;
	}

	ASSERT((pShbMemInst->m_hEventJobReady != INVALID_HANDLE_VALUE)
	       && (pShbMemInst->m_hEventJobReady != NULL));

	TRACE0("\nShbIpcThreadSignalJobReady(): enter wait state");
	dwWaitResult = WaitForSingleObject(pShbMemInst->m_hEventJobReady,	// HANDLE hHandle
					   ulTimeOut);	// DWORD dwMilliseconds
	TRACE0("\nShbIpcThreadSignalJobReady(): wait state leaved: ---> ");
	switch (dwWaitResult) {
	case WAIT_OBJECT_0 + 0:	// event "new data"
		{
			TRACE0("Event = WAIT_OBJECT_0+0");
			fTimeOut = FALSE;
			break;
		}

	case WAIT_TIMEOUT:
		{
			TRACE0("\nEvent = WAIT_TIMEOUT");
			fTimeOut = TRUE;
			// ASSERT(0);
			break;
		}

	default:
		{
			TRACE0("Unhandled Event");
			fTimeOut = TRUE;
			ASSERT(0);
			break;
		}
	}

	if (pShbMemInst->m_pfnSigHndlrJobReady != NULL) {
		TRACE0
		    ("\nShbIpcThreadSignalJobReady(): calling SignalHandlerJobReady");
		pShbMemInst->m_pfnSigHndlrJobReady(pShbInstance, fTimeOut);
	}

	pShbMemInst->m_hThreadJobReady = INVALID_HANDLE_VALUE;
	pShbMemInst->m_pfnSigHndlrJobReady = NULL;

	TRACE1
	    ("\nShbIpcThreadSignalJobReady(): SignalThread terminated (pShbInstance=0x%08lX)\n",
	     (DWORD) pShbInstance);

	ExitThread(0);

}

#endif

// EOF