protected override bool CheckPacket(PacketHandle packet, TaskCompletionSource <object> source)
{
Debug.Assert(packet.Type == PacketHandle.NativePointerType, "unexpected packet type when requiring NativePointer");
IntPtr ptr = packet.NativePointer;
return(IntPtr.Zero == ptr || IntPtr.Zero != ptr && source != null);
}
private static volatile bool s_fSSPILoaded = false; // bool to indicate whether library has been loaded
internal void PostReadAsyncForMars()
{
if (TdsParserStateObjectFactory.UseManagedSNI)
{
return;
}
// HACK HACK HACK - for Async only
// Have to post read to initialize MARS - will get callback on this when connection goes
// down or is closed.
PacketHandle temp = default;
uint error = TdsEnums.SNI_SUCCESS;
_pMarsPhysicalConObj.IncrementPendingCallbacks();
SessionHandle handle = _pMarsPhysicalConObj.SessionHandle;
temp = _pMarsPhysicalConObj.ReadAsync(handle, out error);
Debug.Assert(temp.Type == PacketHandle.NativePointerType, "unexpected packet type when requiring NativePointer");
if (temp.NativePointer != IntPtr.Zero)
{
// Be sure to release packet, otherwise it will be leaked by native.
_pMarsPhysicalConObj.ReleasePacket(temp);
}
Debug.Assert(IntPtr.Zero == temp.NativePointer, "unexpected syncReadPacket without corresponding SNIPacketRelease");
if (TdsEnums.SNI_SUCCESS_IO_PENDING != error)
{
Debug.Assert(TdsEnums.SNI_SUCCESS != error, "Unexpected successful read async on physical connection before enabling MARS!");
_physicalStateObj.AddError(ProcessSNIError(_physicalStateObj));
ThrowExceptionAndWarning(_physicalStateObj);
}
}
internal override PacketHandle ReadSyncOverAsync(int timeoutRemaining, out uint error)
{
SNIHandle handle = Handle;
if (handle == null)
{
throw ADP.ClosedConnectionError();
}
IntPtr readPacketPtr = IntPtr.Zero;
error = SNINativeMethodWrapper.SNIReadSyncOverAsync(handle, ref readPacketPtr, GetTimeoutRemaining());
return(PacketHandle.FromNativePointer(readPacketPtr));
}
private static void ReadDispatcher(IntPtr key, IntPtr packet, uint error)
{
// This is the app-domain dispatcher for all async read callbacks, It
// simply gets the state object from the key that it is passed, and
// calls the state object's read callback.
Debug.Assert(IntPtr.Zero != key, "no key passed to read callback dispatcher?");
if (IntPtr.Zero != key)
{
// NOTE: we will get a null ref here if we don't get a key that
// contains a GCHandle to TDSParserStateObject; that is
// very bad, and we want that to occur so we can catch it.
GCHandle gcHandle = (GCHandle)key;
TdsParserStateObject stateObj = (TdsParserStateObject)gcHandle.Target;
if (null != stateObj)
{
stateObj.ReadAsyncCallback(IntPtr.Zero, PacketHandle.FromNativePointer(packet), error);
}
}
}
protected override void RemovePacketFromPendingList(PacketHandle ptr)
{
Debug.Assert(ptr.Type == PacketHandle.NativePointerType, "unexpected packet type when requiring NativePointer");
IntPtr pointer = ptr.NativePointer;
lock (_writePacketLockObject)
{
if (_pendingWritePackets.TryGetValue(pointer, out SNIPacket recoveredPacket))
{
_pendingWritePackets.Remove(pointer);
_writePacketCache.Add(recoveredPacket);
}
#if DEBUG
else
{
Debug.Fail("Removing a packet from the pending list that was never added to it");
}
#endif
}
}
protected override uint SNIPacketGetData(PacketHandle packet, byte[] _inBuff, ref uint dataSize)
{
Debug.Assert(packet.Type == PacketHandle.NativePointerType, "unexpected packet type when requiring NativePointer");
return(SNINativeMethodWrapper.SNIPacketGetData(packet.NativePointer, _inBuff, ref dataSize));
}