wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-29 03:47:31 +09:00
Code Issues Projects Releases Packages Wiki Activity

Issue #1258 - Part 1: Import mailnews, ldap, and mork from comm-esr52.9.1

Browse source
This commit is contained in:
Matt A. Tobin 2019-11-03 00:17:46 -04:00 • committed by Roy Tam
commit e400f4130a
1564 changed files with 510348 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

32
mailnews/imap/public/moz.build Normal file
View file

@ -0,0 +1,32 @@
# vim: set filetype=python:
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
XPIDL_SOURCES += [
'nsIAutoSyncFolderStrategy.idl',
'nsIAutoSyncManager.idl',
'nsIAutoSyncMsgStrategy.idl',
'nsIAutoSyncState.idl',
'nsIImapFlagAndUidState.idl',
'nsIImapHeaderXferInfo.idl',
'nsIImapIncomingServer.idl',
'nsIImapMailFolderSink.idl',
'nsIImapMessageSink.idl',
'nsIImapMockChannel.idl',
'nsIImapProtocol.idl',
'nsIImapProtocolSink.idl',
'nsIImapServerSink.idl',
'nsIImapService.idl',
'nsIImapUrl.idl',
'nsIMailboxSpec.idl',
'nsIMsgImapMailFolder.idl',
]
XPIDL_MODULE = 'msgimap'
EXPORTS += [
'nsIIMAPHostSessionList.h',
'nsMsgImapCID.h',
]

23
mailnews/imap/public/nsIAutoSyncFolderStrategy.idl Normal file
View file

@ -0,0 +1,23 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
#include "nsIAutoSyncMsgStrategy.idl"
interface nsIMsgAccount;
[scriptable, uuid(d3bf91cc-37bb-4752-9994-1a8473e46a90)]
interface nsIAutoSyncFolderStrategy : nsISupports {
/**
* Returns a relative-priority for the second folder by comparing with the first one.
*/
nsAutoSyncStrategyDecisionType sort(in nsIMsgFolder aFolder1, in nsIMsgFolder aFolder2);
/**
* Tests whether the given folder should be excluded or not.
*/
boolean isExcluded(in nsIMsgFolder aFolder);
};

194
mailnews/imap/public/nsIAutoSyncManager.idl Normal file
View file

@ -0,0 +1,194 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
interface nsIAutoSyncMsgStrategy;
interface nsIAutoSyncFolderStrategy;
interface nsIMsgDBHdr;
interface nsIAutoSyncState;
interface nsIAutoSyncMgrListener;
interface nsIMsgFolder;
interface nsIMsgAccount;
[scriptable, uuid(41ec36a7-1a53-4ca3-b698-dca6452a8761)]
interface nsIAutoSyncMgrListener : nsISupports {
/**
* Queue types
*/
const long PriorityQueue = 1;
const long UpdateQueue = 2;
const long DiscoveryQueue = 3;
/**
* It is called on the listener when a new folder is added into
* the queue
*
* @param aQType type of the queue
* @param aFolder folder that is added into the queue
*/
void onFolderAddedIntoQ(in long aQType, in nsIMsgFolder aFolder);
/**
* It is called on the listener when a folder is removed from
* the queue
*
* @param aQType type of the queue
* @param aFolder folder that is removed from the queue
*/
void onFolderRemovedFromQ(in long aQType, in nsIMsgFolder aFolder);
/**
* It is called on the listener when a message download is successfully started
*
* @param aFolder folder in which the download is started
* @param aNumberOfMessages number of the messages that will be downloaded
* @param aTotalPending total number of messages waiting to be downloaded
*/
void onDownloadStarted(in nsIMsgFolder aFolder, in unsigned long aNumberOfMessages,
in unsigned long aTotalPending);
/**
* It is called on the listener when a message download on the given folder
* is completed
*/
void onDownloadCompleted(in nsIMsgFolder aFolder);
/**
* It is called on the listener when an error occurs during the message download
*/
void onDownloadError(in nsIMsgFolder aFolder);
/*
* Auto-Sync manager is running or waiting for idle
*/
void onStateChanged(in boolean aRunning);
/**
* It is called on the listener after the auto-sync manager starts to process
* existing headers of the given folder to find missing message bodies
* (mostly for debugging purposes)
*/
void onDiscoveryQProcessed(in nsIMsgFolder aFolder, in unsigned long aNumberOfHdrsProcessed,
in unsigned long aLeftToProcess);
/**
* It is called on the listener after the auto-sync manager updates the given folder
* (mostly for debugging purposes)
*/
void onAutoSyncInitiated(in nsIMsgFolder aFolder);
};
[scriptable, uuid(7fe0b48e-f5d8-4747-beb7-888c9cced3a5)]
interface nsIAutoSyncManager : nsISupports {
/**
* Download models
*/
const long dmParallel = 0;
const long dmChained = 1;
/**
* Suggested minimum grouping size in bytes for message downloads.
* Setting this attribute to 0 resets its value to the
* hardcoded default.
*/
attribute unsigned long groupSize;
/**
* Active strategy function to prioritize
* messages in the download queue
*/
attribute nsIAutoSyncMsgStrategy msgStrategy;
/**
* Active strategy function to prioritize
* folders in the download queue
*/
attribute nsIAutoSyncFolderStrategy folderStrategy;
/**
* Adds a listener to notify about auto-sync events
*/
void addListener(in nsIAutoSyncMgrListener aListener);
/**
* Removes the listener from notification list
*/
void removeListener(in nsIAutoSyncMgrListener aListener);
/**
* Tests the given message to make sure that whether
* it fits the download criteria or not
*/
boolean doesMsgFitDownloadCriteria(in nsIMsgDBHdr aMsgHdr);
/**
* Called by the nsAutoSyncState object when the download
* queue is changed. Given interface is already addref'd.
*/
void onDownloadQChanged(in nsIAutoSyncState aAutoSyncStateObj);
/**
* Called by the nsAutoSyncState object when the download
* is started. Given interface is already addref'd.
*/
void onDownloadStarted(in nsIAutoSyncState aAutoSyncStateObj, in nsresult aStartCode);
/**
* Called by the nsAutoSyncState object when the download
* completed. Given interface is already addref'd.
*/
void onDownloadCompleted(in nsIAutoSyncState aAutoSyncStateObj, in nsresult aExitCode);
/**
* Number of elements in the discovery queue.
* @see nsAutoSyncManager.h for details
*/
readonly attribute unsigned long discoveryQLength;
/**
* Number of elements in the update queue.
* @see nsAutoSyncManager.h for details
*/
readonly attribute unsigned long updateQLength;
/**
* Number of elements in the download queue (a.k.a priority queue).
* @see nsAutoSyncManager.h for details
*/
readonly attribute unsigned long downloadQLength;
/**
* Active download model; Chained (serial), or Parallel
*/
attribute long downloadModel;
/**
* The imap folder corresponding to aAutoSyncState has had a message
* added to it. Autosync may want to add this folder to the update q.
*
* @param aAutoSyncState state obj for folder needing updating
*/
void onFolderHasPendingMsgs(in nsIAutoSyncState aAutoSyncState);
/// Pause autosync (e.g., we're downloading for offline).
void pause();
/// Resume normal autosync activities (e.g., we've come back online).
void resume();
};
%{C++
#define NS_AUTOSYNCMANAGER_CID \
{ /* C358C568-47B2-42b2-8146-3C0F8D1FAD6E */ \
0xc358c568, 0x47b2, 0x42b2, \
{ 0x81, 0x46, 0x3c, 0xf, 0x8d, 0x1f, 0xad, 0x6e }}
#define NS_AUTOSYNCMANAGER_CLASSNAME \
"Auto-Sync Manager"
#define NS_AUTOSYNCMANAGER_CONTRACTID \
"@mozilla.org/imap/autosyncmgr;1"
%}

35
mailnews/imap/public/nsIAutoSyncMsgStrategy.idl Normal file
View file

@ -0,0 +1,35 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
interface nsIMsgFolder;
interface nsIMsgDBHdr;
typedef long nsAutoSyncStrategyDecisionType;
[scriptable,uuid(0365bec5-3753-43c2-b13e-441747815f37)]
interface nsAutoSyncStrategyDecisions
{
/// same priority
const nsAutoSyncStrategyDecisionType Same = 0x00000001;
/// higher priority
const nsAutoSyncStrategyDecisionType Higher = 0x00000002;
/// lower priority
const nsAutoSyncStrategyDecisionType Lower = 0x00000004;
};
[scriptable, uuid(9cb4baff-3112-4cf8-8463-f81b0aa78f93)]
interface nsIAutoSyncMsgStrategy : nsISupports {
/**
* Returns a relative-priority for the second message by comparing with the first message.
*/
nsAutoSyncStrategyDecisionType sort(in nsIMsgFolder aFolder, in nsIMsgDBHdr aMsgHdr1, in nsIMsgDBHdr aMsgHdr2);
/**
* Tests whether the given message should be excluded or not.
*/
boolean isExcluded(in nsIMsgFolder aFolder, in nsIMsgDBHdr aMsgHdr);
};

130
mailnews/imap/public/nsIAutoSyncState.idl Normal file
View file

