Exemple #1
0
    def __init__(self, backend_type, paths=None, lp=None,
                 credentials=None, names=None, logger=None, domainsid=None,
                 schema=None, hostname=None, ldapadminpass=None, slapd_path=None,
                 ldap_backend_extra_port=None, ldap_dryrun_mode=False,
                 ol_mmr_urls=None, nosync=False, ldap_backend_forced_uri=None):
        from samba.provision import setup_path
        super(OpenLDAPBackend, self).__init__(backend_type=backend_type,
                                              paths=paths, lp=lp,
                                              names=names, logger=logger,
                                              domainsid=domainsid, schema=schema, hostname=hostname,
                                              ldapadminpass=ldapadminpass, slapd_path=slapd_path,
                                              ldap_backend_extra_port=ldap_backend_extra_port,
                                              ldap_backend_forced_uri=ldap_backend_forced_uri,
                                              ldap_dryrun_mode=ldap_dryrun_mode)

        self.ol_mmr_urls = ol_mmr_urls
        self.nosync = nosync

        self.slapdconf          = os.path.join(self.ldapdir, "slapd.conf")
        self.modulesconf        = os.path.join(self.ldapdir, "modules.conf")
        self.memberofconf       = os.path.join(self.ldapdir, "memberof.conf")
        self.olmmrserveridsconf = os.path.join(self.ldapdir, "mmr_serverids.conf")
        self.olmmrsyncreplconf  = os.path.join(self.ldapdir, "mmr_syncrepl.conf")
        self.olcdir             = os.path.join(self.ldapdir, "slapd.d")
        self.olcseedldif        = os.path.join(self.ldapdir, "olc_seed.ldif")

        self.schema = Schema(self.domainsid,
                             schemadn=self.names.schemadn, files=[
                                 setup_path("schema_samba4.ldif")])
Exemple #2
0
 def create_tmp_samdb(ctx):
     '''create a temporary samdb object for schema queries'''
     ctx.tmp_schema = Schema(security.dom_sid(ctx.domsid),
                             schemadn=ctx.schema_dn)
     ctx.tmp_samdb = SamDB(session_info=system_session(), url=None, auto_connect=False,
                           credentials=ctx.creds, lp=ctx.lp, global_schema=False,
                           am_rodc=False)
     ctx.tmp_samdb.set_schema(ctx.tmp_schema)
Exemple #3
0
    def __init__(self, backend_type, paths=None, lp=None,
                 names=None, logger=None, domainsid=None,
                 schema=None, hostname=None, ldapadminpass=None,
                 slapd_path=None, ldap_backend_extra_port=None,
                 ldap_backend_forced_uri=None, ldap_dryrun_mode=False,
                 root=None, setup_ds_path=None):

        from samba.provision import setup_path

        super(FDSBackend, self).__init__(backend_type=backend_type,
                                         paths=paths, lp=lp,
                                         names=names, logger=logger,
                                         domainsid=domainsid, schema=schema, hostname=hostname,
                                         ldapadminpass=ldapadminpass, slapd_path=slapd_path,
                                         ldap_backend_extra_port=ldap_backend_extra_port,
                                         ldap_backend_forced_uri=ldap_backend_forced_uri,
                                         ldap_dryrun_mode=ldap_dryrun_mode)

        self.root = root
        self.setup_ds_path = setup_ds_path
        self.ldap_instance = self.names.netbiosname.lower()

        self.sambadn = "CN=Samba"

        self.fedoradsinf = os.path.join(self.ldapdir, "fedorads.inf")
        self.partitions_ldif = os.path.join(self.ldapdir,
                                            "fedorads-partitions.ldif")
        self.sasl_ldif = os.path.join(self.ldapdir, "fedorads-sasl.ldif")
        self.dna_ldif = os.path.join(self.ldapdir, "fedorads-dna.ldif")
        self.pam_ldif = os.path.join(self.ldapdir, "fedorads-pam.ldif")
        self.refint_ldif = os.path.join(self.ldapdir, "fedorads-refint.ldif")
        self.linked_attrs_ldif = os.path.join(self.ldapdir,
                                              "fedorads-linked-attributes.ldif")
        self.index_ldif = os.path.join(self.ldapdir, "fedorads-index.ldif")
        self.samba_ldif = os.path.join(self.ldapdir, "fedorads-samba.ldif")

        self.samba3_schema = setup_path(
            "../../examples/LDAP/samba.schema")
        self.samba3_ldif = os.path.join(self.ldapdir, "samba3.ldif")

        self.retcode = subprocess.call(["bin/oLschema2ldif",
                                        "-I", self.samba3_schema,
                                        "-O", self.samba3_ldif,
                                        "-b", self.names.domaindn],
                                       close_fds=True, shell=False)

        if self.retcode != 0:
            raise Exception("Unable to convert Samba 3 schema.")

        self.schema = Schema(
            self.domainsid,
            schemadn=self.names.schemadn,
            files=[setup_path("schema_samba4.ldif"), self.samba3_ldif],
            additional_prefixmap=["1000:1.3.6.1.4.1.7165.2.1",
                                  "1001:1.3.6.1.4.1.7165.2.2"])
Exemple #4
0
    def setUp(self):
        super(SamDBTestCase, self).setUp()
        invocationid = str(uuid.uuid4())
        domaindn = "DC=COM,DC=EXAMPLE"
        self.domaindn = domaindn
        configdn = "CN=Configuration," + domaindn
        schemadn = "CN=Schema," + configdn
        domainguid = str(uuid.uuid4())
        policyguid = DEFAULT_POLICY_GUID
        domainsid = security.random_sid()
        path = os.path.join(self.tempdir, "samdb.ldb")
        session_info = system_session()

        hostname = "foo"
        domain = "EXAMPLE"
        dnsdomain = "example.com"
        serverrole = "domain controller"
        policyguid_dc = DEFAULT_DC_POLICY_GUID

        smbconf = os.path.join(self.tempdir, "smb.conf")
        make_smbconf(smbconf, hostname, domain, dnsdomain, serverrole,
                     self.tempdir)

        self.lp = param.LoadParm()
        self.lp.load(smbconf)

        names = guess_names(lp=self.lp,
                            hostname=hostname,
                            domain=domain,
                            dnsdomain=dnsdomain,
                            serverrole=serverrole,
                            domaindn=self.domaindn,
                            configdn=configdn,
                            schemadn=schemadn)

        paths = provision_paths_from_lp(self.lp, names.dnsdomain)

        logger = logging.getLogger("provision")

        provision_backend = ProvisionBackend("ldb",
                                             paths=paths,
                                             lp=self.lp,
                                             credentials=None,
                                             names=names,
                                             logger=logger)

        schema = Schema(domainsid,
                        invocationid=invocationid,
                        schemadn=names.schemadn,
                        serverdn=names.serverdn,
                        am_rodc=False)

        self.samdb = setup_samdb(path,
                                 session_info,
                                 provision_backend,
                                 self.lp,
                                 names,
                                 logger,
                                 domainsid,
                                 domainguid,
                                 policyguid,
                                 policyguid_dc,
                                 False,
                                 "secret",
                                 "secret",
                                 "secret",
                                 invocationid,
                                 "secret",
                                 None,
                                 "domain controller",
                                 schema=schema)