feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/com/sun/jndi/ldap/LdapSearchEnumeration.java

@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.sun.jndi.ldap;
+
+import java.security.AccessControlContext;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.util.Vector;
+import javax.naming.*;
+import javax.naming.directory.*;
+import javax.naming.spi.*;
+import javax.naming.ldap.*;
+import javax.naming.ldap.LdapName;
+
+import com.sun.jndi.toolkit.ctx.Continuation;
+
+final class LdapSearchEnumeration
+        extends AbstractLdapNamingEnumeration<SearchResult> {
+
+    private Name startName;             // prefix of names of search results
+    private LdapCtx.SearchArgs searchArgs = null;
+
+    private final AccessControlContext acc = AccessController.getContext();
+
+    LdapSearchEnumeration(LdapCtx homeCtx, LdapResult search_results,
+        String starter, LdapCtx.SearchArgs args, Continuation cont)
+        throws NamingException {
+
+        super(homeCtx, search_results,
+              args.name, /* listArg */
+              cont);
+
+        // fully qualified name of starting context of search
+        startName = new LdapName(starter);
+        searchArgs = args;
+    }
+
+    @Override
+    protected SearchResult createItem(String dn, Attributes attrs,
+                                      Vector<Control> respCtls)
+            throws NamingException {
+
+        Object obj = null;
+
+        String relStart;         // name relative to starting search context
+        String relHome;          // name relative to homeCtx.currentDN
+        boolean relative = true; // whether relative to currentDN
+
+        // need to strip off all but lowest component of dn
+        // so that is relative to current context (currentDN)
+
+        try {
+            Name parsed = new LdapName(dn);
+            // System.err.println("dn string: " + dn);
+            // System.err.println("dn name: " + parsed);
+
+            if (startName != null && parsed.startsWith(startName)) {
+                relStart = parsed.getSuffix(startName.size()).toString();
+                relHome = parsed.getSuffix(homeCtx.currentParsedDN.size()).toString();
+            } else {
+                relative = false;
+                relHome = relStart =
+                    LdapURL.toUrlString(homeCtx.hostname, homeCtx.port_number,
+                    dn, homeCtx.hasLdapsScheme);
+            }
+        } catch (NamingException e) {
+            // could not parse name
+            relative = false;
+            relHome = relStart =
+                LdapURL.toUrlString(homeCtx.hostname, homeCtx.port_number,
+                dn, homeCtx.hasLdapsScheme);
+        }
+
+        // Name relative to search context
+        CompositeName cn = new CompositeName();
+        if (!relStart.equals("")) {
+            cn.add(relStart);
+        }
+
+        // Name relative to homeCtx
+        CompositeName rcn = new CompositeName();
+        if (!relHome.equals("")) {
+            rcn.add(relHome);
+        }
+        //System.err.println("relStart: " + cn);
+        //System.err.println("relHome: " + rcn);
+
+        // Fix attributes to be able to get schema
+        homeCtx.setParents(attrs, rcn);
+
+        // only generate object when requested
+        if (searchArgs.cons.getReturningObjFlag()) {
+
+            if (attrs.get(Obj.JAVA_ATTRIBUTES[Obj.CLASSNAME]) != null) {
+                // Entry contains Java-object attributes (ser/ref object)
+                // serialized object or object reference
+                try {
+                    obj = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
+                        @Override
+                        public Object run() throws NamingException {
+                            return Obj.decodeObject(attrs);
+                        }
+                    }, acc);
+                } catch (PrivilegedActionException e) {
+                    throw (NamingException)e.getException();
+                }
+            }
+            if (obj == null) {
+                obj = new LdapCtx(homeCtx, dn);
+            }
+
+            // Call getObjectInstance before removing unrequested attributes
+            try {
+                // rcn is either relative to homeCtx or a fully qualified DN
+                obj = DirectoryManager.getObjectInstance(
+                    obj, rcn, (relative ? homeCtx : null),
+                    homeCtx.envprops, attrs);
+            } catch (NamingException e) {
+                throw e;
+            } catch (Exception e) {
+                NamingException ne =
+                    new NamingException(
+                            "problem generating object using object factory");
+                ne.setRootCause(e);
+                throw ne;
+            }
+
+            // remove Java attributes from result, if necessary
+            // Even if CLASSNAME attr not there, there might be some
+            // residual attributes
+
+            String[] reqAttrs;
+            if ((reqAttrs = searchArgs.reqAttrs) != null) {
+                // create an attribute set for those requested
+                Attributes rattrs = new BasicAttributes(true); // caseignore
+                for (int i = 0; i < reqAttrs.length; i++) {
+                    rattrs.put(reqAttrs[i], null);
+                }
+                for (int i = 0; i < Obj.JAVA_ATTRIBUTES.length; i++) {
+                    // Remove Java-object attributes if not requested
+                    if (rattrs.get(Obj.JAVA_ATTRIBUTES[i]) == null) {
+                        attrs.remove(Obj.JAVA_ATTRIBUTES[i]);
+                    }
+                }
+            }
+
+        }
+
+        /*
+         * name in search result is either the stringified composite name
+         * relative to the search context that can be passed directly to
+         * methods of the search context, or the fully qualified DN
+         * which can be used with the initial context.
+         */
+        SearchResult sr;
+        if (respCtls != null) {
+            sr = new SearchResultWithControls(
+                (relative ? cn.toString() : relStart), obj, attrs,
+                relative, homeCtx.convertControls(respCtls));
+        } else {
+            sr = new SearchResult(
+                (relative ? cn.toString() : relStart),
+                obj, attrs, relative);
+        }
+        sr.setNameInNamespace(dn);
+        return sr;
+    }
+
+    @Override
+    public void appendUnprocessedReferrals(LdapReferralException ex) {
+
+        // a referral has been followed so do not create relative names
+        startName = null;
+        super.appendUnprocessedReferrals(ex);
+    }
+
+    @Override
+    protected AbstractLdapNamingEnumeration<? extends NameClassPair> getReferredResults(
+            LdapReferralContext refCtx) throws NamingException {
+        // repeat the original operation at the new context
+        return (AbstractLdapNamingEnumeration<? extends NameClassPair>)refCtx.search(
+                searchArgs.name, searchArgs.filter, searchArgs.cons);
+    }
+
+    @Override
+    protected void update(AbstractLdapNamingEnumeration<? extends NameClassPair> ne) {
+        super.update(ne);
+
+        // Update search-specific variables
+        LdapSearchEnumeration se = (LdapSearchEnumeration)ne;
+        startName = se.startName;
+//VR - keep original args, don't overwite with current args
+//      searchArgs = se.searchArgs;
+    }
+
+    void setStartName(Name nm) {
+        startName = nm;
+    }
+}