static const xpc_qsHashEntry *
LookupInterfaceOrAncestor(PRUint32 tableSize, const xpc_qsHashEntry *table,
const nsID &iid)
{
const xpc_qsHashEntry *entry = LookupEntry(tableSize, table, iid);
if(!entry)
{
/*
* On a miss, we have to search for every interface the object
* supports, including ancestors.
*/
nsCOMPtr<nsIInterfaceInfo> info;
if(NS_FAILED(nsXPConnect::GetXPConnect()->GetInfoForIID(
&iid, getter_AddRefs(info))))
return nsnull;
const nsIID *piid;
for(;;)
{
nsCOMPtr<nsIInterfaceInfo> parent;
if(NS_FAILED(info->GetParent(getter_AddRefs(parent))) ||
!parent ||
NS_FAILED(parent->GetIIDShared(&piid)))
{
break;
}
entry = LookupEntry(tableSize, table, *piid);
if(entry)
break;
info.swap(parent);
}
}
return entry;
}
const char *
nsHttpHeaderArray::PeekHeader(nsHttpAtom header)
{
nsEntry *entry = nsnull;
LookupEntry(header, &entry);
return entry ? entry->value.get() : nsnull;
}
::Node*
TarFS::Directory::Lookup(const char* name, bool traverseLinks)
{
TarFS::Entry* entry = LookupEntry(name);
if (!entry)
return NULL;
Node* node = entry->ToNode();
if (traverseLinks) {
if (S_ISLNK(node->Type())) {
Symlink* symlink = static_cast<Symlink*>(node);
int fd = open_from(this, symlink->LinkPath(), O_RDONLY);
if (fd >= 0) {
node = get_node_from(fd);
close(fd);
}
}
}
if (node)
node->Acquire();
return node;
}
nsresult
nsHttpHeaderArray::SetEmptyHeader(const nsACString &headerName,
HeaderVariety variety)
{
nsHttpAtom header = nsHttp::ResolveAtom(PromiseFlatCString(headerName).get());
if (!header) {
NS_WARNING("failed to resolve atom");
return NS_ERROR_NOT_AVAILABLE;
}
MOZ_ASSERT((variety == eVarietyResponse) ||
(variety == eVarietyRequestDefault) ||
(variety == eVarietyRequestOverride),
"Original headers can only be set using SetHeader_internal().");
nsEntry *entry = nullptr;
LookupEntry(header, &entry);
if (entry &&
entry->variety != eVarietyResponseNetOriginalAndResponse) {
entry->value.Truncate();
return NS_OK;
} else if (entry) {
MOZ_ASSERT(variety == eVarietyResponse);
entry->variety = eVarietyResponseNetOriginal;
}
return SetHeader_internal(header, headerName, EmptyCString(), variety);
}
//-----------------------------------------------------------------------------
// nsHttpHeaderArray <public>
//-----------------------------------------------------------------------------
nsresult
nsHttpHeaderArray::SetHeader(nsHttpAtom header,
const nsACString &value,
bool merge)
{
nsEntry *entry = nullptr;
int32_t index;
index = LookupEntry(header, &entry);
// If an empty value is passed in, then delete the header entry...
// unless we are merging, in which case this function becomes a NOP.
if (value.IsEmpty()) {
if (!merge && entry)
mHeaders.RemoveElementAt(index);
return NS_OK;
}
if (!entry) {
entry = mHeaders.AppendElement(); // new nsEntry()
if (!entry)
return NS_ERROR_OUT_OF_MEMORY;
entry->header = header;
entry->value = value;
} else if (merge && !IsSingletonHeader(header)) {
MergeHeader(header, entry, value);
} else {
// Replace the existing string with the new value
entry->value = value;
}
return NS_OK;
}
bool
nsHttpHeaderArray::HasHeader(nsHttpAtom header) const
{
const nsEntry *entry = nullptr;
LookupEntry(header, &entry);
return entry;
}
const char *
nsHttpHeaderArray::PeekHeader(nsHttpAtom header) const
{
const nsEntry *entry = nullptr;
LookupEntry(header, &entry);
return entry ? entry->value.get() : nullptr;
}
nsresult
nsHttpHeaderArray::SetHeaderFromNet(nsHttpAtom header, const nsACString &value)
{
nsEntry *entry = nsnull;
PRInt32 index;
index = LookupEntry(header, &entry);
if (!entry) {
if (value.IsEmpty())
return NS_OK; // ignore empty headers
entry = mHeaders.AppendElement(); //new nsEntry(header, value);
if (!entry)
return NS_ERROR_OUT_OF_MEMORY;
entry->header = header;
entry->value = value;
} else if (!IsSingletonHeader(header)) {
MergeHeader(header, entry, value);
} else {
// Multiple instances of non-mergeable header received from network
// - ignore if same value
if (!entry->value.Equals(value)) {
if (IsSuspectDuplicateHeader(header)) {
// reply may be corrupt/hacked (ex: CLRF injection attacks)
return NS_ERROR_CORRUPTED_CONTENT;
} // else silently drop value: keep value from 1st header seen
}
}
return NS_OK;
}
nsresult
nsHttpHeaderArray::GetHeader(nsHttpAtom header, nsACString &result) const
{
const nsEntry *entry = nullptr;
LookupEntry(header, &entry);
if (!entry)
return NS_ERROR_NOT_AVAILABLE;
result = entry->value;
return NS_OK;
}
void Library::AddPublicationsInContainer(Container* container, const string& path)
{
// store the container
auto existing = _containers.find(path);
if ( existing == _containers.end() )
_containers[path] = container;
for ( auto pkg : container->Packages() )
{
_packages.emplace(pkg->UniqueID(), LookupEntry({path, pkg}));
}
}
HRESULT DomainAssemblyCache::InsertEntry(AssemblySpec* pSpec, LPVOID pData1, LPVOID pData2)
{
HRESULT hr = S_FALSE;
LPVOID ptr = LookupEntry(pSpec);
if(ptr == NULL) {
m_pDomain->EnterCacheLock();
PAL_TRY {
ptr = LookupEntry(pSpec);
if(ptr == NULL) {
hr = E_OUTOFMEMORY;
AssemblyEntry* pEntry = (AssemblyEntry*) m_pDomain->GetLowFrequencyHeap()->AllocMem(sizeof(AssemblyEntry));
if(pEntry) {
new (&pEntry->spec) AssemblySpec ();
hr = pEntry->spec.Init(pSpec,FALSE);
if (SUCCEEDED(hr)) {
// the ref is kept alive as long as the appdomain is alive in the assemblyspec. The Init call
// adds an extra addref which we can't easily clean up later because we don't keep the
// assemblyspec in the cache.
IAssembly *pa = pEntry->spec.GetCodeBase()->GetParentAssembly();
if (pa != NULL)
pa->Release();
hr = pEntry->spec.CloneFieldsToLoaderHeap(AssemblySpec::ALL_OWNED, m_pDomain->GetLowFrequencyHeap());
if (hr == S_OK) {
pEntry->pData[0] = pData1;
pEntry->pData[1] = pData2;
DWORD hashValue = pEntry->Hash();
m_Table.InsertValue(hashValue, pEntry);
}
}
}
}
}
PAL_FINALLY {
m_pDomain->LeaveCacheLock();
}
PAL_ENDTRY
}
void
nsHttpHeaderArray::ClearHeader(nsHttpAtom header)
{
nsEntry *entry = nullptr;
int32_t index = LookupEntry(header, &entry);
if (entry) {
if (entry->variety == eVarietyResponseNetOriginalAndResponse) {
entry->variety = eVarietyResponseNetOriginal;
} else {
mHeaders.RemoveElementAt(index);
}
}
}
::Node*
TarFS::Directory::LookupDontTraverse(const char* name)
{
TarFS::Entry* entry = LookupEntry(name);
if (!entry)
return NULL;
Node* node = entry->ToNode();
if (node)
node->Acquire();
return node;
}
//-----------------------------------------------------------------------------
// nsHttpHeaderArray <public>
//-----------------------------------------------------------------------------
nsresult
nsHttpHeaderArray::SetHeader(nsHttpAtom header,
const nsACString &value,
bool merge,
nsHttpHeaderArray::HeaderVariety variety)
{
MOZ_ASSERT((variety == eVarietyResponse) ||
(variety == eVarietyRequestDefault) ||
(variety == eVarietyRequestOverride),
"Net original headers can only be set using SetHeader_internal().");
nsEntry *entry = nullptr;
int32_t index;
index = LookupEntry(header, &entry);
// If an empty value is passed in, then delete the header entry...
// unless we are merging, in which case this function becomes a NOP.
if (value.IsEmpty()) {
if (!merge && entry) {
if (entry->variety == eVarietyResponseNetOriginalAndResponse) {
MOZ_ASSERT(variety == eVarietyResponse);
entry->variety = eVarietyResponseNetOriginal;
} else {
mHeaders.RemoveElementAt(index);
}
}
return NS_OK;
}
MOZ_ASSERT(!entry || variety != eVarietyRequestDefault,
"Cannot set default entry which overrides existing entry!");
if (!entry) {
return SetHeader_internal(header, value, variety);
} else if (merge && !IsSingletonHeader(header)) {
return MergeHeader(header, entry, value, variety);
} else {
// Replace the existing string with the new value
if (entry->variety == eVarietyResponseNetOriginalAndResponse) {
MOZ_ASSERT(variety == eVarietyResponse);
entry->variety = eVarietyResponseNetOriginal;
return SetHeader_internal(header, value, variety);
} else {
entry->value = value;
entry->variety = variety;
}
}
return NS_OK;
}
SkPathHeap::LookupEntry* SkPathHeap::addIfNotPresent(const SkPath& path) {
LookupEntry searchKey(path);
int index = SkTSearch<const LookupEntry, LookupEntry::Less>(
fLookupTable.begin(),
fLookupTable.count(),
searchKey,
sizeof(LookupEntry));
if (index < 0) {
index = ~index;
*fLookupTable.insert(index) = LookupEntry(path);
}
return &fLookupTable[index];;
}
nsresult
nsHttpHeaderArray::SetHeader(nsHttpAtom header,
const nsACString &value,
PRBool merge)
{
nsEntry *entry = nsnull;
PRInt32 index;
index = LookupEntry(header, &entry);
// If an empty value is passed in, then delete the header entry...
// unless we are merging, in which case this function becomes a NOP.
if (value.IsEmpty()) {
if (!merge && entry)
mHeaders.RemoveElementAt(index);
return NS_OK;
}
// Create a new entry, or...
if (!entry) {
entry = mHeaders.AppendElement(); //new nsEntry(header, value);
if (!entry)
return NS_ERROR_OUT_OF_MEMORY;
entry->header = header;
entry->value = value;
}
// Append the new value to the existing value iff...
else if (merge && CanAppendToHeader(header)) {
if (header == nsHttp::Set_Cookie ||
header == nsHttp::WWW_Authenticate ||
header == nsHttp::Proxy_Authenticate)
// Special case these headers and use a newline delimiter to
// delimit the values from one another as commas may appear
// in the values of these headers contrary to what the spec says.
entry->value.Append('\n');
else
// Delimit each value from the others using a comma (per HTTP spec)
entry->value.AppendLiteral(", ");
entry->value.Append(value);
}
// Replace the existing string with the new value
else if (CanOverwriteHeader(header))
entry->value = value;
else if (!entry->value.Equals(value))
return NS_ERROR_CORRUPTED_CONTENT;
return NS_OK;
}
nsresult
nsHttpHeaderArray::SetEmptyHeader(nsHttpAtom header)
{
nsEntry *entry = nullptr;
LookupEntry(header, &entry);
if (!entry) {
entry = mHeaders.AppendElement(); // new nsEntry()
if (!entry)
return NS_ERROR_OUT_OF_MEMORY;
entry->header = header;
} else {
entry->value.Truncate();
}
return NS_OK;
}
status_t
TarFS::Directory::AddDirectory(char* dirName, TarFS::Directory** _dir)
{
char* subDir = strchr(dirName, '/');
if (subDir) {
// skip slashes
while (*subDir == '/') {
*subDir = '\0';
subDir++;
}
if (*subDir == '\0') {
// a trailing slash
subDir = NULL;
}
}
// check, whether the directory does already exist
Entry* entry = LookupEntry(dirName);
TarFS::Directory* dir = (entry ? entry->ToTarDirectory() : NULL);
if (entry) {
if (!dir)
return B_ERROR;
} else {
// doesn't exist yet -- create it
dir = new(nothrow) TarFS::Directory(this, dirName);
if (!dir)
return B_NO_MEMORY;
fEntries.Add(dir);
}
// recursively create the subdirectories
if (subDir) {
status_t error = dir->AddDirectory(subDir, &dir);
if (error != B_OK)
return error;
}
if (_dir)
*_dir = dir;
return B_OK;
}
nsresult
nsHttpHeaderArray::SetEmptyHeader(nsHttpAtom header, HeaderVariety variety)
{
MOZ_ASSERT((variety == eVarietyResponse) ||
(variety == eVarietyRequestDefault) ||
(variety == eVarietyRequestOverride),
"Original headers can only be set using SetHeader_internal().");
nsEntry *entry = nullptr;
LookupEntry(header, &entry);
if (entry &&
entry->variety != eVarietyResponseNetOriginalAndResponse) {
entry->value.Truncate();
return NS_OK;
} else if (entry) {
MOZ_ASSERT(variety == eVarietyResponse);
entry->variety = eVarietyResponseNetOriginal;
}
return SetHeader_internal(header, EmptyCString(), variety);
}
nsresult
nsHttpHeaderArray::SetHeaderFromNet(nsHttpAtom header,
const nsACString &value,
bool response)
{
// mHeader holds the consolidated (merged or updated) headers.
// mHeader for response header will keep the original heades as well.
nsEntry *entry = nullptr;
LookupEntry(header, &entry);
if (!entry) {
if (value.IsEmpty()) {
if (!gHttpHandler->KeepEmptyResponseHeadersAsEmtpyString() &&
!TrackEmptyHeader(header)) {
LOG(("Ignoring Empty Header: %s\n", header.get()));
if (response) {
// Set header as original but not as response header.
return SetHeader_internal(header, value,
eVarietyResponseNetOriginal);
}
return NS_OK; // ignore empty headers by default
}
}
HeaderVariety variety = eVarietyRequestOverride;
if (response) {
variety = eVarietyResponseNetOriginalAndResponse;
}
return SetHeader_internal(header, value, variety);
} else if (!IsSingletonHeader(header)) {
HeaderVariety variety = eVarietyRequestOverride;
if (response) {
variety = eVarietyResponse;
}
nsresult rv = MergeHeader(header, entry, value, variety);
if (NS_FAILED(rv)) {
return rv;
}
if (response) {
rv = SetHeader_internal(header, value,
eVarietyResponseNetOriginal);
}
return rv;
} else {
// Multiple instances of non-mergeable header received from network
// - ignore if same value
if (!entry->value.Equals(value)) {
if (IsSuspectDuplicateHeader(header)) {
// reply may be corrupt/hacked (ex: CLRF injection attacks)
return NS_ERROR_CORRUPTED_CONTENT;
} // else silently drop value: keep value from 1st header seen
LOG(("Header %s silently dropped as non mergeable header\n",
header.get()));
}
if (response) {
return SetHeader_internal(header, value,
eVarietyResponseNetOriginal);
}
}
return NS_OK;
}
T const* AssertEntry(uint32 id) const
{
T const* entry = LookupEntry(id);
ASSERT(entry);
return entry;
}
