CMXSL.org/trisquel-icecat
2
0
Fork 0
Code Issues Pull requests Projects Releases 11 Packages Wiki Activity Actions

icecat: add release icecat-140.9.0-1gnu1 for ecne

Browse source
This commit is contained in:
Ark74 2026-03-28 14:10:24 -06:00
parent 8eb1f1732f
commit a5f93cb214
1197 changed files with 30593 additions and 15344 deletions
Download patch file Download diff file Expand all files Collapse all files

46
icecat/netwerk/protocol/http/PHttpChannelParams.h
View file

@ -10,6 +10,7 @@
#define ALLOW_LATE_NSHTTP_H_INCLUDE 1
#include "base/basictypes.h"
#include "ipc/EnumSerializer.h"
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsHttp.h"
@ -34,6 +35,19 @@ struct RequestHeaderTuple {
typedef CopyableTArray<RequestHeaderTuple> RequestHeaderTuples;
struct HttpVersionValidator {
using IntegralType = std::underlying_type_t<HttpVersion>;
static bool IsLegalValue(const IntegralType e) {
return e == static_cast<IntegralType>(HttpVersion::UNKNOWN) ||
e == static_cast<IntegralType>(HttpVersion::v0_9) ||
e == static_cast<IntegralType>(HttpVersion::v1_0) ||
e == static_cast<IntegralType>(HttpVersion::v1_1) ||
e == static_cast<IntegralType>(HttpVersion::v2_0) ||
e == static_cast<IntegralType>(HttpVersion::v3_0);
}
};
} // namespace net
} // namespace mozilla
@ -61,6 +75,18 @@ struct ParamTraits<mozilla::net::RequestHeaderTuple> {
}
};
template <>
struct ParamTraits<mozilla::net::HttpVersion>
: public EnumSerializer<mozilla::net::HttpVersion,
mozilla::net::HttpVersionValidator> {};
template <>
struct ParamTraits<mozilla::net::nsHttpRequestHead::ParsedMethodType>
: public ContiguousEnumSerializerInclusive<
mozilla::net::nsHttpRequestHead::ParsedMethodType,
mozilla::net::nsHttpRequestHead::kMethod_Custom,
mozilla::net::nsHttpRequestHead::kMethod_Trace> {};
template <>
struct ParamTraits<mozilla::net::nsHttpAtom> {
typedef mozilla::net::nsHttpAtom paramType;
@ -192,33 +218,29 @@ struct ParamTraits<mozilla::net::nsHttpRequestHead> {
aParam.Enter();
WriteParam(aWriter, aParam.mHeaders);
WriteParam(aWriter, aParam.mMethod);
WriteParam(aWriter, static_cast<uint32_t>(aParam.mVersion));
WriteParam(aWriter, aParam.mVersion);
WriteParam(aWriter, aParam.mRequestURI);
WriteParam(aWriter, aParam.mPath);
WriteParam(aWriter, aParam.mOrigin);
WriteParam(aWriter, static_cast<uint8_t>(aParam.mParsedMethod));
WriteParam(aWriter, aParam.mParsedMethod);
WriteParam(aWriter, aParam.mHTTPS);
aParam.Exit();
}
static bool Read(MessageReader* aReader, paramType* aResult) {
uint32_t version;
uint8_t method;
aResult->Enter();
if (!ReadParam(aReader, &aResult->mHeaders) ||
!ReadParam(aReader, &aResult->mMethod) ||
!ReadParam(aReader, &version) ||
!ReadParam(aReader, &aResult->mVersion) ||
!ReadParam(aReader, &aResult->mRequestURI) ||
!ReadParam(aReader, &aResult->mPath) ||
!ReadParam(aReader, &aResult->mOrigin) ||
!ReadParam(aReader, &method) || !ReadParam(aReader, &aResult->mHTTPS)) {
!ReadParam(aReader, &aResult->mParsedMethod) ||
!ReadParam(aReader, &aResult->mHTTPS)) {
aResult->Exit();
return false;
}
aResult->mVersion = static_cast<mozilla::net::HttpVersion>(version);
aResult->mParsedMethod =
static_cast<mozilla::net::nsHttpRequestHead::ParsedMethodType>(method);
aResult->Exit();
return true;
}
@ -234,7 +256,7 @@ struct ParamTraits<mozilla::net::nsHttpResponseHead> {
const paramType& aParam) MOZ_NO_THREAD_SAFETY_ANALYSIS {
aParam.Enter();
WriteParam(aWriter, aParam.mHeaders);
WriteParam(aWriter, static_cast<uint32_t>(aParam.mVersion));
WriteParam(aWriter, aParam.mVersion);
WriteParam(aWriter, aParam.mStatus);
WriteParam(aWriter, aParam.mStatusText);
WriteParam(aWriter, aParam.mContentLength);
@ -255,10 +277,9 @@ struct ParamTraits<mozilla::net::nsHttpResponseHead> {
}
static bool Read(MessageReader* aReader, paramType* aResult) {
uint32_t version;
aResult->Enter();
if (!ReadParam(aReader, &aResult->mHeaders) ||
!ReadParam(aReader, &version) ||
!ReadParam(aReader, &aResult->mVersion) ||
!ReadParam(aReader, &aResult->mStatus) ||
!ReadParam(aReader, &aResult->mStatusText) ||
!ReadParam(aReader, &aResult->mContentLength) ||
@ -279,7 +300,6 @@ struct ParamTraits<mozilla::net::nsHttpResponseHead> {
return false;
}
aResult->mVersion = static_cast<mozilla::net::HttpVersion>(version);
aResult->Exit();
return true;
}

64
icecat/netwerk/protocol/http/nsHttpResponseHead.cpp
View file

@ -293,6 +293,25 @@ void nsHttpResponseHead::FlattenNetworkOriginalHeaders(nsACString& buf) {
mHeaders.FlattenOriginalHeader(buf);
}
class ResponseHeaderVisitor : public nsIHttpHeaderVisitor {
using callbackType =
std::function<void(const nsACString& aName, const nsACString& aValue)>;
NS_DECL_ISUPPORTS
explicit ResponseHeaderVisitor(callbackType&& aCallback)
: mCallback(std::move(aCallback)) {}
NS_IMETHOD VisitHeader(const nsACString& aName,
const nsACString& aValue) override {
mCallback(aName, aValue);
return NS_OK;
}
private:
virtual ~ResponseHeaderVisitor() = default;
callbackType mCallback;
};
NS_IMPL_ISUPPORTS(ResponseHeaderVisitor, nsIHttpHeaderVisitor)
nsresult nsHttpResponseHead::ParseCachedHead(const char* block) {
RecursiveMutexAutoLock monitor(mRecursiveMutex);
LOG(("nsHttpResponseHead::ParseCachedHead [this=%p]\n", this));
@ -318,6 +337,15 @@ nsresult nsHttpResponseHead::ParseCachedHead(const char* block) {
} while (true);
// fixup content-type header.
mContentTypeBuffer.Truncate();
RefPtr<ResponseHeaderVisitor> visitor = new ResponseHeaderVisitor(
[&](const nsACString& aName, const nsACString& aValue)
MOZ_REQUIRES(mRecursiveMutex) {
MOZ_ASSERT(nsHttp::Content_Type.val().EqualsIgnoreCase(aName));
ParseContentTypeValue(nsHttp::ResolveAtom(aName), aValue);
});
(void)mHeaders.GetOriginalHeader(nsHttp::Content_Type, visitor);
return NS_OK;
}
@ -444,6 +472,33 @@ nsresult nsHttpResponseHead::ParseHeaderLine(const nsACString& line) {
return ParseHeaderLine_locked(line, true);
}
void nsHttpResponseHead::ParseContentTypeValue(const nsHttpAtom& aAtom,
const nsACString& aValue) {
if (!mContentTypeBuffer.IsEmpty()) {
mContentTypeBuffer.AppendLiteral(",");
}
mContentTypeBuffer.Append(aValue);
mContentType.Truncate();
mContentCharset.Truncate();
if (CMimeType::Parse(mContentTypeBuffer, mContentType, mContentCharset)) {
} else if (StaticPrefs::network_http_fallback_to_net_parse_ct()) {
bool dummy;
net_ParseContentType(aValue, mContentType, mContentCharset, &dummy);
}
LOG(("ParseContentType [input=%s, type=%s, charset=%s]\n",
nsPromiseFlatCString(aValue).get(), mContentType.get(),
mContentCharset.get()));
nsAutoCString existingHeader;
if (NS_SUCCEEDED(mHeaders.GetHeader(aAtom, existingHeader)) &&
existingHeader != mContentTypeBuffer) {
// Always set the header to the merged buffer, as per Fetch spec.
DebugOnly<nsresult> rv = mHeaders.SetHeader(
aAtom, mContentTypeBuffer, false, nsHttpHeaderArray::eVarietyResponse);
MOZ_ASSERT(NS_SUCCEEDED(rv));
}
}
nsresult nsHttpResponseHead::ParseHeaderLine_locked(
const nsACString& line, bool originalFromNetHeaders) {
nsHttpAtom hdr;
@ -487,14 +542,7 @@ nsresult nsHttpResponseHead::ParseHeaderLine_locked(
}
} else if (hdr == nsHttp::Content_Type) {
if (StaticPrefs::network_standard_content_type_parsing_response_headers() &&
CMimeType::Parse(val, mContentType, mContentCharset)) {
} else {
bool dummy;
net_ParseContentType(val, mContentType, mContentCharset, &dummy);
}
LOG(("ParseContentType [input=%s, type=%s, charset=%s]\n", val.get(),
mContentType.get(), mContentCharset.get()));
ParseContentTypeValue(hdr, val);
} else if (hdr == nsHttp::Cache_Control) {
ParseCacheControl(mHeaders.PeekHeader(hdr));
} else if (hdr == nsHttp::Pragma) {

4
icecat/netwerk/protocol/http/nsHttpResponseHead.h
View file

@ -160,6 +160,9 @@ class nsHttpResponseHead {
// https://fetch.spec.whatwg.org/#content-length-header
nsresult ParseResponseContentLength(const nsACString& aHeaderStr)
MOZ_REQUIRES(mRecursiveMutex);
void ParseContentTypeValue(const nsHttpAtom& aAtom,
const nsACString& aContentTypeValue)
MOZ_REQUIRES(mRecursiveMutex);
nsresult ParseStatusLine_locked(const nsACString& line)
MOZ_REQUIRES(mRecursiveMutex);
@ -210,6 +213,7 @@ class nsHttpResponseHead {
uint16_t mStatus MOZ_GUARDED_BY(mRecursiveMutex){200};
nsCString mStatusText MOZ_GUARDED_BY(mRecursiveMutex);
int64_t mContentLength MOZ_GUARDED_BY(mRecursiveMutex){-1};
nsCString mContentTypeBuffer MOZ_GUARDED_BY(mRecursiveMutex);
nsCString mContentType MOZ_GUARDED_BY(mRecursiveMutex);
nsCString mContentCharset MOZ_GUARDED_BY(mRecursiveMutex);
bool mHasCacheControl MOZ_GUARDED_BY(mRecursiveMutex){false};

10
icecat/netwerk/protocol/webtransport/WebTransportSessionProxy.cpp
View file

@ -135,13 +135,12 @@ nsresult WebTransportSessionProxy::AsyncConnectWithClient(
mDedicatedConnection = aDedicated;
if (!aServerCertHashes.IsEmpty()) {
mServerCertHashes.Clear();
mServerCertHashes.AppendElements(aServerCertHashes);
}
{
MutexAutoLock lock(mMutex);
if (!aServerCertHashes.IsEmpty()) {
mServerCertHashes.Clear();
mServerCertHashes.AppendElements(aServerCertHashes);
}
ChangeState(WebTransportSessionProxyState::NEGOTIATING);
}
@ -252,6 +251,7 @@ NS_IMETHODIMP WebTransportSessionProxy::GetDedicated(bool* dedicated) {
NS_IMETHODIMP WebTransportSessionProxy::GetServerCertificateHashes(
nsTArray<RefPtr<nsIWebTransportHash>>& aServerCertHashes) {
MutexAutoLock lock(mMutex);
aServerCertHashes.Clear();
aServerCertHashes.AppendElements(mServerCertHashes);
return NS_OK;

3
icecat/netwerk/protocol/webtransport/WebTransportSessionProxy.h
View file

@ -191,7 +191,8 @@ class WebTransportSessionProxy final
nsTArray<std::function<void(nsresult)>> mPendingCreateStreamEvents
MOZ_GUARDED_BY(mMutex);
nsCOMPtr<nsIEventTarget> mTarget MOZ_GUARDED_BY(mMutex);
nsTArray<RefPtr<nsIWebTransportHash>> mServerCertHashes;
nsTArray<RefPtr<nsIWebTransportHash>> mServerCertHashes
MOZ_GUARDED_BY(mMutex);
bool mDedicatedConnection; // for WebTranport
nsIWebTransport::HTTPVersion mHTTPVersion = nsIWebTransport::HTTPVersion::h3;
};