LONG QueryKey(LPCWSTR lpSubKey, LPWSTR lpData, PLONG lpSize)
const
{
if (!IsValidHandle())
return ERROR_INVALID_HANDLE;
return RegQueryValueW(hKey(), lpSubKey, lpData, lpSize);
}
LONG SetKey(LPCWSTR lpSubKey, LPCWSTR lpData, DWORD dwSize)
const
{
if (!IsValidHandle())
return ERROR_INVALID_HANDLE;
return RegSetValueW(hKey(), lpSubKey, REG_SZ, lpData, dwSize);
}
ST_ErrorCode_t STEXTVIN_SelectVipOutput(
const STEXTVIN_Handle_t Handle,
const STEXTVIN_VipOutputSelection_t Selection
)
{
ST_ErrorCode_t ErrorCode = ST_NO_ERROR;
stextvin_Unit_t *Unit_p;
if (!IsValidHandle(Handle))
{
return(ST_ERROR_INVALID_HANDLE);
}
else
{
Unit_p = (stextvin_Unit_t *) Handle;
switch (Unit_p->Device_p->DeviceType)
{
case STEXTVIN_SAA7114 :
ErrorCode = EXTVIN_SelectVipOutput(I2cHandle_SAA7114,Selection);
break;
default :
ErrorCode = STEXTVIN_ERROR_FUNCTION_NOT_IMPLEMENTED;
break;
}
}
return(ErrorCode);
}
ST_ErrorCode_t STEXTVIN_GetVipStatus(STEXTVIN_Handle_t Handle,U8* Status_p)
{
ST_ErrorCode_t ErrorCode = ST_NO_ERROR;
stextvin_Unit_t *Unit_p;
if (!IsValidHandle(Handle))
{
return(ST_ERROR_INVALID_HANDLE);
}
else
{
Unit_p = (stextvin_Unit_t *) Handle;
switch (Unit_p->Device_p->DeviceType)
{
case STEXTVIN_SAA7114 :
ErrorCode = EXTVIN_GetSAA7114Status(I2cHandle_SAA7114,Status_p);
break;
case STEXTVIN_DB331 :
ErrorCode = EXTVIN_GetSAA7111Status(I2cHandle_SAA7111,Status_p);
break;
case STEXTVIN_STV2310 :
ErrorCode = EXTVIN_GetSTV2310Status(I2cHandle_STV2310,Status_p);
break;
default :
ErrorCode = STEXTVIN_ERROR_INVALID_INPUT_TYPE;
break;
}
}
return(ErrorCode);
}
/*******************************************************************************
Name : STEXTVIN_WriteI2C
Description : Write I2C register.
Parameters : I2C Handle, Adress and Value
Assumptions :
Limitations :
Returns : ST_ErrorCode_t
*******************************************************************************/
ST_ErrorCode_t STEXTVIN_WriteI2C(const STEXTVIN_Handle_t Handle, const U8 Adress, const U8 Value)
{
ST_ErrorCode_t ErrorCode = ST_NO_ERROR;
stextvin_Unit_t *Unit_p;
if (!IsValidHandle(Handle))
{
return(ST_ERROR_INVALID_HANDLE);
}
else
{
Unit_p = (stextvin_Unit_t *) Handle;
switch (Unit_p->Device_p->DeviceType)
{
case STEXTVIN_SAA7114 :
ErrorCode = EXTVIN_WriteI2C(I2cHandle_SAA7114, Adress, Value);
break;
case STEXTVIN_TDA8752 :
ErrorCode = EXTVIN_WriteI2C(I2cHandle_TDA8752, Adress, Value);
break;
case STEXTVIN_STV2310 :
ErrorCode = EXTVIN_WriteI2C(I2cHandle_STV2310, Adress, Value);
break;
default :
ErrorCode = STEXTVIN_ERROR_FUNCTION_NOT_IMPLEMENTED;
break;
}
}
return(ErrorCode);
}
static DWORD GetParentProcessId()
{
DWORD dwParentProcessId = 0;
HANDLE hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
if ( IsValidHandle( hSnapshot ) )
{
PROCESSENTRY32 pe;
BOOL fSuccess;
ZeroMemory( &pe, sizeof(pe) );
pe.dwSize = sizeof(pe);
fSuccess = Process32First( hSnapshot, &pe );
while( fSuccess )
{
if ( GetCurrentProcessId() == pe.th32ProcessID )
{
dwParentProcessId = pe.th32ParentProcessID;
break;
}
fSuccess = Process32Next( hSnapshot, &pe );
}
CloseHandle( hSnapshot );
}
return dwParentProcessId;
}
ST_ErrorCode_t STEXTVIN_SetAdcInputFormat(
const STEXTVIN_Handle_t Handle,
const STEXTVIN_AdcInputFormat_t Format
)
{
ST_ErrorCode_t ErrorCode = ST_NO_ERROR;
stextvin_Unit_t *Unit_p;
if (!IsValidHandle(Handle))
{
return(ST_ERROR_INVALID_HANDLE);
}
else
{
Unit_p = (stextvin_Unit_t *) Handle;
switch (Unit_p->Device_p->DeviceType)
{
case STEXTVIN_TDA8752 :
ErrorCode = EXTVIN_SetAdcInputFormat(I2cHandle_TDA8752,Format);
break;
default :
ErrorCode = STEXTVIN_ERROR_INVALID_STANDARD_TYPE;
break;
}
}
return(ErrorCode);
}
BOOL
CNdasEventSubscriber::
RemoveCallback(HNDASEVENTCALLBACK hCallback)
{
if (!IsValidHandle(hCallback)) {
::SetLastError(NDASUSER_ERROR_INVALID_EVENT_CALLBACK_HANDLE);
return FALSE;
}
::EnterCriticalSection(&m_cs);
size_t i = (size_t)hCallback - (size_t)HNDASEVTCB_BASE;
m_CallbackData[i].EventProc = NULL;
m_CallbackData[i].lpContext = NULL;
--m_cRef;
::LeaveCriticalSection(&m_cs);
if (0 == m_cRef) {
::SetEvent(m_hThreadStopEvent);
::WaitForSingleObject(m_hThread, 10*1000);
::CloseHandle(m_hThread);
m_hThread = INVALID_HANDLE_VALUE;
}
return TRUE;
}
/*****************************************************************************
* CKsFilter::Instantiate()
*****************************************************************************
*//*!
* @brief
* Instantiates the filter.
*/
HRESULT
CKsFilter::
Instantiate
( void
)
{
HRESULT hr = S_OK;
m_Handle = CreateFile
(
m_SymbolicLink,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL
);
if (!IsValidHandle(m_Handle))
{
hr = E_FAIL;
}
if (FAILED(hr))
{
DWORD w32Error = GetLastError();
_DbgPrintF(DEBUGLVL_ERROR,("[CKsFilter::Instantiate] - CreateFile failed for device %s. ErrorCode = 0x%08x", m_SymbolicLink, w32Error));
}
return hr;
}
LONG DeleteValue(LPCWSTR lpValueName)
const
{
if (!IsValidHandle())
return ERROR_INVALID_HANDLE;
return RegDeleteValueW(hKey(), lpValueName);
}
LONG SetValue(LPCWSTR lpValueName = NULL, const LPVOID lpData = NULL,
DWORD dwSize = 0, DWORD dwType = REG_BINARY)
const
{
if (!IsValidHandle())
return ERROR_INVALID_HANDLE;
return RegSetValueExW(hKey(), lpValueName, NULL, dwType,
(CONST LPBYTE)lpData, dwSize);
}
LONG QueryValue(LPCWSTR lpValueName = NULL, LPVOID lpData = NULL,
LPDWORD lpSize = 0, LPDWORD lpType = NULL)
const
{
if (!IsValidHandle())
return ERROR_INVALID_HANDLE;
return RegQueryValueExW(hKey(), lpValueName, NULL, lpType, (LPBYTE)lpData,
lpSize);
}
bool ReCreate(LPWSAPROTOCOL_INFO lpProtocolInfo = NULL,
GROUP g = 0,
DWORD dwFlags = 0)
{
Close();
hObject = (HANDLE)WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP,
lpProtocolInfo, g, dwFlags);
return IsValidHandle();
}
void * BSScriptObject::Resolve(UInt32 typeID) const
{
void *result = nullptr;
VMHandle handle = GetHandle();
auto policy = ms_handlePolicy;
if (policy->IsType(typeID, handle) && policy->IsValidHandle(handle))
result = policy->Resolve(typeID, handle);
return result;
}
Mutex::Mutex(LPCWSTR lpName, BOOL bInheritanceHandle, DWORD dwDesiredAccess)
{
m_hHandle = ::OpenMutex(dwDesiredAccess, bInheritanceHandle, lpName);
if (IsValidHandle(m_hHandle))
{
m_dwStatus = NO_ERROR;
}
else
{
m_dwStatus = GetLastError();
}
}
/*****************************************************************************
* CKsPin::ClosePin()
*****************************************************************************
*//*!
* @brief
* Closes the pin.
*/
VOID
CKsPin::
ClosePin
( void
)
{
if (IsValidHandle(m_Handle))
{
SetState(KSSTATE_STOP);
SafeCloseHandle(m_Handle);
}
}
static DWORD WINAPI ParentMonitorThreadProc( LPVOID lpParam )
{
DWORD_PTR dwParentProcessId = (DWORD_PTR)lpParam;
HANDLE hParentProcess = OpenProcess( SYNCHRONIZE, FALSE, dwParentProcessId );
if ( IsValidHandle( hParentProcess ) )
{
if ( WAIT_OBJECT_0 == WaitForSingleObject( hParentProcess, INFINITE ) )
{
TerminateProcess( GetCurrentProcess(), 0 );
}
CloseHandle( hParentProcess );
}
return 0;
}
bool Close()
{
if (!IsValidHandle())
return true;
if (shutdown(Socket(), 0x01) == 0)
{
shutdown(Socket(), 0x00);
closesocket(Socket());
hObject = INVALID_HANDLE_VALUE;
return true;
}
else
return WKernelObject::Close();
}
BOOL CKsIrpTarget::SafeCloseHandle(HANDLE &handle)
{
TRACE_ENTER();
BOOL bRet;
bRet = TRUE;
if (IsValidHandle(handle))
{
bRet = CloseHandle(handle);
handle = INVALID_HANDLE_VALUE;
}
TRACE_LEAVE();
return bRet;
}
int CTwain::LoadSourceManager(void)
{
USES_CONVERSION;
OFSTRUCT of;
if (nState >= SOURCE_MANAGER_LOADED) {
return TRUE; // SM already loaded
}
TCHAR szSM[MAX_PATH];
GetWindowsDirectory(szSM, MAX_PATH);
if (szSM[_tcsclen(szSM)-1] != '\\')
{
_tcscat_s(szSM, MAX_PATH, _T("\\"));
}
_tcscat_s(szSM, MAX_PATH, _T(DSM_FILENAME)); // could crash!
if (OpenFile(CT2CA(szSM), &of, OF_EXIST) != -1)
{
hSMLib = LoadLibrary(szSM);
}
else
{
if (bTrace) ATLTRACE(_T("TWAIN:LoadLibrary(%s) failed\n"), szSM);
hSMLib = NULL;
}
if (IsValidHandle(hSMLib)) {
pSM_Entry = (DSMENTRYPROC) GetProcAddress(hSMLib, DSM_ENTRYPOINT);
if (pSM_Entry) {
iAvailable = 1;
SetState(SOURCE_MANAGER_LOADED);
} else {
if (bTrace) ATLTRACE(_T("TWAIN:GetProcAddress() failed!!\n"));
FreeLibrary(hSMLib);
hSMLib = NULL;
}
} else {
pSM_Entry = NULL;
}
if (nState != SOURCE_MANAGER_LOADED && bTrace) ATLTRACE(_T("TWAIN:LoadSourceManager() failed.\n"));
return (nState >= SOURCE_MANAGER_LOADED);
} // LoadSourceManager
/// Closes the embedded handle if it is valid.
bool Close()
{
if (!IsValidHandle())
return false;
LONG lRegError = RegCloseKey(hKey());
if (lRegError == ERROR_SUCCESS)
{
hObject = INVALID_HANDLE_VALUE;
return true;
}
else
{
SetLastError(lRegError);
return false;
}
}
/*****************************************************************************
* CKsIrpTarget::SafeCloseHandle()
*****************************************************************************
*//*!
* @brief
* Safely closes a file handle.
*/
BOOL
CKsIrpTarget::
SafeCloseHandle
(
IN OUT HANDLE& Handle
)
{
BOOL Success = TRUE;
if (IsValidHandle(Handle))
{
Success = CloseHandle(Handle);
Handle = INVALID_HANDLE_VALUE;
}
return Success;
}
bool Connect(u_long ulAddress, u_short usPort)
const
{
// Is socket handle ok?
if (!IsValidHandle())
return false;
sockaddr_in addr = { 0 };
addr.sin_family = AF_INET;
addr.sin_port = usPort;
addr.sin_addr.s_addr = ulAddress;
if (connect((SOCKET)hObject, (sockaddr*)&addr, sizeof addr)
== SOCKET_ERROR)
return false;
return true;
}
Event::Event(BOOL bManualReset, BOOL bInitialState, LPCTSTR lpName, LPSECURITY_ATTRIBUTES lpEventAttributes)
{
m_hHandle = ::CreateEvent(lpEventAttributes, bManualReset, bInitialState, lpName);
if (IsValidHandle(m_hHandle))
{
if (lpName)
{
m_dwStatus = GetLastError();
}
else
{
m_dwStatus = NO_ERROR;
}
}
else
{
m_dwStatus = GetLastError();
}
}
Mutex::Mutex(BOOL bInitialOwner, LPCWSTR lpName, LPSECURITY_ATTRIBUTES lpMutexAttributes)
{
m_hHandle = ::CreateMutex(lpMutexAttributes, bInitialOwner, lpName);
if (IsValidHandle(m_hHandle))
{
if (lpName)
{
m_dwStatus = GetLastError();
}
else
{
m_dwStatus = NO_ERROR;
}
}
else
{
m_dwStatus = GetLastError();
}
}
Event::Event( LPCTSTR lpName, BOOL bInheritHandle, DWORD dwDesiredAccess)
{
m_hHandle = ::OpenEvent(dwDesiredAccess, bInheritHandle, lpName);
if (IsValidHandle(m_hHandle))
{
if (lpName)
{
m_dwStatus = GetLastError();
}
else
{
m_dwStatus = NO_ERROR;
}
}
else
{
m_dwStatus = GetLastError();
}
}
/*
--------------------------------------------------------------------------------
Close ...
(Standard instances management. Driver specific implementations should be put in Close() function.)
--------------------------------------------------------------------------------
*/
ST_ErrorCode_t STCC_Close(const STCC_Handle_t Handle)
{
stcc_Unit_t *Unit_p;
ST_ErrorCode_t ErrorCode = ST_NO_ERROR;
EnterCriticalSection();
if (!(FirstInitDone))
{
ErrorCode = ST_ERROR_INVALID_HANDLE;
}
else
{
if (!IsValidHandle(Handle))
{
ErrorCode = ST_ERROR_INVALID_HANDLE;
}
else
{
Unit_p = (stcc_Unit_t *) Handle;
/* API specific actions before closing */
ErrorCode = Close(Unit_p);
/* Close only if no errors */
if (ErrorCode == ST_NO_ERROR)
{
/* Un-register opened handle */
Unit_p->UnitValidity = 0;
CC_Trace(("Handle closed on device CC"));
}
} /* End handle valid */
} /* End FirstInitDone */
LeaveCriticalSection();
if(ErrorCode != ST_NO_ERROR)
{
CC_Defense(ErrorCode);
}
return(ErrorCode);
}
bool Listen(u_long ulAddress = INADDR_ANY, u_short usPort = 0,
int backlog = 0)
const
{
// Is socket handle ok?
if (!IsValidHandle())
return false;
sockaddr_in addr = { 0 };
addr.sin_family = AF_INET;
addr.sin_port = usPort;
addr.sin_addr.s_addr = ulAddress;
if (bind((SOCKET)hObject, (sockaddr*)&addr, sizeof addr) == SOCKET_ERROR)
return false;
if (listen((SOCKET)hObject, backlog) == SOCKET_ERROR)
return false;
return true;
}
size_t File::GetFileSize()
{
if( !IsValidHandle() )
return 0;
size_t Size = 0;
#if _WIN32 || _WIN64
LARGE_INTEGER LInt;
Memory::Memzero( &LInt, sizeof(LInt) );
GetFileSizeEx( m_file_handle, &LInt );
Size = (size_t) LInt.QuadPart;
//DWORD dwSize = GetFileSize( m_hFile, NULL );
#else
size_t Pos = ftell(m_file_handle);
fseek( m_file_handle, 0, SEEK_END );
Size = ftell(m_file_handle);
fseek( m_file_handle, Pos, SEEK_SET );
#endif
return Size;
}
ST_ErrorCode_t STEXTVIN_SelectVipInput(
const STEXTVIN_Handle_t Handle,
const STEXTVIN_VipInputSelection_t Selection
)
{
ST_ErrorCode_t ErrorCode = ST_NO_ERROR;
stextvin_Unit_t *Unit_p;
if (!IsValidHandle(Handle))
{
return(ST_ERROR_INVALID_HANDLE);
}
else
{
Unit_p = (stextvin_Unit_t *) Handle;
switch (Unit_p->Device_p->DeviceType)
{
case STEXTVIN_SAA7114 :
ErrorCode = EXTVIN_SelectSAA7114Input(I2cHandle_SAA7114,Selection);
break;
case STEXTVIN_DB331 :
ErrorCode = EXTVIN_SelectSAA7111Input(I2cHandle_SAA7111,Selection);
break;
case STEXTVIN_STV2310 :
ErrorCode = EXTVIN_SelectSTV2310Input(I2cHandle_STV2310,Selection);
break;
default :
ErrorCode = STEXTVIN_ERROR_INVALID_INPUT_TYPE;
break;
}
}
return(ErrorCode);
}
