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 }