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;
}
