already_AddRefed<nsMIMEInfoWin> nsOSHelperAppService::GetByExtension(const nsAFlatString& aFileExt, const char *aTypeHint) { if (aFileExt.IsEmpty()) return nsnull; // windows registry assumes your file extension is going to include the '.'. // so make sure it's there... nsAutoString fileExtToUse; if (aFileExt.First() != PRUnichar('.')) fileExtToUse = PRUnichar('.'); fileExtToUse.Append(aFileExt); // Try to get an entry from the windows registry. nsCOMPtr<nsIWindowsRegKey> regKey = do_CreateInstance("@mozilla.org/windows-registry-key;1"); if (!regKey) return nsnull; nsresult rv = regKey->Open(nsIWindowsRegKey::ROOT_KEY_CLASSES_ROOT, fileExtToUse, nsIWindowsRegKey::ACCESS_QUERY_VALUE); if (NS_FAILED(rv)) return nsnull; nsCAutoString typeToUse; if (aTypeHint && *aTypeHint) { typeToUse.Assign(aTypeHint); } else { nsAutoString temp; if (NS_FAILED(regKey->ReadStringValue(NS_LITERAL_STRING("Content Type"), temp)) || temp.IsEmpty()) { return nsnull; } // Content-Type is always in ASCII LossyAppendUTF16toASCII(temp, typeToUse); } nsMIMEInfoWin* mimeInfo = new nsMIMEInfoWin(typeToUse); if (!mimeInfo) return nsnull; // out of memory NS_ADDREF(mimeInfo); // don't append the '.' mimeInfo->AppendExtension(NS_ConvertUTF16toUTF8(Substring(fileExtToUse, 1))); mimeInfo->SetPreferredAction(nsIMIMEInfo::useSystemDefault); nsAutoString appInfo; bool found; #if MOZ_WINSDK_TARGETVER >= MOZ_NTDDI_LONGHORN // Retrieve the default application for this extension if (mAppAssoc) { // Vista: use the new application association COM interfaces // for resolving helpers. nsString assocType(fileExtToUse); PRUnichar * pResult = nsnull; HRESULT hr = mAppAssoc->QueryCurrentDefault(assocType.get(), AT_FILEEXTENSION, AL_EFFECTIVE, &pResult); if (SUCCEEDED(hr)) { found = PR_TRUE; appInfo.Assign(pResult); CoTaskMemFree(pResult); } else { found = PR_FALSE; } } else #endif { found = NS_SUCCEEDED(regKey->ReadStringValue(EmptyString(), appInfo)); } // Bug 358297 - ignore the default handler, force the user to choose app if (appInfo.EqualsLiteral("XPSViewer.Document")) found = PR_FALSE; if (!found) { NS_IF_RELEASE(mimeInfo); // we failed to really find an entry in the registry return nsnull; } // Get other nsIMIMEInfo fields from registry, if possible. nsAutoString defaultDescription; nsCOMPtr<nsIFile> defaultApplication; if (NS_FAILED(GetDefaultAppInfo(appInfo, defaultDescription, getter_AddRefs(defaultApplication)))) { NS_IF_RELEASE(mimeInfo); return nsnull; } mimeInfo->SetDefaultDescription(defaultDescription); mimeInfo->SetDefaultApplicationHandler(defaultApplication); // Grab the general description GetMIMEInfoFromRegistry(appInfo, mimeInfo); return mimeInfo; }
void XPCCallContext::Init(XPCContext::LangType callerLanguage, JSBool callBeginRequest, JSObject* obj, JSObject* funobj, WrapperInitOptions wrapperInitOptions, jsid name, uintN argc, jsval *argv, jsval *rval) { if (!mXPC) return; mThreadData = XPCPerThreadData::GetData(mJSContext); if (!mThreadData) return; XPCJSContextStack* stack = mThreadData->GetJSContextStack(); JSContext* topJSContext; if (!stack || NS_FAILED(stack->Peek(&topJSContext))) { // If we don't have a stack we're probably in shutdown. NS_ASSERTION(!stack, "Bad, Peek failed!"); mJSContext = nsnull; return; } if (!mJSContext) { // This is slightly questionable. If called without an explicit // JSContext (generally a call to a wrappedJS) we will use the JSContext // on the top of the JSContext stack - if there is one - *before* // falling back on the safe JSContext. // This is good AND bad because it makes calls from JS -> native -> JS // have JS stack 'continuity' for purposes of stack traces etc. // Note: this *is* what the pre-XPCCallContext xpconnect did too. if (topJSContext) mJSContext = topJSContext; else if (NS_FAILED(stack->GetSafeJSContext(&mJSContext)) || !mJSContext) return; } if (topJSContext != mJSContext) { if (NS_FAILED(stack->Push(mJSContext))) { NS_ERROR("bad!"); return; } mContextPopRequired = JS_TRUE; } // Get into the request as early as we can to avoid problems with scanning // callcontexts on other threads from within the gc callbacks. NS_ASSERTION(!callBeginRequest || mCallerLanguage == NATIVE_CALLER, "Don't call JS_BeginRequest unless the caller is native."); if (callBeginRequest) JS_BeginRequest(mJSContext); mXPCContext = XPCContext::GetXPCContext(mJSContext); mPrevCallerLanguage = mXPCContext->SetCallingLangType(mCallerLanguage); // hook into call context chain for our thread mPrevCallContext = mThreadData->SetCallContext(this); // We only need to addref xpconnect once so only do it if this is the first // context in the chain. if (!mPrevCallContext) NS_ADDREF(mXPC); mState = HAVE_CONTEXT; if (!obj) return; mScopeForNewJSObjects = obj; mState = HAVE_SCOPE; mMethodIndex = 0xDEAD; mState = HAVE_OBJECT; mTearOff = nsnull; if (wrapperInitOptions == INIT_SHOULD_LOOKUP_WRAPPER) { mWrapper = XPCWrappedNative::GetWrappedNativeOfJSObject(mJSContext, obj, funobj, &mFlattenedJSObject, &mTearOff); if (mWrapper) { DEBUG_CheckWrapperThreadSafety(mWrapper); mFlattenedJSObject = mWrapper->GetFlatJSObject(); if (mTearOff) mScriptableInfo = nsnull; else mScriptableInfo = mWrapper->GetScriptableInfo(); } else { NS_ABORT_IF_FALSE(!mFlattenedJSObject || IS_SLIM_WRAPPER(mFlattenedJSObject), "should have a slim wrapper"); } } if (!JSID_IS_VOID(name)) SetName(name); if (argc != NO_ARGS) SetArgsAndResultPtr(argc, argv, rval); CHECK_STATE(HAVE_OBJECT); }
nsXPIDLPlugin::nsXPIDLPlugin( nsIXPIDLPlugin *plugin ) { NS_INIT_ISUPPORTS(); this->plugin = plugin; NS_ADDREF( plugin ); }
NS_IMETHODIMP nsJavaXPTCStub::QueryInterface(const nsID &aIID, void **aInstancePtr) { nsresult rv; LOG(("JavaStub::QueryInterface()\n")); *aInstancePtr = nsnull; nsJavaXPTCStub *master = mMaster ? mMaster : this; // This helps us differentiate between the help classes. if (aIID.Equals(NS_GET_IID(nsJavaXPTCStub))) { *aInstancePtr = master; NS_ADDREF(this); return NS_OK; } // always return the master stub for nsISupports if (aIID.Equals(NS_GET_IID(nsISupports))) { *aInstancePtr = master->mXPTCStub; NS_ADDREF(master); return NS_OK; } // All Java objects support weak references if (aIID.Equals(NS_GET_IID(nsISupportsWeakReference))) { *aInstancePtr = static_cast<nsISupportsWeakReference*>(master); NS_ADDREF(master); return NS_OK; } // does any existing stub support the requested IID? nsJavaXPTCStub *stub = master->FindStubSupportingIID(aIID); if (stub) { *aInstancePtr = stub->mXPTCStub; NS_ADDREF(stub); return NS_OK; } JNIEnv* env = GetJNIEnv(); // Query Java object LOG(("\tCalling Java object queryInterface\n")); jobject javaObject = env->CallObjectMethod(mJavaWeakRef, getReferentMID); jmethodID qiMID = 0; jclass clazz = env->GetObjectClass(javaObject); if (clazz) { char* sig = "(Ljava/lang/String;)Lorg/mozilla/interfaces/nsISupports;"; qiMID = env->GetMethodID(clazz, "queryInterface", sig); NS_ASSERTION(qiMID, "Failed to get queryInterface method ID"); } if (qiMID == 0) { env->ExceptionClear(); return NS_NOINTERFACE; } // construct IID string jstring iid_jstr = nsnull; char* iid_str = aIID.ToString(); if (iid_str) { iid_jstr = env->NewStringUTF(iid_str); } if (!iid_str || !iid_jstr) { env->ExceptionClear(); return NS_ERROR_OUT_OF_MEMORY; } NS_Free(iid_str); // call queryInterface method jobject obj = env->CallObjectMethod(javaObject, qiMID, iid_jstr); if (env->ExceptionCheck()) { env->ExceptionClear(); return NS_ERROR_FAILURE; } if (!obj) return NS_NOINTERFACE; // Get interface info for new java object nsCOMPtr<nsIInterfaceInfoManager> iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv)); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIInterfaceInfo> iinfo; rv = iim->GetInfoForIID(&aIID, getter_AddRefs(iinfo)); if (NS_FAILED(rv)) return rv; stub = new nsJavaXPTCStub(obj, iinfo, &rv); if (!stub) return NS_ERROR_OUT_OF_MEMORY; if (NS_FAILED(rv)) { delete stub; return rv; } // add stub to the master's list of children, so we can preserve // symmetry in future QI calls. the master will delete each child // when it is destroyed. the refcount of each child is bound to // the refcount of the master. this is done to deal with code // like this: // // nsCOMPtr<nsIBar> bar = ...; // nsIFoo *foo; // { // nsCOMPtr<nsIFoo> temp = do_QueryInterface(bar); // foo = temp; // } // foo->DoStuff(); // // while this code is not valid XPCOM (since it is using |foo| // after having called Release on it), such code is unfortunately // very common in the mozilla codebase. the assumption this code // is making is that so long as |bar| is alive, it should be valid // to access |foo| even if the code doesn't own a strong reference // to |foo|! clearly wrong, but we need to support it anyways. stub->mMaster = master; master->mChildren.AppendElement(stub); *aInstancePtr = stub->mXPTCStub; NS_ADDREF(stub); return NS_OK; }
NS_IMETHODIMP nsXREDirProvider::GetFile(const char* aProperty, bool* aPersistent, nsIFile** aFile) { nsresult rv; bool gettingProfile = false; if (!strcmp(aProperty, NS_APP_USER_PROFILE_LOCAL_50_DIR)) { // If XRE_NotifyProfile hasn't been called, don't fall through to // mAppProvider on the profile keys. if (!mProfileNotified) return NS_ERROR_FAILURE; if (mProfileLocalDir) return mProfileLocalDir->Clone(aFile); if (mAppProvider) return mAppProvider->GetFile(aProperty, aPersistent, aFile); // This falls through to the case below gettingProfile = true; } if (!strcmp(aProperty, NS_APP_USER_PROFILE_50_DIR) || gettingProfile) { if (!mProfileNotified) return NS_ERROR_FAILURE; if (mProfileDir) return mProfileDir->Clone(aFile); if (mAppProvider) return mAppProvider->GetFile(aProperty, aPersistent, aFile); // If we don't succeed here, bail early so that we aren't reentrant // through the "GetProfileDir" call below. return NS_ERROR_FAILURE; } if (mAppProvider) { rv = mAppProvider->GetFile(aProperty, aPersistent, aFile); if (NS_SUCCEEDED(rv) && *aFile) return rv; } *aPersistent = true; if (!strcmp(aProperty, NS_GRE_DIR)) { return mGREDir->Clone(aFile); } else if (!strcmp(aProperty, NS_OS_CURRENT_PROCESS_DIR) || !strcmp(aProperty, NS_APP_INSTALL_CLEANUP_DIR)) { return GetAppDir()->Clone(aFile); } rv = NS_ERROR_FAILURE; nsCOMPtr<nsIFile> file; if (!strcmp(aProperty, NS_APP_PROFILE_DEFAULTS_50_DIR) || !strcmp(aProperty, NS_APP_PROFILE_DEFAULTS_NLOC_50_DIR)) { return GetProfileDefaultsDir(aFile); } else if (!strcmp(aProperty, NS_APP_PREF_DEFAULTS_50_DIR)) { // return the GRE default prefs directory here, and the app default prefs // directory (if applicable) in NS_APP_PREFS_DEFAULTS_DIR_LIST. rv = mGREDir->Clone(getter_AddRefs(file)); if (NS_SUCCEEDED(rv)) { rv = file->AppendNative(NS_LITERAL_CSTRING("defaults")); if (NS_SUCCEEDED(rv)) rv = file->AppendNative(NS_LITERAL_CSTRING("pref")); } } else if (!strcmp(aProperty, NS_APP_APPLICATION_REGISTRY_DIR) || !strcmp(aProperty, XRE_USER_APP_DATA_DIR)) { rv = GetUserAppDataDirectory(getter_AddRefs(file)); } else if (!strcmp(aProperty, XRE_UPDATE_ROOT_DIR)) { rv = GetUpdateRootDir(getter_AddRefs(file)); } else if (!strcmp(aProperty, NS_APP_APPLICATION_REGISTRY_FILE)) { rv = GetUserAppDataDirectory(getter_AddRefs(file)); if (NS_SUCCEEDED(rv)) rv = file->AppendNative(NS_LITERAL_CSTRING(APP_REGISTRY_NAME)); } else if (!strcmp(aProperty, NS_APP_USER_PROFILES_ROOT_DIR)) { rv = GetUserProfilesRootDir(getter_AddRefs(file), nullptr, nullptr, nullptr); } else if (!strcmp(aProperty, NS_APP_USER_PROFILES_LOCAL_ROOT_DIR)) { rv = GetUserProfilesLocalDir(getter_AddRefs(file), nullptr, nullptr, nullptr); } else if (!strcmp(aProperty, XRE_EXECUTABLE_FILE) && gArgv[0]) { nsCOMPtr<nsIFile> lf; rv = XRE_GetBinaryPath(gArgv[0], getter_AddRefs(lf)); if (NS_SUCCEEDED(rv)) file = lf; } else if (!strcmp(aProperty, NS_APP_PROFILE_DIR_STARTUP) && mProfileDir) { return mProfileDir->Clone(aFile); } else if (!strcmp(aProperty, NS_APP_PROFILE_LOCAL_DIR_STARTUP)) { if (mProfileLocalDir) return mProfileLocalDir->Clone(aFile); if (mProfileDir) return mProfileDir->Clone(aFile); if (mAppProvider) return mAppProvider->GetFile(NS_APP_PROFILE_DIR_STARTUP, aPersistent, aFile); } #if defined(XP_UNIX) || defined(XP_MACOSX) else if (!strcmp(aProperty, XRE_SYS_LOCAL_EXTENSION_PARENT_DIR)) { #ifdef ENABLE_SYSTEM_EXTENSION_DIRS return GetSystemExtensionsDirectory(aFile); #else return NS_ERROR_FAILURE; #endif } #endif #if defined(XP_UNIX) && !defined(XP_MACOSX) else if (!strcmp(aProperty, XRE_SYS_SHARE_EXTENSION_PARENT_DIR)) { #ifdef ENABLE_SYSTEM_EXTENSION_DIRS #if defined(__OpenBSD__) || defined(__FreeBSD__) static const char *const sysLExtDir = "/usr/local/share/mozilla/extensions"; #else static const char *const sysLExtDir = "/usr/share/mozilla/extensions"; #endif return NS_NewNativeLocalFile(nsDependentCString(sysLExtDir), false, aFile); #else return NS_ERROR_FAILURE; #endif } #endif else if (!strcmp(aProperty, XRE_USER_SYS_EXTENSION_DIR)) { #ifdef ENABLE_SYSTEM_EXTENSION_DIRS return GetSysUserExtensionsDirectory(aFile); #else return NS_ERROR_FAILURE; #endif } else if (!strcmp(aProperty, XRE_APP_DISTRIBUTION_DIR)) { bool persistent = false; rv = GetFile(XRE_EXECUTABLE_FILE, &persistent, getter_AddRefs(file)); if (NS_SUCCEEDED(rv)) rv = file->SetNativeLeafName(NS_LITERAL_CSTRING("distribution")); } else if (NS_SUCCEEDED(GetProfileStartupDir(getter_AddRefs(file)))) { // We need to allow component, xpt, and chrome registration to // occur prior to the profile-after-change notification. if (!strcmp(aProperty, NS_APP_USER_CHROME_DIR)) { rv = file->AppendNative(NS_LITERAL_CSTRING("chrome")); } } if (NS_SUCCEEDED(rv) && file) { NS_ADDREF(*aFile = file); return NS_OK; } bool ensureFilePermissions = false; if (NS_SUCCEEDED(GetProfileDir(getter_AddRefs(file)))) { if (!strcmp(aProperty, NS_APP_PREFS_50_DIR)) { rv = NS_OK; } else if (!strcmp(aProperty, NS_APP_PREFS_50_FILE)) { rv = file->AppendNative(NS_LITERAL_CSTRING("prefs.js")); } else if (!strcmp(aProperty, NS_METRO_APP_PREFS_50_FILE)) { rv = file->AppendNative(NS_LITERAL_CSTRING("metro-prefs.js")); } else if (!strcmp(aProperty, NS_LOCALSTORE_UNSAFE_FILE)) { rv = file->AppendNative(NS_LITERAL_CSTRING("localstore.rdf")); } else if (!strcmp(aProperty, NS_APP_LOCALSTORE_50_FILE)) { if (gSafeMode) { rv = file->AppendNative(NS_LITERAL_CSTRING("localstore-safe.rdf")); file->Remove(false); } else { rv = file->AppendNative(NS_LITERAL_CSTRING("localstore.rdf")); EnsureProfileFileExists(file); ensureFilePermissions = true; } } else if (!strcmp(aProperty, NS_APP_USER_MIMETYPES_50_FILE)) { rv = file->AppendNative(NS_LITERAL_CSTRING("mimeTypes.rdf")); EnsureProfileFileExists(file); ensureFilePermissions = true; } else if (!strcmp(aProperty, NS_APP_DOWNLOADS_50_FILE)) { rv = file->AppendNative(NS_LITERAL_CSTRING("downloads.rdf")); } else if (!strcmp(aProperty, NS_APP_PREFS_OVERRIDE_DIR)) { rv = mProfileDir->Clone(getter_AddRefs(file)); nsresult tmp = file->AppendNative(NS_LITERAL_CSTRING(PREF_OVERRIDE_DIRNAME)); if (NS_FAILED(tmp)) { rv = tmp; } tmp = EnsureDirectoryExists(file); if (NS_FAILED(tmp)) { rv = tmp; } } } if (NS_FAILED(rv) || !file) return NS_ERROR_FAILURE; if (ensureFilePermissions) { bool fileToEnsureExists; bool isWritable; if (NS_SUCCEEDED(file->Exists(&fileToEnsureExists)) && fileToEnsureExists && NS_SUCCEEDED(file->IsWritable(&isWritable)) && !isWritable) { uint32_t permissions; if (NS_SUCCEEDED(file->GetPermissions(&permissions))) { rv = file->SetPermissions(permissions | 0600); NS_ASSERTION(NS_SUCCEEDED(rv), "failed to ensure file permissions"); } } } NS_ADDREF(*aFile = file); return NS_OK; }
NS_IMETHODIMP nsSyncStreamListener::GetInputStream(nsIInputStream **result) { NS_ADDREF(*result = this); return NS_OK; }
nsresult ImportWMMailImpl::Create(nsIImportMail **aImport) { NS_ENSURE_ARG_POINTER(aImport); NS_ADDREF(*aImport = new ImportWMMailImpl()); return NS_OK; }
/** * Evaluates this Expr based on the given context node and processor state * @param context the context node for evaluation of this Expr * @param ps the ProcessorState containing the stack information needed * for evaluation * @return the result of the evaluation * @see Expr **/ nsresult LocationStep::evaluate(txIEvalContext* aContext, txAExprResult** aResult) { NS_ASSERTION(aContext, "internal error"); *aResult = nullptr; RefPtr<txNodeSet> nodes; nsresult rv = aContext->recycler()->getNodeSet(getter_AddRefs(nodes)); NS_ENSURE_SUCCESS(rv, rv); txXPathTreeWalker walker(aContext->getContextNode()); switch (mAxisIdentifier) { case ANCESTOR_AXIS: { if (!walker.moveToParent()) { break; } MOZ_FALLTHROUGH; } case ANCESTOR_OR_SELF_AXIS: { nodes->setReverse(); do { rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); } while (walker.moveToParent()); break; } case ATTRIBUTE_AXIS: { if (!walker.moveToFirstAttribute()) { break; } do { rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); } while (walker.moveToNextAttribute()); break; } case DESCENDANT_OR_SELF_AXIS: { rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); MOZ_FALLTHROUGH; } case DESCENDANT_AXIS: { rv = appendMatchingDescendants(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); break; } case FOLLOWING_AXIS: { if (txXPathNodeUtils::isAttribute(walker.getCurrentPosition())) { walker.moveToParent(); rv = appendMatchingDescendants(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); } bool cont = true; while (!walker.moveToNextSibling()) { if (!walker.moveToParent()) { cont = false; break; } } while (cont) { rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); rv = appendMatchingDescendants(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); while (!walker.moveToNextSibling()) { if (!walker.moveToParent()) { cont = false; break; } } } break; } case FOLLOWING_SIBLING_AXIS: { while (walker.moveToNextSibling()) { rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); } break; } case NAMESPACE_AXIS: //-- not yet implemented #if 0 // XXX DEBUG OUTPUT cout << "namespace axis not yet implemented"<<endl; #endif break; case PARENT_AXIS: { if (walker.moveToParent()) { rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); } break; } case PRECEDING_AXIS: { nodes->setReverse(); bool cont = true; while (!walker.moveToPreviousSibling()) { if (!walker.moveToParent()) { cont = false; break; } } while (cont) { rv = appendMatchingDescendantsRev(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); while (!walker.moveToPreviousSibling()) { if (!walker.moveToParent()) { cont = false; break; } } } break; } case PRECEDING_SIBLING_AXIS: { nodes->setReverse(); while (walker.moveToPreviousSibling()) { rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); } break; } case SELF_AXIS: { rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); break; } default: // Children Axis { if (!walker.moveToFirstChild()) { break; } do { rv = appendIfMatching(walker, aContext, nodes); NS_ENSURE_SUCCESS(rv, rv); } while (walker.moveToNextSibling()); break; } } // Apply predicates if (!isEmpty()) { rv = evaluatePredicates(nodes, aContext); NS_ENSURE_SUCCESS(rv, rv); } nodes->unsetReverse(); NS_ADDREF(*aResult = nodes); return NS_OK; }
// wrapper for get_values_len // NS_IMETHODIMP nsLDAPMessage::GetBinaryValues(const char *aAttr, uint32_t *aCount, nsILDAPBERValue ***aValues) { struct berval **values; #if defined(DEBUG) // We only want this being logged for debug builds so as not to affect performance too much. PR_LOG(gLDAPLogModule, PR_LOG_DEBUG, ("nsLDAPMessage::GetBinaryValues(): called with aAttr = '%s'", aAttr)); #endif values = ldap_get_values_len(mConnectionHandle, mMsgHandle, aAttr); // bail out if there was a problem // if (!values) { int32_t lderrno = ldap_get_lderrno(mConnectionHandle, 0, 0); if ( lderrno == LDAP_DECODING_ERROR ) { // this may not be an error; it could just be that the // caller has asked for an attribute that doesn't exist. // PR_LOG(gLDAPLogModule, PR_LOG_WARNING, ("nsLDAPMessage::GetBinaryValues(): ldap_get_values " "returned LDAP_DECODING_ERROR")); return NS_ERROR_LDAP_DECODING_ERROR; } else if ( lderrno == LDAP_PARAM_ERROR ) { NS_ERROR("nsLDAPMessage::GetBinaryValues(): internal error: 1"); return NS_ERROR_UNEXPECTED; } else { NS_ERROR("nsLDAPMessage::GetBinaryValues(): internal error: 2"); return NS_ERROR_UNEXPECTED; } } // count the values // uint32_t numVals = ldap_count_values_len(values); // create the out array // *aValues = static_cast<nsILDAPBERValue **>(nsMemory::Alloc(numVals * sizeof(nsILDAPBERValue))); if (!aValues) { ldap_value_free_len(values); return NS_ERROR_OUT_OF_MEMORY; } // clone the array (except for the trailing NULL entry) using the // shared allocator for XPCOM correctness // uint32_t i; nsresult rv; for ( i = 0 ; i < numVals ; i++ ) { // create an nsBERValue object // nsCOMPtr<nsILDAPBERValue> berValue = new nsLDAPBERValue(); if (!berValue) { NS_ERROR("nsLDAPMessage::GetBinaryValues(): out of memory" " creating nsLDAPBERValue object"); NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(i, aValues); ldap_value_free_len(values); return NS_ERROR_OUT_OF_MEMORY; } // copy the value from the struct into the nsBERValue // rv = berValue->Set(values[i]->bv_len, reinterpret_cast<uint8_t *>(values[i]->bv_val)); if (NS_FAILED(rv)) { NS_ERROR("nsLDAPMessage::GetBinaryValues(): error setting" " nsBERValue"); ldap_value_free_len(values); return rv == NS_ERROR_OUT_OF_MEMORY ? rv : NS_ERROR_UNEXPECTED; } // put the nsIBERValue object into the out array // NS_ADDREF( (*aValues)[i] = berValue.get() ); } *aCount = numVals; ldap_value_free_len(values); return NS_OK; }
NS_IMETHODIMP nsChromeProtocolHandler::NewChannel(nsIURI *aURI, nsILoadInfo *aLoadInfo, nsIChannel **aResult) { nsresult rv; NS_ENSURE_ARG_POINTER(aURI); NS_ENSURE_ARG_POINTER(aLoadInfo); MOZ_ASSERT(aResult, "Null out param"); #ifdef DEBUG // Check that the uri we got is already canonified nsresult debug_rv; nsCOMPtr<nsIURI> debugURL = aURI; debug_rv = nsChromeRegistry::Canonify(debugURL); if (NS_SUCCEEDED(debug_rv)) { bool same; debug_rv = aURI->Equals(debugURL, &same); if (NS_SUCCEEDED(debug_rv)) { NS_ASSERTION(same, "Non-canonified chrome uri passed to " "nsChromeProtocolHandler::NewChannel!"); } } #endif nsCOMPtr<nsIChannel> result; if (!nsChromeRegistry::gChromeRegistry) { // We don't actually want this ref, we just want the service to // initialize if it hasn't already. nsCOMPtr<nsIChromeRegistry> reg = mozilla::services::GetChromeRegistryService(); NS_ENSURE_TRUE(nsChromeRegistry::gChromeRegistry, NS_ERROR_FAILURE); } nsCOMPtr<nsIURI> resolvedURI; rv = nsChromeRegistry::gChromeRegistry->ConvertChromeURL( aURI, getter_AddRefs(resolvedURI)); if (NS_FAILED(rv)) { #ifdef DEBUG printf("Couldn't convert chrome URL: %s\n", aURI->GetSpecOrDefault().get()); #endif return rv; } // We don't want to allow the inner protocol handler modify the result // principal URI since we want either |aURI| or anything pre-set by upper // layers to prevail. nsCOMPtr<nsIURI> savedResultPrincipalURI; rv = aLoadInfo->GetResultPrincipalURI(getter_AddRefs(savedResultPrincipalURI)); NS_ENSURE_SUCCESS(rv, rv); rv = NS_NewChannelInternal(getter_AddRefs(result), resolvedURI, aLoadInfo); NS_ENSURE_SUCCESS(rv, rv); #ifdef DEBUG nsCOMPtr<nsIFileChannel> fileChan(do_QueryInterface(result)); if (fileChan) { nsCOMPtr<nsIFile> file; fileChan->GetFile(getter_AddRefs(file)); bool exists = false; file->Exists(&exists); if (!exists) { printf("Chrome file doesn't exist: %s\n", file->HumanReadablePath().get()); } } #endif // Make sure that the channel remembers where it was // originally loaded from. rv = aLoadInfo->SetResultPrincipalURI(savedResultPrincipalURI); NS_ENSURE_SUCCESS(rv, rv); rv = result->SetOriginalURI(aURI); if (NS_FAILED(rv)) return rv; // Get a system principal for content files and set the owner // property of the result nsCOMPtr<nsIURL> url = do_QueryInterface(aURI); nsAutoCString path; rv = url->GetPathQueryRef(path); if (StringBeginsWith(path, NS_LITERAL_CSTRING("/content/"))) { result->SetOwner(nsContentUtils::GetSystemPrincipal()); } // XXX Removed dependency-tracking code from here, because we're not // tracking them anyways (with fastload we checked only in DEBUG // and with startupcache not at all), but this is where we would start // if we need to re-add. // See bug 531886, bug 533038. result->SetContentCharset(NS_LITERAL_CSTRING("UTF-8")); *aResult = result; NS_ADDREF(*aResult); return NS_OK; }
nsXPIDLPluginInstance::nsXPIDLPluginInstance( nsIXPIDLPluginInstance *pluginInstance ) { NS_INIT_ISUPPORTS(); this->pluginInstance = pluginInstance; NS_ADDREF( pluginInstance ); }
nsresult txCoreFunctionCall::getNameAtom(nsIAtom** aAtom) { NS_ADDREF(*aAtom = *descriptTable[mType].mName); return NS_OK; }
/* * Evaluates this Expr based on the given context node and processor state * @param context the context node for evaluation of this Expr * @param ps the ContextState containing the stack information needed * for evaluation * @return the result of the evaluation */ nsresult txCoreFunctionCall::evaluate(txIEvalContext* aContext, txAExprResult** aResult) { *aResult = nsnull; if (!requireParams(descriptTable[mType].mMinParams, descriptTable[mType].mMaxParams, aContext)) { return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT; } nsresult rv = NS_OK; switch (mType) { case COUNT: { nsRefPtr<txNodeSet> nodes; rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes)); NS_ENSURE_SUCCESS(rv, rv); return aContext->recycler()->getNumberResult(nodes->size(), aResult); } case ID: { nsRefPtr<txAExprResult> exprResult; rv = mParams[0]->evaluate(aContext, getter_AddRefs(exprResult)); NS_ENSURE_SUCCESS(rv, rv); nsRefPtr<txNodeSet> resultSet; rv = aContext->recycler()->getNodeSet(getter_AddRefs(resultSet)); NS_ENSURE_SUCCESS(rv, rv); txXPathTreeWalker walker(aContext->getContextNode()); if (exprResult->getResultType() == txAExprResult::NODESET) { txNodeSet* nodes = static_cast<txNodeSet*> (static_cast<txAExprResult*> (exprResult)); PRInt32 i; for (i = 0; i < nodes->size(); ++i) { nsAutoString idList; txXPathNodeUtils::appendNodeValue(nodes->get(i), idList); nsWhitespaceTokenizer tokenizer(idList); while (tokenizer.hasMoreTokens()) { if (walker.moveToElementById(tokenizer.nextToken())) { resultSet->add(walker.getCurrentPosition()); } } } } else { nsAutoString idList; exprResult->stringValue(idList); nsWhitespaceTokenizer tokenizer(idList); while (tokenizer.hasMoreTokens()) { if (walker.moveToElementById(tokenizer.nextToken())) { resultSet->add(walker.getCurrentPosition()); } } } *aResult = resultSet; NS_ADDREF(*aResult); return NS_OK; } case LAST: { return aContext->recycler()->getNumberResult(aContext->size(), aResult); } case LOCAL_NAME: case NAME: case NAMESPACE_URI: { // Check for optional arg nsRefPtr<txNodeSet> nodes; if (!mParams.IsEmpty()) { rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes)); NS_ENSURE_SUCCESS(rv, rv); if (nodes->isEmpty()) { aContext->recycler()->getEmptyStringResult(aResult); return NS_OK; } } const txXPathNode& node = nodes ? nodes->get(0) : aContext->getContextNode(); switch (mType) { case LOCAL_NAME: { StringResult* strRes = nsnull; rv = aContext->recycler()->getStringResult(&strRes); NS_ENSURE_SUCCESS(rv, rv); *aResult = strRes; txXPathNodeUtils::getLocalName(node, strRes->mValue); return NS_OK; } case NAMESPACE_URI: { StringResult* strRes = nsnull; rv = aContext->recycler()->getStringResult(&strRes); NS_ENSURE_SUCCESS(rv, rv); *aResult = strRes; txXPathNodeUtils::getNamespaceURI(node, strRes->mValue); return NS_OK; } case NAME: { // XXX Namespace: namespaces have a name if (txXPathNodeUtils::isAttribute(node) || txXPathNodeUtils::isElement(node) || txXPathNodeUtils::isProcessingInstruction(node)) { StringResult* strRes = nsnull; rv = aContext->recycler()->getStringResult(&strRes); NS_ENSURE_SUCCESS(rv, rv); *aResult = strRes; txXPathNodeUtils::getNodeName(node, strRes->mValue); } else { aContext->recycler()->getEmptyStringResult(aResult); } return NS_OK; } default: { break; } } } case POSITION: { return aContext->recycler()->getNumberResult(aContext->position(), aResult); } // String functions case CONCAT: { nsRefPtr<StringResult> strRes; rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes)); NS_ENSURE_SUCCESS(rv, rv); PRUint32 i, len = mParams.Length(); for (i = 0; i < len; ++i) { rv = mParams[i]->evaluateToString(aContext, strRes->mValue); NS_ENSURE_SUCCESS(rv, rv); } NS_ADDREF(*aResult = strRes); return NS_OK; } case CONTAINS: { nsAutoString arg2; rv = mParams[1]->evaluateToString(aContext, arg2); NS_ENSURE_SUCCESS(rv, rv); if (arg2.IsEmpty()) { aContext->recycler()->getBoolResult(PR_TRUE, aResult); } else { nsAutoString arg1; rv = mParams[0]->evaluateToString(aContext, arg1); NS_ENSURE_SUCCESS(rv, rv); aContext->recycler()->getBoolResult(FindInReadable(arg2, arg1), aResult); } return NS_OK; } case NORMALIZE_SPACE: { nsAutoString resultStr; if (!mParams.IsEmpty()) { rv = mParams[0]->evaluateToString(aContext, resultStr); NS_ENSURE_SUCCESS(rv, rv); } else { txXPathNodeUtils::appendNodeValue(aContext->getContextNode(), resultStr); } nsRefPtr<StringResult> strRes; rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes)); NS_ENSURE_SUCCESS(rv, rv); MBool addSpace = MB_FALSE; MBool first = MB_TRUE; strRes->mValue.SetCapacity(resultStr.Length()); PRUnichar c; PRUint32 src; for (src = 0; src < resultStr.Length(); src++) { c = resultStr.CharAt(src); if (XMLUtils::isWhitespace(c)) { addSpace = MB_TRUE; } else { if (addSpace && !first) strRes->mValue.Append(PRUnichar(' ')); strRes->mValue.Append(c); addSpace = MB_FALSE; first = MB_FALSE; } } *aResult = strRes; NS_ADDREF(*aResult); return NS_OK; } case STARTS_WITH: { nsAutoString arg2; rv = mParams[1]->evaluateToString(aContext, arg2); NS_ENSURE_SUCCESS(rv, rv); PRBool result = PR_FALSE; if (arg2.IsEmpty()) { result = PR_TRUE; } else { nsAutoString arg1; rv = mParams[0]->evaluateToString(aContext, arg1); NS_ENSURE_SUCCESS(rv, rv); result = StringBeginsWith(arg1, arg2); } aContext->recycler()->getBoolResult(result, aResult); return NS_OK; } case STRING: { nsRefPtr<StringResult> strRes; rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes)); NS_ENSURE_SUCCESS(rv, rv); if (!mParams.IsEmpty()) { rv = mParams[0]->evaluateToString(aContext, strRes->mValue); NS_ENSURE_SUCCESS(rv, rv); } else { txXPathNodeUtils::appendNodeValue(aContext->getContextNode(), strRes->mValue); } NS_ADDREF(*aResult = strRes); return NS_OK; } case STRING_LENGTH: { nsAutoString resultStr; if (!mParams.IsEmpty()) { rv = mParams[0]->evaluateToString(aContext, resultStr); NS_ENSURE_SUCCESS(rv, rv); } else { txXPathNodeUtils::appendNodeValue(aContext->getContextNode(), resultStr); } rv = aContext->recycler()->getNumberResult(resultStr.Length(), aResult); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } case SUBSTRING: { nsAutoString src; rv = mParams[0]->evaluateToString(aContext, src); NS_ENSURE_SUCCESS(rv, rv); double start; rv = evaluateToNumber(mParams[1], aContext, &start); NS_ENSURE_SUCCESS(rv, rv); // check for NaN or +/-Inf if (Double::isNaN(start) || Double::isInfinite(start) || start >= src.Length() + 0.5) { aContext->recycler()->getEmptyStringResult(aResult); return NS_OK; } start = floor(start + 0.5) - 1; double end; if (mParams.Length() == 3) { rv = evaluateToNumber(mParams[2], aContext, &end); NS_ENSURE_SUCCESS(rv, rv); end += start; if (Double::isNaN(end) || end < 0) { aContext->recycler()->getEmptyStringResult(aResult); return NS_OK; } if (end > src.Length()) end = src.Length(); else end = floor(end + 0.5); } else { end = src.Length(); } if (start < 0) start = 0; if (start > end) { aContext->recycler()->getEmptyStringResult(aResult); return NS_OK; } return aContext->recycler()->getStringResult( Substring(src, (PRUint32)start, (PRUint32)(end - start)), aResult); } case SUBSTRING_AFTER: { nsAutoString arg1; rv = mParams[0]->evaluateToString(aContext, arg1); NS_ENSURE_SUCCESS(rv, rv); nsAutoString arg2; rv = mParams[1]->evaluateToString(aContext, arg2); NS_ENSURE_SUCCESS(rv, rv); if (arg2.IsEmpty()) { return aContext->recycler()->getStringResult(arg1, aResult); } PRInt32 idx = arg1.Find(arg2); if (idx == kNotFound) { aContext->recycler()->getEmptyStringResult(aResult); return NS_OK; } const nsSubstring& result = Substring(arg1, idx + arg2.Length()); return aContext->recycler()->getStringResult(result, aResult); } case SUBSTRING_BEFORE: { nsAutoString arg2; rv = mParams[1]->evaluateToString(aContext, arg2); NS_ENSURE_SUCCESS(rv, rv); if (arg2.IsEmpty()) { aContext->recycler()->getEmptyStringResult(aResult); return NS_OK; } nsAutoString arg1; rv = mParams[0]->evaluateToString(aContext, arg1); NS_ENSURE_SUCCESS(rv, rv); PRInt32 idx = arg1.Find(arg2); if (idx == kNotFound) { aContext->recycler()->getEmptyStringResult(aResult); return NS_OK; } return aContext->recycler()->getStringResult(StringHead(arg1, idx), aResult); } case TRANSLATE: { nsAutoString src; rv = mParams[0]->evaluateToString(aContext, src); NS_ENSURE_SUCCESS(rv, rv); if (src.IsEmpty()) { aContext->recycler()->getEmptyStringResult(aResult); return NS_OK; } nsRefPtr<StringResult> strRes; rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes)); NS_ENSURE_SUCCESS(rv, rv); strRes->mValue.SetCapacity(src.Length()); nsAutoString oldChars, newChars; rv = mParams[1]->evaluateToString(aContext, oldChars); NS_ENSURE_SUCCESS(rv, rv); rv = mParams[2]->evaluateToString(aContext, newChars); NS_ENSURE_SUCCESS(rv, rv); PRUint32 i; PRInt32 newCharsLength = (PRInt32)newChars.Length(); for (i = 0; i < src.Length(); i++) { PRInt32 idx = oldChars.FindChar(src.CharAt(i)); if (idx != kNotFound) { if (idx < newCharsLength) strRes->mValue.Append(newChars.CharAt((PRUint32)idx)); } else { strRes->mValue.Append(src.CharAt(i)); } } NS_ADDREF(*aResult = strRes); return NS_OK; } // Number functions case NUMBER: { double res; if (!mParams.IsEmpty()) { rv = evaluateToNumber(mParams[0], aContext, &res); NS_ENSURE_SUCCESS(rv, rv); } else { nsAutoString resultStr; txXPathNodeUtils::appendNodeValue(aContext->getContextNode(), resultStr); res = Double::toDouble(resultStr); } return aContext->recycler()->getNumberResult(res, aResult); } case ROUND: { double dbl; rv = evaluateToNumber(mParams[0], aContext, &dbl); NS_ENSURE_SUCCESS(rv, rv); if (!Double::isNaN(dbl) && !Double::isInfinite(dbl)) { if (Double::isNeg(dbl) && dbl >= -0.5) { dbl *= 0; } else { dbl = floor(dbl + 0.5); } } return aContext->recycler()->getNumberResult(dbl, aResult); } case FLOOR: { double dbl; rv = evaluateToNumber(mParams[0], aContext, &dbl); NS_ENSURE_SUCCESS(rv, rv); if (!Double::isNaN(dbl) && !Double::isInfinite(dbl) && !(dbl == 0 && Double::isNeg(dbl))) { dbl = floor(dbl); } return aContext->recycler()->getNumberResult(dbl, aResult); } case CEILING: { double dbl; rv = evaluateToNumber(mParams[0], aContext, &dbl); NS_ENSURE_SUCCESS(rv, rv); if (!Double::isNaN(dbl) && !Double::isInfinite(dbl)) { if (Double::isNeg(dbl) && dbl > -1) { dbl *= 0; } else { dbl = ceil(dbl); } } return aContext->recycler()->getNumberResult(dbl, aResult); } case SUM: { nsRefPtr<txNodeSet> nodes; nsresult rv = evaluateToNodeSet(mParams[0], aContext, getter_AddRefs(nodes)); NS_ENSURE_SUCCESS(rv, rv); double res = 0; PRInt32 i; for (i = 0; i < nodes->size(); ++i) { nsAutoString resultStr; txXPathNodeUtils::appendNodeValue(nodes->get(i), resultStr); res += Double::toDouble(resultStr); } return aContext->recycler()->getNumberResult(res, aResult); } // Boolean functions case BOOLEAN: { PRBool result; nsresult rv = mParams[0]->evaluateToBool(aContext, result); NS_ENSURE_SUCCESS(rv, rv); aContext->recycler()->getBoolResult(result, aResult); return NS_OK; } case _FALSE: { aContext->recycler()->getBoolResult(PR_FALSE, aResult); return NS_OK; } case LANG: { txXPathTreeWalker walker(aContext->getContextNode()); nsAutoString lang; PRBool found; do { found = walker.getAttr(txXMLAtoms::lang, kNameSpaceID_XML, lang); } while (!found && walker.moveToParent()); if (!found) { aContext->recycler()->getBoolResult(PR_FALSE, aResult); return NS_OK; } nsAutoString arg; rv = mParams[0]->evaluateToString(aContext, arg); NS_ENSURE_SUCCESS(rv, rv); PRBool result = StringBeginsWith(lang, arg, txCaseInsensitiveStringComparator()) && (lang.Length() == arg.Length() || lang.CharAt(arg.Length()) == '-'); aContext->recycler()->getBoolResult(result, aResult); return NS_OK; } case _NOT: { PRBool result; rv = mParams[0]->evaluateToBool(aContext, result); NS_ENSURE_SUCCESS(rv, rv); aContext->recycler()->getBoolResult(!result, aResult); return NS_OK; } case _TRUE: { aContext->recycler()->getBoolResult(PR_TRUE, aResult); return NS_OK; } } aContext->receiveError(NS_LITERAL_STRING("Internal error"), NS_ERROR_UNEXPECTED); return NS_ERROR_UNEXPECTED; }
already_AddRefed<nsIMIMEInfo> nsOSHelperAppService::GetMIMEInfoFromOS(const nsACString& aMIMEType, const nsACString& aFileExt, bool *aFound) { *aFound = PR_TRUE; const nsCString& flatType = PromiseFlatCString(aMIMEType); const nsCString& flatExt = PromiseFlatCString(aFileExt); nsAutoString fileExtension; /* XXX The Equals is a gross hack to wallpaper over the most common Win32 * extension issues caused by the fix for bug 116938. See bug * 120327, comment 271 for why this is needed. Not even sure we * want to remove this once we have fixed all this stuff to work * right; any info we get from the OS on this type is pretty much * useless.... * We'll do extension-based lookup for this type later in this function. */ if (!aMIMEType.LowerCaseEqualsLiteral(APPLICATION_OCTET_STREAM)) { // (1) try to use the windows mime database to see if there is a mapping to a file extension // (2) try to see if we have some left over 4.x registry info we can peek at... GetExtensionFromWindowsMimeDatabase(aMIMEType, fileExtension); LOG(("Windows mime database: extension '%s'\n", fileExtension.get())); if (fileExtension.IsEmpty()) { GetExtensionFrom4xRegistryInfo(aMIMEType, fileExtension); LOG(("4.x Registry: extension '%s'\n", fileExtension.get())); } } // If we found an extension for the type, do the lookup nsMIMEInfoWin* mi = nsnull; if (!fileExtension.IsEmpty()) mi = GetByExtension(fileExtension, flatType.get()).get(); LOG(("Extension lookup on '%s' found: 0x%p\n", fileExtension.get(), mi)); bool hasDefault = false; if (mi) { mi->GetHasDefaultHandler(&hasDefault); // OK. We might have the case that |aFileExt| is a valid extension for the // mimetype we were given. In that case, we do want to append aFileExt // to the mimeinfo that we have. (E.g.: We are asked for video/mpeg and // .mpg, but the primary extension for video/mpeg is .mpeg. But because // .mpg is an extension for video/mpeg content, we want to append it) if (!aFileExt.IsEmpty() && typeFromExtEquals(NS_ConvertUTF8toUTF16(flatExt).get(), flatType.get())) { LOG(("Appending extension '%s' to mimeinfo, because its mimetype is '%s'\n", flatExt.get(), flatType.get())); bool extExist = false; mi->ExtensionExists(aFileExt, &extExist); if (!extExist) mi->AppendExtension(aFileExt); } } if (!mi || !hasDefault) { nsRefPtr<nsMIMEInfoWin> miByExt = GetByExtension(NS_ConvertUTF8toUTF16(aFileExt), flatType.get()); LOG(("Ext. lookup for '%s' found 0x%p\n", flatExt.get(), miByExt.get())); if (!miByExt && mi) return mi; if (miByExt && !mi) { miByExt.swap(mi); return mi; } if (!miByExt && !mi) { *aFound = PR_FALSE; mi = new nsMIMEInfoWin(flatType); if (mi) { NS_ADDREF(mi); if (!aFileExt.IsEmpty()) mi->AppendExtension(aFileExt); } return mi; } // if we get here, mi has no default app. copy from extension lookup. nsCOMPtr<nsIFile> defaultApp; nsAutoString desc; miByExt->GetDefaultDescription(desc); mi->SetDefaultDescription(desc); } return mi; }
NS_IMETHODIMP HTMLOutputElement::GetHtmlFor(nsISupports** aResult) { NS_ADDREF(*aResult = HtmlFor()); return NS_OK; }
NS_IMETHODIMP nsXULTemplateQueryProcessorStorage::GetDatasource(nsIArray* aDataSources, nsIDOMNode* aRootNode, bool aIsTrusted, nsIXULTemplateBuilder* aBuilder, bool* aShouldDelayBuilding, nsISupports** aReturn) { *aReturn = nullptr; *aShouldDelayBuilding = false; if (!aIsTrusted) { return NS_OK; } uint32_t length; nsresult rv = aDataSources->GetLength(&length); NS_ENSURE_SUCCESS(rv, rv); if (length == 0) { return NS_OK; } // We get only the first uri. This query processor supports // only one database at a time. nsCOMPtr<nsIURI> uri; uri = do_QueryElementAt(aDataSources, 0); if (!uri) { // No uri in the list of datasources return NS_OK; } nsCOMPtr<mozIStorageService> storage = do_GetService("@mozilla.org/storage/service;1", &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIFile> databaseFile; nsAutoCString scheme; rv = uri->GetScheme(scheme); NS_ENSURE_SUCCESS(rv, rv); if (scheme.EqualsLiteral("profile")) { nsAutoCString path; rv = uri->GetPath(path); NS_ENSURE_SUCCESS(rv, rv); if (path.IsEmpty()) { return NS_ERROR_FAILURE; } rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(databaseFile)); NS_ENSURE_SUCCESS(rv, rv); rv = databaseFile->AppendNative(path); NS_ENSURE_SUCCESS(rv, rv); } else { nsCOMPtr<nsIChannel> channel; nsCOMPtr<nsINode> node = do_QueryInterface(aRootNode); rv = NS_NewChannel(getter_AddRefs(channel), uri, node, nsILoadInfo::SEC_NORMAL, nsIContentPolicy::TYPE_OTHER); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(channel, &rv); if (NS_FAILED(rv)) { // if it fails, not a file url nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_STORAGE_BAD_URI); return rv; } nsCOMPtr<nsIFile> file; rv = fileChannel->GetFile(getter_AddRefs(databaseFile)); NS_ENSURE_SUCCESS(rv, rv); } // ok now we have an URI of a sqlite file nsCOMPtr<mozIStorageConnection> connection; rv = storage->OpenDatabase(databaseFile, getter_AddRefs(connection)); if (NS_FAILED(rv)) { nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_STORAGE_CANNOT_OPEN_DATABASE); return rv; } NS_ADDREF(*aReturn = connection); return NS_OK; }
nsresult nsFtpProtocolHandler::InsertConnection(nsIURI *aKey, nsFtpControlConnection *aConn) { NS_ASSERTION(aConn, "null pointer"); NS_ASSERTION(aKey, "null pointer"); if (aConn->mSessionId != mSessionId) return NS_ERROR_FAILURE; nsCAutoString spec; aKey->GetPrePath(spec); LOG(("FTP:inserting connection for %s\n", spec.get())); nsresult rv; nsCOMPtr<nsITimer> timer = do_CreateInstance("@mozilla.org/timer;1", &rv); if (NS_FAILED(rv)) return rv; timerStruct* ts = new timerStruct(); if (!ts) return NS_ERROR_OUT_OF_MEMORY; rv = timer->InitWithFuncCallback(nsFtpProtocolHandler::Timeout, ts, mIdleTimeout*1000, nsITimer::TYPE_REPEATING_SLACK); if (NS_FAILED(rv)) { delete ts; return rv; } ts->key = ToNewCString(spec); if (!ts->key) { delete ts; return NS_ERROR_OUT_OF_MEMORY; } NS_ADDREF(aConn); ts->conn = aConn; ts->timer = timer; // // limit number of idle connections. if limit is reached, then prune // eldest connection with matching key. if none matching, then prune // eldest connection. // if (mRootConnectionList.Length() == IDLE_CONNECTION_LIMIT) { uint32_t i; for (i=0;i<mRootConnectionList.Length();++i) { timerStruct *candidate = mRootConnectionList[i]; if (strcmp(candidate->key, ts->key) == 0) { mRootConnectionList.RemoveElementAt(i); delete candidate; break; } } if (mRootConnectionList.Length() == IDLE_CONNECTION_LIMIT) { timerStruct *eldest = mRootConnectionList[0]; mRootConnectionList.RemoveElementAt(0); delete eldest; } } mRootConnectionList.AppendElement(ts); return NS_OK; }
PChromiumCDMParent* GMPContentParent::AllocPChromiumCDMParent() { GMP_LOG("GMPContentParent::AllocPChromiumCDMParent(this=%p)", this); ChromiumCDMParent* parent = new ChromiumCDMParent(this, GetPluginId()); NS_ADDREF(parent); return parent; }
NS_IMETHODIMP nsContentDLF::CreateBlankDocument(nsILoadGroup *aLoadGroup, nsIPrincipal* aPrincipal, nsIDocument **aDocument) { NS_TIME_FUNCTION; *aDocument = nullptr; nsresult rv = NS_ERROR_FAILURE; // create a new blank HTML document nsCOMPtr<nsIDocument> blankDoc(do_CreateInstance(kHTMLDocumentCID)); if (blankDoc) { // initialize nsCOMPtr<nsIURI> uri; NS_NewURI(getter_AddRefs(uri), NS_LITERAL_CSTRING("about:blank")); if (uri) { blankDoc->ResetToURI(uri, aLoadGroup, aPrincipal); rv = NS_OK; } } // add some simple content structure if (NS_SUCCEEDED(rv)) { rv = NS_ERROR_FAILURE; nsNodeInfoManager *nim = blankDoc->NodeInfoManager(); nsCOMPtr<nsINodeInfo> htmlNodeInfo; // generate an html html element htmlNodeInfo = nim->GetNodeInfo(nsGkAtoms::html, 0, kNameSpaceID_XHTML, nsIDOMNode::ELEMENT_NODE); nsCOMPtr<nsIContent> htmlElement = NS_NewHTMLHtmlElement(htmlNodeInfo.forget()); // generate an html head element htmlNodeInfo = nim->GetNodeInfo(nsGkAtoms::head, 0, kNameSpaceID_XHTML, nsIDOMNode::ELEMENT_NODE); nsCOMPtr<nsIContent> headElement = NS_NewHTMLHeadElement(htmlNodeInfo.forget()); // generate an html body elemment htmlNodeInfo = nim->GetNodeInfo(nsGkAtoms::body, 0, kNameSpaceID_XHTML, nsIDOMNode::ELEMENT_NODE); nsCOMPtr<nsIContent> bodyElement = NS_NewHTMLBodyElement(htmlNodeInfo.forget()); // blat in the structure if (htmlElement && headElement && bodyElement) { NS_ASSERTION(blankDoc->GetChildCount() == 0, "Shouldn't have children"); rv = blankDoc->AppendChildTo(htmlElement, false); if (NS_SUCCEEDED(rv)) { rv = htmlElement->AppendChildTo(headElement, false); if (NS_SUCCEEDED(rv)) { // XXXbz Why not notifying here? htmlElement->AppendChildTo(bodyElement, false); } } } } // add a nice bow if (NS_SUCCEEDED(rv)) { blankDoc->SetDocumentCharacterSetSource(kCharsetFromDocTypeDefault); blankDoc->SetDocumentCharacterSet(NS_LITERAL_CSTRING("UTF-8")); *aDocument = blankDoc; NS_ADDREF(*aDocument); } return rv; }
PGMPVideoEncoderParent* GMPContentParent::AllocPGMPVideoEncoderParent() { GMP_LOG("GMPContentParent::AllocPGMPVideoEncoderParent(this=%p)", this); GMPVideoEncoderParent* vep = new GMPVideoEncoderParent(this); NS_ADDREF(vep); return vep; }
/** * Handle 'inout', 'out', and 'retval' params */ nsresult nsJavaXPTCStub::FinalizeJavaParams(const nsXPTParamInfo &aParamInfo, const XPTMethodDescriptor *aMethodInfo, PRUint16 aMethodIndex, nsXPTCMiniVariant* aDispatchParams, nsXPTCMiniVariant &aVariant, jvalue &aJValue) { nsresult rv = NS_OK; JNIEnv* env = GetJNIEnv(); const nsXPTType &type = aParamInfo.GetType(); PRUint8 tag = type.TagPart(); switch (tag) { case nsXPTType::T_I8: { jbyte value; if (aParamInfo.IsRetval()) { // 'retval' value = aJValue.b; } else if (aJValue.l) { // 'inout' & 'out' env->GetByteArrayRegion((jbyteArray) aJValue.l, 0, 1, &value); } if (aVariant.val.p) *((PRInt8 *) aVariant.val.p) = value; } break; case nsXPTType::T_U8: case nsXPTType::T_I16: { jshort value = 0; if (aParamInfo.IsRetval()) { // 'retval' value = aJValue.s; } else if (aJValue.l) { // 'inout' & 'out' env->GetShortArrayRegion((jshortArray) aJValue.l, 0, 1, &value); } if (aVariant.val.p) { if (tag == nsXPTType::T_U8) *((PRUint8 *) aVariant.val.p) = value; else *((PRInt16 *) aVariant.val.p) = value; } } break; case nsXPTType::T_U16: case nsXPTType::T_I32: { jint value = 0; if (aParamInfo.IsRetval()) { // 'retval' value = aJValue.i; } else if (aJValue.l) { // 'inout' & 'out' env->GetIntArrayRegion((jintArray) aJValue.l, 0, 1, &value); } if (aVariant.val.p) { if (tag == nsXPTType::T_U16) *((PRUint16 *) aVariant.val.p) = value; else *((PRInt32 *) aVariant.val.p) = value; } } break; case nsXPTType::T_U32: case nsXPTType::T_I64: { jlong value = 0; if (aParamInfo.IsRetval()) { // 'retval' value = aJValue.j; } else if (aJValue.l) { // 'inout' & 'out' env->GetLongArrayRegion((jlongArray) aJValue.l, 0, 1, &value); } if (aVariant.val.p) { if (tag == nsXPTType::T_U32) *((PRUint32 *) aVariant.val.p) = value; else *((PRInt64 *) aVariant.val.p) = value; } } break; case nsXPTType::T_FLOAT: { if (aParamInfo.IsRetval()) { // 'retval' *((float *) aVariant.val.p) = aJValue.f; } else if (aJValue.l) { // 'inout' & 'out' env->GetFloatArrayRegion((jfloatArray) aJValue.l, 0, 1, (jfloat*) aVariant.val.p); } } break; // XXX how do we handle 64-bit values? case nsXPTType::T_U64: case nsXPTType::T_DOUBLE: { jdouble value = 0; if (aParamInfo.IsRetval()) { // 'retval' value = aJValue.d; } else if (aJValue.l) { // 'inout' & 'out' env->GetDoubleArrayRegion((jdoubleArray) aJValue.l, 0, 1, &value); } if (aVariant.val.p) { if (tag == nsXPTType::T_DOUBLE) *((double *) aVariant.val.p) = value; else *((PRUint64 *) aVariant.val.p) = static_cast<PRUint64>(value); } } break; case nsXPTType::T_BOOL: { if (aParamInfo.IsRetval()) { // 'retval' *((PRBool *) aVariant.val.p) = aJValue.z; } else if (aJValue.l) { // 'inout' & 'out' env->GetBooleanArrayRegion((jbooleanArray) aJValue.l, 0, 1, (jboolean*) aVariant.val.p); } } break; case nsXPTType::T_CHAR: case nsXPTType::T_WCHAR: { if (aParamInfo.IsRetval()) { // 'retval' if (type.TagPart() == nsXPTType::T_CHAR) *((char *) aVariant.val.p) = aJValue.c; else *((PRUnichar *) aVariant.val.p) = aJValue.c; } else if (aJValue.l) { // 'inout' & 'out' jchar* array = env->GetCharArrayElements((jcharArray) aJValue.l, nsnull); if (!array) { rv = NS_ERROR_OUT_OF_MEMORY; break; } if (type.TagPart() == nsXPTType::T_CHAR) *((char *) aVariant.val.p) = array[0]; else *((PRUnichar *) aVariant.val.p) = array[0]; env->ReleaseCharArrayElements((jcharArray) aJValue.l, array, JNI_ABORT); } } break; case nsXPTType::T_CHAR_STR: { jstring str = nsnull; if (aParamInfo.IsRetval()) { // 'retval' str = (jstring) aJValue.l; } else { // 'inout' & 'out' str = (jstring) env->GetObjectArrayElement((jobjectArray) aJValue.l, 0); } char** variant = static_cast<char**>(aVariant.val.p); if (str) { // Get string buffer const char* char_ptr = env->GetStringUTFChars(str, nsnull); if (!char_ptr) { rv = NS_ERROR_OUT_OF_MEMORY; break; } // If new string is different from one passed in, free old string // and replace with new string. if (aParamInfo.IsRetval() || *variant == nsnull || strcmp(*variant, char_ptr) != 0) { if (!aParamInfo.IsRetval() && *variant) PR_Free(*variant); *variant = strdup(char_ptr); if (*variant == nsnull) { rv = NS_ERROR_OUT_OF_MEMORY; // don't 'break'; fall through to release chars } } // Release string buffer env->ReleaseStringUTFChars(str, char_ptr); } else { // If we were passed in a string, delete it now, and set to null. // (Only for 'inout' & 'out' params) if (*variant && !aParamInfo.IsRetval()) { PR_Free(*variant); } *variant = nsnull; } } break; case nsXPTType::T_WCHAR_STR: { jstring str = nsnull; if (aParamInfo.IsRetval()) { // 'retval' str = (jstring) aJValue.l; } else { // 'inout' & 'out' str = (jstring) env->GetObjectArrayElement((jobjectArray) aJValue.l, 0); } PRUnichar** variant = static_cast<PRUnichar**>(aVariant.val.p); if (str) { // Get string buffer const jchar* wchar_ptr = env->GetStringChars(str, nsnull); if (!wchar_ptr) { rv = NS_ERROR_OUT_OF_MEMORY; break; } // If new string is different from one passed in, free old string // and replace with new string. We if (aParamInfo.IsRetval() || *variant == nsnull || nsCRT::strcmp(*variant, wchar_ptr) != 0) { if (!aParamInfo.IsRetval() && *variant) PR_Free(*variant); PRUint32 length = nsCRT::strlen(wchar_ptr); *variant = (PRUnichar*) PR_Malloc((length + 1) * sizeof(PRUnichar)); if (*variant) { memcpy(*variant, wchar_ptr, length * sizeof(PRUnichar)); (*variant)[length] = 0; } else { rv = NS_ERROR_OUT_OF_MEMORY; // don't 'break'; fall through to release chars } } // Release string buffer env->ReleaseStringChars(str, wchar_ptr); } else { // If we were passed in a string, delete it now, and set to null. // (Only for 'inout' & 'out' params) if (*variant && !aParamInfo.IsRetval()) { PR_Free(*variant); } *variant = nsnull; } } break; case nsXPTType::T_IID: { jstring str = nsnull; if (aParamInfo.IsRetval()) { // 'retval' str = (jstring) aJValue.l; } else { // 'inout' & 'out' str = (jstring) env->GetObjectArrayElement((jobjectArray) aJValue.l, 0); } nsID** variant = static_cast<nsID**>(aVariant.val.p); if (str) { // Get string buffer const char* char_ptr = env->GetStringUTFChars(str, nsnull); if (!char_ptr) { rv = NS_ERROR_OUT_OF_MEMORY; break; } if (!aParamInfo.IsRetval() && *variant) { // If we were given an nsID, set it to the new string nsID* oldIID = *variant; oldIID->Parse(char_ptr); } else { // If the argument that was passed in was null, then we need to // create a new nsID. nsID* newIID = new nsID; if (newIID) { newIID->Parse(char_ptr); *variant = newIID; } else { rv = NS_ERROR_OUT_OF_MEMORY; // don't 'break'; fall through to release chars } } // Release string buffer env->ReleaseStringUTFChars(str, char_ptr); } else { // If we were passed in an nsID, delete it now, and set to null. // (Free only 'inout' & 'out' params) if (*variant && !aParamInfo.IsRetval()) { delete *variant; } *variant = nsnull; } } break; case nsXPTType::T_INTERFACE: case nsXPTType::T_INTERFACE_IS: { jobject java_obj = nsnull; if (aParamInfo.IsRetval()) { // 'retval' java_obj = aJValue.l; } else if (aJValue.l) { // 'inout' & 'out' java_obj = env->GetObjectArrayElement((jobjectArray) aJValue.l, 0); } void* xpcom_obj = nsnull; if (java_obj) { // Get IID for this param nsID iid; rv = GetIIDForMethodParam(mIInfo, aMethodInfo, aParamInfo, aParamInfo.GetType().TagPart(), aMethodIndex, aDispatchParams, PR_FALSE, iid); if (NS_FAILED(rv)) break; // If the requested interface is nsIWeakReference, then we look for or // create a stub for the nsISupports interface. Then we create a weak // reference from that stub. PRBool isWeakRef; if (iid.Equals(NS_GET_IID(nsIWeakReference))) { isWeakRef = PR_TRUE; iid = NS_GET_IID(nsISupports); } else { isWeakRef = PR_FALSE; } rv = JavaObjectToNativeInterface(env, java_obj, iid, &xpcom_obj); if (NS_FAILED(rv)) break; rv = ((nsISupports*) xpcom_obj)->QueryInterface(iid, &xpcom_obj); if (NS_FAILED(rv)) break; // If the function expects a weak reference, then we need to // create it here. if (isWeakRef) { nsISupports* isupports = (nsISupports*) xpcom_obj; nsCOMPtr<nsISupportsWeakReference> supportsweak = do_QueryInterface(isupports); if (supportsweak) { nsWeakPtr weakref; supportsweak->GetWeakReference(getter_AddRefs(weakref)); NS_RELEASE(isupports); xpcom_obj = weakref; NS_ADDREF((nsISupports*) xpcom_obj); } else { xpcom_obj = nsnull; } } } // For 'inout' params, if the resulting xpcom value is different than the // one passed in, then we must release the incoming xpcom value. nsISupports** variant = static_cast<nsISupports**>(aVariant.val.p); if (aParamInfo.IsIn() && *variant) { nsCOMPtr<nsISupports> in = do_QueryInterface(*variant); nsCOMPtr<nsISupports> out = do_QueryInterface((nsISupports*) xpcom_obj); if (in != out) { NS_RELEASE(*variant); } } *(static_cast<void**>(aVariant.val.p)) = xpcom_obj; } break; case nsXPTType::T_ASTRING: case nsXPTType::T_DOMSTRING: { NS_PRECONDITION(aParamInfo.IsDipper(), "string argument is not dipper"); if (!aParamInfo.IsDipper()) { rv = NS_ERROR_UNEXPECTED; break; } jstring jstr = (jstring) aJValue.l; nsString* variant = static_cast<nsString*>(aVariant.val.p); if (jstr) { // Get string buffer const jchar* wchar_ptr = env->GetStringChars(jstr, nsnull); if (!wchar_ptr) { rv = NS_ERROR_OUT_OF_MEMORY; break; } variant->Assign(wchar_ptr); // release String buffer env->ReleaseStringChars(jstr, wchar_ptr); } else { variant->SetIsVoid(PR_TRUE); } } break; case nsXPTType::T_UTF8STRING: case nsXPTType::T_CSTRING: { NS_PRECONDITION(aParamInfo.IsDipper(), "string argument is not dipper"); if (!aParamInfo.IsDipper()) { rv = NS_ERROR_UNEXPECTED; break; } jstring jstr = (jstring) aJValue.l; nsCString* variant = static_cast<nsCString*>(aVariant.val.p); if (jstr) { // Get string buffer const char* char_ptr = env->GetStringUTFChars(jstr, nsnull); if (!char_ptr) { rv = NS_ERROR_OUT_OF_MEMORY; break; } variant->Assign(char_ptr); // release String buffer env->ReleaseStringUTFChars(jstr, char_ptr); } else { variant->SetIsVoid(PR_TRUE); } } break; case nsXPTType::T_VOID: { if (aParamInfo.IsRetval()) { // 'retval' aVariant.val.p = reinterpret_cast<void*>(aJValue.j); } else if (aJValue.l) { // 'inout' & 'out' env->GetLongArrayRegion((jlongArray) aJValue.l, 0, 1, (jlong*) aVariant.val.p); } } break; default: NS_WARNING("unexpected parameter type"); return NS_ERROR_UNEXPECTED; } return rv; }
nsMsgThreadEnumerator::nsMsgThreadEnumerator(nsMsgThread *thread, nsMsgKey startKey, nsMsgThreadEnumeratorFilter filter, void* closure) : mRowCursor(nullptr), mDone(false), mFilter(filter), mClosure(closure), mFoundChildren(false) { mThreadParentKey = startKey; mChildIndex = 0; mThread = thread; mNeedToPrefetch = true; mFirstMsgKey = nsMsgKey_None; nsresult rv = mThread->GetRootHdr(nullptr, getter_AddRefs(mResultHdr)); if (NS_SUCCEEDED(rv) && mResultHdr) mResultHdr->GetMessageKey(&mFirstMsgKey); uint32_t numChildren; mThread->GetNumChildren(&numChildren); if (mThreadParentKey != nsMsgKey_None) { nsMsgKey msgKey = nsMsgKey_None; uint32_t childIndex = 0; for (childIndex = 0; childIndex < numChildren; childIndex++) { rv = mThread->GetChildHdrAt(childIndex, getter_AddRefs(mResultHdr)); if (NS_SUCCEEDED(rv) && mResultHdr) { mResultHdr->GetMessageKey(&msgKey); if (msgKey == startKey) { mChildIndex = MsgKeyFirstChildIndex(msgKey); mDone = (mChildIndex < 0); break; } if (mDone) break; } else NS_ASSERTION(false, "couldn't get child from thread"); } } #ifdef DEBUG_bienvenu1 nsCOMPtr <nsIMsgDBHdr> child; for (uint32_t childIndex = 0; childIndex < numChildren; childIndex++) { rv = mThread->GetChildHdrAt(childIndex, getter_AddRefs(child)); if (NS_SUCCEEDED(rv) && child) { nsMsgKey threadParent; nsMsgKey msgKey; // we're only doing one level of threading, so check if caller is // asking for children of the first message in the thread or not. // if not, we will tell him there are no children. child->GetMessageKey(&msgKey); child->GetThreadParent(&threadParent); printf("index = %ld key = %ld parent = %lx\n", childIndex, msgKey, threadParent); } } #endif NS_ADDREF(thread); }
// add SOCKS IO layer to an existing socket nsresult nsSOCKSIOLayerAddToSocket(PRInt32 family, const char *host, PRInt32 port, const char *proxyHost, PRInt32 proxyPort, PRInt32 socksVersion, PRUint32 flags, PRFileDesc *fd, nsISupports** info) { NS_ENSURE_TRUE((socksVersion == 4) || (socksVersion == 5), NS_ERROR_NOT_INITIALIZED); if (firstTime) { //XXX hack until NSPR provides an official way to detect system IPv6 // support (bug 388519) PRFileDesc *tmpfd = PR_OpenTCPSocket(PR_AF_INET6); if (!tmpfd) { ipv6Supported = false; } else { // If the system does not support IPv6, NSPR will push // IPv6-to-IPv4 emulation layer onto the native layer ipv6Supported = PR_GetIdentitiesLayer(tmpfd, PR_NSPR_IO_LAYER) == tmpfd; PR_Close(tmpfd); } nsSOCKSIOLayerIdentity = PR_GetUniqueIdentity("SOCKS layer"); nsSOCKSIOLayerMethods = *PR_GetDefaultIOMethods(); nsSOCKSIOLayerMethods.connect = nsSOCKSIOLayerConnect; nsSOCKSIOLayerMethods.connectcontinue = nsSOCKSIOLayerConnectContinue; nsSOCKSIOLayerMethods.poll = nsSOCKSIOLayerPoll; nsSOCKSIOLayerMethods.bind = nsSOCKSIOLayerBind; nsSOCKSIOLayerMethods.acceptread = nsSOCKSIOLayerAcceptRead; nsSOCKSIOLayerMethods.getsockname = nsSOCKSIOLayerGetName; nsSOCKSIOLayerMethods.getpeername = nsSOCKSIOLayerGetPeerName; nsSOCKSIOLayerMethods.accept = nsSOCKSIOLayerAccept; nsSOCKSIOLayerMethods.listen = nsSOCKSIOLayerListen; nsSOCKSIOLayerMethods.close = nsSOCKSIOLayerClose; firstTime = false; #if defined(PR_LOGGING) gSOCKSLog = PR_NewLogModule("SOCKS"); #endif } LOGDEBUG(("Entering nsSOCKSIOLayerAddToSocket().")); PRFileDesc * layer; PRStatus rv; layer = PR_CreateIOLayerStub(nsSOCKSIOLayerIdentity, &nsSOCKSIOLayerMethods); if (! layer) { LOGERROR(("PR_CreateIOLayerStub() failed.")); return NS_ERROR_FAILURE; } nsSOCKSSocketInfo * infoObject = new nsSOCKSSocketInfo(); if (!infoObject) { // clean up IOLayerStub LOGERROR(("Failed to create nsSOCKSSocketInfo().")); PR_DELETE(layer); return NS_ERROR_FAILURE; } NS_ADDREF(infoObject); infoObject->Init(socksVersion, family, proxyHost, proxyPort, host, flags); layer->secret = (PRFilePrivate*) infoObject; rv = PR_PushIOLayer(fd, PR_GetLayersIdentity(fd), layer); if (NS_FAILED(rv)) { LOGERROR(("PR_PushIOLayer() failed. rv = %x.", rv)); NS_RELEASE(infoObject); PR_DELETE(layer); return NS_ERROR_FAILURE; } *info = static_cast<nsISOCKSSocketInfo*>(infoObject); NS_ADDREF(*info); return NS_OK; }
NS_IMETHODIMP nsMsgThread::GetRootHdr(int32_t *resultIndex, nsIMsgDBHdr **result) { NS_ENSURE_ARG_POINTER(result); *result = nullptr; nsresult rv = NS_OK; if (m_threadRootKey != nsMsgKey_None) { rv = GetChildHdrForKey(m_threadRootKey, result, resultIndex); if (NS_SUCCEEDED(rv) && *result) { // check that we're really the root key. nsMsgKey parentKey; (*result)->GetThreadParent(&parentKey); if (parentKey == nsMsgKey_None) return rv; NS_RELEASE(*result); } #ifdef DEBUG_David_Bienvenu printf("need to reset thread root key\n"); #endif uint32_t numChildren; nsMsgKey threadParentKey = nsMsgKey_None; GetNumChildren(&numChildren); for (uint32_t childIndex = 0; childIndex < numChildren; childIndex++) { nsCOMPtr <nsIMsgDBHdr> curChild; rv = GetChildHdrAt(childIndex, getter_AddRefs(curChild)); if (NS_SUCCEEDED(rv) && curChild) { nsMsgKey parentKey; curChild->GetThreadParent(&parentKey); if (parentKey == nsMsgKey_None) { curChild->GetMessageKey(&threadParentKey); if (*result) { NS_WARNING("two top level msgs, not good"); continue; } SetThreadRootKey(threadParentKey); if (resultIndex) *resultIndex = childIndex; NS_ADDREF(*result = curChild); ReparentMsgsWithInvalidParent(numChildren, threadParentKey); // return NS_OK; } } } } if (!*result) { // if we can't get the thread root key, we'll just get the first hdr. // there's a bug where sometimes we weren't resetting the thread root key // when removing the thread root key. if (resultIndex) *resultIndex = 0; rv = GetChildHdrAt(0, result); } if (!*result) return rv; // Check that the thread id of the message is this thread. nsMsgKey threadId = nsMsgKey_None; (void)(*result)->GetThreadId(&threadId); if (threadId != m_threadKey) (*result)->SetThreadId(m_threadKey); return rv; }
nsresult nsXREDirProvider::GetUpdateRootDir(nsIFile* *aResult) { nsCOMPtr<nsIFile> updRoot; #if defined(MOZ_WIDGET_GONK) nsresult rv = NS_NewNativeLocalFile(nsDependentCString("/data/local"), true, getter_AddRefs(updRoot)); NS_ENSURE_SUCCESS(rv, rv); #else nsCOMPtr<nsIFile> appFile; bool per = false; nsresult rv = GetFile(XRE_EXECUTABLE_FILE, &per, getter_AddRefs(appFile)); NS_ENSURE_SUCCESS(rv, rv); rv = appFile->GetParent(getter_AddRefs(updRoot)); NS_ENSURE_SUCCESS(rv, rv); #ifdef XP_WIN nsAutoString pathHash; bool pathHashResult = false; bool hasVendor = gAppData->vendor && strlen(gAppData->vendor) != 0; nsAutoString appDirPath; if (SUCCEEDED(updRoot->GetPath(appDirPath))) { // Figure out where we should check for a cached hash value. If the // application doesn't have the nsXREAppData vendor value defined check // under SOFTWARE\Mozilla. wchar_t regPath[1024] = { L'\0' }; swprintf_s(regPath, mozilla::ArrayLength(regPath), L"SOFTWARE\\%S\\%S\\TaskBarIDs", (hasVendor ? gAppData->vendor : "Mozilla"), MOZ_APP_BASENAME); // If we pre-computed the hash, grab it from the registry. pathHashResult = GetCachedHash(HKEY_LOCAL_MACHINE, nsDependentString(regPath), appDirPath, pathHash); if (!pathHashResult) { pathHashResult = GetCachedHash(HKEY_CURRENT_USER, nsDependentString(regPath), appDirPath, pathHash); } } // Get the local app data directory and if a vendor name exists append it. // If only a product name exists, append it. If neither exist fallback to // old handling. We don't use the product name on purpose because we want a // shared update directory for different apps run from the same path (like // Metro & Desktop). nsCOMPtr<nsIFile> localDir; if (pathHashResult && (hasVendor || gAppData->name) && NS_SUCCEEDED(GetUserDataDirectoryHome(getter_AddRefs(localDir), true)) && NS_SUCCEEDED(localDir->AppendNative(nsDependentCString(hasVendor ? gAppData->vendor : gAppData->name))) && NS_SUCCEEDED(localDir->Append(NS_LITERAL_STRING("updates"))) && NS_SUCCEEDED(localDir->Append(pathHash))) { NS_ADDREF(*aResult = localDir); return NS_OK; } nsAutoString appPath; rv = updRoot->GetPath(appPath); NS_ENSURE_SUCCESS(rv, rv); // AppDir may be a short path. Convert to long path to make sure // the consistency of the update folder location nsString longPath; wchar_t* buf; uint32_t bufLength = longPath.GetMutableData(&buf, MAXPATHLEN); NS_ENSURE_TRUE(bufLength >= MAXPATHLEN, NS_ERROR_OUT_OF_MEMORY); DWORD len = GetLongPathNameW(appPath.get(), buf, bufLength); // Failing GetLongPathName() is not fatal. if (len <= 0 || len >= bufLength) longPath.Assign(appPath); else longPath.SetLength(len); // Use <UserLocalDataDir>\updates\<relative path to app dir from // Program Files> if app dir is under Program Files to avoid the // folder virtualization mess on Windows Vista nsAutoString programFiles; rv = GetShellFolderPath(CSIDL_PROGRAM_FILES, programFiles); NS_ENSURE_SUCCESS(rv, rv); programFiles.AppendLiteral("\\"); uint32_t programFilesLen = programFiles.Length(); nsAutoString programName; if (_wcsnicmp(programFiles.get(), longPath.get(), programFilesLen) == 0) { programName = Substring(longPath, programFilesLen); } else { // We need the update root directory to live outside of the installation // directory, because otherwise the updater writing the log file can cause // the directory to be locked, which prevents it from being replaced after // background updates. programName.AssignASCII(MOZ_APP_NAME); } rv = GetUserLocalDataDirectory(getter_AddRefs(updRoot)); NS_ENSURE_SUCCESS(rv, rv); rv = updRoot->AppendRelativePath(programName); NS_ENSURE_SUCCESS(rv, rv); #endif #endif NS_ADDREF(*aResult = updRoot); return NS_OK; }
bool OutlookSettings::DoImport(nsIMsgAccount **aAccount) { nsCOMPtr<nsIWindowsRegKey> key; nsresult rv = OutlookSettings::FindAccountsKey(getter_AddRefs(key)); if (NS_FAILED(rv)) { IMPORT_LOG0("*** Error finding Outlook registry account keys\n"); return false; } nsCOMPtr<nsIMsgAccountManager> accMgr = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv); if (NS_FAILED(rv)) { IMPORT_LOG0("*** Failed to create a account manager!\n"); return false; } nsAutoString defMailName; rv = GetDefaultMailAccountName(defMailName); uint32_t childCount; key->GetChildCount(&childCount); uint32_t accounts = 0; uint32_t popCount = 0; for (uint32_t i = 0; i < childCount; i++) { nsAutoString keyName; key->GetChildName(i, keyName); nsCOMPtr<nsIWindowsRegKey> subKey; rv = key->OpenChild(keyName, nsIWindowsRegKey::ACCESS_QUERY_VALUE, getter_AddRefs(subKey)); if (NS_FAILED(rv)) continue; // Get the values for this account. nsAutoCString nativeKeyName; NS_CopyUnicodeToNative(keyName, nativeKeyName); IMPORT_LOG1("Opened Outlook account: %s\n", nativeKeyName.get()); nsCOMPtr<nsIMsgAccount> account; nsAutoString value; rv = subKey->ReadStringValue(NS_LITERAL_STRING("IMAP Server"), value); if (NS_SUCCEEDED(rv) && DoIMAPServer(accMgr, subKey, value, getter_AddRefs(account))) accounts++; rv = subKey->ReadStringValue(NS_LITERAL_STRING("POP3 Server"), value); if (NS_SUCCEEDED(rv) && DoPOP3Server(accMgr, subKey, value, getter_AddRefs(account))) { popCount++; accounts++; if (aAccount && account) { // If we created a mail account, get rid of it since // we have 2 POP accounts! if (popCount > 1) NS_RELEASE(*aAccount); else NS_ADDREF(*aAccount = account); } } // Is this the default account? if (account && keyName.Equals(defMailName)) accMgr->SetDefaultAccount(account); } // Now save the new acct info to pref file. rv = accMgr->SaveAccountInfo(); NS_ASSERTION(NS_SUCCEEDED(rv), "Can't save account info to pref file"); return accounts != 0; }
nsresult nsHttpTransaction::Init(PRUint8 caps, nsHttpConnectionInfo *cinfo, nsHttpRequestHead *requestHead, nsIInputStream *requestBody, PRBool requestBodyHasHeaders, nsIEventTarget *target, nsIInterfaceRequestor *callbacks, nsITransportEventSink *eventsink, nsIAsyncInputStream **responseBody) { NS_TIME_FUNCTION; nsresult rv; LOG(("nsHttpTransaction::Init [this=%x caps=%x]\n", this, caps)); NS_ASSERTION(cinfo, "ouch"); NS_ASSERTION(requestHead, "ouch"); NS_ASSERTION(target, "ouch"); mActivityDistributor = do_GetService(NS_HTTPACTIVITYDISTRIBUTOR_CONTRACTID, &rv); if (NS_FAILED(rv)) return rv; PRBool activityDistributorActive; rv = mActivityDistributor->GetIsActive(&activityDistributorActive); if (NS_SUCCEEDED(rv) && activityDistributorActive) { // there are some observers registered at activity distributor, gather // nsISupports for the channel that called Init() mChannel = do_QueryInterface(eventsink); LOG(("nsHttpTransaction::Init() " \ "mActivityDistributor is active " \ "this=%x", this)); } else { // there is no observer, so don't use it activityDistributorActive = PR_FALSE; mActivityDistributor = nsnull; } // create transport event sink proxy. it coalesces all events if and only // if the activity observer is not active. when the observer is active // we need not to coalesce any events to get all expected notifications // of the transaction state, necessary for correct debugging and logging. rv = net_NewTransportEventSinkProxy(getter_AddRefs(mTransportSink), eventsink, target, !activityDistributorActive); if (NS_FAILED(rv)) return rv; NS_ADDREF(mConnInfo = cinfo); mCallbacks = callbacks; mConsumerTarget = target; mCaps = caps; if (requestHead->Method() == nsHttp::Head) mNoContent = PR_TRUE; // Make sure that there is "Content-Length: 0" header in the requestHead // in case of POST and PUT methods when there is no requestBody and // requestHead doesn't contain "Transfer-Encoding" header. // // RFC1945 section 7.2.2: // HTTP/1.0 requests containing an entity body must include a valid // Content-Length header field. // // RFC2616 section 4.4: // For compatibility with HTTP/1.0 applications, HTTP/1.1 requests // containing a message-body MUST include a valid Content-Length header // field unless the server is known to be HTTP/1.1 compliant. if ((requestHead->Method() == nsHttp::Post || requestHead->Method() == nsHttp::Put) && !requestBody && !requestHead->PeekHeader(nsHttp::Transfer_Encoding)) { requestHead->SetHeader(nsHttp::Content_Length, NS_LITERAL_CSTRING("0")); } // grab a weak reference to the request head mRequestHead = requestHead; // make sure we eliminate any proxy specific headers from // the request if we are talking HTTPS via a SSL tunnel. PRBool pruneProxyHeaders = cinfo->ShouldForceConnectMethod() || (cinfo->UsingSSL() && cinfo->UsingHttpProxy()); mReqHeaderBuf.Truncate(); requestHead->Flatten(mReqHeaderBuf, pruneProxyHeaders); #if defined(PR_LOGGING) if (LOG3_ENABLED()) { LOG3(("http request [\n")); LogHeaders(mReqHeaderBuf.get()); LOG3(("]\n")); } #endif // If the request body does not include headers or if there is no request // body, then we must add the header/body separator manually. if (!requestBodyHasHeaders || !requestBody) mReqHeaderBuf.AppendLiteral("\r\n"); // report the request header if (mActivityDistributor) mActivityDistributor->ObserveActivity( mChannel, NS_HTTP_ACTIVITY_TYPE_HTTP_TRANSACTION, NS_HTTP_ACTIVITY_SUBTYPE_REQUEST_HEADER, PR_Now(), LL_ZERO, mReqHeaderBuf); // Create a string stream for the request header buf (the stream holds // a non-owning reference to the request header data, so we MUST keep // mReqHeaderBuf around). nsCOMPtr<nsIInputStream> headers; rv = NS_NewByteInputStream(getter_AddRefs(headers), mReqHeaderBuf.get(), mReqHeaderBuf.Length()); if (NS_FAILED(rv)) return rv; if (requestBody) { mHasRequestBody = PR_TRUE; // wrap the headers and request body in a multiplexed input stream. nsCOMPtr<nsIMultiplexInputStream> multi = do_CreateInstance(kMultiplexInputStream, &rv); if (NS_FAILED(rv)) return rv; rv = multi->AppendStream(headers); if (NS_FAILED(rv)) return rv; rv = multi->AppendStream(requestBody); if (NS_FAILED(rv)) return rv; // wrap the multiplexed input stream with a buffered input stream, so // that we write data in the largest chunks possible. this is actually // necessary to workaround some common server bugs (see bug 137155). rv = NS_NewBufferedInputStream(getter_AddRefs(mRequestStream), multi, nsIOService::gDefaultSegmentSize); if (NS_FAILED(rv)) return rv; } else mRequestStream = headers; rv = mRequestStream->Available(&mRequestSize); if (NS_FAILED(rv)) return rv; // create pipe for response stream rv = NS_NewPipe2(getter_AddRefs(mPipeIn), getter_AddRefs(mPipeOut), PR_TRUE, PR_TRUE, nsIOService::gDefaultSegmentSize, nsIOService::gDefaultSegmentCount, nsIOService::gBufferCache); if (NS_FAILED(rv)) return rv; NS_ADDREF(*responseBody = mPipeIn); return NS_OK; }
NS_IMETHODIMP nsUnknownContentTypeHandler::PromptForSaveToFile( nsIHelperAppLauncher* aLauncher, nsISupports *aWindowContext, const PRUnichar *aDefaultFile, const PRUnichar *aSuggestedFileExtension, nsILocalFile **_retval ) { ///* ATENTIE */ printf("PromptForSaveToFile!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n"); NS_ENSURE_ARG_POINTER(_retval); *_retval = nsnull; /* try to get the PtMozillawidget_t* pointer form the aContext - use the fact the the WebBrowserContainer is registering itself as nsIDocumentLoaderObserver ( SetDocLoaderObserver ) */ nsCOMPtr<nsIDOMWindow> domw( do_GetInterface( aWindowContext ) ); nsIDOMWindow *parent; domw->GetParent( &parent ); PtWidget_t *w = GetWebBrowser( parent ); PtMozillaWidget_t *moz = ( PtMozillaWidget_t * ) w; /* get the suggested filename */ NS_ConvertUCS2toUTF8 theUnicodeString( aDefaultFile ); const char *filename = theUnicodeString.get( ); /* get the url */ nsCOMPtr<nsIURI> aSourceUrl; aLauncher->GetSource( getter_AddRefs(aSourceUrl) ); const char *url; nsCAutoString specString; aSourceUrl->GetSpec(specString); url = specString.get(); /* get the mime type */ nsCOMPtr<nsIMIMEInfo> mimeInfo; aLauncher->GetMIMEInfo( getter_AddRefs(mimeInfo) ); nsCAutoString mimeType; mimeInfo->GetMIMEType( mimeType ); PtCallbackInfo_t cbinfo; PtWebUnknownWithNameCallback_t cb; memset( &cbinfo, 0, sizeof( cbinfo ) ); cbinfo.reason = Pt_CB_MOZ_UNKNOWN; cbinfo.cbdata = &cb; cb.action = Pt_WEB_ACTION_OK; cb.content_type = (char*)mimeType.get(); cb.url = (char *)url; cb.content_length = strlen( cb.url ); cb.suggested_filename = (char*)filename; PtInvokeCallbackList( moz->web_unknown_cb, (PtWidget_t *)moz, &cbinfo ); /* this will modal wait for a Pt_ARG_WEB_UNKNOWN_RESP, in mozserver */ /* we have the result in moz->moz_unknown_ctrl */ if( moz->moz_unknown_ctrl->response != Pt_WEB_RESPONSE_OK ) return NS_ERROR_ABORT; /* the user chosen filename is moz->moz_unknown_ctrl->filename */ nsCOMPtr<nsILocalFile> file(do_CreateInstance("@mozilla.org/file/local;1")); NS_ENSURE_TRUE(file, NS_ERROR_FAILURE); nsCString s ( moz->moz_unknown_ctrl->filename ); file->InitWithNativePath( s ); if( !file ) return NS_ERROR_FAILURE; *_retval = file; NS_ADDREF( *_retval ); /* add this download to our list */ EmbedDownload *download = new EmbedDownload( moz, moz->moz_unknown_ctrl->download_ticket, url ); download->mLauncher = aLauncher; aLauncher->SetWebProgressListener( download ); return NS_OK; }
NS_IMETHODIMP nsHttpNTLMAuth::ChallengeReceived(nsIHttpAuthenticableChannel *channel, const char *challenge, bool isProxyAuth, nsISupports **sessionState, nsISupports **continuationState, bool *identityInvalid) { LOG(("nsHttpNTLMAuth::ChallengeReceived [ss=%p cs=%p]\n", *sessionState, *continuationState)); // Use the native NTLM if available mUseNative = true; // NOTE: we don't define any session state, but we do use the pointer. *identityInvalid = false; // Start a new auth sequence if the challenge is exactly "NTLM". // If native NTLM auth apis are available and enabled through prefs, // try to use them. if (PL_strcasecmp(challenge, "NTLM") == 0) { nsCOMPtr<nsISupports> module; // Check to see if we should default to our generic NTLM auth module // through UseGenericNTLM. (We use native auth by default if the // system provides it.) If *sessionState is non-null, we failed to // instantiate a native NTLM module the last time, so skip trying again. bool forceGeneric = ForceGenericNTLM(); if (!forceGeneric && !*sessionState) { // Check for approved default credentials hosts and proxies. If // *continuationState is non-null, the last authentication attempt // failed so skip default credential use. if (!*continuationState && CanUseDefaultCredentials(channel, isProxyAuth)) { // Try logging in with the user's default credentials. If // successful, |identityInvalid| is false, which will trigger // a default credentials attempt once we return. module = do_CreateInstance(NS_AUTH_MODULE_CONTRACTID_PREFIX "sys-ntlm"); } #ifdef XP_WIN else { // Try to use native NTLM and prompt the user for their domain, // username, and password. (only supported by windows nsAuthSSPI module.) // Note, for servers that use LMv1 a weak hash of the user's password // will be sent. We rely on windows internal apis to decide whether // we should support this older, less secure version of the protocol. module = do_CreateInstance(NS_AUTH_MODULE_CONTRACTID_PREFIX "sys-ntlm"); *identityInvalid = true; } #endif // XP_WIN if (!module) LOG(("Native sys-ntlm auth module not found.\n")); } #ifdef XP_WIN // On windows, never fall back unless the user has specifically requested so. if (!forceGeneric && !module) return NS_ERROR_UNEXPECTED; #endif // If no native support was available. Fall back on our internal NTLM implementation. if (!module) { if (!*sessionState) { // Remember the fact that we cannot use the "sys-ntlm" module, // so we don't ever bother trying again for this auth domain. *sessionState = new nsNTLMSessionState(); if (!*sessionState) return NS_ERROR_OUT_OF_MEMORY; NS_ADDREF(*sessionState); } // Use our internal NTLM implementation. Note, this is less secure, // see bug 520607 for details. LOG(("Trying to fall back on internal ntlm auth.\n")); module = do_CreateInstance(NS_AUTH_MODULE_CONTRACTID_PREFIX "ntlm"); mUseNative = false; // Prompt user for domain, username, and password. *identityInvalid = true; } // If this fails, then it means that we cannot do NTLM auth. if (!module) { LOG(("No ntlm auth modules available.\n")); return NS_ERROR_UNEXPECTED; } // A non-null continuation state implies that we failed to authenticate. // Blow away the old authentication state, and use the new one. module.swap(*continuationState); } return NS_OK; }
/* * Evaluates this Expr based on the given context node and processor state * NOTE: the implementation is incomplete since it does not make use of the * second argument (base URI) * @param context the context node for evaluation of this Expr * @return the result of the evaluation */ nsresult DocumentFunctionCall::evaluate(txIEvalContext* aContext, txAExprResult** aResult) { *aResult = nsnull; txExecutionState* es = static_cast<txExecutionState*>(aContext->getPrivateContext()); nsRefPtr<txNodeSet> nodeSet; nsresult rv = aContext->recycler()->getNodeSet(getter_AddRefs(nodeSet)); NS_ENSURE_SUCCESS(rv, rv); // document(object, node-set?) if (!requireParams(1, 2, aContext)) { return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT; } nsRefPtr<txAExprResult> exprResult1; rv = mParams[0]->evaluate(aContext, getter_AddRefs(exprResult1)); NS_ENSURE_SUCCESS(rv, rv); nsAutoString baseURI; MBool baseURISet = MB_FALSE; if (mParams.Length() == 2) { // We have 2 arguments, get baseURI from the first node // in the resulting nodeset nsRefPtr<txNodeSet> nodeSet2; rv = evaluateToNodeSet(mParams[1], aContext, getter_AddRefs(nodeSet2)); NS_ENSURE_SUCCESS(rv, rv); // Make this true, even if nodeSet2 is empty. For relative URLs, // we'll fail to load the document with an empty base URI, and for // absolute URLs, the base URI doesn't matter baseURISet = MB_TRUE; if (!nodeSet2->isEmpty()) { txXPathNodeUtils::getBaseURI(nodeSet2->get(0), baseURI); } } if (exprResult1->getResultType() == txAExprResult::NODESET) { // The first argument is a NodeSet, iterate on its nodes txNodeSet* nodeSet1 = static_cast<txNodeSet*> (static_cast<txAExprResult*> (exprResult1)); PRInt32 i; for (i = 0; i < nodeSet1->size(); ++i) { const txXPathNode& node = nodeSet1->get(i); nsAutoString uriStr; txXPathNodeUtils::appendNodeValue(node, uriStr); if (!baseURISet) { // if the second argument wasn't specified, use // the baseUri of node itself txXPathNodeUtils::getBaseURI(node, baseURI); } retrieveNode(es, uriStr, baseURI, nodeSet); } NS_ADDREF(*aResult = nodeSet); return NS_OK; } // The first argument is not a NodeSet nsAutoString uriStr; exprResult1->stringValue(uriStr); const nsAString* base = baseURISet ? &baseURI : &mBaseURI; retrieveNode(es, uriStr, *base, nodeSet); NS_ADDREF(*aResult = nodeSet); return NS_OK; }