@ -0,0 +1,130 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
interface nsIMsgFolder;
interface nsIArray;
interface nsIMutableArray;
[scriptable, uuid(7512f927-b8f0-48c4-b101-03e859e61281)]
interface nsIAutoSyncState : nsISupports {
/**
* Auto-Sync states.
*
* ***WARNING***: If you change these, be sure to update stateStrings in
* nsAutoSyncState.cpp. If you do not, out-of-bounds memory accesses may
* happen.
*/
/** sync'd and no pending messages */
const long stCompletedIdle = 0;
/** STATUS issued. Will check to see if any counts changed since last STATUS */
const long stStatusIssued = 1;
/**
* Status found new messages. Update should be issued next. Status most
* likely was issued by non-autosync code (e.g., check other folders for
* new messages).
*/
const long stUpdateNeeded = 2;
/** Update issued. Will figure out if there are any bodies to download */
const long stUpdateIssued = 3;
/** Message body download in progress */
const long stDownloadInProgress = 4;
/** ready to download the next group of messages */
const long stReadyToDownload = 5;
/**
* Puts the download queue offset to its previous position.
*/
void rollback();
/**
* Clears the download queue. Resets the offsets.
*/
void resetDownloadQ();
/**
* Rollbacks the offset to the previous position and
* changes the state to ready-to-download.
*/
void tryCurrentGroupAgain(in unsigned long aRetryCount);
/**
* Resets the retry counter.
*/
void resetRetryCounter();
/**
* Tests whether the given folder has the same imap server.
*/
boolean isSibling(in nsIAutoSyncState aAnotherStateObj);
/**
* Update the folder to find new message headers to download
*/
void updateFolder();
/**
* Downloads the bodies of the given messages from the server.
*/
void downloadMessagesForOffline(in nsIArray aMessageList);
/**
* Populates the given array with the keys of the messages that will
* be downloaded next.
*
* @param aSuggestedGroupSizeLimit suggested size per group in bytes
* @param aActualGroupSize total size of the messages in bytes in the group
*/
nsIMutableArray getNextGroupOfMessages(in unsigned long aSuggestedGroupSizeLimit,
out unsigned long aActualGroupSize);
/**
* Iterates through the existing headers of the folder to find
* the messages not downloaded yet.
*
* @param aNumberOfHeadersToProcess number of headers to be processed
* at this pass
*
* @return the number of headers left to process
*/
unsigned long processExistingHeaders(in unsigned long aNumberOfHeadersToProcess);
/**
* Last time the existing headers are completely processed.
*/
[noscript]readonly attribute PRTime lastSyncTime;
/**
* Last time the owner folder is updated.
*/
[noscript]attribute PRTime lastUpdateTime;
/**
* Download operation state.
*/
attribute long state;
/**
* Number of messages waiting to be downloaded.
*/
readonly attribute long pendingMessageCount;
/**
* Total number of messages in the download queue.
*/
readonly attribute long totalMessageCount;
/**
* The folder this auto-sync object is related to.
*/
readonly attribute nsIMsgFolder ownerFolder;
};

100
mailnews/imap/public/nsIIMAPHostSessionList.h Normal file
View file

@ -0,0 +1,100 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef _nsIImapHostSessionList_H_
#define _nsIImapHostSessionList_H_
#include "nsISupports.h"
#include "nsImapCore.h"
class nsIMAPBodyShellCache;
class nsIMAPBodyShell;
class nsIImapIncomingServer;
// f4d89e3e-77da-492c-962b-7835f0742c22
#define NS_IIMAPHOSTSESSIONLIST_IID \
{ 0xf4d89e3e, 0x77da, 0x492c, {0x96, 0x2b, 0x78, 0x35, 0xf0, 0x74, 0x2c, 0x22 } }
// this is an interface to a linked list of host info's
class nsIImapHostSessionList : public nsISupports
{
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IIMAPHOSTSESSIONLIST_IID)
// Host List
NS_IMETHOD AddHostToList(const char *serverKey, nsIImapIncomingServer *server) = 0;
NS_IMETHOD ResetAll() = 0;
// Capabilities
NS_IMETHOD GetHostHasAdminURL(const char *serverKey, bool &result) = 0;
NS_IMETHOD SetHostHasAdminURL(const char *serverKey, bool hasAdminUrl) = 0;
// Subscription
NS_IMETHOD GetHostIsUsingSubscription(const char *serverKey, bool &result) = 0;
NS_IMETHOD SetHostIsUsingSubscription(const char *serverKey, bool usingSubscription) = 0;
// Passwords
NS_IMETHOD GetPasswordForHost(const char *serverKey, nsString &result) = 0;
NS_IMETHOD SetPasswordForHost(const char *serverKey, const char *password) = 0;
NS_IMETHOD GetPasswordVerifiedOnline(const char *serverKey, bool &result) = 0;
NS_IMETHOD SetPasswordVerifiedOnline(const char *serverKey) = 0;
// OnlineDir
NS_IMETHOD GetOnlineDirForHost(const char *serverKey,
nsString &result) = 0;
NS_IMETHOD SetOnlineDirForHost(const char *serverKey,
const char *onlineDir) = 0;
// Delete is move to trash folder
NS_IMETHOD GetDeleteIsMoveToTrashForHost(const char *serverKey, bool &result) = 0;
NS_IMETHOD SetDeleteIsMoveToTrashForHost(const char *serverKey, bool isMoveToTrash) = 0;
NS_IMETHOD GetShowDeletedMessagesForHost(const char *serverKey, bool &result) = 0;
NS_IMETHOD SetShowDeletedMessagesForHost(const char *serverKey, bool showDeletedMessages) = 0;
// Get namespaces
NS_IMETHOD GetGotNamespacesForHost(const char *serverKey, bool &result) = 0;
NS_IMETHOD SetGotNamespacesForHost(const char *serverKey, bool gotNamespaces) = 0;
// Folders
NS_IMETHOD SetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool discovered) = 0;
NS_IMETHOD GetHaveWeEverDiscoveredFoldersForHost(const char *serverKey, bool &result) = 0;
// Trash Folder
NS_IMETHOD SetOnlineTrashFolderExistsForHost(const char *serverKey, bool exists) = 0;
NS_IMETHOD GetOnlineTrashFolderExistsForHost(const char *serverKey, bool &result) = 0;
// INBOX
NS_IMETHOD GetOnlineInboxPathForHost(const char *serverKey, nsString &result) = 0;
NS_IMETHOD GetShouldAlwaysListInboxForHost(const char *serverKey, bool &result) = 0;
NS_IMETHOD SetShouldAlwaysListInboxForHost(const char *serverKey, bool shouldList) = 0;
// Namespaces
NS_IMETHOD GetNamespaceForMailboxForHost(const char *serverKey, const char *mailbox_name, nsIMAPNamespace * & result) = 0;
NS_IMETHOD SetNamespaceFromPrefForHost(const char *serverKey, const char *namespacePref, EIMAPNamespaceType type) = 0;
NS_IMETHOD AddNewNamespaceForHost(const char *serverKey, nsIMAPNamespace *ns) = 0;
NS_IMETHOD ClearServerAdvertisedNamespacesForHost(const char *serverKey) = 0;
NS_IMETHOD ClearPrefsNamespacesForHost(const char *serverKey) = 0;
NS_IMETHOD GetDefaultNamespaceOfTypeForHost(const char *serverKey, EIMAPNamespaceType type, nsIMAPNamespace * & result) = 0;
NS_IMETHOD SetNamespacesOverridableForHost(const char *serverKey, bool overridable) = 0;
NS_IMETHOD GetNamespacesOverridableForHost(const char *serverKey,bool &result) = 0;
NS_IMETHOD GetNumberOfNamespacesForHost(const char *serverKey, uint32_t &result) = 0;
NS_IMETHOD GetNamespaceNumberForHost(const char *serverKey, int32_t n, nsIMAPNamespace * &result) = 0;
// ### dmb hoo boy, how are we going to do this?
NS_IMETHOD CommitNamespacesForHost(nsIImapIncomingServer *server) = 0;
NS_IMETHOD FlushUncommittedNamespacesForHost(const char *serverKey, bool &result) = 0;
// Hierarchy Delimiters
NS_IMETHOD SetNamespaceHierarchyDelimiterFromMailboxForHost(const char *serverKey, const char *boxName, char delimiter) = 0;
// Message Body Shells
NS_IMETHOD AddShellToCacheForHost(const char *serverKey, nsIMAPBodyShell *shell) = 0;
NS_IMETHOD FindShellInCacheForHost(const char *serverKey, const char *mailboxName, const char *UID, IMAP_ContentModifiedType modType, nsIMAPBodyShell **result) = 0;
NS_IMETHOD ClearShellCacheForHost(const char *serverKey) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIImapHostSessionList,
NS_IIMAPHOSTSESSIONLIST_IID)
#endif

74
mailnews/imap/public/nsIImapFlagAndUidState.idl Normal file
View file

