/* void getInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result); */ NS_IMETHODIMP nsSDRContext::GetInterface(const nsIID & uuid, void * *result) { if (!uuid.Equals(NS_GET_IID(nsIPrompt))) return NS_ERROR_NO_INTERFACE; nsCOMPtr<nsIPrompt> prompter; nsresult rv; nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv)); if (NS_FAILED(rv)) return rv; rv = wwatch->GetNewPrompter(0, getter_AddRefs(prompter)); if (!prompter) return NS_ERROR_FAILURE; nsCOMPtr<nsIPrompt> proxyPrompt; rv = NS_GetProxyForObject(NS_PROXY_TO_MAIN_THREAD, NS_GET_IID(nsIPrompt), prompter, NS_PROXY_SYNC, getter_AddRefs(proxyPrompt)); if (!proxyPrompt) return NS_ERROR_FAILURE; *result = proxyPrompt; NS_ADDREF((nsIPrompt*)*result); return NS_OK; }
nsresult nsMsgAskBooleanQuestionByString(nsIPrompt * aPrompt, const PRUnichar * msg, PRBool *answer, const PRUnichar * windowTitle) { nsresult rv; PRInt32 result; nsCOMPtr<nsIPrompt> dialog = aPrompt; if ((!msg) || (!*msg)) return NS_ERROR_INVALID_ARG; if (!dialog) { nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); if (wwatch) wwatch->GetNewPrompter(0, getter_AddRefs(dialog)); } if (dialog) { rv = dialog->Confirm(windowTitle, msg, &result); if (result == 1) *answer = PR_TRUE; else *answer = PR_FALSE; } return NS_OK; }
PtWidget_t *nsUnknownContentTypeHandler::GetWebBrowser(nsIDOMWindow *aWindow) { nsCOMPtr<nsIWebBrowserChrome> chrome; PtWidget_t *val = 0; nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService("@mozilla.org/embedcomp/window-watcher;1")); if (!wwatch) return nsnull; if( wwatch ) { nsCOMPtr<nsIDOMWindow> fosterParent; if (!aWindow) { // it will be a dependent window. try to find a foster parent. wwatch->GetActiveWindow(getter_AddRefs(fosterParent)); aWindow = fosterParent; } wwatch->GetChromeForWindow(aWindow, getter_AddRefs(chrome)); } if (chrome) { nsCOMPtr<nsIEmbeddingSiteWindow> site(do_QueryInterface(chrome)); if (site) { site->GetSiteWindow(reinterpret_cast<void **>(&val)); } } return val; }
// Opening Thunderbird's new mail alert notification window for not supporting libnotify // aUserInitiated --> true if we are opening the alert notification in response to a user action // like clicking on the biff icon nsresult nsMessengerUnixIntegration::ShowNewAlertNotification(bool aUserInitiated) { nsresult rv; // if we are already in the process of showing an alert, don't try to show another.... if (mAlertInProgress) return NS_OK; nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); bool showAlert = true; prefBranch->GetBoolPref(SHOW_ALERT_PREF, &showAlert); if (showAlert) { nsCOMPtr<nsIMutableArray> argsArray = do_CreateInstance(NS_ARRAY_CONTRACTID); if (!argsArray) return NS_ERROR_FAILURE; // pass in the array of folders with unread messages nsCOMPtr<nsISupportsInterfacePointer> ifptr = do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); ifptr->SetData(mFoldersWithNewMail); ifptr->SetDataIID(&NS_GET_IID(nsISupportsArray)); argsArray->AppendElement(ifptr, PR_FALSE); // pass in the observer ifptr = do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr <nsISupports> supports = do_QueryInterface(static_cast<nsIMessengerOSIntegration*>(this)); ifptr->SetData(supports); ifptr->SetDataIID(&NS_GET_IID(nsIObserver)); argsArray->AppendElement(ifptr, PR_FALSE); // pass in the animation flag nsCOMPtr<nsISupportsPRBool> scriptableUserInitiated (do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); scriptableUserInitiated->SetData(aUserInitiated); argsArray->AppendElement(scriptableUserInitiated, PR_FALSE); nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); nsCOMPtr<nsIDOMWindow> newWindow; rv = wwatch->OpenWindow(0, ALERT_CHROME_URL, "_blank", "chrome,dialog=yes,titlebar=no,popup=yes", argsArray, getter_AddRefs(newWindow)); mAlertInProgress = PR_TRUE; } // if the user has turned off the mail alert, or openWindow generated an error, // then go straight to the system tray. if (!showAlert || NS_FAILED(rv)) AlertFinished(); return rv; }
NS_IMETHODIMP nsMessengerBootstrap::OpenMessengerWindowWithUri(const char *windowType, const char * aFolderURI, nsMsgKey aMessageKey) { bool standAloneMsgWindow = false; nsCAutoString chromeUrl("chrome://messenger/content/"); if (windowType && !strcmp(windowType, "mail:messageWindow")) { chromeUrl.Append("messageWindow.xul"); standAloneMsgWindow = true; } nsCOMPtr<nsISupportsArray> argsArray; nsresult rv = NS_NewISupportsArray(getter_AddRefs(argsArray)); NS_ENSURE_SUCCESS(rv, rv); // create scriptable versions of our strings that we can store in our nsISupportsArray.... if (aFolderURI) { if (standAloneMsgWindow) { nsCOMPtr <nsIMsgFolder> folder; rv = GetExistingFolder(nsDependentCString(aFolderURI), getter_AddRefs(folder)); NS_ENSURE_SUCCESS(rv, rv); nsCAutoString msgUri; folder->GetBaseMessageURI(msgUri); nsCOMPtr<nsISupportsCString> scriptableMsgURI (do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID)); NS_ENSURE_TRUE(scriptableMsgURI, NS_ERROR_FAILURE); msgUri.Append('#'); msgUri.AppendInt(aMessageKey, 10); scriptableMsgURI->SetData(msgUri); argsArray->AppendElement(scriptableMsgURI); } nsCOMPtr<nsISupportsCString> scriptableFolderURI (do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID)); NS_ENSURE_TRUE(scriptableFolderURI, NS_ERROR_FAILURE); scriptableFolderURI->SetData(nsDependentCString(aFolderURI)); argsArray->AppendElement(scriptableFolderURI); if (!standAloneMsgWindow) { nsCOMPtr<nsISupportsPRUint32> scriptableMessageKey (do_CreateInstance(NS_SUPPORTS_PRUINT32_CONTRACTID)); NS_ENSURE_TRUE(scriptableMessageKey, NS_ERROR_FAILURE); scriptableMessageKey->SetData(aMessageKey); argsArray->AppendElement(scriptableMessageKey); } } nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); // we need to use the "mailnews.reuse_thread_window2" pref // to determine if we should open a new window, or use an existing one. nsCOMPtr<nsIDOMWindow> newWindow; return wwatch->OpenWindow(0, chromeUrl.get(), "_blank", "chrome,all,dialog=no", argsArray, getter_AddRefs(newWindow)); }
int InitWindowCreator(){ nsCOMPtr<nsIWindowCreator> creator(new CWindowCreator()); if (!creator) return -1; nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); if (!wwatch) return -1; return wwatch->SetWindowCreator(creator); }
/* InitializeWindowCreator creates and hands off an object with a callback to a window creation function. This is how all new windows are opened, except any created directly by the embedding app. */ nsresult InitializeWindowCreator() { // create an nsWindowCreator and give it to the WindowWatcher service nsCOMPtr<nsIWindowCreator> creator(new WindowCreator()); if (!creator) return NS_ERROR_OUT_OF_MEMORY; nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); if (!wwatch) return NS_ERROR_UNEXPECTED; return wwatch->SetWindowCreator(creator); }
//---------------------------------------------------------------------------------------- nsresult nsMacCommandLine::OpenWindow(const char *chrome, const PRUnichar *url) //---------------------------------------------------------------------------------------- { nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); nsCOMPtr<nsISupportsString> urlWrapper(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID)); if (!wwatch || !urlWrapper) return NS_ERROR_FAILURE; urlWrapper->SetData(nsDependentString(url)); nsCOMPtr<nsIDOMWindow> newWindow; nsresult rv; rv = wwatch->OpenWindow(0, chrome, "_blank", "chrome,dialog=no,all", urlWrapper, getter_AddRefs(newWindow)); return rv; }
nsresult nsMsgDisplayMessageByString(nsIPrompt * aPrompt, const PRUnichar * msg, const PRUnichar * windowTitle) { NS_ENSURE_ARG_POINTER(msg); nsresult rv; nsCOMPtr<nsIPrompt> prompt = aPrompt; if (!prompt) { nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); if (wwatch) wwatch->GetNewPrompter(0, getter_AddRefs(prompt)); } if (prompt) rv = prompt->Alert(windowTitle, msg); return NS_OK; }
/* InitializeWindowCreator creates and hands off an object with a callback to a window creation function. This is how all new windows are opened, except any created directly by the embedding app. */ nsresult InitializeWindowCreator() { // create an nsWindowCreator and give it to the WindowWatcher service WindowCreator *creatorCallback = new WindowCreator(); if (creatorCallback) { nsCOMPtr<nsIWindowCreator> windowCreator(NS_STATIC_CAST(nsIWindowCreator *, creatorCallback)); if (windowCreator) { nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); if (wwatch) { wwatch->SetWindowCreator(windowCreator); return NS_OK; } } } return NS_ERROR_FAILURE; }
static void mozilla_embed_visibility (GtkMozEmbed *embed, gboolean visibility) { MozillaEmbed *membed = MOZILLA_EMBED (embed); g_signal_emit_by_name (membed, "ge_visibility", visibility); GaleonWrapper *wrapper = MOZILLA_EMBED(membed)->priv->wrapper; nsresult rv; nsCOMPtr<nsIWindowWatcher> wwatch (do_GetService(WINDOWWATCHER_CONTRACTID, &rv)); if (NS_FAILED(rv) || !wwatch) return; nsCOMPtr<nsIDOMWindow> domWindow; rv = wrapper->GetDOMWindow(getter_AddRefs(domWindow)); if(NS_FAILED(rv) || !domWindow) return; rv = wwatch->SetActiveWindow(domWindow); }
NS_IMETHODIMP nsAbManager::Handle(nsICommandLine* aCmdLine) { nsresult rv; bool found; rv = aCmdLine->HandleFlag(NS_LITERAL_STRING("addressbook"), PR_FALSE, &found); NS_ENSURE_SUCCESS(rv, rv); if (!found) return NS_OK; nsCOMPtr<nsIWindowWatcher> wwatch (do_GetService(NS_WINDOWWATCHER_CONTRACTID)); NS_ENSURE_TRUE(wwatch, NS_ERROR_FAILURE); nsCOMPtr<nsIDOMWindow> opened; wwatch->OpenWindow(nsnull, "chrome://messenger/content/addressbook/addressbook.xul", "_blank", "chrome,extrachrome,menubar,resizable,scrollbars,status,toolbar", nsnull, getter_AddRefs(opened)); aCmdLine->SetPreventDefault(PR_TRUE); return NS_OK; }
NS_IMETHODIMP nsCRLManager::ImportCrl (PRUint8 *aData, PRUint32 aLength, nsIURI * aURI, PRUint32 aType, PRBool doSilentDonwload, const PRUnichar* crlKey) { nsNSSShutDownPreventionLock locker; nsresult rv; PRArenaPool *arena = NULL; CERTCertificate *caCert; SECItem derName = { siBuffer, NULL, 0 }; SECItem derCrl; CERTSignedData sd; SECStatus sec_rv; CERTSignedCrl *crl; nsCAutoString url; nsCOMPtr<nsICRLInfo> crlData; PRBool importSuccessful; PRInt32 errorCode; nsString errorMessage; nsCOMPtr<nsINSSComponent> nssComponent(do_GetService(kNSSComponentCID, &rv)); if (NS_FAILED(rv)) return rv; aURI->GetSpec(url); arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE); if (!arena) { goto loser; } memset(&sd, 0, sizeof(sd)); derCrl.data = (unsigned char*)aData; derCrl.len = aLength; sec_rv = CERT_KeyFromDERCrl(arena, &derCrl, &derName); if (sec_rv != SECSuccess) { goto loser; } caCert = CERT_FindCertByName(CERT_GetDefaultCertDB(), &derName); if (!caCert) { if (aType == SEC_KRL_TYPE){ goto loser; } } else { sec_rv = SEC_ASN1DecodeItem(arena, &sd, SEC_ASN1_GET(CERT_SignedDataTemplate), &derCrl); if (sec_rv != SECSuccess) { goto loser; } sec_rv = CERT_VerifySignedData(&sd, caCert, PR_Now(), nsnull); if (sec_rv != SECSuccess) { goto loser; } } crl = SEC_NewCrl(CERT_GetDefaultCertDB(), const_cast<char*>(url.get()), &derCrl, aType); if (!crl) { goto loser; } crlData = new nsCRLInfo(crl); SSL_ClearSessionCache(); SEC_DestroyCrl(crl); importSuccessful = PR_TRUE; goto done; loser: importSuccessful = PR_FALSE; errorCode = PR_GetError(); switch (errorCode) { case SEC_ERROR_CRL_EXPIRED: nssComponent->GetPIPNSSBundleString("CrlImportFailureExpired", errorMessage); break; case SEC_ERROR_CRL_BAD_SIGNATURE: nssComponent->GetPIPNSSBundleString("CrlImportFailureBadSignature", errorMessage); break; case SEC_ERROR_CRL_INVALID: nssComponent->GetPIPNSSBundleString("CrlImportFailureInvalid", errorMessage); break; case SEC_ERROR_OLD_CRL: nssComponent->GetPIPNSSBundleString("CrlImportFailureOld", errorMessage); break; case SEC_ERROR_CRL_NOT_YET_VALID: nssComponent->GetPIPNSSBundleString("CrlImportFailureNotYetValid", errorMessage); break; default: nssComponent->GetPIPNSSBundleString("CrlImportFailureReasonUnknown", errorMessage); errorMessage.AppendInt(errorCode,16); break; } done: if(!doSilentDonwload){ if (!importSuccessful){ nsString message; nsString temp; nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); nsCOMPtr<nsIPrompt> prompter; if (wwatch){ wwatch->GetNewPrompter(0, getter_AddRefs(prompter)); nssComponent->GetPIPNSSBundleString("CrlImportFailure1x", message); message.Append(NS_LITERAL_STRING("\n").get()); message.Append(errorMessage); nssComponent->GetPIPNSSBundleString("CrlImportFailure2", temp); message.Append(NS_LITERAL_STRING("\n").get()); message.Append(temp); if(prompter) { nsPSMUITracker tracker; if (!tracker.isUIForbidden()) { prompter->Alert(0, message.get()); } } } } else { nsCOMPtr<nsICertificateDialogs> certDialogs; // Not being able to display the success dialog should not // be a fatal error, so don't return a failure code. { nsPSMUITracker tracker; if (tracker.isUIForbidden()) { rv = NS_ERROR_NOT_AVAILABLE; } else { rv = ::getNSSDialogs(getter_AddRefs(certDialogs), NS_GET_IID(nsICertificateDialogs), NS_CERTIFICATEDIALOGS_CONTRACTID); } } if (NS_SUCCEEDED(rv)) { nsCOMPtr<nsIInterfaceRequestor> cxt = new PipUIContext(); certDialogs->CrlImportStatusDialog(cxt, crlData); } } } else { if(crlKey == nsnull){ return NS_ERROR_FAILURE; } nsCOMPtr<nsIPrefService> prefSvc = do_GetService(NS_PREFSERVICE_CONTRACTID,&rv); nsCOMPtr<nsIPrefBranch> pref = do_GetService(NS_PREFSERVICE_CONTRACTID,&rv); if (NS_FAILED(rv)){ return rv; } nsCAutoString updateErrCntPrefStr(CRL_AUTOUPDATE_ERRCNT_PREF); updateErrCntPrefStr.AppendWithConversion(crlKey); if(importSuccessful){ PRUnichar *updateTime; nsCAutoString updateTimeStr; nsCString updateURL; PRInt32 timingTypePref; double dayCnt; char *dayCntStr; nsCAutoString updateTypePrefStr(CRL_AUTOUPDATE_TIMIINGTYPE_PREF); nsCAutoString updateTimePrefStr(CRL_AUTOUPDATE_TIME_PREF); nsCAutoString updateUrlPrefStr(CRL_AUTOUPDATE_URL_PREF); nsCAutoString updateDayCntPrefStr(CRL_AUTOUPDATE_DAYCNT_PREF); nsCAutoString updateFreqCntPrefStr(CRL_AUTOUPDATE_FREQCNT_PREF); updateTypePrefStr.AppendWithConversion(crlKey); updateTimePrefStr.AppendWithConversion(crlKey); updateUrlPrefStr.AppendWithConversion(crlKey); updateDayCntPrefStr.AppendWithConversion(crlKey); updateFreqCntPrefStr.AppendWithConversion(crlKey); pref->GetIntPref(updateTypePrefStr.get(),&timingTypePref); //Compute and update the next download instant if(timingTypePref == TYPE_AUTOUPDATE_TIME_BASED){ pref->GetCharPref(updateDayCntPrefStr.get(),&dayCntStr); }else{ pref->GetCharPref(updateFreqCntPrefStr.get(),&dayCntStr); } dayCnt = atof(dayCntStr); nsMemory::Free(dayCntStr); PRBool toBeRescheduled = PR_FALSE; if(NS_SUCCEEDED(ComputeNextAutoUpdateTime(crlData, timingTypePref, dayCnt, &updateTime))){ updateTimeStr.AssignWithConversion(updateTime); nsMemory::Free(updateTime); pref->SetCharPref(updateTimePrefStr.get(),updateTimeStr.get()); //Now, check if this update time is already in the past. This would //imply we have downloaded the same crl, or there is something wrong //with the next update date. We will not reschedule this crl in this //session anymore - or else, we land into a loop. It would anyway be //imported once the browser is restarted. PRTime nextTime; PR_ParseTimeString(updateTimeStr.get(),PR_TRUE, &nextTime); if(LL_CMP(nextTime, > , PR_Now())){ toBeRescheduled = PR_TRUE; } } //Update the url to download from, next time crlData->GetLastFetchURL(updateURL); pref->SetCharPref(updateUrlPrefStr.get(),updateURL.get()); pref->SetIntPref(updateErrCntPrefStr.get(),0); if (toBeRescheduled) { nsAutoString hashKey(crlKey); nssComponent->RemoveCrlFromList(hashKey); nssComponent->DefineNextTimer(); } } else{
NS_IMETHODIMP nsXPInstallManager::OpenProgressDialog(const PRUnichar **aPackageList, PRUint32 aCount, nsIObserver *aObserver) { // --- convert parameters into nsISupportArray members nsCOMPtr<nsIDialogParamBlock> list; nsresult rv = LoadParams( aCount, aPackageList, getter_AddRefs(list) ); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsISupportsInterfacePointer> listwrap(do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID)); if (listwrap) { listwrap->SetData(list); listwrap->SetDataIID(&NS_GET_IID(nsIDialogParamBlock)); } nsCOMPtr<nsISupportsInterfacePointer> callbackwrap(do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID)); if (callbackwrap) { callbackwrap->SetData(aObserver); callbackwrap->SetDataIID(&NS_GET_IID(nsIObserver)); } nsCOMPtr<nsISupportsArray> params(do_CreateInstance(NS_SUPPORTSARRAY_CONTRACTID)); if ( !params || !listwrap || !callbackwrap ) return NS_ERROR_FAILURE; params->AppendElement(listwrap); params->AppendElement(callbackwrap); // --- open the window nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv)); if (!wwatch) return rv; char *statusDialogURL, *statusDialogType; nsCOMPtr<nsIPrefBranch> pref(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv)); if (!pref) return rv; const char* statusDlg = mChromeType == CHROME_SKIN ? PREF_XPINSTALL_STATUS_DLG_SKIN : PREF_XPINSTALL_STATUS_DLG_CHROME; rv = pref->GetCharPref(statusDlg, &statusDialogURL); NS_ASSERTION(NS_SUCCEEDED(rv), "Can't invoke XPInstall FE without a FE URL! Set xpinstall.dialog.status"); if (NS_FAILED(rv)) return rv; const char* statusType = mChromeType == CHROME_SKIN ? PREF_XPINSTALL_STATUS_DLG_TYPE_SKIN : PREF_XPINSTALL_STATUS_DLG_TYPE_CHROME; rv = pref->GetCharPref(statusType, &statusDialogType); nsAutoString type; type.AssignWithConversion(statusDialogType); if (NS_SUCCEEDED(rv) && !type.IsEmpty()) { nsCOMPtr<nsIWindowMediator> wm = do_GetService(NS_WINDOWMEDIATOR_CONTRACTID); nsCOMPtr<nsIDOMWindowInternal> recentWindow; wm->GetMostRecentWindow(type.get(), getter_AddRefs(recentWindow)); if (recentWindow) { nsCOMPtr<nsIObserverService> os(do_GetService("@mozilla.org/observer-service;1")); os->NotifyObservers(params, "xpinstall-download-started", nsnull); recentWindow->Focus(); return NS_OK; } } nsCOMPtr<nsIDOMWindow> newWindow; rv = wwatch->OpenWindow(0, statusDialogURL, "_blank", "chrome,centerscreen,titlebar,dialog=no,resizable", params, getter_AddRefs(newWindow)); return rv; }
nsresult nsAbLDAPProcessChangeLogData::GetAuthData() { if(!mInitialized) return NS_ERROR_NOT_INITIALIZED; nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); if (!wwatch) return NS_ERROR_FAILURE; nsCOMPtr<nsIAuthPrompt> dialog; nsresult rv = wwatch->GetNewAuthPrompter(0, getter_AddRefs(dialog)); if (NS_FAILED(rv)) return rv; if (!dialog) return NS_ERROR_FAILURE; nsCOMPtr<nsILDAPURL> url; rv = mQuery->GetReplicationURL(getter_AddRefs(url)); if (NS_FAILED(rv)) return rv; nsCAutoString serverUri; rv = url->GetSpec(serverUri); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIStringBundleService> bundleService = do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv); if (NS_FAILED (rv)) return rv ; nsCOMPtr<nsIStringBundle> bundle; rv = bundleService->CreateBundle("chrome://messenger/locale/addressbook/addressBook.properties", getter_AddRefs(bundle)); if (NS_FAILED (rv)) return rv ; nsString title; rv = bundle->GetStringFromName(NS_LITERAL_STRING("AuthDlgTitle").get(), getter_Copies(title)); if (NS_FAILED (rv)) return rv ; nsString desc; rv = bundle->GetStringFromName(NS_LITERAL_STRING("AuthDlgDesc").get(), getter_Copies(desc)); if (NS_FAILED (rv)) return rv ; nsString username; nsString password; bool btnResult = false; rv = dialog->PromptUsernameAndPassword(title, desc, NS_ConvertUTF8toUTF16(serverUri).get(), nsIAuthPrompt::SAVE_PASSWORD_PERMANENTLY, getter_Copies(username), getter_Copies(password), &btnResult); if(NS_SUCCEEDED(rv) && btnResult) { CopyUTF16toUTF8(username, mAuthUserID); CopyUTF16toUTF8(password, mAuthPswd); } else rv = NS_ERROR_FAILURE; return rv; }
// short cut function for creating a mailto url... nsresult NS_MsgBuildSmtpUrl(nsIFile * aFilePath, const nsCString &aSmtpHostName, PRInt32 aSmtpPort, const nsCString &aSmtpUserName, const char * aRecipients, nsIMsgIdentity * aSenderIdentity, nsIUrlListener * aUrlListener, nsIMsgStatusFeedback *aStatusFeedback, nsIInterfaceRequestor* aNotificationCallbacks, nsIURI ** aUrl, PRBool aRequestDSN) { // mscott: this function is a convience hack until netlib actually dispatches // smtp urls. in addition until we have a session to get a password, host and // other stuff from, we need to use default values.... // ..for testing purposes.... nsresult rv; nsCOMPtr<nsISmtpUrl> smtpUrl(do_CreateInstance(kCSmtpUrlCID, &rv)); NS_ENSURE_SUCCESS(rv, rv); nsCAutoString urlSpec("smtp://"); if (!aSmtpUserName.IsEmpty()) { nsCString escapedUsername; MsgEscapeString(aSmtpUserName, nsINetUtil::ESCAPE_XALPHAS, escapedUsername); urlSpec.Append(escapedUsername); urlSpec.Append('@'); } urlSpec.Append(aSmtpHostName); if (aSmtpHostName.FindChar(':') == -1) { urlSpec.Append(':'); urlSpec.AppendInt(aSmtpPort); } nsCOMPtr<nsIMsgMailNewsUrl> url(do_QueryInterface(smtpUrl, &rv)); NS_ENSURE_SUCCESS(rv, rv); url->SetSpec(urlSpec); smtpUrl->SetRecipients(aRecipients); smtpUrl->SetRequestDSN(aRequestDSN); smtpUrl->SetPostMessageFile(aFilePath); smtpUrl->SetSenderIdentity(aSenderIdentity); smtpUrl->SetNotificationCallbacks(aNotificationCallbacks); nsCOMPtr<nsIPrompt> smtpPrompt(do_GetInterface(aNotificationCallbacks)); nsCOMPtr<nsIAuthPrompt> smtpAuthPrompt(do_GetInterface(aNotificationCallbacks)); if (!smtpPrompt || !smtpAuthPrompt) { nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); if (!smtpPrompt) wwatch->GetNewPrompter(0, getter_AddRefs(smtpPrompt)); if (!smtpAuthPrompt) wwatch->GetNewAuthPrompter(0, getter_AddRefs(smtpAuthPrompt)); } smtpUrl->SetPrompt(smtpPrompt); smtpUrl->SetAuthPrompt(smtpAuthPrompt); url->RegisterListener(aUrlListener); if (aStatusFeedback) url->SetStatusFeedback(aStatusFeedback); return CallQueryInterface(smtpUrl, aUrl); }
void nsPKCS12Blob::handleError(int myerr) { nsPSMUITracker tracker; if (tracker.isUIForbidden()) { return; } nsresult rv; int prerr = PORT_GetError(); PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("PKCS12: NSS/NSPR error(%d)", prerr)); PR_LOG(gPIPNSSLog, PR_LOG_DEBUG, ("PKCS12: I called(%d)", myerr)); nsCOMPtr<nsINSSComponent> nssComponent(do_GetService(kNSSComponentCID, &rv)); if (NS_FAILED(rv)) return; nsCOMPtr<nsIPrompt> errPrompt; nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); if (wwatch) { wwatch->GetNewPrompter(0, getter_AddRefs(errPrompt)); if (errPrompt) { nsCOMPtr<nsIPrompt> proxyPrompt; NS_GetProxyForObject(NS_PROXY_TO_MAIN_THREAD, NS_GET_IID(nsIPrompt), errPrompt, NS_PROXY_SYNC, getter_AddRefs(proxyPrompt)); if (!proxyPrompt) return; } else { return; } } else { return; } nsAutoString errorMsg; switch (myerr) { case PIP_PKCS12_RESTORE_OK: rv = nssComponent->GetPIPNSSBundleString("SuccessfulP12Restore", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); return; case PIP_PKCS12_BACKUP_OK: rv = nssComponent->GetPIPNSSBundleString("SuccessfulP12Backup", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); return; case PIP_PKCS12_USER_CANCELED: return; /* Just ignore it for now */ case PIP_PKCS12_NOSMARTCARD_EXPORT: rv = nssComponent->GetPIPNSSBundleString("PKCS12InfoNoSmartcardBackup", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); return; case PIP_PKCS12_RESTORE_FAILED: rv = nssComponent->GetPIPNSSBundleString("PKCS12UnknownErrRestore", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); return; case PIP_PKCS12_BACKUP_FAILED: rv = nssComponent->GetPIPNSSBundleString("PKCS12UnknownErrBackup", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); return; case PIP_PKCS12_NSS_ERROR: switch (prerr) { // The following errors have the potential to be "handled", by asking // the user (via a dialog) whether s/he wishes to continue case 0: break; case SEC_ERROR_PKCS12_CERT_COLLISION: /* pop a dialog saying the cert is already in the database */ /* ask to keep going? what happens if one collision but others ok? */ // The following errors cannot be "handled", notify the user (via an alert) // that the operation failed. #if 0 // XXX a boy can dream... // but the PKCS12 lib never throws this error // but then again, how would it? anyway, convey the info below case SEC_ERROR_PKCS12_PRIVACY_PASSWORD_INCORRECT: rv = nssComponent->GetPIPNSSBundleString("PKCS12PasswordInvalid", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); break; #endif case SEC_ERROR_BAD_PASSWORD: rv = nssComponent->GetPIPNSSBundleString("PK11BadPassword", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); break; case SEC_ERROR_BAD_DER: case SEC_ERROR_PKCS12_CORRUPT_PFX_STRUCTURE: case SEC_ERROR_PKCS12_INVALID_MAC: rv = nssComponent->GetPIPNSSBundleString("PKCS12DecodeErr", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); break; case SEC_ERROR_PKCS12_DUPLICATE_DATA: rv = nssComponent->GetPIPNSSBundleString("PKCS12DupData", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); break; default: rv = nssComponent->GetPIPNSSBundleString("PKCS12UnknownErr", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); } break; case 0: default: rv = nssComponent->GetPIPNSSBundleString("PKCS12UnknownErr", errorMsg); if (NS_FAILED(rv)) return; errPrompt->Alert(nsnull, errorMsg.get()); break; } }
char* PR_CALLBACK PK11PasswordPrompt(PK11SlotInfo* slot, PRBool retry, void* arg) { nsNSSShutDownPreventionLock locker; nsresult rv = NS_OK; PRUnichar *password = nsnull; PRBool value = PR_FALSE; nsIInterfaceRequestor *ir = static_cast<nsIInterfaceRequestor*>(arg); nsCOMPtr<nsIPrompt> proxyPrompt; /* TODO: Retry should generate a different dialog message */ /* if (retry) return nsnull; */ if (!ir) { nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID)); if (!wwatch) return nsnull; nsCOMPtr<nsIPrompt> prompter; wwatch->GetNewPrompter(0, getter_AddRefs(prompter)); if (!prompter) return nsnull; NS_GetProxyForObject(NS_PROXY_TO_MAIN_THREAD, NS_GET_IID(nsIPrompt), prompter, NS_PROXY_SYNC, getter_AddRefs(proxyPrompt)); if (!proxyPrompt) return nsnull; } else { // The interface requestor object may not be safe, so // proxy the call to get the nsIPrompt. nsCOMPtr<nsIInterfaceRequestor> proxiedCallbacks; NS_GetProxyForObject(NS_PROXY_TO_MAIN_THREAD, NS_GET_IID(nsIInterfaceRequestor), ir, NS_PROXY_SYNC, getter_AddRefs(proxiedCallbacks)); // Get the desired interface nsCOMPtr<nsIPrompt> prompt(do_GetInterface(proxiedCallbacks)); if (!prompt) { NS_ASSERTION(PR_FALSE, "callbacks does not implement nsIPrompt"); return nsnull; } // Finally, get a proxy for the nsIPrompt NS_GetProxyForObject(NS_PROXY_TO_MAIN_THREAD, NS_GET_IID(nsIPrompt), prompt, NS_PROXY_SYNC, getter_AddRefs(proxyPrompt)); } if (PK11_ProtectedAuthenticationPath(slot)) return ShowProtectedAuthPrompt(slot, ir); nsAutoString promptString; nsCOMPtr<nsINSSComponent> nssComponent(do_GetService(kNSSComponentCID, &rv)); if (NS_FAILED(rv)) return nsnull; const PRUnichar* formatStrings[1] = { ToNewUnicode(NS_ConvertUTF8toUTF16(PK11_GetTokenName(slot))) }; rv = nssComponent->PIPBundleFormatStringFromName("CertPassPrompt", formatStrings, 1, promptString); nsMemory::Free(const_cast<PRUnichar*>(formatStrings[0])); if (NS_FAILED(rv)) return nsnull; { nsPSMUITracker tracker; if (tracker.isUIForbidden()) { rv = NS_ERROR_NOT_AVAILABLE; } else { rv = proxyPrompt->PromptPassword(nsnull, promptString.get(), &password, nsnull, nsnull, &value); } } if (NS_SUCCEEDED(rv) && value) { char* str = ToNewUTF8String(nsDependentString(password)); NS_Free(password); return str; } return nsnull; }