Java NextFilter类代码示例

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
/**
 * Static method which effectively delivers the specified event to the next filter
 * <code>nextFilter</code> on the <code>session</code>.
 * 
 * @param nextFilter the next filter
 * @param session the session on which the event occured
 * @param type the event type
 * @param status the idle status should only be non null only if the event type is 
 * {@link IoSessionEventType#IDLE} 
 */
private static void deliverEvent(final NextFilter nextFilter, final IoSession session,
        final IoSessionEventType type, final IdleStatus status) {
    switch (type) {
    case CREATED:
        nextFilter.sessionCreated(session);
        break;
    case OPENED:
        nextFilter.sessionOpened(session);
        break;
    case IDLE:
        nextFilter.sessionIdle(session, status);
        break;
    case CLOSED:
        nextFilter.sessionClosed(session);
        break;
    }
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void doHandshake(final NextFilter nextFilter) throws ProxyAuthException {
    logger.debug(" doHandshake()");

    if (step > 0) {
        throw new ProxyAuthException("Authentication request already sent");
    }

    // Send request
    HttpProxyRequest req = (HttpProxyRequest) request;
    Map<String, List<String>> headers = req.getHeaders() != null ? req.getHeaders()
            : new HashMap<String, List<String>>();

    String username = req.getProperties().get(HttpProxyConstants.USER_PROPERTY);
    String password = req.getProperties().get(HttpProxyConstants.PWD_PROPERTY);

    StringUtilities.addValueToHeader(headers, "Proxy-Authorization",
            "Basic " + createAuthorization(username, password), true);

    addKeepAliveHeaders(headers);
    req.setHeaders(headers);

    writeRequest(nextFilter, req);
    step++;
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
/**
 * Handles incoming data during the handshake process. Should consume only the
 * handshake data from the buffer, leaving any extra data in place.
 * 
 * @param nextFilter the next filter
 * @param buf the buffered data received 
 */
public synchronized void messageReceived(final NextFilter nextFilter, final IoBuffer buf) {
    try {
        int step = ((Integer) getSession().getAttribute(HANDSHAKE_STEP)).intValue();

        if (step == SocksProxyConstants.SOCKS5_GREETING_STEP && buf.get(0) != SocksProxyConstants.SOCKS_VERSION_5) {
            throw new IllegalStateException("Wrong socks version running on server");
        }

        if ((step == SocksProxyConstants.SOCKS5_GREETING_STEP || step == SocksProxyConstants.SOCKS5_AUTH_STEP)
                && buf.remaining() >= 2) {
            handleResponse(nextFilter, buf, step);
        } else if (step == SocksProxyConstants.SOCKS5_REQUEST_STEP && buf.remaining() >= 5) {
            handleResponse(nextFilter, buf, step);
        }
    } catch (Exception ex) {
        closeSession("Proxy handshake failed: ", ex);
    }
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
private void callNextExceptionCaught(Entry entry, IoSession session, Throwable cause) {
    // Notify the related future.
    ConnectFuture future = (ConnectFuture) session.removeAttribute(SESSION_CREATED_FUTURE);
    if (future == null) {
        try {
            IoFilter filter = entry.getFilter();
            NextFilter nextFilter = entry.getNextFilter();
            filter.exceptionCaught(nextFilter, session, cause);
        } catch (Throwable e) {
            LOGGER.warn("Unexpected exception from exceptionCaught handler.", e);
        }
    } else {
        // Please note that this place is not the only place that
        // calls ConnectFuture.setException().
        session.close(true);
        future.setException(cause);
    }
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
@Override
public void sessionClosed(NextFilter nextFilter, IoSession session) throws Exception {
    AbstractIoSession s = (AbstractIoSession) session;
    try {
        s.getHandler().sessionClosed(session);
    } finally {
        try {
            s.getWriteRequestQueue().dispose(session);
        } finally {
            try {
                s.getAttributeMap().dispose(session);
            } finally {
                try {
                    // Remove all filters.
                    session.getFilterChain().clear();
                } finally {
                    if (s.getConfig().isUseReadOperation()) {
                        s.offerClosedReadFuture();
                    }
                }
            }
        }
    }
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
@Override
public void messageReceived(NextFilter nextFilter, IoSession session, Object message) throws Exception {
    AbstractIoSession s = (AbstractIoSession) session;
    if (!(message instanceof IoBuffer)) {
        s.increaseReadMessages(System.currentTimeMillis());
    } else if (!((IoBuffer) message).hasRemaining()) {
        s.increaseReadMessages(System.currentTimeMillis());
    }

    try {
        session.getHandler().messageReceived(s, message);
    } finally {
        if (s.getConfig().isUseReadOperation()) {
            s.offerReadFuture(message);
        }
    }
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
public void wrap(NextFilter nextFilter, WriteRequest writeRequest, IoBuffer buf)
  	throws AuthException
  {
int endOriginalMessage = buf.limit() - DigestMD5IntegrityIoFilterCodec.LINE_TERMINATOR.length;
byte[] originalMessage = new byte[endOriginalMessage]; 
buf.get(originalMessage);				
buf.put(AuthDigestMD5IoFilter.computeMACBlock(session, originalMessage, false));
buf.put(DigestMD5IntegrityIoFilterCodec.LINE_TERMINATOR);				
buf.flip();

if (buf.limit() > ((Integer)session.getAttribute(AuthDigestMD5Command.CLIENT_MAXBUF)).intValue())
	throw new AuthException("Data exceeds client maxbuf capabilities");

nextFilter.filterWrite(session, 
      		new DefaultWriteRequest(buf, writeRequest.getFuture()));
  }
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
void flushScheduledEvents() {
	scheduled_events.getAndIncrement();

	// Fire events only when the lock is available for this handler.
	if (sslLock.tryLock()) {
		try {
			do {
				Entry<NextFilter, WriteRequest> eventW;
				// We need synchronization here inevitably because filterWrite can be
				// called simultaneously and cause 'bad record MAC' integrity error.
				while ((eventW = filterWriteEventQueue.poll()) != null) {
					eventW.getKey().filterWrite(eventW.getValue());
				}

				Entry<NextFilter, Object> eventR;
				while ((eventR = messageReceivedEventQueue.poll()) != null) {
					eventR.getKey().messageReceived(eventR.getValue());
				}
			} while (scheduled_events.decrementAndGet() > 0);
		} finally {
			sslLock.unlock();
		}
	}
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
public HandshakeContext ( final ProtocolConfiguration protocolConfiguration, final boolean clientMode, final IoSession session, final NextFilter nextFilter )
{
    super ();
    this.protocolConfiguration = protocolConfiguration;
    this.clientMode = clientMode;
    this.session = session;
    this.nextFilter = nextFilter;
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
/**
 * Writes data to the proxy server.
 * 
 * @param nextFilter the next filter
 * @param data Data buffer to be written.
 */
protected WriteFuture writeData(final NextFilter nextFilter, final IoBuffer data) {
    // write net data
    ProxyHandshakeIoBuffer writeBuffer = new ProxyHandshakeIoBuffer(data);

    LOGGER.debug("   session write: {}", writeBuffer);

    WriteFuture writeFuture = new DefaultWriteFuture(getSession());
    getProxyFilter().writeData(nextFilter, getSession(), new DefaultWriteRequest(writeBuffer, writeFuture), true);

    return writeFuture;
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
/**
 * Enqueue a message to be written once handshaking is complete.
 */
public synchronized void enqueueWriteRequest(final NextFilter nextFilter, final WriteRequest writeRequest) {
    if (writeRequestQueue == null) {
        writeRequestQueue = new LinkedList<Event>();
    }

    writeRequestQueue.offer(new Event(nextFilter, writeRequest));
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
/**
 * Performs the handshake processing.
 * 
 * @param nextFilter the next filter
 */
public void doHandshake(final NextFilter nextFilter) throws ProxyAuthException {
    logger.debug(" doHandshake()");

    if (authHandler != null) {
        authHandler.doHandshake(nextFilter);
    } else {
        if (requestSent) {
            // Safety check
            throw new ProxyAuthException("Authentication request already sent");
        }

        logger.debug("  sending HTTP request");

        // Compute request headers
        HttpProxyRequest req = (HttpProxyRequest) getProxyIoSession().getRequest();
        Map<String, List<String>> headers = req.getHeaders() != null ? req.getHeaders()
                : new HashMap<String, List<String>>();

        AbstractAuthLogicHandler.addKeepAliveHeaders(headers);
        req.setHeaders(headers);

        // Write request to the proxy
        writeRequest(nextFilter, req);
        requestSent = true;
    }
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void doHandshake(final NextFilter nextFilter) throws ProxyAuthException {
    logger.debug(" doHandshake()");

    // Just send the request, no authentication needed
    writeRequest(nextFilter, (HttpProxyRequest) request);
    step++;
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
/**
 * Calls{@link #writeRequest0(NextFilter, HttpProxyRequest)} to write the request. 
 * If needed a reconnection to the proxy is done previously.
 * 
 * @param nextFilter the next filter
 * @param request the http request
 */
public void writeRequest(final NextFilter nextFilter, final HttpProxyRequest request) {
    ProxyIoSession proxyIoSession = getProxyIoSession();

    if (proxyIoSession.isReconnectionNeeded()) {
        reconnect(nextFilter, request);
    } else {
        writeRequest0(nextFilter, request);
    }
}
 

import org.apache.mina.core.filterchain.IoFilter.NextFilter; //导入依赖的package包/类
/**
 * Encodes a HTTP request and sends it to the proxy server.
 * 
 * @param nextFilter the next filter
 * @param request the http request
 */
private void writeRequest0(final NextFilter nextFilter, final HttpProxyRequest request) {
    try {
        String data = request.toHttpString();
        IoBuffer buf = IoBuffer.wrap(data.getBytes(getProxyIoSession().getCharsetName()));

        LOGGER.debug("   write:\n{}", data.replace("\r", "\\r").replace("\n", "\\n\n"));

        writeData(nextFilter, buf);

    } catch (UnsupportedEncodingException ex) {
        closeSession("Unable to send HTTP request: ", ex);
    }
}