@ -0,0 +1,74 @@
/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
[scriptable, uuid(290412eb-5824-4087-8984-05450c9397be)]
interface nsIImapFlagAndUidState : nsISupports
{
readonly attribute long numberOfMessages;
readonly attribute long numberOfRecentMessages;
/**
* If a full update, the total number of deleted messages
* in the folder; if a partial update, the number of deleted
* messages in the partial update
**/
readonly attribute long numberOfDeletedMessages;
/**
* If this is true, instead of fetching 1:* (FLAGS), and putting all
* UIDs and flags in the array, we only fetched the uids and flags
* that changed since the last time we were selected on this folder.
* This means we have a sparse array, and should not assume missing
* UIDs have been deleted.
**/
readonly attribute boolean partialUIDFetch;
/**
* Set of flags the server supports storing per message. See nsImapCore.h
* for the set of flags.
*/
readonly attribute unsigned short supportedUserFlags;
/**
* OR's the passed in flags with the previous flags because we want to
* accumulate the FLAGS and PERMANENTFLAGS response.
*
* @param aFlags - flags to OR with current flags.
*/
void orSupportedUserFlags(in unsigned short aFlags);
void getUidOfMessage(in long zeroBasedIndex, out unsigned long result);
void getMessageFlags(in long zeroBasedIndex, out unsigned short result);
void setMessageFlags(in long zeroBasedIndex, in unsigned short flags);
void expungeByIndex(in unsigned long zeroBasedIndex);
void addUidFlagPair(in unsigned long uid, in unsigned short flags, in unsigned long zeroBasedIndex);
void addUidCustomFlagPair(in unsigned long uid, in string customFlag);
string getCustomFlags(in unsigned long uid); // returns space-separated keywords
void reset();
void clearCustomFlags(in unsigned long uid);
/**
* Adds custom attributes to a hash table for the purpose of storing them
* them.
* @param aUid UID of the associated msg
* @param aCustomAttributeName Name of the custom attribute value
* @param aCustomAttributeValue Value of the attribute,
*/
void setCustomAttribute(in unsigned long aUid,
in ACString aCustomAttributeName,
in ACString aCustomAttributeValue);
/**
* Gets the custom attributes from the hash table where they were stored earlier
* them.
* @param aUid UID of the associated msg
* @param aCustomAttributeName Name of the custom attribute value
* @param aCustomAttributeValue Value of the attribute,
*/
ACString getCustomAttribute(in unsigned long aUid,
in ACString aCustomAttributeName);
};

23
mailnews/imap/public/nsIImapHeaderXferInfo.idl Normal file
View file

@ -0,0 +1,23 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
#include "MailNewsTypes2.idl"
[scriptable, uuid(38f8f784-b092-11d6-ba4b-00108335942a)]
interface nsIImapHeaderInfo : nsISupports {
attribute nsMsgKey msgUid;
attribute long msgSize;
[noscript] void getMsgHdrs ([shared] out string aMsgHdrs); // this doesn't copy the msgHdrs
void cacheLine(in string line, in unsigned long uid);
void resetCache();
};
[scriptable, uuid(f0842eda-af29-4ecd-82e1-fba91bd65d66)]
interface nsIImapHeaderXferInfo : nsISupports {
readonly attribute long numHeaders;
nsIImapHeaderInfo getHeader(in long hdrIndex);
};

105
mailnews/imap/public/nsIImapIncomingServer.idl Normal file
View file

@ -0,0 +1,105 @@
/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
interface nsIURI;
interface nsIImapUrl;
interface nsIImapProtocol;
interface nsIMsgFolder;
interface nsIMsgWindow;
typedef long nsMsgImapDeleteModel;
[scriptable, uuid(bbfc33de-fe89-11d3-a564-0060b0fc04b7)]
interface nsMsgImapDeleteModels
{
const long IMAPDelete = 0; /* delete with a big red x */
const long MoveToTrash = 1; /* delete moves message to the trash */
const long DeleteNoTrash = 2; /* delete is shift delete - don't create or use trash */
};
[scriptable, uuid(ea6a0765-07b8-40df-924c-9004ed707251)]
interface nsIImapIncomingServer : nsISupports {
attribute long maximumConnectionsNumber;
attribute ACString forceSelect;
attribute long timeOutLimits;
attribute ACString adminUrl;
attribute ACString serverDirectory;
/// RFC 2971 ID response stored as a pref
attribute ACString serverIDPref;
attribute boolean cleanupInboxOnExit;
attribute nsMsgImapDeleteModel deleteModel;
attribute boolean dualUseFolders;
attribute long emptyTrashThreshhold;
attribute ACString personalNamespace;
attribute ACString publicNamespace;
attribute ACString otherUsersNamespace;
attribute boolean offlineDownload;
attribute boolean overrideNamespaces;
attribute boolean usingSubscription;
attribute ACString manageMailAccountUrl;
attribute boolean fetchByChunks;
attribute boolean mimePartsOnDemand;
attribute boolean sendID;
attribute boolean isAOLServer;
attribute boolean capabilityACL;
attribute boolean capabilityQuota;
attribute boolean useIdle;
attribute boolean checkAllFoldersForNew;
/// Is this a GMail Server?
attribute boolean isGMailServer;
/**
* See IMAP RFC 4551
**/
attribute boolean useCondStore;
/**
* See IMAP RFC 4978
*/
attribute boolean useCompressDeflate;
attribute AString trashFolderName;
attribute boolean downloadBodiesOnGetNewMail;
attribute boolean autoSyncOfflineStores;
/// Max age of messages we will autosync to, or keep in offline store.
attribute long autoSyncMaxAgeDays;
void GetImapConnectionAndLoadUrl(in nsIImapUrl aImapUrl,
in nsISupports aConsumer);
void RemoveConnection(in nsIImapProtocol aImapConnection);
void ResetNamespaceReferences();
void pseudoInterruptMsgLoad(in nsIMsgFolder aImapFolder, in nsIMsgWindow aMsgWindow, out boolean interrupted);
void ResetConnection(in ACString folderName);
void CloseConnectionForFolder(in nsIMsgFolder aMsgFolder);
void reDiscoverAllFolders();
nsIURI subscribeToFolder(in AString name, in boolean subscribe);
void GetNewMessagesForNonInboxFolders(in nsIMsgFolder aRootFolder,
in nsIMsgWindow aWindow,
in boolean forceAllFolders,
in boolean performingBiff);
/**
* Get the password from the nsIMsgIncomingServer. May prompt the user
* if there's no password in the password manager or cached in the
* server object.
* @param aWindow msgWindow to associate the password prompt with
* @return Password string.
* @exception NS_ERROR_FAILURE The password could not be obtained.
* @note NS_MSG_PASSWORD_PROMPT_CANCELLED is a success code that is returned
* if the prompt was presented to the user but the user cancelled the
* prompt.
*/
ACString PromptPassword(in nsIMsgWindow aWindow);
attribute boolean doingLsub;
ACString getUriWithNamespacePrefixIfNecessary(in long namespaceType, in ACString originalUri);
attribute boolean shuttingDown;
};

103
mailnews/imap/public/nsIImapMailFolderSink.idl Normal file
View file

