private static FilterChainContext obtainProtocolChainContext(
      final FilterChainContext ctx, final FilterChain completeProtocolFilterChain) {

    final FilterChainContext newFilterChainContext =
        completeProtocolFilterChain.obtainFilterChainContext(
            ctx.getConnection(),
            ctx.getStartIdx() + 1,
            completeProtocolFilterChain.size(),
            ctx.getFilterIdx() + 1);

    newFilterChainContext.setAddressHolder(ctx.getAddressHolder());
    newFilterChainContext.setMessage(ctx.getMessage());
    newFilterChainContext.getInternalContext().setIoEvent(ctx.getInternalContext().getIoEvent());
    ctx.getConnection().setProcessor(completeProtocolFilterChain);
    return newFilterChainContext;
  }
Exemplo n.º 2
0
  @Override
  public NextAction handleWrite(FilterChainContext context) throws IOException {
    Connection<?> connection = context.getConnection();
    GrizzlyChannel channel = GrizzlyChannel.getOrAddChannel(connection, url, handler);
    try {
      UnsafeByteArrayOutputStream output = new UnsafeByteArrayOutputStream(1024); // 不需要关闭

      if (!(context.getMessage() instanceof Response)) {
        downstreamCodec.encode(channel, output, context.getMessage());
      } else {
        upstreamCodec.encode(channel, output, context.getMessage());
      }

      GrizzlyChannel.removeChannelIfDisconnectd(connection);
      byte[] bytes = output.toByteArray();
      Buffer buffer = connection.getTransport().getMemoryManager().allocate(bytes.length);
      buffer.put(bytes);
      buffer.flip();
      buffer.allowBufferDispose(true);
      context.setMessage(buffer);
    } finally {
      GrizzlyChannel.removeChannelIfDisconnectd(connection);
    }
    return context.getInvokeAction();
  }
    @Override
    public NextAction handleRead(final FilterChainContext ctx) throws IOException {

      String message = (String) ctx.getMessage();

      logger.log(Level.INFO, "First chunk come: {0}", message);
      intermResultQueue.add(message);

      Connection connection = ctx.getConnection();
      connection.setBlockingReadTimeout(10, TimeUnit.SECONDS);

      try {
        for (int i = 0; i < clientMsgs - 1; i++) {
          final ReadResult rr = ctx.read();
          final String blckMsg = (String) rr.getMessage();

          rr.recycle();
          logger.log(Level.INFO, "Blocking chunk come: {0}", blckMsg);
          intermResultQueue.add(blckMsg);
          message += blckMsg;
        }
      } catch (Exception e) {
        intermResultQueue.add(e);
        return ctx.getStopAction();
      }

      ctx.setMessage(message);

      return ctx.getInvokeAction();
    }
  @SuppressWarnings("unchecked")
  @Override
  public NextAction handleEvent(final FilterChainContext ctx, final FilterChainEvent event)
      throws IOException {

    final Object type = event.type();
    if (type == ContinueEvent.class) {
      final ContinueEvent continueEvent = (ContinueEvent) event;
      ((ExpectHandler) continueEvent.getContext().getBodyHandler()).finish(ctx);
    } else if (type == TunnelRequestEvent.class) {
      // Disable SSL for the time being...
      ctx.notifyDownstream(new SSLSwitchingEvent(false, ctx.getConnection()));
      ctx.suspend();
      TunnelRequestEvent tunnelRequestEvent = (TunnelRequestEvent) event;
      final ProxyServer proxyServer = tunnelRequestEvent.getProxyServer();
      final URI requestUri = tunnelRequestEvent.getUri();

      RequestBuilder builder = new RequestBuilder();
      builder.setMethod(Method.CONNECT.getMethodString());
      builder.setUrl("http://" + getAuthority(requestUri));
      Request request = builder.build();

      AsyncHandler handler =
          new AsyncCompletionHandler() {
            @Override
            public Object onCompleted(Response response) throws Exception {
              if (response.getStatusCode() != 200) {
                PROXY_AUTH_FAILURE.set(ctx.getConnection(), Boolean.TRUE);
              }
              ctx.notifyDownstream(new SSLSwitchingEvent(true, ctx.getConnection()));
              ctx.notifyDownstream(event);
              return response;
            }
          };
      final GrizzlyResponseFuture future =
          new GrizzlyResponseFuture(grizzlyAsyncHttpProvider, request, handler, proxyServer);
      future.setDelegate(SafeFutureImpl.create());

      grizzlyAsyncHttpProvider.execute(
          ctx.getConnection(), request, handler, future, HttpTxContext.get(ctx));
      return ctx.getSuspendAction();
    }

    return ctx.getStopAction();
  }
 private static boolean checkHandshakeError(
     final FilterChainContext ctx, final HttpTxContext httpCtx) {
   Throwable t = getHandshakeError(ctx.getConnection());
   if (t != null) {
     httpCtx.abort(t);
     return true;
   }
   return false;
 }
