private void closeSocket(long socket) { // Once this is called, the mapping from socket to wrapper will no // longer be required. SocketWrapperBase<Long> wrapper = connections.remove(Long.valueOf(socket)); if (wrapper != null) { // Cast to avoid having to catch an IOE that is never thrown. ((AprSocketWrapper) wrapper).close(); } }
@Override protected void writeNonBlockingDirect(ByteBuffer from) throws IOException { if (from.isDirect()) { super.writeNonBlockingDirect(from); } else { // The socket write buffer capacity is socket.appWriteBufSize ByteBuffer writeBuffer = socketBufferHandler.getWriteBuffer(); int limit = writeBuffer.capacity(); while (from.remaining() >= limit) { socketBufferHandler.configureWriteBufferForWrite(); transfer(from, writeBuffer); int newPosition = writeBuffer.position() + limit; doWrite(false); if (writeBuffer.position() != newPosition) { // Didn't write the whole amount of data in the last // non-blocking write. // Exit the loop. return; } } if (from.remaining() > 0) { socketBufferHandler.configureWriteBufferForWrite(); transfer(from, writeBuffer); } } }
@Override public boolean isReadyForRead() throws IOException { socketBufferHandler.configureReadBufferForRead(); if (socketBufferHandler.getReadBuffer().remaining() > 0) { return true; } int read = fillReadBuffer(false); boolean isReady = socketBufferHandler.getReadBuffer().position() > 0 || read == -1; return isReady; }
private int fillReadBuffer(boolean block, ByteBuffer to) throws IOException { if (closed) { throw new IOException(sm.getString("socket.apr.closed", getSocket())); Lock readLock = getBlockingStatusReadLock(); WriteLock writeLock = getBlockingStatusWriteLock(); readLock.lock(); try { if (getBlockingStatus() == block) { if (block) { Socket.timeoutSet(getSocket().longValue(), getReadTimeout() * 1000); result = Socket.recvb(getSocket().longValue(), to, to.position(), to.remaining()); readDone = true; setBlockingStatus(block); if (block) { Socket.timeoutSet(getSocket().longValue(), getReadTimeout() * 1000); } else { Socket.timeoutSet(getSocket().longValue(), 0); try { writeLock.unlock(); result = Socket.recvb(getSocket().longValue(), to, to.position(), to.remaining()); } finally { } else {
@Override public void doClientAuth(SSLSupport sslSupport) throws IOException { long socket = getSocket().longValue(); Lock readLock = getBlockingStatusReadLock(); WriteLock writeLock = getBlockingStatusWriteLock(); boolean renegotiateDone = false; try { readLock.lock(); try { if (getBlockingStatus()) { Socket.timeoutSet(getSocket().longValue(), getReadTimeout() * 1000); try { setBlockingStatus(true); Socket.timeoutSet(getSocket().longValue(), getReadTimeout() * 1000);
@Override public int read(boolean block, ByteBuffer to) throws IOException { int nRead = populateReadBuffer(to); if (nRead > 0) { return nRead; if (to.isDirect() && to.remaining() >= limit) { to.limit(to.position() + limit); nRead = fillReadBuffer(block, to); if (log.isDebugEnabled()) { log.debug("Socket: [" + this + "], Read direct from socket: [" + nRead + "]"); nRead = fillReadBuffer(block); if (log.isDebugEnabled()) { log.debug("Socket: [" + this + "], Read into buffer: [" + nRead + "]"); nRead = populateReadBuffer(to);
if (getEndpoint().isSSLEnabled()) { if (sslOutputBuffer.remaining() == 0) { transfer(from, sslOutputBuffer); sslOutputBuffer.flip(); } else { thisTime = Socket.sendb(getSocket().longValue(), sslOutputBuffer, sslOutputBuffer.position(), sslOutputBuffer.limit()); if (thisTime > 0) { thisTime = Socket.sendb(getSocket().longValue(), from, from.position(), from.remaining()); if (thisTime > 0) { } else if (thisTime < 0) { throw new IOException(sm.getString("socket.apr.write.error", Integer.valueOf(-thisTime), getSocket(), this)); } while ((thisTime > 0 || getBlockingStatus()) && from.hasRemaining());
@Override protected void doWrite(boolean block, ByteBuffer from) throws IOException { if (closed) { throw new IOException(sm.getString("socket.apr.closed", getSocket())); Lock readLock = getBlockingStatusReadLock(); WriteLock writeLock = getBlockingStatusWriteLock(); if (getBlockingStatus() == block) { if (block) { Socket.timeoutSet(getSocket().longValue(), getWriteTimeout() * 1000); doWriteInternal(from); return; try { setBlockingStatus(block); if (block) { Socket.timeoutSet(getSocket().longValue(), getWriteTimeout() * 1000); } else { Socket.timeoutSet(getSocket().longValue(), 0); try { writeLock.unlock(); doWriteInternal(from); } finally { readLock.unlock();
log.debug(sm.getString("endpoint.debug.socket", socket)); AprSocketWrapper wrapper = new AprSocketWrapper(socket, this); wrapper.setKeepAliveLeft(getMaxKeepAliveRequests()); wrapper.setSecure(isSSLEnabled()); wrapper.setReadTimeout(getConnectionTimeout()); wrapper.setWriteTimeout(getConnectionTimeout()); connections.put(socket, wrapper); getExecutor().execute(new SocketWithOptionsProcessor(wrapper));
@Override public int read(boolean block, byte[] b, int off, int len) throws IOException { int nRead = populateReadBuffer(b, off, len); if (nRead > 0) { return nRead; /* * Since more bytes may have arrived since the buffer was last * filled, it is an option at this point to perform a * non-blocking read. However correctly handling the case if * that read returns end of stream adds complexity. Therefore, * at the moment, the preference is for simplicity. */ } // Fill the read buffer as best we can. nRead = fillReadBuffer(block); // Fill as much of the remaining byte array as possible with the // data that was just read if (nRead > 0) { socketBufferHandler.configureReadBufferForRead(); nRead = Math.min(nRead, len); socketBufferHandler.getReadBuffer().get(b, off, nRead); } return nRead; }
new AprSocketWrapper(Long.valueOf(socket)); wrapper.setKeepAliveLeft(getMaxKeepAliveRequests()); wrapper.setSecure(isSSLEnabled()); connections.put(Long.valueOf(socket), wrapper); getExecutor().execute(new SocketWithOptionsProcessor(wrapper));
@Override protected void writeBlockingDirect(ByteBuffer from) throws IOException { if (from.isDirect()) { super.writeBlockingDirect(from); } else { // The socket write buffer capacity is socket.appWriteBufSize ByteBuffer writeBuffer = socketBufferHandler.getWriteBuffer(); int limit = writeBuffer.capacity(); while (from.remaining() >= limit) { socketBufferHandler.configureWriteBufferForWrite(); transfer(from, writeBuffer); doWrite(true); } if (from.remaining() > 0) { socketBufferHandler.configureWriteBufferForWrite(); transfer(from, writeBuffer); } } }
private int fillReadBuffer(boolean block) throws IOException { socketBufferHandler.configureReadBufferForWrite(); return fillReadBuffer(block, socketBufferHandler.getReadBuffer()); }