ProxyToServerConnection (LittleProxy 2.0.2 API)

java.lang.Object
- io.netty.channel.ChannelHandlerAdapter
- - io.netty.channel.ChannelInboundHandlerAdapter
  - - io.netty.channel.SimpleChannelInboundHandler<Object>
    - - org.littleshoot.proxy.impl.ProxyConnection<HttpResponse>
      - org.littleshoot.proxy.impl.ProxyToServerConnection

All Implemented Interfaces:

ChannelHandler, ChannelInboundHandler
```
@ChannelHandler.Sharable
public class ProxyToServerConnection
extends ProxyConnection<HttpResponse>
```
Represents a connection from our proxy to a server on the web. ProxyConnections are reused fairly liberally, and can go from disconnected to connected, back to disconnected and so on.

Connecting a ProxyToServerConnection can involve more than just connecting the underlying Channel. In particular, the connection may use encryption (i.e. TLS) and it may also establish an HTTP CONNECT tunnel. The various steps involved in fully establishing a connection are encapsulated in the property connectionFlow, which is initialized in initializeConnectionFlow().

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private class`	`ProxyToServerConnection.HeadAwareHttpResponseDecoder` Responses to HEAD requests aren't supposed to have content, but Netty doesn't know that any given response is to a HEAD request, so it needs to be told that there's no content so that it doesn't hang waiting for it.

Nested classes/interfaces inherited from class org.littleshoot.proxy.impl.ProxyConnection
ProxyConnection.BytesReadMonitor, ProxyConnection.BytesWrittenMonitor, ProxyConnection.RequestReadMonitor, ProxyConnection.RequestWrittenMonitor, ProxyConnection.ResponseReadMonitor, ProxyConnection.ResponseWrittenMonitor

Nested classes/interfaces inherited from interface io.netty.channel.ChannelHandler
ChannelHandler.Sharable

Field Summary

Fields
Modifier and Type	Field and Description
`private Queue<ChainedProxy>`	`availableChainedProxies`
`private ProxyConnection.BytesReadMonitor`	`bytesReadMonitor`
`private ProxyConnection.BytesWrittenMonitor`	`bytesWrittenMonitor`
`private ChainedProxy`	`chainedProxy`
`private ChainedProxyType`	`chainedProxyType`
`private ClientToProxyConnection`	`clientConnection`
`private ConnectionFlowStep`	`ConnectChannel` Opens the socket connection.
`private ConnectionFlow`	`connectionFlow` Encapsulates the flow for establishing a connection, which can vary depending on how things are configured.
`private Object`	`connectLock` While we're in the process of connecting, it's possible that we'll receive a new message to write.
`private HttpFilters`	`currentFilters` The filters to apply to response/chunks received from server.
`private HttpRequest`	`currentHttpRequest` Keeps track of HttpRequests that have been issued so that we can associate them with responses that we get back
`private HttpResponse`	`currentHttpResponse` While we're doing a chunked transfer, this keeps track of the initial HttpResponse object for our transfer (which is useful for its headers).
`private boolean`	`disableSni` Disables SNI when initializing connection flow in `initializeConnectionFlow()`.
`private static String`	`HTTP_DECODER_NAME`
`private static String`	`HTTP_ENCODER_NAME`
`private static String`	`HTTP_PROXY_ENCODER_NAME`
`private static String`	`HTTP_REQUEST_WRITTEN_MONITOR_NAME`
`private static String`	`HTTP_RESPONSE_READ_MONITOR_NAME`
`private ConnectionFlowStep`	`HTTPCONNECTWithChainedProxy` Writes the HTTP CONNECT to the server and waits for a 200 response.
`private HttpRequest`	`initialRequest` This is the initial request received prior to connecting.
`private InetSocketAddress`	`localAddress`
`private static String`	`MAIN_HANDLER_NAME`
`private static int`	`MINIMUM_RECV_BUFFER_SIZE_BYTES` Minimum size of the adaptive recv buffer when throttling is enabled.
`private ConnectionFlowStep`	`MitmEncryptClientChannel` Encrypts the client channel based on our server `SSLSession`.
`private String`	`password`
`private InetSocketAddress`	`remoteAddress`
`private io.netty.resolver.AddressResolverGroup<?>`	`remoteAddressResolver`
`private ProxyConnection.RequestWrittenMonitor`	`requestWrittenMonitor`
`private ProxyConnection.ResponseReadMonitor`	`responseReadMonitor`
`private ProxyToServerConnection`	`serverConnection`
`private String`	`serverHostAndPort`
`private static String`	`SOCKS_DECODER_NAME`
`private static String`	`SOCKS_ENCODER_NAME`
`private ConnectionFlowStep`	`SOCKS4CONNECTWithChainedProxy` Establishes a SOCKS4 connection.
`private ConnectionFlowStep`	`SOCKS5CONNECTRequestWithChainedProxy` Establishes a SOCKS5 connection after `SOCKS5InitialRequest` and (optionally) `SOCKS5SendPasswordCredentials` have completed.
`private ConnectionFlowStep`	`SOCKS5InitialRequest` Initiates a SOCKS5 connection.
`private ConnectionFlowStep`	`SOCKS5SendPasswordCredentials` Sends SOCKS5 password credentials after `SOCKS5InitialRequest` has completed.
`private GlobalTrafficShapingHandler`	`trafficHandler` Limits bandwidth when throttling is enabled.
`private TransportProtocol`	`transportProtocol`
`private String`	`username`

Fields inherited from class org.littleshoot.proxy.impl.ProxyConnection
channel, ctx, lastReadTime, LOG, proxyServer, runsAsSslClient, sslEngine, StartTunneling

Constructor Summary

Constructors
Modifier	Constructor and Description
`private`	`ProxyToServerConnection(DefaultHttpProxyServer proxyServer, ClientToProxyConnection clientConnection, String serverHostAndPort, ChainedProxy chainedProxy, Queue<ChainedProxy> availableChainedProxies, HttpFilters initialFilters, GlobalTrafficShapingHandler globalTrafficShapingHandler)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`addFirstOrReplaceHandler(String name, ChannelHandler handler)`
`static InetSocketAddress`	`addressFor(String hostAndPort, DefaultHttpProxyServer proxyServer)` Build an `InetSocketAddress` for the given hostAndPort.
`protected void`	`becameSaturated()` Callback that's invoked if this connection becomes saturated.
`protected void`	`becameWritable()` Callback that's invoked when this connection becomes writeable again.
`protected void`	`become(ConnectionState newState)` Updates the current state to the given value.
`private void`	`connectAndWrite(HttpRequest initialRequest)` Configures the connection to the upstream server and begins the `ConnectionFlow`.
`protected boolean`	`connectionFailed(Throwable cause)` Called when the connection to the server or upstream chained proxy fails.
`(package private) void`	`connectionSucceeded(boolean shouldForwardInitialRequest)` Do all the stuff that needs to be done after our `ConnectionFlow` has succeeded.
`(package private) static ProxyToServerConnection`	`create(DefaultHttpProxyServer proxyServer, ClientToProxyConnection clientConnection, String serverHostAndPort, HttpFilters initialFilters, HttpRequest initialHttpRequest, GlobalTrafficShapingHandler globalTrafficShapingHandler)` Create a new ProxyToServerConnection.
`protected void`	`disconnected()` This method is called as soon as the underlying `Channel` becomes disconnected.
`protected void`	`exceptionCaught(Throwable cause)` Override this to handle exceptions that occurred during asynchronous processing on the `Channel`.
`ChainedProxy`	`getChainedProxy()`
`InetSocketAddress`	`getChainedProxyAddress()`
`ChainedProxyType`	`getChainedProxyType()`
`protected HttpFilters`	`getHttpFiltersFromProxyServer(HttpRequest httpRequest)` Request the ProxyServer for Filters.
`HttpRequest`	`getInitialRequest()`
`InetSocketAddress`	`getRemoteAddress()`
`String`	`getServerHostAndPort()`
`TransportProtocol`	`getTransportProtocol()`
`boolean`	`hasUpstreamChainedProxy()`
`private void`	`initChannelPipeline(ChannelPipeline pipeline, HttpRequest httpRequest)` Initialize our `ChannelPipeline` to connect the upstream server.
`private void`	`initializeConnectionFlow()` This method initializes our `ConnectionFlow` based on however this connection has been configured.
`protected void`	`read(Object msg)` Read is invoked automatically by Netty as messages arrive on the socket.
`protected void`	`readHAProxyMessage(HAProxyMessage msg)` Read an `HAProxyMessage`
`protected void`	`readHTTPChunk(HttpContent chunk)` Implement this to handle reading a chunk in a chunked transfer.
`protected ConnectionState`	`readHTTPInitial(HttpResponse httpResponse)` Implement this to handle reading the initial object (e.g.
`protected void`	`readRaw(ByteBuf buf)` Implement this to handle reading a raw buffer as they are used in HTTP tunneling.
`private void`	`rememberCurrentResponse(HttpResponse response)` Keeps track of the current HttpResponse so that we can associate its headers with future related chunks for this same transfer.
`private void`	`removeHandlerIfPresent(String name)`
`private void`	`resetConnectionForRetry()` Convenience method to prepare to retry this connection.
`private void`	`respondWith(HttpObject httpObject)` Respond to the client with the given `HttpObject`.
`private void`	`setupConnectionParameters()` Set up our connection parameters based on server address and chained proxies.
`(package private) void`	`switchToWebSocketProtocol()`
`protected void`	`timedOut()` This method is called when the underlying `Channel` times out due to an idle timeout.
`private static InetSocketAddress`	`unresolvedAddressFor(String hostAndPort)` Similar to `addressFor(String, DefaultHttpProxyServer)` except that it does not resolve the address.
`(package private) void`	`write(Object msg)` This method is called by users of the ProxyConnection to send stuff out over the socket.
`(package private) void`	`write(Object msg, HttpFilters filters)` Like `write(Object)` and also sets the current filters to the given value.
`protected void`	`writeHttp(HttpObject httpObject)` Writes HttpObjects to the connection asynchronously.

Methods inherited from class org.littleshoot.proxy.impl.ProxyConnection
aggregateContentForFiltering, channelActive, channelInactive, channelRead0, channelRegistered, channelWritabilityChanged, connected, disconnect, doWrite, encrypt, encrypt, EncryptChannel, exceptionCaught, getCurrentState, getLOG, getSslEngine, is, isConnecting, isSaturated, isTunneling, resumeReading, stopReading, userEventTriggered, writeRaw, writeToChannel

Methods inherited from class io.netty.channel.SimpleChannelInboundHandler
acceptInboundMessage, channelRead

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter
channelReadComplete, channelUnregistered

Methods inherited from class io.netty.channel.ChannelHandlerAdapter
ensureNotSharable, handlerAdded, handlerRemoved, isSharable

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.netty.channel.ChannelHandler
handlerAdded, handlerRemoved

- Field Detail
  - HTTP_ENCODER_NAME
```
private static final String HTTP_ENCODER_NAME
```
    See Also:
    
    Constant Field Values
  - HTTP_DECODER_NAME
```
private static final String HTTP_DECODER_NAME
```
    See Also:
    
    Constant Field Values
  - HTTP_PROXY_ENCODER_NAME
```
private static final String HTTP_PROXY_ENCODER_NAME
```
    See Also:
    
    Constant Field Values
  - HTTP_REQUEST_WRITTEN_MONITOR_NAME
```
private static final String HTTP_REQUEST_WRITTEN_MONITOR_NAME
```
    See Also:
    
    Constant Field Values
  - HTTP_RESPONSE_READ_MONITOR_NAME
```
private static final String HTTP_RESPONSE_READ_MONITOR_NAME
```
    See Also:
    
    Constant Field Values
  - SOCKS_ENCODER_NAME
```
private static final String SOCKS_ENCODER_NAME
```
    See Also:
    
    Constant Field Values
  - SOCKS_DECODER_NAME
```
private static final String SOCKS_DECODER_NAME
```
    See Also:
    
    Constant Field Values
  - MAIN_HANDLER_NAME
```
private static final String MAIN_HANDLER_NAME
```
    See Also:
    
    Constant Field Values
  - clientConnection
```
private final ClientToProxyConnection clientConnection
```
  - serverConnection
```
private final ProxyToServerConnection serverConnection
```
  - transportProtocol
```
private volatile TransportProtocol transportProtocol
```
  - chainedProxyType
```
private volatile ChainedProxyType chainedProxyType
```
  - remoteAddress
```
private volatile InetSocketAddress remoteAddress
```
  - localAddress
```
private volatile InetSocketAddress localAddress
```
  - remoteAddressResolver
```
private volatile io.netty.resolver.AddressResolverGroup<?> remoteAddressResolver
```
  - username
```
private volatile String username
```
  - password
```
private volatile String password
```
  - serverHostAndPort
```
private final String serverHostAndPort
```
  - chainedProxy
```
private volatile ChainedProxy chainedProxy
```
  - availableChainedProxies
```
private final Queue<ChainedProxy> availableChainedProxies
```
  - currentFilters
```
private volatile HttpFilters currentFilters
```
    The filters to apply to response/chunks received from server.
  - connectionFlow
```
private volatile ConnectionFlow connectionFlow
```
    Encapsulates the flow for establishing a connection, which can vary depending on how things are configured.
  - disableSni
```
private volatile boolean disableSni
```
    Disables SNI when initializing connection flow in initializeConnectionFlow(). This value is set to true when retrying a connection without SNI to work around Java's SNI handling issue (see connectionFailed(Throwable)).
  - connectLock
```
private final Object connectLock
```
    While we're in the process of connecting, it's possible that we'll receive a new message to write. This lock helps us synchronize and wait for the connection to be established before writing the next message.
  - initialRequest
```
private volatile HttpRequest initialRequest
```
    This is the initial request received prior to connecting. We keep track of it so that we can process it after connection finishes.
  - currentHttpRequest
```
private volatile HttpRequest currentHttpRequest
```
    Keeps track of HttpRequests that have been issued so that we can associate them with responses that we get back
  - currentHttpResponse
```
private volatile HttpResponse currentHttpResponse
```
    While we're doing a chunked transfer, this keeps track of the initial HttpResponse object for our transfer (which is useful for its headers).
  - trafficHandler
```
private volatile GlobalTrafficShapingHandler trafficHandler
```
    Limits bandwidth when throttling is enabled.
  - MINIMUM_RECV_BUFFER_SIZE_BYTES
```
private static final int MINIMUM_RECV_BUFFER_SIZE_BYTES
```
    Minimum size of the adaptive recv buffer when throttling is enabled.
    
    See Also:
    
    Constant Field Values
  - ConnectChannel
```
private ConnectionFlowStep ConnectChannel
```
    Opens the socket connection.
  - HTTPCONNECTWithChainedProxy
```
private ConnectionFlowStep HTTPCONNECTWithChainedProxy
```
    Writes the HTTP CONNECT to the server and waits for a 200 response.
  - SOCKS4CONNECTWithChainedProxy
```
private ConnectionFlowStep SOCKS4CONNECTWithChainedProxy
```
    Establishes a SOCKS4 connection.
  - SOCKS5InitialRequest
```
private ConnectionFlowStep SOCKS5InitialRequest
```
    Initiates a SOCKS5 connection.
  - SOCKS5SendPasswordCredentials
```
private ConnectionFlowStep SOCKS5SendPasswordCredentials
```
    Sends SOCKS5 password credentials after SOCKS5InitialRequest has completed.
  - SOCKS5CONNECTRequestWithChainedProxy
```
private ConnectionFlowStep SOCKS5CONNECTRequestWithChainedProxy
```
    Establishes a SOCKS5 connection after SOCKS5InitialRequest and (optionally) SOCKS5SendPasswordCredentials have completed.
  - MitmEncryptClientChannel
```
private ConnectionFlowStep MitmEncryptClientChannel
```
    Encrypts the client channel based on our server SSLSession.
    
    This does not wait for the handshake to finish so that we can go on and respond to the CONNECT request.
  - bytesReadMonitor
```
private final ProxyConnection.BytesReadMonitor bytesReadMonitor
```
  - responseReadMonitor
```
private ProxyConnection.ResponseReadMonitor responseReadMonitor
```
  - bytesWrittenMonitor
```
private ProxyConnection.BytesWrittenMonitor bytesWrittenMonitor
```
  - requestWrittenMonitor
```
private ProxyConnection.RequestWrittenMonitor requestWrittenMonitor
```
- Constructor Detail
  - ProxyToServerConnection
```
private ProxyToServerConnection(DefaultHttpProxyServer proxyServer,
                                ClientToProxyConnection clientConnection,
                                String serverHostAndPort,
                                ChainedProxy chainedProxy,
                                Queue<ChainedProxy> availableChainedProxies,
                                HttpFilters initialFilters,
                                GlobalTrafficShapingHandler globalTrafficShapingHandler)
                         throws UnknownHostException
```
    Throws:
    
    UnknownHostException
- Method Detail
  - create
```
static ProxyToServerConnection create(DefaultHttpProxyServer proxyServer,
                                      ClientToProxyConnection clientConnection,
                                      String serverHostAndPort,
                                      HttpFilters initialFilters,
                                      HttpRequest initialHttpRequest,
                                      GlobalTrafficShapingHandler globalTrafficShapingHandler)
                               throws UnknownHostException
```
    Create a new ProxyToServerConnection.
    
    Throws:
    
    UnknownHostException
  - read
```
protected void read(Object msg)
```
    Description copied from class: ProxyConnection
    
    Read is invoked automatically by Netty as messages arrive on the socket.
    
    Overrides:
    
    read in class ProxyConnection<HttpResponse>
  - readHAProxyMessage
```
protected void readHAProxyMessage(HAProxyMessage msg)
```
    Description copied from class: ProxyConnection
    
    Read an HAProxyMessage
    
    Specified by:
    
    readHAProxyMessage in class ProxyConnection<HttpResponse>
    
    Parameters:
    
    msg - HAProxyMessage
  - readHTTPInitial
```
protected ConnectionState readHTTPInitial(HttpResponse httpResponse)
```
    Description copied from class: ProxyConnection
    
    Implement this to handle reading the initial object (e.g. HttpRequest or HttpResponse).
    
    Specified by:
    
    readHTTPInitial in class ProxyConnection<HttpResponse>
  - readHTTPChunk
```
protected void readHTTPChunk(HttpContent chunk)
```
    Description copied from class: ProxyConnection
    
    Implement this to handle reading a chunk in a chunked transfer.
    
    Specified by:
    
    readHTTPChunk in class ProxyConnection<HttpResponse>
  - readRaw
```
protected void readRaw(ByteBuf buf)
```
    Description copied from class: ProxyConnection
    
    Implement this to handle reading a raw buffer as they are used in HTTP tunneling.
    
    Specified by:
    
    readRaw in class ProxyConnection<HttpResponse>
  - write
```
void write(Object msg,
           HttpFilters filters)
```
    Like write(Object) and also sets the current filters to the given value.
  - write
```
void write(Object msg)
```
    Description copied from class: ProxyConnection
    
    This method is called by users of the ProxyConnection to send stuff out over the socket.
    
    Overrides:
    
    write in class ProxyConnection<HttpResponse>
  - writeHttp
```
protected void writeHttp(HttpObject httpObject)
```
    Description copied from class: ProxyConnection
    
    Writes HttpObjects to the connection asynchronously.
    
    Overrides:
    
    writeHttp in class ProxyConnection<HttpResponse>
  - become
```
protected void become(ConnectionState newState)
```
    Description copied from class: ProxyConnection
    
    Updates the current state to the given value.
    
    Overrides:
    
    become in class ProxyConnection<HttpResponse>
  - becameSaturated
```
protected void becameSaturated()
```
    Description copied from class: ProxyConnection
    
    Callback that's invoked if this connection becomes saturated.
    
    Overrides:
    
    becameSaturated in class ProxyConnection<HttpResponse>
  - becameWritable
```
protected void becameWritable()
```
    Description copied from class: ProxyConnection
    
    Callback that's invoked when this connection becomes writeable again.
    
    Overrides:
    
    becameWritable in class ProxyConnection<HttpResponse>
  - timedOut
```
protected void timedOut()
```
    Description copied from class: ProxyConnection
    
    This method is called when the underlying Channel times out due to an idle timeout.
    
    Overrides:
    
    timedOut in class ProxyConnection<HttpResponse>
  - disconnected
```
protected void disconnected()
```
    Description copied from class: ProxyConnection
    
    This method is called as soon as the underlying Channel becomes disconnected.
    
    Overrides:
    
    disconnected in class ProxyConnection<HttpResponse>
  - exceptionCaught
```
protected void exceptionCaught(Throwable cause)
```
    Description copied from class: ProxyConnection
    
    Override this to handle exceptions that occurred during asynchronous processing on the Channel.
    
    Overrides:
    
    exceptionCaught in class ProxyConnection<HttpResponse>
  - getTransportProtocol
```
public TransportProtocol getTransportProtocol()
```
  - getChainedProxyType
```
public ChainedProxyType getChainedProxyType()
```
  - getRemoteAddress
```
public InetSocketAddress getRemoteAddress()
```
  - getServerHostAndPort
```
public String getServerHostAndPort()
```
  - hasUpstreamChainedProxy
```
public boolean hasUpstreamChainedProxy()
```
  - getChainedProxyAddress
```
public InetSocketAddress getChainedProxyAddress()
```
  - getChainedProxy
```
public ChainedProxy getChainedProxy()
```
  - getInitialRequest
```
public HttpRequest getInitialRequest()
```
  - getHttpFiltersFromProxyServer
```
protected HttpFilters getHttpFiltersFromProxyServer(HttpRequest httpRequest)
```
    Description copied from class: ProxyConnection
    
    Request the ProxyServer for Filters. By default, no-op filters are returned by DefaultHttpProxyServer. Subclasses of ProxyConnection can change this behaviour.
    
    Overrides:
    
    getHttpFiltersFromProxyServer in class ProxyConnection<HttpResponse>
    
    Parameters:
    
    httpRequest - Filter attached to the give HttpRequest (if any)
  - rememberCurrentResponse
```
private void rememberCurrentResponse(HttpResponse response)
```
    Keeps track of the current HttpResponse so that we can associate its headers with future related chunks for this same transfer.
  - respondWith
```
private void respondWith(HttpObject httpObject)
```
    Respond to the client with the given HttpObject.
  - connectAndWrite
```
private void connectAndWrite(HttpRequest initialRequest)
```
    Configures the connection to the upstream server and begins the ConnectionFlow.
    
    Parameters:
    
    initialRequest - the current HTTP request being handled
  - initializeConnectionFlow
```
private void initializeConnectionFlow()
```
    This method initializes our ConnectionFlow based on however this connection has been configured. If the disableSni value is true, this method will not pass peer information to the MitmManager when handling CONNECTs.
  - addFirstOrReplaceHandler
```
private void addFirstOrReplaceHandler(String name,
                                      ChannelHandler handler)
```
  - removeHandlerIfPresent
```
private void removeHandlerIfPresent(String name)
```
  - connectionFailed
```
protected boolean connectionFailed(Throwable cause)
                            throws UnknownHostException
```
    Called when the connection to the server or upstream chained proxy fails. This method may return true to indicate that the connection should be retried. If returning true, this method must set up the connection itself.
    
    Parameters:
    
    cause - the reason that our attempt to connect failed (can be null)
    
    Returns:
    
    true if we are trying to fall back to another connection
    
    Throws:
    
    UnknownHostException
  - resetConnectionForRetry
```
private void resetConnectionForRetry()
                              throws UnknownHostException
```
    Convenience method to prepare to retry this connection. Closes the connection's channel and sets up the connection again using setupConnectionParameters().
    
    Throws:
    
    UnknownHostException - when setupConnectionParameters() is unable to resolve the hostname
  - setupConnectionParameters
```
private void setupConnectionParameters()
                                throws UnknownHostException
```
    Set up our connection parameters based on server address and chained proxies.
    
    Throws:
    
    UnknownHostException - when unable to resolve the hostname to an IP address
  - initChannelPipeline
```
private void initChannelPipeline(ChannelPipeline pipeline,
                                 HttpRequest httpRequest)
```
    Initialize our ChannelPipeline to connect the upstream server. LittleProxy acts as a client here. A ChannelPipeline invokes the read (Inbound) handlers in ascending ordering of the list and then the write (Outbound) handlers in descending ordering. Regarding the Javadoc of HttpObjectAggregator it's needed to have the HttpResponseEncoder or HttpRequestEncoder before the HttpObjectAggregator in the ChannelPipeline.
  - connectionSucceeded
```
void connectionSucceeded(boolean shouldForwardInitialRequest)
```
    Do all the stuff that needs to be done after our ConnectionFlow has succeeded.
    
    Parameters:
    
    shouldForwardInitialRequest - whether or not we should forward the initial HttpRequest to the server after the connection has been established.
  - addressFor
```
public static InetSocketAddress addressFor(String hostAndPort,
                                           DefaultHttpProxyServer proxyServer)
                                    throws UnknownHostException
```
    Build an InetSocketAddress for the given hostAndPort.
    
    Parameters:
    
    hostAndPort - String representation of the host and port
    
    proxyServer - the current DefaultHttpProxyServer
    
    Returns:
    
    a resolved InetSocketAddress for the specified hostAndPort
    
    Throws:
    
    UnknownHostException - if hostAndPort could not be resolved, or if the input string could not be parsed into a host and port.
  - unresolvedAddressFor
```
private static InetSocketAddress unresolvedAddressFor(String hostAndPort)
```
    Similar to addressFor(String, DefaultHttpProxyServer) except that it does not resolve the address.
    
    Parameters:
    
    hostAndPort - the host and port to parse.
    
    Returns:
    
    an unresolved InetSocketAddress.
  - switchToWebSocketProtocol
```
void switchToWebSocketProtocol()
```

Class ProxyToServerConnection

Nested Class Summary

Nested classes/interfaces inherited from class org.littleshoot.proxy.impl.ProxyConnection

Nested classes/interfaces inherited from interface io.netty.channel.ChannelHandler

Field Summary

Fields inherited from class org.littleshoot.proxy.impl.ProxyConnection

Constructor Summary

Method Summary

Methods inherited from class org.littleshoot.proxy.impl.ProxyConnection

Methods inherited from class io.netty.channel.SimpleChannelInboundHandler

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter

Methods inherited from class io.netty.channel.ChannelHandlerAdapter

Methods inherited from class java.lang.Object

Methods inherited from interface io.netty.channel.ChannelHandler

Field Detail

HTTP_ENCODER_NAME

HTTP_DECODER_NAME

HTTP_PROXY_ENCODER_NAME

HTTP_REQUEST_WRITTEN_MONITOR_NAME

HTTP_RESPONSE_READ_MONITOR_NAME

SOCKS_ENCODER_NAME

SOCKS_DECODER_NAME

MAIN_HANDLER_NAME

clientConnection

serverConnection

transportProtocol

chainedProxyType

remoteAddress

localAddress

remoteAddressResolver

username

password

serverHostAndPort

chainedProxy

availableChainedProxies

currentFilters

connectionFlow

disableSni

connectLock

initialRequest

currentHttpRequest

currentHttpResponse

trafficHandler

MINIMUM_RECV_BUFFER_SIZE_BYTES

ConnectChannel

HTTPCONNECTWithChainedProxy

SOCKS4CONNECTWithChainedProxy

SOCKS5InitialRequest

SOCKS5SendPasswordCredentials

SOCKS5CONNECTRequestWithChainedProxy

MitmEncryptClientChannel

bytesReadMonitor

responseReadMonitor

bytesWrittenMonitor

requestWrittenMonitor

Constructor Detail

ProxyToServerConnection

Method Detail

create

read

readHAProxyMessage

readHTTPInitial

readHTTPChunk

readRaw

write

write

writeHttp

become

becameSaturated

becameWritable

timedOut

disconnected

exceptionCaught

getTransportProtocol

getChainedProxyType

getRemoteAddress

getServerHostAndPort

hasUpstreamChainedProxy

getChainedProxyAddress

getChainedProxy