43435d5c2b489517c7fc5456a5bf14de3fc394b3
[WebKit-https.git] / Source / WebCore / loader / FormSubmission.cpp
1 /*
2  * Copyright (C) 2010 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "FormSubmission.h"
33
34 #include "DOMFormData.h"
35 #include "Document.h"
36 #include "Event.h"
37 #include "FormData.h"
38 #include "FormDataBuilder.h"
39 #include "FormState.h"
40 #include "Frame.h"
41 #include "FrameLoadRequest.h"
42 #include "FrameLoader.h"
43 #include "HTMLFormControlElement.h"
44 #include "HTMLFormElement.h"
45 #include "HTMLInputElement.h"
46 #include "HTMLNames.h"
47 #include "HTMLParserIdioms.h"
48 #include "TextEncoding.h"
49 #include <wtf/CurrentTime.h>
50 #include <wtf/RandomNumber.h>
51
52 namespace WebCore {
53
54 using namespace HTMLNames;
55
56 static int64_t generateFormDataIdentifier()
57 {
58     // Initialize to the current time to reduce the likelihood of generating
59     // identifiers that overlap with those from past/future browser sessions.
60     static int64_t nextIdentifier = static_cast<int64_t>(currentTime() * 1000000.0);
61     return ++nextIdentifier;
62 }
63
64 static void appendMailtoPostFormDataToURL(URL& url, const FormData& data, const String& encodingType)
65 {
66     String body = data.flattenToString();
67
68     if (equalIgnoringCase(encodingType, "text/plain")) {
69         // Convention seems to be to decode, and s/&/\r\n/. Also, spaces are encoded as %20.
70         body = decodeURLEscapeSequences(body.replaceWithLiteral('&', "\r\n").replace('+', ' ') + "\r\n");
71     }
72
73     Vector<char> bodyData;
74     bodyData.append("body=", 5);
75     FormDataBuilder::encodeStringAsFormData(bodyData, body.utf8());
76     body = String(bodyData.data(), bodyData.size()).replaceWithLiteral('+', "%20");
77
78     String query = url.query();
79     if (query.isEmpty())
80         url.setQuery(body);
81     else
82         url.setQuery(query + '&' + body);
83 }
84
85 void FormSubmission::Attributes::parseAction(const String& action)
86 {
87     // FIXME: Can we parse into a URL?
88     m_action = stripLeadingAndTrailingHTMLSpaces(action);
89 }
90
91 String FormSubmission::Attributes::parseEncodingType(const String& type)
92 {
93     if (equalIgnoringCase(type, "multipart/form-data"))
94         return "multipart/form-data";
95     if (equalIgnoringCase(type, "text/plain"))
96         return "text/plain";
97     return "application/x-www-form-urlencoded";
98 }
99
100 void FormSubmission::Attributes::updateEncodingType(const String& type)
101 {
102     m_encodingType = parseEncodingType(type);
103     m_isMultiPartForm = (m_encodingType == "multipart/form-data");
104 }
105
106 FormSubmission::Method FormSubmission::Attributes::parseMethodType(const String& type)
107 {
108     return equalIgnoringCase(type, "post") ? FormSubmission::PostMethod : FormSubmission::GetMethod;
109 }
110
111 void FormSubmission::Attributes::updateMethodType(const String& type)
112 {
113     m_method = parseMethodType(type);
114 }
115
116 void FormSubmission::Attributes::copyFrom(const Attributes& other)
117 {
118     m_method = other.m_method;
119     m_isMultiPartForm = other.m_isMultiPartForm;
120
121     m_action = other.m_action;
122     m_target = other.m_target;
123     m_encodingType = other.m_encodingType;
124     m_acceptCharset = other.m_acceptCharset;
125 }
126
127 inline FormSubmission::FormSubmission(Method method, const URL& action, const String& target, const String& contentType, PassRefPtr<FormState> state, PassRefPtr<FormData> data, const String& boundary, LockHistory lockHistory, PassRefPtr<Event> event)
128     : m_method(method)
129     , m_action(action)
130     , m_target(target)
131     , m_contentType(contentType)
132     , m_formState(state)
133     , m_formData(data)
134     , m_boundary(boundary)
135     , m_lockHistory(lockHistory)
136     , m_event(event)
137 {
138 }
139
140 static TextEncoding encodingFromAcceptCharset(const String& acceptCharset, Document& document)
141 {
142     String normalizedAcceptCharset = acceptCharset;
143     normalizedAcceptCharset.replace(',', ' ');
144
145     Vector<String> charsets;
146     normalizedAcceptCharset.split(' ', charsets);
147
148     for (auto& charset : charsets) {
149         TextEncoding encoding(charset);
150         if (encoding.isValid())
151             return encoding;
152     }
153
154     return TextEncoding(document.encoding());
155 }
156
157 Ref<FormSubmission> FormSubmission::create(HTMLFormElement* form, const Attributes& attributes, PassRefPtr<Event> event, LockHistory lockHistory, FormSubmissionTrigger trigger)
158 {
159     ASSERT(form);
160
161     HTMLFormControlElement* submitButton = 0;
162     if (event && event->target()) {
163         for (Node* node = event->target()->toNode(); node; node = node->parentNode()) {
164             if (is<HTMLFormControlElement>(*node)) {
165                 submitButton = downcast<HTMLFormControlElement>(node);
166                 break;
167             }
168         }
169     }
170
171     FormSubmission::Attributes copiedAttributes;
172     copiedAttributes.copyFrom(attributes);
173     if (submitButton) {
174         AtomicString attributeValue;
175         if (!(attributeValue = submitButton->fastGetAttribute(formactionAttr)).isNull())
176             copiedAttributes.parseAction(attributeValue);
177         if (!(attributeValue = submitButton->fastGetAttribute(formenctypeAttr)).isNull())
178             copiedAttributes.updateEncodingType(attributeValue);
179         if (!(attributeValue = submitButton->fastGetAttribute(formmethodAttr)).isNull())
180             copiedAttributes.updateMethodType(attributeValue);
181         if (!(attributeValue = submitButton->fastGetAttribute(formtargetAttr)).isNull())
182             copiedAttributes.setTarget(attributeValue);
183     }
184     
185     Document& document = form->document();
186     URL actionURL = document.completeURL(copiedAttributes.action().isEmpty() ? document.url().string() : copiedAttributes.action());
187     bool isMailtoForm = actionURL.protocolIs("mailto");
188     bool isMultiPartForm = false;
189     String encodingType = copiedAttributes.encodingType();
190
191     if (copiedAttributes.method() == PostMethod) {
192         isMultiPartForm = copiedAttributes.isMultiPartForm();
193         if (isMultiPartForm && isMailtoForm) {
194             encodingType = "application/x-www-form-urlencoded";
195             isMultiPartForm = false;
196         }
197     }
198
199     TextEncoding dataEncoding = isMailtoForm ? UTF8Encoding() : encodingFromAcceptCharset(copiedAttributes.acceptCharset(), document);
200     RefPtr<DOMFormData> domFormData = DOMFormData::create(dataEncoding.encodingForFormSubmission());
201     Vector<std::pair<String, String>> formValues;
202
203     bool containsPasswordData = false;
204     for (unsigned i = 0; i < form->associatedElements().size(); ++i) {
205         FormAssociatedElement& control = *form->associatedElements()[i];
206         HTMLElement& element = control.asHTMLElement();
207         if (!element.isDisabledFormControl())
208             control.appendFormData(*domFormData, isMultiPartForm);
209         if (is<HTMLInputElement>(element)) {
210             HTMLInputElement& input = downcast<HTMLInputElement>(element);
211             if (input.isTextField()) {
212                 formValues.append(std::pair<String, String>(input.name().string(), input.value()));
213                 input.addSearchResult();
214             }
215             if (input.isPasswordField() && !input.value().isEmpty())
216                 containsPasswordData = true;
217         }
218     }
219
220     RefPtr<FormData> formData;
221     String boundary;
222
223     if (isMultiPartForm) {
224         formData = FormData::createMultiPart(*(static_cast<FormDataList*>(domFormData.get())), domFormData->encoding(), &document);
225         boundary = formData->boundary().data();
226     } else {
227         formData = FormData::create(*(static_cast<FormDataList*>(domFormData.get())), domFormData->encoding(), attributes.method() == GetMethod ? FormData::FormURLEncoded : FormData::parseEncodingType(encodingType));
228         if (copiedAttributes.method() == PostMethod && isMailtoForm) {
229             // Convert the form data into a string that we put into the URL.
230             appendMailtoPostFormDataToURL(actionURL, *formData, encodingType);
231             formData = FormData::create();
232         }
233     }
234
235     formData->setIdentifier(generateFormDataIdentifier());
236     formData->setContainsPasswordData(containsPasswordData);
237     String targetOrBaseTarget = copiedAttributes.target().isEmpty() ? document.baseTarget() : copiedAttributes.target();
238     RefPtr<FormState> formState = FormState::create(form, formValues, &document, trigger);
239     return adoptRef(*new FormSubmission(copiedAttributes.method(), actionURL, targetOrBaseTarget, encodingType, formState.release(), formData.release(), boundary, lockHistory, event));
240 }
241
242 URL FormSubmission::requestURL() const
243 {
244     if (m_method == FormSubmission::PostMethod)
245         return m_action;
246
247     URL requestURL(m_action);
248     requestURL.setQuery(m_formData->flattenToString());    
249     return requestURL;
250 }
251
252 void FormSubmission::populateFrameLoadRequest(FrameLoadRequest& frameRequest)
253 {
254     if (!m_target.isEmpty())
255         frameRequest.setFrameName(m_target);
256
257     if (!m_referrer.isEmpty())
258         frameRequest.resourceRequest().setHTTPReferrer(m_referrer);
259
260     if (m_method == FormSubmission::PostMethod) {
261         frameRequest.resourceRequest().setHTTPMethod("POST");
262         frameRequest.resourceRequest().setHTTPBody(m_formData);
263
264         // construct some user headers if necessary
265         if (m_boundary.isEmpty())
266             frameRequest.resourceRequest().setHTTPContentType(m_contentType);
267         else
268             frameRequest.resourceRequest().setHTTPContentType(m_contentType + "; boundary=" + m_boundary);
269     }
270
271     frameRequest.resourceRequest().setURL(requestURL());
272     FrameLoader::addHTTPOriginIfNeeded(frameRequest.resourceRequest(), m_origin);
273 }
274
275 }