Exemplo n.º 6
0
    @Override
    public NextAction handleClose(final FilterChainContext ctx) throws IOException {
      Socket tunnelSocket = tunnelSockets.get(ctx.getConnection());
      if (tunnelSocket != null) {
        tunnelSocket.close();
      }

      return ctx.getStopAction();
    }
 private static boolean checkProxyAuthFailure(
     final FilterChainContext ctx, final HttpTxContext httpCtx) {
   final Boolean failed = PROXY_AUTH_FAILURE.get(ctx.getConnection());
   if (failed != null && failed) {
     httpCtx.abort(new IllegalStateException("Unable to authenticate with proxy"));
     return true;
   }
   return false;
 }
  @Override
  public NextAction handleRead(final FilterChainContext ctx) throws IOException {
    final HttpContent httpContent = ctx.getMessage();
    if (httpContent.isLast()) {
      // Perform the cleanup logic if it's the last chunk of the payload
      final HttpResponsePacket response = (HttpResponsePacket) httpContent.getHttpHeader();

      recycleRequestResponsePackets(ctx.getConnection(), response);
      return ctx.getStopAction();
    }

    return ctx.getInvokeAction();
  }
  private static FilterChainContext checkAndHandleFilterChainUpdate(
      final FilterChainContext ctx, final FilterChainContext sendingCtx) {
    FilterChainContext ctxLocal = sendingCtx;
    SSLConnectionContext sslCtx = SSLUtils.getSslConnectionContext(ctx.getConnection());
    if (sslCtx != null) {
      FilterChain fc = sslCtx.getNewConnectionFilterChain();

      if (fc != null) {
        // Create a new FilterChain context using the new
        // FilterChain.
        // TODO:  We need to mark this connection somehow
        //        as being only suitable for this type of
        //        request.
        ctxLocal = obtainProtocolChainContext(ctx, fc);
      }
    }
    return ctxLocal;
  }
Exemplo n.º 10
0
 @Override
 public NextAction handleRead(FilterChainContext context) throws IOException {
   Object message = context.getMessage();
   Connection<?> connection = context.getConnection();
   Channel channel = GrizzlyChannel.getOrAddChannel(connection, url, handler);
   try {
     if (message instanceof Buffer) { // 收到新的数据包
       Buffer buffer = (Buffer) message; // 缓存
       int readable = buffer.capacity(); // 本次可读取新数据的大小
       if (readable == 0) {
         return context.getStopAction();
       }
       byte[] bytes; // byte[]缓存区,将Buffer转成byte[],再转成UnsafeByteArrayInputStream
       int offset; // 指向已用数据的偏移量,off之前的数据都是已用过的
       int limit; // 有效长度,limit之后的长度是空白或无效数据,off到limit之间的数据是准备使用的有效数据
       Object[] remainder = (Object[]) channel.getAttribute(BUFFER_KEY); // 上次序列化剩下的数据
       channel.removeAttribute(BUFFER_KEY);
       if (remainder == null) { // 如果没有,创建新的bytes缓存
         bytes = new byte[bufferSize];
         offset = 0;
         limit = 0;
       } else { // 如果有,使用剩下的bytes缓存
         bytes = (byte[]) remainder[0];
         offset = (Integer) remainder[1];
         limit = (Integer) remainder[2];
       }
       return receive(context, channel, buffer, readable, bytes, offset, limit);
     } else if (message instanceof Object[]) { // 同一Buffer多轮Filter,即:一个Buffer里有多个请求
       Object[] remainder = (Object[]) message;
       Buffer buffer = (Buffer) remainder[0];
       int readable = (Integer) remainder[1];
       byte[] bytes = (byte[]) remainder[2];
       int offset = (Integer) remainder[3];
       int limit = (Integer) remainder[4];
       return receive(context, channel, buffer, readable, bytes, offset, limit);
     } else { // 其它事件直接往下传
       return context.getInvokeAction();
     }
   } finally {
     GrizzlyChannel.removeChannelIfDisconnectd(connection);
   }
 }
Exemplo n.º 11
0
  @Override
  public NextAction handleRead(FilterChainContext ctx) throws IOException {

    final Object message = ctx.getMessage();

    if (_logger.isDebugEnabled()) {
      _logger.debug(String.format("%s: Got [%s] from [%s].", this, message, ctx.getAddress()));
    }

    String responseXML = _coreCommandProcessor.processCommand((String) message);

    if (_logger.isDebugEnabled()) {
      _logger.debug(
          String.format("%s: Returning [%s] to [%s].", this, responseXML, ctx.getAddress()));
    }

    ctx.write(ctx.getAddress(), responseXML, null);

    //  Close the connection
    ctx.getConnection().closeSilently();

    return ctx.getStopAction();
  }