@ -0,0 +1,103 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
#include "MailNewsTypes2.idl"
#include "nsIImapProtocol.idl"
#include "nsIMailboxSpec.idl"
interface nsIMsgMailNewsUrl;
interface nsIImapMockChannel;
interface nsIImapHeaderXferInfo;
typedef long ImapOnlineCopyState;
[scriptable, uuid(5f7484b0-68b4-11d3-a53e-0060b0fc04b7)]
interface ImapOnlineCopyStateType
{
const long kInProgress = 0;
const long kSuccessfulCopy = 1;
const long kSuccessfulMove = 2;
const long kSuccessfulDelete = 3;
const long kFailedDelete = 4;
const long kReadyForAppendData = 5;
const long kFailedAppend = 6;
const long kInterruptedState = 7;
const long kFailedCopy = 8;
const long kFailedMove = 9;
};
[scriptable, uuid(525e1278-a39d-46d6-9dbc-b48c7e1d4faa)]
interface nsIImapMailFolderSink : nsISupports {
attribute boolean folderNeedsACLListed;
attribute boolean folderNeedsSubscribing;
attribute boolean folderNeedsAdded;
attribute unsigned long aclFlags;
attribute long uidValidity;
/**
* Whether we have asked the server for this folder's quota information.
* If the server supports quotas, this occurs when the folder is opened.
*/
attribute boolean folderQuotaCommandIssued;
/**
* Set FolderQuotaData information
* @param aFolderQuotaRoot The IMAP quota root for this folder,
* as returned by the GETQUOTAROOT IMAP command.
* @param aFolderQuotaUsedKB Used space, in KB, on this folder's quota root.
* @param aFolderQuotaMaxKB Size, in KB, of this folder's quota root.
**/
void setFolderQuotaData(in ACString aFolderQuotaRoot, in unsigned long aFolderQuotaUsedKB,
in unsigned long aFolderQuotaMaxKB);
/// Should we download all the rfc822 headers of messages, instead of subset.
readonly attribute boolean shouldDownloadAllHeaders;
readonly attribute char onlineDelimiter;
void OnNewIdleMessages();
// Tell mail master about the newly selected mailbox
void UpdateImapMailboxInfo(in nsIImapProtocol aProtocol,
in nsIMailboxSpec aSpec);
void UpdateImapMailboxStatus(in nsIImapProtocol aProtocol,
in nsIMailboxSpec aSpec);
/**
* Used when downloading headers in chunks.
* @param aSpec Mailbox spec of folder we're downloading headers for.
* @returns true if more to download, false otherwise.
* @returns total count of headers to download (across all chunks)
* @returns an array of msg keys to download, array size is this chunk's size
*/
void getMsgHdrsToDownload(out boolean aMore, out long aTotalCount,
out unsigned long aCount,
[retval, array, size_is(aCount)] out nsMsgKey aKeys);
void parseMsgHdrs(in nsIImapProtocol aProtocol, in nsIImapHeaderXferInfo aHdrXferInfo);
void AbortHeaderParseStream(in nsIImapProtocol aProtocol) ;
void OnlineCopyCompleted(in nsIImapProtocol aProtocol, in ImapOnlineCopyState aCopyState);
void StartMessage(in nsIMsgMailNewsUrl aUrl);
void EndMessage(in nsIMsgMailNewsUrl aUrl, in nsMsgKey uidOfMessage);
void NotifySearchHit(in nsIMsgMailNewsUrl aUrl, in string hitLine);
void copyNextStreamMessage(in boolean copySucceeded, in nsISupports copyState);
void closeMockChannel(in nsIImapMockChannel aChannel);
void setUrlState(in nsIImapProtocol aProtocol, in nsIMsgMailNewsUrl aUrl,
in boolean isRunning, in boolean aSuspend,
in nsresult status);
void releaseUrlCacheEntry(in nsIMsgMailNewsUrl aUrl);
void headerFetchCompleted(in nsIImapProtocol aProtocol);
void setBiffStateAndUpdate(in long biffState);
void progressStatusString(in nsIImapProtocol aProtocol, in string aMsgId, in wstring extraInfo);
void percentProgress(in nsIImapProtocol aProtocol, in wstring aMessage,
in long long aCurrentProgress, in long long aMaxProgressProgressInfo);
void clearFolderRights();
void setCopyResponseUid(in string msgIdString,
in nsIImapUrl aUrl);
void setAppendMsgUid(in nsMsgKey newKey,
in nsIImapUrl aUrl);
ACString getMessageId(in nsIImapUrl aUrl);
};

80
mailnews/imap/public/nsIImapMessageSink.idl Normal file
View file

@ -0,0 +1,80 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
#include "MailNewsTypes2.idl"
#include "nsIImapUrl.idl"
interface nsIMsgMailNewsUrl;
[scriptable, uuid(6ffb6a92-e43a-405f-92ea-92cf81a5e17b)]
interface nsIImapMessageSink : nsISupports {
// set up messge download output stream
void setupMsgWriteStream(in nsIFile aFile, in boolean aAppendDummyEnvelope);
/**
* Used by the imap protocol code to notify the core backend code about
* downloaded imap messages.
*
* @param aAdoptedMsgLine a string with a lot of message lines,
* separated by native line terminators.
* @param aUidOfMsg IMAP UID of the fetched message.
* @param aImapUrl IMAP Url used to fetch the message.
*/
void parseAdoptedMsgLine(in string aAdoptedMsgLine, in nsMsgKey aUidOfMsg,
in nsIImapUrl aImapUrl);
/**
* Notify the backend that the imap protocol is done downloading a message
*
* @param aUidOfMsg IMAP UID of the fetched message.
* @param aMarkMsgRead Set the SEEN flag on the message.
* @param aImapUrl IMAP Url used to fetch the message.
* @param aUpdatedMessageSize if this parameter is not -1, the stored size of the message
* should be set to this value to reflect the actual size of
* the downloaded message.
*/
void normalEndMsgWriteStream(in nsMsgKey aUidOfMessage,
in boolean aMarkMsgRead, in nsIImapUrl aImapUrl,
in long aUpdatedMessageSize);
void abortMsgWriteStream();
void beginMessageUpload();
/**
* Notify the message sink that one or more flags have changed
* For Condstore servers, also update the highestMod Sequence
* @param aFlags - The new flags for the message
* @param aKeywords keywords for the message
* @param aMessageKey - The UID of the message that changed
* @param aHighestModSeq - The highest mod seq the parser has seen
* for this folder
**/
void notifyMessageFlags(in unsigned long aFlags, in ACString aKeywords,
in nsMsgKey aMessageKey,
in unsigned long long aHighestModSeq);
void notifyMessageDeleted(in string aOnlineFolderName,in boolean aDeleteAllMsgs,in string aMsgIdString);
void getMessageSizeFromDB(in string aId, out unsigned long aSize);
void setContentModified(in nsIImapUrl aImapUrl, in nsImapContentModifiedType aModified);
/**
* For a message stored in a file, get the message metadata needed to copy
* that message to an imap folder
*
* @param aRunningUrl message URL
* @param aDate message date
* @param aKeywords message custom keywords (if supported by the server),
* including messages tags and junk status
*
* @return message flags
*/
unsigned long getCurMoveCopyMessageInfo(in nsIImapUrl aRunningUrl,
out PRTime aDate, out ACString aKeywords);
};

49
mailnews/imap/public/nsIImapMockChannel.idl Normal file
View file

@ -0,0 +1,49 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
Because imap protocol connections (which are channels) run through a cache,
it isn't always the case that when you want to run a url, you actually get
a connection back right away. Often times, the url goes into a queue until
a connection becomes available.
Unfortunately, if we want to be a truly pluggable protocol with necko, necko
requires the ability to get a channel back right away when it wants to run
a url. It doesn't let you wait until an imap connection becomes available.
So I've created the notion of a "mock channel". This mock channel is what
gets returned to necko (or other callers) when they ask the imap service
for a new channel for a url. The mock channel has "mock" implementations
of nsIChannel. Eventually, when we actually assign the url to a real
channel, we set the real channel on the mock channel. From that point forward,
the mock channel forwards channel calls directly to the real channel.
In short, this class is how I'm solving the problem where necko wants
a channel back as soon as they ask for when with the fact that it
may be a while until the url is loaded into a connection.
*/
#include "nsISupports.idl"
#include "nsIChannel.idl"
interface nsIStreamListener;
interface nsIProgressEventSink;
interface nsIURI;
interface nsIImapProtocol;
[scriptable, uuid(e0178cd5-d37b-4bde-9ab8-752083536225)]
interface nsIImapMockChannel : nsIChannel
{
attribute nsIProgressEventSink progressEventSink;
void GetChannelListener(out nsIStreamListener aChannelListener);
void GetChannelContext(out nsISupports aChannelContext);
void Close();
void setImapProtocol(in nsIImapProtocol aProtocol);
[noscript] void setSecurityInfo(in nsISupports securityInfo);
void setURI(in nsIURI uri);
};

71
mailnews/imap/public/nsIImapProtocol.idl Normal file
View file

@ -0,0 +1,71 @@
/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
interface nsIURI;
interface nsIImapUrl;
interface nsIImapProtocol;
interface nsIImapIncomingServer;
interface nsIMsgFolder;
interface nsIImapHostSessionList;
interface nsIMsgWindow;
interface nsIImapFlagAndUidState;
[scriptable, uuid(290412eb-5824-4087-8984-05450c9397be)]
interface nsIImapProtocol : nsISupports {
void LoadImapUrl(in nsIURI aUrl, in nsISupports aConsumer);
/**
* IsBusy returns true if the connection is currently processing a url
* and false otherwise.
*/
void IsBusy(out boolean aIsConnectionBusy,
out boolean isInboxConnection);
/** Protocol instance examines the url, looking at the host name,
* user name and folder the action would be on in order to figure out
* if it can process this url. I decided to push the semantics about
* whether a connection can handle a url down into the connection level
* instead of in the connection cache.
*/
void CanHandleUrl(in nsIImapUrl aImapUrl, out boolean aCanRunUrl,
out boolean hasToWait);
/**
* Initialize a protocol object.
* @param aHostSessionList host session list service
* @param aServer imap server the protocol object will be talking to
*/
void Initialize(in nsIImapHostSessionList aHostSessionList, in nsIImapIncomingServer aServer);
void NotifyBodysToDownload(out unsigned long keys, in unsigned long count);
// methods to get data from the imap parser flag state.
void GetFlagsForUID(in unsigned long uid, out boolean foundIt, out unsigned short flags, out string customFlags);
void GetSupportedUserFlags(out unsigned short flags);
void GetRunningImapURL(out nsIImapUrl aImapUrl);
void GetRunningUrl(out nsIURI aUrl);
readonly attribute nsIImapFlagAndUidState flagAndUidState;
/**
* Tell thread to die - only call from the UI thread
*
* @param aIsSafeToClose false if we're dropping a timed out connection.
*/
void tellThreadToDie(in boolean aIsSafeToClose);
// Get last active time stamp
void GetLastActiveTimeStamp(out PRTime aTimeStamp);
void pseudoInterruptMsgLoad(in nsIMsgFolder imapFolder, in nsIMsgWindow aMsgWindow, out boolean interrupted);
void GetSelectedMailboxName(out string folderName);
// Reset folder connection to authenticated state
void ResetToAuthenticatedState();
void OverrideConnectionInfo(in wstring pHost, in unsigned short pPort, in string pCookieData);
};

