source4/scripting/python/samba/netcmd/domain.py

   1 #!/usr/bin/env python
   2 #
   3 # domain management
   4 #
   5 # Copyright Matthias Dieter Wallnoefer 2009
   6 # Copyright Andrew Kroeger 2009
   7 # Copyright Jelmer Vernooij 2009
   8 # Copyright Giampaolo Lauria 2011
   9 #
  10 # This program is free software; you can redistribute it and/or modify
  11 # it under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation; either version 3 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # This program is distributed in the hope that it will be useful,
  16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 #
  23
  24
  25
  26 import samba.getopt as options
  27 import ldb
  28 import os
  29 import tempfile
  30 import logging
  31 from samba import Ldb
  32 from samba.net import Net, LIBNET_JOIN_AUTOMATIC
  33 import samba.ntacls
  34 from samba.join import join_RODC, join_DC, join_subdomain
  35 from samba.auth import system_session
  36 from samba.samdb import SamDB
  37 from samba.dcerpc.samr import DOMAIN_PASSWORD_COMPLEX, DOMAIN_PASSWORD_STORE_CLEARTEXT
  38 from samba.netcmd import (
  39     Command,
  40     CommandError,
  41     SuperCommand,
  42     Option
  43     )
  44 from samba.netcmd.common import netcmd_get_domain_infos_via_cldap
  45 from samba.samba3 import Samba3
  46 from samba.samba3 import param as s3param
  47 from samba.upgrade import upgrade_from_samba3
  48
  49 from samba.dsdb import (
  50     DS_DOMAIN_FUNCTION_2000,
  51     DS_DOMAIN_FUNCTION_2003,
  52     DS_DOMAIN_FUNCTION_2003_MIXED,
  53     DS_DOMAIN_FUNCTION_2008,
  54     DS_DOMAIN_FUNCTION_2008_R2,
  55     )
  56
  57 def get_testparm_var(testparm, smbconf, varname):
  58     cmd = "%s -s -l --parameter-name='%s' %s 2>/dev/null" % (testparm, varname, smbconf)
  59     output = os.popen(cmd, 'r').readline()
  60     return output.strip()
  61
  62
  63 class cmd_domain_export_keytab(Command):
  64     """Dumps kerberos keys of the domain into a keytab"""
  65
  66     synopsis = "%prog <keytab> [options]"
  67
  68     takes_options = [
  69         Option("--principal", help="extract only this principal", type=str),
  70         ]
  71
  72     takes_args = ["keytab"]
  73
  74     def run(self, keytab, credopts=None, sambaopts=None, versionopts=None, principal=None):
  75         lp = sambaopts.get_loadparm()
  76         net = Net(None, lp)
  77         net.export_keytab(keytab=keytab, principal=principal)
  78
  79 class cmd_domain_info(Command):
  80     """Print basic info about a domain and the DC passed as parameter"""
  81
  82     synopsis = "%prog domain info <ip_address> [options]"
  83
  84     takes_options = [
  85         ]
  86
  87     takes_args = ["address"]
  88
  89     def run(self, address, credopts=None, sambaopts=None, versionopts=None):
  90         lp = sambaopts.get_loadparm()
  91         try:
  92             res = netcmd_get_domain_infos_via_cldap(lp, None, address)
  93             print "Forest           : %s" % res.forest
  94             print "Domain           : %s" % res.dns_domain
  95             print "Netbios domain   : %s" % res.domain_name
  96             print "DC name          : %s" % res.pdc_dns_name
  97             print "DC netbios name  : %s" % res.pdc_name
  98             print "Server site      : %s" % res.server_site
  99             print "Client site      : %s" % res.client_site
 100         except RuntimeError:
 101             raise CommandError("Invalid IP address '" + address + "'!")
 102
 103
 104
 105 class cmd_domain_join(Command):
 106     """Joins domain as either member or backup domain controller"""
 107
 108     synopsis = "%prog <dnsdomain> [DC|RODC|MEMBER|SUBDOMAIN] [options]"
 109
 110     takes_options = [
 111         Option("--server", help="DC to join", type=str),
 112         Option("--site", help="site to join", type=str),
 113         Option("--targetdir", help="where to store provision", type=str),
 114         Option("--parent-domain", help="parent domain to create subdomain under", type=str),
 115         Option("--domain-critical-only",
 116                help="only replicate critical domain objects",
 117                action="store_true"),
 118         Option("--machinepass", type=str, metavar="PASSWORD",
 119                help="choose machine password (otherwise random)")
 120         ]
 121
 122     takes_args = ["domain", "role?"]
 123
 124     def run(self, domain, role=None, sambaopts=None, credopts=None,
 125             versionopts=None, server=None, site=None, targetdir=None,
 126             domain_critical_only=False, parent_domain=None, machinepass=None):
 127         lp = sambaopts.get_loadparm()
 128         creds = credopts.get_credentials(lp)
 129         net = Net(creds, lp, server=credopts.ipaddress)
 130
 131         if site is None:
 132             site = "Default-First-Site-Name"
 133
 134         netbios_name = lp.get("netbios name")
 135
 136         if not role is None:
 137             role = role.upper()
 138
 139         if role is None or role == "MEMBER":
 140             (join_password, sid, domain_name) = net.join_member(domain,
 141                                                                 netbios_name,
 142                                                                 LIBNET_JOIN_AUTOMATIC,
 143                                                                 machinepass=machinepass)
 144
 145             self.outf.write("Joined domain %s (%s)\n" % (domain_name, sid))
 146             return
 147         elif role == "DC":
 148             join_DC(server=server, creds=creds, lp=lp, domain=domain,
 149                     site=site, netbios_name=netbios_name, targetdir=targetdir,
 150                     domain_critical_only=domain_critical_only,
 151                     machinepass=machinepass)
 152             return
 153         elif role == "RODC":
 154             join_RODC(server=server, creds=creds, lp=lp, domain=domain,
 155                       site=site, netbios_name=netbios_name, targetdir=targetdir,
 156                       domain_critical_only=domain_critical_only,
 157                       machinepass=machinepass)
 158             return
 159         elif role == "SUBDOMAIN":
 160             netbios_domain = lp.get("workgroup")
 161             if parent_domain is None:
 162                 parent_domain = ".".join(domain.split(".")[1:])
 163             join_subdomain(server=server, creds=creds, lp=lp, dnsdomain=domain, parent_domain=parent_domain,
 164                            site=site, netbios_name=netbios_name, netbios_domain=netbios_domain, targetdir=targetdir,
 165                            machinepass=machinepass)
 166             return
 167         else:
 168             raise CommandError("Invalid role '%s' (possible values: MEMBER, DC, RODC, SUBDOMAIN)" % role)
 169
 170
 171
 172 class cmd_domain_level(Command):
 173     """Raises domain and forest function levels"""
 174
 175     synopsis = "%prog (show|raise <options>) [options]"
 176
 177     takes_options = [
 178         Option("-H", "--URL", help="LDB URL for database or target server", type=str,
 179                metavar="URL", dest="H"),
 180         Option("--quiet", help="Be quiet", action="store_true"),
 181         Option("--forest-level", type="choice", choices=["2003", "2008", "2008_R2"],
 182             help="The forest function level (2003 | 2008 | 2008_R2)"),
 183         Option("--domain-level", type="choice", choices=["2003", "2008", "2008_R2"],
 184             help="The domain function level (2003 | 2008 | 2008_R2)")
 185             ]
 186
 187     takes_args = ["subcommand"]
 188
 189     def run(self, subcommand, H=None, forest_level=None, domain_level=None,
 190             quiet=False, credopts=None, sambaopts=None, versionopts=None):
 191         lp = sambaopts.get_loadparm()
 192         creds = credopts.get_credentials(lp, fallback_machine=True)
 193
 194         samdb = SamDB(url=H, session_info=system_session(),
 195             credentials=creds, lp=lp)
 196
 197         domain_dn = samdb.domain_dn()
 198
 199         res_forest = samdb.search("CN=Partitions,%s" % samdb.get_config_basedn(),
 200           scope=ldb.SCOPE_BASE, attrs=["msDS-Behavior-Version"])
 201         assert len(res_forest) == 1
 202
 203         res_domain = samdb.search(domain_dn, scope=ldb.SCOPE_BASE,
 204           attrs=["msDS-Behavior-Version", "nTMixedDomain"])
 205         assert len(res_domain) == 1
 206
 207         res_dc_s = samdb.search("CN=Sites,%s" % samdb.get_config_basedn(),
 208           scope=ldb.SCOPE_SUBTREE, expression="(objectClass=nTDSDSA)",
 209           attrs=["msDS-Behavior-Version"])
 210         assert len(res_dc_s) >= 1
 211
 212         try:
 213             level_forest = int(res_forest[0]["msDS-Behavior-Version"][0])
 214             level_domain = int(res_domain[0]["msDS-Behavior-Version"][0])
 215             level_domain_mixed = int(res_domain[0]["nTMixedDomain"][0])
 216
 217             min_level_dc = int(res_dc_s[0]["msDS-Behavior-Version"][0]) # Init value
 218             for msg in res_dc_s:
 219                 if int(msg["msDS-Behavior-Version"][0]) < min_level_dc:
 220                     min_level_dc = int(msg["msDS-Behavior-Version"][0])
 221
 222             if level_forest < 0 or level_domain < 0:
 223                 raise CommandError("Domain and/or forest function level(s) is/are invalid. Correct them or reprovision!")
 224             if min_level_dc < 0:
 225                 raise CommandError("Lowest function level of a DC is invalid. Correct this or reprovision!")
 226             if level_forest > level_domain:
 227                 raise CommandError("Forest function level is higher than the domain level(s). Correct this or reprovision!")
 228             if level_domain > min_level_dc:
 229                 raise CommandError("Domain function level is higher than the lowest function level of a DC. Correct this or reprovision!")
 230
 231         except KeyError:
 232             raise CommandError("Could not retrieve the actual domain, forest level and/or lowest DC function level!")
 233
 234         if subcommand == "show":
 235             self.message("Domain and forest function level for domain '%s'" % domain_dn)
 236             if level_forest == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed != 0:
 237                 self.message("\nATTENTION: You run SAMBA 4 on a forest function level lower than Windows 2000 (Native). This isn't supported! Please raise!")
 238             if level_domain == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed != 0:
 239                 self.message("\nATTENTION: You run SAMBA 4 on a domain function level lower than Windows 2000 (Native). This isn't supported! Please raise!")
 240             if min_level_dc == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed != 0:
 241                 self.message("\nATTENTION: You run SAMBA 4 on a lowest function level of a DC lower than Windows 2003. This isn't supported! Please step-up or upgrade the concerning DC(s)!")
 242
 243             self.message("")
 244
 245             if level_forest == DS_DOMAIN_FUNCTION_2000:
 246                 outstr = "2000"
 247             elif level_forest == DS_DOMAIN_FUNCTION_2003_MIXED:
 248                 outstr = "2003 with mixed domains/interim (NT4 DC support)"
 249             elif level_forest == DS_DOMAIN_FUNCTION_2003:
 250                 outstr = "2003"
 251             elif level_forest == DS_DOMAIN_FUNCTION_2008:
 252                 outstr = "2008"
 253             elif level_forest == DS_DOMAIN_FUNCTION_2008_R2:
 254                 outstr = "2008 R2"
 255             else:
 256                 outstr = "higher than 2008 R2"
 257             self.message("Forest function level: (Windows) " + outstr)
 258
 259             if level_domain == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed != 0:
 260                 outstr = "2000 mixed (NT4 DC support)"
 261             elif level_domain == DS_DOMAIN_FUNCTION_2000 and level_domain_mixed == 0:
 262                 outstr = "2000"
 263             elif level_domain == DS_DOMAIN_FUNCTION_2003_MIXED:
 264                 outstr = "2003 with mixed domains/interim (NT4 DC support)"
 265             elif level_domain == DS_DOMAIN_FUNCTION_2003:
 266                 outstr = "2003"
 267             elif level_domain == DS_DOMAIN_FUNCTION_2008:
 268                 outstr = "2008"
 269             elif level_domain == DS_DOMAIN_FUNCTION_2008_R2:
 270                 outstr = "2008 R2"
 271             else:
 272                 outstr = "higher than 2008 R2"
 273             self.message("Domain function level: (Windows) " + outstr)
 274
 275             if min_level_dc == DS_DOMAIN_FUNCTION_2000:
 276                 outstr = "2000"
 277             elif min_level_dc == DS_DOMAIN_FUNCTION_2003:
 278                 outstr = "2003"
 279             elif min_level_dc == DS_DOMAIN_FUNCTION_2008:
 280                 outstr = "2008"
 281             elif min_level_dc == DS_DOMAIN_FUNCTION_2008_R2:
 282                 outstr = "2008 R2"
 283             else:
 284                 outstr = "higher than 2008 R2"
 285             self.message("Lowest function level of a DC: (Windows) " + outstr)
 286
 287         elif subcommand == "raise":
 288             msgs = []
 289
 290             if domain_level is not None:
 291                 if domain_level == "2003":
 292                     new_level_domain = DS_DOMAIN_FUNCTION_2003
 293                 elif domain_level == "2008":
 294                     new_level_domain = DS_DOMAIN_FUNCTION_2008
 295                 elif domain_level == "2008_R2":
 296                     new_level_domain = DS_DOMAIN_FUNCTION_2008_R2
 297
 298                 if new_level_domain <= level_domain and level_domain_mixed == 0:
 299                     raise CommandError("Domain function level can't be smaller than or equal to the actual one!")
 300
 301                 if new_level_domain > min_level_dc:
 302                     raise CommandError("Domain function level can't be higher than the lowest function level of a DC!")
 303
 304                 # Deactivate mixed/interim domain support
 305                 if level_domain_mixed != 0:
 306                     # Directly on the base DN
 307                     m = ldb.Message()
 308                     m.dn = ldb.Dn(samdb, domain_dn)
 309                     m["nTMixedDomain"] = ldb.MessageElement("0",
 310                       ldb.FLAG_MOD_REPLACE, "nTMixedDomain")
 311                     samdb.modify(m)
 312                     # Under partitions
 313                     m = ldb.Message()
 314                     m.dn = ldb.Dn(samdb, "CN=" + lp.get("workgroup") + ",CN=Partitions,%s" % ldb.get_config_basedn())
 315                     m["nTMixedDomain"] = ldb.MessageElement("0",
 316                       ldb.FLAG_MOD_REPLACE, "nTMixedDomain")
 317                     try:
 318                         samdb.modify(m)
 319                     except ldb.LdbError, (enum, emsg):
 320                         if enum != ldb.ERR_UNWILLING_TO_PERFORM:
 321                             raise
 322
 323                 # Directly on the base DN
 324                 m = ldb.Message()
 325                 m.dn = ldb.Dn(samdb, domain_dn)
 326                 m["msDS-Behavior-Version"]= ldb.MessageElement(
 327                   str(new_level_domain), ldb.FLAG_MOD_REPLACE,
 328                             "msDS-Behavior-Version")
 329                 samdb.modify(m)
 330                 # Under partitions
 331                 m = ldb.Message()
 332                 m.dn = ldb.Dn(samdb, "CN=" + lp.get("workgroup")
 333                   + ",CN=Partitions,%s" % ldb.get_config_basedn())
 334                 m["msDS-Behavior-Version"]= ldb.MessageElement(
 335                   str(new_level_domain), ldb.FLAG_MOD_REPLACE,
 336                           "msDS-Behavior-Version")
 337                 try:
 338                     samdb.modify(m)
 339                 except ldb.LdbError, (enum, emsg):
 340                     if enum != ldb.ERR_UNWILLING_TO_PERFORM:
 341                         raise
 342
 343                 level_domain = new_level_domain
 344                 msgs.append("Domain function level changed!")
 345
 346             if forest_level is not None:
 347                 if forest_level == "2003":
 348                     new_level_forest = DS_DOMAIN_FUNCTION_2003
 349                 elif forest_level == "2008":
 350                     new_level_forest = DS_DOMAIN_FUNCTION_2008
 351                 elif forest_level == "2008_R2":
 352                     new_level_forest = DS_DOMAIN_FUNCTION_2008_R2
 353                 if new_level_forest <= level_forest:
 354                     raise CommandError("Forest function level can't be smaller than or equal to the actual one!")
 355                 if new_level_forest > level_domain:
 356                     raise CommandError("Forest function level can't be higher than the domain function level(s). Please raise it/them first!")
 357                 m = ldb.Message()
 358                 m.dn = ldb.Dn(samdb, "CN=Partitions,%s" % ldb.get_config_basedn())
 359                 m["msDS-Behavior-Version"]= ldb.MessageElement(
 360                   str(new_level_forest), ldb.FLAG_MOD_REPLACE,
 361                           "msDS-Behavior-Version")
 362                 samdb.modify(m)
 363                 msgs.append("Forest function level changed!")
 364             msgs.append("All changes applied successfully!")
 365             self.message("\n".join(msgs))
 366         else:
 367             raise CommandError("invalid argument: '%s' (choose from 'show', 'raise')" % subcommand)
 368
 369
 370
 371 class cmd_domain_passwordsettings(Command):
 372     """Sets password settings
 373
 374     Password complexity, history length, minimum password length, the minimum
 375     and maximum password age) on a Samba4 server.
 376     """
 377
 378     synopsis = "%prog (show|set <options>) [options]"
 379
 380     takes_options = [
 381         Option("-H", "--URL", help="LDB URL for database or target server", type=str,
 382                metavar="URL", dest="H"),
 383         Option("--quiet", help="Be quiet", action="store_true"),
 384         Option("--complexity", type="choice", choices=["on","off","default"],
 385           help="The password complexity (on | off | default). Default is 'on'"),
 386         Option("--store-plaintext", type="choice", choices=["on","off","default"],
 387           help="Store plaintext passwords where account have 'store passwords with reversible encryption' set (on | off | default). Default is 'off'"),
 388         Option("--history-length",
 389           help="The password history length (<integer> | default).  Default is 24.", type=str),
 390         Option("--min-pwd-length",
 391           help="The minimum password length (<integer> | default).  Default is 7.", type=str),
 392         Option("--min-pwd-age",
 393           help="The minimum password age (<integer in days> | default).  Default is 1.", type=str),
 394         Option("--max-pwd-age",
 395           help="The maximum password age (<integer in days> | default).  Default is 43.", type=str),
 396           ]
 397
 398     takes_args = ["subcommand"]
 399
 400     def run(self, subcommand, H=None, min_pwd_age=None, max_pwd_age=None,
 401             quiet=False, complexity=None, store_plaintext=None, history_length=None,
 402             min_pwd_length=None, credopts=None, sambaopts=None,
 403             versionopts=None):
 404         lp = sambaopts.get_loadparm()
 405         creds = credopts.get_credentials(lp)
 406
 407         samdb = SamDB(url=H, session_info=system_session(),
 408             credentials=creds, lp=lp)
 409
 410         domain_dn = samdb.domain_dn()
 411         res = samdb.search(domain_dn, scope=ldb.SCOPE_BASE,
 412           attrs=["pwdProperties", "pwdHistoryLength", "minPwdLength",
 413                  "minPwdAge", "maxPwdAge"])
 414         assert(len(res) == 1)
 415         try:
 416             pwd_props = int(res[0]["pwdProperties"][0])
 417             pwd_hist_len = int(res[0]["pwdHistoryLength"][0])
 418             cur_min_pwd_len = int(res[0]["minPwdLength"][0])
 419             # ticks -> days
 420             cur_min_pwd_age = int(abs(int(res[0]["minPwdAge"][0])) / (1e7 * 60 * 60 * 24))
 421             if int(res[0]["maxPwdAge"][0]) == -0x8000000000000000:
 422                 cur_max_pwd_age = 0
 423             else:
 424                 cur_max_pwd_age = int(abs(int(res[0]["maxPwdAge"][0])) / (1e7 * 60 * 60 * 24))
 425         except Exception, e:
 426             raise CommandError("Could not retrieve password properties!", e)
 427
 428         if subcommand == "show":
 429             self.message("Password informations for domain '%s'" % domain_dn)
 430             self.message("")
 431             if pwd_props & DOMAIN_PASSWORD_COMPLEX != 0:
 432                 self.message("Password complexity: on")
 433             else:
 434                 self.message("Password complexity: off")
 435             if pwd_props & DOMAIN_PASSWORD_STORE_CLEARTEXT != 0:
 436                 self.message("Store plaintext passwords: on")
 437             else:
 438                 self.message("Store plaintext passwords: off")
 439             self.message("Password history length: %d" % pwd_hist_len)
 440             self.message("Minimum password length: %d" % cur_min_pwd_len)
 441             self.message("Minimum password age (days): %d" % cur_min_pwd_age)
 442             self.message("Maximum password age (days): %d" % cur_max_pwd_age)
 443         elif subcommand == "set":
 444             msgs = []
 445             m = ldb.Message()
 446             m.dn = ldb.Dn(samdb, domain_dn)
 447
 448             if complexity is not None:
 449                 if complexity == "on" or complexity == "default":
 450                     pwd_props = pwd_props | DOMAIN_PASSWORD_COMPLEX
 451                     msgs.append("Password complexity activated!")
 452                 elif complexity == "off":
 453                     pwd_props = pwd_props & (~DOMAIN_PASSWORD_COMPLEX)
 454                     msgs.append("Password complexity deactivated!")
 455
 456             if store_plaintext is not None:
 457                 if store_plaintext == "on" or store_plaintext == "default":
 458                     pwd_props = pwd_props | DOMAIN_PASSWORD_STORE_CLEARTEXT
 459                     msgs.append("Plaintext password storage for changed passwords activated!")
 460                 elif store_plaintext == "off":
 461                     pwd_props = pwd_props & (~DOMAIN_PASSWORD_STORE_CLEARTEXT)
 462                     msgs.append("Plaintext password storage for changed passwords deactivated!")
 463
 464             if complexity is not None or store_plaintext is not None:
 465                 m["pwdProperties"] = ldb.MessageElement(str(pwd_props),
 466                   ldb.FLAG_MOD_REPLACE, "pwdProperties")
 467
 468             if history_length is not None:
 469                 if history_length == "default":
 470                     pwd_hist_len = 24
 471                 else:
 472                     pwd_hist_len = int(history_length)
 473
 474                 if pwd_hist_len < 0 or pwd_hist_len > 24:
 475                     raise CommandError("Password history length must be in the range of 0 to 24!")
 476
 477                 m["pwdHistoryLength"] = ldb.MessageElement(str(pwd_hist_len),
 478                   ldb.FLAG_MOD_REPLACE, "pwdHistoryLength")
 479                 msgs.append("Password history length changed!")
 480
 481             if min_pwd_length is not None:
 482                 if min_pwd_length == "default":
 483                     min_pwd_len = 7
 484                 else:
 485                     min_pwd_len = int(min_pwd_length)
 486
 487                 if min_pwd_len < 0 or min_pwd_len > 14:
 488                     raise CommandError("Minimum password length must be in the range of 0 to 14!")
 489
 490                 m["minPwdLength"] = ldb.MessageElement(str(min_pwd_len),
 491                   ldb.FLAG_MOD_REPLACE, "minPwdLength")
 492                 msgs.append("Minimum password length changed!")
 493
 494             if min_pwd_age is not None:
 495                 if min_pwd_age == "default":
 496                     min_pwd_age = 1
 497                 else:
 498                     min_pwd_age = int(min_pwd_age)
 499
 500                 if min_pwd_age < 0 or min_pwd_age > 998:
 501                     raise CommandError("Minimum password age must be in the range of 0 to 998!")
 502
 503                 # days -> ticks
 504                 min_pwd_age_ticks = -int(min_pwd_age * (24 * 60 * 60 * 1e7))
 505
 506                 m["minPwdAge"] = ldb.MessageElement(str(min_pwd_age_ticks),
 507                   ldb.FLAG_MOD_REPLACE, "minPwdAge")
 508                 msgs.append("Minimum password age changed!")
 509
 510             if max_pwd_age is not None:
 511                 if max_pwd_age == "default":
 512                     max_pwd_age = 43
 513                 else:
 514                     max_pwd_age = int(max_pwd_age)
 515
 516                 if max_pwd_age < 0 or max_pwd_age > 999:
 517                     raise CommandError("Maximum password age must be in the range of 0 to 999!")
 518
 519                 # days -> ticks
 520                 if max_pwd_age == 0:
 521                     max_pwd_age_ticks = -0x8000000000000000
 522                 else:
 523                     max_pwd_age_ticks = -int(max_pwd_age * (24 * 60 * 60 * 1e7))
 524
 525                 m["maxPwdAge"] = ldb.MessageElement(str(max_pwd_age_ticks),
 526                   ldb.FLAG_MOD_REPLACE, "maxPwdAge")
 527                 msgs.append("Maximum password age changed!")
 528
 529             if max_pwd_age > 0 and min_pwd_age >= max_pwd_age:
 530                 raise CommandError("Maximum password age (%d) must be greater than minimum password age (%d)!" % (max_pwd_age, min_pwd_age))
 531
 532             if len(m) == 0:
 533                 raise CommandError("You must specify at least one option to set. Try --help")
 534             samdb.modify(m)
 535             msgs.append("All changes applied successfully!")
 536             self.message("\n".join(msgs))
 537         else:
 538             raise CommandError("Wrong argument '%s'!" % subcommand)
 539
 540
 541 class cmd_domain_samba3upgrade(Command):
 542     """Upgrade from Samba3 database to Samba4 AD database.
 543
 544     Specify either a directory with all samba3 databases and state files (with --dbdir) or
 545     samba3 testparm utility (with --testparm).
 546     """
 547
 548     synopsis = "%prog [options] <samba3_smb_conf>"
 549
 550     takes_optiongroups = {
 551         "sambaopts": options.SambaOptions,
 552         "versionopts": options.VersionOptions
 553     }
 554
 555     takes_options = [
 556         Option("--dbdir", type="string", metavar="DIR",
 557                   help="Path to samba3 database directory"),
 558         Option("--testparm", type="string", metavar="PATH",
 559                   help="Path to samba3 testparm utility from the previous installation.  This allows the default paths of the previous installation to be followed"),
 560         Option("--targetdir", type="string", metavar="DIR",
 561                   help="Path prefix where the new Samba 4.0 AD domain should be initialised"),
 562         Option("--quiet", help="Be quiet", action="store_true"),
 563         Option("--verbose", help="Be verbose", action="store_true"),
 564         Option("--use-xattrs", type="choice", choices=["yes","no","auto"], metavar="[yes|no|auto]",
 565                    help="Define if we should use the native fs capabilities or a tdb file for storing attributes likes ntacl, auto tries to make an inteligent guess based on the user rights and system capabilities", default="auto"),
 566     ]
 567
 568     takes_args = ["smbconf"]
 569
 570     def run(self, smbconf=None, targetdir=None, dbdir=None, testparm=None,
 571             quiet=False, verbose=False, use_xattrs=None, sambaopts=None, versionopts=None):
 572
 573         if not os.path.exists(smbconf):
 574             raise CommandError("File %s does not exist" % smbconf)
 575
 576         if testparm and not os.path.exists(testparm):
 577             raise CommandError("Testparm utility %s does not exist" % testparm)
 578
 579         if dbdir and not os.path.exists(dbdir):
 580             raise CommandError("Directory %s does not exist" % dbdir)
 581
 582         if not dbdir and not testparm:
 583             raise CommandError("Please specify either dbdir or testparm")
 584
 585         logger = self.get_logger()
 586         if verbose:
 587             logger.setLevel(logging.DEBUG)
 588         elif quiet:
 589             logger.setLevel(logging.WARNING)
 590         else:
 591             logger.setLevel(logging.INFO)
 592
 593         if dbdir and testparm:
 594             logger.warning("both dbdir and testparm specified, ignoring dbdir.")
 595             dbdir = None
 596
 597         lp = sambaopts.get_loadparm()
 598
 599         s3conf = s3param.get_context()
 600
 601         if sambaopts.realm:
 602             s3conf.set("realm", sambaopts.realm)
 603
 604         eadb = True
 605         if use_xattrs == "yes":
 606             eadb = False
 607         elif use_xattrs == "auto" and not s3conf.get("posix:eadb"):
 608             if targetdir:
 609                 tmpfile = tempfile.NamedTemporaryFile(prefix=os.path.abspath(targetdir))
 610             else:
 611                 tmpfile = tempfile.NamedTemporaryFile(prefix=os.path.abspath(os.path.dirname(lp.get("private dir"))))
 612             try:
 613                 samba.ntacls.setntacl(lp, tmpfile.name,
 614                             "O:S-1-5-32G:S-1-5-32", "S-1-5-32", "native")
 615                 eadb = False
 616             except:
 617                 # FIXME: Don't catch all exceptions here
 618                 logger.info("You are not root or your system do not support xattr, using tdb backend for attributes. "
 619                             "If you intend to use this provision in production, rerun the script as root on a system supporting xattrs.")
 620             tmpfile.close()
 621
 622         # Set correct default values from dbdir or testparm
 623         paths = {}
 624         if dbdir:
 625             paths["state directory"] = dbdir
 626             paths["private dir"] = dbdir
 627             paths["lock directory"] = dbdir
 628         else:
 629             paths["state directory"] = get_testparm_var(testparm, smbconf, "state directory")
 630             paths["private dir"] = get_testparm_var(testparm, smbconf, "private dir")
 631             paths["lock directory"] = get_testparm_var(testparm, smbconf, "lock directory")
 632             # "testparm" from Samba 3 < 3.4.x is not aware of the parameter
 633             # "state directory", instead make use of "lock directory"
 634             if len(paths["state directory"]) == 0:
 635                 paths["state directory"] = paths["lock directory"]
 636
 637         for p in paths:
 638             s3conf.set(p, paths[p])
 639
 640         # load smb.conf parameters
 641         logger.info("Reading smb.conf")
 642         s3conf.load(smbconf)
 643         samba3 = Samba3(smbconf, s3conf)
 644
 645         logger.info("Provisioning")
 646         upgrade_from_samba3(samba3, logger, targetdir, session_info=system_session(),
 647                             useeadb=eadb)
 648
 649 class cmd_domain(SuperCommand):
 650     """Domain management"""
 651
 652     subcommands = {}
 653     subcommands["exportkeytab"] = cmd_domain_export_keytab()
 654     subcommands["info"] = cmd_domain_info()
 655     subcommands["join"] = cmd_domain_join()
 656     subcommands["level"] = cmd_domain_level()
 657     subcommands["passwordsettings"] = cmd_domain_passwordsettings()
 658     subcommands["samba3upgrade"] = cmd_domain_samba3upgrade()