dxops.java

JAVA开源LDAP浏览器jxplorer的源码!

package com.ca.commons.naming;


import com.ca.commons.cbutil.*;
import com.ca.commons.jndi.AdvancedOps;
import com.ca.commons.jndi.ConnectionData;

import javax.naming.*;
import javax.naming.directory.*;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * A wrapper for BasicOps that converts the jndi primative names
 * into com.ca.commons.naming objects...
 */

public class DXOps extends AdvancedOps
{

    private final static Logger log = Logger.getLogger(DXOps.class.getName());

    /**
     * Initialise with the directory context.
     */


    public DXOps(DirContext ctx)
            throws NamingException
    {
        super(ctx);
    }

    public DXOps(ConnectionData cData)
            throws NamingException
    {
        super(cData);
    }


    /**
     * This preparses a name, preparitory to passing to the jndi operation.
     * Usefull to over-ride if a Name needs to be escaped or re-formatted.
     *
     * @param name the pre jndi operation name.
     * @return the version used by the operation.
     */

    public Name preParse(Name name)
    {
        //(assuming jndi doesn't mess with the names it's given, we don't need this...)
        //DN newName = (name instanceof DN)?new DN((DN)name):new DN(name);
        return name;
    }

    /**
     * This postparses a name, after it has been returned from the jndi operation.
     * Usefull to over-ride if the name needs to be unescaped or reformatted.
     *
     * @param name the post jndi operation name.
     * @return the re-formatted version used by the application.
     */

    public Name postParse(Name name)
    {
        return postParse(name.toString());
    }

    /**
     * This postparses a name, after it has been returned from the jndi operation.
     * It assumes that it has got a jndi <i>CompositeName</i> that needs to be
     * converted to a legal ldap dn (i.e. an ldap <i>CompoundName</i>).  If this
     * is *not* the case, there will be trouble...
     *
     * @param name the post jndi operation name.
     * @return the re-formatted version used by the application, as a DN object.
     */
//TODO: figure out if this is needed still.
//TODO: can we avoid the horrible, horrible, horrible JNDI Composite name disaster?
// (Ans: I don't think so; jndi gives us back strings that are composite names, even though
// we are never using federated name spaces.  So we have to warp the whole program to cope with
// them)

    public Name postParse(String name)
    {
        /* EMERGENCY HACK
         * (JNDI apparently does not handle terminating spaces correctly - it
         * retains the escape characters, but trims the actual space, resulting
         * in an illegal ldap dn)
         */
        if (name.charAt(name.length() - 1) == '\\')
        {
            name = NameUtility.checkEndSpaces(name);
        }


        try
        {
            Name cn = new CompositeName(name);
            if (cn.size() == 0)                     // if the name is empty ...
                return new DN();                  // ... just return an empty DN

            return new DN(cn.get(cn.size() - 1));  // get the last element of the composite name, which will be the ldap compound name, and init the DN with that.
        }
        catch (NamingException e)     // should never happen :-) (ROTFL)
        {
            log.log(Level.WARNING, "unexpected error: bad name back from jndi ftn in CBOps.postParse(" + name + ")?", e);
            e.printStackTrace();
            //System.exit(-1);
            return new DN(name);  // bad server response?  return (possibly) corrupt name anyway...
        }
    }

    /**
     * This postparses a name, after it has been returned from the jndi operation.
     * It assumes that it has got a jndi <i>CompositeName</i> that needs to be
     * converted to a legal ldap dn (i.e. an ldap <i>CompoundName</i>).  If this
     * is *not* the case, there will be trouble...
     *
     * @param name the post jndi operation name.
     * @return the re-formatted version used by the application as an ldap String.
     */
    public String postParseString(String name)
    {
        /* EMERGENCY HACK
         * (JNDI apparently does not handle terminating spaces correctly - it
         * retains the escape characters, but trims the actual space, resulting
         * in an illegal ldap dn)
         */

        if (name.length() == 0)
            return name;

        if (name.charAt(name.length() - 1) == '\\')
        {
            name = NameUtility.checkEndSpaces(name);
        }
        if (name.startsWith("ldap://"))
        {
            try
            {
                name = URLDecoder.decode(name, "UTF8");
            }
            catch (UnsupportedEncodingException e)
            {
                log.severe("unexpected error: couldn't URL decode in CBOps.postParseString(" + name + ")?\n" + e.toString());
                e.printStackTrace();
                return name;
            }
        }

        //if (name.indexOf('\\')>0 || name.indexOf('/')>0)
        //    System.out.println("PRE  postParseName: " + name);


        try
        {
            Name cn = new CompositeName(name);    // If it isn't a composite name, this will fail horribly.  But since it's JNDI, and therefore not object oriented, we have no way of telling...
            if (cn.size() == 0)                     // if the name is empty ...
                return "";                  // ... just return an empty DN

            name = cn.get(cn.size() - 1);
            //      if (name.indexOf('\\')>0 || name.indexOf('/')>0)
            //          System.out.println("POST postParseName: " + name);

            return name;  // get the last element of the composite name, which will be the ldap compound name, and init the DN with that.
        }
        catch (NamingException e)     // should never happen :-) (ROTFL)
        {
            log.log(Level.WARNING, "unexpected error: bad name back from jndi ftn in CBOps.postParseString(" + name + ")?", e);
            e.printStackTrace();
            return name;  // bad server response?  return (possibly) corrupt name anyway...
        }

    }


