From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- dom/html/HTMLFormSubmission.h | 292 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 292 insertions(+) create mode 100644 dom/html/HTMLFormSubmission.h (limited to 'dom/html/HTMLFormSubmission.h') diff --git a/dom/html/HTMLFormSubmission.h b/dom/html/HTMLFormSubmission.h new file mode 100644 index 0000000000..8968fee187 --- /dev/null +++ b/dom/html/HTMLFormSubmission.h @@ -0,0 +1,292 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_HTMLFormSubmission_h +#define mozilla_dom_HTMLFormSubmission_h + +#include "mozilla/Attributes.h" +#include "mozilla/dom/UserActivation.h" +#include "mozilla/dom/HTMLDialogElement.h" +#include "nsCOMPtr.h" +#include "mozilla/Encoding.h" +#include "nsString.h" + +class nsIURI; +class nsIInputStream; +class nsGenericHTMLElement; +class nsIMultiplexInputStream; + +namespace mozilla::dom { + +class Blob; +class DialogFormSubmission; +class Directory; +class Element; +class HTMLFormElement; + +/** + * Class for form submissions; encompasses the function to call to submit as + * well as the form submission name/value pairs + */ +class HTMLFormSubmission { + public: + /** + * Get a submission object based on attributes in the form (ENCTYPE and + * METHOD) + * + * @param aForm the form to get a submission object based on + * @param aSubmitter the submitter element (can be null) + * @param aFormSubmission the form submission object (out param) + */ + static nsresult GetFromForm(HTMLFormElement* aForm, + nsGenericHTMLElement* aSubmitter, + NotNull& aEncoding, + HTMLFormSubmission** aFormSubmission); + + MOZ_COUNTED_DTOR_VIRTUAL(HTMLFormSubmission) + + /** + * Submit a name/value pair + * + * @param aName the name of the parameter + * @param aValue the value of the parameter + */ + virtual nsresult AddNameValuePair(const nsAString& aName, + const nsAString& aValue) = 0; + + /** + * Submit a name/blob pair + * + * @param aName the name of the parameter + * @param aBlob the blob to submit. The file's name will be used if the Blob + * is actually a File, otherwise 'blob' string is used instead. Must not be + * null. + */ + virtual nsresult AddNameBlobPair(const nsAString& aName, Blob* aBlob) = 0; + + /** + * Submit a name/directory pair + * + * @param aName the name of the parameter + * @param aBlob the directory to submit. + */ + virtual nsresult AddNameDirectoryPair(const nsAString& aName, + Directory* aDirectory) = 0; + + /** + * Given a URI and the current submission, create the final URI and data + * stream that will be submitted. Subclasses *must* implement this. + * + * @param aURI the URI being submitted to [IN] + * @param aPostDataStream a data stream for POST data [OUT] + * @param aOutURI the resulting URI. May be the same as aURI [OUT] + */ + virtual nsresult GetEncodedSubmission(nsIURI* aURI, + nsIInputStream** aPostDataStream, + nsCOMPtr& aOutURI) = 0; + + /** + * Get the charset that will be used for submission. + */ + void GetCharset(nsACString& aCharset) { mEncoding->Name(aCharset); } + + /** + * Get the action URI that will be used for submission. + */ + nsIURI* GetActionURL() const { return mActionURL; } + + /** + * Get the target that will be used for submission. + */ + void GetTarget(nsAString& aTarget) { aTarget = mTarget; } + + /** + * Return true if this form submission was user-initiated. + */ + bool IsInitiatedFromUserInput() const { return mInitiatedFromUserInput; } + + virtual DialogFormSubmission* GetAsDialogSubmission() { return nullptr; } + + protected: + /** + * Can only be constructed by subclasses. + * + * @param aEncoding the character encoding of the form + */ + HTMLFormSubmission(nsIURI* aActionURL, const nsAString& aTarget, + mozilla::NotNull aEncoding); + + // The action url. + nsCOMPtr mActionURL; + + // The target. + nsString mTarget; + + // The character encoding of this form submission + mozilla::NotNull mEncoding; + + // Keep track of whether this form submission was user-initiated or not + bool mInitiatedFromUserInput; +}; + +class EncodingFormSubmission : public HTMLFormSubmission { + public: + EncodingFormSubmission(nsIURI* aActionURL, const nsAString& aTarget, + mozilla::NotNull aEncoding, + Element* aSubmitter); + + virtual ~EncodingFormSubmission(); + + // Indicates the type of newline normalization and escaping to perform in + // `EncodeVal`, in addition to encoding the string into bytes. + enum EncodeType { + // Normalizes newlines to CRLF and then escapes for use in + // `Content-Disposition`. (Useful for `multipart/form-data` entry names.) + eNameEncode, + // Escapes for use in `Content-Disposition`. (Useful for + // `multipart/form-data` filenames.) + eFilenameEncode, + // Normalizes newlines to CRLF. + eValueEncode, + }; + + /** + * Encode a Unicode string to bytes, additionally performing escapes or + * normalizations. + * @param aStr the string to encode + * @param aOut the encoded string [OUT] + * @param aEncodeType The type of escapes or normalizations to perform on the + * encoded string. + * @throws an error if UnicodeToNewBytes fails + */ + nsresult EncodeVal(const nsAString& aStr, nsCString& aOut, + EncodeType aEncodeType); +}; + +class DialogFormSubmission final : public HTMLFormSubmission { + public: + DialogFormSubmission(nsAString& aResult, nsIURI* aActionURL, + const nsAString& aTarget, + NotNull aEncoding, + HTMLDialogElement* aDialogElement) + : HTMLFormSubmission(aActionURL, aTarget, aEncoding), + mDialogElement(aDialogElement), + mReturnValue(aResult) {} + nsresult AddNameValuePair(const nsAString& aName, + const nsAString& aValue) override { + MOZ_CRASH("This method should not be called"); + return NS_OK; + } + + nsresult AddNameBlobPair(const nsAString& aName, Blob* aBlob) override { + MOZ_CRASH("This method should not be called"); + return NS_OK; + } + + nsresult AddNameDirectoryPair(const nsAString& aName, + Directory* aDirectory) override { + MOZ_CRASH("This method should not be called"); + return NS_OK; + } + + nsresult GetEncodedSubmission(nsIURI* aURI, nsIInputStream** aPostDataStream, + nsCOMPtr& aOutURI) override { + MOZ_CRASH("This method should not be called"); + return NS_OK; + } + + DialogFormSubmission* GetAsDialogSubmission() override { return this; } + + HTMLDialogElement* DialogElement() { return mDialogElement; } + + nsString& ReturnValue() { return mReturnValue; } + + private: + const RefPtr mDialogElement; + nsString mReturnValue; +}; + +/** + * Handle multipart/form-data encoding, which does files as well as normal + * inputs. This always does POST. + */ +class FSMultipartFormData : public EncodingFormSubmission { + public: + /** + * @param aEncoding the character encoding of the form + */ + FSMultipartFormData(nsIURI* aActionURL, const nsAString& aTarget, + mozilla::NotNull aEncoding, + Element* aSubmitter); + ~FSMultipartFormData(); + + virtual nsresult AddNameValuePair(const nsAString& aName, + const nsAString& aValue) override; + + virtual nsresult AddNameBlobPair(const nsAString& aName, + Blob* aBlob) override; + + virtual nsresult AddNameDirectoryPair(const nsAString& aName, + Directory* aDirectory) override; + + virtual nsresult GetEncodedSubmission(nsIURI* aURI, + nsIInputStream** aPostDataStream, + nsCOMPtr& aOutURI) override; + + void GetContentType(nsACString& aContentType) { + aContentType = "multipart/form-data; boundary="_ns + mBoundary; + } + + nsIInputStream* GetSubmissionBody(uint64_t* aContentLength); + + protected: + /** + * Roll up the data we have so far and add it to the multiplexed data stream. + */ + nsresult AddPostDataStream(); + + private: + void AddDataChunk(const nsACString& aName, const nsACString& aFilename, + const nsACString& aContentType, + nsIInputStream* aInputStream, uint64_t aInputStreamSize); + /** + * The post data stream as it is so far. This is a collection of smaller + * chunks--string streams and file streams interleaved to make one big POST + * stream. + */ + nsCOMPtr mPostData; + + /** + * The same stream, but as an nsIInputStream. + * Raw pointers because it is just QI of mInputStream. + */ + nsIInputStream* mPostDataStream; + + /** + * The current string chunk. When a file is hit, the string chunk gets + * wrapped up into an input stream and put into mPostDataStream so that the + * file input stream can then be appended and everything is in the right + * order. Then the string chunk gets appended to again as we process more + * name/value pairs. + */ + nsCString mPostDataChunk; + + /** + * The boundary string to use after each "part" (the boundary that marks the + * end of a value). This is computed randomly and is different for each + * submission. + */ + nsCString mBoundary; + + /** + * The total length in bytes of the streams that make up mPostDataStream + */ + uint64_t mTotalLength; +}; + +} // namespace mozilla::dom + +#endif /* mozilla_dom_HTMLFormSubmission_h */ -- cgit v1.2.3