View Javadoc

    1   /*
    2    * Copyright 2009 Red Hat, Inc.
    3    *
    4    * Red Hat licenses this file to you under the Apache License, version 2.0
    5    * (the "License"); you may not use this file except in compliance with the
    6    * License.  You may obtain a copy of the License at:
    7    *
    8    *    http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
    13   * License for the specific language governing permissions and limitations
    14   * under the License.
    15   */
    16  package org.jboss.netty.handler.codec.http;
    17
    18  import static org.jboss.netty.channel.Channels.*;
    19  import static org.jboss.netty.handler.codec.http.HttpHeaders.*;
    20
    21  import java.util.List;
    22  import java.util.Map.Entry;
    23
    24  import org.jboss.netty.buffer.ChannelBuffer;
    25  import org.jboss.netty.buffer.ChannelBuffers;
    26  import org.jboss.netty.channel.ChannelHandler;
    27  import org.jboss.netty.channel.ChannelHandlerContext;
    28  import org.jboss.netty.channel.ChannelPipeline;
    29  import org.jboss.netty.channel.Channels;
    30  import org.jboss.netty.channel.MessageEvent;
    31  import org.jboss.netty.channel.SimpleChannelUpstreamHandler;
    32  import org.jboss.netty.handler.codec.frame.TooLongFrameException;
    33  import org.jboss.netty.util.CharsetUtil;
    34
    35  /**
    36   * A {@link ChannelHandler} that aggregates an {@link HttpMessage}
    37   * and its following {@link HttpChunk}s into a single {@link HttpMessage} with
    38   * no following {@link HttpChunk}s.  It is useful when you don't want to take
    39   * care of HTTP messages whose transfer encoding is 'chunked'.  Insert this
    40   * handler after {@link HttpMessageDecoder} in the {@link ChannelPipeline}:
    41   * <pre>
    42   * {@link ChannelPipeline} p = ...;
    43   * ...
    44   * p.addLast("decoder", new {@link HttpRequestDecoder}());
    45   * p.addLast("aggregator", <b>new {@link HttpChunkAggregator}(1048576)</b>);
    46   * ...
    47   * p.addLast("encoder", new {@link HttpResponseEncoder}());
    48   * p.addLast("handler", new HttpRequestHandler());
    49   * </pre>
    50   *
    51   * @author <a href="http://www.jboss.org/netty/">The Netty Project</a>
    52   * @author <a href="http://gleamynode.net/">Trustin Lee</a>
    53   * @version $Rev: 2370 $, $Date: 2010-10-19 14:40:44 +0900 (Tue, 19 Oct 2010) $
    54   *
    55   * @apiviz.landmark
    56   * @apiviz.has org.jboss.netty.handler.codec.http.HttpChunk oneway - - filters out
    57   */
    58  public class HttpChunkAggregator extends SimpleChannelUpstreamHandler {
    59
    60      private static final ChannelBuffer CONTINUE = ChannelBuffers.copiedBuffer(
    61              "HTTP/1.1 100 Continue\r\n\r\n", CharsetUtil.US_ASCII);
    62
    63      private final int maxContentLength;
    64      private HttpMessage currentMessage;
    65
    66      /**
    67       * Creates a new instance.
    68       *
    69       * @param maxContentLength
    70       *        the maximum length of the aggregated content.
    71       *        If the length of the aggregated content exceeds this value,
    72       *        a {@link TooLongFrameException} will be raised.
    73       */
    74      public HttpChunkAggregator(int maxContentLength) {
    75          if (maxContentLength <= 0) {
    76              throw new IllegalArgumentException(
    77                      "maxContentLength must be a positive integer: " +
    78                      maxContentLength);
    79          }
    80          this.maxContentLength = maxContentLength;
    81      }
    82
    83      @Override
    84      public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    85              throws Exception {
    86
    87          Object msg = e.getMessage();
    88          HttpMessage currentMessage = this.currentMessage;
    89
    90          if (msg instanceof HttpMessage) {
    91              HttpMessage m = (HttpMessage) msg;
    92
    93              // Handle the 'Expect: 100-continue' header if necessary.
    94              // TODO: Respond with 413 Request Entity Too Large
    95              //   and discard the traffic or close the connection.
    96              //       No need to notify the upstream handlers - just log.
    97              //       If decoding a response, just throw an exception.
    98              if (is100ContinueExpected(m)) {
    99                  write(ctx, succeededFuture(ctx.getChannel()), CONTINUE.duplicate());
    100             }
    101
    102             if (m.isChunked()) {
    103                 // A chunked message - remove 'Transfer-Encoding' header,
    104                 // initialize the cumulative buffer, and wait for incoming chunks.
    105                 List<String> encodings = m.getHeaders(HttpHeaders.Names.TRANSFER_ENCODING);
    106                 encodings.remove(HttpHeaders.Values.CHUNKED);
    107                 if (encodings.isEmpty()) {
    108                     m.removeHeader(HttpHeaders.Names.TRANSFER_ENCODING);
    109                 }
    110                 m.setChunked(false);
    111                 m.setContent(ChannelBuffers.dynamicBuffer(e.getChannel().getConfig().getBufferFactory()));
    112                 this.currentMessage = m;
    113             } else {
    114                 // Not a chunked message - pass through.
    115                 this.currentMessage = null;
    116                 ctx.sendUpstream(e);
    117             }
    118         } else if (msg instanceof HttpChunk) {
    119             // Sanity check
    120             if (currentMessage == null) {
    121                 throw new IllegalStateException(
    122                         "received " + HttpChunk.class.getSimpleName() +
    123                         " without " + HttpMessage.class.getSimpleName());
    124             }
    125
    126             // Merge the received chunk into the content of the current message.
    127             HttpChunk chunk = (HttpChunk) msg;
    128             ChannelBuffer content = currentMessage.getContent();
    129
    130             if (content.readableBytes() > maxContentLength - chunk.getContent().readableBytes()) {
    131                 // TODO: Respond with 413 Request Entity Too Large
    132                 //   and discard the traffic or close the connection.
    133                 //       No need to notify the upstream handlers - just log.
    134                 //       If decoding a response, just throw an exception.
    135                 throw new TooLongFrameException(
    136                         "HTTP content length exceeded " + maxContentLength +
    137                         " bytes.");
    138             }
    139
    140             content.writeBytes(chunk.getContent());
    141             if (chunk.isLast()) {
    142                 this.currentMessage = null;
    143
    144                 // Merge trailing headers into the message.
    145                 if (chunk instanceof HttpChunkTrailer) {
    146                     HttpChunkTrailer trailer = (HttpChunkTrailer) chunk;
    147                     for (Entry<String, String> header: trailer.getHeaders()) {
    148                         currentMessage.setHeader(header.getKey(), header.getValue());
    149                     }
    150                 }
    151
    152                 // Set the 'Content-Length' header.
    153                 currentMessage.setHeader(
    154                         HttpHeaders.Names.CONTENT_LENGTH,
    155                         String.valueOf(content.readableBytes()));
    156
    157                 // All done - generate the event.
    158                 Channels.fireMessageReceived(ctx, currentMessage, e.getRemoteAddress());
    159             }
    160         } else {
    161             // Neither HttpMessage or HttpChunk
    162             ctx.sendUpstream(e);
    163         }
    164     }
    165 }