2190 lines
47 KiB
C
2190 lines
47 KiB
C
/*++
|
|
|
|
Copyright (c) 1990 Microsoft Corporation
|
|
|
|
Module Name:
|
|
winsmsc.c
|
|
|
|
|
|
|
|
Abstract:
|
|
|
|
This module contains miscellanous functions that in general are used by
|
|
more than one component of WINS. Some of the functions in this module are
|
|
wrappers for WIN32 api functions. These wrappers serve to isolate
|
|
WINS code from changes in the WIN32 api.
|
|
|
|
Functions:
|
|
|
|
WinsMscAlloc
|
|
WinsMscDealloc
|
|
WinsMscFreeMem
|
|
WinsMscWaitInfinite
|
|
WinsMscWaitTimed
|
|
WinsMscCreateEvt
|
|
WinsMscSetUpThd
|
|
WinsMscWaitUntilSignaled
|
|
WinsMscWaitTimedUntilSignaled
|
|
WinsMscHeapAlloc
|
|
WinsMscHeapFree
|
|
WinsMscHeapCreate
|
|
WinsMscHeapDestroy
|
|
WinsMscTermThd
|
|
WinsMscSignalHdl
|
|
WinsMscResetHdl
|
|
WinsMscCloseHdl
|
|
WinsMscCreateThd
|
|
WinsMscSetThdPriority
|
|
WinsMscOpenFile
|
|
WinsMscMapFile
|
|
|
|
|
|
Portability:
|
|
This module is portable
|
|
|
|
Author:
|
|
|
|
Pradeep Bahl (PradeepB) Dec-1992
|
|
|
|
Revision History:
|
|
|
|
Modification date Person Description of modification
|
|
----------------- ------- ----------------------------
|
|
--*/
|
|
|
|
#include <string.h>
|
|
|
|
#if 0
|
|
//
|
|
// The following is just for the system call
|
|
//
|
|
#ifdef WINSDBG
|
|
#include <process.h>
|
|
#include <stdlib.h>
|
|
#endif
|
|
#endif
|
|
|
|
#include "wins.h"
|
|
#include "nms.h"
|
|
#include "nmsdb.h"
|
|
#include "winsmsc.h"
|
|
#include "winscnf.h"
|
|
#include "winstmm.h"
|
|
#include "winsevt.h"
|
|
#include "winsque.h"
|
|
#include "winsprs.h"
|
|
#include "winsdbg.h"
|
|
|
|
/*
|
|
* Local Macro Declarations
|
|
*/
|
|
|
|
#define PERCENT_CHAR TEXT('%')
|
|
/*
|
|
* Local Typedef Declarations
|
|
*/
|
|
|
|
|
|
/*
|
|
* Global Variable Definitions
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
* Local Variable Definitions
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
* Local Function Prototype Declarations
|
|
*/
|
|
|
|
/* prototypes for functions local to this module go here */
|
|
|
|
__inline
|
|
VOID
|
|
WinsMscAlloc(
|
|
IN DWORD BuffSize,
|
|
OUT LPVOID *ppRspBuff
|
|
)
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is called to allocate memory.
|
|
|
|
|
|
Arguments:
|
|
BuffSize - Size of buffer to allocate
|
|
ppRspBuff - Buffer allocated
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
None
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
NmsDbGetDataRecs, GetGroupMembers
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
FUTURES("Change this function into a macro")
|
|
|
|
*ppRspBuff = WinsMscHeapAlloc(GenBuffHeapHdl, BuffSize);
|
|
|
|
return;
|
|
}
|
|
|
|
__inline
|
|
VOID
|
|
WinsMscDealloc(
|
|
IN LPVOID pBuff
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function frees memory allocated via NmsDbAlloc
|
|
Arguments:
|
|
pBuff -- Buffer to deallocate
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
|
|
{
|
|
FUTURES("Change this function into a macro")
|
|
WinsMscHeapFree(GenBuffHeapHdl, pBuff);
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
WinsMscFreeMem(
|
|
IN PWINS_MEM_T pWinsMem
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is called to free memory that is pointed to by one
|
|
or more pointers in the pWinsMem array
|
|
|
|
|
|
This function is called from all those functions that allocate
|
|
memory or that acquire memory allocated by called function via
|
|
OUT args of those "memory allocating" called functions.
|
|
|
|
Arguments:
|
|
|
|
pWinsMem - ptr to an array of buffers to deallocate
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes --
|
|
Error status codes --
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
pWinsMem array should end with a NULL pointer
|
|
--*/
|
|
|
|
{
|
|
|
|
if (pWinsMem != NULL)
|
|
{
|
|
|
|
for (; pWinsMem->pMem != NULL; pWinsMem++)
|
|
{
|
|
WinsMscDealloc(pWinsMem->pMem);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
WinsMscWaitInfinite(
|
|
IN HANDLE Hdl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
The function is called to wait on a handle until signalled.
|
|
|
|
Arguments:
|
|
Hdl -- handle to wait on until signaled
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes --
|
|
Error status codes --
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
|
|
DWORD RetVal = WAIT_OBJECT_0;
|
|
|
|
/*
|
|
The function should return only if the handle is in the signaled state
|
|
*/
|
|
RetVal = WaitForSingleObject(Hdl, INFINITE);
|
|
|
|
if (RetVal != WAIT_OBJECT_0)
|
|
{
|
|
WINS_RAISE_EXC_M(WINS_EXC_ABNORMAL_TERM);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
WinsMscWaitTimed(
|
|
IN HANDLE Hdl,
|
|
IN DWORD TimeOut,
|
|
OUT LPBOOL pfSignaled
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
The function is called to wait on a handle until signalled.
|
|
|
|
Arguments:
|
|
Hdl - handle to wait on until signaled
|
|
TimeOut - TIme for which the wait has to be done
|
|
pfSIgnaled - Indicates whether the hdl got signaled.
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
|
|
DWORD RetVal = WAIT_OBJECT_0;
|
|
|
|
*pfSignaled = TRUE;
|
|
|
|
/*
|
|
The function should return only if the handle is in the signaled state
|
|
*/
|
|
RetVal = WaitForSingleObject(Hdl, TimeOut);
|
|
|
|
if (RetVal == WAIT_ABANDONED)
|
|
{
|
|
WINS_RAISE_EXC_M(WINS_EXC_ABNORMAL_TERM);
|
|
|
|
}
|
|
if (RetVal == WAIT_TIMEOUT)
|
|
{
|
|
if (TimeOut == INFINITE)
|
|
{
|
|
WINS_RAISE_EXC_M(WINS_EXC_ABNORMAL_TERM);
|
|
}
|
|
else
|
|
{
|
|
*pfSignaled = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
WinsMscCreateEvt(
|
|
IN LPTSTR pName,
|
|
IN BOOL fManualReset,
|
|
IN PHANDLE pHdl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function creates an event with the specified name
|
|
|
|
|
|
Arguments:
|
|
pName - Name of Event to create
|
|
fManualReset - Flag indicating whether it is a manual reset event
|
|
pHdl - Handle to Event created
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
Init in nms.c
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
|
|
DWORD Error;
|
|
|
|
*pHdl = CreateEvent(
|
|
NULL, //default security attributes
|
|
fManualReset, //auto reset event
|
|
FALSE, //Not signalled initially
|
|
pName // name
|
|
);
|
|
|
|
if (*pHdl == NULL)
|
|
{
|
|
Error = GetLastError();
|
|
WINSEVT_LOG_M(WINS_FATAL_ERR, WINS_EVT_CANT_CREATE_EVT);
|
|
WINS_RAISE_EXC_M(WINS_EXC_OUT_OF_RSRCS);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
STATUS
|
|
WinsMscSetUpThd(
|
|
PQUE_HD_T pQueHd,
|
|
LPTHREAD_START_ROUTINE pThdInitFn,
|
|
LPVOID pParam,
|
|
PHANDLE pThdHdl,
|
|
LPDWORD pThdId
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function initializes a queue and its critical section, creates
|
|
an event and a thread to wait on that event. The event is signaled
|
|
whenever a work item is put on the queue.
|
|
|
|
Arguments:
|
|
pQueHd - Head of queue to be monitored by the thread
|
|
pThdInitFn - Startup function of the thread
|
|
pParam - param to be passed to the startup function
|
|
pThdhdl - Hdl of thread created by this function
|
|
pThdId - Id of thread created by this function
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes -- WINS_SUCCESS
|
|
Error status codes -- none currently
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
WinsTmmInit, RplInit, NmsChlInit
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
|
|
DWORD ThdId;
|
|
|
|
/*
|
|
* Initialize the critical section that protects the work queue of
|
|
* the Pull thread
|
|
*/
|
|
InitializeCriticalSection(&pQueHd->CrtSec);
|
|
|
|
/*
|
|
* Initialize the listhead for the pull thread's queue
|
|
*/
|
|
InitializeListHead(&pQueHd->Head);
|
|
|
|
/*
|
|
* Create an auto-reset event for the above queue
|
|
*/
|
|
WinsMscCreateEvt(
|
|
NULL, //create without name
|
|
FALSE, //auto-reser var
|
|
&pQueHd->EvtHdl
|
|
);
|
|
|
|
/*
|
|
Create the thread
|
|
*/
|
|
*pThdHdl = WinsMscCreateThd(
|
|
pThdInitFn,
|
|
pParam,
|
|
&ThdId
|
|
);
|
|
|
|
if (pThdId != NULL)
|
|
{
|
|
*pThdId = ThdId;
|
|
}
|
|
return(WINS_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
WinsMscWaitUntilSignaled(
|
|
LPHANDLE pHdlArray,
|
|
DWORD NoOfHdls,
|
|
LPDWORD pIndexOfHdlSignaled,
|
|
BOOL fAlertable
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is called to wait on multiple handles, one of which
|
|
is the handle which is signaled at termination time
|
|
|
|
|
|
Arguments:
|
|
pHdlArray - Array of handles to wait on
|
|
NoOfHdls - No of hdls in the array
|
|
pIndexOfHdlSignaled - Index of the hdl signaled
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
|
|
--*/
|
|
{
|
|
|
|
DWORD RetHdl;
|
|
|
|
do {
|
|
RetHdl = WaitForMultipleObjectsEx(
|
|
NoOfHdls, //# of handles in the array
|
|
pHdlArray, //array of handles
|
|
FALSE, //return when any of the events
|
|
//gets signaled
|
|
INFINITE, //Infinite timeout
|
|
fAlertable
|
|
);
|
|
|
|
DBGPRINT1(DET, "WinsMscWaitUntilSignaled. WaitForMultipleObjects returned (%d)\n", RetHdl);
|
|
// if we got signaled due to IO completion queued on the thread
|
|
// just go back and wait again
|
|
} while (fAlertable && WAIT_IO_COMPLETION == RetHdl);
|
|
|
|
if (RetHdl == 0xFFFFFFFF)
|
|
{
|
|
DBGPRINT1(EXC, "WinsMscWaitUntilSignaled. WaitForMultipleObjects returned error. Error = (%d)\n", GetLastError());
|
|
WINS_RAISE_EXC_M(WINS_EXC_FATAL_ERR);
|
|
}
|
|
|
|
*pIndexOfHdlSignaled = RetHdl - WAIT_OBJECT_0;
|
|
if (*pIndexOfHdlSignaled >= NoOfHdls)
|
|
{
|
|
|
|
WINS_RAISE_EXC_M(WINS_EXC_FATAL_ERR);
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
WinsMscWaitTimedUntilSignaled(
|
|
LPHANDLE pHdlArray,
|
|
DWORD NoOfHdls,
|
|
LPDWORD pIndexOfHdlSignaled,
|
|
DWORD TimeOut,
|
|
LPBOOL pfSignaled
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is called to wait on multiple handles, one of which
|
|
is the handle which is signaled at termination time
|
|
|
|
|
|
Arguments:
|
|
pHdlArray - Array of handles to wait on
|
|
NoOfHdls - No of handles in the array
|
|
pIndexOfHdlSignaled - Index of handle signaled
|
|
Timeout - Max time for which to do the wait
|
|
pfSignaled - indicates whether a hdl was signaled
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
|
|
--*/
|
|
{
|
|
|
|
DWORD RetHdl = 0xFFFFFFFF;
|
|
DWORD Error;
|
|
int Index;
|
|
|
|
*pfSignaled = TRUE;
|
|
|
|
RetHdl = WaitForMultipleObjects(
|
|
NoOfHdls, //# of handles in the array
|
|
pHdlArray, //array of handles
|
|
FALSE, //return when either event gets
|
|
//signaled
|
|
TimeOut //Infinite timeout
|
|
);
|
|
|
|
if (RetHdl == 0xFFFFFFFF)
|
|
{
|
|
Error = GetLastError();
|
|
WINS_RAISE_EXC_M(WINS_EXC_FATAL_ERR);
|
|
}
|
|
|
|
if (RetHdl == WAIT_TIMEOUT)
|
|
{
|
|
*pfSignaled = FALSE;
|
|
return;
|
|
}
|
|
|
|
Index = RetHdl - WAIT_OBJECT_0;
|
|
|
|
if ((Index >= (int)NoOfHdls) || (Index < 0))
|
|
{
|
|
|
|
DBGPRINT1(EXC, "WinsMscWaitTimedUntilSignaled: Index of handle signaled (%d) is INVALID\n", Index);
|
|
|
|
Index = RetHdl - WAIT_ABANDONED_0 ;
|
|
if ((Index > 0) && (Index < (int)NoOfHdls))
|
|
{
|
|
DBGPRINT1(EXC, "WinsMscWaitTimedUntilSignaled: Index of handle in the abandoned state (%d)\n", Index);
|
|
}
|
|
|
|
WINS_RAISE_EXC_M(WINS_EXC_FATAL_ERR);
|
|
|
|
}
|
|
else
|
|
{
|
|
*pIndexOfHdlSignaled = Index;
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
__inline
|
|
LPVOID
|
|
WinsMscHeapAlloc(
|
|
IN HANDLE HeapHdl,
|
|
IN DWORD Size
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
The function returns with a buffer allocated from the specified heap
|
|
|
|
|
|
|
|
Arguments:
|
|
|
|
HeapHdl - Handle to the heap
|
|
ppBuff - Buffer allocated
|
|
Size - Size of Buffer
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
Return Value:
|
|
|
|
Success status codes -- ptr to the allocated memory
|
|
Error status codes -- NULL
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
|
|
|
|
LPVOID pBuff;
|
|
#ifdef WINSDBG
|
|
LPDWORD pHeapCntr;
|
|
#endif
|
|
|
|
//
|
|
// Note: It is very important that the memory be initialized to zero
|
|
// (for example, until we have longlong (LARGE INTEGER) support
|
|
// in the db engine - JET, we will retrieve the version number
|
|
// as a long data type and store it in the LowPart field of the
|
|
// large integer storing the version number in our in-memory
|
|
// data structure. The HighPart will be 0 by default due to
|
|
// the initialization done at allocation time. This is what
|
|
// we want.
|
|
//
|
|
|
|
//
|
|
// if you pass a very large value for the size, HeapAlloc returns NULL
|
|
// instead of raising an exception.
|
|
//
|
|
pBuff = (MSG_T)HeapAlloc(
|
|
HeapHdl,
|
|
HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY,
|
|
Size
|
|
);
|
|
|
|
DBGPRINT2(HEAP, "HeapAlloc: HeapHandle = (%p), pBuff = (%p)\n",
|
|
HeapHdl, pBuff);
|
|
|
|
#ifdef WINSDBG
|
|
if (Size == 0)
|
|
{
|
|
DBGPRINT2(ERR, "WinsMscHeapAlloc: Size = 0; pBuff returned = (%p); HeapHdl = (%p)\n", pBuff, HeapHdl);
|
|
|
|
}
|
|
IF_DBG(HEAP_CNTRS)
|
|
{
|
|
|
|
if (HeapHdl == CommUdpBuffHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsUdpHeapAlloc;
|
|
} else if (HeapHdl == CommUdpDlgHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsUdpDlgHeapAlloc;
|
|
} else if (HeapHdl == CommAssocDlgHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsDlgHeapAlloc;
|
|
} else if (HeapHdl == CommAssocTcpMsgHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsTcpMsgHeapAlloc;
|
|
} else if (HeapHdl == GenBuffHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsGenHeapAlloc;
|
|
} else if (HeapHdl == QueBuffHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsQueHeapAlloc;
|
|
} else if (HeapHdl == NmsChlHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsChlHeapAlloc;
|
|
} else if (HeapHdl == CommAssocAssocHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsAssocHeapAlloc;
|
|
} else if (HeapHdl == RplWrkItmHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsRplWrkItmHeapAlloc;
|
|
} else if (HeapHdl == NmsRpcHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsRpcHeapAlloc;
|
|
} else if (HeapHdl == WinsTmmHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsTmmHeapAlloc;
|
|
} else
|
|
{
|
|
DBGPRINT1(HEAP, "WinsMscHeapAlloc: HeapHdl = (%p)\n", HeapHdl);
|
|
pHeapCntr = &NmsCatchAllHeapAlloc;
|
|
}
|
|
|
|
|
|
EnterCriticalSection(&NmsHeapCrtSec);
|
|
|
|
(*pHeapCntr)++;
|
|
LeaveCriticalSection(&NmsHeapCrtSec);
|
|
}
|
|
#endif
|
|
return(pBuff);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
__inline
|
|
VOID
|
|
WinsMscHeapFree(
|
|
IN HANDLE HeapHdl,
|
|
IN LPVOID pBuff
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function deallocates the memory pointed to by pBuff from the
|
|
specified heap
|
|
|
|
Arguments:
|
|
HeapHdl - Handle to the heap
|
|
pBuff - Buffer to deallocate
|
|
|
|
Externals Used:
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
{
|
|
|
|
DWORD Error;
|
|
BOOL fStatus;
|
|
#ifdef WINSDBG
|
|
LPDWORD pHeapCntr;
|
|
#endif
|
|
|
|
DBGPRINT2(HEAP, "HeapFree: HeapHandle = (%p), pBuff = (%p)\n",
|
|
HeapHdl, pBuff);
|
|
|
|
fStatus = HeapFree(
|
|
HeapHdl,
|
|
0, //we want mutual exclusion
|
|
pBuff
|
|
);
|
|
|
|
if (!fStatus)
|
|
{
|
|
Error = GetLastError();
|
|
WINSEVT_LOG_M(Error, WINS_EVT_HEAP_ERROR);
|
|
WINS_RAISE_EXC_M(WINS_EXC_HEAP_FREE_ERR);
|
|
}
|
|
#ifdef WINSDBG
|
|
IF_DBG(HEAP_CNTRS)
|
|
{
|
|
if (HeapHdl == CommUdpBuffHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsUdpHeapFree;
|
|
} else if (HeapHdl == CommUdpDlgHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsUdpDlgHeapFree;
|
|
} else if (HeapHdl == CommAssocDlgHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsDlgHeapFree;
|
|
} else if (HeapHdl == CommAssocTcpMsgHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsTcpMsgHeapFree;
|
|
} else if (HeapHdl == GenBuffHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsGenHeapFree;
|
|
} else if (HeapHdl == QueBuffHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsQueHeapFree;
|
|
} else if (HeapHdl == NmsChlHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsChlHeapFree;
|
|
} else if (HeapHdl == CommAssocAssocHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsAssocHeapFree;
|
|
} else if (HeapHdl == RplWrkItmHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsRplWrkItmHeapFree;
|
|
} else if (HeapHdl == NmsRpcHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsRpcHeapFree;
|
|
} else if (HeapHdl == WinsTmmHeapHdl)
|
|
{
|
|
pHeapCntr = &NmsTmmHeapFree;
|
|
} else
|
|
{
|
|
DBGPRINT1(HEAP, "WinsMscHeapFree: HeapHdl = (%p)\n", HeapHdl);
|
|
pHeapCntr = &NmsCatchAllHeapFree;
|
|
}
|
|
EnterCriticalSection(&NmsHeapCrtSec);
|
|
(*pHeapCntr)++;
|
|
LeaveCriticalSection(&NmsHeapCrtSec);
|
|
}
|
|
#endif
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
HANDLE
|
|
WinsMscHeapCreate(
|
|
IN DWORD Options,
|
|
IN DWORD InitSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function creates a heap with the specified options
|
|
|
|
|
|
Arguments:
|
|
Options -- Options for the HeapCreate function (Example: whether or
|
|
not to enable mutual exclusion)
|
|
|
|
InitSize -- Initial Size of the heap (committed memory size)
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes -- Hdl to heap
|
|
Error status codes --
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
DWORD Error;
|
|
HANDLE HeapHdl;
|
|
|
|
HeapHdl = HeapCreate(
|
|
Options,
|
|
InitSize,
|
|
0 //limited only by available memory
|
|
);
|
|
|
|
|
|
if (HeapHdl == NULL)
|
|
{
|
|
Error = GetLastError();
|
|
DBGPRINT0(HEAP, "Cant create heap\n");
|
|
WINSEVT_LOG_M(Error, WINS_EVT_CANT_CREATE_HEAP);
|
|
WINS_RAISE_EXC_M(WINS_EXC_HEAP_CREATE_ERR);
|
|
}
|
|
|
|
#ifdef WINSDBG
|
|
IF_DBG(HEAP_CNTRS)
|
|
{
|
|
DBGPRINT1(HEAP_CRDL, "HeapCreate: HeapHandle = (%p)\n", HeapHdl);
|
|
EnterCriticalSection(&NmsHeapCrtSec);
|
|
NmsHeapCreate++;
|
|
LeaveCriticalSection(&NmsHeapCrtSec);
|
|
}
|
|
#endif
|
|
return(HeapHdl);
|
|
|
|
}
|
|
|
|
VOID
|
|
WinsMscHeapDestroy(
|
|
HANDLE HeapHdl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This is a wrapper for the HeapDestroy function
|
|
|
|
Arguments:
|
|
HeapHdl - Handle to heap to destroy
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
WrapUp() in nms.c
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
{
|
|
BOOL fRetVal;
|
|
fRetVal = HeapDestroy(HeapHdl);
|
|
|
|
ASSERT(fRetVal);
|
|
#ifdef WINSDBG
|
|
if (!fRetVal)
|
|
{
|
|
DBGPRINT1(ERR, "HeapDestroy: FAILED -- HeapHandle used = (%p)\n", HeapHdl);
|
|
}
|
|
else
|
|
{
|
|
IF_DBG(HEAP_CNTRS)
|
|
{
|
|
if (HeapHdl == CommUdpBuffHeapHdl)
|
|
{
|
|
DBGPRINT0(HEAP_CRDL, "Udp Buff heap\n");
|
|
} else if (HeapHdl == CommAssocDlgHeapHdl)
|
|
{
|
|
DBGPRINT0(HEAP_CRDL, "Dlg Buff heap\n");
|
|
} else if (HeapHdl == GenBuffHeapHdl)
|
|
{
|
|
DBGPRINT0(HEAP_CRDL, "Gen Buff heap\n");
|
|
} else if (HeapHdl == QueBuffHeapHdl)
|
|
{
|
|
DBGPRINT0(HEAP_CRDL, "Que Buff heap\n");
|
|
} else if (HeapHdl == NmsChlHeapHdl)
|
|
{
|
|
DBGPRINT0(HEAP_CRDL, "Chl Buff heap\n");
|
|
} else if (HeapHdl == CommAssocAssocHeapHdl)
|
|
{
|
|
DBGPRINT0(HEAP_CRDL, "Assoc Buff heap\n");
|
|
} else if (HeapHdl == RplWrkItmHeapHdl)
|
|
{
|
|
DBGPRINT0(HEAP_CRDL, "Rpl Work Item heap\n");
|
|
} else if (HeapHdl == NmsRpcHeapHdl)
|
|
{
|
|
DBGPRINT0(HEAP_CRDL, "Rpc Work Item heap\n");
|
|
} else if (HeapHdl == WinsTmmHeapHdl)
|
|
{
|
|
DBGPRINT0(HEAP_CRDL, "Tmm Work Item heap\n");
|
|
} else
|
|
{
|
|
static DWORD sAdjust = 0;
|
|
DBGPRINT0(HEAP_CRDL, "Catchall Work Item heap\n");
|
|
EnterCriticalSection(&NmsHeapCrtSec);
|
|
if (((NmsHeapCreate - NmsHeapDestroy) == 12) && (NmsCatchAllHeapAlloc > (NmsCatchAllHeapFree + sAdjust)))
|
|
{
|
|
PWINSTHD_TLS_T pTls;
|
|
pTls = TlsGetValue(WinsTlsIndex);
|
|
if (pTls == NULL)
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscHeapDestroy: Could not get TLS. GetLastError() = (%d)\n", GetLastError());
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT4(ERR, "WinsMscHeapDestroy: %s thd noticed a mismatch between allocs (%d) and frees (%d). Free count was adjusted by (%d)\n", pTls->ThdName, NmsCatchAllHeapAlloc, NmsCatchAllHeapFree, sAdjust);
|
|
sAdjust = NmsCatchAllHeapAlloc - NmsCatchAllHeapFree;
|
|
//system("net send pradeepb MISMATCH");
|
|
}
|
|
}
|
|
LeaveCriticalSection(&NmsHeapCrtSec);
|
|
}
|
|
|
|
DBGPRINT1(HEAP_CRDL, "HeapDestroy: HeapHandle = (%p)\n", HeapHdl);
|
|
EnterCriticalSection(&NmsHeapCrtSec);
|
|
NmsHeapDestroy++;
|
|
LeaveCriticalSection(&NmsHeapCrtSec);
|
|
}
|
|
}
|
|
#endif
|
|
return;
|
|
} //WinsMscHeapDestroy
|
|
|
|
|
|
VOID
|
|
WinsMscTermThd(
|
|
IN STATUS ExitStatus,
|
|
IN DWORD DbSessionExistent
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is called to terminate the thread.
|
|
The function does the necessary cleanup and exit.
|
|
|
|
Arguments:
|
|
ExitStatus - Status to exit with
|
|
DbSessionExistent - indicates whether DB session is existent
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
Thread is exited
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
DBGPRINT0(FLOW, "Enter: WinsMscTermThd\n");
|
|
|
|
/*
|
|
* End the database session if it exists. Decrement the count of
|
|
* threads. If it reaches 1, signal the main thread so that it can
|
|
* terminate itself. At the end terminate yourself.
|
|
*
|
|
*/
|
|
|
|
//
|
|
// I could enter the critical section after the if block but it is
|
|
// not important. This way, I get the prints in the right
|
|
// order.
|
|
//
|
|
EnterCriticalSection(&NmsTermCrtSec);
|
|
if (DbSessionExistent == WINS_DB_SESSION_EXISTS)
|
|
{
|
|
try {
|
|
if (ExitStatus == WINS_SUCCESS)
|
|
{
|
|
DBGPRINT0(FLOW, "Ending the db session for thd -- ");
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT0(ERR, "Ending the db session for thd -- ");
|
|
}
|
|
DBGPRINTNAME;
|
|
DBGPRINT0(FLOW,"\n");
|
|
|
|
//for now, we don't check the return value
|
|
NmsDbEndSession();
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER) {
|
|
DBGPRINTEXC("WinsMscTermThd");
|
|
}
|
|
} // end of if block
|
|
|
|
//
|
|
// If the total thread count after decrementing is 1, it means
|
|
// that after we exit from this thread, only the main thread
|
|
// will be left. Let us signal it to inform it of this situation.
|
|
//
|
|
// If the exit status is not success, it means that we have enetered
|
|
// this function as a result of a fatal error/exception. We need
|
|
// to signal the main thread to kick off the process termination
|
|
//
|
|
if ((--NmsTotalTrmThdCnt == 1) || (ExitStatus != WINS_SUCCESS))
|
|
{
|
|
DBGPRINT1(FLOW, "Signaling the main thread. Exit status = (%x)\n",
|
|
ExitStatus);
|
|
if (!SetEvent(NmsMainTermEvt))
|
|
{
|
|
WINSEVT_LOG_M(WINS_FATAL_ERR, WINS_EVT_CANT_SIGNAL_MAIN_THD);
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// If NmsTotalTrmThdCnt reached 1 above, then the main thread will
|
|
// exit invalidating the NmsTermCrtSec. We may get an INVALID_HANDLE
|
|
// exception. If we get it, it is ok.
|
|
//
|
|
try {
|
|
LeaveCriticalSection(&NmsTermCrtSec);
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER) {
|
|
if (GetExceptionCode() == STATUS_INVALID_HANDLE)
|
|
{
|
|
DBGPRINT1(FLOW, "WinsMscTermThd: LAST THREAD. NmsTotalTrmThdCnt = (%d)\n", NmsTotalTrmThdCnt);
|
|
}
|
|
else
|
|
{
|
|
WINS_RERAISE_EXC_M();
|
|
}
|
|
}
|
|
|
|
|
|
DBGPRINT0(FLOW, "EXITING the thread\n");
|
|
ExitThread(ExitStatus);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
WinsMscSignalHdl(
|
|
IN HANDLE Hdl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is a wrapper for the WIN32 SignalEvent function
|
|
|
|
Arguments:
|
|
Hdl - Handle to signal
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
{
|
|
|
|
if (!SetEvent(Hdl))
|
|
{
|
|
WINSEVT_LOG_M(WINS_FATAL_ERR, WINS_EVT_CANT_SIGNAL_HDL);
|
|
WINS_RAISE_EXC_M(WINS_EXC_FATAL_ERR);
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
VOID
|
|
WinsMscResetHdl(
|
|
IN HANDLE Hdl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is a wrapper for the WIN32 ResetEvent function
|
|
|
|
Arguments:
|
|
Hdl - Handle to signal
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
Change to a macro
|
|
--*/
|
|
{
|
|
|
|
if (!ResetEvent(Hdl))
|
|
{
|
|
WINSEVT_LOG_M(WINS_FATAL_ERR, WINS_EVT_CANT_RESET_HDL);
|
|
WINS_RAISE_EXC_M(WINS_EXC_FATAL_ERR);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
WinsMscCloseHdl (
|
|
HANDLE Hdl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is a wrapper for the WIN32 CloseHandle function
|
|
|
|
Arguments:
|
|
Hdl - Handle to close
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
change to a macro
|
|
--*/
|
|
|
|
{
|
|
|
|
BOOL fRet;
|
|
|
|
fRet = CloseHandle(Hdl);
|
|
if(!fRet)
|
|
{
|
|
DBGPRINT0(ERR, "WinsMscCloseHdl:Could not close handle\n");
|
|
WINS_RAISE_EXC_M(WINS_EXC_FATAL_ERR);
|
|
}
|
|
return;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
HANDLE
|
|
WinsMscCreateThd(
|
|
IN LPTHREAD_START_ROUTINE pThdInitFn,
|
|
IN LPVOID pParam,
|
|
OUT LPDWORD pThdId
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is a wrapper around the WIN32 Create Thread function
|
|
|
|
Arguments:
|
|
pThdInitFn - Thread startup function
|
|
pParam - Param to be passed to the startup function
|
|
pThdId - Thd Id
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
None
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
HANDLE ThdHdl; //Thread handle
|
|
DWORD Error;
|
|
|
|
/*
|
|
* Create a thread with no sec attributes (i.e. it will take the
|
|
* security attributes of the process), and default stack size
|
|
*/
|
|
ThdHdl = CreateThread(
|
|
NULL, /*no sec. attrbutes*/
|
|
0, /*default stack size*/
|
|
pThdInitFn,
|
|
pParam, /*arg*/
|
|
0, /*run it now*/
|
|
pThdId
|
|
);
|
|
|
|
if (ThdHdl == NULL)
|
|
{
|
|
Error = GetLastError();
|
|
|
|
DBGPRINT1(ERR, "WinsMscCreateThd: Can not create thread. Error = (%d)\n",
|
|
Error);
|
|
WINSEVT_LOG_M( Error, WINS_EVT_CANT_CREATE_THD);
|
|
WINS_RAISE_EXC_M(WINS_EXC_OUT_OF_RSRCS);
|
|
}
|
|
|
|
return(ThdHdl);
|
|
}
|
|
|
|
VOID
|
|
WinsMscSetThreadPriority(
|
|
HANDLE ThdHdl,
|
|
int PrLvl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is a wrapper for the "set thread priority" function
|
|
|
|
Arguments:
|
|
ThdHdl - Handle of thread whose priority needs to be set
|
|
PrLvl - New Prirority level
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
Error Handling:
|
|
|
|
|
|
Called by:
|
|
DoScavenging in nmsscv.c
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
BOOL fRet;
|
|
DWORD Error;
|
|
|
|
//
|
|
// Set the priority
|
|
//
|
|
fRet = SetThreadPriority(
|
|
ThdHdl,
|
|
PrLvl
|
|
);
|
|
if (!fRet)
|
|
{
|
|
Error = GetLastError();
|
|
DBGPRINT1(ERR, "NmsScvInit: Could not lower the priority of the scavanmger thread. Error = (%d)\n", Error);
|
|
WINSEVT_LOG_M(WINS_FAILURE, WINS_EVT_UNABLE_TO_CHG_PRIORITY);
|
|
WINS_RAISE_EXC_M(WINS_EXC_FAILURE);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
WinsMscOpenFile(
|
|
IN LPTCH pFileName,
|
|
IN DWORD StrType,
|
|
OUT LPHANDLE pFileHdl
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This is a wrapper for the WIN32 function to open an existing file
|
|
|
|
Arguments:
|
|
pFileName - Name of file
|
|
StrType - Indicates REG_EXPAND_SZ or REG_SZ
|
|
pFileHdl - handle to file if it could be opened
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes -- TRUE
|
|
Error status codes -- FALSE
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
DWORD Error;
|
|
SECURITY_ATTRIBUTES SecAtt;
|
|
TCHAR ExpandedFileName[WINS_MAX_FILENAME_SZ];
|
|
LPTCH pHoldFileName;
|
|
|
|
SecAtt.nLength = sizeof(SecAtt);
|
|
SecAtt.lpSecurityDescriptor = NULL; //use default security descriptor
|
|
SecAtt.bInheritHandle = FALSE; //actually don't care
|
|
|
|
|
|
if (!WinsMscGetName(StrType, pFileName, ExpandedFileName,
|
|
WINS_MAX_FILENAME_SZ, &pHoldFileName))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Open the file for reading and position self to start of the
|
|
// file
|
|
//
|
|
*pFileHdl = CreateFile(
|
|
pHoldFileName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
&SecAtt,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
0 //ignored ?? check
|
|
);
|
|
|
|
if (*pFileHdl == INVALID_HANDLE_VALUE)
|
|
{
|
|
WINSEVT_STRS_T EvtStr;
|
|
EvtStr.NoOfStrs = 1;
|
|
EvtStr.pStr[0] = pHoldFileName;
|
|
Error = GetLastError();
|
|
|
|
DBGPRINT1(ERR, "WinsMscOpenFile: Could not open the file (Error = %d)\n", Error);
|
|
FUTURES("Use WINSEVT_LOG_STR_M. Make sure it takes TCHAR instead of CHAR")
|
|
WINSEVT_LOG_STR_M(WINS_EVT_FILE_ERR, &EvtStr);
|
|
|
|
return(FALSE);
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
BOOL
|
|
WinsMscMapFile(
|
|
IN OUT PWINSPRS_FILE_INFO_T pFileInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function maps a file into allocated memory
|
|
|
|
Arguments:
|
|
FileHdl - Handle to the file
|
|
pFileInfo - Address of buffer into which the file was mapped
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes -- TRUE
|
|
Error status codes -- FALSE
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
Note: The function returns an error if te file is more than
|
|
2**32 bytes in size
|
|
--*/
|
|
|
|
{
|
|
DWORD HighWordOfFSz = 0;
|
|
DWORD Error;
|
|
DWORD cBytesRead;
|
|
BOOL fRetVal = FALSE;
|
|
try {
|
|
//
|
|
// get the size of the file so that we can allocate enough memory
|
|
// to read the file in
|
|
//
|
|
pFileInfo->FileSize = GetFileSize(pFileInfo->FileHdl, &HighWordOfFSz);
|
|
|
|
if (HighWordOfFSz)
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscMapFile: File too big. High word of size is (%x)\n", HighWordOfFSz);
|
|
WINSEVT_LOG_M(WINS_FAILURE, WINS_EVT_FILE_TOO_BIG);
|
|
fRetVal = FALSE;
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// if the low word of size is 0xFFFFFFFF either it is a valid
|
|
// size or it is an error. Check it
|
|
//
|
|
if (pFileInfo->FileSize == 0xFFFFFFFF)
|
|
{
|
|
Error = GetLastError();
|
|
if (Error != NO_ERROR)
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscMapFile: Error from GetFileSz = (%d)\n", Error);
|
|
WINSEVT_LOG_M(Error, WINS_EVT_FILE_ERR);
|
|
fRetVal = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Allocate a buffer to hold the contents of the file
|
|
//
|
|
WinsMscAlloc(
|
|
pFileInfo->FileSize,
|
|
&pFileInfo->pFileBuff
|
|
);
|
|
pFileInfo->pLimit = pFileInfo->pFileBuff +
|
|
pFileInfo->FileSize;
|
|
|
|
fRetVal = ReadFile(
|
|
pFileInfo->FileHdl,
|
|
pFileInfo->pFileBuff,
|
|
pFileInfo->FileSize,
|
|
&cBytesRead,
|
|
NULL
|
|
);
|
|
if (!fRetVal)
|
|
{
|
|
DBGPRINT1(ERR,
|
|
"WinsMscMapFile: Error reading file (Error = %d)\n", GetLastError());
|
|
WinsMscDealloc(pFileInfo->pFileBuff);
|
|
}
|
|
|
|
}
|
|
}
|
|
} // end of try ...
|
|
except(EXCEPTION_EXECUTE_HANDLER) {
|
|
DBGPRINTEXC("WinsMscParse");
|
|
}
|
|
//
|
|
// close the file
|
|
//
|
|
if (!CloseHandle(pFileInfo->FileHdl))
|
|
{
|
|
Error = GetLastError();
|
|
DBGPRINT1(ERR, "WinsMscMapFile: Could not close the file (Error = %d)\n", Error);
|
|
}
|
|
#ifdef WINSDBG
|
|
else
|
|
{
|
|
DBGPRINT0(DET, "WinsMscMapFile: Closed handle to open file\n");
|
|
}
|
|
#endif
|
|
|
|
return(fRetVal);
|
|
}
|
|
|
|
VOID
|
|
WinsMscLogEvtStrs(
|
|
LPBYTE pAscii,
|
|
DWORD Evt,
|
|
BOOL fInfo
|
|
)
|
|
|
|
{
|
|
|
|
WINSEVT_STRS_T EvtStrs;
|
|
WCHAR String[NMSDB_MAX_NAM_LEN];
|
|
EvtStrs.NoOfStrs = 1;
|
|
(VOID)WinsMscConvertAsciiStringToUnicode(
|
|
pAscii,
|
|
(LPBYTE)String,
|
|
NMSDB_MAX_NAM_LEN);
|
|
EvtStrs.pStr[0] = String;
|
|
if (!fInfo)
|
|
{
|
|
WINSEVT_LOG_STR_M(Evt, &EvtStrs);
|
|
}
|
|
else
|
|
{
|
|
WINSEVT_LOG_INFO_STR_D_M(Evt, &EvtStrs);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
WinsMscConvertUnicodeStringToAscii(
|
|
LPBYTE pUnicodeString,
|
|
LPBYTE pAsciiString,
|
|
DWORD MaxSz
|
|
)
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, (LPWSTR)pUnicodeString, -1,
|
|
pAsciiString, MaxSz, NULL,
|
|
NULL);
|
|
return;
|
|
}
|
|
VOID
|
|
WinsMscConvertAsciiStringToUnicode(
|
|
LPBYTE pAsciiString,
|
|
LPBYTE pUnicodeString,
|
|
DWORD MaxSz
|
|
)
|
|
{
|
|
MultiByteToWideChar(CP_ACP, 0, pAsciiString, -1,
|
|
(LPWSTR)pUnicodeString, MaxSz);
|
|
|
|
return;
|
|
}
|
|
|
|
BOOL
|
|
WinsMscGetName(
|
|
DWORD StrType,
|
|
LPTSTR pFileName,
|
|
LPTSTR pExpandedFileName,
|
|
DWORD ExpandedFileNameBuffLen,
|
|
LPTSTR *ppHoldFileName
|
|
)
|
|
{
|
|
DWORD ChInDest;
|
|
|
|
if (StrType == REG_EXPAND_SZ)
|
|
{
|
|
ChInDest = ExpandEnvironmentStrings(
|
|
pFileName,
|
|
pExpandedFileName,
|
|
ExpandedFileNameBuffLen);
|
|
|
|
if (ChInDest == 0)
|
|
{
|
|
WINSEVT_STRS_T EvtStr;
|
|
EvtStr.NoOfStrs = 1;
|
|
EvtStr.pStr[0] = pFileName;
|
|
DBGPRINT2(ERR, "WinsPrsDoStaticInit: Could not expand environment strings in (%s). Error is (%d)\n", pFileName, (DWORD)GetLastError());
|
|
WINSEVT_LOG_STR_M(WINS_EVT_FILE_ERR, &EvtStr);
|
|
return(FALSE);
|
|
}
|
|
//
|
|
// If only part of the expanded name could be stored, log error
|
|
//
|
|
if (ChInDest > ExpandedFileNameBuffLen)
|
|
{
|
|
WINSEVT_STRS_T EvtStr;
|
|
EvtStr.NoOfStrs = 1;
|
|
EvtStr.pStr[0] = pFileName;
|
|
DBGPRINT2(ERR, "WinsPrsDoStaticInit: File name after expansion is just too big (%d> 255).\nThe name to be expanded is (%s))", ChInDest, pFileName);
|
|
WINSEVT_LOG_STR_M(WINS_EVT_FILE_NAME_TOO_BIG, &EvtStr);
|
|
return(FALSE);
|
|
}
|
|
*ppHoldFileName = pExpandedFileName;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// There were no env. var. to expand
|
|
//
|
|
*ppHoldFileName = pFileName;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
VOID
|
|
WinsMscSendControlToSc(
|
|
DWORD ControlCode
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes --
|
|
Error status codes --
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
{
|
|
SERVICE_STATUS ServiceStatus;
|
|
BOOL fStatus;
|
|
SC_HANDLE ScHdl;
|
|
SC_HANDLE SvcHdl;
|
|
BOOL sCalled = FALSE;
|
|
|
|
try {
|
|
ScHdl = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
|
|
if (ScHdl == NULL)
|
|
{
|
|
|
|
DBGPRINT1(ERR, "WinsMscSendControlToSc: Error (%d) from OpenSCManager\n", GetLastError());
|
|
return;
|
|
}
|
|
|
|
SvcHdl = OpenService(ScHdl, WINS_SERVER, SERVICE_ALL_ACCESS);
|
|
if (SvcHdl == NULL)
|
|
{
|
|
|
|
DBGPRINT1(ERR, "WinsMscSendControlToSc: Error (%d) from OpenService\n", GetLastError());
|
|
goto CLOSE_SC;
|
|
}
|
|
|
|
fStatus = ControlService(SvcHdl, ControlCode, &ServiceStatus);
|
|
if (!fStatus)
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscSendControlToSc: Error (%d) from ControlService\n", GetLastError());
|
|
goto CLOSE_SERVICE;
|
|
}
|
|
else
|
|
{
|
|
DBGPRINT1(FLOW, "WinsMscSendControlToSc: Current State is (%d)\n",
|
|
ServiceStatus.dwCurrentState);
|
|
|
|
}
|
|
CLOSE_SERVICE:
|
|
fStatus = CloseServiceHandle(SvcHdl);
|
|
if (!fStatus)
|
|
{
|
|
|
|
DBGPRINT1(ERR, "WinsMscSendControlToSc: Error (%d) from CloseServiceHandle called for service\n", GetLastError());
|
|
}
|
|
|
|
CLOSE_SC:
|
|
fStatus = CloseServiceHandle(ScHdl);
|
|
if (!fStatus)
|
|
{
|
|
|
|
DBGPRINT1(ERR, "WinsMscSendControlToSc: Error (%d) from CloseServiceHandle called for SC\n", GetLastError());
|
|
}
|
|
}
|
|
except(EXCEPTION_EXECUTE_HANDLER) {
|
|
DBGPRINTEXC("WinsMscSendControlToSc");
|
|
}
|
|
return;
|
|
}
|
|
|
|
unsigned
|
|
WinsMscPutMsg(
|
|
unsigned usMsgNum,
|
|
... )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
Displays a message
|
|
|
|
Arguments:
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes --
|
|
Error status codes --
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
//unsigned msglen;
|
|
//va_list arglist;
|
|
//LPVOID pMsg;
|
|
//HINSTANCE hModule;
|
|
|
|
DBGENTER("WinsMscPutMsg\n");
|
|
|
|
//--ft: #106568 - WINS is a service and it shouldn't pop up message boxes.
|
|
//--this is mostly annoying for cluster: in case the db. is corrupted WINS is popping the message wnd
|
|
//--and does not terminate (at least the process wins.exe will be there for as long as the dialog is
|
|
//--on the screen. This will prevent the cluster from bringing up WINS resource on the same node.
|
|
//--In case of such a failure, the event being logged (in system log) should suffice.
|
|
//
|
|
//if ((hModule = LoadLibrary(TEXT("winsevnt.dll")))==NULL)
|
|
//{
|
|
// DBGPRINT1(ERR, "WinsMscPutMsg: LoadLibrary(\"winsevnt.dll\") failed with error = (%d)\n.", GetLastError());
|
|
// return 0;
|
|
//}
|
|
//va_start(arglist, usMsgNum);
|
|
//if (!(msglen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
// FORMAT_MESSAGE_FROM_HMODULE,
|
|
// hModule,
|
|
// usMsgNum,
|
|
// 0L, // Default country ID.
|
|
// (LPTSTR)&pMsg,
|
|
// 0,
|
|
// &arglist)))
|
|
//{
|
|
// DBGPRINT1(ERR, "WinsMscPutMsg: FormatMessage failed with error = (%d)\n",
|
|
// GetLastError());
|
|
//}
|
|
//else
|
|
//{
|
|
|
|
// DBGPRINT0(DET, "WinsMscPutMsg: Putting up the message box\n");
|
|
// if(MessageBoxEx(NULL, pMsg, WINS_SERVER_FULL_NAME, MB_SYSTEMMODAL | MB_OK | MB_SETFOREGROUND | MB_SERVICE_NOTIFICATION | MB_ICONSTOP, MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL)) == 0)
|
|
// {
|
|
// DBGPRINT1(ERR, "WinsMscPutMsg: MessageBoxEx failed with error = (%d)\n", GetLastError());
|
|
|
|
// }
|
|
// LocalFree(pMsg);
|
|
//}
|
|
|
|
//FreeLibrary(hModule);
|
|
|
|
WINSEVT_LOG_M(WINS_FAILURE, usMsgNum);
|
|
DBGLEAVE("WinsMscPutMsg\n");
|
|
|
|
//return(msglen);
|
|
return 0;
|
|
}
|
|
|
|
LPTSTR
|
|
WinsMscGetString(
|
|
DWORD StrId
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This routine retrieves string corresponding to strid from the resource file.
|
|
|
|
Arguments:
|
|
|
|
StrId - The unique id of the string.
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes --
|
|
Error status codes --
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
unsigned msglen;
|
|
va_list arglist;
|
|
LPTSTR pMsg = NULL;
|
|
HINSTANCE hModule;
|
|
|
|
DBGENTER("WinsMscPutMsg\n");
|
|
|
|
if ((hModule = LoadLibrary(TEXT("winsevnt.dll"))) == NULL)
|
|
{
|
|
DBGPRINT1(ERR, "LoadLibrary(\"winsevnt.dll\") failed with error = (%d)\n",
|
|
GetLastError());
|
|
return NULL;
|
|
}
|
|
|
|
if (!(msglen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
FORMAT_MESSAGE_FROM_HMODULE,
|
|
hModule,
|
|
StrId,
|
|
0L, // Default country ID.
|
|
(LPTSTR)&pMsg,
|
|
0,
|
|
NULL)))
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscPutMsg: FormatMessage failed with error = (%d)\n",
|
|
GetLastError());
|
|
}
|
|
|
|
FreeLibrary(hModule);
|
|
DBGLEAVE("WinsMscPutMsg\n");
|
|
|
|
return(pMsg);
|
|
}
|
|
|
|
VOID
|
|
WinsMscChkTermEvt(
|
|
#ifdef WINSDBG
|
|
WINS_CLIENT_E Client_e,
|
|
#endif
|
|
BOOL fTermTrans
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
Success status codes --
|
|
Error status codes --
|
|
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
Side Effects:
|
|
|
|
Comments:
|
|
Currently (8/6/94), fTermTrans is set only by the scavenger thread
|
|
--*/
|
|
|
|
{
|
|
DWORD fSignaled;
|
|
/*
|
|
* We may have been signaled by the main thread
|
|
* Check it.
|
|
*/
|
|
WinsMscWaitTimed(
|
|
NmsTermEvt,
|
|
0, //timeout is 0
|
|
&fSignaled
|
|
);
|
|
|
|
if (fSignaled)
|
|
{
|
|
DBGPRINT1(DET, "WinsCnfChkTermEvt: %s thread got termination signal\n", Client_e == WINS_E_RPLPULL ? "PULL" : "SCV");
|
|
|
|
if (fTermTrans)
|
|
{
|
|
NmsDbEndTransaction(); //ignore return code
|
|
}
|
|
WinsMscTermThd(WINS_SUCCESS, WINS_DB_SESSION_EXISTS);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
WinsMscDelFiles(
|
|
BOOL fMultiple,
|
|
LPCTSTR pFilePattern,
|
|
LPTSTR pFilePath
|
|
)
|
|
{
|
|
DWORD ErrCode;
|
|
#ifdef WINSDBG
|
|
BYTE FileNameAscii[WINS_MAX_FILENAME_SZ];
|
|
#endif
|
|
DBGENTER("WinsMscDelFiles\n");
|
|
if (fMultiple)
|
|
{
|
|
WIN32_FIND_DATA FileInfo;
|
|
HANDLE SearchHandle;
|
|
TCHAR FullFilePath[WINS_MAX_FILENAME_SZ];
|
|
|
|
//
|
|
// Construct the full file pattern
|
|
//
|
|
lstrcpy(FullFilePath, pFilePath);
|
|
lstrcat(FullFilePath, L"\\");
|
|
lstrcat(FullFilePath, pFilePattern);
|
|
|
|
SearchHandle = FindFirstFile(FullFilePath, &FileInfo);
|
|
if (SearchHandle == INVALID_HANDLE_VALUE)
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscDelFiles: FindFirstFile returned error = (%d)\n", GetLastError());
|
|
return;
|
|
}
|
|
|
|
do {
|
|
//
|
|
// construct the full file path
|
|
//
|
|
lstrcpy(FullFilePath, pFilePath);
|
|
lstrcat(FullFilePath, L"\\");
|
|
lstrcat(FullFilePath, FileInfo.cFileName);
|
|
|
|
#ifdef WINSDBG
|
|
WinsMscConvertUnicodeStringToAscii((LPBYTE)FullFilePath, FileNameAscii, sizeof(FileNameAscii));
|
|
DBGPRINT1(DET, "WinsMscDelFiles: Deleting %s ..\n", FileNameAscii);
|
|
|
|
#endif
|
|
if (!DeleteFile(FullFilePath))
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscDelFiles: DeleteFile returned error = (%d)\n", GetLastError());
|
|
FindClose(SearchHandle);
|
|
return;
|
|
}
|
|
|
|
} while(FindNextFile(SearchHandle, &FileInfo));
|
|
if ((ErrCode = GetLastError()) != ERROR_NO_MORE_FILES)
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscDelFiles: FindNextFile returned error = (%d)\n", ErrCode);
|
|
|
|
}
|
|
if (!FindClose(SearchHandle))
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscDelFiles: FindClose returned error = (%d)\n", ErrCode);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (!DeleteFile(pFilePattern))
|
|
{
|
|
DBGPRINT1(ERR, "WinsMscDelFiles: DeleteFile returned error = (%d)\n", GetLastError());
|
|
return;
|
|
}
|
|
}
|
|
|
|
DBGLEAVE("WinsMscDelFiles\n");
|
|
return;
|
|
}
|
|
|
|
VOID
|
|
WinsMscHeapReAlloc(
|
|
IN HANDLE HeapHdl,
|
|
IN DWORD BuffSize,
|
|
OUT LPVOID *ppRspBuff
|
|
)
|
|
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function is called to allocate memory.
|
|
|
|
|
|
Arguments:
|
|
BuffSize - Size of buffer to allocate
|
|
ppRspBuff - Buffer allocated
|
|
|
|
Externals Used:
|
|
None
|
|
|
|
|
|
Return Value:
|
|
|
|
None
|
|
Error Handling:
|
|
|
|
Called by:
|
|
|
|
NmsDbGetDataRecs, GetGroupMembers
|
|
Side Effects:
|
|
|
|
Comments:
|
|
None
|
|
--*/
|
|
|
|
{
|
|
|
|
*ppRspBuff = HeapReAlloc(
|
|
HeapHdl,
|
|
HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY,
|
|
*ppRspBuff,
|
|
BuffSize
|
|
);
|
|
DBGPRINT3(HEAP, "WinsMscHeapReAlloc: HeapHdl = (%p), pStartBuff = (%p), BuffSize = (%d)\n", HeapHdl, *ppRspBuff, BuffSize);
|
|
|
|
|
|
return;
|
|
}
|
|
|