KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > httpclient > ProxyClient


1 /*
2  * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//httpclient/src/java/org/apache/commons/httpclient/ProxyClient.java,v 1.5 2004/12/20 11:39:04 olegk Exp $
3  * $Revision: 480424 $
4  * $Date: 2006-11-29 05:56:49 +0000 (Wed, 29 Nov 2006) $
5  *
6  * ====================================================================
7  *
8  * Licensed to the Apache Software Foundation (ASF) under one or more
9  * contributor license agreements. See the NOTICE file distributed with
10  * this work for additional information regarding copyright ownership.
11  * The ASF licenses this file to You under the Apache License, Version 2.0
12  * (the "License"); you may not use this file except in compliance with
13  * the License. You may obtain a copy of the License at
14  *
15  * http://www.apache.org/licenses/LICENSE-2.0
16  *
17  * Unless required by applicable law or agreed to in writing, software
18  * distributed under the License is distributed on an "AS IS" BASIS,
19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20  * See the License for the specific language governing permissions and
21  * limitations under the License.
22  * ====================================================================
23  *
24  * This software consists of voluntary contributions made by many
25  * individuals on behalf of the Apache Software Foundation. For more
26  * information on the Apache Software Foundation, please see
27  * <http://www.apache.org/>.
28  *
29  */
30
31 package org.apache.commons.httpclient;
32
33 import java.io.IOException JavaDoc;
34 import java.net.Socket JavaDoc;
35
36 import org.apache.commons.httpclient.params.HttpClientParams;
37 import org.apache.commons.httpclient.params.HttpConnectionManagerParams;
38 import org.apache.commons.httpclient.params.HttpParams;
39
40 /**
41  * A client that provides {@link java.net.Socket sockets} for communicating through HTTP proxies
42  * via the HTTP CONNECT method. This is primarily needed for non-HTTP protocols that wish to
43  * communicate via an HTTP proxy.
44  *
45  * @author <a HREF="mailto:oleg@ural.ru">Oleg Kalnichevski</a>
46  * @author Michael Becke
47  *
48  * @since 3.0
49  *
50  * @version $Revision: 480424 $
51  */
52 public class ProxyClient {
53
54     // ----------------------------------------------------- Instance Variables
55
56     /**
57      * The {@link HttpState HTTP state} associated with this ProxyClient.
58      */
59     private HttpState state = new HttpState();
60     
61     /**
62      * The {@link HttpClientParams collection of parameters} associated with this ProxyClient.
63      */
64     private HttpClientParams params = null;
65
66     /**
67      * The {@link HostConfiguration host configuration} associated with
68      * the ProxyClient
69      */
70     private HostConfiguration hostConfiguration = new HostConfiguration();
71     
72     /**
73      * Creates an instance of ProxyClient using default {@link HttpClientParams parameter set}.
74      *
75      * @see HttpClientParams
76      */
77     public ProxyClient() {
78         this(new HttpClientParams());
79     }
80
81     /**
82      * Creates an instance of ProxyClient using the given
83      * {@link HttpClientParams parameter set}.
84      *
85      * @param params The {@link HttpClientParams parameters} to use.
86      *
87      * @see HttpClientParams
88      */
89     public ProxyClient(HttpClientParams params) {
90         super();
91         if (params == null) {
92             throw new IllegalArgumentException JavaDoc("Params may not be null");
93         }
94         this.params = params;
95     }
96
97     // ------------------------------------------------------------- Properties
98
99     /**
100      * Returns {@link HttpState HTTP state} associated with the ProxyClient.
101      *
102      * @see #setState(HttpState)
103      * @return the shared client state
104      */
105     public synchronized HttpState getState() {
106         return state;
107     }
108
109     /**
110      * Assigns {@link HttpState HTTP state} for the ProxyClient.
111      *
112      * @see #getState()
113      * @param state the new {@link HttpState HTTP state} for the client
114      */
115     public synchronized void setState(HttpState state) {
116         this.state = state;
117     }
118
119     /**
120      * Returns the {@link HostConfiguration host configuration} associated with the
121      * ProxyClient.
122      *
123      * @return {@link HostConfiguration host configuration}
124      */
125     public synchronized HostConfiguration getHostConfiguration() {
126         return hostConfiguration;
127     }
128
129     /**
130      * Assigns the {@link HostConfiguration host configuration} to use with the
131      * ProxyClient.
132      *
133      * @param hostConfiguration The {@link HostConfiguration host configuration} to set
134      */
135     public synchronized void setHostConfiguration(HostConfiguration hostConfiguration) {
136         this.hostConfiguration = hostConfiguration;
137     }
138
139     /**
140      * Returns {@link HttpClientParams HTTP protocol parameters} associated with this ProxyClient.
141      *
142      * @see HttpClientParams
143      */
144     public synchronized HttpClientParams getParams() {
145         return this.params;
146     }
147
148     /**
149      * Assigns {@link HttpClientParams HTTP protocol parameters} for this ProxyClient.
150      *
151      * @see HttpClientParams
152      */
153     public synchronized void setParams(final HttpClientParams params) {
154         if (params == null) {
155             throw new IllegalArgumentException JavaDoc("Parameters may not be null");
156         }
157         this.params = params;
158     }
159
160     /**
161      * Creates a socket that is connected, via the HTTP CONNECT method, to a proxy.
162      *
163      * <p>
164      * Even though HTTP CONNECT proxying is generally used for HTTPS tunneling, the returned
165      * socket will not have been wrapped in an SSL socket.
166      * </p>
167      *
168      * <p>
169      * Both the proxy and destination hosts must be set via the
170      * {@link #getHostConfiguration() host configuration} prior to calling this method.
171      * </p>
172      *
173      * @return the connect response
174      *
175      * @throws IOException
176      * @throws HttpException
177      *
178      * @see #getHostConfiguration()
179      */
180     public ConnectResponse connect() throws IOException JavaDoc, HttpException {
181         
182         HostConfiguration hostconf = getHostConfiguration();
183         if (hostconf.getProxyHost() == null) {
184             throw new IllegalStateException JavaDoc("proxy host must be configured");
185         }
186         if (hostconf.getHost() == null) {
187             throw new IllegalStateException JavaDoc("destination host must be configured");
188         }
189         if (hostconf.getProtocol().isSecure()) {
190             throw new IllegalStateException JavaDoc("secure protocol socket factory may not be used");
191         }
192         
193         ConnectMethod method = new ConnectMethod(getHostConfiguration());
194         method.getParams().setDefaults(getParams());
195         
196         DummyConnectionManager connectionManager = new DummyConnectionManager();
197         connectionManager.setConnectionParams(getParams());
198         
199         HttpMethodDirector director = new HttpMethodDirector(
200             connectionManager,
201             hostconf,
202             getParams(),
203             getState()
204         );
205         
206         director.executeMethod(method);
207         
208         ConnectResponse response = new ConnectResponse();
209         response.setConnectMethod(method);
210         
211         // only set the socket if the connect was successful
212 if (method.getStatusCode() == HttpStatus.SC_OK) {
213             response.setSocket(connectionManager.getConnection().getSocket());
214         } else {
215             connectionManager.getConnection().close();
216         }
217         
218         return response;
219     }
220
221     /**
222      * Contains the method used to execute the connect along with the created socket.
223      */
224     public static class ConnectResponse {
225         
226         private ConnectMethod connectMethod;
227         
228         private Socket JavaDoc socket;
229         
230         private ConnectResponse() {}
231         
232         /**
233          * Gets the method that was used to execute the connect. This method is useful for
234          * analyzing the proxy's response when a connect fails.
235          *
236          * @return the connectMethod.
237          */
238         public ConnectMethod getConnectMethod() {
239             return connectMethod;
240         }
241         /**
242          * @param connectMethod The connectMethod to set.
243          */
244         private void setConnectMethod(ConnectMethod connectMethod) {
245             this.connectMethod = connectMethod;
246         }
247         /**
248          * Gets the socket connected and authenticated (if appropriate) to the configured
249          * HTTP proxy, or <code>null</code> if a connection could not be made. It is the
250          * responsibility of the user to close this socket when it is no longer needed.
251          *
252          * @return the socket.
253          */
254         public Socket JavaDoc getSocket() {
255             return socket;
256         }
257         /**
258          * @param socket The socket to set.
259          */
260         private void setSocket(Socket JavaDoc socket) {
261             this.socket = socket;
262         }
263     }
264     
265     /**
266      * A connection manager that creates a single connection. Meant to be used only once.
267      */
268     static class DummyConnectionManager implements HttpConnectionManager {
269
270         private HttpConnection httpConnection;
271         
272         private HttpParams connectionParams;
273         
274         public void closeIdleConnections(long idleTimeout) {
275         }
276
277         public HttpConnection getConnection() {
278             return httpConnection;
279         }
280
281         public void setConnectionParams(HttpParams httpParams) {
282             this.connectionParams = httpParams;
283         }
284
285         public HttpConnection getConnectionWithTimeout(
286             HostConfiguration hostConfiguration, long timeout) {
287
288             httpConnection = new HttpConnection(hostConfiguration);
289             httpConnection.setHttpConnectionManager(this);
290             httpConnection.getParams().setDefaults(connectionParams);
291             return httpConnection;
292         }
293         
294         /**
295          * @deprecated
296          */
297         public HttpConnection getConnection(HostConfiguration hostConfiguration, long timeout)
298             throws HttpException {
299             return getConnectionWithTimeout(hostConfiguration, timeout);
300         }
301         
302         public HttpConnection getConnection(HostConfiguration hostConfiguration) {
303             return getConnectionWithTimeout(hostConfiguration, -1);
304         }
305     
306         public void releaseConnection(HttpConnection conn) {
307         }
308
309         public HttpConnectionManagerParams getParams() {
310             return null;
311         }
312
313         public void setParams(HttpConnectionManagerParams params) {
314         }
315     }
316 }
317
Popular Tags