HttpMethodBase.java
1 /* 2 * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//httpclient/src/java/org/apache/commons/httpclient/HttpMethodBase.java,v 1.222 2005/01/14 21:16:40 olegk Exp $ 3 * $Revision: 539441 $ 4 * $Date: 2007-05-18 14:56:55 +0200 (Fri, 18 May 2007) $ 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.ByteArrayInputStream; 34 import java.io.ByteArrayOutputStream; 35 import java.io.IOException; 36 import java.io.InputStream; 37 import java.io.InterruptedIOException; 38 import java.util.Collection; 39 40 import org.apache.commons.httpclient.auth.AuthState; 41 import org.apache.commons.httpclient.cookie.CookiePolicy; 42 import org.apache.commons.httpclient.cookie.CookieSpec; 43 import org.apache.commons.httpclient.cookie.CookieVersionSupport; 44 import org.apache.commons.httpclient.cookie.MalformedCookieException; 45 import org.apache.commons.httpclient.params.HttpMethodParams; 46 import org.apache.commons.httpclient.protocol.Protocol; 47 import org.apache.commons.httpclient.util.EncodingUtil; 48 import org.apache.commons.httpclient.util.ExceptionUtil; 49 import org.apache.commons.logging.Log; 50 import org.apache.commons.logging.LogFactory; 51 52 /** 53 * An abstract base implementation of HttpMethod. 54 * <p> 55 * At minimum, subclasses will need to override: 56 * <ul> 57 * <li>{@link #getName} to return the approriate name for this method 58 * </li> 59 * </ul> 60 * </p> 61 * 62 * <p> 63 * When a method requires additional request headers, subclasses will typically 64 * want to override: 65 * <ul> 66 * <li>{@link #addRequestHeaders addRequestHeaders(HttpState,HttpConnection)} 67 * to write those headers 68 * </li> 69 * </ul> 70 * </p> 71 * 72 * <p> 73 * When a method expects specific response headers, subclasses may want to 74 * override: 75 * <ul> 76 * <li>{@link #processResponseHeaders processResponseHeaders(HttpState,HttpConnection)} 77 * to handle those headers 78 * </li> 79 * </ul> 80 * </p> 81 * 82 * 83 * @author <a href="mailto:remm@apache.org">Remy Maucherat</a> 84 * @author Rodney Waldhoff 85 * @author Sean C. Sullivan 86 * @author <a href="mailto:dion@apache.org">dIon Gillard</a> 87 * @author <a href="mailto:jsdever@apache.org">Jeff Dever</a> 88 * @author <a href="mailto:dims@apache.org">Davanum Srinivas</a> 89 * @author Ortwin Glueck 90 * @author Eric Johnson 91 * @author Michael Becke 92 * @author <a href="mailto:oleg@ural.ru">Oleg Kalnichevski</a> 93 * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a> 94 * @author <a href="mailto:ggregory@seagullsw.com">Gary Gregory</a> 95 * @author Christian Kohlschuetter 96 * 97 * @version $Revision: 539441 $ $Date: 2007-05-18 14:56:55 +0200 (Fri, 18 May 2007) $ 98 */ 99 public abstract class HttpMethodBase implements HttpMethod { 100 101 // -------------------------------------------------------------- Constants 102 103 /** Log object for this class. */ 104 private static final Log LOG = LogFactory.getLog(HttpMethodBase.class); 105 106 // ----------------------------------------------------- Instance variables 107 108 /** Request headers, if any. */ 109 private HeaderGroup requestHeaders = new HeaderGroup(); 110 111 /** The Status-Line from the response. */ 112 protected StatusLine statusLine = null; 113 114 /** Response headers, if any. */ 115 private HeaderGroup responseHeaders = new HeaderGroup(); 116 117 /** Response trailer headers, if any. */ 118 private HeaderGroup responseTrailerHeaders = new HeaderGroup(); 119 120 /** Path of the HTTP method. */ 121 private String path = null; 122 123 /** Query string of the HTTP method, if any. */ 124 private String queryString = null; 125 126 /** The response body of the HTTP method, assuming it has not be 127 * intercepted by a sub-class. */ 128 private InputStream responseStream = null; 129 130 /** The connection that the response stream was read from. */ 131 private HttpConnection responseConnection = null; 132 133 /** Buffer for the response */ 134 private byte[] responseBody = null; 135 136 /** True if the HTTP method should automatically follow HTTP redirects.*/ 137 private boolean followRedirects = false; 138 139 /** True if the HTTP method should automatically handle 140 * HTTP authentication challenges. */ 141 private boolean doAuthentication = true; 142 143 /** HTTP protocol parameters. */ 144 private HttpMethodParams params = new HttpMethodParams(); 145 146 /** Host authentication state */ 147 private AuthState hostAuthState = new AuthState(); 148 149 /** Proxy authentication state */ 150 private AuthState proxyAuthState = new AuthState(); 151 152 /** True if this method has already been executed. */ 153 private boolean used = false; 154 155 /** Count of how many times did this HTTP method transparently handle 156 * a recoverable exception. */ 157 private int recoverableExceptionCount = 0; 158 159 /** the host for this HTTP method, can be null */ 160 private HttpHost httphost = null; 161 162 /** 163 * Handles method retries 164 * 165 * @deprecated no loner used 166 */ 167 private MethodRetryHandler methodRetryHandler; 168 169 /** True if the connection must be closed when no longer needed */ 170 private boolean connectionCloseForced = false; 171 172 /** Number of milliseconds to wait for 100-contunue response. */ 173 private static final int RESPONSE_WAIT_TIME_MS = 3000; 174 175 /** HTTP protocol version used for execution of this method. */ 176 protected HttpVersion effectiveVersion = null; 177 178 /** Whether the execution of this method has been aborted */ 179 private volatile boolean aborted = false; 180 181 /** Whether the HTTP request has been transmitted to the target 182 * server it its entirety */ 183 private boolean requestSent = false; 184 185 /** Actual cookie policy */ 186 private CookieSpec cookiespec = null; 187 188 /** Default initial size of the response buffer if content length is unknown. */ 189 private static final int DEFAULT_INITIAL_BUFFER_SIZE = 4*1024; // 4 kB 190 191 // ----------------------------------------------------------- Constructors 192 193 /** 194 * No-arg constructor. 195 */ 196 public HttpMethodBase() { 197 } 198 199 /** 200 * Constructor specifying a URI. 201 * It is responsibility of the caller to ensure that URI elements 202 * (path & query parameters) are properly encoded (URL safe). 203 * 204 * @param uri either an absolute or relative URI. The URI is expected 205 * to be URL-encoded 206 * 207 * @throws IllegalArgumentException when URI is invalid 208 * @throws IllegalStateException when protocol of the absolute URI is not recognised 209 */ 210 public HttpMethodBase(String uri) 211 throws IllegalArgumentException, IllegalStateException { 212 213 try { 214 215 // create a URI and allow for null/empty uri values 216 if (uri == null || uri.equals("")) { 217 uri = "/"; 218 } 219 String charset = getParams().getUriCharset(); 220 setURI(new URI(uri, true, charset)); 221 } catch (URIException e) { 222 throw new IllegalArgumentException("Invalid uri '" 223 + uri + "': " + e.getMessage() 224 ); 225 } 226 } 227 228 // ------------------------------------------- Property Setters and Getters 229 230 /** 231 * Obtains the name of the HTTP method as used in the HTTP request line, 232 * for example <tt>"GET"</tt> or <tt>"POST"</tt>. 233 * 234 * @return the name of this method 235 */ 236 public abstract String getName(); 237 238 /** 239 * Returns the URI of the HTTP method 240 * 241 * @return The URI 242 * 243 * @throws URIException If the URI cannot be created. 244 * 245 * @see org.apache.commons.httpclient.HttpMethod#getURI() 246 */ 247 public URI getURI() throws URIException { 248 StringBuffer buffer = new StringBuffer(); 249 if (this.httphost != null) { 250 buffer.append(this.httphost.getProtocol().getScheme()); 251 buffer.append("://"); 252 buffer.append(this.httphost.getHostName()); 253 int port = this.httphost.getPort(); 254 if (port != -1 && port != this.httphost.getProtocol().getDefaultPort()) { 255 buffer.append(":"); 256 buffer.append(port); 257 } 258 } 259 buffer.append(this.path); 260 if (this.queryString != null) { 261 buffer.append('?'); 262 buffer.append(this.queryString); 263 } 264 String charset = getParams().getUriCharset(); 265 return new URI(buffer.toString(), true, charset); 266 } 267 268 /** 269 * Sets the URI for this method. 270 * 271 * @param uri URI to be set 272 * 273 * @throws URIException if a URI cannot be set 274 * 275 * @since 3.0 276 */ 277 public void setURI(URI uri) throws URIException { 278 // only set the host if specified by the URI 279 if (uri.isAbsoluteURI()) { 280 this.httphost = new HttpHost(uri); 281 } 282 // set the path, defaulting to root 283 setPath( 284 uri.getPath() == null 285 ? "/" 286 : uri.getEscapedPath() 287 ); 288 setQueryString(uri.getEscapedQuery()); 289 } 290 291 /** 292 * Sets whether or not the HTTP method should automatically follow HTTP redirects 293 * (status code 302, etc.) 294 * 295 * @param followRedirects <tt>true</tt> if the method will automatically follow redirects, 296 * <tt>false</tt> otherwise. 297 */ 298 public void setFollowRedirects(boolean followRedirects) { 299 this.followRedirects = followRedirects; 300 } 301 302 /** 303 * Returns <tt>true</tt> if the HTTP method should automatically follow HTTP redirects 304 * (status code 302, etc.), <tt>false</tt> otherwise. 305 * 306 * @return <tt>true</tt> if the method will automatically follow HTTP redirects, 307 * <tt>false</tt> otherwise. 308 */ 309 public boolean getFollowRedirects() { 310 return this.followRedirects; 311 } 312 313 /** Sets whether version 1.1 of the HTTP protocol should be used per default. 314 * 315 * @param http11 <tt>true</tt> to use HTTP/1.1, <tt>false</tt> to use 1.0 316 * 317 * @deprecated Use {@link HttpMethodParams#setVersion(HttpVersion)} 318 */ 319 public void setHttp11(boolean http11) { 320 if (http11) { 321 this.params.setVersion(HttpVersion.HTTP_1_1); 322 } else { 323 this.params.setVersion(HttpVersion.HTTP_1_0); 324 } 325 } 326 327 /** 328 * Returns <tt>true</tt> if the HTTP method should automatically handle HTTP 329 * authentication challenges (status code 401, etc.), <tt>false</tt> otherwise 330 * 331 * @return <tt>true</tt> if authentication challenges will be processed 332 * automatically, <tt>false</tt> otherwise. 333 * 334 * @since 2.0 335 */ 336 public boolean getDoAuthentication() { 337 return doAuthentication; 338 } 339 340 /** 341 * Sets whether or not the HTTP method should automatically handle HTTP 342 * authentication challenges (status code 401, etc.) 343 * 344 * @param doAuthentication <tt>true</tt> to process authentication challenges 345 * authomatically, <tt>false</tt> otherwise. 346 * 347 * @since 2.0 348 */ 349 public void setDoAuthentication(boolean doAuthentication) { 350 this.doAuthentication = doAuthentication; 351 } 352 353 // ---------------------------------------------- Protected Utility Methods 354 355 /** 356 * Returns <tt>true</tt> if version 1.1 of the HTTP protocol should be 357 * used per default, <tt>false</tt> if version 1.0 should be used. 358 * 359 * @return <tt>true</tt> to use HTTP/1.1, <tt>false</tt> to use 1.0 360 * 361 * @deprecated Use {@link HttpMethodParams#getVersion()} 362 */ 363 public boolean isHttp11() { 364 return this.params.getVersion().equals(HttpVersion.HTTP_1_1); 365 } 366 367 /** 368 * Sets the path of the HTTP method. 369 * It is responsibility of the caller to ensure that the path is 370 * properly encoded (URL safe). 371 * 372 * @param path the path of the HTTP method. The path is expected 373 * to be URL-encoded 374 */ 375 public void setPath(String path) { 376 this.path = path; 377 } 378 379 /** 380 * Adds the specified request header, NOT overwriting any previous value. 381 * Note that header-name matching is case insensitive. 382 * 383 * @param header the header to add to the request 384 */ 385 public void addRequestHeader(Header header) { 386 LOG.trace("HttpMethodBase.addRequestHeader(Header)"); 387 388 if (header == null) { 389 LOG.debug("null header value ignored"); 390 } else { 391 getRequestHeaderGroup().addHeader(header); 392 } 393 } 394 395 /** 396 * Use this method internally to add footers. 397 * 398 * @param footer The footer to add. 399 */ 400 public void addResponseFooter(Header footer) { 401 getResponseTrailerHeaderGroup().addHeader(footer); 402 } 403 404 /** 405 * Gets the path of this HTTP method. 406 * Calling this method <em>after</em> the request has been executed will 407 * return the <em>actual</em> path, following any redirects automatically 408 * handled by this HTTP method. 409 * 410 * @return the path to request or "/" if the path is blank. 411 */ 412 public String getPath() { 413 return (path == null || path.equals("")) ? "/" : path; 414 } 415 416 /** 417 * Sets the query string of this HTTP method. The caller must ensure that the string 418 * is properly URL encoded. The query string should not start with the question 419 * mark character. 420 * 421 * @param queryString the query string 422 * 423 * @see EncodingUtil#formUrlEncode(NameValuePair[], String) 424 */ 425 public void setQueryString(String queryString) { 426 this.queryString = queryString; 427 } 428 429 /** 430 * Sets the query string of this HTTP method. The pairs are encoded as UTF-8 characters. 431 * To use a different charset the parameters can be encoded manually using EncodingUtil 432 * and set as a single String. 433 * 434 * @param params an array of {@link NameValuePair}s to add as query string 435 * parameters. The name/value pairs will be automcatically 436 * URL encoded 437 * 438 * @see EncodingUtil#formUrlEncode(NameValuePair[], String) 439 * @see #setQueryString(String) 440 */ 441 public void setQueryString(NameValuePair[] params) { 442 LOG.trace("enter HttpMethodBase.setQueryString(NameValuePair[])"); 443 queryString = EncodingUtil.formUrlEncode(params, "UTF-8"); 444 } 445 446 /** 447 * Gets the query string of this HTTP method. 448 * 449 * @return The query string 450 */ 451 public String getQueryString() { 452 return queryString; 453 } 454 455 /** 456 * Set the specified request header, overwriting any previous value. Note 457 * that header-name matching is case-insensitive. 458 * 459 * @param headerName the header's name 460 * @param headerValue the header's value 461 */ 462 public void setRequestHeader(String headerName, String headerValue) { 463 Header header = new Header(headerName, headerValue); 464 setRequestHeader(header); 465 } 466 467 /** 468 * Sets the specified request header, overwriting any previous value. 469 * Note that header-name matching is case insensitive. 470 * 471 * @param header the header 472 */ 473 public void setRequestHeader(Header header) { 474 475 Header[] headers = getRequestHeaderGroup().getHeaders(header.getName()); 476 477 for (int i = 0; i < headers.length; i++) { 478 getRequestHeaderGroup().removeHeader(headers[i]); 479 } 480 481 getRequestHeaderGroup().addHeader(header); 482 483 } 484 485 /** 486 * Returns the specified request header. Note that header-name matching is 487 * case insensitive. <tt>null</tt> will be returned if either 488 * <i>headerName</i> is <tt>null</tt> or there is no matching header for 489 * <i>headerName</i>. 490 * 491 * @param headerName The name of the header to be returned. 492 * 493 * @return The specified request header. 494 * 495 * @since 3.0 496 */ 497 public Header getRequestHeader(String headerName) { 498 if (headerName == null) { 499 return null; 500 } else { 501 return getRequestHeaderGroup().getCondensedHeader(headerName); 502 } 503 } 504 505 /** 506 * Returns an array of the requests headers that the HTTP method currently has 507 * 508 * @return an array of my request headers. 509 */ 510 public Header[] getRequestHeaders() { 511 return getRequestHeaderGroup().getAllHeaders(); 512 } 513 514 /** 515 * @see org.apache.commons.httpclient.HttpMethod#getRequestHeaders(java.lang.String) 516 */ 517 public Header[] getRequestHeaders(String headerName) { 518 return getRequestHeaderGroup().getHeaders(headerName); 519 } 520 521 /** 522 * Gets the {@link HeaderGroup header group} storing the request headers. 523 * 524 * @return a HeaderGroup 525 * 526 * @since 2.0beta1 527 */ 528 protected HeaderGroup getRequestHeaderGroup() { 529 return requestHeaders; 530 } 531 532 /** 533 * Gets the {@link HeaderGroup header group} storing the response trailer headers 534 * as per RFC 2616 section 3.6.1. 535 * 536 * @return a HeaderGroup 537 * 538 * @since 2.0beta1 539 */ 540 protected HeaderGroup getResponseTrailerHeaderGroup() { 541 return responseTrailerHeaders; 542 } 543 544 /** 545 * Gets the {@link HeaderGroup header group} storing the response headers. 546 * 547 * @return a HeaderGroup 548 * 549 * @since 2.0beta1 550 */ 551 protected HeaderGroup getResponseHeaderGroup() { 552 return responseHeaders; 553 } 554 555 /** 556 * @see org.apache.commons.httpclient.HttpMethod#getResponseHeaders(java.lang.String) 557 * 558 * @since 3.0 559 */ 560 public Header[] getResponseHeaders(String headerName) { 561 return getResponseHeaderGroup().getHeaders(headerName); 562 } 563 564 /** 565 * Returns the response status code. 566 * 567 * @return the status code associated with the latest response. 568 */ 569 public int getStatusCode() { 570 return statusLine.getStatusCode(); 571 } 572 573 /** 574 * Provides access to the response status line. 575 * 576 * @return the status line object from the latest response. 577 * @since 2.0 578 */ 579 public StatusLine getStatusLine() { 580 return statusLine; 581 } 582 583 /** 584 * Checks if response data is available. 585 * @return <tt>true</tt> if response data is available, <tt>false</tt> otherwise. 586 */ 587 private boolean responseAvailable() { 588 return (responseBody != null) || (responseStream != null); 589 } 590 591 /** 592 * Returns an array of the response headers that the HTTP method currently has 593 * in the order in which they were read. 594 * 595 * @return an array of response headers. 596 */ 597 public Header[] getResponseHeaders() { 598 return getResponseHeaderGroup().getAllHeaders(); 599 } 600 601 /** 602 * Gets the response header associated with the given name. Header name 603 * matching is case insensitive. <tt>null</tt> will be returned if either 604 * <i>headerName</i> is <tt>null</tt> or there is no matching header for 605 * <i>headerName</i>. 606 * 607 * @param headerName the header name to match 608 * 609 * @return the matching header 610 */ 611 public Header getResponseHeader(String headerName) { 612 if (headerName == null) { 613 return null; 614 } else { 615 return getResponseHeaderGroup().getCondensedHeader(headerName); 616 } 617 } 618 619 620 /** 621 * Return the length (in bytes) of the response body, as specified in a 622 * <tt>Content-Length</tt> header. 623 * 624 * <p> 625 * Return <tt>-1</tt> when the content-length is unknown. 626 * </p> 627 * 628 * @return content length, if <tt>Content-Length</tt> header is available. 629 * <tt>0</tt> indicates that the request has no body. 630 * If <tt>Content-Length</tt> header is not present, the method 631 * returns <tt>-1</tt>. 632 */ 633 public long getResponseContentLength() { 634 Header[] headers = getResponseHeaderGroup().getHeaders("Content-Length"); 635 if (headers.length == 0) { 636 return -1; 637 } 638 if (headers.length > 1) { 639 LOG.warn("Multiple content-length headers detected"); 640 } 641 for (int i = headers.length - 1; i >= 0; i--) { 642 Header header = headers[i]; 643 try { 644 return Long.parseLong(header.getValue()); 645 } catch (NumberFormatException e) { 646 if (LOG.isWarnEnabled()) { 647 LOG.warn("Invalid content-length value: " + e.getMessage()); 648 } 649 } 650 // See if we can have better luck with another header, if present 651 } 652 return -1; 653 } 654 655 656 /** 657 * Returns the response body of the HTTP method, if any, as an array of bytes. 658 * If response body is not available or cannot be read, returns <tt>null</tt>. 659 * Buffers the response and this method can be called several times yielding 660 * the same result each time. 661 * 662 * Note: This will cause the entire response body to be buffered in memory. A 663 * malicious server may easily exhaust all the VM memory. It is strongly 664 * recommended, to use getResponseAsStream if the content length of the response 665 * is unknown or resonably large. 666 * 667 * @return The response body. 668 * 669 * @throws IOException If an I/O (transport) problem occurs while obtaining the 670 * response body. 671 */ 672 public byte[] getResponseBody() throws IOException { 673 if (this.responseBody == null) { 674 InputStream instream = getResponseBodyAsStream(); 675 if (instream != null) { 676 long contentLength = getResponseContentLength(); 677 if (contentLength > Integer.MAX_VALUE) { //guard below cast from overflow 678 throw new IOException("Content too large to be buffered: "+ contentLength +" bytes"); 679 } 680 int limit = getParams().getIntParameter(HttpMethodParams.BUFFER_WARN_TRIGGER_LIMIT, 1024*1024); 681 if ((contentLength == -1) || (contentLength > limit)) { 682 LOG.warn("Going to buffer response body of large or unknown size. " 683 +"Using getResponseBodyAsStream instead is recommended."); 684 } 685 LOG.debug("Buffering response body"); 686 ByteArrayOutputStream outstream = new ByteArrayOutputStream( 687 contentLength > 0 ? (int) contentLength : DEFAULT_INITIAL_BUFFER_SIZE); 688 byte[] buffer = new byte[4096]; 689 int len; 690 while ((len = instream.read(buffer)) > 0) { 691 outstream.write(buffer, 0, len); 692 } 693 outstream.close(); 694 setResponseStream(null); 695 this.responseBody = outstream.toByteArray(); 696 } 697 } 698 return this.responseBody; 699 } 700 701 /** 702 * Returns the response body of the HTTP method, if any, as an array of bytes. 703 * If response body is not available or cannot be read, returns <tt>null</tt>. 704 * Buffers the response and this method can be called several times yielding 705 * the same result each time. 706 * 707 * Note: This will cause the entire response body to be buffered in memory. This method is 708 * safe if the content length of the response is unknown, because the amount of memory used 709 * is limited.<p> 710 * 711 * If the response is large this method involves lots of array copying and many object 712 * allocations, which makes it unsuitable for high-performance / low-footprint applications. 713 * Those applications should use {@link #getResponseBodyAsStream()}. 714 * 715 * @param maxlen the maximum content length to accept (number of bytes). 716 * @return The response body. 717 * 718 * @throws IOException If an I/O (transport) problem occurs while obtaining the 719 * response body. 720 */ 721 public byte[] getResponseBody(int maxlen) throws IOException { 722 if (maxlen < 0) throw new IllegalArgumentException("maxlen must be positive"); 723 if (this.responseBody == null) { 724 InputStream instream = getResponseBodyAsStream(); 725 if (instream != null) { 726 // we might already know that the content is larger 727 long contentLength = getResponseContentLength(); 728 if ((contentLength != -1) && (contentLength > maxlen)) { 729 throw new HttpContentTooLargeException( 730 "Content-Length is " + contentLength, maxlen); 731 } 732 733 LOG.debug("Buffering response body"); 734 ByteArrayOutputStream rawdata = new ByteArrayOutputStream( 735 contentLength > 0 ? (int) contentLength : DEFAULT_INITIAL_BUFFER_SIZE); 736 byte[] buffer = new byte[2048]; 737 int pos = 0; 738 int len; 739 do { 740 len = instream.read(buffer, 0, Math.min(buffer.length, maxlen-pos)); 741 if (len == -1) break; 742 rawdata.write(buffer, 0, len); 743 pos += len; 744 } while (pos < maxlen); 745 746 setResponseStream(null); 747 // check if there is even more data 748 if (pos == maxlen) { 749 if (instream.read() != -1) 750 throw new HttpContentTooLargeException( 751 "Content-Length not known but larger than " 752 + maxlen, maxlen); 753 } 754 this.responseBody = rawdata.toByteArray(); 755 } 756 } 757 return this.responseBody; 758 } 759 760 /** 761 * Returns the response body of the HTTP method, if any, as an {@link InputStream}. 762 * If response body is not available, returns <tt>null</tt>. If the response has been 763 * buffered this method returns a new stream object on every call. If the response 764 * has not been buffered the returned stream can only be read once. 765 * 766 * @return The response body or <code>null</code>. 767 * 768 * @throws IOException If an I/O (transport) problem occurs while obtaining the 769 * response body. 770 */ 771 public InputStream getResponseBodyAsStream() throws IOException { 772 if (responseStream != null) { 773 return responseStream; 774 } 775 if (responseBody != null) { 776 InputStream byteResponseStream = new ByteArrayInputStream(responseBody); 777 LOG.debug("re-creating response stream from byte array"); 778 return byteResponseStream; 779 } 780 return null; 781 } 782 783 /** 784 * Returns the response body of the HTTP method, if any, as a {@link String}. 785 * If response body is not available or cannot be read, returns <tt>null</tt> 786 * The string conversion on the data is done using the character encoding specified 787 * in <tt>Content-Type</tt> header. Buffers the response and this method can be 788 * called several times yielding the same result each time. 789 * 790 * Note: This will cause the entire response body to be buffered in memory. A 791 * malicious server may easily exhaust all the VM memory. It is strongly 792 * recommended, to use getResponseAsStream if the content length of the response 793 * is unknown or resonably large. 794 * 795 * @return The response body or <code>null</code>. 796 * 797 * @throws IOException If an I/O (transport) problem occurs while obtaining the 798 * response body. 799 */ 800 public String getResponseBodyAsString() throws IOException { 801 byte[] rawdata = null; 802 if (responseAvailable()) { 803 rawdata = getResponseBody(); 804 } 805 if (rawdata != null) { 806 return EncodingUtil.getString(rawdata, getResponseCharSet()); 807 } else { 808 return null; 809 } 810 } 811 812 /** 813 * Returns the response body of the HTTP method, if any, as a {@link String}. 814 * If response body is not available or cannot be read, returns <tt>null</tt> 815 * The string conversion on the data is done using the character encoding specified 816 * in <tt>Content-Type</tt> header. Buffers the response and this method can be 817 * called several times yielding the same result each time.</p> 818 * 819 * Note: This will cause the entire response body to be buffered in memory. This method is 820 * safe if the content length of the response is unknown, because the amount of memory used 821 * is limited.<p> 822 * 823 * If the response is large this method involves lots of array copying and many object 824 * allocations, which makes it unsuitable for high-performance / low-footprint applications. 825 * Those applications should use {@link #getResponseBodyAsStream()}. 826 * 827 * @param maxlen the maximum content length to accept (number of bytes). Note that, 828 * depending on the encoding, this is not equal to the number of characters. 829 * @return The response body or <code>null</code>. 830 * 831 * @throws IOException If an I/O (transport) problem occurs while obtaining the 832 * response body. 833 */ 834 public String getResponseBodyAsString(int maxlen) throws IOException { 835 if (maxlen < 0) throw new IllegalArgumentException("maxlen must be positive"); 836 byte[] rawdata = null; 837 if (responseAvailable()) { 838 rawdata = getResponseBody(maxlen); 839 } 840 if (rawdata != null) { 841 return EncodingUtil.getString(rawdata, getResponseCharSet()); 842 } else { 843 return null; 844 } 845 } 846 847 /** 848 * Returns an array of the response footers that the HTTP method currently has 849 * in the order in which they were read. 850 * 851 * @return an array of footers 852 */ 853 public Header[] getResponseFooters() { 854 return getResponseTrailerHeaderGroup().getAllHeaders(); 855 } 856 857 /** 858 * Gets the response footer associated with the given name. 859 * Footer name matching is case insensitive. 860 * <tt>null</tt> will be returned if either <i>footerName</i> is 861 * <tt>null</tt> or there is no matching footer for <i>footerName</i> 862 * or there are no footers available. If there are multiple footers 863 * with the same name, there values will be combined with the ',' separator 864 * as specified by RFC2616. 865 * 866 * @param footerName the footer name to match 867 * @return the matching footer 868 */ 869 public Header getResponseFooter(String footerName) { 870 if (footerName == null) { 871 return null; 872 } else { 873 return getResponseTrailerHeaderGroup().getCondensedHeader(footerName); 874 } 875 } 876 877 /** 878 * Sets the response stream. 879 * @param responseStream The new response stream. 880 */ 881 protected void setResponseStream(InputStream responseStream) { 882 this.responseStream = responseStream; 883 } 884 885 /** 886 * Returns a stream from which the body of the current response may be read. 887 * If the method has not yet been executed, if <code>responseBodyConsumed</code> 888 * has been called, or if the stream returned by a previous call has been closed, 889 * <code>null</code> will be returned. 890 * 891 * @return the current response stream 892 */ 893 protected InputStream getResponseStream() { 894 return responseStream; 895 } 896 897 /** 898 * Returns the status text (or "reason phrase") associated with the latest 899 * response. 900 * 901 * @return The status text. 902 */ 903 public String getStatusText() { 904 return statusLine.getReasonPhrase(); 905 } 906 907 /** 908 * Defines how strictly HttpClient follows the HTTP protocol specification 909 * (RFC 2616 and other relevant RFCs). In the strict mode HttpClient precisely 910 * implements the requirements of the specification, whereas in non-strict mode 911 * it attempts to mimic the exact behaviour of commonly used HTTP agents, 912 * which many HTTP servers expect. 913 * 914 * @param strictMode <tt>true</tt> for strict mode, <tt>false</tt> otherwise 915 * 916 * @deprecated Use {@link org.apache.commons.httpclient.params.HttpParams#setParameter(String, Object)} 917 * to exercise a more granular control over HTTP protocol strictness. 918 */ 919 public void setStrictMode(boolean strictMode) { 920 if (strictMode) { 921 this.params.makeStrict(); 922 } else { 923 this.params.makeLenient(); 924 } 925 } 926 927 /** 928 * @deprecated Use {@link org.apache.commons.httpclient.params.HttpParams#setParameter(String, Object)} 929 * to exercise a more granular control over HTTP protocol strictness. 930 * 931 * @return <tt>false</tt> 932 */ 933 public boolean isStrictMode() { 934 return false; 935 } 936 937 /** 938 * Adds the specified request header, NOT overwriting any previous value. 939 * Note that header-name matching is case insensitive. 940 * 941 * @param headerName the header's name 942 * @param headerValue the header's value 943 */ 944 public void addRequestHeader(String headerName, String headerValue) { 945 addRequestHeader(new Header(headerName, headerValue)); 946 } 947 948 /** 949 * Tests if the connection should be force-closed when no longer needed. 950 * 951 * @return <code>true</code> if the connection must be closed 952 */ 953 protected boolean isConnectionCloseForced() { 954 return this.connectionCloseForced; 955 } 956 957 /** 958 * Sets whether or not the connection should be force-closed when no longer 959 * needed. This value should only be set to <code>true</code> in abnormal 960 * circumstances, such as HTTP protocol violations. 961 * 962 * @param b <code>true</code> if the connection must be closed, <code>false</code> 963 * otherwise. 964 */ 965 protected void setConnectionCloseForced(boolean b) { 966 if (LOG.isDebugEnabled()) { 967 LOG.debug("Force-close connection: " + b); 968 } 969 this.connectionCloseForced = b; 970 } 971 972 /** 973 * Tests if the connection should be closed after the method has been executed. 974 * The connection will be left open when using HTTP/1.1 or if <tt>Connection: 975 * keep-alive</tt> header was sent. 976 * 977 * @param conn the connection in question 978 * 979 * @return boolean true if we should close the connection. 980 */ 981 protected boolean shouldCloseConnection(HttpConnection conn) { 982 // Connection must be closed due to an abnormal circumstance 983 if (isConnectionCloseForced()) { 984 LOG.debug("Should force-close connection."); 985 return true; 986 } 987 988 Header connectionHeader = null; 989 // In case being connected via a proxy server 990 if (!conn.isTransparent()) { 991 // Check for 'proxy-connection' directive 992 connectionHeader = responseHeaders.getFirstHeader("proxy-connection"); 993 } 994 // In all cases Check for 'connection' directive 995 // some non-complaint proxy servers send it instread of 996 // expected 'proxy-connection' directive 997 if (connectionHeader == null) { 998 connectionHeader = responseHeaders.getFirstHeader("connection"); 999 } 1000 // In case the response does not contain any explict connection 1001 // directives, check whether the request does 1002 if (connectionHeader == null) { 1003 connectionHeader = requestHeaders.getFirstHeader("connection"); 1004 } 1005 if (connectionHeader != null) { 1006 if (connectionHeader.getValue().equalsIgnoreCase("close")) { 1007 if (LOG.isDebugEnabled()) { 1008 LOG.debug("Should close connection in response to directive: " 1009 + connectionHeader.getValue()); 1010 } 1011 return true; 1012 } else if (connectionHeader.getValue().equalsIgnoreCase("keep-alive")) { 1013 if (LOG.isDebugEnabled()) { 1014 LOG.debug("Should NOT close connection in response to directive: " 1015 + connectionHeader.getValue()); 1016 } 1017 return false; 1018 } else { 1019 if (LOG.isDebugEnabled()) { 1020 LOG.debug("Unknown directive: " + connectionHeader.toExternalForm()); 1021 } 1022 } 1023 } 1024 LOG.debug("Resorting to protocol version default close connection policy"); 1025 // missing or invalid connection header, do the default 1026 if (this.effectiveVersion.greaterEquals(HttpVersion.HTTP_1_1)) { 1027 if (LOG.isDebugEnabled()) { 1028 LOG.debug("Should NOT close connection, using " + this.effectiveVersion.toString()); 1029 } 1030 } else { 1031 if (LOG.isDebugEnabled()) { 1032 LOG.debug("Should close connection, using " + this.effectiveVersion.toString()); 1033 } 1034 } 1035 return this.effectiveVersion.lessEquals(HttpVersion.HTTP_1_0); 1036 } 1037 1038 /** 1039 * Tests if the this method is ready to be executed. 1040 * 1041 * @param state the {@link HttpState state} information associated with this method 1042 * @param conn the {@link HttpConnection connection} to be used 1043 * @throws HttpException If the method is in invalid state. 1044 */ 1045 private void checkExecuteConditions(HttpState state, HttpConnection conn) 1046 throws HttpException { 1047 1048 if (state == null) { 1049 throw new IllegalArgumentException("HttpState parameter may not be null"); 1050 } 1051 if (conn == null) { 1052 throw new IllegalArgumentException("HttpConnection parameter may not be null"); 1053 } 1054 if (this.aborted) { 1055 throw new IllegalStateException("Method has been aborted"); 1056 } 1057 if (!validate()) { 1058 throw new ProtocolException("HttpMethodBase object not valid"); 1059 } 1060 } 1061 1062 /** 1063 * Executes this method using the specified <code>HttpConnection</code> and 1064 * <code>HttpState</code>. 1065 * 1066 * @param state {@link HttpState state} information to associate with this 1067 * request. Must be non-null. 1068 * @param conn the {@link HttpConnection connection} to used to execute 1069 * this HTTP method. Must be non-null. 1070 * 1071 * @return the integer status code if one was obtained, or <tt>-1</tt> 1072 * 1073 * @throws IOException if an I/O (transport) error occurs 1074 * @throws HttpException if a protocol exception occurs. 1075 */ 1076 public int execute(HttpState state, HttpConnection conn) 1077 throws HttpException, IOException { 1078 1079 LOG.trace("enter HttpMethodBase.execute(HttpState, HttpConnection)"); 1080 1081 // this is our connection now, assign it to a local variable so 1082 // that it can be released later 1083 this.responseConnection = conn; 1084 1085 checkExecuteConditions(state, conn); 1086 this.statusLine = null; 1087 this.connectionCloseForced = false; 1088 1089 conn.setLastResponseInputStream(null); 1090 1091 // determine the effective protocol version 1092 if (this.effectiveVersion == null) { 1093 this.effectiveVersion = this.params.getVersion(); 1094 } 1095 1096 writeRequest(state, conn); 1097 this.requestSent = true; 1098 readResponse(state, conn); 1099 // the method has successfully executed 1100 used = true; 1101 1102 return statusLine.getStatusCode(); 1103 } 1104 1105 /** 1106 * Aborts the execution of this method. 1107 * 1108 * @since 3.0 1109 */ 1110 public void abort() { 1111 if (this.aborted) { 1112 return; 1113 } 1114 this.aborted = true; 1115 HttpConnection conn = this.responseConnection; 1116 if (conn != null) { 1117 conn.close(); 1118 } 1119 } 1120 1121 /** 1122 * Returns <tt>true</tt> if the HTTP method has been already {@link #execute executed}, 1123 * but not {@link #recycle recycled}. 1124 * 1125 * @return <tt>true</tt> if the method has been executed, <tt>false</tt> otherwise 1126 */ 1127 public boolean hasBeenUsed() { 1128 return used; 1129 } 1130 1131 /** 1132 * Recycles the HTTP method so that it can be used again. 1133 * Note that all of the instance variables will be reset 1134 * once this method has been called. This method will also 1135 * release the connection being used by this HTTP method. 1136 * 1137 * @see #releaseConnection() 1138 * 1139 * @deprecated no longer supported and will be removed in the future 1140 * version of HttpClient 1141 */ 1142 public void recycle() { 1143 LOG.trace("enter HttpMethodBase.recycle()"); 1144 1145 releaseConnection(); 1146 1147 path = null; 1148 followRedirects = false; 1149 doAuthentication = true; 1150 queryString = null; 1151 getRequestHeaderGroup().clear(); 1152 getResponseHeaderGroup().clear(); 1153 getResponseTrailerHeaderGroup().clear(); 1154 statusLine = null; 1155 effectiveVersion = null; 1156 aborted = false; 1157 used = false; 1158 params = new HttpMethodParams(); 1159 responseBody = null; 1160 recoverableExceptionCount = 0; 1161 connectionCloseForced = false; 1162 hostAuthState.invalidate(); 1163 proxyAuthState.invalidate(); 1164 cookiespec = null; 1165 requestSent = false; 1166 } 1167 1168 /** 1169 * Releases the connection being used by this HTTP method. In particular the 1170 * connection is used to read the response(if there is one) and will be held 1171 * until the response has been read. If the connection can be reused by other 1172 * HTTP methods it is NOT closed at this point. 1173 * 1174 * @since 2.0 1175 */ 1176 public void releaseConnection() { 1177 try { 1178 if (this.responseStream != null) { 1179 try { 1180 // FYI - this may indirectly invoke responseBodyConsumed. 1181 this.responseStream.close(); 1182 } catch (IOException ignore) { 1183 } 1184 } 1185 } finally { 1186 ensureConnectionRelease(); 1187 } 1188 } 1189 1190 /** 1191 * Remove the request header associated with the given name. Note that 1192 * header-name matching is case insensitive. 1193 * 1194 * @param headerName the header name 1195 */ 1196 public void removeRequestHeader(String headerName) { 1197 1198 Header[] headers = getRequestHeaderGroup().getHeaders(headerName); 1199 for (int i = 0; i < headers.length; i++) { 1200 getRequestHeaderGroup().removeHeader(headers[i]); 1201 } 1202 1203 } 1204 1205 /** 1206 * Removes the given request header. 1207 * 1208 * @param header the header 1209 */ 1210 public void removeRequestHeader(final Header header) { 1211 if (header == null) { 1212 return; 1213 } 1214 getRequestHeaderGroup().removeHeader(header); 1215 } 1216 1217 // ---------------------------------------------------------------- Queries 1218 1219 /** 1220 * Returns <tt>true</tt> the method is ready to execute, <tt>false</tt> otherwise. 1221 * 1222 * @return This implementation always returns <tt>true</tt>. 1223 */ 1224 public boolean validate() { 1225 return true; 1226 } 1227 1228 1229 /** 1230 * Returns the actual cookie policy 1231 * 1232 * @param state HTTP state. TODO: to be removed in the future 1233 * 1234 * @return cookie spec 1235 */ 1236 private CookieSpec getCookieSpec(final HttpState state) { 1237 if (this.cookiespec == null) { 1238 int i = state.getCookiePolicy(); 1239 if (i == -1) { 1240 this.cookiespec = CookiePolicy.getCookieSpec(this.params.getCookiePolicy()); 1241 } else { 1242 this.cookiespec = CookiePolicy.getSpecByPolicy(i); 1243 } 1244 this.cookiespec.setValidDateFormats( 1245 (Collection)this.params.getParameter(HttpMethodParams.DATE_PATTERNS)); 1246 } 1247 return this.cookiespec; 1248 } 1249 1250 /** 1251 * Generates <tt>Cookie</tt> request headers for those {@link Cookie cookie}s 1252 * that match the given host, port and path. 1253 * 1254 * @param state the {@link HttpState state} information associated with this method 1255 * @param conn the {@link HttpConnection connection} used to execute 1256 * this HTTP method 1257 * 1258 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1259 * can be recovered from. 1260 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1261 * cannot be recovered from. 1262 */ 1263 protected void addCookieRequestHeader(HttpState state, HttpConnection conn) 1264 throws IOException, HttpException { 1265 1266 LOG.trace("enter HttpMethodBase.addCookieRequestHeader(HttpState, " 1267 + "HttpConnection)"); 1268 1269 Header[] cookieheaders = getRequestHeaderGroup().getHeaders("Cookie"); 1270 for (int i = 0; i < cookieheaders.length; i++) { 1271 Header cookieheader = cookieheaders[i]; 1272 if (cookieheader.isAutogenerated()) { 1273 getRequestHeaderGroup().removeHeader(cookieheader); 1274 } 1275 } 1276 1277 CookieSpec matcher = getCookieSpec(state); 1278 String host = this.params.getVirtualHost(); 1279 if (host == null) { 1280 host = conn.getHost(); 1281 } 1282 Cookie[] cookies = matcher.match(host, conn.getPort(), 1283 getPath(), conn.isSecure(), state.getCookies()); 1284 if ((cookies != null) && (cookies.length > 0)) { 1285 if (getParams().isParameterTrue(HttpMethodParams.SINGLE_COOKIE_HEADER)) { 1286 // In strict mode put all cookies on the same header 1287 String s = matcher.formatCookies(cookies); 1288 getRequestHeaderGroup().addHeader(new Header("Cookie", s, true)); 1289 } else { 1290 // In non-strict mode put each cookie on a separate header 1291 for (int i = 0; i < cookies.length; i++) { 1292 String s = matcher.formatCookie(cookies[i]); 1293 getRequestHeaderGroup().addHeader(new Header("Cookie", s, true)); 1294 } 1295 } 1296 if (matcher instanceof CookieVersionSupport) { 1297 CookieVersionSupport versupport = (CookieVersionSupport) matcher; 1298 int ver = versupport.getVersion(); 1299 boolean needVersionHeader = false; 1300 for (int i = 0; i < cookies.length; i++) { 1301 if (ver != cookies[i].getVersion()) { 1302 needVersionHeader = true; 1303 } 1304 } 1305 if (needVersionHeader) { 1306 // Advertise cookie version support 1307 getRequestHeaderGroup().addHeader(versupport.getVersionHeader()); 1308 } 1309 } 1310 } 1311 } 1312 1313 /** 1314 * Generates <tt>Host</tt> request header, as long as no <tt>Host</tt> request 1315 * header already exists. 1316 * 1317 * @param state the {@link HttpState state} information associated with this method 1318 * @param conn the {@link HttpConnection connection} used to execute 1319 * this HTTP method 1320 * 1321 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1322 * can be recovered from. 1323 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1324 * cannot be recovered from. 1325 */ 1326 protected void addHostRequestHeader(HttpState state, HttpConnection conn) 1327 throws IOException, HttpException { 1328 LOG.trace("enter HttpMethodBase.addHostRequestHeader(HttpState, " 1329 + "HttpConnection)"); 1330 1331 // Per 19.6.1.1 of RFC 2616, it is legal for HTTP/1.0 based 1332 // applications to send the Host request-header. 1333 // TODO: Add the ability to disable the sending of this header for 1334 // HTTP/1.0 requests. 1335 String host = this.params.getVirtualHost(); 1336 if (host != null) { 1337 LOG.debug("Using virtual host name: " + host); 1338 } else { 1339 host = conn.getHost(); 1340 } 1341 int port = conn.getPort(); 1342 1343 // Note: RFC 2616 uses the term "internet host name" for what goes on the 1344 // host line. It would seem to imply that host should be blank if the 1345 // host is a number instead of an name. Based on the behavior of web 1346 // browsers, and the fact that RFC 2616 never defines the phrase "internet 1347 // host name", and the bad behavior of HttpClient that follows if we 1348 // send blank, I interpret this as a small misstatement in the RFC, where 1349 // they meant to say "internet host". So IP numbers get sent as host 1350 // entries too. -- Eric Johnson 12/13/2002 1351 if (LOG.isDebugEnabled()) { 1352 LOG.debug("Adding Host request header"); 1353 } 1354 1355 //appends the port only if not using the default port for the protocol 1356 if (conn.getProtocol().getDefaultPort() != port) { 1357 host += (":" + port); 1358 } 1359 1360 setRequestHeader("Host", host); 1361 } 1362 1363 /** 1364 * Generates <tt>Proxy-Connection: Keep-Alive</tt> request header when 1365 * communicating via a proxy server. 1366 * 1367 * @param state the {@link HttpState state} information associated with this method 1368 * @param conn the {@link HttpConnection connection} used to execute 1369 * this HTTP method 1370 * 1371 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1372 * can be recovered from. 1373 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1374 * cannot be recovered from. 1375 */ 1376 protected void addProxyConnectionHeader(HttpState state, 1377 HttpConnection conn) 1378 throws IOException, HttpException { 1379 LOG.trace("enter HttpMethodBase.addProxyConnectionHeader(" 1380 + "HttpState, HttpConnection)"); 1381 if (!conn.isTransparent()) { 1382 if (getRequestHeader("Proxy-Connection") == null) { 1383 addRequestHeader("Proxy-Connection", "Keep-Alive"); 1384 } 1385 } 1386 } 1387 1388 /** 1389 * Generates all the required request {@link Header header}s 1390 * to be submitted via the given {@link HttpConnection connection}. 1391 * 1392 * <p> 1393 * This implementation adds <tt>User-Agent</tt>, <tt>Host</tt>, 1394 * <tt>Cookie</tt>, <tt>Authorization</tt>, <tt>Proxy-Authorization</tt> 1395 * and <tt>Proxy-Connection</tt> headers, when appropriate. 1396 * </p> 1397 * 1398 * <p> 1399 * Subclasses may want to override this method to to add additional 1400 * headers, and may choose to invoke this implementation (via 1401 * <tt>super</tt>) to add the "standard" headers. 1402 * </p> 1403 * 1404 * @param state the {@link HttpState state} information associated with this method 1405 * @param conn the {@link HttpConnection connection} used to execute 1406 * this HTTP method 1407 * 1408 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1409 * can be recovered from. 1410 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1411 * cannot be recovered from. 1412 * 1413 * @see #writeRequestHeaders 1414 */ 1415 protected void addRequestHeaders(HttpState state, HttpConnection conn) 1416 throws IOException, HttpException { 1417 LOG.trace("enter HttpMethodBase.addRequestHeaders(HttpState, " 1418 + "HttpConnection)"); 1419 1420 addUserAgentRequestHeader(state, conn); 1421 addHostRequestHeader(state, conn); 1422 addCookieRequestHeader(state, conn); 1423 addProxyConnectionHeader(state, conn); 1424 } 1425 1426 /** 1427 * Generates default <tt>User-Agent</tt> request header, as long as no 1428 * <tt>User-Agent</tt> request header already exists. 1429 * 1430 * @param state the {@link HttpState state} information associated with this method 1431 * @param conn the {@link HttpConnection connection} used to execute 1432 * this HTTP method 1433 * 1434 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1435 * can be recovered from. 1436 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1437 * cannot be recovered from. 1438 */ 1439 protected void addUserAgentRequestHeader(HttpState state, 1440 HttpConnection conn) 1441 throws IOException, HttpException { 1442 LOG.trace("enter HttpMethodBase.addUserAgentRequestHeaders(HttpState, " 1443 + "HttpConnection)"); 1444 1445 if (getRequestHeader("User-Agent") == null) { 1446 String agent = (String)getParams().getParameter(HttpMethodParams.USER_AGENT); 1447 if (agent == null) { 1448 agent = "Jakarta Commons-HttpClient"; 1449 } 1450 setRequestHeader("User-Agent", agent); 1451 } 1452 } 1453 1454 /** 1455 * Throws an {@link IllegalStateException} if the HTTP method has been already 1456 * {@link #execute executed}, but not {@link #recycle recycled}. 1457 * 1458 * @throws IllegalStateException if the method has been used and not 1459 * recycled 1460 */ 1461 protected void checkNotUsed() throws IllegalStateException { 1462 if (used) { 1463 throw new IllegalStateException("Already used."); 1464 } 1465 } 1466 1467 /** 1468 * Throws an {@link IllegalStateException} if the HTTP method has not been 1469 * {@link #execute executed} since last {@link #recycle recycle}. 1470 * 1471 * 1472 * @throws IllegalStateException if not used 1473 */ 1474 protected void checkUsed() throws IllegalStateException { 1475 if (!used) { 1476 throw new IllegalStateException("Not Used."); 1477 } 1478 } 1479 1480 // ------------------------------------------------- Static Utility Methods 1481 1482 /** 1483 * Generates HTTP request line according to the specified attributes. 1484 * 1485 * @param connection the {@link HttpConnection connection} used to execute 1486 * this HTTP method 1487 * @param name the method name generate a request for 1488 * @param requestPath the path string for the request 1489 * @param query the query string for the request 1490 * @param version the protocol version to use (e.g. HTTP/1.0) 1491 * 1492 * @return HTTP request line 1493 */ 1494 protected static String generateRequestLine(HttpConnection connection, 1495 String name, String requestPath, String query, String version) { 1496 LOG.trace("enter HttpMethodBase.generateRequestLine(HttpConnection, " 1497 + "String, String, String, String)"); 1498 1499 StringBuffer buf = new StringBuffer(); 1500 // Append method name 1501 buf.append(name); 1502 buf.append(" "); 1503 // Absolute or relative URL? 1504 if (!connection.isTransparent()) { 1505 Protocol protocol = connection.getProtocol(); 1506 buf.append(protocol.getScheme().toLowerCase()); 1507 buf.append("://"); 1508 buf.append(connection.getHost()); 1509 if ((connection.getPort() != -1) 1510 && (connection.getPort() != protocol.getDefaultPort()) 1511 ) { 1512 buf.append(":"); 1513 buf.append(connection.getPort()); 1514 } 1515 } 1516 // Append path, if any 1517 if (requestPath == null) { 1518 buf.append("/"); 1519 } else { 1520 if (!connection.isTransparent() && !requestPath.startsWith("/")) { 1521 buf.append("/"); 1522 } 1523 buf.append(requestPath); 1524 } 1525 // Append query, if any 1526 if (query != null) { 1527 if (query.indexOf("?") != 0) { 1528 buf.append("?"); 1529 } 1530 buf.append(query); 1531 } 1532 // Append protocol 1533 buf.append(" "); 1534 buf.append(version); 1535 buf.append("\r\n"); 1536 1537 return buf.toString(); 1538 } 1539 1540 /** 1541 * This method is invoked immediately after 1542 * {@link #readResponseBody(HttpState,HttpConnection)} and can be overridden by 1543 * sub-classes in order to provide custom body processing. 1544 * 1545 * <p> 1546 * This implementation does nothing. 1547 * </p> 1548 * 1549 * @param state the {@link HttpState state} information associated with this method 1550 * @param conn the {@link HttpConnection connection} used to execute 1551 * this HTTP method 1552 * 1553 * @see #readResponse 1554 * @see #readResponseBody 1555 */ 1556 protected void processResponseBody(HttpState state, HttpConnection conn) { 1557 } 1558 1559 /** 1560 * This method is invoked immediately after 1561 * {@link #readResponseHeaders(HttpState,HttpConnection)} and can be overridden by 1562 * sub-classes in order to provide custom response headers processing. 1563 1564 * <p> 1565 * This implementation will handle the <tt>Set-Cookie</tt> and 1566 * <tt>Set-Cookie2</tt> headers, if any, adding the relevant cookies to 1567 * the given {@link HttpState}. 1568 * </p> 1569 * 1570 * @param state the {@link HttpState state} information associated with this method 1571 * @param conn the {@link HttpConnection connection} used to execute 1572 * this HTTP method 1573 * 1574 * @see #readResponse 1575 * @see #readResponseHeaders 1576 */ 1577 protected void processResponseHeaders(HttpState state, 1578 HttpConnection conn) { 1579 LOG.trace("enter HttpMethodBase.processResponseHeaders(HttpState, " 1580 + "HttpConnection)"); 1581 1582 CookieSpec parser = getCookieSpec(state); 1583 1584 // process set-cookie headers 1585 Header[] headers = getResponseHeaderGroup().getHeaders("set-cookie"); 1586 processCookieHeaders(parser, headers, state, conn); 1587 1588 // see if the cookie spec supports cookie versioning. 1589 if (parser instanceof CookieVersionSupport) { 1590 CookieVersionSupport versupport = (CookieVersionSupport) parser; 1591 if (versupport.getVersion() > 0) { 1592 // process set-cookie2 headers. 1593 // Cookie2 will replace equivalent Cookie instances 1594 headers = getResponseHeaderGroup().getHeaders("set-cookie2"); 1595 processCookieHeaders(parser, headers, state, conn); 1596 } 1597 } 1598 } 1599 1600 /** 1601 * This method processes the specified cookie headers. It is invoked from 1602 * within {@link #processResponseHeaders(HttpState,HttpConnection)} 1603 * 1604 * @param headers cookie {@link Header}s to be processed 1605 * @param state the {@link HttpState state} information associated with 1606 * this HTTP method 1607 * @param conn the {@link HttpConnection connection} used to execute 1608 * this HTTP method 1609 */ 1610 protected void processCookieHeaders( 1611 final CookieSpec parser, 1612 final Header[] headers, 1613 final HttpState state, 1614 final HttpConnection conn) { 1615 LOG.trace("enter HttpMethodBase.processCookieHeaders(Header[], HttpState, " 1616 + "HttpConnection)"); 1617 1618 String host = this.params.getVirtualHost(); 1619 if (host == null) { 1620 host = conn.getHost(); 1621 } 1622 for (int i = 0; i < headers.length; i++) { 1623 Header header = headers[i]; 1624 Cookie[] cookies = null; 1625 try { 1626 cookies = parser.parse( 1627 host, 1628 conn.getPort(), 1629 getPath(), 1630 conn.isSecure(), 1631 header); 1632 } catch (MalformedCookieException e) { 1633 if (LOG.isWarnEnabled()) { 1634 LOG.warn("Invalid cookie header: \"" 1635 + header.getValue() 1636 + "\". " + e.getMessage()); 1637 } 1638 } 1639 if (cookies != null) { 1640 for (int j = 0; j < cookies.length; j++) { 1641 Cookie cookie = cookies[j]; 1642 try { 1643 parser.validate( 1644 host, 1645 conn.getPort(), 1646 getPath(), 1647 conn.isSecure(), 1648 cookie); 1649 state.addCookie(cookie); 1650 if (LOG.isDebugEnabled()) { 1651 LOG.debug("Cookie accepted: \"" 1652 + parser.formatCookie(cookie) + "\""); 1653 } 1654 } catch (MalformedCookieException e) { 1655 if (LOG.isWarnEnabled()) { 1656 LOG.warn("Cookie rejected: \"" + parser.formatCookie(cookie) 1657 + "\". " + e.getMessage()); 1658 } 1659 } 1660 } 1661 } 1662 } 1663 } 1664 1665 /** 1666 * This method is invoked immediately after 1667 * {@link #readStatusLine(HttpState,HttpConnection)} and can be overridden by 1668 * sub-classes in order to provide custom response status line processing. 1669 * 1670 * @param state the {@link HttpState state} information associated with this method 1671 * @param conn the {@link HttpConnection connection} used to execute 1672 * this HTTP method 1673 * 1674 * @see #readResponse 1675 * @see #readStatusLine 1676 */ 1677 protected void processStatusLine(HttpState state, HttpConnection conn) { 1678 } 1679 1680 /** 1681 * Reads the response from the given {@link HttpConnection connection}. 1682 * 1683 * <p> 1684 * The response is processed as the following sequence of actions: 1685 * 1686 * <ol> 1687 * <li> 1688 * {@link #readStatusLine(HttpState,HttpConnection)} is 1689 * invoked to read the request line. 1690 * </li> 1691 * <li> 1692 * {@link #processStatusLine(HttpState,HttpConnection)} 1693 * is invoked, allowing the method to process the status line if 1694 * desired. 1695 * </li> 1696 * <li> 1697 * {@link #readResponseHeaders(HttpState,HttpConnection)} is invoked to read 1698 * the associated headers. 1699 * </li> 1700 * <li> 1701 * {@link #processResponseHeaders(HttpState,HttpConnection)} is invoked, allowing 1702 * the method to process the headers if desired. 1703 * </li> 1704 * <li> 1705 * {@link #readResponseBody(HttpState,HttpConnection)} is 1706 * invoked to read the associated body (if any). 1707 * </li> 1708 * <li> 1709 * {@link #processResponseBody(HttpState,HttpConnection)} is invoked, allowing the 1710 * method to process the response body if desired. 1711 * </li> 1712 * </ol> 1713 * 1714 * Subclasses may want to override one or more of the above methods to to 1715 * customize the processing. (Or they may choose to override this method 1716 * if dramatically different processing is required.) 1717 * </p> 1718 * 1719 * @param state the {@link HttpState state} information associated with this method 1720 * @param conn the {@link HttpConnection connection} used to execute 1721 * this HTTP method 1722 * 1723 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1724 * can be recovered from. 1725 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1726 * cannot be recovered from. 1727 */ 1728 protected void readResponse(HttpState state, HttpConnection conn) 1729 throws IOException, HttpException { 1730 LOG.trace( 1731 "enter HttpMethodBase.readResponse(HttpState, HttpConnection)"); 1732 // Status line & line may have already been received 1733 // if 'expect - continue' handshake has been used 1734 while (this.statusLine == null) { 1735 readStatusLine(state, conn); 1736 processStatusLine(state, conn); 1737 readResponseHeaders(state, conn); 1738 processResponseHeaders(state, conn); 1739 1740 int status = this.statusLine.getStatusCode(); 1741 if ((status >= 100) && (status < 200)) { 1742 if (LOG.isInfoEnabled()) { 1743 LOG.info("Discarding unexpected response: " + this.statusLine.toString()); 1744 } 1745 this.statusLine = null; 1746 } 1747 } 1748 readResponseBody(state, conn); 1749 processResponseBody(state, conn); 1750 } 1751 1752 /** 1753 * Read the response body from the given {@link HttpConnection}. 1754 * 1755 * <p> 1756 * The current implementation wraps the socket level stream with 1757 * an appropriate stream for the type of response (chunked, content-length, 1758 * or auto-close). If there is no response body, the connection associated 1759 * with the request will be returned to the connection manager. 1760 * </p> 1761 * 1762 * <p> 1763 * Subclasses may want to override this method to to customize the 1764 * processing. 1765 * </p> 1766 * 1767 * @param state the {@link HttpState state} information associated with this method 1768 * @param conn the {@link HttpConnection connection} used to execute 1769 * this HTTP method 1770 * 1771 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1772 * can be recovered from. 1773 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1774 * cannot be recovered from. 1775 * 1776 * @see #readResponse 1777 * @see #processResponseBody 1778 */ 1779 protected void readResponseBody(HttpState state, HttpConnection conn) 1780 throws IOException, HttpException { 1781 LOG.trace( 1782 "enter HttpMethodBase.readResponseBody(HttpState, HttpConnection)"); 1783 1784 // assume we are not done with the connection if we get a stream 1785 InputStream stream = readResponseBody(conn); 1786 if (stream == null) { 1787 // done using the connection! 1788 responseBodyConsumed(); 1789 } else { 1790 conn.setLastResponseInputStream(stream); 1791 setResponseStream(stream); 1792 } 1793 } 1794 1795 /** 1796 * Returns the response body as an {@link InputStream input stream} 1797 * corresponding to the values of the <tt>Content-Length</tt> and 1798 * <tt>Transfer-Encoding</tt> headers. If no response body is available 1799 * returns <tt>null</tt>. 1800 * <p> 1801 * 1802 * @see #readResponse 1803 * @see #processResponseBody 1804 * 1805 * @param conn the {@link HttpConnection connection} used to execute 1806 * this HTTP method 1807 * 1808 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1809 * can be recovered from. 1810 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1811 * cannot be recovered from. 1812 */ 1813 private InputStream readResponseBody(HttpConnection conn) 1814 throws HttpException, IOException { 1815 1816 LOG.trace("enter HttpMethodBase.readResponseBody(HttpConnection)"); 1817 1818 responseBody = null; 1819 InputStream is = conn.getResponseInputStream(); 1820 if (Wire.CONTENT_WIRE.enabled()) { 1821 is = new WireLogInputStream(is, Wire.CONTENT_WIRE); 1822 } 1823 boolean canHaveBody = canResponseHaveBody(statusLine.getStatusCode()); 1824 InputStream result = null; 1825 Header transferEncodingHeader = responseHeaders.getFirstHeader("Transfer-Encoding"); 1826 // We use Transfer-Encoding if present and ignore Content-Length. 1827 // RFC2616, 4.4 item number 3 1828 if (transferEncodingHeader != null) { 1829 1830 String transferEncoding = transferEncodingHeader.getValue(); 1831 if (!"chunked".equalsIgnoreCase(transferEncoding) 1832 && !"identity".equalsIgnoreCase(transferEncoding)) { 1833 if (LOG.isWarnEnabled()) { 1834 LOG.warn("Unsupported transfer encoding: " + transferEncoding); 1835 } 1836 } 1837 HeaderElement[] encodings = transferEncodingHeader.getElements(); 1838 // The chunked encoding must be the last one applied 1839 // RFC2616, 14.41 1840 int len = encodings.length; 1841 if ((len > 0) && ("chunked".equalsIgnoreCase(encodings[len - 1].getName()))) { 1842 // if response body is empty 1843 if (conn.isResponseAvailable(conn.getParams().getSoTimeout())) { 1844 result = new ChunkedInputStream(is, this); 1845 } else { 1846 if (getParams().isParameterTrue(HttpMethodParams.STRICT_TRANSFER_ENCODING)) { 1847 throw new ProtocolException("Chunk-encoded body declared but not sent"); 1848 } else { 1849 LOG.warn("Chunk-encoded body missing"); 1850 } 1851 } 1852 } else { 1853 LOG.info("Response content is not chunk-encoded"); 1854 // The connection must be terminated by closing 1855 // the socket as per RFC 2616, 3.6 1856 setConnectionCloseForced(true); 1857 result = is; 1858 } 1859 } else { 1860 long expectedLength = getResponseContentLength(); 1861 if (expectedLength == -1) { 1862 if (canHaveBody && this.effectiveVersion.greaterEquals(HttpVersion.HTTP_1_1)) { 1863 Header connectionHeader = responseHeaders.getFirstHeader("Connection"); 1864 String connectionDirective = null; 1865 if (connectionHeader != null) { 1866 connectionDirective = connectionHeader.getValue(); 1867 } 1868 if (!"close".equalsIgnoreCase(connectionDirective)) { 1869 LOG.info("Response content length is not known"); 1870 setConnectionCloseForced(true); 1871 } 1872 } 1873 result = is; 1874 } else { 1875 result = new ContentLengthInputStream(is, expectedLength); 1876 } 1877 } 1878 1879 // See if the response is supposed to have a response body 1880 if (!canHaveBody) { 1881 result = null; 1882 } 1883 // if there is a result - ALWAYS wrap it in an observer which will 1884 // close the underlying stream as soon as it is consumed, and notify 1885 // the watcher that the stream has been consumed. 1886 if (result != null) { 1887 1888 result = new AutoCloseInputStream( 1889 result, 1890 new ResponseConsumedWatcher() { 1891 public void responseConsumed() { 1892 responseBodyConsumed(); 1893 } 1894 } 1895 ); 1896 } 1897 1898 return result; 1899 } 1900 1901 /** 1902 * Reads the response headers from the given {@link HttpConnection connection}. 1903 * 1904 * <p> 1905 * Subclasses may want to override this method to to customize the 1906 * processing. 1907 * </p> 1908 * 1909 * <p> 1910 * "It must be possible to combine the multiple header fields into one 1911 * "field-name: field-value" pair, without changing the semantics of the 1912 * message, by appending each subsequent field-value to the first, each 1913 * separated by a comma." - HTTP/1.0 (4.3) 1914 * </p> 1915 * 1916 * @param state the {@link HttpState state} information associated with this method 1917 * @param conn the {@link HttpConnection connection} used to execute 1918 * this HTTP method 1919 * 1920 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1921 * can be recovered from. 1922 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1923 * cannot be recovered from. 1924 * 1925 * @see #readResponse 1926 * @see #processResponseHeaders 1927 */ 1928 protected void readResponseHeaders(HttpState state, HttpConnection conn) 1929 throws IOException, HttpException { 1930 LOG.trace("enter HttpMethodBase.readResponseHeaders(HttpState," 1931 + "HttpConnection)"); 1932 1933 getResponseHeaderGroup().clear(); 1934 1935 Header[] headers = HttpParser.parseHeaders( 1936 conn.getResponseInputStream(), getParams().getHttpElementCharset()); 1937 // Wire logging moved to HttpParser 1938 getResponseHeaderGroup().setHeaders(headers); 1939 } 1940 1941 /** 1942 * Read the status line from the given {@link HttpConnection}, setting my 1943 * {@link #getStatusCode status code} and {@link #getStatusText status 1944 * text}. 1945 * 1946 * <p> 1947 * Subclasses may want to override this method to to customize the 1948 * processing. 1949 * </p> 1950 * 1951 * @param state the {@link HttpState state} information associated with this method 1952 * @param conn the {@link HttpConnection connection} used to execute 1953 * this HTTP method 1954 * 1955 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 1956 * can be recovered from. 1957 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 1958 * cannot be recovered from. 1959 * 1960 * @see StatusLine 1961 */ 1962 protected void readStatusLine(HttpState state, HttpConnection conn) 1963 throws IOException, HttpException { 1964 LOG.trace("enter HttpMethodBase.readStatusLine(HttpState, HttpConnection)"); 1965 1966 final int maxGarbageLines = getParams(). 1967 getIntParameter(HttpMethodParams.STATUS_LINE_GARBAGE_LIMIT, Integer.MAX_VALUE); 1968 1969 //read out the HTTP status string 1970 int count = 0; 1971 String s; 1972 do { 1973 s = conn.readLine(getParams().getHttpElementCharset()); 1974 if (s == null && count == 0) { 1975 // The server just dropped connection on us 1976 throw new NoHttpResponseException("The server " + conn.getHost() + 1977 " failed to respond"); 1978 } 1979 if (Wire.HEADER_WIRE.enabled()) { 1980 Wire.HEADER_WIRE.input(s + "\r\n"); 1981 } 1982 if (s != null && StatusLine.startsWithHTTP(s)) { 1983 // Got one 1984 break; 1985 } else if (s == null || count >= maxGarbageLines) { 1986 // Giving up 1987 throw new ProtocolException("The server " + conn.getHost() + 1988 " failed to respond with a valid HTTP response"); 1989 } 1990 count++; 1991 } while(true); 1992 1993 //create the status line from the status string 1994 statusLine = new StatusLine(s); 1995 1996 //check for a valid HTTP-Version 1997 String versionStr = statusLine.getHttpVersion(); 1998 if (getParams().isParameterFalse(HttpMethodParams.UNAMBIGUOUS_STATUS_LINE) 1999 && versionStr.equals("HTTP")) { 2000 getParams().setVersion(HttpVersion.HTTP_1_0); 2001 if (LOG.isWarnEnabled()) { 2002 LOG.warn("Ambiguous status line (HTTP protocol version missing):" + 2003 statusLine.toString()); 2004 } 2005 } else { 2006 this.effectiveVersion = HttpVersion.parse(versionStr); 2007 } 2008 2009 } 2010 2011 // ------------------------------------------------------ Protected Methods 2012 2013 /** 2014 * <p> 2015 * Sends the request via the given {@link HttpConnection connection}. 2016 * </p> 2017 * 2018 * <p> 2019 * The request is written as the following sequence of actions: 2020 * </p> 2021 * 2022 * <ol> 2023 * <li> 2024 * {@link #writeRequestLine(HttpState, HttpConnection)} is invoked to 2025 * write the request line. 2026 * </li> 2027 * <li> 2028 * {@link #writeRequestHeaders(HttpState, HttpConnection)} is invoked 2029 * to write the associated headers. 2030 * </li> 2031 * <li> 2032 * <tt>\r\n</tt> is sent to close the head part of the request. 2033 * </li> 2034 * <li> 2035 * {@link #writeRequestBody(HttpState, HttpConnection)} is invoked to 2036 * write the body part of the request. 2037 * </li> 2038 * </ol> 2039 * 2040 * <p> 2041 * Subclasses may want to override one or more of the above methods to to 2042 * customize the processing. (Or they may choose to override this method 2043 * if dramatically different processing is required.) 2044 * </p> 2045 * 2046 * @param state the {@link HttpState state} information associated with this method 2047 * @param conn the {@link HttpConnection connection} used to execute 2048 * this HTTP method 2049 * 2050 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 2051 * can be recovered from. 2052 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 2053 * cannot be recovered from. 2054 */ 2055 protected void writeRequest(HttpState state, HttpConnection conn) 2056 throws IOException, HttpException { 2057 LOG.trace( 2058 "enter HttpMethodBase.writeRequest(HttpState, HttpConnection)"); 2059 writeRequestLine(state, conn); 2060 writeRequestHeaders(state, conn); 2061 conn.writeLine(); // close head 2062 if (Wire.HEADER_WIRE.enabled()) { 2063 Wire.HEADER_WIRE.output("\r\n"); 2064 } 2065 2066 HttpVersion ver = getParams().getVersion(); 2067 Header expectheader = getRequestHeader("Expect"); 2068 String expectvalue = null; 2069 if (expectheader != null) { 2070 expectvalue = expectheader.getValue(); 2071 } 2072 if ((expectvalue != null) 2073 && (expectvalue.compareToIgnoreCase("100-continue") == 0)) { 2074 if (ver.greaterEquals(HttpVersion.HTTP_1_1)) { 2075 2076 // make sure the status line and headers have been sent 2077 conn.flushRequestOutputStream(); 2078 2079 int readTimeout = conn.getParams().getSoTimeout(); 2080 try { 2081 conn.setSocketTimeout(RESPONSE_WAIT_TIME_MS); 2082 readStatusLine(state, conn); 2083 processStatusLine(state, conn); 2084 readResponseHeaders(state, conn); 2085 processResponseHeaders(state, conn); 2086 2087 if (this.statusLine.getStatusCode() == HttpStatus.SC_CONTINUE) { 2088 // Discard status line 2089 this.statusLine = null; 2090 LOG.debug("OK to continue received"); 2091 } else { 2092 return; 2093 } 2094 } catch (InterruptedIOException e) { 2095 if (!ExceptionUtil.isSocketTimeoutException(e)) { 2096 throw e; 2097 } 2098 // Most probably Expect header is not recongnized 2099 // Remove the header to signal the method 2100 // that it's okay to go ahead with sending data 2101 removeRequestHeader("Expect"); 2102 LOG.info("100 (continue) read timeout. Resume sending the request"); 2103 } finally { 2104 conn.setSocketTimeout(readTimeout); 2105 } 2106 2107 } else { 2108 removeRequestHeader("Expect"); 2109 LOG.info("'Expect: 100-continue' handshake is only supported by " 2110 + "HTTP/1.1 or higher"); 2111 } 2112 } 2113 2114 writeRequestBody(state, conn); 2115 // make sure the entire request body has been sent 2116 conn.flushRequestOutputStream(); 2117 } 2118 2119 /** 2120 * Writes the request body to the given {@link HttpConnection connection}. 2121 * 2122 * <p> 2123 * This method should return <tt>true</tt> if the request body was actually 2124 * sent (or is empty), or <tt>false</tt> if it could not be sent for some 2125 * reason. 2126 * </p> 2127 * 2128 * <p> 2129 * This implementation writes nothing and returns <tt>true</tt>. 2130 * </p> 2131 * 2132 * @param state the {@link HttpState state} information associated with this method 2133 * @param conn the {@link HttpConnection connection} used to execute 2134 * this HTTP method 2135 * 2136 * @return <tt>true</tt> 2137 * 2138 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 2139 * can be recovered from. 2140 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 2141 * cannot be recovered from. 2142 */ 2143 protected boolean writeRequestBody(HttpState state, HttpConnection conn) 2144 throws IOException, HttpException { 2145 return true; 2146 } 2147 2148 /** 2149 * Writes the request headers to the given {@link HttpConnection connection}. 2150 * 2151 * <p> 2152 * This implementation invokes {@link #addRequestHeaders(HttpState,HttpConnection)}, 2153 * and then writes each header to the request stream. 2154 * </p> 2155 * 2156 * <p> 2157 * Subclasses may want to override this method to to customize the 2158 * processing. 2159 * </p> 2160 * 2161 * @param state the {@link HttpState state} information associated with this method 2162 * @param conn the {@link HttpConnection connection} used to execute 2163 * this HTTP method 2164 * 2165 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 2166 * can be recovered from. 2167 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 2168 * cannot be recovered from. 2169 * 2170 * @see #addRequestHeaders 2171 * @see #getRequestHeaders 2172 */ 2173 protected void writeRequestHeaders(HttpState state, HttpConnection conn) 2174 throws IOException, HttpException { 2175 LOG.trace("enter HttpMethodBase.writeRequestHeaders(HttpState," 2176 + "HttpConnection)"); 2177 addRequestHeaders(state, conn); 2178 2179 String charset = getParams().getHttpElementCharset(); 2180 2181 Header[] headers = getRequestHeaders(); 2182 for (int i = 0; i < headers.length; i++) { 2183 String s = headers[i].toExternalForm(); 2184 if (Wire.HEADER_WIRE.enabled()) { 2185 Wire.HEADER_WIRE.output(s); 2186 } 2187 conn.print(s, charset); 2188 } 2189 } 2190 2191 /** 2192 * Writes the request line to the given {@link HttpConnection connection}. 2193 * 2194 * <p> 2195 * Subclasses may want to override this method to to customize the 2196 * processing. 2197 * </p> 2198 * 2199 * @param state the {@link HttpState state} information associated with this method 2200 * @param conn the {@link HttpConnection connection} used to execute 2201 * this HTTP method 2202 * 2203 * @throws IOException if an I/O (transport) error occurs. Some transport exceptions 2204 * can be recovered from. 2205 * @throws HttpException if a protocol exception occurs. Usually protocol exceptions 2206 * cannot be recovered from. 2207 * 2208 * @see #generateRequestLine 2209 */ 2210 protected void writeRequestLine(HttpState state, HttpConnection conn) 2211 throws IOException, HttpException { 2212 LOG.trace( 2213 "enter HttpMethodBase.writeRequestLine(HttpState, HttpConnection)"); 2214 String requestLine = getRequestLine(conn); 2215 if (Wire.HEADER_WIRE.enabled()) { 2216 Wire.HEADER_WIRE.output(requestLine); 2217 } 2218 conn.print(requestLine, getParams().getHttpElementCharset()); 2219 } 2220 2221 /** 2222 * Returns the request line. 2223 * 2224 * @param conn the {@link HttpConnection connection} used to execute 2225 * this HTTP method 2226 * 2227 * @return The request line. 2228 */ 2229 private String getRequestLine(HttpConnection conn) { 2230 return HttpMethodBase.generateRequestLine(conn, getName(), 2231 getPath(), getQueryString(), this.effectiveVersion.toString()); 2232 } 2233 2234 /** 2235 * Returns {@link HttpMethodParams HTTP protocol parameters} associated with this method. 2236 * 2237 * @return HTTP parameters. 2238 * 2239 * @since 3.0 2240 */ 2241 public HttpMethodParams getParams() { 2242 return this.params; 2243 } 2244 2245 /** 2246 * Assigns {@link HttpMethodParams HTTP protocol parameters} for this method. 2247 * 2248 * @since 3.0 2249 * 2250 * @see HttpMethodParams 2251 */ 2252 public void setParams(final HttpMethodParams params) { 2253 if (params == null) { 2254 throw new IllegalArgumentException("Parameters may not be null"); 2255 } 2256 this.params = params; 2257 } 2258 2259 /** 2260 * Returns the HTTP version used with this method (may be <tt>null</tt> 2261 * if undefined, that is, the method has not been executed) 2262 * 2263 * @return HTTP version. 2264 * 2265 * @since 3.0 2266 */ 2267 public HttpVersion getEffectiveVersion() { 2268 return this.effectiveVersion; 2269 } 2270 2271 /** 2272 * Per RFC 2616 section 4.3, some response can never contain a message 2273 * body. 2274 * 2275 * @param status - the HTTP status code 2276 * 2277 * @return <tt>true</tt> if the message may contain a body, <tt>false</tt> if it can not 2278 * contain a message body 2279 */ 2280 private static boolean canResponseHaveBody(int status) { 2281 LOG.trace("enter HttpMethodBase.canResponseHaveBody(int)"); 2282 2283 boolean result = true; 2284 2285 if ((status >= 100 && status <= 199) || (status == 204) 2286 || (status == 304)) { // NOT MODIFIED 2287 result = false; 2288 } 2289 2290 return result; 2291 } 2292 2293 /** 2294 * Returns proxy authentication realm, if it has been used during authentication process. 2295 * Otherwise returns <tt>null</tt>. 2296 * 2297 * @return proxy authentication realm 2298 * 2299 * @deprecated use #getProxyAuthState() 2300 */ 2301 public String getProxyAuthenticationRealm() { 2302 return this.proxyAuthState.getRealm(); 2303 } 2304 2305 /** 2306 * Returns authentication realm, if it has been used during authentication process. 2307 * Otherwise returns <tt>null</tt>. 2308 * 2309 * @return authentication realm 2310 * 2311 * @deprecated use #getHostAuthState() 2312 */ 2313 public String getAuthenticationRealm() { 2314 return this.hostAuthState.getRealm(); 2315 } 2316 2317 /** 2318 * Returns the character set from the <tt>Content-Type</tt> header. 2319 * 2320 * @param contentheader The content header. 2321 * @return String The character set. 2322 */ 2323 protected String getContentCharSet(Header contentheader) { 2324 LOG.trace("enter getContentCharSet( Header contentheader )"); 2325 String charset = null; 2326 if (contentheader != null) { 2327 HeaderElement values[] = contentheader.getElements(); 2328 // I expect only one header element to be there 2329 // No more. no less 2330 if (values.length == 1) { 2331 NameValuePair param = values[0].getParameterByName("charset"); 2332 if (param != null) { 2333 // If I get anything "funny" 2334 // UnsupportedEncondingException will result 2335 charset = param.getValue(); 2336 } 2337 } 2338 } 2339 if (charset == null) { 2340 charset = getParams().getContentCharset(); 2341 if (LOG.isDebugEnabled()) { 2342 LOG.debug("Default charset used: " + charset); 2343 } 2344 } 2345 return charset; 2346 } 2347 2348 2349 /** 2350 * Returns the character encoding of the request from the <tt>Content-Type</tt> header. 2351 * 2352 * @return String The character set. 2353 */ 2354 public String getRequestCharSet() { 2355 return getContentCharSet(getRequestHeader("Content-Type")); 2356 } 2357 2358 2359 /** 2360 * Returns the character encoding of the response from the <tt>Content-Type</tt> header. 2361 * 2362 * @return String The character set. 2363 */ 2364 public String getResponseCharSet() { 2365 return getContentCharSet(getResponseHeader("Content-Type")); 2366 } 2367 2368 /** 2369 * @deprecated no longer used 2370 * 2371 * Returns the number of "recoverable" exceptions thrown and handled, to 2372 * allow for monitoring the quality of the connection. 2373 * 2374 * @return The number of recoverable exceptions handled by the method. 2375 */ 2376 public int getRecoverableExceptionCount() { 2377 return recoverableExceptionCount; 2378 } 2379 2380 /** 2381 * A response has been consumed. 2382 * 2383 * <p>The default behavior for this class is to check to see if the connection 2384 * should be closed, and close if need be, and to ensure that the connection 2385 * is returned to the connection manager - if and only if we are not still 2386 * inside the execute call.</p> 2387 * 2388 */ 2389 protected void responseBodyConsumed() { 2390 2391 // make sure this is the initial invocation of the notification, 2392 // ignore subsequent ones. 2393 responseStream = null; 2394 if (responseConnection != null) { 2395 responseConnection.setLastResponseInputStream(null); 2396 2397 // At this point, no response data should be available. 2398 // If there is data available, regard the connection as being 2399 // unreliable and close it. 2400 2401 if (shouldCloseConnection(responseConnection)) { 2402 responseConnection.close(); 2403 } else { 2404 try { 2405 if(responseConnection.isResponseAvailable()) { 2406 boolean logExtraInput = 2407 getParams().isParameterTrue(HttpMethodParams.WARN_EXTRA_INPUT); 2408 2409 if(logExtraInput) { 2410 LOG.warn("Extra response data detected - closing connection"); 2411 } 2412 responseConnection.close(); 2413 } 2414 } 2415 catch (IOException e) { 2416 LOG.warn(e.getMessage()); 2417 responseConnection.close(); 2418 } 2419 } 2420 } 2421 this.connectionCloseForced = false; 2422 ensureConnectionRelease(); 2423 } 2424 2425 /** 2426 * Insure that the connection is released back to the pool. 2427 */ 2428 private void ensureConnectionRelease() { 2429 if (responseConnection != null) { 2430 responseConnection.releaseConnection(); 2431 responseConnection = null; 2432 } 2433 } 2434 2435 /** 2436 * Returns the {@link HostConfiguration host configuration}. 2437 * 2438 * @return the host configuration 2439 * 2440 * @deprecated no longer applicable 2441 */ 2442 public HostConfiguration getHostConfiguration() { 2443 HostConfiguration hostconfig = new HostConfiguration(); 2444 hostconfig.setHost(this.httphost); 2445 return hostconfig; 2446 } 2447 /** 2448 * Sets the {@link HostConfiguration host configuration}. 2449 * 2450 * @param hostconfig The hostConfiguration to set 2451 * 2452 * @deprecated no longer applicable 2453 */ 2454 public void setHostConfiguration(final HostConfiguration hostconfig) { 2455 if (hostconfig != null) { 2456 this.httphost = new HttpHost( 2457 hostconfig.getHost(), 2458 hostconfig.getPort(), 2459 hostconfig.getProtocol()); 2460 } else { 2461 this.httphost = null; 2462 } 2463 } 2464 2465 /** 2466 * Returns the {@link MethodRetryHandler retry handler} for this HTTP method 2467 * 2468 * @return the methodRetryHandler 2469 * 2470 * @deprecated use {@link HttpMethodParams} 2471 */ 2472 public MethodRetryHandler getMethodRetryHandler() { 2473 return methodRetryHandler; 2474 } 2475 2476 /** 2477 * Sets the {@link MethodRetryHandler retry handler} for this HTTP method 2478 * 2479 * @param handler the methodRetryHandler to use when this method executed 2480 * 2481 * @deprecated use {@link HttpMethodParams} 2482 */ 2483 public void setMethodRetryHandler(MethodRetryHandler handler) { 2484 methodRetryHandler = handler; 2485 } 2486 2487 /** 2488 * This method is a dirty hack intended to work around 2489 * current (2.0) design flaw that prevents the user from 2490 * obtaining correct status code, headers and response body from the 2491 * preceding HTTP CONNECT method. 2492 * 2493 * TODO: Remove this crap as soon as possible 2494 */ 2495 void fakeResponse( 2496 StatusLine statusline, 2497 HeaderGroup responseheaders, 2498 InputStream responseStream 2499 ) { 2500 // set used so that the response can be read 2501 this.used = true; 2502 this.statusLine = statusline; 2503 this.responseHeaders = responseheaders; 2504 this.responseBody = null; 2505 this.responseStream = responseStream; 2506 } 2507 2508 /** 2509 * Returns the target host {@link AuthState authentication state} 2510 * 2511 * @return host authentication state 2512 * 2513 * @since 3.0 2514 */ 2515 public AuthState getHostAuthState() { 2516 return this.hostAuthState; 2517 } 2518 2519 /** 2520 * Returns the proxy {@link AuthState authentication state} 2521 * 2522 * @return host authentication state 2523 * 2524 * @since 3.0 2525 */ 2526 public AuthState getProxyAuthState() { 2527 return this.proxyAuthState; 2528 } 2529 2530 /** 2531 * Tests whether the execution of this method has been aborted 2532 * 2533 * @return <tt>true</tt> if the execution of this method has been aborted, 2534 * <tt>false</tt> otherwise 2535 * 2536 * @since 3.0 2537 */ 2538 public boolean isAborted() { 2539 return this.aborted; 2540 } 2541 2542 /** 2543 * Returns <tt>true</tt> if the HTTP has been transmitted to the target 2544 * server in its entirety, <tt>false</tt> otherwise. This flag can be useful 2545 * for recovery logic. If the request has not been transmitted in its entirety, 2546 * it is safe to retry the failed method. 2547 * 2548 * @return <tt>true</tt> if the request has been sent, <tt>false</tt> otherwise 2549 */ 2550 public boolean isRequestSent() { 2551 return this.requestSent; 2552 } 2553 2554 }