/* void getInterfaces (out PRUint32 count, [array, size_is (count), retval] out nsIIDPtr array); */ NS_IMETHODIMP WSPProxy::GetInterfaces(PRUint32 *count, nsIID * **array) { if (!mIID) { return NS_ERROR_NOT_INITIALIZED; } *count = 2; nsIID** iids = static_cast<nsIID**>(nsMemory::Alloc(2 * sizeof(nsIID*))); if (!iids) { return NS_ERROR_OUT_OF_MEMORY; } iids[0] = static_cast<nsIID *>(nsMemory::Clone(mIID, sizeof(nsIID))); if (NS_UNLIKELY(!iids[0])) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(0, iids); return NS_ERROR_OUT_OF_MEMORY; } const nsIID& wsiid = NS_GET_IID(nsIWebServiceProxy); iids[1] = static_cast<nsIID *>(nsMemory::Clone(&wsiid, sizeof(nsIID))); if (NS_UNLIKELY(!iids[1])) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(1, iids); return NS_ERROR_OUT_OF_MEMORY; } *array = iids; return NS_OK; }
/* void Suggest (in wstring word, [array, size_is (count)] out wstring suggestions, out PRUint32 count); */ NS_IMETHODIMP mozHunspell::Suggest(const PRUnichar *aWord, PRUnichar ***aSuggestions, PRUint32 *aSuggestionCount) { NS_ENSURE_ARG_POINTER(aSuggestions); NS_ENSURE_ARG_POINTER(aSuggestionCount); NS_ENSURE_TRUE(mHunspell, NS_ERROR_FAILURE); nsresult rv; *aSuggestionCount = 0; nsXPIDLCString charsetWord; rv = ConvertCharset(aWord, getter_Copies(charsetWord)); NS_ENSURE_SUCCESS(rv, rv); char ** wlst; *aSuggestionCount = mHunspell->suggest(&wlst, charsetWord); if (*aSuggestionCount) { *aSuggestions = (PRUnichar **)nsMemory::Alloc(*aSuggestionCount * sizeof(PRUnichar *)); if (*aSuggestions) { PRUint32 index = 0; for (index = 0; index < *aSuggestionCount && NS_SUCCEEDED(rv); ++index) { // Convert the suggestion to utf16 PRInt32 inLength = nsCRT::strlen(wlst[index]); PRInt32 outLength; rv = mDecoder->GetMaxLength(wlst[index], inLength, &outLength); if (NS_SUCCEEDED(rv)) { (*aSuggestions)[index] = (PRUnichar *) nsMemory::Alloc(sizeof(PRUnichar) * (outLength+1)); if ((*aSuggestions)[index]) { rv = mDecoder->Convert(wlst[index], &inLength, (*aSuggestions)[index], &outLength); if (NS_SUCCEEDED(rv)) (*aSuggestions)[index][outLength] = 0; } else rv = NS_ERROR_OUT_OF_MEMORY; } } if (NS_FAILED(rv)) NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(index, *aSuggestions); // free the PRUnichar strings up to the point at which the error occurred } else // if (*aSuggestions) rv = NS_ERROR_OUT_OF_MEMORY; } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(*aSuggestionCount, wlst); return rv; }
NS_IMETHODIMP nsDOMOfflineResourceList::GetMozItems(nsIDOMDOMStringList **aItems) { *aItems = nsnull; nsRefPtr<nsDOMStringList> items = new nsDOMStringList(); NS_ENSURE_TRUE(items, NS_ERROR_OUT_OF_MEMORY); // If we are not associated with an application cache, return an // empty list. nsCOMPtr<nsIApplicationCache> appCache = GetDocumentAppCache(); if (!appCache) { NS_ADDREF(*aItems = items); return NS_OK; } nsresult rv = Init(); NS_ENSURE_SUCCESS(rv, rv); PRUint32 length; char **keys; rv = appCache->GatherEntries(nsIApplicationCache::ITEM_DYNAMIC, &length, &keys); NS_ENSURE_SUCCESS(rv, rv); for (PRUint32 i = 0; i < length; i++) { items->Add(NS_ConvertUTF8toUTF16(keys[i])); } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(length, keys); NS_ADDREF(*aItems = items); return NS_OK; }
NS_IMETHODIMP nsMsgAccount::ClearAllValues() { nsresult rv; nsCAutoString rootPref("mail.account."); rootPref += m_accountKey; rootPref += '.'; rv = getPrefService(); if (NS_FAILED(rv)) return rv; PRUint32 cntChild, i; char **childArray; rv = m_prefs->GetChildList(rootPref.get(), &cntChild, &childArray); if (NS_SUCCEEDED(rv)) { for (i = 0; i < cntChild; i++) m_prefs->ClearUserPref(childArray[i]); NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(cntChild, childArray); } return rv; }
void nsHyphenationManager::LoadAliases() { nsresult rv; nsCOMPtr<nsIPrefBranch> prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv); if (NS_FAILED(rv)) { return; } PRUint32 prefCount; char **prefNames; rv = prefBranch->GetChildList(INTL_HYPHENATIONALIAS_PREFIX, &prefCount, &prefNames); if (NS_SUCCEEDED(rv) && prefCount > 0) { for (PRUint32 i = 0; i < prefCount; ++i) { char *prefValue; rv = prefBranch->GetCharPref(prefNames[i], &prefValue); if (NS_SUCCEEDED(rv)) { nsCAutoString alias(prefNames[i]); alias.Cut(0, strlen(INTL_HYPHENATIONALIAS_PREFIX)); ToLowerCase(alias); nsCAutoString value(prefValue); ToLowerCase(value); nsCOMPtr<nsIAtom> aliasAtom = do_GetAtom(alias); nsCOMPtr<nsIAtom> valueAtom = do_GetAtom(value); mHyphAliases.Put(aliasAtom, valueAtom); NS_Free(prefValue); } } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefNames); } }
NS_IMETHODIMP mozSpellChecker::CheckWord(const nsAString &aWord, bool *aIsMisspelled, nsTArray<nsString> *aSuggestions) { nsresult result; bool correct; if(!mSpellCheckingEngine) return NS_ERROR_NULL_POINTER; *aIsMisspelled = false; result = mSpellCheckingEngine->Check(PromiseFlatString(aWord).get(), &correct); NS_ENSURE_SUCCESS(result, result); if(!correct){ if(aSuggestions){ uint32_t count,i; PRUnichar **words; result = mSpellCheckingEngine->Suggest(PromiseFlatString(aWord).get(), &words, &count); NS_ENSURE_SUCCESS(result, result); for(i=0;i<count;i++){ aSuggestions->AppendElement(nsDependentString(words[i])); } if (count) NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, words); } *aIsMisspelled = true; } return NS_OK; }
static nsresult dir_GetPrefs(nsVoidArray **list) { nsresult rv; nsCOMPtr<nsIPrefBranch> pPref(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); if (NS_FAILED(rv)) return rv; (*list) = new nsVoidArray(); if (!(*list)) return NS_ERROR_OUT_OF_MEMORY; char **children; PRUint32 prefCount; rv = dir_GetChildList(NS_LITERAL_CSTRING(PREF_LDAP_SERVER_TREE_NAME "."), &prefCount, &children); if (NS_FAILED(rv)) return rv; /* TBD: Temporary code to read broken "ldap" preferences tree. * Remove line with if statement after M10. */ if (dir_UserId == 0) pPref->GetIntPref(PREF_LDAP_GLOBAL_TREE_NAME".user_id", &dir_UserId); for (PRUint32 i = 0; i < prefCount; ++i) { DIR_Server *server; server = (DIR_Server *)PR_Calloc(1, sizeof(DIR_Server)); if (server) { DIR_InitServer(server); server->prefName = strdup(children[i]); DIR_GetPrefsForOneServer(server); if (server->description && server->description[0] && ((server->dirType == PABDirectory || server->dirType == IMDirectory || server->dirType == MAPIDirectory || server->dirType == FixedQueryLDAPDirectory || // this one might go away server->dirType == LDAPDirectory))) { if (!dir_IsServerDeleted(server)) { (*list)->AppendElement(server); } else DIR_DeleteServer(server); } else { DIR_DeleteServer(server); } } } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, children); return NS_OK; }
nsresult nsAbLDAPDirectory::SplitStringList( const nsACString& aString, PRUint32 *aCount, char ***aValues) { NS_ENSURE_ARG_POINTER(aCount); NS_ENSURE_ARG_POINTER(aValues); nsTArray<nsCString> strarr; ParseString(aString, ',', strarr); char **cArray = nsnull; if (!(cArray = static_cast<char **>(nsMemory::Alloc( strarr.Length() * sizeof(char *))))) return NS_ERROR_OUT_OF_MEMORY; for (PRUint32 i = 0; i < strarr.Length(); ++i) { if (!(cArray[i] = ToNewCString(strarr[i]))) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(strarr.Length(), cArray); return NS_ERROR_OUT_OF_MEMORY; } } *aCount = strarr.Length(); *aValues = cArray; return NS_OK; }
/* void getKeyForTag (in wstring tag); */ NS_IMETHODIMP nsMsgTagService::GetKeyForTag(const nsAString &aTag, nsACString &aKey) { uint32_t count; char **prefList; nsresult rv = m_tagPrefBranch->GetChildList("", &count, &prefList); NS_ENSURE_SUCCESS(rv, rv); // traverse the list, and look for a pref with the desired tag value. for (uint32_t i = count; i--;) { // We are returned the tag prefs in the form "<key>.<tag_data_type>", but // since we only want the tags, just check that the string ends with "tag". nsDependentCString prefName(prefList[i]); if (StringEndsWith(prefName, NS_LITERAL_CSTRING(TAG_PREF_SUFFIX_TAG))) { nsAutoString curTag; GetUnicharPref(prefList[i], curTag); if (aTag.Equals(curTag)) { aKey = Substring(prefName, 0, prefName.Length() - STRLEN(TAG_PREF_SUFFIX_TAG)); break; } } } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, prefList); ToLowerCase(aKey); return NS_OK; }
nsresult nsLDAPSyncQuery::OnLDAPSearchEntry(nsILDAPMessage *aMessage) { uint32_t attrCount; char** attributes; nsresult rv = aMessage->GetAttributes(&attrCount, &attributes); if (NS_FAILED(rv)) { NS_WARNING("nsLDAPSyncQuery:OnLDAPSearchEntry(): " "aMessage->GetAttributes() failed"); FinishLDAPQuery(); return rv; } // Iterate through the attributes received in this message for (uint32_t i = 0; i < attrCount; i++) { PRUnichar **vals; uint32_t valueCount; // Get the values of this attribute. // XXX better failure handling rv = aMessage->GetValues(attributes[i], &valueCount, &vals); if (NS_FAILED(rv)) { NS_WARNING("nsLDAPSyncQuery:OnLDAPSearchEntry(): " "aMessage->GetValues() failed\n"); FinishLDAPQuery(); break; } // Store all values of this attribute in the mResults. for (uint32_t j = 0; j < valueCount; j++) { mResults.Append(PRUnichar('\n')); mResults.AppendASCII(attributes[i]); mResults.Append(PRUnichar('=')); mResults.Append(vals[j]); } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(valueCount, vals); } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(attrCount, attributes); return rv; }
void nsDOMOfflineResourceList::ClearCachedKeys() { if (mCachedKeys) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mCachedKeysCount, mCachedKeys); mCachedKeys = nsnull; mCachedKeysCount = 0; } }
NS_IMETHODIMP mozSpellChecker::GetDictionaryList(nsTArray<nsString> *aDictionaryList) { nsresult rv; // For catching duplicates nsClassHashtable<nsStringHashKey, nsCString> dictionaries; nsCOMArray<mozISpellCheckingEngine> spellCheckingEngines; rv = GetEngineList(&spellCheckingEngines); NS_ENSURE_SUCCESS(rv, rv); for (int32_t i = 0; i < spellCheckingEngines.Count(); i++) { nsCOMPtr<mozISpellCheckingEngine> engine = spellCheckingEngines[i]; uint32_t count = 0; PRUnichar **words = nullptr; engine->GetDictionaryList(&words, &count); for (uint32_t k = 0; k < count; k++) { nsAutoString dictName; dictName.Assign(words[k]); // Skip duplicate dictionaries. Only take the first one // for each name. if (dictionaries.Get(dictName, nullptr)) continue; dictionaries.Put(dictName, nullptr); if (!aDictionaryList->AppendElement(dictName)) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, words); return NS_ERROR_OUT_OF_MEMORY; } } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, words); } return NS_OK; }
NS_IMETHODIMP nsNSSCertificate::GetAllTokenNames(uint32_t *aLength, PRUnichar*** aTokenNames) { nsNSSShutDownPreventionLock locker; if (isAlreadyShutDown()) return NS_ERROR_NOT_AVAILABLE; NS_ENSURE_ARG(aLength); NS_ENSURE_ARG(aTokenNames); *aLength = 0; *aTokenNames = NULL; /* Get the slots from NSS */ PK11SlotList *slots = NULL; PK11SlotListCleaner slotCleaner(slots); PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("Getting slots for \"%s\"\n", mCert->nickname)); slots = PK11_GetAllSlotsForCert(mCert, NULL); if (!slots) { if (PORT_GetError() == SEC_ERROR_NO_TOKEN) return NS_OK; // List of slots is empty, return empty array else return NS_ERROR_FAILURE; } /* read the token names from slots */ PK11SlotListElement *le; for (le = slots->head; le; le = le->next) { ++(*aLength); } *aTokenNames = (PRUnichar **)nsMemory::Alloc(sizeof(PRUnichar *) * (*aLength)); if (!*aTokenNames) { *aLength = 0; return NS_ERROR_OUT_OF_MEMORY; } uint32_t iToken; for (le = slots->head, iToken = 0; le; le = le->next, ++iToken) { char *token = PK11_GetTokenName(le->slot); (*aTokenNames)[iToken] = ToNewUnicode(NS_ConvertUTF8toUTF16(token)); if (!(*aTokenNames)[iToken]) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(iToken, *aTokenNames); *aLength = 0; *aTokenNames = NULL; return NS_ERROR_OUT_OF_MEMORY; } } return NS_OK; }
nsresult nsSeamonkeyProfileMigrator::CopyPasswords(PRBool aReplace) { nsresult rv; nsCString signonsFileName; GetSignonFileName(aReplace, getter_Copies(signonsFileName)); if (signonsFileName.IsEmpty()) return NS_ERROR_FILE_NOT_FOUND; NS_ConvertASCIItoUTF16 fileName(signonsFileName); if (aReplace) rv = CopyFile(fileName, fileName); else { // Get the password manager, which is the destination for the passwords // being migrated. Also create a new instance of the legacy password // storage component, which we'll use to slurp in the signons from // Seamonkey's signons.txt. nsCOMPtr<nsILoginManager> pwmgr( do_GetService("@mozilla.org/login-manager;1")); nsCOMPtr<nsILoginManagerStorage> importer( do_CreateInstance("@mozilla.org/login-manager/storage/legacy;1")); nsCOMPtr<nsIFile> signonsFile; mSourceProfile->Clone(getter_AddRefs(signonsFile)); signonsFile->Append(fileName); importer->InitWithFile(signonsFile, nsnull); PRUint32 count; nsILoginInfo **logins; rv = importer->GetAllLogins(&count, &logins); NS_ENSURE_SUCCESS(rv, rv); for (PRUint32 i = 0; i < count; i++) { pwmgr->AddLogin(logins[i]); } NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(count, logins); PRUnichar **hostnames; rv = importer->GetAllDisabledHosts(&count, &hostnames); NS_ENSURE_SUCCESS(rv, rv); for (PRUint32 i = 0; i < count; i++) { pwmgr->SetLoginSavingEnabled(nsDependentString(hostnames[i]), PR_FALSE); } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, hostnames); } return rv; }
void LoadExistingPrefs() { uint32_t count; char** names; nsresult rv = Preferences::GetRootBranch()-> GetChildList(kLoggingPrefPrefix, &count, &names); if (NS_SUCCEEDED(rv) && count) { for (size_t i = 0; i < count; i++) { LoadPrefValue(names[i]); } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, names); } }
/** * Export VirtualBox vrde server */ static void exportVirtualBoxVRDEServer(IVRDEServer *vrdeServer, xmlTextWriterPtr writer) { nsresult rc; // find info PRBool enabled = PR_FALSE; vrdeServer->GetEnabled(&enabled); // vrde enabled ADDXMLBOOL(vrdeServer->GetEnabled, "vrde"); if (enabled == PR_TRUE) { // vrde extpack ADDXMLSTRING(vrdeServer->GetVRDEExtPack, "vrde.ext"); // vrde auth lib ADDXMLSTRING(vrdeServer->GetAuthLibrary, "vrde.authlib"); // vrde multicon ADDXMLBOOL(vrdeServer->GetAllowMultiConnection, "vrde.multicon"); // vrde reusecon ADDXMLBOOL(vrdeServer->GetReuseSingleConnection, "vrde.reusecon"); // vrde properties { PRUnichar **properties = nsnull; PRUint32 propertiesCount = 0; nsAutoString keyPrefix; rc = vrdeServer->GetVRDEProperties(&propertiesCount, &properties); if (NS_SUCCEEDED(rc)) { for (PRUint32 i = 0; i < propertiesCount; i++) { nsXPIDLString value; rc = vrdeServer->GetVRDEProperty(properties[i], getter_Copies(value)); if (NS_SUCCEEDED(rc)) { nsCAutoString key("vrde."); key.AppendWithConversion(properties[i]); WRITEXMLSTRING(convertString(key).c_str(), convertString(value)); } } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(propertiesCount, properties); } } } }
// Convert the list of words in iwords to the same capitalization aWord and // return them in owords. NS_IMETHODIMP mozEnglishWordUtils::FromRootForm(const char16_t *aWord, const char16_t **iwords, uint32_t icount, char16_t ***owords, uint32_t *ocount) { nsAutoString word(aWord); nsresult rv = NS_OK; int32_t length; char16_t **tmpPtr = (char16_t **)moz_xmalloc(sizeof(char16_t *)*icount); if (!tmpPtr) return NS_ERROR_OUT_OF_MEMORY; mozEnglishWordUtils::myspCapitalization ct = captype(word); for(uint32_t i = 0; i < icount; ++i) { length = NS_strlen(iwords[i]); tmpPtr[i] = (char16_t *) moz_xmalloc(sizeof(char16_t) * (length + 1)); if (MOZ_UNLIKELY(!tmpPtr[i])) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, tmpPtr); return NS_ERROR_OUT_OF_MEMORY; } memcpy(tmpPtr[i], iwords[i], (length + 1) * sizeof(char16_t)); nsAutoString capTest(tmpPtr[i]); mozEnglishWordUtils::myspCapitalization newCt=captype(capTest); if(newCt == NoCap){ switch(ct) { case HuhCap: case NoCap: break; case AllCap: ToUpperCase(tmpPtr[i],tmpPtr[i],length); rv = NS_OK; break; case InitCap: ToUpperCase(tmpPtr[i],tmpPtr[i],1); rv = NS_OK; break; default: rv = NS_ERROR_FAILURE; // should never get here; break; } } } if (NS_SUCCEEDED(rv)){ *owords = tmpPtr; *ocount = icount; } return rv; }
nsresult nsLDAPSyncQuery::OnLDAPSearchResult(nsILDAPMessage *aMessage) { // We are done with the LDAP search. // Release the control variable for the eventloop and other members // FinishLDAPQuery(); // Release memory allocated for mAttrs if (mAttrCount > 0) NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mAttrCount, mAttrs); return NS_OK; }
// Convert the list of words in iwords to the same capitalization aWord and // return them in owords. NS_IMETHODIMP mozEnglishWordUtils::FromRootForm(const PRUnichar *aWord, const PRUnichar **iwords, PRUint32 icount, PRUnichar ***owords, PRUint32 *ocount) { nsAutoString word(aWord); nsresult rv = NS_OK; PRInt32 length; PRUnichar **tmpPtr = (PRUnichar **)nsMemory::Alloc(sizeof(PRUnichar *)*icount); if (!tmpPtr) return NS_ERROR_OUT_OF_MEMORY; mozEnglishWordUtils::myspCapitalization ct = captype(word); for(PRUint32 i = 0; i < icount; ++i) { length = nsCRT::strlen(iwords[i]); tmpPtr[i] = (PRUnichar *) nsMemory::Alloc(sizeof(PRUnichar) * (length + 1)); if (NS_UNLIKELY(!tmpPtr[i])) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, tmpPtr); return NS_ERROR_OUT_OF_MEMORY; } memcpy(tmpPtr[i], iwords[i], (length + 1) * sizeof(PRUnichar)); nsAutoString capTest(tmpPtr[i]); mozEnglishWordUtils::myspCapitalization newCt=captype(capTest); if(newCt == NoCap){ switch(ct) { case HuhCap: case NoCap: break; case AllCap: rv = mCaseConv->ToUpper(tmpPtr[i],tmpPtr[i],length); break; case InitCap: rv = mCaseConv->ToUpper(tmpPtr[i],tmpPtr[i],1); break; default: rv = NS_ERROR_FAILURE; // should never get here; break; } } } if (NS_SUCCEEDED(rv)){ *owords = tmpPtr; *ocount = icount; } return rv; }
// we don't get to use exceptions, so we'll fake it. this is an error // handler for IterateAttributes(). // nsresult nsLDAPMessage::IterateAttrErrHandler(PRInt32 aLderrno, PRUint32 *aAttrCount, char** *aAttributes, BerElement *position) { // if necessary, free the position holder used by // ldap_{first,next}_attribute() // if (position) { ldap_ber_free(position, 0); } // deallocate any entries in the array that have been allocated, then // the array itself // if (*aAttributes) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(*aAttrCount, *aAttributes); } // possibly spit out a debugging message, then return an appropriate // error code // switch (aLderrno) { case LDAP_PARAM_ERROR: NS_WARNING("nsLDAPMessage::IterateAttributes() failure; probable bug " "or memory corruption encountered"); return NS_ERROR_UNEXPECTED; break; case LDAP_DECODING_ERROR: NS_WARNING("nsLDAPMessage::IterateAttributes(): decoding error"); return NS_ERROR_LDAP_DECODING_ERROR; break; case LDAP_NO_MEMORY: return NS_ERROR_OUT_OF_MEMORY; break; } NS_WARNING("nsLDAPMessage::IterateAttributes(): LDAP C SDK returned " "unexpected value; possible bug or memory corruption"); return NS_ERROR_UNEXPECTED; }
NS_IMETHODIMP mozSpellChecker::GetDictionaryList(nsStringArray *aDictionaryList) { nsAutoString temp; PRUint32 count,i; PRUnichar **words; if(!aDictionaryList || !mSpellCheckingEngine) return NS_ERROR_NULL_POINTER; mSpellCheckingEngine->GetDictionaryList(&words,&count); for(i=0;i<count;i++){ temp.Assign(words[i]); aDictionaryList->AppendString(temp); } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, words); return NS_OK; }
nsresult nsLDAPSyncQuery::OnLDAPSearchEntry(nsILDAPMessage *aMessage) { nsresult rv; // Attributes are retrieved in StartLDAPSearch // iterate through them // for (PRUint32 i = 0; i < mAttrCount; i++) { PRUnichar **vals; PRUint32 valueCount; // get the values of this attribute // XXX better failure handling // rv = aMessage->GetValues(mAttrs[i], &valueCount, &vals); if (NS_FAILED(rv)) { NS_WARNING("nsLDAPSyncQuery:OnLDAPSearchEntry(): " "aMessage->GetValues() failed\n"); FinishLDAPQuery(); return rv;; } // store all values of this attribute in the mResults. // for (PRUint32 j = 0; j < valueCount; j++) { mResults.Append(PRUnichar('\n')); mResults.AppendASCII(mAttrs[i]); mResults.Append(PRUnichar('=')); mResults.Append(vals[j]); } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(valueCount, vals); } return NS_OK; }
NS_IMETHODIMP mozSpellChecker::CheckWord(const nsAString &aWord, PRBool *aIsMisspelled, nsStringArray *aSuggestions) { nsresult result; PRBool correct; if(!mSpellCheckingEngine) return NS_ERROR_NULL_POINTER; // don't bother to check crazy words, also, myspell gets unhappy if you // give it too much data and crashes sometimes if (aWord.Length() > UNREASONABLE_WORD_LENGTH) { *aIsMisspelled = PR_TRUE; return NS_OK; } *aIsMisspelled = PR_FALSE; result = mSpellCheckingEngine->Check(PromiseFlatString(aWord).get(), &correct); NS_ENSURE_SUCCESS(result, result); if(!correct){ if(aSuggestions){ PRUint32 count,i; PRUnichar **words; result = mSpellCheckingEngine->Suggest(PromiseFlatString(aWord).get(), &words, &count); NS_ENSURE_SUCCESS(result, result); for(i=0;i<count;i++){ aSuggestions->AppendString(nsDependentString(words[i])); } if (count) NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, words); } if(aIsMisspelled){ *aIsMisspelled = PR_TRUE; } } return NS_OK; }
/* void getAllTags (out unsigned long count, [array, size_is (count), retval] out nsIMsgTag tagArray); */ NS_IMETHODIMP nsMsgTagService::GetAllTags(uint32_t *aCount, nsIMsgTag ***aTagArray) { NS_ENSURE_ARG_POINTER(aCount); NS_ENSURE_ARG_POINTER(aTagArray); // preset harmless default values *aCount = 0; *aTagArray = nullptr; // get the actual tag definitions nsresult rv; uint32_t prefCount; char **prefList; rv = m_tagPrefBranch->GetChildList("", &prefCount, &prefList); NS_ENSURE_SUCCESS(rv, rv); // sort them by key for ease of processing NS_QuickSort(prefList, prefCount, sizeof(char*), CompareMsgTagKeys, nullptr); // build an array of nsIMsgTag elements from the orderered list // it's at max the same size as the preflist, but usually only about half nsIMsgTag** tagArray = (nsIMsgTag**) NS_Alloc(sizeof(nsIMsgTag*) * prefCount); if (!tagArray) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList); return NS_ERROR_OUT_OF_MEMORY; } uint32_t currentTagIndex = 0; nsMsgTag *newMsgTag; nsString tag; nsCString lastKey, color, ordinal; for (uint32_t i = prefCount; i--;) { // extract just the key from <key>.<info=tag|color|ordinal> char *info = strrchr(prefList[i], '.'); if (info) { nsCAutoString key(Substring(prefList[i], info)); if (key != lastKey) { if (!key.IsEmpty()) { // .tag MUST exist (but may be empty) rv = GetTagForKey(key, tag); if (NS_SUCCEEDED(rv)) { // .color MAY exist color.Truncate(); GetColorForKey(key, color); // .ordinal MAY exist rv = GetOrdinalForKey(key, ordinal); if (NS_FAILED(rv)) ordinal.Truncate(); // store the tag info in our array newMsgTag = new nsMsgTag(key, tag, color, ordinal); if (!newMsgTag) { NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(currentTagIndex, tagArray); NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList); return NS_ERROR_OUT_OF_MEMORY; } NS_ADDREF(tagArray[currentTagIndex++] = newMsgTag); } } lastKey = key; } } } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList); // sort the non-null entries by ordinal NS_QuickSort(tagArray, currentTagIndex, sizeof(nsMsgTag*), CompareMsgTags, nullptr); // All done, now return the values (the idl's size_is(count) parameter // ensures that the array is cut accordingly). *aCount = currentTagIndex; *aTagArray = tagArray; return NS_OK; }
/** * Export VirtualBox machine */ void exportVirtualBoxMachine(IVirtualBox *virtualBox, IMachine *machine, xmlTextWriterPtr writer) { nsCOMPtr<ISystemProperties> systemProperties; nsresult rc = virtualBox->GetSystemProperties(getter_AddRefs(systemProperties)); if (NS_SUCCEEDED(rc)) { xmlTextWriterStartElement(writer, TOXMLCHAR("machine")); // uuid ADDXMLSTRING(machine->GetId, "id"); // name ADDXMLSTRING(machine->GetName, "name"); // description ADDXMLSTRING(machine->GetDescription, "description"); // os type ADDXMLSTRING(machine->GetOSTypeId, "ostype"); // settings file ADDXMLSTRING(machine->GetSettingsFilePath, "path"); // hardware uuid ADDXMLSTRING(machine->GetHardwareUUID, "hardwareuuid"); // memory size ADDXMLINT32U(machine->GetMemorySize, "memory"); // memory balloon size ADDXMLINT32U(machine->GetMemoryBalloonSize, "memoryballoon"); // page fusion ADDXMLBOOL(machine->GetPageFusionEnabled, "pagefusion"); // vram size ADDXMLINT32U(machine->GetVRAMSize, "vram"); // hpet ADDXMLBOOL(machine->GetHPETEnabled, "hpet"); // cpu count ADDXMLINT32U(machine->GetCPUCount, "cpus"); // cpu execution cap ADDXMLINT32U(machine->GetCPUExecutionCap, "cpucap"); // cpu hotplug ADDXMLBOOL(machine->GetCPUHotPlugEnabled, "cpuhotplug"); // synthcpu // { // PRBool value; // rc = machine->GetCPUProperty(CPUPropertyType_Synthetic, &value); // if (NS_SUCCEEDED(rc)) { // WRITEXMLBOOL("synthcpu", value); // } // } // firmware type ADDXMLENUM(machine->GetFirmwareType, "firmware", firmwareTypeConverter); // bios settings { nsCOMPtr<IBIOSSettings> value; rc = machine->GetBIOSSettings(getter_AddRefs(value)); if (NS_SUCCEEDED(rc)) { exportVirtualBoxBIOSSettings(value, writer); } } // boot order { PRUint32 bootPositions; rc = systemProperties->GetMaxBootPosition(&bootPositions); if (NS_SUCCEEDED(rc)) { for (PRUint32 i = 1; i <= bootPositions; i++) { PRUint32 value; rc = machine->GetBootOrder(i, &value); if (NS_SUCCEEDED(rc)) { char name[256]; sprintf(name, "boot%d", i); WRITEXMLENUM(name, value, deviceTypeConverter); } } } } // pae { PRBool value; rc = machine->GetCPUProperty(CPUPropertyType_PAE, &value); if (NS_SUCCEEDED(rc)) { WRITEXMLBOOL("pae", value); } } // rtc use utc ADDXMLBOOL(machine->GetRTCUseUTC, "rtcuseutc"); // monitor count ADDXMLINT32U(machine->GetMonitorCount, "monitorcount"); // accelerate 3D ADDXMLBOOL(machine->GetAccelerate3DEnabled, "accelerate3d"); // accelerate 2D video ADDXMLBOOL(machine->GetAccelerate2DVideoEnabled, "accelerate2dvideo"); // hwvirtex { PRBool value; rc = machine->GetCPUProperty(HWVirtExPropertyType_Enabled, &value); if (NS_SUCCEEDED(rc)) { WRITEXMLBOOL("hwvirtex", value); } } // vtxvpid { PRBool value; rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_VPID, &value); if (NS_SUCCEEDED(rc)) { WRITEXMLBOOL("vtxvpid", value); } } // nestedpaging { PRBool value; rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &value); if (NS_SUCCEEDED(rc)) { WRITEXMLBOOL("nestedpaging", value); } } // unrestrictedexec { PRBool value; rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &value); if (NS_SUCCEEDED(rc)) { WRITEXMLBOOL("unrestrictedexec", value); } } // largepages { PRBool value; rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &value); if (NS_SUCCEEDED(rc)) { WRITEXMLBOOL("largepages", value); } } // force { PRBool value; rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_Force, &value); if (NS_SUCCEEDED(rc)) { WRITEXMLBOOL("hwforce", value); } } // io cache ADDXMLBOOL(machine->GetIOCacheEnabled, "iocache"); // io cache size ADDXMLINT32U(machine->GetIOCacheSize, "iocachesize"); // chipset type ADDXMLENUM(machine->GetChipsetType, "chipset", chipsetTypeConverter); // pointing hid type ADDXMLENUM(machine->GetPointingHIDType, "mouse", pointingHidTypeConverter); // keyboard hid type ADDXMLENUM(machine->GetKeyboardHIDType, "keyboard", keyboardHidTypeConverter); // clipboard mode ADDXMLENUM(machine->GetClipboardMode, "clipboard", clipboardModeConverter); // vm state ADDXMLENUM(machine->GetState, "state", stateConverter); // vm state change ADDXMLTIMESTAMP(machine->GetLastStateChange, "statechanged"); // teleporterenabled, teleporterport, teleporteraddress, teleporterpassword // storage controller { IStorageController **storageControllers = nsnull; PRUint32 storageControllersCount = 0; rc = machine->GetStorageControllers(&storageControllersCount, &storageControllers); if (NS_SUCCEEDED(rc)) { for (PRUint32 i = 0; i < storageControllersCount; i++) { exportVirtualBoxStorageController(storageControllers[i], i, writer); } } NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(storageControllersCount, storageControllers); } // medium attachments { IMediumAttachment **mediumAttachments = nsnull; PRUint32 mediumAttachmentsCount = 0; rc = machine->GetMediumAttachments(&mediumAttachmentsCount, &mediumAttachments); if (NS_SUCCEEDED(rc)) { for (PRUint32 i = 0; i < mediumAttachmentsCount; i++) { exportVirtualBoxMediumAttachment(mediumAttachments[i], writer); } } NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(mediumAttachmentsCount, mediumAttachments); } // network adapters { PRUint32 networkAdaptersCount; PRUint32 chipsetType; rc = machine->GetChipsetType(&chipsetType); if (NS_SUCCEEDED(rc)) { rc = systemProperties->GetMaxNetworkAdapters(chipsetType, &networkAdaptersCount); if (NS_SUCCEEDED(rc)) { for (PRUint32 i = 0; i < networkAdaptersCount; i++) { nsCOMPtr<INetworkAdapter> networkAdapter; rc = machine->GetNetworkAdapter(i, getter_AddRefs(networkAdapter)); if (NS_SUCCEEDED(rc)) { exportVirtualBoxNetworkAdapter(networkAdapter, i + 1, writer); } } } } } // uartX // audio adapter { nsCOMPtr<IAudioAdapter> value; rc = machine->GetAudioAdapter(getter_AddRefs(value)); if (NS_SUCCEEDED(rc)) { exportVirtualBoxAudioAdapter(value, writer); } } // vrde server { nsCOMPtr<IVRDEServer> value; rc = machine->GetVRDEServer(getter_AddRefs(value)); if (NS_SUCCEEDED(rc)) { exportVirtualBoxVRDEServer(value, writer); } } // usb controllers // { // nsCOMPtr<IUSBController> value; // rc = machine->GetUSBController(getter_AddRefs(value)); // if (NS_SUCCEEDED(rc)) { // exportVirtualBoxUSBController(value, writer); // } // } // guest properties { PRUnichar **names = nsnull; PRUnichar **values = nsnull; PRInt64 *timestamps = nsnull; PRUnichar **flags = nsnull; PRUint32 namesCount = 0; PRUint32 valuesCount = 0; PRUint32 timestampsCount = 0; PRUint32 flagsCount = 0; rc = machine->EnumerateGuestProperties((const PRUnichar*)nsnull, &namesCount, &names, &valuesCount, &values, ×tampsCount, ×tamps, &flagsCount, &flags); if (NS_SUCCEEDED(rc)) { for (PRUint32 i = 0; i < namesCount; i++) { nsAutoString name(names[i]); nsAutoString value(values[i]); PRUint64 timestamp = timestamps[i]; nsAutoString flag(flags[i]); WRITEXMLSTRING(convertString(name).c_str(), convertString(value)); } } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(namesCount, names); NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(valuesCount, values); nsMemory::Free(timestamps); NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(flagsCount, flags); } xmlTextWriterEndElement(writer); } }
/** * Export VirtualBox network adapter */ static void exportVirtualBoxNetworkAdapter(INetworkAdapter *networkAdapter, PRUint32 index, xmlTextWriterPtr writer) { char name[256]; nsresult rc; // find info PRUint32 attachmentType = 0; networkAdapter->GetAttachmentType(&attachmentType); // attachment type sprintf(name, "nic%d", index); ADDXMLENUM(networkAdapter->GetAttachmentType, name, networkAttachmentTypeConverter); // specific configuration switch (attachmentType) { case NetworkAttachmentType_NAT: // nat network sprintf(name, "natnet%d", index); ADDXMLSTRING(networkAdapter->GetNATNetwork, name); break; case NetworkAttachmentType_Bridged: // bridge adapter sprintf(name, "bridgeadapter%d", index); ADDXMLSTRING(networkAdapter->GetBridgedInterface, name); break; case NetworkAttachmentType_Internal: // internal network sprintf(name, "intnet%d", index); ADDXMLSTRING(networkAdapter->GetInternalNetwork, name); break; case NetworkAttachmentType_HostOnly: // host adapter sprintf(name, "hostonlyadapter%d", index); ADDXMLSTRING(networkAdapter->GetHostOnlyInterface, name); break; case NetworkAttachmentType_Generic: // generic adapter sprintf(name, "genericadapter%d", index); ADDXMLSTRING(networkAdapter->GetGenericDriver, name); break; } switch (attachmentType) { case NetworkAttachmentType_NAT: case NetworkAttachmentType_Bridged: case NetworkAttachmentType_Internal: case NetworkAttachmentType_HostOnly: case NetworkAttachmentType_Generic: // enabled sprintf(name, "nicenabled%d", index); ADDXMLBOOL(networkAdapter->GetEnabled, name); // enabled sprintf(name, "nicpriority%d", index); ADDXMLINT32U(networkAdapter->GetBootPriority, name); // adapter type sprintf(name, "nictype%d", index); ADDXMLENUM(networkAdapter->GetAdapterType, name, networkAdapterTypeConverter); // mac address sprintf(name, "macaddress%d", index); ADDXMLSTRING(networkAdapter->GetMACAddress, name); // cable connected sprintf(name, "cableconnected%d", index); ADDXMLBOOL(networkAdapter->GetCableConnected, name); // speed sprintf(name, "nicspeed%d", index); ADDXMLINT32U(networkAdapter->GetLineSpeed, name); break; // promisc policy sprintf(name, "nicpromisc%d", index); ADDXMLENUM(networkAdapter->GetPromiscModePolicy, name, promiscModePolicyConverter); // extra properties { PRUnichar **propertyNames = nsnull; PRUnichar **propertyValues = nsnull; PRUint32 propertyNamesCount = 0; PRUint32 propertyValuesCount = 0; sprintf(name, "nic%d_", index); rc = networkAdapter->GetProperties(NS_LITERAL_STRING("").get(), &propertyNamesCount, &propertyNames, &propertyValuesCount, &propertyValues); if (NS_SUCCEEDED(rc)) { for (PRUint32 i = 0; i < propertyNamesCount && i < propertyValuesCount; i++) { nsCAutoString key(name); nsString value(propertyValues[i]); key.AppendWithConversion(propertyNames[i]); WRITEXMLSTRING(convertString(key).c_str(), convertString(value)); } NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(propertyNamesCount, propertyNames); NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(propertyValuesCount, propertyValues); } } } }
// static XPCNativeSet* XPCNativeSet::GetNewOrUsed(XPCCallContext& ccx, nsIClassInfo* classInfo) { AutoMarkingNativeSetPtr set(ccx); XPCJSRuntime* rt = ccx.GetRuntime(); ClassInfo2NativeSetMap* map = rt->GetClassInfo2NativeSetMap(); if (!map) return nsnull; { // scoped lock XPCAutoLock lock(rt->GetMapLock()); set = map->Find(classInfo); } if (set) return set; nsIID** iidArray = nsnull; AutoMarkingNativeInterfacePtrArrayPtr interfaceArray(ccx); PRUint32 iidCount = 0; if (NS_FAILED(classInfo->GetInterfaces(&iidCount, &iidArray))) { // Note: I'm making it OK for this call to fail so that one can add // nsIClassInfo to classes implemented in script without requiring this // method to be implemented. // Make sure these are set correctly... iidArray = nsnull; iidCount = 0; } NS_ASSERTION((iidCount && iidArray) || !(iidCount || iidArray), "GetInterfaces returned bad array"); // !!! from here on we only exit through the 'out' label !!! if (iidCount) { AutoMarkingNativeInterfacePtrArrayPtr arr(ccx, new XPCNativeInterface*[iidCount], iidCount, true); if (!arr) goto out; interfaceArray = arr; XPCNativeInterface** currentInterface = interfaceArray; nsIID** currentIID = iidArray; PRUint16 interfaceCount = 0; for (PRUint32 i = 0; i < iidCount; i++) { nsIID* iid = *(currentIID++); if (!iid) { NS_ERROR("Null found in classinfo interface list"); continue; } XPCNativeInterface* iface = XPCNativeInterface::GetNewOrUsed(ccx, iid); if (!iface) { // XXX warn here continue; } *(currentInterface++) = iface; interfaceCount++; } if (interfaceCount) { set = NewInstance(ccx, interfaceArray, interfaceCount); if (set) { NativeSetMap* map2 = rt->GetNativeSetMap(); if (!map2) goto out; XPCNativeSetKey key(set, nsnull, 0); { // scoped lock XPCAutoLock lock(rt->GetMapLock()); XPCNativeSet* set2 = map2->Add(&key, set); if (!set2) { NS_ERROR("failed to add our set!"); DestroyInstance(set); set = nsnull; goto out; } if (set2 != set) { DestroyInstance(set); set = set2; } } } } else set = GetNewOrUsed(ccx, &NS_GET_IID(nsISupports)); } else set = GetNewOrUsed(ccx, &NS_GET_IID(nsISupports)); if (set) { // scoped lock XPCAutoLock lock(rt->GetMapLock()); #ifdef DEBUG XPCNativeSet* set2 = #endif map->Add(classInfo, set); NS_ASSERTION(set2, "failed to add our set!"); NS_ASSERTION(set2 == set, "hashtables inconsistent!"); } out: if (iidArray) NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(iidCount, iidArray); if (interfaceArray) delete [] interfaceArray.get(); return set; }
NS_IMETHODIMP nsLDAPOperation::SearchExt(const nsACString& aBaseDn, PRInt32 aScope, const nsACString& aFilter, const nsACString &aAttributes, PRIntervalTime aTimeOut, PRInt32 aSizeLimit) { if (!mMessageListener) { NS_ERROR("nsLDAPOperation::SearchExt(): mMessageListener not set"); return NS_ERROR_NOT_INITIALIZED; } // XXX add control logging PR_LOG(gLDAPLogModule, PR_LOG_DEBUG, ("nsLDAPOperation::SearchExt(): called with aBaseDn = '%s'; " "aFilter = '%s'; aAttributes = %s; aSizeLimit = %d", PromiseFlatCString(aBaseDn).get(), PromiseFlatCString(aFilter).get(), PromiseFlatCString(aAttributes).get(), aSizeLimit)); LDAPControl **serverctls = 0; nsresult rv; if (mServerControls) { rv = convertControlArray(mServerControls, &serverctls); if (NS_FAILED(rv)) { PR_LOG(gLDAPLogModule, PR_LOG_ERROR, ("nsLDAPOperation::SearchExt(): error converting server " "control array: %x", rv)); return rv; } } LDAPControl **clientctls = 0; if (mClientControls) { rv = convertControlArray(mClientControls, &clientctls); if (NS_FAILED(rv)) { PR_LOG(gLDAPLogModule, PR_LOG_ERROR, ("nsLDAPOperation::SearchExt(): error converting client " "control array: %x", rv)); ldap_controls_free(serverctls); return rv; } } // Convert our comma separated string to one that the C-SDK will like, i.e. // convert to a char array and add a last NULL element. nsTArray<nsCString> attrArray; ParseString(aAttributes, ',', attrArray); char **attrs = nsnull; PRUint32 origLength = attrArray.Length(); if (origLength) { attrs = static_cast<char **> (NS_Alloc((origLength + 1) * sizeof(char *))); if (!attrs) return NS_ERROR_OUT_OF_MEMORY; for (PRUint32 i = 0; i < origLength; ++i) attrs[i] = ToNewCString(attrArray[i]); attrs[origLength] = 0; } // XXX deal with timeout here int retVal = ldap_search_ext(mConnectionHandle, PromiseFlatCString(aBaseDn).get(), aScope, PromiseFlatCString(aFilter).get(), attrs, 0, serverctls, clientctls, 0, aSizeLimit, &mMsgID); // clean up ldap_controls_free(serverctls); ldap_controls_free(clientctls); // The last entry is null, so no need to free that. NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(origLength, attrs); rv = TranslateLDAPErrorToNSError(retVal); NS_ENSURE_SUCCESS(rv, rv); // make sure the connection knows where to call back once the messages // for this operation start coming in // rv = mConnection->AddPendingOperation(mMsgID, this); if (NS_FAILED(rv)) { switch (rv) { case NS_ERROR_OUT_OF_MEMORY: (void)ldap_abandon_ext(mConnectionHandle, mMsgID, 0, 0); return NS_ERROR_OUT_OF_MEMORY; default: (void)ldap_abandon_ext(mConnectionHandle, mMsgID, 0, 0); NS_ERROR("nsLDAPOperation::SearchExt(): unexpected error in " "mConnection->AddPendingOperation"); return NS_ERROR_UNEXPECTED; } } return NS_OK; }
nsresult GetSlotWithMechanism(uint32_t aMechanism, nsIInterfaceRequestor* m_ctx, PK11SlotInfo** aSlot, nsNSSShutDownPreventionLock& /*proofOfLock*/) { PK11SlotList * slotList = nullptr; char16_t** tokenNameList = nullptr; nsITokenDialogs * dialogs; char16_t *unicodeTokenChosen; PK11SlotListElement *slotElement, *tmpSlot; uint32_t numSlots = 0, i = 0; bool canceled; nsresult rv = NS_OK; *aSlot = nullptr; // Get the slot slotList = PK11_GetAllTokens(MapGenMechToAlgoMech(aMechanism), true, true, m_ctx); if (!slotList || !slotList->head) { rv = NS_ERROR_FAILURE; goto loser; } if (!slotList->head->next) { /* only one slot available, just return it */ *aSlot = slotList->head->slot; } else { // Gerenate a list of slots and ask the user to choose // tmpSlot = slotList->head; while (tmpSlot) { numSlots++; tmpSlot = tmpSlot->next; } // Allocate the slot name buffer // tokenNameList = static_cast<char16_t**>(moz_xmalloc(sizeof(char16_t *) * numSlots)); if (!tokenNameList) { rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } i = 0; slotElement = PK11_GetFirstSafe(slotList); while (slotElement) { tokenNameList[i] = UTF8ToNewUnicode(nsDependentCString(PK11_GetTokenName(slotElement->slot))); slotElement = PK11_GetNextSafe(slotList, slotElement, false); if (tokenNameList[i]) i++; else { // OOM. adjust numSlots so we don't free unallocated memory. numSlots = i; PK11_FreeSlotListElement(slotList, slotElement); rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } } /* Throw up the token list dialog and get back the token */ rv = getNSSDialogs((void**)&dialogs, NS_GET_IID(nsITokenDialogs), NS_TOKENDIALOGS_CONTRACTID); if (NS_FAILED(rv)) goto loser; if (!tokenNameList || !*tokenNameList) { rv = NS_ERROR_OUT_OF_MEMORY; } else { rv = dialogs->ChooseToken(m_ctx, (const char16_t**)tokenNameList, numSlots, &unicodeTokenChosen, &canceled); } NS_RELEASE(dialogs); if (NS_FAILED(rv)) goto loser; if (canceled) { rv = NS_ERROR_NOT_AVAILABLE; goto loser; } // Get the slot // slotElement = PK11_GetFirstSafe(slotList); nsAutoString tokenStr(unicodeTokenChosen); while (slotElement) { if (tokenStr.Equals(NS_ConvertUTF8toUTF16(PK11_GetTokenName(slotElement->slot)))) { *aSlot = slotElement->slot; PK11_FreeSlotListElement(slotList, slotElement); break; } slotElement = PK11_GetNextSafe(slotList, slotElement, false); } if(!(*aSlot)) { rv = NS_ERROR_FAILURE; goto loser; } } // Get a reference to the slot // PK11_ReferenceSlot(*aSlot); loser: if (slotList) { PK11_FreeSlotList(slotList); } if (tokenNameList) { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(numSlots, tokenNameList); } return rv; }
// wrapper for get_values_len // NS_IMETHODIMP nsLDAPMessage::GetBinaryValues(const char *aAttr, PRUint32 *aCount, nsILDAPBERValue ***aValues) { struct berval **values; #if defined(DEBUG) // We only want this being logged for debug builds so as not to affect performance too much. PR_LOG(gLDAPLogModule, PR_LOG_DEBUG, ("nsLDAPMessage::GetBinaryValues(): called with aAttr = '%s'", aAttr)); #endif values = ldap_get_values_len(mConnectionHandle, mMsgHandle, aAttr); // bail out if there was a problem // if (!values) { PRInt32 lderrno = ldap_get_lderrno(mConnectionHandle, 0, 0); if ( lderrno == LDAP_DECODING_ERROR ) { // this may not be an error; it could just be that the // caller has asked for an attribute that doesn't exist. // PR_LOG(gLDAPLogModule, PR_LOG_WARNING, ("nsLDAPMessage::GetBinaryValues(): ldap_get_values " "returned LDAP_DECODING_ERROR")); return NS_ERROR_LDAP_DECODING_ERROR; } else if ( lderrno == LDAP_PARAM_ERROR ) { NS_ERROR("nsLDAPMessage::GetBinaryValues(): internal error: 1"); return NS_ERROR_UNEXPECTED; } else { NS_ERROR("nsLDAPMessage::GetBinaryValues(): internal error: 2"); return NS_ERROR_UNEXPECTED; } } // count the values // PRUint32 numVals = ldap_count_values_len(values); // create the out array // *aValues = static_cast<nsILDAPBERValue **>(nsMemory::Alloc(numVals * sizeof(nsILDAPBERValue))); if (!aValues) { ldap_value_free_len(values); return NS_ERROR_OUT_OF_MEMORY; } // clone the array (except for the trailing NULL entry) using the // shared allocator for XPCOM correctness // PRUint32 i; nsresult rv; for ( i = 0 ; i < numVals ; i++ ) { // create an nsBERValue object // nsCOMPtr<nsILDAPBERValue> berValue = new nsLDAPBERValue(); if (!berValue) { NS_ERROR("nsLDAPMessage::GetBinaryValues(): out of memory" " creating nsLDAPBERValue object"); NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, aValues); ldap_value_free_len(values); return NS_ERROR_OUT_OF_MEMORY; } // copy the value from the struct into the nsBERValue // rv = berValue->Set(values[i]->bv_len, reinterpret_cast<PRUint8 *>(values[i]->bv_val)); if (NS_FAILED(rv)) { NS_ERROR("nsLDAPMessage::GetBinaryValues(): error setting" " nsBERValue"); ldap_value_free_len(values); return rv == NS_ERROR_OUT_OF_MEMORY ? rv : NS_ERROR_UNEXPECTED; } // put the nsIBERValue object into the out array // NS_ADDREF( (*aValues)[i] = berValue.get() ); } *aCount = numVals; ldap_value_free_len(values); return NS_OK; }