import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
/**
 * Creates an environment configuration for JNDI access.
 */
private Hashtable<Object, Object> createEnv() {
    // Fetch directory service from servlet context
    ServletContext servletContext = this.getServletContext();
    DirectoryService directoryService = (DirectoryService) servletContext.
            getAttribute(DirectoryService.JNDI_KEY);

    Hashtable<Object, Object> env = new Hashtable<Object, Object>();
    env.put(DirectoryService.JNDI_KEY, directoryService);
    env.put(Context.PROVIDER_URL, "");
    env.put(Context.INITIAL_CONTEXT_FACTORY, CoreContextFactory.class.
            getName());

    env.put(Context.SECURITY_PRINCIPAL, "uid=admin,ou=system");
    env.put(Context.SECURITY_CREDENTIALS, "secret");
    env.put(Context.SECURITY_AUTHENTICATION, "simple");

    return env;
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
private void setSchemaContext(KdcConfiguration configuration, DirectoryService service,
                              String connectionUser)
        throws DirectoryServerException {
    Hashtable<String, Object> env = new Hashtable<String, Object>();
    env.put(DirectoryService.JNDI_KEY, service);
    env.put(Context.SECURITY_PRINCIPAL, connectionUser);
    env.put(Context.SECURITY_CREDENTIALS, configuration.getSystemAdminPassword());
    env.put(Context.SECURITY_AUTHENTICATION, ConfigurationConstants.SIMPLE_AUTHENTICATION);
    env.put(Context.INITIAL_CONTEXT_FACTORY, CoreContextFactory.class.getName());

    env.put(Context.PROVIDER_URL, SchemaConstants.OU_SCHEMA);

    try {
        schemaRoot = new InitialLdapContext(env, null);
    } catch (NamingException e) {
        throw new DirectoryServerException(
                "Unable to create Schema context with user " + connectionUser, e);
    }

}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
@SuppressWarnings("unused")
private ApacheDS startKerberos() throws Exception {
  Preconditions.checkState(ldapServer.isStarted());

  kdcServer.setDirectoryService(directoryService);
  // FIXME hard-coded ports
  kdcServer.setTransports(new TcpTransport(6088), new UdpTransport(6088));
  kdcServer.setEnabled(true);
  kdcServer.setPrimaryRealm(realm);
  kdcServer.setSearchBaseDn(baseDn);
  kdcServer.setKdcPrincipal("krbtgt/" + realm + "@" + baseDn);
  kdcServer.start();

  // -------------------------------------------------------------------
  // Enable the krb5kdc schema
  // -------------------------------------------------------------------

  Hashtable<String, Object> env = new Hashtable<String, Object>();
  env.put(DirectoryService.JNDI_KEY, directoryService);
  env.put(Context.INITIAL_CONTEXT_FACTORY, CoreContextFactory.class.getName());
  env.put(Context.PROVIDER_URL, ServerDNConstants.OU_SCHEMA_DN);
  InitialLdapContext schemaRoot = new InitialLdapContext(env, null);

  // check if krb5kdc is disabled
  Attributes krb5kdcAttrs = schemaRoot.getAttributes("cn=Krb5kdc");
  boolean isKrb5KdcDisabled = false;
  if (krb5kdcAttrs.get("m-disabled") != null) {
    isKrb5KdcDisabled = ((String) krb5kdcAttrs.get("m-disabled").get()).equalsIgnoreCase("TRUE");
  }

  // if krb5kdc is disabled then enable it
  if (isKrb5KdcDisabled) {
    Attribute disabled = new BasicAttribute("m-disabled");
    ModificationItem[] mods = new ModificationItem[] {new ModificationItem(DirContext.REMOVE_ATTRIBUTE, disabled)};
    schemaRoot.modifyAttributes("cn=Krb5kdc", mods);
  }
  return this;
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
private static Partition addPartition(
    DirectoryService service, String partitionId, String partitionDn) throws Exception {
  final JdbmPartition partition = new JdbmPartition();
  partition.setId(partitionId);
  partition.setPartitionDir(new File(service.getWorkingDirectory(), partitionId));
  partition.setSuffix(partitionDn);
  service.addPartition(partition);
  return partition;
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
/**
 * Startup ApacheDS embedded.
 *
 * @param sce ServletContext event
 */
@Override
public void contextInitialized(final ServletContextEvent sce) {
    File workDir = (File) sce.getServletContext().getAttribute(
            "javax.servlet.context.tempdir");
    workDir = new File(workDir, "server-work");
    if (!workDir.mkdirs()) {
        throw new RuntimeException("Could not create " + workDir.
                getAbsolutePath());
    }

    Entry result;
    try {
        initDirectoryService(sce.getServletContext(), workDir);

        server = new LdapServer();
        server.setTransports(new TcpTransport(Integer.valueOf(
                sce.getServletContext().
                getInitParameter("testds.port"))));
        server.setDirectoryService(service);

        server.start();

        // store directoryService in context to provide it to servlets etc.
        sce.getServletContext().setAttribute(DirectoryService.JNDI_KEY,
                service);

        result = service.getAdminSession().lookup(new DN("o=isp"));
    } catch (Exception e) {
        sce.getServletContext().log("Fatal error in context init", e);
        throw new RuntimeException(e);
    }

    if (result == null) {
        throw new RuntimeException("Base DN not found");
    } else {
        sce.getServletContext().log(
                "ApacheDS startup completed succesfully");
    }
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
/**
 * @return the directoryService
 */
public DirectoryService getDirectoryService() {
    return directoryService;
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
/** Returns service instance of this server. */
public DirectoryService getService() {
  return service;
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
@Override
public void init(final KdcConfiguration configuration, LDAPServer ldapServer)
        throws DirectoryServerException {

    if (configuration == null) {
        throw new DirectoryServerException("Could not initialize KDC server. " +
                "KDC configurations are null");
    }

    if (ldapServer == null) {
        throw new DirectoryServerException("Could not initialize KDC server. " +
                "Directory service is null.");
    }

    if (!(ldapServer instanceof ApacheLDAPServer)) {
        throw new DirectoryServerException("Apache KDC server is only compatible with " +
                "ApacheLDAPServer");
    }

    ApacheLDAPServer apacheLDAP = (ApacheLDAPServer) ldapServer;

    this.kdcServer.setServiceName(configuration.getKdcName());
    this.kdcServer.setKdcPrincipal(configuration.getKdcPrinciple());
    this.kdcServer.setPrimaryRealm(configuration.getPrimaryRealm());
    this.kdcServer.setMaximumTicketLifetime(configuration.getMaxTicketLifeTime());
    this.kdcServer.setMaximumRenewableLifetime(configuration.getMaxRenewableLifeTime());
    this.kdcServer.setSearchBaseDn(configuration.getSearchBaseDomainName());
    this.kdcServer.setPaEncTimestampRequired(
            configuration.isPreAuthenticateTimeStampRequired());

    configureTransportHandlers(configuration);

    DirectoryService directoryService = apacheLDAP.getService();

    if (directoryService == null) {
        throw new DirectoryServerException("LDAP service is null. " +
                "Could not configure Kerberos.");
    }

    this.kdcServer.setDirectoryService(directoryService);

    setSchemaContext(configuration, directoryService, ldapServer.getConnectionDomainName());

    enableKerberoseSchema();

}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
public ApacheDirectoryPartitionManager(DirectoryService directoryService, String wd) {
    this.directoryService = directoryService;
    this.workingDirectory = wd;
    this.partitionFactory = new JdbmPartitionFactory();
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public DirectoryService getDirectoryService()
        throws Exception {
    return directoryService;
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
public DirectoryService getService() {
    return service;
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
public void setService(DirectoryService service) {
    this.service = service;
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
private EmbeddedLdapServer(DirectoryService directoryService,
                           LdapServer ldapServer) {
    this.directoryService = directoryService;
    this.ldapServer = ldapServer;
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
/**
 * Sets the contexts for this base class. Values of user and password used to set the respective
 * JNDI properties. These values can be overriden by the overrides properties.
 *
 * @param user
 *            the username for authenticating as this user
 * @param passwd
 *            the password of the user
 * @throws Exception
 *             if there is a failure of any kind
 */
protected void setContexts(String user, String passwd) throws Exception {
    Hashtable<String, Object> env = new Hashtable<String, Object>();
    env.put(DirectoryService.JNDI_KEY, getDirectoryService());
    env.put(Context.SECURITY_PRINCIPAL, user);
    env.put(Context.SECURITY_CREDENTIALS, passwd);
    env.put(Context.SECURITY_AUTHENTICATION, "simple");
    env.put(Context.INITIAL_CONTEXT_FACTORY, CoreContextFactory.class.getName());
    setContexts(env);
}
 

import org.apache.directory.server.core.DirectoryService; //导入依赖的package包/类
/**
 * @param directoryService
 *            the directoryService to set
 */
public void setDirectoryService(DirectoryService directoryService) {
    this.directoryService = directoryService;
}