/** * Called when connections, requests or bytes reach to the limit. * * @param remoteAddr * @param connections * @param requests * @param bytes */ protected void onBlock(ConnectionFilter filter, String remoteAddr, int connections, int requests, int bytes) { filter.disconnect(); filter.onDisconnect(); }
@Override public void onConnect(ConnectionSession session_) { session = session_; if (enabled) { onConnect(); } else { super.onConnect(session_); } }
public PacketConsumer getConsumer() { return (b, off, len) -> super.onRecv(b, off, len); }
@Override public void onRecv(byte[] b, int off, int len) { super.onRecv(b, off, len); long period_ = getPeriod(); long limit_ = getLimit(); super.setBufferSize(MAX_BUFFER_SIZE); return; bytesRecv = len; super.setBufferSize((int) Math.min(limit - bytesRecv, MAX_BUFFER_SIZE)); } else { super.setBufferSize(0); timer.postAtTime(() -> { next += period; bytesRecv = 0; super.setBufferSize((int) Math.min(limit, MAX_BUFFER_SIZE)); }, next);
@Override public void disconnect() { super.disconnect(); removeTimeout(); }
@Override public void onDisconnect() { super.onDisconnect(); disconnect_(); }
@Override public void send(byte[] b, int off, int len) { super.send(b, off, len); // Dump After Consume dump(b, off, len, useClientMode); }
public static boolean isMulticast(ConnectionHandler handler) { ConnectionHandler handler_ = handler; while (!(handler_ instanceof MulticastHandler)) { if (!(handler_ instanceof ConnectionFilter)) { return false; } handler_ = ((ConnectionFilter) handler_).getHandler(); } return true; }
@Override public void setBufferSize(int bufferSize) { super.setBufferSize(bufferSize <= 0 || period <= 0 || limit <= 0 ? bufferSize : (int) Math.min(bufferSize, limit)); }
@Override public void disconnect() { super.disconnect(); // Dump After Consume disconnect(useClientMode); }
@Override public void onDisconnect() { super.onDisconnect(); removeTimeout(); }
private SSLEngineResult wrapEx(byte[] b, int off, int len) throws IOException { ByteBuffer srcBB = ByteBuffer.wrap(b, off, len); byte[] outNetBytes = null; SSLEngineResult result; do { int packetBBSize = ssle.getSession().getPacketBufferSize(); if (outNetBytes == null || outNetBytes.length < packetBBSize) { outNetBytes = new byte[packetBBSize]; } ByteBuffer outNetBB = ByteBuffer.wrap(outNetBytes); result = ssle.wrap(srcBB, outNetBB); if (result.getStatus() != Status.OK) { throw new IOException(); } super.send(outNetBytes, 0, outNetBB.position()); } while (srcBB.remaining() > 0); return result; }
break; handler = ((ConnectionFilter) handler).getHandler();
private void onRecv() { if (requestBB.position() > 0) { super.onRecv(requestBytes, 0, requestBB.position()); requestBB.clear(); } }
@Override public void onConnect(ConnectionSession session) { if (contains(session.getRemoteAddr())) { super.onConnect(session); } else { disconnect(); onDisconnect(); } } };
@Override public void disconnect() { super.disconnect(); disconnect_(); } }
@Override public void onDisconnect() { disconnect(!useClientMode); // Dump Before Consume super.onDisconnect(); }
@Override public void send(byte[] b, int off, int len) { if (!enabled) { super.send(b, off, len); return; } if (hs == HandshakeStatus.FINISHED) { disconnectIfClosed(wrap(b, off, len)); } else { baqToSend.add(b, off, len); } }
@Override public void onRecv(byte[] b, int off, int len) { dump(b, off, len, !useClientMode); // Dump Before Consume super.onRecv(b, off, len); }
@Override public void onConnect(ConnectionSession session) { remoteAddr = session.getRemoteAddr(); connected = true; int[] connections__ = getData(connectionsMap, 1); connections__[0] ++; checkTimeout(); int[] requests__ = getData(requestsMap, 2); requests__[0] ++; if ((connections_ > 0 && connections__[0] > connections_) || (requests_ > 0 && requests__[0] > requests_)) { onBlock(this, remoteAddr, connections__[0], requests__[0], 0); } else { super.onConnect(session); } }