2 * Copyright (C) 2004, 2006, 2008, 2011 Apple Inc. All rights reserved.
3 * Copyright (C) 2009 Google Inc. All rights reserved.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
15 * You should have received a copy of the GNU Library General Public License
16 * along with this library; see the file COPYING.LIB. If not, write to
17 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
28 #include "ChromeClient.h"
31 #include "FileSystem.h"
32 #include "FormDataBuilder.h"
33 #include "FormDataList.h"
34 #include "MIMETypeRegistry.h"
36 #include "TextEncoding.h"
37 #include <wtf/Decoder.h>
38 #include <wtf/Encoder.h>
42 inline FormData::FormData()
44 , m_hasGeneratedFiles(false)
45 , m_alwaysStream(false)
49 inline FormData::FormData(const FormData& data)
50 : RefCounted<FormData>()
51 , m_elements(data.m_elements)
52 , m_identifier(data.m_identifier)
53 , m_hasGeneratedFiles(false)
54 , m_alwaysStream(false)
56 // We shouldn't be copying FormData that hasn't already removed its generated files
57 // but just in case, make sure the new FormData is ready to generate its own files.
58 if (data.m_hasGeneratedFiles) {
59 size_t n = m_elements.size();
60 for (size_t i = 0; i < n; ++i) {
61 FormDataElement& e = m_elements[i];
62 if (e.m_type == FormDataElement::encodedFile)
63 e.m_generatedFilename = String();
70 // This cleanup should've happened when the form submission finished.
71 // Just in case, let's assert, and do the cleanup anyway in release builds.
72 ASSERT(!m_hasGeneratedFiles);
73 removeGeneratedFilesIfNeeded();
76 PassRefPtr<FormData> FormData::create()
78 return adoptRef(new FormData);
81 PassRefPtr<FormData> FormData::create(const void* data, size_t size)
83 RefPtr<FormData> result = create();
84 result->appendData(data, size);
85 return result.release();
88 PassRefPtr<FormData> FormData::create(const CString& string)
90 RefPtr<FormData> result = create();
91 result->appendData(string.data(), string.length());
92 return result.release();
95 PassRefPtr<FormData> FormData::create(const Vector<char>& vector)
97 RefPtr<FormData> result = create();
98 result->appendData(vector.data(), vector.size());
99 return result.release();
102 PassRefPtr<FormData> FormData::create(const FormDataList& list, const TextEncoding& encoding)
104 RefPtr<FormData> result = create();
105 result->appendKeyValuePairItems(list, encoding, false, 0);
106 return result.release();
109 PassRefPtr<FormData> FormData::createMultiPart(const FormDataList& list, const TextEncoding& encoding, Document* document)
111 RefPtr<FormData> result = create();
112 result->appendKeyValuePairItems(list, encoding, true, document);
113 return result.release();
116 PassRefPtr<FormData> FormData::copy() const
118 return adoptRef(new FormData(*this));
121 PassRefPtr<FormData> FormData::deepCopy() const
123 RefPtr<FormData> formData(create());
125 formData->m_alwaysStream = m_alwaysStream;
127 size_t n = m_elements.size();
128 formData->m_elements.reserveInitialCapacity(n);
129 for (size_t i = 0; i < n; ++i) {
130 const FormDataElement& e = m_elements[i];
132 case FormDataElement::data:
133 formData->m_elements.append(FormDataElement(e.m_data));
135 case FormDataElement::encodedFile:
137 formData->m_elements.append(FormDataElement(e.m_filename, e.m_fileStart, e.m_fileLength, e.m_expectedFileModificationTime, e.m_shouldGenerateFile));
139 formData->m_elements.append(FormDataElement(e.m_filename, e.m_shouldGenerateFile));
143 case FormDataElement::encodedBlob:
144 formData->m_elements.append(FormDataElement(e.m_blobURL));
149 return formData.release();
152 void FormData::appendData(const void* data, size_t size)
154 if (m_elements.isEmpty() || m_elements.last().m_type != FormDataElement::data)
155 m_elements.append(FormDataElement());
156 FormDataElement& e = m_elements.last();
157 size_t oldSize = e.m_data.size();
158 e.m_data.grow(oldSize + size);
159 memcpy(e.m_data.data() + oldSize, data, size);
162 void FormData::appendFile(const String& filename, bool shouldGenerateFile)
165 m_elements.append(FormDataElement(filename, 0, BlobDataItem::toEndOfFile, BlobDataItem::doNotCheckFileChange, shouldGenerateFile));
167 m_elements.append(FormDataElement(filename, shouldGenerateFile));
172 void FormData::appendFileRange(const String& filename, long long start, long long length, double expectedModificationTime, bool shouldGenerateFile)
174 m_elements.append(FormDataElement(filename, start, length, expectedModificationTime, shouldGenerateFile));
177 void FormData::appendBlob(const KURL& blobURL)
179 m_elements.append(FormDataElement(blobURL));
183 void FormData::appendKeyValuePairItems(const FormDataList& list, const TextEncoding& encoding, bool isMultiPartForm, Document* document)
186 m_boundary = FormDataBuilder::generateUniqueBoundaryString();
188 Vector<char> encodedData;
190 const Vector<FormDataList::Item>& items = list.items();
191 size_t formDataListSize = items.size();
192 ASSERT(!(formDataListSize % 2));
193 for (size_t i = 0; i < formDataListSize; i += 2) {
194 const FormDataList::Item& key = items[i];
195 const FormDataList::Item& value = items[i + 1];
196 if (isMultiPartForm) {
198 FormDataBuilder::beginMultiPartHeader(header, m_boundary.data(), key.data());
200 bool shouldGenerateFile = false;
202 // If the current type is blob, then we also need to include the filename
205 if (value.blob()->isFile()) {
206 // For file blob, use the filename (or relative path if it is present) as the name.
207 File* file = static_cast<File*>(value.blob());
208 #if ENABLE(DIRECTORY_UPLOAD)
209 name = file->webkitRelativePath().isEmpty() ? file->name() : file->webkitRelativePath();
213 // Let the application specify a filename if it's going to generate a replacement file for the upload.
214 const String& path = file->path();
215 if (!path.isEmpty()) {
216 if (Page* page = document->page()) {
217 String generatedFileName;
218 shouldGenerateFile = page->chrome()->client()->shouldReplaceWithGeneratedFileForUpload(path, generatedFileName);
219 if (shouldGenerateFile)
220 name = generatedFileName;
224 // For non-file blob, use the identifier part of the URL as the name.
225 name = "Blob" + BlobURL::getIdentifier(value.blob()->url());
226 name = name.replace("-", ""); // For safety, remove '-' from the filename since some servers may not like it.
229 // We have to include the filename=".." part in the header, even if the filename is empty
230 FormDataBuilder::addFilenameToMultiPartHeader(header, encoding, name);
232 // Add the content type if available, or "application/octet-stream" otherwise (RFC 1867).
234 if (value.blob()->type().isEmpty())
235 contentType = "application/octet-stream";
237 contentType = value.blob()->type();
238 FormDataBuilder::addContentTypeToMultiPartHeader(header, contentType.latin1());
241 FormDataBuilder::finishMultiPartHeader(header);
244 appendData(header.data(), header.size());
246 if (value.blob()->isFile()) {
247 // Do not add the file if the path is empty.
248 if (!static_cast<File*>(value.blob())->path().isEmpty())
249 appendFile(static_cast<File*>(value.blob())->path(), shouldGenerateFile);
253 appendBlob(value.blob()->url());
256 appendData(value.data().data(), value.data().length());
257 appendData("\r\n", 2);
259 // Omit the name "isindex" if it's the first form data element.
260 // FIXME: Why is this a good rule? Is this obsolete now?
261 if (encodedData.isEmpty() && key.data() == "isindex")
262 FormDataBuilder::encodeStringAsFormData(encodedData, value.data());
264 FormDataBuilder::addKeyValuePairAsFormData(encodedData, key.data(), value.data());
269 FormDataBuilder::addBoundaryToMultiPartHeader(encodedData, m_boundary.data(), true);
271 appendData(encodedData.data(), encodedData.size());
274 void FormData::flatten(Vector<char>& data) const
276 // Concatenate all the byte arrays, but omit any files.
278 size_t n = m_elements.size();
279 for (size_t i = 0; i < n; ++i) {
280 const FormDataElement& e = m_elements[i];
281 if (e.m_type == FormDataElement::data)
282 data.append(e.m_data.data(), static_cast<size_t>(e.m_data.size()));
286 String FormData::flattenToString() const
290 return Latin1Encoding().decode(reinterpret_cast<const char*>(bytes.data()), bytes.size());
293 void FormData::generateFiles(Document* document)
295 ASSERT(!m_hasGeneratedFiles);
297 if (m_hasGeneratedFiles)
300 Page* page = document->page();
303 ChromeClient* client = page->chrome()->client();
305 size_t n = m_elements.size();
306 for (size_t i = 0; i < n; ++i) {
307 FormDataElement& e = m_elements[i];
308 if (e.m_type == FormDataElement::encodedFile && e.m_shouldGenerateFile) {
309 e.m_generatedFilename = client->generateReplacementFile(e.m_filename);
310 m_hasGeneratedFiles = true;
315 void FormData::removeGeneratedFilesIfNeeded()
317 if (!m_hasGeneratedFiles)
320 size_t n = m_elements.size();
321 for (size_t i = 0; i < n; ++i) {
322 FormDataElement& e = m_elements[i];
323 if (e.m_type == FormDataElement::encodedFile && !e.m_generatedFilename.isEmpty()) {
324 ASSERT(e.m_shouldGenerateFile);
325 String directory = directoryName(e.m_generatedFilename);
326 deleteFile(e.m_generatedFilename);
327 deleteEmptyDirectory(directory);
328 e.m_generatedFilename = String();
331 m_hasGeneratedFiles = false;
334 static void encode(Encoder& encoder, const FormDataElement& element)
336 encoder.encodeUInt32(element.m_type);
338 switch (element.m_type) {
339 case FormDataElement::data:
340 encoder.encodeBytes(reinterpret_cast<const uint8_t*>(element.m_data.data()), element.m_data.size());
343 case FormDataElement::encodedFile:
344 encoder.encodeString(element.m_filename);
345 encoder.encodeBool(element.m_shouldGenerateFile);
347 encoder.encodeInt64(element.m_fileStart);
348 encoder.encodeInt64(element.m_fileLength);
349 encoder.encodeDouble(element.m_expectedFileModificationTime);
351 encoder.encodeInt64(0);
352 encoder.encodeInt64(0);
353 encoder.encodeDouble(0);
358 case FormDataElement::encodedBlob:
359 encoder.encodeString(element.m_blobURL.string());
364 ASSERT_NOT_REACHED();
367 static bool decode(Decoder& decoder, FormDataElement& element)
370 if (!decoder.decodeUInt32(type))
374 case FormDataElement::data: {
375 element.m_type = FormDataElement::data;
376 Vector<uint8_t> data;
377 if (!decoder.decodeBytes(data))
379 size_t size = data.size();
380 element.m_data.resize(size);
381 memcpy(element.m_data.data(), data.data(), size);
385 case FormDataElement::encodedFile: {
386 element.m_type = FormDataElement::encodedFile;
387 if (!decoder.decodeString(element.m_filename))
389 if (!decoder.decodeBool(element.m_shouldGenerateFile))
392 if (!decoder.decodeInt64(fileStart))
397 if (!decoder.decodeInt64(fileLength))
399 if (fileLength < fileStart)
401 double expectedFileModificationTime;
402 if (!decoder.decodeDouble(expectedFileModificationTime))
405 element.m_fileStart = fileStart;
406 element.m_fileLength = fileLength;
407 element.m_expectedFileModificationTime = expectedFileModificationTime;
413 case FormDataElement::encodedBlob:
414 element.m_type = FormDataElement::encodedBlob;
415 String blobURLString;
416 if (!decoder.decodeString(blobURLString))
418 element.m_blobURL = KURL(KURL(), blobURLString);
426 void FormData::encodeForBackForward(Encoder& encoder) const
428 encoder.encodeBool(m_alwaysStream);
430 encoder.encodeBytes(reinterpret_cast<const uint8_t*>(m_boundary.data()), m_boundary.size());
432 size_t size = m_elements.size();
433 encoder.encodeUInt64(size);
434 for (size_t i = 0; i < size; ++i)
435 encode(encoder, m_elements[i]);
437 encoder.encodeBool(m_hasGeneratedFiles);
439 encoder.encodeInt64(m_identifier);
442 PassRefPtr<FormData> FormData::decodeForBackForward(Decoder& decoder)
444 RefPtr<FormData> data = FormData::create();
446 if (!decoder.decodeBool(data->m_alwaysStream))
449 Vector<uint8_t> boundary;
450 if (!decoder.decodeBytes(boundary))
452 size_t size = boundary.size();
453 data->m_boundary.resize(size);
454 memcpy(data->m_boundary.data(), boundary.data(), size);
456 uint64_t elementsSize;
457 if (!decoder.decodeUInt64(elementsSize))
459 for (size_t i = 0; i < elementsSize; ++i) {
460 FormDataElement element;
461 if (!decode(decoder, element))
463 data->m_elements.append(element);
466 if (!decoder.decodeBool(data->m_hasGeneratedFiles))
469 if (!decoder.decodeInt64(data->m_identifier))
472 return data.release();
475 } // namespace WebCore