| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.cocoon.transformation; |
| |
| import java.io.IOException; |
| import java.io.UnsupportedEncodingException; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.Vector; |
| |
| import javax.naming.Context; |
| import javax.naming.NamingEnumeration; |
| import javax.naming.NamingException; |
| import javax.naming.directory.Attribute; |
| import javax.naming.directory.BasicAttribute; |
| import javax.naming.directory.DirContext; |
| import javax.naming.directory.InitialDirContext; |
| import javax.naming.directory.ModificationItem; |
| import javax.naming.directory.SearchControls; |
| import javax.naming.directory.SearchResult; |
| |
| import org.apache.avalon.framework.logger.Logger; |
| import org.apache.avalon.framework.parameters.Parameters; |
| import org.apache.cocoon.ProcessingException; |
| import org.apache.cocoon.environment.SourceResolver; |
| import org.apache.cocoon.xml.XMLConsumer; |
| import org.apache.commons.collections.MapUtils; |
| import org.apache.commons.lang.BooleanUtils; |
| import org.apache.commons.lang.ObjectUtils; |
| import org.apache.commons.lang.StringUtils; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.ext.LexicalHandler; |
| import org.xml.sax.helpers.AttributesImpl; |
| |
| /** |
| * The <code>LDAPTransformer</code> can be plugged into a pipeline to transform |
| * the SAX events into queries and responses to/from a LDAP interface. |
| * <br> |
| * The file will be specified in a parameter tag in the sitemap pipeline to the |
| * transformer as follows: |
| * <p> |
| * <code> |
| * <map:transform type="ldap"/><br> |
| * </code> |
| * </p> |
| * <br> |
| * |
| * The following DTD is valid:<br> |
| * <!ELEMENT execute-query (attribute+ | show-attribute? | scope? | initializer? | initial-context? | authentication? | error-element? | sax-error? doc-element? | row-element? | version? | serverurl? | rootdn? | password? | deref-link? | count-limit? | searchbase, filter)><br> |
| * <!ELEMENT execute-increment (attribute | show-attribute? | scope? | initializer? | initial-context? | authentication? | error-element? | sax-error? | doc-element? | row-element? | version? | serverurl? | rootdn? | password? | deref-link? | count-limit? | searchbase, filter)><br> |
| * increments (+1) an integer attribute on a directory-server (ldap)<br> |
| * <!ELEMENT execute-replace (attribute | show-attribute? | scope? | initializer? | initial-context? | authentication? | error-element? | sax-error? | doc-element? | row-element? | version? | serverurl? | rootdn? | password? | deref-link? | count-limit? | searchbase, filter)><br> |
| * replace attribute on a directory-server (ldap)<br> |
| * <!ELEMENT execute-add (attribute | show-attribute? | scope? | initializer? | initial-context? | authentication? | error-element? | sax-error? | doc-element? | row-element? | version? | serverurl? | rootdn? | password? | deref-link? | count-limit? | searchbase, filter)><br> |
| * add attribute on a directory-server (ldap)<br> |
| * <br> |
| * <!ELEMENT initializer (#PCDATA)>+ (default: "com.sun.jndi.ldap.LdapCtxFactory")<br> |
| * <!ELEMENT initial-context (#EMPTY)><br> |
| * <!ATTLIST initial-context name CDATA #REQUIRED |
| value CDATA #REQUIRED ><br> |
| * <!ELEMENT authentication (#PCDATA)>+ (default: "simple")<br> |
| * <!ELEMENT version (#PCDATA)>+ (default: "2")<br> |
| * <!ELEMENT serverurl (#PCDATA)>+<br> |
| * <!ELEMENT port (#PCDATA)>+ (default: 389)<br> |
| * <!ELEMENT rootdn (#PCDATA)>+<br> |
| * <!ELEMENT password (#PCDATA)>+<br> |
| * <!ELEMENT scope (ONELEVEL_SCOPE | SUBTREE_SCOPE | OBJECT_SCOPE)>+ (default: ONELEVEL_SCOPE)<br> |
| * <!ELEMENT searchbase (#PCDATA)>+<br> |
| * <!ELEMENT doc-element (#PCDATA)>+ (default: "doc-element")<br> |
| * <!ELEMENT row-element (#PCDATA)>+ (default: "row-element")<br> |
| * <!ELEMENT dn-attribute (#PCDATA)>+ (default: "" meaning no DN attribute)<br> |
| * <!ELEMENT error-element (#PCDATA)>+ (default: "ldap-error") (in case of error returned error tag)<br> |
| * <!ELEMENT sax_error (TRUE | FALSE)>+; (default: FALSE) (throws SAX-Exception instead of error tag)<br> |
| * <!ELEMENT attribute (#PCDATA)><br> |
| * <!ATTLIST attribute name CDATA #IMPLIED |
| mode (append|replace) 'replace' #IMPLIED > (in case execute-replace or execute-add elements using) <br> |
| |
| * <!ELEMENT show-attribute (TRUE | FALSE)> (default: TRUE)<br> |
| * <!ELEMENT filter (#PCDATA | execute-query)+><br> |
| * <!ELEMENT deref-link (TRUE | FALSE)> (default: FALSE)<br> |
| * <!ELEMENT count-limit (#PCDATA)> (integer default: 0 -> no limit)<br> |
| * <!ELEMENT time-limit (#PCDATA)> (integer default: 0 -> infinite)<br> |
| * <!ELEMENT debug (TRUE | FALSE)>+; (default: FALSE)<br> |
| * <br> |
| * + can also be defined as parameter in the sitemap. |
| * <br> |
| * |
| * @version $Id$ |
| */ |
| public class LDAPTransformer extends AbstractTransformer { |
| |
| /** The LDAP namespace ("http://apache.org/cocoon/LDAP/1.0")*/ |
| public static final String my_uri = "http://apache.org/cocoon/LDAP/1.0"; |
| public static final String my_name = "LDAPTransformer"; |
| |
| /** The LDAP namespace element names */ |
| public static final String MAGIC_ATTRIBUTE_ELEMENT = "attribute"; |
| public static final String MAGIC_ATTRIBUTE_ELEMENT_ATTRIBUTE = "name"; |
| public static final String MAGIC_ATTRIBUTE_ELEMENT_MODE_ATTRIBUTE = "mode"; |
| public static final String MAGIC_ATTRIBUTE_ELEMENT_MODE_ATTRIBUTE_DEFAULT = "replace"; |
| public static final String MAGIC_ATTRIBUTE_ELEMENT_MODE_ATTRIBUTE_VALUE_A = "append"; |
| public static final String MAGIC_AUTHENTICATION_ELEMENT = "authentication"; |
| public static final String MAGIC_COUNT_LIMIT_ELEMENT = "count-limit"; |
| public static final String MAGIC_DEBUG_ELEMENT = "debug"; |
| public static final String MAGIC_DEREF_LINK_ELEMENT = "deref-link"; |
| public static final String MAGIC_DOC_ELEMENT = "doc-element"; |
| public static final String MAGIC_ENCODING_ELEMENT = "encoding"; |
| public static final String MAGIC_ERROR_ELEMENT = "error-element"; |
| public static final String MAGIC_EXECUTE_ADD = "execute-add"; |
| public static final String MAGIC_EXECUTE_INCREMENT = "execute-increment"; |
| public static final String MAGIC_EXECUTE_QUERY = "execute-query"; |
| public static final String MAGIC_EXECUTE_REPLACE = "execute-replace"; |
| public static final String MAGIC_FILTER_ELEMENT = "filter"; |
| public static final String MAGIC_INITIALIZER_ELEMENT = "initializer"; |
| public static final String MAGIC_INITIAL_CONTEXT_ELEMENT = "initial-context"; |
| public static final String MAGIC_INITIAL_CONTEXT_NAME_ATTRIBUTE = "name"; |
| public static final String MAGIC_INITIAL_CONTEXT_VALUE_ATTRIBUTE = "value"; |
| public static final String MAGIC_PASSWORD_ELEMENT = "password"; |
| public static final String MAGIC_PORT_ELEMENT = "port"; |
| public static final String MAGIC_ROOT_DN_ELEMENT = "rootdn"; |
| public static final String MAGIC_ROW_ELEMENT = "row-element"; |
| public static final String MAGIC_DN_ATTRIBUTE = "dn-attribute"; |
| public static final String MAGIC_SAX_ERROR = "sax-error"; |
| public static final String MAGIC_SCOPE_ELEMENT = "scope"; |
| public static final String MAGIC_SEARCHBASE_ELEMENT = "searchbase"; |
| public static final String MAGIC_SERVERURL_ELEMENT = "serverurl"; |
| public static final String MAGIC_SHOW_ATTRIBUTE_ELEMENT = "show-attribute"; |
| public static final String MAGIC_TIME_LIMIT_ELEMENT = "time-limit"; |
| public static final String MAGIC_VERSION_ELEMENT = "version"; |
| |
| /** The states we are allowed to be in */ |
| public static final int STATE_OUTSIDE = 0; |
| public static final int STATE_INSIDE_EXECUTE_QUERY = 1; |
| public static final int STATE_INSIDE_EXECUTE_INCREMENT = 2; |
| public static final int STATE_INSIDE_EXECUTE_ELEMENT = 3; |
| public static final int STATE_INSIDE_INITIALIZER_ELEMENT = 4; |
| public static final int STATE_INSIDE_SERVERURL_ELEMENT = 5; |
| public static final int STATE_INSIDE_PORT_ELEMENT = 6; |
| public static final int STATE_INSIDE_SCOPE_ELEMENT = 7; |
| public static final int STATE_INSIDE_VERSION_ELEMENT = 8; |
| public static final int STATE_INSIDE_AUTHENTICATION_ELEMENT = 9; |
| public static final int STATE_INSIDE_ROOT_DN_ELEMENT = 10; |
| public static final int STATE_INSIDE_PASSWORD_ELEMENT = 11; |
| public static final int STATE_INSIDE_SEARCHBASE_ELEMENT = 12; |
| public static final int STATE_INSIDE_DOC_ELEMENT = 13; |
| public static final int STATE_INSIDE_ROW_ELEMENT = 14; |
| public static final int STATE_INSIDE_ATTRIBUTE_ELEMENT = 15; |
| public static final int STATE_INSIDE_SHOW_ATTRIBUTE_ELEMENT = 16; |
| public static final int STATE_INSIDE_ERROR_ELEMENT = 17; |
| public static final int STATE_INSIDE_FILTER_ELEMENT = 18; |
| public static final int STATE_INSIDE_DEREF_LINK_ELEMENT = 19; |
| public static final int STATE_INSIDE_COUNT_LIMIT_ELEMENT = 20; |
| public static final int STATE_INSIDE_TIME_LIMIT_ELEMENT = 21; |
| public static final int STATE_INSIDE_DEBUG_ELEMENT = 22; |
| public static final int STATE_INSIDE_SAX_ERROR_ELEMENT = 23; |
| public static final int STATE_INSIDE_EXECUTE_REPLACE = 24; |
| public static final int STATE_INSIDE_EXECUTE_ADD = 25; |
| public static final int STATE_INSIDE_DN_ATTRIBUTE = 26; |
| public static final int STATE_INSIDE_INITIAL_CONTEXT_ELEMENT = 27; |
| |
| /** Default parameters that might apply to all queries */ |
| protected HashMap default_properties = new HashMap(); |
| |
| /** The name of the value element we're currently receiving */ |
| protected String current_name; |
| |
| /** The current state of the event receiving FSM */ |
| protected int current_state = STATE_OUTSIDE; |
| |
| /** The value of the value element we're currently receiving */ |
| protected StringBuffer current_value = new StringBuffer(); |
| |
| /** The list of queries that we're currently working on */ |
| protected Vector queries = new Vector(); |
| |
| /** The offset of the current query in the queries list */ |
| protected int current_query_index = -1; |
| |
| /** SAX producing state information */ |
| protected XMLConsumer xml_consumer; |
| protected LexicalHandler lexical_handler; |
| |
| /** SitemapComponent methods */ |
| |
| public void setup(SourceResolver resolver, Map objectModel, String source, Parameters parameters) |
| throws ProcessingException, SAXException, IOException { |
| current_state = STATE_OUTSIDE; |
| |
| setDefaultProperty(parameters, MAGIC_INITIALIZER_ELEMENT); // Check the initializer |
| setDefaultProperty(parameters, MAGIC_VERSION_ELEMENT); // Check the version |
| setDefaultProperty(parameters, MAGIC_AUTHENTICATION_ELEMENT); // Check the authentication |
| setDefaultProperty(parameters, MAGIC_SCOPE_ELEMENT); // Check the scope |
| setDefaultProperty(parameters, MAGIC_SERVERURL_ELEMENT); // Check the serverurl |
| setDefaultProperty(parameters, MAGIC_ROOT_DN_ELEMENT); // Check the ldap-root_dn |
| setDefaultProperty(parameters, MAGIC_PASSWORD_ELEMENT); // Check the ldap-pwd |
| setDefaultProperty(parameters, MAGIC_PORT_ELEMENT); // Check the port |
| setDefaultProperty(parameters, MAGIC_SEARCHBASE_ELEMENT); // Check the searchbase |
| setDefaultProperty(parameters, MAGIC_DOC_ELEMENT); // Check the doc-element |
| setDefaultProperty(parameters, MAGIC_ROW_ELEMENT); // Check the row-element |
| setDefaultProperty(parameters, MAGIC_DN_ATTRIBUTE); // Check the dn-attribute |
| setDefaultProperty(parameters, MAGIC_ERROR_ELEMENT); // Check the error-element |
| setDefaultProperty(parameters, MAGIC_SAX_ERROR); // Check the sax-error |
| setDefaultProperty(parameters, MAGIC_DEREF_LINK_ELEMENT); // Check the deref-link-element |
| setDefaultProperty(parameters, MAGIC_COUNT_LIMIT_ELEMENT); // Check the count-limit-element |
| setDefaultProperty(parameters, MAGIC_TIME_LIMIT_ELEMENT); // Check the time-limit-element |
| setDefaultProperty(parameters, MAGIC_DEBUG_ELEMENT); // Check the debug-element |
| setDefaultProperty(parameters, MAGIC_ENCODING_ELEMENT); // Check the encoding |
| setDefaultProperty(parameters, MAGIC_FILTER_ELEMENT); // Check the filter-element |
| } |
| |
| /** My very own methods */ |
| |
| /* Helper to set default properties */ |
| protected void setDefaultProperty(Parameters parameters, String propertyName) { |
| String parameter = parameters.getParameter(propertyName, null); |
| if (parameter != null) { |
| default_properties.put(propertyName, parameter); |
| } |
| } |
| |
| /* Helper class to store a new Query in the stack */ |
| protected void storeQuery(int nextState) { |
| current_state = nextState; |
| current_query_index = queries.size(); |
| LDAPQuery query = new LDAPQuery(this); |
| queries.addElement(query); |
| getCurrentQuery().toDo = nextState; |
| getCurrentQuery().query_index = current_query_index; |
| } |
| |
| /** |
| * This will be the meat of LDAPTransformer, where the query is run. |
| */ |
| protected void executeQuery(int index) throws SAXException { |
| this.contentHandler.startPrefixMapping("", LDAPTransformer.my_uri); |
| LDAPQuery query = (LDAPQuery)queries.elementAt(index); |
| try { |
| query.execute(); |
| } catch (NamingException e) { |
| getLogger().error(e.toString()); |
| throw new SAXException(e); |
| } catch (Exception e) { |
| getLogger().error(e.toString()); |
| throw new SAXException(e); |
| } |
| this.contentHandler.endPrefixMapping(""); |
| } |
| |
| protected static void throwIllegalStateException(String message) { |
| throw new IllegalStateException(my_name + ": " + message); |
| } |
| |
| protected void startExecuteElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_OUTSIDE : |
| case LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT : |
| storeQuery(LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY); |
| break; |
| default : |
| throwIllegalStateException("Not expecting a start execute-query element"); |
| } |
| } |
| |
| protected void startExecuteElement(int state, String name) { |
| switch (current_state) { |
| case LDAPTransformer.STATE_OUTSIDE : |
| case LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY : |
| storeQuery(state); |
| break; |
| default : |
| throwIllegalStateException("Not expecting a start " + name + " element"); |
| } |
| } |
| |
| protected void endExecuteElement(int state, String name) throws SAXException { |
| if (current_state == state) { |
| executeQuery(current_query_index); |
| queries.remove(current_query_index); |
| --current_query_index; |
| if (current_query_index > -1) { |
| current_state = getCurrentQuery().toDo; |
| } else { |
| queries.removeAllElements(); |
| current_state = LDAPTransformer.STATE_OUTSIDE; |
| } |
| } else { |
| throwIllegalStateException("Not expecting a end " + name + " element"); |
| } |
| } |
| |
| protected void startQueryParameterElement(int state, String name) { |
| switch (current_state) { |
| case STATE_INSIDE_EXECUTE_QUERY : |
| case STATE_INSIDE_EXECUTE_INCREMENT : |
| case STATE_INSIDE_EXECUTE_REPLACE : |
| case STATE_INSIDE_EXECUTE_ADD : |
| current_value.setLength(0); |
| current_state = state; |
| getCurrentQuery().current_state = state; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a start " + name + " element"); |
| } |
| } |
| |
| protected void startParameterElement(int state, String name) { |
| switch (current_state) { |
| case STATE_INSIDE_EXECUTE_QUERY : |
| case STATE_INSIDE_EXECUTE_INCREMENT : |
| case STATE_INSIDE_EXECUTE_REPLACE : |
| case STATE_INSIDE_EXECUTE_ADD : |
| current_value.setLength(0); |
| current_state = state; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a start " + name + " serverurl element"); |
| } |
| } |
| |
| protected void endInitializerElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_INITIALIZER_ELEMENT : |
| getCurrentQuery().initializer = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end initializer element"); |
| } |
| } |
| |
| protected void endScopeElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_SCOPE_ELEMENT : |
| getCurrentQuery().scope = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end scope element"); |
| } |
| } |
| |
| protected void endAuthenticationElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_AUTHENTICATION_ELEMENT : |
| getCurrentQuery().authentication = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end authentication element"); |
| } |
| } |
| |
| protected void endServerurlElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_SERVERURL_ELEMENT : |
| getCurrentQuery().serverurl = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end serverurl element"); |
| } |
| } |
| |
| protected void endPortElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_PORT_ELEMENT : |
| getCurrentQuery().port = Integer.parseInt(current_value.toString()); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end server element"); |
| } |
| } |
| |
| protected void startShowAttributeElement(Attributes attributes) { |
| switch (current_state) { |
| case STATE_INSIDE_EXECUTE_QUERY : |
| case STATE_INSIDE_EXECUTE_INCREMENT : |
| //case STATE_INSIDE_EXECUTE_REPLACE: |
| current_value.setLength(0); |
| current_state = LDAPTransformer.STATE_INSIDE_SHOW_ATTRIBUTE_ELEMENT; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a start show-attribute element"); |
| } |
| } |
| |
| protected void endShowAttributeElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_SHOW_ATTRIBUTE_ELEMENT : |
| if (!BooleanUtils.toBoolean(current_value.toString())) { |
| getCurrentQuery().showAttribute = false; |
| } |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end show-attribute element"); |
| } |
| } |
| |
| protected void endSearchbaseElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_SEARCHBASE_ELEMENT : |
| getCurrentQuery().searchbase = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end searchbase element"); |
| } |
| } |
| |
| protected void endDocElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_DOC_ELEMENT : |
| getCurrentQuery().doc_element = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end doc-element element"); |
| } |
| } |
| |
| protected void endRowElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_ROW_ELEMENT : |
| getCurrentQuery().row_element = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end row-element element"); |
| } |
| } |
| |
| protected void endDnAttribute() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_DN_ATTRIBUTE : |
| getCurrentQuery().dn_attribute = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end dn-attribute element"); |
| } |
| } |
| |
| protected void endErrorElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_ERROR_ELEMENT : |
| getCurrentQuery().error_element = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end error-element element"); |
| } |
| } |
| |
| protected void endSaxError() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_SAX_ERROR_ELEMENT : |
| if (current_value.toString().toUpperCase().equals("TRUE")) { |
| getCurrentQuery().sax_error = true; |
| } |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end sax-error element"); |
| } |
| } |
| |
| protected void endRootDnElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_ROOT_DN_ELEMENT : |
| getCurrentQuery().root_dn = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end root-dn element"); |
| } |
| } |
| |
| protected void endPasswordElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_PASSWORD_ELEMENT : |
| getCurrentQuery().password = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end password element"); |
| } |
| } |
| |
| protected void startAttributeElement(Attributes attributes) { |
| switch (current_state) { |
| case STATE_INSIDE_EXECUTE_QUERY : |
| case STATE_INSIDE_EXECUTE_INCREMENT : |
| current_state = LDAPTransformer.STATE_INSIDE_ATTRIBUTE_ELEMENT; |
| current_value.setLength(0); |
| break; |
| case STATE_INSIDE_EXECUTE_REPLACE : |
| boolean is_name_present = false; |
| String mode = MAGIC_ATTRIBUTE_ELEMENT_MODE_ATTRIBUTE_DEFAULT; |
| if (attributes != null && attributes.getLength() > 0) { |
| AttributesImpl new_attributes = new AttributesImpl(attributes); |
| for (int i = 0; i < new_attributes.getLength(); i++) { |
| String attr_name = new_attributes.getLocalName(i); |
| if (attr_name.equals(MAGIC_ATTRIBUTE_ELEMENT_ATTRIBUTE)) { |
| String value = new_attributes.getValue(i); |
| getCurrentQuery().addAttrList(value); |
| is_name_present = true; |
| } else if (attr_name.equals(MAGIC_ATTRIBUTE_ELEMENT_MODE_ATTRIBUTE)) { |
| if (new_attributes.getValue(i).equals(MAGIC_ATTRIBUTE_ELEMENT_MODE_ATTRIBUTE_VALUE_A)) |
| mode = MAGIC_ATTRIBUTE_ELEMENT_MODE_ATTRIBUTE_VALUE_A; |
| } else { |
| this.getLogger().debug("Invalid attribute match: " + attr_name); |
| throwIllegalStateException("Invalid attribute match in start attribute element"); |
| } |
| } |
| } |
| if (!is_name_present) { |
| this.getLogger().debug("Do not match 'value' attribute"); |
| throwIllegalStateException("Do not match 'value' attribute in start attribute element"); |
| } |
| getCurrentQuery().addAttrModeVal(mode); |
| current_state = LDAPTransformer.STATE_INSIDE_ATTRIBUTE_ELEMENT; |
| current_value.setLength(0); |
| break; |
| case STATE_INSIDE_EXECUTE_ADD : |
| if (attributes != null && attributes.getLength() > 0) { |
| AttributesImpl new_attributes = new AttributesImpl(attributes); |
| for (int i = 0; i < new_attributes.getLength(); i++) { |
| String attr_name = new_attributes.getLocalName(i); |
| if (attr_name.equals(MAGIC_ATTRIBUTE_ELEMENT_ATTRIBUTE)) { |
| String value = new_attributes.getValue(i); |
| getCurrentQuery().addAttrList(value); |
| } else { |
| this.getLogger().debug("Invalid attribute match: " + attr_name); |
| throwIllegalStateException("Invalid attribute match in start attribute element"); |
| } |
| } |
| } else { |
| this.getLogger().debug("Do not match 'value' attribute"); |
| throwIllegalStateException("Do not match 'value' attribute in start attribute element"); |
| } |
| current_state = LDAPTransformer.STATE_INSIDE_ATTRIBUTE_ELEMENT; |
| current_value.setLength(0); |
| break; |
| default : |
| throwIllegalStateException("Not expecting a start attribute element"); |
| } |
| } |
| |
| protected void endAttributeElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_ATTRIBUTE_ELEMENT : |
| if ((getCurrentQuery().toDo == STATE_INSIDE_EXECUTE_REPLACE) || (getCurrentQuery().toDo == STATE_INSIDE_EXECUTE_ADD)) { |
| getCurrentQuery().addAttrVal(current_value.toString()); |
| current_state = getCurrentQuery().toDo; |
| break; |
| } |
| getCurrentQuery().addAttrList(current_value.toString()); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end attribute element"); |
| } |
| } |
| |
| protected void startInitialContextElement(Attributes attributes) { |
| switch (current_state) { |
| case STATE_INSIDE_EXECUTE_INCREMENT : |
| current_state = LDAPTransformer.STATE_INSIDE_INITIAL_CONTEXT_ELEMENT; |
| current_value.setLength(0); |
| break; |
| case STATE_INSIDE_EXECUTE_QUERY : |
| case STATE_INSIDE_EXECUTE_ADD : |
| case STATE_INSIDE_EXECUTE_REPLACE : |
| String name = null, value = null; |
| |
| if (attributes != null && attributes.getLength() > 0) { |
| name = attributes.getValue("name"); |
| value = attributes.getValue("value"); |
| |
| if (name != null && value != null) |
| getCurrentQuery().addInitialContextValue(name, value); |
| } |
| if (name == null) { |
| this.getLogger().debug("Could not find 'name' attribute"); |
| throwIllegalStateException("Could not find 'name' attribute in initial-context element"); |
| } |
| if (value == null) { |
| this.getLogger().debug("Could not find 'value' attribute"); |
| throwIllegalStateException("Could not find 'value' attribute in initial-context element"); |
| } |
| |
| current_state = LDAPTransformer.STATE_INSIDE_INITIAL_CONTEXT_ELEMENT; |
| current_value.setLength(0); |
| break; |
| default : |
| throwIllegalStateException("Not expecting a start initial-context element"); |
| } |
| } |
| |
| protected void endInitialContextElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_INITIAL_CONTEXT_ELEMENT : |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end initial-context element"); |
| } |
| } |
| |
| protected void endVersionElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_VERSION_ELEMENT : |
| getCurrentQuery().version = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end version element"); |
| } |
| } |
| |
| protected void startFilterElement(Attributes attributes) { |
| switch (current_state) { |
| case STATE_INSIDE_EXECUTE_QUERY : |
| case STATE_INSIDE_EXECUTE_INCREMENT : |
| case STATE_INSIDE_EXECUTE_REPLACE : |
| case STATE_INSIDE_EXECUTE_ADD : |
| current_state = LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT; |
| getCurrentQuery().current_state = LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT; |
| current_value.setLength(0); |
| break; |
| default : |
| throwIllegalStateException("Not expecting a start filter element"); |
| } |
| } |
| |
| protected void endFilterElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT : |
| getCurrentQuery().filter = current_value.toString(); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end filter element"); |
| } |
| } |
| |
| protected void endDerefLinkElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_DEREF_LINK_ELEMENT : |
| getCurrentQuery().deref_link = BooleanUtils.toBoolean(current_value.toString()); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end deref-link element"); |
| } |
| } |
| |
| protected void endCountLimitElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_COUNT_LIMIT_ELEMENT : |
| getCurrentQuery().count_limit = Integer.parseInt(current_value.toString()); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end count-limit element"); |
| } |
| } |
| |
| protected void endTimeLimitElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_TIME_LIMIT_ELEMENT : |
| getCurrentQuery().time_limit = Integer.parseInt(current_value.toString()); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end time-limit element"); |
| } |
| } |
| |
| protected void endDebugElement() { |
| switch (current_state) { |
| case LDAPTransformer.STATE_INSIDE_DEBUG_ELEMENT : |
| getCurrentQuery().debug = BooleanUtils.toBoolean(current_value.toString()); |
| current_state = getCurrentQuery().toDo; |
| break; |
| default : |
| throwIllegalStateException("Not expecting a end debug element"); |
| } |
| } |
| |
| protected LDAPQuery getCurrentQuery() { |
| return (LDAPQuery)queries.elementAt(current_query_index); |
| } |
| |
| protected LDAPQuery getQuery(int i) { |
| return (LDAPQuery)queries.elementAt(i); |
| } |
| |
| /** END my very own methods */ |
| |
| /** BEGIN SAX ContentHandler handlers */ |
| |
| public void setDocumentLocator(Locator locator) { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("PUBLIC ID: " + locator.getPublicId()); |
| getLogger().debug("SYSTEM ID: " + locator.getSystemId()); |
| } |
| if (super.contentHandler != null) |
| super.contentHandler.setDocumentLocator(locator); |
| } |
| |
| public void startElement(String uri, String name, String raw, Attributes attributes) throws SAXException { |
| if (uri == null || !uri.equals(my_uri)) { |
| super.startElement(uri, name, raw, attributes); |
| return; |
| } |
| getLogger().debug("RECEIVED START ELEMENT " + name + "(" + uri + ")"); |
| |
| if (name.equals(LDAPTransformer.MAGIC_EXECUTE_QUERY)) { |
| startExecuteElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_EXECUTE_INCREMENT)) { |
| startExecuteElement(LDAPTransformer.STATE_INSIDE_EXECUTE_INCREMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_INITIALIZER_ELEMENT)) { |
| startQueryParameterElement(LDAPTransformer.STATE_INSIDE_INITIALIZER_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_INITIAL_CONTEXT_ELEMENT)) { |
| startInitialContextElement(attributes); |
| } else if (name.equals(LDAPTransformer.MAGIC_AUTHENTICATION_ELEMENT)) { |
| startQueryParameterElement(LDAPTransformer.STATE_INSIDE_AUTHENTICATION_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_SCOPE_ELEMENT)) { |
| startQueryParameterElement(LDAPTransformer.STATE_INSIDE_SCOPE_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_VERSION_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_VERSION_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_SERVERURL_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_SERVERURL_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_PORT_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_PORT_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_DOC_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_DOC_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_ROW_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_ROW_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_DN_ATTRIBUTE)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_DN_ATTRIBUTE, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_ERROR_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_ERROR_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_SAX_ERROR)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_SAX_ERROR_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_ROOT_DN_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_ROOT_DN_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_PASSWORD_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_PASSWORD_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_ATTRIBUTE_ELEMENT)) { |
| startAttributeElement(attributes); |
| } else if (name.equals(LDAPTransformer.MAGIC_SHOW_ATTRIBUTE_ELEMENT)) { |
| startShowAttributeElement(attributes); |
| } else if (name.equals(LDAPTransformer.MAGIC_SEARCHBASE_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_SEARCHBASE_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_FILTER_ELEMENT)) { |
| startFilterElement(attributes); |
| } else if (name.equals(LDAPTransformer.MAGIC_DEREF_LINK_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_DEREF_LINK_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_COUNT_LIMIT_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_COUNT_LIMIT_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_TIME_LIMIT_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_TIME_LIMIT_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_DEBUG_ELEMENT)) { |
| startParameterElement(LDAPTransformer.STATE_INSIDE_DEBUG_ELEMENT, name); |
| } else if (name.equals(LDAPTransformer.MAGIC_EXECUTE_REPLACE)) { |
| startExecuteElement(LDAPTransformer.STATE_INSIDE_EXECUTE_REPLACE, LDAPTransformer.MAGIC_EXECUTE_REPLACE); |
| } else if (name.equals(LDAPTransformer.MAGIC_EXECUTE_ADD)) { |
| startExecuteElement(LDAPTransformer.STATE_INSIDE_EXECUTE_ADD, LDAPTransformer.MAGIC_EXECUTE_ADD); |
| } |
| } |
| |
| public void endElement(String uri, String name, String raw) throws SAXException { |
| if (!uri.equals(my_uri)) { |
| super.endElement(uri, name, raw); |
| return; |
| } |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("RECEIVED END ELEMENT " + name + "(" + uri + ")"); |
| } |
| |
| if (name.equals(LDAPTransformer.MAGIC_EXECUTE_QUERY)) { |
| endExecuteElement(LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY, LDAPTransformer.MAGIC_EXECUTE_QUERY); |
| } else if (name.equals(LDAPTransformer.MAGIC_EXECUTE_INCREMENT)) { |
| endExecuteElement(LDAPTransformer.STATE_INSIDE_EXECUTE_INCREMENT, LDAPTransformer.MAGIC_EXECUTE_INCREMENT); |
| } else if (name.equals(LDAPTransformer.MAGIC_INITIALIZER_ELEMENT)) { |
| endInitializerElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_INITIAL_CONTEXT_ELEMENT)) { |
| endInitialContextElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_AUTHENTICATION_ELEMENT)) { |
| endAuthenticationElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_SCOPE_ELEMENT)) { |
| endScopeElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_VERSION_ELEMENT)) { |
| endVersionElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_SERVERURL_ELEMENT)) { |
| endServerurlElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_PORT_ELEMENT)) { |
| endPortElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_DOC_ELEMENT)) { |
| endDocElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_ROW_ELEMENT)) { |
| endRowElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_DN_ATTRIBUTE)) { |
| endDnAttribute(); |
| } else if (name.equals(LDAPTransformer.MAGIC_ERROR_ELEMENT)) { |
| endErrorElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_SAX_ERROR)) { |
| endSaxError(); |
| } else if (name.equals(LDAPTransformer.MAGIC_ROOT_DN_ELEMENT)) { |
| endRootDnElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_PASSWORD_ELEMENT)) { |
| endPasswordElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_ATTRIBUTE_ELEMENT)) { |
| endAttributeElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_SHOW_ATTRIBUTE_ELEMENT)) { |
| endShowAttributeElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_SEARCHBASE_ELEMENT)) { |
| endSearchbaseElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_FILTER_ELEMENT)) { |
| endFilterElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_DEREF_LINK_ELEMENT)) { |
| endDerefLinkElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_COUNT_LIMIT_ELEMENT)) { |
| endCountLimitElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_TIME_LIMIT_ELEMENT)) { |
| endTimeLimitElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_DEBUG_ELEMENT)) { |
| endDebugElement(); |
| } else if (name.equals(LDAPTransformer.MAGIC_EXECUTE_REPLACE)) { |
| endExecuteElement(LDAPTransformer.STATE_INSIDE_EXECUTE_REPLACE, LDAPTransformer.MAGIC_EXECUTE_REPLACE); |
| } else if (name.equals(LDAPTransformer.MAGIC_EXECUTE_ADD)) { |
| endExecuteElement(LDAPTransformer.STATE_INSIDE_EXECUTE_ADD, LDAPTransformer.MAGIC_EXECUTE_ADD); |
| } |
| } |
| |
| public void characters(char ary[], int start, int length) throws SAXException { |
| if (current_state != LDAPTransformer.STATE_INSIDE_INITIALIZER_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_INITIAL_CONTEXT_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_AUTHENTICATION_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_SCOPE_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_VERSION_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_SERVERURL_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_PORT_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_DOC_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_ROW_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_DN_ATTRIBUTE |
| && current_state != LDAPTransformer.STATE_INSIDE_ERROR_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_SAX_ERROR_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_ROOT_DN_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_PASSWORD_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_ATTRIBUTE_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_SHOW_ATTRIBUTE_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_DEREF_LINK_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_COUNT_LIMIT_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_TIME_LIMIT_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_DEBUG_ELEMENT |
| && current_state != LDAPTransformer.STATE_INSIDE_SEARCHBASE_ELEMENT) { |
| super.characters(ary, start, length); |
| } |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("RECEIVED CHARACTERS: " + new String(ary, start, length)); |
| } |
| current_value.append(ary, start, length); |
| } |
| |
| protected void start(String name, AttributesImpl attr) throws SAXException { |
| super.contentHandler.startElement("", name, name, attr); |
| attr.clear(); |
| } |
| |
| protected void end(String name) throws SAXException { |
| super.contentHandler.endElement("", name, name); |
| } |
| |
| protected void data(String data) throws SAXException { |
| if (data != null) { |
| super.contentHandler.characters(data.toCharArray(), 0, data.length()); |
| } |
| } |
| |
| protected static String getStringValue(Object object) { |
| return ObjectUtils.toString(object); |
| } |
| |
| public final Logger getTheLogger() { |
| return getLogger(); |
| } |
| |
| static class LDAPQuery { |
| |
| /** What index are you in daddy's queries list */ |
| protected int query_index; |
| |
| /** The current state of the event receiving FSM */ |
| protected int current_state; |
| |
| /** Who's your daddy? */ |
| protected LDAPTransformer transformer; |
| |
| /** LDAP configuration information */ |
| protected String initializer; |
| protected String serverurl; |
| protected int port; |
| protected String root_dn; |
| protected String password; |
| protected String version; |
| protected String scope; |
| protected String authentication; |
| private final static String LDAP_ENCODING = "ISO-8859-1"; |
| protected String encoding; |
| |
| /** LDAP environment information */ |
| protected Properties env = new Properties(); |
| protected DirContext ctx; |
| |
| /** LDAP Query */ |
| protected int toDo; |
| protected String searchbase; |
| protected List attrModeVal = new LinkedList(); |
| protected List attrListe = new LinkedList(); |
| protected List attrVale = new LinkedList(); |
| protected String REPLACE_MODE_DEFAULT = StringUtils.defaultString(LDAPTransformer.MAGIC_ATTRIBUTE_ELEMENT_MODE_ATTRIBUTE_DEFAULT); |
| protected String REPLACE_MODE_APPEND = StringUtils.defaultString(LDAPTransformer.MAGIC_ATTRIBUTE_ELEMENT_MODE_ATTRIBUTE_VALUE_A); |
| protected Map initialContextValues = new HashMap(); |
| protected boolean showAttribute; |
| protected String filter; |
| protected String doc_element; |
| protected String exec_element = "exec-element"; |
| protected String row_element; |
| protected String dn_attribute; |
| protected String error_element; |
| protected boolean sax_error; |
| protected boolean deref_link; // Dereference: true -> dereference the link during search |
| protected long count_limit; // Maximum number of entries to return: 0 -> no limit |
| protected int time_limit; // Number of milliseconds to wait before return: 0 -> infinite |
| protected boolean debug; |
| |
| protected LDAPQuery(LDAPTransformer transformer) { |
| this.transformer = transformer; |
| initializer = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_INITIALIZER_ELEMENT, "com.sun.jndi.ldap.LdapCtxFactory"); |
| serverurl = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_SERVERURL_ELEMENT, "localhost"); |
| port = MapUtils.getIntValue(transformer.default_properties, LDAPTransformer.MAGIC_PORT_ELEMENT, 389); |
| root_dn = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_ROOT_DN_ELEMENT, ""); |
| password = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_PASSWORD_ELEMENT, ""); |
| version = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_VERSION_ELEMENT, "2"); |
| scope = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_SCOPE_ELEMENT, "ONELEVEL_SCOPE"); |
| authentication = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_AUTHENTICATION_ELEMENT, "simple"); |
| searchbase = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_SEARCHBASE_ELEMENT, ""); |
| showAttribute = MapUtils.getBooleanValue(transformer.default_properties, LDAPTransformer.MAGIC_SHOW_ATTRIBUTE_ELEMENT, true); |
| doc_element = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_DOC_ELEMENT, "doc-element"); |
| row_element = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_ROW_ELEMENT, "row-element"); |
| dn_attribute = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_DN_ATTRIBUTE, ""); |
| error_element = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_ERROR_ELEMENT, "ldap-error"); |
| sax_error = MapUtils.getBooleanValue(transformer.default_properties, LDAPTransformer.MAGIC_SAX_ERROR); |
| deref_link = MapUtils.getBooleanValue(transformer.default_properties, LDAPTransformer.MAGIC_DEREF_LINK_ELEMENT); |
| count_limit = MapUtils.getLongValue(transformer.default_properties, LDAPTransformer.MAGIC_DEREF_LINK_ELEMENT); |
| time_limit = MapUtils.getIntValue(transformer.default_properties, LDAPTransformer.MAGIC_TIME_LIMIT_ELEMENT); |
| debug = MapUtils.getBooleanValue(transformer.default_properties, LDAPTransformer.MAGIC_DEBUG_ELEMENT); |
| encoding = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_ENCODING_ELEMENT, LDAP_ENCODING); |
| filter = MapUtils.getString(transformer.default_properties, LDAPTransformer.MAGIC_FILTER_ELEMENT, ""); |
| } |
| |
| /** shared constraints initialization */ |
| protected void initConstraints(SearchControls constraints) { |
| if (scope.equals("OBJECT_SCOPE")) { |
| constraints.setSearchScope(SearchControls.OBJECT_SCOPE); |
| } else if (scope.equals("SUBTREE_SCOPE")) { |
| constraints.setSearchScope(SearchControls.SUBTREE_SCOPE); |
| } else { |
| constraints.setSearchScope(SearchControls.ONELEVEL_SCOPE); |
| } |
| constraints.setTimeLimit(time_limit); |
| constraints.setDerefLinkFlag(deref_link); |
| constraints.setCountLimit(count_limit); |
| } |
| |
| protected void execute() throws Exception, NamingException { |
| String[] attrList = new String[attrListe.size()]; |
| |
| AttributesImpl attr = new AttributesImpl(); |
| if (debug) { |
| debugPrint(); |
| } |
| SearchControls constraints = new SearchControls(); |
| attrListe.toArray(attrList); |
| attrListe.clear(); |
| try { |
| connect(); |
| switch (toDo) { |
| case LDAPTransformer.STATE_INSIDE_EXECUTE_QUERY : |
| try { |
| initConstraints(constraints); |
| if (attrList.length > 0) { |
| constraints.setReturningAttributes(attrList); |
| } |
| |
| if (!filter.equals("")) { |
| //filter is present |
| if (!doc_element.equals("")) { |
| transformer.start(doc_element, attr); |
| } |
| NamingEnumeration ldapresults = ctx.search(searchbase, filter, constraints); |
| |
| while (ldapresults != null && ldapresults.hasMore()) { |
| SearchResult si = (SearchResult) ldapresults.next(); |
| if (!row_element.equals("")) { |
| if(!"".equals(dn_attribute)) { |
| String dn; |
| if(!"".equals(searchbase)) |
| dn = si.getName() + ',' + searchbase; |
| else |
| dn = si.getName(); |
| attr.addAttribute(null, dn_attribute, dn_attribute, "CDATA", dn); |
| } |
| transformer.start(row_element, attr); |
| } |
| javax.naming.directory.Attributes attrs = si.getAttributes(); |
| if (attrs != null) { |
| NamingEnumeration ae = attrs.getAll(); |
| while (ae.hasMoreElements()) { |
| Attribute at = (Attribute) ae.next(); |
| Enumeration vals = at.getAll(); |
| String attrID = at.getID(); |
| while (vals.hasMoreElements()) { |
| if (showAttribute) { |
| transformer.start(attrID, attr); |
| } |
| String attrVal = recodeFromLDAPEncoding((String) vals.nextElement()); |
| if (query_index > 0) { |
| switch (transformer.getQuery(query_index - 1).current_state) { |
| case LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT : |
| StringBuffer temp = new StringBuffer(transformer.getQuery(query_index - 1).filter); |
| if (temp.length() > 0) { |
| temp.append(", "); |
| } |
| temp.append(attrID).append("=").append(attrVal); |
| transformer.getQuery(query_index - 1).filter = temp.toString(); |
| break; |
| default : |
| transformer.start(attrID, attr); |
| } |
| } else { |
| transformer.data(String.valueOf(attrVal)); |
| } |
| if (showAttribute) { |
| transformer.end(attrID); |
| } |
| } |
| } |
| } |
| if (!row_element.equals("")) { |
| transformer.end(row_element); |
| } |
| } |
| if (!doc_element.equals("")) { |
| transformer.end(doc_element); |
| } |
| } else { |
| //filter not present, get the values from absolete path |
| javax.naming.directory.Attributes attrs = ctx.getAttributes(searchbase, attrList); |
| if (!doc_element.equals("")) { |
| transformer.start(doc_element, attr); |
| } |
| if (!row_element.equals("")) { |
| if(!"".equals(dn_attribute)) { |
| attr.addAttribute(null, dn_attribute, dn_attribute, "CDATA", searchbase); |
| } |
| transformer.start(row_element, attr); |
| } |
| if (attrs != null) { |
| NamingEnumeration ae = attrs.getAll(); |
| while (ae.hasMoreElements()) { |
| Attribute at = (Attribute) ae.next(); |
| Enumeration vals = at.getAll(); |
| String attrID = at.getID(); |
| while (vals.hasMoreElements()) { |
| if (showAttribute) { |
| transformer.start(attrID, attr); |
| } |
| String attrVal = recodeFromLDAPEncoding((String)vals.nextElement()); |
| |
| if (query_index > 0) { |
| switch (transformer.getQuery(query_index - 1).current_state) { |
| case LDAPTransformer.STATE_INSIDE_FILTER_ELEMENT : |
| StringBuffer temp = new StringBuffer(transformer.getQuery(query_index - 1).filter); |
| if (temp.length() > 0) { |
| temp.append(", "); |
| } |
| temp.append(attrID).append("=").append(attrVal); |
| transformer.getQuery(query_index - 1).filter = temp.toString(); |
| break; |
| default : |
| transformer.start(attrID, attr); |
| } |
| } else { |
| transformer.data(String.valueOf(attrVal)); |
| } |
| if (showAttribute) { |
| transformer.end(attrID); |
| } |
| } |
| } |
| } |
| if (!row_element.equals("")) { |
| transformer.end(row_element); |
| } |
| if (!doc_element.equals("")) { |
| transformer.end(doc_element); |
| } |
| } |
| } catch (Exception e) { |
| if (sax_error) { |
| throw new Exception("[LDAPTransformer] Error in LDAP-Query: " + e.toString()); |
| } else { |
| transformer.start(error_element, attr); |
| transformer.data("[LDAPTransformer] Error in LDAP-Query: " + e); |
| transformer.end(error_element); |
| transformer.getTheLogger().error("[LDAPTransformer] Exception: " + e.toString()); |
| } |
| } |
| break; |
| case LDAPTransformer.STATE_INSIDE_EXECUTE_INCREMENT : |
| try { |
| initConstraints(constraints); |
| if (attrList.length != 1) { |
| transformer.start(error_element, attr); |
| transformer.data("Increment must reference exactly 1 attribute."); |
| transformer.end(error_element); |
| } else { |
| constraints.setReturningAttributes(attrList); |
| NamingEnumeration ldapresults = ctx.search(searchbase, filter, constraints); |
| int attrVal = 0; |
| String attrID = ""; |
| SearchResult si = null; |
| while (ldapresults != null && ldapresults.hasMore()) { |
| si = (SearchResult) ldapresults.next(); |
| javax.naming.directory.Attributes attrs = si.getAttributes(); |
| if (attrs != null) { |
| NamingEnumeration ae = attrs.getAll(); |
| while (ae.hasMoreElements()) { |
| Attribute at = (Attribute) ae.next(); |
| Enumeration vals = at.getAll(); |
| attrID = at.getID(); |
| attrVal = Integer.parseInt((String) vals.nextElement()); |
| } |
| } |
| } |
| ++attrVal; |
| // Specify the changes to make |
| ModificationItem[] mods = new ModificationItem[1]; |
| // Replace the "mail" attribute with a new value |
| mods[0] = |
| new ModificationItem( |
| DirContext.REPLACE_ATTRIBUTE, |
| new BasicAttribute(attrID, Integer.toString(attrVal))); |
| // Perform the requested modifications on the named object |
| ctx.modifyAttributes( |
| new StringBuffer(si.toString().substring(0, si.toString().indexOf(":"))) |
| .append(",") |
| .append(searchbase) |
| .toString(), |
| mods); |
| } |
| } catch (Exception e) { |
| if (sax_error) { |
| throw new Exception("[LDAPTransformer] Error incrementing an attribute: " + e.toString()); |
| } else { |
| transformer.start(error_element, attr); |
| transformer.data("[LDAPTransformer] Error incrementing an attribute: " + e.toString()); |
| transformer.end(error_element); |
| transformer.getTheLogger().error("[LDAPTransformer] Error incrementing an attribute: " + e.toString()); |
| } |
| } |
| break; |
| /* execute modes */ |
| case LDAPTransformer.STATE_INSIDE_EXECUTE_REPLACE : |
| try { |
| String[] attrVal = new String[attrVale.size()]; |
| String[] attrMode = new String[attrModeVal.size()]; |
| String replaceMode = REPLACE_MODE_DEFAULT; |
| attrVale.toArray(attrVal); |
| attrVale.clear(); |
| attrModeVal.toArray(attrMode); |
| attrModeVal.clear(); |
| |
| if (attrVal.length != attrList.length) { |
| transformer.start(error_element, attr); |
| transformer.data("Attribute values must have the some number as a names"); |
| transformer.end(error_element); |
| break; |
| } |
| HashMap attrMap = new HashMap(attrVal.length); |
| HashMap attrModeMap = new HashMap(attrMode.length); |
| |
| for (int i = 0; i < attrVal.length; i++) { |
| attrMap.put(attrList[i], attrVal[i]); |
| attrModeMap.put(attrList[i], attrMode[i]); |
| } |
| |
| initConstraints(constraints); |
| if (attrList.length < 1) { |
| transformer.start(error_element, attr); |
| transformer.data("Modify must reference 1 or more attribute."); |
| transformer.end(error_element); |
| } else { |
| if (!filter.equals("")) { |
| constraints.setReturningAttributes(attrList); |
| NamingEnumeration ldapresults = ctx.search(searchbase, filter, constraints); |
| SearchResult si = null; |
| /* start indicate element of executing query */ |
| if (!exec_element.equals("")) { |
| transformer.start(exec_element, attr); |
| } |
| while (ldapresults != null && ldapresults.hasMore()) { |
| if (!row_element.equals("")) { |
| transformer.start(row_element, attr); |
| } |
| |
| si = (SearchResult) ldapresults.next(); |
| javax.naming.directory.Attributes attrs = si.getAttributes(); |
| if (attrs != null) { |
| NamingEnumeration ae = attrs.getAll(); |
| while (ae.hasMoreElements()) { |
| Attribute at = (Attribute) ae.next(); |
| Enumeration vals = at.getAll(); |
| String attrID = at.getID(); |
| ModificationItem[] mods = new ModificationItem[1]; |
| replaceMode = (String) attrModeMap.get(attrID); |
| |
| String attrValue = recodeFromLDAPEncoding((String) vals.nextElement()); |
| String newAttrValue = ""; |
| /* Check the replacing method */ |
| if (replaceMode.equals(REPLACE_MODE_DEFAULT)) { |
| newAttrValue = (String)attrMap.get(attrID); |
| } else if (replaceMode.equals(REPLACE_MODE_APPEND)) { |
| newAttrValue = attrValue + (String) attrMap.get(attrID); |
| } |
| newAttrValue = recodeToLDAPEncoding(newAttrValue); |
| |
| mods[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, |
| new BasicAttribute(attrID,newAttrValue)); |
| |
| // Perform the requested modifications on the named object |
| ctx.modifyAttributes( |
| si.toString().substring(0, si.toString().indexOf(":")) + "," + searchbase, |
| mods); |
| |
| /* confirm of success */ |
| transformer.start(attrID, attr); |
| transformer.data("replaced"); |
| transformer.end(attrID); |
| } |
| } |
| |
| if (!row_element.equals("")) { |
| transformer.end(row_element); |
| } |
| |
| } |
| if (!exec_element.equals("")) { |
| transformer.end(exec_element); |
| } |
| } else { |
| //filter is not present |
| javax.naming.directory.Attributes attrs = ctx.getAttributes(searchbase, attrList); |
| /* start indicate element of executing query */ |
| if (!exec_element.equals("")) { |
| transformer.start(exec_element, attr); |
| } |
| if (!row_element.equals("")) { |
| transformer.start(row_element, attr); |
| } |
| if (attrs != null) { |
| NamingEnumeration ae = attrs.getAll(); |
| while (ae.hasMoreElements()) { |
| Attribute at = (Attribute) ae.next(); |
| Enumeration vals = at.getAll(); |
| String attrID = at.getID(); |
| ModificationItem[] mods = new ModificationItem[1]; |
| replaceMode = (String) attrModeMap.get(attrID); |
| |
| String attrValue = recodeFromLDAPEncoding((String) vals.nextElement()); |
| |
| String newAttrValue = ""; |
| /* Check the replacing method */ |
| if (replaceMode.equals(REPLACE_MODE_DEFAULT)) { |
| newAttrValue = (String) attrMap.get(attrID); |
| } else if (replaceMode.equals(REPLACE_MODE_APPEND)) { |
| newAttrValue = attrValue + (String) attrMap.get(attrID); |
| } |
| newAttrValue = recodeToLDAPEncoding(newAttrValue); |
| |
| mods[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, |
| new BasicAttribute(attrID, newAttrValue)); |
| |
| // Perform the requested modifications on the named object |
| ctx.modifyAttributes(searchbase, mods); |
| |
| /* confirm of success */ |
| transformer.start(attrID, attr); |
| transformer.data("replaced"); |
| transformer.end(attrID); |
| } |
| } |
| |
| if (!row_element.equals("")) { |
| transformer.end(row_element); |
| } |
| |
| /* end indicate element of executing query */ |
| if (!exec_element.equals("")) { |
| transformer.end(exec_element); |
| } |
| } |
| } |
| |
| } catch (Exception e) { |
| if (sax_error) { |
| throw new Exception("[LDAPTransformer] Error replacing an attribute: " + e.toString()); |
| } else { |
| transformer.start(error_element, attr); |
| transformer.data("[LDAPTransformer] Error replacing an attribute: " + e.toString()); |
| transformer.end(error_element); |
| transformer.getTheLogger().error("[LDAPTransformer] Error replacing an attribute: " + e.toString()); |
| if (!row_element.equals("")) { |
| transformer.end(row_element); |
| } |
| if (!exec_element.equals("")) { |
| transformer.end(exec_element); |
| } |
| } |
| } |
| break; |
| case LDAPTransformer.STATE_INSIDE_EXECUTE_ADD : |
| try { |
| String[] attrVal = new String[attrVale.size()]; |
| attrVale.toArray(attrVal); |
| attrVale.clear(); |
| if (attrVal.length != attrList.length) { |
| transformer.start(error_element, attr); |
| transformer.data("Attribute values must have the some number as a names"); |
| transformer.end(error_element); |
| break; |
| } |
| HashMap attrMap = new HashMap(attrVal.length); |
| |
| for (int i = 0; i < attrVal.length; i++) |
| attrMap.put(attrList[i], attrVal[i]); |
| |
| initConstraints(constraints); |
| if (attrList.length < 1) { |
| transformer.start(error_element, attr); |
| transformer.data("Modify must reference 1 or more attribute."); |
| transformer.end(error_element); |
| } else { |
| if (!filter.equals("")) { |
| constraints.setReturningAttributes(attrList); |
| NamingEnumeration ldapresults = ctx.search(searchbase, filter, constraints); |
| SearchResult si = null; |
| /* start indicate element of executing query */ |
| if (!exec_element.equals("")) { |
| transformer.start(exec_element, attr); |
| } |
| while (ldapresults != null && ldapresults.hasMore()) { |
| if (!row_element.equals("")) { |
| transformer.start(row_element, attr); |
| } |
| |
| si = (SearchResult) ldapresults.next(); |
| javax.naming.directory.Attributes attrs = si.getAttributes(); |
| if (attrs != null) { |
| /* Replace the attribute if attribute already exist */ |
| NamingEnumeration ae = attrs.getAll(); |
| while (ae.hasMoreElements()) { |
| Attribute at = (Attribute) ae.next(); |
| String attrID = at.getID(); |
| // Specify the changes to make |
| ModificationItem[] mods = new ModificationItem[1]; |
| |
| String attrValue = recodeToLDAPEncoding((String)attrMap.get(attrID)); |
| mods[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, |
| new BasicAttribute(attrID, attrValue)); |
| // Perform the requested modifications on the named object |
| ctx.modifyAttributes( |
| new StringBuffer(si.toString().substring(0, si.toString().indexOf(":"))) |
| .append(",") |
| .append(searchbase) |
| .toString(), |
| mods); |
| |
| /* confirm of success */ |
| transformer.start(attrID, attr); |
| transformer.data("replaced"); |
| transformer.end(attrID); |
| /* Remove the attribute from map after replacing */ |
| attrMap.remove(attrID); |
| } |
| } |
| /* Add the attributes */ |
| if (!attrMap.isEmpty()) { |
| ModificationItem[] mods = new ModificationItem[1]; |
| for (int i = 0; i < attrList.length; i++) { |
| if (attrMap.containsKey(attrList[i])) { |
| String attrValue = recodeToLDAPEncoding((String)attrMap.get(attrList[i])); |
| mods[0] = new ModificationItem(DirContext.ADD_ATTRIBUTE, |
| new BasicAttribute(attrList[i], attrValue)); |
| // Perform the requested modifications on the named object |
| ctx.modifyAttributes( |
| new StringBuffer(si.toString().substring(0, si.toString().indexOf(":"))) |
| .append(",") |
| .append(searchbase) |
| .toString(), |
| mods); |
| |
| /* confirm of success */ |
| transformer.start(attrList[i], attr); |
| transformer.data("add"); |
| transformer.end(attrList[i]); |
| } |
| } |
| } |
| if (!row_element.equals("")) { |
| transformer.end(row_element); |
| } |
| } |
| if (!exec_element.equals("")) { |
| transformer.end(exec_element); |
| } |
| } else { |
| //filter is not present |
| javax.naming.directory.Attributes attrs = ctx.getAttributes(searchbase, attrList); |
| /* start indicate element of executing query */ |
| if (!exec_element.equals("")) { |
| transformer.start(exec_element, attr); |
| } |
| if (!row_element.equals("")) { |
| transformer.start(row_element, attr); |
| } |
| |
| if (attrs != null) { |
| NamingEnumeration ae = attrs.getAll(); |
| while (ae.hasMoreElements()) { |
| Attribute at = (Attribute) ae.next(); |
| String attrID = at.getID(); |
| // Specify the changes to make |
| ModificationItem[] mods = new ModificationItem[1]; |
| |
| String attrValue = recodeToLDAPEncoding((String)attrMap.get(attrID)); |
| mods[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, |
| new BasicAttribute(attrID, attrValue)); |
| // Perform the requested modifications on the named object |
| ctx.modifyAttributes(searchbase, mods); |
| |
| /* confirm of success */ |
| transformer.start(attrID, attr); |
| transformer.data("replaced"); |
| transformer.end(attrID); |
| /* Remove the attribute from map after replacing */ |
| attrMap.remove(attrID); |
| } |
| } |
| /* Add the attributes */ |
| if (!attrMap.isEmpty()) { |
| ModificationItem[] mods = new ModificationItem[1]; |
| for (int i = 0; i < attrList.length; i++) { |
| if (attrMap.containsKey(attrList[i])) { |
| String attrValue = recodeToLDAPEncoding((String)attrMap.get(attrList[i])); |
| mods[0] = new ModificationItem(DirContext.ADD_ATTRIBUTE, |
| new BasicAttribute(attrList[i], attrValue)); |
| // Perform the requested modifications on the named object |
| ctx.modifyAttributes(searchbase, mods); |
| /* confirm of success */ |
| transformer.start(attrList[i], attr); |
| transformer.data("add"); |
| transformer.end(attrList[i]); |
| } |
| } |
| } |
| if (!row_element.equals("")) { |
| transformer.end(row_element); |
| } |
| /* end indicate element of executing query */ |
| if (!exec_element.equals("")) { |
| transformer.end(exec_element); |
| } |
| } |
| } |
| } catch (Exception e) { |
| if (sax_error) { |
| throw new Exception("[LDAPTransformer] Error replacing an attribute: " + e.toString()); |
| } else { |
| transformer.start(error_element, attr); |
| transformer.data("[LDAPTransformer] Error replacing an attribute: " + e.toString()); |
| transformer.end(error_element); |
| transformer.getTheLogger().error("[LDAPTransformer] Error replacing an attribute: " + e.toString()); |
| if (!row_element.equals("")) { |
| transformer.end(row_element); |
| } |
| if (!exec_element.equals("")) { |
| transformer.end(exec_element); |
| } |
| } |
| } |
| break; |
| default : |
| } //end switch |
| } catch (NamingException e) { |
| if (sax_error) { |
| throw new NamingException("[LDAPTransformer] Failed ldap-connection to directory service: " + e.toString()); |
| } else { |
| transformer.start(error_element, attr); |
| transformer.data("[LDAPTransformer] Failed ldap-connection to directory service."); |
| transformer.end(error_element); |
| transformer.getTheLogger().error("[LDAPTransformer] Failed to connect to " + serverurl + e.toString()); |
| } |
| } |
| try { |
| disconnect(); |
| } catch (NamingException e) { |
| if (sax_error) { |
| throw new NamingException("[LDAPTransformer] Failed ldap-disconnection from directory service: " + e.toString()); |
| } else { |
| transformer.start(error_element, attr); |
| transformer.data("[LDAPTransformer] Failed ldap-disconnection to directory service."); |
| transformer.end(error_element); |
| transformer.getTheLogger().error("[LDAPTransformer] Failed to disconnect from " + serverurl + e.toString()); |
| } |
| } |
| } |
| |
| protected void addAttrList(String attr) { |
| attrListe.add(attr); |
| } |
| |
| protected void addAttrModeVal(String mode) { |
| attrModeVal.add(mode); |
| } |
| |
| protected void addAttrVal(String val) { |
| attrVale.add(val); |
| } |
| |
| protected void addInitialContextValue(String name, String value) |
| { |
| initialContextValues.put(name, value); |
| } |
| |
| protected void connect() throws NamingException { |
| if (root_dn != null && password != null) { |
| env.put(Context.SECURITY_AUTHENTICATION, authentication); |
| env.put(Context.SECURITY_PRINCIPAL, root_dn); |
| env.put(Context.SECURITY_CREDENTIALS, password); |
| } |
| |
| env.put("java.naming.ldap.version", version); |
| env.put(Context.INITIAL_CONTEXT_FACTORY, initializer); |
| env.put(Context.PROVIDER_URL, serverurl + ":" + port); |
| |
| // Override existing properties or add new properties with values from initial-context |
| env.putAll(initialContextValues); |
| |
| try { |
| ctx = new InitialDirContext(env); |
| } catch (NamingException e) { |
| env.clear(); |
| throw new NamingException(e.toString()); |
| } |
| } |
| |
| protected void disconnect() throws NamingException { |
| try { |
| if (ctx != null) |
| ctx.close(); |
| } catch (NamingException e) { |
| ctx = null; |
| env.clear(); |
| throw new NamingException(e.toString()); |
| } |
| ctx = null; |
| env.clear(); |
| } |
| |
| protected void debugPrint() { |
| Logger logger = transformer.getTheLogger(); |
| if (logger.isDebugEnabled()) { |
| logger.debug("[LDAPTransformer] query_index: " + query_index); |
| logger.debug("[LDAPTransformer] current_state: " + current_state); |
| logger.debug("[LDAPTransformer] serverurl: " + serverurl); |
| logger.debug("[LDAPTransformer] port: " + port); |
| logger.debug("[LDAPTransformer] root_dn: " + root_dn); |
| logger.debug("[LDAPTransformer] password: " + password); |
| logger.debug("[LDAPTransformer] version: " + version); |
| logger.debug("[LDAPTransformer] scope: " + scope); |
| logger.debug("[LDAPTransformer] authentication: " + authentication); |
| logger.debug("[LDAPTransformer] toDo: " + toDo); |
| logger.debug("[LDAPTransformer] searchbase: " + searchbase); |
| logger.debug("[LDAPTransformer] showAttribute: " + showAttribute); |
| logger.debug("[LDAPTransformer] attribute: " + attrListe.toString()); |
| logger.debug("[LDAPTransformer] initial-context: " + initialContextValues); |
| logger.debug("[LDAPTransformer] filter: " + filter); |
| logger.debug("[LDAPTransformer] doc_element: " + doc_element); |
| logger.debug("[LDAPTransformer] row_element: " + row_element); |
| logger.debug("[LDAPTransformer] error_element: " + error_element); |
| logger.debug("[LDAPTransformer] sax-error: " + sax_error); |
| logger.debug("[LDAPTransformer] deref_link: " + deref_link); |
| logger.debug("[LDAPTransformer] count_limit: " + count_limit); |
| logger.debug("[LDAPTransformer] time_limit: " + time_limit); |
| } |
| } |
| |
| /** |
| * Recodes a String value from {@link #LDAP_ENCODING} to specified {@link #encoding}. |
| * @param value the String to recode |
| * @return the recoded String |
| * @throws UnsupportedEncodingException if either the used encoding |
| */ |
| private String recodeFromLDAPEncoding(String value) throws UnsupportedEncodingException { |
| if (!LDAP_ENCODING.equals(encoding)) { |
| value = new String(value.getBytes(LDAP_ENCODING), encoding); |
| } |
| return value; |
| } |
| |
| /** |
| * Recodes a String value from specified {@link #encoding} to {@link #LDAP_ENCODING}. |
| * @param value the String to recode |
| * @return the recoded String |
| * @throws UnsupportedEncodingException if either the used encoding |
| */ |
| private String recodeToLDAPEncoding(String value) throws UnsupportedEncodingException { |
| if (!LDAP_ENCODING.equals(encoding)) { |
| value = new String(value.getBytes(encoding), LDAP_ENCODING); |
| } |
| return value; |
| } |
| } |
| } |
