View Javadoc

    1   /*
    2    *  Licensed to the Apache Software Foundation (ASF) under one
    3    *  or more contributor license agreements.  See the NOTICE file
    4    *  distributed with this work for additional information
    5    *  regarding copyright ownership.  The ASF licenses this file
    6    *  to you under the Apache License, Version 2.0 (the
    7    *  "License"); you may not use this file except in compliance
    8    *  with the License.  You may obtain a copy of the License at
    9    *
    10   *    http://www.apache.org/licenses/LICENSE-2.0
    11   *
    12   *  Unless required by applicable law or agreed to in writing,
    13   *  software distributed under the License is distributed on an
    14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    15   *  KIND, either express or implied.  See the License for the
    16   *  specific language governing permissions and limitations
    17   *  under the License.
    18   *
    19   */
    20  package org.apache.mina.proxy;
    21
    22  import java.util.LinkedList;
    23  import java.util.Queue;
    24
    25  import org.apache.mina.core.buffer.IoBuffer;
    26  import org.apache.mina.core.filterchain.IoFilter.NextFilter;
    27  import org.apache.mina.core.future.DefaultWriteFuture;
    28  import org.apache.mina.core.future.WriteFuture;
    29  import org.apache.mina.core.session.IoSession;
    30  import org.apache.mina.core.write.DefaultWriteRequest;
    31  import org.apache.mina.core.write.WriteRequest;
    32  import org.apache.mina.proxy.filter.ProxyFilter;
    33  import org.apache.mina.proxy.filter.ProxyHandshakeIoBuffer;
    34  import org.apache.mina.proxy.session.ProxyIoSession;
    35  import org.slf4j.Logger;
    36  import org.slf4j.LoggerFactory;
    37
    38  /**
    39   * AbstractProxyLogicHandler.java - Helper class to handle proxy handshaking logic. Derived classes
    40   * implement proxy type specific logic.
    41   * <p>
    42   * Based upon SSLHandler from mina-filter-ssl.
    43   *
    44   * @author <a href="http://mina.apache.org">Apache MINA Project</a>
    45   * @since MINA 2.0.0-M3
    46   */
    47  public abstract class AbstractProxyLogicHandler implements ProxyLogicHandler {
    48
    49      private final static Logger LOGGER = LoggerFactory.getLogger(AbstractProxyLogicHandler.class);
    50
    51      /**
    52       * Object that contains all the proxy authentication session informations.
    53       */
    54      private ProxyIoSession proxyIoSession;
    55
    56      /**
    57       * Queue of write events which occurred before the proxy handshake had completed.
    58       */
    59      private Queue<Event> writeRequestQueue = null;
    60
    61      /**
    62       * Has the handshake been completed.
    63       */
    64      private boolean handshakeComplete = false;
    65
    66      /**
    67       * Creates a new {@link AbstractProxyLogicHandler}.
    68       *
    69       * @param proxyIoSession {@link ProxyIoSession} in use.
    70       */
    71      public AbstractProxyLogicHandler(ProxyIoSession proxyIoSession) {
    72          this.proxyIoSession = proxyIoSession;
    73      }
    74
    75      /**
    76       * Returns the proxy filter {@link ProxyFilter}.
    77       */
    78      protected ProxyFilter getProxyFilter() {
    79          return proxyIoSession.getProxyFilter();
    80      }
    81
    82      /**
    83       * Returns the session.
    84       */
    85      protected IoSession getSession() {
    86          return proxyIoSession.getSession();
    87      }
    88
    89      /**
    90       * Returns the {@link ProxyIoSession} object.
    91       */
    92      public ProxyIoSession getProxyIoSession() {
    93          return proxyIoSession;
    94      }
    95
    96      /**
    97       * Writes data to the proxy server.
    98       *
    99       * @param nextFilter the next filter
    100      * @param data Data buffer to be written.
    101      */
    102     protected WriteFuture writeData(final NextFilter nextFilter, final IoBuffer data) {
    103         // write net data
    104         ProxyHandshakeIoBuffer writeBuffer = new ProxyHandshakeIoBuffer(data);
    105
    106         LOGGER.debug("   session write: {}", writeBuffer);
    107
    108         WriteFuture writeFuture = new DefaultWriteFuture(getSession());
    109         getProxyFilter().writeData(nextFilter, getSession(), new DefaultWriteRequest(writeBuffer, writeFuture), true);
    110
    111         return writeFuture;
    112     }
    113
    114     /**
    115      * Returns <code>true</code> if handshaking is complete and
    116      * data can be sent through the proxy.
    117      */
    118     public boolean isHandshakeComplete() {
    119         synchronized (this) {
    120             return handshakeComplete;
    121         }
    122     }
    123
    124     /**
    125      * Signals that the handshake has finished.
    126      */
    127     protected final void setHandshakeComplete() {
    128         synchronized (this) {
    129             handshakeComplete = true;
    130         }
    131
    132         ProxyIoSession proxyIoSession = getProxyIoSession();
    133         proxyIoSession.getConnector().fireConnected(proxyIoSession.getSession()).awaitUninterruptibly();
    134
    135         LOGGER.debug("  handshake completed");
    136
    137         // Connected OK
    138         try {
    139             proxyIoSession.getEventQueue().flushPendingSessionEvents();
    140             flushPendingWriteRequests();
    141         } catch (Exception ex) {
    142             LOGGER.error("Unable to flush pending write requests", ex);
    143         }
    144     }
    145
    146     /**
    147      * Send any write requests which were queued whilst waiting for handshaking to complete.
    148      */
    149     protected synchronized void flushPendingWriteRequests() throws Exception {
    150         LOGGER.debug(" flushPendingWriteRequests()");
    151
    152         if (writeRequestQueue == null) {
    153             return;
    154         }
    155
    156         Event scheduledWrite;
    157         while ((scheduledWrite = writeRequestQueue.poll()) != null) {
    158             LOGGER.debug(" Flushing buffered write request: {}", scheduledWrite.data);
    159
    160             getProxyFilter().filterWrite(scheduledWrite.nextFilter, getSession(), (WriteRequest) scheduledWrite.data);
    161         }
    162
    163         // Free queue
    164         writeRequestQueue = null;
    165     }
    166
    167     /**
    168      * Enqueue a message to be written once handshaking is complete.
    169      */
    170     public synchronized void enqueueWriteRequest(final NextFilter nextFilter, final WriteRequest writeRequest) {
    171         if (writeRequestQueue == null) {
    172             writeRequestQueue = new LinkedList<Event>();
    173         }
    174
    175         writeRequestQueue.offer(new Event(nextFilter, writeRequest));
    176     }
    177
    178     /**
    179      * Closes the session.
    180      *
    181      * @param message the error message
    182      * @param t the exception which caused the session closing
    183      */
    184     protected void closeSession(final String message, final Throwable t) {
    185         if (t != null) {
    186             LOGGER.error(message, t);
    187             proxyIoSession.setAuthenticationFailed(true);
    188         } else {
    189             LOGGER.error(message);
    190         }
    191
    192         getSession().close(true);
    193     }
    194
    195     /**
    196      * Closes the session.
    197      *
    198      * @param message the error message
    199      */
    200     protected void closeSession(final String message) {
    201         closeSession(message, null);
    202     }
    203
    204     /**
    205      * Event wrapper class for enqueued events.
    206      */
    207     private final static class Event {
    208         private final NextFilter nextFilter;
    209
    210         private final Object data;
    211
    212         Event(final NextFilter nextFilter, final Object data) {
    213             this.nextFilter = nextFilter;
    214             this.data = data;
    215         }
    216
    217         public Object getData() {
    218             return data;
    219         }
    220
    221         public NextFilter getNextFilter() {
    222             return nextFilter;
    223         }
    224     }
    225 }