private int write(ByteBuffer buf) { Debug.Assert(_fd != null); if (AssemblyUtil.isMono) { // // Mono on Android and iOS don't support the use of synchronous socket // operations on a non-blocking socket. Returning 0 here forces the caller to schedule // an asynchronous operation. // return(0); } int packetSize = buf.remaining(); if (AssemblyUtil.isWindows) { // // On Windows, limiting the buffer size is important to prevent // poor throughput performances when transfering large amount of // data. See Microsoft KB article KB823764. // if (_maxSendPacketSize > 0 && packetSize > _maxSendPacketSize / 2) { packetSize = _maxSendPacketSize / 2; } } int sent = 0; while (buf.hasRemaining()) { try { int ret = _fd.Send(buf.rawBytes(), buf.position(), packetSize, SocketFlags.None); Debug.Assert(ret > 0); sent += ret; buf.position(buf.position() + ret); if (packetSize > buf.remaining()) { packetSize = buf.remaining(); } } catch (SocketException ex) { if (Network.wouldBlock(ex)) { return(sent); } else if (Network.connectionLost(ex)) { throw new Ice.ConnectionLostException(ex); } throw new Ice.SocketException(ex); } } return(sent); }
private int write(ByteBuffer buf) { Debug.Assert(_fd != null); int packetSize = buf.remaining(); if (AssemblyUtil.platform_ == AssemblyUtil.Platform.Windows) { // // On Windows, limiting the buffer size is important to prevent // poor throughput performances when transfering large amount of // data. See Microsoft KB article KB823764. // if (_maxSendPacketSize > 0 && packetSize > _maxSendPacketSize / 2) { packetSize = _maxSendPacketSize / 2; } } int sent = 0; while (buf.hasRemaining()) { try { int ret = _fd.Send(buf.rawBytes(), buf.position(), packetSize, SocketFlags.None); Debug.Assert(ret > 0); sent += ret; buf.position(buf.position() + ret); if (packetSize > buf.remaining()) { packetSize = buf.remaining(); } } catch (SocketException ex) { if (Network.wouldBlock(ex)) { return(sent); } else if (Network.connectionLost(ex)) { throw new Ice.ConnectionLostException(ex); } throw new Ice.SocketException(ex); } } return(sent); }
private int read(ByteBuffer buf) { Debug.Assert(_fd != null); #if COMPACT || SILVERLIGHT // // Silverlight and the Compact .NET Framework don't // support the use of synchronous socket operations on a // non-blocking socket. Returning 0 here forces the caller // to schedule an asynchronous operation. // return(0); #else int read = 0; while (buf.hasRemaining()) { try { int ret = _fd.Receive(buf.rawBytes(), buf.position(), buf.remaining(), SocketFlags.None); if (ret == 0) { throw new Ice.ConnectionLostException(); } read += ret; buf.position(buf.position() + ret); } catch (SocketException ex) { if (Network.wouldBlock(ex)) { return(read); } else if (Network.interrupted(ex)) { continue; } else if (Network.connectionLost(ex)) { throw new Ice.ConnectionLostException(ex); } throw new Ice.SocketException(ex); } } return(read); #endif }
private int read(ByteBuffer buf) { Debug.Assert(_fd != null); if (AssemblyUtil.isMono) { // // Mono on Android and iOS don't support the use of synchronous socket // operations on a non-blocking socket. Returning 0 here forces the caller to schedule // an asynchronous operation. // return(0); } int read = 0; while (buf.hasRemaining()) { try { int ret = _fd.Receive(buf.rawBytes(), buf.position(), buf.remaining(), SocketFlags.None); if (ret == 0) { throw new Ice.ConnectionLostException(); } read += ret; buf.position(buf.position() + ret); } catch (SocketException ex) { if (Network.wouldBlock(ex)) { return(read); } else if (Network.interrupted(ex)) { continue; } else if (Network.connectionLost(ex)) { throw new Ice.ConnectionLostException(ex); } throw new Ice.SocketException(ex); } } return(read); }
private int read(ByteBuffer buf) { Debug.Assert(_fd != null); int read = 0; while (buf.hasRemaining()) { try { int ret = _fd.Receive(buf.rawBytes(), buf.position(), buf.remaining(), SocketFlags.None); if (ret == 0) { throw new Ice.ConnectionLostException(); } read += ret; buf.position(buf.position() + ret); } catch (SocketException ex) { if (Network.wouldBlock(ex)) { return(read); } else if (Network.interrupted(ex)) { continue; } else if (Network.connectionLost(ex)) { throw new Ice.ConnectionLostException(ex); } throw new Ice.SocketException(ex); } } return(read); }
private int write(ByteBuffer buf) { Debug.Assert(_fd != null); #if COMPACT || SILVERLIGHT // // Silverlight and the Compact .NET Frameworks don't // support the use of synchronous socket operations on a // non-blocking socket. Returning 0 here forces the caller // to schedule an asynchronous operation. // return 0; #else int packetSize = buf.remaining(); if(AssemblyUtil.platform_ == AssemblyUtil.Platform.Windows) { // // On Windows, limiting the buffer size is important to prevent // poor throughput performances when transfering large amount of // data. See Microsoft KB article KB823764. // if(_maxSendPacketSize > 0 && packetSize > _maxSendPacketSize / 2) { packetSize = _maxSendPacketSize / 2; } } int sent = 0; while(buf.hasRemaining()) { try { int ret = _fd.Send(buf.rawBytes(), buf.position(), packetSize, SocketFlags.None); Debug.Assert(ret > 0); sent += ret; buf.position(buf.position() + ret); if(packetSize > buf.remaining()) { packetSize = buf.remaining(); } } catch(SocketException ex) { if(Network.wouldBlock(ex)) { return sent; } else if(Network.connectionLost(ex)) { throw new Ice.ConnectionLostException(ex); } throw new Ice.SocketException(ex); } } return sent; #endif }
private int read(ByteBuffer buf) { Debug.Assert(_fd != null); #if COMPACT || SILVERLIGHT // // Silverlight and the Compact .NET Framework don't // support the use of synchronous socket operations on a // non-blocking socket. Returning 0 here forces the caller // to schedule an asynchronous operation. // return 0; #else int read = 0; while(buf.hasRemaining()) { try { int ret = _fd.Receive(buf.rawBytes(), buf.position(), buf.remaining(), SocketFlags.None); if(ret == 0) { throw new Ice.ConnectionLostException(); } read += ret; buf.position(buf.position() + ret); } catch(SocketException ex) { if(Network.wouldBlock(ex)) { return read; } else if(Network.interrupted(ex)) { continue; } else if(Network.connectionLost(ex)) { throw new Ice.ConnectionLostException(ex); } throw new Ice.SocketException(ex); } } return read; #endif }
private int write(ByteBuffer buf) { Debug.Assert(_fd != null); int packetSize = buf.remaining(); if(AssemblyUtil.platform_ == AssemblyUtil.Platform.Windows) { // // On Windows, limiting the buffer size is important to prevent // poor throughput performances when transfering large amount of // data. See Microsoft KB article KB823764. // if(_maxSendPacketSize > 0 && packetSize > _maxSendPacketSize / 2) { packetSize = _maxSendPacketSize / 2; } } int sent = 0; while(buf.hasRemaining()) { try { int ret = _fd.Send(buf.rawBytes(), buf.position(), packetSize, SocketFlags.None); Debug.Assert(ret > 0); sent += ret; buf.position(buf.position() + ret); if(packetSize > buf.remaining()) { packetSize = buf.remaining(); } } catch(SocketException ex) { if(Network.wouldBlock(ex)) { return sent; } else if(Network.connectionLost(ex)) { throw new Ice.ConnectionLostException(ex); } throw new Ice.SocketException(ex); } } return sent; }
private int read(ByteBuffer buf) { Debug.Assert(_fd != null); int read = 0; while(buf.hasRemaining()) { try { int ret = _fd.Receive(buf.rawBytes(), buf.position(), buf.remaining(), SocketFlags.None); if(ret == 0) { throw new Ice.ConnectionLostException(); } read += ret; buf.position(buf.position() + ret); } catch(SocketException ex) { if(Network.wouldBlock(ex)) { return read; } else if(Network.interrupted(ex)) { continue; } else if(Network.connectionLost(ex)) { throw new Ice.ConnectionLostException(ex); } throw new Ice.SocketException(ex); } } return read; }