f58174621982646b6ebff4d8816802c421328119
[WebKit-https.git] / Source / WebCore / platform / network / FormData.cpp
1 /*
2  * Copyright (C) 2004, 2006, 2008, 2011 Apple Inc. All rights reserved.
3  * Copyright (C) 2009 Google Inc. All rights reserved.
4  *
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.
9  *
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.
14  *
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.
19  */
20
21 #include "config.h"
22
23 #include "FormData.h"
24
25 #include "BlobData.h"
26 #include "BlobURL.h"
27 #include "Chrome.h"
28 #include "ChromeClient.h"
29 #include "Document.h"
30 #include "File.h"
31 #include "FileSystem.h"
32 #include "FormDataBuilder.h"
33 #include "FormDataList.h"
34 #include "MIMETypeRegistry.h"
35 #include "Page.h"
36 #include "TextEncoding.h"
37 #include <wtf/Decoder.h>
38 #include <wtf/Encoder.h>
39
40 namespace WebCore {
41
42 inline FormData::FormData()
43     : m_identifier(0)
44     , m_hasGeneratedFiles(false)
45     , m_alwaysStream(false)
46     , m_containsPasswordData(false)
47 {
48 }
49
50 inline FormData::FormData(const FormData& data)
51     : RefCounted<FormData>()
52     , m_elements(data.m_elements)
53     , m_identifier(data.m_identifier)
54     , m_hasGeneratedFiles(false)
55     , m_alwaysStream(false)
56     , m_containsPasswordData(data.m_containsPasswordData)
57 {
58     // We shouldn't be copying FormData that hasn't already removed its generated files
59     // but just in case, make sure the new FormData is ready to generate its own files.
60     if (data.m_hasGeneratedFiles) {
61         size_t n = m_elements.size();
62         for (size_t i = 0; i < n; ++i) {
63             FormDataElement& e = m_elements[i];
64             if (e.m_type == FormDataElement::encodedFile)
65                 e.m_generatedFilename = String();
66         }
67     }
68 }
69
70 FormData::~FormData()
71 {
72     // This cleanup should've happened when the form submission finished.
73     // Just in case, let's assert, and do the cleanup anyway in release builds.
74     ASSERT(!m_hasGeneratedFiles);
75     removeGeneratedFilesIfNeeded();
76 }
77
78 PassRefPtr<FormData> FormData::create()
79 {
80     return adoptRef(new FormData);
81 }
82
83 PassRefPtr<FormData> FormData::create(const void* data, size_t size)
84 {
85     RefPtr<FormData> result = create();
86     result->appendData(data, size);
87     return result.release();
88 }
89
90 PassRefPtr<FormData> FormData::create(const CString& string)
91 {
92     RefPtr<FormData> result = create();
93     result->appendData(string.data(), string.length());
94     return result.release();
95 }
96
97 PassRefPtr<FormData> FormData::create(const Vector<char>& vector)
98 {
99     RefPtr<FormData> result = create();
100     result->appendData(vector.data(), vector.size());
101     return result.release();
102 }
103
104 PassRefPtr<FormData> FormData::create(const FormDataList& list, const TextEncoding& encoding, EncodingType encodingType)
105 {
106     RefPtr<FormData> result = create();
107     result->appendKeyValuePairItems(list, encoding, false, 0, encodingType);
108     return result.release();
109 }
110
111 PassRefPtr<FormData> FormData::createMultiPart(const FormDataList& list, const TextEncoding& encoding, Document* document)
112 {
113     RefPtr<FormData> result = create();
114     result->appendKeyValuePairItems(list, encoding, true, document);
115     return result.release();
116 }
117
118 PassRefPtr<FormData> FormData::copy() const
119 {
120     return adoptRef(new FormData(*this));
121 }
122
123 PassRefPtr<FormData> FormData::deepCopy() const
124 {
125     RefPtr<FormData> formData(create());
126
127     formData->m_alwaysStream = m_alwaysStream;
128
129     size_t n = m_elements.size();
130     formData->m_elements.reserveInitialCapacity(n);
131     for (size_t i = 0; i < n; ++i) {
132         const FormDataElement& e = m_elements[i];
133         switch (e.m_type) {
134         case FormDataElement::data:
135             formData->m_elements.append(FormDataElement(e.m_data));
136             break;
137         case FormDataElement::encodedFile:
138 #if ENABLE(BLOB)
139             formData->m_elements.append(FormDataElement(e.m_filename, e.m_fileStart, e.m_fileLength, e.m_expectedFileModificationTime, e.m_shouldGenerateFile));
140 #else
141             formData->m_elements.append(FormDataElement(e.m_filename, e.m_shouldGenerateFile));
142 #endif
143             break;
144 #if ENABLE(BLOB)
145         case FormDataElement::encodedBlob:
146             formData->m_elements.append(FormDataElement(e.m_blobURL));
147             break;
148 #endif
149         }
150     }
151     return formData.release();
152 }
153
154 void FormData::appendData(const void* data, size_t size)
155 {
156     if (m_elements.isEmpty() || m_elements.last().m_type != FormDataElement::data)
157         m_elements.append(FormDataElement());
158     FormDataElement& e = m_elements.last();
159     size_t oldSize = e.m_data.size();
160     e.m_data.grow(oldSize + size);
161     memcpy(e.m_data.data() + oldSize, data, size);
162 }
163
164 void FormData::appendFile(const String& filename, bool shouldGenerateFile)
165 {
166 #if ENABLE(BLOB)
167     m_elements.append(FormDataElement(filename, 0, BlobDataItem::toEndOfFile, BlobDataItem::doNotCheckFileChange, shouldGenerateFile));
168 #else
169     m_elements.append(FormDataElement(filename, shouldGenerateFile));
170 #endif
171 }
172
173 #if ENABLE(BLOB)
174 void FormData::appendFileRange(const String& filename, long long start, long long length, double expectedModificationTime, bool shouldGenerateFile)
175 {
176     m_elements.append(FormDataElement(filename, start, length, expectedModificationTime, shouldGenerateFile));
177 }
178
179 void FormData::appendBlob(const KURL& blobURL)
180 {
181     m_elements.append(FormDataElement(blobURL));
182 }
183 #endif
184
185 void FormData::appendKeyValuePairItems(const FormDataList& list, const TextEncoding& encoding, bool isMultiPartForm, Document* document, EncodingType encodingType)
186 {
187     if (isMultiPartForm)
188         m_boundary = FormDataBuilder::generateUniqueBoundaryString();
189
190     Vector<char> encodedData;
191
192     const Vector<FormDataList::Item>& items = list.items();
193     size_t formDataListSize = items.size();
194     ASSERT(!(formDataListSize % 2));
195     for (size_t i = 0; i < formDataListSize; i += 2) {
196         const FormDataList::Item& key = items[i];
197         const FormDataList::Item& value = items[i + 1];
198         if (isMultiPartForm) {
199             Vector<char> header;
200             FormDataBuilder::beginMultiPartHeader(header, m_boundary.data(), key.data());
201
202             bool shouldGenerateFile = false;
203
204             // If the current type is blob, then we also need to include the filename
205             if (value.blob()) {
206                 String name;
207                 if (value.blob()->isFile()) {
208                     // For file blob, use the filename (or relative path if it is present) as the name.
209                     File* file = static_cast<File*>(value.blob());
210 #if ENABLE(DIRECTORY_UPLOAD)                
211                     name = file->webkitRelativePath().isEmpty() ? file->name() : file->webkitRelativePath();
212 #else
213                     name = file->name();
214 #endif
215                     // Let the application specify a filename if it's going to generate a replacement file for the upload.
216                     const String& path = file->path();
217                     if (!path.isEmpty()) {
218                         if (Page* page = document->page()) {
219                             String generatedFileName;
220                             shouldGenerateFile = page->chrome()->client()->shouldReplaceWithGeneratedFileForUpload(path, generatedFileName);
221                             if (shouldGenerateFile)
222                                 name = generatedFileName;
223                         }
224                     }
225                 } else {
226                     // For non-file blob, use the filename if it is passed in FormData.append().
227                     if (!value.filename().isEmpty())
228                         name = value.filename();
229                     else
230                         name = "blob";
231                 }
232
233                 // We have to include the filename=".." part in the header, even if the filename is empty
234                 FormDataBuilder::addFilenameToMultiPartHeader(header, encoding, name);
235
236                 // Add the content type if available, or "application/octet-stream" otherwise (RFC 1867).
237                 String contentType;
238                 if (value.blob()->type().isEmpty())
239                     contentType = "application/octet-stream";
240                 else
241                     contentType = value.blob()->type();
242                 FormDataBuilder::addContentTypeToMultiPartHeader(header, contentType.latin1());
243             }
244
245             FormDataBuilder::finishMultiPartHeader(header);
246
247             // Append body
248             appendData(header.data(), header.size());
249             if (value.blob()) {
250                 if (value.blob()->isFile()) {
251                     // Do not add the file if the path is empty.
252                     if (!static_cast<File*>(value.blob())->path().isEmpty())
253                         appendFile(static_cast<File*>(value.blob())->path(), shouldGenerateFile);
254                 }
255 #if ENABLE(BLOB)
256                 else
257                     appendBlob(value.blob()->url());
258 #endif
259             } else
260                 appendData(value.data().data(), value.data().length());
261             appendData("\r\n", 2);
262         } else {
263             // Omit the name "isindex" if it's the first form data element.
264             // FIXME: Why is this a good rule? Is this obsolete now?
265             if (encodedData.isEmpty() && key.data() == "isindex")
266                 FormDataBuilder::encodeStringAsFormData(encodedData, value.data());
267             else
268                 FormDataBuilder::addKeyValuePairAsFormData(encodedData, key.data(), value.data(), encodingType);
269         }
270     }
271
272     if (isMultiPartForm)
273         FormDataBuilder::addBoundaryToMultiPartHeader(encodedData, m_boundary.data(), true);
274
275     appendData(encodedData.data(), encodedData.size());
276 }
277
278 void FormData::flatten(Vector<char>& data) const
279 {
280     // Concatenate all the byte arrays, but omit any files.
281     data.clear();
282     size_t n = m_elements.size();
283     for (size_t i = 0; i < n; ++i) {
284         const FormDataElement& e = m_elements[i];
285         if (e.m_type == FormDataElement::data)
286             data.append(e.m_data.data(), static_cast<size_t>(e.m_data.size()));
287     }
288 }
289
290 String FormData::flattenToString() const
291 {
292     Vector<char> bytes;
293     flatten(bytes);
294     return Latin1Encoding().decode(reinterpret_cast<const char*>(bytes.data()), bytes.size());
295 }
296
297 void FormData::generateFiles(Document* document)
298 {
299     ASSERT(!m_hasGeneratedFiles);
300
301     if (m_hasGeneratedFiles)
302         return;
303
304     Page* page = document->page();
305     if (!page)
306         return;
307     ChromeClient* client = page->chrome()->client();
308
309     size_t n = m_elements.size();
310     for (size_t i = 0; i < n; ++i) {
311         FormDataElement& e = m_elements[i];
312         if (e.m_type == FormDataElement::encodedFile && e.m_shouldGenerateFile) {
313             e.m_generatedFilename = client->generateReplacementFile(e.m_filename);
314             m_hasGeneratedFiles = true;
315         }
316     }
317 }
318
319 void FormData::removeGeneratedFilesIfNeeded()
320 {
321     if (!m_hasGeneratedFiles)
322         return;
323
324     size_t n = m_elements.size();
325     for (size_t i = 0; i < n; ++i) {
326         FormDataElement& e = m_elements[i];
327         if (e.m_type == FormDataElement::encodedFile && !e.m_generatedFilename.isEmpty()) {
328             ASSERT(e.m_shouldGenerateFile);
329             String directory = directoryName(e.m_generatedFilename);
330             deleteFile(e.m_generatedFilename);
331             deleteEmptyDirectory(directory);
332             e.m_generatedFilename = String();
333         }
334     }
335     m_hasGeneratedFiles = false;
336 }
337
338 static void encode(Encoder& encoder, const FormDataElement& element)
339 {
340     encoder.encodeUInt32(element.m_type);
341
342     switch (element.m_type) {
343     case FormDataElement::data:
344         encoder.encodeBytes(reinterpret_cast<const uint8_t*>(element.m_data.data()), element.m_data.size());
345         return;
346
347     case FormDataElement::encodedFile:
348         encoder.encodeString(element.m_filename);
349         encoder.encodeBool(element.m_shouldGenerateFile);
350 #if ENABLE(BLOB)
351         encoder.encodeInt64(element.m_fileStart);
352         encoder.encodeInt64(element.m_fileLength);
353         encoder.encodeDouble(element.m_expectedFileModificationTime);
354 #else
355         encoder.encodeInt64(0);
356         encoder.encodeInt64(0);
357         encoder.encodeDouble(0);
358 #endif
359         return;
360
361 #if ENABLE(BLOB)
362     case FormDataElement::encodedBlob:
363         encoder.encodeString(element.m_blobURL.string());
364         return;
365 #endif
366     }
367
368     ASSERT_NOT_REACHED();
369 }
370
371 static bool decode(Decoder& decoder, FormDataElement& element)
372 {
373     uint32_t type;
374     if (!decoder.decodeUInt32(type))
375         return false;
376
377     switch (type) {
378     case FormDataElement::data: {
379         element.m_type = FormDataElement::data;
380         Vector<uint8_t> data;
381         if (!decoder.decodeBytes(data))
382             return false;
383         size_t size = data.size();
384         element.m_data.resize(size);
385         memcpy(element.m_data.data(), data.data(), size);
386         return true;
387     }
388
389     case FormDataElement::encodedFile: {
390         element.m_type = FormDataElement::encodedFile;
391         if (!decoder.decodeString(element.m_filename))
392             return false;
393         if (!decoder.decodeBool(element.m_shouldGenerateFile))
394             return false;
395         int64_t fileStart;
396         if (!decoder.decodeInt64(fileStart))
397             return false;
398         if (fileStart < 0)
399             return false;
400         int64_t fileLength;
401         if (!decoder.decodeInt64(fileLength))
402             return false;
403         if (fileLength < fileStart)
404             return false;
405         double expectedFileModificationTime;
406         if (!decoder.decodeDouble(expectedFileModificationTime))
407             return false;
408 #if ENABLE(BLOB)
409         element.m_fileStart = fileStart;
410         element.m_fileLength = fileLength;
411         element.m_expectedFileModificationTime = expectedFileModificationTime;
412 #endif
413         return true;
414     }
415
416 #if ENABLE(BLOB)
417     case FormDataElement::encodedBlob:
418         element.m_type = FormDataElement::encodedBlob;
419         String blobURLString;
420         if (!decoder.decodeString(blobURLString))
421             return false;
422         element.m_blobURL = KURL(KURL(), blobURLString);
423         return true;
424 #endif
425     }
426
427     return false;
428 }
429
430 void FormData::encodeForBackForward(Encoder& encoder) const
431 {
432     encoder.encodeBool(m_alwaysStream);
433
434     encoder.encodeBytes(reinterpret_cast<const uint8_t*>(m_boundary.data()), m_boundary.size());
435
436     size_t size = m_elements.size();
437     encoder.encodeUInt64(size);
438     for (size_t i = 0; i < size; ++i)
439         encode(encoder, m_elements[i]);
440
441     encoder.encodeBool(m_hasGeneratedFiles);
442
443     encoder.encodeInt64(m_identifier);
444 }
445
446 PassRefPtr<FormData> FormData::decodeForBackForward(Decoder& decoder)
447 {
448     RefPtr<FormData> data = FormData::create();
449
450     if (!decoder.decodeBool(data->m_alwaysStream))
451         return 0;
452
453     Vector<uint8_t> boundary;
454     if (!decoder.decodeBytes(boundary))
455         return 0;
456     size_t size = boundary.size();
457     data->m_boundary.resize(size);
458     memcpy(data->m_boundary.data(), boundary.data(), size);
459
460     uint64_t elementsSize;
461     if (!decoder.decodeUInt64(elementsSize))
462         return 0;
463     for (size_t i = 0; i < elementsSize; ++i) {
464         FormDataElement element;
465         if (!decode(decoder, element))
466             return 0;
467         data->m_elements.append(element);
468     }
469
470     if (!decoder.decodeBool(data->m_hasGeneratedFiles))
471         return 0;
472
473     if (!decoder.decodeInt64(data->m_identifier))
474         return 0;
475
476     return data.release();
477 }
478
479 } // namespace WebCore