001: package de.jwic.upload;
002:
003: import java.io.BufferedOutputStream;
004: import java.io.ByteArrayOutputStream;
005: import java.io.File;
006: import java.io.FileOutputStream;
007: import java.io.IOException;
008: import java.io.OutputStream;
009: import java.util.HashMap;
010: import java.util.Map;
011:
012: import javax.servlet.http.HttpServletRequest;
013:
014: /**
015: * Standard Upload
016: */
017:
018: public class Upload {
019:
020: private static final int DEFAULT_MAX_POST_SIZE = 1024 * 1024; // 1 Meg
021: private static final int DEFAULT_MEMORY_USAGE = 1 * 1024 * 1024; // 1 Meg
022: private static final String FIELD_PREFIX = "FLD";
023: private HashMap htFieldValue = null;
024: private HashMap htFields = null;
025: private HashMap htFiles = null;
026: private HashMap htParams = null;
027: private static final String FIELD_ORGFILENAME_SUFFIX = "@@ORGFILENAME";
028: private static final String FIELD_TYPE_SUFFIX = "@@TYPE";
029: private boolean lostConnection = false;
030:
031: /**
032: * Standard Upload
033: * @param req javax.servlet.http.HttpServletRequest
034: * @param sDirSave java.lang.String Zielverzeichnis
035: * @param sFileName java.lang.String Zielname der Datei
036: * @param maxPostSize int max. Dateigröße für die ein Upload getätigt werden soll.
037: * @exception java.io.IOException
038: */
039:
040: public Upload(HttpServletRequest req) throws IOException {
041: this (req, ".", DEFAULT_MAX_POST_SIZE, DEFAULT_MEMORY_USAGE);
042: }
043:
044: /**
045: * Standard Upload
046: * @param req javax.servlet.http.HttpServletRequest
047: * @param sDirSave java.lang.String Zielverzeichnis
048: * @param sFileName java.lang.String Zielname der Datei
049: * @param maxPostSize int max. Dateigröße für die ein Upload getätigt werden soll.
050: * @exception java.io.IOException
051: */
052:
053: public Upload(HttpServletRequest req, long maxPostSize)
054: throws IOException {
055: this (req, ".", maxPostSize, DEFAULT_MEMORY_USAGE);
056: }
057:
058: /**
059: * Standard Upload
060: * @param req javax.servlet.http.HttpServletRequest
061: * @param sDirSave java.lang.String
062: * @exception java.io.IOException
063: * @deprecated
064: */
065: public Upload(HttpServletRequest req, String sDirSave)
066: throws IOException {
067:
068: this (req, sDirSave, DEFAULT_MAX_POST_SIZE);
069:
070: }
071:
072: /**
073: * Standard Upload
074: * @param req javax.servlet.http.HttpServletRequest
075: * @param sDirSave java.lang.String Zielverzeichnis
076: * @param maxPostSize int max. Dateigröße für die ein Upload getätigt werden soll.
077: * @exception java.io.IOException
078: * @deprecated
079: */
080: public Upload(HttpServletRequest req, String sDirSave,
081: long maxPostSize) throws IOException {
082:
083: this (req, sDirSave, null, maxPostSize);
084: }
085:
086: /**
087: * Standard Upload
088: * @param req javax.servlet.http.HttpServletRequest
089: * @param sDirSave java.lang.String Temporäres Arbeitsverzeichnis
090: * @param maxPostSize int max. Dateigröße für die ein Upload getätigt werden soll.
091: * @param memoryUsage int max. Speichernutzung, bei überschreiten wird eine temp. Datei erstellt
092: * @exception java.io.IOException
093: */
094:
095: public Upload(HttpServletRequest req, String sDirSave,
096: long maxPostSize, int memoryUsage) throws IOException {
097:
098: String FieldName = null;
099: String FieldValue = null;
100:
101: // Allgemeine Überprüfungen
102: if (req == null)
103: throw new IllegalArgumentException("request cannot be null");
104: if (sDirSave == null)
105: throw new IllegalArgumentException(
106: "saveDirectory cannot be null");
107: if (maxPostSize <= 0)
108: throw new IllegalArgumentException(
109: "maxPostSize must be positive");
110: if (memoryUsage <= 0)
111: throw new IllegalArgumentException(
112: "memoryUsage must be positive");
113:
114: // Save Directory generieren
115: File fDir = new File(sDirSave);
116:
117: // Überprüfen ob File ein Directory ist
118: if (!fDir.isDirectory())
119: fDir.mkdirs();
120:
121: // Überprüfen ob in Directory geschrieben werden kann
122: if (!fDir.canWrite())
123: throw new IOException("Not writable: " + sDirSave);
124:
125: //InputStream parsen
126: ContentParser parser = new ContentParser(req, maxPostSize);
127: Content content = null;
128:
129: //HashMap für Felder und Inhalt definieren
130: htFieldValue = new HashMap();
131: htFields = new HashMap();
132: htFiles = new HashMap();
133: htParams = new HashMap();
134:
135: while ((content = parser.readNextContent()) != null) {
136: if (content.isFile()) {
137: String fileName = content.getFileName();
138: if (fileName != null) {
139: FieldName = content.getFieldName();
140: htFieldValue.put(FieldName.substring(FIELD_PREFIX
141: .length())
142: + FIELD_ORGFILENAME_SUFFIX, fileName);
143:
144: UploadFile upFile = new UploadFile();
145: upFile.setPath(sDirSave);
146: upFile.setName(fileName);
147: File tmpFile = write(upFile.getOutputStream(),
148: content, memoryUsage);
149:
150: if (tmpFile != null) {
151: upFile.setTmpFile(tmpFile);
152: if (lostConnection)
153: tmpFile.delete();
154: }
155:
156: htFiles.put(content.getFieldName(), upFile);
157:
158: FieldValue = fileName;
159: }
160: } else {
161: FieldValue = getValue(content);
162: }
163:
164: if (!content.isFile()) {
165: htParams.put(content.getFieldName(), FieldValue);
166: }
167: }
168: }
169:
170: /**
171: * Standard Upload
172: * @param req javax.servlet.http.HttpServletRequest
173: * @param sDirSave java.lang.String Zielverzeichnis
174: * @param sFileName java.lang.String Zielname der Datei
175: * @exception java.io.IOException
176: * @deprecated
177: */
178: public Upload(HttpServletRequest req, String sDirSave,
179: String sFileName) throws IOException {
180:
181: this (req, sDirSave, sFileName, DEFAULT_MAX_POST_SIZE);
182: }
183:
184: /**
185: * Standard Upload
186: * @param req javax.servlet.http.HttpServletRequest
187: * @param sDirSave java.lang.String Zielverzeichnis
188: * @param sFileName java.lang.String Zielname der Datei
189: * @param maxPostSize int max. Dateigröße für die ein Upload getätigt werden soll.
190: * @exception java.io.IOException
191: * @deprecated
192: */
193:
194: public Upload(HttpServletRequest req, String sDirSave,
195: String sFileName, long maxPostSize) throws IOException {
196:
197: String FieldName = null;
198: String FieldValue = null;
199:
200: // Allgemeine Überprüfungen
201: if (req == null)
202: throw new IllegalArgumentException("request cannot be null");
203: if (sDirSave == null)
204: throw new IllegalArgumentException(
205: "saveDirectory cannot be null");
206: if (maxPostSize <= 0) {
207: throw new IllegalArgumentException(
208: "maxPostSize must be positive");
209: }
210:
211: // Save Directory generieren
212: File fDir = new File(sDirSave);
213:
214: // Überprüfen ob File ein Directory ist
215: if (!fDir.isDirectory())
216: fDir.mkdirs();
217:
218: // Überprüfen ob in Directory geschrieben werden kann
219: if (!fDir.canWrite())
220: throw new IOException("Not writable: " + sDirSave);
221:
222: //InputStream parsen
223: ContentParser parser = new ContentParser(req, maxPostSize);
224: Content content = null;
225:
226: //HashMap für Felder und Inhalt definieren
227: htFieldValue = new HashMap();
228: htFields = new HashMap();
229: htParams = new HashMap();
230:
231: while ((content = parser.readNextContent()) != null) {
232: if (content.isFile()) {
233: String fileName = content.getFileName();
234: if (fileName != null) {
235: FieldName = content.getFieldName().toUpperCase();
236: htFieldValue.put(FieldName.substring(FIELD_PREFIX
237: .length())
238: + FIELD_ORGFILENAME_SUFFIX, fileName);
239: if (sFileName != null)
240: fileName = sFileName
241: + fileName.substring(fileName
242: .lastIndexOf("."));
243: writeTo(fDir, content, fileName);
244: FieldValue = fileName;
245: }
246: } else {
247: FieldValue = getValue(content);
248: }
249:
250: if (!content.isFile()) {
251: htParams.put(content.getFieldName(), FieldValue);
252: }
253: }
254: }
255:
256: /**
257: * Sollte neben dem Dateiupload noch weitere Felder in dem HTML - Formular
258: * gewesen sein sollen, dann können Sie über diese Methode auf die Felder
259: * und deren Inhalte zugreifen.
260: * @param sFieldName java.lang.String
261: */
262: public double getFieldDouble(String sFieldName) {
263:
264: String value = (String) htFieldValue.get(sFieldName
265: .toUpperCase());
266: if (value != null)
267: return new Double(value).doubleValue();
268: return 0;
269:
270: }
271:
272: /**
273: * Sollte neben dem Dateiupload noch weitere Felder in dem HTML - Formular
274: * gewesen sein sollen, dann können Sie über diese Methode auf die Felder
275: * und deren Inhalte zugreifen.
276: * @param sFieldName java.lang.String
277: */
278: public int getFieldInteger(String sFieldName) {
279:
280: String value = (String) htFieldValue.get(sFieldName
281: .toUpperCase());
282: if (value != null)
283: return new Integer(value).intValue();
284: return 0;
285:
286: }
287:
288: /**
289: * Feld Datentyp
290: * Erstellungsdatum: (08.03.01 19:41:46)
291: * @param sFieldName java.lang.String
292: */
293: public Map getFields() {
294: return htFields;
295: }
296:
297: /**
298: * Gibt die parameter zurück welche nicht als Felder eingelesen wurden.
299: */
300: public Map getParams() {
301: return htParams;
302: }
303:
304: /**
305: * Sollte neben dem Dateiupload noch weitere Felder in dem HTML - Formular
306: * gewesen sein sollen, dann können Sie über diese Methode auf die Felder
307: * und deren Inhalte zugreifen.
308: * @param sFieldName java.lang.String
309: */
310: public String getFieldString(String sFieldName) {
311:
312: return (String) htFieldValue.get(sFieldName.toUpperCase());
313:
314: }
315:
316: /**
317: * Feld Datentyp
318: * Erstellungsdatum: (08.03.01 19:41:46)
319: * @param sFieldName java.lang.String
320: */
321: public Integer getFieldType(String sFieldName) {
322: return (Integer) htFieldValue.get(sFieldName.toUpperCase()
323: + FIELD_TYPE_SUFFIX);
324: }
325:
326: /**
327: * Liest den Inhalt eines Feldes aus.
328: * Erstellungsdatum: (08.03.01 19:41:46)
329: */
330:
331: public Map getFiles() {
332: return htFiles;
333: }
334:
335: /**
336: * Gibt den Namen der Datei an.
337: * Erstellungsdatum: (08.03.01 19:41:46)
338: * @param sFieldName java.lang.String
339: */
340: public String getOrgFileName(String sFieldName) {
341: return getFieldString(sFieldName + FIELD_ORGFILENAME_SUFFIX);
342: }
343:
344: /**
345: * Liest den Inhalt eines Feldes aus.
346: * Erstellungsdatum: (08.03.01 19:41:46)
347: */
348:
349: private String getValue(Content content) throws IOException {
350:
351: ByteArrayOutputStream baOutStream = null;
352: byte[] buf = new byte[128];
353: int read = 0;
354:
355: baOutStream = new ByteArrayOutputStream(512);
356:
357: while ((read = content.read(buf)) != -1) {
358: baOutStream.write(buf, 0, read);
359: }
360:
361: content.close();
362: baOutStream.close();
363:
364: // save it for later
365: return baOutStream.toString("ISO-8859-1");
366: }
367:
368: /**
369: * Sollte neben dem Dateiupload noch weitere Felder in dem HTML - Formular
370: * gewesen sein sollen, dann können Sie über diese Methode auf die Felder
371: * und deren Inhalte zugreifen.
372: * @param sFieldName java.lang.String
373: */
374: public void setFieldString(String sFieldName, String sValue) {
375:
376: htFieldValue.put(sFieldName, sValue);
377:
378: }
379:
380: /**
381: * Schreibt die Datei in den Outputstream
382: * Erstellungsdatum: (08.03.01 19:41:46)
383: * @param out java.io.OutputStream
384: */
385:
386: private long write(OutputStream out, Content content)
387: throws IOException {
388:
389: long size = 0;
390: int read;
391: byte[] buf = new byte[64 * 1024];
392: while ((read = content.read(buf)) != -1) {
393: out.write(buf, 0, read);
394: size += read;
395: }
396: return size;
397: }
398:
399: /**
400: * Schreibt die Datei in den Outputstream
401: * Erstellungsdatum: (08.03.01 19:41:46)
402: * @param out java.io.OutputStream
403: */
404:
405: private File write(OutputStream out, Content content,
406: int memoryUsage) throws IOException {
407:
408: File tmpFile = null;
409: long size = 0;
410: int read = 0;
411: byte[] buf = new byte[memoryUsage];
412:
413: try {
414: try {
415: while ((read = content.read(buf)) != -1) {
416: size += read;
417: if (size >= memoryUsage) {
418: // store it in a new temporary file since max memory usage is reached
419: if (tmpFile == null) {
420: tmpFile = File.createTempFile("UPLOAD",
421: ".FILE");
422: out = new FileOutputStream(tmpFile);
423: }
424: }
425: out.write(buf, 0, read);
426: }
427: } catch (java.net.SocketException se) {
428: // server lost client
429: lostConnection = true;
430: }
431:
432: } finally {
433: if (tmpFile != null) {
434: out.flush();
435: out.close();
436: }
437: }
438: return tmpFile;
439: }
440:
441: /**
442: * Schreibt die Datei in das Zielverzeichnis
443: * Erstellungsdatum: (08.03.01 19:41:46)
444: * @param fileOrDirectory java.io.File
445: * @param sFieldName java.lang.String
446: */
447: private File writeTo(File fileOrDirectory, Content content,
448: String fileName) throws IOException {
449:
450: OutputStream fileOut = null;
451: File file = null;
452:
453: try {
454: if (fileName != null) {
455:
456: if (fileOrDirectory.isDirectory()) {
457: file = new File(fileOrDirectory, fileName);
458: } else {
459: file = fileOrDirectory;
460: }
461:
462: fileOut = new BufferedOutputStream(
463: new FileOutputStream(file));
464: write(fileOut, content);
465:
466: }
467: }
468:
469: finally {
470: if (fileOut != null)
471: fileOut.close();
472: }
473:
474: return file;
475:
476: }
477: }
|