ebf273cd5c8e13163c9acaf62d14bf5040f8cddb
[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                     File* file = toFile(value.blob());
209                     // For file blob, use the filename (or relative path if it is present) as the name.
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                     File* file = toFile(value.blob());
252                     // Do not add the file if the path is empty.
253                     if (!file->path().isEmpty())
254                         appendFile(file->path(), shouldGenerateFile);
255                 }
256 #if ENABLE(BLOB)
257                 else
258                     appendBlob(value.blob()->url());
259 #endif
260             } else
261                 appendData(value.data().data(), value.data().length());
262             appendData("\r\n", 2);
263         } else {
264             // Omit the name "isindex" if it's the first form data element.
265             // FIXME: Why is this a good rule? Is this obsolete now?
266             if (encodedData.isEmpty() && key.data() == "isindex")
267                 FormDataBuilder::encodeStringAsFormData(encodedData, value.data());
268             else
269                 FormDataBuilder::addKeyValuePairAsFormData(encodedData, key.data(), value.data(), encodingType);
270         }
271     }
272
273     if (isMultiPartForm)
274         FormDataBuilder::addBoundaryToMultiPartHeader(encodedData, m_boundary.data(), true);
275
276     appendData(encodedData.data(), encodedData.size());
277 }
278
279 void FormData::flatten(Vector<char>& data) const
280 {
281     // Concatenate all the byte arrays, but omit any files.
282     data.clear();
283     size_t n = m_elements.size();
284     for (size_t i = 0; i < n; ++i) {
285         const FormDataElement& e = m_elements[i];
286         if (e.m_type == FormDataElement::data)
287             data.append(e.m_data.data(), static_cast<size_t>(e.m_data.size()));
288     }
289 }
290
291 String FormData::flattenToString() const
292 {
293     Vector<char> bytes;
294     flatten(bytes);
295     return Latin1Encoding().decode(reinterpret_cast<const char*>(bytes.data()), bytes.size());
296 }
297
298 void FormData::generateFiles(Document* document)
299 {
300     ASSERT(!m_hasGeneratedFiles);
301
302     if (m_hasGeneratedFiles)
303         return;
304
305     Page* page = document->page();
306     if (!page)
307         return;
308     ChromeClient* client = page->chrome()->client();
309
310     size_t n = m_elements.size();
311     for (size_t i = 0; i < n; ++i) {
312         FormDataElement& e = m_elements[i];
313         if (e.m_type == FormDataElement::encodedFile && e.m_shouldGenerateFile) {
314             e.m_generatedFilename = client->generateReplacementFile(e.m_filename);
315             m_hasGeneratedFiles = true;
316         }
317     }
318 }
319
320 void FormData::removeGeneratedFilesIfNeeded()
321 {
322     if (!m_hasGeneratedFiles)
323         return;
324
325     size_t n = m_elements.size();
326     for (size_t i = 0; i < n; ++i) {
327         FormDataElement& e = m_elements[i];
328         if (e.m_type == FormDataElement::encodedFile && !e.m_generatedFilename.isEmpty()) {
329             ASSERT(e.m_shouldGenerateFile);
330             String directory = directoryName(e.m_generatedFilename);
331             deleteFile(e.m_generatedFilename);
332             deleteEmptyDirectory(directory);
333             e.m_generatedFilename = String();
334         }
335     }
336     m_hasGeneratedFiles = false;
337 }
338
339 static void encode(Encoder& encoder, const FormDataElement& element)
340 {
341     encoder.encodeUInt32(element.m_type);
342
343     switch (element.m_type) {
344     case FormDataElement::data:
345         encoder.encodeBytes(reinterpret_cast<const uint8_t*>(element.m_data.data()), element.m_data.size());
346         return;
347
348     case FormDataElement::encodedFile:
349         encoder.encodeString(element.m_filename);
350         encoder.encodeBool(element.m_shouldGenerateFile);
351 #if ENABLE(BLOB)
352         encoder.encodeInt64(element.m_fileStart);
353         encoder.encodeInt64(element.m_fileLength);
354         encoder.encodeDouble(element.m_expectedFileModificationTime);
355 #else
356         encoder.encodeInt64(0);
357         encoder.encodeInt64(0);
358         encoder.encodeDouble(0);
359 #endif
360         return;
361
362 #if ENABLE(BLOB)
363     case FormDataElement::encodedBlob:
364         encoder.encodeString(element.m_blobURL.string());
365         return;
366 #endif
367     }
368
369     ASSERT_NOT_REACHED();
370 }
371
372 static bool decode(Decoder& decoder, FormDataElement& element)
373 {
374     uint32_t type;
375     if (!decoder.decodeUInt32(type))
376         return false;
377
378     switch (type) {
379     case FormDataElement::data: {
380         element.m_type = FormDataElement::data;
381         Vector<uint8_t> data;
382         if (!decoder.decodeBytes(data))
383             return false;
384         size_t size = data.size();
385         element.m_data.resize(size);
386         memcpy(element.m_data.data(), data.data(), size);
387         return true;
388     }
389
390     case FormDataElement::encodedFile: {
391         element.m_type = FormDataElement::encodedFile;
392         if (!decoder.decodeString(element.m_filename))
393             return false;
394         if (!decoder.decodeBool(element.m_shouldGenerateFile))
395             return false;
396         int64_t fileStart;
397         if (!decoder.decodeInt64(fileStart))
398             return false;
399         if (fileStart < 0)
400             return false;
401         int64_t fileLength;
402         if (!decoder.decodeInt64(fileLength))
403             return false;
404         if (fileLength < fileStart)
405             return false;
406         double expectedFileModificationTime;
407         if (!decoder.decodeDouble(expectedFileModificationTime))
408             return false;
409 #if ENABLE(BLOB)
410         element.m_fileStart = fileStart;
411         element.m_fileLength = fileLength;
412         element.m_expectedFileModificationTime = expectedFileModificationTime;
413 #endif
414         return true;
415     }
416
417 #if ENABLE(BLOB)
418     case FormDataElement::encodedBlob:
419         element.m_type = FormDataElement::encodedBlob;
420         String blobURLString;
421         if (!decoder.decodeString(blobURLString))
422             return false;
423         element.m_blobURL = KURL(KURL(), blobURLString);
424         return true;
425 #endif
426     }
427
428     return false;
429 }
430
431 void FormData::encodeForBackForward(Encoder& encoder) const
432 {
433     encoder.encodeBool(m_alwaysStream);
434
435     encoder.encodeBytes(reinterpret_cast<const uint8_t*>(m_boundary.data()), m_boundary.size());
436
437     size_t size = m_elements.size();
438     encoder.encodeUInt64(size);
439     for (size_t i = 0; i < size; ++i)
440         encode(encoder, m_elements[i]);
441
442     encoder.encodeBool(m_hasGeneratedFiles);
443
444     encoder.encodeInt64(m_identifier);
445 }
446
447 PassRefPtr<FormData> FormData::decodeForBackForward(Decoder& decoder)
448 {
449     RefPtr<FormData> data = FormData::create();
450
451     if (!decoder.decodeBool(data->m_alwaysStream))
452         return 0;
453
454     Vector<uint8_t> boundary;
455     if (!decoder.decodeBytes(boundary))
456         return 0;
457     size_t size = boundary.size();
458     data->m_boundary.resize(size);
459     memcpy(data->m_boundary.data(), boundary.data(), size);
460
461     uint64_t elementsSize;
462     if (!decoder.decodeUInt64(elementsSize))
463         return 0;
464     for (size_t i = 0; i < elementsSize; ++i) {
465         FormDataElement element;
466         if (!decode(decoder, element))
467             return 0;
468         data->m_elements.append(element);
469     }
470
471     if (!decoder.decodeBool(data->m_hasGeneratedFiles))
472         return 0;
473
474     if (!decoder.decodeInt64(data->m_identifier))
475         return 0;
476
477     return data.release();
478 }
479
480 } // namespace WebCore