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;
}
static SNIMemRegion * Init()
{
LONG i = 0;
DWORD dwErr = ERROR_SUCCESS;
SNIMemRegion * rgMemRegion;
rgMemRegion= NewNoX(gpmo) SNIMemRegion[MAX_MEM_TAGS];
if(NULL == rgMemRegion)
{
return NULL;
}
for(i = 0; i < MAX_MEM_TAGS; i++)
{
if( ERROR_SUCCESS != rgMemRegion[i].FInit((MemTagTypes) i))
{
delete [] rgMemRegion;
return NULL;
}
}
return rgMemRegion;
//
}
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::LoadInstapiIfNeeded()
{
DWORD dwError = ERROR_SUCCESS;
INSTAPILIBSTRUCT* pInstapiStruct = NULL;
BidxScopeAutoSNI0( SNIAPI_TAG _T("\n") );
// Check to see if instapdll is already loaded
//
if (InterlockedCompareExchangePointer (
reinterpret_cast<volatile PVOID*>(&gpInstapiStruct),
NULL, NULL))
{
goto ErrorExit;
}
pInstapiStruct = NewNoX(gpmo) INSTAPILIBSTRUCT;
if ( NULL == pInstapiStruct )
{
dwError = ERROR_OUTOFMEMORY;
goto ErrorExit;
}
pInstapiStruct -> hInstapidll = NULL;
// Temparorily load the DLL.
//1. Read registry value SharedCode under HKLM\Software\Microsoft\Microsoft SQL Server\90\Shared,
const char szSharedPathLocation[]="Software\\Microsoft\\Microsoft SQL Server\\90";
HKEY hKey;
dwError = static_cast<DWORD> (RegOpenKeyEx( HKEY_LOCAL_MACHINE,// handle to open key
szSharedPathLocation, // subkey name
0, // reserved
KEY_QUERY_VALUE, // security access mask
&hKey )); // handle to open key
if( ERROR_SUCCESS != dwError )
{
BidTrace1(ERROR_TAG _T("Cannot retrieve the shared path. %d{WINERR}\n"), dwError);
goto ErrorExit;
}
char szSharedPath[MAX_PATH+1];
DWORD cszSharedPath = MAX_PATH;
DWORD dwSharedPathRegType;
dwError = static_cast<DWORD> ( RegQueryValueEx( hKey, // handle to key
"SharedCode", // value name
0, // reserved
&dwSharedPathRegType, // value type
(LPBYTE)szSharedPath, // value data
&cszSharedPath )); // size of value data
RegCloseKey( hKey );
if( ERROR_SUCCESS != dwError )
{
BidTrace1(ERROR_TAG _T("Cannot retrieve the shared path. %d{WINERR}\n"), dwError);
goto ErrorExit;
}
if(REG_SZ != dwSharedPathRegType)
{
// RegValue is corrupted. In this case, we error out.
dwError = ERROR_INVALID_DATA;
goto ErrorExit;
}
__analysis_assume(cszSharedPath<=MAX_PATH); //The current header we use does not annotate RegQueryValueEx correctly, adding this to suppress Prefast 26015, we could remove it when the tools set is updated to Vista SDK.
// Ensure NULL-termination.
szSharedPath[cszSharedPath] = '\0';
//2. Load instapi.dll from the location where SharedCode points to
const char szInstapidllname[] ="instapi.dll";
char szInstapipath[MAX_PATH+sizeof(szInstapidllname)+1];
if(FAILED(StringCchPrintf_lA( szInstapipath,
CCH_ANSI_STRING(szInstapipath),
"%s%s", GetDefaultLocale(),szSharedPath,szInstapidllname)))
{
dwError = ERROR_INVALID_PARAMETER;
goto ErrorExit;
}
szInstapipath[sizeof(szInstapipath)-1] = '\0';
if( NULL == (pInstapiStruct->hInstapidll = LoadLibrary( szInstapipath)) )
{
dwError = GetLastError();
BidTrace1(ERROR_TAG _T("Failed to load instapi.dll. %d{WINERR}\n"), dwError );
goto ErrorExit;
}
const char * szGetSvcInstanceIDFromName = "GetSvcInstanceIDFromName";
if( !(pInstapiStruct->pfnGetSvcInstanceIDFromName
= (PFNGetSvcInstanceIDFromName)GetProcAddress( pInstapiStruct->hInstapidll,
szGetSvcInstanceIDFromName))
)
{
dwError = GetLastError();
BidTrace1(ERROR_TAG _T("Failed to load function GetSvcInstanceIDFromName. %d{WINERR}\n"), dwError );
goto ErrorExit;
}
const char * szGetSQLInstanceRegStringByID = "GetSQLInstanceRegStringByID";
if( !(pInstapiStruct->pfnGetSQLInstanceRegStringByID
= (PFNGetSQLInstanceRegStringByID)GetProcAddress( pInstapiStruct->hInstapidll,
szGetSQLInstanceRegStringByID))
)
{
dwError = GetLastError();
BidTrace1(ERROR_TAG _T("Failed to load function GetSQLInstanceRegStringByID. %d{WINERR}\n"), dwError );
goto ErrorExit;
}
Assert (ERROR_SUCCESS == dwError );
// Now try to set global gpInstapiStruct
if ( InterlockedCompareExchangePointer (
reinterpret_cast<volatile PVOID*>(&gpInstapiStruct),
reinterpret_cast<PVOID>(pInstapiStruct) ,NULL))
{
goto ErrorExit;
}
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("Loaded instapi.dll. %d{WINERR}\n"), dwError );
return dwError;
ErrorExit:
if ( pInstapiStruct )
{
if ( pInstapiStruct -> hInstapidll )
FreeLibrary( pInstapiStruct -> hInstapidll );
delete pInstapiStruct;
}
if ( ERROR_SUCCESS != dwError )
SNI_SET_LAST_ERROR( SM_PROV, SNIE_36, dwError );
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;
}
// This is a wrapper around NewNoX call to eliminate exception handler
// set up/teardown in the calling function; we do not want to inline
// this.
friend SNI_Packet * SNIPacketNew( __in SNI_Conn * pConn,
SNI_Packet_IOType IOType,
SNIMemRegion * pMemRegion,
DWORD MemTag,
DWORD dwSize,
SOS_IOCompRoutine* IOCompRoutine,
ConsumerNum ConsNum )
{
BidTraceU2( SNI_BID_TRACE_ON, SNIAPI_TAG _T( "pConn: %p{SNI_Conn*}, IOType: %d\n"), pConn, IOType);
DWORD dwError = ERROR_SUCCESS;
Assert(IOType < SNI_Packet_InvalidType);
Assert(ConsNum < SNI_Consumer_Invalid);
#ifndef SNI_BASED_CLIENT
Assert ( pMemRegion && pMemRegion->GetPacketPmo() );
SNI_Packet * pPacket =
NewNoX(pMemRegion->GetPacketPmo()) SNI_Packet( dwSize,
pConn,
IOCompRoutine,
MemTag,
pMemRegion,
IOType,
ConsNum);
#else
SNI_Packet * pPacket =
NewNoX(gpmo) SNI_Packet( dwSize,
pConn,
IOCompRoutine,
MemTag,
pMemRegion,
IOType,
ConsNum);
#endif
if (NULL == pPacket) // SNI_Packet object allocation failed
{
dwError = ERROR_OUTOFMEMORY;
goto ret;
}
else if( ((SNI_Packet_Read == IOType) || // If IOType is Read or Write
(SNI_Packet_Write == IOType)) && // we must have a buffer allocated successfully
(NULL == pPacket->m_pBuffer) )
{
delete pPacket;
pPacket = NULL;
dwError = ERROR_OUTOFMEMORY;
goto ret;
}
#ifdef SNI_BASED_CLIENT
dwError = pPacket->InitOvlEvent();
if (ERROR_SUCCESS != dwError)
{
// Already BID-traced at InitOvlEvent
delete pPacket;
pPacket = NULL;
goto ret;
}
#endif
ret:
if( NULL == pPacket )
{
SNI_SET_LAST_ERROR( INVALID_PROV, SNIE_SYSTEM, dwError );
}
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%p{SNI_Packet*}\n"), pPacket);
return (SNI_Packet *)pPacket;
}
DWORD Sm_Shiloh::Open( SNI_Conn * pConn,
ProtElem * pProtElem,
__out SNI_Provider ** ppProv )
{
BidxScopeAutoSNI3( SNIAPI_TAG _T("pConn: %p{SNI_Conn*}, ")
_T("pProtElem: %p{ProtElem*}, ")
_T("ppProv: %p{SNI_Provider**}\n"),
pConn, pProtElem, ppProv);
Sm_Shiloh * pSm_ShilohProv = 0;
DWORD dwRet = ERROR_FAIL;
// If we failed to initialize the SM SHiloh shim, faill
// all connections to Shiloh.
//
if( NULL == DllCritSec )
{
dwRet = ERROR_INVALID_STATE;
SNI_SET_LAST_ERROR( SM_PROV, SNIE_SYSTEM, dwRet );
goto ErrorExit;
}
{
CAutoSNICritSec a_csDll( DllCritSec, SNI_AUTOCS_DO_NOT_ENTER );
pSm_ShilohProv = NewNoX(gpmo) Sm_Shiloh(pConn);
if( !pSm_ShilohProv )
{
dwRet = ERROR_OUTOFMEMORY;
SNI_SET_LAST_ERROR( SM_PROV, SNIE_SYSTEM, dwRet );
goto ErrorExit;
}
// Set the handle to be invalid
pSm_ShilohProv->m_hNwk = INVALID_HANDLE_VALUE;
// Load the Dll, if necessary
//
a_csDll.Enter();
if( NULL == hNetlib )
{
if( ERROR_SUCCESS != (dwRet = Sm_Shiloh::LoadDll(&g_rgFuncs)) )
{
a_csDll.Leave();
goto ErrorExit;
}
}
a_csDll.Leave();
}
// Check if Shared Memory is valid
{
// Get the instance
LPWSTR wszInstance = NULL;
wszInstance = StrChrW_SYS(pProtElem->Sm.Alias,(int) wcslen(pProtElem->Sm.Alias), L'\\' );
if( wszInstance )
wszInstance += 1;
else
wszInstance = L"MSSQLSERVER";
CONNECTIONVALIDSHAREDMEMORY_FN ConnectionValidSharedMemory;
// Let's make sure Shared-Memory Netlib is valid (correct version, matchup, etc.)
ConnectionValidSharedMemory
= (CONNECTIONVALIDSHAREDMEMORY_FN)GetProcAddress( hNetlib, "ConnectionValidSharedMemory" );
if( !ConnectionValidSharedMemory || !ConnectionValidSharedMemory(wszInstance) )
{
dwRet = ERROR_INVALID_PARAMETER;
SNI_SET_LAST_ERROR( SM_PROV, SNIE_39, dwRet );
goto ErrorExit;
}
}
pSm_ShilohProv->m_pConnObj = NewNoX (gpmo) BYTE[g_rgFuncs.Size()];
if( !pSm_ShilohProv->m_pConnObj )
{
dwRet = ERROR_OUTOFMEMORY;
SNI_SET_LAST_ERROR( SM_PROV, SNIE_SYSTEM, dwRet );
goto ErrorExit;
}
LONG Error = ERROR_SUCCESS;
if( !g_rgFuncs.Open(pSm_ShilohProv->m_pConnObj, pProtElem->Sm.Alias, &Error) )
{
// If the netlibs function returned an error, use it.
// Otherwise, return a generic one.
if( ERROR_SUCCESS != Error )
{
dwRet = static_cast<DWORD>(Error);
}
else
{
dwRet = ERROR_NOT_CONNECTED;
}
SNI_SET_LAST_ERROR( SM_PROV, SNIE_38, dwRet );
goto ErrorExit;
}
BidUpdateItemIDA( pSm_ShilohProv->GetBidIdPtr(), SNI_ID_TAG
"connection: %p{ProtElem}", pProtElem );
// Set the out provider param to point to the new Sm_Shiloh object
*ppProv = pSm_ShilohProv;
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), ERROR_SUCCESS);
return ERROR_SUCCESS;
ErrorExit:
if( pSm_ShilohProv )
{
if( pSm_ShilohProv->m_pConnObj )
delete [] pSm_ShilohProv->m_pConnObj;
delete pSm_ShilohProv;
}
*ppProv = NULL;
BidTraceU1( SNI_BID_TRACE_ON, RETURN_TAG _T("%d{WINERR}\n"), dwRet);
return dwRet;
}
