//
// This is the internal callback that will be called when
// the IO we issued for the user to winsock has completed.
// when this function gets called it must:
// 1) update the AsyncResult object with the results of the completed IO
// 2) signal events that the user might be waiting on
// 3) call the callback function that the user might have specified
//
// This method was copied from a ConnectAsyncResult class that became useless.
private void ConnectCallback()
{
LazyAsyncResult asyncResult = (LazyAsyncResult) m_AcceptQueueOrConnectResult;
GlobalLog.Enter("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback");
//
// If we came here due to a ---- between BeginConnect and Dispose
//
if (asyncResult.InternalPeekCompleted)
{
GlobalLog.Assert(CleanedUp, "Socket#{0}::ConnectCallback()|asyncResult is compelted but the socket does not have CleanedUp set.", ValidationHelper.HashString(this));
GlobalLog.Leave("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback", "Already completed, socket must be closed");
return;
}
//<STRIP>
// we now need to get the status of the async completion, we had an easy implementation
// that uses GetSocketOption(), but VadimE suggested not to use this 'cause it may be
// buggy on some platforms, so we use WSAEnumNetworkEvents() instead:
//
// The best way to do this is to call WSAEnumNetworkEvents and use the error code iError
// array corresponding to FD_CONNECT. getsockopt (SO_ERROR) may return NO_ERROR under
// stress even in case of error at least on Winnt4.0 (I don't remember whether I fixed
// it on Win2000 or WinXP).
//</STRIP>
//
// get async completion
//
/*
int errorCode = (int)socket.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Error);
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() GetSocketOption() returns errorCode:" + errorCode.ToString());
*/
NetworkEvents networkEvents = new NetworkEvents();
networkEvents.Events = AsyncEventBits.FdConnect;
SocketError errorCode = SocketError.OperationAborted;
object result = null;
try
{
if (!CleanedUp)
{
try
{
errorCode = UnsafeNclNativeMethods.OSSOCK.WSAEnumNetworkEvents(
m_Handle,
m_AsyncEvent.SafeWaitHandle,
ref networkEvents);
if (errorCode != SocketError.Success)
{
errorCode = (SocketError) Marshal.GetLastWin32Error();
GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback() WSAEnumNetworkEvents() failed with errorCode:" + errorCode.ToString());
}
else
{
errorCode = (SocketError) networkEvents.ErrorCodes[(int) AsyncEventBitsPos.FdConnectBit];
GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback() ErrorCodes(FdConnect) got errorCode:" + errorCode.ToString());
}
//
// Cancel async event and go back to blocking mode.
//
UnsetAsyncEventSelect();
}
catch (ObjectDisposedException)
{
errorCode = SocketError.OperationAborted;
}
}
//
// if the native non-blocking call failed we'll throw a SocketException in EndConnect()
//
if (errorCode == SocketError.Success)
{
//
// the Socket is connected, update our state and performance counter
//
SetToConnected();
}
}
catch (Exception exception)
{
if (NclUtilities.IsFatal(exception)) throw;
GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback() caught exception:" + exception.Message + ", CleanedUp:" + CleanedUp);
result = exception;
}
if (!asyncResult.InternalPeekCompleted)
{
// A "ErrorCode" concept is questionable, for ex. below lines are subject to a race condition
asyncResult.ErrorCode = (int) errorCode;
asyncResult.InvokeCallback(result);
}
GlobalLog.Leave("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback", errorCode.ToString());
}
//
// This is the internal callback that will be called when
// the IO we issued for the user to winsock has completed.
// when this function gets called it must:
// 1) update the AsyncResult object with the results of the completed IO
// 2) signal events that the user might be waiting on
// 3) call the callback function that the user might have specified
//
// This method was copied from a ConnectAsyncResult class that became useless.
private void ConnectCallback()
{
LazyAsyncResult asyncResult = (LazyAsyncResult) m_AcceptQueueOrConnectResult;
GlobalLog.Enter("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback");
//
// If we came here due to a ---- between BeginConnect and Dispose
//
if (asyncResult.InternalPeekCompleted)
{
GlobalLog.Assert(CleanedUp, "Socket#{0}::ConnectCallback()|asyncResult is compelted but the socket does not have CleanedUp set.", ValidationHelper.HashString(this));
GlobalLog.Leave("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback", "Already completed, socket must be closed");
return;
}
//<
//
// get async completion
//
/*
int errorCode = (int)socket.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Error);
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() GetSocketOption() returns errorCode:" + errorCode.ToString());
*/
NetworkEvents networkEvents = new NetworkEvents();
networkEvents.Events = AsyncEventBits.FdConnect;
SocketError errorCode = SocketError.OperationAborted;
object result = null;
try
{
if (!CleanedUp)
{
try
{
errorCode = UnsafeNclNativeMethods.OSSOCK.WSAEnumNetworkEvents(
m_Handle,
m_AsyncEvent.SafeWaitHandle,
ref networkEvents);
if (errorCode != SocketError.Success)
{
errorCode = (SocketError) Marshal.GetLastWin32Error();
GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback() WSAEnumNetworkEvents() failed with errorCode:" + errorCode.ToString());
}
else
{
errorCode = (SocketError) networkEvents.ErrorCodes[(int) AsyncEventBitsPos.FdConnectBit];
GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback() ErrorCodes(FdConnect) got errorCode:" + errorCode.ToString());
}
//
// Cancel async event and go back to blocking mode.
//
UnsetAsyncEventSelect();
}
catch (ObjectDisposedException)
{
errorCode = SocketError.OperationAborted;
}
}
//
// if the native non-blocking call failed we'll throw a SocketException in EndConnect()
//
if (errorCode == SocketError.Success)
{
//
// the Socket is connected, update our state and performance counter
//
SetToConnected();
}
}
catch (Exception exception)
{
if (NclUtilities.IsFatal(exception)) throw;
GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback() caught exception:" + exception.Message + ", CleanedUp:" + CleanedUp);
result = exception;
}
if (!asyncResult.InternalPeekCompleted)
{
// A "ErrorCode" concept is questionable, for ex. below lines are subject to a race condition
asyncResult.ErrorCode = (int) errorCode;
asyncResult.InvokeCallback(result);
}
GlobalLog.Leave("Socket#" + ValidationHelper.HashString(this) + "::ConnectCallback", errorCode.ToString());
}
//
// This is the static internal callback that will be called when
// the IO we issued for the user to winsock has completed, either
// synchronously (Signaled=false) or asynchronously (Signaled=true)
// when this function gets called it must:
// 1) update the AsyncResult object with the results of the completed IO
// 2) signal events that the user might be waiting on
// 3) cal the callback function that the user might have specified
//
internal static void ConnectCallback(object stateObject, bool Signaled) {
ConnectAsyncResult asyncResult = stateObject as ConnectAsyncResult;
Socket socket = asyncResult.AsyncObject as Socket;
GlobalLog.Enter("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback", "Signaled:" + Signaled.ToString());
GlobalLog.Assert(!asyncResult.IsCompleted, "Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() asyncResult.IsCompleted", "");
//
//
// get async completion
//
/*
int errorCode = (int)socket.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Error);
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() GetSocketOption() returns errorCode:" + errorCode.ToString());
*/
NetworkEvents networkEvents = new NetworkEvents();
networkEvents.Events = AsyncEventBits.FdConnect;
AutoResetEvent chkAsyncEvent = socket.m_AsyncEvent;
int errorCode = SocketErrors.WSAENOTSOCK;
if (chkAsyncEvent!=null) {
errorCode =
UnsafeNclNativeMethods.OSSOCK.WSAEnumNetworkEvents(
socket.m_Handle,
chkAsyncEvent.Handle,
ref networkEvents );
if (errorCode!=SocketErrors.Success) {
errorCode = Marshal.GetLastWin32Error();
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() WSAEnumNetworkEvents() failed with errorCode:" + errorCode.ToString());
}
else {
errorCode = networkEvents.ErrorCodes[(int)AsyncEventBitsPos.FdConnectBit];
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() ErrorCodes(FdConnect) got errorCode:" + errorCode.ToString());
}
}
try {
//
// cancel async event
//
socket.SetAsyncEventSelect(AsyncEventBits.FdNone);
//
// go back to blocking mode
//
socket.InternalSetBlocking(true);
}
catch (Exception exception) {
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() caught exception::" + exception.Message);
asyncResult.Result = exception;
}
//
// if the native non-blocking call failed we'll throw a SocketException in EndConnect()
//
if (errorCode!=SocketErrors.Success) {
//
// just save the error code, the SocketException will be thrown in EndConnect()
//
asyncResult.ErrorCode = errorCode;
}
else {
//
// the Socket is connected, update our state and performance counter
//
socket.SetToConnected();
}
//
// call the user's callback now, if there is one.
//
asyncResult.InvokeCallback(false);
GlobalLog.Leave("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback", errorCode.ToString());
}
private void ConnectCallback()
{
LazyAsyncResult lazyAsyncResult = (LazyAsyncResult) this.m_AcceptQueueOrConnectResult;
if (lazyAsyncResult.InternalPeekCompleted)
return;
NetworkEvents networkEvents = new NetworkEvents();
networkEvents.Events = AsyncEventBits.FdConnect;
SocketError socketError = SocketError.OperationAborted;
object result = (object) null;
try
{
if (!this.CleanedUp)
{
try
{
socketError = UnsafeNclNativeMethods.OSSOCK.WSAEnumNetworkEvents(this.m_Handle, this.m_AsyncEvent.SafeWaitHandle, out networkEvents);
socketError = socketError == SocketError.Success ? (SocketError) networkEvents.ErrorCodes[4] : (SocketError) Marshal.GetLastWin32Error();
this.UnsetAsyncEventSelect();
}
catch (ObjectDisposedException ex)
{
socketError = SocketError.OperationAborted;
}
}
if (socketError == SocketError.Success)
this.SetToConnected();
}
catch (Exception ex)
{
if (NclUtilities.IsFatal(ex))
throw;
else
result = (object) ex;
}
if (lazyAsyncResult.InternalPeekCompleted)
return;
lazyAsyncResult.ErrorCode = (int) socketError;
lazyAsyncResult.InvokeCallback(result);
}
//
// This is the static internal callback that will be called when
// the IO we issued for the user to winsock has completed, either
// synchronously (Signaled=false) or asynchronously (Signaled=true)
// when this function gets called it must:
// 1) update the AsyncResult object with the results of the completed IO
// 2) signal events that the user might be waiting on
// 3) cal the callback function that the user might have specified
//
internal static void ConnectCallback(object stateObject, bool Signaled)
{
ConnectAsyncResult asyncResult = stateObject as ConnectAsyncResult;
Socket socket = asyncResult.AsyncObject as Socket;
GlobalLog.Enter("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback", "Signaled:" + Signaled.ToString());
GlobalLog.Assert(!asyncResult.IsCompleted, "Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() asyncResult.IsCompleted", "");
//
// we now need to get the status of the async completion, we had an easy implementation
// that uses GetSocketOption(), but VadimE suggested not to use this 'cause it may be
// buggy on some platforms, so we use WSAEnumNetworkEvents() instead:
//
// The best way to do this is to call WSAEnumNetworkEvents and use the error code iError
// array corresponding to FD_CONNECT. getsockopt (SO_ERROR) may return NO_ERROR under
// stress even in case of error at least on Winnt4.0 (I don't remember whether I fixed
// it on Win2000 or WinXP).
//
//
// get async completion
//
/*
* int errorCode = (int)socket.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Error);
* GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() GetSocketOption() returns errorCode:" + errorCode.ToString());
*/
NetworkEvents networkEvents = new NetworkEvents();
networkEvents.Events = AsyncEventBits.FdConnect;
AutoResetEvent chkAsyncEvent = socket.m_AsyncEvent;
int errorCode = SocketErrors.WSAENOTSOCK;
if (chkAsyncEvent != null)
{
errorCode =
UnsafeNclNativeMethods.OSSOCK.WSAEnumNetworkEvents(
socket.m_Handle,
chkAsyncEvent.Handle,
ref networkEvents);
if (errorCode != SocketErrors.Success)
{
errorCode = Marshal.GetLastWin32Error();
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() WSAEnumNetworkEvents() failed with errorCode:" + errorCode.ToString());
}
else
{
errorCode = networkEvents.ErrorCodes[(int)AsyncEventBitsPos.FdConnectBit];
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() ErrorCodes(FdConnect) got errorCode:" + errorCode.ToString());
}
}
try {
//
// cancel async event
//
socket.SetAsyncEventSelect(AsyncEventBits.FdNone);
//
// go back to blocking mode
//
socket.InternalSetBlocking(true);
}
catch (Exception exception) {
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() caught exception::" + exception.Message);
asyncResult.Result = exception;
}
//
// if the native non-blocking call failed we'll throw a SocketException in EndConnect()
//
if (errorCode != SocketErrors.Success)
{
//
// just save the error code, the SocketException will be thrown in EndConnect()
//
asyncResult.ErrorCode = errorCode;
}
else
{
//
// the Socket is connected, update our state and performance counter
//
socket.SetToConnected();
}
//
// call the user's callback now, if there is one.
//
asyncResult.InvokeCallback(false);
GlobalLog.Leave("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback", errorCode.ToString());
}
//
// This is the static internal callback that will be called when
// the IO we issued for the user to winsock has completed, either
// synchronously (Signaled=false) or asynchronously (Signaled=true)
// when this function gets called it must:
// 1) update the AsyncResult object with the results of the completed IO
// 2) signal events that the user might be waiting on
// 3) cal the callback function that the user might have specified
//
internal static void ConnectCallback(object stateObject, bool Signaled)
{
ConnectAsyncResult asyncResult = stateObject as ConnectAsyncResult;
Socket socket = asyncResult.AsyncObject as Socket;
GlobalLog.Enter("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback", "Signaled:" + Signaled.ToString());
GlobalLog.Assert(!asyncResult.IsCompleted, "Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() asyncResult.IsCompleted", "");
//
//
// get async completion
//
/*
* int errorCode = (int)socket.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Error);
* GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() GetSocketOption() returns errorCode:" + errorCode.ToString());
*/
NetworkEvents networkEvents = new NetworkEvents();
networkEvents.Events = AsyncEventBits.FdConnect;
AutoResetEvent chkAsyncEvent = socket.m_AsyncEvent;
int errorCode = SocketErrors.WSAENOTSOCK;
if (chkAsyncEvent != null)
{
errorCode =
UnsafeNclNativeMethods.OSSOCK.WSAEnumNetworkEvents(
socket.m_Handle,
chkAsyncEvent.Handle,
ref networkEvents);
if (errorCode != SocketErrors.Success)
{
errorCode = Marshal.GetLastWin32Error();
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() WSAEnumNetworkEvents() failed with errorCode:" + errorCode.ToString());
}
else
{
errorCode = networkEvents.ErrorCodes[(int)AsyncEventBitsPos.FdConnectBit];
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() ErrorCodes(FdConnect) got errorCode:" + errorCode.ToString());
}
}
try {
//
// cancel async event
//
socket.SetAsyncEventSelect(AsyncEventBits.FdNone);
//
// go back to blocking mode
//
socket.InternalSetBlocking(true);
}
catch (Exception exception) {
GlobalLog.Print("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback() caught exception::" + exception.Message);
asyncResult.Result = exception;
}
//
// if the native non-blocking call failed we'll throw a SocketException in EndConnect()
//
if (errorCode != SocketErrors.Success)
{
//
// just save the error code, the SocketException will be thrown in EndConnect()
//
asyncResult.ErrorCode = errorCode;
}
else
{
//
// the Socket is connected, update our state and performance counter
//
socket.SetToConnected();
}
//
// call the user's callback now, if there is one.
//
asyncResult.InvokeCallback(false);
GlobalLog.Leave("Socket#" + ValidationHelper.HashString(socket) + "::ConnectCallback", errorCode.ToString());
}
private void ConnectCallback()
{
LazyAsyncResult acceptQueueOrConnectResult = (LazyAsyncResult) this.m_AcceptQueueOrConnectResult;
if (!acceptQueueOrConnectResult.InternalPeekCompleted)
{
NetworkEvents networkEvents = new NetworkEvents {
Events = AsyncEventBits.FdConnect
};
SocketError operationAborted = SocketError.OperationAborted;
object result = null;
try
{
if (!this.CleanedUp)
{
try
{
operationAborted = UnsafeNclNativeMethods.OSSOCK.WSAEnumNetworkEvents(this.m_Handle, this.m_AsyncEvent.SafeWaitHandle, ref networkEvents);
if (operationAborted != SocketError.Success)
{
operationAborted = (SocketError) Marshal.GetLastWin32Error();
}
else
{
operationAborted = (SocketError) networkEvents.ErrorCodes[4];
}
this.UnsetAsyncEventSelect();
}
catch (ObjectDisposedException)
{
operationAborted = SocketError.OperationAborted;
}
}
if (operationAborted == SocketError.Success)
{
this.SetToConnected();
}
}
catch (Exception exception)
{
if (NclUtilities.IsFatal(exception))
{
throw;
}
result = exception;
}
if (!acceptQueueOrConnectResult.InternalPeekCompleted)
{
acceptQueueOrConnectResult.ErrorCode = (int) operationAborted;
acceptQueueOrConnectResult.InvokeCallback(result);
}
}
}