Exemplo n.º 12
0
  /**
   * Per-request initialization required for the InputBuffer to function properly.
   *
   * @param httpHeader the header from which input will be obtained.
   * @param ctx the FilterChainContext for the chain processing this request
   */
  public void initialize(final HttpHeader httpHeader, final FilterChainContext ctx) {

    if (ctx == null) {
      throw new IllegalArgumentException("ctx cannot be null.");
    }
    this.httpHeader = httpHeader;

    this.ctx = ctx;
    connection = ctx.getConnection();
    final Object message = ctx.getMessage();
    if (message instanceof HttpContent) {
      final HttpContent content = (HttpContent) message;

      // Check if HttpContent is chunked message trailer w/ headers
      checkHttpTrailer(content);
      updateInputContentBuffer(content.getContent());
      contentRead = content.isLast();
      content.recycle();

      if (LOGGER.isLoggable(LOGGER_LEVEL)) {
        log("InputBuffer %s initialize with ready content: %s", this, inputContentBuffer);
      }
    }
  }
Exemplo n.º 13
0
    @Override
    public NextAction handleRead(FilterChainContext ctx) throws IOException {
      // Get the parsed HttpContent (we assume prev. filter was HTTP)
      HttpContent message = ctx.getMessage();
      Socket tunnelSocket = tunnelSockets.get(ctx.getConnection());

      if (tunnelSocket == null) {
        // handle connection procedure
        return GrizzlyModProxy.this.handleConnect(ctx, message);
      }

      if (message.getContent().hasRemaining()) {
        // relay the content to the tunnel connection

        Buffer buffer = message.getContent();
        message.recycle();

        tunnelSocket
            .getOutputStream()
            .write(buffer.array(), buffer.arrayOffset(), buffer.remaining());
      }

      return ctx.getStopAction();
    }
Exemplo n.º 14
0
  /**
   * Method is called, when new client {@link Connection} was connected to some endpoint
   *
   * @param ctx the filter chain context
   * @return the next action to be executed by chain
   * @throws java.io.IOException
   */
  @Override
  public NextAction handleConnect(FilterChainContext ctx) throws IOException {
    newConnection(ctx.getConnection());

    return ctx.getInvokeAction();
  }
Exemplo n.º 15
0
 /**
  * Method is called, when the {@link Connection} is getting closed
  *
  * @param ctx the filter chain context
  * @return the next action to be executed by chain
  * @throws java.io.IOException
  */
 @Override
 public NextAction handleClose(FilterChainContext ctx) throws IOException {
   activeConnectionsMap.remove(ctx.getConnection());
   return ctx.getInvokeAction();
 }
