/* void setTagForKey (in string key); */
NS_IMETHODIMP nsMsgTagService::SetTagForKey(const nsACString &key, const nsAString &tag )
{
nsCAutoString prefName(key);
ToLowerCase(prefName);
prefName.AppendLiteral(TAG_PREF_SUFFIX_TAG);
return SetUnicharPref(prefName.get(), tag);
}
/* 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;
}
/* void addTag (in wstring tag, in long color); */
NS_IMETHODIMP nsMsgTagService::AddTag(const nsAString &tag,
const nsACString &color,
const nsACString &ordinal)
{
// figure out key from tag. Apply transformation stripping out
// illegal characters like <SP> and then convert to imap mod utf7.
// Then, check if we have a tag with that key yet, and if so,
// make it unique by appending A, AA, etc.
// Should we use an iterator?
nsAutoString transformedTag(tag);
MsgReplaceChar(transformedTag, " ()/{%*<>\\\"", '_');
nsCAutoString key;
CopyUTF16toMUTF7(transformedTag, key);
// We have an imap server that converts keys to upper case so we're going
// to normalize all keys to lower case (upper case looks ugly in prefs.js)
ToLowerCase(key);
nsCAutoString prefName(key);
while (true)
{
nsAutoString tagValue;
nsresult rv = GetTagForKey(prefName, tagValue);
if (NS_FAILED(rv) || tagValue.IsEmpty() || tagValue.Equals(tag))
return AddTagForKey(prefName, tag, color, ordinal);
prefName.Append('A');
}
NS_ASSERTION(false, "can't get here");
return NS_ERROR_FAILURE;
}
nsresult
nsNetscapeProfileMigratorBase::CopyAddressBookDirectories(PBStructArray &aLdapServers,
nsIPrefService* aPrefService)
{
// each server has a pref ending with .filename. The value of that pref
// points to a profile which we need to migrate.
nsAutoString index;
index.AppendInt(nsISuiteProfileMigrator::ADDRESSBOOK_DATA);
NOTIFY_OBSERVERS(MIGRATION_ITEMBEFOREMIGRATE, index.get());
uint32_t count = aLdapServers.Length();
for (uint32_t i = 0; i < count; ++i) {
PrefBranchStruct* pref = aLdapServers.ElementAt(i);
nsDependentCString prefName(pref->prefName);
if (StringEndsWith(prefName, NS_LITERAL_CSTRING(".filename"))) {
CopyFile(pref->stringValue, pref->stringValue);
}
// we don't need to do anything to the fileName pref itself
}
NOTIFY_OBSERVERS(MIGRATION_ITEMAFTERMIGRATE, index.get());
return NS_OK;
}
/* wstring getTagForKey (in string key); */
NS_IMETHODIMP nsMsgTagService::GetTagForKey(const nsACString &key, nsAString &_retval)
{
nsCAutoString prefName(key);
if (!gMigratingKeys)
ToLowerCase(prefName);
prefName.AppendLiteral(TAG_PREF_SUFFIX_TAG);
return GetUnicharPref(prefName.get(), _retval);
}
STDMETHODIMP CPalmSyncImp::nsGetABDeleted(LPTSTR aABName, BOOL *abDeleted)
{
nsCAutoString prefName("ldap_2.servers.");
prefName.Append((const char *)aABName);
prefName.Append(".position");
PRInt32 position = GetIntPref(prefName.get(), -1);
*abDeleted = (position == 0);
return S_OK;
}
/* void deleteTag (in wstring tag); */
NS_IMETHODIMP nsMsgTagService::DeleteKey(const nsACString &key)
{
// clear the associated prefs
nsCAutoString prefName(key);
if (!gMigratingKeys)
ToLowerCase(prefName);
nsresult rv = m_tagPrefBranch->DeleteBranch(prefName.get());
NS_ENSURE_SUCCESS(rv, rv);
return RefreshKeyCache();
}
/* ACString getOrdinalForKey (in ACString key); */
NS_IMETHODIMP nsMsgTagService::GetOrdinalForKey(const nsACString & key, nsACString & _retval)
{
nsCAutoString prefName(key);
if (!gMigratingKeys)
ToLowerCase(prefName);
prefName.AppendLiteral(TAG_PREF_SUFFIX_ORDINAL);
nsCString ordinal;
nsresult rv = m_tagPrefBranch->GetCharPref(prefName.get(), getter_Copies(ordinal));
_retval = ordinal;
return rv;
}
NS_IMETHODIMP
LogModulePrefWatcher::Observe(nsISupports* aSubject, const char* aTopic,
const char16_t* aData)
{
if (strcmp(NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, aTopic) == 0) {
NS_LossyConvertUTF16toASCII prefName(aData);
LoadPrefValue(prefName.get());
}
return NS_OK;
}
/* void setOrdinalForKey (in ACString key, in ACString ordinal); */
NS_IMETHODIMP nsMsgTagService::SetOrdinalForKey(const nsACString & key, const nsACString & ordinal)
{
nsCAutoString prefName(key);
ToLowerCase(prefName);
prefName.AppendLiteral(TAG_PREF_SUFFIX_ORDINAL);
if (ordinal.IsEmpty())
{
m_tagPrefBranch->ClearUserPref(prefName.get());
return NS_OK;
}
return m_tagPrefBranch->SetCharPref(prefName.get(), nsCString(ordinal).get());
}
/* void setColorForKey (in ACString key, in ACString color); */
NS_IMETHODIMP nsMsgTagService::SetColorForKey(const nsACString & key, const nsACString & color)
{
nsCAutoString prefName(key);
ToLowerCase(prefName);
prefName.AppendLiteral(TAG_PREF_SUFFIX_COLOR);
if (color.IsEmpty())
{
m_tagPrefBranch->ClearUserPref(prefName.get());
return NS_OK;
}
return m_tagPrefBranch->SetCharPref(prefName.get(), nsCString(color).get());
}
/* long getColorForKey (in string key); */
NS_IMETHODIMP nsMsgTagService::GetColorForKey(const nsACString &key, nsACString &_retval)
{
nsCAutoString prefName(key);
if (!gMigratingKeys)
ToLowerCase(prefName);
prefName.AppendLiteral(TAG_PREF_SUFFIX_COLOR);
nsCString color;
nsresult rv = m_tagPrefBranch->GetCharPref(prefName.get(), getter_Copies(color));
if (NS_SUCCEEDED(rv))
_retval = color;
return NS_OK;
}
nsresult
nsNetscapeProfileMigratorBase::CopySignatureFiles(PBStructArray &aIdentities,
nsIPrefService* aPrefService)
{
nsresult rv = NS_OK;
uint32_t count = aIdentities.Length();
for (uint32_t i = 0; i < count; ++i)
{
PrefBranchStruct* pref = aIdentities.ElementAt(i);
nsDependentCString prefName(pref->prefName);
// a partial fix for bug #255043
// if the user's signature file from seamonkey lives in the
// old profile root, we'll copy it over to the new profile root and
// then set the pref to the new value. Note, this doesn't work for
// multiple signatures that live below the seamonkey profile root
if (StringEndsWith(prefName, NS_LITERAL_CSTRING(".sig_file")))
{
// turn the pref into a nsIFile
nsCOMPtr<nsIFile> srcSigFile =
do_CreateInstance(NS_LOCAL_FILE_CONTRACTID);
srcSigFile->SetPersistentDescriptor(nsDependentCString(pref->stringValue));
nsCOMPtr<nsIFile> targetSigFile;
rv = mTargetProfile->Clone(getter_AddRefs(targetSigFile));
NS_ENSURE_SUCCESS(rv, rv);
// now make the copy
bool exists;
srcSigFile->Exists(&exists);
if (exists)
{
nsAutoString leafName;
srcSigFile->GetLeafName(leafName);
// will fail if we've already copied a sig file here
srcSigFile->CopyTo(targetSigFile, leafName);
targetSigFile->Append(leafName);
// now write out the new descriptor
nsAutoCString descriptorString;
targetSigFile->GetPersistentDescriptor(descriptorString);
NS_Free(pref->stringValue);
pref->stringValue = ToNewCString(descriptorString);
}
}
}
return NS_OK;
}
nsresult
nsSafariProfileMigrator::SetFontSize(void* aTransform, nsIPrefBranch* aBranch)
{
nsCString associatedLangGroup;
nsresult rv = aBranch->GetCharPref("migration.associatedLangGroup",
getter_Copies(associatedLangGroup));
if (NS_FAILED(rv))
return NS_OK;
PrefTransform* xform = (PrefTransform*)aTransform;
nsCAutoString prefName(xform->targetPrefName);
prefName.Append(associatedLangGroup);
return aBranch->SetIntPref(prefName.get(), xform->intValue);
}
/* void addTagForKey (in string key, in wstring tag, in string color, in string ordinal); */
NS_IMETHODIMP nsMsgTagService::AddTagForKey(const nsACString &key,
const nsAString &tag,
const nsACString &color,
const nsACString &ordinal)
{
nsCAutoString prefName(key);
ToLowerCase(prefName);
prefName.AppendLiteral(TAG_PREF_SUFFIX_TAG);
nsresult rv = SetUnicharPref(prefName.get(), tag);
NS_ENSURE_SUCCESS(rv, rv);
rv = SetColorForKey(key, color);
NS_ENSURE_SUCCESS(rv, rv);
rv = RefreshKeyCache();
NS_ENSURE_SUCCESS(rv, rv);
return SetOrdinalForKey(key, ordinal);
}
NS_IMETHODIMP
Vacuumer::HandleCompletion(PRUint16 aReason)
{
if (aReason == REASON_FINISHED) {
// Update last vacuum time.
PRInt32 now = static_cast<PRInt32>(PR_Now() / PR_USEC_PER_SEC);
NS_ASSERTION(!mDBFilename.IsEmpty(), "Database filename cannot be empty");
nsCAutoString prefName(PREF_VACUUM_BRANCH);
prefName += mDBFilename;
(void)Preferences::SetInt(prefName.get(), now);
}
notifyCompletion(aReason == REASON_FINISHED);
return NS_OK;
}
NS_IMETHODIMP
Vacuumer::HandleCompletion(uint16_t aReason)
{
if (aReason == REASON_FINISHED) {
// Update last vacuum time.
int32_t now = static_cast<int32_t>(PR_Now() / PR_USEC_PER_SEC);
MOZ_ASSERT(!mDBFilename.IsEmpty(), "Database filename cannot be empty");
nsAutoCString prefName(PREF_VACUUM_BRANCH);
prefName += mDBFilename;
DebugOnly<nsresult> rv = Preferences::SetInt(prefName.get(), now);
MOZ_ASSERT(NS_SUCCEEDED(rv), "Should be able to set a preference");
}
notifyCompletion(aReason == REASON_FINISHED);
return NS_OK;
}
NS_IMETHODIMP nsFolderCharsetObserver::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *someData)
{
nsresult rv;
nsCOMPtr<nsIPrefService> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
nsCOMPtr<nsIPrefBranch> prefBranch;
rv = prefs->GetBranch(nsnull, getter_AddRefs(prefBranch));
NS_ENSURE_SUCCESS(rv, rv);
if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID))
{
nsDependentString prefName(someData);
if (prefName.EqualsLiteral(kMAILNEWS_VIEW_DEFAULT_CHARSET))
{
nsCOMPtr<nsIPrefLocalizedString> pls;
rv = prefBranch->GetComplexValue(kMAILNEWS_VIEW_DEFAULT_CHARSET,
NS_GET_IID(nsIPrefLocalizedString), getter_AddRefs(pls));
if (NS_SUCCEEDED(rv))
{
nsString ucsval;
pls->ToString(getter_Copies(ucsval));
if (!ucsval.IsEmpty())
{
if (gDefaultCharacterSet)
CopyUTF16toUTF8(ucsval, *gDefaultCharacterSet);
}
}
}
else if (prefName.EqualsLiteral(kMAILNEWS_DEFAULT_CHARSET_OVERRIDE))
{
rv = prefBranch->GetBoolPref(kMAILNEWS_DEFAULT_CHARSET_OVERRIDE, &gDefaultCharacterOverride);
}
}
else if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID))
{
rv = prefBranch->RemoveObserver(kMAILNEWS_VIEW_DEFAULT_CHARSET, this);
rv = prefBranch->RemoveObserver(kMAILNEWS_DEFAULT_CHARSET_OVERRIDE, this);
NS_IF_RELEASE(gFolderCharsetObserver);
delete gDefaultCharacterSet;
gDefaultCharacterSet = nsnull;
}
return rv;
}
NS_IMETHODIMP
nsMsgAccountManagerDataSource::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *aData)
{
nsMsgRDFDataSource::Observe(aSubject, aTopic, aData);
if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
nsDependentString prefName(aData);
if (prefName.EqualsLiteral(PREF_SHOW_FAKE_ACCOUNT)) {
NotifyObservers(kNC_AccountRoot, kNC_Child, kNC_PageTitleFakeAccount, nsnull, PR_FALSE, PR_FALSE);
NotifyObservers(kNC_AccountRoot, kNC_Settings, kNC_PageTitleFakeAccount, nsnull, PR_FALSE, PR_FALSE);
}
}
else if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
nsCOMPtr<nsIPrefBranch2> prefBranchInternal = do_GetService(NS_PREFSERVICE_CONTRACTID);
if (prefBranchInternal)
prefBranchInternal->RemoveObserver(PREF_SHOW_FAKE_ACCOUNT, this);
}
return NS_OK;
}
nsresult
nsNetscapeProfileMigratorBase::CopyMailFolderPrefs(PBStructArray &aMailServers,
nsIPrefService* aPrefService)
{
// Each server has a .directory pref which points to the location of the
// mail data for that server. We need to do two things for that case...
// (1) Fix up the directory path for the new profile
// (2) copy the mail folder data from the source directory pref to the
// destination directory pref
CopyFile(FILE_NAME_VIRTUALFOLDERS, FILE_NAME_VIRTUALFOLDERS);
int32_t count = aMailServers.Length();
for (int32_t i = 0; i < count; ++i) {
PrefBranchStruct* pref = aMailServers.ElementAt(i);
nsDependentCString prefName(pref->prefName);
if (StringEndsWith(prefName, NS_LITERAL_CSTRING(".directory"))) {
// let's try to get a branch for this particular server to simplify things
prefName.Cut(prefName.Length() - strlen("directory"),
strlen("directory"));
prefName.Insert("mail.server.", 0);
nsCOMPtr<nsIPrefBranch> serverBranch;
aPrefService->GetBranch(prefName.get(), getter_AddRefs(serverBranch));
if (!serverBranch)
break; // should we clear out this server pref from aMailServers?
nsCString serverType;
serverBranch->GetCharPref("type", getter_Copies(serverType));
nsCOMPtr<nsIFile> sourceMailFolder;
nsresult rv = GetFileValue(serverBranch, "directory-rel", "directory",
getter_AddRefs(sourceMailFolder));
NS_ENSURE_SUCCESS(rv, rv);
// now based on type, we need to build a new destination path for the
// mail folders for this server
nsCOMPtr<nsIFile> targetMailFolder;
if (serverType.Equals("imap")) {
mTargetProfile->Clone(getter_AddRefs(targetMailFolder));
targetMailFolder->Append(IMAP_MAIL_DIR_50_NAME);
}
else if (serverType.Equals("none") || serverType.Equals("pop3") ||
serverType.Equals("movemail")) {
// local folders and POP3 servers go under <profile>\Mail
mTargetProfile->Clone(getter_AddRefs(targetMailFolder));
targetMailFolder->Append(MAIL_DIR_50_NAME);
}
else if (serverType.Equals("nntp")) {
mTargetProfile->Clone(getter_AddRefs(targetMailFolder));
targetMailFolder->Append(NEWS_DIR_50_NAME);
}
if (targetMailFolder) {
// for all of our server types, append the host name to the directory
// as part of the new location
nsCString hostName;
serverBranch->GetCharPref("hostname", getter_Copies(hostName));
targetMailFolder->Append(NS_ConvertASCIItoUTF16(hostName));
// we should make sure the host name based directory we are going to
// migrate the accounts into is unique. This protects against the
// case where the user has multiple servers with the same host name.
targetMailFolder->CreateUnique(nsIFile::DIRECTORY_TYPE, 0777);
RecursiveCopy(sourceMailFolder, targetMailFolder);
// now we want to make sure the actual directory pref that gets
// transformed into the new profile's pref.js has the right file
// location.
nsAutoCString descriptorString;
targetMailFolder->GetPersistentDescriptor(descriptorString);
NS_Free(pref->stringValue);
pref->stringValue = ToNewCString(descriptorString);
}
}
else if (StringEndsWith(prefName, NS_LITERAL_CSTRING(".newsrc.file"))) {
// copy the news RC file into \News. this won't work if the user has
// different newsrc files for each account I don't know what to do in
// that situation.
nsCOMPtr<nsIFile> targetNewsRCFile;
mTargetProfile->Clone(getter_AddRefs(targetNewsRCFile));
targetNewsRCFile->Append(NEWS_DIR_50_NAME);
// turn the pref into a nsIFile
nsCOMPtr<nsIFile> srcNewsRCFile =
do_CreateInstance(NS_LOCAL_FILE_CONTRACTID);
srcNewsRCFile->SetPersistentDescriptor(
nsDependentCString(pref->stringValue));
// now make the copy
bool exists;
srcNewsRCFile->Exists(&exists);
if (exists) {
nsAutoString leafName;
srcNewsRCFile->GetLeafName(leafName);
// will fail if we've already copied a newsrc file here
srcNewsRCFile->CopyTo(targetNewsRCFile,leafName);
targetNewsRCFile->Append(leafName);
// now write out the new descriptor
nsAutoCString descriptorString;
targetNewsRCFile->GetPersistentDescriptor(descriptorString);
NS_Free(pref->stringValue);
pref->stringValue = ToNewCString(descriptorString);
}
}
}
// Remove all .directory-rel prefs as those might have changed; MailNews
// will create those prefs again on first use
for (int32_t i = count; i-- > 0; ) {
PrefBranchStruct* pref = aMailServers.ElementAt(i);
nsDependentCString prefName(pref->prefName);
if (StringEndsWith(prefName, NS_LITERAL_CSTRING(".directory-rel"))) {
if (pref->type == nsIPrefBranch::PREF_STRING)
NS_Free(pref->stringValue);
aMailServers.RemoveElementAt(i);
}
}
return NS_OK;
}
NS_IMETHODIMP nsAbMDBDirectory::Init(const char *aUri)
{
// We need to ensure that the m_DirPrefId is initialized properly
nsDependentCString uri(aUri);
if (uri.Find("MailList") != -1)
m_IsMailList = true;
// Mailing lists don't have their own prefs.
if (m_DirPrefId.IsEmpty() && !m_IsMailList)
{
// Find the first ? (of the search params) if there is one.
// We know we can start at the end of the moz-abmdbdirectory:// because
// that's the URI we should have been passed.
int32_t searchCharLocation = uri.FindChar('?', kMDBDirectoryRootLen);
nsAutoCString filename;
// extract the filename from the uri.
if (searchCharLocation == -1)
filename = Substring(uri, kMDBDirectoryRootLen);
else
filename = Substring(uri, kMDBDirectoryRootLen, searchCharLocation - kMDBDirectoryRootLen);
// Get the pref servers and the address book directory branch
nsresult rv;
nsCOMPtr<nsIPrefService> prefService(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIPrefBranch> prefBranch;
rv = prefService->GetBranch(NS_LITERAL_CSTRING(PREF_LDAP_SERVER_TREE_NAME ".").get(),
getter_AddRefs(prefBranch));
NS_ENSURE_SUCCESS(rv, rv);
char** childArray;
uint32_t childCount, i;
int32_t dotOffset;
nsCString childValue;
nsDependentCString child;
rv = prefBranch->GetChildList("", &childCount, &childArray);
NS_ENSURE_SUCCESS(rv, rv);
for (i = 0; i < childCount; ++i)
{
child.Assign(childArray[i]);
if (StringEndsWith(child, NS_LITERAL_CSTRING(".filename")))
{
if (NS_SUCCEEDED(prefBranch->GetCharPref(child.get(),
getter_Copies(childValue))))
{
if (childValue == filename)
{
dotOffset = child.RFindChar('.');
if (dotOffset != -1)
{
nsAutoCString prefName(StringHead(child, dotOffset));
m_DirPrefId.AssignLiteral(PREF_LDAP_SERVER_TREE_NAME ".");
m_DirPrefId.Append(prefName);
}
}
}
}
}
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(childCount, childArray);
NS_ASSERTION(!m_DirPrefId.IsEmpty(),
"Error, Could not set m_DirPrefId in nsAbMDBDirectory::Init");
}
return nsAbDirProperty::Init(aUri);
}
