mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-06 15:58:39 +09:00
Merge remote-tracking branch 'origin/master' into custom
This commit is contained in:
roytam1
commit
75da290189
25 changed files with 2660 additions and 1361 deletions
|
|
@ -9140,10 +9140,6 @@ ShouldEscape(nsIContent* aParent)
|
|||
nsGkAtoms::style, nsGkAtoms::script, nsGkAtoms::xmp,
|
||||
nsGkAtoms::iframe, nsGkAtoms::noembed, nsGkAtoms::noframes,
|
||||
nsGkAtoms::plaintext,
|
||||
// Per the current spec noscript should be escaped in case
|
||||
// scripts are disabled or if document doesn't have
|
||||
// browsing context. However the latter seems to be a spec bug
|
||||
// and Gecko hasn't traditionally done the former.
|
||||
nsGkAtoms::noscript
|
||||
};
|
||||
static mozilla::BloomFilter<12, nsIAtom> sFilter;
|
||||
|
|
@ -9159,6 +9155,10 @@ ShouldEscape(nsIContent* aParent)
|
|||
if (sFilter.mightContain(tag)) {
|
||||
for (uint32_t i = 0; i < ArrayLength(nonEscapingElements); ++i) {
|
||||
if (tag == nonEscapingElements[i]) {
|
||||
if (MOZ_UNLIKELY(tag == nsGkAtoms::noscript) &&
|
||||
MOZ_UNLIKELY(!aParent->OwnerDoc()->IsScriptEnabled())) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -866,7 +866,7 @@ HTMLInputElement::InitFilePicker(FilePickerType aType)
|
|||
mode = static_cast<int16_t>(nsIFilePicker::modeOpen);
|
||||
}
|
||||
|
||||
nsresult rv = filePicker->Init(win, title, mode);
|
||||
nsresult rv = filePicker->Init(win, title, mode, /*aRequireInteraction = */ true);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
if (!okButtonLabel.IsEmpty()) {
|
||||
|
|
|
|||
|
|
@ -4600,8 +4600,12 @@ void HTMLMediaElement::DecodeError(const MediaResult& aError)
|
|||
}
|
||||
} else if (mReadyState == nsIDOMHTMLMediaElement::HAVE_NOTHING) {
|
||||
NoSupportedMediaSourceError(aError.Description());
|
||||
} else {
|
||||
} else if (IsCORSSameOrigin()) {
|
||||
Error(MEDIA_ERR_DECODE, aError.Description());
|
||||
} else {
|
||||
nsAutoCString eMessage;
|
||||
eMessage.AssignLiteral("Failed to decode media");
|
||||
Error(MEDIA_ERR_DECODE, eMessage);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -248,7 +248,8 @@ FilePickerParent::CreateFilePicker()
|
|||
return false;
|
||||
}
|
||||
|
||||
return NS_SUCCEEDED(mFilePicker->Init(window, mTitle, mMode));
|
||||
return NS_SUCCEEDED(mFilePicker->Init(window, mTitle, mMode,
|
||||
element->IsNodeOfType(nsINode::eHTML_FORM_CONTROL)));
|
||||
}
|
||||
|
||||
bool
|
||||
|
|
|
|||
|
|
@ -99,6 +99,12 @@ bool OpenTypeGLYF::ParseSimpleGlyph(Buffer &glyph,
|
|||
num_flags = tmp_index + 1;
|
||||
}
|
||||
|
||||
if (this->maxp->version_1 &&
|
||||
num_flags > this->maxp->max_points) {
|
||||
Warning("Number of contour points exceeds maxp maxPoints, adjusting limit.");
|
||||
this->maxp->max_points = num_flags;
|
||||
}
|
||||
|
||||
uint16_t bytecode_length = 0;
|
||||
if (!glyph.ReadU16(&bytecode_length)) {
|
||||
return Error("Can't read bytecode length");
|
||||
|
|
@ -144,7 +150,9 @@ bool OpenTypeGLYF::ParseSimpleGlyph(Buffer &glyph,
|
|||
#define WE_HAVE_A_TWO_BY_TWO (1u << 7)
|
||||
#define WE_HAVE_INSTRUCTIONS (1u << 8)
|
||||
|
||||
bool OpenTypeGLYF::ParseCompositeGlyph(Buffer &glyph) {
|
||||
bool OpenTypeGLYF::ParseCompositeGlyph(
|
||||
Buffer &glyph,
|
||||
ComponentPointCount* component_point_count) {
|
||||
uint16_t flags = 0;
|
||||
uint16_t gid = 0;
|
||||
do {
|
||||
|
|
@ -193,6 +201,10 @@ bool OpenTypeGLYF::ParseCompositeGlyph(Buffer &glyph) {
|
|||
return Error("Can't read transform");
|
||||
}
|
||||
}
|
||||
|
||||
// Push inital components on stack at level 1
|
||||
// to traverse them in parent function.
|
||||
component_point_count->gid_stack.push_back({gid, 1});
|
||||
} while (flags & MORE_COMPONENTS);
|
||||
|
||||
if (flags & WE_HAVE_INSTRUCTIONS) {
|
||||
|
|
@ -243,29 +255,14 @@ bool OpenTypeGLYF::Parse(const uint8_t *data, size_t length) {
|
|||
uint32_t current_offset = 0;
|
||||
|
||||
for (unsigned i = 0; i < num_glyphs; ++i) {
|
||||
const unsigned gly_offset = offsets[i];
|
||||
// The LOCA parser checks that these values are monotonic
|
||||
const unsigned gly_length = offsets[i + 1] - offsets[i];
|
||||
if (!gly_length) {
|
||||
// this glyph has no outline (e.g. the space charactor)
|
||||
Buffer glyph(GetGlyphBufferSection(data, length, offsets, i));
|
||||
if (!glyph.buffer())
|
||||
return false;
|
||||
if (!glyph.length()) {
|
||||
resulting_offsets[i] = current_offset;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (gly_offset >= length) {
|
||||
return Error("Glyph %d offset %d too high %ld", i, gly_offset, length);
|
||||
}
|
||||
// Since these are unsigned types, the compiler is not allowed to assume
|
||||
// that they never overflow.
|
||||
if (gly_offset + gly_length < gly_offset) {
|
||||
return Error("Glyph %d length (%d < 0)!", i, gly_length);
|
||||
}
|
||||
if (gly_offset + gly_length > length) {
|
||||
return Error("Glyph %d length %d too high", i, gly_length);
|
||||
}
|
||||
|
||||
Buffer glyph(data + gly_offset, gly_length);
|
||||
|
||||
int16_t num_contours, xmin, ymin, xmax, ymax;
|
||||
if (!glyph.ReadS16(&num_contours) ||
|
||||
!glyph.ReadS16(&xmin) ||
|
||||
|
|
@ -302,9 +299,56 @@ bool OpenTypeGLYF::Parse(const uint8_t *data, size_t length) {
|
|||
return Error("Failed to parse glyph %d", i);
|
||||
}
|
||||
} else {
|
||||
if (!ParseCompositeGlyph(glyph)) {
|
||||
ComponentPointCount component_point_count;
|
||||
if (!ParseCompositeGlyph(glyph, &component_point_count)) {
|
||||
return Error("Failed to parse glyph %d", i);
|
||||
}
|
||||
|
||||
// Check maxComponentDepth and validate maxComponentPoints.
|
||||
// ParseCompositeGlyph placed the first set of component glyphs on the
|
||||
// component_point_count.gid_stack, which we start to process below. If a
|
||||
// nested glyph is in turn a component glyph, additional glyphs are placed
|
||||
// on the stack.
|
||||
while (component_point_count.gid_stack.size()) {
|
||||
GidAtLevel stack_top_gid = component_point_count.gid_stack.back();
|
||||
component_point_count.gid_stack.pop_back();
|
||||
|
||||
Buffer points_count_glyph(GetGlyphBufferSection(
|
||||
data,
|
||||
length,
|
||||
offsets,
|
||||
stack_top_gid.gid));
|
||||
|
||||
if (!points_count_glyph.buffer())
|
||||
return false;
|
||||
|
||||
if (!points_count_glyph.length())
|
||||
continue;
|
||||
|
||||
if (!TraverseComponentsCountingPoints(points_count_glyph,
|
||||
i,
|
||||
stack_top_gid.level,
|
||||
&component_point_count)) {
|
||||
return Error("Error validating component points and depth.");
|
||||
}
|
||||
|
||||
if (component_point_count.accumulated_component_points >
|
||||
std::numeric_limits<uint16_t>::max()) {
|
||||
return Error("Illegal composite points value "
|
||||
"exceeding 0xFFFF for base glyph %d.", i);
|
||||
} else if (this->maxp->version_1 &&
|
||||
component_point_count.accumulated_component_points >
|
||||
this->maxp->max_c_points) {
|
||||
Warning("Number of composite points in glyph %d exceeds "
|
||||
"maxp maxCompositePoints: %d vs %d, adjusting limit.",
|
||||
i,
|
||||
component_point_count.accumulated_component_points,
|
||||
this->maxp->max_c_points
|
||||
);
|
||||
this->maxp->max_c_points =
|
||||
component_point_count.accumulated_component_points;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
size_t new_size = glyph.offset();
|
||||
|
|
@ -344,6 +388,123 @@ bool OpenTypeGLYF::Parse(const uint8_t *data, size_t length) {
|
|||
return true;
|
||||
}
|
||||
|
||||
bool OpenTypeGLYF::TraverseComponentsCountingPoints(
|
||||
Buffer &glyph,
|
||||
uint16_t base_glyph_id,
|
||||
uint32_t level,
|
||||
ComponentPointCount* component_point_count) {
|
||||
|
||||
int16_t num_contours;
|
||||
if (!glyph.ReadS16(&num_contours) ||
|
||||
!glyph.Skip(8)) {
|
||||
return Error("Can't read glyph header.");
|
||||
}
|
||||
|
||||
if (num_contours <= -2) {
|
||||
return Error("Bad number of contours %d in glyph.", num_contours);
|
||||
}
|
||||
|
||||
if (num_contours == 0)
|
||||
return true;
|
||||
|
||||
// FontTools counts a component level for each traversed recursion. We start
|
||||
// counting at level 0. If we reach a level that's deeper than
|
||||
// maxComponentDepth, we expand maxComponentDepth unless it's larger than
|
||||
// the maximum possible depth.
|
||||
if (level > std::numeric_limits<uint16_t>::max()) {
|
||||
return Error("Illegal component depth exceeding 0xFFFF in base glyph id %d.",
|
||||
base_glyph_id);
|
||||
} else if (this->maxp->version_1 &&
|
||||
level > this->maxp->max_c_depth) {
|
||||
this->maxp->max_c_depth = level;
|
||||
Warning("Component depth exceeds maxp maxComponentDepth "
|
||||
"in glyph %d, adjust limit to %d.",
|
||||
base_glyph_id, level);
|
||||
}
|
||||
|
||||
if (num_contours > 0) {
|
||||
uint16_t num_points = 0;
|
||||
for (int i = 0; i < num_contours; ++i) {
|
||||
// Simple glyph, add contour points.
|
||||
uint16_t tmp_index = 0;
|
||||
if (!glyph.ReadU16(&tmp_index)) {
|
||||
return Error("Can't read contour index %d", i);
|
||||
}
|
||||
num_points = tmp_index + 1;
|
||||
}
|
||||
|
||||
component_point_count->accumulated_component_points += num_points;
|
||||
return true;
|
||||
} else {
|
||||
assert(num_contours == -1);
|
||||
|
||||
// Composite glyph, add gid's to stack.
|
||||
uint16_t flags = 0;
|
||||
uint16_t gid = 0;
|
||||
do {
|
||||
if (!glyph.ReadU16(&flags) || !glyph.ReadU16(&gid)) {
|
||||
return Error("Can't read composite glyph flags or glyphIndex");
|
||||
}
|
||||
|
||||
size_t skip_bytes = 0;
|
||||
skip_bytes += flags & ARG_1_AND_2_ARE_WORDS ? 4 : 2;
|
||||
|
||||
if (flags & WE_HAVE_A_SCALE) {
|
||||
skip_bytes += 2;
|
||||
} else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
|
||||
skip_bytes += 4;
|
||||
} else if (flags & WE_HAVE_A_TWO_BY_TWO) {
|
||||
skip_bytes += 8;
|
||||
}
|
||||
|
||||
if (!glyph.Skip(skip_bytes)) {
|
||||
return Error("Failed to parse component glyph.");
|
||||
}
|
||||
|
||||
if (gid >= this->maxp->num_glyphs) {
|
||||
return Error("Invalid glyph id used in composite glyph: %d", gid);
|
||||
}
|
||||
|
||||
component_point_count->gid_stack.push_back({gid, level + 1u});
|
||||
} while (flags & MORE_COMPONENTS);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
Buffer OpenTypeGLYF::GetGlyphBufferSection(
|
||||
const uint8_t *data,
|
||||
size_t length,
|
||||
const std::vector<uint32_t>& loca_offsets,
|
||||
unsigned glyph_id) {
|
||||
|
||||
Buffer null_buffer(nullptr, 0);
|
||||
|
||||
const unsigned gly_offset = loca_offsets[glyph_id];
|
||||
// The LOCA parser checks that these values are monotonic
|
||||
const unsigned gly_length = loca_offsets[glyph_id + 1] - loca_offsets[glyph_id];
|
||||
if (!gly_length) {
|
||||
// this glyph has no outline (e.g. the space character)
|
||||
return Buffer(data + gly_offset, 0);
|
||||
}
|
||||
|
||||
if (gly_offset >= length) {
|
||||
Error("Glyph %d offset %d too high %ld", glyph_id, gly_offset, length);
|
||||
return null_buffer;
|
||||
}
|
||||
// Since these are unsigned types, the compiler is not allowed to assume
|
||||
// that they never overflow.
|
||||
if (gly_offset + gly_length < gly_offset) {
|
||||
Error("Glyph %d length (%d < 0)!", glyph_id, gly_length);
|
||||
return null_buffer;
|
||||
}
|
||||
if (gly_offset + gly_length > length) {
|
||||
Error("Glyph %d length %d too high", glyph_id, gly_length);
|
||||
return null_buffer;
|
||||
}
|
||||
|
||||
return Buffer(data + gly_offset, gly_length);
|
||||
}
|
||||
|
||||
bool OpenTypeGLYF::Serialize(OTSStream *out) {
|
||||
for (unsigned i = 0; i < this->iov.size(); ++i) {
|
||||
if (!out->Write(this->iov[i].first, this->iov[i].second)) {
|
||||
|
|
|
|||
|
|
@ -23,12 +23,38 @@ class OpenTypeGLYF : public Table {
|
|||
bool Serialize(OTSStream *out);
|
||||
|
||||
private:
|
||||
struct GidAtLevel {
|
||||
uint16_t gid;
|
||||
uint32_t level;
|
||||
};
|
||||
|
||||
struct ComponentPointCount {
|
||||
ComponentPointCount() : accumulated_component_points(0) {};
|
||||
uint32_t accumulated_component_points;
|
||||
std::vector<GidAtLevel> gid_stack;
|
||||
};
|
||||
|
||||
bool ParseFlagsForSimpleGlyph(Buffer &glyph,
|
||||
uint32_t num_flags,
|
||||
uint32_t *flag_index,
|
||||
uint32_t *coordinates_length);
|
||||
bool ParseSimpleGlyph(Buffer &glyph, int16_t num_contours);
|
||||
bool ParseCompositeGlyph(Buffer &glyph);
|
||||
bool ParseCompositeGlyph(
|
||||
Buffer &glyph,
|
||||
ComponentPointCount* component_point_count);
|
||||
|
||||
|
||||
bool TraverseComponentsCountingPoints(
|
||||
Buffer& glyph,
|
||||
uint16_t base_glyph_id,
|
||||
uint32_t level,
|
||||
ComponentPointCount* component_point_count);
|
||||
|
||||
Buffer GetGlyphBufferSection(
|
||||
const uint8_t *data,
|
||||
size_t length,
|
||||
const std::vector<uint32_t>& loca_offsets,
|
||||
unsigned glyph_id);
|
||||
|
||||
OpenTypeMAXP* maxp;
|
||||
|
||||
|
|
|
|||
2379
mfbt/lz4.c
2379
mfbt/lz4.c
File diff suppressed because it is too large
Load diff
789
mfbt/lz4.h
789
mfbt/lz4.h
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* LZ4 - Fast LZ compression algorithm
|
||||
* Header File
|
||||
* Copyright (C) 2011-2017, Yann Collet.
|
||||
* Copyright (C) 2011-present, Yann Collet.
|
||||
|
||||
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
|
||||
|
||||
|
|
@ -46,24 +46,31 @@ extern "C" {
|
|||
/**
|
||||
Introduction
|
||||
|
||||
LZ4 is lossless compression algorithm, providing compression speed at 400 MB/s per core,
|
||||
LZ4 is lossless compression algorithm, providing compression speed >500 MB/s per core,
|
||||
scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
|
||||
multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
|
||||
|
||||
The LZ4 compression library provides in-memory compression and decompression functions.
|
||||
It gives full buffer control to user.
|
||||
Compression can be done in:
|
||||
- a single step (described as Simple Functions)
|
||||
- a single step, reusing a context (described in Advanced Functions)
|
||||
- unbounded multiple steps (described as Streaming compression)
|
||||
|
||||
lz4.h provides block compression functions. It gives full buffer control to user.
|
||||
Decompressing an lz4-compressed block also requires metadata (such as compressed size).
|
||||
Each application is free to encode such metadata in whichever way it wants.
|
||||
lz4.h generates and decodes LZ4-compressed blocks (doc/lz4_Block_format.md).
|
||||
Decompressing such a compressed block requires additional metadata.
|
||||
Exact metadata depends on exact decompression function.
|
||||
For the typical case of LZ4_decompress_safe(),
|
||||
metadata includes block's compressed size, and maximum bound of decompressed size.
|
||||
Each application is free to encode and pass such metadata in whichever way it wants.
|
||||
|
||||
An additional format, called LZ4 frame specification (doc/lz4_Frame_format.md),
|
||||
take care of encoding standard metadata alongside LZ4-compressed blocks.
|
||||
If your application requires interoperability, it's recommended to use it.
|
||||
A library is provided to take care of it, see lz4frame.h.
|
||||
lz4.h only handle blocks, it can not generate Frames.
|
||||
|
||||
Blocks are different from Frames (doc/lz4_Frame_format.md).
|
||||
Frames bundle both blocks and metadata in a specified manner.
|
||||
Embedding metadata is required for compressed data to be self-contained and portable.
|
||||
Frame format is delivered through a companion API, declared in lz4frame.h.
|
||||
The `lz4` CLI can only manage frames.
|
||||
*/
|
||||
|
||||
/*^***************************************************************
|
||||
|
|
@ -72,24 +79,28 @@ extern "C" {
|
|||
/*
|
||||
* LZ4_DLL_EXPORT :
|
||||
* Enable exporting of functions when building a Windows DLL
|
||||
* LZ4LIB_API :
|
||||
* LZ4LIB_VISIBILITY :
|
||||
* Control library symbols visibility.
|
||||
*/
|
||||
#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
|
||||
# define LZ4LIB_API __declspec(dllexport)
|
||||
#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
|
||||
# define LZ4LIB_API __declspec(dllimport) /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
|
||||
#elif defined(__GNUC__) && (__GNUC__ >= 4)
|
||||
# define LZ4LIB_API __attribute__ ((__visibility__ ("default")))
|
||||
#else
|
||||
# define LZ4LIB_API
|
||||
#ifndef LZ4LIB_VISIBILITY
|
||||
# if defined(__GNUC__) && (__GNUC__ >= 4)
|
||||
# define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default")))
|
||||
# else
|
||||
# define LZ4LIB_VISIBILITY
|
||||
# endif
|
||||
#endif
|
||||
#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
|
||||
# define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY
|
||||
#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
|
||||
# define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
|
||||
#else
|
||||
# define LZ4LIB_API LZ4LIB_VISIBILITY
|
||||
#endif
|
||||
|
||||
|
||||
/*------ Version ------*/
|
||||
#define LZ4_VERSION_MAJOR 1 /* for breaking interface changes */
|
||||
#define LZ4_VERSION_MINOR 8 /* for new (non-breaking) interface capabilities */
|
||||
#define LZ4_VERSION_RELEASE 0 /* for tweaks, bug-fixes, or development */
|
||||
#define LZ4_VERSION_MINOR 9 /* for new (non-breaking) interface capabilities */
|
||||
#define LZ4_VERSION_RELEASE 3 /* for tweaks, bug-fixes, or development */
|
||||
|
||||
#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
|
||||
|
||||
|
|
@ -98,8 +109,8 @@ extern "C" {
|
|||
#define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
|
||||
#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)
|
||||
|
||||
LZ4LIB_API int LZ4_versionNumber (void); /**< library version number; to be used when checking dll version */
|
||||
LZ4LIB_API const char* LZ4_versionString (void); /**< library version string; to be used when checking dll version */
|
||||
LZ4LIB_API int LZ4_versionNumber (void); /**< library version number; useful to check dll version */
|
||||
LZ4LIB_API const char* LZ4_versionString (void); /**< library version string; useful to check dll version */
|
||||
|
||||
|
||||
/*-************************************
|
||||
|
|
@ -108,42 +119,49 @@ LZ4LIB_API const char* LZ4_versionString (void); /**< library version string;
|
|||
/*!
|
||||
* LZ4_MEMORY_USAGE :
|
||||
* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
|
||||
* Increasing memory usage improves compression ratio
|
||||
* Reduced memory usage can improve speed, due to cache effect
|
||||
* Increasing memory usage improves compression ratio.
|
||||
* Reduced memory usage may improve speed, thanks to better cache locality.
|
||||
* Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
|
||||
*/
|
||||
#ifndef LZ4_MEMORY_USAGE
|
||||
# define LZ4_MEMORY_USAGE 14
|
||||
#endif
|
||||
|
||||
|
||||
/*-************************************
|
||||
* Simple Functions
|
||||
**************************************/
|
||||
/*! LZ4_compress_default() :
|
||||
Compresses 'sourceSize' bytes from buffer 'source'
|
||||
into already allocated 'dest' buffer of size 'maxDestSize'.
|
||||
Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
|
||||
It also runs faster, so it's a recommended setting.
|
||||
If the function cannot compress 'source' into a more limited 'dest' budget,
|
||||
compression stops *immediately*, and the function result is zero.
|
||||
As a consequence, 'dest' content is not valid.
|
||||
This function never writes outside 'dest' buffer, nor read outside 'source' buffer.
|
||||
sourceSize : Max supported value is LZ4_MAX_INPUT_VALUE
|
||||
maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
|
||||
return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
|
||||
or 0 if compression fails */
|
||||
LZ4LIB_API int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
|
||||
* Compresses 'srcSize' bytes from buffer 'src'
|
||||
* into already allocated 'dst' buffer of size 'dstCapacity'.
|
||||
* Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize).
|
||||
* It also runs faster, so it's a recommended setting.
|
||||
* If the function cannot compress 'src' into a more limited 'dst' budget,
|
||||
* compression stops *immediately*, and the function result is zero.
|
||||
* In which case, 'dst' content is undefined (invalid).
|
||||
* srcSize : max supported value is LZ4_MAX_INPUT_SIZE.
|
||||
* dstCapacity : size of buffer 'dst' (which must be already allocated)
|
||||
* @return : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity)
|
||||
* or 0 if compression fails
|
||||
* Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer).
|
||||
*/
|
||||
LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity);
|
||||
|
||||
/*! LZ4_decompress_safe() :
|
||||
compressedSize : is the precise full size of the compressed block.
|
||||
maxDecompressedSize : is the size of destination buffer, which must be already allocated.
|
||||
return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
|
||||
If destination buffer is not large enough, decoding will stop and output an error code (<0).
|
||||
If the source stream is detected malformed, the function will stop decoding and return a negative result.
|
||||
This function is protected against buffer overflow exploits, including malicious data packets.
|
||||
It never writes outside output buffer, nor reads outside input buffer.
|
||||
*/
|
||||
LZ4LIB_API int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
|
||||
* compressedSize : is the exact complete size of the compressed block.
|
||||
* dstCapacity : is the size of destination buffer (which must be already allocated), presumed an upper bound of decompressed size.
|
||||
* @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
|
||||
* If destination buffer is not large enough, decoding will stop and output an error code (negative value).
|
||||
* If the source stream is detected malformed, the function will stop decoding and return a negative result.
|
||||
* Note 1 : This function is protected against malicious data packets :
|
||||
* it will never writes outside 'dst' buffer, nor read outside 'source' buffer,
|
||||
* even if the compressed block is maliciously modified to order the decoder to do these actions.
|
||||
* In such case, the decoder stops immediately, and considers the compressed block malformed.
|
||||
* Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them.
|
||||
* The implementation is free to send / store / derive this information in whichever way is most beneficial.
|
||||
* If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead.
|
||||
*/
|
||||
LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity);
|
||||
|
||||
|
||||
/*-************************************
|
||||
|
|
@ -152,252 +170,489 @@ LZ4LIB_API int LZ4_decompress_safe (const char* source, char* dest, int compress
|
|||
#define LZ4_MAX_INPUT_SIZE 0x7E000000 /* 2 113 929 216 bytes */
|
||||
#define LZ4_COMPRESSBOUND(isize) ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
|
||||
|
||||
/*!
|
||||
LZ4_compressBound() :
|
||||
/*! LZ4_compressBound() :
|
||||
Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
|
||||
This function is primarily useful for memory allocation purposes (destination buffer size).
|
||||
Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
|
||||
Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
|
||||
Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize)
|
||||
inputSize : max supported value is LZ4_MAX_INPUT_SIZE
|
||||
return : maximum output size in a "worst case" scenario
|
||||
or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
|
||||
or 0, if input size is incorrect (too large or negative)
|
||||
*/
|
||||
LZ4LIB_API int LZ4_compressBound(int inputSize);
|
||||
|
||||
/*!
|
||||
LZ4_compress_fast() :
|
||||
Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
|
||||
/*! LZ4_compress_fast() :
|
||||
Same as LZ4_compress_default(), but allows selection of "acceleration" factor.
|
||||
The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
|
||||
It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
|
||||
An acceleration value of "1" is the same as regular LZ4_compress_default()
|
||||
Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
|
||||
Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c).
|
||||
Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c).
|
||||
*/
|
||||
LZ4LIB_API int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
|
||||
LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
|
||||
|
||||
|
||||
/*!
|
||||
LZ4_compress_fast_extState() :
|
||||
Same compression function, just using an externally allocated memory space to store compression state.
|
||||
Use LZ4_sizeofState() to know how much memory must be allocated,
|
||||
and allocate it on 8-bytes boundaries (using malloc() typically).
|
||||
Then, provide it as 'void* state' to compression function.
|
||||
*/
|
||||
/*! LZ4_compress_fast_extState() :
|
||||
* Same as LZ4_compress_fast(), using an externally allocated memory space for its state.
|
||||
* Use LZ4_sizeofState() to know how much memory must be allocated,
|
||||
* and allocate it on 8-bytes boundaries (using `malloc()` typically).
|
||||
* Then, provide this buffer as `void* state` to compression function.
|
||||
*/
|
||||
LZ4LIB_API int LZ4_sizeofState(void);
|
||||
LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
|
||||
LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
|
||||
|
||||
|
||||
/*!
|
||||
LZ4_compress_destSize() :
|
||||
Reverse the logic, by compressing as much data as possible from 'source' buffer
|
||||
into already allocated buffer 'dest' of size 'targetDestSize'.
|
||||
This function either compresses the entire 'source' content into 'dest' if it's large enough,
|
||||
or fill 'dest' buffer completely with as much data as possible from 'source'.
|
||||
*sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'.
|
||||
New value is necessarily <= old value.
|
||||
return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
|
||||
or 0 if compression fails
|
||||
*/
|
||||
LZ4LIB_API int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
|
||||
/*! LZ4_compress_destSize() :
|
||||
* Reverse the logic : compresses as much data as possible from 'src' buffer
|
||||
* into already allocated buffer 'dst', of size >= 'targetDestSize'.
|
||||
* This function either compresses the entire 'src' content into 'dst' if it's large enough,
|
||||
* or fill 'dst' buffer completely with as much data as possible from 'src'.
|
||||
* note: acceleration parameter is fixed to "default".
|
||||
*
|
||||
* *srcSizePtr : will be modified to indicate how many bytes where read from 'src' to fill 'dst'.
|
||||
* New value is necessarily <= input value.
|
||||
* @return : Nb bytes written into 'dst' (necessarily <= targetDestSize)
|
||||
* or 0 if compression fails.
|
||||
*
|
||||
* Note : from v1.8.2 to v1.9.1, this function had a bug (fixed un v1.9.2+):
|
||||
* the produced compressed content could, in specific circumstances,
|
||||
* require to be decompressed into a destination buffer larger
|
||||
* by at least 1 byte than the content to decompress.
|
||||
* If an application uses `LZ4_compress_destSize()`,
|
||||
* it's highly recommended to update liblz4 to v1.9.2 or better.
|
||||
* If this can't be done or ensured,
|
||||
* the receiving decompression function should provide
|
||||
* a dstCapacity which is > decompressedSize, by at least 1 byte.
|
||||
* See https://github.com/lz4/lz4/issues/859 for details
|
||||
*/
|
||||
LZ4LIB_API int LZ4_compress_destSize (const char* src, char* dst, int* srcSizePtr, int targetDstSize);
|
||||
|
||||
|
||||
/*!
|
||||
LZ4_decompress_fast() :
|
||||
originalSize : is the original and therefore uncompressed size
|
||||
return : the number of bytes read from the source buffer (in other words, the compressed size)
|
||||
If the source stream is detected malformed, the function will stop decoding and return a negative result.
|
||||
Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
|
||||
note : This function fully respect memory boundaries for properly formed compressed data.
|
||||
It is a bit faster than LZ4_decompress_safe().
|
||||
However, it does not provide any protection against intentionally modified data stream (malicious input).
|
||||
Use this function in trusted environment only (data to decode comes from a trusted source).
|
||||
*/
|
||||
LZ4LIB_API int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
|
||||
|
||||
/*!
|
||||
LZ4_decompress_safe_partial() :
|
||||
This function decompress a compressed block of size 'compressedSize' at position 'source'
|
||||
into destination buffer 'dest' of size 'maxDecompressedSize'.
|
||||
The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
|
||||
reducing decompression time.
|
||||
return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
|
||||
Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
|
||||
Always control how many bytes were decoded.
|
||||
If the source stream is detected malformed, the function will stop decoding and return a negative result.
|
||||
This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
|
||||
*/
|
||||
LZ4LIB_API int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
|
||||
/*! LZ4_decompress_safe_partial() :
|
||||
* Decompress an LZ4 compressed block, of size 'srcSize' at position 'src',
|
||||
* into destination buffer 'dst' of size 'dstCapacity'.
|
||||
* Up to 'targetOutputSize' bytes will be decoded.
|
||||
* The function stops decoding on reaching this objective.
|
||||
* This can be useful to boost performance
|
||||
* whenever only the beginning of a block is required.
|
||||
*
|
||||
* @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize)
|
||||
* If source stream is detected malformed, function returns a negative result.
|
||||
*
|
||||
* Note 1 : @return can be < targetOutputSize, if compressed block contains less data.
|
||||
*
|
||||
* Note 2 : targetOutputSize must be <= dstCapacity
|
||||
*
|
||||
* Note 3 : this function effectively stops decoding on reaching targetOutputSize,
|
||||
* so dstCapacity is kind of redundant.
|
||||
* This is because in older versions of this function,
|
||||
* decoding operation would still write complete sequences.
|
||||
* Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize,
|
||||
* it could write more bytes, though only up to dstCapacity.
|
||||
* Some "margin" used to be required for this operation to work properly.
|
||||
* Thankfully, this is no longer necessary.
|
||||
* The function nonetheless keeps the same signature, in an effort to preserve API compatibility.
|
||||
*
|
||||
* Note 4 : If srcSize is the exact size of the block,
|
||||
* then targetOutputSize can be any value,
|
||||
* including larger than the block's decompressed size.
|
||||
* The function will, at most, generate block's decompressed size.
|
||||
*
|
||||
* Note 5 : If srcSize is _larger_ than block's compressed size,
|
||||
* then targetOutputSize **MUST** be <= block's decompressed size.
|
||||
* Otherwise, *silent corruption will occur*.
|
||||
*/
|
||||
LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity);
|
||||
|
||||
|
||||
/*-*********************************************
|
||||
* Streaming Compression Functions
|
||||
***********************************************/
|
||||
typedef union LZ4_stream_u LZ4_stream_t; /* incomplete type (defined later) */
|
||||
typedef union LZ4_stream_u LZ4_stream_t; /* incomplete type (defined later) */
|
||||
|
||||
/*! LZ4_createStream() and LZ4_freeStream() :
|
||||
* LZ4_createStream() will allocate and initialize an `LZ4_stream_t` structure.
|
||||
* LZ4_freeStream() releases its memory.
|
||||
*/
|
||||
LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
|
||||
LZ4LIB_API int LZ4_freeStream (LZ4_stream_t* streamPtr);
|
||||
|
||||
/*! LZ4_resetStream() :
|
||||
* An LZ4_stream_t structure can be allocated once and re-used multiple times.
|
||||
* Use this function to init an allocated `LZ4_stream_t` structure and start a new compression.
|
||||
/*! LZ4_resetStream_fast() : v1.9.0+
|
||||
* Use this to prepare an LZ4_stream_t for a new chain of dependent blocks
|
||||
* (e.g., LZ4_compress_fast_continue()).
|
||||
*
|
||||
* An LZ4_stream_t must be initialized once before usage.
|
||||
* This is automatically done when created by LZ4_createStream().
|
||||
* However, should the LZ4_stream_t be simply declared on stack (for example),
|
||||
* it's necessary to initialize it first, using LZ4_initStream().
|
||||
*
|
||||
* After init, start any new stream with LZ4_resetStream_fast().
|
||||
* A same LZ4_stream_t can be re-used multiple times consecutively
|
||||
* and compress multiple streams,
|
||||
* provided that it starts each new stream with LZ4_resetStream_fast().
|
||||
*
|
||||
* LZ4_resetStream_fast() is much faster than LZ4_initStream(),
|
||||
* but is not compatible with memory regions containing garbage data.
|
||||
*
|
||||
* Note: it's only useful to call LZ4_resetStream_fast()
|
||||
* in the context of streaming compression.
|
||||
* The *extState* functions perform their own resets.
|
||||
* Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive.
|
||||
*/
|
||||
LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
|
||||
LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr);
|
||||
|
||||
/*! LZ4_loadDict() :
|
||||
* Use this function to load a static dictionary into LZ4_stream.
|
||||
* Any previous data will be forgotten, only 'dictionary' will remain in memory.
|
||||
* Loading a size of 0 is allowed.
|
||||
* Return : dictionary size, in bytes (necessarily <= 64 KB)
|
||||
* Use this function to reference a static dictionary into LZ4_stream_t.
|
||||
* The dictionary must remain available during compression.
|
||||
* LZ4_loadDict() triggers a reset, so any previous data will be forgotten.
|
||||
* The same dictionary will have to be loaded on decompression side for successful decoding.
|
||||
* Dictionary are useful for better compression of small data (KB range).
|
||||
* While LZ4 accept any input as dictionary,
|
||||
* results are generally better when using Zstandard's Dictionary Builder.
|
||||
* Loading a size of 0 is allowed, and is the same as reset.
|
||||
* @return : loaded dictionary size, in bytes (necessarily <= 64 KB)
|
||||
*/
|
||||
LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
|
||||
|
||||
/*! LZ4_compress_fast_continue() :
|
||||
* Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio.
|
||||
* Important : Previous data blocks are assumed to remain present and unmodified !
|
||||
* 'dst' buffer must be already allocated.
|
||||
* Compress 'src' content using data from previously compressed blocks, for better compression ratio.
|
||||
* 'dst' buffer must be already allocated.
|
||||
* If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
|
||||
* If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function @return==0.
|
||||
* After an error, the stream status is invalid, it can only be reset or freed.
|
||||
*
|
||||
* @return : size of compressed block
|
||||
* or 0 if there is an error (typically, cannot fit into 'dst').
|
||||
*
|
||||
* Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block.
|
||||
* Each block has precise boundaries.
|
||||
* Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata.
|
||||
* It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together.
|
||||
*
|
||||
* Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory !
|
||||
*
|
||||
* Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB.
|
||||
* Make sure that buffers are separated, by at least one byte.
|
||||
* This construction ensures that each block only depends on previous block.
|
||||
*
|
||||
* Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.
|
||||
*
|
||||
* Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed.
|
||||
*/
|
||||
LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
|
||||
|
||||
/*! LZ4_saveDict() :
|
||||
* If previously compressed data block is not guaranteed to remain available at its current memory location,
|
||||
* If last 64KB data cannot be guaranteed to remain available at its current memory location,
|
||||
* save it into a safer place (char* safeBuffer).
|
||||
* Note : it's not necessary to call LZ4_loadDict() after LZ4_saveDict(), dictionary is immediately usable.
|
||||
* @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
|
||||
* This is schematically equivalent to a memcpy() followed by LZ4_loadDict(),
|
||||
* but is much faster, because LZ4_saveDict() doesn't need to rebuild tables.
|
||||
* @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error.
|
||||
*/
|
||||
LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
|
||||
LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize);
|
||||
|
||||
|
||||
/*-**********************************************
|
||||
* Streaming Decompression Functions
|
||||
* Bufferless synchronous API
|
||||
************************************************/
|
||||
typedef union LZ4_streamDecode_u LZ4_streamDecode_t; /* incomplete type (defined later) */
|
||||
typedef union LZ4_streamDecode_u LZ4_streamDecode_t; /* tracking context */
|
||||
|
||||
/*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() :
|
||||
* creation / destruction of streaming decompression tracking structure */
|
||||
* creation / destruction of streaming decompression tracking context.
|
||||
* A tracking context can be re-used multiple times.
|
||||
*/
|
||||
LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
|
||||
LZ4LIB_API int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
|
||||
|
||||
/*! LZ4_setStreamDecode() :
|
||||
* Use this function to instruct where to find the dictionary.
|
||||
* Setting a size of 0 is allowed (same effect as reset).
|
||||
* @return : 1 if OK, 0 if error
|
||||
* An LZ4_streamDecode_t context can be allocated once and re-used multiple times.
|
||||
* Use this function to start decompression of a new stream of blocks.
|
||||
* A dictionary can optionally be set. Use NULL or size 0 for a reset order.
|
||||
* Dictionary is presumed stable : it must remain accessible and unmodified during next decompression.
|
||||
* @return : 1 if OK, 0 if error
|
||||
*/
|
||||
LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
|
||||
|
||||
/*! LZ4_decoderRingBufferSize() : v1.8.2+
|
||||
* Note : in a ring buffer scenario (optional),
|
||||
* blocks are presumed decompressed next to each other
|
||||
* up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize),
|
||||
* at which stage it resumes from beginning of ring buffer.
|
||||
* When setting such a ring buffer for streaming decompression,
|
||||
* provides the minimum size of this ring buffer
|
||||
* to be compatible with any source respecting maxBlockSize condition.
|
||||
* @return : minimum ring buffer size,
|
||||
* or 0 if there is an error (invalid maxBlockSize).
|
||||
*/
|
||||
LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize);
|
||||
#define LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize) (65536 + 14 + (maxBlockSize)) /* for static allocation; maxBlockSize presumed valid */
|
||||
|
||||
/*! LZ4_decompress_*_continue() :
|
||||
* These decoding functions allow decompression of multiple blocks in "streaming" mode.
|
||||
* Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
|
||||
* In the case of a ring buffers, decoding buffer must be either :
|
||||
* - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
|
||||
* In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
|
||||
* - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
|
||||
* maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
|
||||
* These decoding functions allow decompression of consecutive blocks in "streaming" mode.
|
||||
* A block is an unsplittable entity, it must be presented entirely to a decompression function.
|
||||
* Decompression functions only accepts one block at a time.
|
||||
* The last 64KB of previously decoded data *must* remain available and unmodified at the memory position where they were decoded.
|
||||
* If less than 64KB of data has been decoded, all the data must be present.
|
||||
*
|
||||
* Special : if decompression side sets a ring buffer, it must respect one of the following conditions :
|
||||
* - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize).
|
||||
* maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes.
|
||||
* In which case, encoding and decoding buffers do not need to be synchronized.
|
||||
* Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize.
|
||||
* - Synchronized mode :
|
||||
* Decompression buffer size is _exactly_ the same as compression buffer size,
|
||||
* and follows exactly same update rule (block boundaries at same positions),
|
||||
* and decoding function is provided with exact decompressed size of each block (exception for last block of the stream),
|
||||
* _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).
|
||||
* - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes.
|
||||
* In which case, encoding and decoding buffers do not need to be synchronized,
|
||||
* and encoding ring buffer can have any size, including small ones ( < 64 KB).
|
||||
* - _At least_ 64 KB + 8 bytes + maxBlockSize.
|
||||
* In which case, encoding and decoding buffers do not need to be synchronized,
|
||||
* and encoding ring buffer can have any size, including larger than decoding buffer.
|
||||
* Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
|
||||
* and indicate where it is saved using LZ4_setStreamDecode()
|
||||
*
|
||||
* Whenever these conditions are not possible,
|
||||
* save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression,
|
||||
* then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block.
|
||||
*/
|
||||
LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
|
||||
LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
|
||||
LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int srcSize, int dstCapacity);
|
||||
|
||||
|
||||
/*! LZ4_decompress_*_usingDict() :
|
||||
* These decoding functions work the same as
|
||||
* a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue()
|
||||
* They are stand-alone, and don't need an LZ4_streamDecode_t structure.
|
||||
* Dictionary is presumed stable : it must remain accessible and unmodified during decompression.
|
||||
* Performance tip : Decompression speed can be substantially increased
|
||||
* when dst == dictStart + dictSize.
|
||||
*/
|
||||
LZ4LIB_API int LZ4_decompress_safe_usingDict (const char* source, char* dest, int compressedSize, int maxDecompressedSize, const char* dictStart, int dictSize);
|
||||
LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalSize, const char* dictStart, int dictSize);
|
||||
LZ4LIB_API int LZ4_decompress_safe_usingDict (const char* src, char* dst, int srcSize, int dstCapcity, const char* dictStart, int dictSize);
|
||||
|
||||
#endif /* LZ4_H_2983827168210 */
|
||||
|
||||
|
||||
/*^**********************************************
|
||||
/*^*************************************
|
||||
* !!!!!! STATIC LINKING ONLY !!!!!!
|
||||
***********************************************/
|
||||
/*-************************************
|
||||
* Private definitions
|
||||
**************************************
|
||||
* Do not use these definitions.
|
||||
* They are exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
|
||||
* Using these definitions will expose code to API and/or ABI break in future versions of the library.
|
||||
**************************************/
|
||||
***************************************/
|
||||
|
||||
/*-****************************************************************************
|
||||
* Experimental section
|
||||
*
|
||||
* Symbols declared in this section must be considered unstable. Their
|
||||
* signatures or semantics may change, or they may be removed altogether in the
|
||||
* future. They are therefore only safe to depend on when the caller is
|
||||
* statically linked against the library.
|
||||
*
|
||||
* To protect against unsafe usage, not only are the declarations guarded,
|
||||
* the definitions are hidden by default
|
||||
* when building LZ4 as a shared/dynamic library.
|
||||
*
|
||||
* In order to access these declarations,
|
||||
* define LZ4_STATIC_LINKING_ONLY in your application
|
||||
* before including LZ4's headers.
|
||||
*
|
||||
* In order to make their implementations accessible dynamically, you must
|
||||
* define LZ4_PUBLISH_STATIC_FUNCTIONS when building the LZ4 library.
|
||||
******************************************************************************/
|
||||
|
||||
#ifdef LZ4_STATIC_LINKING_ONLY
|
||||
|
||||
#ifndef LZ4_STATIC_3504398509
|
||||
#define LZ4_STATIC_3504398509
|
||||
|
||||
#ifdef LZ4_PUBLISH_STATIC_FUNCTIONS
|
||||
#define LZ4LIB_STATIC_API LZ4LIB_API
|
||||
#else
|
||||
#define LZ4LIB_STATIC_API
|
||||
#endif
|
||||
|
||||
|
||||
/*! LZ4_compress_fast_extState_fastReset() :
|
||||
* A variant of LZ4_compress_fast_extState().
|
||||
*
|
||||
* Using this variant avoids an expensive initialization step.
|
||||
* It is only safe to call if the state buffer is known to be correctly initialized already
|
||||
* (see above comment on LZ4_resetStream_fast() for a definition of "correctly initialized").
|
||||
* From a high level, the difference is that
|
||||
* this function initializes the provided state with a call to something like LZ4_resetStream_fast()
|
||||
* while LZ4_compress_fast_extState() starts with a call to LZ4_resetStream().
|
||||
*/
|
||||
LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
|
||||
|
||||
/*! LZ4_attach_dictionary() :
|
||||
* This is an experimental API that allows
|
||||
* efficient use of a static dictionary many times.
|
||||
*
|
||||
* Rather than re-loading the dictionary buffer into a working context before
|
||||
* each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a
|
||||
* working LZ4_stream_t, this function introduces a no-copy setup mechanism,
|
||||
* in which the working stream references the dictionary stream in-place.
|
||||
*
|
||||
* Several assumptions are made about the state of the dictionary stream.
|
||||
* Currently, only streams which have been prepared by LZ4_loadDict() should
|
||||
* be expected to work.
|
||||
*
|
||||
* Alternatively, the provided dictionaryStream may be NULL,
|
||||
* in which case any existing dictionary stream is unset.
|
||||
*
|
||||
* If a dictionary is provided, it replaces any pre-existing stream history.
|
||||
* The dictionary contents are the only history that can be referenced and
|
||||
* logically immediately precede the data compressed in the first subsequent
|
||||
* compression call.
|
||||
*
|
||||
* The dictionary will only remain attached to the working stream through the
|
||||
* first compression call, at the end of which it is cleared. The dictionary
|
||||
* stream (and source buffer) must remain in-place / accessible / unchanged
|
||||
* through the completion of the first compression call on the stream.
|
||||
*/
|
||||
LZ4LIB_STATIC_API void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream);
|
||||
|
||||
|
||||
/*! In-place compression and decompression
|
||||
*
|
||||
* It's possible to have input and output sharing the same buffer,
|
||||
* for highly contrained memory environments.
|
||||
* In both cases, it requires input to lay at the end of the buffer,
|
||||
* and decompression to start at beginning of the buffer.
|
||||
* Buffer size must feature some margin, hence be larger than final size.
|
||||
*
|
||||
* |<------------------------buffer--------------------------------->|
|
||||
* |<-----------compressed data--------->|
|
||||
* |<-----------decompressed size------------------>|
|
||||
* |<----margin---->|
|
||||
*
|
||||
* This technique is more useful for decompression,
|
||||
* since decompressed size is typically larger,
|
||||
* and margin is short.
|
||||
*
|
||||
* In-place decompression will work inside any buffer
|
||||
* which size is >= LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize).
|
||||
* This presumes that decompressedSize > compressedSize.
|
||||
* Otherwise, it means compression actually expanded data,
|
||||
* and it would be more efficient to store such data with a flag indicating it's not compressed.
|
||||
* This can happen when data is not compressible (already compressed, or encrypted).
|
||||
*
|
||||
* For in-place compression, margin is larger, as it must be able to cope with both
|
||||
* history preservation, requiring input data to remain unmodified up to LZ4_DISTANCE_MAX,
|
||||
* and data expansion, which can happen when input is not compressible.
|
||||
* As a consequence, buffer size requirements are much higher,
|
||||
* and memory savings offered by in-place compression are more limited.
|
||||
*
|
||||
* There are ways to limit this cost for compression :
|
||||
* - Reduce history size, by modifying LZ4_DISTANCE_MAX.
|
||||
* Note that it is a compile-time constant, so all compressions will apply this limit.
|
||||
* Lower values will reduce compression ratio, except when input_size < LZ4_DISTANCE_MAX,
|
||||
* so it's a reasonable trick when inputs are known to be small.
|
||||
* - Require the compressor to deliver a "maximum compressed size".
|
||||
* This is the `dstCapacity` parameter in `LZ4_compress*()`.
|
||||
* When this size is < LZ4_COMPRESSBOUND(inputSize), then compression can fail,
|
||||
* in which case, the return code will be 0 (zero).
|
||||
* The caller must be ready for these cases to happen,
|
||||
* and typically design a backup scheme to send data uncompressed.
|
||||
* The combination of both techniques can significantly reduce
|
||||
* the amount of margin required for in-place compression.
|
||||
*
|
||||
* In-place compression can work in any buffer
|
||||
* which size is >= (maxCompressedSize)
|
||||
* with maxCompressedSize == LZ4_COMPRESSBOUND(srcSize) for guaranteed compression success.
|
||||
* LZ4_COMPRESS_INPLACE_BUFFER_SIZE() depends on both maxCompressedSize and LZ4_DISTANCE_MAX,
|
||||
* so it's possible to reduce memory requirements by playing with them.
|
||||
*/
|
||||
|
||||
#define LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize) (((compressedSize) >> 8) + 32)
|
||||
#define LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize) ((decompressedSize) + LZ4_DECOMPRESS_INPLACE_MARGIN(decompressedSize)) /**< note: presumes that compressedSize < decompressedSize. note2: margin is overestimated a bit, since it could use compressedSize instead */
|
||||
|
||||
#ifndef LZ4_DISTANCE_MAX /* history window size; can be user-defined at compile time */
|
||||
# define LZ4_DISTANCE_MAX 65535 /* set to maximum value by default */
|
||||
#endif
|
||||
|
||||
#define LZ4_COMPRESS_INPLACE_MARGIN (LZ4_DISTANCE_MAX + 32) /* LZ4_DISTANCE_MAX can be safely replaced by srcSize when it's smaller */
|
||||
#define LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCompressedSize) ((maxCompressedSize) + LZ4_COMPRESS_INPLACE_MARGIN) /**< maxCompressedSize is generally LZ4_COMPRESSBOUND(inputSize), but can be set to any lower value, with the risk that compression can fail (return code 0(zero)) */
|
||||
|
||||
#endif /* LZ4_STATIC_3504398509 */
|
||||
#endif /* LZ4_STATIC_LINKING_ONLY */
|
||||
|
||||
|
||||
|
||||
#ifndef LZ4_H_98237428734687
|
||||
#define LZ4_H_98237428734687
|
||||
|
||||
/*-************************************************************
|
||||
* Private Definitions
|
||||
**************************************************************
|
||||
* Do not use these definitions directly.
|
||||
* They are only exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
|
||||
* Accessing members will expose user code to API and/or ABI break in future versions of the library.
|
||||
**************************************************************/
|
||||
#define LZ4_HASHLOG (LZ4_MEMORY_USAGE-2)
|
||||
#define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
|
||||
#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG) /* required as macro for static allocation */
|
||||
|
||||
#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
|
||||
#include <stdint.h>
|
||||
|
||||
typedef struct {
|
||||
uint32_t hashTable[LZ4_HASH_SIZE_U32];
|
||||
uint32_t currentOffset;
|
||||
uint32_t initCheck;
|
||||
const uint8_t* dictionary;
|
||||
uint8_t* bufferStart; /* obsolete, used for slideInputBuffer */
|
||||
uint32_t dictSize;
|
||||
} LZ4_stream_t_internal;
|
||||
|
||||
typedef struct {
|
||||
const uint8_t* externalDict;
|
||||
size_t extDictSize;
|
||||
const uint8_t* prefixEnd;
|
||||
size_t prefixSize;
|
||||
} LZ4_streamDecode_t_internal;
|
||||
|
||||
# include <stdint.h>
|
||||
typedef int8_t LZ4_i8;
|
||||
typedef uint8_t LZ4_byte;
|
||||
typedef uint16_t LZ4_u16;
|
||||
typedef uint32_t LZ4_u32;
|
||||
#else
|
||||
|
||||
typedef struct {
|
||||
unsigned int hashTable[LZ4_HASH_SIZE_U32];
|
||||
unsigned int currentOffset;
|
||||
unsigned int initCheck;
|
||||
const unsigned char* dictionary;
|
||||
unsigned char* bufferStart; /* obsolete, used for slideInputBuffer */
|
||||
unsigned int dictSize;
|
||||
} LZ4_stream_t_internal;
|
||||
|
||||
typedef struct {
|
||||
const unsigned char* externalDict;
|
||||
size_t extDictSize;
|
||||
const unsigned char* prefixEnd;
|
||||
size_t prefixSize;
|
||||
} LZ4_streamDecode_t_internal;
|
||||
|
||||
typedef signed char LZ4_i8;
|
||||
typedef unsigned char LZ4_byte;
|
||||
typedef unsigned short LZ4_u16;
|
||||
typedef unsigned int LZ4_u32;
|
||||
#endif
|
||||
|
||||
/*!
|
||||
* LZ4_stream_t :
|
||||
* information structure to track an LZ4 stream.
|
||||
* init this structure before first use.
|
||||
* note : only use in association with static linking !
|
||||
* this definition is not API/ABI safe,
|
||||
* it may change in a future version !
|
||||
typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
|
||||
struct LZ4_stream_t_internal {
|
||||
LZ4_u32 hashTable[LZ4_HASH_SIZE_U32];
|
||||
LZ4_u32 currentOffset;
|
||||
LZ4_u32 tableType;
|
||||
const LZ4_byte* dictionary;
|
||||
const LZ4_stream_t_internal* dictCtx;
|
||||
LZ4_u32 dictSize;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
const LZ4_byte* externalDict;
|
||||
size_t extDictSize;
|
||||
const LZ4_byte* prefixEnd;
|
||||
size_t prefixSize;
|
||||
} LZ4_streamDecode_t_internal;
|
||||
|
||||
|
||||
/*! LZ4_stream_t :
|
||||
* Do not use below internal definitions directly !
|
||||
* Declare or allocate an LZ4_stream_t instead.
|
||||
* LZ4_stream_t can also be created using LZ4_createStream(), which is recommended.
|
||||
* The structure definition can be convenient for static allocation
|
||||
* (on stack, or as part of larger structure).
|
||||
* Init this structure with LZ4_initStream() before first use.
|
||||
* note : only use this definition in association with static linking !
|
||||
* this definition is not API/ABI safe, and may change in future versions.
|
||||
*/
|
||||
#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
|
||||
#define LZ4_STREAMSIZE (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
|
||||
#define LZ4_STREAMSIZE 16416 /* static size, for inter-version compatibility */
|
||||
#define LZ4_STREAMSIZE_VOIDP (LZ4_STREAMSIZE / sizeof(void*))
|
||||
union LZ4_stream_u {
|
||||
unsigned long long table[LZ4_STREAMSIZE_U64];
|
||||
void* table[LZ4_STREAMSIZE_VOIDP];
|
||||
LZ4_stream_t_internal internal_donotuse;
|
||||
} ; /* previously typedef'd to LZ4_stream_t */
|
||||
}; /* previously typedef'd to LZ4_stream_t */
|
||||
|
||||
|
||||
/*!
|
||||
* LZ4_streamDecode_t :
|
||||
* information structure to track an LZ4 stream during decompression.
|
||||
* init this structure using LZ4_setStreamDecode (or memset()) before first use
|
||||
* note : only use in association with static linking !
|
||||
* this definition is not API/ABI safe,
|
||||
* and may change in a future version !
|
||||
/*! LZ4_initStream() : v1.9.0+
|
||||
* An LZ4_stream_t structure must be initialized at least once.
|
||||
* This is automatically done when invoking LZ4_createStream(),
|
||||
* but it's not when the structure is simply declared on stack (for example).
|
||||
*
|
||||
* Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t.
|
||||
* It can also initialize any arbitrary buffer of sufficient size,
|
||||
* and will @return a pointer of proper type upon initialization.
|
||||
*
|
||||
* Note : initialization fails if size and alignment conditions are not respected.
|
||||
* In which case, the function will @return NULL.
|
||||
* Note2: An LZ4_stream_t structure guarantees correct alignment and size.
|
||||
* Note3: Before v1.9.0, use LZ4_resetStream() instead
|
||||
*/
|
||||
#define LZ4_STREAMDECODESIZE_U64 4
|
||||
LZ4LIB_API LZ4_stream_t* LZ4_initStream (void* buffer, size_t size);
|
||||
|
||||
|
||||
/*! LZ4_streamDecode_t :
|
||||
* information structure to track an LZ4 stream during decompression.
|
||||
* init this structure using LZ4_setStreamDecode() before first use.
|
||||
* note : only use in association with static linking !
|
||||
* this definition is not API/ABI safe,
|
||||
* and may change in a future version !
|
||||
*/
|
||||
#define LZ4_STREAMDECODESIZE_U64 (4 + ((sizeof(void*)==16) ? 2 : 0) /*AS-400*/ )
|
||||
#define LZ4_STREAMDECODESIZE (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
|
||||
union LZ4_streamDecode_u {
|
||||
unsigned long long table[LZ4_STREAMDECODESIZE_U64];
|
||||
|
|
@ -405,57 +660,113 @@ union LZ4_streamDecode_u {
|
|||
} ; /* previously typedef'd to LZ4_streamDecode_t */
|
||||
|
||||
|
||||
|
||||
/*-************************************
|
||||
* Obsolete Functions
|
||||
**************************************/
|
||||
|
||||
/*! Deprecation warnings
|
||||
Should deprecation warnings be a problem,
|
||||
it is generally possible to disable them,
|
||||
typically with -Wno-deprecated-declarations for gcc
|
||||
or _CRT_SECURE_NO_WARNINGS in Visual.
|
||||
Otherwise, it's also possible to define LZ4_DISABLE_DEPRECATE_WARNINGS */
|
||||
*
|
||||
* Deprecated functions make the compiler generate a warning when invoked.
|
||||
* This is meant to invite users to update their source code.
|
||||
* Should deprecation warnings be a problem, it is generally possible to disable them,
|
||||
* typically with -Wno-deprecated-declarations for gcc
|
||||
* or _CRT_SECURE_NO_WARNINGS in Visual.
|
||||
*
|
||||
* Another method is to define LZ4_DISABLE_DEPRECATE_WARNINGS
|
||||
* before including the header file.
|
||||
*/
|
||||
#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
|
||||
# define LZ4_DEPRECATED(message) /* disable deprecation warnings */
|
||||
#else
|
||||
# define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
|
||||
# if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
|
||||
# define LZ4_DEPRECATED(message) [[deprecated(message)]]
|
||||
# elif (LZ4_GCC_VERSION >= 405) || defined(__clang__)
|
||||
# define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
|
||||
# elif (LZ4_GCC_VERSION >= 301)
|
||||
# define LZ4_DEPRECATED(message) __attribute__((deprecated))
|
||||
# elif defined(_MSC_VER)
|
||||
# define LZ4_DEPRECATED(message) __declspec(deprecated(message))
|
||||
# elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 45))
|
||||
# define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
|
||||
# elif defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 31)
|
||||
# define LZ4_DEPRECATED(message) __attribute__((deprecated))
|
||||
# else
|
||||
# pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
|
||||
# define LZ4_DEPRECATED(message)
|
||||
# pragma message("WARNING: LZ4_DEPRECATED needs custom implementation for this compiler")
|
||||
# define LZ4_DEPRECATED(message) /* disabled */
|
||||
# endif
|
||||
#endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
|
||||
|
||||
/* Obsolete compression functions */
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress (const char* source, char* dest, int sourceSize);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_withState (void* state, const char* source, char* dest, int inputSize);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
|
||||
/*! Obsolete compression functions (since v1.7.3) */
|
||||
LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress (const char* src, char* dest, int srcSize);
|
||||
LZ4_DEPRECATED("use LZ4_compress_default() instead") LZ4LIB_API int LZ4_compress_limitedOutput (const char* src, char* dest, int srcSize, int maxOutputSize);
|
||||
LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState (void* state, const char* source, char* dest, int inputSize);
|
||||
LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
|
||||
LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
|
||||
LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
|
||||
|
||||
/* Obsolete decompression functions */
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_fast() instead") int LZ4_uncompress (const char* source, char* dest, int outputSize);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_safe() instead") int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
|
||||
/*! Obsolete decompression functions (since v1.8.0) */
|
||||
LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize);
|
||||
LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
|
||||
|
||||
/* Obsolete streaming functions; use new streaming interface whenever possible */
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStream() instead") int LZ4_sizeofStreamState(void);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_resetStream() instead") int LZ4_resetStreamState(void* state, char* inputBuffer);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_saveDict() instead") char* LZ4_slideInputBuffer (void* state);
|
||||
/* Obsolete streaming functions (since v1.7.0)
|
||||
* degraded functionality; do not use!
|
||||
*
|
||||
* In order to perform streaming compression, these functions depended on data
|
||||
* that is no longer tracked in the state. They have been preserved as well as
|
||||
* possible: using them will still produce a correct output. However, they don't
|
||||
* actually retain any history between compression calls. The compression ratio
|
||||
* achieved will therefore be no better than compressing each chunk
|
||||
* independently.
|
||||
*/
|
||||
LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer);
|
||||
LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int LZ4_sizeofStreamState(void);
|
||||
LZ4_DEPRECATED("Use LZ4_resetStream() instead") LZ4LIB_API int LZ4_resetStreamState(void* state, char* inputBuffer);
|
||||
LZ4_DEPRECATED("Use LZ4_saveDict() instead") LZ4LIB_API char* LZ4_slideInputBuffer (void* state);
|
||||
|
||||
/* Obsolete streaming decoding functions */
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
|
||||
LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
|
||||
/*! Obsolete streaming decoding functions (since v1.7.0) */
|
||||
LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
|
||||
LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
|
||||
|
||||
#endif /* LZ4_H_2983827168210 */
|
||||
/*! Obsolete LZ4_decompress_fast variants (since v1.9.0) :
|
||||
* These functions used to be faster than LZ4_decompress_safe(),
|
||||
* but this is no longer the case. They are now slower.
|
||||
* This is because LZ4_decompress_fast() doesn't know the input size,
|
||||
* and therefore must progress more cautiously into the input buffer to not read beyond the end of block.
|
||||
* On top of that `LZ4_decompress_fast()` is not protected vs malformed or malicious inputs, making it a security liability.
|
||||
* As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated.
|
||||
*
|
||||
* The last remaining LZ4_decompress_fast() specificity is that
|
||||
* it can decompress a block without knowing its compressed size.
|
||||
* Such functionality can be achieved in a more secure manner
|
||||
* by employing LZ4_decompress_safe_partial().
|
||||
*
|
||||
* Parameters:
|
||||
* originalSize : is the uncompressed size to regenerate.
|
||||
* `dst` must be already allocated, its size must be >= 'originalSize' bytes.
|
||||
* @return : number of bytes read from source buffer (== compressed size).
|
||||
* The function expects to finish at block's end exactly.
|
||||
* If the source stream is detected malformed, the function stops decoding and returns a negative result.
|
||||
* note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer.
|
||||
* However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds.
|
||||
* Also, since match offsets are not validated, match reads from 'src' may underflow too.
|
||||
* These issues never happen if input (compressed) data is correct.
|
||||
* But they may happen if input data is invalid (error or intentional tampering).
|
||||
* As a consequence, use these functions in trusted environments with trusted data **only**.
|
||||
*/
|
||||
LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe() instead")
|
||||
LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize);
|
||||
LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_continue() instead")
|
||||
LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize);
|
||||
LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_usingDict() instead")
|
||||
LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize);
|
||||
|
||||
/*! LZ4_resetStream() :
|
||||
* An LZ4_stream_t structure must be initialized at least once.
|
||||
* This is done with LZ4_initStream(), or LZ4_resetStream().
|
||||
* Consider switching to LZ4_initStream(),
|
||||
* invoking LZ4_resetStream() will trigger deprecation warnings in the future.
|
||||
*/
|
||||
LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
|
||||
|
||||
|
||||
#endif /* LZ4_H_98237428734687 */
|
||||
|
||||
|
||||
#if defined (__cplusplus)
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* Copyright (c) 2007 Henri Sivonen
|
||||
* Copyright (c) 2008-2015 Mozilla Foundation
|
||||
* Copyright (c) 2018-2020 Moonchild Productions
|
||||
* Copyright (c) 2018-2021 Moonchild Productions
|
||||
* Copyright (c) 2020 Binary Outcast
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
|
|
@ -753,7 +753,7 @@ public abstract class MetaScanner {
|
|||
stateSave = state;
|
||||
}
|
||||
|
||||
private void handleCharInAttributeValue(int c) {
|
||||
private void handleCharInAttributeValue(int c) throws SAXException {
|
||||
if (metaState == A) {
|
||||
if (contentIndex == CONTENT.length || charsetIndex == CHARSET.length) {
|
||||
addToBuffer(c);
|
||||
|
|
@ -778,9 +778,9 @@ public abstract class MetaScanner {
|
|||
* Adds a character to the accumulation buffer.
|
||||
* @param c the character to add
|
||||
*/
|
||||
private void addToBuffer(int c) {
|
||||
private void addToBuffer(int c) throws SAXException {
|
||||
if (strBufLen == strBuf.length) {
|
||||
char[] newBuf = new char[strBuf.length + (strBuf.length << 1)];
|
||||
char[] newBuf = new char[Portability.checkedAdd(strBuf.length, (strBuf.length << 1))];
|
||||
System.arraycopy(strBuf, 0, newBuf, 0, strBuf.length);
|
||||
strBuf = newBuf;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Copyright (c) 2008-2015 Mozilla Foundation
|
||||
* Copyright (c) 2018-2020 Moonchild Productions
|
||||
* Copyright (c) 2018-2021 Moonchild Productions
|
||||
* Copyright (c) 2020 Binary Outcast
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
|
|
@ -24,6 +24,8 @@
|
|||
|
||||
package nu.validator.htmlparser.impl;
|
||||
|
||||
import org.xml.sax.SAXException;
|
||||
|
||||
import nu.validator.htmlparser.annotation.Literal;
|
||||
import nu.validator.htmlparser.annotation.Local;
|
||||
import nu.validator.htmlparser.annotation.NoLength;
|
||||
|
|
@ -31,6 +33,17 @@ import nu.validator.htmlparser.common.Interner;
|
|||
|
||||
public final class Portability {
|
||||
|
||||
public static int checkedAdd(int a, int b) throws SAXException {
|
||||
// This can't be translated code, because in C++ signed integer overflow is UB, so the below code would be wrong.
|
||||
assert a >= 0;
|
||||
assert b >= 0;
|
||||
int sum = a + b;
|
||||
if (sum < a || sum < b) {
|
||||
throw new SAXException("Integer overflow");
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
|
||||
// Allocating methods
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* Copyright (c) 2005-2007 Henri Sivonen
|
||||
* Copyright (c) 2007-2015 Mozilla Foundation
|
||||
* Copyright (c) 2018-2020 Moonchild Productions
|
||||
* Copyright (c) 2018-2021 Moonchild Productions
|
||||
* Copyright (c) 2020 Binary Outcast
|
||||
* Portions of comments Copyright 2004-2010 Apple Computer, Inc., Mozilla
|
||||
* Foundation, and Opera Software ASA.
|
||||
|
|
@ -1009,8 +1009,8 @@ public class Tokenizer implements Locator {
|
|||
// ]NOCPP]
|
||||
}
|
||||
|
||||
private void appendStrBuf(@NoLength char[] buffer, int offset, int length) {
|
||||
int newLen = strBufLen + length;
|
||||
private void appendStrBuf(@NoLength char[] buffer, int offset, int length) throws SAXException {
|
||||
int newLen = Portability.checkedAdd(strBufLen, length);
|
||||
// CPPONLY: assert newLen <= strBuf.length: "Previous buffer length insufficient.";
|
||||
// CPPONLY: if (strBuf.length < newLen) {
|
||||
// CPPONLY: if (!EnsureBufferSpace(length)) {
|
||||
|
|
@ -1024,7 +1024,7 @@ public class Tokenizer implements Locator {
|
|||
/**
|
||||
* Append the contents of the char reference buffer to the main one.
|
||||
*/
|
||||
@Inline private void appendCharRefBufToStrBuf() {
|
||||
@Inline private void appendCharRefBufToStrBuf() throws SAXException {
|
||||
appendStrBuf(charRefBuf, 0, charRefBufLen);
|
||||
charRefBufLen = 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -743,7 +743,7 @@ void
|
|||
nsHtml5MetaScanner::addToBuffer(int32_t c)
|
||||
{
|
||||
if (strBufLen == strBuf.length) {
|
||||
jArray<char16_t,int32_t> newBuf = jArray<char16_t,int32_t>::newJArray(strBuf.length + (strBuf.length << 1));
|
||||
jArray<char16_t,int32_t> newBuf = jArray<char16_t,int32_t>::newJArray(nsHtml5Portability::checkedAdd(strBuf.length, (strBuf.length << 1)));
|
||||
nsHtml5ArrayCopy::arraycopy(strBuf, newBuf, strBuf.length);
|
||||
strBuf = newBuf;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,15 @@
|
|||
#include "jArray.h"
|
||||
#include "nsHtml5Portability.h"
|
||||
#include "nsHtml5TreeBuilder.h"
|
||||
#include "mozilla/CheckedInt.h"
|
||||
|
||||
int32_t nsHtml5Portability::checkedAdd(int32_t a, int32_t b) {
|
||||
mozilla::CheckedInt<int32_t> sum(a);
|
||||
sum += b;
|
||||
MOZ_RELEASE_ASSERT(sum.isValid(),
|
||||
"HTML input too large for signed 32-bit integer.");
|
||||
return sum.value();
|
||||
}
|
||||
|
||||
nsIAtom*
|
||||
nsHtml5Portability::newLocalNameFromBuffer(char16_t* buf, int32_t offset, int32_t length, nsHtml5AtomTable* interner)
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Copyright (c) 2008-2015 Mozilla Foundation
|
||||
* Copyright (c) 2018-2020 Moonchild Productions
|
||||
* Copyright (c) 2018-2021 Moonchild Productions
|
||||
* Copyright (c) 2020 Binary Outcast
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
|
|
@ -60,6 +60,7 @@ class nsHtml5StateSnapshot;
|
|||
class nsHtml5Portability
|
||||
{
|
||||
public:
|
||||
static int32_t checkedAdd(int32_t a, int32_t b);
|
||||
static nsIAtom* newLocalNameFromBuffer(char16_t* buf, int32_t offset, int32_t length, nsHtml5AtomTable* interner);
|
||||
static nsHtml5String newStringFromBuffer(char16_t* buf, int32_t offset, int32_t length, nsHtml5TreeBuilder* treeBuilder, bool maybeAtomize);
|
||||
static nsHtml5String newEmptyString();
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
* Copyright (c) 2005-2007 Henri Sivonen
|
||||
* Copyright (c) 2007-2015 Mozilla Foundation
|
||||
* Copyright (c) 2018-2020 Moonchild Productions
|
||||
* Copyright (c) 2018-2021 Moonchild Productions
|
||||
* Copyright (c) 2020 Binary Outcast
|
||||
* Portions of comments Copyright 2004-2010 Apple Computer, Inc., Mozilla
|
||||
* Foundation, and Opera Software ASA.
|
||||
|
|
@ -249,7 +249,7 @@ nsHtml5Tokenizer::emitStrBuf()
|
|||
void
|
||||
nsHtml5Tokenizer::appendStrBuf(char16_t* buffer, int32_t offset, int32_t length)
|
||||
{
|
||||
int32_t newLen = strBufLen + length;
|
||||
int32_t newLen = nsHtml5Portability::checkedAdd(strBufLen, length);
|
||||
MOZ_ASSERT(newLen <= strBuf.length, "Previous buffer length insufficient.");
|
||||
if (MOZ_UNLIKELY(strBuf.length < newLen)) {
|
||||
if (MOZ_UNLIKELY(!EnsureBufferSpace(length))) {
|
||||
|
|
|
|||
|
|
@ -74,6 +74,7 @@ NS_IMPL_ISUPPORTS(TransportSecurityInfo,
|
|||
nsresult
|
||||
TransportSecurityInfo::SetHostName(const char* host)
|
||||
{
|
||||
MutexAutoLock lock(mMutex);
|
||||
mHostName.Adopt(host ? NS_strdup(host) : 0);
|
||||
return NS_OK;
|
||||
}
|
||||
|
|
@ -103,6 +104,7 @@ nsresult
|
|||
TransportSecurityInfo::SetOriginAttributes(
|
||||
const NeckoOriginAttributes& aOriginAttributes)
|
||||
{
|
||||
MutexAutoLock lock(mMutex);
|
||||
mOriginAttributes = aOriginAttributes;
|
||||
return NS_OK;
|
||||
}
|
||||
|
|
@ -136,6 +138,7 @@ TransportSecurityInfo::GetSecurityState(uint32_t* state)
|
|||
nsresult
|
||||
TransportSecurityInfo::SetSecurityState(uint32_t aState)
|
||||
{
|
||||
MutexAutoLock lock(mMutex);
|
||||
mSecurityState = aState;
|
||||
return NS_OK;
|
||||
}
|
||||
|
|
@ -152,6 +155,7 @@ NS_IMETHODIMP
|
|||
TransportSecurityInfo::SetCountSubRequestsBrokenSecurity(
|
||||
int32_t aSubRequestsBrokenSecurity)
|
||||
{
|
||||
MutexAutoLock lock(mMutex);
|
||||
mSubRequestsBrokenSecurity = aSubRequestsBrokenSecurity;
|
||||
return NS_OK;
|
||||
}
|
||||
|
|
@ -168,6 +172,7 @@ NS_IMETHODIMP
|
|||
TransportSecurityInfo::SetCountSubRequestsNoSecurity(
|
||||
int32_t aSubRequestsNoSecurity)
|
||||
{
|
||||
MutexAutoLock lock(mMutex);
|
||||
mSubRequestsNoSecurity = aSubRequestsNoSecurity;
|
||||
return NS_OK;
|
||||
}
|
||||
|
|
@ -515,6 +520,7 @@ TransportSecurityInfo::GetSSLStatus(nsISSLStatus** _result)
|
|||
nsresult
|
||||
TransportSecurityInfo::SetSSLStatus(nsSSLStatus *aSSLStatus)
|
||||
{
|
||||
MutexAutoLock lock(mMutex);
|
||||
mSSLStatus = aSSLStatus;
|
||||
|
||||
return NS_OK;
|
||||
|
|
|
|||
|
|
@ -26,10 +26,6 @@
|
|||
#include "secder.h"
|
||||
#include "secdert.h"
|
||||
|
||||
//These defines are taken from the PKCS#11 spec
|
||||
#define CKM_RSA_PKCS_KEY_PAIR_GEN 0x00000000
|
||||
#define CKM_DH_PKCS_KEY_PAIR_GEN 0x00000020
|
||||
|
||||
DERTemplate SECAlgorithmIDTemplate[] = {
|
||||
{ DER_SEQUENCE,
|
||||
0, nullptr, sizeof(SECAlgorithmID) },
|
||||
|
|
|
|||
|
|
@ -33,9 +33,7 @@
|
|||
available under licenses which are both
|
||||
<a href="http://www.gnu.org/philosophy/free-sw.html">free</a> and
|
||||
<a href="http://www.opensource.org/docs/definition.php">open source</a>.
|
||||
A URL identifying the specific source code used to create this copy can be found
|
||||
on the <a href="about:buildconfig">build configuration page</a>, and you can read
|
||||
<a href="https://developer.mozilla.org/en/Mozilla_Source_Code_%28Mercurial%29">instructions
|
||||
You can read <a href="https://developer.palemoon.org/">instructions
|
||||
on how to download and build the code for yourself</a>.
|
||||
</p>
|
||||
|
||||
|
|
@ -65,31 +63,34 @@
|
|||
<li><a href="about:license#gpl-3.0">GNU General Public License 3.0</a>
|
||||
<br><br>
|
||||
</li>
|
||||
#ifdef MOZ_WEBRTC
|
||||
<li><a href="about:license#ACE">ACE License</a></li>
|
||||
#endif
|
||||
#ifdef MOZ_DEVTOOLS_SERVER
|
||||
<li><a href="about:license#acorn">acorn License</a></li>
|
||||
#ifdef MOZ_INSTALL_TRACKING
|
||||
<li><a href="about:license#adjust">Adjust SDK License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#adobecmap">Adobe CMap License</a></li>
|
||||
<li><a href="about:license#android">Android Open Source License</a></li>
|
||||
#ifdef MOZ_ANGLE_RENDERER
|
||||
<li><a href="about:license#angle">ANGLE License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#apache">Apache License 2.0</a></li>
|
||||
<li><a href="about:license#apple">Apple License</a></li>
|
||||
<li><a href="about:license#apple-mozilla">Apple/Mozilla NPRuntime License</a></li>
|
||||
<li><a href="about:license#arm">ARM License</a></li>
|
||||
#ifdef MOZ_UPDATER
|
||||
<li><a href="about:license#bspatch">bspatch License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#cairo">Cairo Component Licenses</a></li>
|
||||
<li><a href="about:license#chromium">Chromium License</a></li>
|
||||
<li><a href="about:license#codemirror">CodeMirror License</a></li>
|
||||
#ifdef MOZ_DEVTOOLS <li><a href="about:license#codemirror">CodeMirror License</a></li>
|
||||
<li><a href="about:license#cubic-bezier">cubic-bezier License</a></li>
|
||||
<li><a href="about:license#d3">D3 License</a></li>
|
||||
<li><a href="about:license#dagre-d3">Dagre-D3 License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#dtoa">dtoa License</a></li>
|
||||
<li><a href="about:license#hunspell-nl">Dutch Spellchecking Dictionary License</a></li>
|
||||
#if defined(XP_WIN) || defined(XP_LINUX)
|
||||
<li><a href="about:license#twemoji">Twemoji License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#hunspell-ee">Estonian Spellchecking Dictionary License</a></li>
|
||||
<li><a href="about:license#expat">Expat License</a></li>
|
||||
<li><a href="about:license#firebug">Firebug License</a></li>
|
||||
<li><a href="about:license#gfx-font-list">gfxFontList License</a></li>
|
||||
|
|
@ -98,11 +99,15 @@
|
|||
<li><a href="about:license#gears-istumbler">Google Gears/iStumbler License</a></li>
|
||||
<li><a href="about:license#vp8">Google VP8 License</a></li>
|
||||
<li><a href="about:license#gsl">GSL License</a></li>
|
||||
#ifdef MOZ_WEBRTC
|
||||
<li><a href="about:license#gyp">gyp License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#halloc">halloc License</a></li>
|
||||
<li><a href="about:license#harfbuzz">HarfBuzz License</a></li>
|
||||
<li><a href="about:license#icu">ICU License</a></li>
|
||||
#ifdef MOZ_DEVTOOLS
|
||||
<li><a href="about:license#immutable">Immutable.js License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#jpnic">Japan Network Information Center License</a></li>
|
||||
<li><a href="about:license#jquery">jQuery License</a></li>
|
||||
<li><a href="about:license#k_exp">k_exp License</a></li>
|
||||
|
|
@ -118,42 +123,56 @@
|
|||
<li><a href="about:license#libnestegg">libnestegg License</a></li>
|
||||
<li><a href="about:license#libsoundtouch">libsoundtouch License</a></li>
|
||||
<li><a href="about:license#libyuv">libyuv License</a></li>
|
||||
<li><a href="about:license#hunspell-lt">Lithuanian Spellchecking Dictionary License</a></li>
|
||||
<li><a href="about:license#microformatsshiv">MIT license — microformat-shiv</a></li>
|
||||
<li><a href="about:license#myspell">MySpell License</a></li>
|
||||
#ifdef MOZ_DEVTOOLS
|
||||
<li><a href="about:license#naturalSort">naturalSort License</a></li>
|
||||
#endif
|
||||
#ifdef MOZ_WEBRTC
|
||||
<li><a href="about:license#nicer">nICEr License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#node-properties">node-properties License</a></li>
|
||||
#ifdef MOZ_WEBRTC
|
||||
<li><a href="about:license#nrappkit">nrappkit License</a></li>
|
||||
#endif
|
||||
#ifdef MOZ_EME
|
||||
<li><a href="about:license#openaes">OpenAES License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#openvision">OpenVision License</a></li>
|
||||
<li><a href="about:license#pbkdf2-sha256">pbkdf2_sha256 License</a></li>
|
||||
<li><a href="about:license#praton">praton License</a></li>
|
||||
<li><a href="about:license#qcms">qcms License</a></li>
|
||||
#ifdef MOZ_DEVTOOLS_SERVER
|
||||
<li><a href="about:license#qrcode-generator">QR Code Generator License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#react">React License</a></li>
|
||||
#ifdef MOZ_DEVTOOLS
|
||||
<li><a href="about:license#react-redux">React-Redux License</a></li>
|
||||
<li><a href="about:license#react-virtualized">React Virtualized License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#xdg">Red Hat xdg_user_dir_lookup License</a></li>
|
||||
#ifdef MOZ_DEVTOOLS
|
||||
<li><a href="about:license#redux">Redux License</a></li>
|
||||
<li><a href="about:license#reselect">Reselect License</a></li>
|
||||
<li><a href="about:license#hunspell-ru">Russian Spellchecking Dictionary License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#sctp">SCTP Licenses</a></li>
|
||||
#ifdef MOZ_ENABLE_SKIA
|
||||
<li><a href="about:license#skia">Skia License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#snappy">Snappy License</a></li>
|
||||
#ifdef MOZ_DEVTOOLS_SERVER
|
||||
<li><a href="about:license#sprintf.js">sprintf.js License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#sunsoft">SunSoft License</a></li>
|
||||
<li><a href="about:license#superfasthash">SuperFastHash License</a></li>
|
||||
<li><a href="about:license#unicode">Unicode License</a></li>
|
||||
<li><a href="about:license#ucal">University of California License</a></li>
|
||||
<li><a href="about:license#hunspell-en-US">US English Spellchecking Dictionary Licenses</a></li>
|
||||
<li><a href="about:license#v8">V8 License</a></li>
|
||||
#if defined(XP_WIN) || defined(XP_MACOSX) || defined(XP_LINUX)
|
||||
<li><a href="about:license#valve">Valve BSD License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#vtune">VTune License</a></li>
|
||||
#ifdef MOZ_WEBRTC
|
||||
<li><a href="about:license#webrtc">WebRTC License</a></li>
|
||||
<li><a href="about:license#x264">x264 License</a></li>
|
||||
#endif
|
||||
<li><a href="about:license#xiph">Xiph.org Foundation License</a></li>
|
||||
</ul>
|
||||
|
||||
|
|
@ -2053,7 +2072,7 @@ Public License instead of this License. But first, please read
|
|||
<<a href="http://www.gnu.org/philosophy/why-not-lgpl.html">http://www.gnu.org/philosophy/why-not-lgpl.html</a>>.</p>
|
||||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_WEBRTC
|
||||
<h1><a id="ACE"></a>ACE License</h1>
|
||||
|
||||
<p>This license applies to the file
|
||||
|
|
@ -2077,11 +2096,13 @@ executables of your software products.
|
|||
|
||||
|
||||
<hr>
|
||||
|
||||
#endif
|
||||
<h1><a id="adobecmap"></a>Adobe CMap License</h1>
|
||||
|
||||
<p>This license applies to files in the directory
|
||||
<span class="path">browser/extensions/pdfjs/content/web/cmaps/</span>.</p>
|
||||
<p>This license applies to files in application directories for
|
||||
applications including the pdf.js in-application PDF reader,
|
||||
specifically
|
||||
<span class="path">*/pdfjs/content/web/cmaps/</span>.</p>
|
||||
|
||||
<pre>
|
||||
Copyright 1990-2009 Adobe Systems Incorporated.
|
||||
|
|
@ -2122,41 +2143,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="android"></a>Android Open Source License</h1>
|
||||
|
||||
<p>This license applies to various files in the Mozilla codebase,
|
||||
including those in the directory <span class="path">gfx/skia/</span>.</p>
|
||||
<!-- This is the wrong directory, what was intended? -->
|
||||
|
||||
<pre>
|
||||
Copyright 2009, The Android Open Source Project
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
</pre>
|
||||
|
||||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_ANGLE_RENDERER
|
||||
<h1><a id="angle"></a>ANGLE License</h1>
|
||||
|
||||
<p>This license applies to files in the directory <span class="path">gfx/angle/</span>.</p>
|
||||
|
|
@ -2198,7 +2185,8 @@ POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
|
||||
#endif
|
||||
#ifdef MOZ_DEVTOOLS_SERVER
|
||||
<h1><a id="acorn"></a>acorn License</h1>
|
||||
|
||||
<p>This license applies to all files in
|
||||
|
|
@ -2232,6 +2220,7 @@ licences.
|
|||
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
#ifdef MOZ_INSTALL_TRACKING
|
||||
<h1><a id="adjust"></a>Adjust SDK License</h1>
|
||||
|
|
@ -2559,6 +2548,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_UPDATER
|
||||
<h1><a id="bspatch"></a>bspatch License</h1>
|
||||
|
||||
<p>This license applies to the files
|
||||
|
|
@ -2594,6 +2584,7 @@ POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="cairo"></a>Cairo Component Licenses</h1>
|
||||
|
||||
|
|
@ -2652,7 +2643,6 @@ WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|||
<p>This license applies to parts of the code in:</p>
|
||||
<ul>
|
||||
<li><span class="path">editor/libeditor/EditorEventListener.cpp</span></li>
|
||||
<li><span class="path">security/sandbox/</span></li>
|
||||
<li><span class="path">widget/cocoa/GfxInfo.mm</span></li>
|
||||
</ul>
|
||||
<p>and also some files in these directories:</p>
|
||||
|
|
@ -2700,7 +2690,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_DEVTOOLS
|
||||
<h1><a id="codemirror"></a>CodeMirror License</h1>
|
||||
|
||||
<p>This license applies to all files in
|
||||
|
|
@ -2777,7 +2767,7 @@ DEALINGS IN THE SOFTWARE.
|
|||
<h1><a id="d3"></a>D3 License</h1>
|
||||
|
||||
<p>This license applies to the file
|
||||
<span class="path">devtools/client/shared/d3.js</span>.
|
||||
<span class="path">devtools/client/shared/vendor/d3.js</span>.
|
||||
</p>
|
||||
<pre>
|
||||
Copyright (c) 2014, Michael Bostock
|
||||
|
|
@ -2840,6 +2830,7 @@ THE SOFTWARE.
|
|||
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="dtoa"></a>dtoa License</h1>
|
||||
|
||||
|
|
@ -2866,47 +2857,6 @@ OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
|
|||
|
||||
<hr>
|
||||
|
||||
<h1><a id="hunspell-nl"></a>Dutch Spellchecking Dictionary License</h1>
|
||||
|
||||
<p>This license applies to the Dutch Spellchecking Dictionary. (This
|
||||
code only ships in some localized versions of this product.)</p>
|
||||
|
||||
<pre>
|
||||
Copyright (c) 2006, 2007 OpenTaal
|
||||
Copyright (c) 2001, 2002, 2003, 2005 Simon Brouwer e.a.
|
||||
Copyright (c) 1996 Nederlandstalige Tex Gebruikersgroep
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
* Neither the name of the OpenTaal, Simon Brouwer e.a., or Nederlandstalige Tex
|
||||
Gebruikersgroep nor the names of its contributors may be used to endorse or
|
||||
promote products derived from this software without specific prior written
|
||||
permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
||||
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
</pre>
|
||||
|
||||
|
||||
<hr>
|
||||
|
||||
#if defined(XP_WIN) || defined(XP_LINUX)
|
||||
<h1><a id="twemoji"></a>Twemoji License</h1>
|
||||
|
||||
|
|
@ -2951,56 +2901,6 @@ publicity, privacy, or moral rights may limit how you use the material.
|
|||
<hr>
|
||||
|
||||
#endif
|
||||
<h1><a id="hunspell-ee"></a>Estonian Spellchecking Dictionary License</h1>
|
||||
|
||||
<p>This license applies to precursor works to certain files which are
|
||||
part of the Estonian Spellchecking Dictionary. The
|
||||
shipped versions are under the GNU Lesser General Public License. (This
|
||||
code only ships in some localized versions of this product.)</p>
|
||||
|
||||
<pre>
|
||||
Copyright © Institute of the Estonian Language
|
||||
|
||||
E-mail: litsents@eki.ee
|
||||
URL: http://www.eki.ee/tarkvara/
|
||||
|
||||
The present Licence Agreement gives the user of this Software Product
|
||||
(hereinafter: Product) the right to use the Product for whatever purpose
|
||||
(incl. distribution, copying, altering, inclusion in other software, and
|
||||
selling) on the following conditions:
|
||||
|
||||
1. The present Licence Agreement should belong unaltered to each copy ever
|
||||
made of this Product;
|
||||
2. Neither the Institute of the Estonian Language (hereinafter: IEL) nor the
|
||||
author(s) of the Product will take responsibility for any detriment, direct
|
||||
or indirect, possibly ensuing from the application of the Product;
|
||||
3. The IEL is ready to share the Product with other users as we wish to
|
||||
advance research on the Estonian language and to promote the use of
|
||||
Estonian in rapidly developing infotechnology, yet we refuse to bind
|
||||
ourselves to any further obligation, which means that the IEL is not
|
||||
obliged either to warrant the suitability of the Product for a specific
|
||||
purpose, to improve the software, or to provide a more detailed description
|
||||
of the underlying algorithms. (Which does not mean, though, that we may not
|
||||
do it.)
|
||||
|
||||
Notification Request:
|
||||
|
||||
As a courtesy, we would appreciate being informed whenever our linguistic
|
||||
products are used to create derivative works. If you modify our software or
|
||||
include it in other products, please inform us by sending e-mail to
|
||||
litsents@eki.ee or by letter to
|
||||
|
||||
Institute of the Estonian Language
|
||||
Roosikrantsi 6
|
||||
10119 Tallinn
|
||||
ESTONIA
|
||||
|
||||
Phone & Fax: +372 6411443
|
||||
</pre>
|
||||
|
||||
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="expat"></a>Expat License</h1>
|
||||
|
||||
|
|
@ -3036,8 +2936,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
|
||||
<hr>
|
||||
|
||||
|
||||
<h1><a id="firebug"></a>Firebug License</h1>
|
||||
#ifdef MOZ_DEVTOOLS_SERVER <h1><a id="firebug"></a>Firebug License</h1>
|
||||
|
||||
<p>This license applies to the code
|
||||
<span class="path">devtools/shared/webconsole/network-helper.js</span>.</p>
|
||||
|
|
@ -3079,6 +2978,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="gfx-font-list"></a>gfxFontList License</h1>
|
||||
|
||||
|
|
@ -3122,7 +3022,6 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
<h1><a id="google-bsd"></a>Google BSD License</h1>
|
||||
|
||||
<p>This license applies to files in the directories
|
||||
<span class="path">toolkit/crashreporter/google-breakpad/</span> and
|
||||
<span class="path">toolkit/components/protobuf/</span>.</p>
|
||||
|
||||
<pre>
|
||||
|
|
@ -3159,30 +3058,29 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
<hr>
|
||||
|
||||
<h1><a id="vp8"></a>Google VP8 License</h1>
|
||||
<h1><a id="vpx"></a>VPX License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
<p>This license applies to the files in the directory
|
||||
<span class="path">media/libvpx</span>.</p>
|
||||
<pre>
|
||||
Copyright (c) 2010, Google, Inc.
|
||||
|
||||
All rights reserved.
|
||||
Copyright (c) 2010, The WebM Project authors. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
|
||||
- Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
- Redistributions in binary form must reproduce the above
|
||||
copyright notice, this list of conditions and the following
|
||||
disclaimer in the documentation and/or other materials provided
|
||||
with the distribution.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in
|
||||
the documentation and/or other materials provided with the
|
||||
distribution.
|
||||
|
||||
- Neither the name of Google nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software
|
||||
without specific prior written permission.
|
||||
* Neither the name of Google, nor the WebM Project, nor the names
|
||||
of its contributors may be used to endorse or promote products
|
||||
derived from this software without specific prior written
|
||||
permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
|
|
@ -3196,22 +3094,29 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
Subject to the terms and conditions of the above License, Google
|
||||
hereby grants to You a perpetual, worldwide, non-exclusive,
|
||||
no-charge, royalty-free, irrevocable (except as stated in this
|
||||
section) patent license to make, have made, use, offer to sell, sell,
|
||||
import, and otherwise transfer this implementation of VP8, where such
|
||||
license applies only to those patent claims, both currently owned by
|
||||
Google and acquired in the future, licensable by Google that are
|
||||
necessarily infringed by this implementation of VP8. If You or your
|
||||
agent or exclusive licensee institute or order or agree to the
|
||||
institution of patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that this
|
||||
implementation of VP8 or any code incorporated within this
|
||||
implementation of VP8 constitutes direct or contributory patent
|
||||
infringement, or inducement of patent infringement, then any rights
|
||||
granted to You under this License for this implementation of VP8
|
||||
shall terminate as of the date such litigation is filed.
|
||||
Additional IP Rights Grant (Patents)
|
||||
------------------------------------
|
||||
|
||||
"These implementations" means the copyrightable works that implement the WebM
|
||||
codecs distributed by Google as part of the WebM Project.
|
||||
|
||||
Google hereby grants to you a perpetual, worldwide, non-exclusive, no-charge,
|
||||
royalty-free, irrevocable (except as stated in this section) patent license to
|
||||
make, have made, use, offer to sell, sell, import, transfer, and otherwise
|
||||
run, modify and propagate the contents of these implementations of WebM, where
|
||||
such license applies only to those patent claims, both currently owned by
|
||||
Google and acquired in the future, licensable by Google that are necessarily
|
||||
infringed by these implementations of WebM. This grant does not include claims
|
||||
that would be infringed only as a consequence of further modification of these
|
||||
implementations. If you or your agent or exclusive licensee institute or order
|
||||
or agree to the institution of patent litigation or any other patent
|
||||
enforcement activity against any entity (including a cross-claim or
|
||||
counterclaim in a lawsuit) alleging that any of these implementations of WebM
|
||||
or any code incorporated within any of these implementations of WebM
|
||||
constitute direct or contributory patent infringement, or inducement of
|
||||
patent infringement, then any patent rights granted to you under this License
|
||||
for these implementations of WebM shall terminate as of the date such
|
||||
litigation is filed.
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
|
@ -3290,6 +3195,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
<!-- https://github.com/Microsoft/GSL/blob/3819df6e378ffccf0e29465afe99c3b324c2aa70/LICENSE -->
|
||||
<pre>
|
||||
Copyright (c) 2015 Microsoft Corporation. All rights reserved.
|
||||
Copyright (c) 2020 Moonchild Productions. All rights reserved.
|
||||
|
||||
This code is licensed under the MIT License (MIT).
|
||||
|
||||
|
|
@ -3314,7 +3220,7 @@ THE SOFTWARE.
|
|||
|
||||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_WEBRTC
|
||||
<h1><a id="gyp"></a>gyp License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
|
|
@ -3351,6 +3257,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="halloc"></a>halloc License</h1>
|
||||
|
||||
|
|
@ -3470,6 +3377,8 @@ All trademarks and registered trademarks mentioned herein are the property
|
|||
of their respective owners.
|
||||
</pre>
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_DEVTOOLS
|
||||
<h1><a id="immutable"></a>Immutable.js License</h1>
|
||||
|
||||
<pre>
|
||||
|
|
@ -3506,6 +3415,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="jpnic"></a>Japan Network Information Center License</h1>
|
||||
<p>This license applies to certain files in the
|
||||
|
|
@ -3624,8 +3534,8 @@ SUCH DAMAGE.
|
|||
<p>This license applies to the following files:</p>
|
||||
|
||||
<ul>
|
||||
<li class="path">openmax_dl/dl/api/omxtypes.h</li>
|
||||
<li class="path">openmax_dl/dl/sp/api/omxSP.h</li>
|
||||
<li class="path">media/openmax_dl/dl/api/omxtypes.h</li>
|
||||
<li class="path">media/openmax_dl/dl/sp/api/omxSP.h</li>
|
||||
</ul>
|
||||
|
||||
<pre>
|
||||
|
|
@ -3663,6 +3573,7 @@ Khronos and OpenMAX are trademarks of the Khronos Group Inc.
|
|||
|
||||
<pre>
|
||||
Copyright (c) 2003-2010 Mark Borgerding
|
||||
Copyright (c) 2017 Mark Straver BASc
|
||||
|
||||
All rights reserved.
|
||||
|
||||
|
|
@ -3945,43 +3856,6 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="hunspell-lt"></a>Lithuanian Spellchecking Dictionary License</h1>
|
||||
|
||||
<p>This license applies to the Lithuanian Spellchecking Dictionary. (This
|
||||
code only ships in some localized versions of this product.)</p>
|
||||
|
||||
<pre>
|
||||
Copyright (c) 2000-2013, Albertas Agejevas and contributors.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
3. Neither the name of the copyright holders nor the names of its contributors
|
||||
may be used to endorse or promote products derived from this software
|
||||
without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL ALBERTAS AGEJEVAS OR CONTRIBUTORS BE LIABLE
|
||||
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGE.
|
||||
</pre>
|
||||
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="microformatsshiv"></a>MIT license — microformat-shiv</h1>
|
||||
|
|
@ -4056,7 +3930,7 @@ SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_DEVTOOLS
|
||||
<h1><a id="naturalSort"></a>naturalSort License</h1>
|
||||
|
||||
<p>This license applies to <span class="path">devtools/client/shared/natural-sort.js</span>.</p>
|
||||
|
|
@ -4086,7 +3960,8 @@ THE SOFTWARE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
#endif
|
||||
#ifdef MOZ_WEBRTC
|
||||
<h1><a id="nicer"></a>nICEr License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
|
|
@ -4131,7 +4006,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
|
||||
#endif
|
||||
#ifdef MOZ_EME
|
||||
<h1><a id="openaes"></a>OpenAES License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
|
|
@ -4166,6 +4042,7 @@ POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="openvision"></a>OpenVision License</h1>
|
||||
|
||||
|
|
@ -4195,7 +4072,7 @@ PERFORMANCE OF THIS SOFTWARE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_DEVTOOLS_SERVER
|
||||
<h1><a id="node-properties"></a>node-properties License</h1>
|
||||
|
||||
<p>This license applies to
|
||||
|
|
@ -4226,7 +4103,8 @@ THE SOFTWARE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
#endif
|
||||
#ifdef MOZ_WEBRTC
|
||||
<h1><a id="nrappkit"></a>nrappkit License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
|
|
@ -4373,6 +4251,7 @@ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="praton"></a>praton License</h1>
|
||||
|
||||
|
|
@ -4444,41 +4323,6 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|||
</pre>
|
||||
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="pbkdf2-sha256"></a>pbkdf2_sha256 License</h1>
|
||||
|
||||
<p>This license applies to the code
|
||||
<span class="path">mozglue/android/pbkdf2_sha256.c</span> and
|
||||
<span class="path">mozglue/android/pbkdf2_sha256.h</span>.
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
Copyright 2005,2007,2009 Colin Percival
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
SUCH DAMAGE.
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="qcms"></a>qcms License</h1>
|
||||
|
|
@ -4511,6 +4355,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_DEVTOOLS_SERVER
|
||||
<h1><a id="qrcode-generator"></a>QR Code Generator License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
|
|
@ -4539,6 +4384,7 @@ THE SOFTWARE.
|
|||
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="react"></a>React License</h1>
|
||||
|
||||
|
|
@ -4576,6 +4422,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_DEVTOOLS
|
||||
<h1><a id="react-redux"></a>React-Redux License</h1>
|
||||
|
||||
<p>This license applies to the file
|
||||
|
|
@ -4631,6 +4478,7 @@ SOFTWARE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="xdg"></a>Red Hat xdg_user_dir_lookup License</h1>
|
||||
|
||||
|
|
@ -4663,7 +4511,7 @@ SOFTWARE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_DEVTOOLS
|
||||
<h1><a id="redux"></a>Redux License</h1>
|
||||
|
||||
<p>This license applies to the file
|
||||
|
|
@ -4721,44 +4569,7 @@ SOFTWARE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="hunspell-ru"></a>Russian Spellchecking Dictionary License</h1>
|
||||
|
||||
<p>This license applies to the Russian Spellchecking Dictionary. (This
|
||||
code only ships in some localized versions of this product.)</p>
|
||||
|
||||
<pre>
|
||||
* Copyright (c) 1997-2008, Alexander I. Lebedev
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Modified versions must be clearly marked as such.
|
||||
* The name of Alexander I. Lebedev may not be used to endorse or promote
|
||||
products derived from this software without specific prior written
|
||||
permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
</pre>
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="sctp"></a>SCTP Licenses</h1>
|
||||
|
||||
|
|
@ -4831,6 +4642,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_ENABLE_SKIA
|
||||
<h1><a id="skia"></a>Skia License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
|
|
@ -4867,6 +4679,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="snappy"></a>Snappy License</h1>
|
||||
|
||||
|
|
@ -4905,7 +4718,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_DEVTOOLS_SERVER
|
||||
<h1><a id="sprintf.js"></a>sprintf.js License</h1>
|
||||
|
||||
<p>This license applies to
|
||||
|
|
@ -4939,6 +4752,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="sunsoft"></a>SunSoft License</h1>
|
||||
|
||||
|
|
@ -4978,42 +4792,6 @@ authorization from SunSoft Inc.
|
|||
</pre>
|
||||
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="superfasthash"></a>SuperFastHash License</h1>
|
||||
|
||||
<p>This license applies to files in the directory
|
||||
<span class="path">security/sandbox/chromium/base/third_party/superfasthash/</span>.</p>
|
||||
|
||||
<pre>
|
||||
Copyright (c) 2010, Paul Hsieh
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright notice, this
|
||||
list of conditions and the following disclaimer in the documentation and/or
|
||||
other materials provided with the distribution.
|
||||
* Neither my name, Paul Hsieh, nor the names of any other contributors to the
|
||||
code use may not be used to endorse or promote products derived from this
|
||||
software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
</pre>
|
||||
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="unicode"></a>Unicode License</h1>
|
||||
|
|
@ -5419,7 +5197,7 @@ Database section 7.
|
|||
directories, certain files in those directories:</p>
|
||||
|
||||
<ul>
|
||||
<li class="path">dbm/</li>
|
||||
<li class="path">security/nss/lib/dbm/</li>
|
||||
<li class="path">db/mork/src/morkQuickSort.cpp</li>
|
||||
<li class="path">xpcom/glue/nsQuickSort.cpp</li>
|
||||
<li class="path">nsprpub/pr/src/misc/praton.c</li>
|
||||
|
|
@ -5600,44 +5378,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
<hr>
|
||||
|
||||
<h1><a id="valve"></a>Valve BSD License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
<span class="path">gfx/vr/openvr</span>.</p>
|
||||
<pre>
|
||||
Copyright (c) 2015, Valve Corporation
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation and/or
|
||||
other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the copyright holder nor the names of its contributors
|
||||
may be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
</pre>
|
||||
|
||||
#endif
|
||||
|
||||
<hr>
|
||||
|
||||
<h1><a id="vtune"></a>VTune License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
|
|
@ -5675,7 +5415,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
||||
|
||||
<hr>
|
||||
|
||||
#ifdef MOZ_WEBRTC
|
||||
<h1><a id="webrtc"></a>WebRTC License</h1>
|
||||
|
||||
<p>This license applies to certain files in the directory
|
||||
|
|
@ -5743,6 +5483,7 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|||
</pre>
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<h1><a id="xiph"></a>Xiph.org Foundation License</h1>
|
||||
|
||||
|
|
@ -5795,10 +5536,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
<ul>
|
||||
<li>This software is based in part on the work of the Independent
|
||||
JPEG Group.</li>
|
||||
<li>Portions of the OS/2 and Android versions
|
||||
of this software are copyright ©1996-2012
|
||||
<a href="http://www.freetype.org/">The FreeType Project</a>.
|
||||
All rights reserved.</li>
|
||||
</ul>
|
||||
|
||||
|
||||
|
|
@ -5825,16 +5562,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
</ul>
|
||||
|
||||
|
||||
|
||||
#ifdef XP_WIN
|
||||
|
||||
<hr>
|
||||
#ifdef XP_WIN
|
||||
|
||||
<h1><a id="proprietary-notices"></a>Proprietary Operating System Components</h1>
|
||||
|
||||
<p>Under some circumstances, under our
|
||||
<a href="http://www.mozilla.org/foundation/licensing/binary-components/">binary components policy</a>,
|
||||
Mozilla may decide to include additional
|
||||
<a href="http://www.palemoon.org/policies/binarycomponents.html">Binary Component Policy</a>,
|
||||
we may decide to include additional
|
||||
operating system vendor code with the installer of our products designed
|
||||
for that vendor's proprietary platform, to make our products work well on
|
||||
that specific operating system. The following license statements
|
||||
|
|
@ -5846,7 +5581,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
they are referred to below as "Distributable Code":
|
||||
<ul>
|
||||
<li><span class="path">d3d*.dll</span> (Direct3D libraries)</li>
|
||||
<li><span class="path">msvc*.dll</span> (C and C++ runtime libraries)</li>
|
||||
<li><span class="path">msvc*.dll</span> and <span class="path">vcruntime*.dll</span> (C and C++ runtime libraries)</li>
|
||||
<li><span class="path">api-ms-win*.dll</span> and <span class="path">ucrtbase.dll</span> (Universal CRT runtime libraries)</li>
|
||||
</ul>
|
||||
</p>
|
||||
|
||||
|
|
@ -5870,10 +5606,8 @@ following terms:
|
|||
regulations that apply to the Distributable Code.
|
||||
</pre>
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
<hr>
|
||||
#endif
|
||||
|
||||
<p><a href="about:license#top">Return to top</a>.</p>
|
||||
|
||||
|
|
|
|||
|
|
@ -166,7 +166,8 @@ nsBaseFilePicker::~nsBaseFilePicker()
|
|||
|
||||
NS_IMETHODIMP nsBaseFilePicker::Init(mozIDOMWindowProxy* aParent,
|
||||
const nsAString& aTitle,
|
||||
int16_t aMode)
|
||||
int16_t aMode,
|
||||
bool aRequireInteraction)
|
||||
{
|
||||
NS_PRECONDITION(aParent, "Null parent passed to filepicker, no file "
|
||||
"picker for you!");
|
||||
|
|
|
|||
|
|
@ -25,7 +25,8 @@ public:
|
|||
|
||||
NS_IMETHOD Init(mozIDOMWindowProxy* aParent,
|
||||
const nsAString& aTitle,
|
||||
int16_t aMode);
|
||||
int16_t aMode,
|
||||
bool aRequireInteraction = false);
|
||||
|
||||
NS_IMETHOD Open(nsIFilePickerShownCallback *aCallback);
|
||||
NS_IMETHOD AppendFilters(int32_t filterMask);
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ nsFilePickerProxy::~nsFilePickerProxy()
|
|||
|
||||
NS_IMETHODIMP
|
||||
nsFilePickerProxy::Init(mozIDOMWindowProxy* aParent, const nsAString& aTitle,
|
||||
int16_t aMode)
|
||||
int16_t aMode, bool aRequireInteraction)
|
||||
{
|
||||
TabChild* tabChild = TabChild::GetFrom(aParent);
|
||||
if (!tabChild) {
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ public:
|
|||
NS_DECL_ISUPPORTS
|
||||
|
||||
// nsIFilePicker (less what's in nsBaseFilePicker)
|
||||
NS_IMETHOD Init(mozIDOMWindowProxy* aParent, const nsAString& aTitle, int16_t aMode) override;
|
||||
NS_IMETHOD Init(mozIDOMWindowProxy* aParent, const nsAString& aTitle, int16_t aMode, bool aRequireInteraction = false) override;
|
||||
NS_IMETHOD AppendFilter(const nsAString& aTitle, const nsAString& aFilter) override;
|
||||
NS_IMETHOD GetDefaultString(nsAString& aDefaultString) override;
|
||||
NS_IMETHOD SetDefaultString(const nsAString& aDefaultString) override;
|
||||
|
|
|
|||
|
|
@ -66,9 +66,12 @@ interface nsIFilePicker : nsISupports
|
|||
* on this parent. parent must be non-null.
|
||||
* @param title The title for the file widget
|
||||
* @param mode load, save, or get folder
|
||||
* @param requireinteraction (optional)
|
||||
* require interaction before confirmation is possible
|
||||
*
|
||||
*/
|
||||
void init(in mozIDOMWindowProxy parent, in AString title, in short mode);
|
||||
void init(in mozIDOMWindowProxy parent, in AString title, in short mode,
|
||||
[optional] in boolean requireinteraction);
|
||||
|
||||
/**
|
||||
* Append to the filter list with things from the predefined list
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
|
||||
using mozilla::IsVistaOrLater;
|
||||
using mozilla::IsWin8OrLater;
|
||||
using mozilla::IsWin10OrLater;
|
||||
using mozilla::MakeUnique;
|
||||
using mozilla::mscom::EnsureMTA;
|
||||
using mozilla::UniquePtr;
|
||||
|
|
@ -194,11 +195,13 @@ nsFilePicker::~nsFilePicker()
|
|||
|
||||
NS_IMPL_ISUPPORTS(nsFilePicker, nsIFilePicker)
|
||||
|
||||
NS_IMETHODIMP nsFilePicker::Init(mozIDOMWindowProxy *aParent, const nsAString& aTitle, int16_t aMode)
|
||||
NS_IMETHODIMP nsFilePicker::Init(mozIDOMWindowProxy *aParent, const nsAString& aTitle, int16_t aMode,
|
||||
bool aRequireInteraction)
|
||||
{
|
||||
nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(aParent);
|
||||
nsIDocShell* docShell = window ? window->GetDocShell() : nullptr;
|
||||
mLoadContext = do_QueryInterface(docShell);
|
||||
mRequireInteraction = aRequireInteraction;
|
||||
|
||||
return nsBaseFilePicker::Init(aParent, aTitle, aMode);
|
||||
}
|
||||
|
|
@ -603,6 +606,13 @@ nsFilePicker::ShowFolderPicker(const nsString& aInitialDir, bool &aWasInitError)
|
|||
|
||||
// options
|
||||
FILEOPENDIALOGOPTIONS fos = FOS_PICKFOLDERS;
|
||||
// Require interaction if the folder picker is triggered by an element that
|
||||
// is potentially unsafe to use the default value in.
|
||||
// Win 10+ only, because this dialog flag is broken in earlier versions.
|
||||
if (IsWin10OrLater() && mRequireInteraction) {
|
||||
fos |= FOS_OKBUTTONNEEDSINTERACTION;
|
||||
}
|
||||
|
||||
dialog->SetOptions(fos);
|
||||
|
||||
// initial strings
|
||||
|
|
@ -923,6 +933,13 @@ nsFilePicker::ShowFilePicker(const nsString& aInitialDir, bool &aWasInitError)
|
|||
FILEOPENDIALOGOPTIONS fos = 0;
|
||||
fos |= FOS_SHAREAWARE | FOS_OVERWRITEPROMPT |
|
||||
FOS_FORCEFILESYSTEM;
|
||||
|
||||
// Require interaction if the file picker is triggered by an element that
|
||||
// is potentially unsafe to use the default value in.
|
||||
// Win 10+ only, because this dialog flag is broken in earlier versions.
|
||||
if (IsWin10OrLater() && mRequireInteraction) {
|
||||
fos |= FOS_OKBUTTONNEEDSINTERACTION;
|
||||
}
|
||||
|
||||
// Handle add to recent docs settings
|
||||
if (IsPrivacyModeEnabled() || !mAddToRecentDocs) {
|
||||
|
|
|
|||
|
|
@ -60,7 +60,8 @@ class nsFilePicker :
|
|||
public:
|
||||
nsFilePicker();
|
||||
|
||||
NS_IMETHOD Init(mozIDOMWindowProxy *aParent, const nsAString& aTitle, int16_t aMode);
|
||||
NS_IMETHOD Init(mozIDOMWindowProxy *aParent, const nsAString& aTitle, int16_t aMode,
|
||||
bool aRequireInteraction = false);
|
||||
|
||||
NS_DECL_ISUPPORTS
|
||||
|
||||
|
|
@ -125,6 +126,7 @@ protected:
|
|||
nsString mUnicodeFile;
|
||||
static char16_t *mLastUsedUnicodeDirectory;
|
||||
HWND mDlgWnd;
|
||||
bool mRequireInteraction;
|
||||
|
||||
class ComDlgFilterSpec
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue