← Back to branch summary

~ubuntu-branches/ubuntu/wily/libjboss-remoting-java/wily

« back to all changes in this revision

Viewing changes to src/main/org/jboss/remoting/transport/http/HTTPClientInvoker.java

  • Committer: Package Import Robot
  • Author(s): Torsten Werner
  • Date: 2011-09-09 14:01:03 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: package-import@ubuntu.com-20110909140103-hqokx61534tas9rg
Tags: 2.5.3.SP1-1
http://bugs.debian.org/628303
* Newer but not newest upstream release. Do not build samples.
* Change debian/watch to upstream's svn repo.
* Add patch to fix compile error caused by tomcat update.
  (Closes: #628303)
* Switch to source format 3.0.
* Switch to debhelper level 7.
* Remove useless Depends.
* Update Standards-Version: 3.9.2.
* Update README.source.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/main/org/jboss/remoting/transport/http/HTTPClientInvoker.java
 
1
/*
 
2
* JBoss, Home of Professional Open Source
 
3
* Copyright 2005, JBoss Inc., and individual contributors as indicated
 
4
* by the @authors tag. See the copyright.txt in the distribution for a
 
5
* full listing of individual contributors.
 
6
*
 
7
* This is free software; you can redistribute it and/or modify it
 
8
* under the terms of the GNU Lesser General Public License as
 
9
* published by the Free Software Foundation; either version 2.1 of
 
10
* the License, or (at your option) any later version.
 
11
*
 
12
* This software is distributed in the hope that it will be useful,
 
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 
15
* Lesser General Public License for more details.
 
16
*
 
17
* You should have received a copy of the GNU Lesser General Public
 
18
* License along with this software; if not, write to the Free
 
19
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 
20
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
21
*/
 
22
 
 
23
package org.jboss.remoting.transport.http;
 
24
 
 
25
import org.jboss.logging.Logger;
 
26
import org.jboss.remoting.CannotConnectException;
 
27
import org.jboss.remoting.ConnectionFailedException;
 
28
import org.jboss.remoting.Home;
 
29
import org.jboss.remoting.InvocationRequest;
 
30
import org.jboss.remoting.InvocationResponse;
 
31
import org.jboss.remoting.InvokerLocator;
 
32
import org.jboss.remoting.RemoteClientInvoker;
 
33
import org.jboss.remoting.ServerInvoker;
 
34
import org.jboss.remoting.Version;
 
35
import org.jboss.remoting.marshal.MarshalFactory;
 
36
import org.jboss.remoting.marshal.Marshaller;
 
37
import org.jboss.remoting.marshal.UnMarshaller;
 
38
import org.jboss.remoting.marshal.VersionedMarshaller;
 
39
import org.jboss.remoting.marshal.VersionedUnMarshaller;
 
40
import org.jboss.remoting.marshal.compress.CompressingUnMarshaller;
 
41
import org.jboss.remoting.marshal.http.HTTPMarshaller;
 
42
import org.jboss.remoting.marshal.http.HTTPUnMarshaller;
 
43
import org.jboss.remoting.marshal.serializable.SerializableUnMarshaller;
 
44
import org.jboss.remoting.serialization.ClassLoaderUtility;
 
45
import org.jboss.remoting.transport.web.WebUtil;
 
46
import org.jboss.remoting.util.SecurityUtility;
 
47
import org.jboss.util.Base64;
 
48
import org.jboss.util.threadpool.BasicThreadPool;
 
49
import org.jboss.util.threadpool.BlockingMode;
 
50
import org.jboss.util.threadpool.RunnableTaskWrapper;
 
51
import org.jboss.util.threadpool.Task;
 
52
import org.jboss.util.threadpool.ThreadPool;
 
53
 
 
54
import java.io.EOFException;
 
55
import java.io.IOException;
 
56
import java.io.InputStream;
 
57
import java.io.OutputStream;
 
58
import java.lang.reflect.Constructor;
 
59
import java.lang.reflect.Field;
 
60
import java.lang.reflect.InvocationTargetException;
 
61
import java.lang.reflect.Method;
 
62
import java.net.HttpURLConnection;
 
63
import java.net.InetSocketAddress;
 
64
import java.net.SocketAddress;
 
65
import java.net.SocketTimeoutException;
 
66
import java.net.URL;
 
67
import java.security.AccessController;
 
68
import java.security.PrivilegedActionException;
 
69
import java.security.PrivilegedExceptionAction;
 
70
import java.util.HashMap;
 
71
import java.util.Iterator;
 
72
import java.util.List;
 
73
import java.util.Map;
 
74
import java.util.Set;
 
75
 
 
76
/**
 
77
 * HTTP client invoker.  Used for making http requests on http/servlet invoker.
 
78
 *
 
79
 * @author <a href="mailto:tom@jboss.org">Tom Elrod</a>
 
80
 */
 
81
public class HTTPClientInvoker extends RemoteClientInvoker
 
82
{
 
83
   /**
 
84
    * Key for the configuration map that determines the threadpool size for 
 
85
    * simulated timeouts when using jdk 1.4.
 
86
    */
 
87
   public static final String MAX_NUM_TIMEOUT_THREADS = "maxNumTimeoutThreads";
 
88
 
 
89
   /**
 
90
    * Key for the configuration map that determines the queue size for simulated
 
91
    * timeout threadpool when using jdk 1.4.
 
92
    */
 
93
   public static final String MAX_TIMEOUT_QUEUE_SIZE = "maxTimeoutQueueSize";
 
94
   
 
95
   /**
 
96
    * Specifies the default number of work threads in the thread pool for 
 
97
    * simulating timeouts when using jdk 1.4.
 
98
    */
 
99
   public static final int MAX_NUM_TIMEOUT_THREADS_DEFAULT = 10;
 
100
   
 
101
   /**
 
102
    * Specifies the number of attempts to get a functioning connection
 
103
    * to the http server.  Defaults to 1.
 
104
    */
 
105
   public static final String NUMBER_OF_CALL_ATTEMPTS = "numberOfCallAttempts";
 
106
   
 
107
   /*
 
108
    * Specifies whether useHttpURLConnection(), upon receiving a null InputStream or ErrorStream,
 
109
    * should call the UnMarshaller.
 
110
    */
 
111
   public static final String UNMARSHAL_NULL_STREAM = "unmarshalNullStream";
 
112
   
 
113
   protected static final Logger log = Logger.getLogger(HTTPClientInvoker.class);
 
114
   
 
115
   protected boolean noThrowOnError;
 
116
   protected int numberOfCallAttempts = 1;
 
117
   protected boolean unmarshalNullStream = true;
 
118
   protected boolean useRemotingContentType = false;
 
119
   
 
120
   private Object timeoutThreadPoolLock = new Object();
 
121
   private ThreadPool timeoutThreadPool;
 
122
 
 
123
   public HTTPClientInvoker(InvokerLocator locator)
 
124
   {
 
125
      super(locator);
 
126
      configureParameters();
 
127
   }
 
128
 
 
129
   public HTTPClientInvoker(InvokerLocator locator, Map configuration)
 
130
   {
 
131
      super(locator, configuration);
 
132
      configureParameters();
 
133
   }
 
134
 
 
135
   /**
 
136
    * @param sessionId
 
137
    * @param invocation
 
138
    * @param marshaller
 
139
    * @return
 
140
    * @throws java.io.IOException
 
141
    * @throws org.jboss.remoting.ConnectionFailedException
 
142
    *
 
143
    */
 
144
   protected Object transport(String sessionId, final Object invocation, Map metadata,
 
145
                              final Marshaller marshaller, final UnMarshaller unmarshaller)
 
146
         throws IOException, ConnectionFailedException
 
147
   {
 
148
      // need to check the url and make sure it compatible protocol
 
149
      final String validatedUrl = validateURL(getLocator().getLocatorURI());
 
150
 
 
151
      if (metadata == null)
 
152
      {
 
153
         metadata = new HashMap();
 
154
      }
 
155
 
 
156
      final HttpURLConnection conn = createURLConnection(validatedUrl, metadata);
 
157
      
 
158
      int simulatedTimeout = getSimulatedTimeout(configuration, metadata, conn);
 
159
      
 
160
      if (simulatedTimeout <= 0)
 
161
      {
 
162
         return makeInvocation(conn, validatedUrl, invocation, metadata, marshaller, unmarshaller, true);
 
163
      }
 
164
      else
 
165
      {
 
166
         if (log.isTraceEnabled()) log.trace("using simulated timeout: " + simulatedTimeout);
 
167
         class Holder {public Object value;}
 
168
         final Holder resultHolder = new Holder();
 
169
         final Map finalMetadata = metadata;
 
170
         
 
171
         Runnable r = new Runnable()
 
172
         {
 
173
            public void run()
 
174
            {
 
175
               try
 
176
               {
 
177
                  resultHolder.value = useHttpURLConnection(conn, invocation, finalMetadata, marshaller, unmarshaller);
 
178
                  if (log.isTraceEnabled()) log.trace("result: " + resultHolder.value);
 
179
               }
 
180
               catch (Exception e)
 
181
               {
 
182
                  resultHolder.value = e;
 
183
                  if (log.isTraceEnabled()) log.trace("exception: " + e); 
 
184
               }
 
185
            }
 
186
         };
 
187
         
 
188
         // BasicThreadPool timeout mechanism depends on the interrupted status of
 
189
         // the running thread.
 
190
         Thread.interrupted();
 
191
         
 
192
         ThreadPool pool = getTimeoutThreadPool();
 
193
         WaitingTaskWrapper wrapper = new WaitingTaskWrapper(r, simulatedTimeout);
 
194
         if (log.isTraceEnabled()) log.trace("starting task in thread pool");
 
195
         pool.runTaskWrapper(wrapper);
 
196
         if (log.isTraceEnabled()) log.trace("task finished in thread pool");
 
197
         
 
198
         Object result = resultHolder.value;
 
199
         if (result == null)
 
200
         {
 
201
            if (log.isDebugEnabled()) log.debug("invocation timed out");
 
202
            Exception cause = new SocketTimeoutException("timed out");
 
203
            throw new CannotConnectException("Can not connect http client invoker.", cause);
 
204
         }
 
205
         else if (result instanceof IOException)
 
206
         {
 
207
            throw (IOException) result;
 
208
         }
 
209
         else if (result instanceof RuntimeException)
 
210
         {
 
211
            throw (RuntimeException) result;
 
212
         }
 
213
         else
 
214
         {
 
215
            if (log.isTraceEnabled()) log.trace("returning result: " + result);
 
216
            return result;
 
217
         }
 
218
      }
 
219
   }
 
220
 
 
221
   protected Object makeInvocation(HttpURLConnection conn, String url, Object invocation,
 
222
                                   Map metadata, Marshaller marshaller, UnMarshaller unmarshaller,
 
223
                                   boolean setTimeout)
 
224
   throws IOException
 
225
   {
 
226
      Throwable savedException = null;
 
227
      
 
228
      for (int i = 0; i < numberOfCallAttempts; i++)
 
229
      {
 
230
         try
 
231
         {
 
232
            Object o = useHttpURLConnection(conn, invocation, metadata, marshaller, unmarshaller);
 
233
            if (log.isTraceEnabled()) log.trace("result: " + o);
 
234
            return o;
 
235
         }
 
236
         catch (CannotConnectException e)
 
237
         {
 
238
            savedException = e.getCause();
 
239
            String suffix = (i < (numberOfCallAttempts - 1) ? ": will retry" : "");
 
240
            log.debug("Cannot connect on attempt " + (i + 1) + suffix);
 
241
            conn = createURLConnection(url, metadata);
 
242
            if (setTimeout)
 
243
            {
 
244
               getSimulatedTimeout(configuration, metadata, conn);
 
245
            }
 
246
         }
 
247
      }
 
248
      
 
249
      String msg = "Can not connect http client invoker after " + numberOfCallAttempts + " attempt(s)";
 
250
      throw new CannotConnectException(msg, savedException);
 
251
   }
 
252
   
 
253
   
 
254
   private Object useHttpURLConnection(HttpURLConnection conn, Object invocation, Map metadata,
 
255
                                       Marshaller marshaller, UnMarshaller unmarshaller) throws WebServerError
 
256
   {
 
257
      Object result = null;
 
258
      int responseCode = -1;
 
259
 
 
260
      try
 
261
      {
 
262
         setChunked(configuration, conn);
 
263
 
 
264
         // check to see if basic auth required
 
265
         String basicAuth = getBasicAuth(metadata);
 
266
         if (basicAuth != null)
 
267
         {
 
268
            conn.setRequestProperty("Authorization", basicAuth);
 
269
         }
 
270
 
 
271
         // check for ping request and process it now and return
 
272
         result = checkForLeasePing(conn,  invocation, metadata);
 
273
         if(result != null)
 
274
         {
 
275
            return result;
 
276
         }
 
277
 
 
278
 
 
279
         // Get the request method type
 
280
         boolean sendingData = true;
 
281
         String type = "POST";
 
282
         if (metadata != null)
 
283
         {
 
284
            type = (String) metadata.get("TYPE");
 
285
            if (type != null)
 
286
            {
 
287
               if ((!type.equals("POST") && !type.equals("PUT")))
 
288
               {
 
289
                  sendingData = false;
 
290
               }
 
291
            }
 
292
            else
 
293
            {
 
294
               type = "POST";
 
295
            }
 
296
         }
 
297
         else // need to check for content type and set metadata
 
298
         {
 
299
            metadata = new HashMap();
 
300
            Map header = new HashMap();
 
301
            header.put(HTTPMetadataConstants.CONTENTTYPE, WebUtil.getContentType(invocation));
 
302
            metadata.put("HEADER", header);
 
303
         }
 
304
         // Set request headers
 
305
         Map header = (Map) metadata.get("HEADER");
 
306
         if (header != null)
 
307
         {
 
308
            Set keys = header.keySet();
 
309
            Iterator itr = keys.iterator();
 
310
            while (itr.hasNext())
 
311
            {
 
312
               String key = (String) itr.next();
 
313
               String value = (String) header.get(key);
 
314
               log.debug("Setting request header with " + key + " : " + value);
 
315
               conn.setRequestProperty(key, value);
 
316
            }
 
317
         }
 
318
         else
 
319
         {
 
320
            conn.setRequestProperty(HTTPMetadataConstants.CONTENTTYPE, WebUtil.getContentType(invocation));
 
321
         }
 
322
         
 
323
         metadata.put(HTTPMetadataConstants.USE_REMOTING_CONTENT_TYPE, Boolean.toString(useRemotingContentType));
 
324
 
 
325
         // set the remoting version
 
326
         conn.setRequestProperty(HTTPMetadataConstants.REMOTING_VERSION_HEADER, new Integer(getVersion()).toString());
 
327
         // set the user agent
 
328
         conn.setRequestProperty(HTTPMetadataConstants.REMOTING_USER_AGENT, "JBossRemoting - " + Version.VERSION);
 
329
 
 
330
         if (sendingData)
 
331
         {
 
332
            //POST or PUT
 
333
            conn.setDoOutput(true);
 
334
            conn.setDoInput(true);
 
335
            conn.setRequestMethod(type);
 
336
 
 
337
            if (invocation instanceof String)
 
338
            {
 
339
               conn.setRequestProperty(HTTPMetadataConstants.REMOTING_CONTENT_TYPE, HTTPMetadataConstants.REMOTING_CONTENT_TYPE_STRING);
 
340
            }
 
341
            else
 
342
            {
 
343
               conn.setRequestProperty(HTTPMetadataConstants.REMOTING_CONTENT_TYPE, HTTPMetadataConstants.REMOTING_CONTENT_TYPE_NON_STRING);       
 
344
            }
 
345
            
 
346
            OutputStream stream = getOutputStream(conn);        
 
347
            if (marshaller instanceof VersionedMarshaller)
 
348
               ((VersionedMarshaller) marshaller).write(invocation, stream, getVersion());
 
349
            else
 
350
               marshaller.write(invocation, stream);
 
351
            responseCode = getResponseCode(conn);
 
352
 
 
353
            Map headers = conn.getHeaderFields();
 
354
            if (metadata == null)
 
355
            {
 
356
               metadata = new HashMap();
 
357
            }
 
358
 
 
359
            // sometimes I get headers with "null" keys (I don't know who's fault is it), so I need
 
360
            // to clean the header map, unless I want to get an NPE thrown by metadata.putAll()
 
361
            if (headers != null)
 
362
            {
 
363
               for(Iterator i = headers.entrySet().iterator(); i.hasNext(); )
 
364
               {
 
365
                  Map.Entry e = (Map.Entry)i.next();
 
366
                  if (e.getKey() != null)
 
367
                  {
 
368
                     metadata.put(e.getKey(), e.getValue());
 
369
                  }
 
370
               }
 
371
            }
 
372
 
 
373
            String responseMessage = getResponseMessage(conn);
 
374
            metadata.put(HTTPMetadataConstants.RESPONSE_CODE_MESSAGE, responseMessage);
 
375
            metadata.put(HTTPMetadataConstants.RESPONSE_CODE, new Integer(responseCode));
 
376
            metadata.put(HTTPMetadataConstants.RESPONSE_HEADERS, headers);
 
377
 
 
378
            InputStream is = (responseCode < 400) ? conn.getInputStream() : conn.getErrorStream();
 
379
            if (is != null || unmarshalNullStream)
 
380
            {
 
381
               result = readResponse(metadata, headers, unmarshaller, is);
 
382
            }
 
383
         }
 
384
         else
 
385
         {
 
386
            conn.setDoOutput(false);
 
387
            conn.setDoInput(true);
 
388
            conn.setRequestMethod(type);
 
389
 
 
390
            connect(conn);
 
391
 
 
392
            InputStream is = (getResponseCode(conn) < 400) ? conn.getInputStream() : conn.getErrorStream();
 
393
            Map headers = conn.getHeaderFields();
 
394
 
 
395
            if (is != null || unmarshalNullStream)
 
396
            {
 
397
               result = readResponse(null, headers, unmarshaller, is);
 
398
            }
 
399
            
 
400
            if (metadata == null)
 
401
            {
 
402
               metadata = new HashMap();
 
403
            }
 
404
            metadata.putAll(headers);
 
405
            String responseMessage = getResponseMessage(conn);
 
406
            metadata.put(HTTPMetadataConstants.RESPONSE_CODE_MESSAGE, responseMessage);
 
407
            responseCode = getResponseCode(conn);
 
408
            metadata.put(HTTPMetadataConstants.RESPONSE_CODE, new Integer(responseCode));
 
409
            metadata.put(HTTPMetadataConstants.RESPONSE_HEADERS, conn.getHeaderFields());
 
410
         }
 
411
      }
 
412
      catch (Exception e)
 
413
      {
 
414
         String message = "Can not connect http client invoker.";
 
415
         if (e.getMessage() != null)
 
416
            message += " " + e.getMessage() + ".";
 
417
 
 
418
         try
 
419
         {
 
420
            String responseMessage = getResponseMessage(conn);
 
421
            int code = getResponseCode(conn);
 
422
            message += " Response: " + responseMessage + "/" + code + ".";
 
423
         }
 
424
         catch (IOException e1)
 
425
         {
 
426
            log.debug("Unable to retrieve response message", e1);
 
427
         }
 
428
         throw new CannotConnectException(message, e);
 
429
      }
 
430
 
 
431
      // now check for error response and throw exception unless configured to not do so
 
432
      if(responseCode >= 400)
 
433
      {
 
434
         boolean doNotThrow = noThrowOnError;
 
435
         if(metadata != null)
 
436
         {
 
437
            Object configObj = metadata.get(HTTPMetadataConstants.NO_THROW_ON_ERROR);
 
438
            if(configObj != null && configObj instanceof String)
 
439
            {
 
440
               doNotThrow = Boolean.valueOf((String)configObj).booleanValue();
 
441
            }
 
442
         }
 
443
 
 
444
         if(doNotThrow)
 
445
         {
 
446
            if(result instanceof String)
 
447
            {
 
448
               // this is a html error page displayed by web server, need to conver to exception
 
449
               WebServerError ex = new WebServerError((String)result);
 
450
               return ex;
 
451
            }
 
452
            else if (result instanceof InvocationResponse)
 
453
            {
 
454
               return ((InvocationResponse) result).getResult();
 
455
            }
 
456
            else
 
457
            {
 
458
               return result;
 
459
            }
 
460
         }
 
461
 
 
462
 
 
463
         // if got here, wasn't configured to not throw exception, so will throw it.
 
464
 
 
465
         // In this case, MicroRemoteClientInvoker will throw the exception carried by
 
466
         // the InvocationResponse.
 
467
         if (result instanceof InvocationResponse)
 
468
            return result;
 
469
 
 
470
         // Otherwise, create a new WebServerError.
 
471
         if(result instanceof String)
 
472
         {
 
473
            WebServerError ex = new WebServerError((String)result);
 
474
            throw ex;
 
475
         }
 
476
         else
 
477
         {
 
478
            WebServerError ex = new WebServerError("Error received when calling on web server.  Error returned was " + responseCode);
 
479
            throw ex;
 
480
         }
 
481
 
 
482
      }
 
483
 
 
484
      return result;
 
485
   }
 
486
 
 
487
   private Object checkForLeasePing(HttpURLConnection conn, Object invocation, Map metadata) throws IOException
 
488
   {
 
489
      InvocationResponse response = null;
 
490
      boolean shouldLease = false;
 
491
      long leasePeriod = -1;
 
492
 
 
493
      if(invocation != null && invocation instanceof InvocationRequest)
 
494
      {
 
495
         InvocationRequest request = (InvocationRequest)invocation;
 
496
 
 
497
         Object payload = request.getParameter();
 
498
         // although a bit of a hack, this will determin if first time ping called by client.
 
499
         if(payload != null && payload instanceof String && "$PING$".equalsIgnoreCase((String)payload) && request.getReturnPayload() != null)
 
500
         {
 
501
            try
 
502
            {
 
503
               // now know is a ping request, so convert to be a HEAD method call
 
504
               conn.setDoOutput(false);
 
505
               conn.setDoInput(true);
 
506
               conn.setRequestMethod("HEAD");
 
507
               // set the remoting version
 
508
               conn.setRequestProperty(HTTPMetadataConstants.REMOTING_VERSION_HEADER, new Integer(getVersion()).toString());
 
509
               // set the user agent
 
510
               conn.setRequestProperty(HTTPMetadataConstants.REMOTING_USER_AGENT, "JBossRemoting - " + Version.VERSION);
 
511
               conn.setRequestProperty(HTTPMetadataConstants.REMOTING_LEASE_QUERY, "true");
 
512
               conn.setRequestProperty("sessionId", request.getSessionId());
 
513
               connect(conn);
 
514
 
 
515
               //InputStream is = (conn.getResponseCode() < 400) ? conn.getInputStream() : conn.getErrorStream();
 
516
               Map headers = conn.getHeaderFields();
 
517
 
 
518
               if(headers != null)
 
519
               {
 
520
                  Object leasingEnabled = headers.get("LEASING_ENABLED");
 
521
                  if(leasingEnabled != null && leasingEnabled instanceof List)
 
522
                  {
 
523
                     shouldLease = new Boolean((String)((List)leasingEnabled).get(0)).booleanValue();
 
524
                  }
 
525
                  Object leasingPeriod = headers.get("LEASE_PERIOD");
 
526
                  if(leasingPeriod != null && leasingPeriod instanceof List)
 
527
                  {
 
528
                     leasePeriod = new Long((String)((List)leasingPeriod).get(0)).longValue();
 
529
                  }
 
530
               }
 
531
            }
 
532
            catch (IOException e)
 
533
            {
 
534
               log.error("Error checking server for lease information.", e);
 
535
            }
 
536
 
 
537
            Map p = new HashMap();
 
538
            p.put("clientLeasePeriod", new Long(leasePeriod));
 
539
            InvocationResponse innterResponse = new InvocationResponse(null, new Boolean(shouldLease), false, p);
 
540
            response = new InvocationResponse(null, innterResponse, false, null);
 
541
 
 
542
         }
 
543
      }
 
544
 
 
545
      return response;
 
546
   }
 
547
 
 
548
   private Object readResponse(Map metadata, Map headers, UnMarshaller unmarshaller, InputStream is)
 
549
         throws  ClassNotFoundException, IOException
 
550
   {
 
551
      Object result = null;
 
552
      String encoding = null;
 
553
      Object ceObj = headers.get("Content-Encoding");
 
554
      if (ceObj != null)
 
555
      {
 
556
         if (ceObj instanceof List)
 
557
         {
 
558
            encoding = (String) ((List) ceObj).get(0);
 
559
         }
 
560
      }
 
561
      if (encoding != null && encoding.indexOf("gzip") >= 0)
 
562
      {
 
563
         unmarshaller = new CompressingUnMarshaller(MarshalFactory.getUnMarshaller(SerializableUnMarshaller.DATATYPE));
 
564
      }
 
565
 
 
566
      Map map = metadata == null ? new HashMap(headers) : metadata;
 
567
      
 
568
      // UnMarshaller may not be an HTTPUnMarshaller, in which case it
 
569
      // can ignore this parameter.
 
570
      if (map.get(HTTPUnMarshaller.PRESERVE_LINES) == null)
 
571
      {
 
572
         Object o = configuration.get(HTTPUnMarshaller.PRESERVE_LINES);
 
573
         if (o != null)
 
574
            map.put(HTTPUnMarshaller.PRESERVE_LINES, o);
 
575
      }
 
576
      
 
577
      map.put(HTTPMetadataConstants.USE_REMOTING_CONTENT_TYPE, Boolean.toString(useRemotingContentType));
 
578
      
 
579
      try
 
580
      {
 
581
         if (unmarshaller instanceof VersionedUnMarshaller)
 
582
            result = ((VersionedUnMarshaller)unmarshaller).read(is, map, getVersion());
 
583
         else
 
584
            result = unmarshaller.read(is, map);
 
585
      }
 
586
      catch (ClassNotFoundException e)
 
587
      {
 
588
         throw e;
 
589
      }
 
590
      catch (IOException e)
 
591
      {
 
592
         log.trace(this + " unable to read response", e);
 
593
         if (-1 == is.read())
 
594
         {
 
595
            throw new EOFException();
 
596
         }
 
597
         throw e;
 
598
      }
 
599
 
 
600
      return result;
 
601
   }
 
602
 
 
603
   private void setChunked(Map metadata, final HttpURLConnection conn)
 
604
   {
 
605
      String chunkedValue = (String) metadata.get("chunkedLength");
 
606
      if (chunkedValue != null && chunkedValue.length() > 0)
 
607
      {
 
608
         try
 
609
         {
 
610
            int chunkedLength = Integer.parseInt(chunkedValue);
 
611
 
 
612
            /**
 
613
             * Since HTTPURLConnection in jdk 1.4 does NOT have a setChunkedStreamingMode() method and
 
614
             * the one in jdk 1.5 does, will have to use reflection to see if it exists before trying to set it.
 
615
             */
 
616
            try
 
617
            {
 
618
               Class cl = conn.getClass();
 
619
               Class[] paramTypes = new Class[] {int.class};
 
620
               Method setChunkedLengthMethod = getMethod(cl, "setChunkedStreamingMode", paramTypes);
 
621
               setChunkedLengthMethod.invoke(conn, new Object[]{new Integer(chunkedLength)});
 
622
            }
 
623
            catch (NoSuchMethodException e)
 
624
            {
 
625
               log.warn("Could not set chunked length (" + chunkedLength + ") on http client transport as method not available with JDK 1.4 (only JDK 1.5 or higher)");
 
626
            }
 
627
            catch (IllegalAccessException e)
 
628
            {
 
629
               log.error("Error setting http client connection chunked length.");
 
630
               log.debug(e);
 
631
            }
 
632
            catch (InvocationTargetException e)
 
633
            {
 
634
               log.error("Error setting http client connection chunked length.");
 
635
               log.debug(e);
 
636
            }
 
637
            catch (Exception e)
 
638
            {
 
639
               // Unexpected.
 
640
               log.error("Unexpected error setting http client connection chunked length.");
 
641
               log.debug(e);
 
642
            }
 
643
         }
 
644
         catch (NumberFormatException e)
 
645
         {
 
646
            log.error("Could not set chunked length for http client connection because value (" + chunkedValue + ") is not a number.");
 
647
         }
 
648
 
 
649
 
 
650
      }
 
651
   }
 
652
 
 
653
 
 
654
   private int getSimulatedTimeout(Map configuration, Map metadata, final HttpURLConnection conn)
 
655
   {
 
656
      int timeout = -1;
 
657
      String connectionTimeout = (String) configuration.get("timeout");
 
658
      String invocationTimeout = (String) metadata.get("timeout");
 
659
      
 
660
      if (invocationTimeout != null && invocationTimeout.length() > 0)
 
661
      {
 
662
         try
 
663
         {
 
664
            timeout = Integer.parseInt(invocationTimeout);
 
665
         }
 
666
         catch (NumberFormatException e)
 
667
         {
 
668
            log.error("Could not set timeout for current invocation because value (" + invocationTimeout + ") is not a number.");
 
669
         }
 
670
      }
 
671
      
 
672
      if (timeout < 0 && connectionTimeout != null && connectionTimeout.length() > 0)
 
673
      {
 
674
         try
 
675
         {
 
676
            timeout = Integer.parseInt(connectionTimeout);
 
677
         }
 
678
         catch (NumberFormatException e)
 
679
         {
 
680
            log.error("Could not set timeout for http client connection because value (" + connectionTimeout + ") is not a number.");
 
681
         }
 
682
      }
 
683
      
 
684
      if (timeout < 0)
 
685
         timeout = 0;
 
686
 
 
687
      /**
 
688
       * Since URLConnection in jdk 1.4 does NOT have a setConnectTimeout() method and
 
689
       * the one in jdk 1.5 does, will have to use reflection to see if it exists before
 
690
       * trying to set it.
 
691
       */
 
692
      try
 
693
      {
 
694
         Class cl = conn.getClass();
 
695
         Class[] paramTypes = new Class[] {int.class};
 
696
         Method setTimeoutMethod = getMethod(cl, "setConnectTimeout", paramTypes);
 
697
         setTimeoutMethod.invoke(conn, new Object[]{new Integer(timeout)});
 
698
         setTimeoutMethod = getMethod(cl, "setReadTimeout", paramTypes);
 
699
         setTimeoutMethod.invoke(conn, new Object[]{new Integer(timeout)});
 
700
         return -1;
 
701
      }
 
702
      catch (NoSuchMethodException e)
 
703
      {
 
704
         log.debug("Using older JDK (prior to 1.5): will simulate timeout");
 
705
      }
 
706
      catch (IllegalAccessException e)
 
707
      {
 
708
         log.error("Error setting http client connection timeout.");
 
709
         log.debug(e);
 
710
      }
 
711
      catch (InvocationTargetException e)
 
712
      {
 
713
         log.error("Error setting http client connection timeout.");
 
714
         log.debug(e);
 
715
      }
 
716
      catch (Exception e)
 
717
      {
 
718
         // Unexpected.
 
719
         log.error("Unexpected error setting http client connection timeout.");
 
720
         log.debug(e);
 
721
      }
 
722
 
 
723
      return timeout;
 
724
   }
 
725
 
 
726
   protected String validateURL(String url)
 
727
   {
 
728
      String validatedUrl = url;
 
729
 
 
730
      if (validatedUrl.startsWith("servlet"))
 
731
      {
 
732
         // servlet:// is a valid protocol, but only in the remoting world, so need to convert to http
 
733
         validatedUrl = "http" + validatedUrl.substring("servlet".length());
 
734
      }
 
735
      return validatedUrl;
 
736
   }
 
737
   
 
738
   protected Home getUsableAddress()
 
739
   {
 
740
      InvokerLocator savedLocator = locator;
 
741
      String protocol = savedLocator.getProtocol();
 
742
      String path = savedLocator.getPath();
 
743
      Map params = savedLocator.getParameters();
 
744
      List homes = getConnectHomes();
 
745
      
 
746
      Iterator it = homes.iterator();
 
747
      while (it.hasNext())
 
748
      {
 
749
         Home home = null;
 
750
         try
 
751
         {
 
752
            home = (Home) it.next();
 
753
            locator = new InvokerLocator(protocol, home.host, home.port, path, params);
 
754
            invoke(new InvocationRequest(null, null, ServerInvoker.ECHO, null, null, null));
 
755
            if (log.isTraceEnabled()) log.trace(this + " able to contact server at: " + home);
 
756
            return home;
 
757
         }
 
758
         catch (Throwable e)
 
759
         {
 
760
            log.debug(this + " unable to contact server at: " + home);
 
761
         }
 
762
         finally
 
763
         {
 
764
            locator = savedLocator;
 
765
         }
 
766
      }
 
767
   
 
768
      return null;
 
769
   }
 
770
 
 
771
   protected HttpURLConnection createURLConnection(String url, Map metadata) throws IOException
 
772
   {
 
773
      URL externalURL = null;
 
774
      HttpURLConnection httpURLConn = null;
 
775
 
 
776
      // need to find out if need to use a proxy or not
 
777
      String proxyHost = null;
 
778
      String proxyportString = null;
 
779
      int proxyPort = 80;
 
780
 
 
781
      if (metadata != null)
 
782
      {
 
783
         // first check the metadata as will have precedence
 
784
         proxyHost = (String) metadata.get("http.proxyHost");
 
785
         proxyportString = (String) metadata.get("http.proxyPort");
 
786
         if (proxyportString != null && proxyportString.length() > 0)
 
787
         {
 
788
            try
 
789
            {
 
790
               proxyPort = Integer.parseInt(proxyportString);
 
791
            }
 
792
            catch (NumberFormatException e)
 
793
            {
 
794
               log.warn("Error converting proxy port specified (" + proxyportString + ") to a number.");
 
795
            }
 
796
         }
 
797
      }
 
798
 
 
799
      // now determin if going to use proxy or not
 
800
      if (proxyHost != null)
 
801
      {
 
802
         externalURL = new URL(url);
 
803
 
 
804
         /**
 
805
          * Since URL in jdk 1.4 does NOT have a openConnection(Proxy) method and
 
806
          * the one in jdk 1.5 does, will have to use reflection to see if it exists before trying to set it.
 
807
          */
 
808
         try
 
809
         {
 
810
            final Class proxyClass = ClassLoaderUtility.loadClass("java.net.Proxy", HTTPClientInvoker.class);
 
811
            InetSocketAddress proxyAddress = new InetSocketAddress(proxyHost, proxyPort);
 
812
            Class[] decalredClasses = proxyClass.getDeclaredClasses();
 
813
            Class proxyTypeClass = null;
 
814
            for(int x = 0; x < decalredClasses.length; x++)
 
815
            {
 
816
               Class declaredClass = decalredClasses[x];
 
817
               String className = declaredClass.getName();
 
818
               if(className.endsWith("Type"))
 
819
               {
 
820
                  proxyTypeClass = declaredClass;
 
821
                  break;
 
822
               }
 
823
            }
 
824
            Object proxyType = null;
 
825
            Field[] fields = proxyTypeClass.getDeclaredFields();
 
826
            for(int i = 0; i < fields.length; i++)
 
827
            {
 
828
               Field field = fields[i];
 
829
               String fieldName = field.getName();
 
830
               if(fieldName.endsWith("HTTP"))
 
831
               {
 
832
                  proxyType = field.get(proxyTypeClass);
 
833
                  break;
 
834
               }
 
835
            }
 
836
            Constructor proxyConstructor = proxyClass.getConstructor(new Class[] {proxyTypeClass, SocketAddress.class});
 
837
            Object proxy = proxyConstructor.newInstance(new Object[] {proxyType, proxyAddress});
 
838
            Method openConnection = getMethod(URL.class, "openConnection", new Class[] {proxyClass});
 
839
            httpURLConn = (HttpURLConnection)openConnection.invoke(externalURL, new Object[] {proxy});
 
840
         }
 
841
         catch (Exception e)
 
842
         {
 
843
            log.error("Can not set proxy for http invocation (proxy host: " + proxyHost + ", proxy port: " + proxyPort + ") " +
 
844
                      "as this configuration requires JDK 1.5 or later.  If running JDK 1.4, can use proxy by setting system properties.");
 
845
            log.debug(e);
 
846
         }
 
847
 
 
848
         // since know it is a proxy being used, see if have proxy auth
 
849
         String proxyAuth = getProxyAuth(metadata);
 
850
         if (proxyAuth != null)
 
851
         {
 
852
            httpURLConn.setRequestProperty("Proxy-Authorization", proxyAuth);
 
853
         }
 
854
      }
 
855
      else
 
856
      {
 
857
         externalURL = new URL(url);
 
858
         httpURLConn = (HttpURLConnection) externalURL.openConnection();
 
859
         
 
860
         // Check if proxy is being configured by system properties.
 
861
         if (getSystemProperty("http.proxyHost") != null)
 
862
         {
 
863
            String proxyAuth = getProxyAuth(metadata);
 
864
            if (proxyAuth != null)
 
865
            {
 
866
               httpURLConn.setRequestProperty("Proxy-Authorization", proxyAuth);
 
867
            }
 
868
         }
 
869
      }
 
870
 
 
871
      return httpURLConn;
 
872
   }
 
873
 
 
874
   private String getProxyAuth(Map metadata)
 
875
   {
 
876
      String authString = null;
 
877
      String username = null;
 
878
      String password = null;
 
879
 
 
880
      if (metadata != null)
 
881
      {
 
882
         username = (String) metadata.get("http.proxy.username");
 
883
      }
 
884
      if (username == null || username.length() == 0)
 
885
      {
 
886
         username = getSystemProperty("http.proxy.username");
 
887
      }
 
888
      if (metadata != null)
 
889
      {
 
890
         password = (String) metadata.get("http.proxy.password");
 
891
      }
 
892
      if (password == null)
 
893
      {
 
894
         password = getSystemProperty("http.proxy.password");
 
895
      }
 
896
 
 
897
      if (username != null && password != null)
 
898
      {
 
899
         StringBuffer buffer = new StringBuffer();
 
900
         buffer.append(username);
 
901
         buffer.append(":");
 
902
         buffer.append(password);
 
903
 
 
904
         String encoded = Base64.encodeBytes(buffer.toString().getBytes());
 
905
 
 
906
         authString = "Basic " + encoded;
 
907
 
 
908
      }
 
909
 
 
910
      return authString;
 
911
   }
 
912
 
 
913
   private String getBasicAuth(Map metadata)
 
914
   {
 
915
      String authString = null;
 
916
      String username = null;
 
917
      String password = null;
 
918
 
 
919
      if (metadata != null)
 
920
      {
 
921
         username = (String) metadata.get("http.basic.username");
 
922
      }
 
923
      if (username == null || username.length() == 0)
 
924
      {
 
925
         username = getSystemProperty("http.basic.username");
 
926
      }
 
927
      if (metadata != null)
 
928
      {
 
929
         password = (String) metadata.get("http.basic.password");
 
930
      }
 
931
      if (password == null)
 
932
      {
 
933
         password = getSystemProperty("http.basic.password");
 
934
      }
 
935
 
 
936
      if (username != null && password != null)
 
937
      {
 
938
         StringBuffer buffer = new StringBuffer();
 
939
         buffer.append(username);
 
940
         buffer.append(":");
 
941
         buffer.append(password);
 
942
 
 
943
         String encoded = Base64.encodeBytes(buffer.toString().getBytes(), Base64.DONT_BREAK_LINES);
 
944
 
 
945
         authString = "Basic " + encoded;
 
946
 
 
947
      }
 
948
 
 
949
      return authString;
 
950
   }
 
951
 
 
952
 
 
953
   /**
 
954
    * subclasses must implement this method to provide a hook to connect to the remote server, if this applies
 
955
    * to the specific transport. However, in some transport implementations, this may not make must difference since
 
956
    * the connection is not persistent among invocations, such as SOAP.  In these cases, the method should
 
957
    * silently return without any processing.
 
958
    *
 
959
    * @throws org.jboss.remoting.ConnectionFailedException
 
960
    *
 
961
    */
 
962
   protected void handleConnect() throws ConnectionFailedException
 
963
   {
 
964
      if (InvokerLocator.MULTIHOME.equals(locator.getHost()))
 
965
      {
 
966
         Home home = getUsableAddress();
 
967
         if (home == null)
 
968
         {
 
969
            throw new ConnectionFailedException(this + " unable to find a usable address for: " + home);
 
970
         }
 
971
         
 
972
         String protocol = locator.getProtocol();
 
973
         String path = locator.getPath();
 
974
         Map params = locator.getParameters();
 
975
         locator = new InvokerLocator(protocol, home.host, home.port, path, params);
 
976
         if (log.isDebugEnabled()) log.debug(this + " will use InvokerLocator " + locator);
 
977
      }
 
978
   }
 
979
 
 
980
   /**
 
981
    * subclasses must implement this method to provide a hook to disconnect from the remote server, if this applies
 
982
    * to the specific transport. However, in some transport implementations, this may not make must difference since
 
983
    * the connection is not persistent among invocations, such as SOAP.  In these cases, the method should
 
984
    * silently return without any processing.
 
985
    */
 
986
   protected void handleDisconnect()
 
987
   {
 
988
      // NO OP as not statefull connection
 
989
   }
 
990
 
 
991
   /**
 
992
    * Each implementation of the remote client invoker should have
 
993
    * a default data type that is uses in the case it is not specified
 
994
    * in the invoker locator uri.
 
995
    *
 
996
    * @return
 
997
    */
 
998
   protected String getDefaultDataType()
 
999
   {
 
1000
      return HTTPMarshaller.DATATYPE;
 
1001
   }
 
1002
 
 
1003
 
 
1004
   /**
 
1005
    * Sets the thread pool to be used for simulating timeouts with jdk 1.4.
 
1006
    */
 
1007
   public void setTimeoutThreadPool(ThreadPool pool)
 
1008
   {
 
1009
      this.timeoutThreadPool = pool;
 
1010
   }
 
1011
   
 
1012
   protected void configureParameters()
 
1013
   {
 
1014
      Object val = configuration.get(HTTPMetadataConstants.NO_THROW_ON_ERROR);
 
1015
      if (val != null)
 
1016
      {
 
1017
         try
 
1018
         {
 
1019
            noThrowOnError = Boolean.valueOf((String)val).booleanValue();
 
1020
            log.debug(this + " setting noThrowOnError to " + noThrowOnError);
 
1021
         }
 
1022
         catch (Exception e)
 
1023
         {
 
1024
            log.warn(this + " could not convert " + 
 
1025
                     HTTPMetadataConstants.NO_THROW_ON_ERROR + " value of " +
 
1026
                     val + " to a boolean value.");
 
1027
         }
 
1028
      }
 
1029
      
 
1030
      val = configuration.get(NUMBER_OF_CALL_ATTEMPTS);
 
1031
      if (val != null)
 
1032
      {
 
1033
         try
 
1034
         {
 
1035
            numberOfCallAttempts = Integer.valueOf((String)val).intValue();
 
1036
            log.debug(this + " setting numberOfCallRetries to " + numberOfCallAttempts);
 
1037
         }
 
1038
         catch (Exception e)
 
1039
         {
 
1040
            log.warn(this + " could not convert " + 
 
1041
                     NUMBER_OF_CALL_ATTEMPTS + " value of " +
 
1042
                     val + " to an int value.");
 
1043
         }
 
1044
      }
 
1045
      
 
1046
      val = configuration.get(UNMARSHAL_NULL_STREAM);
 
1047
      if (val != null)
 
1048
      {
 
1049
         try
 
1050
         {
 
1051
            unmarshalNullStream = Boolean.valueOf((String)val).booleanValue();
 
1052
            log.debug(this + " setting unmarshalNullStream to " + unmarshalNullStream);
 
1053
         }
 
1054
         catch (Exception e)
 
1055
         {
 
1056
            log.warn(this + " could not convert " + 
 
1057
                     UNMARSHAL_NULL_STREAM + " value of " +
 
1058
                     val + " to a boolean value.");
 
1059
         }
 
1060
      }
 
1061
 
 
1062
      val = configuration.get(HTTPMetadataConstants.USE_REMOTING_CONTENT_TYPE);
 
1063
      if (val != null)
 
1064
      {
 
1065
         try
 
1066
         {
 
1067
            useRemotingContentType = Boolean.valueOf((String)val).booleanValue();
 
1068
            log.debug(this + " setting useRemotingContent to " + useRemotingContentType);
 
1069
         }
 
1070
         catch (Exception e)
 
1071
         {
 
1072
            log.warn(this + " could not convert " + 
 
1073
                     HTTPMetadataConstants.USE_REMOTING_CONTENT_TYPE + " value of " +
 
1074
                     val + " to a boolean value.");
 
1075
         }
 
1076
      }
 
1077
   }
 
1078
   
 
1079
   /**
 
1080
    * Gets the thread pool being used for simulating timeouts with jdk 1.4. If one has
 
1081
    * not be specifically set via configuration or call to set it, will always return
 
1082
    * instance of org.jboss.util.threadpool.BasicThreadPool.
 
1083
    */
 
1084
   public ThreadPool getTimeoutThreadPool()
 
1085
   {
 
1086
      synchronized (timeoutThreadPoolLock)
 
1087
      {
 
1088
         if (timeoutThreadPool == null)
 
1089
         {
 
1090
            int maxNumberThreads = MAX_NUM_TIMEOUT_THREADS_DEFAULT;
 
1091
            int maxTimeoutQueueSize = -1;
 
1092
            
 
1093
            BasicThreadPool pool = new BasicThreadPool("HTTP timeout");
 
1094
            log.debug("created new thread pool: " + pool);
 
1095
            Object param = configuration.get(MAX_NUM_TIMEOUT_THREADS);
 
1096
            if (param instanceof String)
 
1097
            {
 
1098
               try
 
1099
               {
 
1100
                  maxNumberThreads = Integer.parseInt((String) param);
 
1101
               }
 
1102
               catch (NumberFormatException  e)
 
1103
               {
 
1104
                  log.error("maxNumberThreads parameter has invalid format: " + param);
 
1105
               }
 
1106
            }
 
1107
            else if (param != null)
 
1108
            {
 
1109
               log.error("maxNumberThreads parameter must be a string in integer format: " + param);
 
1110
            }
 
1111
 
 
1112
            param = configuration.get(MAX_TIMEOUT_QUEUE_SIZE);
 
1113
 
 
1114
            if (param instanceof String)
 
1115
            {
 
1116
               try
 
1117
               {
 
1118
                  maxTimeoutQueueSize = Integer.parseInt((String) param);
 
1119
               }
 
1120
               catch (NumberFormatException  e)
 
1121
               {
 
1122
                  log.error("maxTimeoutQueueSize parameter has invalid format: " + param);
 
1123
               }
 
1124
            }
 
1125
            else if (param != null)
 
1126
            {
 
1127
               log.error("maxTimeoutQueueSize parameter must be a string in integer format: " + param);
 
1128
            }
 
1129
 
 
1130
            pool.setMaximumPoolSize(maxNumberThreads);
 
1131
 
 
1132
            if (maxTimeoutQueueSize > 0)
 
1133
            {
 
1134
               pool.setMaximumQueueSize(maxTimeoutQueueSize);
 
1135
            }
 
1136
            pool.setBlockingMode(BlockingMode.RUN);
 
1137
            timeoutThreadPool = pool;
 
1138
         }
 
1139
      }
 
1140
      return timeoutThreadPool;
 
1141
   }
 
1142
   
 
1143
   
 
1144
   /**
 
1145
    * When a WaitingTaskWrapper is run in a BasicThreadPool, the calling thread
 
1146
    * will block for the designated timeout period.
 
1147
    */
 
1148
   static class WaitingTaskWrapper extends RunnableTaskWrapper
 
1149
   {
 
1150
      long completeTimeout;
 
1151
      
 
1152
      public WaitingTaskWrapper(Runnable runnable, long completeTimeout)
 
1153
      {
 
1154
         super(runnable, 0, completeTimeout);
 
1155
         this.completeTimeout = completeTimeout;
 
1156
      }
 
1157
      public int getTaskWaitType()
 
1158
      {
 
1159
         return Task.WAIT_FOR_COMPLETE;
 
1160
      }
 
1161
      public String toString()
 
1162
      {
 
1163
         return "WaitingTaskWrapper[" + completeTimeout + "]";
 
1164
      }
 
1165
   }
 
1166
   
 
1167
   static private String getSystemProperty(final String name)
 
1168
   {
 
1169
      if (SecurityUtility.skipAccessControl())
 
1170
         return System.getProperty(name);
 
1171
      
 
1172
      String value = null;
 
1173
      try
 
1174
      {
 
1175
         value = (String)AccessController.doPrivileged( new PrivilegedExceptionAction()
 
1176
         {
 
1177
            public Object run() throws Exception
 
1178
            {
 
1179
               return System.getProperty(name);
 
1180
            }
 
1181
         });
 
1182
      }
 
1183
      catch (PrivilegedActionException e)
 
1184
      {
 
1185
         throw (RuntimeException) e.getCause();
 
1186
      }
 
1187
      
 
1188
      return value;
 
1189
   }
 
1190
   
 
1191
   static private Method getMethod(final Class c, final String name, final Class[] parameterTypes)
 
1192
   throws NoSuchMethodException
 
1193
   {
 
1194
      if (SecurityUtility.skipAccessControl())
 
1195
      {
 
1196
         return c.getMethod(name, parameterTypes);
 
1197
      }
 
1198
 
 
1199
      try
 
1200
      {
 
1201
         return (Method) AccessController.doPrivileged( new PrivilegedExceptionAction()
 
1202
         {
 
1203
            public Object run() throws NoSuchMethodException
 
1204
            {
 
1205
               return c.getMethod(name, parameterTypes);
 
1206
            }
 
1207
         });
 
1208
      }
 
1209
      catch (PrivilegedActionException e)
 
1210
      {
 
1211
         throw (NoSuchMethodException) e.getCause();
 
1212
      }
 
1213
   }
 
1214
   
 
1215
   static private void connect(final HttpURLConnection conn) throws IOException
 
1216
   {
 
1217
      if (SecurityUtility.skipAccessControl())
 
1218
      {
 
1219
         conn.connect();
 
1220
         return;
 
1221
      }
 
1222
 
 
1223
      try
 
1224
      {
 
1225
         AccessController.doPrivileged( new PrivilegedExceptionAction()
 
1226
         {
 
1227
            public Object run() throws IOException
 
1228
            {
 
1229
               conn.connect();
 
1230
               return null;
 
1231
            }
 
1232
         });
 
1233
      }
 
1234
      catch (PrivilegedActionException e)
 
1235
      {
 
1236
         throw (IOException) e.getCause();
 
1237
      }
 
1238
   }
 
1239
   
 
1240
   static private OutputStream getOutputStream(final HttpURLConnection conn)
 
1241
   throws IOException
 
1242
   {
 
1243
      if (SecurityUtility.skipAccessControl())
 
1244
      {
 
1245
         return conn.getOutputStream();
 
1246
      }
 
1247
      
 
1248
      try
 
1249
      {
 
1250
         return (OutputStream)AccessController.doPrivileged( new PrivilegedExceptionAction()
 
1251
         {
 
1252
            public Object run() throws IOException
 
1253
            {
 
1254
               return conn.getOutputStream();
 
1255
            }
 
1256
         });
 
1257
      }
 
1258
      catch (PrivilegedActionException e)
 
1259
      {
 
1260
         throw (IOException) e.getCause();
 
1261
      }
 
1262
   }
 
1263
   
 
1264
   static private int getResponseCode(final HttpURLConnection conn)
 
1265
   throws IOException
 
1266
   {
 
1267
      if (SecurityUtility.skipAccessControl())
 
1268
      {
 
1269
         return conn.getResponseCode();
 
1270
      }
 
1271
      
 
1272
      try
 
1273
      {
 
1274
         return ((Integer) AccessController.doPrivileged( new PrivilegedExceptionAction()
 
1275
         {
 
1276
            public Object run() throws IOException
 
1277
            {
 
1278
               return new Integer(conn.getResponseCode());
 
1279
            }
 
1280
         })).intValue();
 
1281
      }
 
1282
      catch (PrivilegedActionException e)
 
1283
      {
 
1284
         throw (IOException) e.getCause();
 
1285
      }
 
1286
   }
 
1287
   
 
1288
   static private String getResponseMessage(final HttpURLConnection conn)
 
1289
   throws IOException
 
1290
   {
 
1291
      if (SecurityUtility.skipAccessControl())
 
1292
      {
 
1293
         return conn.getResponseMessage();
 
1294
      }
 
1295
      
 
1296
      try
 
1297
      {
 
1298
         return (String) AccessController.doPrivileged( new PrivilegedExceptionAction()
 
1299
         {
 
1300
            public Object run() throws IOException
 
1301
            {
 
1302
               return conn.getResponseMessage();
 
1303
            }
 
1304
         });
 
1305
      }
 
1306
      catch (PrivilegedActionException e)
 
1307
      {
 
1308
         throw (IOException) e.getCause();
 
1309
      }
 
1310
   }
 
1311
}
 
 
b'\\ No newline at end of file'