HRESULT CNktDvProcessMemory::WriteStringW(__in LPVOID lpRemoteDest, __in_nz_opt LPCWSTR szSrcW,
__in SIZE_T nSrcLen, __in BOOL bWriteNulTerminator)
{
CNktAutoFastMutex cLock(&GetLockObject());
HRESULT hRes;
WCHAR chW;
if (lpRemoteDest == NULL || szSrcW == NULL)
return E_POINTER;
if (nSrcLen == NKT_SIZE_T_MAX)
nSrcLen = wcslen(szSrcW);
if (nSrcLen > 0)
{
hRes = WriteProtected((LPWSTR)lpRemoteDest, szSrcW, nSrcLen*sizeof(WCHAR));
if (FAILED(hRes))
return hRes;
}
if (bWriteNulTerminator != FALSE)
{
chW = 0;
hRes = WriteProtected((LPWSTR)lpRemoteDest+nSrcLen, &chW, sizeof(WCHAR));
if (FAILED(hRes))
return hRes;
}
return S_OK;
}
VOID CNktDvTransportEngine::InternalDisconnectAgent2(__inout CNktDvTransportEngine::CConnection *lpConn,
__in BOOL bCallCallback)
{
BOOL bDoRelease;
SIZE_T i, nCount;
//remove packets from dispatchers if any
nCount = cFixedDispatchersList.GetCount();
for (i=0; i<nCount; i++)
cFixedDispatchersList[i]->RemoveConnection(lpConn);
{
CNktAutoFastMutex cLock(&(sOneShotDispatchers.cMtx));
TNktLnkLst<CDispatcher>::Iterator it;
CDispatcher *lpDisp;
for (lpDisp=it.Begin(sOneShotDispatchers.cList); lpDisp!=NULL; lpDisp=it.Next())
lpDisp->RemoveConnection(lpConn);
}
//release?
bDoRelease = (lpConn->nState != XSTATE_Destroying) ? TRUE : FALSE;
//shutdown
lpConn->Shutdown();
//call callback
if (bCallCallback != FALSE && bDoRelease != FALSE)
{
CNktAutoFastMutexReverse cLockRev(this);
lpCallback->TEC_OnConnectionClosed(this, lpConn->dwPid);
}
//extra release for destroying
if (bDoRelease != FALSE)
lpConn->Release();
return;
}
// Reset
HRESULT COpcDaEnumItemWrapper::Reset()
{
COpcLock cLock(*this);
// check inner server.
if (m_ipUnknown == NULL)
{
return E_FAIL;
}
// fetch required interface.
IEnumOPCItemAttributes* ipInterface = NULL;
if (FAILED(m_ipUnknown->QueryInterface(IID_IEnumOPCItemAttributes, (void**)&ipInterface)))
{
return E_NOTIMPL;
}
// invoke method.
HRESULT hResult = ipInterface->Reset();
// release interface.
ipInterface->Release();
return hResult;
}
VOID CNktDvTransportEngine::CConnection::Shutdown()
{
BOOL bDiscardBuffers;
bDiscardBuffers = FALSE;
{
CNktAutoFastMutex cLock(this);
if (nState != XSTATE_Destroying)
{
//destroy pipe
if (hPipe != NULL)
{
::DisconnectNamedPipe(hPipe);
::CloseHandle(hPipe);
hPipe = NULL;
}
//set new state
nState = XSTATE_Destroying;
bDiscardBuffers = TRUE;
}
}
if (bDiscardBuffers != FALSE)
DiscardAllBuffers();
return;
}
HRESULT CNktDvStackTrace::GetNearestFunction(__deref_out CNktDvExportedFunction **lplpFunc,
__in SIZE_T nDepth)
{
HRESULT hRes;
if (lplpFunc == NULL)
return E_POINTER;
*lplpFunc = NULL;
if (nDepth >= NKT_DV_TMSG_ONHOOKCALLED_StackTraceDepth)
return E_INVALIDARG;
if (nStackTrace[nDepth] == 0)
return NKT_DVERR_NotFound;
{
CNktAutoFastMutex cLock(&GetLockObject());
hRes = InitExpFunc(nDepth);
if (FAILED(hRes))
return hRes;
if (cExpFunc[nDepth] == NULL)
return NKT_DVERR_NotFound;
*lplpFunc = cExpFunc[nDepth];
(*lplpFunc)->AddRef();
}
return S_OK;
}
// SetSize
void COpcThreadPool::SetSize(UINT uMinThreads, UINT uMaxThreads)
{
COpcLock cLock(*this);
m_uMinThreads = uMinThreads;
m_uMaxThreads = uMaxThreads;
}
HRESULT CNktDvTransportEngine::CConnection::SendReadPacket()
{
CNktDvTransportOverlapped *lpOvr;
DWORD dwReaded;
HRESULT hRes;
//prepare buffer
lpOvr = GetBuffer();
if (lpOvr == NULL)
return E_OUTOFMEMORY;
//do read
{
CNktAutoFastMutex cLock(this);
lpOvr->dwType = XTYPE_Read;
lpOvr->nOrder = NktInterlockedIncrement(&nNextReadOrder);
AddBufferToRwList(lpOvr);
hRes = (::ReadFile(hPipe, &(lpOvr->sMsg), sizeof(lpOvr->sMsg), &dwReaded, &(lpOvr->sOvr)) != FALSE)
? S_OK : NKT_HRESULT_FROM_LASTERROR();
}
if (FAILED(hRes) && hRes != NKT_HRESULT_FROM_WIN32(ERROR_IO_PENDING))
{
FreeBuffer(lpOvr);
return hRes;
}
AddRef();
NKT_DEBUGPRINTLNA(Nektra::dlTransport, ("%lu) TransportEngine[SendReadPacket]: Ovr=%IXh%s",
::GetTickCount(), lpOvr, (hRes != S_OK) ? " (pending)" : ""));
return S_OK;
}
HRESULT CNktDvTransportEngine::ConnectAgent(__in DWORD dwPid, __in DWORD dwTimeout)
{
CNktDvShutdownAutoLock cSdLock(&cShutdownMtx);
CNktDvAutoCancellableFastMutex cLock(this, &cShutdownMtx);
CConnection *lpConn;
HRESULT hRes;
if (cLock.IsLockHeld() == FALSE || cShutdownMtx.IsShuttingDown() != FALSE)
return NKT_DVERR_Cancelled;
if (cShutdownMtx.IsSystemActive() == FALSE)
return E_FAIL; //not initialized
if (dwPid == 0 || dwPid == dwMePid)
return E_INVALIDARG;
//check if connection already exists
{
CConnectionAutoRef cConnAutoRef(lpConn = FindConnectionAndAddRef(dwPid), FALSE);
if (lpConn != NULL)
return NKT_DVERR_AlreadyExists;
}
//----
lpConn = NKT_MEMMGR_NEW CConnection(this, dwPid);
if (lpConn == NULL)
return E_OUTOFMEMORY;
//create pipe
hRes = lpConn->Initialize(hIOCP, dwTimeout);
if (FAILED(hRes))
{
lpConn->Release();
return hRes;
}
//add to connection list
cConnList.PushTail(lpConn);
return S_OK;
}
HRESULT EMReadFrameInputPin::SetMediaType(const CMediaType *pmt)
{
CAutoLock cLock(m_pReceiveLock);
m_pDump->SetMediaType(pmt);
return CRenderedInputPin::SetMediaType(pmt);
}
HRESULT CNktHookInfoImpl::SendCustomMessage(__in my_ssize_t msgCode, __in my_ssize_t msgParam, __in VARIANT_BOOL sync,
__out my_ssize_t *pRetVal)
{
CNktSimpleLockNonReentrant cLock(&nLock);
HRESULT hRes;
if (nValid == 0)
{
hRes = E_FAIL;
}
else if (pRetVal == NULL)
{
hRes = E_POINTER;
}
else if (sCallTrampoline.fnSendCustomMessage == NULL)
{
*pRetVal = 0;
hRes = E_FAIL;
}
else
{
NKT_ASSERT(sCallTrampoline.lpInternal != NULL);
hRes = sCallTrampoline.fnSendCustomMessage(sCallTrampoline.lpInternal, (SIZE_T*)pRetVal, (SIZE_T)msgCode,
(SIZE_T)msgParam, Bool_From_VariantBool(sync));
}
if (FAILED(hRes) && pRetVal != NULL)
*pRetVal = 0;
return ::SetupErrorInfoAndReturn(IID_INktHookInfo, hRes);
}
HRESULT CNktDvTransportEngine::SendMsg(__in DWORD dwPid, __inout NKT_DV_TMSG_COMMON *lpMsg,
__in SIZE_T nMsgSize)
{
CNktDvShutdownAutoLock cSdLock(&cShutdownMtx);
CConnectionAutoRef cConnAutoRef;
CConnection *lpConn;
CNktDvTransportOverlapped *lpOvr;
HRESULT hRes;
if (lpMsg == NULL)
return E_POINTER;
if (nMsgSize < sizeof(NKT_DV_TMSG_COMMON) || nMsgSize > NKT_DV_TRANSPORT_MAX_DATA_SIZE)
return E_INVALIDARG;
{
CNktDvAutoCancellableFastMutex cLock(this, &cShutdownMtx);
if (cLock.IsLockHeld() == FALSE || cShutdownMtx.IsShuttingDown() != FALSE)
return NKT_DVERR_Cancelled;
if (cShutdownMtx.IsSystemActive() == FALSE)
return E_FAIL; //not initialized
//find connection
cConnAutoRef.Attach(lpConn = FindConnectionAndAddRef(dwPid), FALSE);
if (lpConn == NULL)
return NKT_DVERR_NotFound;
NKT_DEBUGPRINTLNA(Nektra::dlTransport, ("%lu) TransportEngine[SendMsg]: Pid=%lu, Code=%lu, Id=%lu",
::GetTickCount(), dwPid, lpMsg->dwMsgCode & (~NKT_DV_TMSG_CODE_CALLBACK),
lpMsg->dwMsgId & (~NKT_DV_TMSG_ID_CALLBACK)));
}
{
CNktAutoFastMutex cConnAutoLock(lpConn);
if (lpConn->nState != XSTATE_Connected)
return E_FAIL; //not initialized
//get a free buffer
lpOvr = lpConn->GetBuffer();
if (lpOvr == NULL)
return E_OUTOFMEMORY;
//fill buffer
nktMemCopy(lpOvr->sMsg.aBuf, lpMsg, nMsgSize);
//do write prepare
lpOvr->dwType = XTYPE_WriteRequest;
lpOvr->nOrder = NktInterlockedIncrement(&(lpConn->nNextWriteOrder));
lpOvr->dwWrittenBytes = (DWORD)nMsgSize;
lpConn->AddBufferToRwList(lpOvr);
hRes = S_OK;
if (::PostQueuedCompletionStatus(lpConn->hIocpCopy, 0, (ULONG_PTR)lpConn, &(lpOvr->sOvr)) == FALSE)
hRes = NKT_HRESULT_FROM_LASTERROR();
}
if (FAILED(hRes))
{
lpConn->FreeBuffer(lpOvr);
return hRes;
}
//done
lpConn->AddRef();
NKT_DEBUGPRINTLNA(Nektra::dlTransport, ("%lu) TransportEngine[SendMsg]: Pid=%lu, Ovr=%IXh",
::GetTickCount(), dwPid, lpOvr));
return S_OK;
}
VOID CClsIdIidList::RemoveAll()
{
CNktAutoFastMutex cLock(this);
NKT_FREE(lpList);
lpList = NULL;
nCount = nSize = 0;
return;
}
bool multiMutex::trylock(unsigned long key, size_t& nLock)
{
bool status(true);
namedLock *pLock(NULL);
if (pthread_mutex_lock(&controlMutex_))
throw std::runtime_error("multiMutex::lock: pthread_mutex_lock error return");
for (size_t n=0; n < N_locks_; ++n){
namedLock& cLock(vLock_[n]);
// Either find an already assigned named lock, or
// return the first available named lock.
if (key == cLock.key_){
// there already is a matching lock:
pLock = &cLock;
nLock = n;
break;
}
else
if ((NULL == pLock) && (static_cast<unsigned long>(NULL) == cLock.key_)){
// first available lock:
pLock = &cLock;
nLock = n;
}
}
if (NULL == pLock)
throw std::runtime_error("multiMutex::lock: no new lock available");
// This case should probably be a throw -- it will segfault next...
// Either there are fewer locks than threads, or a thread took a lock
// for another key and didn't give it back.
if (static_cast<unsigned long>(NULL) == pLock->key_)
pLock->key_ = key; // name the lock.
// note: this also will work with recursive mutexes:
++pLock->refCount_;
if (pthread_mutex_unlock(&controlMutex_))
throw std::runtime_error("multiMutex::lock: pthread_mutex_unlock error return");
// attempt to lock the mutex:
int N_STAT(0);
if ((N_STAT = pthread_mutex_trylock(&pLock->mutex_))){
if (N_STAT == EBUSY)
status = false; // mutex is locked
else
throw std::runtime_error("multiMutex::trylock: pthread_mutex_trylock error return");
}
else{
pLock->tid_ = pthread_self();
assert(pLock->tid_ != 0);
}
return status;
}
// Run
void COpcThreadPool::Run()
{
COpcLock cLock(*this);
do
{
// increment waiting thread count.
m_uWaitingThreads++;
cLock.Unlock();
// wait for message.
DWORD dwResult = WaitForSingleObject(m_hEvent, INFINITE);
cLock.Lock();
// decrement waiting thread count.
m_uWaitingThreads--;
// check for error or shutdown event.
if (m_hEvent == NULL || dwResult != WAIT_OBJECT_0)
{
break;
}
// check if the queue has already been cleared.
if (m_cQueue.GetCount() == 0)
{
ResetEvent(m_hEvent);
if (m_uWaitingThreads >= m_uMinThreads)
{
break;
}
continue;
}
// get next message.
COpcMessage* pMessage = m_cQueue.RemoveHead();
// release queue lock - process message could hang.
cLock.Unlock();
// process message.
pMessage->Process();
delete pMessage;
// re-acquire lock.
cLock.Lock();
}
while (m_uWaitingThreads < m_uMinThreads);
// decrement thread count.
m_uTotalThreads--;
}
void
CPuLog::Uninit()
{
CSmartLock cLock(static_cast<CCriticalClient*>(this));
//
if (NULL != m_pfpFile)
{
fclose(m_pfpFile);
m_pfpFile = NULL;
}
}
void NetServer::OnUpdateAccept()
{
mutex::scoped_lock cLock(m_cClientListMutex);
size_t nSize = m_vecAcceptSocket.size();
for(size_t i = 0; i < nSize; ++i)
{
(m_pOnEnter)(*m_vecAcceptSocket[i]);
m_vecUsedSocket.push_back(m_vecAcceptSocket[i]);
}
m_vecAcceptSocket.clear();
cLock.unlock();
}
VOID CNktDvTransportEngine::DisconnectAgent(__in DWORD dwPid)
{
CNktDvShutdownAutoLock cSdLock(&cShutdownMtx);
CNktDvAutoCancellableFastMutex cLock(this, &cShutdownMtx);
if (cLock.IsLockHeld() == FALSE || cShutdownMtx.IsShuttingDown() != FALSE)
return;
if (cShutdownMtx.IsSystemActive() == FALSE)
return; //not initialized
InternalDisconnectAgent(dwPid);
return;
}
HRESULT CClsIdIidList::Remove(__in REFCLSID sClsId, __in REFIID sIid)
{
CNktAutoFastMutex cLock(this);
SIZE_T nIndex;
if ((nIndex = Find(sClsId, sIid)) != NKT_SIZE_T_MAX)
{
memmove(lpList+nIndex, lpList+(nIndex+1), (nCount-nIndex-1)*sizeof(ITEM));
nCount--;
return S_OK;
}
return S_FALSE;
}
// Stop
void COpcThreadPool::Stop()
{
COpcLock cLock(*this);
// delete any remaining messages.
while (m_cQueue.GetCount() > 0)
{
COpcMessage* pMessage = m_cQueue.RemoveHead();
delete pMessage;
}
// close handle.
CloseHandle(m_hEvent);
m_hEvent = NULL;
}
HANDLE CNktDvProcessMemory::GetReadAccessHandle()
{
if (hProc[0] == NULL)
{
CNktAutoFastMutex cLock(&GetLockObject());
TNktComPtr<CNktDvProcessHandlesMgr> cPhMgr;
if (hProc[0] == NULL)
{
if (SUCCEEDED(CNktDvProcessHandlesMgr::Get(&cPhMgr)))
hProc[0] = cPhMgr->GetHandle(dwPid, NKT_ACCESS_READ);
}
}
return hProc[0];
}
HRESULT CNktHookInfoImpl::get_Address(__deref_out my_ssize_t *pVal)
{
CNktSimpleLockNonReentrant cLock(&nLock);
if (pVal == NULL)
return ::SetupErrorInfoAndReturn(IID_INktHookInfo, E_POINTER);
if (nValid == 0)
{
*pVal = 0;
return ::SetupErrorInfoAndReturn(IID_INktHookInfo, E_FAIL);
}
//get "address"
*pVal = (my_ssize_t)nAddress;
return ::SetupErrorInfoAndReturn(IID_INktHookInfo, S_OK);
}
HRESULT CNktDvModulesEnumerator::MarkModuleAsDirty(__in HINSTANCE hDll)
{
CNktAutoFastMutex cLock(&GetLockObject());
SIZE_T i, nCount;
nCount = sDirtyModules.aList.GetCount();
for (i=0; i<nCount; i++)
{
if (sDirtyModules.aList[i] == hDll)
return S_OK;
}
if (sDirtyModules.aList.AddElement(hDll) == FALSE)
return E_OUTOFMEMORY;
NktInterlockedExchange(&(sDirtyModules.nDoCheck), 1);
return S_OK;
}
VOID CNktDvTransportEngine::CDispatcher::RemoveConnection(__in CNktDvTransportEngine::CConnection *lpConn)
{
CNktAutoFastMutex cLock(this);
TNktLnkLst<CNktDvTransportOverlapped>::Iterator it;
CNktDvTransportOverlapped *lpOvr;
for (lpOvr=it.Begin(cQueueBufferList); lpOvr!=NULL; lpOvr=it.Next())
{
if (lpOvr->sEngineInternals.lpConn == lpConn)
{
lpConn->FreeBuffer(lpOvr);
lpConn->Release();
}
}
return;
}
HANDLE CNktDvProcessMemory::GetWriteAccessHandle()
{
if (hProc[1] == NULL)
{
CNktAutoFastMutex cLock(&GetLockObject());
TNktComPtr<CNktDvProcessHandlesMgr> cPhMgr;
if (hProc[1] == NULL && bWriteAccessChecked == FALSE)
{
bWriteAccessChecked = TRUE;
if (SUCCEEDED(CNktDvProcessHandlesMgr::Get(&cPhMgr)))
hProc[1] = cPhMgr->GetHandle(dwPid, NKT_ACCESS_WRITE);
}
}
return hProc[1];
}
// Clone
HRESULT COpcDaEnumItemWrapper::Clone(IEnumOPCItemAttributes** ppEnum)
{
COpcLock cLock(*this);
// check for invalid arguments.
if (ppEnum == NULL)
{
return E_INVALIDARG;
}
// check inner server.
if (m_ipUnknown == NULL)
{
return E_FAIL;
}
// fetch required interface.
IEnumOPCItemAttributes* ipInterface = NULL;
if (FAILED(m_ipUnknown->QueryInterface(IID_IEnumOPCItemAttributes, (void**)&ipInterface)))
{
return E_NOTIMPL;
}
// invoke method.
IEnumOPCItemAttributes* ipEnum = NULL;
HRESULT hResult = ipInterface->Clone(&ipEnum);
// release interface.
ipInterface->Release();
// create wrapper.
COpcDaEnumItemWrapper* pEnum = new COpcDaEnumItemWrapper(ipEnum);
// release local reference.
ipEnum->Release();
// query for interface.
hResult = pEnum->QueryInterface(IID_IEnumOPCItemAttributes, (void**)ppEnum);
// release local reference.
pEnum->Release();
return hResult;
}
HRESULT CNktHookInfoImpl::CurrentProcess(__deref_out INktProcess **ppProc)
{
CNktSimpleLockNonReentrant cLock(&nLock);
TNktComPtr<INktProcess> cIProc;
HRESULT hRes;
if (ppProc == NULL)
return ::SetupErrorInfoAndReturn(IID_INktHookInfo, E_POINTER);
*ppProc = NULL;
if (nValid == 0)
return ::SetupErrorInfoAndReturn(IID_INktHookInfo, E_FAIL);
//get outer interface
hRes = GetComLinkHelper<CNktProcessImpl,INktProcess,CNktDvProcess>(&cIProc, cProc, InterfaceItemGetCookies());
//done (don't create dummy interface on error)
*ppProc = cIProc.Detach();
return ::SetupErrorInfoAndReturn(IID_INktHookInfo, hRes);
}
CNktDvDbObjectNoRef* CNktDvExportedFunction::GetFunctionEntry() const
{
if (nDbObjInitialized == 0)
{
CNktDvExportedFunction *lpThis = const_cast<CNktDvExportedFunction*>(this);
{
CNktAutoFastMutex cLock(&(lpThis->GetLockObject()));
if (nDbObjInitialized == 0)
{
//search the DbObject in the database the first time it is required
lpThis->lpDbObj = (cDvDB != NULL) ? (cDvDB->FindFunctionByName(GetName())) : NULL;
NktInterlockedExchange(&(lpThis->nDbObjInitialized), 1);
}
}
}
return lpDbObj;
}
LPWSTR CNktDvStackTrace::GetNearestSymbol(__in SIZE_T nDepth) const
{
CNktDvStackTrace *lpThis = const_cast<CNktDvStackTrace*>(this);
LPWSTR sW;
sW = NULL;
if (nDepth < NKT_DV_TMSG_ONHOOKCALLED_StackTraceDepth &&
nStackTrace[nDepth] != 0)
{
CNktAutoFastMutex cLock(&(lpThis->GetLockObject()));
LPWSTR szCopyW;
SIZE_T nLen;
HRESULT hRes;
if (szSymbolW[nDepth] == NULL)
{
hRes = lpThis->InitExpFunc(nDepth);
if (FAILED(hRes))
return NULL;
if (cExpFunc[nDepth] != NULL)
{
sW = cExpFunc[nDepth]->GetCompleteName();
}
else if (cMod[nDepth] != NULL)
{
sW = cMod[nDepth]->GetFileName();
}
else
{
sW = L"";
}
nLen = wcslen(sW) + 1;
szCopyW = (LPWSTR)nktMemMalloc(nLen * sizeof(WCHAR));
if (szCopyW == NULL)
return NULL;
nktMemCopy(szCopyW, sW, nLen * sizeof(WCHAR));
_ReadWriteBarrier();
lpThis->szSymbolW[nDepth] = szCopyW;
_ReadWriteBarrier();
}
sW = szSymbolW[nDepth];
}
return sW;
}
BOOL
CPuLog::Init()
{
if (FALSE == CCriticalClient::IsActive())
{
return FALSE;
}
//
CSmartLock cLock(static_cast<CCriticalClient*>(this));
//
if (NULL != m_pfpFile)
{
return TRUE;
}
//
char achLogFile[MAX_PATH + 1];
char achBackupLogFile[MAX_PATH + 1];
GetPuCfgInstance().GetLogFileName(achLogFile);
GetPuCfgInstance().GetBackupLogFileName(achBackupLogFile);
//
if ('\0' == achLogFile[0] || '\0' == achBackupLogFile[0])
{
return FALSE;
}
//
remove(achBackupLogFile);
rename(achLogFile, achBackupLogFile);
//
m_pfpFile = fopen(achLogFile, "a");
if (NULL == m_pfpFile)
{
return FALSE;
}
return TRUE;
}
// Next
HRESULT COpcDaEnumItemWrapper::Next(
ULONG celt,
OPCITEMATTRIBUTES** ppItemArray,
ULONG* pceltFetched
)
{
COpcLock cLock(*this);
// check inner server.
if (m_ipUnknown == NULL)
{
return E_FAIL;
}
// fetch required interface.
IEnumOPCItemAttributes* ipInterface = NULL;
if (FAILED(m_ipUnknown->QueryInterface(IID_IEnumOPCItemAttributes, (void**)&ipInterface)))
{
return E_NOTIMPL;
}
// invoke method.
HRESULT hResult = ipInterface->Next(
celt,
ppItemArray,
pceltFetched
);
// release interface.
ipInterface->Release();
if (hResult == S_OK)
{
if (celt > 0 && (*ppItemArray == NULL || *pceltFetched == 0))
{
return S_FALSE;
}
}
return hResult;
}