32
mailnews/imap/public/nsIImapProtocolSink.idl Normal file
View file

@ -0,0 +1,32 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
interface nsIMsgWindow;
interface nsIMsgMailNewsUrl;
/**
* Helper interface that contains operations MUST be proxied
* over UI thread.
*/
[scriptable, uuid(1217cd9d-7678-4026-b323-0d4b45816af0)]
interface nsIImapProtocolSink : nsISupports {
/**
* Does general cleanup for the imap protocol object.
*/
void closeStreams();
/**
* Get the msg window associated with a url
*
* @param aUrl url whose msgWindow we want.
* @returns msgWindow associated with url.
*/
nsIMsgWindow getUrlWindow(in nsIMsgMailNewsUrl aUrl);
/**
* Setup main thread proxies.
*/
void setupMainThreadProxies();
};

169
mailnews/imap/public/nsIImapServerSink.idl Normal file
View file

@ -0,0 +1,169 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
#include "MailNewsTypes2.idl"
interface nsIMsgWindow;
interface nsIMsgMailNewsUrl;
interface nsIImapProtocol;
interface nsIImapUrl;
interface nsIImapMockChannel;
/**
* nsIImapServerSink is designed to be used as a proxy to the application's UI
* thread from the running IMAP threads.
*/
[scriptable, uuid(2160c641-e4fa-4bbc-ab8b-d9ba45069027)]
interface nsIImapServerSink : nsISupports {
/**
* Check if the given folder path is a possible IMAP mailbox.
* @param folderPath folder path to check
* @param hierarchyDelimiter IMAP hierarchy delimiter in canonical format,
* i.e., hierarchy delimiter has been replaced
* with '/'
* @param boxFlags IMAP folder flags (for subscription, namespaces etc.)
* @return true if it's a new mailbox
*/
boolean possibleImapMailbox(in ACString folderPath,
in char hierarchyDelimiter, in long boxFlags);
boolean folderNeedsACLInitialized(in ACString folderPath);
void addFolderRights(in ACString folderPath, in ACString userName, in ACString rights);
void refreshFolderRights(in ACString folderPath);
void discoveryDone();
void onlineFolderDelete(in ACString folderName);
void onlineFolderCreateFailed(in ACString aFolderName);
void onlineFolderRename(in nsIMsgWindow msgWindow, in ACString oldName, in ACString newName);
boolean folderIsNoSelect(in ACString folderName);
void setFolderAdminURL(in ACString folderName, in ACString adminUrl);
boolean folderVerifiedOnline(in ACString folderName);
void setCapability(in unsigned long long capability);
/// RFC 2971 ID server response
void setServerID(in ACString aServerID);
boolean loadNextQueuedUrl(in nsIImapProtocol protocol);
/**
* Prepare to retry the given URL.
* @param imapUrl the url we're going to retry
* @return channel to associate with the url. We return this because access
* to the channel should only happen on the ui thread.
*/
nsIImapMockChannel prepareToRetryUrl(in nsIImapUrl imapUrl);
/**
* Suspend the url. This puts it at the end of the queue. If the queue is
* empty, the url will get resumed immediately. Currently, the plan is
* do this when we have to download a lot of headers in chunks, though we
* could find other uses for it.
* @param imapUrl url to suspend
*/
void suspendUrl(in nsIImapUrl aImapUrl);
/**
* Retry the given URL.
* @param imapUrl url to retry
* @param channel the channel to associate with the url
*/
void retryUrl(in nsIImapUrl imapUrl, in nsIImapMockChannel channel);
/**
* If previous URL failed, this gives server chance to abort URLs with same
* mock channel.
*/
void abortQueuedUrls();
AString getImapStringByName(in string msgName);
/**
* Alerts the user that the login to the IMAP server failed. Asks whether the
* connection should: retry, cancel, or request a new password.
*
* @param aMsgWindow The message window associated with this action (cannot
* be null).
* @return The button pressed. 0 for retry, 1 for cancel,
* 2 for enter a new password.
*/
int32_t promptLoginFailed(in nsIMsgWindow aMsgWindow);
/**
* Alerts the user with the given string (FE = 'Front End').
*
* @param aAlertString The string to alert the user with.
* @param aUrl The running url.
*/
void fEAlert(in AString aAlertString, in nsIMsgMailNewsUrl aUrl);
/**
* Alerts the user with a localized string. It will attempt to fill in
* the hostname into the string if necessary.
*
* @param aMsgName The id of the string to present to the user..
* @param aUrl The running url.
*/
void fEAlertWithName(in string aMsgName, in nsIMsgMailNewsUrl aUrl);
/**
* Takes a response from the server and prepends it with IMAP_SERVER_SAID
*
* @param aServerString The string to alert the user with.
* @param url The running url.
*/
void fEAlertFromServer(in ACString aServerString, in nsIMsgMailNewsUrl aUrl);
void commitNamespaces();
/**
* Returns a password via the out param, if we were able to prompt for one,
* or had one stored.
* If there is already a password prompt up, we return false, but we
* ask the async prompt service to notify us when we can put up a prompt.
* When that notification is received, we prompt the user and set the
* password on the protocol object, and signal a monitor that the imap
* thread should be waiting on.
*
* rv is NS_MSG_PASSWORD_PROMPT_CANCELLED if the user cancels the
* password prompt. That's not an exception, however.
*
* @param aProtocol imap protocol object requesting the password.
* @param aNewPasswordRequested Forces password prompt immediately
* @param aPassword returns the password, unless we had to prompt or use the,
* login manager and there was already a prompt up.
*/
void asyncGetPassword(in nsIImapProtocol aProtocol,
in boolean aNewPasswordRequested,
out ACString aPassword);
attribute boolean userAuthenticated;
void setMailServerUrls(in ACString manageMailAccount, in ACString manageLists, in ACString manageFilters);
/** Used by the imap thread when upgrading from the socketType
* trySTARTTLS.
* @param aSucceeded whether STARTTLS succeeded. If it did, the server
* will set the socket type to alwaysSTARTTLS, otherwise plain.
*/
void UpdateTrySTARTTLSPref(in boolean aSucceeded);
readonly attribute ACString arbitraryHeaders;
void forgetPassword();
readonly attribute boolean showAttachmentsInline;
string cramMD5Hash(in string decodedChallenge, in string key);
/// String to send to the imap server as the login user name.
readonly attribute ACString loginUsername;
/// String to send to the imap server as the user name.
readonly attribute ACString originalUsername;
/// Internal pref key, unique over all servers
readonly attribute ACString serverKey;
/// password for server login
readonly attribute ACString serverPassword;
/// remove a connection to the server
void removeServerConnection(in nsIImapProtocol aProtocol);
/// is the imap server shutting down?
readonly attribute boolean serverShuttingDown;
/// reset the connection for a particular folder
void resetServerConnection(in ACString aFolderName);
/// tell the server if listing using lsub command
void setServerDoingLsub(in boolean aDoingLsub);
/// set force select string
void SetServerForceSelect(in ACString forceSelect);
};

258
mailnews/imap/public/nsIImapService.idl Normal file
View file

