Source code

Revision control

Other Tools

/* -*- 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/Element.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 {
namespace dom {
class Blob;
class Directory;
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<const Encoding*>& 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 if the aBlob is
* not null.
*/
virtual nsresult AddNameBlobOrNullPair(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<nsIURI>& aOutURI) = 0;
/**
* Get the charset that will be used for submission.
*/
void GetCharset(nsACString& aCharset) { mEncoding->Name(aCharset); }
Element* GetSubmitterElement() const { return mSubmitter.get(); }
/**
* 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
* @param aSubmitter the submitter element (can be null)
*/
HTMLFormSubmission(nsIURI* aActionURL, const nsAString& aTarget,
mozilla::NotNull<const mozilla::Encoding*> aEncoding,
Element* aSubmitter)
: mActionURL(aActionURL),
mTarget(aTarget),
mEncoding(aEncoding),
mSubmitter(aSubmitter),
mInitiatedFromUserInput(UserActivation::IsHandlingUserInput()) {
MOZ_COUNT_CTOR(HTMLFormSubmission);
}
// The action url.
nsCOMPtr<nsIURI> mActionURL;
// The target.
nsString mTarget;
// The character encoding of this form submission
mozilla::NotNull<const mozilla::Encoding*> mEncoding;
// Submitter element.
RefPtr<Element> mSubmitter;
// 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<const mozilla::Encoding*> aEncoding,
Element* aSubmitter);
virtual ~EncodingFormSubmission();
/**
* Encode a Unicode string to bytes using the encoder (or just copy the input
* if there is no encoder).
* @param aStr the string to encode
* @param aResult the encoded string [OUT]
* @param aHeaderEncode If true, turns all linebreaks into spaces and escapes
* all quotes
* @throws an error if UnicodeToNewBytes fails
*/
nsresult EncodeVal(const nsAString& aStr, nsCString& aResult,
bool aHeaderEncode);
};
class DialogFormSubmission final : public HTMLFormSubmission {
public:
DialogFormSubmission(nsAString& aResult, nsIURI* aActionURL,
const nsAString& aTarget,
NotNull<const Encoding*> aEncoding, Element* aSubmitter,
HTMLDialogElement* aDialogElement)
: HTMLFormSubmission(aActionURL, aTarget, aEncoding, aSubmitter),
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 AddNameBlobOrNullPair(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<nsIURI>& 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<HTMLDialogElement> 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<const mozilla::Encoding*> aEncoding,
Element* aSubmitter);
~FSMultipartFormData();
virtual nsresult AddNameValuePair(const nsAString& aName,
const nsAString& aValue) override;
virtual nsresult AddNameBlobOrNullPair(const nsAString& aName,
Blob* aBlob) override;
virtual nsresult AddNameDirectoryPair(const nsAString& aName,
Directory* aDirectory) override;
virtual nsresult GetEncodedSubmission(nsIURI* aURI,
nsIInputStream** aPostDataStream,
nsCOMPtr<nsIURI>& 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<nsIMultiplexInputStream> 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 dom
} // namespace mozilla
#endif /* mozilla_dom_HTMLFormSubmission_h */