framework/base/src/main/java/org/apache/ofbiz/base/util/HttpRequestFileUpload.java - ofbiz - Git at Google

 /*******************************************************************************
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.
  *******************************************************************************/

 package org.apache.ofbiz.base.util;


 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;

 import javax.servlet.ServletInputStream;
 import javax.servlet.http.HttpServletRequest;

 /**
  * HttpRequestFileUpload - Receive a file upload through an HttpServletRequest
  *
  */
 public class HttpRequestFileUpload {

     private int BUFFER_SIZE = 4096;
     private int WAIT_INTERVAL = 200; // in milliseconds
     private int MAX_WAITS = 20;
     private int waitCount = 0;
     private String savePath;
     private String filepath;
     private String filename;
     private String contentType;
     private String overrideFilename = null;
     private Map<String, String> fields;

     public String getOverrideFilename() {
         return overrideFilename;
     }

     public void setOverrideFilename(String ofName) {
         overrideFilename = ofName;
     }

     public String getFilename() {
         return filename;
     }

     public String getFilepath() {
         return filepath;
     }

     public void setSavePath(String savePath) {
         this.savePath = savePath;
     }

     public String getContentType() {
         return contentType;
     }

     public String getFieldValue(String fieldName) {
         if (fields == null || fieldName == null)
             return null;
         return fields.get(fieldName);
     }

     private void setFilename(String s) {
         if (s == null)
             return;

         int pos = s.indexOf("filename=\"");

         if (pos != -1) {
             filepath = s.substring(pos + 10, s.length() - 1);
             // Windows browsers include the full path on the client
             // But Linux/Unix and Mac browsers only send the filename
             // test if this is from a Windows browser
             pos = filepath.lastIndexOf("\\");
             if (pos != -1)
                 filename = filepath.substring(pos + 1);
             else
                 filename = filepath;
         }
     }

     private void setContentType(String s) {
         if (s == null)
             return;

         int pos = s.indexOf(": ");

         if (pos != -1)
             contentType = s.substring(pos + 2, s.length());
     }

     public void doUpload(HttpServletRequest request) throws IOException {
         ServletInputStream in = request.getInputStream();

         String reqLengthString = request.getHeader("content-length");

         System.out.println("expect " + reqLengthString + " bytes.");
         int requestLength = 0;

         try {
             requestLength = Integer.valueOf(reqLengthString).intValue();
         } catch (Exception e2) {
             e2.printStackTrace();
             return;
         }
         byte[] line = new byte[BUFFER_SIZE];

         int i = -1;

         i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
         requestLength -= i;
         if (i < 3)
             return;
         int boundaryLength = i - 2;

         String boundary = new String(line, 0, boundaryLength); // -2 discards the newline character

         System.out.println("boundary=[" + boundary + "] length is " + boundaryLength);
         fields = new HashMap<String, String>();

         while (requestLength > 0/* i != -1*/) {
             String newLine = "";

             if (i > -1) {
                 newLine = new String(line, 0, i);
             }
             if (newLine.startsWith("Content-Disposition: form-data; name=\"")) {
                 if (newLine.indexOf("filename=\"") != -1) {
                     setFilename(new String(line, 0, i - 2));
                     if (filename == null)
                         return;
                     // this is the file content
                     i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
                     requestLength -= i;

                     setContentType(new String(line, 0, i - 2));

                     // blank line
                     i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
                     requestLength -= i;
                     newLine = new String(line, 0, i);
                     String filenameToUse = filename;

                     if (overrideFilename != null) {
                         filenameToUse = overrideFilename;
                     }

                     // first line of actual file
                     i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
                     requestLength -= i;
                     newLine = new String(line, 0, i);

                     byte[] lastTwoBytes = new byte[2];

                     if (i > 1) {
                         lastTwoBytes[0] = line[i - 2];
                         lastTwoBytes[1] = line[i - 1];
                     }
                     System.out.println("about to create a file:" + (savePath == null ? "" : savePath) + filenameToUse);
                     // before creating the file make sure directory exists
                     File savePathFile = new File(savePath);
                     if (!savePathFile.exists()) {
                         savePathFile.mkdirs();
                     }
                     FileOutputStream fos = new FileOutputStream((savePath == null ? "" : savePath) + filenameToUse);
                     boolean bail = (new String(line, 0, i).startsWith(boundary));
                     boolean oneByteLine = (i == 1); // handle one-byte lines

                     while ((requestLength > 0/* i != -1*/) && !bail) {

                         // write the current buffer, except the last 2 bytes;
                         if (i > 1) {
                             fos.write(line, 0, i - 2);
                         }

                         oneByteLine = (i == 1); // we need to track on-byte lines differently

                         i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
                         requestLength -= i;

                         // the problem is the last line of the file content
                         // contains the new line character.

                         // if the line just read was the last line, we're done.
                         // if not, we must write the last 2 bytes of the previous buffer
                         // just assume that a one-byte line isn't the last line

                         if (requestLength < 1) {
                             bail = true;
                         } else if (oneByteLine) {
                             fos.write(lastTwoBytes, 0, 1); // we only saved one byte
                         } else {
                             fos.write(lastTwoBytes, 0, 2);
                         }

                         if (i > 1) {
                             // save the last 2 bytes of the buffer
                             lastTwoBytes[0] = line[i - 2];
                             lastTwoBytes[1] = line[i - 1];
                         } else {
                             lastTwoBytes[0] = line[0]; // only save one byte
                         }
                     }
                     fos.flush();
                     fos.close();
                 } else {
                     // this is a field
                     // get the field name
                     int pos = newLine.indexOf("name=\"");
                     String fieldName = newLine.substring(pos + 6, newLine.length() - 3);

                     // blank line
                     i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
                     requestLength -= i;
                     i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
                     requestLength -= i;
                     newLine = new String(line, 0, i);
                     StringBuilder fieldValue = new StringBuilder(BUFFER_SIZE);

                     while (requestLength > 0/* i != -1*/ && !newLine.startsWith(boundary)) {
                         // The last line of the field
                         // contains the new line character.
                         // So, we need to check if the current line is
                         // the last line.
                         i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
                         requestLength -= i;
                         if ((i == boundaryLength + 2 || i == boundaryLength + 4) // + 4 is eof
                             && (new String(line, 0, i).startsWith(boundary)))
                             fieldValue.append(newLine.substring(0, newLine.length() - 2));
                         else
                             fieldValue.append(newLine);
                         newLine = new String(line, 0, i);
                     }
                     fields.put(fieldName, fieldValue.toString());
                 }
             }
             i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
             if (i > -1) {
                 requestLength -= i;
             }

         } // end while
     }

     // reads a line, waiting if there is nothing available and reqLen > 0
     private int waitingReadLine(ServletInputStream in, byte[] buf, int off, int len, int reqLen) throws IOException {
         int i = -1;

         while (((i = in.readLine(buf, off, len)) == -1) && (reqLen > 0)) {
             System.out.print("waiting");
             if (waitCount > MAX_WAITS) {
                 System.out.println("waited " + waitCount + " times, bailing out while still expecting " +
                     reqLen + " bytes.");
                 throw new IOException("waited " + waitCount + " times, bailing out while still expecting " +
                         reqLen + " bytes.");
             }
             waitCount++;
             long endMS = new Date().getTime() + WAIT_INTERVAL;

             while (endMS > (new Date().getTime())) {
                 try {
                     wait(WAIT_INTERVAL);
                 } catch (Exception e3) {
                     System.out.print(".");
                 }
             }
             System.out.println((new Date().getTime() - endMS) + " ms");
         }
         return i;
     }
 }
	/*******************************************************************************
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.
	*******************************************************************************/

	package org.apache.ofbiz.base.util;


	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.util.Date;
	import java.util.HashMap;
	import java.util.Map;

	import javax.servlet.ServletInputStream;
	import javax.servlet.http.HttpServletRequest;

	/**
	* HttpRequestFileUpload - Receive a file upload through an HttpServletRequest
	*
	*/
	public class HttpRequestFileUpload {

	private int BUFFER_SIZE = 4096;
	private int WAIT_INTERVAL = 200; // in milliseconds
	private int MAX_WAITS = 20;
	private int waitCount = 0;
	private String savePath;
	private String filepath;
	private String filename;
	private String contentType;
	private String overrideFilename = null;
	private Map<String, String> fields;

	public String getOverrideFilename() {
	return overrideFilename;
	}

	public void setOverrideFilename(String ofName) {
	overrideFilename = ofName;
	}

	public String getFilename() {
	return filename;
	}

	public String getFilepath() {
	return filepath;
	}

	public void setSavePath(String savePath) {
	this.savePath = savePath;
	}

	public String getContentType() {
	return contentType;
	}

	public String getFieldValue(String fieldName) {
	if (fields == null \|\| fieldName == null)
	return null;
	return fields.get(fieldName);
	}

	private void setFilename(String s) {
	if (s == null)
	return;

	int pos = s.indexOf("filename=\"");

	if (pos != -1) {
	filepath = s.substring(pos + 10, s.length() - 1);
	// Windows browsers include the full path on the client
	// But Linux/Unix and Mac browsers only send the filename
	// test if this is from a Windows browser
	pos = filepath.lastIndexOf("\\");
	if (pos != -1)
	filename = filepath.substring(pos + 1);
	else
	filename = filepath;
	}
	}

	private void setContentType(String s) {
	if (s == null)
	return;

	int pos = s.indexOf(": ");

	if (pos != -1)
	contentType = s.substring(pos + 2, s.length());
	}

	public void doUpload(HttpServletRequest request) throws IOException {
	ServletInputStream in = request.getInputStream();

	String reqLengthString = request.getHeader("content-length");

	System.out.println("expect " + reqLengthString + " bytes.");
	int requestLength = 0;

	try {
	requestLength = Integer.valueOf(reqLengthString).intValue();
	} catch (Exception e2) {
	e2.printStackTrace();
	return;
	}
	byte[] line = new byte[BUFFER_SIZE];

	int i = -1;

	i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
	requestLength -= i;
	if (i < 3)
	return;
	int boundaryLength = i - 2;

	String boundary = new String(line, 0, boundaryLength); // -2 discards the newline character

	System.out.println("boundary=[" + boundary + "] length is " + boundaryLength);
	fields = new HashMap<String, String>();

	while (requestLength > 0/* i != -1*/) {
	String newLine = "";

	if (i > -1) {
	newLine = new String(line, 0, i);
	}
	if (newLine.startsWith("Content-Disposition: form-data; name=\"")) {
	if (newLine.indexOf("filename=\"") != -1) {
	setFilename(new String(line, 0, i - 2));
	if (filename == null)
	return;
	// this is the file content
	i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
	requestLength -= i;

	setContentType(new String(line, 0, i - 2));

	// blank line
	i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
	requestLength -= i;
	newLine = new String(line, 0, i);
	String filenameToUse = filename;

	if (overrideFilename != null) {
	filenameToUse = overrideFilename;
	}

	// first line of actual file
	i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
	requestLength -= i;
	newLine = new String(line, 0, i);

	byte[] lastTwoBytes = new byte[2];

	if (i > 1) {
	lastTwoBytes[0] = line[i - 2];
	lastTwoBytes[1] = line[i - 1];
	}
	System.out.println("about to create a file:" + (savePath == null ? "" : savePath) + filenameToUse);
	// before creating the file make sure directory exists
	File savePathFile = new File(savePath);
	if (!savePathFile.exists()) {
	savePathFile.mkdirs();
	}
	FileOutputStream fos = new FileOutputStream((savePath == null ? "" : savePath) + filenameToUse);
	boolean bail = (new String(line, 0, i).startsWith(boundary));
	boolean oneByteLine = (i == 1); // handle one-byte lines

	while ((requestLength > 0/* i != -1*/) && !bail) {

	// write the current buffer, except the last 2 bytes;
	if (i > 1) {
	fos.write(line, 0, i - 2);
	}

	oneByteLine = (i == 1); // we need to track on-byte lines differently

	i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
	requestLength -= i;

	// the problem is the last line of the file content
	// contains the new line character.

	// if the line just read was the last line, we're done.
	// if not, we must write the last 2 bytes of the previous buffer
	// just assume that a one-byte line isn't the last line

	if (requestLength < 1) {
	bail = true;
	} else if (oneByteLine) {
	fos.write(lastTwoBytes, 0, 1); // we only saved one byte
	} else {
	fos.write(lastTwoBytes, 0, 2);
	}

	if (i > 1) {
	// save the last 2 bytes of the buffer
	lastTwoBytes[0] = line[i - 2];
	lastTwoBytes[1] = line[i - 1];
	} else {
	lastTwoBytes[0] = line[0]; // only save one byte
	}
	}
	fos.flush();
	fos.close();
	} else {
	// this is a field
	// get the field name
	int pos = newLine.indexOf("name=\"");
	String fieldName = newLine.substring(pos + 6, newLine.length() - 3);

	// blank line
	i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
	requestLength -= i;
	i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
	requestLength -= i;
	newLine = new String(line, 0, i);
	StringBuilder fieldValue = new StringBuilder(BUFFER_SIZE);

	while (requestLength > 0/* i != -1*/ && !newLine.startsWith(boundary)) {
	// The last line of the field
	// contains the new line character.
	// So, we need to check if the current line is
	// the last line.
	i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
	requestLength -= i;
	if ((i == boundaryLength + 2 \|\| i == boundaryLength + 4) // + 4 is eof
	&& (new String(line, 0, i).startsWith(boundary)))
	fieldValue.append(newLine.substring(0, newLine.length() - 2));
	else
	fieldValue.append(newLine);
	newLine = new String(line, 0, i);
	}
	fields.put(fieldName, fieldValue.toString());
	}
	}
	i = waitingReadLine(in, line, 0, BUFFER_SIZE, requestLength);
	if (i > -1) {
	requestLength -= i;
	}

	} // end while
	}

	// reads a line, waiting if there is nothing available and reqLen > 0
	private int waitingReadLine(ServletInputStream in, byte[] buf, int off, int len, int reqLen) throws IOException {
	int i = -1;

	while (((i = in.readLine(buf, off, len)) == -1) && (reqLen > 0)) {
	System.out.print("waiting");
	if (waitCount > MAX_WAITS) {
	System.out.println("waited " + waitCount + " times, bailing out while still expecting " +
	reqLen + " bytes.");
	throw new IOException("waited " + waitCount + " times, bailing out while still expecting " +
	reqLen + " bytes.");
	}
	waitCount++;
	long endMS = new Date().getTime() + WAIT_INTERVAL;

	while (endMS > (new Date().getTime())) {
	try {
	wait(WAIT_INTERVAL);
	} catch (Exception e3) {
	System.out.print(".");
	}
	}
	System.out.println((new Date().getTime() - endMS) + " ms");
	}
	return i;
	}
	}