import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
@Override
protected void configure() {

  Multibinder<AuthenticationHandler> handlerBinder =
      Multibinder.newSetBinder(
          binder(), com.codenvy.api.dao.authentication.AuthenticationHandler.class);
  handlerBinder.addBinding().to(LdapAuthenticationHandler.class);

  bind(Authenticator.class).toProvider(AuthenticatorProvider.class);
  bind(ConnectionFactory.class).toProvider(LdapConnectionFactoryProvider.class);
  bind(PooledConnectionFactory.class).toProvider(LdapConnectionFactoryProvider.class);

  bind(EntryResolver.class).toProvider(EntryResolverProvider.class);

  bind(DBUserLinker.class).toProvider(DBUserLinkerProvider.class);
  bind(LdapEntrySelector.class).toProvider(LdapEntrySelectorProvider.class);
  bind(LdapSynchronizer.class).asEagerSingleton();
  bind(LdapSynchronizerService.class);
  bind(LdapSynchronizerPermissionsFilter.class);
  bind(DisablePasswordOperationsFilter.class);
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
@Inject
public AuthenticatorProvider(
    PooledConnectionFactory connFactory,
    EntryResolver entryResolver,
    @NotNull @Named(BASE_DN_PROPERTY_NAME) String baseDn,
    @NotNull @Named(AUTH_TYPE_PROPERTY_NAME) String type,
    @Nullable @Named(DN_FORMAT_PROPERTY_NAME) String dnFormat,
    @Nullable @Named(USER_PASSWORD_ATTRIBUTE_PROPERTY_NAME) String userPasswordAttribute,
    @Nullable @Named(USER_FILTER_PROPERTY_NAME) String userFilter,
    @Nullable @Named(ALLOW_MULTIPLE_DNS_PROPERTY_NAME) String allowMultipleDns,
    @Nullable @Named(SUBTREE_SEARCH_PROPERTY_NAME) String subtreeSearch) {
  this.baseDn = baseDn;
  checkRequiredProperty(AUTH_TYPE_PROPERTY_NAME, type);
  this.type = AuthenticationType.valueOf(type);
  this.dnFormat = dnFormat;
  this.userPasswordAttribute = userPasswordAttribute;
  this.userFilter = userFilter;
  this.allowMultipleDns =
      isNullOrEmpty(allowMultipleDns) ? false : Boolean.valueOf(allowMultipleDns);
  this.subtreeSearch = isNullOrEmpty(subtreeSearch) ? false : Boolean.valueOf(subtreeSearch);
  this.authenticator = getAuthenticator(connFactory, entryResolver);
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
/**
 * Close connection pull and shut down the executor.
 */
@PreDestroy
public void destroy() {
    logger.debug("Shutting down connection pools...");
    for (final PooledConnectionFactory factory : connectionPoolMap.values()) {
        factory.getConnectionPool().close();
    }
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
@Autowired
@Bean
public Monitor pooledLdapConnectionFactoryMonitor(@Qualifier("pooledConnectionFactoryMonitorExecutorService") final ExecutorService executor) {
    final MonitorProperties.Ldap ldap = casProperties.getMonitor().getLdap();
    final PooledConnectionFactory connectionFactory = Beans.newLdaptivePooledConnectionFactory(ldap);
    return new PooledLdapConnectionFactoryMonitor(executor, Long.valueOf(ldap.getMaxWait()).intValue(), connectionFactory, new SearchValidator());
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
/**
 * Creates a new instance that monitors the given pooled connection factory.
 *
 * @param executorService the executor service
 * @param maxWait         the max wait
 * @param factory         Connection factory to monitor.
 * @param validator       Validates connections from the factory.
 */
public PooledLdapConnectionFactoryMonitor(final ExecutorService executorService, 
                                          final int maxWait, 
                                          final PooledConnectionFactory factory,
                                          final Validator<Connection> validator) {
    super(PooledLdapConnectionFactoryMonitor.class.getSimpleName(), executorService, maxWait);
    this.connectionFactory = factory;
    this.validator = validator;
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
@Inject
public EntryResolverProvider(
    PooledConnectionFactory connFactory,
    @NotNull @Named("ldap.base_dn") String baseDn,
    @Nullable @Named("ldap.auth.user.filter") String userFilter,
    @Nullable @Named("ldap.auth.subtree_search") String subtreeSearch) {
  this.entryResolver = new PooledSearchEntryResolver();
  this.entryResolver.setBaseDn(baseDn);
  this.entryResolver.setUserFilter(userFilter);
  this.entryResolver.setSubtreeSearch(
      Strings.isNullOrEmpty(subtreeSearch) ? false : Boolean.valueOf(subtreeSearch));
  this.entryResolver.setConnectionFactory(connFactory);
  this.entryResolver.setSearchEntryHandlers(new ObjectGuidHandler());
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
private Authenticator getAuthenticator(
    PooledConnectionFactory connFactory, EntryResolver entryResolver) {
  switch (type) {
    case AD:
      return getActiveDirectoryAuthenticator(connFactory, entryResolver);
    case DIRECT:
      return getDirectBindAuthenticator(connFactory);
    case SASL:
      return getSaslAuthenticator(connFactory);
    case ANONYMOUS:
    case AUTHENTICATED:
    default:
      return getAuthenticatedOrAnonSearchAuthenticator(connFactory, entryResolver);
  }
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
private Authenticator getSaslAuthenticator(PooledConnectionFactory connFactory) {
  checkRequiredProperty(
      Pair.of(USER_FILTER_PROPERTY_NAME, userFilter),
      Pair.of(BASE_DN_PROPERTY_NAME, baseDn),
      Pair.of(USER_FILTER_PROPERTY_NAME, userFilter));
  final PooledSearchDnResolver resolver = new PooledSearchDnResolver();
  resolver.setBaseDn(baseDn);
  resolver.setSubtreeSearch(subtreeSearch);
  resolver.setAllowMultipleDns(allowMultipleDns);
  resolver.setConnectionFactory(connFactory);
  resolver.setUserFilter(userFilter);
  return new Authenticator(resolver, getPooledBindAuthenticationHandler(connFactory));
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
private Authenticator getActiveDirectoryAuthenticator(
    PooledConnectionFactory connFactory, EntryResolver entryResolver) {
  checkRequiredProperty(DN_FORMAT_PROPERTY_NAME, dnFormat);
  final FormatDnResolver resolver = new FormatDnResolver(dnFormat);
  final Authenticator authn =
      new Authenticator(resolver, getPooledBindAuthenticationHandler(connFactory));
  authn.setEntryResolver(entryResolver);
  return authn;
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
private PooledBindAuthenticationHandler getPooledBindAuthenticationHandler(
    PooledConnectionFactory connFactory) {
  final PooledBindAuthenticationHandler handler =
      new PooledBindAuthenticationHandler(connFactory);
  handler.setAuthenticationControls(new PasswordPolicyControl());
  return handler;
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
private PooledCompareAuthenticationHandler getPooledCompareAuthenticationHandler(
    PooledConnectionFactory connFactory) {
  final PooledCompareAuthenticationHandler handler =
      new PooledCompareAuthenticationHandler(connFactory);
  checkRequiredProperty(USER_PASSWORD_ATTRIBUTE_PROPERTY_NAME, userPasswordAttribute);
  handler.setPasswordAttribute(userPasswordAttribute);
  return handler;
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
@Test
public void directAuth() throws Exception {
  PooledConnectionFactory connFactory = server.getConnectionFactory();
  EntryResolver entryResolver =
      new EntryResolverProvider(
              connFactory,
              "ou=developers,dc=codenvy,dc=com", // <- base dn
              null, // <- user filter
              null)
          .get(); // <- subtree search
  Authenticator authenticator =
      new AuthenticatorProvider(
              connFactory,
              entryResolver,
              "ou=developers,dc=codenvy,dc=com", // <- base dn
              "DIRECT", // <- auth type
              "cn=%s,ou=developers,dc=codenvy,dc=com", // <- dn format
              null, // <- user password attribute
              null, // <- user filter
              null, // <- allow multiple dns
              null)
          .get(); // <- subtree search

  LdapAuthenticationHandler handler = new LdapAuthenticationHandler(authenticator, cnNormalizer);

  mustAuthenticate(handler, "mike", "mike");
  mustAuthenticate(handler, "john", "john");
  mustNotAuthenticate(handler, "brad", "brad");
  mustNotAuthenticate(handler, "ivan", "ivan");
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
@Test
public void authenticatedAuthUsingRootBaseDN() {
  PooledConnectionFactory connFactory = server.getConnectionFactory();
  EntryResolver entryResolver =
      new EntryResolverProvider(
              connFactory,
              "dc=codenvy,dc=com", // <- base dn
              "cn={user}", // <- user filter
              "true")
          .get(); // <- subtree search
  Authenticator authenticator =
      new AuthenticatorProvider(
              connFactory,
              entryResolver,
              "dc=codenvy,dc=com", // <- base dn
              "AUTHENTICATED", // <- auth type
              null, // <- dn format
              null, // <- user password attribute
              "cn={user}", // <- user filter
              null, // <- allow multiple dns
              "true")
          .get(); // <- subtree search

  LdapAuthenticationHandler handler = new LdapAuthenticationHandler(authenticator, cnNormalizer);

  mustAuthenticate(handler, "mike", "mike");
  mustAuthenticate(handler, "john", "john");
  mustAuthenticate(handler, "ivan", "ivan");
  mustAuthenticate(handler, "brad", "brad");
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
@Test
public void authenticatedAuthUsingCertainBaseDn() {
  PooledConnectionFactory connFactory = server.getConnectionFactory();
  EntryResolver entryResolver =
      new EntryResolverProvider(
              connFactory,
              "ou=managers,dc=codenvy,dc=com", // <- base dn
              "(&(objectClass=inetOrgPerson)(cn={user}))", // <- user filter
              "true")
          .get(); // <- subtree search
  Authenticator authenticator =
      new AuthenticatorProvider(
              connFactory,
              entryResolver,
              "ou=managers,dc=codenvy,dc=com", // <- base dn
              "AUTHENTICATED", // <- auth type
              null, // <- dn format
              null, // <- user password attribute
              "(&(objectClass=inetOrgPerson)(cn={user}))", // <- user filter
              null, // <- allow multiple dns
              "true")
          .get(); // <- subtree search

  LdapAuthenticationHandler handler = new LdapAuthenticationHandler(authenticator, cnNormalizer);

  mustAuthenticate(handler, "ivan", "ivan");
  mustAuthenticate(handler, "brad", "brad");
  mustNotAuthenticate(handler, "mike", "mike");
  mustNotAuthenticate(handler, "john", "john");
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
public void connect() {
    this.config = new ConnectionConfig();
    this.config.setLdapUrl(this.url);
    this.config.setUseSSL(this.ssl);
    this.config.setConnectionInitializer(new BindConnectionInitializer(user, new Credential(password)));
    this.pool = new BlockingConnectionPool(new DefaultConnectionFactory(this.config));
    if (!this.pool.isInitialized()) {
        this.pool.initialize();
    }
    this.connFactory = new PooledConnectionFactory(this.pool);
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
/**
 * New dn resolver entry resolver.
 * Creates the necessary search entry resolver.
 *
 * @param l       the ldap settings
 * @param factory the factory
 * @return the entry resolver
 */
public static EntryResolver newLdaptiveSearchEntryResolver(final AbstractLdapAuthenticationProperties l,
                                                           final PooledConnectionFactory factory) {
    if (StringUtils.isBlank(l.getBaseDn())) {
        throw new IllegalArgumentException("To create a search entry resolver, base dn cannot be empty/blank ");
    }
    if (StringUtils.isBlank(l.getUserFilter())) {
        throw new IllegalArgumentException("To create a search entry resolver, user filter cannot be empty/blank");
    }

    final PooledSearchEntryResolver entryResolver = new PooledSearchEntryResolver();
    entryResolver.setBaseDn(l.getBaseDn());
    entryResolver.setUserFilter(l.getUserFilter());
    entryResolver.setSubtreeSearch(l.isSubtreeSearch());
    entryResolver.setConnectionFactory(factory);

    final List<SearchEntryHandler> handlers = new ArrayList<>();
    l.getSearchEntryHandlers().forEach(h -> {
        switch (h.getType()) {
            case CASE_CHANGE:
                final CaseChangeEntryHandler eh = new CaseChangeEntryHandler();
                eh.setAttributeNameCaseChange(h.getCasChange().getAttributeNameCaseChange());
                eh.setAttributeNames(h.getCasChange().getAttributeNames());
                eh.setAttributeValueCaseChange(h.getCasChange().getAttributeValueCaseChange());
                eh.setDnCaseChange(h.getCasChange().getDnCaseChange());
                handlers.add(eh);
                break;
            case DN_ATTRIBUTE_ENTRY:
                final DnAttributeEntryHandler ehd = new DnAttributeEntryHandler();
                ehd.setAddIfExists(h.getDnAttribute().isAddIfExists());
                ehd.setDnAttributeName(h.getDnAttribute().getDnAttributeName());
                handlers.add(ehd);
                break;
            case MERGE:
                final MergeAttributeEntryHandler ehm = new MergeAttributeEntryHandler();
                ehm.setAttributeNames(h.getMergeAttribute().getAttributeNames());
                ehm.setMergeAttributeName(h.getMergeAttribute().getMergeAttributeName());
                handlers.add(ehm);
                break;
            case OBJECT_GUID:
                handlers.add(new ObjectGuidHandler());
                break;
            case OBJECT_SID:
                handlers.add(new ObjectSidHandler());
                break;
            case PRIMARY_GROUP:
                final PrimaryGroupIdHandler ehp = new PrimaryGroupIdHandler();
                ehp.setBaseDn(h.getPrimaryGroupId().getBaseDn());
                ehp.setGroupFilter(h.getPrimaryGroupId().getGroupFilter());
                handlers.add(ehp);
                break;
            case RANGE_ENTRY:
                handlers.add(new RangeEntryHandler());
                break;
            case RECURSIVE_ENTRY:
                handlers.add(new RecursiveEntryHandler(h.getRecursive().getSearchAttribute(), h.getRecursive().getMergeAttributes()));
                break;
            default:
                break;
        }
    });

    if (!handlers.isEmpty()) {
        LOGGER.debug("Search entry handlers defined for the entry resolver of [{}] are [{}]", l.getLdapUrl(), handlers);
        entryResolver.setSearchEntryHandlers(handlers.toArray(new SearchEntryHandler[]{}));
    }
    return entryResolver;
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
private static PooledBindAuthenticationHandler getPooledBindAuthenticationHandler(final AbstractLdapAuthenticationProperties l,
                                                                                  final PooledConnectionFactory factory) {
    final PooledBindAuthenticationHandler handler = new PooledBindAuthenticationHandler(factory);
    handler.setAuthenticationControls(new PasswordPolicyControl());
    return handler;
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
private static PooledCompareAuthenticationHandler getPooledCompareAuthenticationHandler(final AbstractLdapAuthenticationProperties l,
                                                                                        final PooledConnectionFactory factory) {
    final PooledCompareAuthenticationHandler handler = new PooledCompareAuthenticationHandler(factory);
    handler.setPasswordAttribute(l.getPrincipalAttributePassword());
    return handler;
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
@Override
public PooledConnectionFactory get() {
  return connFactory;
}
 

import org.ldaptive.pool.PooledConnectionFactory; //导入依赖的package包/类
private Authenticator getDirectBindAuthenticator(PooledConnectionFactory connFactory) {
  checkRequiredProperty(DN_FORMAT_PROPERTY_NAME, dnFormat);
  final FormatDnResolver resolver = new FormatDnResolver(dnFormat);
  return new Authenticator(resolver, getPooledBindAuthenticationHandler(connFactory));
}