001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.commons.fileupload; 018 019import static java.lang.String.format; 020 021import java.io.ByteArrayOutputStream; 022import java.io.IOException; 023import java.io.InputStream; 024import java.io.OutputStream; 025import java.io.UnsupportedEncodingException; 026 027import org.apache.commons.fileupload.FileUploadBase.FileUploadIOException; 028import org.apache.commons.fileupload.util.Closeable; 029import org.apache.commons.fileupload.util.Streams; 030 031/** 032 * <p> Low level API for processing file uploads. 033 * 034 * <p> This class can be used to process data streams conforming to MIME 035 * 'multipart' format as defined in 036 * <a href="http://www.ietf.org/rfc/rfc1867.txt">RFC 1867</a>. Arbitrarily 037 * large amounts of data in the stream can be processed under constant 038 * memory usage. 039 * 040 * <p> The format of the stream is defined in the following way:<br> 041 * 042 * <code> 043 * multipart-body := preamble 1*encapsulation close-delimiter epilogue<br> 044 * encapsulation := delimiter body CRLF<br> 045 * delimiter := "--" boundary CRLF<br> 046 * close-delimiter := "--" boundary "--"<br> 047 * preamble := <ignore><br> 048 * epilogue := <ignore><br> 049 * body := header-part CRLF body-part<br> 050 * header-part := 1*header CRLF<br> 051 * header := header-name ":" header-value<br> 052 * header-name := <printable ascii characters except ":"><br> 053 * header-value := <any ascii characters except CR & LF><br> 054 * body-data := <arbitrary data><br> 055 * </code> 056 * 057 * <p>Note that body-data can contain another mulipart entity. There 058 * is limited support for single pass processing of such nested 059 * streams. The nested stream is <strong>required</strong> to have a 060 * boundary token of the same length as the parent stream (see {@link 061 * #setBoundary(byte[])}). 062 * 063 * <p>Here is an example of usage of this class.<br> 064 * 065 * <pre> 066 * try { 067 * MultipartStream multipartStream = new MultipartStream(input, boundary); 068 * boolean nextPart = multipartStream.skipPreamble(); 069 * OutputStream output; 070 * while(nextPart) { 071 * String header = multipartStream.readHeaders(); 072 * // process headers 073 * // create some output stream 074 * multipartStream.readBodyData(output); 075 * nextPart = multipartStream.readBoundary(); 076 * } 077 * } catch(MultipartStream.MalformedStreamException e) { 078 * // the stream failed to follow required syntax 079 * } catch(IOException e) { 080 * // a read or write error occurred 081 * } 082 * </pre> 083 */ 084public class MultipartStream { 085 086 /** 087 * Internal class, which is used to invoke the 088 * {@link ProgressListener}. 089 */ 090 public static class ProgressNotifier { 091 092 /** 093 * The listener to invoke. 094 */ 095 private final ProgressListener listener; 096 097 /** 098 * Number of expected bytes, if known, or -1. 099 */ 100 private final long contentLength; 101 102 /** 103 * Number of bytes, which have been read so far. 104 */ 105 private long bytesRead; 106 107 /** 108 * Number of items, which have been read so far. 109 */ 110 private int items; 111 112 /** 113 * Creates a new instance with the given listener 114 * and content length. 115 * 116 * @param pListener The listener to invoke. 117 * @param pContentLength The expected content length. 118 */ 119 ProgressNotifier(ProgressListener pListener, long pContentLength) { 120 listener = pListener; 121 contentLength = pContentLength; 122 } 123 124 /** 125 * Called to indicate that bytes have been read. 126 * 127 * @param pBytes Number of bytes, which have been read. 128 */ 129 void noteBytesRead(int pBytes) { 130 /* Indicates, that the given number of bytes have been read from 131 * the input stream. 132 */ 133 bytesRead += pBytes; 134 notifyListener(); 135 } 136 137 /** 138 * Called to indicate, that a new file item has been detected. 139 */ 140 void noteItem() { 141 ++items; 142 notifyListener(); 143 } 144 145 /** 146 * Called for notifying the listener. 147 */ 148 private void notifyListener() { 149 if (listener != null) { 150 listener.update(bytesRead, contentLength, items); 151 } 152 } 153 154 } 155 156 // ----------------------------------------------------- Manifest constants 157 158 /** 159 * The Carriage Return ASCII character value. 160 */ 161 public static final byte CR = 0x0D; 162 163 /** 164 * The Line Feed ASCII character value. 165 */ 166 public static final byte LF = 0x0A; 167 168 /** 169 * The dash (-) ASCII character value. 170 */ 171 public static final byte DASH = 0x2D; 172 173 /** 174 * The maximum length of <code>header-part</code> that will be 175 * processed (10 kilobytes = 10240 bytes.). 176 */ 177 public static final int HEADER_PART_SIZE_MAX = 10240; 178 179 /** 180 * The default length of the buffer used for processing a request. 181 */ 182 protected static final int DEFAULT_BUFSIZE = 4096; 183 184 /** 185 * A byte sequence that marks the end of <code>header-part</code> 186 * (<code>CRLFCRLF</code>). 187 */ 188 protected static final byte[] HEADER_SEPARATOR = {CR, LF, CR, LF}; 189 190 /** 191 * A byte sequence that that follows a delimiter that will be 192 * followed by an encapsulation (<code>CRLF</code>). 193 */ 194 protected static final byte[] FIELD_SEPARATOR = {CR, LF}; 195 196 /** 197 * A byte sequence that that follows a delimiter of the last 198 * encapsulation in the stream (<code>--</code>). 199 */ 200 protected static final byte[] STREAM_TERMINATOR = {DASH, DASH}; 201 202 /** 203 * A byte sequence that precedes a boundary (<code>CRLF--</code>). 204 */ 205 protected static final byte[] BOUNDARY_PREFIX = {CR, LF, DASH, DASH}; 206 207 // ----------------------------------------------------------- Data members 208 209 /** 210 * The input stream from which data is read. 211 */ 212 private final InputStream input; 213 214 /** 215 * The length of the boundary token plus the leading <code>CRLF--</code>. 216 */ 217 private int boundaryLength; 218 219 /** 220 * The amount of data, in bytes, that must be kept in the buffer in order 221 * to detect delimiters reliably. 222 */ 223 private final int keepRegion; 224 225 /** 226 * The byte sequence that partitions the stream. 227 */ 228 private final byte[] boundary; 229 230 /** 231 * The table for Knuth-Morris-Pratt search algorithm. 232 */ 233 private final int[] boundaryTable; 234 235 /** 236 * The length of the buffer used for processing the request. 237 */ 238 private final int bufSize; 239 240 /** 241 * The buffer used for processing the request. 242 */ 243 private final byte[] buffer; 244 245 /** 246 * The index of first valid character in the buffer. 247 * <br> 248 * 0 <= head < bufSize 249 */ 250 private int head; 251 252 /** 253 * The index of last valid character in the buffer + 1. 254 * <br> 255 * 0 <= tail <= bufSize 256 */ 257 private int tail; 258 259 /** 260 * The content encoding to use when reading headers. 261 */ 262 private String headerEncoding; 263 264 /** 265 * The progress notifier, if any, or null. 266 */ 267 private final ProgressNotifier notifier; 268 269 // ----------------------------------------------------------- Constructors 270 271 /** 272 * Creates a new instance. 273 * 274 * @deprecated 1.2.1 Use {@link #MultipartStream(InputStream, byte[], int, 275 * ProgressNotifier)} 276 */ 277 @Deprecated 278 public MultipartStream() { 279 this(null, null, null); 280 } 281 282 /** 283 * <p> Constructs a <code>MultipartStream</code> with a custom size buffer 284 * and no progress notifier. 285 * 286 * <p> Note that the buffer must be at least big enough to contain the 287 * boundary string, plus 4 characters for CR/LF and double dash, plus at 288 * least one byte of data. Too small a buffer size setting will degrade 289 * performance. 290 * 291 * @param input The <code>InputStream</code> to serve as a data source. 292 * @param boundary The token used for dividing the stream into 293 * <code>encapsulations</code>. 294 * @param bufSize The size of the buffer to be used, in bytes. 295 * 296 * @deprecated 1.2.1 Use {@link #MultipartStream(InputStream, byte[], int, 297 * ProgressNotifier)}. 298 */ 299 @Deprecated 300 public MultipartStream(InputStream input, byte[] boundary, int bufSize) { 301 this(input, boundary, bufSize, null); 302 } 303 304 /** 305 * <p> Constructs a <code>MultipartStream</code> with a custom size buffer. 306 * 307 * <p> Note that the buffer must be at least big enough to contain the 308 * boundary string, plus 4 characters for CR/LF and double dash, plus at 309 * least one byte of data. Too small a buffer size setting will degrade 310 * performance. 311 * 312 * @param input The <code>InputStream</code> to serve as a data source. 313 * @param boundary The token used for dividing the stream into 314 * <code>encapsulations</code>. 315 * @param bufSize The size of the buffer to be used, in bytes. 316 * @param pNotifier The notifier, which is used for calling the 317 * progress listener, if any. 318 * 319 * @throws IllegalArgumentException If the buffer size is too small 320 * 321 * @since 1.3.1 322 */ 323 public MultipartStream(InputStream input, 324 byte[] boundary, 325 int bufSize, 326 ProgressNotifier pNotifier) { 327 328 if (boundary == null) { 329 throw new IllegalArgumentException("boundary may not be null"); 330 } 331 // We prepend CR/LF to the boundary to chop trailing CR/LF from 332 // body-data tokens. 333 this.boundaryLength = boundary.length + BOUNDARY_PREFIX.length; 334 if (bufSize < this.boundaryLength + 1) { 335 throw new IllegalArgumentException( 336 "The buffer size specified for the MultipartStream is too small"); 337 } 338 339 this.input = input; 340 this.bufSize = Math.max(bufSize, boundaryLength * 2); 341 this.buffer = new byte[this.bufSize]; 342 this.notifier = pNotifier; 343 344 this.boundary = new byte[this.boundaryLength]; 345 this.boundaryTable = new int[this.boundaryLength + 1]; 346 this.keepRegion = this.boundary.length; 347 348 System.arraycopy(BOUNDARY_PREFIX, 0, this.boundary, 0, 349 BOUNDARY_PREFIX.length); 350 System.arraycopy(boundary, 0, this.boundary, BOUNDARY_PREFIX.length, 351 boundary.length); 352 computeBoundaryTable(); 353 354 head = 0; 355 tail = 0; 356 } 357 358 /** 359 * <p> Constructs a <code>MultipartStream</code> with a default size buffer. 360 * 361 * @param input The <code>InputStream</code> to serve as a data source. 362 * @param boundary The token used for dividing the stream into 363 * <code>encapsulations</code>. 364 * @param pNotifier An object for calling the progress listener, if any. 365 * 366 * 367 * @see #MultipartStream(InputStream, byte[], int, ProgressNotifier) 368 */ 369 MultipartStream(InputStream input, 370 byte[] boundary, 371 ProgressNotifier pNotifier) { 372 this(input, boundary, DEFAULT_BUFSIZE, pNotifier); 373 } 374 375 /** 376 * <p> Constructs a <code>MultipartStream</code> with a default size buffer. 377 * 378 * @param input The <code>InputStream</code> to serve as a data source. 379 * @param boundary The token used for dividing the stream into 380 * <code>encapsulations</code>. 381 * 382 * @deprecated 1.2.1 Use {@link #MultipartStream(InputStream, byte[], int, 383 * ProgressNotifier)}. 384 */ 385 @Deprecated 386 public MultipartStream(InputStream input, 387 byte[] boundary) { 388 this(input, boundary, DEFAULT_BUFSIZE, null); 389 } 390 391 // --------------------------------------------------------- Public methods 392 393 /** 394 * Retrieves the character encoding used when reading the headers of an 395 * individual part. When not specified, or <code>null</code>, the platform 396 * default encoding is used. 397 * 398 * @return The encoding used to read part headers. 399 */ 400 public String getHeaderEncoding() { 401 return headerEncoding; 402 } 403 404 /** 405 * Specifies the character encoding to be used when reading the headers of 406 * individual parts. When not specified, or <code>null</code>, the platform 407 * default encoding is used. 408 * 409 * @param encoding The encoding used to read part headers. 410 */ 411 public void setHeaderEncoding(String encoding) { 412 headerEncoding = encoding; 413 } 414 415 /** 416 * Reads a byte from the <code>buffer</code>, and refills it as 417 * necessary. 418 * 419 * @return The next byte from the input stream. 420 * 421 * @throws IOException if there is no more data available. 422 */ 423 public byte readByte() throws IOException { 424 // Buffer depleted ? 425 if (head == tail) { 426 head = 0; 427 // Refill. 428 tail = input.read(buffer, head, bufSize); 429 if (tail == -1) { 430 // No more data available. 431 throw new IOException("No more data is available"); 432 } 433 if (notifier != null) { 434 notifier.noteBytesRead(tail); 435 } 436 } 437 return buffer[head++]; 438 } 439 440 /** 441 * Skips a <code>boundary</code> token, and checks whether more 442 * <code>encapsulations</code> are contained in the stream. 443 * 444 * @return <code>true</code> if there are more encapsulations in 445 * this stream; <code>false</code> otherwise. 446 * 447 * @throws FileUploadIOException if the bytes read from the stream exceeded the size limits 448 * @throws MalformedStreamException if the stream ends unexpectedly or 449 * fails to follow required syntax. 450 */ 451 public boolean readBoundary() 452 throws FileUploadIOException, MalformedStreamException { 453 byte[] marker = new byte[2]; 454 boolean nextChunk = false; 455 456 head += boundaryLength; 457 try { 458 marker[0] = readByte(); 459 if (marker[0] == LF) { 460 // Work around IE5 Mac bug with input type=image. 461 // Because the boundary delimiter, not including the trailing 462 // CRLF, must not appear within any file (RFC 2046, section 463 // 5.1.1), we know the missing CR is due to a buggy browser 464 // rather than a file containing something similar to a 465 // boundary. 466 return true; 467 } 468 469 marker[1] = readByte(); 470 if (arrayequals(marker, STREAM_TERMINATOR, 2)) { 471 nextChunk = false; 472 } else if (arrayequals(marker, FIELD_SEPARATOR, 2)) { 473 nextChunk = true; 474 } else { 475 throw new MalformedStreamException( 476 "Unexpected characters follow a boundary"); 477 } 478 } catch (FileUploadIOException e) { 479 // wraps a SizeException, re-throw as it will be unwrapped later 480 throw e; 481 } catch (IOException e) { 482 throw new MalformedStreamException("Stream ended unexpectedly"); 483 } 484 return nextChunk; 485 } 486 487 /** 488 * <p>Changes the boundary token used for partitioning the stream. 489 * 490 * <p>This method allows single pass processing of nested multipart 491 * streams. 492 * 493 * <p>The boundary token of the nested stream is <code>required</code> 494 * to be of the same length as the boundary token in parent stream. 495 * 496 * <p>Restoring the parent stream boundary token after processing of a 497 * nested stream is left to the application. 498 * 499 * @param boundary The boundary to be used for parsing of the nested 500 * stream. 501 * 502 * @throws IllegalBoundaryException if the <code>boundary</code> 503 * has a different length than the one 504 * being currently parsed. 505 */ 506 public void setBoundary(byte[] boundary) 507 throws IllegalBoundaryException { 508 if (boundary.length != boundaryLength - BOUNDARY_PREFIX.length) { 509 throw new IllegalBoundaryException( 510 "The length of a boundary token cannot be changed"); 511 } 512 System.arraycopy(boundary, 0, this.boundary, BOUNDARY_PREFIX.length, 513 boundary.length); 514 computeBoundaryTable(); 515 } 516 517 /** 518 * Compute the table used for Knuth-Morris-Pratt search algorithm. 519 */ 520 private void computeBoundaryTable() { 521 int position = 2; 522 int candidate = 0; 523 524 boundaryTable[0] = -1; 525 boundaryTable[1] = 0; 526 527 while (position <= boundaryLength) { 528 if (boundary[position - 1] == boundary[candidate]) { 529 boundaryTable[position] = candidate + 1; 530 candidate++; 531 position++; 532 } else if (candidate > 0) { 533 candidate = boundaryTable[candidate]; 534 } else { 535 boundaryTable[position] = 0; 536 position++; 537 } 538 } 539 } 540 541 /** 542 * <p>Reads the <code>header-part</code> of the current 543 * <code>encapsulation</code>. 544 * 545 * <p>Headers are returned verbatim to the input stream, including the 546 * trailing <code>CRLF</code> marker. Parsing is left to the 547 * application. 548 * 549 * <p><strong>TODO</strong> allow limiting maximum header size to 550 * protect against abuse. 551 * 552 * @return The <code>header-part</code> of the current encapsulation. 553 * 554 * @throws FileUploadIOException if the bytes read from the stream exceeded the size limits. 555 * @throws MalformedStreamException if the stream ends unexpectedly. 556 */ 557 public String readHeaders() throws FileUploadIOException, MalformedStreamException { 558 int i = 0; 559 byte b; 560 // to support multi-byte characters 561 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 562 int size = 0; 563 while (i < HEADER_SEPARATOR.length) { 564 try { 565 b = readByte(); 566 } catch (FileUploadIOException e) { 567 // wraps a SizeException, re-throw as it will be unwrapped later 568 throw e; 569 } catch (IOException e) { 570 throw new MalformedStreamException("Stream ended unexpectedly"); 571 } 572 if (++size > HEADER_PART_SIZE_MAX) { 573 throw new MalformedStreamException( 574 format("Header section has more than %s bytes (maybe it is not properly terminated)", 575 Integer.valueOf(HEADER_PART_SIZE_MAX))); 576 } 577 if (b == HEADER_SEPARATOR[i]) { 578 i++; 579 } else { 580 i = 0; 581 } 582 baos.write(b); 583 } 584 585 String headers = null; 586 if (headerEncoding != null) { 587 try { 588 headers = baos.toString(headerEncoding); 589 } catch (UnsupportedEncodingException e) { 590 // Fall back to platform default if specified encoding is not 591 // supported. 592 headers = baos.toString(); 593 } 594 } else { 595 headers = baos.toString(); 596 } 597 598 return headers; 599 } 600 601 /** 602 * <p>Reads <code>body-data</code> from the current 603 * <code>encapsulation</code> and writes its contents into the 604 * output <code>Stream</code>. 605 * 606 * <p>Arbitrary large amounts of data can be processed by this 607 * method using a constant size buffer. (see {@link 608 * #MultipartStream(InputStream,byte[],int, 609 * MultipartStream.ProgressNotifier) constructor}). 610 * 611 * @param output The <code>Stream</code> to write data into. May 612 * be null, in which case this method is equivalent 613 * to {@link #discardBodyData()}. 614 * 615 * @return the amount of data written. 616 * 617 * @throws MalformedStreamException if the stream ends unexpectedly. 618 * @throws IOException if an i/o error occurs. 619 */ 620 public int readBodyData(OutputStream output) 621 throws MalformedStreamException, IOException { 622 return (int) Streams.copy(newInputStream(), output, false); // N.B. Streams.copy closes the input stream 623 } 624 625 /** 626 * Creates a new {@link ItemInputStream}. 627 * @return A new instance of {@link ItemInputStream}. 628 */ 629 ItemInputStream newInputStream() { 630 return new ItemInputStream(); 631 } 632 633 /** 634 * <p> Reads <code>body-data</code> from the current 635 * <code>encapsulation</code> and discards it. 636 * 637 * <p>Use this method to skip encapsulations you don't need or don't 638 * understand. 639 * 640 * @return The amount of data discarded. 641 * 642 * @throws MalformedStreamException if the stream ends unexpectedly. 643 * @throws IOException if an i/o error occurs. 644 */ 645 public int discardBodyData() throws MalformedStreamException, IOException { 646 return readBodyData(null); 647 } 648 649 /** 650 * Finds the beginning of the first <code>encapsulation</code>. 651 * 652 * @return <code>true</code> if an <code>encapsulation</code> was found in 653 * the stream. 654 * 655 * @throws IOException if an i/o error occurs. 656 */ 657 public boolean skipPreamble() throws IOException { 658 // First delimiter may be not preceeded with a CRLF. 659 System.arraycopy(boundary, 2, boundary, 0, boundary.length - 2); 660 boundaryLength = boundary.length - 2; 661 computeBoundaryTable(); 662 try { 663 // Discard all data up to the delimiter. 664 discardBodyData(); 665 666 // Read boundary - if succeeded, the stream contains an 667 // encapsulation. 668 return readBoundary(); 669 } catch (MalformedStreamException e) { 670 return false; 671 } finally { 672 // Restore delimiter. 673 System.arraycopy(boundary, 0, boundary, 2, boundary.length - 2); 674 boundaryLength = boundary.length; 675 boundary[0] = CR; 676 boundary[1] = LF; 677 computeBoundaryTable(); 678 } 679 } 680 681 /** 682 * Compares <code>count</code> first bytes in the arrays 683 * <code>a</code> and <code>b</code>. 684 * 685 * @param a The first array to compare. 686 * @param b The second array to compare. 687 * @param count How many bytes should be compared. 688 * 689 * @return <code>true</code> if <code>count</code> first bytes in arrays 690 * <code>a</code> and <code>b</code> are equal. 691 */ 692 public static boolean arrayequals(byte[] a, 693 byte[] b, 694 int count) { 695 for (int i = 0; i < count; i++) { 696 if (a[i] != b[i]) { 697 return false; 698 } 699 } 700 return true; 701 } 702 703 /** 704 * Searches for a byte of specified value in the <code>buffer</code>, 705 * starting at the specified <code>position</code>. 706 * 707 * @param value The value to find. 708 * @param pos The starting position for searching. 709 * 710 * @return The position of byte found, counting from beginning of the 711 * <code>buffer</code>, or <code>-1</code> if not found. 712 */ 713 protected int findByte(byte value, 714 int pos) { 715 for (int i = pos; i < tail; i++) { 716 if (buffer[i] == value) { 717 return i; 718 } 719 } 720 721 return -1; 722 } 723 724 /** 725 * Searches for the <code>boundary</code> in the <code>buffer</code> 726 * region delimited by <code>head</code> and <code>tail</code>. 727 * 728 * @return The position of the boundary found, counting from the 729 * beginning of the <code>buffer</code>, or <code>-1</code> if 730 * not found. 731 */ 732 protected int findSeparator() { 733 734 int bufferPos = this.head; 735 int tablePos = 0; 736 737 while (bufferPos < this.tail) { 738 while (tablePos >= 0 && buffer[bufferPos] != boundary[tablePos]) { 739 tablePos = boundaryTable[tablePos]; 740 } 741 bufferPos++; 742 tablePos++; 743 if (tablePos == boundaryLength) { 744 return bufferPos - boundaryLength; 745 } 746 } 747 return -1; 748 } 749 750 /** 751 * Thrown to indicate that the input stream fails to follow the 752 * required syntax. 753 */ 754 public static class MalformedStreamException extends IOException { 755 756 /** 757 * The UID to use when serializing this instance. 758 */ 759 private static final long serialVersionUID = 6466926458059796677L; 760 761 /** 762 * Constructs a <code>MalformedStreamException</code> with no 763 * detail message. 764 */ 765 public MalformedStreamException() { 766 super(); 767 } 768 769 /** 770 * Constructs an <code>MalformedStreamException</code> with 771 * the specified detail message. 772 * 773 * @param message The detail message. 774 */ 775 public MalformedStreamException(String message) { 776 super(message); 777 } 778 779 } 780 781 /** 782 * Thrown upon attempt of setting an invalid boundary token. 783 */ 784 public static class IllegalBoundaryException extends IOException { 785 786 /** 787 * The UID to use when serializing this instance. 788 */ 789 private static final long serialVersionUID = -161533165102632918L; 790 791 /** 792 * Constructs an <code>IllegalBoundaryException</code> with no 793 * detail message. 794 */ 795 public IllegalBoundaryException() { 796 super(); 797 } 798 799 /** 800 * Constructs an <code>IllegalBoundaryException</code> with 801 * the specified detail message. 802 * 803 * @param message The detail message. 804 */ 805 public IllegalBoundaryException(String message) { 806 super(message); 807 } 808 809 } 810 811 /** 812 * An {@link InputStream} for reading an items contents. 813 */ 814 public class ItemInputStream extends InputStream implements Closeable { 815 816 /** 817 * The number of bytes, which have been read so far. 818 */ 819 private long total; 820 821 /** 822 * The number of bytes, which must be hold, because 823 * they might be a part of the boundary. 824 */ 825 private int pad; 826 827 /** 828 * The current offset in the buffer. 829 */ 830 private int pos; 831 832 /** 833 * Whether the stream is already closed. 834 */ 835 private boolean closed; 836 837 /** 838 * Creates a new instance. 839 */ 840 ItemInputStream() { 841 findSeparator(); 842 } 843 844 /** 845 * Called for finding the separator. 846 */ 847 private void findSeparator() { 848 pos = MultipartStream.this.findSeparator(); 849 if (pos == -1) { 850 if (tail - head > keepRegion) { 851 pad = keepRegion; 852 } else { 853 pad = tail - head; 854 } 855 } 856 } 857 858 /** 859 * Returns the number of bytes, which have been read 860 * by the stream. 861 * 862 * @return Number of bytes, which have been read so far. 863 */ 864 public long getBytesRead() { 865 return total; 866 } 867 868 /** 869 * Returns the number of bytes, which are currently 870 * available, without blocking. 871 * 872 * @throws IOException An I/O error occurs. 873 * @return Number of bytes in the buffer. 874 */ 875 @Override 876 public int available() throws IOException { 877 if (pos == -1) { 878 return tail - head - pad; 879 } 880 return pos - head; 881 } 882 883 /** 884 * Offset when converting negative bytes to integers. 885 */ 886 private static final int BYTE_POSITIVE_OFFSET = 256; 887 888 /** 889 * Returns the next byte in the stream. 890 * 891 * @return The next byte in the stream, as a non-negative 892 * integer, or -1 for EOF. 893 * @throws IOException An I/O error occurred. 894 */ 895 @Override 896 public int read() throws IOException { 897 if (closed) { 898 throw new FileItemStream.ItemSkippedException(); 899 } 900 if (available() == 0 && makeAvailable() == 0) { 901 return -1; 902 } 903 ++total; 904 int b = buffer[head++]; 905 if (b >= 0) { 906 return b; 907 } 908 return b + BYTE_POSITIVE_OFFSET; 909 } 910 911 /** 912 * Reads bytes into the given buffer. 913 * 914 * @param b The destination buffer, where to write to. 915 * @param off Offset of the first byte in the buffer. 916 * @param len Maximum number of bytes to read. 917 * @return Number of bytes, which have been actually read, 918 * or -1 for EOF. 919 * @throws IOException An I/O error occurred. 920 */ 921 @Override 922 public int read(byte[] b, int off, int len) throws IOException { 923 if (closed) { 924 throw new FileItemStream.ItemSkippedException(); 925 } 926 if (len == 0) { 927 return 0; 928 } 929 int res = available(); 930 if (res == 0) { 931 res = makeAvailable(); 932 if (res == 0) { 933 return -1; 934 } 935 } 936 res = Math.min(res, len); 937 System.arraycopy(buffer, head, b, off, res); 938 head += res; 939 total += res; 940 return res; 941 } 942 943 /** 944 * Closes the input stream. 945 * 946 * @throws IOException An I/O error occurred. 947 */ 948 @Override 949 public void close() throws IOException { 950 close(false); 951 } 952 953 /** 954 * Closes the input stream. 955 * 956 * @param pCloseUnderlying Whether to close the underlying stream 957 * (hard close) 958 * @throws IOException An I/O error occurred. 959 */ 960 public void close(boolean pCloseUnderlying) throws IOException { 961 if (closed) { 962 return; 963 } 964 if (pCloseUnderlying) { 965 closed = true; 966 input.close(); 967 } else { 968 for (;;) { 969 int av = available(); 970 if (av == 0) { 971 av = makeAvailable(); 972 if (av == 0) { 973 break; 974 } 975 } 976 skip(av); 977 } 978 } 979 closed = true; 980 } 981 982 /** 983 * Skips the given number of bytes. 984 * 985 * @param bytes Number of bytes to skip. 986 * @return The number of bytes, which have actually been 987 * skipped. 988 * @throws IOException An I/O error occurred. 989 */ 990 @Override 991 public long skip(long bytes) throws IOException { 992 if (closed) { 993 throw new FileItemStream.ItemSkippedException(); 994 } 995 int av = available(); 996 if (av == 0) { 997 av = makeAvailable(); 998 if (av == 0) { 999 return 0; 1000 } 1001 } 1002 long res = Math.min(av, bytes); 1003 head += res; 1004 return res; 1005 } 1006 1007 /** 1008 * Attempts to read more data. 1009 * 1010 * @return Number of available bytes 1011 * @throws IOException An I/O error occurred. 1012 */ 1013 private int makeAvailable() throws IOException { 1014 if (pos != -1) { 1015 return 0; 1016 } 1017 1018 // Move the data to the beginning of the buffer. 1019 total += tail - head - pad; 1020 System.arraycopy(buffer, tail - pad, buffer, 0, pad); 1021 1022 // Refill buffer with new data. 1023 head = 0; 1024 tail = pad; 1025 1026 for (;;) { 1027 int bytesRead = input.read(buffer, tail, bufSize - tail); 1028 if (bytesRead == -1) { 1029 // The last pad amount is left in the buffer. 1030 // Boundary can't be in there so signal an error 1031 // condition. 1032 final String msg = "Stream ended unexpectedly"; 1033 throw new MalformedStreamException(msg); 1034 } 1035 if (notifier != null) { 1036 notifier.noteBytesRead(bytesRead); 1037 } 1038 tail += bytesRead; 1039 1040 findSeparator(); 1041 int av = available(); 1042 1043 if (av > 0 || pos != -1) { 1044 return av; 1045 } 1046 } 1047 } 1048 1049 /** 1050 * Returns, whether the stream is closed. 1051 * 1052 * @return True, if the stream is closed, otherwise false. 1053 */ 1054 @Override 1055 public boolean isClosed() { 1056 return closed; 1057 } 1058 1059 } 1060 1061}