Exemplo n.º 16
0
  /**
   * Method invoked when a first massage (Assumed to be HTTP) is received. Normally this would be
   * HTTP CONNECT and this method processes it and opens a connection to the destination (the server
   * that the client wants to access).
   *
   * <p>This method can be overridden to provide a test-specific handling of the CONNECT method.
   */
  protected NextAction handleConnect(FilterChainContext ctx, HttpContent content) {
    System.out.println("Handle CONNECT start . . .");
    HttpHeader httpHeader = content.getHttpHeader();
    HttpRequestPacket requestPacket = (HttpRequestPacket) httpHeader.getHttpHeader();

    if (!requestPacket.getMethod().matchesMethod("CONNECT")) {
      System.out.println("Received method is not CONNECT");
      writeHttpResponse(ctx, 400);
      return ctx.getStopAction();
    }

    String destinationUri = requestPacket.getRequestURI();

    // We expect URI in form host:port, this is not flexible, but we use it only to test our clients
    int colonIdx = destinationUri.indexOf(':');

    if (colonIdx == -1) {
      System.out.println("Destination URI not in host:port format: " + destinationUri);
      writeHttpResponse(ctx, 400);
      return ctx.getStopAction();
    }

    String hostName = destinationUri.substring(0, colonIdx);
    String portStr = destinationUri.substring(colonIdx + 1);

    int port;
    try {
      port = Integer.parseInt(portStr);
    } catch (Throwable t) {
      System.out.println("Could not parse destination port: " + portStr);
      writeHttpResponse(ctx, 400);
      return ctx.getStopAction();
    }

    try {
      Socket tunnelSocket = new Socket(hostName, port);

      Connection grizzlyConnection = ctx.getConnection();
      tunnelSockets.set(grizzlyConnection, tunnelSocket);

      TunnelSocketReader tunnelSocketReader =
          new TunnelSocketReader(tunnelSocket, grizzlyConnection);
      executorService.submit(tunnelSocketReader::read);
    } catch (IOException e) {
      writeHttpResponse(ctx, 400);
      return ctx.getStopAction();
    }

    // Grizzly does not like CONNECT method and sets "keep alive" to false, if it is present
    // This hacks Grizzly, so it will keep the connection open
    HttpRequestPacket request = getHttpRequest(ctx);
    request.getResponse().getProcessingState().setKeepAlive(true);
    request.getResponse().setContentLength(0);
    request.setMethod("GET");
    // end of hack

    writeHttpResponse(ctx, 200);

    System.out.println("Connection to proxy established.");

    return ctx.getStopAction();
  }
  private boolean sendAsGrizzlyRequest(
      final RequestInfoHolder requestInfoHolder, final FilterChainContext ctx) throws IOException {

    HttpTxContext httpTxContext = requestInfoHolder.getHttpTxContext();
    if (httpTxContext == null) {
      httpTxContext = HttpTxContext.create(requestInfoHolder);
    }

    if (checkProxyAuthFailure(ctx, httpTxContext)) {
      return true;
    }

    final Request request = httpTxContext.getRequest();
    final URI uri = request.isUseRawUrl() ? request.getRawURI() : request.getURI();
    boolean secure = Utils.isSecure(uri);

    // If the request is secure, check to see if an error occurred during
    // the handshake.  We have to do this here, as the error would occur
    // out of the scope of a HttpTxContext so there would be
    // no good way to communicate the problem to the caller.
    if (secure && checkHandshakeError(ctx, httpTxContext)) {
      return true;
    }

    if (isUpgradeRequest(httpTxContext.getHandler())
        && isWSRequest(httpTxContext.getRequestUrl())) {
      httpTxContext.setWSRequest(true);
      convertToUpgradeRequest(httpTxContext);
    }

    HttpRequestPacket requestPacket = requestCache.poll();
    if (requestPacket == null) {
      requestPacket = new HttpRequestPacketImpl();
    }
    requestPacket.setMethod(request.getMethod());
    requestPacket.setProtocol(Protocol.HTTP_1_1);

    // Special handling for CONNECT.
    if (Method.CONNECT.matchesMethod(request.getMethod())) {
      final int port = uri.getPort();
      requestPacket.setRequestURI(uri.getHost() + ':' + (port == -1 ? 443 : port));
    } else {
      requestPacket.setRequestURI(uri.getPath());
    }

    if (Utils.requestHasEntityBody(request)) {
      final long contentLength = request.getContentLength();
      if (contentLength >= 0) {
        requestPacket.setContentLengthLong(contentLength);
        requestPacket.setChunked(false);
      } else {
        requestPacket.setChunked(true);
      }
    }

    if (httpTxContext.isWSRequest()) {
      try {
        final URI wsURI = new URI(httpTxContext.getWsRequestURI());
        httpTxContext.setProtocolHandler(Version.RFC6455.createHandler(true));
        httpTxContext.setHandshake(httpTxContext.getProtocolHandler().createHandShake(wsURI));
        requestPacket =
            (HttpRequestPacket) httpTxContext.getHandshake().composeHeaders().getHttpHeader();
      } catch (URISyntaxException e) {
        throw new IllegalArgumentException("Invalid WS URI: " + httpTxContext.getWsRequestURI());
      }
    }

    requestPacket.setSecure(secure);
    addQueryString(request, requestPacket);
    addHostHeader(request, uri, requestPacket);
    addGeneralHeaders(request, requestPacket);
    addCookies(request, requestPacket);

    initTransferCompletionHandler(request, httpTxContext.getHandler());

    final HttpRequestPacket requestPacketLocal = requestPacket;
    FilterChainContext sendingCtx = ctx;

    if (secure) {
      // Check to see if the ProtocolNegotiator has given
      // us a different FilterChain to use.  If so, we need
      // use a different FilterChainContext when invoking sendRequest().
      sendingCtx = checkAndHandleFilterChainUpdate(ctx, sendingCtx);
    }
    final Connection c = ctx.getConnection();
    if (!Utils.isSpdyConnection(c)) {
      HttpContext.newInstance(ctx, c, c, c);
    } else {
      SpdySession session = SpdySession.get(c);
      final Lock lock = session.getNewClientStreamLock();
      try {
        lock.lock();
        SpdyStream stream =
            session.openStream(
                requestPacketLocal,
                session.getNextLocalStreamId(),
                0,
                0,
                0,
                false,
                !requestPacketLocal.isExpectContent());
        HttpContext.newInstance(ctx, stream, stream, stream);
      } finally {
        lock.unlock();
      }
    }
    HttpTxContext.set(ctx, httpTxContext);
    return sendRequest(sendingCtx, request, requestPacketLocal);
  }