void
nsTraceRefcnt::Shutdown()
{
#ifdef NS_IMPL_REFCNT_LOGGING
#ifdef MOZ_STACKWALKING
gCodeAddressService = nullptr;
#endif
if (gBloatView) {
PL_HashTableDestroy(gBloatView);
gBloatView = nullptr;
}
if (gTypesToLog) {
PL_HashTableDestroy(gTypesToLog);
gTypesToLog = nullptr;
}
if (gObjectsToLog) {
PL_HashTableDestroy(gObjectsToLog);
gObjectsToLog = nullptr;
}
if (gSerialNumbers) {
PL_HashTableDestroy(gSerialNumbers);
gSerialNumbers = nullptr;
}
maybeUnregisterAndCloseFile(gBloatLog);
maybeUnregisterAndCloseFile(gRefcntsLog);
maybeUnregisterAndCloseFile(gAllocLog);
maybeUnregisterAndCloseFile(gCOMPtrLog);
#endif
}
void
nsTraceRefcntImpl::Shutdown()
{
#ifdef NS_IMPL_REFCNT_LOGGING
if (gBloatView) {
PL_HashTableDestroy(gBloatView);
gBloatView = nullptr;
}
if (gTypesToLog) {
PL_HashTableDestroy(gTypesToLog);
gTypesToLog = nullptr;
}
if (gObjectsToLog) {
PL_HashTableDestroy(gObjectsToLog);
gObjectsToLog = nullptr;
}
if (gSerialNumbers) {
PL_HashTableDestroy(gSerialNumbers);
gSerialNumbers = nullptr;
}
maybeUnregisterAndCloseFile(gBloatLog);
maybeUnregisterAndCloseFile(gRefcntsLog);
maybeUnregisterAndCloseFile(gAllocLog);
maybeUnregisterAndCloseFile(gLeakyLog);
maybeUnregisterAndCloseFile(gCOMPtrLog);
#endif
}
void
nsTraceRefcnt::Shutdown()
{
gCodeAddressService = nullptr;
if (gBloatView) {
PL_HashTableDestroy(gBloatView);
gBloatView = nullptr;
}
if (gTypesToLog) {
PL_HashTableDestroy(gTypesToLog);
gTypesToLog = nullptr;
}
if (gObjectsToLog) {
PL_HashTableDestroy(gObjectsToLog);
gObjectsToLog = nullptr;
}
if (gSerialNumbers) {
PL_HashTableDestroy(gSerialNumbers);
gSerialNumbers = nullptr;
}
maybeUnregisterAndCloseFile(gBloatLog);
maybeUnregisterAndCloseFile(gRefcntsLog);
maybeUnregisterAndCloseFile(gAllocLog);
maybeUnregisterAndCloseFile(gCOMPtrLog);
}
void tmreader_destroy(tmreader *tmr)
{
if (tmr->libraries)
PL_HashTableDestroy(tmr->libraries);
if (tmr->filenames)
PL_HashTableDestroy(tmr->filenames);
if (tmr->components)
PL_HashTableDestroy(tmr->components);
if (tmr->methods)
PL_HashTableDestroy(tmr->methods);
if (tmr->callsites)
PL_HashTableDestroy(tmr->callsites);
PL_FinishArenaPool(&tmr->arena);
free(tmr);
}
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;
}
/* static */ void
nsAppShell::ReleaseGlobals()
{
if (sQueueHashTable) {
PL_HashTableDestroy(sQueueHashTable);
sQueueHashTable = nsnull;
}
if (sCountHashTable) {
PL_HashTableDestroy(sCountHashTable);
sCountHashTable = nsnull;
}
if (sEventQueueList) {
delete sEventQueueList;
sEventQueueList = nsnull;
}
}
//
// when we shutdown the thread, be sure to stop it first. If not, it just might
// crash when the mModule it is looking at disappears.
//
SmartCardMonitoringThread::~SmartCardMonitoringThread()
{
Stop();
SECMOD_DestroyModule(mModule);
if (mHash) {
PL_HashTableDestroy(mHash);
}
}
nsLocale::~nsLocale(void)
{
// enumerate all the entries with a delete function to
// safely delete all the keys and values
PL_HashTableEnumerateEntries(fHashtable, &nsLocale::Hash_EnumerateDelete,
NULL);
PL_HashTableDestroy(fHashtable);
}
// If the ConfigStoreRoot goes out of scope, we can't destroy
// the Hashtable because others maybe depending on the values
// inside.
ConfigStoreRoot::~ConfigStoreRoot ()
{
if( m_set != NULL ) {
if (m_set_refcount==0) {
PL_HashTableDestroy( m_set );
m_set = NULL;
}
}
}
void
nsTraceRefcnt::ResetStatistics()
{
AutoTraceLogLock lock;
if (gBloatView) {
PL_HashTableDestroy(gBloatView);
gBloatView = nullptr;
}
}
ATSUILayoutCache::~ATSUILayoutCache()
{
if (mTable)
{
PL_HashTableEnumerateEntries(mTable, FreeHashEntries, 0);
PL_HashTableDestroy(mTable);
mTable = nsnull;
}
}
void
replica_updatedn_list_free(ReplicaUpdateDNList list)
{
/* destroy the content */
PLHashTable *hash = list;
PL_HashTableEnumerateEntries(hash, replica_destroy_hash_entry, NULL);
if (hash)
PL_HashTableDestroy(hash);
}
/*
* nssCKFWHash_Destroy
*
*/
NSS_IMPLEMENT void
nssCKFWHash_Destroy
(
nssCKFWHash *hash
)
{
(void)nssCKFWMutex_Destroy(hash->mutex);
PL_HashTableDestroy(hash->plHashTable);
(void)nss_ZFreeIf(hash);
}
void
nsTraceRefcntImpl::Shutdown()
{
#ifdef NS_IMPL_REFCNT_LOGGING
if (gBloatView) {
PL_HashTableDestroy(gBloatView);
gBloatView = nsnull;
}
if (gTypesToLog) {
PL_HashTableDestroy(gTypesToLog);
gTypesToLog = nsnull;
}
if (gObjectsToLog) {
PL_HashTableDestroy(gObjectsToLog);
gObjectsToLog = nsnull;
}
if (gSerialNumbers) {
PL_HashTableDestroy(gSerialNumbers);
gSerialNumbers = nsnull;
}
if (gBloatLog) {
fclose(gBloatLog);
gBloatLog = nsnull;
}
if (gRefcntsLog) {
fclose(gRefcntsLog);
gRefcntsLog = nsnull;
}
if (gAllocLog) {
fclose(gAllocLog);
gAllocLog = nsnull;
}
if (gLeakyLog) {
fclose(gLeakyLog);
gLeakyLog = nsnull;
}
if (gCOMPtrLog) {
fclose(gCOMPtrLog);
gCOMPtrLog = nsnull;
}
#endif
}
void
nsTraceRefcnt::ResetStatistics()
{
#ifdef NS_IMPL_REFCNT_LOGGING
AutoTraceLogLock lock;
if (gBloatView) {
PL_HashTableDestroy(gBloatView);
gBloatView = nullptr;
}
#endif
}
nsresult
nsHttpAuthCache::ClearAll()
{
LOG(("nsHttpAuthCache::ClearAll\n"));
if (mDB) {
PL_HashTableDestroy(mDB);
mDB = 0;
}
return NS_OK;
}
void
nsTraceRefcntImpl::ResetStatistics()
{
#ifdef NS_IMPL_REFCNT_LOGGING
LOCK_TRACELOG();
if (gBloatView) {
PL_HashTableDestroy(gBloatView);
gBloatView = nullptr;
}
UNLOCK_TRACELOG();
#endif
}
// Must be single-threaded here, early in primordial thread.
static void InitAutoLockStatics()
{
(void) PR_NewThreadPrivateIndex(&LockStackTPI, 0);
OrderTable = PL_NewHashTable(64, _hash_pointer,
PL_CompareValues, PL_CompareValues,
&_hash_alloc_ops, 0);
if (OrderTable && !(OrderTableLock = PR_NewLock())) {
PL_HashTableDestroy(OrderTable);
OrderTable = 0;
}
PR_CSetOnMonitorRecycle(OnSemaphoreRecycle);
}
void _FreeAutoLockStatics()
{
PLHashTable* table = OrderTable;
if (!table) return;
// Called at shutdown, so we don't need to lock.
PR_CSetOnMonitorRecycle(0);
PR_DestroyLock(OrderTableLock);
OrderTableLock = 0;
PL_HashTableDestroy(table);
OrderTable = 0;
}
// static
void
nsHTMLTags::ReleaseTable(void)
{
if (0 == --gTableRefCount) {
if (gTagTable) {
// Nothing to delete/free in this table, just destroy the table.
PL_HashTableDestroy(gTagTable);
gTagTable = nsnull;
}
}
}
/*
* nssHash_Destroy
*
*/
NSS_IMPLEMENT void
nssHash_Destroy
(
nssHash *hash
)
{
(void)PZ_DestroyLock(hash->mutex);
PL_HashTableDestroy(hash->plHashTable);
if (hash->i_alloced_arena) {
nssArena_Destroy(hash->arena);
} else {
nss_ZFreeIf(hash);
}
}
static void
MimeMultipartRelated_finalize (MimeObject *obj)
{
MimeMultipartRelated* relobj = (MimeMultipartRelated*) obj;
PR_FREEIF(relobj->base_url);
PR_FREEIF(relobj->curtag);
if (relobj->buffered_hdrs) {
PR_FREEIF(relobj->buffered_hdrs->all_headers);
PR_FREEIF(relobj->buffered_hdrs->heads);
PR_FREEIF(relobj->buffered_hdrs);
}
PR_FREEIF(relobj->head_buffer);
relobj->head_buffer_fp = 0;
relobj->head_buffer_size = 0;
if (relobj->hash) {
PL_HashTableEnumerateEntries(relobj->hash, mime_multipart_related_nukehash, NULL);
PL_HashTableDestroy(relobj->hash);
relobj->hash = NULL;
}
if (relobj->input_file_stream)
{
relobj->input_file_stream->Close();
relobj->input_file_stream = nullptr;
}
if (relobj->output_file_stream)
{
relobj->output_file_stream->Close();
relobj->output_file_stream = nullptr;
}
if (relobj->file_buffer)
{
relobj->file_buffer->Remove(false);
relobj->file_buffer = nullptr;
}
if (relobj->headobj) {
mime_free(relobj->headobj);
relobj->headobj = nullptr;
}
((MimeObjectClass*)&MIME_SUPERCLASS)->finalize(obj);
}
nsNodeInfoManager::~nsNodeInfoManager()
{
if (mNodeInfoHash)
PL_HashTableDestroy(mNodeInfoHash);
// Note: mPrincipal may be null here if we never got inited correctly
NS_IF_RELEASE(mPrincipal);
NS_IF_RELEASE(mBindingManager);
#ifdef PR_LOGGING
if (gNodeInfoManagerLeakPRLog)
PR_LOG(gNodeInfoManagerLeakPRLog, PR_LOG_DEBUG,
("NODEINFOMANAGER %p destroyed", this));
#endif
nsLayoutStatics::Release();
}
void
nsTopProgressManager::Tick(void)
{
TRACE_PROGRESS(("nsProgressManager.Tick: aggregating information for active objects\n"));
AggregateTransferInfo info = { 0, 0, 0, 0, 0, 0, 0 };
PL_HashTableEnumerateEntries(fURLs, pm_AggregateTransferInfo, (void*) &info);
TRACE_PROGRESS(("nsProgressManager.Tick: %ld of %ld objects complete, "
"%ldms left, "
"%ld of %ld bytes xferred\n",
info.CompleteCount, info.ObjectCount,
info.MSecRemaining,
info.BytesReceived, info.ContentLength));
PR_ASSERT(info.ObjectCount > 0);
if (info.ObjectCount == 0)
return;
UpdateProgressBar(info);
UpdateStatusMessage(info);
// Check to see if we're done.
if (info.CompleteCount == info.ObjectCount) {
TRACE_PROGRESS(("Complete: %ld/%ld objects loaded\n",
info.CompleteCount,
info.ObjectCount));
// XXX needs to go to allxpstr.h
FE_Progress(fContext, " ");
PL_HashTableDestroy(fURLs);
fURLs = NULL;
fTimeout = NULL;
}
else {
// Reset the timeout to fire again...
fTimeout = FE_SetTimeout(nsTopProgressManager::TimeoutCallback,
(void*) this, 500);
}
}
nsTopProgressManager::~nsTopProgressManager(void)
{
if (fDefaultStatus) {
PL_strfree(fDefaultStatus);
fDefaultStatus = NULL;
}
if (fURLs) {
PL_HashTableDestroy(fURLs);
fURLs = NULL;
}
if (fTimeout) {
FE_ClearTimeout(fTimeout);
fTimeout = NULL;
}
// XXX Needs to go to allxpstr.h
FE_Progress(fContext, "Done.");
}
tmTransactionService::~tmTransactionService() {
// just destroy this, it contains 2 pointers it doesn't own.
if (mObservers)
PL_HashTableDestroy(mObservers);
PRUint32 index = 0;
PRUint32 size = mWaitingMessages.Size();
tm_waiting_msg *msg = nsnull;
for ( ; index < size; index ++) {
msg = (tm_waiting_msg*) mWaitingMessages[index];
delete msg;
}
size = mQueueMaps.Size();
tm_queue_mapping *qmap = nsnull;
for (index = 0; index < size; index++) {
qmap = (tm_queue_mapping*) mQueueMaps[index];
if (qmap)
delete qmap;
}
}
~TimelineThreadData() {if (timers) PL_HashTableDestroy(timers);}
/*********************************************************************
*
* m a i n
*/
int
main(int argc, char *argv[])
{
PRBool readOnly;
int retval = 0;
outputFD = PR_STDOUT;
errorFD = PR_STDERR;
progName = argv[0];
if (argc < 2) {
Usage();
}
excludeDirs = PL_NewHashTable(10, PL_HashString, PL_CompareStrings,
PL_CompareStrings, NULL, NULL);
extensions = PL_NewHashTable(10, PL_HashString, PL_CompareStrings,
PL_CompareStrings, NULL, NULL);
if (parse_args(argc, argv)) {
retval = -1;
goto cleanup;
}
/* Parse the command file if one was given */
if (cmdFile) {
if (ProcessCommandFile()) {
retval = -1;
goto cleanup;
}
}
/* Set up output redirection */
if (outfile) {
if (PR_Access(outfile, PR_ACCESS_EXISTS) == PR_SUCCESS) {
/* delete the file if it is already present */
PR_fprintf(errorFD,
"warning: %s already exists and will be overwritten.\n",
outfile);
warningCount++;
if (PR_Delete(outfile) != PR_SUCCESS) {
PR_fprintf(errorFD, "ERROR: unable to delete %s.\n", outfile);
errorCount++;
exit(ERRX);
}
}
outputFD = PR_Open(outfile,
PR_WRONLY |
PR_CREATE_FILE | PR_TRUNCATE,
0777);
if (!outputFD) {
PR_fprintf(errorFD, "ERROR: Unable to create %s.\n",
outfile);
errorCount++;
exit(ERRX);
}
errorFD = outputFD;
}
/* This seems to be a fairly common user error */
if (verify && list_certs > 0) {
PR_fprintf(errorFD, "%s: Can't use -l and -v at the same time\n",
PROGRAM_NAME);
errorCount++;
retval = -1;
goto cleanup;
}
/* -J assumes -Z now */
if (javascript && zipfile) {
PR_fprintf(errorFD, "%s: Can't use -J and -Z at the same time\n",
PROGRAM_NAME);
PR_fprintf(errorFD, "%s: -J option will create the jar files for you\n",
PROGRAM_NAME);
errorCount++;
retval = -1;
goto cleanup;
}
/* -X needs -Z */
if (xpi_arc && !zipfile) {
PR_fprintf(errorFD, "%s: option XPI (-X) requires option jarfile (-Z)\n",
PROGRAM_NAME);
errorCount++;
retval = -1;
goto cleanup;
}
/* Less common mixing of -L with various options */
if (list_certs > 0 &&
(tell_who || zipfile || javascript ||
scriptdir || extensionsGiven || exclusionsGiven || install_script)) {
PR_fprintf(errorFD, "%s: Can't use -l or -L with that option\n",
PROGRAM_NAME);
errorCount++;
retval = -1;
goto cleanup;
}
if (!cert_dir)
cert_dir = get_default_cert_dir();
VerifyCertDir(cert_dir, keyName);
if (compression_level < MIN_COMPRESSION_LEVEL ||
compression_level > MAX_COMPRESSION_LEVEL) {
PR_fprintf(errorFD, "Compression level must be between %d and %d.\n",
MIN_COMPRESSION_LEVEL, MAX_COMPRESSION_LEVEL);
errorCount++;
retval = -1;
goto cleanup;
}
if (jartree && !keyName) {
PR_fprintf(errorFD, "You must specify a key with which to sign.\n");
errorCount++;
retval = -1;
goto cleanup;
}
readOnly = (genkey == NULL); /* only key generation requires write */
if (InitCrypto(cert_dir, readOnly)) {
PR_fprintf(errorFD, "ERROR: Cryptographic initialization failed.\n");
errorCount++;
retval = -1;
goto cleanup;
}
if (enableOCSP) {
SECStatus rv = CERT_EnableOCSPChecking(CERT_GetDefaultCertDB());
if (rv != SECSuccess) {
PR_fprintf(errorFD, "ERROR: Attempt to enable OCSP Checking failed.\n");
errorCount++;
retval = -1;
}
}
if (verify) {
if (VerifyJar(verify)) {
errorCount++;
retval = -1;
goto cleanup;
}
} else if (list_certs) {
if (ListCerts(keyName, list_certs)) {
errorCount++;
retval = -1;
goto cleanup;
}
} else if (list_modules) {
JarListModules();
} else if (genkey) {
if (GenerateCert(genkey, keySize, token)) {
errorCount++;
retval = -1;
goto cleanup;
}
} else if (tell_who) {
if (JarWho(tell_who)) {
errorCount++;
retval = -1;
goto cleanup;
}
} else if (javascript && jartree) {
/* make sure directory exists */
PRDir *dir;
dir = PR_OpenDir(jartree);
if (!dir) {
PR_fprintf(errorFD, "ERROR: unable to open directory %s.\n",
jartree);
errorCount++;
retval = -1;
goto cleanup;
} else {
PR_CloseDir(dir);
}
/* undo junk from prior runs of signtool*/
if (RemoveAllArc(jartree)) {
PR_fprintf(errorFD, "Error removing archive directories under %s\n",
jartree);
errorCount++;
retval = -1;
goto cleanup;
}
/* traverse all the htm|html files in the directory */
if (InlineJavaScript(jartree, !noRecurse)) {
retval = -1;
goto cleanup;
}
/* sign any resultant .arc directories created in above step */
if (SignAllArc(jartree, keyName, javascript, metafile, install_script,
optimize, !noRecurse)) {
retval = -1;
goto cleanup;
}
if (!leaveArc) {
RemoveAllArc(jartree);
}
if (errorCount > 0 || warningCount > 0) {
PR_fprintf(outputFD, "%d error%s, %d warning%s.\n",
errorCount,
errorCount == 1 ? "" : "s", warningCount, warningCount == 1 ? "" : "s");
} else {
PR_fprintf(outputFD, "Directory %s signed successfully.\n",
jartree);
}
} else if (jartree) {
SignArchive(jartree, keyName, zipfile, javascript, metafile,
install_script, optimize, !noRecurse);
} else
Usage();
cleanup:
if (extensions) {
PL_HashTableDestroy(extensions);
extensions = NULL;
}
if (excludeDirs) {
PL_HashTableDestroy(excludeDirs);
excludeDirs = NULL;
}
if (outputFD != PR_STDOUT) {
PR_Close(outputFD);
}
rm_dash_r(TMP_OUTPUT);
if (retval == 0) {
if (NSS_Shutdown() != SECSuccess) {
exit(1);
}
}
return retval;
}
~State()
{
PL_HashTableDestroy(m_pHash);
};