@ -0,0 +1,258 @@
/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
////////////////////////////////////////////////////////////////////////////////////////
// The IMAP Service is an interfaced designed to make building and running imap urls
// easier. Clients typically go to the imap service and ask it do things such as:
// get new mail, etc....
//
// Oh and in case you couldn't tell by the name, the imap service is a service! and you
// should go through the service manager to obtain an instance of it.
////////////////////////////////////////////////////////////////////////////////////////
#include "nsISupports.idl"
#include "nsIImapUrl.idl"
interface nsIImapMessageSink;
interface nsIUrlListener;
interface nsIURI;
interface nsIFile;
interface nsIMsgFolder;
interface nsIMsgWindow;
interface nsIImapIncomingServer;
interface nsICacheStorage;
[scriptable, uuid(aba44b3d-7a0f-4987-8794-96d2de66d966)]
interface nsIImapService : nsISupports
{
// You can pass in null for the url listener and the url if you don't require either.....
void selectFolder(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
in nsIMsgWindow aMsgWindow,
out nsIURI aURL);
/**
* Select the folder on the imap server without doing a sync of flags or
* headers. This is used for offline playback, where we don't want to
* download hdrs we don't have, because they may have been offline deleted.
*
* @param aImapMailFolder the folder to select
* @param aUrlListener url listener, can be null
* @param aMsgWindow msg window url is running in, can be null
*
* @returns the url created to run the lite select in.
*/
nsIURI liteSelectFolder(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
in nsIMsgWindow aMsgWindow);
void addImapFetchToUrl(in nsIURI aURL,
in nsIMsgFolder aImapMailFolder,
in ACString aMessageIdentifierList,
in ACString aAdditionalHeader);
void fetchMessage(in nsIImapUrl aUrl,
in nsImapState aImapAction,
in nsIMsgFolder aImapMailFolder,
in nsIImapMessageSink aImapMessageSink,
in nsIMsgWindow aMsgWindow,
in nsISupports aConsumer,
in ACString aMessageIdentifierList,
in boolean convertDataToText,
in ACString additionalHeader,
out nsIURI aOutURL);
void noop(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
out nsIURI aURL);
void getHeaders(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
out nsIURI aURL,
in ACString aMessageIdentifierList,
in boolean aMessageIdsAreUID);
nsIURI getBodyStart(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
in ACString aMessageIdentifierList,
in long numBytes);
/**
* Issue an EXPUNGE on the target folder.
*
* @param aImapMailFolder the folder to expunge
* @param aUrlListener url listener, can be null
* @param aMsgWindow msg window url is running in, can be null
*
* @returns the url created to run the expunge.
*/
void expunge(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
in nsIMsgWindow aMsgWindow,
out nsIURI aURL);
/**
* Issue a STATUS on the target folder.
*
* @param aImapMailFolder the folder to expunge
* @param aUrlListener url listener, can be null
*
* @returns the url created to run the status.
*/
nsIURI updateFolderStatus(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener);
/**
* Verify that we can login.
*
* @param aImapMailFolder - any old imap folder - we just need it to
* set url sinks.
* @param aMsgWindow - nsIMsgWindow to use for notification callbacks.
* @return - the url that we run.
*/
nsIURI verifyLogon(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
in nsIMsgWindow aMsgWindow);
void biff(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
out nsIURI aURL,
in unsigned long aUidHighWater);
void deleteMessages(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
out nsIURI aURL,
in ACString aMessageIdentifierList,
in boolean aMessageIdsAreUID);
void deleteAllMessages(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
out nsIURI aURL);
void addMessageFlags(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
out nsIURI aURL,
in ACString aMessageIdentifierList,
in imapMessageFlagsType aFlags,
in boolean aMessageIdsAreUID);
void subtractMessageFlags(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
out nsIURI aURL,
in ACString aMessageIdentifierList,
in imapMessageFlagsType aFlags,
in boolean aMessageIdsAreUID);
void setMessageFlags(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
out nsIURI aURL,
in ACString aMessageIdentifierList,
in imapMessageFlagsType aFlags,
in boolean aMessageIdsAreUID);
void discoverAllFolders(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
in nsIMsgWindow aMsgWindow,
out nsIURI aURL);
void discoverAllAndSubscribedFolders(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
out nsIURI aURL);
void discoverChildren(in nsIMsgFolder aImapMailFolder,
in nsIUrlListener aUrlListener,
in ACString folderPath,
out nsIURI aURL);
void onlineMessageCopy(in nsIMsgFolder aSrcFolder,
in ACString aMessageIds,
in nsIMsgFolder aDstFolder,
in boolean aIdsAreUids,
in boolean aIsMove,
in nsIUrlListener aUrlListener,
out nsIURI aURL,
in nsISupports aCopyState,
in nsIMsgWindow aWindow);
void appendMessageFromFile(in nsIFile aFile,
in nsIMsgFolder aDstFolder,
in ACString aMessageId,
in boolean idsAreUids,
in boolean aInSelectedState,
in nsIUrlListener aUrlListener,
out nsIURI aURL,
in nsISupports aCopyState,
in nsIMsgWindow aMsgWindow);
void downloadMessagesForOffline(in ACString aMessageIds, in nsIMsgFolder aSrcFolder,
in nsIUrlListener aListener, in nsIMsgWindow aMsgWindow);
nsIURI moveFolder(in nsIMsgFolder aSrcFolder,
in nsIMsgFolder aDstFolder,
in nsIUrlListener aUrlListener,
in nsIMsgWindow msgWindow);
nsIURI renameLeaf(in nsIMsgFolder aSrcFolder,
in AString aLeafName,
in nsIUrlListener aUrlListener,
in nsIMsgWindow msgWindow);
nsIURI deleteFolder(in nsIMsgFolder aFolder,
in nsIUrlListener aUrlListener,
in nsIMsgWindow aMsgWindow);
nsIURI createFolder(in nsIMsgFolder aParentFolder,
in AString aLeafName,
in nsIUrlListener aUrlListener);
nsIURI listFolder(in nsIMsgFolder aMailFolder,
in nsIUrlListener aUrlListener);
nsIURI subscribeFolder(in nsIMsgFolder aMailFolder,
in AString mailboxName,
in nsIUrlListener aUrlListener);
nsIURI unsubscribeFolder(in nsIMsgFolder aMailFolder,
in AString mailboxName,
in nsIUrlListener aUrlListener);
// this method will first check if the folder exists but is
// not subscribed to, in which case it will subscribe to the folder.
// otherwise, it will try to create the folder. It will try to do this
// with one url.
nsIURI ensureFolderExists(in nsIMsgFolder aParentFolder,
in AString aLeafName,
in nsIUrlListener aUrlListener);
nsIURI getFolderAdminUrl(in nsIMsgFolder aMailFolder,
in nsIMsgWindow aMsgWindow,
in nsIUrlListener aUrlListener);
nsIURI issueCommandOnMsgs(in nsIMsgFolder aMailFolder,
in nsIMsgWindow aMsgWindow,
in ACString aCommand,
in ACString aMessageIdentifierList);
nsIURI fetchCustomMsgAttribute(in nsIMsgFolder aMailFolder,
in nsIMsgWindow aMsgWindow,
in ACString aAttribute,
in ACString aMessageIdentifierList);
nsIURI storeCustomKeywords(in nsIMsgFolder aMailFolder,
in nsIMsgWindow aMsgWindow,
in ACString flagsToAdd,
in ACString flagsToSubtract,
in ACString aMessageIdentifierList);
void getListOfFoldersOnServer(in nsIImapIncomingServer aServer, in nsIMsgWindow aMsgWindow);
void getListOfFoldersWithPath(in nsIImapIncomingServer aServer, in nsIMsgWindow aMsgWindow, in ACString folderPath);
nsISupports playbackAllOfflineOperations(in nsIMsgWindow aMsgWindow, in nsIUrlListener aListener);
void downloadAllOffineImapFolders(in nsIMsgWindow aMsgWindow, in nsIUrlListener aListener);
readonly attribute nsICacheStorage cacheStorage;
};

207
mailnews/imap/public/nsIImapUrl.idl Normal file
View file

