// block api public void Connect() { if (Connected) return; Log.Info("BeginReceive sysSocket.Connect(hostIp, hostPort);"); try { sysSocket.Connect(hostIp, hostPort); } catch (Exception e) { Log.Error("ClientNetwork BeginReceive throw exp:{0}", e); defferedConnected = new ConnectAsyncResult() { Ex = e, }; return; } defferedConnected = new ConnectAsyncResult() { Conn = new Connector(sysSocket, 0), }; }
public override IAsyncResult BeginConnect(System.Net.EndPoint endPoint, AsyncCallback callback, Object state) { ConnectAsyncResult lWrapper = new ConnectAsyncResult(callback, state); this.fInnerConnection.BeginConnect(endPoint, lWrapper.ConnectionConnect, this); return lWrapper; }
internal IAsyncResult UnsafeBeginConnect(EndPoint remoteEP, AsyncCallback callback, object state) { if (CanUseConnectEx(remoteEP)) { return BeginConnectEx(remoteEP, false, callback, state); } EndPoint endPointSnapshot = remoteEP; SocketAddress socketAddress = SnapshotAndSerialize(ref endPointSnapshot); // No context flow here. Can use Lazy. ConnectAsyncResult asyncResult = new ConnectAsyncResult(this, endPointSnapshot, state, callback); DoBeginConnect(endPointSnapshot, socketAddress, asyncResult); return asyncResult; }
public void Poll() { try { if (defferedConnected != null) { connector = defferedConnected.Conn; connector.BeginReceive(); // notify if (ConnectorConnected != null) { ConnectorConnected(defferedConnected.Conn, defferedConnected.Ex); } defferedConnected = null; } RefreshMessageQueue(); RefreshClient(); } catch (Exception e) { Log.Error(e); } }
// // Async Winsock Support, the following functions use either // the Async Winsock support to do overlapped I/O WSASend/WSARecv // or a WSAEventSelect call to enable selection and non-blocking mode // of otherwise normal Winsock calls. // // Currently the following Async Socket calls are supported: // Send, Recv, SendTo, RecvFrom, Connect, Accept // /*++ Routine Description: BeginConnect - Does a async winsock connect, by calling WSAEventSelect to enable Connect Events to signal an event and wake up a callback which involkes a callback. So note: This routine may go pending at which time, but any case the callback Delegate will be called upon completion Arguments: remoteEP - status line that we wish to parse Callback - Async Callback Delegate that is called upon Async Completion State - State used to track callback, set by caller, not required Return Value: IAsyncResult - Async result used to retreive result --*/ /// <include file='doc\Socket.uex' path='docs/doc[@for="Socket.BeginConnect"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public IAsyncResult BeginConnect(EndPoint remoteEP, AsyncCallback callback, Object state) { if (CleanedUp) { throw new ObjectDisposedException(this.GetType().FullName); } // // parameter validation // if (remoteEP==null) { throw new ArgumentNullException("remoteEP"); } GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::BeginConnect() remoteEP:" + remoteEP.ToString()); // // ask the EndPoint to generate a SocketAddress that we // can pass down to winsock // EndPoint endPointSnapshot = remoteEP; if (remoteEP.GetType()==typeof(IPEndPoint)) { endPointSnapshot = new IPEndPoint(((IPEndPoint)remoteEP).Address, ((IPEndPoint)remoteEP).Port); } SocketAddress socketAddress = endPointSnapshot.Serialize(); // This will check the permissions for connect. CheckCacheRemote(socketAddress, endPointSnapshot, true); // get async going SetAsyncEventSelect(AsyncEventBits.FdConnect); ConnectAsyncResult asyncResult = new ConnectAsyncResult(this, state, callback); int errorCode = UnsafeNclNativeMethods.OSSOCK.connect( m_Handle, socketAddress.m_Buffer, socketAddress.m_Size ); if (errorCode!=SocketErrors.Success) { errorCode = Marshal.GetLastWin32Error(); } GlobalLog.Print("Socket#" + ValidationHelper.HashString(this) + "::BeginConnect() UnsafeNclNativeMethods.OSSOCK.connect returns:" + errorCode.ToString()); if (errorCode==SocketErrors.Success) { SetToConnected(); } asyncResult.CheckAsyncCallResult(errorCode); // // if the asynchronous native call fails synchronously // we'll throw a SocketException // if (asyncResult.ErrorCode!=SocketErrors.Success) { // // update our internal state after this socket error and throw // UpdateStatusAfterSocketError(); throw new SocketException(asyncResult.ErrorCode); } if (m_RightEndPoint==null) { // // save a copy of the EndPoint so we can use it for Create() // m_RightEndPoint = endPointSnapshot; } GlobalLog.Print( "BeginConnect() to:" + endPointSnapshot.ToString() + " returning AsyncResult:" + ValidationHelper.HashString(asyncResult)); return asyncResult; }
public IAsyncResult BeginConnect(EndPoint remoteEP, AsyncCallback callback, object state) { // // parameter validation // if(s_LoggingEnabled)Logging.Enter(Logging.Sockets, this, "BeginConnect", remoteEP); if (CleanedUp) { throw new ObjectDisposedException(this.GetType().FullName); } if (remoteEP==null) { throw new ArgumentNullException("remoteEP"); } if (isListening) { throw new InvalidOperationException(SR.GetString(SR.net_sockets_mustnotlisten)); } DnsEndPoint dnsEP = remoteEP as DnsEndPoint; if (dnsEP != null) { if (dnsEP.AddressFamily != AddressFamily.Unspecified && !CanTryAddressFamily(dnsEP.AddressFamily)) { throw new NotSupportedException(SR.GetString(SR.net_invalidversion)); } return BeginConnect(dnsEP.Host, dnsEP.Port, callback, state); } if (CanUseConnectEx(remoteEP)) { return BeginConnectEx(remoteEP, true, callback, state); } // This will check the permissions for connect. EndPoint endPointSnapshot = remoteEP; SocketAddress socketAddress = CheckCacheRemote(ref endPointSnapshot, true); // Flow the context. No need to lock it since we don't use it until the callback. ConnectAsyncResult asyncResult = new ConnectAsyncResult(this, endPointSnapshot, state, callback); asyncResult.StartPostingAsyncOp(false); // Post the connect. DoBeginConnect(endPointSnapshot, socketAddress, asyncResult); // We didn't throw, so finish the posting op. This will call the callback if the operation already completed. asyncResult.FinishPostingAsyncOp(ref Caches.ConnectClosureCache); if(s_LoggingEnabled)Logging.Exit(Logging.Sockets, this, "BeginConnect", asyncResult); return asyncResult; }
public IAsyncResult BeginConnect(EndPoint remoteEP, AsyncCallback callback, object state) { if (Socket.s_LoggingEnabled) Logging.Enter(Logging.Sockets, (object) this, "BeginConnect", (object) remoteEP); if (this.CleanedUp) throw new ObjectDisposedException(this.GetType().FullName); if (remoteEP == null) throw new ArgumentNullException("remoteEP"); if (this.isListening) throw new InvalidOperationException(SR.GetString("net_sockets_mustnotlisten")); DnsEndPoint dnsEndPoint = remoteEP as DnsEndPoint; if (dnsEndPoint != null) { if (dnsEndPoint.AddressFamily != AddressFamily.Unspecified && !this.CanTryAddressFamily(dnsEndPoint.AddressFamily)) throw new NotSupportedException(SR.GetString("net_invalidversion")); else return this.BeginConnect(dnsEndPoint.Host, dnsEndPoint.Port, callback, state); } else { if (this.CanUseConnectEx(remoteEP)) return this.BeginConnectEx(remoteEP, true, callback, state); EndPoint remoteEP1 = remoteEP; SocketAddress socketAddress = this.CheckCacheRemote(ref remoteEP1, true); ConnectAsyncResult connectAsyncResult = new ConnectAsyncResult((object) this, remoteEP1, state, callback); connectAsyncResult.StartPostingAsyncOp(false); this.DoBeginConnect(remoteEP1, socketAddress, (LazyAsyncResult) connectAsyncResult); connectAsyncResult.FinishPostingAsyncOp(ref this.Caches.ConnectClosureCache); if (Socket.s_LoggingEnabled) Logging.Exit(Logging.Sockets, (object) this, "BeginConnect", (object) connectAsyncResult); return (IAsyncResult) connectAsyncResult; } }
internal IAsyncResult UnsafeBeginConnect(EndPoint remoteEP, AsyncCallback callback, object state) { if (this.CanUseConnectEx(remoteEP)) return this.BeginConnectEx(remoteEP, false, callback, state); EndPoint remoteEP1 = remoteEP; SocketAddress socketAddress = this.SnapshotAndSerialize(ref remoteEP1); ConnectAsyncResult connectAsyncResult = new ConnectAsyncResult((object) this, remoteEP1, state, callback); this.DoBeginConnect(remoteEP1, socketAddress, (LazyAsyncResult) connectAsyncResult); return (IAsyncResult) connectAsyncResult; }
internal IAsyncResult UnsafeBeginConnect(IPEndPoint remoteEP, AsyncCallback callback, object state) { if (CanUseConnectEx(remoteEP)) { return BeginConnectEx(remoteEP, false, callback, state); } EndPoint endPointSnapshot = remoteEP; var asyncResult = new ConnectAsyncResult(this, endPointSnapshot, state, callback); // For connectionless protocols, Connect is not an I/O call. Connect(remoteEP); asyncResult.FinishPostingAsyncOp(); // Synchronously complete the I/O and call the user's callback. asyncResult.InvokeCallback(); return asyncResult; }
// // 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()); }
internal IAsyncResult UnsafeBeginConnect(EndPoint remoteEP, AsyncCallback callback, object state) { if (this.CanUseConnectEx(remoteEP)) { return this.BeginConnectEx(remoteEP, false, callback, state); } EndPoint point = remoteEP; SocketAddress socketAddress = this.SnapshotAndSerialize(ref point); ConnectAsyncResult asyncResult = new ConnectAsyncResult(this, point, state, callback); this.DoBeginConnect(point, socketAddress, asyncResult); return asyncResult; }
public IAsyncResult BeginConnect(EndPoint remoteEP, AsyncCallback callback, object state) { if (s_LoggingEnabled) { Logging.Enter(Logging.Sockets, this, "BeginConnect", remoteEP); } if (this.CleanedUp) { throw new ObjectDisposedException(base.GetType().FullName); } if (remoteEP == null) { throw new ArgumentNullException("remoteEP"); } if (this.isListening) { throw new InvalidOperationException(SR.GetString("net_sockets_mustnotlisten")); } DnsEndPoint point = remoteEP as DnsEndPoint; if (point != null) { if ((point.AddressFamily != System.Net.Sockets.AddressFamily.Unspecified) && (point.AddressFamily != this.addressFamily)) { throw new NotSupportedException(SR.GetString("net_invalidversion")); } return this.BeginConnect(point.Host, point.Port, callback, state); } if (this.CanUseConnectEx(remoteEP)) { return this.BeginConnectEx(remoteEP, true, callback, state); } EndPoint point2 = remoteEP; SocketAddress socketAddress = this.CheckCacheRemote(ref point2, true); ConnectAsyncResult asyncResult = new ConnectAsyncResult(this, point2, state, callback); asyncResult.StartPostingAsyncOp(false); this.DoBeginConnect(point2, socketAddress, asyncResult); asyncResult.FinishPostingAsyncOp(ref this.Caches.ConnectClosureCache); if (s_LoggingEnabled) { Logging.Exit(Logging.Sockets, this, "BeginConnect", asyncResult); } return asyncResult; }