import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * Builds a new request.
 *
 * @param filter the filter
 * @return the search request
 */
private SearchRequest newRequest(final SearchFilter filter) {

    final SearchRequest sr = new SearchRequest(this.searchRequest.getBaseDn(), filter);
    sr.setBinaryAttributes(ReturnAttributes.ALL_USER.value());
    sr.setDerefAliases(this.searchRequest.getDerefAliases());
    sr.setSearchEntryHandlers(this.searchRequest.getSearchEntryHandlers());
    sr.setSearchReferenceHandlers(this.searchRequest.getSearchReferenceHandlers());
    sr.setFollowReferrals(this.searchRequest.getFollowReferrals());
    sr.setReturnAttributes(ReturnAttributes.ALL_USER.value());
    sr.setSearchScope(this.searchRequest.getSearchScope());
    sr.setSizeLimit(this.searchRequest.getSizeLimit());
    sr.setSortBehavior(this.searchRequest.getSortBehavior());
    sr.setTimeLimit(this.searchRequest.getTimeLimit());
    sr.setTypesOnly(this.searchRequest.getTypesOnly());
    sr.setControls(this.searchRequest.getControls());
    return sr;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
@Lazy
@Bean
@RefreshScope
public Action ldapSpnegoClientAction() {
    final SpnegoProperties spnegoProperties = casProperties.getAuthn().getSpnego();
    final ConnectionFactory connectionFactory = Beans.newLdaptivePooledConnectionFactory(spnegoProperties.getLdap());
    final SearchFilter filter = Beans.newLdaptiveSearchFilter(spnegoProperties.getLdap().getSearchFilter(),
            "host", Collections.emptyList());

    final SearchRequest searchRequest = Beans.newLdaptiveSearchRequest(spnegoProperties.getLdap().getBaseDn(), filter);
    return new LdapSpnegoKnownClientSystemsFilterAction(spnegoProperties.getIpsToCheckPattern(), 
            spnegoProperties.getAlternativeRemoteHostAttribute(),
            spnegoProperties.getDnsTimeout(), 
            connectionFactory, 
            searchRequest, 
            spnegoProperties.getSpnegoAttributeName());
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
private SearchRequest newRequest(final SearchFilter filter) {
    final SearchRequest sr = new SearchRequest(this.searchRequest.getBaseDn(), filter);
    sr.setBinaryAttributes(this.searchRequest.getBinaryAttributes());
    sr.setDerefAliases(this.searchRequest.getDerefAliases());
    sr.setSearchEntryHandlers(this.searchRequest.getSearchEntryHandlers());
    sr.setSearchReferenceHandlers(this.searchRequest.getSearchReferenceHandlers());
    sr.setFollowReferrals(this.searchRequest.getFollowReferrals());
    sr.setReturnAttributes(this.searchRequest.getReturnAttributes());
    sr.setSearchScope(this.searchRequest.getSearchScope());
    sr.setSizeLimit(this.searchRequest.getSizeLimit());
    sr.setSortBehavior(this.searchRequest.getSortBehavior());
    sr.setTimeLimit(this.searchRequest.getTimeLimit());
    sr.setTypesOnly(this.searchRequest.getTypesOnly());
    sr.setControls(this.searchRequest.getControls());
    return sr;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * Builds a new request.
 *
 * @param filter the filter
 * @return the search request
 */
private SearchRequest newRequest(final SearchFilter filter) {

    final SearchRequest sr = new SearchRequest(this.searchRequest.getBaseDn(), filter);
    sr.setBinaryAttributes(ReturnAttributes.ALL_USER.value());
    sr.setDerefAliases(this.searchRequest.getDerefAliases());
    sr.setSearchEntryHandlers(this.searchRequest.getSearchEntryHandlers());
    sr.setSearchReferenceHandlers(this.searchRequest.getSearchReferenceHandlers());
    sr.setReferralHandler(this.searchRequest.getReferralHandler());
    sr.setReturnAttributes(ReturnAttributes.ALL_USER.value());
    sr.setSearchScope(this.searchRequest.getSearchScope());
    sr.setSizeLimit(this.searchRequest.getSizeLimit());
    sr.setSortBehavior(this.searchRequest.getSortBehavior());
    sr.setTimeLimit(this.searchRequest.getTimeLimit());
    sr.setTypesOnly(this.searchRequest.getTypesOnly());
    sr.setControls(this.searchRequest.getControls());
    return sr;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
@Override
public LdapEntry next() {
  final String dn = dnsIterator.next();
  final SearchRequest request = new SearchRequest();
  request.setBaseDn(dn);
  request.setSearchFilter(usersFilter);
  request.setSearchScope(OBJECT);
  request.setReturnAttributes(returnAttrs);
  request.setSearchEntryHandlers(new ObjectGuidHandler());
  try {
    final Response<SearchResult> response = searchOp.execute(request);
    if (response.getResultCode() != SUCCESS) {
      throw new SyncException(
          format(
              "Couldn't get entry dn '%s', result code is '%s'", dn, response.getResultCode()));
    }
    return response.getResult().getEntry();
  } catch (LdapException x) {
    throw new SyncException(x.getLocalizedMessage(), x);
  }
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * Execute search operation.
 *
 * @param connectionFactory the connection factory
 * @param baseDn            the base dn
 * @param filter            the filter
 * @return the response
 * @throws LdapException the ldap exception
 */
public static Response<SearchResult> executeSearchOperation(final ConnectionFactory connectionFactory,
                                                            final String baseDn,
                                                            final SearchFilter filter)
        throws LdapException {
    try (Connection connection = createConnection(connectionFactory)) {
        final SearchOperation searchOperation = new SearchOperation(connection);
        final SearchRequest request = createSearchRequest(baseDn, filter);
        request.setReferralHandler(new SearchReferralHandler());
        return searchOperation.execute(request);
    }
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * Builds a new request.
 *
 * @param baseDn the base dn
 * @param filter the filter
 * @return the search request
 */
public static SearchRequest createSearchRequest(final String baseDn, final SearchFilter filter) {
    final SearchRequest sr = new SearchRequest(baseDn, filter);
    sr.setBinaryAttributes(ReturnAttributes.ALL_USER.value());
    sr.setReturnAttributes(ReturnAttributes.ALL_USER.value());
    sr.setSearchScope(SearchScope.SUBTREE);
    return sr;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * Instantiates a new action.
 *
 * @param connectionFactory the connection factory
 * @param searchRequest the search request
 * @param spnegoAttributeName the certificate revocation list attribute name
 */
public LdapSpnegoKnownClientSystemsFilterAction(
        @NotNull final ConnectionFactory connectionFactory,
        @NotNull final SearchRequest searchRequest,
        @NotNull final String spnegoAttributeName) {
    this.connectionFactory = connectionFactory;
    this.spnegoAttributeName = spnegoAttributeName;
    this.searchRequest = searchRequest;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected SearchRequest createSearchRequest(final AuthenticationCriteria ac) {
    final SearchRequest sr = new SearchRequest();
    sr.setSearchScope(SearchScope.SUBTREE);
    sr.setBaseDn(this.baseDn);
    sr.setSearchFilter(new SearchFilter(SEARCH_FILTER, new Object[]{ac.getDn()}));
    sr.setSearchEntryHandlers(getSearchEntryHandlers());
    sr.setReturnAttributes(ac.getAuthenticationRequest().getReturnAttributes());
    return sr;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * Creates a search request from a search filter.
 *
 * @param filter LDAP search filter.
 *
 * @return ldaptive search request.
 */
private SearchRequest createRequest(final SearchFilter filter) {
    final SearchRequest request = new SearchRequest();
    request.setBaseDn(this.baseDN);
    request.setSearchFilter(filter);
    request.setReturnAttributes(this.attributes);
    request.setSearchScope(this.searchScope);
    request.setSizeLimit(this.searchControls.getCountLimit());
    request.setTimeLimit(this.searchControls.getTimeLimit());
    return request;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * Execute search operation.
 *
 * @param connection the connection
 * @param filter the filter
 * @return the response
 * @throws LdapException the ldap exception
 */
private Response<SearchResult> executeSearchOperation(final Connection connection, final SearchFilter filter)
        throws LdapException {

    final SearchOperation searchOperation = new SearchOperation(connection);
    final SearchRequest request = newRequest(filter);
    logger.debug("Using search request {}", request.toString());
    return searchOperation.execute(request);
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * Execute search operation.
 *
 * @param connectionFactory the connection factory
 * @param baseDn            the base dn
 * @param filter            the filter
 * @param binaryAttributes  the binary attributes
 * @param returnAttributes  the return attributes
 * @return the response
 * @throws LdapException the ldap exception
 */
public static Response<SearchResult> executeSearchOperation(final ConnectionFactory connectionFactory,
                                                            final String baseDn,
                                                            final SearchFilter filter,
                                                            final String[] binaryAttributes,
                                                            final String[] returnAttributes) throws LdapException {
    try (Connection connection = createConnection(connectionFactory)) {
        final SearchOperation searchOperation = new SearchOperation(connection);
        final SearchRequest request = Beans.newLdaptiveSearchRequest(baseDn, filter, binaryAttributes, returnAttributes);
        request.setReferralHandler(new SearchReferralHandler());
        return searchOperation.execute(request);
    }
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * Builds a new request.
 *
 * @param baseDn           the base dn
 * @param filter           the filter
 * @param binaryAttributes the binary attributes
 * @param returnAttributes the return attributes
 * @return the search request
 */
public static SearchRequest newLdaptiveSearchRequest(final String baseDn,
                                                     final SearchFilter filter,
                                                     final String[] binaryAttributes,
                                                     final String[] returnAttributes) {
    final SearchRequest sr = new SearchRequest(baseDn, filter);
    sr.setBinaryAttributes(binaryAttributes);
    sr.setReturnAttributes(returnAttributes);
    sr.setSearchScope(SearchScope.SUBTREE);
    return sr;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
protected SearchRequest createSearchRequest(final AuthenticationCriteria ac) {
    final SearchRequest sr = new SearchRequest();
    sr.setSearchScope(SearchScope.SUBTREE);
    sr.setBaseDn(this.baseDn);
    sr.setSearchFilter(new SearchFilter(SEARCH_FILTER, new Object[] {ac.getDn()}));
    sr.setSearchEntryHandlers(getSearchEntryHandlers());
    sr.setReturnAttributes(ac.getAuthenticationRequest().getReturnAttributes());
    return sr;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
private Response<SearchResult> executeSearchOperation(final Connection connection, final SearchFilter filter)
        throws LdapException {

    final SearchOperation searchOperation = new SearchOperation(connection);
    final SearchRequest request = newRequest(filter);
    logger.debug("Using search request {}", request.toString());
    return searchOperation.execute(request);
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
@Override
public Iterable<LdapEntry> select(Connection connection) {
  final SearchRequest groupsSearch = new SearchRequest();
  groupsSearch.setBaseDn(baseDn);
  groupsSearch.setSearchFilter(new SearchFilter(groupsFilter));
  groupsSearch.setSearchScope(SUBTREE);
  groupsSearch.setReturnAttributes(membersAttr);
  groupsSearch.setSearchEntryHandlers(new RangeEntryHandler());
  try {
    final Response<SearchResult> response = new SearchOperation(connection).execute(groupsSearch);
    if (response.getResultCode() != SUCCESS) {
      throw new SyncException("Couldn't get groups, result code is " + response.getResultCode());
    }
    return new RequestEachEntryIterable(
        response
            .getResult()
            .getEntries()
            .stream()
            .flatMap(entry -> entry.getAttribute(membersAttr).getStringValues().stream())
            .collect(toSet()),
        connection,
        usersFilter,
        returnAttrs);
  } catch (LdapException x) {
    throw new SyncException(x.getLocalizedMessage(), x);
  }
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
@Override
public Iterable<LdapEntry> select(Connection connection) {
  final SearchRequest req = new SearchRequest();
  req.setBaseDn(baseDn);
  req.setSearchFilter(new SearchFilter(filter));
  req.setReturnAttributes(attributes);
  req.setSearchScope(SearchScope.SUBTREE);
  req.setTimeLimit(Duration.ofMillis(readPageTimeoutMs));
  req.setSearchEntryHandlers(new ObjectGuidHandler());
  return new PagedIterable(new PagedResultsClient(connection, pageSize), req);
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
public void setSearchRequest(@NotNull final SearchRequest request) {
    this.searchRequest = request;
}
 

import org.ldaptive.SearchRequest; //导入依赖的package包/类
/**
 * New blocking connection pool connection pool.
 *
 * @param l the l
 * @return the connection pool
 */
public static ConnectionPool newLdaptiveBlockingConnectionPool(final AbstractLdapProperties l) {
    final DefaultConnectionFactory bindCf = newLdaptiveConnectionFactory(l);
    final PoolConfig pc = newLdaptivePoolConfig(l);
    final BlockingConnectionPool cp = new BlockingConnectionPool(pc, bindCf);

    cp.setBlockWaitTime(newDuration(l.getBlockWaitTime()));
    cp.setPoolConfig(pc);

    final IdlePruneStrategy strategy = new IdlePruneStrategy();
    strategy.setIdleTime(newDuration(l.getIdleTime()));
    strategy.setPrunePeriod(newDuration(l.getPrunePeriod()));

    cp.setPruneStrategy(strategy);

    switch (l.getValidator().getType().trim().toLowerCase()) {
        case "compare":
            final CompareRequest compareRequest = new CompareRequest();
            compareRequest.setDn(l.getValidator().getDn());
            compareRequest.setAttribute(new LdapAttribute(l.getValidator().getAttributeName(),
                    l.getValidator().getAttributeValues().toArray(new String[]{})));
            compareRequest.setReferralHandler(new SearchReferralHandler());
            cp.setValidator(new CompareValidator(compareRequest));
            break;
        case "none":
            LOGGER.debug("No validator is configured for the LDAP connection pool of [{}]", l.getLdapUrl());
            break;
        case "search":
        default:
            final SearchRequest searchRequest = new SearchRequest();
            searchRequest.setBaseDn(l.getValidator().getBaseDn());
            searchRequest.setSearchFilter(new SearchFilter(l.getValidator().getSearchFilter()));
            searchRequest.setReturnAttributes(ReturnAttributes.NONE.value());
            searchRequest.setSearchScope(l.getValidator().getScope());
            searchRequest.setSizeLimit(1L);
            searchRequest.setReferralHandler(new SearchReferralHandler());
            cp.setValidator(new SearchValidator(searchRequest));
            break;
    }

    cp.setFailFastInitialize(l.isFailFast());

    if (StringUtils.isNotBlank(l.getPoolPassivator())) {
        final AbstractLdapProperties.LdapConnectionPoolPassivator pass =
                AbstractLdapProperties.LdapConnectionPoolPassivator.valueOf(l.getPoolPassivator().toUpperCase());
        switch (pass) {
            case CLOSE:
                cp.setPassivator(new ClosePassivator());
                LOGGER.debug("Created [{}] passivator for [{}]", l.getPoolPassivator(), l.getLdapUrl());
                break;
            case BIND:
                if (StringUtils.isNotBlank(l.getBindDn()) && StringUtils.isNoneBlank(l.getBindCredential())) {
                    final BindRequest bindRequest = new BindRequest();
                    bindRequest.setDn(l.getBindDn());
                    bindRequest.setCredential(new Credential(l.getBindCredential()));
                    cp.setPassivator(new BindPassivator(bindRequest));
                    LOGGER.debug("Created [{}] passivator for [{}]", l.getPoolPassivator(), l.getLdapUrl());
                } else {
                    LOGGER.warn("No [{}] passivator could be created for [{}] given bind credentials are not specified",
                            l.getPoolPassivator(), l.getLdapUrl());
                }
                break;
            default:
                break;
        }
    }

    LOGGER.debug("Initializing ldap connection pool for [{}] and bindDn [{}]", l.getLdapUrl(), l.getBindDn());
    cp.initialize();
    return cp;
}