/// <summary> /// The Channel layer normalizes exceptions thrown by the underlying networking implementations /// into subclasses of CommunicationException, so that Channels can be used polymorphically from /// an exception handling perspective. /// </summary> internal static CommunicationException ConvertTransferException(SocketException socketException) { return new CommunicationException( string.Format(CultureInfo.CurrentCulture, "A Udp error ({0}: {1}) occurred while transmitting data.", socketException.ErrorCode, socketException.Message), socketException); }
private void OnDisconnect(/*OPTIONAL*/ SocketException socketException) { // This handles disconnects if, for example, the app exits // If we have any waiting operations, we want to abort them List<WaitingOperationDescriptor> operationsToAbort = null; lock (_waitingOperations) { operationsToAbort = new List<WaitingOperationDescriptor>(_waitingOperations.Values); _waitingOperations.Clear(); } foreach (var operation in operationsToAbort) { if (socketException == null) { operation.Abort(); } else { operation.OnSocketError(socketException); } } // Otherwise just drop the connection }
/// <summary> /// Determines if the exception thrown is a <see cref="SocketException"/> meaning that the connection was closed by the other side. /// </summary> public static bool IsConnectionAbortedByTheOtherSide(SocketException socketEx) { if (socketEx == null) throw new ArgumentNullException("socketEx"); return ConnectionClosedErrors.Contains(socketEx.SocketErrorCode); }
void Complete(SocketAsyncEventArgs e, bool completeSynchronously) { TransportBase transport = null; Exception exception = null; if (e.SocketError != SocketError.Success) { exception = new SocketException((int)e.SocketError); if (e.AcceptSocket != null) { e.AcceptSocket.Close(0); } } else { Fx.Assert(e.AcceptSocket != null, "Must have a valid socket accepted."); transport = new TcpTransport(e.AcceptSocket, this.transportSettings); transport.Open(); } e.Dispose(); this.callbackArgs.CompletedSynchronously = completeSynchronously; this.callbackArgs.Exception = exception; this.callbackArgs.Transport = transport; if (!completeSynchronously) { this.callbackArgs.CompletedCallback(this.callbackArgs); } }
public static TcpClient Connect(IPEndPoint remoteEndPoint, int timeoutMSec) { TimeoutObject.Reset(); socketexception = null; string serverip = Convert.ToString(remoteEndPoint.Address); int serverport = remoteEndPoint.Port; TcpClient tcpclient = new TcpClient(); tcpclient.BeginConnect(serverip, serverport, new AsyncCallback(CallBackMethod), tcpclient); if (TimeoutObject.WaitOne(timeoutMSec, false)) { if (IsConnectionSuccessful) { return tcpclient; } else { throw socketexception; } } else { tcpclient.Close(); throw new TimeoutException("TimeOut Exception"); } }
unsafe public void Run(object state) { byte[] address = new byte [1024]; int size = 1024; Errno errno; fixed(byte *ptr = address) do { accepted = accept(socket, ptr, ref size); errno = Stdlib.GetLastError(); } while ((int)accepted == -1 && errno == Errno.EINTR); if ((int)accepted == -1) { except = GetException(errno); } completed = true; if (waithandle != null) { waithandle.Set(); } if (callback != null) { callback(this); } }
public static unsafe SafeCloseSocket CreateSocket(SocketInformation socketInformation, out AddressFamily addressFamily, out SocketType socketType, out ProtocolType protocolType) { SafeCloseSocket handle; Interop.Winsock.WSAPROTOCOL_INFO protocolInfo; fixed (byte* pinnedBuffer = socketInformation.ProtocolInformation) { handle = SafeCloseSocket.CreateWSASocket(pinnedBuffer); protocolInfo = (Interop.Winsock.WSAPROTOCOL_INFO)Marshal.PtrToStructure<Interop.Winsock.WSAPROTOCOL_INFO>((IntPtr)pinnedBuffer); } if (handle.IsInvalid) { SocketException e = new SocketException(); if (e.SocketErrorCode == SocketError.InvalidArgument) { throw new ArgumentException(SR.net_sockets_invalid_socketinformation, "socketInformation"); } else { throw e; } } addressFamily = protocolInfo.iAddressFamily; socketType = (SocketType)protocolInfo.iSocketType; protocolType = (ProtocolType)protocolInfo.iProtocol; return handle; }
private async Task <SocketMessage> InternalReceiveAsync() { if (this.Closed) { throw new SocketException((int)SocketError.NotConnected); } SocketMessage msg = null; try { using (BinaryReader streamReader = new BinaryReader(this.Stream, Encoding.UTF8, true)) { int len = streamReader.ReadInt32(); byte[] block = streamReader.ReadBytes(len); object result = this.Serializer.ReadObject(new MemoryStream(block)); var wrapper = result as MessageWrapper; if (wrapper != null && wrapper.Message is SocketMessage) { msg = (SocketMessage)wrapper.Message; if (msg.Id == DisconnectMessageId) { // client is politely saying good bye... this.OnClosed(); } else if (msg.Id == ConnectedMessageId) { // must send an acknowledgement of the connect message this.Name = msg.Sender; await this.SendAsync(new SocketMessage(MessageAck, this.Name)); } else if (msg.Id == OpenBackChannelMessageId && this.Server != null) { // client is requesting a back channel. await this.HandleBackchannelRequest(msg); } } } } catch (EndOfStreamException) { this.OnClosed(); } catch (System.IO.IOException ioe) { System.Net.Sockets.SocketException se = ioe.InnerException as System.Net.Sockets.SocketException; if (se.SocketErrorCode == SocketError.ConnectionReset) { this.OnClosed(); } } catch (Exception ex) { this.OnError(ex); } return(msg); }
bool IsWouldBlockException(SocketException e) { #if CF return (e.NativeErrorCode == 10035); #else return (e.SocketErrorCode == SocketError.WouldBlock); #endif }
bool IsTimeoutException(SocketException e) { #if CF return (e.NativeErrorCode == 10060); #else return (e.SocketErrorCode == SocketError.TimedOut); #endif }
internal static IPAddress Parse(string ipString, bool tryParse) { if (ipString == null) { if (tryParse) { return null; } throw new ArgumentNullException("ipString"); } uint error = 0; // IPv6 Changes: Detect probable IPv6 addresses and use separate parse method. if (ipString.IndexOf(':') != -1) { // If the address string contains the colon character // then it can only be an IPv6 address. Use a separate // parse method to unpick it all. Note: we don't support // port specification at the end of address and so can // make this decision. uint scope; byte[] bytes = new byte[IPAddressParserStatics.IPv6AddressBytes]; error = IPAddressPal.Ipv6StringToAddress(ipString, bytes, out scope); if (error == IPAddressPal.SuccessErrorCode) { // AppCompat: .Net 4.5 ignores a correct port if the address was specified in brackets. // Will still throw for an incorrect port. return new IPAddress(bytes, (long)scope); } } else { ushort port; byte[] bytes = new byte[IPAddressParserStatics.IPv4AddressBytes]; error = IPAddressPal.Ipv4StringToAddress(ipString, bytes, out port); if (error == IPAddressPal.SuccessErrorCode) { if (port != 0) { throw new FormatException(SR.dns_bad_ip_address); } return new IPAddress(bytes); } } if (tryParse) { return null; } Exception e = new SocketException(IPAddressPal.GetSocketErrorForErrorCode(error), error); throw new FormatException(SR.dns_bad_ip_address, e); }
public int Connect(ref ArraySegment <byte> readBuffer, IList <ArraySegment <byte> > writeBuffer) { if (_state == StateNeedConnect) { _state = StateConnectPending; return(SocketOperation.Connect); } else if (_state <= StateConnectPending) { Debug.Assert(_writeEventArgs != null); if (_writeEventArgs.SocketError != SocketError.Success) { var ex = new System.Net.Sockets.SocketException((int)_writeEventArgs.SocketError); if (Network.ConnectionRefused(ex)) { throw new ConnectionRefusedException(ex); } else { throw new ConnectFailedException(ex); } } Debug.Assert(_fd != null); _desc = Network.FdToString(_fd, _proxy, _addr); _state = _proxy != null ? StateProxyWrite : StateConnected; } if (_state == StateProxyWrite) { Debug.Assert(_proxy != null); Debug.Assert(_addr != null); _proxy.BeginWrite(_addr, writeBuffer); return(SocketOperation.Write); } else if (_state == StateProxyRead) { Debug.Assert(_proxy != null); readBuffer = _proxy.BeginRead(); return(SocketOperation.Read); } else if (_state == StateProxyConnected) { Debug.Assert(_proxy != null); _proxy.Finish(readBuffer); // TODO Return buffers to the pool readBuffer = ArraySegment <byte> .Empty; writeBuffer.Clear(); _state = StateConnected; } Debug.Assert(_state == StateConnected); return(SocketOperation.None); }
public int initialize() { if(_state == StateNeedConnect) { _state = StateConnectPending; return SocketOperation.Connect; } else if(_state <= StateConnectPending) { try { #if ICE_SOCKET_ASYNC_API if(_writeEventArgs.SocketError != SocketError.Success) { SocketException ex = new SocketException((int)_writeEventArgs.SocketError); if(Network.connectionRefused(ex)) { throw new Ice.ConnectionRefusedException(ex); } else { throw new Ice.ConnectFailedException(ex); } } #else Network.doFinishConnectAsync(_fd, _writeResult); _writeResult = null; #endif _state = StateConnected; _desc = Network.fdToString(_fd); } catch(Ice.LocalException ex) { if(_traceLevels.network >= 2) { System.Text.StringBuilder s = new System.Text.StringBuilder(); s.Append("failed to establish tcp connection\n"); s.Append(Network.fdLocalAddressToString(_fd)); Debug.Assert(_addr != null); s.Append("\nremote address = " + _addr.ToString() + "\n"); s.Append(ex.ToString()); _logger.trace(_traceLevels.networkCat, s.ToString()); } throw; } if(_traceLevels.network >= 1) { string s = "tcp connection established\n" + _desc; _logger.trace(_traceLevels.networkCat, s); } } Debug.Assert(_state == StateConnected); return SocketOperation.None; }
private void RecvCallback_obsolete(IAsyncResult ar) { try { if (RemoteState != null) { if (RemoteState.Stream.CanRead) { int len = RemoteState.Stream.EndRead(ar); if (len == 0) { Disconnect(); } else { string data = ""; if (ProtocolStrategy != null) { data = ProtocolStrategy.Encoding.GetString(RemoteState.ReadBuffer, 0, len); ProtocolStrategy.Parse(data, null); } RemoteState.Stream.BeginRead(RemoteState.ReadBuffer, 0, RemoteState.ReadBuffer.Length, new AsyncCallback(RecvCallback_obsolete), null); } } } else { } } catch (System.IO.IOException ioe) { if (ioe.InnerException.GetType() == typeof(System.Net.Sockets.SocketError)) { System.Net.Sockets.SocketException se = (System.Net.Sockets.SocketException)ioe.InnerException; try { Disconnect(); } catch (NullReferenceException) { } catch (Exception e) { OnAsyncException(new ExceptionEventArgs(e)); } } } catch (NullReferenceException) { } catch (Exception e) { OnAsyncException(new ExceptionEventArgs(e)); } }
protected bool ValidateAsyncResult(SocketAsyncEventArgs e) { if (e.SocketError != SocketError.Success) { var socketException = new SocketException((int)e.SocketError); OnCompleted(new ProxyEventArgs(new Exception(socketException.Message, socketException))); return false; } return true; }
static ErrorType HandleDnsLookupError( string context, SocketException se ) { switch( se.SocketErrorCode ) { case SocketError.HostNotFound: case SocketError.NoData: return ErrorType.PermanentKnown; default: Debug.WriteLine( string.Format( "WARNING: Unexpected SocketException with SocketErrorCode=={0} in {1}", Enum.GetName(typeof(SocketError),se.SocketErrorCode), context ) ); return ErrorType.TemporaryUnknown; } }
public static Exception ConvertListenException(SocketException socketException, IPEndPoint localEndpoint) { if (socketException.ErrorCode == 6) { return new CommunicationObjectAbortedException(socketException.Message, socketException); } if (socketException.ErrorCode == 0x2740) { return new AddressAlreadyInUseException(System.ServiceModel.SR.GetString("TcpAddressInUse", new object[] { localEndpoint.ToString() }), socketException); } return new CommunicationException(System.ServiceModel.SR.GetString("TcpListenError", new object[] { socketException.ErrorCode, socketException.Message, localEndpoint.ToString() }), socketException); }
void HandleIOException(System.IO.IOException ioe, RemoteHostState state) { if (ioe.InnerException.GetType() == typeof(System.Net.Sockets.SocketError)) { System.Net.Sockets.SocketException se = (System.Net.Sockets.SocketException)ioe.InnerException; CloseConnection(state, (se.SocketErrorCode == SocketError.Interrupted) ? null : se); } else { CloseConnection(state, ioe); } }
internal ServerMockReceivedEventArgs( SocketAsyncEventArgs context ) { this._context = context; if ( context.SocketError != SocketError.Success ) { this._socketException = new SocketException( ( int )context.SocketError ); } else { this._socketException = null; } }
public int connect(Buffer readBuffer, Buffer writeBuffer, ref bool moreData) { if(_state == StateNeedConnect) { _state = StateConnectPending; return SocketOperation.Connect; } else if(_state <= StateConnectPending) { #if ICE_SOCKET_ASYNC_API if(_writeEventArgs.SocketError != SocketError.Success) { SocketException ex = new SocketException((int)_writeEventArgs.SocketError); if(Network.connectionRefused(ex)) { throw new Ice.ConnectionRefusedException(ex); } else { throw new Ice.ConnectFailedException(ex); } } #else Network.doFinishConnectAsync(_fd, _writeResult); _writeResult = null; #endif _desc = Network.fdToString(_fd, _proxy, _addr); _state = _proxy != null ? StateProxyWrite : StateConnected; } if(_state == StateProxyWrite) { _proxy.beginWrite(_addr, writeBuffer); return SocketOperation.Write; } else if(_state == StateProxyRead) { _proxy.beginRead(readBuffer); return SocketOperation.Read; } else if(_state == StateProxyConnected) { _proxy.finish(readBuffer, writeBuffer); readBuffer.clear(); writeBuffer.clear(); _state = StateConnected; } Debug.Assert(_state == StateConnected); return SocketOperation.None; }
private void server_ErrorReceived(object sender, NetSockErrorReceivedEventArgs e) { if (e.Exception.GetType() == typeof(System.Net.Sockets.SocketException)) { System.Net.Sockets.SocketException s = (System.Net.Sockets.SocketException)e.Exception; account.Log(new ErrorTextInformation("Error: " + e.Function + " - " + s.SocketErrorCode.ToString() + "\r\n" + s.ToString()), 0); } else { account.Log(new ErrorTextInformation("Error: " + e.Function + "\r\n" + e.Exception.ToString()), 0); } }
private void OnSocketError(object sender, EventNetSockErrorReceived e) { if (e.Exception.GetType() == typeof(System.Net.Sockets.SocketException)) { System.Net.Sockets.SocketException s = (System.Net.Sockets.SocketException)e.Exception; Debug.Log("OnSocketError > System.Net.Sockets Exception " + e.Function + " - " + s.SocketErrorCode.ToString() + " => " + s.ToString()); } else { Debug.Log("OnSocketError > ERROR : " + e.Function.ToString() + " => " + e.Exception.ToString()); } _ReceiveSchedule.AddMessage(eEventIDs.SocketError); }
private void catchSocketException(System.Net.Sockets.SocketException e) { Console.WriteLine("Socket Error..."); if (e.ErrorCode == /*WSAECONNRESET*/ 0x2746) { state = CONNSTATE.Disconnected; form.updateConnectionListEntry(this); } else { die(); } }
public static void ThrowServerException(SocketException e, ServerContext serverContext = null) { string ipAddress = serverContext != null ? serverContext.IPAddress.ToString() : "unknown"; string port = serverContext != null ? serverContext.Port.ToString() : "-"; if (ipAddress.Equals("0.0.0.0")) ipAddress = "any"; if (e.Message.StartsWith("Only one usage of each socket address")) throw new ServerException( string.Format( "Can't bind to socket on port {0} for IP addresses ({1}) because it is already in use (is the server already running?)", port, ipAddress), e); throw e; }
void WriteCallback(IAsyncResult ar) { try { RemoteHostState state = ar.AsyncState as RemoteHostState; state.Stream.EndWrite(ar); } catch (System.IO.IOException ioe) { if (ioe.InnerException.GetType() == typeof(System.Net.Sockets.SocketError)) { System.Net.Sockets.SocketException se = (System.Net.Sockets.SocketException)ioe.InnerException; if (DoCloseConnection()) { OnClosedConnection((se.SocketErrorCode == SocketError.Interrupted) ? null : se); } } else if (DoCloseConnection()) { OnClosedConnection(ioe); } return; } //We dont need to take care of ObjectDisposedException. //ObjectDisposedException would indicate that the state has been closed, and that means it has been disconnected already catch { } bool doSendMore = false; if (RemoteState != null) { lock (RemoteState.SendQueue) { RemoteState.SendQueue.Dequeue(); if (RemoteState.SendQueue.Count > 0) { doSendMore = true; } } } if (doSendMore) { DoSend(); } }
public static bool IsDisconnected(SocketException exception) { switch ((SocketError) exception.ErrorCode) { case SocketError.ConnectionAborted: case SocketError.ConnectionReset: case SocketError.Fault: case SocketError.NetworkReset: case SocketError.OperationAborted: case SocketError.Shutdown: case SocketError.SocketError: case SocketError.TimedOut: return true; } return false; }
public static bool IsSocketDisconnectedException(SocketException socketException) { var errorCode = socketException.SocketErrorCode; return errorCode == SocketError.NetworkDown || errorCode == SocketError.NetworkReset || errorCode == SocketError.NetworkUnreachable || errorCode == SocketError.ConnectionAborted || errorCode == SocketError.ConnectionReset || errorCode == SocketError.HostNotFound || errorCode == SocketError.HostUnreachable || errorCode == SocketError.NotConnected || errorCode == SocketError.Shutdown || errorCode == SocketError.Disconnecting || errorCode == SocketError.AddressNotAvailable || errorCode == SocketError.TimedOut; }
protected bool ValidateAsyncResult(SocketAsyncEventArgs e) { if (e == null) { throw new ArgumentNullException("e"); } if (e.SocketError != SocketError.Success) { var socketException = new SocketException((int)e.SocketError); this.OnCompleted(new ProxyEventArgs(new Exception(socketException.Message, socketException))); return false; } return true; }
private static void CurrentDomain_FirstChanceException(object sender, System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs e) { if (ExceptionLogger != null) { System.Net.Sockets.SocketException tempExcption = null; if (e.Exception is System.Net.Sockets.SocketException) { tempExcption = (System.Net.Sockets.SocketException)e.Exception; } if (tempExcption == null || (tempExcption.ErrorCode != 125 && tempExcption.ErrorCode != 111 && tempExcption.ErrorCode != 104)) { ExceptionLogger.Error("Exception: {0} ", e.Exception.ToString()); } } }
void Complete(SocketAsyncEventArgs e, bool completeSynchronously) { TransportBase transport = null; Exception exception = null; if (e.SocketError != SocketError.Success) { exception = new SocketException((int)e.SocketError); if (e.AcceptSocket != null) { e.AcceptSocket.Dispose(); } } else { try { Fx.Assert(e.ConnectSocket != null, "Must have a valid socket accepted."); e.ConnectSocket.NoDelay = true; transport = new TcpTransport(e.ConnectSocket, this.transportSettings); transport.Open(); } catch (Exception exp) { if (Fx.IsFatal(exp)) { throw; } exception = exp; if (transport != null) { transport.SafeClose(); } transport = null; } } e.Dispose(); this.callbackArgs.CompletedSynchronously = completeSynchronously; this.callbackArgs.Exception = exception; this.callbackArgs.Transport = transport; if (!completeSynchronously) { this.callbackArgs.CompletedCallback(this.callbackArgs); } }
public static void Connect(this TcpClient connection, string ip, int port, out SocketException ex) { ex = null; for (int i = 0; i < 10 && !connection.Connected; i++) { try { connection.Connect(IPAddress.Parse(ip), port); break; } catch (SocketException se) { ex = se; continue; } } }
private static void ShowError(SocketException aSocketException) { String errorText; switch (aSocketException.ErrorCode) { case 10060: errorText = ExceptionStrings.ErrorWsaETimedOut; break; case 10061: errorText = ExceptionStrings.ErrorWsaEConnRefused; break; default: errorText = Convert.ToString(aSocketException.ErrorCode) + "; " + aSocketException.Message; break; } ShowError(errorText); }
internal static Exception ConvertSocketException(SocketException socketException, string operation) { if (socketException.ErrorCode == 10049 // WSAEADDRNOTAVAIL || socketException.ErrorCode == 10061 // WSAECONNREFUSED || socketException.ErrorCode == 10050 // WSAENETDOWN || socketException.ErrorCode == 10051 // WSAENETUNREACH || socketException.ErrorCode == 10064 // WSAEHOSTDOWN || socketException.ErrorCode == 10065) // WSAEHOSTUNREACH { return new EndpointNotFoundException(string.Format(operation + " error: {0} ({1})", socketException.Message, socketException.ErrorCode), socketException); } if (socketException.ErrorCode == 10060) // WSAETIMEDOUT { return new TimeoutException(operation + " timed out.", socketException); } else { return new CommunicationException(string.Format(operation + " error: {0} ({1})", socketException.Message, socketException.ErrorCode), socketException); } }
private void SendFileInternal(string fileName, byte[] preBuffer, byte[] postBuffer, TransmitFileOptions flags) { CheckTransmitFileOptions(flags); // Open the file, if any // Open it before we send the preBuffer so that any exception happens first FileStream fileStream = OpenFile(fileName); SocketError errorCode = SocketError.Success; using (fileStream) { // Send the preBuffer, if any // This will throw on error if (preBuffer != null && preBuffer.Length > 0) { Send(preBuffer); } // Send the file, if any if (fileStream != null) { // This can throw ObjectDisposedException. errorCode = SocketPal.SendFile(_handle, fileStream); } } if (errorCode != SocketError.Success) { SocketException socketException = new SocketException((int)errorCode); UpdateStatusAfterSocketError(socketException); if (NetEventSource.IsEnabled) NetEventSource.Error(this, socketException); throw socketException; } // Send the postBuffer, if any // This will throw on error if (postBuffer != null && postBuffer.Length > 0) { Send(postBuffer); } }
public void Connect(TcpClient client, out SocketException ex) { ex = null; for (int i = 0; i < 10 && !ReadWriteClient.Connected; i++) { try { if (client.Equals(ReadWriteClient)) client.Connect(_readWriteEndpoint); if (client.Equals(ReadOnlyClient)) client.Connect(_readOnlyEndpoint); break; } catch (SocketException se) { ex = se; continue; } } }
void DoSend() { try { byte[] data = null; lock (RemoteState.SendQueue) { if (RemoteState.SendQueue.Count > 0) { data = RemoteState.SendQueue.Peek(); } } if (data != null) { RemoteState.Stream.BeginWrite(data, 0, data.Length, writeCallback, RemoteState); } } catch (System.IO.IOException ioe) { if (ioe.InnerException.GetType() == typeof(System.Net.Sockets.SocketError)) { System.Net.Sockets.SocketException se = (System.Net.Sockets.SocketException)ioe.InnerException; if (DoCloseConnection()) { OnClosedConnection((se.SocketErrorCode == SocketError.Interrupted) ? null : se); } } else if (DoCloseConnection()) { OnClosedConnection(ioe); } } //We dont need to take care of ObjectDisposedException. //ObjectDisposedException would indicate that the state has been closed, and that means it has been disconnected already catch { } }
private static void CallBackMethod(IAsyncResult asyncresult) { try { IsConnectionSuccessful = false; TcpClient tcpclient = asyncresult.AsyncState as TcpClient; if (tcpclient.Client != null) { tcpclient.EndConnect(asyncresult); IsConnectionSuccessful = true; } } catch (Exception ex) { IsConnectionSuccessful = false; socketexception = (SocketException) ex; } finally { TimeoutObject.Set(); } }
/// <summary> /// 错误日志 /// </summary> /// <param name="error">错误异常</param> public static void ErrorLog(Exception error) { if (error != null) { IOException ioError = error as IOException; if (ioError != null) { error = ioError.InnerException; } ObjectDisposedException disposedError = error.InnerException as ObjectDisposedException; if (disposedError == null) { System.Net.Sockets.SocketException socketException = error as System.Net.Sockets.SocketException; if (socketException == null || socketException.ErrorCode != 10053 || socketException.ErrorCode != 10054) { log.Default.Add(error, null, true); } } else { log.Default.Add(error, null, true); } } }
public void SplashPresenter_StartApplication_Picks_Up_SocketExceptions_When_Starting_WebServer() { var exception = new SocketException(); _WebServer.SetupSet(s => s.Online = true).Callback(() => { throw exception; }); _WebServer.Setup(a => a.Port).Returns(123); _Presenter.Initialise(_View.Object); _Presenter.StartApplication(); _Log.Verify(g => g.WriteLine("Caught exception when starting web server: {0}", exception.ToString()), Times.Once()); _View.Verify(v => v.ReportProblem(String.Format(Strings.CannotStartWebServerFull, 123), Strings.CannotStartWebServerTitle, false), Times.Once()); _View.Verify(v => v.ReportProblem(Strings.SuggestUseDifferentPortFull, Strings.SuggestUseDifferentPortTitle, false), Times.Once()); }
// Callback which fires when an internal connection attempt completes. // If it failed and there are more addresses to try, do it. private void InternalConnectCallback(object sender, SocketAsyncEventArgs args) { Exception exception = null; lock (_lockObject) { if (_state == State.Canceled) { // If Cancel was called before we got the lock, the Socket will be closed soon. We need to report // OperationAborted (even though the connection actually completed), or the user will try to use a // closed Socket. exception = new SocketException((int)SocketError.OperationAborted); } else if (_state == State.ConnectAttempt) { if (args.SocketError == SocketError.Success) { if (RequiresUserConnectAttempt) { exception = AttemptUserConnection(); if (exception == null) { // Don't call the callback; we've started a connection attempt on the // user's socket. _state = State.UserConnectAttempt; return; } } // The connection attempt succeeded or the user connect attempt failed synchronously; go to the // completed state. The callback will be called outside the lock. _state = State.Completed; } else if (args.SocketError == SocketError.OperationAborted) { // The socket was closed while the connect was in progress. This can happen if the user // closes the socket, and is equivalent to a call to CancelConnectAsync exception = new SocketException((int)SocketError.OperationAborted); _state = State.Canceled; } else { // Try again, if there are more IPAddresses to be had. // If the underlying OS does not support multiple connect attempts // on the same socket, dispose the socket used for the last attempt. if (!SocketPal.SupportsMultipleConnectAttempts) { _lastAttemptSocket.Dispose(); } // Keep track of this because it will be overwritten by AttemptConnection SocketError currentFailure = args.SocketError; Exception connectException = AttemptConnection(); if (connectException == null) { // don't call the callback, another connection attempt is successfully started return; } else { SocketException socketException = connectException as SocketException; if (socketException != null && socketException.SocketErrorCode == SocketError.NoData) { // If the error is NoData, that means there are no more IPAddresses to attempt // a connection to. Return the last error from an actual connection instead. exception = new SocketException((int)currentFailure); } else { exception = connectException; } _state = State.Completed; } } } else { if (GlobalLog.IsEnabled) { if (_state != State.UserConnectAttempt) { GlobalLog.Assert("MultipleConnectAsync.InternalConnectCallback(): Unexpected object state"); } if (!RequiresUserConnectAttempt) { GlobalLog.Assert("MultipleConnectAsync.InternalConnectCallback(): State.UserConnectAttempt without RequiresUserConnectAttempt"); } } if (args.SocketError == SocketError.Success) { _state = State.Completed; } else if (args.SocketError == SocketError.OperationAborted) { // The socket was closed while the connect was in progress. This can happen if the user // closes the socket, and is equivalent to a call to CancelConnectAsync exception = new SocketException((int)SocketError.OperationAborted); _state = State.Canceled; } else { // The connect attempt on the user's socket failed. Return the corresponding error. exception = new SocketException((int)args.SocketError); _state = State.Completed; } } } if (exception == null) { Succeed(); } else { AsyncFail(exception); } }
// Callback which fires when an internal connection attempt completes. // If it failed and there are more addresses to try, do it. private void InternalConnectCallback(object sender, SocketAsyncEventArgs args) { Exception exception = null; lock (_lockObject) { if (_state == State.Canceled) { // If Cancel was called before we got the lock, the Socket will be closed soon. We need to report // OperationAborted (even though the connection actually completed), or the user will try to use a // closed Socket. exception = new SocketException((int)SocketError.OperationAborted); } else { Debug.Assert(_state == State.ConnectAttempt); if (args.SocketError == SocketError.Success) { // The connection attempt succeeded; go to the completed state. // The callback will be called outside the lock. _state = State.Completed; } else if (args.SocketError == SocketError.OperationAborted) { // The socket was closed while the connect was in progress. This can happen if the user // closes the socket, and is equivalent to a call to CancelConnectAsync exception = new SocketException((int)SocketError.OperationAborted); _state = State.Canceled; } else { // Keep track of this because it will be overwritten by AttemptConnection SocketError currentFailure = args.SocketError; Exception connectException = AttemptConnection(); if (connectException == null) { // don't call the callback, another connection attempt is successfully started return; } else { SocketException socketException = connectException as SocketException; if (socketException != null && socketException.SocketErrorCode == SocketError.NoData) { // If the error is NoData, that means there are no more IPAddresses to attempt // a connection to. Return the last error from an actual connection instead. exception = new SocketException((int)currentFailure); } else { exception = connectException; } _state = State.Completed; } } } } if (exception == null) { Succeed(); } else { AsyncFail(exception); } }
private static IOException GetExceptionFromSocketException(string message, SocketException innerException) { return(new IOException(message, innerException)); }
// Callback which fires when an internal connection attempt completes. // If it failed and there are more addresses to try, do it. // Returns true if the operation is pending, false if it completed synchronously. private bool DoConnectCallback(SocketAsyncEventArgs args, bool sync) { Exception?exception = null; Debug.Assert(!Monitor.IsEntered(_lockObject)); lock (_lockObject) { if (_state == State.Canceled) { // If Cancel was called before we got the lock, the Socket will be closed soon. We need to report // OperationAborted (even though the connection actually completed), or the user will try to use a // closed Socket. exception = new SocketException((int)SocketError.OperationAborted); } else { while (true) { Debug.Assert(_state == State.ConnectAttempt); if (args.SocketError == SocketError.Success) { // The connection attempt succeeded; go to the completed state. // The callback will be called outside the lock. _state = State.Completed; break; } else if (args.SocketError == SocketError.OperationAborted) { // The socket was closed while the connect was in progress. This can happen if the user // closes the socket, and is equivalent to a call to CancelConnectAsync exception = new SocketException((int)SocketError.OperationAborted); _state = State.Canceled; break; } else { // Keep track of this because it will be overwritten by AttemptConnection SocketError currentFailure = args.SocketError; (Exception? connectException, bool pending) = AttemptConnection(); if (connectException == null) { if (pending) { // don't call the callback, another connection attempt is successfully started return(true); } // We have a sync completion from AttemptConnection. // Loop around and process its results. } else { SocketException?socketException = connectException as SocketException; if (socketException != null && socketException.SocketErrorCode == SocketError.NoData) { // If the error is NoData, that means there are no more IPAddresses to attempt // a connection to. Return the last error from an actual connection instead. exception = new SocketException((int)currentFailure); } else { exception = connectException; } _state = State.Completed; break; } } } } } if (exception != null) { return(Fail(sync, exception)); } else { return(Succeed(sync)); } }
private void ThrowIOSocketException() { var se = new SocketException((int)SocketError); throw new IOException(SR.Format(SR.net_io_readfailure, se.Message), se); }
/// <summary> /// Raises the <see cref="ClientBase.ReceiveDataException"/> event. /// </summary> /// <param name="ex">Exception to send to <see cref="ClientBase.ReceiveDataException"/> event.</param> protected void OnReceiveDataException(SocketException ex) { if (ex.SocketErrorCode != SocketError.Disconnecting) OnReceiveDataException((Exception)ex); }
private void ReadCallback(IAsyncResult ar) { try { RemoteHostState state = ar.AsyncState as RemoteHostState; int len = 0; len = state.Stream.EndRead(ar); if (len == 0) { CloseConnection(); } else { try { if (ProtocolStrategy != null) { if (ProtocolStrategy.Encoding != null) { if (state.Decoder == null) { state.Decoder = ProtocolStrategy.Encoding.GetDecoder(); } int charCount = state.Decoder.GetCharCount(state.ReadBuffer, 0, len); char[] chars = new char[charCount]; state.Decoder.GetChars(state.ReadBuffer, 0, len, chars, 0); string msg = new string(chars); ProtocolStrategy.Parse(msg, state); } else { ProtocolStrategy.Parse(state.ReadBuffer, len, state); } } } catch { } state.Stream.BeginRead(state.ReadBuffer, 0, state.ReadBuffer.Length, readCallback, state); } } catch (System.IO.IOException ioe) { if (ioe.InnerException.GetType() == typeof(System.Net.Sockets.SocketError)) { System.Net.Sockets.SocketException se = (System.Net.Sockets.SocketException)ioe.InnerException; if (DoCloseConnection()) { OnClosedConnection((se.SocketErrorCode == SocketError.Interrupted) ? null : se); } } else if (DoCloseConnection()) { OnClosedConnection(ioe); } } //We dont need to take care of ObjectDisposedException. //ObjectDisposedException would indicate that the state has been closed, and that means it has been disconnected already catch { } }
private async Task <SocketMessage> InternalReceiveAsync() { if (this.Closed) { throw new SocketException((int)SocketError.NotConnected); } SocketMessage msg = null; try { using (BinaryReader streamReader = new BinaryReader(this.Stream, Encoding.UTF8, true)) { int len = streamReader.ReadInt32(); byte[] block = streamReader.ReadBytes(len); object result = null; if (len != block.Length) { // Can happen if the process at the other side of this socket was terminated. // If we don't have the exact requested bytes then we cannot deserialize it. } else { try { result = this.Serializer.ReadObject(new MemoryStream(block)); } catch (Exception) { // This can also happen when process on other side is terminated, the last network // packet can be scrambled. This is usually just the DisconnectMessageId which is // ignorable. } } var wrapper = result as MessageWrapper; if (wrapper != null && wrapper.Message is SocketMessage) { msg = (SocketMessage)wrapper.Message; if (msg.Id == DisconnectMessageId) { // client is politely saying good bye... this.OnClosed(); } else if (msg.Id == ConnectedMessageId) { // must send an acknowledgement of the connect message this.Name = msg.Sender; await this.SendAsync(new SocketMessage(MessageAck, this.Name)); } else if (msg.Id == OpenBackChannelMessageId && this.Server != null) { // client is requesting a back channel. await this.HandleBackchannelRequest(msg); } } } } catch (EndOfStreamException) { this.OnClosed(); } catch (System.IO.IOException ioe) { System.Net.Sockets.SocketException se = ioe.InnerException as System.Net.Sockets.SocketException; if (se.SocketErrorCode == SocketError.ConnectionReset) { this.OnClosed(); } } catch (Exception ex) { this.OnError(ex); } return(msg); }
internal void OnSocketError(SocketException socketException) { _completionSource.TrySetException(new JdwpException(ErrorCode.SocketError, "Socket error reading the result", socketException)); }
public void FinishWrite(IList <ArraySegment <byte> > buffer, ref int offset) { Debug.Assert(_writeEventArgs != null); Debug.Assert(offset == 0); if (_fd == null) { int count = buffer.GetByteCount(); // Assume all the data was sent for at-most-once semantics. _writeEventArgs = null; offset = count; return; } if (!_incoming && _state < StateConnected) { if (_writeEventArgs.SocketError != SocketError.Success) { var ex = new System.Net.Sockets.SocketException((int)_writeEventArgs.SocketError); if (Network.ConnectionRefused(ex)) { throw new ConnectionRefusedException(ex); } else { throw new ConnectFailedException(ex); } } return; } int ret; try { if (_writeEventArgs.SocketError != SocketError.Success) { throw new System.Net.Sockets.SocketException((int)_writeEventArgs.SocketError); } ret = _writeEventArgs.BytesTransferred; _writeEventArgs.SetBuffer(null, 0, 0); if (_writeEventArgs.BufferList != null && _writeEventArgs.BufferList != buffer) { _writeEventArgs.BufferList.Clear(); } _writeEventArgs.BufferList = null; } catch (System.Net.Sockets.SocketException ex) { if (Network.ConnectionLost(ex)) { throw new ConnectionLostException(ex); } else { throw new Ice.SocketException(ex); } } if (ret == 0) { throw new ConnectionLostException(); } Debug.Assert(ret > 0); Debug.Assert(ret == buffer.GetByteCount()); offset = ret; return; }
private void _DaemonPipe_OnDisconnected(SocketException se) { if (se != null) Console.WriteLine("Disconnected! " + se.Message); else Console.WriteLine("Disconnected!"); }
private async Task SendFileInternalAsync(FileStream fileStream, byte[] preBuffer, byte[] postBuffer) { SocketError errorCode = SocketError.Success; using (fileStream) { // Send the preBuffer, if any // This will throw on error if (preBuffer != null && preBuffer.Length > 0) { // Using "this." makes the extension method kick in await this.SendAsync(new ArraySegment <byte>(preBuffer), SocketFlags.None).ConfigureAwait(false); } // Send the file, if any if (fileStream != null) { var tcs = new TaskCompletionSource <bool>(); // This can throw ObjectDisposedException. errorCode = SocketPal.SendFileAsync(_handle, fileStream, (bytesTransferred, socketError) => { if (socketError != SocketError.Success) { // Synchronous exception from SendFileAsync SocketException socketException = new SocketException((int)errorCode); UpdateStatusAfterSocketError(socketException); if (NetEventSource.IsEnabled) { NetEventSource.Error(this, socketException); } tcs.SetException(socketException); } tcs.SetResult(true); }); await tcs.Task.ConfigureAwait(false); } } if (errorCode != SocketError.Success) { // Synchronous exception from SendFileAsync SocketException socketException = new SocketException((int)errorCode); UpdateStatusAfterSocketError(socketException); if (NetEventSource.IsEnabled) { NetEventSource.Error(this, socketException); } throw socketException; } // Send the postBuffer, if any // This will throw on error if (postBuffer != null && postBuffer.Length > 0) { // Using "this." makes the extension method kick in await this.SendAsync(new ArraySegment <byte>(postBuffer), SocketFlags.None).ConfigureAwait(false); } }