@ -0,0 +1,207 @@
/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
interface nsIImapMailFolderSink;
interface nsIImapMessageSink;
interface nsIImapServerSink;
interface nsIImapMockChannel;
interface nsIFile;
typedef long nsImapAction;
typedef long nsImapState;
typedef unsigned short imapMessageFlagsType;
typedef long nsImapContentModifiedType;
[scriptable, uuid(2e91901e-ff6c-11d3-b9fa-00108335942a)]
interface nsImapContentModifiedTypes
{
const long IMAP_CONTENT_NOT_MODIFIED = 0;
const long IMAP_CONTENT_MODIFIED_VIEW_INLINE = 1;
const long IMAP_CONTENT_MODIFIED_VIEW_AS_LINKS = 2;
const long IMAP_CONTENT_FORCE_CONTENT_NOT_MODIFIED = 3;
} ;
[scriptable, uuid(fe2a8f9e-2886-4146-9896-27fff660c69f)]
interface nsIImapUrl : nsISupports
{
///////////////////////////////////////////////////////////////////////////////
// Getters and Setters for the imap specific event sinks to bind to to the url
///////////////////////////////////////////////////////////////////////////////
attribute nsIImapMailFolderSink imapMailFolderSink;
attribute nsIImapMessageSink imapMessageSink;
attribute nsIImapServerSink imapServerSink;
///////////////////////////////////////////////////////////////////////////////
// Getters and Setters for the imap url state
///////////////////////////////////////////////////////////////////////////////
attribute nsImapAction imapAction;
readonly attribute nsImapState requiredImapState;
readonly attribute string imapPartToFetch;
readonly attribute ACString customAttributeToFetch;
attribute ACString customAttributeResult;
readonly attribute ACString command;
attribute ACString customCommandResult;
readonly attribute ACString customAddFlags;
readonly attribute ACString customSubtractFlags;
void allocateCanonicalPath(in string aServerPath, in char aOnlineDelimiter, out string aAllocatedPath);
void allocateServerPath(in string aCanonicalPath, in char aOnlineDelimiter, out string aAllocatedPath);
string createServerSourceFolderPathString();
string createCanonicalSourceFolderPathString();
string createServerDestinationFolderPathString();
string addOnlineDirectoryIfNecessary(in string onlineMailboxName);
void createSearchCriteriaString (out string aResult);
readonly attribute ACString listOfMessageIds;
boolean messageIdsAreUids();
readonly attribute imapMessageFlagsType msgFlags; // kAddMsgFlags or kSubtractMsgFlags only
readonly attribute long numBytesToFetch;
attribute char onlineSubDirSeparator;
attribute boolean allowContentChange;
attribute boolean mimePartSelectorDetected;
attribute nsImapContentModifiedType contentModified;
attribute boolean fetchPartsOnDemand; // set to true if we're fetching a msg for display and want to not download parts
attribute boolean msgLoadingFromCache; // true if this msg load is coming from a cache, so we can know to mark it read
attribute boolean externalLinkUrl; // true if we ran this url because the user clicked on a link.
attribute boolean validUrl; // false if we couldn't parse url for whatever reason.
attribute nsISupports copyState;
attribute nsIFile msgFile;
attribute nsIImapMockChannel mockChannel;
/**
* Set to true if we should store the msg(s) for offline use if we can,
* e.g., we're fetching a message and the folder is configured for offline
* use and we're not doing mime parts on demand.
*/
attribute boolean storeResultsOffline;
/**
* If we fallback from fetching by parts to fetching the whole message,
* because all the parts were inline, this tells us we should store
* the message offline.
*/
attribute boolean storeOfflineOnFallback;
/**
* This attribute defaults to false, but if we only want to use the offline
* cache (disk, memory, or offline store) to fetch the message, then we set
* this to true. Currently, nsIMsgMessageService.streamMessage does this.
*/
attribute boolean localFetchOnly;
/// Server disconnected first time so we're retrying.
attribute boolean rerunningUrl;
/**
* Do we have more headers to download? This is set when we decide to
* download newest headers first, followed by older headers in a subsequent
* run of the url, which allows other urls to run against the folder in the
* meantime.
*/
attribute boolean moreHeadersToDownload;
/**
* @{
* This is used to tell the runner of the url more about the status of
* the command, beyond whether it was successful or not. For example,
* subtracting flags from a UID that doesn't exist isn't an error
* (the server returns OK), but the backend code may want to know about it.
*/
attribute long extraStatus;
/**
* Current possible extra status values
*/
const long ImapStatusNone = 0;
const long ImapStatusFlagChangeFailed = 1;
const long ImapStatusFlagsNotSettable = 2;
/** @} */
///////////////////////////////////////////////////////////////////////////////
// Enumerated types specific to imap urls...
///////////////////////////////////////////////////////////////////////////////
// the following are nsImapState enums.
// we have a basic set of imap url actions. These actions are nsImapActions.
// Certain actions require us to be in the authenticated state and others require us to
// be in the selected state. nsImapState is used to store the state the url needs to
// be in. You'll later see us refer to the imap url state in the imap protocol when we
// are processing the current url. Don't confuse nsImapState with the generic url state
// used to keep track of whether the url is running or not...
const long nsImapAuthenticatedState = 0;
const long nsImapSelectedState = 1;
const long nsImapActionSendText = 0; // a state used for testing purposes to send raw url text straight to the server....
// nsImapAuthenticatedStateUrl urls
// since the following url actions require us to be in the authenticated
// state, the high bit is left blank....
const long nsImapTest = 0x00000001;
const long nsImapCreateFolder = 0x00000005;
const long nsImapDeleteFolder = 0x00000006;
const long nsImapRenameFolder = 0x00000007;
const long nsImapMoveFolderHierarchy = 0x00000008;
const long nsImapLsubFolders = 0x00000009;
const long nsImapGetMailAccountUrl = 0x0000000A;
const long nsImapDiscoverChildrenUrl = 0x0000000B;
const long nsImapDiscoverAllBoxesUrl = 0x0000000D;
const long nsImapDiscoverAllAndSubscribedBoxesUrl = 0x0000000E;
const long nsImapAppendMsgFromFile = 0x0000000F;
const long nsImapSubscribe = 0x00000010;
const long nsImapUnsubscribe = 0x00000011;
const long nsImapRefreshACL = 0x00000012;
const long nsImapRefreshAllACLs = 0x00000013;
const long nsImapListFolder = 0x00000014;
const long nsImapUpgradeToSubscription = 0x00000015;
const long nsImapFolderStatus = 0x00000016;
const long nsImapRefreshFolderUrls = 0x00000017;
const long nsImapEnsureExistsFolder = 0x00000018;
const long nsImapOfflineToOnlineCopy = 0x00000019;
const long nsImapOfflineToOnlineMove = 0x0000001A;
const long nsImapVerifylogon = 0x0000001B;
// it's okay to add more imap actions that require us to
// be in the authenticated state here without renumbering
// the imap selected state url actions. just make sure you don't
// set the high bit...
// nsImapSelectedState urls. Note, the high bit is always set for
// imap actions which require us to be in the selected state
const long nsImapSelectFolder = 0x10000002;
const long nsImapLiteSelectFolder = 0x10000003;
const long nsImapExpungeFolder = 0x10000004;
const long nsImapMsgFetch = 0x10000018;
const long nsImapMsgHeader = 0x10000019;
const long nsImapSearch = 0x1000001A;
const long nsImapDeleteMsg = 0x1000001B;
const long nsImapDeleteAllMsgs = 0x1000001C;
const long nsImapAddMsgFlags = 0x1000001D;
const long nsImapSubtractMsgFlags = 0x1000001E;
const long nsImapSetMsgFlags = 0x1000001F;
const long nsImapOnlineCopy = 0x10000020;
const long nsImapOnlineMove = 0x10000021;
const long nsImapOnlineToOfflineCopy = 0x10000022;
const long nsImapOnlineToOfflineMove = 0x10000023;
const long nsImapMsgPreview = 0x10000024;
const long nsImapBiff = 0x10000026;
const long nsImapSelectNoopFolder = 0x10000027;
const long nsImapAppendDraftFromFile = 0x10000028;
const long nsImapUidExpunge = 0x10000029;
const long nsImapSaveMessageToDisk = 0x10000030;
const long nsImapOpenMimePart = 0x10000031;
const long nsImapMsgDownloadForOffline = 0x10000032;
const long nsImapDeleteFolderAndMsgs = 0x10000033;
const long nsImapUserDefinedMsgCommand = 0x10000034;
const long nsImapUserDefinedFetchAttribute = 0x10000035;
const long nsImapMsgFetchPeek = 0x10000036;
const long nsImapMsgStoreCustomKeywords = 0x10000037;
/// Constant for the default IMAP port number
const int32_t DEFAULT_IMAP_PORT = 143;
/// Constant for the default IMAP over ssl port number
const int32_t DEFAULT_IMAPS_PORT = 993;
};

43
mailnews/imap/public/nsIMailboxSpec.idl Normal file
View file

@ -0,0 +1,43 @@
/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
#include "nsIImapFlagAndUidState.idl"
interface nsIMAPNamespace;
[scriptable, uuid(a9fbbc80-5291-4ed8-a7f7-c2fcad231269)]
interface nsIMailboxSpec : nsISupports
{
attribute long folder_UIDVALIDITY;
/**
* The highest modification sequence number the parser has seen
* for this mailbox. See IMAP RFC 4551
**/
attribute unsigned long long highestModSeq;
attribute long numMessages;
attribute long numUnseenMessages;
attribute long numRecentMessages;
/// If server supports UIDNEXT, we store the result here.
attribute long nextUID;
attribute unsigned long box_flags;
attribute unsigned long supportedUserFlags;
attribute ACString allocatedPathName;
attribute AString unicharPathName;
attribute char hierarchyDelimiter;
attribute ACString hostName;
attribute nsIImapFlagAndUidState flagState;
attribute boolean folderSelected;
attribute boolean discoveredFromLsub;
attribute boolean onlineVerified;
[noscript] attribute nsIMAPNamespace namespaceForFolder;
};

215
mailnews/imap/public/nsIMsgImapMailFolder.idl Normal file
View file

