mirror of
https://github.com/rn10950/RetroZilla.git
synced 2024-07-04 08:20:14 +02:00
1467 lines
54 KiB
JavaScript
1467 lines
54 KiB
JavaScript
/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
*
|
|
* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is the mozilla.org LDAP RDF datasource.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 2000
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Dan Mosedale <dmose@mozilla.org>
|
|
* Brendan Eich <brendan@mozilla.org>
|
|
* Peter Van der Beken <peter.vanderbeken@pandora.be>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
const DEBUG = true;
|
|
|
|
// core RDF schema
|
|
//
|
|
const RDF_NAMESPACE_URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
|
|
const NC_NAMESPACE_URI = "http://home.netscape.com/NC-rdf#";
|
|
const LDAPATTR_NAMESPACE_URI = "http://www.mozilla.org/LDAPATTR-rdf#";
|
|
|
|
// RDF-specific success nsresults
|
|
//
|
|
const NS_ERROR_RDF_BASE = 0x804f0000; // XXX is this right?
|
|
const NS_RDF_CURSOR_EMPTY = NS_ERROR_RDF_BASE + 1;
|
|
const NS_RDF_NO_VALUE = NS_ERROR_RDF_BASE + 2;
|
|
const NS_RDF_ASSERTION_ACCEPTED = Components.results.NS_OK;
|
|
const NS_RDF_ASSERTION_REJECTED = NS_ERROR_RDF_BASE + 3;
|
|
|
|
// Scope constants
|
|
//
|
|
const SCOPE_BASE = Components.interfaces.nsILDAPURL.SCOPE_BASE;
|
|
const SCOPE_ONELEVEL = Components.interfaces.nsILDAPURL.SCOPE_ONELEVEL;
|
|
const SCOPE_SUBTREE = Components.interfaces.nsILDAPURL.SCOPE_SUBTREE;
|
|
|
|
// Types of delegates
|
|
const MESSAGE = 1;
|
|
const FLAT_LIST = 2;
|
|
const RECURSIVE_LIST = 3;
|
|
|
|
// ArrayEnumerator courtesy of Brendan Eich <brendan@mozilla.org>
|
|
//
|
|
function ArrayEnumerator(array) {
|
|
this.array = array;
|
|
this.index = 0;
|
|
}
|
|
ArrayEnumerator.prototype = {
|
|
hasMoreElements: function() { return this.index < this.array.length; },
|
|
getNext: function () { return (this.index < this.array.length) ?
|
|
this.array[this.index++] : null; }
|
|
}
|
|
|
|
// nsISupportsArrayEnumerator
|
|
//
|
|
function nsISupportsArrayEnumerator(array) {
|
|
this.array = array;
|
|
this.index = 0;
|
|
}
|
|
nsISupportsArrayEnumerator.prototype = {
|
|
hasMoreElements: function() { return this.index < this.array.Count(); },
|
|
getNext: function () { return (this.index < this.array.Count()) ?
|
|
this.array.GetElementAt(this.index++) : null; }
|
|
}
|
|
|
|
/**
|
|
* getProxyOnUIThread returns a proxy to aObject on the main (UI) thread.
|
|
* We need this because the RDF service should only be used on the main
|
|
* thread. Moreover, the RDF classes aren't (marked as?) thread-safe, so
|
|
* any objects we create using the RDF service should only be used on the
|
|
* main thread.
|
|
*/
|
|
function getProxyOnUIThread(aObject, aInterface) {
|
|
var eventQSvc = Components.
|
|
classes["@mozilla.org/event-queue-service;1"].
|
|
getService(Components.interfaces.nsIEventQueueService);
|
|
var uiQueue = eventQSvc.
|
|
getSpecialEventQueue(Components.interfaces.
|
|
nsIEventQueueService.UI_THREAD_EVENT_QUEUE);
|
|
var proxyMgr = Components.
|
|
classes["@mozilla.org/xpcomproxy;1"].
|
|
getService(Components.interfaces.nsIProxyObjectManager);
|
|
|
|
return proxyMgr.getProxyForObject(uiQueue,
|
|
aInterface, aObject, 5);
|
|
// 5 == PROXY_ALWAYS | PROXY_SYNC
|
|
}
|
|
|
|
|
|
// the datasource object itself
|
|
//
|
|
const NS_LDAPDATASOURCE_CONTRACTID =
|
|
'@mozilla.org/rdf/datasource;1?name=ldap';
|
|
const NS_LDAPDATASOURCE_CID =
|
|
Components.ID('{8da18684-6486-4a7e-b261-35331f3e7163}');
|
|
|
|
function nsLDAPDataSource() {}
|
|
|
|
nsLDAPDataSource.prototype = {
|
|
|
|
// who is watching us; XXX ok to use new Array?
|
|
mObserverList: new Array(),
|
|
|
|
// RDF property constants.
|
|
//
|
|
// XXXdmose - can these can actually be statics (ie JS class
|
|
// properties rather than JS instance properties)? or would that
|
|
// make it hard for the datasource and/or component to be GCed?
|
|
//
|
|
kRDF_instanceOf: {},
|
|
kNC_DN: {},
|
|
kNC_child: {},
|
|
kNC_recursiveChild: {},
|
|
|
|
mRdfSvc: {},
|
|
|
|
// since we implement multiple interfaces, we have to provide QI
|
|
//
|
|
QueryInterface: function(iid) {
|
|
if (iid.equals(Components.interfaces.nsISupports) ||
|
|
iid.equals(Components.interfaces.nsIRDFDataSource) ||
|
|
iid.equals(Components.interfaces.nsIRDFRemoteDataSource) ||
|
|
iid.equals(Components.interfaces.nsIRDFObserver))
|
|
return this;
|
|
|
|
Components.returnCode = Components.results.NS_ERROR_NO_INTERFACE;
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* nsIRDFRemoteDataSource
|
|
*/
|
|
|
|
/**
|
|
* This value is <code>true</code> when the datasource has
|
|
* fully loaded itself.
|
|
*/
|
|
get loaded() {
|
|
debug("getter for loaded called\n");
|
|
// We're never fully loaded
|
|
return false;
|
|
},
|
|
|
|
/**
|
|
* Specify the URI for the data source: this is the prefix
|
|
* that will be used to register the data source in the
|
|
* data source registry.
|
|
* @param aURI the URI to load
|
|
*/
|
|
Init: function(aURI)
|
|
{
|
|
if (DEBUG) {
|
|
dump("Init() called with args: \n\t" + aURI + "\n\n");
|
|
}
|
|
|
|
// XXX - if this a "single-connection" datasource
|
|
// (ie non-anonymous to a specific server); we should figure
|
|
// that out here by noticing that there is a ; after "rdf:ldap", and
|
|
// that after that there is a cookie which happens to be an LDAP URL
|
|
// designating the connection. for now, we just assume that this will
|
|
// be a "universal" (anonymous to any & all servers) datasource.
|
|
//
|
|
// XXX rayw changed the delimiter char; it's not a ; any more.
|
|
// I think it might be ? now. He or waterson would know. The code
|
|
// that knows about this is somewhere in rdf, perhaps in the XUL
|
|
// template builder.
|
|
|
|
// get the RDF service
|
|
//
|
|
this.mRdfSvc = Components.
|
|
classes["@mozilla.org/rdf/rdf-service;1"].
|
|
getService(Components.interfaces.nsIRDFService);
|
|
|
|
// get some RDF Resources that we'll need
|
|
//
|
|
this.kRDF_instanceOf = this.mRdfSvc.GetResource(RDF_NAMESPACE_URI +
|
|
"instanceOf");
|
|
this.kNC_DN = this.mRdfSvc.GetResource(NC_NAMESPACE_URI + "DN");
|
|
this.kNC_child = this.mRdfSvc.GetResource(NC_NAMESPACE_URI + "child");
|
|
this.kNC_recursiveChild = this.mRdfSvc.GetResource(NC_NAMESPACE_URI +
|
|
"recursiveChild");
|
|
|
|
return;
|
|
},
|
|
|
|
/**
|
|
* Refresh the remote datasource, re-loading its contents
|
|
* from the URI.
|
|
*
|
|
* @param aBlocking If <code>true</code>, the call will block
|
|
* until the datasource has completely reloaded.
|
|
*/
|
|
Refresh: function(aBlocking)
|
|
{
|
|
if (DEBUG) {
|
|
dump("Refresh() called with args: \n\t" + aBlocking + "\n\n");
|
|
}
|
|
return;
|
|
},
|
|
|
|
/**
|
|
* Request that a data source write it's contents out to
|
|
* permanent storage, if applicable.
|
|
*/
|
|
Flush: function()
|
|
{
|
|
if (DEBUG) {
|
|
dump("Flush() called\n\n");
|
|
}
|
|
return;
|
|
},
|
|
|
|
/**
|
|
* nsIRDFDataSource
|
|
*/
|
|
|
|
/** Find an RDF resource that points to a given node over the
|
|
* specified arc & truth value
|
|
*
|
|
* @return NS_RDF_NO_VALUE if there is no source that leads
|
|
* to the target with the specified property.
|
|
*
|
|
* nsIRDFResource GetSource (in nsIRDFResource aProperty,
|
|
* in nsIRDFNode aTarget,
|
|
* in boolean aTruthValue);
|
|
*/
|
|
GetSource: function(aProperty, aTarget, aTruthValue) {
|
|
if (DEBUG) {
|
|
dump("GetSource() called with args: \n\t" + aProperty.Value +
|
|
"\n\t" + aTarget.Value + "\n\t" + aTruthValue + "\n\n");
|
|
}
|
|
|
|
Components.returnCode = NS_RDF_NO_VALUE;
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* Find all RDF resources that point to a given node over the
|
|
* specified arc & truth value
|
|
*
|
|
* @return NS_OK unless a catastrophic error occurs. If the
|
|
* method returns NS_OK, you may assume that nsISimpleEnumerator points
|
|
* to a valid (but possibly empty) cursor.
|
|
*
|
|
* nsISimpleEnumerator GetSources (in nsIRDFResource aProperty,
|
|
* in nsIRDFNode aTarget,
|
|
* in boolean aTruthValue);
|
|
*/
|
|
GetSources: function(aProperty, aTarget, aTruthValue) {
|
|
if (DEBUG) {
|
|
dump("GetSources() called with args: \n\t" + aProperty.Value +
|
|
"\n\t" + aTarget.Value + "\n\t" + aTruthValue + "\n\n");
|
|
}
|
|
|
|
return new ArrayEnumerator(new Array());
|
|
},
|
|
|
|
/**
|
|
* Find a child of that is related to the source by the given arc
|
|
* and truth value
|
|
*
|
|
* @return NS_RDF_NO_VALUE if there is no target accessable from the
|
|
* source via the specified property.
|
|
*
|
|
* nsIRDFNode GetTarget (in nsIRDFResource aSource,
|
|
* in nsIRDFResource aProperty,
|
|
* in boolean aTruthValue);
|
|
*/
|
|
GetTarget: function(aSource, aProperty, aTruthValue) {
|
|
if (DEBUG) {
|
|
dump("GetTarget() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aProperty.Value + "\n\t" + aTruthValue + "\n\n");
|
|
}
|
|
|
|
// We don't handle negative assertions.
|
|
// XXX Should we? Can we?
|
|
if (!aTruthValue) {
|
|
Components.returnCode = NS_RDF_NO_VALUE;
|
|
return null;
|
|
}
|
|
|
|
var delegate;
|
|
var enumerator;
|
|
|
|
if (aProperty.EqualsNode(this.kNC_child)
|
|
|| aProperty.EqualsNode(this.kNC_recursiveChild)) {
|
|
// Find a child or recursiveChild. Get the messagelist delegate
|
|
// (flat for child, recursive for recursiveChild) for aSource and
|
|
// return the first element of the list, if available.
|
|
var listType = (aProperty.EqualsNode(this.kNC_child) ?
|
|
"flat.messagelist.ldap" :
|
|
"recursive.messagelist.ldap");
|
|
try {
|
|
delegate = aSource.GetDelegate(listType,
|
|
Components.interfaces.nsISupportsArray);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
try {
|
|
var target = delegate.QueryElementAt(0,
|
|
Components.interfaces.nsIRDFNode);
|
|
return target;
|
|
}
|
|
catch (e) {
|
|
}
|
|
}
|
|
}
|
|
else if (aProperty.EqualsNode(this.kNC_DN)) {
|
|
// Find the DN arc. Get the message delegate for aSource
|
|
// and return the resource for the dn property of the message,
|
|
// if available.
|
|
try {
|
|
delegate = aSource.GetDelegate("message.ldap",
|
|
Components.interfaces.nsILDAPMessage);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
return this.mRdfSvc.GetResource(delegate.dn);
|
|
}
|
|
}
|
|
else {
|
|
// Find a different arc. See if we're looking for an LDAP attribute
|
|
// arc. If so, get the message delegate for aSource, if we find one
|
|
// get the attribute array for the specified LDAP attribute and
|
|
// return the first value if it isn't empty.
|
|
var refStart = aProperty.Value.indexOf("#");
|
|
if (aProperty.Value.slice(0, refStart + 1) ==
|
|
LDAPATTR_NAMESPACE_URI) {
|
|
|
|
try {
|
|
delegate = aSource.GetDelegate("message.ldap",
|
|
Components.interfaces.nsILDAPMessage);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
var attributeName = aProperty.Value.slice(refStart + 1);
|
|
enumerator = new ArrayEnumerator(this.getAttributeArray(
|
|
delegate, attributeName));
|
|
if (enumerator.hasMoreElements()) {
|
|
return enumerator.getNext();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Found nothing.
|
|
Components.returnCode = NS_RDF_NO_VALUE;
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* Find all children of that are related to the source by the given arc
|
|
* arc and truth value.
|
|
*
|
|
* @return NS_OK unless a catastrophic error occurs. If the
|
|
* method returns NS_OK, you may assume that nsISimpleEnumerator points
|
|
* to a valid (but possibly empty) cursor.
|
|
*
|
|
* nsISimpleEnumerator GetTargets (in nsIRDFResource aSource,
|
|
* in nsIRDFResource aProperty,
|
|
* in boolean aTruthValue);
|
|
*/
|
|
GetTargets: function(aSource, aProperty, aTruthValue) {
|
|
if (DEBUG) {
|
|
dump("GetTargets() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aProperty.Value + "\n\t" + aTruthValue + "\n\n");
|
|
}
|
|
|
|
// We don't handle negative assertions.
|
|
// XXX Should we? Can we?
|
|
if (!aTruthValue) {
|
|
return new ArrayEnumerator(new Array());
|
|
}
|
|
|
|
var delegate;
|
|
|
|
if (aProperty.EqualsNode(this.kNC_child)
|
|
|| aProperty.EqualsNode(this.kNC_recursiveChild)) {
|
|
// Find children or recursiveChildren. Get the messagelist delegate
|
|
// (flat for child, recursive for recursiveChild) for aSource and
|
|
// return an enumerator for the list, if available.
|
|
var listType = (aProperty.EqualsNode(this.kNC_child) ?
|
|
"flat.messagelist.ldap" :
|
|
"recursive.messagelist.ldap");
|
|
try {
|
|
delegate = aSource.GetDelegate(listType,
|
|
Components.interfaces.nsISupportsArray);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
return new nsISupportsArrayEnumerator(delegate);
|
|
}
|
|
}
|
|
else if (aProperty.EqualsNode(this.kNC_DN)) {
|
|
// Find the DN arc. Get the message delegate for aSource
|
|
// and return the resource for the dn property of the message,
|
|
// if available.
|
|
try {
|
|
delegate = aSource.GetDelegate("message.ldap",
|
|
Components.interfaces.nsILDAPMessage);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
return this.mRdfSvc.GetResource(delegate.dn);
|
|
}
|
|
}
|
|
else {
|
|
// Find a different arc. See if we're looking for an LDAP attribute
|
|
// arc. If so, get the message delegate for aSource, if we find one
|
|
// get the attribute array for the specified LDAP attribute and
|
|
// an enumerator for the array.
|
|
var refStart = aProperty.Value.indexOf("#");
|
|
if (aProperty.Value.slice(0, refStart + 1) ==
|
|
LDAPATTR_NAMESPACE_URI) {
|
|
try {
|
|
delegate = aSource.GetDelegate("message.ldap",
|
|
Components.interfaces.nsILDAPMessage);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
var attributeName = aProperty.Value.slice(refStart + 1);
|
|
return new ArrayEnumerator(
|
|
this.getAttributeArray(delegate, attributeName));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Found nothing, return enumerator for empty array.
|
|
return new ArrayEnumerator(new Array());
|
|
},
|
|
|
|
/**
|
|
* Add an assertion to the graph.
|
|
*
|
|
* void Assert (in nsIRDFResource aSource,
|
|
* in nsIRDFResource aProperty,
|
|
* in nsIRDFNode aTarget,
|
|
* in boolean aTruthValue);
|
|
*/
|
|
Assert: function(aSource, aProperty, aTarget, aTruthValue) {
|
|
if (DEBUG) {
|
|
dump("Assert() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aProperty.Value + "\n\t" + aTarget.Value +
|
|
"\n\t" + aTruthValue + "\n\n");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Remove an assertion from the graph.
|
|
*
|
|
* void Unassert (in nsIRDFResource aSource,
|
|
* in nsIRDFResource aProperty,
|
|
* in nsIRDFNode aTarget);
|
|
*/
|
|
Unassert: function(aSource, aProperty, aTarget) {
|
|
if (DEBUG) {
|
|
dump("Unassert() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aProperty.Value + "\n\t" + aTarget.Value + "\n\n");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Change an assertion from
|
|
*
|
|
* [aSource]--[aProperty]-->[aOldTarget]
|
|
*
|
|
* to
|
|
*
|
|
* [aSource]--[aProperty]-->[aNewTarget]
|
|
*
|
|
* void Change (in nsIRDFResource aSource,
|
|
* in nsIRDFResource aProperty,
|
|
* in nsIRDFNode aOldTarget,
|
|
* in nsIRDFNode aNewTarget);
|
|
*/
|
|
Change: function(aSource, aProperty, aOldTarget, aNewTarget) {
|
|
if (DEBUG) {
|
|
dump("Change() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aProperty.Value + "\n\t" + aOldTarget.Value +
|
|
"\n\t" + aNewTarget.Value + "\n\n");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* 'Move' an assertion from
|
|
*
|
|
* [aOldSource]--[aProperty]-->[aTarget]
|
|
*
|
|
* to
|
|
*
|
|
* [aNewSource]--[aProperty]-->[aTarget]
|
|
*
|
|
* void Move (in nsIRDFResource aOldSource,
|
|
* in nsIRDFResource aNewSource,
|
|
* in nsIRDFResource aProperty,
|
|
* in nsIRDFNode aTarget);
|
|
*/
|
|
Move: function(aOldSource, aNewSource, aProperty, aTarget) {
|
|
if (DEBUG) {
|
|
dump("Move() called with args: \n\t" + aOldSource.Value +
|
|
"\n\t" + aNewSource.Value + "\n\t" + aProperty.Value +
|
|
"\n\t" + aTarget.Value + "\n\n");
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Query whether an assertion exists in this graph.
|
|
*
|
|
* boolean HasAssertion(in nsIRDFResource aSource,
|
|
* in nsIRDFResource aProperty,
|
|
* in nsIRDFNode aTarget,
|
|
* in boolean aTruthValue);
|
|
*/
|
|
HasAssertion: function(aSource, aProperty, aTarget, aTruthValue) {
|
|
// The datasource doesn't currently use any sort of standard
|
|
// RDF containers.
|
|
if (aProperty.EqualsNode(this.kRDF_instanceOf)) {
|
|
return false;
|
|
}
|
|
|
|
if (DEBUG) {
|
|
dump("HasAssertion() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aProperty.Value + "\n\t" + aTarget.Value + "\n\t" +
|
|
aTruthValue + "\n\n");
|
|
}
|
|
|
|
// We don't handle negative assertions.
|
|
// XXX Should we? Can we?
|
|
if (!aTruthValue) {
|
|
return false;
|
|
}
|
|
|
|
var delegate;
|
|
|
|
if (aProperty.EqualsNode(this.kNC_child)
|
|
|| aProperty.EqualsNode(this.kNC_recursiveChild)) {
|
|
// Find out if aTarget is in the children or recursiveChildren of
|
|
// aSource. Get the messagelist delegate (flat for child, recursive
|
|
// for recursiveChild) for aSource.
|
|
var listType = (aProperty.EqualsNode(this.kNC_child) ?
|
|
"flat.messagelist.ldap" :
|
|
"recursive.messagelist.ldap");
|
|
try {
|
|
delegate = aSource.GetDelegate(listType,
|
|
Components.interfaces.nsISupportsArray);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
// We have a delegate message list, loop through it and return
|
|
// true if the target is in the list.
|
|
var enumerator = delegate.Enumerate();
|
|
var done = false;
|
|
try {
|
|
enumerator.isDone();
|
|
}
|
|
catch (e) {
|
|
done = true;
|
|
}
|
|
while(!done) {
|
|
var resource = enumerator.currentItem().QueryInterface(
|
|
Components.interfaces.nsIRDFResource);
|
|
if (resource.Value == aTarget.Value) {
|
|
return true;
|
|
}
|
|
try {
|
|
enumerator.next();
|
|
}
|
|
catch (e) {
|
|
done = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (aProperty.EqualsNode(this.kNC_DN)) {
|
|
// Find the DN arc. Get the message delegate for aSource
|
|
// and return the resource for the dn property of the message,
|
|
// if available.
|
|
try {
|
|
delegate = aSource.GetDelegate("message.ldap",
|
|
Components.interfaces.nsILDAPMessage);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
return (delegate.dn == aTarget.Value);
|
|
}
|
|
}
|
|
else {
|
|
// Find a different arc. See if we're looking for an LDAP attribute
|
|
// arc. If so, get the message delegate for aSource, if we find one
|
|
// get the attribute array for the specified LDAP attribute and
|
|
// an enumerator for the array.
|
|
var refStart = aProperty.Value.indexOf("#");
|
|
if (aProperty.Value.slice(0, refStart + 1) ==
|
|
LDAPATTR_NAMESPACE_URI) {
|
|
try {
|
|
delegate = aSource.GetDelegate("message.ldap",
|
|
Components.interfaces.nsILDAPMessage);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
var attributeName = aProperty.Value.slice(refStart + 1);
|
|
var attributeArray = this.getAttributeArray(delegate,
|
|
attributeName);
|
|
var attributes = new ArrayEnumerator(attributeArray);
|
|
while (attributes.hasMoreElements()) {
|
|
var attribute = attributes.getNext();
|
|
if (attribute.Value == aTarget.Value) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we haven't returned true yet, there's nothing here
|
|
//
|
|
return false;
|
|
},
|
|
|
|
/**
|
|
* Add an observer to this data source. If the datasource
|
|
* supports observers, the datasource source should hold a strong
|
|
* reference to the observer.
|
|
*
|
|
* void AddObserver(in nsIRDFObserver aObserver);
|
|
*/
|
|
AddObserver: function(aObserver) {
|
|
if (DEBUG) {
|
|
dump("AddObserver() called\n\n");
|
|
}
|
|
|
|
// We need to proxy our observers on the main (UI) thread, because
|
|
// the RDF code wants to run on the main thread.
|
|
this.mObserverList.push(getProxyOnUIThread(aObserver,
|
|
Components.interfaces.nsIRDFObserver));
|
|
},
|
|
|
|
/**
|
|
* Remove an observer from this data source.
|
|
*
|
|
* void RemoveObserver (in nsIRDFObserver aObserver);
|
|
*/
|
|
RemoveObserver: function(aObserver) {
|
|
if (DEBUG) {
|
|
dump("RemoveObserver() called" + "\n\n");
|
|
}
|
|
|
|
var iter = new ArrayEnumerator(this.mObserverList);
|
|
var nextObserver;
|
|
while ((nextObserver = iter.getNext())) {
|
|
if (nextObserver == aObserver) {
|
|
splice(iter.index, 1);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Get a cursor to iterate over all the arcs that point into a node.
|
|
*
|
|
* @return NS_OK unless a catastrophic error occurs. If the method
|
|
* returns NS_OK, you may assume that labels points to a valid (but
|
|
* possible empty) nsISimpleEnumerator object.
|
|
*
|
|
* nsISimpleEnumerator ArcLabelsIn (in nsIRDFNode aNode);
|
|
*/
|
|
ArcLabelsIn: function(aNode) {
|
|
if (DEBUG) {
|
|
dump("ArcLabelsIn() called with args: \n\t" + aNode.Value +
|
|
"\n\n");
|
|
}
|
|
|
|
return new ArrayEnumerator(new Array());
|
|
},
|
|
|
|
/**
|
|
* Get a cursor to iterate over all the arcs that originate in
|
|
* a resource.
|
|
*
|
|
* @return NS_OK unless a catastrophic error occurs. If the method
|
|
* returns NS_OK, you may assume that labels points to a valid (but
|
|
* possible empty) nsISimpleEnumerator object.
|
|
*
|
|
* nsISimpleEnumerator ArcLabelsOut(in nsIRDFResource aSource);
|
|
*/
|
|
ArcLabelsOut: function(aSource)
|
|
{
|
|
if (DEBUG) {
|
|
dump("ArcLabelsOut() called with args: \n\t" + aSource.Value +
|
|
"\n\n");
|
|
}
|
|
|
|
return new ArrayEnumerator(new Array());
|
|
},
|
|
|
|
/**
|
|
* Returns true if the specified node is pointed to by the specified arc.
|
|
* Equivalent to enumerating ArcLabelsIn and comparing for the specified
|
|
* arc.
|
|
*
|
|
* boolean hasArcIn (in nsIRDFNode aNode,
|
|
* in nsIRDFResource aArc);
|
|
*/
|
|
hasArcIn: function(aNode, aArc)
|
|
{
|
|
if (DEBUG) {
|
|
dump("hasArcIn() called with args: \n\t" + aNode.Value +
|
|
"\n\t" + aArc.Value + "\n\n");
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
/**
|
|
* Returns true if the specified node has the specified outward arc.
|
|
* Equivalent to enumerating ArcLabelsOut and comparing for the specified
|
|
* arc.
|
|
*
|
|
* boolean hasArcOut (in nsIRDFResource aSource,
|
|
* in nsIRDFResource aArc);
|
|
*/
|
|
hasArcOut: function(aSource, aArc)
|
|
{
|
|
if (DEBUG) {
|
|
dump("hasArcOut() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aArc.Value + "\n\n");
|
|
}
|
|
|
|
var delegate;
|
|
|
|
if (aArc.EqualsNode(this.kNC_child)
|
|
|| aArc.EqualsNode(this.kNC_recursiveChild)) {
|
|
// Find children or recursiveChildren. Get the messagelist delegate
|
|
// (flat for child, recursive for recursiveChild) for aSource and
|
|
// return true if we have one.
|
|
var listType = (aArc.EqualsNode(this.kNC_child) ?
|
|
"flat.messagelist.ldap" :
|
|
"recursive.messagelist.ldap");
|
|
try {
|
|
delegate = aSource.GetDelegate(listType,
|
|
Components.interfaces.nsISupportsArray);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
return true;
|
|
}
|
|
}
|
|
else if (aArc.EqualsNode(this.kNC_DN)) {
|
|
// Find the DN arc. Get the message delegate for aSource
|
|
// and return true if we have a delegate and its dn
|
|
// attribute is non-null.
|
|
try {
|
|
delegate = aSource.GetDelegate("message.ldap",
|
|
Components.interfaces.nsILDAPMessage);
|
|
}
|
|
catch (e) {
|
|
}
|
|
return (delegate != null);
|
|
}
|
|
|
|
// Find a different arc. See if we're looking for an LDAP attribute
|
|
// arc. If so, get the message delegate for aSource, if we find one
|
|
// get the attribute array for the specified LDAP attribute and
|
|
// return true if it contains at least one value.
|
|
var refStart = aArc.Value.indexOf("#");
|
|
if (aArc.Value.slice(0, refStart + 1) == LDAPATTR_NAMESPACE_URI) {
|
|
try {
|
|
delegate = aSource.GetDelegate("message.ldap",
|
|
Components.interfaces.nsILDAPMessage);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (delegate != null) {
|
|
var attributeName = aArc.Value.slice(refStart + 1);
|
|
var attributeArray = this.getAttributeArray(delegate,
|
|
attributeName);
|
|
if (attributeArray.length > 0) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
|
|
/**
|
|
* Private functions
|
|
*/
|
|
|
|
onAssert: function(aDataSource, aSource, aProperty, aTarget)
|
|
{
|
|
if (DEBUG) {
|
|
dump("OnAssert() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aProperty.Value + "\n\t" + aTarget.Value + "\n\n");
|
|
}
|
|
|
|
var iter = new ArrayEnumerator(this.mObserverList);
|
|
var nextObserver;
|
|
while ((nextObserver = iter.getNext()) != null) {
|
|
nextObserver.onAssert(this, aSource, aProperty, aTarget);
|
|
}
|
|
},
|
|
|
|
onUnassert: function(aDataSource, aSource, aProperty, aTarget)
|
|
{
|
|
if (DEBUG) {
|
|
dump("onUnassert() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aProperty.Value + "\n\t" + aTarget.Value + "\n\n");
|
|
}
|
|
|
|
var iter = new ArrayEnumerator(this.mObserverList);
|
|
var nextObserver;
|
|
while ((nextObserver = iter.getNext()) != null) {
|
|
nextObserver.onUnassert(this, aSource, aProperty, aTarget);
|
|
}
|
|
},
|
|
|
|
onChange: function(aDataSource, aSource, aProperty, aOldTarget, aNewTarget)
|
|
{
|
|
if (DEBUG) {
|
|
dump("onChange() called with args: \n\t" + aSource.Value +
|
|
"\n\t" + aProperty.Value + "\n\t" + aOldTarget.Value +
|
|
"\n\t" + aNewTarget.Value + "\n\n");
|
|
}
|
|
|
|
var iter = new ArrayEnumerator(this.mObserverList);
|
|
var nextObserver;
|
|
while ((nextObserver = iter.getNext()) != null) {
|
|
nextObserver.onChange(this, aSource, aProperty, aOldTarget, aNewTarget);
|
|
}
|
|
},
|
|
|
|
onBeginUpdateBatch: function()
|
|
{
|
|
if (DEBUG) {
|
|
dump("onBeginUpdateBatch() called\n\n");
|
|
}
|
|
|
|
var iter = new ArrayEnumerator(this.mObserverList);
|
|
var nextObserver;
|
|
while ((nextObserver = iter.getNext()) != null) {
|
|
nextObserver.onBeginUpdateBatch(this);
|
|
}
|
|
},
|
|
|
|
onEndUpdateBatch: function()
|
|
{
|
|
if (DEBUG) {
|
|
dump("onEndUpdateBatch() called\n\n");
|
|
}
|
|
|
|
var iter = new ArrayEnumerator(this.mObserverList);
|
|
var nextObserver;
|
|
while ((nextObserver = iter.getNext()) != null) {
|
|
nextObserver.onEndUpdateBatch(this);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Fills an array with the RDF nodes for the values of an attribute
|
|
* out of a nsLDAPMessage.
|
|
*/
|
|
getAttributeArray: function(aMessage, aAttributeName) {
|
|
var resultArray = new Array();
|
|
var valuesCount = {};
|
|
try {
|
|
var values = aMessage.getValues(aAttributeName, valuesCount);
|
|
for (var j = 0; j < valuesCount.value; j++) {
|
|
var attributeValue = this.mRdfSvc.GetLiteral(values[j]);
|
|
resultArray.push(attributeValue);
|
|
}
|
|
}
|
|
catch (e) {
|
|
// Error or the attribute was not there.
|
|
// XXX Do we need to do something about the real errors?
|
|
// XXX Just returning empty array for now.
|
|
}
|
|
return resultArray;
|
|
}
|
|
}
|
|
|
|
// the nsILDAPMessage associated with a given resource
|
|
//
|
|
const NS_LDAPMESSAGERDFDELEGATEFACTORY_CONTRACTID =
|
|
'@mozilla.org/rdf/delegate-factory;1?key='+"message.ldap"+'&scheme=ldap'
|
|
const NS_LDAPFLATMESSAGELISTRDFDELEGATEFACTORY_CONTRACTID =
|
|
'@mozilla.org/rdf/delegate-factory;1?key=flat.messagelist.ldap&scheme=ldap'
|
|
const NS_LDAPRECURSIVEMESSAGELISTRDFDELEGATEFACTORY_CONTRACTID =
|
|
'@mozilla.org/rdf/delegate-factory;1?key=recursive.messagelist.ldap&scheme=ldap'
|
|
const NS_LDAPMESSAGERDFDELEGATEFACTORY_CID =
|
|
Components.ID('{4b6fb566-1dd2-11b2-a1a9-889a3f852b0b}');
|
|
|
|
function nsLDAPMessageRDFDelegateFactory() {}
|
|
|
|
nsLDAPMessageRDFDelegateFactory.prototype =
|
|
{
|
|
mRdfSvc: {},
|
|
mLDAPSvc: {},
|
|
mLDAPDataSource: {},
|
|
kNC_child: {},
|
|
kNC_recursiveChild: {},
|
|
|
|
mConnection: {}, // connection to the LDAP server
|
|
mOperation: {}, // current LDAP operation
|
|
mMessagesHash: {}, // hash with the currently known messages
|
|
// (hashed on URI)
|
|
mMessagesListHash: {},
|
|
mInProgressHash: {},
|
|
kInited: -1,
|
|
|
|
Init: function() {
|
|
if (this.kInited == -1) {
|
|
this.kInited = 0;
|
|
|
|
// get the RDF service
|
|
//
|
|
this.mRdfSvc = Components.
|
|
classes["@mozilla.org/rdf/rdf-service;1"].
|
|
getService(Components.interfaces.nsIRDFService);
|
|
this.mLDAPSvc = Components.
|
|
classes["@mozilla.org/network/ldap-service;1"].
|
|
getService(Components.interfaces.nsILDAPService);
|
|
this.mLDAPDataSource = this.mRdfSvc.GetDataSource("rdf:ldap").
|
|
QueryInterface(Components.interfaces.nsIRDFObserver);
|
|
|
|
// get some RDF Resources that we'll need
|
|
//
|
|
this.kNC_child = this.mRdfSvc.GetResource(NC_NAMESPACE_URI +
|
|
"child");
|
|
this.kNC_recursiveChild = this.mRdfSvc.GetResource(NC_NAMESPACE_URI +
|
|
"recursiveChild");
|
|
}
|
|
},
|
|
|
|
QueryInterface: function(iid) {
|
|
if (DEBUG) {
|
|
dump("QueryInterface called\n\n");
|
|
}
|
|
if (iid.equals(Components.interfaces.nsISupports) ||
|
|
iid.equals(Components.interfaces.nsIRDFDelegateFactory))
|
|
return this;
|
|
|
|
Components.returnCode = Components.results.NS_ERROR_NO_INTERFACE;
|
|
return null;
|
|
},
|
|
|
|
// from nsIRDFDelegateFactory:
|
|
//
|
|
// Create a delegate for the specified RDF resource.
|
|
//
|
|
// The created delegate should forward AddRef() and Release()
|
|
// calls to the aOuter object.
|
|
//
|
|
// void CreateDelegate(in nsIRDFResource aOuter,
|
|
// in string aKey,
|
|
// in nsIIDRef aIID,
|
|
// [retval, iid_is(aIID)] out nsQIResult aResult);
|
|
CreateDelegate: function (aOuter, aKey, aIID) {
|
|
|
|
function generateGetTargetsBoundCallback() {
|
|
function getTargetsBoundCallback() {
|
|
}
|
|
|
|
getTargetsBoundCallback.prototype.QueryInterface =
|
|
function(iid) {
|
|
if (iid.equals(Components.interfaces.nsISupports) ||
|
|
iid.equals(Components.interfaces.nsILDAPMessageListener))
|
|
return this;
|
|
|
|
Components.returnCode = Components.results.NS_ERROR_NO_INTERFACE;
|
|
return null;
|
|
}
|
|
|
|
getTargetsBoundCallback.prototype.onLDAPMessage =
|
|
function(aMessage) {
|
|
if (DEBUG) {
|
|
dump("getTargetsBoundCallback.onLDAPMessage()" +
|
|
"called with scope: \n\t" +
|
|
aOuter.Value + "\n\n");
|
|
}
|
|
|
|
// XXX how do we deal with this in release builds?
|
|
// XXX deal with already bound case
|
|
//
|
|
if (aMessage.type != aMessage.RES_BIND) {
|
|
dump("bind failed\n");
|
|
delete callerObject.mInProgressHash[queryURL.spec];
|
|
return;
|
|
}
|
|
|
|
// kick off a search
|
|
//
|
|
var searchOp = Components.classes[
|
|
"@mozilla.org/network/ldap-operation;1"].
|
|
createInstance(Components.interfaces.
|
|
nsILDAPOperation);
|
|
|
|
// XXX err handling
|
|
searchOp.init(connection,
|
|
generateGetTargetsSearchCallback());
|
|
// XXX err handling (also for url. accessors)
|
|
// XXX constipate this
|
|
// XXX real timeout
|
|
searchOp.searchExt(queryURL.dn, queryURL.scope,
|
|
queryURL.filter, 0, new Array(),
|
|
0, -1);
|
|
}
|
|
|
|
getTargetsBoundCallback.prototype.onLDAPInit =
|
|
function(aConn, aStatus) {
|
|
if (DEBUG) {
|
|
dump("getTargetsBoundCallback.onLDAPInit()" +
|
|
" called with status of " + aStatus + "\n\n");
|
|
}
|
|
|
|
// get and initialize an operation object
|
|
//
|
|
var operation = Components.classes
|
|
["@mozilla.org/network/ldap-operation;1"].
|
|
createInstance(Components.interfaces.nsILDAPOperation);
|
|
operation.init(connection,
|
|
getProxyOnUIThread(this, Components.interfaces.
|
|
nsILDAPMessageListener));
|
|
|
|
caller.mInProgressHash[aOuter.Value] = 1;
|
|
|
|
// bind to the server. we'll get a callback when this
|
|
// finishes. XXX handle a password
|
|
//
|
|
operation.simpleBind(null);
|
|
}
|
|
|
|
return getProxyOnUIThread(new getTargetsBoundCallback(),
|
|
Components.interfaces.nsILDAPMessageListener);
|
|
}
|
|
|
|
function generateGetTargetsSearchCallback() {
|
|
function getTargetsSearchCallback() {
|
|
}
|
|
|
|
getTargetsSearchCallback.prototype.QueryInterface = function(iid) {
|
|
if (iid.equals(Components.interfaces.nsISupports) ||
|
|
iid.equals(Components.interfaces.nsILDAPMessageListener))
|
|
return this;
|
|
|
|
Components.returnCode = Components.results.NS_ERROR_NO_INTERFACE;
|
|
return null;
|
|
};
|
|
|
|
getTargetsSearchCallback.prototype.onLDAPMessage =
|
|
function(aMessage) {
|
|
if (DEBUG) {
|
|
dump("getTargetsSearchCallback() called with message" +
|
|
" of type " + aMessage.type + "\n\n");
|
|
}
|
|
|
|
var listHash = caller.mMessagesListHash;
|
|
if (aMessage.type == aMessage.RES_SEARCH_ENTRY) {
|
|
if (DEBUG) {
|
|
dump("getTargetsSearchCallback() called with " +
|
|
"message " + aMessage.dn + " for " +
|
|
aOuter.Value + "\n\n");
|
|
}
|
|
|
|
// Create a resource for the message we just got.
|
|
// This is a single entry for which we'll cache the
|
|
// nsILDAPMessage. If we got this as a result of a
|
|
// "list" query we'll also add it to the result array.
|
|
var newURL = Components.classes["@mozilla.org/network/ldap-url;1"]
|
|
.createInstance(Components.interfaces.nsILDAPURL);
|
|
newURL.spec = queryURL.spec;
|
|
newURL.dn = aMessage.dn;
|
|
newURL.scope = SCOPE_BASE;
|
|
newURL.filter = "(objectClass=*)";
|
|
var newResource =
|
|
caller.mRdfSvc.GetResource(newURL.spec);
|
|
|
|
// Add the LDAP message for the new resource in our
|
|
// messages hashlist. We do this before adding it to
|
|
// a query result array (when applicable), so that
|
|
// when we onAssert this as a result for a query
|
|
// returning multiple results, it is already cached.
|
|
// If we wouldn't do this here, we'd start another
|
|
// query for this resource.
|
|
var messageHash = caller.mMessagesHash;
|
|
if (!messageHash.hasOwnProperty(newURL.spec)) {
|
|
messageHash[newURL.spec] = aMessage;
|
|
}
|
|
|
|
if (queryType == MESSAGE) {
|
|
// XXX - we need to onAssert this resource. However,
|
|
// we need to know somehow what the caller wanted
|
|
// to use this delegate for, so that we can limit
|
|
// the onAssert to what was asked for. This might be
|
|
// tricky, as we'd need to keep track of multiple
|
|
// "questions" coming in while the LDAP server
|
|
// hasn't responded yet.
|
|
}
|
|
else {
|
|
// Add the LDAP message to the result array for
|
|
// the query resource and onAssert the result
|
|
// as a child of the query resource.
|
|
var queryResource =
|
|
caller.mRdfSvc.GetResource(queryURL.spec);
|
|
if (!listHash.hasOwnProperty(queryURL.spec)) {
|
|
// No entry for the query resource in the
|
|
// results hashlist, let's create one.
|
|
listHash[queryURL.spec] = Components.classes
|
|
["@mozilla.org/supports-array;1"].
|
|
createInstance(
|
|
Components.interfaces.nsISupportsArray);
|
|
}
|
|
listHash[queryURL.spec].AppendElement(newResource);
|
|
if (queryType == FLAT_LIST) {
|
|
caller.mLDAPDataSource.onAssert(
|
|
caller.mLDAPDataSource, aOuter,
|
|
caller.kNC_child, newResource);
|
|
}
|
|
else if (queryType == RECURSIVE_LIST) {
|
|
caller.mLDAPDataSource.onAssert(
|
|
caller.mLDAPDataSource, queryResource,
|
|
caller.kNC_child, newResource);
|
|
caller.mLDAPDataSource.onAssert(
|
|
caller.mLDAPDataSource, aOuter,
|
|
caller.kNC_recursiveChild, newResource);
|
|
}
|
|
}
|
|
}
|
|
else if (aMessage.type == aMessage.RES_SEARCH_RESULT) {
|
|
// We got all the results for the query.
|
|
// If we were looking for a list, let's check if we
|
|
// have an entry for the query resource in the result's
|
|
// hashlist. If we don't, add an empty array to help
|
|
// performance, otherwise we'll keep requerying for this
|
|
// query resource.
|
|
if (queryType == FLAT_LIST || queryType == RECURSIVE_LIST) {
|
|
if (!listHash.hasOwnProperty(queryURL.spec)) {
|
|
// No entry for the query resource in the
|
|
// results hashlist, let's create an empty one.
|
|
listHash[queryURL.spec] = Components.classes
|
|
["@mozilla.org/supports-array;1"].
|
|
createInstance(
|
|
Components.interfaces.nsISupportsArray);
|
|
}
|
|
}
|
|
delete caller.mInProgressHash[queryURL.spec];
|
|
}
|
|
}
|
|
|
|
return getProxyOnUIThread(new getTargetsSearchCallback(),
|
|
Components.interfaces.nsILDAPMessageListener);
|
|
}
|
|
|
|
// end of closure decls; the CreateDelegate code proper begins below
|
|
|
|
// XXX - We need to keep track of queries that are in progress for a
|
|
// message too (cf. mInProgressHash for messagelist's).
|
|
//
|
|
if (DEBUG) {
|
|
dump("GetDelegate() called with args: \n\t" + aOuter.Value +
|
|
"\n\t" + aKey + "\n\t" + aIID + "\n\n");
|
|
}
|
|
|
|
var caller = this;
|
|
var queryURL;
|
|
var queryType;
|
|
|
|
if (aKey == "message.ldap") {
|
|
queryType = MESSAGE;
|
|
}
|
|
else if (aKey == "flat.messagelist.ldap") {
|
|
queryType = FLAT_LIST;
|
|
}
|
|
else if (aKey == "recursive.messagelist.ldap") {
|
|
queryType = RECURSIVE_LIST;
|
|
}
|
|
|
|
switch (queryType) {
|
|
case MESSAGE:
|
|
if (this.mMessagesHash.hasOwnProperty(aOuter.Value)) {
|
|
return (this.mMessagesHash[aOuter.Value].QueryInterface(aIID));
|
|
}
|
|
break;
|
|
case FLAT_LIST:
|
|
if (this.mMessagesListHash.hasOwnProperty(aOuter.Value)) {
|
|
return (this.mMessagesListHash[aOuter.Value].QueryInterface(aIID));
|
|
}
|
|
break;
|
|
case RECURSIVE_LIST:
|
|
queryURL = Components.classes["@mozilla.org/network/ldap-url;1"]
|
|
.createInstance(Components.interfaces.nsILDAPURL);
|
|
queryURL.spec = aOuter.Value;
|
|
if (queryURL.scope == SCOPE_BASE) {
|
|
// Retarget the URL, asking for recursive children on
|
|
// a base URL should descend, so we do a one-level search.
|
|
queryURL.scope = SCOPE_ONELEVEL;
|
|
}
|
|
if (this.mMessagesListHash.hasOwnProperty(queryURL.spec)) {
|
|
return (this.mMessagesListHash[queryURL.spec].QueryInterface(aIID));
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (queryURL == null) {
|
|
queryURL = Components.classes["@mozilla.org/network/ldap-url;1"]
|
|
.createInstance(Components.interfaces.nsILDAPURL);
|
|
queryURL.spec = aOuter.Value;
|
|
}
|
|
|
|
// make sure that this if this URL is for a messagelist, it
|
|
// represents something other than a base search
|
|
//
|
|
if ((queryType == FLAT_LIST) && (queryURL.scope == SCOPE_BASE)) {
|
|
if (DEBUG) {
|
|
dump("Early return, asking for a list of children for an " +
|
|
"URL with a BASE scope\n\n");
|
|
}
|
|
throw Components.results.NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (!this.mInProgressHash.hasOwnProperty(queryURL.spec)) {
|
|
this.Init();
|
|
|
|
// XXX - not sure what this should be
|
|
var key = queryURL.host + ":" + queryURL.port;
|
|
|
|
// Get the LDAP service and request a connection to the server from
|
|
// the service
|
|
var server;
|
|
try {
|
|
server = this.mLDAPSvc.getServer(key);
|
|
}
|
|
catch (e) {
|
|
}
|
|
if (!server) {
|
|
// Create a server object and let the service know about it
|
|
// XXX - not sure if I initialize enough here
|
|
server = Components.classes
|
|
["@mozilla.org/network/ldap-server;1"].
|
|
createInstance(Components.interfaces.nsILDAPServer);
|
|
server.key = key;
|
|
server.url = queryURL;
|
|
this.mLDAPSvc.addServer(server);
|
|
}
|
|
|
|
// Mark this URL as being in progress, to avoid requerying for the
|
|
// same URL
|
|
this.mInProgressHash[queryURL.spec] = 1;
|
|
|
|
// get a connection object
|
|
//
|
|
var connection = Components.classes
|
|
["@mozilla.org/network/ldap-connection;1"].
|
|
createInstance(Components.interfaces.nsILDAPConnection);
|
|
connection.init(queryURL.host, queryURL.port, null,
|
|
generateGetTargetsBoundCallback(), null,
|
|
Components.interfaces.nsILDAPConnection.VERSION3);
|
|
|
|
// XXXdmose - in this case, we almost certainly shouldn't be
|
|
// falling through to an error case, but instead returning
|
|
// something reasonable, since this is actually a success
|
|
// condition
|
|
//
|
|
debug("falling through!\n");
|
|
}
|
|
|
|
throw Components.results.NS_ERROR_FAILURE;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// the nsILDAPURL associated with a given resource
|
|
//
|
|
const NS_LDAPURLRDFDELEGATEFACTORY_CONTRACTID =
|
|
'@mozilla.org/rdf/delegate-factory/url.ldap;1';
|
|
const NS_LDAPURLRDFDELEGATEFACTORY_CID =
|
|
Components.ID('b6048700-1dd1-11b2-ae88-a5e18bb1f25e');
|
|
|
|
function nsLDAPURLRDFDelegateFactory() {}
|
|
|
|
nsLDAPURLRDFDelegateFactory.prototype =
|
|
{
|
|
// from nsIRDFDelegateFactory:
|
|
//
|
|
// Create a delegate for the specified RDF resource.
|
|
//
|
|
// The created delegate should forward AddRef() and Release()
|
|
// calls to the aOuter object.
|
|
//
|
|
// void CreateDelegate(in nsIRDFResource aOuter,
|
|
// in string aKey,
|
|
// in nsIIDRef aIID,
|
|
// [retval, iid_is(aIID)] out nsQIResult aResult);
|
|
CreateDelegate: function (aOuter, aKey, aIID) {
|
|
}
|
|
}
|
|
|
|
// the nsILDAPConnection associated with a given resource
|
|
//
|
|
const NS_LDAPCONNECTIONRDFDELEGATEFACTORY_CONTRACTID =
|
|
'@mozilla.org/rdf/delegate-factory/connection.ldap;1';
|
|
const NS_LDAPCONNECTIONRDFDELEGATEFACTORY_CID =
|
|
Components.ID('57075fc6-1dd2-11b2-9df5-dbb9111d1b38');
|
|
|
|
function nsLDAPConnectionRDFDelegateFactory() {}
|
|
|
|
nsLDAPConnectionRDFDelegateFactory.prototype =
|
|
{
|
|
// from nsIRDFDelegateFactory:
|
|
//
|
|
// Create a delegate for the specified RDF resource.
|
|
//
|
|
// The created delegate should forward AddRef() and Release()
|
|
// calls to the aOuter object.
|
|
//
|
|
// void CreateDelegate(in nsIRDFResource aOuter,
|
|
// in string aKey,
|
|
// in nsIIDRef aIID,
|
|
// [retval, iid_is(aIID)] out nsQIResult aResult);
|
|
CreateDelegate: function (aOuter, aKey, aIID) {
|
|
}
|
|
}
|
|
|
|
var Datasource = null;
|
|
var MessageDelegateFactory = null;
|
|
|
|
// nsLDAPDataSource Module (for XPCOM registration)
|
|
//
|
|
var nsLDAPDataSourceModule = {
|
|
|
|
registerSelf: function (compMgr, fileSpec, location, type) {
|
|
debug("*** Registering LDAP datasource components" +
|
|
" (all right -- a JavaScript module!)\n");
|
|
|
|
compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
|
|
|
|
compMgr.registerFactoryLocation(
|
|
NS_LDAPDATASOURCE_CID,
|
|
'LDAP RDF DataSource',
|
|
NS_LDAPDATASOURCE_CONTRACTID,
|
|
fileSpec, location,
|
|
type);
|
|
|
|
compMgr.registerFactoryLocation(
|
|
NS_LDAPMESSAGERDFDELEGATEFACTORY_CID,
|
|
'LDAP Message RDF Delegate',
|
|
NS_LDAPMESSAGERDFDELEGATEFACTORY_CONTRACTID,
|
|
fileSpec, location,
|
|
type);
|
|
|
|
compMgr.registerFactoryLocation(
|
|
NS_LDAPMESSAGERDFDELEGATEFACTORY_CID,
|
|
'LDAP Flat MessageList RDF Delegate',
|
|
NS_LDAPFLATMESSAGELISTRDFDELEGATEFACTORY_CONTRACTID,
|
|
fileSpec, location,
|
|
type);
|
|
|
|
compMgr.registerFactoryLocation(
|
|
NS_LDAPMESSAGERDFDELEGATEFACTORY_CID,
|
|
'LDAP Recursive MessageList RDF Delegate',
|
|
NS_LDAPRECURSIVEMESSAGELISTRDFDELEGATEFACTORY_CONTRACTID,
|
|
fileSpec, location,
|
|
type);
|
|
|
|
compMgr.registerFactoryLocation(
|
|
NS_LDAPURLRDFDELEGATEFACTORY_CID,
|
|
'LDAP URL RDF Delegate',
|
|
NS_LDAPURLRDFDELEGATEFACTORY_CONTRACTID,
|
|
fileSpec, location,
|
|
type);
|
|
},
|
|
|
|
getClassObject: function(compMgr, cid, iid) {
|
|
if (!iid.equals(Components.interfaces.nsIFactory)) {
|
|
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
if (cid.equals(NS_LDAPDATASOURCE_CID))
|
|
return this.nsLDAPDataSourceFactory;
|
|
else if (cid.equals(NS_LDAPMESSAGERDFDELEGATEFACTORY_CID))
|
|
return this.nsLDAPMessageRDFDelegateFactoryFactory;
|
|
else if (cid.equals(NS_LDAPURLRDFDELEGATEFACTORY_CID))
|
|
return this.nsLDAPURLRDFDelegateFactoryFactory;
|
|
|
|
throw Components.results.NS_ERROR_NO_INTERFACE;
|
|
},
|
|
|
|
nsLDAPDataSourceFactory: {
|
|
createInstance: function(outer, iid) {
|
|
if (outer != null)
|
|
throw Components.results.NS_ERROR_NO_AGGREGATION;
|
|
|
|
if (Datasource == null) {
|
|
Datasource = new nsLDAPDataSource();
|
|
}
|
|
|
|
return Datasource.QueryInterface(iid);
|
|
}
|
|
},
|
|
|
|
nsLDAPMessageRDFDelegateFactoryFactory: {
|
|
createInstance: function(outer, iid) {
|
|
if (outer != null)
|
|
throw Components.results.NS_ERROR_NO_AGGREGATION;
|
|
|
|
if (MessageDelegateFactory == null) {
|
|
MessageDelegateFactory = new nsLDAPMessageRDFDelegateFactory();
|
|
}
|
|
|
|
return MessageDelegateFactory.QueryInterface(iid);
|
|
}
|
|
},
|
|
|
|
nsLDAPURLRDFDelegateFactoryFactory: {
|
|
createInstance: function(outer, iid) {
|
|
if (outer != null)
|
|
throw Components.results.NS_ERROR_NO_AGGREGATION;
|
|
|
|
return (new nsLDAPURLRDFDelegateFactory()).QueryInterface(iid);
|
|
}
|
|
},
|
|
|
|
// because of the way JS components work (the JS garbage-collector
|
|
// keeps track of all the memory refs and won't unload until appropriate)
|
|
// this ends up being a dummy function; it can always return true.
|
|
//
|
|
canUnload: function(compMgr) { return true; }
|
|
};
|
|
|
|
function NSGetModule(compMgr, fileSpec) { return nsLDAPDataSourceModule; }
|