Class ConnectHandler

java.lang.Object
org.eclipse.jetty.util.component.AbstractLifeCycle
org.eclipse.jetty.util.component.ContainerLifeCycle
org.eclipse.jetty.server.Handler.Abstract
org.eclipse.jetty.server.Handler.AbstractContainer
org.eclipse.jetty.server.Handler.Wrapper
org.eclipse.jetty.server.handler.ConnectHandler
All Implemented Interfaces:
Handler, Handler.Container, Handler.Singleton, Request.Handler, Container, Destroyable, Dumpable, Dumpable.DumpableContainer, LifeCycle, Invocable
public class ConnectHandler extends Handler.Wrapper

Implementation of a Handler that supports HTTP CONNECT.

  • Constructor Details

    • ConnectHandler

      public ConnectHandler()

    • ConnectHandler

      public ConnectHandler(Handler handler)

  • Method Details

    • getExecutor

      public Executor getExecutor()

    • setExecutor

      public void setExecutor(Executor executor)

    • getScheduler

      public Scheduler getScheduler()

    • setScheduler

      public void setScheduler(Scheduler scheduler)

    • getByteBufferPool

      public ByteBufferPool getByteBufferPool()

    • setByteBufferPool

      public void setByteBufferPool(ByteBufferPool bufferPool)

    • getConnectTimeout

      public long getConnectTimeout()
      Get the timeout, in milliseconds, to connect to the remote server.
      Returns:
      the timeout, in milliseconds, to connect to the remote server

    • setConnectTimeout

      public void setConnectTimeout(long connectTimeout)
      Set the timeout, in milliseconds, to connect to the remote server.
      Parameters:
      connectTimeout - the timeout, in milliseconds, to connect to the remote server

    • getIdleTimeout

      public long getIdleTimeout()
      Get the idle timeout, in milliseconds.
      Returns:
      the idle timeout, in milliseconds

    • setIdleTimeout

      public void setIdleTimeout(long idleTimeout)
      Set the idle timeout, in milliseconds.
      Parameters:
      idleTimeout - the idle timeout, in milliseconds

    • getBufferSize

      public int getBufferSize()

    • setBufferSize

      public void setBufferSize(int bufferSize)

    • doStart

      protected void doStart() throws Exception
      Description copied from class: ContainerLifeCycle
      Starts the managed lifecycle beans in the order they were added.
      Overrides:
      doStart in class Handler.Abstract
      Throws:
      Exception - If there was a problem starting. Will cause a transition to FAILED state

    • newSelectorManager

      protected SelectorManager newSelectorManager()

    • handle

      public boolean handle(Request request, Response response, Callback callback) throws Exception
      Description copied from interface: Request.Handler

      Invoked to handle the passed HTTP request and response.

      The request is accepted by returning true, then handling must be concluded by completing the passed callback. The handling may be asynchronous, i.e. this method may return true and complete the given callback later, possibly from a different thread. If this method returns false, then the callback must not be invoked and any mutation on the response reversed.

      Exceptions thrown by this method may be subsequently handled by an error Request.Handler, if present, otherwise a default HTTP 500 error is generated and the callback completed while writing the error response.

      The simplest implementation is:

      public boolean handle(Request request, Response response, Callback callback)
{
    callback.succeeded();
    return true;
}

      A HelloWorld implementation is:

      public boolean handle(Request request, Response response, Callback callback)
{
    response.write(true, ByteBuffer.wrap("Hello World\n".getBytes(StandardCharsets.UTF_8)), callback);
    return true;
}
      Specified by:
      handle in interface Request.Handler
      Overrides:
      handle in class Handler.Wrapper
      Parameters:
      request - the HTTP request to handle
      response - the HTTP response to handle
      callback - the callback to complete when the handling is complete
      Returns:
      True if and only if the request will be handled, a response generated and the callback eventually called. This may occur within the scope of the call to this method, or asynchronously some time later. If false is returned, then this method must not generate a response, nor complete the callback.
      Throws:
      Exception - if there is a failure during the handling. Catchers cannot assume that the callback will be called and thus should attempt to complete the request as if a false had been returned.
      See Also:

    • handleConnect

      protected void handleConnect(Request request, Response response, Callback callback, String serverAddress)

      Handles a CONNECT request.

      CONNECT requests may have authentication headers such as Proxy-Authorization that authenticate the client with the proxy.

      Parameters:
      request - the jetty request
      response - the jetty response
      callback - the callback with which to generate a response
      serverAddress - the remote server address in the form host:port

    • connectToServer

      protected void connectToServer(Request request, String host, int port, Promise<SocketChannel> promise)

    • newConnectAddress

      protected InetSocketAddress newConnectAddress(String host, int port)
      Creates the server address to connect to.
      Parameters:
      host - The host from the CONNECT request
      port - The port from the CONNECT request
      Returns:
      The InetSocketAddress to connect to.

    • onConnectSuccess

      protected void onConnectSuccess(ConnectHandler.ConnectContext connectContext, ConnectHandler.UpstreamConnection upstreamConnection)

    • onConnectFailure

      protected void onConnectFailure(Request request, Response response, Callback callback, Throwable failure)

    • handleAuthentication

      protected boolean handleAuthentication(Request request, Response response, String address)

      Handles the authentication before setting up the tunnel to the remote server.

      The default implementation returns true.

      Parameters:
      request - the HTTP request
      response - the HTTP response
      address - the address of the remote server in the form host:port.
      Returns:
      true to allow to connect to the remote host, false otherwise

    • newDownstreamConnection

      protected ConnectHandler.DownstreamConnection newDownstreamConnection(EndPoint endPoint, ConcurrentMap<String,Object> context)

    • newUpstreamConnection

      protected ConnectHandler.UpstreamConnection newUpstreamConnection(EndPoint endPoint, ConnectHandler.ConnectContext connectContext)

    • prepareContext

      protected void prepareContext(Request request, ConcurrentMap<String,Object> context)

    • read

      protected int read(EndPoint endPoint, ByteBuffer buffer, ConcurrentMap<String,Object> context) throws IOException

      Reads (with non-blocking semantic) into the given buffer from the given endPoint.

      Parameters:
      endPoint - the endPoint to read from
      buffer - the buffer to read data into
      context - the context information related to the connection
      Returns:
      the number of bytes read (possibly 0 since the read is non-blocking) or -1 if the channel has been closed remotely
      Throws:
      IOException - if the endPoint cannot be read

    • write

      protected void write(EndPoint endPoint, ByteBuffer buffer, Callback callback, ConcurrentMap<String,Object> context)

      Writes (with non-blocking semantic) the given buffer of data onto the given endPoint.

      Parameters:
      endPoint - the endPoint to write to
      buffer - the buffer to write
      callback - the completion callback to invoke
      context - the context information related to the connection

    • getWhiteListHosts

      public Set<String> getWhiteListHosts()

    • getBlackListHosts

      public Set<String> getBlackListHosts()

    • validateDestination

      public boolean validateDestination(String host, int port)
      Checks the given host and port against whitelist and blacklist.
      Parameters:
      host - the host to check
      port - the port to check
      Returns:
      true if it is allowed to connect to the given host and port