NS_IMETHODIMP nsMsgBrkMBoxStore::ChangeKeywords(nsIArray *aHdrArray, const nsACString &aKeywords, bool aAdd) { NS_ENSURE_ARG_POINTER(aHdrArray); nsCOMPtr<nsIOutputStream> outputStream; nsCOMPtr<nsISeekableStream> seekableStream; int64_t restoreStreamPos; uint32_t messageCount; nsresult rv = aHdrArray->GetLength(&messageCount); NS_ENSURE_SUCCESS(rv, rv); if (!messageCount) return NS_ERROR_INVALID_ARG; rv = GetOutputStream(aHdrArray, outputStream, seekableStream, restoreStreamPos); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIInputStream> inputStream = do_QueryInterface(outputStream, &rv); NS_ENSURE_SUCCESS(rv, rv); nsLineBuffer<char> *lineBuffer; rv = NS_InitLineBuffer(&lineBuffer); NS_ENSURE_SUCCESS(rv, rv); // For each message, we seek to the beginning of the x-mozilla-status header, // and start reading lines, looking for x-mozilla-keys: headers; If we're // adding the keyword and we find // a header with the desired keyword already in it, we don't need to // do anything. Likewise, if removing keyword and we don't find it, // we don't need to do anything. Otherwise, if adding, we need to // see if there's an x-mozilla-keys // header with room for the new keyword. If so, we replace the // corresponding number of spaces with the keyword. If no room, // we can't do anything until the folder is compacted and another // x-mozilla-keys header is added. In that case, we set a property // on the header, which the compaction code will check. nsTArray<nsCString> keywordArray; ParseString(aKeywords, ' ', keywordArray); nsCOMPtr<nsIMsgDBHdr> msgHdr; for (uint32_t i = 0; i < messageCount; ++i) // for each message { msgHdr = do_QueryElementAt(aHdrArray, i, &rv); NS_ENSURE_SUCCESS(rv, rv); uint64_t messageOffset; msgHdr->GetMessageOffset(&messageOffset); uint32_t statusOffset = 0; (void)msgHdr->GetStatusOffset(&statusOffset); uint64_t desiredOffset = messageOffset + statusOffset; ChangeKeywordsHelper(msgHdr, desiredOffset, lineBuffer, keywordArray, aAdd, outputStream, seekableStream, inputStream); } PR_Free(lineBuffer); if (restoreStreamPos != -1) seekableStream->Seek(nsISeekableStream::NS_SEEK_SET, restoreStreamPos); else if (outputStream) outputStream->Close(); if (messageCount > 0) { msgHdr = do_QueryElementAt(aHdrArray, 0); SetDBValid(msgHdr); } return NS_OK; }
NS_IMETHODIMP InputPortManager::NotifySuccess(nsIArray* aDataList) { MOZ_ASSERT(aDataList); if (!aDataList) { RejectPendingGetInputPortsPromises(NS_ERROR_DOM_ABORT_ERR); return NS_ERROR_INVALID_ARG; } uint32_t length; nsresult rv = aDataList->GetLength(&length); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } nsCOMPtr<nsIInputPortListener> portListener; rv = mInputPortService->GetInputPortListener( getter_AddRefs(portListener)); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } ErrorResult erv; nsTArray<RefPtr<InputPort>> ports(length); for (uint32_t i = 0; i < length; i++) { nsCOMPtr<nsIInputPortData> portData = do_QueryElementAt(aDataList, i); if (NS_WARN_IF(!portData)) { continue; } InputPortData* data = static_cast<InputPortData*>(portData.get()); RefPtr<InputPort> port; switch (data->GetType()) { case InputPortType::Av: port = AVInputPort::Create(GetParentObject(), portListener, portData, erv); break; case InputPortType::Displayport: port = DisplayPortInputPort::Create(GetParentObject(), portListener, portData, erv); break; case InputPortType::Hdmi: port = HDMIInputPort::Create(GetParentObject(), portListener, portData, erv); break; default: MOZ_ASSERT_UNREACHABLE("Unknown InputPort type"); break; } MOZ_ASSERT(port); ports.AppendElement(port); } if (NS_WARN_IF(erv.Failed())) { return erv.StealNSResult(); } erv = SetInputPorts(ports); return erv.StealNSResult(); }
NS_IMETHODIMP sbDeviceFirmwareUpdater::ContinueUpdate(sbIDevice *aDevice, sbIDeviceEventListener *aListener, PRBool *_retval) { LOG(("[sbDeviceFirmwareUpdater] - ContinueUpdate")); NS_ENSURE_TRUE(mMonitor, NS_ERROR_NOT_INITIALIZED); NS_ENSURE_FALSE(mIsShutdown, NS_ERROR_ILLEGAL_DURING_SHUTDOWN); NS_ENSURE_ARG_POINTER(aDevice); NS_ENSURE_ARG_POINTER(_retval); nsresult rv = NS_ERROR_UNEXPECTED; *_retval = PR_FALSE; nsCOMPtr<nsIMutableArray> mutableArray = do_CreateInstance("@songbirdnest.com/moz/xpcom/threadsafe-array;1", &rv); NS_ENSURE_SUCCESS(rv, rv); mRecoveryModeHandlers.EnumerateRead( sbDeviceFirmwareUpdater::EnumerateIntoArrayISupportsKey, mutableArray.get()); PRUint32 length = 0; rv = mutableArray->GetLength(&length); NS_ENSURE_SUCCESS(rv, rv); for(PRUint32 current = 0; current < length; ++current) { nsCOMPtr<sbIDeviceFirmwareHandler> handler = do_QueryElementAt(mutableArray, current, &rv); NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Bad object in hashtable!"); if(NS_FAILED(rv)) { continue; } nsCOMPtr<sbIDevice> oldDevice; rv = handler->GetBoundDevice(getter_AddRefs(oldDevice)); NS_ENSURE_SUCCESS(rv, rv); PRBool success = PR_FALSE; rv = handler->Rebind(aDevice, aListener, &success); NS_ENSURE_SUCCESS(rv, rv); if(success) { if (oldDevice) { mRecoveryModeHandlers.Remove(oldDevice); mRunningHandlers.Remove(oldDevice); } rv = PutRunningHandler(aDevice, handler); NS_ENSURE_SUCCESS(rv, rv); *_retval = PR_TRUE; #ifdef PR_LOGGING nsString contractId; rv = handler->GetContractId(contractId); NS_ENSURE_SUCCESS(rv, rv); LOG(("[%s] continueUpdate successful", __FUNCTION__)); LOG(("Handler with contract id %s will continue the update", NS_ConvertUTF16toUTF8(contractId).BeginReading())); #endif return NS_OK; } } return NS_OK; }
NS_IMETHODIMP nsMsgCopyService::CopyMessages(nsIMsgFolder* srcFolder, /* UI src folder */ nsIArray* messages, nsIMsgFolder* dstFolder, bool isMove, nsIMsgCopyServiceListener* listener, nsIMsgWindow* window, bool allowUndo) { NS_ENSURE_ARG_POINTER(srcFolder); NS_ENSURE_ARG_POINTER(messages); NS_ENSURE_ARG_POINTER(dstFolder); PR_LOG(gCopyServiceLog, PR_LOG_DEBUG, ("CopyMessages")); if (srcFolder == dstFolder) { NS_ERROR("src and dest folders for msg copy can't be the same"); return NS_ERROR_FAILURE; } nsCopyRequest* copyRequest; nsCopySource* copySource = nullptr; nsCOMArray<nsIMsgDBHdr> msgArray; uint32_t cnt; nsCOMPtr<nsIMsgDBHdr> msg; nsCOMPtr<nsIMsgFolder> curFolder; nsCOMPtr<nsISupports> aSupport; nsresult rv; // XXX TODO // JUNK MAIL RELATED // make sure dest folder exists // and has proper flags, before we start copying? copyRequest = new nsCopyRequest(); if (!copyRequest) return NS_ERROR_OUT_OF_MEMORY; aSupport = do_QueryInterface(srcFolder, &rv); rv = copyRequest->Init(nsCopyMessagesType, aSupport, dstFolder, isMove, 0 /* new msg flags, not used */, EmptyCString(), listener, window, allowUndo); if (NS_FAILED(rv)) goto done; messages->GetLength(&cnt); if (PR_LOG_TEST(gCopyServiceLog, PR_LOG_ALWAYS)) LogCopyRequest("CopyMessages request", copyRequest); // duplicate the message array so we could sort the messages by it's // folder easily for (uint32_t i = 0; i < cnt; i++) { nsCOMPtr<nsIMsgDBHdr> currMsg = do_QueryElementAt(messages, i); msgArray.AppendObject(currMsg); } cnt = msgArray.Count(); while (cnt-- > 0) { msg = msgArray[cnt]; rv = msg->GetFolder(getter_AddRefs(curFolder)); if (NS_FAILED(rv)) goto done; if (!copySource) { copySource = copyRequest->AddNewCopySource(curFolder); if (!copySource) { rv = NS_ERROR_OUT_OF_MEMORY; goto done; } } if (curFolder == copySource->m_msgFolder) { copySource->AddMessage(msg); msgArray.RemoveObjectAt(cnt); } if (cnt == 0) { cnt = msgArray.Count(); if (cnt > 0) copySource = nullptr; // * force to create a new one and // * continue grouping the messages } } // undo stuff if (NS_SUCCEEDED(rv) && copyRequest->m_allowUndo && copyRequest->m_copySourceArray.Length() > 1 && copyRequest->m_txnMgr) copyRequest->m_txnMgr->BeginBatch(); done: if (NS_FAILED(rv)) delete copyRequest; else rv = DoCopy(copyRequest); return rv; }
nsresult nsAbManager::AppendLDIFForMailList(nsIAbCard *aCard, nsIAbLDAPAttributeMap *aAttrMap, nsACString &aResult) { nsresult rv; nsString attrValue; rv = AppendDNForCard("dn", aCard, aAttrMap, aResult); NS_ENSURE_SUCCESS(rv,rv); aResult += MSG_LINEBREAK \ "objectclass: top" MSG_LINEBREAK \ "objectclass: groupOfNames" MSG_LINEBREAK; rv = aCard->GetDisplayName(attrValue); NS_ENSURE_SUCCESS(rv,rv); nsCAutoString ldapAttributeName; rv = aAttrMap->GetFirstAttribute(NS_LITERAL_CSTRING(kDisplayNameProperty), ldapAttributeName); NS_ENSURE_SUCCESS(rv, rv); rv = AppendProperty(ldapAttributeName.get(), attrValue.get(), aResult); NS_ENSURE_SUCCESS(rv,rv); aResult += MSG_LINEBREAK; rv = aAttrMap->GetFirstAttribute(NS_LITERAL_CSTRING(kNicknameProperty), ldapAttributeName); NS_ENSURE_SUCCESS(rv, rv); rv = aCard->GetPropertyAsAString(kNicknameProperty, attrValue); if (NS_SUCCEEDED(rv) && !attrValue.IsEmpty()) { rv = AppendProperty(ldapAttributeName.get(), attrValue.get(), aResult); NS_ENSURE_SUCCESS(rv,rv); aResult += MSG_LINEBREAK; } rv = aAttrMap->GetFirstAttribute(NS_LITERAL_CSTRING(kNotesProperty), ldapAttributeName); NS_ENSURE_SUCCESS(rv, rv); rv = aCard->GetPropertyAsAString(kNotesProperty, attrValue); if (NS_SUCCEEDED(rv) && !attrValue.IsEmpty()) { rv = AppendProperty(ldapAttributeName.get(), attrValue.get(), aResult); NS_ENSURE_SUCCESS(rv,rv); aResult += MSG_LINEBREAK; } nsCString mailListURI; rv = aCard->GetMailListURI(getter_Copies(mailListURI)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr <nsIAbDirectory> mailList; rv = GetDirectory(mailListURI, getter_AddRefs(mailList)); NS_ENSURE_SUCCESS(rv,rv); nsCOMPtr<nsIMutableArray> addresses; rv = mailList->GetAddressLists(getter_AddRefs(addresses)); if (addresses) { PRUint32 total = 0; addresses->GetLength(&total); if (total) { PRUint32 i; for (i = 0; i < total; i++) { nsCOMPtr <nsIAbCard> listCard = do_QueryElementAt(addresses, i, &rv); NS_ENSURE_SUCCESS(rv,rv); rv = AppendDNForCard("member", listCard, aAttrMap, aResult); NS_ENSURE_SUCCESS(rv,rv); aResult += MSG_LINEBREAK; } } } aResult += MSG_LINEBREAK; return NS_OK; }
nsresult nsEudoraFilters::AddTerm(const char* pHeader, const char* pVerb, const char* pValue, bool booleanAnd, bool negateVerb) { nsresult rv; nsMsgSearchAttribValue attrib = FindHeader(pHeader); nsMsgSearchOpValue op = FindOperator(pVerb); nsAutoCString arbitraryHeader; nsAutoString unicodeHeader, unicodeVerb, unicodeValue; nsAutoString filterTitle; NS_CopyNativeToUnicode(nsCString(pHeader), unicodeHeader); NS_CopyNativeToUnicode(nsCString(pVerb), unicodeVerb); NS_CopyNativeToUnicode(nsCString(pValue), unicodeValue); filterTitle = NS_LITERAL_STRING("- "); filterTitle += unicodeHeader; filterTitle += NS_LITERAL_STRING(" "); filterTitle += unicodeVerb; filterTitle += NS_LITERAL_STRING(" "); filterTitle += unicodeValue; filterTitle += NS_LITERAL_STRING(": "); if (op < 0) { m_errorLog += filterTitle; m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_VERB, pVerb); m_errorLog += NS_LITERAL_STRING("\n"); return NS_ERROR_INVALID_ARG; } if (!pHeader || !*pHeader) { m_errorLog += filterTitle; m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_EMPTY_HEADER); m_errorLog += NS_LITERAL_STRING("\n"); return NS_ERROR_INVALID_ARG; } if (negateVerb) { switch (op) { case nsMsgSearchOp::Contains: case nsMsgSearchOp::Is: case nsMsgSearchOp::IsInAB: op++; break; case nsMsgSearchOp::DoesntContain: case nsMsgSearchOp::Isnt: case nsMsgSearchOp::IsntInAB: op--; break; default: m_errorLog += filterTitle; m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_NEGATE_VERB, unicodeVerb.get()); m_errorLog += NS_LITERAL_STRING("\n"); return NS_ERROR_INVALID_ARG; } } if (attrib < 0) { // Can't handle other Eudora meta-headers (Any Header, Personality, Junk Score) if (*pHeader == *LDAQ) { m_errorLog += filterTitle; m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_META_HEADER, unicodeHeader.get()); m_errorLog += NS_LITERAL_STRING("\n"); return NS_ERROR_INVALID_ARG; } // Arbitrary headers for filters don't like the colon at the end arbitraryHeader = pHeader; int32_t index = arbitraryHeader.FindChar(':'); if (index >= 0) arbitraryHeader.SetLength(index); int32_t headerIndex = AddCustomHeader(arbitraryHeader.get()); NS_ENSURE_TRUE(headerIndex >= 0, NS_ERROR_FAILURE); attrib = nsMsgSearchAttrib::OtherHeader + 1 + headerIndex; } uint32_t numFilters; rv = m_pFilterArray->Count(&numFilters); NS_ENSURE_SUCCESS(rv, rv); for (uint32_t filterIndex = 0; filterIndex < numFilters; filterIndex++) { nsCOMPtr<nsIMsgFilter> filter = do_QueryElementAt(m_pFilterArray, filterIndex, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsISupportsArray> terms; rv = filter->GetSearchTerms(getter_AddRefs(terms)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMsgSearchTerm> term; if (booleanAnd) { term = do_QueryElementAt(terms, 0, &rv); if (NS_SUCCEEDED(rv) && term) { term->SetBooleanAnd(true); term = nullptr; } } rv = filter->CreateTerm(getter_AddRefs(term)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMsgSearchValue> value; rv = term->GetValue(getter_AddRefs(value)); NS_ENSURE_SUCCESS(rv, rv); value->SetAttrib(attrib); value->SetStr(unicodeValue); term->SetAttrib(attrib); term->SetOp(op); term->SetBooleanAnd(booleanAnd); if (!arbitraryHeader.IsEmpty()) term->SetArbitraryHeader(arbitraryHeader); term->SetValue(value); filter->AppendTerm(term); } return NS_OK; }
NS_IMETHODIMP nsSpamSettings::Initialize(nsIMsgIncomingServer *aServer) { NS_ENSURE_ARG_POINTER(aServer); nsresult rv; PRInt32 spamLevel; rv = aServer->GetIntValue("spamLevel", &spamLevel); NS_ENSURE_SUCCESS(rv, rv); rv = SetLevel(spamLevel); NS_ENSURE_SUCCESS(rv, rv); bool moveOnSpam; rv = aServer->GetBoolValue("moveOnSpam", &moveOnSpam); NS_ENSURE_SUCCESS(rv, rv); rv = SetMoveOnSpam(moveOnSpam); NS_ENSURE_SUCCESS(rv, rv); PRInt32 moveTargetMode; rv = aServer->GetIntValue("moveTargetMode", &moveTargetMode); NS_ENSURE_SUCCESS(rv, rv); rv = SetMoveTargetMode(moveTargetMode); NS_ENSURE_SUCCESS(rv, rv); nsCString spamActionTargetAccount; rv = aServer->GetCharValue("spamActionTargetAccount", spamActionTargetAccount); NS_ENSURE_SUCCESS(rv, rv); rv = SetActionTargetAccount(spamActionTargetAccount.get()); NS_ENSURE_SUCCESS(rv, rv); nsCString spamActionTargetFolder; rv = aServer->GetCharValue("spamActionTargetFolder", spamActionTargetFolder); NS_ENSURE_SUCCESS(rv, rv); rv = SetActionTargetFolder(spamActionTargetFolder.get()); NS_ENSURE_SUCCESS(rv, rv); bool useWhiteList; rv = aServer->GetBoolValue("useWhiteList", &useWhiteList); NS_ENSURE_SUCCESS(rv, rv); rv = SetUseWhiteList(useWhiteList); NS_ENSURE_SUCCESS(rv, rv); nsCString whiteListAbURI; rv = aServer->GetCharValue("whiteListAbURI", whiteListAbURI); NS_ENSURE_SUCCESS(rv, rv); rv = SetWhiteListAbURI(whiteListAbURI.get()); NS_ENSURE_SUCCESS(rv, rv); bool purgeSpam; rv = aServer->GetBoolValue("purgeSpam", &purgeSpam); NS_ENSURE_SUCCESS(rv, rv); rv = SetPurge(purgeSpam); NS_ENSURE_SUCCESS(rv, rv); PRInt32 purgeSpamInterval; rv = aServer->GetIntValue("purgeSpamInterval", &purgeSpamInterval); NS_ENSURE_SUCCESS(rv, rv); rv = SetPurgeInterval(purgeSpamInterval); NS_ENSURE_SUCCESS(rv, rv); bool useServerFilter; rv = aServer->GetBoolValue("useServerFilter", &useServerFilter); NS_ENSURE_SUCCESS(rv, rv); rv = SetUseServerFilter(useServerFilter); NS_ENSURE_SUCCESS(rv, rv); nsCString serverFilterName; rv = aServer->GetCharValue("serverFilterName", serverFilterName); if (NS_SUCCEEDED(rv)) SetServerFilterName(serverFilterName); PRInt32 serverFilterTrustFlags = 0; rv = aServer->GetIntValue("serverFilterTrustFlags", &serverFilterTrustFlags); NS_ENSURE_SUCCESS(rv, rv); rv = SetServerFilterTrustFlags(serverFilterTrustFlags); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); if (prefBranch) prefBranch->GetCharPref("mail.trusteddomains", getter_Copies(mTrustedMailDomains)); mWhiteListDirArray.Clear(); if (!mWhiteListAbURI.IsEmpty()) { nsCOMPtr<nsIAbManager> abManager(do_GetService(NS_ABMANAGER_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); nsTArray<nsCString> whiteListArray; ParseString(mWhiteListAbURI, ' ', whiteListArray); for (PRUint32 index = 0; index < whiteListArray.Length(); index++) { nsCOMPtr<nsIAbDirectory> directory; rv = abManager->GetDirectory(whiteListArray[index], getter_AddRefs(directory)); NS_ENSURE_SUCCESS(rv, rv); if (directory) mWhiteListDirArray.AppendObject(directory); } } // the next two preferences affect whether we try to whitelist our own // address or domain. Spammers send emails with spoofed from address matching // either the email address of the recipient, or the recipient's domain, // hoping to get whitelisted. // // The terms to describe this get wrapped up in chains of negatives. A full // definition of the boolean inhibitWhiteListingIdentityUser is "Suppress address // book whitelisting if the sender matches an identity's email address" rv = aServer->GetBoolValue("inhibitWhiteListingIdentityUser", &mInhibitWhiteListingIdentityUser); NS_ENSURE_SUCCESS(rv, rv); rv = aServer->GetBoolValue("inhibitWhiteListingIdentityDomain", &mInhibitWhiteListingIdentityDomain); NS_ENSURE_SUCCESS(rv, rv); // collect lists of identity users if needed if (mInhibitWhiteListingIdentityDomain || mInhibitWhiteListingIdentityUser) { nsCOMPtr<nsIMsgAccountManager> accountManager(do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMsgAccount> account; rv = accountManager->FindAccountForServer(aServer, getter_AddRefs(account)); NS_ENSURE_SUCCESS(rv, rv); nsCAutoString accountKey; if (account) account->GetKey(accountKey); // Loop through all accounts, adding emails from this account, as well as // from any accounts that defer to this account. mEmails.Clear(); nsCOMPtr<nsISupportsArray> accounts; rv = accountManager->GetAccounts(getter_AddRefs(accounts)); NS_ENSURE_SUCCESS(rv, rv); PRUint32 accountCount = 0; if (account && accounts) // no sense scanning accounts if we've nothing to match accounts->Count(&accountCount); for (PRUint32 i = 0; i < accountCount; i++) { nsCOMPtr<nsIMsgAccount> loopAccount(do_QueryElementAt(accounts, i)); if (!loopAccount) continue; nsCAutoString loopAccountKey; loopAccount->GetKey(loopAccountKey); nsCOMPtr<nsIMsgIncomingServer> loopServer; loopAccount->GetIncomingServer(getter_AddRefs(loopServer)); nsCAutoString deferredToAccountKey; if (loopServer) loopServer->GetCharValue("deferred_to_account", deferredToAccountKey); // Add the emails for any account that defers to this one, or for the // account itself. if (accountKey.Equals(deferredToAccountKey) || accountKey.Equals(loopAccountKey)) { nsCOMPtr<nsISupportsArray> identities; loopAccount->GetIdentities(getter_AddRefs(identities)); if (!identities) continue; PRUint32 identityCount = 0; identities->Count(&identityCount); for (PRUint32 j = 0; j < identityCount; ++j) { nsCOMPtr<nsIMsgIdentity> identity(do_QueryElementAt(identities, j)); if (!identity) continue; nsCAutoString email; identity->GetEmail(email); if (!email.IsEmpty()) mEmails.AppendElement(email); } } } } return UpdateJunkFolderState(); }
NS_IMETHODIMP nsMsgMaildirStore::CopyMessages(bool aIsMove, nsIArray *aHdrArray, nsIMsgFolder *aDstFolder, nsIMsgCopyServiceListener *aListener, nsITransaction **aUndoAction, bool *aCopyDone) { NS_ENSURE_ARG_POINTER(aHdrArray); NS_ENSURE_ARG_POINTER(aDstFolder); NS_ENSURE_ARG_POINTER(aCopyDone); NS_ENSURE_ARG_POINTER(aUndoAction); uint32_t messageCount; nsresult rv = aHdrArray->GetLength(&messageCount); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMsgFolder> srcFolder; nsCOMPtr<nsIFile> destFolderPath; nsCOMPtr<nsIMsgDatabase> destDB; nsCOMPtr<nsIMsgDatabase> srcDB; aDstFolder->GetMsgDatabase(getter_AddRefs(destDB)); aDstFolder->GetFilePath(getter_AddRefs(destFolderPath)); destFolderPath->Append(NS_LITERAL_STRING("cur")); nsCOMPtr<nsIMsgDBHdr> msgHdr = do_QueryElementAt(aHdrArray, 0, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = msgHdr->GetFolder(getter_AddRefs(srcFolder)); NS_ENSURE_SUCCESS(rv, rv); srcFolder->GetMsgDatabase(getter_AddRefs(srcDB)); nsRefPtr<nsLocalMoveCopyMsgTxn> msgTxn = new nsLocalMoveCopyMsgTxn; NS_ENSURE_TRUE(msgTxn, NS_ERROR_OUT_OF_MEMORY); if (NS_SUCCEEDED(msgTxn->Init(srcFolder, aDstFolder, aIsMove))) { if (aIsMove) msgTxn->SetTransactionType(nsIMessenger::eMoveMsg); else msgTxn->SetTransactionType(nsIMessenger::eCopyMsg); } nsCOMPtr<nsIMutableArray> dstHdrs(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); for (uint32_t i = 0; i < messageCount; i++) { nsCOMPtr<nsIMsgDBHdr> msgHdr = do_QueryElementAt(aHdrArray, i, &rv); if (NS_FAILED(rv)) continue; nsMsgKey srcKey; msgHdr->GetMessageKey(&srcKey); msgTxn->AddSrcKey(srcKey); msgHdr->GetFolder(getter_AddRefs(srcFolder)); nsCOMPtr<nsIFile> path; rv = srcFolder->GetFilePath(getter_AddRefs(path)); NS_ENSURE_SUCCESS(rv, rv); nsAutoCString fileName; msgHdr->GetStringProperty("storeToken", getter_Copies(fileName)); if (fileName.IsEmpty()) return NS_ERROR_FAILURE; if (fileName.IsEmpty()) { PR_LOG(MailDirLog, PR_LOG_ALWAYS, ("GetMsgInputStream - empty storeToken!!\n")); return NS_ERROR_FAILURE; } path->Append(NS_LITERAL_STRING("cur")); path->AppendNative(fileName); nsCOMPtr<nsIFile> destFile; destFolderPath->Clone(getter_AddRefs(destFile)); destFile->AppendNative(fileName); bool exists; destFile->Exists(&exists); if (exists) { rv = destFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600); NS_ENSURE_SUCCESS(rv, rv); destFile->GetNativeLeafName(fileName); } if (aIsMove) path->MoveToNative(destFolderPath, fileName); else path->CopyToNative(destFolderPath, fileName); nsCOMPtr<nsIMsgDBHdr> destHdr; if (destDB) { rv = destDB->CopyHdrFromExistingHdr(nsMsgKey_None, msgHdr, true, getter_AddRefs(destHdr)); NS_ENSURE_SUCCESS(rv, rv); destHdr->SetStringProperty("storeToken", fileName.get()); dstHdrs->AppendElement(destHdr, false); nsMsgKey dstKey; destHdr->GetMessageKey(&dstKey); msgTxn->AddDstKey(dstKey); } } nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID)); if (notifier) notifier->NotifyMsgsMoveCopyCompleted(aIsMove, aHdrArray, aDstFolder, dstHdrs); if (aIsMove) { for (uint32_t i = 0; i < messageCount; ++i) { nsCOMPtr<nsIMsgDBHdr> msgDBHdr(do_QueryElementAt(aHdrArray, i, &rv)); rv = srcDB->DeleteHeader(msgDBHdr, nullptr, false, true); } } *aCopyDone = true; nsCOMPtr<nsISupports> srcSupports(do_QueryInterface(srcFolder)); nsCOMPtr<nsIMsgLocalMailFolder> localDest(do_QueryInterface(aDstFolder)); if (localDest) localDest->OnCopyCompleted(srcSupports, true); if (aListener) aListener->OnStopCopy(NS_OK); msgTxn.forget(aUndoAction); return NS_OK; }
NS_IMETHODIMP nsMessengerOSXIntegration::OnItemIntPropertyChanged(nsIRDFResource *aItem, nsIAtom *aProperty, PRInt32 aOldValue, PRInt32 aNewValue) { nsresult rv; // if we got new mail bounce the Dock icon and/or apply badge to Dock icon if (mBiffStateAtom == aProperty && mFoldersWithNewMail) { nsCOMPtr<nsIMsgFolder> folder = do_QueryInterface(aItem); NS_ENSURE_TRUE(folder, NS_OK); if (aNewValue == nsIMsgFolder::nsMsgBiffState_NewMail) { // if the icon is not already visible, only show a system tray icon iff // we are performing biff (as opposed to the user getting new mail) if (!mBiffIconVisible) { PRBool performingBiff = PR_FALSE; nsCOMPtr<nsIMsgIncomingServer> server; folder->GetServer(getter_AddRefs(server)); if (server) server->GetPerformingBiff(&performingBiff); if (!performingBiff) return NS_OK; // kick out right now... } nsCOMPtr<nsIWeakReference> weakFolder = do_GetWeakReference(folder); // remove the element if it is already in the array.... PRUint32 count = 0; PRUint32 index = 0; mFoldersWithNewMail->Count(&count); nsCOMPtr<nsIMsgFolder> oldFolder; nsCOMPtr<nsIWeakReference> weakReference; for (index = 0; index < count; index++) { weakReference = do_QueryElementAt(mFoldersWithNewMail, index); oldFolder = do_QueryReferent(weakReference); if (oldFolder == folder) // if they point to the same folder break; oldFolder = nsnull; } if (oldFolder) mFoldersWithNewMail->ReplaceElementAt(weakFolder, index); else mFoldersWithNewMail->AppendElement(weakFolder); // now regenerate the tooltip OnAlertFinished(nsnull); } else if (aNewValue == nsIMsgFolder::nsMsgBiffState_NoMail) { // we are always going to remove the icon whenever we get our first no mail // notification. mFoldersWithNewMail->Clear(); if (mBiffIconVisible) { RestoreApplicationDockTileImage(); mBiffIconVisible = PR_FALSE; } } } // if the biff property changed return NS_OK; }
//----------------------------------------------------------------------------- NS_IMETHODIMP CPlaylistCommandsManager::UnregisterPlaylistCommandsForLibrary (bool aTargetServicePane, sbILibrary *aLibrary, sbIPlaylistCommands *aCommandObj) { NS_ENSURE_ARG_POINTER(aLibrary); NS_ENSURE_ARG_POINTER(aCommandObj); nsresult rv; // Get all medialists in that library, including the library itself nsCOMPtr<nsIArray> mediaLists; rv = GetAllMediaListsForLibrary(aLibrary, getter_AddRefs(mediaLists)); NS_ENSURE_SUCCESS(rv, rv); // Determine which map to unregister the new command from commandobjmap_t* targetMap = (aTargetServicePane ? &m_ServicePaneCommandObjMap : &m_PlaylistCommandObjMap); // For each medialist in the library, unregister aCommandObj from it PRUint32 length; rv = mediaLists->GetLength(&length); NS_ENSURE_SUCCESS(rv, rv); bool unregisterFailure = false; for (PRUint32 i = 0; i < length; i++) { nsCOMPtr<sbIMediaList> currList = do_QueryElementAt(mediaLists, i, &rv); if (NS_FAILED(rv)) { unregisterFailure = true; continue; } nsString guid; rv = currList->GetGuid(guid); if (NS_FAILED(rv)) { unregisterFailure = true; continue; } rv = UnregisterPlaylistCommands(targetMap, guid, SBVoidString(), aCommandObj); if (NS_FAILED(rv)) { unregisterFailure = true; } } nsString libGuid; rv = aLibrary->GetGuid(libGuid); NS_ENSURE_SUCCESS(rv, rv); // Finally remove the listener from the library rv = aLibrary->RemoveListener(m_LibraryGuidToLibraryListenerMap[libGuid]); if (NS_FAILED(rv)) { unregisterFailure = true; } if (unregisterFailure) { NS_ERROR("Error while unregistering playlist commands from a library"); } return NS_OK; }
/* boolean addListToBuild(in short aCatType, [optional] in nsIArray items, [optional] in AString catName); */ NS_IMETHODIMP JumpListBuilder::AddListToBuild(PRInt16 aCatType, nsIArray *items, const nsAString &catName, PRBool *_retval) { nsresult rv; *_retval = PR_FALSE; if (!mJumpListMgr) return NS_ERROR_NOT_AVAILABLE; switch(aCatType) { case nsIJumpListBuilder::JUMPLIST_CATEGORY_TASKS: { NS_ENSURE_ARG_POINTER(items); HRESULT hr; nsRefPtr<IObjectCollection> collection; hr = CoCreateInstance(CLSID_EnumerableObjectCollection, NULL, CLSCTX_INPROC_SERVER, IID_IObjectCollection, getter_AddRefs(collection)); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; // Build the list PRUint32 length; items->GetLength(&length); for (PRUint32 i = 0; i < length; ++i) { nsCOMPtr<nsIJumpListItem> item = do_QueryElementAt(items, i); if (!item) continue; // Check for separators if (IsSeparator(item)) { nsRefPtr<IShellLinkW> link; rv = JumpListSeparator::GetSeparator(link); if (NS_FAILED(rv)) return rv; collection->AddObject(link); continue; } // These should all be ShellLinks nsRefPtr<IShellLinkW> link; rv = JumpListShortcut::GetShellLink(item, link, mIOThread); if (NS_FAILED(rv)) return rv; collection->AddObject(link); } // We need IObjectArray to submit nsRefPtr<IObjectArray> pArray; hr = collection->QueryInterface(IID_IObjectArray, getter_AddRefs(pArray)); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; // Add the tasks hr = mJumpListMgr->AddUserTasks(pArray); if (SUCCEEDED(hr)) *_retval = PR_TRUE; return NS_OK; } break; case nsIJumpListBuilder::JUMPLIST_CATEGORY_RECENT: { if (SUCCEEDED(mJumpListMgr->AppendKnownCategory(KDC_RECENT))) *_retval = PR_TRUE; return NS_OK; } break; case nsIJumpListBuilder::JUMPLIST_CATEGORY_FREQUENT: { if (SUCCEEDED(mJumpListMgr->AppendKnownCategory(KDC_FREQUENT))) *_retval = PR_TRUE; return NS_OK; } break; case nsIJumpListBuilder::JUMPLIST_CATEGORY_CUSTOMLIST: { NS_ENSURE_ARG_POINTER(items); if (catName.IsEmpty()) return NS_ERROR_INVALID_ARG; HRESULT hr; nsRefPtr<IObjectCollection> collection; hr = CoCreateInstance(CLSID_EnumerableObjectCollection, NULL, CLSCTX_INPROC_SERVER, IID_IObjectCollection, getter_AddRefs(collection)); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; PRUint32 length; items->GetLength(&length); for (PRUint32 i = 0; i < length; ++i) { nsCOMPtr<nsIJumpListItem> item = do_QueryElementAt(items, i); if (!item) continue; PRInt16 type; if (NS_FAILED(item->GetType(&type))) continue; switch(type) { case nsIJumpListItem::JUMPLIST_ITEM_SEPARATOR: { nsRefPtr<IShellLinkW> shellItem; rv = JumpListSeparator::GetSeparator(shellItem); if (NS_FAILED(rv)) return rv; collection->AddObject(shellItem); } break; case nsIJumpListItem::JUMPLIST_ITEM_LINK: { nsRefPtr<IShellItem2> shellItem; rv = JumpListLink::GetShellItem(item, shellItem); if (NS_FAILED(rv)) return rv; collection->AddObject(shellItem); } break; case nsIJumpListItem::JUMPLIST_ITEM_SHORTCUT: { nsRefPtr<IShellLinkW> shellItem; rv = JumpListShortcut::GetShellLink(item, shellItem, mIOThread); if (NS_FAILED(rv)) return rv; collection->AddObject(shellItem); } break; } } // We need IObjectArray to submit nsRefPtr<IObjectArray> pArray; hr = collection->QueryInterface(IID_IObjectArray, (LPVOID*)&pArray); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; // Add the tasks hr = mJumpListMgr->AppendCategory(catName.BeginReading(), pArray); if (SUCCEEDED(hr)) *_retval = PR_TRUE; return NS_OK; } break; } return NS_OK; }
//----------------------------------------------------------------------------- NS_IMETHODIMP CPlaylistCommandsManager::RegisterPlaylistCommandsForLibrary (bool aTargetServicePane, sbILibrary *aLibrary, sbIPlaylistCommands *aCommandObj) { NS_ENSURE_ARG_POINTER(aLibrary); NS_ENSURE_ARG_POINTER(aCommandObj); nsresult rv; // Get all the medialists for that library, including the library itself nsCOMPtr<nsIArray> mediaLists; rv = GetAllMediaListsForLibrary(aLibrary, getter_AddRefs(mediaLists)); NS_ENSURE_SUCCESS(rv, rv); // Determine which map to register the new command in commandobjmap_t* targetMap = (aTargetServicePane ? &m_ServicePaneCommandObjMap : &m_PlaylistCommandObjMap); // Register aCommandObj to the appropriate map for each of the mediaLists PRUint32 length; rv = mediaLists->GetLength(&length); NS_ENSURE_SUCCESS(rv, rv); for (PRUint32 i = 0; i < length; i++) { nsCOMPtr<sbIMediaList> currList = do_QueryElementAt(mediaLists, i, &rv); NS_ENSURE_SUCCESS(rv, rv); nsString guid; rv = currList->GetGuid(guid); NS_ENSURE_SUCCESS(rv, rv); rv = RegisterPlaylistCommands(targetMap, guid, SBVoidString(), aCommandObj); NS_ENSURE_SUCCESS(rv, rv); } /* Save a reference to aCommandObj so that we can retrieve it when a new * mediaList is added to the library we are registering this command to */ // Save the command in a map depending on where it is registered libraryGuidToCommandsMap_t *libraryToPlaylistCommandsMap = (aTargetServicePane ? &m_LibraryGuidToServicePaneCommandsMap : &m_LibraryGuidToMenuOrToolbarCommandsMap); nsString libGuid; rv = aLibrary->GetGuid(libGuid); NS_ENSURE_SUCCESS(rv, rv); /* See if we already have any commands registered in this location for this * library */ libraryGuidToCommandsMap_t::iterator registeredCommandsIter = libraryToPlaylistCommandsMap->find(libGuid); if (registeredCommandsIter == libraryToPlaylistCommandsMap->end()) { // There are no commands in this location registered to this library yet. // Save the command object to a new nsCOMArray in the saved command map. (*libraryToPlaylistCommandsMap)[libGuid].AppendObject(aCommandObj); /* Add a listener to the library so that we can detect if a new medialist * is added or if one is removed */ nsCOMPtr<LibraryPlaylistCommandsListener> listener = new LibraryPlaylistCommandsListener(this); NS_ENSURE_TRUE(listener, NS_ERROR_OUT_OF_MEMORY); rv = aLibrary->AddListener(listener, PR_FALSE, sbIMediaList::LISTENER_FLAGS_ITEMADDED | sbIMediaList::LISTENER_FLAGS_BEFOREITEMREMOVED, nsnull); NS_ENSURE_SUCCESS(rv, rv); // And save a reference to this listener in case we need to unregister m_LibraryGuidToLibraryListenerMap[libGuid] = listener; } else { // There are other commands registered to this library already. // Retrieve the array of registered commands and add aCommandObj. nsCOMArray<sbIPlaylistCommands> *registeredCommands = ®isteredCommandsIter->second; registeredCommands->AppendObject(aCommandObj); } return NS_OK; }
NS_IMETHODIMP sbBaseDevice::ImportFromDevice(sbILibrary * aImportToLibrary, sbILibraryChangeset * aImportChangeset) { NS_ENSURE_ARG_POINTER(aImportToLibrary); NS_ENSURE_ARG_POINTER(aImportChangeset); nsresult rv; // Get the list of all changes. nsCOMPtr<nsIArray> changeList; rv = aImportChangeset->GetChanges(getter_AddRefs(changeList)); NS_ENSURE_SUCCESS(rv, rv); PRUint32 changeCount; rv = changeList->GetLength(&changeCount); NS_ENSURE_SUCCESS(rv, rv); // If there aren't any changes, don't bother setting up for the import if (changeCount == 0) { return NS_OK; } // Accumulators so we can batch the operations nsCOMPtr<nsIMutableArray> mediaItemsToAdd = do_CreateInstance("@songbirdnest.com/moz/xpcom/threadsafe-array;1", &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMutableArray> mediaListsToAdd = do_CreateInstance("@songbirdnest.com/moz/xpcom/threadsafe-array;1", &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMutableArray> mediaItemsToRemove = do_CreateInstance("@songbirdnest.com/moz/xpcom/threadsafe-array;1", &rv); // Determine if playlists are supported NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMutableArray> mediaListsToUpdate = do_CreateInstance("@songbirdnest.com/moz/xpcom/threadsafe-array;1", &rv); NS_ENSURE_SUCCESS(rv, rv); bool const playlistsSupported = sbDeviceUtils::ArePlaylistsSupported(this); // Accumulate changes for later processing to take advantage of batching for (PRUint32 i = 0; i < changeCount; i++) { if (IsRequestAborted()) { return NS_ERROR_ABORT; } // Get the next change. nsCOMPtr<sbILibraryChange> change = do_QueryElementAt(changeList, i, &rv); NS_ENSURE_SUCCESS(rv, rv); // Put the change into the appropriate lists. PRUint32 operation; rv = change->GetOperation(&operation); NS_ENSURE_SUCCESS(rv, rv); // Is this a media item list bool itemIsList; rv = change->GetItemIsList(&itemIsList); NS_ENSURE_SUCCESS(rv, rv); // if this is a playlist and they're not supported ignore the change if (itemIsList && !playlistsSupported) { continue; } switch (operation) { case sbIChangeOperation::ADDED: { // Get the source item to add. nsCOMPtr<sbIMediaItem> mediaItem; rv = change->GetSourceItem(getter_AddRefs(mediaItem)); NS_ENSURE_SUCCESS(rv, rv); if (itemIsList) { rv = mediaListsToAdd->AppendElement(change, PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); } else { rv = mediaItemsToAdd->AppendElement(mediaItem, PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); } } break; case sbIChangeOperation::MODIFIED: { nsCOMPtr<sbIMediaItem> destItem; rv = change->GetDestinationItem(getter_AddRefs(destItem)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<sbIMediaList> destItemAsList = do_QueryInterface(destItem); if (destItemAsList) { // If the change is to a media list, add it to the media list change // list. bool success = mediaListsToUpdate->AppendElement(change, PR_FALSE); NS_ENSURE_SUCCESS(success, NS_ERROR_OUT_OF_MEMORY); } else { rv = mediaItemsToRemove->AppendElement(destItem, PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<sbIMediaItem> sourceItem; rv = change->GetSourceItem(getter_AddRefs(sourceItem)); rv = mediaItemsToAdd->AppendElement(sourceItem, PR_FALSE); NS_ENSURE_SUCCESS(rv, rv); } } break; default: { NS_WARNING("Unexpected change operation value in sbBaseDevice::Import"); } break; } } // Remove items that need to be removed nsCOMPtr<nsISimpleEnumerator> enumerator; rv = mediaItemsToRemove->Enumerate(getter_AddRefs(enumerator)); NS_ENSURE_SUCCESS(rv, rv); rv = aImportToLibrary->RemoveSome(enumerator); NS_ENSURE_SUCCESS(rv, rv); // Add media lists. rv = mediaItemsToAdd->Enumerate(getter_AddRefs(enumerator)); NS_ENSURE_SUCCESS(rv, rv); rv = aImportToLibrary->AddSome(enumerator); NS_ENSURE_SUCCESS(rv, rv); rv = AddMediaLists(aImportToLibrary, mediaListsToAdd); NS_ENSURE_SUCCESS(rv, rv); rv = UpdateMediaLists(mediaListsToUpdate); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; }
// The style context cache impl nsStyleContext* nsTreeStyleCache::GetStyleContext(nsICSSPseudoComparator* aComparator, nsPresContext* aPresContext, nsIContent* aContent, nsStyleContext* aContext, nsIAtom* aPseudoElement, nsISupportsArray* aInputWord) { uint32_t count; aInputWord->Count(&count); nsDFAState startState(0); nsDFAState* currState = &startState; // Go ahead and init the transition table. if (!mTransitionTable) { // Automatic miss. Build the table mTransitionTable = new nsObjectHashtable(nullptr, nullptr, DeleteDFAState, nullptr); } // The first transition is always made off the supplied pseudo-element. nsTransitionKey key(currState->GetStateID(), aPseudoElement); currState = static_cast<nsDFAState*>(mTransitionTable->Get(&key)); if (!currState) { // We had a miss. Make a new state and add it to our hash. currState = new nsDFAState(mNextState); mNextState++; mTransitionTable->Put(&key, currState); } for (uint32_t i = 0; i < count; i++) { nsCOMPtr<nsIAtom> pseudo = do_QueryElementAt(aInputWord, i); nsTransitionKey key(currState->GetStateID(), pseudo); currState = static_cast<nsDFAState*>(mTransitionTable->Get(&key)); if (!currState) { // We had a miss. Make a new state and add it to our hash. currState = new nsDFAState(mNextState); mNextState++; mTransitionTable->Put(&key, currState); } } // We're in a final state. // Look up our style context for this state. nsStyleContext* result = nullptr; if (mCache) result = static_cast<nsStyleContext*>(mCache->Get(currState)); if (!result) { // We missed the cache. Resolve this pseudo-style. result = aPresContext->StyleSet()-> ResolveXULTreePseudoStyle(aContent->AsElement(), aPseudoElement, aContext, aComparator).get(); // Put the style context in our table, transferring the owning reference to the table. if (!mCache) { mCache = new nsObjectHashtable(nullptr, nullptr, ReleaseStyleContext, nullptr); } mCache->Put(currState, result); } return result; }
nsresult nsAbBoolExprToLDAPFilter::FilterExpression ( nsIAbLDAPAttributeMap* map, nsIAbBooleanExpression* expression, nsCString& filter, int flags) { nsCOMPtr<nsIArray> childExpressions; nsresult rv = expression->GetExpressions(getter_AddRefs(childExpressions)); NS_ENSURE_SUCCESS(rv, rv); PRUint32 count; rv = childExpressions->GetLength(&count); NS_ENSURE_SUCCESS(rv, rv); if (count == 0) return NS_OK; nsAbBooleanOperationType operation; rv = expression->GetOperation(&operation); NS_ENSURE_SUCCESS(rv, rv); /* * 3rd party query integration with Mozilla is achieved * by calling nsAbLDAPDirectoryQuery::DoQuery(). Thus * we can arrive here with a query asking for all the * ldap attributes using the card:nsIAbCard interface. * * So we need to check that we are not creating a condition * filter against this expression otherwise we will end up with an invalid * filter equal to "(|)". */ if (count == 1 ) { nsCOMPtr<nsIAbBooleanConditionString> childCondition(do_QueryElementAt(childExpressions, 1, &rv)); if (NS_SUCCEEDED(rv)) { nsCString name; rv = childCondition->GetName (getter_Copies (name)); NS_ENSURE_SUCCESS(rv, rv); if(name.Equals("card:nsIAbCard")) return NS_OK; } } filter.AppendLiteral("("); switch (operation) { case nsIAbBooleanOperationTypes::AND: filter.AppendLiteral("&"); rv = FilterExpressions (map, childExpressions, filter, flags); break; case nsIAbBooleanOperationTypes::OR: filter.AppendLiteral("|"); rv = FilterExpressions (map, childExpressions, filter, flags); break; case nsIAbBooleanOperationTypes::NOT: if (count > 1) return NS_ERROR_FAILURE; filter.AppendLiteral("!"); rv = FilterExpressions (map, childExpressions, filter, flags); break; default: break; } filter.AppendLiteral(")"); return rv; }
NS_IMETHODIMP nsCMSMessage::CreateEncrypted(nsIArray * aRecipientCerts) { nsNSSShutDownPreventionLock locker; if (isAlreadyShutDown()) return NS_ERROR_NOT_AVAILABLE; PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsCMSMessage::CreateEncrypted\n")); NSSCMSContentInfo *cinfo; NSSCMSEnvelopedData *envd; NSSCMSRecipientInfo *recipientInfo; nsZeroTerminatedCertArray recipientCerts; SECOidTag bulkAlgTag; int keySize; PRUint32 i; nsNSSCertificate *nssRecipientCert; nsresult rv = NS_ERROR_FAILURE; // Check the recipient certificates // PRUint32 recipientCertCount; aRecipientCerts->GetLength(&recipientCertCount); PR_ASSERT(recipientCertCount > 0); if (!recipientCerts.allocate(recipientCertCount)) { goto loser; } for (i=0; i<recipientCertCount; i++) { nsCOMPtr<nsIX509Cert> x509cert = do_QueryElementAt(aRecipientCerts, i); nssRecipientCert = NS_STATIC_CAST(nsNSSCertificate*, NS_STATIC_CAST(nsIX509Cert*, x509cert)); if (!nssRecipientCert) return NS_ERROR_FAILURE; CERTCertificate *c = nssRecipientCert->GetCert(); CERTCertificateCleaner rcCleaner(c); recipientCerts.set(i, c); } // Find a bulk key algorithm // if (NSS_SMIMEUtil_FindBulkAlgForRecipients(recipientCerts.getRawArray(), &bulkAlgTag, &keySize) != SECSuccess) { PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsCMSMessage::CreateEncrypted - can't find bulk alg for recipients\n")); rv = NS_ERROR_CMS_ENCRYPT_NO_BULK_ALG; goto loser; } m_cmsMsg = NSS_CMSMessage_Create(NULL); if (m_cmsMsg == nsnull) { PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsCMSMessage::CreateEncrypted - can't create new cms message\n")); rv = NS_ERROR_OUT_OF_MEMORY; goto loser; } if ((envd = NSS_CMSEnvelopedData_Create(m_cmsMsg, bulkAlgTag, keySize)) == nsnull) { PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsCMSMessage::CreateEncrypted - can't create enveloped data\n")); goto loser; } cinfo = NSS_CMSMessage_GetContentInfo(m_cmsMsg); if (NSS_CMSContentInfo_SetContent_EnvelopedData(m_cmsMsg, cinfo, envd) != SECSuccess) { PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsCMSMessage::CreateEncrypted - can't create content enveloped data\n")); goto loser; } cinfo = NSS_CMSEnvelopedData_GetContentInfo(envd); if (NSS_CMSContentInfo_SetContent_Data(m_cmsMsg, cinfo, nsnull, PR_FALSE) != SECSuccess) { PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsCMSMessage::CreateEncrypted - can't set content data\n")); goto loser; } // Create and attach recipient information // for (i=0; i < recipientCertCount; i++) { CERTCertificate *rc = recipientCerts.get(i); CERTCertificateCleaner rcCleaner(rc); if ((recipientInfo = NSS_CMSRecipientInfo_Create(m_cmsMsg, rc)) == nsnull) { PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsCMSMessage::CreateEncrypted - can't create recipient info\n")); goto loser; } if (NSS_CMSEnvelopedData_AddRecipient(envd, recipientInfo) != SECSuccess) { PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("nsCMSMessage::CreateEncrypted - can't add recipient info\n")); goto loser; } } return NS_OK; loser: if (m_cmsMsg) { NSS_CMSMessage_Destroy(m_cmsMsg); m_cmsMsg = nsnull; } return rv; }
/* Astring getCellText (in long row, in nsITreeColumn col); */ NS_IMETHODIMP nsCertTree::GetCellText(PRInt32 row, nsITreeColumn* col, nsAString& _retval) { if (!mTreeArray) return NS_ERROR_NOT_INITIALIZED; nsresult rv; _retval.Truncate(); const PRUnichar* colID; col->GetIdConst(&colID); treeArrayEl *el = GetThreadDescAtIndex(row); if (el != nsnull) { if (NS_LITERAL_STRING("certcol").Equals(colID)) _retval.Assign(el->orgName); else _retval.Truncate(); return NS_OK; } PRInt32 absoluteCertOffset; nsRefPtr<nsCertTreeDispInfo> certdi = GetDispInfoAtIndex(row, &absoluteCertOffset); if (!certdi) return NS_ERROR_FAILURE; nsCOMPtr<nsIX509Cert> cert = certdi->mCert; if (!cert && certdi->mAddonInfo) { cert = certdi->mAddonInfo->mCert; } PRInt32 colIndex; col->GetIndex(&colIndex); PRUint32 arrayIndex=absoluteCertOffset+colIndex*(mNumRows-mNumOrgs); PRUint32 arrayLength=0; if (mCellText) { mCellText->GetLength(&arrayLength); } if (arrayIndex < arrayLength) { nsCOMPtr<nsISupportsString> myString(do_QueryElementAt(mCellText, arrayIndex)); if (myString) { myString->GetData(_retval); return NS_OK; } } if (NS_LITERAL_STRING("certcol").Equals(colID)) { if (!cert) { mNSSComponent->GetPIPNSSBundleString("CertNotStored", _retval); } else { rv = cert->GetCommonName(_retval); if (NS_FAILED(rv) || _retval.IsEmpty()) { // kaie: I didn't invent the idea to cut off anything before // the first colon. :-) nsAutoString nick; rv = cert->GetNickname(nick); nsAString::const_iterator start, end, end2; nick.BeginReading(start); nick.EndReading(end); end2 = end; if (FindInReadable(NS_LITERAL_STRING(":"), start, end)) { // found. end points to the first char after the colon, // that's what we want. _retval = Substring(end, end2); } else { _retval = nick; } } } } else if (NS_LITERAL_STRING("tokencol").Equals(colID) && cert) { rv = cert->GetTokenName(_retval); } else if (NS_LITERAL_STRING("emailcol").Equals(colID) && cert) { rv = cert->GetEmailAddress(_retval); } else if (NS_LITERAL_STRING("purposecol").Equals(colID) && mNSSComponent && cert) { PRUint32 verified; nsAutoString theUsages; rv = cert->GetUsagesString(false, &verified, theUsages); // allow OCSP if (NS_FAILED(rv)) { verified = nsIX509Cert::NOT_VERIFIED_UNKNOWN; } switch (verified) { case nsIX509Cert::VERIFIED_OK: _retval = theUsages; break; case nsIX509Cert::CERT_REVOKED: rv = mNSSComponent->GetPIPNSSBundleString("VerifyRevoked", _retval); break; case nsIX509Cert::CERT_EXPIRED: rv = mNSSComponent->GetPIPNSSBundleString("VerifyExpired", _retval); break; case nsIX509Cert::CERT_NOT_TRUSTED: rv = mNSSComponent->GetPIPNSSBundleString("VerifyNotTrusted", _retval); break; case nsIX509Cert::ISSUER_NOT_TRUSTED: rv = mNSSComponent->GetPIPNSSBundleString("VerifyIssuerNotTrusted", _retval); break; case nsIX509Cert::ISSUER_UNKNOWN: rv = mNSSComponent->GetPIPNSSBundleString("VerifyIssuerUnknown", _retval); break; case nsIX509Cert::INVALID_CA: rv = mNSSComponent->GetPIPNSSBundleString("VerifyInvalidCA", _retval); break; case nsIX509Cert::NOT_VERIFIED_UNKNOWN: case nsIX509Cert::USAGE_NOT_ALLOWED: default: rv = mNSSComponent->GetPIPNSSBundleString("VerifyUnknown", _retval); break; } } else if (NS_LITERAL_STRING("issuedcol").Equals(colID) && cert) { nsCOMPtr<nsIX509CertValidity> validity; rv = cert->GetValidity(getter_AddRefs(validity)); if (NS_SUCCEEDED(rv)) { validity->GetNotBeforeLocalDay(_retval); } } else if (NS_LITERAL_STRING("expiredcol").Equals(colID) && cert) { nsCOMPtr<nsIX509CertValidity> validity; rv = cert->GetValidity(getter_AddRefs(validity)); if (NS_SUCCEEDED(rv)) { validity->GetNotAfterLocalDay(_retval); } } else if (NS_LITERAL_STRING("serialnumcol").Equals(colID) && cert) { rv = cert->GetSerialNumber(_retval); } else if (NS_LITERAL_STRING("overridetypecol").Equals(colID)) { // default to classic permanent-trust nsCertOverride::OverrideBits ob = nsCertOverride::ob_Untrusted; if (certdi->mTypeOfEntry == nsCertTreeDispInfo::host_port_override) { ob = certdi->mOverrideBits; } nsCAutoString temp; nsCertOverride::convertBitsToString(ob, temp); _retval = NS_ConvertUTF8toUTF16(temp); } else if (NS_LITERAL_STRING("sitecol").Equals(colID)) { if (certdi->mTypeOfEntry == nsCertTreeDispInfo::host_port_override) { nsCAutoString hostPort; nsCertOverrideService::GetHostWithPort(certdi->mAsciiHost, certdi->mPort, hostPort); _retval = NS_ConvertUTF8toUTF16(hostPort); } else { _retval = NS_LITERAL_STRING("*"); } } else if (NS_LITERAL_STRING("lifetimecol").Equals(colID)) { const char *stringID = (certdi->mIsTemporary) ? "CertExceptionTemporary" : "CertExceptionPermanent"; rv = mNSSComponent->GetPIPNSSBundleString(stringID, _retval); } else if (NS_LITERAL_STRING("typecol").Equals(colID) && cert) { nsCOMPtr<nsIX509Cert2> pipCert = do_QueryInterface(cert); PRUint32 type = nsIX509Cert::UNKNOWN_CERT; if (pipCert) { rv = pipCert->GetCertType(&type); } switch (type) { case nsIX509Cert::USER_CERT: rv = mNSSComponent->GetPIPNSSBundleString("CertUser", _retval); break; case nsIX509Cert::CA_CERT: rv = mNSSComponent->GetPIPNSSBundleString("CertCA", _retval); break; case nsIX509Cert::SERVER_CERT: rv = mNSSComponent->GetPIPNSSBundleString("CertSSL", _retval); break; case nsIX509Cert::EMAIL_CERT: rv = mNSSComponent->GetPIPNSSBundleString("CertEmail", _retval); break; default: rv = mNSSComponent->GetPIPNSSBundleString("CertUnknown", _retval); break; } } else { return NS_ERROR_FAILURE; } if (mCellText) { nsCOMPtr<nsISupportsString> text(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); text->SetData(_retval); mCellText->ReplaceElementAt(text, arrayIndex, false); } return rv; }
static void ImportMailThread(void *stuff) { ImportThreadData *pData = (ImportThreadData *)stuff; IMPORT_LOG0("ImportMailThread: Starting..."); nsresult rv = NS_OK; nsCOMPtr<nsIMsgFolder> destRoot(pData->destRoot); uint32_t count = 0; rv = pData->boxes->Count(&count); uint32_t i; bool import; uint32_t size; uint32_t depth = 1; uint32_t newDepth; nsString lastName; PRUnichar * pName; nsCOMPtr<nsIMsgFolder> curFolder(destRoot); nsCOMPtr<nsIMsgFolder> newFolder; nsCOMPtr<nsIMsgFolder> subFolder; nsCOMPtr<nsISimpleEnumerator> enumerator; bool exists; nsString success; nsString error; // GetSubFolders() will initialize folders if they are not already initialized. ProxyGetSubFolders(curFolder, getter_AddRefs(enumerator)); IMPORT_LOG1("ImportMailThread: Total number of folders to import = %d.", count); // Note that the front-end js script only displays one import result string so // we combine both good and bad import status into one string (in var 'success'). for (i = 0; (i < count) && !(pData->abort); i++) { nsCOMPtr<nsIImportMailboxDescriptor> box = do_QueryElementAt(pData->boxes, i); if (box) { pData->currentMailbox = i; import = false; size = 0; rv = box->GetImport(&import); if (import) rv = box->GetSize(&size); rv = box->GetDepth(&newDepth); if (newDepth > depth) { // OK, we are going to add a subfolder under the last/previous folder we processed, so // find this folder (stored in 'lastName') who is going to be the new parent folder. IMPORT_LOG1("ImportMailThread: Processing child folder '%s'.", NS_ConvertUTF16toUTF8(lastName).get()); rv = ProxyGetChildNamed(curFolder, lastName, getter_AddRefs(subFolder)); if (NS_FAILED(rv)) { IMPORT_LOG1("*** ImportMailThread: Failed to get the interface for child folder '%s'.", NS_ConvertUTF16toUTF8(lastName).get()); nsImportGenericMail::ReportError(IMPORT_ERROR_MB_FINDCHILD, lastName.get(), &error, pData->stringBundle); pData->fatalError = true; break; } curFolder = subFolder; // Make sure this new parent folder obj has the correct subfolder list so far. rv = ProxyGetSubFolders(curFolder, getter_AddRefs(enumerator)); } else if (newDepth < depth) { rv = NS_OK; while ((newDepth < depth) && NS_SUCCEEDED(rv)) { rv = curFolder->GetParent(getter_AddRefs(curFolder)); if (NS_FAILED(rv)) { IMPORT_LOG1("*** ImportMailThread: Failed to get the interface for parent folder '%s'.", lastName.get()); nsImportGenericMail::ReportError(IMPORT_ERROR_MB_FINDCHILD, lastName.get(), &error, pData->stringBundle); pData->fatalError = true; break; } depth--; } if (NS_FAILED(rv)) { IMPORT_LOG1("*** ImportMailThread: Failed to get the proxy interface for parent folder '%s'.", lastName.get()); nsImportStringBundle::GetStringByID(IMPORT_ERROR_MB_NOPROXY, pData->stringBundle, error); pData->fatalError = true; break; } } depth = newDepth; pName = nullptr; box->GetDisplayName(&pName); if (pName) { lastName = pName; NS_Free(pName); } else lastName.AssignLiteral("Unknown!"); // translate the folder name if we are doing migration, but // only for special folders which are at the root level if (pData->performingMigration && depth == 1) pData->mailImport->TranslateFolderName(lastName, lastName); exists = false; rv = ProxyContainsChildNamed(curFolder, lastName, &exists); // If we are performing profile migration (as opposed to importing) then we are starting // with empty local folders. In that case, always choose to over-write the existing local folder // with this name. Don't create a unique subfolder name. Otherwise you end up with "Inbox, Inbox0" // or "Unsent Folders, UnsentFolders0" if (exists && !pData->performingMigration) { nsString subName; ProxyGenerateUniqueSubfolderName(curFolder, lastName, nullptr, subName); if (!subName.IsEmpty()) lastName.Assign(subName); } IMPORT_LOG1("ImportMailThread: Creating new import folder '%s'.", NS_ConvertUTF16toUTF8(lastName).get()); ProxyCreateSubfolder(curFolder, lastName); // this may fail if the folder already exists..that's ok rv = ProxyGetChildNamed(curFolder, lastName, getter_AddRefs(newFolder)); if (NS_FAILED(rv)) { IMPORT_LOG1("*** ImportMailThread: Failed to locate subfolder '%s' after it's been created.", lastName.get()); nsImportGenericMail::ReportError(IMPORT_ERROR_MB_CREATE, lastName.get(), &error, pData->stringBundle); } if (size && import && newFolder && NS_SUCCEEDED(rv)) { bool fatalError = false; pData->currentSize = size; PRUnichar *pSuccess = nullptr; PRUnichar *pError = nullptr; rv = pData->mailImport->ImportMailbox(box, newFolder, &pError, &pSuccess, &fatalError); if (pError) { error.Append(pError); NS_Free(pError); } if (pSuccess) { success.Append(pSuccess); NS_Free(pSuccess); } pData->currentSize = 0; pData->currentTotal += size; // commit to the db synchronously, but using a proxy since it doesn't like being used // elsewhere than from the main thread. // OK, we've copied the actual folder/file over if the folder size is not 0 // (ie, the msg summary is no longer valid) so close the msg database so that // when the folder is reopened the folder db can be reconstructed (which // validates msg summary and forces folder to be reparsed). rv = ProxyForceDBClosed(newFolder); fatalError = NS_FAILED(rv); if (fatalError) { IMPORT_LOG1("*** ImportMailThread: ImportMailbox returned fatalError, mailbox #%d\n", (int) i); pData->fatalError = true; break; } } } } // Now save the new acct info to pref file. nsCOMPtr <nsIMsgAccountManager> accMgr = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv); if (NS_SUCCEEDED(rv) && accMgr) { rv = accMgr->SaveAccountInfo(); NS_ASSERTION(NS_SUCCEEDED(rv), "Can't save account info to pref file"); } nsImportGenericMail::SetLogs(success, error, pData->successLog, pData->errorLog); if (pData->abort || pData->fatalError) { IMPORT_LOG0("*** ImportMailThread: Abort or fatalError flag was set\n"); if (pData->ownsDestRoot) { IMPORT_LOG0("Calling destRoot->RecursiveDelete\n"); destRoot->RecursiveDelete(true, nullptr); } else { // FIXME: just delete the stuff we created? } } IMPORT_LOG1("Import mailbox thread done: %d\n", (int) pData->currentTotal); pData->ThreadDelete(); }
nsresult nsEudoraFilters::AddAction(nsMsgRuleActionType actionType, int32_t junkScore /*= 0*/, nsMsgLabelValue label/*= 0*/, nsMsgPriorityValue priority/*= 0*/, const char* strValue/*= nullptr*/, const char* targetFolderUri/*= nullptr*/) { nsresult rv; uint32_t numFilters; rv = m_pFilterArray->Count(&numFilters); NS_ENSURE_SUCCESS(rv, rv); for (uint32_t filterIndex = 0; filterIndex < numFilters; filterIndex++) { nsCOMPtr<nsIMsgFilter> filter = do_QueryElementAt(m_pFilterArray, filterIndex, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMsgRuleAction> action; rv = filter->CreateAction(getter_AddRefs(action)); NS_ENSURE_SUCCESS(rv, rv); rv = action->SetType(actionType); NS_ENSURE_SUCCESS(rv, rv); switch (actionType) { case nsMsgFilterAction::MoveToFolder: case nsMsgFilterAction::CopyToFolder: rv = action->SetTargetFolderUri(nsAutoCString(targetFolderUri)); break; case nsMsgFilterAction::ChangePriority: rv = action->SetPriority(priority); break; case nsMsgFilterAction::JunkScore: rv = action->SetJunkScore(junkScore); break; case nsMsgFilterAction::AddTag: case nsMsgFilterAction::Reply: case nsMsgFilterAction::Forward: rv = action->SetStrValue(nsAutoCString(strValue)); break; case nsMsgFilterAction::MarkRead: case nsMsgFilterAction::StopExecution: case nsMsgFilterAction::DeleteFromPop3Server: case nsMsgFilterAction::LeaveOnPop3Server: case nsMsgFilterAction::FetchBodyFromPop3Server: // No parameters for these break; case nsMsgFilterAction::Delete: case nsMsgFilterAction::KillThread: case nsMsgFilterAction::WatchThread: case nsMsgFilterAction::MarkFlagged: case nsMsgFilterAction::Label: default: // Something we don't handle return NS_ERROR_FAILURE; } NS_ENSURE_SUCCESS(rv, rv); rv = filter->AppendAction(action); NS_ENSURE_SUCCESS(rv, rv); } m_addedAction = true; return rv; }
nsresult nsNSSCertificateDB::handleCACertDownload(nsIArray *x509Certs, nsIInterfaceRequestor *ctx) { // First thing we have to do is figure out which certificate we're // gonna present to the user. The CA may have sent down a list of // certs which may or may not be a chained list of certs. Until // the day we can design some solid UI for the general case, we'll // code to the > 90% case. That case is where a CA sends down a // list that is a hierarchy whose root is either the first or // the last cert. What we're gonna do is compare the first // 2 entries, if the second was signed by the first, we assume // the root cert is the first cert and display it. Otherwise, // we compare the last 2 entries, if the second to last cert was // signed by the last cert, then we assume the last cert is the // root and display it. nsNSSShutDownPreventionLock locker; PRUint32 numCerts; x509Certs->GetLength(&numCerts); NS_ASSERTION(numCerts > 0, "Didn't get any certs to import."); if (numCerts == 0) return NS_OK; // Nothing to import, so nothing to do. nsCOMPtr<nsIX509Cert> certToShow; nsCOMPtr<nsISupports> isupports; PRUint32 selCertIndex; if (numCerts == 1) { // There's only one cert, so let's show it. selCertIndex = 0; certToShow = do_QueryElementAt(x509Certs, selCertIndex); } else { nsCOMPtr<nsIX509Cert> cert0; // first cert nsCOMPtr<nsIX509Cert> cert1; // second cert nsCOMPtr<nsIX509Cert> certn_2; // second to last cert nsCOMPtr<nsIX509Cert> certn_1; // last cert cert0 = do_QueryElementAt(x509Certs, 0); cert1 = do_QueryElementAt(x509Certs, 1); certn_2 = do_QueryElementAt(x509Certs, numCerts-2); certn_1 = do_QueryElementAt(x509Certs, numCerts-1); nsXPIDLString cert0SubjectName; nsXPIDLString cert1IssuerName; nsXPIDLString certn_2IssuerName; nsXPIDLString certn_1SubjectName; cert0->GetSubjectName(cert0SubjectName); cert1->GetIssuerName(cert1IssuerName); certn_2->GetIssuerName(certn_2IssuerName); certn_1->GetSubjectName(certn_1SubjectName); if (cert1IssuerName.Equals(cert0SubjectName)) { // In this case, the first cert in the list signed the second, // so the first cert is the root. Let's display it. selCertIndex = 0; certToShow = cert0; } else if (certn_2IssuerName.Equals(certn_1SubjectName)) { // In this case the last cert has signed the second to last cert. // The last cert is the root, so let's display it. selCertIndex = numCerts-1; certToShow = certn_1; } else { // It's not a chain, so let's just show the first one in the // downloaded list. selCertIndex = 0; certToShow = cert0; } } if (!certToShow) return NS_ERROR_FAILURE; nsCOMPtr<nsICertificateDialogs> dialogs; nsresult rv = ::getNSSDialogs(getter_AddRefs(dialogs), NS_GET_IID(nsICertificateDialogs), NS_CERTIFICATEDIALOGS_CONTRACTID); if (NS_FAILED(rv)) return rv; SECItem der; rv=certToShow->GetRawDER(&der.len, (PRUint8 **)&der.data); if (NS_FAILED(rv)) return rv; PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("Creating temp cert\n")); CERTCertificate *tmpCert; CERTCertDBHandle *certdb = CERT_GetDefaultCertDB(); tmpCert = CERT_FindCertByDERCert(certdb, &der); if (!tmpCert) { tmpCert = CERT_NewTempCertificate(certdb, &der, nsnull, PR_FALSE, PR_TRUE); } nsMemory::Free(der.data); der.data = nsnull; der.len = 0; if (!tmpCert) { NS_ERROR("Couldn't create cert from DER blob\n"); return NS_ERROR_FAILURE; } CERTCertificateCleaner tmpCertCleaner(tmpCert); if (!CERT_IsCACert(tmpCert, NULL)) { DisplayCertificateAlert(ctx, "NotACACert", certToShow); return NS_ERROR_FAILURE; } if (tmpCert->isperm) { DisplayCertificateAlert(ctx, "CaCertExists", certToShow); return NS_ERROR_FAILURE; } PRUint32 trustBits; PRBool allows; rv = dialogs->ConfirmDownloadCACert(ctx, certToShow, &trustBits, &allows); if (NS_FAILED(rv)) return rv; if (!allows) return NS_ERROR_NOT_AVAILABLE; PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("trust is %d\n", trustBits)); nsXPIDLCString nickname; nickname.Adopt(CERT_MakeCANickname(tmpCert)); PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("Created nick \"%s\"\n", nickname.get())); nsNSSCertTrust trust; trust.SetValidCA(); trust.AddCATrust(!!(trustBits & nsIX509CertDB::TRUSTED_SSL), !!(trustBits & nsIX509CertDB::TRUSTED_EMAIL), !!(trustBits & nsIX509CertDB::TRUSTED_OBJSIGN)); SECStatus srv = CERT_AddTempCertToPerm(tmpCert, const_cast<char*>(nickname.get()), trust.GetTrust()); if (srv != SECSuccess) return NS_ERROR_FAILURE; // Import additional delivered certificates that can be verified. // build a CertList for filtering CERTCertList *certList = CERT_NewCertList(); if (certList == NULL) { return NS_ERROR_FAILURE; } CERTCertListCleaner listCleaner(certList); // get all remaining certs into temp store for (PRUint32 i=0; i<numCerts; i++) { if (i == selCertIndex) { // we already processed that one continue; } certToShow = do_QueryElementAt(x509Certs, i); certToShow->GetRawDER(&der.len, (PRUint8 **)&der.data); CERTCertificate *tmpCert2 = CERT_NewTempCertificate(certdb, &der, nsnull, PR_FALSE, PR_TRUE); nsMemory::Free(der.data); der.data = nsnull; der.len = 0; if (!tmpCert2) { NS_ASSERTION(0, "Couldn't create temp cert from DER blob\n"); continue; // Let's try to import the rest of 'em } CERT_AddCertToListTail(certList, tmpCert2); } return ImportValidCACertsInList(certList, ctx); }
nsresult nsMsgCopyService::DoNextCopy() { nsresult rv = NS_OK; nsCopyRequest* copyRequest = nullptr; nsCopySource* copySource = nullptr; uint32_t i, j, scnt; uint32_t cnt = m_copyRequests.Length(); if (cnt > 0) { nsCOMArray<nsIMsgFolder> activeTargets; // ** jt -- always FIFO for (i = 0; i < cnt; i++) { copyRequest = m_copyRequests.ElementAt(i); copySource = nullptr; scnt = copyRequest->m_copySourceArray.Length(); if (!copyRequest->m_processed) { // if the target folder of this request already has an active // copy request, skip this request for now. if (activeTargets.IndexOfObject(copyRequest->m_dstFolder) != kNotFound) { copyRequest = nullptr; continue; } if (scnt <= 0) goto found; // must be CopyFileMessage for (j = 0; j < scnt; j++) { copySource = copyRequest->m_copySourceArray.ElementAt(j); if (!copySource->m_processed) goto found; } if (j >= scnt) // all processed set the value copyRequest->m_processed = true; } if (copyRequest->m_processed) // keep track of folders actively getting copied to. activeTargets.AppendObject(copyRequest->m_dstFolder); } found: if (copyRequest && !copyRequest->m_processed) { if (copyRequest->m_listener) copyRequest->m_listener->OnStartCopy(); if (copyRequest->m_requestType == nsCopyMessagesType && copySource) { copySource->m_processed = true; rv = copyRequest->m_dstFolder->CopyMessages (copySource->m_msgFolder, copySource->m_messageArray, copyRequest->m_isMoveOrDraftOrTemplate, copyRequest->m_msgWindow, copyRequest->m_listener, false, copyRequest->m_allowUndo); //isFolder operation false } else if (copyRequest->m_requestType == nsCopyFoldersType ) { copySource->m_processed = true; rv = copyRequest->m_dstFolder->CopyFolder (copySource->m_msgFolder, copyRequest->m_isMoveOrDraftOrTemplate, copyRequest->m_msgWindow, copyRequest->m_listener); // If it's a copy folder operation and the destination // folder already exists, CopyFolder() returns an error w/o sending // a completion notification, so clear it here. if (NS_FAILED(rv)) ClearRequest(copyRequest, rv); } else if (copyRequest->m_requestType == nsCopyFileMessageType) { nsCOMPtr<nsIFile> aFile(do_QueryInterface(copyRequest->m_srcSupport, &rv)); if (NS_SUCCEEDED(rv)) { // ** in case of saving draft/template; the very first // time we may not have the original message to replace // with; if we do we shall have an instance of copySource nsCOMPtr<nsIMsgDBHdr> aMessage; if (copySource) { aMessage = do_QueryElementAt(copySource->m_messageArray, 0, &rv); copySource->m_processed = true; } copyRequest->m_processed = true; rv = copyRequest->m_dstFolder->CopyFileMessage (aFile, aMessage, copyRequest->m_isMoveOrDraftOrTemplate, copyRequest->m_newMsgFlags, copyRequest->m_newMsgKeywords, copyRequest->m_msgWindow, copyRequest->m_listener); } } } } return rv; }
// Override a web page NS_IMETHODIMP nsParentalControlsServiceWin::RequestURIOverrides(nsIArray *aTargets, nsIInterfaceRequestor *aWindowContext, bool *_retval) { *_retval = false; if (!mEnabled) return NS_ERROR_NOT_AVAILABLE; NS_ENSURE_ARG_POINTER(aTargets); PRUint32 arrayLength = 0; aTargets->GetLength(&arrayLength); if (!arrayLength) return NS_ERROR_INVALID_ARG; if (arrayLength == 1) { nsCOMPtr<nsIURI> uri = do_QueryElementAt(aTargets, 0); if (!uri) return NS_ERROR_INVALID_ARG; return RequestURIOverride(uri, aWindowContext, _retval); } HWND hWnd = nullptr; // If we have a native window, use its handle instead nsCOMPtr<nsIWidget> widget(do_GetInterface(aWindowContext)); if (widget) hWnd = (HWND)widget->GetNativeData(NS_NATIVE_WINDOW); if (hWnd == nullptr) hWnd = GetDesktopWindow(); // The first entry should be the root uri nsCAutoString rootSpec; nsCOMPtr<nsIURI> rootURI = do_QueryElementAt(aTargets, 0); if (!rootURI) return NS_ERROR_INVALID_ARG; rootURI->GetSpec(rootSpec); if (rootSpec.IsEmpty()) return NS_ERROR_INVALID_ARG; // Allocate an array of sub uri PRInt32 count = arrayLength - 1; nsAutoArrayPtr<LPCWSTR> arrUrls(new LPCWSTR[count]); if (!arrUrls) return NS_ERROR_OUT_OF_MEMORY; PRUint32 uriIdx = 0, idx; for (idx = 1; idx < arrayLength; idx++) { nsCOMPtr<nsIURI> uri = do_QueryElementAt(aTargets, idx); if (!uri) continue; nsCAutoString subURI; if (NS_FAILED(uri->GetSpec(subURI))) continue; arrUrls[uriIdx] = (LPCWSTR)UTF8ToNewUnicode(subURI); // allocation if (!arrUrls[uriIdx]) continue; uriIdx++; } if (!uriIdx) return NS_ERROR_INVALID_ARG; BOOL ret; nsRefPtr<IWPCWebSettings> wpcws; if (SUCCEEDED(mPC->GetWebSettings(NULL, getter_AddRefs(wpcws)))) { wpcws->RequestURLOverride(hWnd, NS_ConvertUTF8toUTF16(rootSpec).get(), uriIdx, (LPCWSTR*)arrUrls.get(), &ret); *_retval = ret; } // Free up the allocated strings in our array for (idx = 0; idx < uriIdx; idx++) NS_Free((void*)arrUrls[idx]); return NS_OK; }
NS_IMETHODIMP nsXULTemplateQueryProcessorStorage::GetDatasource(nsIArray* aDataSources, nsIDOMNode* aRootNode, bool aIsTrusted, nsIXULTemplateBuilder* aBuilder, bool* aShouldDelayBuilding, nsISupports** aReturn) { *aReturn = nullptr; *aShouldDelayBuilding = false; if (!aIsTrusted) { return NS_OK; } uint32_t length; nsresult rv = aDataSources->GetLength(&length); NS_ENSURE_SUCCESS(rv, rv); if (length == 0) { return NS_OK; } // We get only the first uri. This query processor supports // only one database at a time. nsCOMPtr<nsIURI> uri; uri = do_QueryElementAt(aDataSources, 0); if (!uri) { // No uri in the list of datasources return NS_OK; } nsCOMPtr<mozIStorageService> storage = do_GetService("@mozilla.org/storage/service;1", &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIFile> databaseFile; nsAutoCString scheme; rv = uri->GetScheme(scheme); NS_ENSURE_SUCCESS(rv, rv); if (scheme.EqualsLiteral("profile")) { nsAutoCString path; rv = uri->GetPath(path); NS_ENSURE_SUCCESS(rv, rv); if (path.IsEmpty()) { return NS_ERROR_FAILURE; } rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(databaseFile)); NS_ENSURE_SUCCESS(rv, rv); rv = databaseFile->AppendNative(path); NS_ENSURE_SUCCESS(rv, rv); } else { nsCOMPtr<nsIChannel> channel; nsCOMPtr<nsINode> node = do_QueryInterface(aRootNode); rv = NS_NewChannel(getter_AddRefs(channel), uri, node, nsILoadInfo::SEC_NORMAL, nsIContentPolicy::TYPE_OTHER); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(channel, &rv); if (NS_FAILED(rv)) { // if it fails, not a file url nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_STORAGE_BAD_URI); return rv; } nsCOMPtr<nsIFile> file; rv = fileChannel->GetFile(getter_AddRefs(databaseFile)); NS_ENSURE_SUCCESS(rv, rv); } // ok now we have an URI of a sqlite file nsCOMPtr<mozIStorageConnection> connection; rv = storage->OpenDatabase(databaseFile, getter_AddRefs(connection)); if (NS_FAILED(rv)) { nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_STORAGE_CANNOT_OPEN_DATABASE); return rv; } NS_ADDREF(*aReturn = connection); return NS_OK; }
// This is the function that looks for the first folder to purge. It also // applies retention settings to any folder that hasn't had retention settings // applied in mMinDelayBetweenPurges minutes (default, 8 hours). // However, if we've spent more than .5 seconds in this loop, don't // apply any more retention settings because it might lock up the UI. // This might starve folders later on in the hierarchy, since we always // start at the top, but since we also apply retention settings when you // open a folder, or when you compact all folders, I think this will do // for now, until we have a cleanup on shutdown architecture. nsresult nsMsgPurgeService::PerformPurge() { PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("performing purge")); nsresult rv; nsCOMPtr <nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv,rv); bool keepApplyingRetentionSettings = true; nsCOMPtr<nsISupportsArray> allServers; rv = accountManager->GetAllServers(getter_AddRefs(allServers)); if (NS_SUCCEEDED(rv) && allServers) { PRUint32 numServers; rv = allServers->Count(&numServers); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("%d servers", numServers)); nsCOMPtr<nsIMsgFolder> folderToPurge; PRIntervalTime startTime = PR_IntervalNow(); PRInt32 purgeIntervalToUse; PRTime oldestPurgeTime = 0; // we're going to pick the least-recently purged folder // apply retention settings to folders that haven't had retention settings // applied in mMinDelayBetweenPurges minutes (default 8 hours) // Because we get last purge time from the folder cache, // this code won't open db's for folders until it decides it needs // to apply retention settings, and since nsIMsgFolder::ApplyRetentionSettings // will close any db's it opens, this code won't leave db's open. for (PRUint32 serverIndex=0; serverIndex < numServers; serverIndex++) { nsCOMPtr <nsIMsgIncomingServer> server = do_QueryElementAt(allServers, serverIndex, &rv); if (NS_SUCCEEDED(rv) && server) { if (keepApplyingRetentionSettings) { nsCOMPtr <nsIMsgFolder> rootFolder; rv = server->GetRootFolder(getter_AddRefs(rootFolder)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr <nsISupportsArray> childFolders = do_CreateInstance(NS_SUPPORTSARRAY_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = rootFolder->ListDescendents(childFolders); PRUint32 cnt = 0; childFolders->Count(&cnt); nsCOMPtr<nsISupports> supports; nsCOMPtr<nsIUrlListener> urlListener; nsCOMPtr<nsIMsgFolder> childFolder; for (PRUint32 index = 0; index < cnt; index++) { childFolder = do_QueryElementAt(childFolders, index); if (childFolder) { PRUint32 folderFlags; (void) childFolder->GetFlags(&folderFlags); if (folderFlags & nsMsgFolderFlags::Virtual) continue; PRTime curFolderLastPurgeTime = 0; nsCString curFolderLastPurgeTimeString, curFolderUri; rv = childFolder->GetStringProperty("LastPurgeTime", curFolderLastPurgeTimeString); if (NS_FAILED(rv)) continue; // it is ok to fail, go on to next folder if (!curFolderLastPurgeTimeString.IsEmpty()) { PRInt64 theTime; PR_ParseTimeString(curFolderLastPurgeTimeString.get(), PR_FALSE, &theTime); curFolderLastPurgeTime = theTime; } childFolder->GetURI(curFolderUri); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("%s curFolderLastPurgeTime=%s (if blank, then never)", curFolderUri.get(), curFolderLastPurgeTimeString.get())); // check if this folder is due to purge // has to have been purged at least mMinDelayBetweenPurges minutes ago // we don't want to purge the folders all the time - once a day is good enough PRInt64 minDelayBetweenPurges(mMinDelayBetweenPurges); PRInt64 microSecondsPerMinute(60000000); PRTime nextPurgeTime = curFolderLastPurgeTime + (minDelayBetweenPurges * microSecondsPerMinute); if (nextPurgeTime < PR_Now()) { PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("purging %s", curFolderUri.get())); childFolder->ApplyRetentionSettings(); } PRIntervalTime elapsedTime; LL_SUB(elapsedTime, PR_IntervalNow(), startTime); // check if more than 500 milliseconds have elapsed in this purge process if (PR_IntervalToMilliseconds(elapsedTime) > 500) { keepApplyingRetentionSettings = PR_FALSE; break; } } } } nsCString type; nsresult rv = server->GetType(type); NS_ENSURE_SUCCESS(rv, rv); nsCAutoString contractid(NS_MSGPROTOCOLINFO_CONTRACTID_PREFIX); contractid.Append(type); nsCOMPtr<nsIMsgProtocolInfo> protocolInfo = do_GetService(contractid.get(), &rv); NS_ENSURE_SUCCESS(rv, PR_FALSE); nsCString realHostName; server->GetRealHostName(realHostName); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] %s (%s)", serverIndex, realHostName.get(), type.get())); nsCOMPtr <nsISpamSettings> spamSettings; rv = server->GetSpamSettings(getter_AddRefs(spamSettings)); NS_ENSURE_SUCCESS(rv, rv); PRInt32 spamLevel; spamSettings->GetLevel(&spamLevel); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] spamLevel=%d (if 0, don't purge)", serverIndex, spamLevel)); if (!spamLevel) continue; // check if we are set up to purge for this server // if not, skip it. bool purgeSpam; spamSettings->GetPurge(&purgeSpam); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] purgeSpam=%s (if false, don't purge)", serverIndex, purgeSpam ? "true" : "false")); if (!purgeSpam) continue; // check if the spam folder uri is set for this server // if not skip it. nsCString junkFolderURI; rv = spamSettings->GetSpamFolderURI(getter_Copies(junkFolderURI)); NS_ENSURE_SUCCESS(rv,rv); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] junkFolderURI=%s (if empty, don't purge)", serverIndex, junkFolderURI.get())); if (junkFolderURI.IsEmpty()) continue; // if the junk folder doesn't exist // because the folder pane isn't built yet, for example // skip this account nsCOMPtr<nsIMsgFolder> junkFolder; GetExistingFolder(junkFolderURI, getter_AddRefs(junkFolder)); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] %s exists? %s (if doesn't exist, don't purge)", serverIndex, junkFolderURI.get(), junkFolder ? "true" : "false")); if (!junkFolder) continue; PRTime curJunkFolderLastPurgeTime = 0; nsCString curJunkFolderLastPurgeTimeString; rv = junkFolder->GetStringProperty("curJunkFolderLastPurgeTime", curJunkFolderLastPurgeTimeString); if (NS_FAILED(rv)) continue; // it is ok to fail, junk folder may not exist if (!curJunkFolderLastPurgeTimeString.IsEmpty()) { PRInt64 theTime; PR_ParseTimeString(curJunkFolderLastPurgeTimeString.get(), PR_FALSE, &theTime); curJunkFolderLastPurgeTime = theTime; } PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] %s curJunkFolderLastPurgeTime=%s (if blank, then never)", serverIndex, junkFolderURI.get(), curJunkFolderLastPurgeTimeString.get())); // check if this account is due to purge // has to have been purged at least mMinDelayBetweenPurges minutes ago // we don't want to purge the folders all the time PRTime nextPurgeTime = curJunkFolderLastPurgeTime + mMinDelayBetweenPurges * 60000000 /* convert mMinDelayBetweenPurges to into microseconds */; if (nextPurgeTime < PR_Now()) { PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] last purge greater than min delay", serverIndex)); nsCOMPtr <nsIMsgIncomingServer> junkFolderServer; rv = junkFolder->GetServer(getter_AddRefs(junkFolderServer)); NS_ENSURE_SUCCESS(rv,rv); bool serverBusy = false; bool serverRequiresPassword = true; bool passwordPromptRequired; bool canSearchMessages = false; junkFolderServer->GetPasswordPromptRequired(&passwordPromptRequired); junkFolderServer->GetServerBusy(&serverBusy); junkFolderServer->GetServerRequiresPasswordForBiff(&serverRequiresPassword); junkFolderServer->GetCanSearchMessages(&canSearchMessages); // Make sure we're logged on before doing the search (assuming we need to be) // and make sure the server isn't already in the middle of downloading new messages // and make sure a search isn't already going on PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] (search in progress? %s)", serverIndex, mSearchSession ? "true" : "false")); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] (server busy? %s)", serverIndex, serverBusy ? "true" : "false")); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] (serverRequiresPassword? %s)", serverIndex, serverRequiresPassword ? "true" : "false")); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] (passwordPromptRequired? %s)", serverIndex, passwordPromptRequired ? "true" : "false")); if (canSearchMessages && !mSearchSession && !serverBusy && (!serverRequiresPassword || !passwordPromptRequired)) { PRInt32 purgeInterval; spamSettings->GetPurgeInterval(&purgeInterval); if ((oldestPurgeTime == 0) || (curJunkFolderLastPurgeTime < oldestPurgeTime)) { PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] purging! searching for messages older than %d days", serverIndex, purgeInterval)); oldestPurgeTime = curJunkFolderLastPurgeTime; purgeIntervalToUse = purgeInterval; folderToPurge = junkFolder; // if we've never purged this folder, do it... if (curJunkFolderLastPurgeTime == 0) break; } } else { NS_ASSERTION(canSearchMessages, "unexpected, you should be able to search"); PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] not a good time for this server, try again later", serverIndex)); } } else { PR_LOG(MsgPurgeLogModule, PR_LOG_ALWAYS, ("[%d] last purge too recent", serverIndex)); } } } if (folderToPurge) rv = SearchFolderToPurge(folderToPurge, purgeIntervalToUse); } // set up timer to check accounts again SetupNextPurge(); return rv; }
//////////////////////////////////////////////////////////////////////////////////// // Utility Functions for MsgFolders //////////////////////////////////////////////////////////////////////////////////// nsresult LocateMessageFolder(nsIMsgIdentity *userIdentity, nsMsgDeliverMode aFolderType, const char *aFolderURI, nsIMsgFolder **msgFolder) { nsresult rv = NS_OK; if (!msgFolder) return NS_ERROR_NULL_POINTER; *msgFolder = nullptr; if (!aFolderURI || !*aFolderURI) return NS_ERROR_INVALID_ARG; // as long as it doesn't start with anyfolder:// if (PL_strncasecmp(ANY_SERVER, aFolderURI, strlen(aFolderURI)) != 0) { nsCOMPtr<nsIRDFService> rdf(do_GetService(kRDFServiceCID, &rv)); if (NS_FAILED(rv)) return rv; // get the corresponding RDF resource // RDF will create the folder resource if it doesn't already exist nsCOMPtr<nsIRDFResource> resource; rv = rdf->GetResource(nsDependentCString(aFolderURI), getter_AddRefs(resource)); if (NS_FAILED(rv)) return rv; nsCOMPtr <nsIMsgFolder> folderResource; folderResource = do_QueryInterface(resource, &rv); if (NS_SUCCEEDED(rv) && folderResource) { // don't check validity of folder - caller will handle creating it nsCOMPtr<nsIMsgIncomingServer> server; //make sure that folder hierarchy is built so that legitimate parent-child relationship is established rv = folderResource->GetServer(getter_AddRefs(server)); NS_ENSURE_SUCCESS(rv,rv); return server->GetMsgFolderFromURI(folderResource, nsDependentCString(aFolderURI), msgFolder); } else { return NS_ERROR_FAILURE; } } else { uint32_t cnt = 0; uint32_t i; if (!userIdentity) return NS_ERROR_INVALID_ARG; // get the account manager nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv); if (NS_FAILED(rv)) return rv; // If any folder will do, go look for one. nsCOMPtr<nsIArray> retval; accountManager->GetServersForIdentity(userIdentity, getter_AddRefs(retval)); if (!retval) return NS_ERROR_FAILURE; // Ok, we have to look through the servers and try to find the server that // has a valid folder of the type that interests us... rv = retval->GetLength(&cnt); if (NS_FAILED(rv)) return rv; for (i=0; i<cnt; i++) { // Now that we have the server...we need to get the named message folder nsCOMPtr<nsIMsgIncomingServer> inServer; inServer = do_QueryElementAt(retval, i, &rv); if(NS_FAILED(rv) || (!inServer)) continue; // // If aFolderURI is passed in, then the user has chosen a specific // mail folder to save the message, but if it is null, just find the // first one and make that work. The folder is specified as a URI, like // the following: // // mailbox://nobody@Local Folders/Sent // imap://rhp@nsmail-2/Drafts // newsgroup://news.mozilla.org/netscape.test // nsCString serverURI; rv = inServer->GetServerURI(serverURI); if (NS_FAILED(rv) || serverURI.IsEmpty()) continue; nsCOMPtr<nsIMsgFolder> rootFolder; rv = inServer->GetRootFolder(getter_AddRefs(rootFolder)); if(NS_FAILED(rv) || (!rootFolder)) continue; // use the defaults by getting the folder by flags if (aFolderType == nsIMsgSend::nsMsgQueueForLater || aFolderType == nsIMsgSend::nsMsgDeliverBackground) { // QueueForLater (Outbox) rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Queue, msgFolder); } else if (aFolderType == nsIMsgSend::nsMsgSaveAsDraft) // SaveAsDraft (Drafts) { rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Drafts, msgFolder); } else if (aFolderType == nsIMsgSend::nsMsgSaveAsTemplate) // SaveAsTemplate (Templates) { rootFolder->GetFolderWithFlags(nsMsgFolderFlags::Templates, msgFolder); } else // SaveInSentFolder (Sent) - nsMsgDeliverNow or nsMsgSendUnsent { rootFolder->GetFolderWithFlags(nsMsgFolderFlags::SentMail, msgFolder); } if (*msgFolder) { return NS_OK; } } } return NS_ERROR_FAILURE; }
NS_IMETHODIMP nsAbView::GetSelectedAddresses(nsIArray **_retval) { NS_ENSURE_ARG_POINTER(_retval); nsresult rv; nsCOMPtr<nsIMutableArray> selectedCards = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = GetSelectedCards(selectedCards); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMutableArray> addresses = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); PRUint32 count; selectedCards->GetLength(&count); for (PRUint32 i = 0; i < count; i++) { nsCOMPtr<nsIAbCard> card(do_QueryElementAt(selectedCards, i, &rv)); NS_ENSURE_SUCCESS(rv, rv); bool isMailList; card->GetIsMailList(&isMailList); nsAutoString primaryEmail; if (isMailList) { nsCOMPtr<nsIAbManager> abManager(do_GetService(NS_ABMANAGER_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); nsCString mailListURI; rv = card->GetMailListURI(getter_Copies(mailListURI)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIAbDirectory> mailList; rv = abManager->GetDirectory(mailListURI, getter_AddRefs(mailList)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMutableArray> mailListAddresses; rv = mailList->GetAddressLists(getter_AddRefs(mailListAddresses)); NS_ENSURE_SUCCESS(rv,rv); PRUint32 mailListCount = 0; mailListAddresses->GetLength(&mailListCount); for (PRUint32 j = 0; j < mailListCount; j++) { nsCOMPtr<nsIAbCard> mailListCard = do_QueryElementAt(mailListAddresses, j, &rv); NS_ENSURE_SUCCESS(rv,rv); rv = mailListCard->GetPrimaryEmail(primaryEmail); NS_ENSURE_SUCCESS(rv,rv); if (!primaryEmail.IsEmpty()) { nsCOMPtr<nsISupportsString> supportsEmail(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); supportsEmail->SetData(primaryEmail); addresses->AppendElement(supportsEmail, false); } } } else { rv = card->GetPrimaryEmail(primaryEmail); NS_ENSURE_SUCCESS(rv,rv); if (!primaryEmail.IsEmpty()) { nsCOMPtr<nsISupportsString> supportsEmail(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); supportsEmail->SetData(primaryEmail); addresses->AppendElement(supportsEmail, false); } } } NS_IF_ADDREF(*_retval = addresses); return NS_OK; }
NS_IMETHODIMP JumpListBuilder::AddListToBuild(int16_t aCatType, nsIArray *items, const nsAString &catName, bool *_retval) { nsresult rv; *_retval = false; if (!mJumpListMgr) return NS_ERROR_NOT_AVAILABLE; switch(aCatType) { case nsIJumpListBuilder::JUMPLIST_CATEGORY_TASKS: { NS_ENSURE_ARG_POINTER(items); HRESULT hr; RefPtr<IObjectCollection> collection; hr = CoCreateInstance(CLSID_EnumerableObjectCollection, nullptr, CLSCTX_INPROC_SERVER, IID_IObjectCollection, getter_AddRefs(collection)); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; // Build the list uint32_t length; items->GetLength(&length); for (uint32_t i = 0; i < length; ++i) { nsCOMPtr<nsIJumpListItem> item = do_QueryElementAt(items, i); if (!item) continue; // Check for separators if (IsSeparator(item)) { RefPtr<IShellLinkW> link; rv = JumpListSeparator::GetSeparator(link); if (NS_FAILED(rv)) return rv; collection->AddObject(link); continue; } // These should all be ShellLinks RefPtr<IShellLinkW> link; rv = JumpListShortcut::GetShellLink(item, link, mIOThread); if (NS_FAILED(rv)) return rv; collection->AddObject(link); } // We need IObjectArray to submit RefPtr<IObjectArray> pArray; hr = collection->QueryInterface(IID_IObjectArray, getter_AddRefs(pArray)); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; // Add the tasks hr = mJumpListMgr->AddUserTasks(pArray); if (SUCCEEDED(hr)) *_retval = true; return NS_OK; } break; case nsIJumpListBuilder::JUMPLIST_CATEGORY_RECENT: { if (SUCCEEDED(mJumpListMgr->AppendKnownCategory(KDC_RECENT))) *_retval = true; return NS_OK; } break; case nsIJumpListBuilder::JUMPLIST_CATEGORY_FREQUENT: { if (SUCCEEDED(mJumpListMgr->AppendKnownCategory(KDC_FREQUENT))) *_retval = true; return NS_OK; } break; case nsIJumpListBuilder::JUMPLIST_CATEGORY_CUSTOMLIST: { NS_ENSURE_ARG_POINTER(items); if (catName.IsEmpty()) return NS_ERROR_INVALID_ARG; HRESULT hr; RefPtr<IObjectCollection> collection; hr = CoCreateInstance(CLSID_EnumerableObjectCollection, nullptr, CLSCTX_INPROC_SERVER, IID_IObjectCollection, getter_AddRefs(collection)); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; uint32_t length; items->GetLength(&length); for (uint32_t i = 0; i < length; ++i) { nsCOMPtr<nsIJumpListItem> item = do_QueryElementAt(items, i); if (!item) continue; int16_t type; if (NS_FAILED(item->GetType(&type))) continue; switch(type) { case nsIJumpListItem::JUMPLIST_ITEM_SEPARATOR: { RefPtr<IShellLinkW> shellItem; rv = JumpListSeparator::GetSeparator(shellItem); if (NS_FAILED(rv)) return rv; collection->AddObject(shellItem); } break; case nsIJumpListItem::JUMPLIST_ITEM_LINK: { RefPtr<IShellItem2> shellItem; rv = JumpListLink::GetShellItem(item, shellItem); if (NS_FAILED(rv)) return rv; collection->AddObject(shellItem); } break; case nsIJumpListItem::JUMPLIST_ITEM_SHORTCUT: { RefPtr<IShellLinkW> shellItem; rv = JumpListShortcut::GetShellLink(item, shellItem, mIOThread); if (NS_FAILED(rv)) return rv; collection->AddObject(shellItem); } break; } } // We need IObjectArray to submit RefPtr<IObjectArray> pArray; hr = collection->QueryInterface(IID_IObjectArray, (LPVOID*)&pArray); if (FAILED(hr)) return NS_ERROR_UNEXPECTED; // Add the tasks hr = mJumpListMgr->AppendCategory(reinterpret_cast<const wchar_t*>(catName.BeginReading()), pArray); if (SUCCEEDED(hr)) *_retval = true; // Get rid of the old icons nsCOMPtr<nsIRunnable> event = new mozilla::widget::AsyncDeleteAllFaviconsFromDisk(true); mIOThread->Dispatch(event, NS_DISPATCH_NORMAL); return NS_OK; } break; } return NS_OK; }
NS_IMETHODIMP nsMsgMaildirStore::CopyMessages(bool aIsMove, nsIArray *aHdrArray, nsIMsgFolder *aDstFolder, nsIMsgCopyServiceListener *aListener, nsITransaction **aUndoAction, bool *aCopyDone) { NS_ENSURE_ARG_POINTER(aHdrArray); NS_ENSURE_ARG_POINTER(aDstFolder); NS_ENSURE_ARG_POINTER(aCopyDone); NS_ENSURE_ARG_POINTER(aUndoAction); *aCopyDone = false; nsCOMPtr<nsIMsgFolder> srcFolder; nsresult rv; nsCOMPtr<nsIMsgDBHdr> msgHdr = do_QueryElementAt(aHdrArray, 0, &rv); NS_ENSURE_SUCCESS(rv, rv); rv = msgHdr->GetFolder(getter_AddRefs(srcFolder)); NS_ENSURE_SUCCESS(rv, rv); // Both source and destination folders must use maildir type store. nsCOMPtr<nsIMsgPluggableStore> srcStore; nsAutoCString srcType; srcFolder->GetMsgStore(getter_AddRefs(srcStore)); if (srcStore) srcStore->GetStoreType(srcType); nsCOMPtr<nsIMsgPluggableStore> dstStore; nsAutoCString dstType; aDstFolder->GetMsgStore(getter_AddRefs(dstStore)); if (dstStore) dstStore->GetStoreType(dstType); if (!srcType.EqualsLiteral("maildir") || !dstType.EqualsLiteral("maildir")) return NS_OK; // Both source and destination must be local folders. In theory we could // do efficient copies of the offline store of IMAP, but this is not // supported yet. For that, we need to deal with both correct handling // of deletes from the src server, and msgKey = UIDL in the dst folder. nsCOMPtr<nsIMsgLocalMailFolder> destLocalFolder(do_QueryInterface(aDstFolder)); if (!destLocalFolder) return NS_OK; nsCOMPtr<nsIMsgLocalMailFolder> srcLocalFolder(do_QueryInterface(srcFolder)); if (!srcLocalFolder) return NS_OK; // We should be able to use a file move for an efficient copy. nsCOMPtr<nsIFile> destFolderPath; nsCOMPtr<nsIMsgDatabase> destDB; aDstFolder->GetMsgDatabase(getter_AddRefs(destDB)); rv = aDstFolder->GetFilePath(getter_AddRefs(destFolderPath)); NS_ENSURE_SUCCESS(rv, rv); destFolderPath->Append(NS_LITERAL_STRING("cur")); nsCOMPtr<nsIFile> srcFolderPath; rv = srcFolder->GetFilePath(getter_AddRefs(srcFolderPath)); NS_ENSURE_SUCCESS(rv, rv); srcFolderPath->Append(NS_LITERAL_STRING("cur")); nsCOMPtr<nsIMsgDatabase> srcDB; srcFolder->GetMsgDatabase(getter_AddRefs(srcDB)); nsRefPtr<nsLocalMoveCopyMsgTxn> msgTxn = new nsLocalMoveCopyMsgTxn; NS_ENSURE_TRUE(msgTxn, NS_ERROR_OUT_OF_MEMORY); if (NS_SUCCEEDED(msgTxn->Init(srcFolder, aDstFolder, aIsMove))) { if (aIsMove) msgTxn->SetTransactionType(nsIMessenger::eMoveMsg); else msgTxn->SetTransactionType(nsIMessenger::eCopyMsg); } if (aListener) aListener->OnStartCopy(); nsCOMPtr<nsIMutableArray> dstHdrs(do_CreateInstance(NS_ARRAY_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); uint32_t messageCount; rv = aHdrArray->GetLength(&messageCount); NS_ENSURE_SUCCESS(rv, rv); for (uint32_t i = 0; i < messageCount; i++) { nsCOMPtr<nsIMsgDBHdr> srcHdr = do_QueryElementAt(aHdrArray, i, &rv); if (NS_FAILED(rv)) { PR_LOG(MailDirLog, PR_LOG_ALWAYS, ("srcHdr null\n")); continue; } nsMsgKey srcKey; srcHdr->GetMessageKey(&srcKey); msgTxn->AddSrcKey(srcKey); nsAutoCString fileName; msgHdr->GetStringProperty("storeToken", getter_Copies(fileName)); if (fileName.IsEmpty()) { PR_LOG(MailDirLog, PR_LOG_ALWAYS, ("GetMsgInputStream - empty storeToken!!\n")); return NS_ERROR_FAILURE; } nsCOMPtr<nsIFile> srcFile; rv = srcFolderPath->Clone(getter_AddRefs(srcFile)); NS_ENSURE_SUCCESS(rv, rv); srcFile->AppendNative(fileName); nsCOMPtr<nsIFile> destFile; destFolderPath->Clone(getter_AddRefs(destFile)); destFile->AppendNative(fileName); bool exists; destFile->Exists(&exists); if (exists) { rv = destFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600); NS_ENSURE_SUCCESS(rv, rv); destFile->GetNativeLeafName(fileName); } if (aIsMove) rv = srcFile->MoveToNative(destFolderPath, fileName); else rv = srcFile->CopyToNative(destFolderPath, fileName); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIMsgDBHdr> destHdr; if (destDB) { rv = destDB->CopyHdrFromExistingHdr(nsMsgKey_None, srcHdr, true, getter_AddRefs(destHdr)); NS_ENSURE_SUCCESS(rv, rv); destHdr->SetStringProperty("storeToken", fileName.get()); dstHdrs->AppendElement(destHdr, false); nsMsgKey dstKey; destHdr->GetMessageKey(&dstKey); msgTxn->AddDstKey(dstKey); if (aListener) aListener->SetMessageKey(dstKey); } } nsCOMPtr<nsIMsgFolderNotificationService> notifier(do_GetService(NS_MSGNOTIFICATIONSERVICE_CONTRACTID)); if (notifier) notifier->NotifyMsgsMoveCopyCompleted(aIsMove, aHdrArray, aDstFolder, dstHdrs); // For now, we only support local dest folders, and for those we are done and // can delete the messages. Perhaps this should be moved into the folder // when we try to support other folder types. if (aIsMove) { for (uint32_t i = 0; i < messageCount; ++i) { nsCOMPtr<nsIMsgDBHdr> msgDBHdr(do_QueryElementAt(aHdrArray, i, &rv)); rv = srcDB->DeleteHeader(msgDBHdr, nullptr, false, true); } } *aCopyDone = true; nsCOMPtr<nsISupports> srcSupports(do_QueryInterface(srcFolder)); if (destLocalFolder) destLocalFolder->OnCopyCompleted(srcSupports, true); if (aListener) aListener->OnStopCopy(NS_OK); msgTxn.forget(aUndoAction); return NS_OK; }