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; }