s4-s3-upgrade: convert password age policies to the negative NTTIME format
[amitay/samba.git] / source4 / scripting / python / samba / upgrade.py
1 # backend code for upgrading from Samba3
2 # Copyright Jelmer Vernooij 2005-2007
3 #
4 # This program is free software; you can redistribute it and/or modify
5 # it under the terms of the GNU General Public License as published by
6 # the Free Software Foundation; either version 3 of the License, or
7 # (at your option) any later version.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 # GNU General Public License for more details.
13 #
14 # You should have received a copy of the GNU General Public License
15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 #
17
18 """Support code for upgrading from Samba 3 to Samba 4."""
19
20 __docformat__ = "restructuredText"
21
22 import grp
23 import ldb
24 import time
25 import pwd
26
27 from samba import Ldb, registry
28 from samba.param import LoadParm
29 from samba.provision import provision, FILL_FULL, ProvisioningError
30 from samba.samba3 import passdb
31 from samba.samba3 import param as s3param
32 from samba.dcerpc import lsa, samr, security
33 from samba.dcerpc.security import dom_sid
34 from samba import dsdb
35 from samba.ndr import ndr_pack
36 from samba import unix2nttime
37
38 def import_sam_policy(samdb, policy, logger):
39     """Import a Samba 3 policy.
40
41     :param samdb: Samba4 SAM database
42     :param policy: Samba3 account policy
43     :param logger: Logger object
44     """
45
46     # Following entries are used -
47     #    min password length, password history, minimum password age,
48     #    maximum password age, lockout duration
49     #
50     # Following entries are not used -
51     #    reset count minutes, user must logon to change password,
52     #    bad lockout minutes, disconnect time
53
54     m = ldb.Message()
55     m.dn = samdb.get_default_basedn()
56     m['a01'] = ldb.MessageElement(str(unix2nttime(policy['min password length'])), ldb.FLAG_MOD_REPLACE,
57                             'minPwdLength')
58     m['a02'] = ldb.MessageElement(str(policy['password history']), ldb.FLAG_MOD_REPLACE,
59                             'pwdHistoryLength')
60
61     min_pw_age_unix = policy['minimum password age']
62     min_pw_age_nt = 0 - unix2nttime(min_pw_age_unix)
63     m['a03'] = ldb.MessageElement(str(min_pw_age_nt), ldb.FLAG_MOD_REPLACE, 'minPwdAge')
64
65     max_pw_age_unix = policy['maximum password age']
66     if (max_pw_age_unix == 0xFFFFFFFF):
67         max_pw_age_nt = 0
68     else:
69         max_pw_age_nt = unix2nttime(max_pw_age_unix)
70
71     m['a04'] = ldb.MessageElement(str(max_pw_age_nt), ldb.FLAG_MOD_REPLACE,
72                                   'maxPwdAge')
73
74     lockout_duration_mins = policy['lockout duration']
75     lockout_duration_nt = unix2nttime(lockout_duration_mins * 60)
76
77     m['a05'] = ldb.MessageElement(str(lockout_duration_nt), ldb.FLAG_MOD_REPLACE,
78                                   'lockoutDuration')
79
80     try:
81         samdb.modify(m)
82     except ldb.LdbError, e:
83         logger.warn("Could not set account policy, (%s)", str(e))
84
85
86 def add_idmap_entry(idmapdb, sid, xid, xid_type, logger):
87     """Create idmap entry
88
89     :param idmapdb: Samba4 IDMAP database
90     :param sid: user/group sid
91     :param xid: user/group id
92     :param xid_type: type of id (UID/GID)
93     :param logger: Logger object
94     """
95
96     # First try to see if we already have this entry
97     found = False
98     msg = idmapdb.search(expression='objectSid=%s' % str(sid))
99     if msg.count == 1:
100         found = True
101
102     if found:
103         try:
104             m = ldb.Message()
105             m.dn = msg[0]['dn']
106             m['xidNumber'] = ldb.MessageElement(str(xid), ldb.FLAG_MOD_REPLACE, 'xidNumber')
107             m['type'] = ldb.MessageElement(xid_type, ldb.FLAG_MOD_REPLACE, 'type')
108             idmapdb.modify(m)
109         except ldb.LdbError, e:
110             logger.warn('Could not modify idmap entry for sid=%s, id=%s, type=%s (%s)',
111                             str(sid), str(xid), xid_type, str(e))
112     else:
113         try:
114             idmapdb.add({"dn": "CN=%s" % str(sid),
115                         "cn": str(sid),
116                         "objectClass": "sidMap",
117                         "objectSid": ndr_pack(sid),
118                         "type": xid_type,
119                         "xidNumber": str(xid)})
120         except ldb.LdbError, e:
121             logger.warn('Could not add idmap entry for sid=%s, id=%s, type=%s (%s)',
122                             str(sid), str(xid), xid_type, str(e))
123
124
125 def import_idmap(idmapdb, samba3, logger):
126     """Import idmap data.
127
128     :param idmapdb: Samba4 IDMAP database
129     :param samba3_idmap: Samba3 IDMAP database to import from
130     :param logger: Logger object
131     """
132
133     try:
134         samba3_idmap = samba3.get_idmap_db()
135     except IOError as (errno, strerror):
136         logger.warn('Cannot open idmap database, Ignoring: ({0}): {1}'.format(errno, strerror))
137         return
138
139     currentxid = max(samba3_idmap.get_user_hwm(), samba3_idmap.get_group_hwm())
140     lowerbound = currentxid
141     # FIXME: upperbound
142
143     m = ldb.Message()
144     m.dn = ldb.Dn(idmapdb, 'CN=CONFIG')
145     m['lowerbound'] = ldb.MessageElement(str(lowerbound), ldb.FLAG_MOD_REPLACE, 'lowerBound')
146     m['xidNumber'] = ldb.MessageElement(str(currentxid), ldb.FLAG_MOD_REPLACE, 'xidNumber')
147     idmapdb.modify(m)
148
149     for id_type, xid in samba3_idmap.ids():
150         if id_type == 'UID':
151             xid_type = 'ID_TYPE_UID'
152         elif id_type == 'GID':
153             xid_type = 'ID_TYPE_GID'
154         else:
155             logger.warn('Wrong type of entry in idmap (%s), Ignoring', id_type)
156             continue
157
158         sid = samba3_idmap.get_sid(xid, id_type)
159         add_idmap_entry(idmapdb, dom_sid(sid), xid, xid_type, logger)
160
161
162 def add_group_from_mapping_entry(samdb, groupmap, logger):
163     """Add or modify group from group mapping entry
164
165     param samdb: Samba4 SAM database
166     param groupmap: Groupmap entry
167     param logger: Logger object
168     """
169
170     # First try to see if we already have this entry
171     try:
172         msg = samdb.search(base='<SID=%s>' % str(groupmap.sid), scope=ldb.SCOPE_BASE)
173         found = True
174     except ldb.LdbError, (ecode, emsg):
175         if ecode == ldb.ERR_NO_SUCH_OBJECT:
176             found = False
177         else:
178             raise ldb.LdbError(ecode, emsg)
179
180     if found:
181         logger.warn('Group already exists sid=%s, groupname=%s existing_groupname=%s, Ignoring.',
182                             str(groupmap.sid), groupmap.nt_name, msg[0]['sAMAccountName'][0])
183     else:
184         if groupmap.sid_name_use == lsa.SID_NAME_WKN_GRP:
185             # In a lot of Samba3 databases, aliases are marked as well known groups
186             (group_dom_sid, rid) = group.sid.split()
187             if (group_dom_sid != security.dom_sid(security.SID_BUILTIN)):
188                 return
189
190         m = ldb.Message()
191         m.dn = ldb.Dn(samdb, "CN=%s,CN=Users,%s" % (groupmap.nt_name, samdb.get_default_basedn()))
192         m['a01'] = ldb.MessageElement(groupmap.nt_name, ldb.FLAG_MOD_ADD, 'cn')
193         m['a02'] = ldb.MessageElement('group', ldb.FLAG_MOD_ADD, 'objectClass')
194         m['a03'] = ldb.MessageElement(ndr_pack(groupmap.sid), ldb.FLAG_MOD_ADD, 'objectSid')
195         m['a04'] = ldb.MessageElement(groupmap.comment, ldb.FLAG_MOD_ADD, 'description')
196         m['a05'] = ldb.MessageElement(groupmap.nt_name, ldb.FLAG_MOD_ADD, 'sAMAccountName')
197
198         # Fix up incorrect 'well known' groups that are actually builtin (per test above) to be aliases
199         if groupmap.sid_name_use == lsa.SID_NAME_ALIAS or groupmap.sid_name_use == lsa.SID_NAME_WKN_GRP:
200             m['a06'] = ldb.MessageElement(str(dsdb.GTYPE_SECURITY_DOMAIN_LOCAL_GROUP), ldb.FLAG_MOD_ADD, 'groupType')
201
202         try:
203             samdb.add(m, controls=["relax:0"])
204         except ldb.LdbError, e:
205             logger.warn('Could not add group name=%s (%s)', groupmap.nt_name, str(e))
206
207
208 def add_users_to_group(samdb, group, members, logger):
209     """Add user/member to group/alias
210
211     param samdb: Samba4 SAM database
212     param group: Groupmap object
213     param members: List of member SIDs
214     param logger: Logger object
215     """
216     for member_sid in members:
217         m = ldb.Message()
218         m.dn = ldb.Dn(samdb, "<SID=%s>" % str(group.sid))
219         m['a01'] = ldb.MessageElement("<SID=%s>" % str(member_sid), ldb.FLAG_MOD_ADD, 'member')
220
221         try:
222             samdb.modify(m)
223         except ldb.LdbError, (ecode, emsg):
224             if ecode == ldb.ERR_ENTRY_ALREADY_EXISTS:
225                 logger.info("skipped re-adding member '%s' to group '%s': %s", member_sid, group.sid, emsg)
226             elif ecode == ldb.ERR_NO_SUCH_OBJECT:
227                 raise ProvisioningError("Could not add member '%s' to group '%s' as either group or user record doesn't exist: %s" % (member_sid, group.sid, emsg))
228             else:
229                 raise ProvisioningError("Could not add member '%s' to group '%s': %s" % (member_sid, group.sid, emsg))
230
231
232 def import_wins(samba4_winsdb, samba3_winsdb):
233     """Import settings from a Samba3 WINS database.
234
235     :param samba4_winsdb: WINS database to import to
236     :param samba3_winsdb: WINS database to import from
237     """
238     version_id = 0
239
240     for (name, (ttl, ips, nb_flags)) in samba3_winsdb.items():
241         version_id+=1
242
243         type = int(name.split("#", 1)[1], 16)
244
245         if type == 0x1C:
246             rType = 0x2
247         elif type & 0x80:
248             if len(ips) > 1:
249                 rType = 0x2
250             else:
251                 rType = 0x1
252         else:
253             if len(ips) > 1:
254                 rType = 0x3
255             else:
256                 rType = 0x0
257
258         if ttl > time.time():
259             rState = 0x0 # active
260         else:
261             rState = 0x1 # released
262
263         nType = ((nb_flags & 0x60)>>5)
264
265         samba4_winsdb.add({"dn": "name=%s,type=0x%s" % tuple(name.split("#")),
266                            "type": name.split("#")[1],
267                            "name": name.split("#")[0],
268                            "objectClass": "winsRecord",
269                            "recordType": str(rType),
270                            "recordState": str(rState),
271                            "nodeType": str(nType),
272                            "expireTime": ldb.timestring(ttl),
273                            "isStatic": "0",
274                            "versionID": str(version_id),
275                            "address": ips})
276
277     samba4_winsdb.add({"dn": "cn=VERSION",
278                        "cn": "VERSION",
279                        "objectClass": "winsMaxVersion",
280                        "maxVersion": str(version_id)})
281
282 def enable_samba3sam(samdb, ldapurl):
283     """Enable Samba 3 LDAP URL database.
284
285     :param samdb: SAM Database.
286     :param ldapurl: Samba 3 LDAP URL
287     """
288     samdb.modify_ldif("""
289 dn: @MODULES
290 changetype: modify
291 replace: @LIST
292 @LIST: samldb,operational,objectguid,rdn_name,samba3sam
293 """)
294
295     samdb.add({"dn": "@MAP=samba3sam", "@MAP_URL": ldapurl})
296
297
298 smbconf_keep = [
299     "dos charset",
300     "unix charset",
301     "display charset",
302     "comment",
303     "path",
304     "directory",
305     "workgroup",
306     "realm",
307     "netbios name",
308     "netbios aliases",
309     "netbios scope",
310     "server string",
311     "interfaces",
312     "bind interfaces only",
313     "security",
314     "auth methods",
315     "encrypt passwords",
316     "null passwords",
317     "obey pam restrictions",
318     "password server",
319     "smb passwd file",
320     "private dir",
321     "passwd chat",
322     "password level",
323     "lanman auth",
324     "ntlm auth",
325     "client NTLMv2 auth",
326     "client lanman auth",
327     "client plaintext auth",
328     "read only",
329     "hosts allow",
330     "hosts deny",
331     "log level",
332     "debuglevel",
333     "log file",
334     "smb ports",
335     "large readwrite",
336     "max protocol",
337     "min protocol",
338     "unicode",
339     "read raw",
340     "write raw",
341     "disable netbios",
342     "nt status support",
343     "max mux",
344     "max xmit",
345     "name resolve order",
346     "max wins ttl",
347     "min wins ttl",
348     "time server",
349     "unix extensions",
350     "use spnego",
351     "server signing",
352     "client signing",
353     "max connections",
354     "paranoid server security",
355     "socket options",
356     "strict sync",
357     "max print jobs",
358     "printable",
359     "print ok",
360     "printer name",
361     "printer",
362     "map system",
363     "map hidden",
364     "map archive",
365     "preferred master",
366     "prefered master",
367     "local master",
368     "browseable",
369     "browsable",
370     "wins server",
371     "wins support",
372     "csc policy",
373     "strict locking",
374     "preload",
375     "auto services",
376     "lock dir",
377     "lock directory",
378     "pid directory",
379     "socket address",
380     "copy",
381     "include",
382     "available",
383     "volume",
384     "fstype",
385     "panic action",
386     "msdfs root",
387     "host msdfs",
388     "winbind separator"]
389
390 def upgrade_smbconf(oldconf,mark):
391     """Remove configuration variables not present in Samba4
392
393     :param oldconf: Old configuration structure
394     :param mark: Whether removed configuration variables should be
395         kept in the new configuration as "samba3:<name>"
396     """
397     data = oldconf.data()
398     newconf = LoadParm()
399
400     for s in data:
401         for p in data[s]:
402             keep = False
403             for k in smbconf_keep:
404                 if smbconf_keep[k] == p:
405                     keep = True
406                     break
407
408             if keep:
409                 newconf.set(s, p, oldconf.get(s, p))
410             elif mark:
411                 newconf.set(s, "samba3:"+p, oldconf.get(s,p))
412
413     return newconf
414
415 SAMBA3_PREDEF_NAMES = {
416         'HKLM': registry.HKEY_LOCAL_MACHINE,
417 }
418
419 def import_registry(samba4_registry, samba3_regdb):
420     """Import a Samba 3 registry database into the Samba 4 registry.
421
422     :param samba4_registry: Samba 4 registry handle.
423     :param samba3_regdb: Samba 3 registry database handle.
424     """
425     def ensure_key_exists(keypath):
426         (predef_name, keypath) = keypath.split("/", 1)
427         predef_id = SAMBA3_PREDEF_NAMES[predef_name]
428         keypath = keypath.replace("/", "\\")
429         return samba4_registry.create_key(predef_id, keypath)
430
431     for key in samba3_regdb.keys():
432         key_handle = ensure_key_exists(key)
433         for subkey in samba3_regdb.subkeys(key):
434             ensure_key_exists(subkey)
435         for (value_name, (value_type, value_data)) in samba3_regdb.values(key).items():
436             key_handle.set_value(value_name, value_type, value_data)
437
438
439 def upgrade_from_samba3(samba3, logger, targetdir, session_info=None, useeadb=False):
440     """Upgrade from samba3 database to samba4 AD database
441
442     :param samba3: samba3 object
443     :param logger: Logger object
444     :param targetdir: samba4 database directory
445     :param session_info: Session information
446     """
447
448     if samba3.lp.get("domain logons"):
449         serverrole = "domain controller"
450     else:
451         if samba3.lp.get("security") == "user":
452             serverrole = "standalone"
453         else:
454             serverrole = "member server"
455
456     domainname = samba3.lp.get("workgroup")
457     realm = samba3.lp.get("realm")
458     netbiosname = samba3.lp.get("netbios name")
459
460     # secrets db
461     secrets_db = samba3.get_secrets_db()
462
463     if not domainname:
464         domainname = secrets_db.domains()[0]
465         logger.warning("No workgroup specified in smb.conf file, assuming '%s'",
466                 domainname)
467
468     if not realm:
469         if serverrole == "domain controller":
470             raise ProvisioningError("No realm specified in smb.conf file and being a DC. That upgrade path doesn't work! Please add a 'realm' directive to your old smb.conf to let us know which one you want to use (it is the DNS name of the AD domain you wish to create.")
471         else:
472             realm = domainname.upper()
473             logger.warning("No realm specified in smb.conf file, assuming '%s'",
474                     realm)
475
476     # Find machine account and password
477     machinepass = None
478     machinerid = None
479     machinesid = None
480     next_rid = 1000
481
482     try:
483         machinepass = secrets_db.get_machine_password(netbiosname)
484     except:
485         pass
486
487     # We must close the direct pytdb database before the C code loads it
488     secrets_db.close()
489
490     # Connect to old password backend
491     passdb.set_secrets_dir(samba3.lp.get("private dir"))
492     s3db = samba3.get_sam_db()
493
494     # Get domain sid
495     try:
496         domainsid = passdb.get_global_sam_sid()
497     except passdb.error:
498         raise Exception("Can't find domain sid for '%s', Exiting." % domainname)
499
500     # Get machine account, sid, rid
501     try:
502         machineacct = s3db.getsampwnam('%s$' % netbiosname)
503         machinesid, machinerid = machineacct.user_sid.split()
504     except:
505         pass
506
507     # Export account policy
508     logger.info("Exporting account policy")
509     policy = s3db.get_account_policy()
510
511     # Export groups from old passdb backend
512     logger.info("Exporting groups")
513     grouplist = s3db.enum_group_mapping()
514     groupmembers = {}
515     for group in grouplist:
516         sid, rid = group.sid.split()
517         if sid == domainsid:
518             if rid >= next_rid:
519                next_rid = rid + 1
520
521         # Get members for each group/alias
522         if group.sid_name_use == lsa.SID_NAME_ALIAS:
523             members = s3db.enum_aliasmem(group.sid)
524         elif group.sid_name_use == lsa.SID_NAME_DOM_GRP:
525             try:
526                 members = s3db.enum_group_members(group.sid)
527             except:
528                 continue
529             groupmembers[group.nt_name] = members
530         elif group.sid_name_use == lsa.SID_NAME_WKN_GRP:
531             (group_dom_sid, rid) = group.sid.split()
532             if (group_dom_sid != security.dom_sid(security.SID_BUILTIN)):
533                 logger.warn("Ignoring 'well known' group '%s' (should already be in AD, and have no members)",
534                             group.nt_name)
535                 continue
536             # A number of buggy databases mix up well known groups and aliases.
537             members = s3db.enum_aliasmem(group.sid)
538         else:
539             logger.warn("Ignoring group '%s' with sid_name_use=%d",
540                         group.nt_name, group.sid_name_use)
541             continue
542
543
544     # Export users from old passdb backend
545     logger.info("Exporting users")
546     userlist = s3db.search_users(0)
547     userdata = {}
548     uids = {}
549     admin_user = None
550     for entry in userlist:
551         if machinerid and machinerid == entry['rid']:
552             continue
553         username = entry['account_name']
554         if entry['rid'] < 1000:
555             logger.info("  Skipping wellknown rid=%d (for username=%s)", entry['rid'], username)
556             continue
557         if entry['rid'] >= next_rid:
558             next_rid = entry['rid'] + 1
559
560         user = s3db.getsampwnam(username)
561         acct_type = (user.acct_ctrl & (samr.ACB_NORMAL|samr.ACB_WSTRUST|samr.ACB_SVRTRUST|samr.ACB_DOMTRUST))
562         if (acct_type == samr.ACB_NORMAL or acct_type == samr.ACB_WSTRUST or acct_type == samr.ACB_SVRTRUST):
563             pass
564         elif acct_type == samr.ACB_DOMTRUST:
565             logger.warn("  Skipping inter-domain trust from domain %s, this trust must be re-created as an AD trust" % username[:-1])
566             continue
567         elif acct_type == (samr.ACB_NORMAL|samr.ACB_WSTRUST) and username[-1] == '$':
568             logger.warn("  Fixing account %s which had both ACB_NORMAL (U) and ACB_WSTRUST (W) set.  Account will be marked as ACB_WSTRUST (W), i.e. as a domain member" % username)
569             user.acct_ctrl = (user.acct_ctrl & ~samr.ACB_NORMAL)
570         else:
571             raise ProvisioningError("""Failed to upgrade due to invalid account %s, account control flags 0x%08X must have exactly one of
572 ACB_NORMAL (N, 0x%08X), ACB_WSTRUST (W 0x%08X), ACB_SVRTRUST (S 0x%08X) or ACB_DOMTRUST (D 0x%08X).
573
574 Please fix this account before attempting to upgrade again
575 """
576                                     % (user.acct_flags, username,
577                                        samr.ACB_NORMAL, samr.ACB_WSTRUST, samr.ACB_SVRTRUST, samr.ACB_DOMTRUST))
578         
579         userdata[username] = user
580         try:
581             uids[username] = s3db.sid_to_id(user.user_sid)[0]
582         except:
583             try:
584                 uids[username] = pwd.getpwnam(username).pw_uid
585             except:
586                 pass
587
588         if not admin_user and username.lower() == 'root':
589             admin_user = username
590         if username.lower() == 'administrator':
591             admin_user = username
592
593     logger.info("Next rid = %d", next_rid)
594
595     # Do full provision
596     result = provision(logger, session_info, None,
597                        targetdir=targetdir, realm=realm, domain=domainname,
598                        domainsid=str(domainsid), next_rid=next_rid,
599                        dc_rid=machinerid,
600                        hostname=netbiosname, machinepass=machinepass,
601                        serverrole=serverrole, samdb_fill=FILL_FULL,
602                        useeadb=useeadb)
603
604     # Import WINS database
605     logger.info("Importing WINS database")
606     import_wins(Ldb(result.paths.winsdb), samba3.get_wins_db())
607
608     # Set Account policy
609     logger.info("Importing Account policy")
610     import_sam_policy(result.samdb, policy, logger)
611
612     # Migrate IDMAP database
613     logger.info("Importing idmap database")
614     import_idmap(result.idmap, samba3, logger)
615
616     # Set the s3 context for samba4 configuration
617     new_lp_ctx = s3param.get_context()
618     new_lp_ctx.load(result.lp.configfile)
619     new_lp_ctx.set("private dir", result.lp.get("private dir"))
620     new_lp_ctx.set("state directory", result.lp.get("state directory"))
621     new_lp_ctx.set("lock directory", result.lp.get("lock directory"))
622
623     # Connect to samba4 backend
624     s4_passdb = passdb.PDB(new_lp_ctx.get("passdb backend"))
625
626     # Export groups to samba4 backend
627     logger.info("Importing groups")
628     for g in grouplist:
629         # Ignore uninitialized groups (gid = -1)
630         if g.gid != 0xffffffff:
631             add_idmap_entry(result.idmap, g.sid, g.gid, "GID", logger)
632             add_group_from_mapping_entry(result.samdb, g, logger)
633
634     # Export users to samba4 backend
635     logger.info("Importing users")
636     for username in userdata:
637         if username.lower() == 'administrator' or username.lower() == 'root':
638             continue
639         s4_passdb.add_sam_account(userdata[username])
640         if username in uids:
641             add_idmap_entry(result.idmap, userdata[username].user_sid, uids[username], "UID", logger)
642
643     logger.info("Adding users to groups")
644     for g in grouplist:
645         if g.nt_name in groupmembers:
646             add_users_to_group(result.samdb, g, groupmembers[g.nt_name], logger)
647
648     # Set password for administrator
649     if admin_user:
650         logger.info("Setting password for administrator")
651         admin_userdata = s4_passdb.getsampwnam("administrator")
652         admin_userdata.nt_passwd = userdata[admin_user].nt_passwd
653         if userdata[admin_user].lanman_passwd:
654             admin_userdata.lanman_passwd = userdata[admin_user].lanman_passwd
655         admin_userdata.pass_last_set_time = userdata[admin_user].pass_last_set_time
656         if userdata[admin_user].pw_history:
657             admin_userdata.pw_history = userdata[admin_user].pw_history
658         s4_passdb.update_sam_account(admin_userdata)
659         logger.info("Administrator password has been set to password of user '%s'", admin_user)
660
661     # FIXME: import_registry(registry.Registry(), samba3.get_registry())
662     # FIXME: shares