    /**
     * This postparses a namingEnumeration of NameClassPairs, after it has been returned from the jndi operation.
     * It returns a DXNamingEnumeration, and sets all the names to be the complete, full dn, rather than simply
     * the dn relative to the base.
     *
     * @param names the post jndi operation namingEnumeration.
     * @param base  the 'base' dn from which the names in the enumeration (may) be relative.
     *              If the Names in
     *              the enumeration are suffixed by the searchBase, they are unaltered, otherwise the searchBase
     *              is added to the names to give the full DN in the namespace.
     * @return the re-formatted version used by the application.
     */
    public NamingEnumeration postParseNameClassPairs(NamingEnumeration names, Name base)
    {
        log.finer("parsing with base :" + base.toString());
        DXNamingEnumeration dxe = new DXNamingEnumeration();

        String baseString = null;

        if (base != null && base.isEmpty() == false)
            baseString = base.toString();

        try
        {
            while (names.hasMore())
            {
                NameClassPair ncp = (NameClassPair) names.next();

                String rawName = postParseString(ncp.getName()).toString();

                // IMPORTANT!
                // This appends the 'base' DN to the enumerated DNs in order to get absolute DNs...

                if (ncp.isRelative() && baseString != null)
                {
                    if (rawName.length() != 0)
                        rawName = rawName + "," + baseString;
                    else
                        rawName = baseString;
                }

                log.finer("ended up with: '" + rawName + "'");
                ncp.setName(rawName);
                dxe.add(ncp);
            }
        }
        catch (NamingException ex)
        {
            CBUtility.error(CBIntText.get("Search partially failed! - only {0} entries returned", new Integer[]{new Integer(dxe.size())}), ex);
        }

        return dxe;
    }


    /*
     * <p>Takes a NamingEnumeration and converts any names from being
     * relative to the base to being full (i.e. including the base).</p>
     * @param
     * /

    protected NamingEnumeration setFullDNs(NamingEnumeration ne, Name base)
        throws NamingException
    {
System.out.println("setting full dns for " + base);

        DXNamingEnumeration dxne = new DXNamingEnumeration();

        while (ne.hasMore())
        {
            NameClassPair ncp = (NameClassPair)ne.next();


            // IMPORTANT!
            // This appends the 'base' DN to the enumerated DNs in order to get absolute DNs...

            if (ncp.isRelative() && base != null && base.size() > 0)
            {
                String rawName = postParseString(ncp.getName());

System.out.println("modifying: " + rawName + " + " + base);

                if (rawName.length() != 0)
                    rawName = rawName + "," + base.toString();
                else
                    rawName = base.toString();

System.out.println("ended up with: '" + rawName + "'");

                ncp.setName(rawName);  // I *think* this only needs to be done if we're changing stuff...
            }

            dxne.add(ncp);
        }

        return dxne;
    }
*/

    /**
     * overload the corresponding method in JNDIOps so that we can play silly buggers with parsing
     * the stupid composite names that jndi inflicts on us.
     *
     * @param searchbase
     * @param filter
     * @param limit
     * @param timeout
     * @param returnAttributes
     * @return
     * @throws NamingException
     */
    protected NamingEnumeration rawSearchBaseEntry(Name searchbase, String filter, int limit,
                                                   int timeout, String[] returnAttributes)
            throws NamingException
    {
        return postParseNameClassPairs(super.rawSearchBaseEntry(searchbase, filter, limit, timeout, returnAttributes), searchbase);
    }

    /**
     * overload the corresponding method in JNDIOps so that we can play silly buggers with parsing
     * the stupid composite names that jndi inflicts on us.
     *
     * @param searchbase
     * @param filter
     * @param limit
     * @param timeout
     * @param returnAttributes
     * @return
     * @throws NamingException
     */
    protected NamingEnumeration rawSearchOneLevel(Name searchbase, String filter, int limit,
                                                  int timeout, String[] returnAttributes) throws NamingException
    {
        return postParseNameClassPairs(super.rawSearchOneLevel(searchbase, filter, limit, timeout, returnAttributes), searchbase);
    }

    /**
     * overload the corresponding method in JNDIOps so that we can play silly buggers with parsing
     * the stupid composite names that jndi inflicts on us.
     *
     * @param searchbase
     * @param filter
     * @param limit
     * @param timeout
     * @param returnAttributes
     * @return
     * @throws NamingException
     */
    protected NamingEnumeration rawSearchSubTree(Name searchbase, String filter, int limit,
                                                 int timeout, String[] returnAttributes) throws NamingException
    {
        return postParseNameClassPairs(super.rawSearchSubTree(searchbase, filter, limit, timeout, returnAttributes), searchbase);
    }

    /**
     * Update an entry with the designated DN.
     *
     * @param oldEntry the old entry containing the old set of attributes.
     * @param newEntry the new entry containing the replacement set of attributes.
     */

    public void modifyEntry(DXEntry oldEntry, DXEntry newEntry)