Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright 2011 Tirasa. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License. You can obtain
  * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
  * or glassfish/bootstrap/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
  * Sun designates this particular file as subject to the "Classpath" exception
  * as provided by Sun in the GPL Version 2 section of the License file that
  * accompanied this code.  If applicable, add the following below the License
  * Header, with the fields enclosed by brackets [] replaced by your own
  * identifying information: "Portions Copyrighted [year]
  * [name of copyright owner]"
  */
 package org.connid.ad.search;
 
 import static org.connid.ad.ADConnector.*;
 
 import static java.util.Collections.singletonList;
 import static org.identityconnectors.common.CollectionUtil.newCaseInsensitiveSet;
 import static org.identityconnectors.common.CollectionUtil.newSet;
 import static org.identityconnectors.common.StringUtil.isBlank;
 
 import  com.sun.jndi.ldap.ctl.VirtualListViewControl;
 import java.util.List;
 import java.util.Set;
 
 public class ADSearch {
 
     private final LdapConnection conn;
 
     private final ObjectClass oclass;
 
     private final LdapFilter filter;
 
     private final OperationOptions options;
 
     private final String[] baseDNs;
 
     private static final Log LOG = Log.getLog(ADSearch.class);
 
     public ADSearch(
             final LdapConnection conn,
             final ObjectClass oclass,
             final LdapFilter filter,
             final OperationOptions options,
             final String[] baseDNs) {
 
         this. = conn;
         this. = oclass;
         this. = filter;
         this. = options;
         this. = baseDNs;
     }
 
     public ADSearch(
             final LdapConnection conn,
             final ObjectClass oclass,
             final LdapFilter filter,
             final OperationOptions options) {
 
         this(connoclassfilteroptions,
                 conn.getConfiguration().getBaseContexts());
    }
    public final void executeADQuery(final ResultsHandler handler) {
        final String[] attrsToGetOption = .getAttributesToGet();
        final Set<StringattrsToGet = getAttributesToGet(attrsToGetOption);
        LdapInternalSearch search = getInternalSearch(attrsToGet);
        final ADUtilities utils = new ADUtilities((ADConnection);
        search.execute(new SearchResultsHandler() {
            @Override
            public boolean handle(String baseDNSearchResult result)
                    throws NamingException {
                return handler.handle(utils.createConnectorObject(
                        result.getNameInNamespace(),
                        result.getAttributes(),
                        ));
            }
        });
    }
    private Set<StringgetAttributesToGet(String[] attributesToGet) {
        Set<Stringresult;
        if (attributesToGet != null) {
            result = CollectionUtil.newCaseInsensitiveSet();
            result.addAll(Arrays.asList(attributesToGet));
            removeNonReadableAttributes(result);
            result.add(.);
        } else {
            // This should include Name.NAME.
            result = getAttributesReturnedByDefault();
        }
        // Uid is required to build a ConnectorObject.
        result.add(.);
        // AD specific, for checking wether a user is enabled or not
        result.add();
        // Our password is marked as readable because of sync().
        // We really can't return it from search.
        if (result.contains(.)) {
            .warn("Reading passwords not supported");
        }
        return result;
    }
    private LdapInternalSearch getInternalSearch(Set<StringattrsToGet) {
        // This is a bit tricky. If the LdapFilter has an entry DN,
        // we only need to look at that entry and check whether it matches
        // the native filter. Moreover, when looking at the entry DN
        // we must not throw exceptions if the entry DN does not exist or is
        // not valid -- just as no exceptions are thrown when the native
        // filter doesn't return any values.
        //
        // In the simple case when the LdapFilter has no entryDN, we
        // will just search over our base DNs looking for entries
        // matching the native filter.
        LdapSearchStrategy strategy;
        List<Stringdns;
        int searchScope;
        String filterEntryDN =  != null ? .getEntryDN() : null;
        if (filterEntryDN != null) {
            // Would be good to check that filterEntryDN is under the configured 
            // base contexts. However, the adapter is likely to pass entries
            // outside the base contexts, so not checking in order to be on the
            // safe side.
            strategy = new ADDefaultSearchStrategy(true);
            dns = singletonList(filterEntryDN);
            searchScope = .;
        } else {
            strategy = getSearchStrategy();
            dns = getBaseDNs();
            searchScope = getLdapSearchScope();
        }
        SearchControls controls =
                LdapInternalSearch.createDefaultSearchControls();
        Set<StringldapAttrsToGet = getLdapAttributesToGet(attrsToGet);
        controls.setReturningAttributes(
                ldapAttrsToGet.toArray(new String[ldapAttrsToGet.size()]));
        controls.setSearchScope(searchScope);
        String optionsFilter = LdapConstants.getSearchFilter();
        String userFilter = null;
        if (.equals(.)) {
            userFilter = .getConfiguration().getAccountSearchFilter();
        }
        String nativeFilter =  != null ? .getNativeFilter() : null;
        return new LdapInternalSearch(
                ,
                getSearchFilter(optionsFilternativeFilteruserFilter),
                dns,
                strategy,
                controls);
    }
    private String getSearchFilter(String... optionalFilters) {
        StringBuilder builder = new StringBuilder();
        String ocFilter = getObjectClassFilter();
        int nonBlank = isBlank(ocFilter) ? 0 : 1;
        for (String optionalFilter : optionalFilters) {
            nonBlank += (isBlank(optionalFilter) ? 0 : 1);
        }
        if (nonBlank > 1) {
            builder.append("(&");
        }
        appendFilter(ocFilterbuilder);
        for (String optionalFilter : optionalFilters) {
            appendFilter(optionalFilterbuilder);
        }
        if (nonBlank > 1) {
            builder.append(')');
        }
        return builder.toString();
    }
        LdapSearchStrategy strategy;
        if (..equals()) {
            // Only consider paged strategies for accounts,
            // just as the adapter does.
            boolean useBlocks = .getConfiguration().isUseBlocks();
            boolean usePagedResultsControl =
                    .getConfiguration().isUsePagedResultControl();
            int pageSize = .getConfiguration().getBlockSize();
            if (useBlocks && !usePagedResultsControl
                    && .supportsControl(VirtualListViewControl.OID)) {
                String vlvSortAttr =
                        .getConfiguration().getVlvSortAttribute();
                strategy = new ADVlvIndexSearchStrategy(vlvSortAttrpageSize);
            } else if (useBlocks
                    && .supportsControl(.)) {
                strategy = new ADSimplePagedSearchStrategy(pageSize);
            } else {
                strategy = new ADDefaultSearchStrategy(false);
            }
        } else {
            strategy = new ADDefaultSearchStrategy(false);
        }
        return strategy;
    }
    private static void appendFilter(String filterStringBuilder toBuilder) {
        if (!isBlank(filter)) {
            String trimmedUserFilter = filter.trim();
            boolean enclose = filter.charAt(0) != '(';
            if (enclose) {
                toBuilder.append('(');
            }
            toBuilder.append(trimmedUserFilter);
            if (enclose) {
                toBuilder.append(')');
            }
        }
    }
    private void removeNonReadableAttributes(Set<Stringattributes) {
        // Since the groups attributes are fake attributes, we don't want to
        // send them to LdapSchemaMapping. This, for example, avoid an 
        // (unlikely) conflict with a custom attribute defined in the server
        // schema.
        boolean ldapGroups =
                attributes.remove(.);
        boolean posixGroups =
                attributes.remove(.);
        if (ldapGroups) {
            attributes.add(.);
        }
        if (posixGroups) {
            attributes.add(.);
        }
    }
    private List<StringgetBaseDNs() {
        List<Stringresult;
        QualifiedUid container = .getContainer();
        if (container != null) {
            result = singletonList(LdapSearches.findEntryDN(
                    container.getObjectClass(), container.getUid()));
        } else {
            result = Arrays.asList();
        }
        assert result != null;
        return result;
    }
    private String getObjectClassFilter() {
        StringBuilder builder = new StringBuilder();
        List<StringldapClasses =
                .getSchemaMapping().getLdapClasses();
        boolean and = ldapClasses.size() > 1;
        if (and) {
            builder.append("(&");
        }
        for (String ldapClass : ldapClasses) {
            builder.append("(objectClass=");
            builder.append(ldapClass);
            builder.append(')');
        }
        if (and) {
            builder.append(')');
        }
        return builder.toString();
    }
    private int getLdapSearchScope() {
        String scope = .getScope();
        if (..equals(scope)) {
            return .;
        } else if (..equals(scope)) {
            return .;
        } else if (..equals(scope)
                || scope == null) {
            return .;
        } else {
            throw new IllegalArgumentException("Invalid search scope " + scope);
        }
    }
    private Set<StringgetLdapAttributesToGet(Set<StringattrsToGet) {
        Set<StringcleanAttrsToGet = newCaseInsensitiveSet();
        cleanAttrsToGet.addAll(attrsToGet);
        cleanAttrsToGet.remove(.);
        boolean posixGroups =
                cleanAttrsToGet.remove(.);
        Set<Stringresult = .getSchemaMapping().getLdapAttributes(
                cleanAttrsToGettrue);
        if (posixGroups) {
            result.add(GroupHelper.getPosixRefAttribute());
        }
        // For compatibility with the adapter, we do not ask the server for DN
        // attributes, such as entryDN; we compute them ourselves. Some servers
        // might not support such attributes anyway.
        result.removeAll(.);
        return result;
    }
    public static Set<StringgetAttributesReturnedByDefault(
            final LdapConnection connfinal ObjectClass oclass) {
        if (oclass.equals(.)) {
            return newSet(.);
        }
        Set<Stringresult = newCaseInsensitiveSet();
        ObjectClassInfo oci = conn.getSchemaMapping().schema().
                findObjectClassInfo(oclass.getObjectClassValue());
        if (oci != null) {
            for (AttributeInfo info : oci.getAttributeInfo()) {
                if (info.isReturnedByDefault()) {
                    result.add(info.getName());
                }
            }
        }
        return result;
    }
New to GrepCode? Check out our FAQ X