diff --git a/libx/commons-codec-1.3.License b/libx/commons-codec-1.3.License new file mode 100644 index 000000000..75b52484e --- /dev/null +++ b/libx/commons-codec-1.3.License @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/libx/commons-codec-1.3.jar b/libx/commons-codec-1.3.jar new file mode 100644 index 000000000..957b6752a Binary files /dev/null and b/libx/commons-codec-1.3.jar differ diff --git a/libx/jmimemagic-0.0.4a.jar b/libx/jmimemagic-0.0.4a.jar index a95d8c566..b3cbfea22 100644 Binary files a/libx/jmimemagic-0.0.4a.jar and b/libx/jmimemagic-0.0.4a.jar differ diff --git a/source/de/anomic/kelondro/kelondroTree.java b/source/de/anomic/kelondro/kelondroTree.java index 4b37325cc..c6ae259f3 100644 --- a/source/de/anomic/kelondro/kelondroTree.java +++ b/source/de/anomic/kelondro/kelondroTree.java @@ -218,7 +218,8 @@ public class kelondroTree extends kelondroRecords implements Comparator, kelondr try { otherkey = new String(thenode.getKey()); } catch (NullPointerException e) { - throw new kelondroException(filename, "kelondroTree.Search.process: nullpointer" + e.getMessage()); + throw new kelondroException(filename, "kelondroTree.Search.process: nullpointer" + e.getMessage() + + "\nNode: " + thenode.toString()); } if (visitedNodeKeys.containsKey(otherkey)) { // we have loops in the database. diff --git a/source/de/anomic/plasma/parser/bzip/bzipParser.java b/source/de/anomic/plasma/parser/bzip/bzipParser.java index 6475e8d4b..e9e378b81 100644 --- a/source/de/anomic/plasma/parser/bzip/bzipParser.java +++ b/source/de/anomic/plasma/parser/bzip/bzipParser.java @@ -63,8 +63,11 @@ public class bzipParser extends AbstractParser implements Parser { * @see #getSupportedMimeTypes() */ public static final Hashtable SUPPORTED_MIME_TYPES = new Hashtable(); + static String fileExtensions = "bz2,tbz,tbz2"; static { - SUPPORTED_MIME_TYPES.put("application/x-bzip2","bz2,tbz,tbz2"); + SUPPORTED_MIME_TYPES.put("application/x-bzip2",fileExtensions); + SUPPORTED_MIME_TYPES.put("application/bzip2", fileExtensions); + SUPPORTED_MIME_TYPES.put("application/x-bz2", fileExtensions); } /** diff --git a/source/de/anomic/plasma/parser/vcf/build.xml b/source/de/anomic/plasma/parser/vcf/build.xml new file mode 100644 index 000000000..f40c34538 --- /dev/null +++ b/source/de/anomic/plasma/parser/vcf/build.xml @@ -0,0 +1,55 @@ + + + + A class to parse vCard files + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/source/de/anomic/plasma/parser/vcf/vcfParser.java b/source/de/anomic/plasma/parser/vcf/vcfParser.java new file mode 100644 index 000000000..258deb41e --- /dev/null +++ b/source/de/anomic/plasma/parser/vcf/vcfParser.java @@ -0,0 +1,267 @@ +//vcfParser.java +//------------------------ +//part of YaCy +//(C) by Michael Peter Christen; mc@anomic.de +//first published on http://www.anomic.de +//Frankfurt, Germany, 2005 +// +//this file is contributed by Martin Thelian +//last major change: 20.11.2005 +// +//This program is free software; you can redistribute it and/or modify +//it under the terms of the GNU General Public License as published by +//the Free Software Foundation; either version 2 of the License, or +//(at your option) any later version. +// +//This program is distributed in the hope that it will be useful, +//but WITHOUT ANY WARRANTY; without even the implied warranty of +//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +//GNU General Public License for more details. +// +//You should have received a copy of the GNU General Public License +//along with this program; if not, write to the Free Software +//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +//Using this software in any meaning (reading, learning, copying, compiling, +//running) means that you agree that the Author(s) is (are) not responsible +//for cost, loss of data or any harm that may be caused directly or indirectly +//by usage of this softare or this documentation. The usage of this software +//is on your own risk. The installation and usage (starting/running) of this +//software may allow other people or application to access your computer and +//any attached devices and is highly dependent on the configuration of the +//software which must be done by the user of the software; the author(s) is +//(are) also not responsible for proper configuration and usage of the +//software, even if provoked by documentation provided together with +//the software. +// +//Any changes to this file according to the GPL as documented in the file +//gpl.txt aside this file in the shipment you received can be done to the +//lines that follows this copyright notice here, but changes must not be +//done inside the copyright notive above. A re-distribution must contain +//the intact and unchanged copyright notice. +//Contributions and changes to the program code must be marked as such. + +package de.anomic.plasma.parser.vcf; + +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.net.MalformedURLException; +import java.net.URL; +import java.util.HashMap; +import java.util.Hashtable; +import java.util.Iterator; +import java.util.LinkedList; + +import org.apache.commons.codec.net.QuotedPrintableCodec; + +import de.anomic.http.httpc; +import de.anomic.plasma.plasmaParserDocument; +import de.anomic.plasma.parser.AbstractParser; +import de.anomic.plasma.parser.Parser; +import de.anomic.plasma.parser.ParserException; +import de.anomic.server.serverCodings; + +/** + * Vcard specification: http://www.imc.org/pdi/vcard-21.txt + * @author theli + * + */ +public class vcfParser extends AbstractParser implements Parser { + + /** + * a list of mime types that are supported by this parser class + * @see #getSupportedMimeTypes() + */ + public static final Hashtable SUPPORTED_MIME_TYPES = new Hashtable(); + static { + SUPPORTED_MIME_TYPES.put("text/x-vcard","vcf"); + SUPPORTED_MIME_TYPES.put("application/vcard","vcf"); + } + + /** + * a list of library names that are needed by this parser + * @see Parser#getLibxDependences() + */ + private static final String[] LIBX_DEPENDENCIES = new String[] {"commons-codec-1.3.jar"}; + + public vcfParser() { + super(LIBX_DEPENDENCIES); + } + + public Hashtable getSupportedMimeTypes() { + return SUPPORTED_MIME_TYPES; + } + + public plasmaParserDocument parse(URL location, String mimeType, InputStream source) throws ParserException { + + try { + StringBuffer parsedTitle = new StringBuffer(); + StringBuffer parsedDataText = new StringBuffer(); + HashMap parsedData = new HashMap(); + HashMap anchors = new HashMap(); + LinkedList parsedNames = new LinkedList(); + + boolean useLastLine = false; + int lineNr = 0; + String line = null; + BufferedReader inputReader = new BufferedReader(new InputStreamReader(source)); + while (true) { + if (!useLastLine) { + line = inputReader.readLine(); + } else { + useLastLine = false; + } + + if (line == null) break; + else if (line.length() == 0) continue; + + lineNr++; + int pos = line.indexOf(":"); + if (pos != -1) { + String key = line.substring(0,pos).trim().toUpperCase(); + String value = line.substring(pos+1).trim(); + + String encoding = null; + String[] keyParts = key.split(";"); + if (keyParts.length > 1) { + for (int i=0; i < keyParts.length; i++) { + if (keyParts[i].toUpperCase().startsWith("ENCODING")) { + encoding = keyParts[i].substring("ENCODING".length()+1); + } else if (keyParts[i].toUpperCase().startsWith("QUOTED-PRINTABLE")) { + encoding = "QUOTED-PRINTABLE"; + } else if (keyParts[i].toUpperCase().startsWith("BASE64")) { + encoding = "BASE64"; + } + + } + if (encoding != null) { + try { + if (encoding.equalsIgnoreCase("QUOTED-PRINTABLE")) { + // if the value has multiple lines ... + if (line.endsWith("=")) { + do { + value = value.substring(0,value.length()-1); + line = inputReader.readLine(); + if (line == null) break; + value += line; + } while (line.endsWith("=")); + } + value = (new QuotedPrintableCodec()).decode(value); + } else if (encoding.equalsIgnoreCase("base64")) { + do { + line = inputReader.readLine(); + if (line == null) break; + if (line.indexOf(":")!= -1) { + // we have detected an illegal block end of the base64 data + useLastLine = true; + } + if (!useLastLine) value += line.trim(); + else break; + } while (line.length()!=0); + value = serverCodings.standardCoder.decodeBase64String(value); + } + } catch (Exception ey) { + // Encoding error: This could occure e.g. if the base64 doesn't + // end with an empty newline + // + // We can simply ignore it. + } + } + } + + if (key.equalsIgnoreCase("END")) { + String name = null, title = null; + + // using the name of the current persion as section headline + if (parsedData.containsKey("FN")) { + parsedNames.add(name = (String)parsedData.get("FN")); + } else if (parsedData.containsKey("N")) { + parsedNames.add(name = (String)parsedData.get("N")); + } else { + parsedNames.add(name = "unknown name"); + } + + // getting the vcard title + if (parsedData.containsKey("TITLE")) { + parsedNames.add(title = (String) parsedData.get("TITLE")); + } + + if (parsedTitle.length() > 0) parsedTitle.append(", "); + parsedTitle.append((title==null)?name:name + " - " + title); + + + // looping through the properties and add there values to + // the text representation of the vCard + Iterator iter = parsedData.values().iterator(); + while (iter.hasNext()) { + value = (String) iter.next(); + parsedDataText.append(value).append("\r\n"); + } + parsedDataText.append("\r\n"); + parsedData.clear(); + } else if (key.toUpperCase().startsWith("URL")) { + try { + URL newURL = new URL(value); + anchors.put(newURL.toString(),newURL.toString()); + //parsedData.put(key,value); + } catch (MalformedURLException ex) {} + } else if ( + !key.equalsIgnoreCase("BEGIN") && + !key.equalsIgnoreCase("END") && + !key.equalsIgnoreCase("VERSION") && + !key.toUpperCase().startsWith("LOGO") && + !key.toUpperCase().startsWith("PHOTO") && + !key.toUpperCase().startsWith("SOUND") && + !key.toUpperCase().startsWith("KEY") && + !key.toUpperCase().startsWith("X-") + ) { + // value = value.replaceAll(";","\t"); + if ((value.length() > 0)) parsedData.put(key, value); + } + + } else { + this.theLogger.logFinest("Invalid data in vcf file" + + "\n\tURL: " + location + + "\n\tLine: " + line + + "\n\tLine-Nr: " + lineNr); + } + } + + plasmaParserDocument theDoc = new plasmaParserDocument( + location, + mimeType, + null, + null, + parsedTitle.toString(), + (String[]) parsedNames.toArray(new String[parsedNames.size()]), + "vCard", + parsedDataText.toString().getBytes(), + anchors, + null); + return theDoc; + } catch (Exception e) { + throw new ParserException("Unable to parse the vcard content. " + e.getMessage()); + } finally { + } + } + + public void reset() { + // Nothing todo here at the moment + + } + + public static void main(String[] args) { + try { + URL contentUrl = new URL(args[0]); + + vcfParser testParser = new vcfParser(); + byte[] content = httpc.singleGET(contentUrl, 10000, null, null, null); + ByteArrayInputStream input = new ByteArrayInputStream(content); + testParser.parse(contentUrl, "text/x-vcard", input); + } catch (Exception e) { + e.printStackTrace(); + } + } +} diff --git a/source/de/anomic/plasma/parser/zip/zipParser.java b/source/de/anomic/plasma/parser/zip/zipParser.java index 146721f4a..fa5cd2388 100644 --- a/source/de/anomic/plasma/parser/zip/zipParser.java +++ b/source/de/anomic/plasma/parser/zip/zipParser.java @@ -70,6 +70,8 @@ public class zipParser extends AbstractParser implements Parser { public static final Hashtable SUPPORTED_MIME_TYPES = new Hashtable(); static { SUPPORTED_MIME_TYPES.put("application/zip","zip"); + SUPPORTED_MIME_TYPES.put("application/x-zip","zip"); + SUPPORTED_MIME_TYPES.put("application/x-zip-compressed","zip"); SUPPORTED_MIME_TYPES.put("application/java-archive","jar"); } diff --git a/source/de/anomic/plasma/plasmaParser.java b/source/de/anomic/plasma/plasmaParser.java index 1c9af0da2..38ffb529d 100644 --- a/source/de/anomic/plasma/plasmaParser.java +++ b/source/de/anomic/plasma/plasmaParser.java @@ -282,7 +282,7 @@ public final class plasmaParser { } } - public static boolean supportedFileExt(URL url) { + public static String getFileExt(URL url) { // getting the file path String name = url.getFile(); @@ -299,9 +299,15 @@ public final class plasmaParser { } // termining last position of . in file path - p = (p != -1) ? name.lastIndexOf('.',p) : name.lastIndexOf('.'); - if (p < 0) return true; // seams to be strange, but this is a directory entry or default file (html) - return supportedFileExtContains(name.substring(p + 1)); + p = name.lastIndexOf('.'); + if (p < 0) return name; // seams to be strange, but this is a directory entry or default file (html) + return name.substring(p + 1); + } + + public static boolean supportedFileExt(URL url) { + // getting the file path + String name = getFileExt(url); + return supportedFileExtContains(name); } public static boolean supportedFileExtContains(String fileExt) { @@ -503,7 +509,7 @@ public final class plasmaParser { String mimeType = (String) mimeTypeIterator.next(); availableParserList.put(mimeType,fullClassName); serverLog.logInfo("PARSER", "Found functional parser for mimeType '" + mimeType + "'." + - ((neededLibxBuf.length()>0)?"\nDependencies: " + neededLibxBuf.toString():"")); + ((neededLibxBuf.length()>0)?"\n Dependencies: " + neededLibxBuf.toString():"")); } } catch (Exception e) { /* we can ignore this for the moment */ @@ -536,9 +542,21 @@ public final class plasmaParser { Parser theParser = null; try { mimeType = getRealMimeType(mimeType); + String fileExt = getFileExt(location); + + // TODO: Handling of not trustable mimeTypes + // text/plain, octet-stream + if ( + (mimeType.equalsIgnoreCase("text/plain") && !fileExt.equalsIgnoreCase("txt")) || + (mimeType.equalsIgnoreCase("text/xml") && !fileExt.equalsIgnoreCase("txt")) + ) { + if (enabledParserList.containsKey("application/octet-stream")) { + mimeType = "application/octet-stream"; + } + } // getting the correct parser for the given mimeType - theParser = this.getParser(mimeType); + theParser = this.getParser(mimeType); // if a parser was found we use it ... if (theParser != null) { @@ -568,6 +586,18 @@ public final class plasmaParser { Parser theParser = null; try { mimeType = getRealMimeType(mimeType); + String fileExt = getFileExt(location); + + // TODO: Handling of not trustable mimeTypes + // text/plain, octet-stream + if ( + (mimeType.equalsIgnoreCase("text/plain") && !fileExt.equalsIgnoreCase("txt")) || + (mimeType.equalsIgnoreCase("text/xml") && !fileExt.equalsIgnoreCase("txt")) + ) { + if (enabledParserList.containsKey("application/octet-stream")) { + mimeType = "application/octet-stream"; + } + } // getting the correct parser for the given mimeType theParser = this.getParser(mimeType); @@ -712,7 +742,26 @@ public final class plasmaParser { //File out = new File(args[1]); plasmaParser theParser = new plasmaParser(); plasmaParser.initRealtimeParsableMimeTypes("application/xhtml+xml,text/html,text/plain"); - plasmaParser.initParseableMimeTypes("application/atom+xml,application/gzip,application/java-archive,application/msword,application/octet-stream,application/pdf,application/rdf+xml,application/rss+xml,application/rtf,application/x-gzip,application/x-tar,application/xml,application/zip,text/rss,text/rtf,text/xml,application/x-bzip2,application/postscript"); + plasmaParser.initParseableMimeTypes( + "application/atom+xml," + + "application/gzip," + + "application/java-archive," + + "application/msword," + + "application/octet-stream," + + "application/pdf," + + "application/rdf+xml," + + "application/rss+xml," + + "application/rtf," + + "application/x-gzip," + + "application/x-tar," + + "application/xml," + + "application/zip," + + "text/rss," + + "text/rtf," + + "text/xml," + + "application/x-bzip2," + + "application/postscript," + + "text/x-vcard"); FileInputStream theInput = new FileInputStream(in); ByteArrayOutputStream theOutput = new ByteArrayOutputStream(); serverFileUtils.copy(theInput, theOutput);