forked from mirrors/gecko-dev
288 lines
9.3 KiB
C++
288 lines
9.3 KiB
C++
/* -*- 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 {
|
|
namespace dom {
|
|
|
|
class Blob;
|
|
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<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);
|
|
|
|
// 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 */
|