@ -0,0 +1,215 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
#include "nsIMsgFolder.idl"
#include "nsIStringEnumerator.idl"
interface nsIMsgWindow;
interface nsIImapIncomingServer;
interface nsIMsgParseMailMsgState;
interface nsIAutoSyncState;
/**
* This is a simple interface which allows the IMAP folder to update some
* values that the folder props js code will use to update the sharing and
* quota tabs in the folder properties.
*/
[scriptable, uuid(09D99F2C-3E23-4f8c-A536-5C277BAA9585)]
interface nsIMsgImapFolderProps : nsISupports {
void setFolderType(in AString folderType);
void setFolderTypeDescription(in AString folderTypeDescription);
void setFolderPermissions(in AString permissions);
void serverDoesntSupportACL();
/**
* Toggles the display of quota information in the Quota tab of the folder properties.
* If on, the quota root, usage, and percentage used are displayed.
* If off, a status message is displayed. The status message can be set with setQuotaStatus().
* @param showData If true, display the quota root, usage information and usage percentage bar.
* If false, display the status message.
*/
void showQuotaData(in boolean showData);
/**
* Sets the status string displayed in the Quota tab of the folder properties if quota
* information is not visible.
*/
void setQuotaStatus(in AString folderQuotaStatus);
/**
* Updates the quota data displayed in the Quota tab.
*/
void setQuotaData(in ACString quotaroot, in unsigned long usedKB, in unsigned long maxKB);
};
[scriptable, uuid(fea0f455-7adf-4683-bf2f-c95c3fff03df)]
interface nsIMsgImapMailFolder : nsISupports {
void removeSubFolder(in nsIMsgFolder folder);
void createClientSubfolderInfo(in ACString folderName, in char hierarchyDelimiter,
in long flags, in boolean suppressNotification);
void list();
void renameLocal(in ACString newname, in nsIMsgFolder parent);
void prepareToRename();
void performExpand(in nsIMsgWindow aMsgWindow);
void recursiveCloseActiveConnections(in nsIImapIncomingServer aImapServer);
void renameClient(in nsIMsgWindow msgWindow, in nsIMsgFolder msgFolder, in ACString oldName, in ACString newName);
// these are used for offline synchronization
void storeImapFlags(in long aFlags, in boolean aAddFlags, [array, size_is (aNumKeys)]
in nsMsgKey aKeysToFlag, in unsigned long aNumKeys, in nsIUrlListener aUrlListener);
nsIURI setImapFlags(in string uids, in long flags);
void replayOfflineMoveCopy([array, size_is (numKeys)] in nsMsgKey keys, in unsigned long numKeys, in boolean isMove, in nsIMsgFolder aDstFolder,
in nsIUrlListener aUrlListener, in nsIMsgWindow aWindow);
nsIURI playbackOfflineFolderCreate(in AString folderName, in nsIMsgWindow aWindow);
/**
* This is called by the offline sync code to tell the imap folder to
* remember info about the header with this key (messageId and key) because
* it's an offline move result header, and we need to generate an
* nsIMsgFolderListener.msgKeyChanged notification when we download the
* real header from the imap server.
*
* @param aMsgKey msg key of move result pseudo hdr.
*/
void addMoveResultPseudoKey(in nsMsgKey aMsgKey);
/**
* Select this folder on the imap server without doing a sync of flags or
* headers. This is used for offline playback, where we don't want to
* download hdrs we don't have, because they may have been offline deleted.
*
* @param aUrlListener url listener, can be null
* @param aWindow msg window url is running in, can be null
*/
void liteSelect(in nsIUrlListener aUrlListener, in nsIMsgWindow aWindow);
void fillInFolderProps(in nsIMsgImapFolderProps aFolderProps);
void resetNamespaceReferences();
void folderPrivileges(in nsIMsgWindow aWindow);
nsIMsgImapMailFolder findOnlineSubFolder(in ACString onlineName);
void addFolderRights(in ACString userName, in ACString rights);
void refreshFolderRights();
/**
* Mark/unmark the header as pending removal from the offline store. If mark,
* this also increases the expungedBytes count on the folder so we know
* there's more local disk space to be reclaimed.
*
* @param aHdr msg hdr to mark pending removal from offline store.
* @param aMark whether to set or clear the pending removal status.
*
*/
void markPendingRemoval(in nsIMsgDBHdr aHdr, in boolean aMark);
/**
* Issue an expunge of this folder to the imap server.
*
* @param aUrlListener url listener, can be null
* @param aWindow msg window url is running in, can be null
*
* @returns status of attempt to run url.
*/
void expunge(in nsIUrlListener aListener, in nsIMsgWindow aMsgWindow);
void updateStatus(in nsIUrlListener aListener, in nsIMsgWindow aMsgWindow);
void updateFolderWithListener(in nsIMsgWindow aMsgWindow, in nsIUrlListener aListener);
// this is used to issue an arbitrary imap command on the passed in msgs.
// It assumes the command needs to be run in the selected state.
nsIURI issueCommandOnMsgs(in ACString command, in string uids, in nsIMsgWindow aWindow);
nsIURI fetchCustomMsgAttribute(in ACString msgAttribute, in string uids, in nsIMsgWindow aWindow);
nsIURI storeCustomKeywords(in nsIMsgWindow aMsgWindow,
in ACString aFlagsToAdd,
in ACString aFlagsToSubtract,
[array, size_is (aNumKeys)] in nsMsgKey aKeysToStore,
in unsigned long aNumKeys);
void notifyIfNewMail();
void initiateAutoSync(in nsIUrlListener aUrlListener);
attribute boolean verifiedAsOnlineFolder;
attribute boolean explicitlyVerify;
attribute char hierarchyDelimiter;
attribute long boxFlags;
attribute ACString onlineName;
attribute boolean isNamespace;
readonly attribute boolean canOpenFolder;
attribute ACString adminUrl;
readonly attribute boolean hasAdminUrl;
attribute boolean performingBiff;
readonly attribute nsIMsgParseMailMsgState hdrParser;
readonly attribute nsIImapIncomingServer imapIncomingServer;
readonly attribute nsIAutoSyncState autoSyncStateObj;
/**
* @{
* These are used to access the response to the STATUS or SELECT command.
* The counts include deleted messages, or headers we haven't downloaded yet.
*/
readonly attribute long serverTotal;
readonly attribute long serverUnseen;
readonly attribute long serverRecent;
readonly attribute long serverNextUID;
/** @} */
/**
* Quota
* |valid| indicates whether the server has provided quota information on
* this folder. This can be false
* - if the server does not supports quotas,
* - if there are no storage quotas on this folder, or
* - if the folder has never been opened.
* If it is true and maxKB > 0, the folder has a storage quota and
* the usedKB and maxKB attributes are set to the values provided by
* the server (in kilobytes), for this quota root.
* Lotus Notes sends us maxKB = 0, usedKB > 0 for unlimited quota.
*/
void getQuota(out boolean valid, out unsigned long usedKB, out unsigned long maxKB);
/**
* List all (human) users apart from the current user who have access to
* this folder.
*
* You can find out which rights they have with getRightsForUser().
*/
nsIUTF8StringEnumerator getOtherUsersWithAccess();
/**
* Which access rights a certain user has for this folder.
*
* @return list of flags
* e.g. "lrswipcd" for write access and "lrs" for read only access.
*
* See RFC 2086 (e.g. Cyrus) and RFC 4314 (e.g. dovecot)
*
* l = locate = visible in folder list
* r = read = list mails, get/read mail contents
* s = set seen flag = mark read. Does not affect other users.
* d (or t) = delete mails
* w = write = change (other) flags of existing mails
* i = insert = add mails to this folder
* p = post = send mail directly to the submission address for folder
* c (or k) = create subfolders
* (e = expunge = compress)
* (x = delete folder)
* a = admin = change permissions
*/
ACString getPermissionsForUser(in ACString username);
/**
* Change the number of "pending" messages in a folder,
* messages we know about, but don't have the headers for yet
*
* @param aDelta amount to change total by.
*/
void changePendingTotal(in long aDelta);
/**
* Change the number of "pending" unread messages in a folder,
* unread messages we know about, but don't have the headers for yet
*
* @param aDelta amount to change the unread count by.
*/
void changePendingUnread(in long aDelta);
};

59
mailnews/imap/public/nsMsgImapCID.h Normal file
View file

@ -0,0 +1,59 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef nsMsgImapCID_h__
#define nsMsgImapCID_h__
#include "nsISupports.h"
#include "nsIFactory.h"
#include "nsIComponentManager.h"
#include "nsMsgBaseCID.h"
#define NS_IMAPURL_CID \
{ /* 21A89611-DC0D-11d2-806C-006008128C4E */ \
0x21a89611, 0xdc0d, 0x11d2, \
{ 0x80, 0x6c, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e }}
#define NS_IMAPPROTOCOLINFO_CONTRACTID \
NS_MSGPROTOCOLINFO_CONTRACTID_PREFIX "imap"
#define NS_IMAPINCOMINGSERVER_CONTRACTID \
NS_MSGINCOMINGSERVER_CONTRACTID_PREFIX "imap"
#define NS_IMAPSERVICE_CONTRACTID \
"@mozilla.org/messenger/imapservice;1"
#define NS_IMAPSERVICE_CID \
{ /* C5852B22-EBE2-11d2-95AD-000064657374 */ \
0xc5852b22, 0xebe2, 0x11d2, \
{0x95, 0xad, 0x0, 0x0, 0x64, 0x65, 0x73, 0x74}}
#define NS_IMAPPROTOCOL_CID \
{ /* 8C0C40D1-E173-11d2-806E-006008128C4E */ \
0x8c0c40d1, 0xe173, 0x11d2, \
{ 0x80, 0x6e, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e }}
#define NS_IIMAPHOSTSESSIONLIST_CID \
{ /* 479ce8fc-e725-11d2-a505-0060b0fc04b7 */ \
0x479ce8fc, 0xe725, 0x11d2, \
{0xa5, 0x05, 0x00, 0x60, 0xb0, 0xfc, 0x04, 0xb7 }}
#define NS_IMAPINCOMINGSERVER_CID \
{ /* 8D3675E0-ED46-11d2-8077-006008128C4E */ \
0x8d3675e0, 0xed46, 0x11d2, \
{0x80, 0x77, 0x0, 0x60, 0x8, 0x12, 0x8c, 0x4e}}
#define NS_IMAPRESOURCE_CID \
{ /* fa32d000-f6a0-11d2-af8d-001083002da8 */ \
0xfa32d000, 0xf6a0, 0x11d2, \
{ 0xaf, 0x8d, 0x00, 0x10, 0x83, 0x00, 0x2d, 0xa8 }}
// 4ECA51DF-6734-11d3-989A-001083010E9B
#define NS_IMAPMOCKCHANNEL_CID \
{0x4eca51df, 0x6734, 0x11d3, \
{0x98, 0x9a, 0x0, 0x10, 0x83, 0x1, 0xe, 0x9b}}
#endif // nsMsgImapCID_h__