// refresh the local tag key array m_keys from preferences
nsresult nsMsgTagService::RefreshKeyCache()
{
nsIMsgTag **tagArray;
uint32_t numTags;
nsresult rv = GetAllTags(&numTags, &tagArray);
NS_ENSURE_SUCCESS(rv, rv);
m_keys.Clear();
for (uint32_t tagIndex = 0; tagIndex < numTags; tagIndex++)
{
nsIMsgTag *tag = tagArray[tagIndex];
if (!tag) {
rv = NS_ERROR_FAILURE;
break;
}
nsCAutoString key;
tag->GetKey(key);
if (!m_keys.InsertElementAt(tagIndex, key)) {
rv = NS_ERROR_FAILURE;
break;
}
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(numTags, tagArray);
return rv;
}
NS_IMETHODIMP
nsSmtpServer::ForgetPassword()
{
nsresult rv;
nsCOMPtr<nsILoginManager> loginMgr =
do_GetService(NS_LOGINMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Get the current server URI without the username
nsCAutoString serverUri(NS_LITERAL_CSTRING("smtp://"));
nsCString hostname;
rv = GetHostname(hostname);
if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) {
nsCString escapedHostname;
*((char **)getter_Copies(escapedHostname)) =
nsEscape(hostname.get(), url_Path);
// not all servers have a hostname
serverUri.Append(escapedHostname);
}
PRUint32 count;
nsILoginInfo** logins;
NS_ConvertUTF8toUTF16 currServer(serverUri);
nsCString serverCUsername;
rv = GetUsername(serverCUsername);
NS_ENSURE_SUCCESS(rv, rv);
NS_ConvertUTF8toUTF16 serverUsername(serverCUsername);
rv = loginMgr->FindLogins(&count, currServer, EmptyString(),
currServer, &logins);
NS_ENSURE_SUCCESS(rv, rv);
// There should only be one-login stored for this url, however just in case
// there isn't.
nsString username;
for (PRUint32 i = 0; i < count; ++i)
{
if (NS_SUCCEEDED(logins[i]->GetUsername(username)) &&
username.Equals(serverUsername))
{
// If this fails, just continue, we'll still want to remove the password
// from our local cache.
loginMgr->RemoveLogin(logins[i]);
}
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(count, logins);
rv = SetPassword(EmptyCString());
m_logonFailed = PR_TRUE;
return rv;
}
nsresult
nsSeamonkeyProfileMigrator::CopyPasswords(PRBool aReplace)
{
nsresult rv;
nsCString signonsFileName;
GetSignonFileName(aReplace, getter_Copies(signonsFileName));
if (signonsFileName.IsEmpty())
return NS_ERROR_FILE_NOT_FOUND;
NS_ConvertASCIItoUTF16 fileName(signonsFileName);
if (aReplace)
rv = CopyFile(fileName, fileName);
else {
// Get the password manager, which is the destination for the passwords
// being migrated. Also create a new instance of the legacy password
// storage component, which we'll use to slurp in the signons from
// Seamonkey's signons.txt.
nsCOMPtr<nsILoginManager> pwmgr(
do_GetService("@mozilla.org/login-manager;1"));
nsCOMPtr<nsILoginManagerStorage> importer(
do_CreateInstance("@mozilla.org/login-manager/storage/legacy;1"));
nsCOMPtr<nsIFile> signonsFile;
mSourceProfile->Clone(getter_AddRefs(signonsFile));
signonsFile->Append(fileName);
importer->InitWithFile(signonsFile, nsnull);
PRUint32 count;
nsILoginInfo **logins;
rv = importer->GetAllLogins(&count, &logins);
NS_ENSURE_SUCCESS(rv, rv);
for (PRUint32 i = 0; i < count; i++) {
pwmgr->AddLogin(logins[i]);
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(count, logins);
PRUnichar **hostnames;
rv = importer->GetAllDisabledHosts(&count, &hostnames);
NS_ENSURE_SUCCESS(rv, rv);
for (PRUint32 i = 0; i < count; i++) {
pwmgr->SetLoginSavingEnabled(nsDependentString(hostnames[i]),
PR_FALSE);
}
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, hostnames);
}
return rv;
}
nsresult
nsSmtpServer::GetPasswordWithoutUI()
{
nsresult rv;
nsCOMPtr<nsILoginManager> loginMgr(do_GetService(NS_LOGINMANAGER_CONTRACTID,
&rv));
NS_ENSURE_SUCCESS(rv, rv);
NS_ConvertASCIItoUTF16 serverUri(GetServerURIInternal(false));
uint32_t numLogins = 0;
nsILoginInfo** logins = nullptr;
rv = loginMgr->FindLogins(&numLogins, serverUri, EmptyString(),
serverUri, &logins);
// Login manager can produce valid fails, e.g. NS_ERROR_ABORT when a user
// cancels the master password dialog. Therefore handle that here, but don't
// warn about it.
if (NS_FAILED(rv))
return rv;
// Don't abort here, if we didn't find any or failed, then we'll just have
// to prompt.
if (numLogins > 0)
{
nsCString serverCUsername;
rv = GetUsername(serverCUsername);
NS_ConvertASCIItoUTF16 serverUsername(serverCUsername);
nsString username;
for (uint32_t i = 0; i < numLogins; ++i)
{
rv = logins[i]->GetUsername(username);
NS_ENSURE_SUCCESS(rv, rv);
if (username.Equals(serverUsername))
{
nsString password;
rv = logins[i]->GetPassword(password);
NS_ENSURE_SUCCESS(rv, rv);
LossyCopyUTF16toASCII(password, m_password);
break;
}
}
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(numLogins, logins);
return NS_OK;
}
/**
* Export VirtualBox machines
*/
void exportVirtualBoxMachines(IVirtualBox *virtualBox, xmlTextWriterPtr writer) {
IMachine **machines = NULL;
PRUint32 machinesCount = 0;
nsresult rc = virtualBox->GetMachines(&machinesCount, &machines);
if (NS_SUCCEEDED(rc)) {
xmlTextWriterStartElement(writer, TOXMLCHAR("machines"));
for (PRUint32 i = 0; i < machinesCount; i++) {
PRBool accessible = PR_FALSE;
rc = machines[i]->GetAccessible(&accessible);
if (NS_SUCCEEDED(rc) && accessible) {
exportVirtualBoxMachine(virtualBox, machines[i], writer);
}
}
xmlTextWriterEndElement(writer);
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(machinesCount, machines);
}
}
nsresult nsMsgTagService::MigrateLabelsToTags()
{
nsCString prefString;
int32_t prefVersion = 0;
nsresult rv = m_tagPrefBranch->GetIntPref(TAG_PREF_VERSION, &prefVersion);
if (NS_SUCCEEDED(rv) && prefVersion > 1)
return rv;
else if (prefVersion == 1)
{
gMigratingKeys = true;
// need to convert the keys to lower case
nsIMsgTag **tagArray;
uint32_t numTags;
GetAllTags(&numTags, &tagArray);
for (uint32_t tagIndex = 0; tagIndex < numTags; tagIndex++)
{
nsCAutoString key, color, ordinal;
nsAutoString tagStr;
nsIMsgTag *tag = tagArray[tagIndex];
tag->GetKey(key);
tag->GetTag(tagStr);
tag->GetOrdinal(ordinal);
tag->GetColor(color);
DeleteKey(key);
ToLowerCase(key);
AddTagForKey(key, tagStr, color, ordinal);
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(numTags, tagArray);
gMigratingKeys = false;
}
else
{
nsCOMPtr<nsIPrefBranch> prefRoot(do_GetService(NS_PREFSERVICE_CONTRACTID));
nsCOMPtr<nsIPrefLocalizedString> pls;
nsString ucsval;
nsCAutoString labelKey("$label1");
for(int32_t i = 0; i < PREF_LABELS_MAX; )
{
prefString.Assign(PREF_LABELS_DESCRIPTION);
prefString.AppendInt(i + 1);
rv = prefRoot->GetComplexValue(prefString.get(),
NS_GET_IID(nsIPrefLocalizedString),
getter_AddRefs(pls));
NS_ENSURE_SUCCESS(rv, rv);
pls->ToString(getter_Copies(ucsval));
prefString.Assign(PREF_LABELS_COLOR);
prefString.AppendInt(i + 1);
nsCString csval;
rv = prefRoot->GetCharPref(prefString.get(), getter_Copies(csval));
NS_ENSURE_SUCCESS(rv, rv);
rv = AddTagForKey(labelKey, ucsval, csval, EmptyCString());
NS_ENSURE_SUCCESS(rv, rv);
labelKey.SetCharAt(++i + '1', 6);
}
}
m_tagPrefBranch->SetIntPref(TAG_PREF_VERSION, 2);
return rv;
}
/* void getAllTags (out unsigned long count, [array, size_is (count), retval] out nsIMsgTag tagArray); */
NS_IMETHODIMP nsMsgTagService::GetAllTags(uint32_t *aCount, nsIMsgTag ***aTagArray)
{
NS_ENSURE_ARG_POINTER(aCount);
NS_ENSURE_ARG_POINTER(aTagArray);
// preset harmless default values
*aCount = 0;
*aTagArray = nullptr;
// get the actual tag definitions
nsresult rv;
uint32_t prefCount;
char **prefList;
rv = m_tagPrefBranch->GetChildList("", &prefCount, &prefList);
NS_ENSURE_SUCCESS(rv, rv);
// sort them by key for ease of processing
NS_QuickSort(prefList, prefCount, sizeof(char*), CompareMsgTagKeys, nullptr);
// build an array of nsIMsgTag elements from the orderered list
// it's at max the same size as the preflist, but usually only about half
nsIMsgTag** tagArray = (nsIMsgTag**) NS_Alloc(sizeof(nsIMsgTag*) * prefCount);
if (!tagArray)
{
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList);
return NS_ERROR_OUT_OF_MEMORY;
}
uint32_t currentTagIndex = 0;
nsMsgTag *newMsgTag;
nsString tag;
nsCString lastKey, color, ordinal;
for (uint32_t i = prefCount; i--;)
{
// extract just the key from <key>.<info=tag|color|ordinal>
char *info = strrchr(prefList[i], '.');
if (info)
{
nsCAutoString key(Substring(prefList[i], info));
if (key != lastKey)
{
if (!key.IsEmpty())
{
// .tag MUST exist (but may be empty)
rv = GetTagForKey(key, tag);
if (NS_SUCCEEDED(rv))
{
// .color MAY exist
color.Truncate();
GetColorForKey(key, color);
// .ordinal MAY exist
rv = GetOrdinalForKey(key, ordinal);
if (NS_FAILED(rv))
ordinal.Truncate();
// store the tag info in our array
newMsgTag = new nsMsgTag(key, tag, color, ordinal);
if (!newMsgTag)
{
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(currentTagIndex, tagArray);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList);
return NS_ERROR_OUT_OF_MEMORY;
}
NS_ADDREF(tagArray[currentTagIndex++] = newMsgTag);
}
}
lastKey = key;
}
}
}
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefList);
// sort the non-null entries by ordinal
NS_QuickSort(tagArray, currentTagIndex, sizeof(nsMsgTag*), CompareMsgTags,
nullptr);
// All done, now return the values (the idl's size_is(count) parameter
// ensures that the array is cut accordingly).
*aCount = currentTagIndex;
*aTagArray = tagArray;
return NS_OK;
}
/**
* Export VirtualBox machine
*/
void exportVirtualBoxMachine(IVirtualBox *virtualBox, IMachine *machine, xmlTextWriterPtr writer) {
nsCOMPtr<ISystemProperties> systemProperties;
nsresult rc = virtualBox->GetSystemProperties(getter_AddRefs(systemProperties));
if (NS_SUCCEEDED(rc)) {
xmlTextWriterStartElement(writer, TOXMLCHAR("machine"));
// uuid
ADDXMLSTRING(machine->GetId, "id");
// name
ADDXMLSTRING(machine->GetName, "name");
// description
ADDXMLSTRING(machine->GetDescription, "description");
// os type
ADDXMLSTRING(machine->GetOSTypeId, "ostype");
// settings file
ADDXMLSTRING(machine->GetSettingsFilePath, "path");
// hardware uuid
ADDXMLSTRING(machine->GetHardwareUUID, "hardwareuuid");
// memory size
ADDXMLINT32U(machine->GetMemorySize, "memory");
// memory balloon size
ADDXMLINT32U(machine->GetMemoryBalloonSize, "memoryballoon");
// page fusion
ADDXMLBOOL(machine->GetPageFusionEnabled, "pagefusion");
// vram size
ADDXMLINT32U(machine->GetVRAMSize, "vram");
// hpet
ADDXMLBOOL(machine->GetHPETEnabled, "hpet");
// cpu count
ADDXMLINT32U(machine->GetCPUCount, "cpus");
// cpu execution cap
ADDXMLINT32U(machine->GetCPUExecutionCap, "cpucap");
// cpu hotplug
ADDXMLBOOL(machine->GetCPUHotPlugEnabled, "cpuhotplug");
// synthcpu
// {
// PRBool value;
// rc = machine->GetCPUProperty(CPUPropertyType_Synthetic, &value);
// if (NS_SUCCEEDED(rc)) {
// WRITEXMLBOOL("synthcpu", value);
// }
// }
// firmware type
ADDXMLENUM(machine->GetFirmwareType, "firmware", firmwareTypeConverter);
// bios settings
{
nsCOMPtr<IBIOSSettings> value;
rc = machine->GetBIOSSettings(getter_AddRefs(value));
if (NS_SUCCEEDED(rc)) {
exportVirtualBoxBIOSSettings(value, writer);
}
}
// boot order
{
PRUint32 bootPositions;
rc = systemProperties->GetMaxBootPosition(&bootPositions);
if (NS_SUCCEEDED(rc)) {
for (PRUint32 i = 1; i <= bootPositions; i++) {
PRUint32 value;
rc = machine->GetBootOrder(i, &value);
if (NS_SUCCEEDED(rc)) {
char name[256];
sprintf(name, "boot%d", i);
WRITEXMLENUM(name, value, deviceTypeConverter);
}
}
}
}
// pae
{
PRBool value;
rc = machine->GetCPUProperty(CPUPropertyType_PAE, &value);
if (NS_SUCCEEDED(rc)) {
WRITEXMLBOOL("pae", value);
}
}
// rtc use utc
ADDXMLBOOL(machine->GetRTCUseUTC, "rtcuseutc");
// monitor count
ADDXMLINT32U(machine->GetMonitorCount, "monitorcount");
// accelerate 3D
ADDXMLBOOL(machine->GetAccelerate3DEnabled, "accelerate3d");
// accelerate 2D video
ADDXMLBOOL(machine->GetAccelerate2DVideoEnabled, "accelerate2dvideo");
// hwvirtex
{
PRBool value;
rc = machine->GetCPUProperty(HWVirtExPropertyType_Enabled, &value);
if (NS_SUCCEEDED(rc)) {
WRITEXMLBOOL("hwvirtex", value);
}
}
// vtxvpid
{
PRBool value;
rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_VPID, &value);
if (NS_SUCCEEDED(rc)) {
WRITEXMLBOOL("vtxvpid", value);
}
}
// nestedpaging
{
PRBool value;
rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_NestedPaging, &value);
if (NS_SUCCEEDED(rc)) {
WRITEXMLBOOL("nestedpaging", value);
}
}
// unrestrictedexec
{
PRBool value;
rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_UnrestrictedExecution, &value);
if (NS_SUCCEEDED(rc)) {
WRITEXMLBOOL("unrestrictedexec", value);
}
}
// largepages
{
PRBool value;
rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_LargePages, &value);
if (NS_SUCCEEDED(rc)) {
WRITEXMLBOOL("largepages", value);
}
}
// force
{
PRBool value;
rc = machine->GetHWVirtExProperty(HWVirtExPropertyType_Force, &value);
if (NS_SUCCEEDED(rc)) {
WRITEXMLBOOL("hwforce", value);
}
}
// io cache
ADDXMLBOOL(machine->GetIOCacheEnabled, "iocache");
// io cache size
ADDXMLINT32U(machine->GetIOCacheSize, "iocachesize");
// chipset type
ADDXMLENUM(machine->GetChipsetType, "chipset", chipsetTypeConverter);
// pointing hid type
ADDXMLENUM(machine->GetPointingHIDType, "mouse", pointingHidTypeConverter);
// keyboard hid type
ADDXMLENUM(machine->GetKeyboardHIDType, "keyboard", keyboardHidTypeConverter);
// clipboard mode
ADDXMLENUM(machine->GetClipboardMode, "clipboard", clipboardModeConverter);
// vm state
ADDXMLENUM(machine->GetState, "state", stateConverter);
// vm state change
ADDXMLTIMESTAMP(machine->GetLastStateChange, "statechanged");
// teleporterenabled, teleporterport, teleporteraddress, teleporterpassword
// storage controller
{
IStorageController **storageControllers = nsnull;
PRUint32 storageControllersCount = 0;
rc = machine->GetStorageControllers(&storageControllersCount, &storageControllers);
if (NS_SUCCEEDED(rc)) {
for (PRUint32 i = 0; i < storageControllersCount; i++) {
exportVirtualBoxStorageController(storageControllers[i], i, writer);
}
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(storageControllersCount, storageControllers);
}
// medium attachments
{
IMediumAttachment **mediumAttachments = nsnull;
PRUint32 mediumAttachmentsCount = 0;
rc = machine->GetMediumAttachments(&mediumAttachmentsCount, &mediumAttachments);
if (NS_SUCCEEDED(rc)) {
for (PRUint32 i = 0; i < mediumAttachmentsCount; i++) {
exportVirtualBoxMediumAttachment(mediumAttachments[i], writer);
}
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(mediumAttachmentsCount, mediumAttachments);
}
// network adapters
{
PRUint32 networkAdaptersCount;
PRUint32 chipsetType;
rc = machine->GetChipsetType(&chipsetType);
if (NS_SUCCEEDED(rc)) {
rc = systemProperties->GetMaxNetworkAdapters(chipsetType, &networkAdaptersCount);
if (NS_SUCCEEDED(rc)) {
for (PRUint32 i = 0; i < networkAdaptersCount; i++) {
nsCOMPtr<INetworkAdapter> networkAdapter;
rc = machine->GetNetworkAdapter(i, getter_AddRefs(networkAdapter));
if (NS_SUCCEEDED(rc)) {
exportVirtualBoxNetworkAdapter(networkAdapter, i + 1, writer);
}
}
}
}
}
// uartX
// audio adapter
{
nsCOMPtr<IAudioAdapter> value;
rc = machine->GetAudioAdapter(getter_AddRefs(value));
if (NS_SUCCEEDED(rc)) {
exportVirtualBoxAudioAdapter(value, writer);
}
}
// vrde server
{
nsCOMPtr<IVRDEServer> value;
rc = machine->GetVRDEServer(getter_AddRefs(value));
if (NS_SUCCEEDED(rc)) {
exportVirtualBoxVRDEServer(value, writer);
}
}
// usb controllers
// {
// nsCOMPtr<IUSBController> value;
// rc = machine->GetUSBController(getter_AddRefs(value));
// if (NS_SUCCEEDED(rc)) {
// exportVirtualBoxUSBController(value, writer);
// }
// }
// guest properties
{
PRUnichar **names = nsnull;
PRUnichar **values = nsnull;
PRInt64 *timestamps = nsnull;
PRUnichar **flags = nsnull;
PRUint32 namesCount = 0;
PRUint32 valuesCount = 0;
PRUint32 timestampsCount = 0;
PRUint32 flagsCount = 0;
rc = machine->EnumerateGuestProperties((const PRUnichar*)nsnull, &namesCount, &names, &valuesCount, &values, ×tampsCount, ×tamps, &flagsCount, &flags);
if (NS_SUCCEEDED(rc)) {
for (PRUint32 i = 0; i < namesCount; i++) {
nsAutoString name(names[i]);
nsAutoString value(values[i]);
PRUint64 timestamp = timestamps[i];
nsAutoString flag(flags[i]);
WRITEXMLSTRING(convertString(name).c_str(), convertString(value));
}
}
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(namesCount, names);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(valuesCount, values);
nsMemory::Free(timestamps);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(flagsCount, flags);
}
xmlTextWriterEndElement(writer);
}
}
NS_IMETHODIMP nsSMimeJSHelper::GetRecipientCertsInfo(
nsIMsgCompFields *compFields,
PRUint32 *count,
PRUnichar ***emailAddresses,
PRInt32 **certVerification,
PRUnichar ***certIssuedInfos,
PRUnichar ***certExpiresInfos,
nsIX509Cert ***certs,
PRBool *canEncrypt)
{
NS_ENSURE_ARG_POINTER(count);
*count = 0;
NS_ENSURE_ARG_POINTER(emailAddresses);
NS_ENSURE_ARG_POINTER(certVerification);
NS_ENSURE_ARG_POINTER(certIssuedInfos);
NS_ENSURE_ARG_POINTER(certExpiresInfos);
NS_ENSURE_ARG_POINTER(certs);
NS_ENSURE_ARG_POINTER(canEncrypt);
NS_ENSURE_ARG_POINTER(compFields);
PRUint32 mailbox_count;
char *mailbox_list;
nsresult rv = getMailboxList(compFields, &mailbox_count, &mailbox_list);
if (NS_FAILED(rv))
return rv;
if (!mailbox_list)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIX509CertDB> certdb = do_GetService(NS_X509CERTDB_CONTRACTID);
*count = mailbox_count;
*canEncrypt = PR_FALSE;
rv = NS_OK;
if (mailbox_count)
{
PRUnichar **outEA = static_cast<PRUnichar **>(nsMemory::Alloc(mailbox_count * sizeof(PRUnichar *)));
PRInt32 *outCV = static_cast<PRInt32 *>(nsMemory::Alloc(mailbox_count * sizeof(PRInt32)));
PRUnichar **outCII = static_cast<PRUnichar **>(nsMemory::Alloc(mailbox_count * sizeof(PRUnichar *)));
PRUnichar **outCEI = static_cast<PRUnichar **>(nsMemory::Alloc(mailbox_count * sizeof(PRUnichar *)));
nsIX509Cert **outCerts = static_cast<nsIX509Cert **>(nsMemory::Alloc(mailbox_count * sizeof(nsIX509Cert *)));
if (!outEA || !outCV || !outCII || !outCEI || !outCerts)
{
nsMemory::Free(outEA);
nsMemory::Free(outCV);
nsMemory::Free(outCII);
nsMemory::Free(outCEI);
nsMemory::Free(outCerts);
rv = NS_ERROR_OUT_OF_MEMORY;
}
else
{
PRUnichar **iEA = outEA;
PRInt32 *iCV = outCV;
PRUnichar **iCII = outCII;
PRUnichar **iCEI = outCEI;
nsIX509Cert **iCert = outCerts;
PRBool found_blocker = PR_FALSE;
PRBool memory_failure = PR_FALSE;
const char *walk = mailbox_list;
// To understand this loop, especially the "+= strlen +1", look at the documentation
// of ParseHeaderAddresses. Basically, it returns a list of zero terminated strings.
for (PRUint32 i = 0;
i < mailbox_count;
++i, ++iEA, ++iCV, ++iCII, ++iCEI, ++iCert, walk += strlen(walk) + 1)
{
*iCert = nsnull;
*iCV = 0;
*iCII = nsnull;
*iCEI = nsnull;
if (memory_failure) {
*iEA = nsnull;
continue;
}
nsDependentCString email(walk);
*iEA = ToNewUnicode(email);
if (!*iEA) {
memory_failure = PR_TRUE;
continue;
}
nsCString email_lowercase;
ToLowerCase(email, email_lowercase);
nsCOMPtr<nsIX509Cert> cert;
if (NS_SUCCEEDED(certdb->FindCertByEmailAddress(nsnull, email_lowercase.get(), getter_AddRefs(cert)))
&& cert)
{
*iCert = cert;
NS_ADDREF(*iCert);
PRUint32 verification_result;
if (NS_FAILED(
cert->VerifyForUsage(nsIX509Cert::CERT_USAGE_EmailRecipient, &verification_result)))
{
*iCV = nsIX509Cert::NOT_VERIFIED_UNKNOWN;
found_blocker = PR_TRUE;
}
else
{
*iCV = verification_result;
if (verification_result != nsIX509Cert::VERIFIED_OK)
{
found_blocker = PR_TRUE;
}
}
nsCOMPtr<nsIX509CertValidity> validity;
rv = cert->GetValidity(getter_AddRefs(validity));
if (NS_SUCCEEDED(rv)) {
nsString id, ed;
if (NS_SUCCEEDED(validity->GetNotBeforeLocalDay(id)))
{
*iCII = ToNewUnicode(id);
if (!*iCII) {
memory_failure = PR_TRUE;
continue;
}
}
if (NS_SUCCEEDED(validity->GetNotAfterLocalDay(ed)))
{
*iCEI = ToNewUnicode(ed);
if (!*iCEI) {
memory_failure = PR_TRUE;
continue;
}
}
}
}
else
{
found_blocker = PR_TRUE;
}
}
if (memory_failure) {
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mailbox_count, outEA);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mailbox_count, outCII);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mailbox_count, outCEI);
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(mailbox_count, outCerts);
nsMemory::Free(outCV);
rv = NS_ERROR_OUT_OF_MEMORY;
}
else {
if (mailbox_count > 0 && !found_blocker)
{
*canEncrypt = PR_TRUE;
}
*emailAddresses = outEA;
*certVerification = outCV;
*certIssuedInfos = outCII;
*certExpiresInfos = outCEI;
*certs = outCerts;
}
}
}
if (mailbox_list) {
nsMemory::Free(mailbox_list);
}
return rv;
}
nsresult
WSPProxy::ArrayXPTCMiniVariantToVariant(uint8 aTypeTag,
nsXPTCMiniVariant aResult,
PRUint32 aLength,
nsIInterfaceInfo* aInterfaceInfo,
nsIVariant** aVariant)
{
nsresult rv;
nsCOMPtr<nsIWritableVariant> retvar =
do_CreateInstance(NS_VARIANT_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
if (aLength) {
PRUint32 i = 0;
void* array = aResult.val.p;
void* entries;
nsISupports** entriesSup = nsnull;
const nsIID* iid = nsnull;
switch (aTypeTag) {
case nsXPTType::T_I8:
case nsXPTType::T_I16:
case nsXPTType::T_I32:
case nsXPTType::T_I64:
case nsXPTType::T_U8:
case nsXPTType::T_U16:
case nsXPTType::T_U32:
case nsXPTType::T_U64:
case nsXPTType::T_FLOAT:
case nsXPTType::T_DOUBLE:
case nsXPTType::T_BOOL:
case nsXPTType::T_CHAR:
case nsXPTType::T_WCHAR:
case nsXPTType::T_CHAR_STR:
case nsXPTType::T_WCHAR_STR:
entries = array;
break;
case nsXPTType::T_INTERFACE:
{
aInterfaceInfo->GetIIDShared(&iid);
if (iid->Equals(NS_GET_IID(nsIVariant))) {
entries = array;
}
else {
entriesSup = (nsISupports**)nsMemory::Alloc(aLength *
sizeof(nsISupports*));
if (!entriesSup) {
return NS_ERROR_OUT_OF_MEMORY;
}
const nsIID& propbagIID = NS_GET_IID(nsIPropertyBag);
iid = &propbagIID;
entries = (void*)entriesSup;
for(i = 0; i < aLength; i++) {
nsISupports* instance = *((nsISupports**)array + i);
nsISupports** outptr = entriesSup + i;
if (instance) {
nsCOMPtr<nsIPropertyBag> propBag;
rv = WrapInPropertyBag(instance, aInterfaceInfo,
getter_AddRefs(propBag));
if (NS_FAILED(rv)) {
break;
}
propBag->QueryInterface(NS_GET_IID(nsISupports),
(void**)outptr);
}
else {
*outptr = nsnull;
}
}
}
aTypeTag = nsXPTType::T_INTERFACE_IS;
break;
}
default:
NS_ERROR("Conversion of illegal array type");
return NS_ERROR_FAILURE;
}
if (NS_SUCCEEDED(rv)) {
rv = retvar->SetAsArray(aTypeTag, iid, aLength, entries);
}
if (entriesSup) {
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(i, entriesSup);
}
}
else {
retvar->SetAsEmpty();
}
if (NS_SUCCEEDED(rv)) {
*aVariant = retvar;
NS_ADDREF(*aVariant);
}
return rv;
}
/**
* Asynchronous processing :
* 1-> WSPProxy::CallMethod
* 2 -> WSPCallContext::CallAsync
* 3 -> nsSOAPCall::AsyncInvoke
* 4 -> nsXXXSOAPTransport::AsyncCall
* 5 -> nsIXMLHttpRequest::Send, nsXXXSOAPTransportCompletion::AddEventListener
* ---- asynchronous ----
* 6 -> nsXXXSOAPTransportCompletion::HandleEvent
* 7 -> WSPCallContext::HandleResponse,
* WSPCallContext::CallCompletionListener
* 8 -> nsSOAPBlock::SetSchemaType, nsSOAPBlock::GetValue
* 9 -> nsSOAPEncoding::Decode, nsDefaultSOAPDecode::Decode
* 10 -> WSPProxy::CallCompleted
*/
NS_IMETHODIMP
WSPProxy::CallMethod(PRUint16 methodIndex,
const XPTMethodDescriptor* info,
nsXPTCMiniVariant* params)
{
nsresult rv;
nsCOMPtr<nsIWebServiceCallContext> cc;
nsCOMPtr<nsIWSDLBinding> binding;
if (methodIndex < 3) {
NS_ERROR("WSPProxy: bad method index");
return NS_ERROR_FAILURE;
}
// The first method in the interface for async callers is the
// one to set the async listener
if (mIsAsync && (methodIndex == 3)) {
nsISupports* listener = static_cast<nsISupports*>(params[0].val.p);
mAsyncListener = listener;
return NS_OK;
}
PRUint32 methodOffset;
if (mIsAsync) {
methodOffset = 4;
}
else {
methodOffset = 3;
}
nsCOMPtr<nsIWSDLOperation> operation;
rv = mPort->GetOperation(methodIndex - methodOffset,
getter_AddRefs(operation));
if (NS_FAILED(rv)) {
return rv;
}
nsCOMPtr<nsIWSDLMessage> input;
rv = operation->GetInput(getter_AddRefs(input));
if (NS_FAILED(rv)) {
return rv;
}
// Create the call instance
nsCOMPtr<nsISOAPCall> call = do_CreateInstance(NS_SOAPCALL_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
nsCOMPtr<nsISOAPEncoding> encoding =
do_CreateInstance(NS_SOAPENCODING_CONTRACTID, &rv);
if (NS_FAILED(rv)) {
return rv;
}
call->SetEncoding(encoding);
// Get the method name and target object uri
nsAutoString methodName, targetObjectURI;
rv = operation->GetBinding(getter_AddRefs(binding));
if (NS_FAILED(rv)) {
return rv;
}
nsCOMPtr<nsISOAPOperationBinding> operationBinding =
do_QueryInterface(binding, &rv);
if (NS_FAILED(rv)) {
return rv;
}
nsAutoString soapAction;
operationBinding->GetSoapAction(soapAction);
call->SetActionURI(soapAction);
PRUint16 style;
operationBinding->GetStyle(&style);
// If the style is RPC, find the method name and target object URI.
// If it is document-style, these are both left blank.
if (style == nsISOAPPortBinding::STYLE_RPC) {
operation->GetName(methodName);
rv = input->GetBinding(getter_AddRefs(binding));
if (NS_FAILED(rv)) {
return rv;
}
nsCOMPtr<nsISOAPMessageBinding> messageBinding =
do_QueryInterface(binding, &rv);
if (NS_FAILED(rv)) {
return rv;
}
messageBinding->GetNamespace(targetObjectURI);
}
// Set the transport URI
rv = mPort->GetBinding(getter_AddRefs(binding));
if (NS_FAILED(rv)) {
return rv;
}
nsCOMPtr<nsISOAPPortBinding> portBinding = do_QueryInterface(binding, &rv);
if (NS_FAILED(rv)) {
return rv;
}
nsAutoString address;
portBinding->GetAddress(address);
rv = call->SetTransportURI(address);
if (NS_FAILED(rv)) {
return rv;
}
PRUint16 version;
portBinding->GetSoapVersion(&version);
if (version == nsISOAPMessage::VERSION_UNKNOWN) {
version = nsISOAPMessage::VERSION_1_1;
}
// Set up the parameters to the call
PRUint32 i, partCount;
input->GetPartCount(&partCount);
PRUint32 maxParamIndex = info->num_args - 1;
// Iterate through the parts to figure out how many are
// body vs. header blocks
nsCOMPtr<nsIWSDLPart> part;
PRUint32 headerCount = 0, bodyCount = 0;
for (i = 0; i < partCount; i++) {
rv = input->GetPart(i, getter_AddRefs(part));
if (NS_FAILED(rv)) {
return rv;
}
rv = part->GetBinding(getter_AddRefs(binding));
if (NS_FAILED(rv)) {
return rv;
}
nsCOMPtr<nsISOAPPartBinding> partBinding = do_QueryInterface(binding, &rv);
if (NS_FAILED(rv)) {
return rv;
}
PRUint16 location;
partBinding->GetLocation(&location);
if (location == nsISOAPPartBinding::LOCATION_HEADER) {
headerCount++;
}
else if (location == nsISOAPPartBinding::LOCATION_BODY) {
bodyCount++;
}
}
// Allocate parameter and header blocks
nsISOAPParameter** bodyBlocks = nsnull;
if (bodyCount) {
bodyBlocks = static_cast<nsISOAPParameter**>
(nsMemory::Alloc(bodyCount * sizeof(nsISOAPParameter*)));
if (!bodyBlocks) {
return NS_ERROR_OUT_OF_MEMORY;
}
for (i = 0; i < bodyCount; i++) {
rv = CallCreateInstance(NS_SOAPPARAMETER_CONTRACTID, &bodyBlocks[i]);
if (NS_FAILED(rv)) {
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(i, bodyBlocks);
return rv;
}
}
}
nsISOAPHeaderBlock** headerBlocks = nsnull;
if (headerCount) {
headerBlocks = static_cast<nsISOAPHeaderBlock**>
(nsMemory::Alloc(headerCount * sizeof(nsISOAPHeaderBlock*)));
if (!headerBlocks) {
if (bodyBlocks) {
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(bodyCount, bodyBlocks);
}
return NS_ERROR_OUT_OF_MEMORY;
}
for (i = 0; i < headerCount; i++) {
rv = CallCreateInstance(NS_SOAPHEADERBLOCK_CONTRACTID, &headerBlocks[i]);
if (NS_FAILED(rv)) {
if (bodyBlocks) {
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(bodyCount, bodyBlocks);
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(i, headerBlocks);
return rv;
}
}
}
// Now iterate through the parameters and set up the parameter blocks
PRUint32 bodyEntry = 0, headerEntry = 0, paramIndex = 0;
for (i = 0; i < partCount; paramIndex++, i++) {
input->GetPart(i, getter_AddRefs(part));
part->GetBinding(getter_AddRefs(binding));
nsCOMPtr<nsISOAPPartBinding> partBinding = do_QueryInterface(binding);
PRUint16 location;
partBinding->GetLocation(&location);
nsCOMPtr<nsISOAPBlock> block;
if (location == nsISOAPPartBinding::LOCATION_HEADER) {
block = do_QueryInterface(headerBlocks[headerEntry++]);
}
else if (location == nsISOAPPartBinding::LOCATION_BODY) {
block = do_QueryInterface(bodyBlocks[bodyEntry++]);
}
if (!block) {
rv = NS_ERROR_FAILURE;
goto call_method_end;
}
// Get the name, namespaceURI and type of the block based on
// information from the WSDL part. If the schema component
// associated with the part is an element, these values come
// from the schema description of the element. If it is a
// type, then the values are gathered from elsewhere.
nsCOMPtr<nsISchemaComponent> schemaComponent;
rv = part->GetSchemaComponent(getter_AddRefs(schemaComponent));
if (NS_FAILED(rv)) {
goto call_method_end;
}
nsCOMPtr<nsISchemaType> type;
nsAutoString blockName, blockNamespace;
nsCOMPtr<nsISchemaElement> element = do_QueryInterface(schemaComponent);
if (element) {
rv = element->GetType(getter_AddRefs(type));
if (NS_FAILED(rv)) {
goto call_method_end;
}
element->GetName(blockName);
element->GetTargetNamespace(blockNamespace);
}
else {
type = do_QueryInterface(schemaComponent);
nsAutoString paramName;
part->GetName(paramName);
blockName.Assign(paramName);
partBinding->GetNamespace(blockNamespace);
}
block->SetName(blockName);
block->SetNamespaceURI(blockNamespace);
block->SetSchemaType(type);
nsAutoString encodingStyle;
PRUint16 use;
partBinding->GetUse(&use);
// XXX Need a way to specify that a block should not be
// encoded.
if (use == nsISOAPPartBinding::USE_ENCODED) {
partBinding->GetEncodingStyle(encodingStyle);
if (!encodingStyle.IsEmpty()) {
nsCOMPtr<nsISOAPEncoding> partEncoding;
encoding->GetAssociatedEncoding(encodingStyle, PR_FALSE,
getter_AddRefs(partEncoding));
block->SetEncoding(partEncoding);
}
}
// Look ahead in the param info array to see if the current part has to be
// treated as an array. If so then get the array length from the current
// param and increment the param index.
PRUint32 arrayLength;
if (paramIndex < maxParamIndex &&
nsXPTType(info->params[paramIndex + 1].type.prefix).IsArray()) {
arrayLength = params[paramIndex++].val.u32;
}
else {
arrayLength = 0;
}
NS_ASSERTION(paramIndex <= maxParamIndex,
"WSDL/IInfo param count mismatch");
const nsXPTParamInfo& paramInfo = info->params[paramIndex];
nsCOMPtr<nsIVariant> value;
rv = ParameterToVariant(mPrimaryInterface, methodIndex,
¶mInfo, params[paramIndex],
arrayLength, getter_AddRefs(value));
if (NS_FAILED(rv)) {
goto call_method_end;
}
block->SetValue(value);
}
// Encode the parameters to the call
rv = call->Encode(version,
methodName, targetObjectURI,
headerCount, headerBlocks,
bodyCount, bodyBlocks);
if (NS_FAILED(rv)) {
goto call_method_end;
}
WSPCallContext* ccInst;
ccInst = new WSPCallContext(this, call, methodName, operation);
if (!ccInst) {
rv = NS_ERROR_OUT_OF_MEMORY;
goto call_method_end;
}
cc = ccInst;
if (mIsAsync) {
PRUint8 pcount;
pcount = info->num_args;
// There has to be at least one parameter - the retval.
if (pcount == 0) {
rv = NS_ERROR_FAILURE;
goto call_method_end;
}
#ifdef DEBUG
// The last one should be the retval.
const nsXPTParamInfo& retParamInfo = info->params[pcount - 1];
if (!retParamInfo.IsRetval()) {
rv = NS_ERROR_FAILURE;
goto call_method_end;
}
// It should be an interface pointer
const nsXPTType& retType = retParamInfo.GetType();
if (!retType.IsInterfacePointer()) {
rv = NS_ERROR_FAILURE;
goto call_method_end;
}
#endif
nsIWebServiceCallContext** retval =
static_cast<nsIWebServiceCallContext**>(params[pcount-1].val.p);
if (!retval) {
rv = NS_ERROR_FAILURE;
goto call_method_end;
}
*retval = cc;
NS_ADDREF(*retval);
rv = ccInst->CallAsync(methodIndex, mAsyncListener);
if (NS_FAILED(rv)) {
goto call_method_end;
}
mPendingCalls.AppendObject(ccInst);
}
else {
rv = ccInst->CallSync(methodIndex, params);
}
call_method_end:
if (bodyBlocks) {
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(bodyCount, bodyBlocks);
}
if (headerBlocks) {
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(headerCount, headerBlocks);
}
return rv;
}
nsresult
WSPProxy::VariantToArrayValue(uint8 aTypeTag,
nsXPTCMiniVariant* aResultSize,
nsXPTCMiniVariant* aResultArray,
nsIInterfaceInfo* aInterfaceInfo,
nsIVariant* aProperty)
{
void* array;
PRUint16 type;
PRUint32 count;
nsIID arrayIID;
nsresult rv = aProperty->GetAsArray(&type, &arrayIID, &count, &array);
if (NS_FAILED(rv)) {
return rv;
}
aResultSize->val.u32 = count;
switch (aTypeTag) {
case nsXPTType::T_I8:
case nsXPTType::T_U8:
case nsXPTType::T_I16:
case nsXPTType::T_U16:
case nsXPTType::T_I32:
case nsXPTType::T_U32:
case nsXPTType::T_I64:
case nsXPTType::T_U64:
case nsXPTType::T_FLOAT:
case nsXPTType::T_DOUBLE:
case nsXPTType::T_BOOL:
case nsXPTType::T_CHAR:
case nsXPTType::T_WCHAR:
case nsXPTType::T_CHAR_STR:
case nsXPTType::T_WCHAR_STR:
aResultArray->val.p = array;
break;
case nsXPTType::T_INTERFACE:
case nsXPTType::T_INTERFACE_IS:
{
if (arrayIID.Equals(NS_GET_IID(nsIVariant))) {
aResultArray->val.p = array;
}
else if (!arrayIID.Equals(NS_GET_IID(nsIPropertyBag))) {
NS_ERROR("Array of complex types should be represented by property "
"bags");
return NS_ERROR_FAILURE;
}
else {
nsISupports** outptr =
(nsISupports**)nsMemory::Alloc(count * sizeof(nsISupports*));
if (!outptr) {
return NS_ERROR_OUT_OF_MEMORY;
}
nsISupports** arraySup = (nsISupports**)array;
const nsIID* iid;
aInterfaceInfo->GetIIDShared(&iid);
PRUint32 i;
for (i = 0; i < count; i++) {
nsCOMPtr<nsIPropertyBag> propBag(do_QueryInterface(arraySup[i]));
if (!propBag) {
*(outptr + i) = nsnull;
}
else {
nsCOMPtr<nsISupports> wrapper;
rv = WrapInComplexType(propBag, aInterfaceInfo,
getter_AddRefs(wrapper));
if (NS_FAILED(rv)) {
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(i, outptr);
return rv;
}
rv = wrapper->QueryInterface(*iid, (void**)(outptr + i));
if (NS_FAILED(rv)) {
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(i, outptr);
return rv;
}
}
}
aResultArray->val.p = outptr;
}
break;
}
default:
NS_ERROR("Conversion of illegal array type");
return NS_ERROR_FAILURE;
}
return NS_OK;
}
