DWORD DynamicQueue::EnQueue(HANDLE Key)
{
BidxScopeAutoSNI1( SNIAPI_TAG _T("Key: %p{HANDLE}\n"), Key );
QueueItem *pNew;
if(m_pFree)
{
pNew = m_pFree;
m_pFree = m_pFree->pNext;
}
else
{
pNew = NewNoX(gpmo) QueueItem;
if( pNew == NULL )
{
SNI_SET_LAST_ERROR( INVALID_PROV, SNIE_4, ERROR_OUTOFMEMORY );
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), ERROR_OUTOFMEMORY);
return ERROR_OUTOFMEMORY;
}
}
pNew->pNext = NULL;
pNew->Key = Key;
*m_ppTail = pNew;
m_ppTail=&pNew->pNext;
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), ERROR_SUCCESS);
return ERROR_SUCCESS;
}
DWORD
Sm::Initialize( PSNI_PROVIDER_INFO pInfo )
{
BidxScopeAutoSNI1( SNIAPI_TAG _T("pInfo: %p{PSNI_PROVIDER_INFO}\n"), pInfo );
DWORD dwError = ERROR_SUCCESS;
// Fill all these up
pInfo->fBaseProv = TRUE;
pInfo->Size = 0;
pInfo->Offset = 0;
pInfo->ProvNum = SM_PROV;
pInfo->fInitialized = TRUE;
#ifdef SNI_BASED_CLIENT
SNI_PROVIDER_INFO Info;
if( ERROR_SUCCESS != (dwError = Sm_Shiloh::Initialize(&Info)) )
{
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), dwError);
return dwError;
}
#endif
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), ERROR_SUCCESS);
return ERROR_SUCCESS;
}
Sm_Shiloh::Sm_Shiloh(SNI_Conn * pConn) : SNI_Provider(pConn)
{
BidxScopeAutoSNI1( SNIAPI_TAG _T( "pConn: %p{SNI_Conn*}\n"), pConn );
m_pConnObj = 0;
m_Prot = SM_PROV;
BidObtainItemID2A( &m_iBidId, SNI_ID_TAG "%p{.} created by %u#{SNI_Conn}",
this, pConn->GetBidId() );
}
DWORD Sm_Shiloh::TerminateListener(HANDLE hListener)
{
BidxScopeAutoSNI1( SNIAPI_TAG _T( "hListener: %p{HANDLE}\n"), hListener );
SNI_SET_LAST_ERROR( SM_PROV, SNIE_15, ERROR_FAIL );
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), ERROR_FAIL);
return ERROR_FAIL;
}
BOOL Sm::IsShilohClustered(LPSTR szInstance)
{
BidxScopeAutoSNI1( SNIAPI_TAG _T("szInstance: \"%hs\"\n"), szInstance );
char szRegLocation[MAX_PATH+128] = "";
szRegLocation[ sizeof(szRegLocation) -1] = 0;
// If its MSSQLSERVER (default instance), append another MSSQLServer to the path
if(!_stricmp_l("MSSQLSERVER", szInstance, GetDefaultLocale()) )
{
if(FAILED(StringCchPrintf_lA( szRegLocation,
CCH_ANSI_STRING(szRegLocation),
"SOFTWARE\\Microsoft\\MSSQLServer\\Cluster", GetDefaultLocale())))
{
goto ErrorExit;
}
}
// Else, its a named instance
else
{
if(FAILED(StringCchPrintf_lA( szRegLocation,
CCH_ANSI_STRING(szRegLocation),
"SOFTWARE\\Microsoft\\Microsoft SQL Server\\%s\\Cluster", GetDefaultLocale(),
szInstance)))
{
goto ErrorExit;
}
}
HKEY hKey;
LONG lReturn = RegOpenKeyEx( HKEY_LOCAL_MACHINE, // handle to open key
szRegLocation, // subkey name
0, // reserved
KEY_QUERY_VALUE, // security access mask
&hKey ); // handle to open key
if( ERROR_SUCCESS != lReturn )
{
goto ErrorExit;
}
RegCloseKey( hKey );
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{BOOL}\n"), TRUE);
return TRUE;
ErrorExit:
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{BOOL}\n"), FALSE);
return FALSE;
}
DWORD Sm_Shiloh::LoadDll(__out NLFunctionTable * pFuncs)
{
BidxScopeAutoSNI1( SNIAPI_TAG _T( "pFuncs: %p{NLFunctionTable*}\n"), pFuncs);
DWORD dwError;
// Function Names for Wrapper Netlib Dlls - keep in [....] with enum in .hpp
CHAR * rgFnName[CLNT_NETFUNCS] =
{
"ConnectionObjectSize",
"ConnectionOpen",
"ConnectionRead",
"ConnectionWrite",
"ConnectionClose",
"ConnectionCheckForData"
};
FARPROC rgFnPtr[CLNT_NETFUNCS];
if( NULL == (hNetlib = SNILoadSystemLibraryA( "dbmslpcn.dll" )) )
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_36, dwError );
goto ErrorExit;
}
int i;
for( i = 0; i < CLNT_NETFUNCS; i++ )
{
if( NULL == (rgFnPtr[i] = GetProcAddress(hNetlib, rgFnName[i])) )
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_37, dwError );
goto ErrorExit;
}
}
memcpy(pFuncs, rgFnPtr, sizeof(NLFunctionTable));
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), ERROR_SUCCESS);
return ERROR_SUCCESS;
ErrorExit:
if( hNetlib )
FreeLibrary( hNetlib );
hNetlib = NULL;
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), dwError);
return dwError;
}
BOOL Sm::IsClustered(__in LPWSTR wszInstance)
{
BidxScopeAutoSNI1( SNIAPI_TAG _T("wszInstance: \"%s\"\n"), wszInstance );
BOOL fisClustered = FALSE;
DWORD dwError = ERROR_SUCCESS;
if( !gpInstapiStruct )
{
// failed in load instapi.dll, try shiloh
fisClustered = Sm::IsShilohClustered(wszInstance);
goto Exit;
}
//Try to use instapi to obtain the server?s cluster name.
WCHAR wszClusterName[MAX_NAME_SIZE+1];
DWORD cwszClusterName = MAX_NAME_SIZE;
// For obtain instance ID specifying SQL Server service to make sure we
// don't get version for AS or RS.
//
INST_ID instID;
if( !gpInstapiStruct->pfnGetSvcInstanceIDFromName( wszInstance, //instance name
SVC_SQL,
&instID ) )
{
// If we cannot get instance ID it means the server is not installed,
// hence, it's not clustered.
goto Exit;
}
if( !gpInstapiStruct->pfnGetSQLInstanceRegStringByID( &instID,
L"Cluster", //RegPath
L"ClusterName", //ValueName
wszClusterName, //String
&cwszClusterName)
)
{
// If we cannot get the clustername, it is not clustered
goto Exit;
}
fisClustered = TRUE;
Exit:
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{BOOL}\n"), fisClustered);
return fisClustered;
}
DWORD Sm_Shiloh::Close()
{
BidxScopeAutoSNI1( SNIAPI_TAG _T("%u#\n"), GetBidId() );
DWORD dwRet = ERROR_SUCCESS;
LONG Error;
if( FALSE == g_rgFuncs.Close( m_pConnObj, &Error ) )
{
dwRet = Error;
SNI_SET_LAST_ERROR( SM_PROV, SNIE_1, dwRet );
}
delete [] m_pConnObj;
m_pConnObj = 0;
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), dwRet);
return dwRet;
}
DWORD Sm_Shiloh::Initialize(PSNI_PROVIDER_INFO pInfo)
{
BidxScopeAutoSNI1( SNIAPI_TAG _T( "pInfo: %p{PSNI_PROVIDER_INFO}\n"), pInfo );
// Fill all these up
pInfo->fBaseProv = TRUE;
pInfo->Size = 0;
pInfo->Offset = 0;
pInfo->ProvNum = SM_PROV;
DWORD dwError = SNICritSec::Initialize( &DllCritSec );
if( ERROR_SUCCESS != dwError)
{
SNI_SET_LAST_ERROR( SM_PROV, SNIE_SYSTEM, dwError );
}
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), dwError);
return dwError;
}
DWORD
Sm::GetThreadSID( SID ** ppSID )
{
BidxScopeAutoSNI1( SNIAPI_TAG _T( "ppSID: %p{SID**}\n"), ppSID );
BOOL fReturn = FALSE;
HANDLE TokenHandle = NULL;
PTOKEN_USER pUserToken = NULL;
DWORD dwSizeNeeded = 0;
DWORD dwError = ERROR_SUCCESS;
PSID pSID = NULL;
*ppSID = NULL;
BOOL fThreadSID = OpenThreadToken( GetCurrentThread(),
TOKEN_READ,
FALSE,
&TokenHandle );
if (fThreadSID)
{
fReturn = GetTokenInformation( TokenHandle,
TokenUser,
NULL,
0,
&dwSizeNeeded );
if( FALSE == fReturn )
{
if( ERROR_INSUFFICIENT_BUFFER != (dwError = GetLastError()) )
{
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
goto ErrorExit;
}
}
pUserToken = (PTOKEN_USER) NewNoX(gpmo) BYTE[dwSizeNeeded];
if( !pUserToken )
{
dwError = ERROR_OUTOFMEMORY;
SNI_SET_LAST_ERROR( SM_PROV, SNIE_4, dwError );
goto ErrorExit;
}
fReturn = GetTokenInformation( TokenHandle,
TokenUser,
(LPVOID) pUserToken,
dwSizeNeeded,
&dwSizeNeeded );
if( FALSE == fReturn )
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
goto ErrorExit;
}
pSID = pUserToken->User.Sid;
}
//Grab the Process SID (which is already available from the SOS)
else
{
//We merely grab the SID for the process
if( ERROR_NO_TOKEN == (dwError = GetLastError()))
{
pSID = SOS_OS::GetProcessSID();
}
else
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
goto ErrorExit;
}
}
// Validate the SID before copying.
//
if( !IsValidSid( pSID ) )
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
goto ErrorExit;
}
// Let's make a copy the SID
//
dwSizeNeeded = GetLengthSid( pSID );
*ppSID = (SID *) NewNoX(gpmo) BYTE[dwSizeNeeded];
if( !*ppSID )
{
dwError = ERROR_OUTOFMEMORY;
SNI_SET_LAST_ERROR( SM_PROV, SNIE_4, dwError );
goto ErrorExit;
}
fReturn = CopySid( dwSizeNeeded,
*ppSID,
pSID );
if( FALSE == fReturn )
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
goto ErrorExit;
}
//We never obtained a user token at all if this is a process sid
if (fThreadSID)
{
delete [] pUserToken;
CloseHandle( TokenHandle );
}
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), ERROR_SUCCESS);
return ERROR_SUCCESS;
ErrorExit:
if( fThreadSID && pUserToken )
delete [] pUserToken;
if( *ppSID )
delete [] *ppSID;
*ppSID = 0;
if( fThreadSID && TokenHandle )
CloseHandle( TokenHandle );
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), dwError);
return dwError;
}
DWORD
Sm::GetThreadSID( __out SID ** ppSID )
{
BidxScopeAutoSNI1( SNIAPI_TAG _T( "ppSID: %p{SID**}\n"), ppSID );
BOOL fReturn = FALSE;
HANDLE TokenHandle = NULL;
PTOKEN_USER pUserToken = NULL;
DWORD dwSizeNeeded = 0;
DWORD dwError = ERROR_SUCCESS;
*ppSID = NULL;
fReturn = OpenThreadToken( GetCurrentThread(),
TOKEN_READ,
FALSE,
&TokenHandle );
if( FALSE == fReturn )
{
// If this was because there was no token for the thread, then
// use the token of the process
if( ERROR_NO_TOKEN == (dwError = GetLastError()) )
{
fReturn = OpenProcessToken( GetCurrentProcess(),
TOKEN_READ,
&TokenHandle );
if( FALSE == fReturn )
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
}
}
else
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
}
if( FALSE == fReturn )
goto ErrorExit;
}
fReturn = GetTokenInformation( TokenHandle,
TokenUser,
NULL,
0,
&dwSizeNeeded );
if( FALSE == fReturn )
{
if( ERROR_INSUFFICIENT_BUFFER != (dwError = GetLastError()) )
{
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
goto ErrorExit;
}
}
pUserToken = (PTOKEN_USER) NewNoX(gpmo) BYTE[dwSizeNeeded];
if( !pUserToken )
{
dwError = ERROR_OUTOFMEMORY;
SNI_SET_LAST_ERROR( SM_PROV, SNIE_4, dwError );
goto ErrorExit;
}
fReturn = GetTokenInformation( TokenHandle,
TokenUser,
(LPVOID) pUserToken,
dwSizeNeeded,
&dwSizeNeeded );
if( FALSE == fReturn )
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
goto ErrorExit;
}
// Validate the SID before copying.
//
if( !IsValidSid( pUserToken->User.Sid ) )
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
goto ErrorExit;
}
// Let's make a copy the SID
//
dwSizeNeeded = GetLengthSid( pUserToken->User.Sid );
*ppSID = (SID *) NewNoX(gpmo) BYTE[dwSizeNeeded];
if( !*ppSID )
{
dwError = ERROR_OUTOFMEMORY;
SNI_SET_LAST_ERROR( SM_PROV, SNIE_4, dwError );
goto ErrorExit;
}
fReturn = CopySid( dwSizeNeeded,
*ppSID,
pUserToken->User.Sid );
if( FALSE == fReturn )
{
dwError = GetLastError();
SNI_SET_LAST_ERROR( SM_PROV, SNIE_10, dwError );
goto ErrorExit;
}
delete [] pUserToken;
CloseHandle( TokenHandle );
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), ERROR_SUCCESS);
return ERROR_SUCCESS;
ErrorExit:
if( pUserToken )
delete [] pUserToken;
if( *ppSID )
delete [] *ppSID;
*ppSID = 0;
if( TokenHandle )
CloseHandle( TokenHandle );
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), dwError);
return dwError;
}
void SetSsrpWaitTimeout(int timeout_millis)
{
BidxScopeAutoSNI1( SNIAPI_TAG _T( "timeout_millis %d\n"), timeout_millis);
Assert( timeout_millis > 0 || timeout_millis == INFINITE);
m_ssrp_wait_timeout = timeout_millis;
}
