nsresult nsPluginFile::FreePluginInfo(nsPluginInfo& info)
{
if (info.fName)
PL_strfree(info.fName);
if (info.fDescription)
PL_strfree(info.fDescription);
if (info.fMimeTypeArray)
FreeStringArray(info.fVariantCount, info.fMimeTypeArray);
if (info.fMimeDescriptionArray)
FreeStringArray(info.fVariantCount, info.fMimeDescriptionArray);
if (info.fExtensionArray)
FreeStringArray(info.fVariantCount, info.fExtensionArray);
if (info.fFullPath)
PL_strfree(info.fFullPath);
if (info.fFileName)
PL_strfree(info.fFileName);
if (info.fVersion)
PR_smprintf_free(info.fVersion);
ZeroMemory((void *)&info, sizeof(info));
return NS_OK;
}
nsresult nsPluginFile::FreePluginInfo(nsPluginInfo& info)
{
if(info.fName != nsnull)
PL_strfree(info.fName);
if(info.fFullPath != nsnull)
PL_strfree(info.fFullPath);
if(info.fFileName != nsnull)
PL_strfree(info.fFileName);
if(info.fVersion != nsnull)
PL_strfree(info.fVersion);
if(info.fDescription != nsnull)
PL_strfree(info.fDescription);
if(info.fMimeTypeArray != nsnull)
FreeStringArray(info.fVariantCount, info.fMimeTypeArray);
if(info.fMimeDescriptionArray != nsnull)
FreeStringArray(info.fVariantCount, info.fMimeDescriptionArray);
if(info.fExtensionArray != nsnull)
FreeStringArray(info.fVariantCount, info.fExtensionArray);
memset((void *)&info, 0, sizeof(info));
return NS_OK;
}
nsNPAPIPluginStreamListener::~nsNPAPIPluginStreamListener()
{
// remove this from the plugin instance's stream list
nsTArray<nsNPAPIPluginStreamListener*> *streamListeners = mInst->StreamListeners();
streamListeners->RemoveElement(this);
// For those cases when NewStream is never called, we still may need
// to fire a notification callback. Return network error as fallback
// reason because for other cases, notify should have already been
// called for other reasons elsewhere.
CallURLNotify(NPRES_NETWORK_ERR);
// lets get rid of the buffer
if (mStreamBuffer) {
PR_Free(mStreamBuffer);
mStreamBuffer=nullptr;
}
if (mNotifyURL)
PL_strfree(mNotifyURL);
if (mResponseHeaderBuf)
PL_strfree(mResponseHeaderBuf);
if (mNPStreamWrapper) {
delete mNPStreamWrapper;
}
}
NS_IMETHODIMP
nsCommandLine::Init(int32_t argc, const char* const* argv, nsIFile* aWorkingDir,
uint32_t aState)
{
NS_ENSURE_ARG_MAX(aState, 2);
int32_t i;
mWorkingDir = aWorkingDir;
// skip argv[0], we don't want it
for (i = 1; i < argc; ++i) {
const char* curarg = argv[i];
#ifdef DEBUG_COMMANDLINE
printf("Testing native arg %i: '%s'\n", i, curarg);
#endif
#if defined(XP_WIN)
if (*curarg == '/') {
char* dup = PL_strdup(curarg);
if (!dup) return NS_ERROR_OUT_OF_MEMORY;
*dup = '-';
char* colon = PL_strchr(dup, ':');
if (colon) {
*colon = '\0';
appendArg(dup);
appendArg(colon+1);
} else {
appendArg(dup);
}
PL_strfree(dup);
continue;
}
#endif
if (*curarg == '-') {
if (*(curarg+1) == '-') ++curarg;
char* dup = PL_strdup(curarg);
if (!dup) return NS_ERROR_OUT_OF_MEMORY;
char* eq = PL_strchr(dup, '=');
if (eq) {
*eq = '\0';
appendArg(dup);
appendArg(eq + 1);
} else {
appendArg(dup);
}
PL_strfree(dup);
continue;
}
appendArg(curarg);
}
mState = aState;
return NS_OK;
}
nsJVMPluginTagInfo::~nsJVMPluginTagInfo(void)
{
if (fSimulatedCodebase)
PL_strfree(fSimulatedCodebase);
if (fSimulatedCode)
PL_strfree(fSimulatedCode);
}
nsresult nsPluginFile::FreePluginInfo(nsPluginInfo& info)
{
if (info.fName != nsnull)
PL_strfree(info.fName);
if (info.fDescription != nsnull)
PL_strfree(info.fDescription);
for (PRUint32 i = 0; i < info.fVariantCount; i++) {
if (info.fMimeTypeArray[i] != nsnull)
PL_strfree(info.fMimeTypeArray[i]);
if (info.fMimeDescriptionArray[i] != nsnull)
PL_strfree(info.fMimeDescriptionArray[i]);
if (info.fExtensionArray[i] != nsnull)
PL_strfree(info.fExtensionArray[i]);
}
PR_FREEIF(info.fMimeTypeArray);
PR_FREEIF(info.fMimeDescriptionArray);
PR_FREEIF(info.fExtensionArray);
if (info.fFullPath != nsnull)
PL_strfree(info.fFullPath);
if (info.fFileName != nsnull)
PL_strfree(info.fFileName);
if (info.fVersion != nsnull)
PL_strfree(info.fVersion);
return NS_OK;
}
SKIndexResult::~SKIndexResult()
{
if(m_pszSearchString)
PL_strfree(m_pszSearchString);
if(m_pTokens)
delete (IndexTokens*)m_pTokens;
}
static void
clearPrefEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
{
PrefHashEntry *pref = static_cast<PrefHashEntry *>(entry);
if (pref->flags & PREF_STRING)
{
if (pref->defaultPref.stringVal)
PL_strfree(pref->defaultPref.stringVal);
if (pref->userPref.stringVal)
PL_strfree(pref->userPref.stringVal);
}
// don't need to free this as it's allocated in memory owned by
// gPrefNameArena
pref->key = nsnull;
memset(entry, 0, table->entrySize);
}
// Create an atom
// This function does not advance the parser.
// Call AdvanceToNextToken() to get the next token after the atom.
// RFC3501: atom = 1*ATOM-CHAR
// ASTRING-CHAR = ATOM-CHAR / resp-specials
// ATOM-CHAR = <any CHAR except atom-specials>
// atom-specials = "(" / ")" / "{" / SP / CTL / list-wildcards /
// quoted-specials / resp-specials
// list-wildcards = "%" / "*"
// quoted-specials = DQUOTE / "\"
// resp-specials = "]"
// "Characters are 7-bit US-ASCII unless otherwise specified." [RFC3501, 1.2.]
char *nsIMAPGenericParser::CreateAtom(bool isAstring)
{
char *rv = PL_strdup(fNextToken);
if (!rv)
{
HandleMemoryFailure();
return nsnull;
}
// We wish to stop at the following characters (in decimal ascii)
// 1-31 (CTL), 32 (SP), 34 '"', 37 '%', 40-42 "()*", 92 '\\', 123 '{'
// also, ']' is only allowed in astrings
char *last = rv;
char c = *last;
while ((c > 42 || c == 33 || c == 35 || c == 36 || c == 38 || c == 39)
&& c != '\\' && c != '{' && (isAstring || c != ']'))
c = *++last;
if (rv == last) {
SetSyntaxError(true, "no atom characters found");
PL_strfree(rv);
return nsnull;
}
if (*last)
{
// not the whole token was consumed
*last = '\0';
AdvanceTokenizerStartingPoint((fNextToken - fLineOfTokens) + (last-rv));
}
return rv;
}
NS_METHOD
LocalSearchDataSource::parseResourceIntoFindTokens(nsIRDFResource *u, findTokenPtr tokens)
{
const char *uri = nsnull;
char *id, *token, *value, *newstr;
int loop;
nsresult rv;
if (NS_FAILED(rv = u->GetValueConst(&uri))) return(rv);
#ifdef DEBUG
printf("Find: %s\n", (const char*) uri);
#endif
if (!(id = PL_strdup(uri + sizeof(kFindProtocol) - 1)))
return(NS_ERROR_OUT_OF_MEMORY);
/* parse ID, build up token list */
if ((token = nsCRT::strtok(id, "&", &newstr)) != NULL)
{
while (token != NULL)
{
if ((value = strstr(token, "=")) != NULL)
{
*value++ = '\0';
}
for (loop=0; tokens[loop].token != NULL; loop++)
{
if (!strcmp(token, tokens[loop].token))
{
if (!strcmp(token, "text"))
{
nsCOMPtr<nsITextToSubURI> textToSubURI =
do_GetService(kTextToSubURICID, &rv);
if (NS_SUCCEEDED(rv) && (textToSubURI))
{
PRUnichar *uni = nsnull;
if (NS_SUCCEEDED(rv = textToSubURI->UnEscapeAndConvert("UTF-8", value, &uni)) && (uni))
{
tokens[loop].value = uni;
Recycle(uni);
}
}
}
else
{
nsAutoString valueStr;
valueStr.AssignWithConversion(value);
tokens[loop].value = valueStr;
}
break;
}
}
token = nsCRT::strtok(newstr, "&", &newstr);
}
}
PL_strfree(id);
return(NS_OK);
}
SKERR SKIndex::SetOperators(const char* pszOperators)
{
if(m_pszOperators)
PL_strfree(m_pszOperators);
m_pszOperators = PL_strdup(pszOperators);
::SetOperators(m_pszOperators);
return noErr;
}
static void
DataSourceFreeEntry(void *pool, PLHashEntry *he, PRUintn flag)
{
if (flag == HT_FREE_ENTRY) {
PL_strfree((char*) he->key);
PR_Free(he);
}
}
/**
* returns a string containing all the parameters in the ConfigStore hash set in the
* format key1=value1&&key2=value2&& ...
* The list will be lexically ordered by parameter key values.
* The string needs to be freed by the caller.
**/
TPS_PUBLIC const char* ConfigStore::GetOrderedList()
{
char *outstr = NULL;
char *new_string = NULL;
PRCList order_list;
PR_INIT_CLIST(&order_list);
PR_Lock(m_lock);
PL_HashTableEnumerateEntries(m_root->getSet(), &OrderLoop, &order_list);
PR_Unlock(m_lock);
PRCList *current = PR_LIST_HEAD(&order_list);
PRCList *next;
outstr = (char*) PR_Malloc(128);
int allocated = 128;
int needed = 0;
PR_snprintf(outstr, 128, "");
while (current != &order_list) {
OrderedEntry_t *entry = (OrderedEntry_t *) current;
const char *value = GetConfigAsString(entry->key, "");
if ((entry != NULL) && (entry->key != NULL)) {
needed = PL_strlen(outstr) + PL_strlen(entry->key) + PL_strlen(value) + 4;
if (allocated <= needed) {
while (allocated <= needed) {
allocated = allocated * 2;
}
new_string = (char *)PR_Malloc(allocated);
PR_snprintf(new_string, allocated, "%s", outstr);
PR_Free(outstr);
outstr = new_string;
}
PL_strcat(outstr, entry->key);
PL_strcat(outstr, "=");
PL_strcat(outstr, value);
// free the memory for the Ordered Entry
PL_strfree(entry->key);
}
next = PR_NEXT_LINK(current);
PR_REMOVE_AND_INIT_LINK(current);
if (current != NULL) {
PR_Free(current);
}
current = next;
if (current != &order_list) PL_strcat(outstr, "&&");
}
return outstr;
}
static void FreeStringArray(PRUint32 variants, char ** array)
{
if ((variants == 0) || !array)
return;
for (PRUint32 i = 0; i < variants; i++) {
if (array[i]) {
PL_strfree(array[i]);
array[i] = NULL;
}
}
PR_Free(array);
}
/**
* Destructs processor.
*/
TPS_PUBLIC HttpConnection::~HttpConnection ()
{
if( m_clientnickname != NULL ) {
PL_strfree( m_clientnickname );
m_clientnickname = NULL;
}
if( m_Id != NULL ) {
PL_strfree( m_Id );
m_Id = NULL;
}
if( m_failoverList != NULL ) {
delete m_failoverList;
m_failoverList = NULL;
}
if( m_headers != NULL ) {
delete m_headers;
m_headers = NULL;
}
if( m_lock != NULL ) {
PR_DestroyLock( m_lock );
m_lock = NULL;
}
}
static void FreeStringArray(PRUint32 variants, char ** array)
{
if((variants == 0) || (array == nsnull))
return;
for(PRUint32 i = 0; i < variants; i++)
{
if(array[i] != nsnull)
{
PL_strfree(array[i]);
array[i] = nsnull;
}
}
PR_Free(array);
}
static void FreeStringArray(uint32_t variants, char ** array)
{
if((variants == 0) || (array == nullptr))
return;
for(uint32_t i = 0; i < variants; i++)
{
if(array[i] != nullptr)
{
PL_strfree(array[i]);
array[i] = nullptr;
}
}
PR_Free(array);
}
static PR_CALLBACK void
_FreeEntry(void* pool, PLHashEntry* he, PRUintn flag)
{
if( he == NULL ) {
return;
}
if (flag == HT_FREE_VALUE) {
if( he->value != NULL ) {
PL_strfree( (char*) he->value );
he->value = NULL;
}
} else if (flag == HT_FREE_ENTRY) {
if( he->key != NULL ) {
PL_strfree( (char*) he->key );
he->key = NULL;
}
if( he->value != NULL ) {
PL_strfree( (char*) he->value );
he->value = NULL;
}
PR_DELETE(he);
}
}
static void pref_SetValue(PrefValue* oldValue, PrefValue newValue, PrefType type)
{
switch (type & PREF_VALUETYPE_MASK)
{
case PREF_STRING:
PR_ASSERT(newValue.stringVal);
if (oldValue->stringVal)
PL_strfree(oldValue->stringVal);
oldValue->stringVal = newValue.stringVal ? PL_strdup(newValue.stringVal) : NULL;
break;
default:
*oldValue = newValue;
}
gDirty = true;
}
void DisableWritePoisoning() {
if (sPoisoningState != POISON_ON)
return;
sPoisoningState = POISON_OFF;
PL_strfree(sProfileDirectory);
sProfileDirectory = nullptr;
PRLock *Lock;
{
DebugFDAutoLock lockedScope;
delete getDebugFDs();
Lock = DebugFDAutoLock::getDebugFDsLock();
DebugFDAutoLock::Clear();
}
PR_DestroyLock(Lock);
}
/* Frees the callback list. */
void PREF_Cleanup()
{
NS_ASSERTION(!gCallbacksInProgress,
"PREF_Cleanup was called while gCallbacksInProgress is true!");
struct CallbackNode* node = gCallbacks;
struct CallbackNode* next_node;
while (node)
{
next_node = node->next;
PL_strfree(node->domain);
free(node);
node = next_node;
}
gCallbacks = NULL;
PREF_CleanupPrefs();
}
tmQueue::~tmQueue() {
// empty the vectors
PRUint32 index = 0;
PRUint32 size = mTransactions.Size();
for ( ; index < size ; index++) {
if (mTransactions[index])
delete (tmTransaction *)mTransactions[index];
}
// don't need to delete the mListeners because
// we just insert PRUint32s, no allocation
mTM = nsnull;
mID = 0;
if (mName)
PL_strfree(mName);
}
NSAPI_PUBLIC char * baseName (const char *fileName) {
char *base = NULL;
char *fname = NULL;
base = PL_strdup(fileName);
fname = base;
int len = PL_strlen(fname);
char *p = PL_strrchr(base, '/');
#ifdef XP_WIN32
if (!p) { // if no forward slashes check for backward slashes
p = PL_strrchr(base, '\\');
}
#endif // XP_WIN32
if (!p) { // if no slashes
#ifdef XP_WIN32
char *driveLetter = strchr(base, ':');
if (driveLetter) { // specified only the drive letter
base = NULL;
}
#endif // XP_WIN32
} else if (p == base) { // only one slash
if (len > 1) { // more chars after '/'
base = p + 1;
} else {
base = NULL;
}
} else if (p == (base + (len - 1))) {
// name is ending with a slash..set base to NULL
base = NULL;
} else {
base = p + 1;
}
if (!base) {
// set the passed name as the base name
base = fname;
}
char *bname = PL_strdup(base);
PL_strfree(fname);
return bname;
}
/* Removes |node| from gCallbacks list.
Returns the node after the deleted one. */
struct CallbackNode*
pref_RemoveCallbackNode(struct CallbackNode* node,
struct CallbackNode* prev_node)
{
NS_PRECONDITION(!prev_node || prev_node->next == node, "invalid params");
NS_PRECONDITION(prev_node || gCallbacks == node, "invalid params");
NS_ASSERTION(!gCallbacksInProgress,
"modifying the callback list while gCallbacksInProgress is true");
struct CallbackNode* next_node = node->next;
if (prev_node)
prev_node->next = next_node;
else
gCallbacks = next_node;
PL_strfree(node->domain);
free(node);
return next_node;
}
void
nsSeamonkeyProfileMigrator::WriteFontsBranch(nsIPrefService* aPrefService,
nsVoidArray* aPrefs)
{
nsresult rv;
// Enumerate the branch
nsCOMPtr<nsIPrefBranch> branch;
aPrefService->GetBranch("font.", getter_AddRefs(branch));
PRUint32 count = aPrefs->Count();
for (PRUint32 i = 0; i < count; ++i) {
FontPref* pref = (FontPref*)aPrefs->ElementAt(i);
switch (pref->type) {
case nsIPrefBranch::PREF_STRING:
rv = branch->SetCharPref(pref->prefName, pref->stringValue);
PL_strfree(pref->stringValue);
pref->stringValue = nsnull;
break;
case nsIPrefBranch::PREF_BOOL:
rv = branch->SetBoolPref(pref->prefName, pref->boolValue);
break;
case nsIPrefBranch::PREF_INT:
rv = branch->SetIntPref(pref->prefName, pref->intValue);
break;
case nsIPrefBranch::PREF_INVALID:
nsCOMPtr<nsIPrefLocalizedString> pls(do_CreateInstance("@mozilla.org/pref-localizedstring;1"));
pls->SetData(pref->wstringValue);
rv = branch->SetComplexValue(pref->prefName,
NS_GET_IID(nsIPrefLocalizedString),
pls);
NS_Free(pref->wstringValue);
pref->wstringValue = nsnull;
break;
}
NS_Free(pref->prefName);
pref->prefName = nsnull;
delete pref;
pref = nsnull;
}
aPrefs->Clear();
}
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.");
}
/**
* Parses string of format "n1=v1&n2=v2..."
* into a ConfigStore.
*/
ConfigStore *ConfigStore::Parse(const char *s, const char *separator)
{
char *pair;
char *line = NULL;
int i;
int len;
char *lasts = NULL;
if (s == NULL)
return NULL;
ConfigStoreRoot *root = new ConfigStoreRoot();
ConfigStore *set= new ConfigStore(root,"");
line = PL_strdup(s);
pair = PL_strtok_r(line, separator, &lasts);
while (pair != NULL) {
len = strlen(pair);
i = 0;
while (1) {
if (i >= len) {
goto skip;
}
if (pair[i] == '\0') {
goto skip;
}
if (pair[i] == '=') {
pair[i] = '\0';
break;
}
i++;
}
set->Add(&pair[0], &pair[i+1]);
skip:
pair = PL_strtok_r(NULL, separator, &lasts);
}
if( line != NULL ) {
PL_strfree( line );
line = NULL;
}
return set;
}
COMobject
COMcreateComponent (COMclass cClass)
{
const nsCID *cid = (const nsCID *) cClass;
nsIID iid;
const char *className = COM_get_class_name (cClass);
char *interfaceName = NULL;
nsCOMPtr<nsIComponentManager> compMgr;
NS_GetComponentManager (getter_AddRefs (compMgr));
if (!compMgr)
abort ();
size_t len;
nsISupports *obj;
len = PL_strlen (className);
if (len > 10) /* swarm + name + Impl */
{
if (PL_strcmp (className + len - 4, "Impl") == 0)
{
interfaceName = PL_strdup (className + 5);
interfaceName[len - 4 - 5] = '\0';
}
else
interfaceName = NULL;
}
else
interfaceName = NULL;
iid = getSwarmIID (interfaceName);
if (!NS_SUCCEEDED (compMgr->CreateInstance (*cid, nsnull, iid, (void **) &obj)))
obj = nsnull;
if (obj == nsnull)
abort ();
if (interfaceName)
PL_strfree (interfaceName);
return (COMobject) obj;
}
nsresult nsPluginFile::FreePluginInfo(nsPluginInfo& info)
{
if (info.fName != nullptr)
PL_strfree(info.fName);
if (info.fDescription != nullptr)
PL_strfree(info.fDescription);
for (uint32_t i = 0; i < info.fVariantCount; i++) {
if (info.fMimeTypeArray[i] != nullptr)
PL_strfree(info.fMimeTypeArray[i]);
if (info.fMimeDescriptionArray[i] != nullptr)
PL_strfree(info.fMimeDescriptionArray[i]);
if (info.fExtensionArray[i] != nullptr)
PL_strfree(info.fExtensionArray[i]);
}
free(info.fMimeTypeArray);
info.fMimeTypeArray = nullptr;
free(info.fMimeDescriptionArray);
info.fMimeDescriptionArray = nullptr;
free(info.fExtensionArray);
info.fExtensionArray = nullptr;
if (info.fFullPath != nullptr)
PL_strfree(info.fFullPath);
if (info.fFileName != nullptr)
PL_strfree(info.fFileName);
if (info.fVersion != nullptr)
PL_strfree(info.fVersion);
return NS_OK;
}
SKERR SKIndex::AppendFieldComparator(SKIField *pField)
{
skPtr<SKRecordComparatorUNumField> pFieldComparator;
char *pszFieldName = NULL;
*pFieldComparator.already_AddRefed() =
sk_CreateInstance(SKRecordComparatorUNumField)();
if(!pFieldComparator)
return err_memory;
SKERR err;
err = pField->GetName(&pszFieldName);
if(err != noErr)
return err;
err = pFieldComparator->SetField(pszFieldName);
PL_strfree(pszFieldName);
if(err != noErr)
return err;
return m_docComparator.AddComparator(pFieldComparator);
}
