View Javadoc

    1   /*
    2    * Copyright 2012 The Netty Project
    3    *
    4    * The Netty Project licenses this file to you under the Apache License,
    5    * version 2.0 (the "License"); you may not use this file except in compliance
    6    * with the 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.ipfilter;
    17
    18  import java.net.InetSocketAddress;
    19
    20  import org.jboss.netty.channel.ChannelEvent;
    21  import org.jboss.netty.channel.ChannelFuture;
    22  import org.jboss.netty.channel.ChannelFutureListener;
    23  import org.jboss.netty.channel.ChannelHandlerContext;
    24  import org.jboss.netty.channel.ChannelStateEvent;
    25  import org.jboss.netty.channel.ChannelUpstreamHandler;
    26  import org.jboss.netty.channel.Channels;
    27
    28  // TODO: Auto-generated Javadoc
    29
    30  /** General class that handle Ip Filtering. */
    31  public abstract class IpFilteringHandlerImpl implements ChannelUpstreamHandler, IpFilteringHandler {
    32
    33      private IpFilterListener listener;
    34
    35      /**
    36       * Called when the channel is connected. It returns True if the corresponding connection
    37       * is to be allowed. Else it returns False.
    38       *
    39       * @param inetSocketAddress the remote {@link InetSocketAddress} from client
    40       * @return True if the corresponding connection is allowed, else False.
    41       */
    42      protected abstract boolean accept(ChannelHandlerContext ctx, ChannelEvent e, InetSocketAddress inetSocketAddress)
    43              throws Exception;
    44
    45      /**
    46       * Called when the channel has the CONNECTED status and the channel was refused by a previous call to accept().
    47       * This method enables your implementation to send a message back to the client before closing
    48       * or whatever you need. This method returns a ChannelFuture on which the implementation
    49       * will wait uninterruptibly before closing the channel.<br>
    50       * For instance, If a message is sent back, the corresponding ChannelFuture has to be returned.
    51       *
    52       * @param inetSocketAddress the remote {@link InetSocketAddress} from client
    53       * @return the associated ChannelFuture to be waited for before closing the channel. Null is allowed.
    54       */
    55      protected ChannelFuture handleRefusedChannel(ChannelHandlerContext ctx, ChannelEvent e,
    56                                                   InetSocketAddress inetSocketAddress) throws Exception {
    57          if (listener == null) {
    58              return null;
    59          }
    60          return listener.refused(ctx, e, inetSocketAddress);
    61      }
    62
    63      protected ChannelFuture handleAllowedChannel(ChannelHandlerContext ctx, ChannelEvent e,
    64                                                   InetSocketAddress inetSocketAddress) throws Exception {
    65          if (listener == null) {
    66              return null;
    67          }
    68          return listener.allowed(ctx, e, inetSocketAddress);
    69      }
    70
    71      /**
    72       * Internal method to test if the current channel is blocked. Should not be overridden.
    73       *
    74       * @return True if the current channel is blocked, else False
    75       */
    76      protected boolean isBlocked(ChannelHandlerContext ctx) {
    77          return ctx.getAttachment() != null;
    78      }
    79
    80      /**
    81       * Called in handleUpstream, if this channel was previously blocked,
    82       * to check if whatever the event, it should be passed to the next entry in the pipeline.<br>
    83       * If one wants to not block events, just overridden this method by returning always true.<br><br>
    84       * <b>Note that OPENED and BOUND events are still passed to the next entry in the pipeline since
    85       * those events come out before the CONNECTED event and so the possibility to filter the connection.</b>
    86       *
    87       * @return True if the event should continue, False if the event should not continue
    88       *         since this channel was blocked by this filter
    89       */
    90      protected boolean continues(ChannelHandlerContext ctx, ChannelEvent e) throws Exception {
    91          if (listener != null) {
    92              return listener.continues(ctx, e);
    93          } else {
    94              return false;
    95          }
    96      }
    97
    98
    99      public void handleUpstream(ChannelHandlerContext ctx, ChannelEvent e) throws Exception {
    100         if (e instanceof ChannelStateEvent) {
    101             ChannelStateEvent evt = (ChannelStateEvent) e;
    102             switch (evt.getState()) {
    103                 case OPEN:
    104                 case BOUND:
    105                     // Special case: OPEND and BOUND events are before CONNECTED,
    106                     // but CLOSED and UNBOUND events are after DISCONNECTED: should those events be blocked too?
    107                     if (isBlocked(ctx) && !continues(ctx, evt)) {
    108                         // don't pass to next level since channel was blocked early
    109                         return;
    110                     } else {
    111                         ctx.sendUpstream(e);
    112                         return;
    113                     }
    114                 case CONNECTED:
    115                     if (evt.getValue() != null) {
    116                         // CONNECTED
    117                         InetSocketAddress inetSocketAddress = (InetSocketAddress) e.getChannel().getRemoteAddress();
    118                         if (!accept(ctx, e, inetSocketAddress)) {
    119                             ctx.setAttachment(Boolean.TRUE);
    120                             ChannelFuture future = handleRefusedChannel(ctx, e, inetSocketAddress);
    121                             if (future != null) {
    122                                 future.addListener(ChannelFutureListener.CLOSE);
    123                             } else {
    124                                 Channels.close(e.getChannel());
    125                             }
    126                             if (isBlocked(ctx) && !continues(ctx, evt)) {
    127                                 // don't pass to next level since channel was blocked early
    128                                 return;
    129                             }
    130                         } else {
    131                             handleAllowedChannel(ctx, e, inetSocketAddress);
    132                         }
    133                         // This channel is not blocked
    134                         ctx.setAttachment(null);
    135                     } else {
    136                         // DISCONNECTED
    137                         if (isBlocked(ctx) && !continues(ctx, evt)) {
    138                             // don't pass to next level since channel was blocked early
    139                             return;
    140                         }
    141                     }
    142                     break;
    143             }
    144         }
    145         if (isBlocked(ctx) && !continues(ctx, e)) {
    146             // don't pass to next level since channel was blocked early
    147             return;
    148         }
    149         // Whatever it is, if not blocked, goes to the next level
    150         ctx.sendUpstream(e);
    151     }
    152
    153
    154     public void setIpFilterListener(IpFilterListener listener) {
    155         this.listener = listener;
    156     }
    157
    158
    159     public void removeIpFilterListener() {
    160         listener = null;
    161
    162     }
    163
    164 }