/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
package org.apache.mina.proxy;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.util.concurrent.Executor;
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.file.FileRegion;
import org.apache.mina.core.filterchain.IoFilter;
import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.future.DefaultConnectFuture;
import org.apache.mina.core.service.AbstractIoConnector;
import org.apache.mina.core.service.DefaultTransportMetadata;
import org.apache.mina.core.service.IoHandler;
import org.apache.mina.core.service.TransportMetadata;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.core.session.IoSessionConfig;
import org.apache.mina.core.session.IoSessionInitializer;
import org.apache.mina.proxy.filter.ProxyFilter;
import org.apache.mina.proxy.handlers.socks.SocksProxyRequest;
import org.apache.mina.proxy.session.ProxyIoSession;
import org.apache.mina.proxy.session.ProxyIoSessionInitializer;
import org.apache.mina.transport.socket.DefaultSocketSessionConfig;
import org.apache.mina.transport.socket.SocketConnector;
import org.apache.mina.transport.socket.SocketSessionConfig;
/**
* ProxyConnector.java - Decorator for {@link SocketConnector} to provide proxy
* support, as suggested by MINA list discussions.
* <p>
* Operates by intercepting connect requests and replacing the endpoint address
* with the proxy address, then adding a {@link ProxyFilter} as the first
* {@link IoFilter} which performs any necessary handshaking with the proxy
* before allowing data to flow normally. During the handshake, any outgoing
* write requests are buffered.
*
* @see <a
* href="http://www.nabble.com/Meta-Transport%3A-an-idea-on-implementing-reconnection-and-proxy-td12969001.html">Proxy
* reconnection</a>
* @see <a href="http://issues.apache.org/jira/browse/DIRMINA-415">Proxy
* support</a>
*
* @author <a href="http://mina.apache.org">Apache MINA Project</a>
* @since MINA 2.0.0-M3
*/
public class ProxyConnector extends AbstractIoConnector {
private static final TransportMetadata METADATA = new DefaultTransportMetadata("proxy", "proxyconnector", false,
true, InetSocketAddress.class, SocketSessionConfig.class, IoBuffer.class, FileRegion.class);
/**
* Wrapped connector to use for outgoing TCP connections.
*/
private SocketConnector connector = null;
/**
* Proxy filter instance.
*/
private final ProxyFilter proxyFilter = new ProxyFilter();
/**
* The {@link ProxyIoSession} in use.
*/
private ProxyIoSession proxyIoSession;
/**
* This future will notify it's listeners when really connected to the target
*/
private DefaultConnectFuture future;
/**
* Creates a new proxy connector.
*/
public ProxyConnector() {
super(new DefaultSocketSessionConfig(), null);
}
/**
* Creates a new proxy connector.
*
* @param connector Connector used to establish proxy connections.
*/
public ProxyConnector(final SocketConnector connector) {
this(connector, new DefaultSocketSessionConfig(), null);
}
/**
* Creates a new proxy connector.
* @see AbstractIoConnector#AbstractIoConnector(IoSessionConfig, Executor).
*/
public ProxyConnector(final SocketConnector connector, IoSessionConfig config, Executor executor) {
super(config, executor);
setConnector(connector);
}
/**
* {@inheritDoc}
*/
public IoSessionConfig getSessionConfig() {
return connector.getSessionConfig();
}
/**
* Returns the {@link ProxyIoSession} linked with this connector.
*/
public ProxyIoSession getProxyIoSession() {
return proxyIoSession;
}
/**
* Sets the proxy session object of this connector.
* @param proxyIoSession the configuration of this connector.
*/
public void setProxyIoSession(ProxyIoSession proxyIoSession) {
if (proxyIoSession == null) {
throw new IllegalArgumentException("proxySession object cannot be null");
}
if (proxyIoSession.getProxyAddress() == null) {
throw new IllegalArgumentException("proxySession.proxyAddress cannot be null");
}
proxyIoSession.setConnector(this);
setDefaultRemoteAddress(proxyIoSession.getProxyAddress());
this.proxyIoSession = proxyIoSession;
}
/**
* Connects to the specified <code>address</code>. If communication starts
* successfully, events are fired to the connector's <code>handler</code>.
*
* @param remoteAddress the remote address to connect to
* @param localAddress the local address
* @param sessionInitializer the session initializer
* @return {@link ConnectFuture} that will tell the result of the connection attempt
*/
@SuppressWarnings("unchecked")
@Override
protected ConnectFuture connect0(final SocketAddress remoteAddress, final SocketAddress localAddress,
final IoSessionInitializer<? extends ConnectFuture> sessionInitializer) {
if (!proxyIoSession.isReconnectionNeeded()) {
// First connection
IoHandler handler = getHandler();
if (!(handler instanceof AbstractProxyIoHandler)) {
throw new IllegalArgumentException("IoHandler must be an instance of AbstractProxyIoHandler");
}
connector.setHandler(handler);
future = new DefaultConnectFuture();
}
ConnectFuture conFuture = connector.connect(proxyIoSession.getProxyAddress(), new ProxyIoSessionInitializer(
sessionInitializer, proxyIoSession));
// If proxy does not use reconnection like socks the connector's
// future is returned. If we're in the middle of a reconnection
// then we send back the connector's future which is only used
// internally while <code>future</code> will be used to notify
// the user of the connection state.
if (proxyIoSession.getRequest() instanceof SocksProxyRequest || proxyIoSession.isReconnectionNeeded()) {
return conFuture;
}
return future;
}
/**
* Cancels the real connection when reconnection is in use.
*/
public void cancelConnectFuture() {
future.cancel();
}
/**
* Fires the connection event on the real future to notify the client.
*
* @param session the current session
* @return the future holding the connected session
*/
protected ConnectFuture fireConnected(final IoSession session) {
future.setSession(session);
return future;
}
/**
* Get the {@link SocketConnector} to be used for connections
* to the proxy server.
*/
public final SocketConnector getConnector() {
return connector;
}
/**
* Sets the {@link SocketConnector} to be used for connections
* to the proxy server.
*
* @param connector the connector to use
*/
private final void setConnector(final SocketConnector connector) {
if (connector == null) {
throw new IllegalArgumentException("connector cannot be null");
}
this.connector = connector;
String className = ProxyFilter.class.getName();
// Removes an old ProxyFilter instance from the chain
if (connector.getFilterChain().contains(className)) {
connector.getFilterChain().remove(className);
}
// Insert the ProxyFilter as the first filter in the filter chain builder
connector.getFilterChain().addFirst(className, proxyFilter);
}
/**
* {@inheritDoc}
*/
@Override
protected void dispose0() throws Exception {
if (connector != null) {
connector.dispose();
}
}
/**
* {@inheritDoc}
*/
public TransportMetadata getTransportMetadata() {
return METADATA;
}
}