//static
void nsHTMLTags::RemoveExpandedTag(int index) {
void *oldTag = (void*)kExpandedTagUnicodeTable[index];
if (oldTag) {
PL_HashTableRemove(gTagTable, oldTag);
free(oldTag);
kExpandedTagUnicodeTable[index] = NULL;
}
void *oldUnderScoreTag = (void*)kExpandedTagUnicodeUnderScoreTable[index];
if (oldUnderScoreTag) {
PL_HashTableRemove(gTagTable, oldUnderScoreTag);
free(oldUnderScoreTag);
kExpandedTagUnicodeUnderScoreTable[index] = NULL;
}
}
//
// remember the name and series of a token in a particular slot.
// This is important because the name is no longer available when
// the token is removed. If listeners depended on this information,
// They would be out of luck. It also is a handy way of making sure
// we don't generate spurious insertion and removal events as the slot
// cycles through various states.
//
void
SmartCardMonitoringThread::SetTokenName(CK_SLOT_ID slotid,
const char *tokenName, PRUint32 series)
{
if (mHash) {
if (tokenName) {
int len = strlen(tokenName) + 1;
/* this must match the allocator used in
* PLHashAllocOps.freeEntry DefaultFreeEntry */
char *entry = (char *)PR_Malloc(len+sizeof(PRUint32));
if (entry) {
memcpy(entry,&series,sizeof(PRUint32));
memcpy(&entry[sizeof(PRUint32)],tokenName,len);
PL_HashTableAdd(mHash,(void *)slotid, entry); /* adopt */
return;
}
}
else {
// if tokenName was not provided, remove the old one (implicit delete)
PL_HashTableRemove(mHash,(void *)slotid);
}
}
}
void
tmTransactionService::OnDetachReply(tmTransaction *aTrans) {
tm_queue_mapping *qmap = GetQueueMap(aTrans->GetQueueID());
// get the observer before we release the hashtable entry
ipcITransactionObserver *observer =
(ipcITransactionObserver *)PL_HashTableLookup(mObservers,
qmap->joinedQueueName);
// if it was removed, clean up
if (aTrans->GetStatus() >= 0) {
// remove the link between observer and queue
PL_HashTableRemove(mObservers, qmap->joinedQueueName);
// remove the mapping of queue names and id
mQueueMaps.Remove(qmap);
delete qmap;
}
// notify the observer -- could be didn't detach
if (observer)
observer->OnDetachReply(aTrans->GetQueueID(), aTrans->GetStatus());
}
NS_IMETHODIMP nsAppShell::ListenToEventQueue(nsIEventQueue *aQueue,
PRBool aListen)
{
#ifdef DEBUG_APPSHELL
printf("ListenToEventQueue(%p, %d) this=%p\n", aQueue, aListen, this);
#endif
if (!sQueueHashTable) {
sQueueHashTable = PL_NewHashTable(3, (PLHashFunction)IntHashKey,
PL_CompareValues, PL_CompareValues, 0, 0);
}
if (!sCountHashTable) {
sCountHashTable = PL_NewHashTable(3, (PLHashFunction)IntHashKey,
PL_CompareValues, PL_CompareValues, 0, 0);
}
if (aListen) {
/* add listener */
PRInt32 key = aQueue->GetEventQueueSelectFD();
/* only add if we arn't already in the table */
if (!PL_HashTableLookup(sQueueHashTable, GINT_TO_POINTER(key))) {
gint tag;
tag = our_gdk_input_add(aQueue->GetEventQueueSelectFD(),
event_processor_callback,
aQueue,
G_PRIORITY_HIGH_IDLE);
if (tag >= 0) {
PL_HashTableAdd(sQueueHashTable, GINT_TO_POINTER(key), GINT_TO_POINTER(tag));
}
PLEventQueue *plqueue;
aQueue->GetPLEventQueue(&plqueue);
PL_RegisterEventIDFunc(plqueue, getNextRequest, 0);
sEventQueueList->AppendElement(plqueue);
}
/* bump up the count */
gint count = GPOINTER_TO_INT(PL_HashTableLookup(sCountHashTable, GINT_TO_POINTER(key)));
PL_HashTableAdd(sCountHashTable, GINT_TO_POINTER(key), GINT_TO_POINTER(count+1));
} else {
/* remove listener */
PRInt32 key = aQueue->GetEventQueueSelectFD();
PLEventQueue *plqueue;
aQueue->GetPLEventQueue(&plqueue);
PL_UnregisterEventIDFunc(plqueue);
sEventQueueList->RemoveElement(plqueue);
gint count = GPOINTER_TO_INT(PL_HashTableLookup(sCountHashTable, GINT_TO_POINTER(key)));
if (count - 1 == 0) {
gint tag = GPOINTER_TO_INT(PL_HashTableLookup(sQueueHashTable, GINT_TO_POINTER(key)));
if (tag > 0) {
g_source_remove(tag);
PL_HashTableRemove(sQueueHashTable, GINT_TO_POINTER(key));
}
}
PL_HashTableAdd(sCountHashTable, GINT_TO_POINTER(key), GINT_TO_POINTER(count-1));
}
return NS_OK;
}
HRESULT CNode::SetDOMNode(nsIDOMNode *pIDOMNode)
{
if (pIDOMNode)
{
if (g_NodeLookupTable == NULL)
{
g_NodeLookupTable = PL_NewHashTable(123, HashFunction, HashComparator, HashComparator, NULL, NULL);
}
mDOMNode = pIDOMNode;
nsCOMPtr<nsISupports> nodeAsSupports= do_QueryInterface(mDOMNode);
PL_HashTableAdd(g_NodeLookupTable, nodeAsSupports, this);
}
else if (mDOMNode)
{
// Remove the entry from the hashtable
nsCOMPtr<nsISupports> nodeAsSupports = do_QueryInterface(mDOMNode);
PL_HashTableRemove(g_NodeLookupTable, nodeAsSupports);
mDOMNode = nsnull;
if (g_NodeLookupTable->nentries == 0)
{
PL_HashTableDestroy(g_NodeLookupTable);
g_NodeLookupTable = NULL;
}
}
return S_OK;
}
/* if vs is given, delete only those values - otherwise, delete all values */
void
replica_updatedn_list_delete(ReplicaUpdateDNList list, const Slapi_ValueSet *vs)
{
PLHashTable *hash = list;
if (!vs || slapi_valueset_count(vs) == 0) { /* just delete everything */
PL_HashTableEnumerateEntries(hash, replica_destroy_hash_entry, NULL);
} else {
Slapi_ValueSet *vs_nc = (Slapi_ValueSet *)vs; /* cast away const */
Slapi_Value *val = NULL;
int index = 0;
for (index = slapi_valueset_first_value(vs_nc, &val); val;
index = slapi_valueset_next_value(vs_nc, index, &val)) {
Slapi_DN *dn = slapi_sdn_new_dn_byval(slapi_value_get_string(val));
/* locate object */
Slapi_DN *deldn = (Slapi_DN *)PL_HashTableLookup(hash, slapi_sdn_get_ndn(dn));
if (deldn == NULL)
{
slapi_log_err(SLAPI_LOG_REPL, repl_plugin_name, "replica_updatedn_list_delete -"
"Update DN with value (%s) is not in the update DN list.\n",
slapi_sdn_get_ndn(dn));
} else {
/* remove from hash */
PL_HashTableRemove(hash, slapi_sdn_get_ndn(dn));
/* free the pointer */
slapi_sdn_free(&deldn);
}
/* free the temp dn */
slapi_sdn_free(&dn);
}
}
return;
}
void ConfigStore::Remove(const char *name)
{
if (IsNameDefined(name)) {
PR_Lock(m_lock);
PL_HashTableRemove(m_root->getSet(), name);
PR_Unlock(m_lock);
}
}
SKERR SetValue(const char* pKey, const char* pValue)
{
char * pOldValue;
if((pOldValue = (char*) PL_HashTableLookup(m_pHash, pKey)))
{
PL_HashTableRemove(m_pHash, pKey);
}
char* pHashKey = PL_strdup(pKey);
char* pHashValue = PL_strdup(pValue);
PL_HashTableAdd(m_pHash, pHashKey, pHashValue);
return noErr;
}
void
nsHttpAuthCache::ClearAuthEntry(const char *scheme,
const char *host,
PRInt32 port,
const char *realm)
{
if (!mDB)
return;
nsCAutoString key;
GetAuthKey(scheme, host, port, key);
PL_HashTableRemove(mDB, key.get());
}
void ConfigStore::Add(const char *name, const char *value)
{
if (IsNameDefined(name)) {
PR_Lock(m_lock);
PL_HashTableRemove(m_root->getSet(), name);
PL_HashTableAdd(m_root->getSet(), PL_strdup(name), PL_strdup(value));
PR_Unlock(m_lock);
} else {
PR_Lock(m_lock);
PL_HashTableAdd(m_root->getSet(), PL_strdup(name), PL_strdup(value));
PR_Unlock(m_lock);
}
}
void
nsHttpAuthCache::ClearAuthEntry(const char *scheme,
const char *host,
int32_t port,
const char *realm,
nsACString const &originSuffix)
{
if (!mDB)
return;
nsAutoCString key;
GetAuthKey(scheme, host, port, originSuffix, key);
PL_HashTableRemove(mDB, key.get());
}
void
nsHttpAuthCache::ClearAuthEntry(const char *scheme,
const char *host,
int32_t port,
const char *realm,
uint32_t appId,
bool inBrowserElement)
{
if (!mDB)
return;
nsAutoCString key;
GetAuthKey(scheme, host, port, appId, inBrowserElement, key);
PL_HashTableRemove(mDB, key.get());
}
/*
* nssHash_Remove
*
*/
NSS_IMPLEMENT void
nssHash_Remove
(
nssHash *hash,
const void *it
)
{
PRBool found;
PZ_Lock(hash->mutex);
found = PL_HashTableRemove(hash->plHashTable, it);
if( found ) {
hash->count--;
}
(void)PZ_Unlock(hash->mutex);
return;
}
/*
* nssCKFWHash_Remove
*
*/
NSS_IMPLEMENT void
nssCKFWHash_Remove
(
nssCKFWHash *hash,
const void *it
)
{
PRBool found;
if( CKR_OK != nssCKFWMutex_Lock(hash->mutex) ) {
return;
}
found = PL_HashTableRemove(hash->plHashTable, it);
if( found ) {
hash->count--;
}
(void)nssCKFWMutex_Unlock(hash->mutex);
return;
}
void
nsNodeInfoManager::RemoveNodeInfo(nsNodeInfo *aNodeInfo)
{
NS_PRECONDITION(aNodeInfo, "Trying to remove null nodeinfo from manager!");
// Drop weak reference if needed
if (aNodeInfo == mTextNodeInfo) {
mTextNodeInfo = nsnull;
}
else if (aNodeInfo == mCommentNodeInfo) {
mCommentNodeInfo = nsnull;
}
else if (aNodeInfo == mDocumentNodeInfo) {
mDocumentNodeInfo = nsnull;
}
#ifdef DEBUG
PRBool ret =
#endif
PL_HashTableRemove(mNodeInfoHash, &aNodeInfo->mInner);
NS_POSTCONDITION(ret, "Can't find nsINodeInfo to remove!!!");
}
static void RecycleSerialNumberPtr(void* aPtr)
{
PL_HashTableRemove(gSerialNumbers, aPtr);
}
NS_IMETHODIMP
tmTransactionService::Attach(const nsACString & aDomainName,
ipcITransactionObserver *aObserver,
PRBool aLockingCall) {
// if the queue already exists, then someone else is attached to it. must
// return an error here. Only one module attached to a queue per app.
if (GetQueueID(aDomainName) != TM_NO_ID)
return TM_ERROR_QUEUE_EXISTS;
if (!mObservers)
return NS_ERROR_NOT_INITIALIZED;
// create the full queue name: namespace + queue
nsCString jQName;
jQName.Assign(mNamespace);
jQName.Append(aDomainName);
// this char* has two homes, make sure it gets PL_free()ed properly
char* joinedQueueName = ToNewCString(jQName);
if (!joinedQueueName)
return NS_ERROR_OUT_OF_MEMORY;
// link the observer to the joinedqueuename. home #1 for joinedQueueName
// these currently don't get removed until the destructor on this is called.
PL_HashTableAdd(mObservers, joinedQueueName, aObserver);
// store the domainName and JoinedQueueName, create a place to store the ID
tm_queue_mapping *qm = new tm_queue_mapping();
if (!qm)
return NS_ERROR_OUT_OF_MEMORY;
qm->queueID = TM_NO_ID; // initially no ID for the queue
qm->joinedQueueName = joinedQueueName; // home #2, owner of joinedQueueName
qm->domainName = ToNewCString(aDomainName);
if (!qm->domainName) {
PL_HashTableRemove(mObservers, joinedQueueName);
delete qm;
return NS_ERROR_OUT_OF_MEMORY;
}
mQueueMaps.Append(qm);
nsresult rv = NS_ERROR_FAILURE;
tmTransaction trans;
// acquire a lock if necessary
if (aLockingCall)
lockService->AcquireLock(joinedQueueName, PR_TRUE);
// XXX need to handle lock failures
if (NS_SUCCEEDED(trans.Init(0, // no IPC client
TM_NO_ID, // qID gets returned to us
TM_ATTACH, // action
NS_OK, // default status
(PRUint8 *)joinedQueueName, // qName gets copied
PL_strlen(joinedQueueName)+1))) { // message length
// send the attach msg
SendMessage(&trans, PR_TRUE); // synchronous
rv = NS_OK;
}
// drop the lock if necessary
if (aLockingCall)
lockService->ReleaseLock(joinedQueueName);
return rv;
}
