s4-provision Add an invalid names check for 'domain == netbiosname'
[nivanova/samba-autobuild/.git] / source4 / scripting / python / samba / samba3.py
1 # Unix SMB/CIFS implementation.
2 # Copyright (C) Jelmer Vernooij <jelmer@samba.org> 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 for reading Samba 3 data files."""
19
20 __docformat__ = "restructuredText"
21
22 REGISTRY_VALUE_PREFIX = "SAMBA_REGVAL"
23 REGISTRY_DB_VERSION = 1
24
25 import os
26 import struct
27 import tdb
28
29
30 def fetch_uint32(tdb, key):
31     try:
32         data = tdb[key]
33     except KeyError:
34         return None
35     assert len(data) == 4
36     return struct.unpack("<L", data)[0]
37
38
39 def fetch_int32(tdb, key):
40     try:
41         data = tdb[key]
42     except KeyError:
43         return None
44     assert len(data) == 4
45     return struct.unpack("<l", data)[0]
46
47
48 class TdbDatabase(object):
49     """Simple Samba 3 TDB database reader."""
50     def __init__(self, file):
51         """Open a file.
52
53         :param file: Path of the file to open.
54         """
55         self.tdb = tdb.Tdb(file, flags=os.O_RDONLY)
56         self._check_version()
57
58     def _check_version(self):
59         pass
60
61     def close(self):
62         """Close resources associated with this object."""
63         self.tdb.close()
64
65
66 class Registry(TdbDatabase):
67     """Simple read-only support for reading the Samba3 registry.
68
69     :note: This object uses the same syntax for registry key paths as 
70         Samba 3. This particular format uses forward slashes for key path 
71         separators and abbreviations for the predefined key names. 
72         e.g.: HKLM/Software/Bar.
73     """
74     def __len__(self):
75         """Return the number of keys."""
76         return len(self.keys())
77
78     def keys(self):
79         """Return list with all the keys."""
80         return [k.rstrip("\x00") for k in self.tdb.iterkeys() if not k.startswith(REGISTRY_VALUE_PREFIX)]
81
82     def subkeys(self, key):
83         """Retrieve the subkeys for the specified key.
84
85         :param key: Key path.
86         :return: list with key names
87         """
88         data = self.tdb.get("%s\x00" % key)
89         if data is None:
90             return []
91         (num, ) = struct.unpack("<L", data[0:4])
92         keys = data[4:].split("\0")
93         assert keys[-1] == ""
94         keys.pop()
95         assert len(keys) == num
96         return keys
97
98     def values(self, key):
99         """Return a dictionary with the values set for a specific key.
100         
101         :param key: Key to retrieve values for.
102         :return: Dictionary with value names as key, tuple with type and 
103             data as value."""
104         data = self.tdb.get("%s/%s\x00" % (REGISTRY_VALUE_PREFIX, key))
105         if data is None:
106             return {}
107         ret = {}
108         (num, ) = struct.unpack("<L", data[0:4])
109         data = data[4:]
110         for i in range(num):
111             # Value name
112             (name, data) = data.split("\0", 1)
113
114             (type, ) = struct.unpack("<L", data[0:4])
115             data = data[4:]
116             (value_len, ) = struct.unpack("<L", data[0:4])
117             data = data[4:]
118
119             ret[name] = (type, data[:value_len])
120             data = data[value_len:]
121
122         return ret
123
124
125 class PolicyDatabase(TdbDatabase):
126     """Samba 3 Account Policy database reader."""
127     def __init__(self, file):
128         """Open a policy database
129         
130         :param file: Path to the file to open.
131         """
132         super(PolicyDatabase, self).__init__(file)
133         self.min_password_length = fetch_uint32(self.tdb, "min password length\x00")
134         self.password_history = fetch_uint32(self.tdb, "password history\x00")
135         self.user_must_logon_to_change_password = fetch_uint32(self.tdb, "user must logon to change pasword\x00")
136         self.maximum_password_age = fetch_uint32(self.tdb, "maximum password age\x00")
137         self.minimum_password_age = fetch_uint32(self.tdb, "minimum password age\x00")
138         self.lockout_duration = fetch_uint32(self.tdb, "lockout duration\x00")
139         self.reset_count_minutes = fetch_uint32(self.tdb, "reset count minutes\x00")
140         self.bad_lockout_minutes = fetch_uint32(self.tdb, "bad lockout minutes\x00")
141         self.disconnect_time = fetch_int32(self.tdb, "disconnect time\x00")
142         self.refuse_machine_password_change = fetch_uint32(self.tdb, "refuse machine password change\x00")
143
144         # FIXME: Read privileges as well
145
146
147 GROUPDB_DATABASE_VERSION_V1 = 1 # native byte format.
148 GROUPDB_DATABASE_VERSION_V2 = 2 # le format.
149
150 GROUP_PREFIX = "UNIXGROUP/"
151
152 # Alias memberships are stored reverse, as memberships. The performance
153 # critical operation is to determine the aliases a SID is member of, not
154 # listing alias members. So we store a list of alias SIDs a SID is member of
155 # hanging of the member as key.
156 MEMBEROF_PREFIX = "MEMBEROF/"
157
158 class GroupMappingDatabase(TdbDatabase):
159     """Samba 3 group mapping database reader."""
160     def _check_version(self):
161         assert fetch_int32(self.tdb, "INFO/version\x00") in (GROUPDB_DATABASE_VERSION_V1, GROUPDB_DATABASE_VERSION_V2)
162
163     def groupsids(self):
164         """Retrieve the SIDs for the groups in this database.
165
166         :return: List with sids as strings.
167         """
168         for k in self.tdb.iterkeys():
169             if k.startswith(GROUP_PREFIX):
170                 yield k[len(GROUP_PREFIX):].rstrip("\0")
171
172     def get_group(self, sid):
173         """Retrieve the group mapping information for a particular group.
174
175         :param sid: SID of the group
176         :return: None if the group can not be found, otherwise 
177             a tuple with gid, sid_name_use, the NT name and comment.
178         """
179         data = self.tdb.get("%s%s\0" % (GROUP_PREFIX, sid))
180         if data is None:
181             return data
182         (gid, sid_name_use) = struct.unpack("<lL", data[0:8])
183         (nt_name, comment, _) = data[8:].split("\0")
184         return (gid, sid_name_use, nt_name, comment)
185
186     def aliases(self):
187         """Retrieve the aliases in this database."""
188         for k in self.tdb.iterkeys():
189             if k.startswith(MEMBEROF_PREFIX):
190                 yield k[len(MEMBEROF_PREFIX):].rstrip("\0")
191
192
193 # High water mark keys
194 IDMAP_HWM_GROUP = "GROUP HWM\0"
195 IDMAP_HWM_USER = "USER HWM\0"
196
197 IDMAP_GROUP_PREFIX = "GID "
198 IDMAP_USER_PREFIX = "UID "
199
200 # idmap version determines auto-conversion
201 IDMAP_VERSION_V2 = 2
202
203 class IdmapDatabase(TdbDatabase):
204     """Samba 3 ID map database reader."""
205     def _check_version(self):
206         assert fetch_int32(self.tdb, "IDMAP_VERSION\0") == IDMAP_VERSION_V2
207
208     def uids(self):
209         """Retrieve a list of all uids in this database."""
210         for k in self.tdb.iterkeys():
211             if k.startswith(IDMAP_USER_PREFIX):
212                 yield int(k[len(IDMAP_USER_PREFIX):].rstrip("\0"))
213
214     def gids(self):
215         """Retrieve a list of all gids in this database."""
216         for k in self.tdb.iterkeys():
217             if k.startswith(IDMAP_GROUP_PREFIX):
218                 yield int(k[len(IDMAP_GROUP_PREFIX):].rstrip("\0"))
219
220     def get_user_sid(self, uid):
221         """Retrieve the SID associated with a particular uid.
222
223         :param uid: UID to retrieve SID for.
224         :return: A SID or None if no mapping was found.
225         """
226         data = self.tdb.get("%s%d\0" % (IDMAP_USER_PREFIX, uid))
227         if data is None:
228             return data
229         return data.rstrip("\0")
230
231     def get_group_sid(self, gid):
232         data = self.tdb.get("%s%d\0" % (IDMAP_GROUP_PREFIX, gid))
233         if data is None:
234             return data
235         return data.rstrip("\0")
236
237     def get_user_hwm(self):
238         """Obtain the user high-water mark."""
239         return fetch_uint32(self.tdb, IDMAP_HWM_USER)
240
241     def get_group_hwm(self):
242         """Obtain the group high-water mark."""
243         return fetch_uint32(self.tdb, IDMAP_HWM_GROUP)
244
245
246 class SecretsDatabase(TdbDatabase):
247     """Samba 3 Secrets database reader."""
248     def get_auth_password(self):
249         return self.tdb.get("SECRETS/AUTH_PASSWORD")
250
251     def get_auth_domain(self):
252         return self.tdb.get("SECRETS/AUTH_DOMAIN")
253
254     def get_auth_user(self):
255         return self.tdb.get("SECRETS/AUTH_USER")
256
257     def get_domain_guid(self, host):
258         return self.tdb.get("SECRETS/DOMGUID/%s" % host)
259
260     def ldap_dns(self):
261         for k in self.tdb.iterkeys():
262             if k.startswith("SECRETS/LDAP_BIND_PW/"):
263                 yield k[len("SECRETS/LDAP_BIND_PW/"):].rstrip("\0")
264
265     def domains(self):
266         """Iterate over domains in this database.
267
268         :return: Iterator over the names of domains in this database.
269         """
270         for k in self.tdb.iterkeys():
271             if k.startswith("SECRETS/SID/"):
272                 yield k[len("SECRETS/SID/"):].rstrip("\0")
273
274     def get_ldap_bind_pw(self, host):
275         return self.tdb.get("SECRETS/LDAP_BIND_PW/%s" % host)
276     
277     def get_afs_keyfile(self, host):
278         return self.tdb.get("SECRETS/AFS_KEYFILE/%s" % host)
279
280     def get_machine_sec_channel_type(self, host):
281         return fetch_uint32(self.tdb, "SECRETS/MACHINE_SEC_CHANNEL_TYPE/%s" % host)
282
283     def get_machine_last_change_time(self, host):
284         return fetch_uint32(self.tdb, "SECRETS/MACHINE_LAST_CHANGE_TIME/%s" % host)
285             
286     def get_machine_password(self, host):
287         return self.tdb.get("SECRETS/MACHINE_PASSWORD/%s" % host)
288
289     def get_machine_acc(self, host):
290         return self.tdb.get("SECRETS/$MACHINE.ACC/%s" % host)
291
292     def get_domtrust_acc(self, host):
293         return self.tdb.get("SECRETS/$DOMTRUST.ACC/%s" % host)
294
295     def trusted_domains(self):
296         for k in self.tdb.iterkeys():
297             if k.startswith("SECRETS/$DOMTRUST.ACC/"):
298                 yield k[len("SECRETS/$DOMTRUST.ACC/"):].rstrip("\0")
299
300     def get_random_seed(self):
301         return self.tdb.get("INFO/random_seed")
302
303     def get_sid(self, host):
304         return self.tdb.get("SECRETS/SID/%s" % host.upper())
305
306
307 SHARE_DATABASE_VERSION_V1 = 1
308 SHARE_DATABASE_VERSION_V2 = 2
309
310 class ShareInfoDatabase(TdbDatabase):
311     """Samba 3 Share Info database reader."""
312     def _check_version(self):
313         assert fetch_int32(self.tdb, "INFO/version\0") in (SHARE_DATABASE_VERSION_V1, SHARE_DATABASE_VERSION_V2)
314
315     def get_secdesc(self, name):
316         """Obtain the security descriptor on a particular share.
317         
318         :param name: Name of the share
319         """
320         secdesc = self.tdb.get("SECDESC/%s" % name)
321         # FIXME: Run ndr_pull_security_descriptor
322         return secdesc
323
324
325 class Shares(object):
326     """Container for share objects."""
327     def __init__(self, lp, shareinfo):
328         self.lp = lp
329         self.shareinfo = shareinfo
330
331     def __len__(self):
332         """Number of shares."""
333         return len(self.lp) - 1
334
335     def __iter__(self):
336         """Iterate over the share names."""
337         return self.lp.__iter__()
338
339
340 ACB_DISABLED = 0x00000001
341 ACB_HOMDIRREQ = 0x00000002
342 ACB_PWNOTREQ = 0x00000004
343 ACB_TEMPDUP = 0x00000008
344 ACB_NORMAL = 0x00000010
345 ACB_MNS = 0x00000020
346 ACB_DOMTRUST = 0x00000040
347 ACB_WSTRUST = 0x00000080
348 ACB_SVRTRUST = 0x00000100
349 ACB_PWNOEXP = 0x00000200
350 ACB_AUTOLOCK = 0x00000400
351 ACB_ENC_TXT_PWD_ALLOWED = 0x00000800
352 ACB_SMARTCARD_REQUIRED = 0x00001000
353 ACB_TRUSTED_FOR_DELEGATION = 0x00002000
354 ACB_NOT_DELEGATED = 0x00004000
355 ACB_USE_DES_KEY_ONLY = 0x00008000
356 ACB_DONT_REQUIRE_PREAUTH = 0x00010000
357 ACB_PW_EXPIRED = 0x00020000
358 ACB_NO_AUTH_DATA_REQD = 0x00080000
359
360 acb_info_mapping = {
361         'N': ACB_PWNOTREQ,  # 'N'o password.
362         'D': ACB_DISABLED,  # 'D'isabled.
363         'H': ACB_HOMDIRREQ, # 'H'omedir required.
364         'T': ACB_TEMPDUP,   # 'T'emp account.
365         'U': ACB_NORMAL,    # 'U'ser account (normal).
366         'M': ACB_MNS,       # 'M'NS logon user account. What is this ?
367         'W': ACB_WSTRUST,   # 'W'orkstation account.
368         'S': ACB_SVRTRUST,  # 'S'erver account. 
369         'L': ACB_AUTOLOCK,  # 'L'ocked account.
370         'X': ACB_PWNOEXP,   # No 'X'piry on password
371         'I': ACB_DOMTRUST,  # 'I'nterdomain trust account.
372         ' ': 0
373         }
374
375 def decode_acb(text):
376     """Decode a ACB field.
377
378     :param text: ACB text
379     :return: integer with flags set.
380     """
381     assert not "[" in text and not "]" in text
382     ret = 0
383     for x in text:
384         ret |= acb_info_mapping[x]
385     return ret
386
387
388 class SAMUser(object):
389     """Samba 3 SAM User.
390     
391     :note: Unknown or unset fields are set to None.
392     """
393     def __init__(self, name, uid=None, lm_password=None, nt_password=None, acct_ctrl=None, 
394                  last_change_time=None, nt_username=None, fullname=None, logon_time=None, logoff_time=None,
395                  acct_desc=None, group_rid=None, bad_password_count=None, logon_count=None,
396                  domain=None, dir_drive=None, munged_dial=None, homedir=None, logon_script=None,
397                  profile_path=None, workstations=None, kickoff_time=None, bad_password_time=None,
398                  pass_last_set_time=None, pass_can_change_time=None, pass_must_change_time=None,
399                  user_rid=None, unknown_6=None, nt_password_history=None,
400                  unknown_str=None, hours=None, logon_divs=None):
401         self.username = name
402         self.uid = uid
403         self.lm_password = lm_password
404         self.nt_password = nt_password
405         self.acct_ctrl = acct_ctrl
406         self.pass_last_set_time = last_change_time
407         self.nt_username = nt_username
408         self.fullname = fullname
409         self.logon_time = logon_time
410         self.logoff_time = logoff_time
411         self.acct_desc = acct_desc
412         self.group_rid = group_rid
413         self.bad_password_count = bad_password_count
414         self.logon_count = logon_count
415         self.domain = domain
416         self.dir_drive = dir_drive
417         self.munged_dial = munged_dial
418         self.homedir = homedir
419         self.logon_script = logon_script
420         self.profile_path = profile_path
421         self.workstations = workstations
422         self.kickoff_time = kickoff_time
423         self.bad_password_time = bad_password_time
424         self.pass_can_change_time = pass_can_change_time
425         self.pass_must_change_time = pass_must_change_time
426         self.user_rid = user_rid
427         self.unknown_6 = unknown_6
428         self.nt_password_history = nt_password_history
429         self.unknown_str = unknown_str
430         self.hours = hours
431         self.logon_divs = logon_divs
432
433     def __eq__(self, other): 
434         if not isinstance(other, SAMUser):
435             return False
436         return self.__dict__ == other.__dict__
437
438
439 class SmbpasswdFile(object):
440     """Samba 3 smbpasswd file reader."""
441     def __init__(self, file):
442         self.users = {}
443         f = open(file, 'r')
444         for l in f.readlines():
445             if len(l) == 0 or l[0] == "#":
446                 continue # Skip comments and blank lines
447             parts = l.split(":")
448             username = parts[0]
449             uid = int(parts[1])
450             acct_ctrl = 0
451             last_change_time = None
452             if parts[2] == "NO PASSWORD":
453                 acct_ctrl |= ACB_PWNOTREQ
454                 lm_password = None
455             elif parts[2][0] in ("*", "X"):
456                 # No password set
457                 lm_password = None
458             else:
459                 lm_password = parts[2]
460
461             if parts[3][0] in ("*", "X"):
462                 # No password set
463                 nt_password = None
464             else:
465                 nt_password = parts[3]
466
467             if parts[4][0] == '[':
468                 assert "]" in parts[4]
469                 acct_ctrl |= decode_acb(parts[4][1:-1])
470                 if parts[5].startswith("LCT-"):
471                     last_change_time = int(parts[5][len("LCT-"):], 16)
472             else: # old style file
473                 if username[-1] == "$":
474                     acct_ctrl &= ~ACB_NORMAL
475                     acct_ctrl |= ACB_WSTRUST
476
477             self.users[username] = SAMUser(username, uid, lm_password, nt_password, acct_ctrl, last_change_time)
478
479         f.close()
480
481     def __len__(self):
482         return len(self.users)
483
484     def __getitem__(self, name):
485         return self.users[name]
486
487     def __iter__(self):
488         return iter(self.users)
489
490     def close(self): # For consistency
491         pass
492
493
494 TDBSAM_FORMAT_STRING_V0 = "ddddddBBBBBBBBBBBBddBBwdwdBwwd"
495 TDBSAM_FORMAT_STRING_V1 = "dddddddBBBBBBBBBBBBddBBwdwdBwwd"
496 TDBSAM_FORMAT_STRING_V2 = "dddddddBBBBBBBBBBBBddBBBwwdBwwd"
497 TDBSAM_USER_PREFIX = "USER_"
498
499
500 class LdapSam(object):
501     """Samba 3 LDAP passdb backend reader."""
502     def __init__(self, url):
503         self.ldap_url = url
504
505
506 class TdbSam(TdbDatabase):
507     """Samba 3 TDB passdb backend reader."""
508     def _check_version(self):
509         self.version = fetch_uint32(self.tdb, "INFO/version\0") or 0
510         assert self.version in (0, 1, 2)
511
512     def usernames(self):
513         """Iterate over the usernames in this Tdb database."""
514         for k in self.tdb.iterkeys():
515             if k.startswith(TDBSAM_USER_PREFIX):
516                 yield k[len(TDBSAM_USER_PREFIX):].rstrip("\0")
517
518     __iter__ = usernames
519     
520     def __getitem__(self, name):
521         data = self.tdb["%s%s\0" % (TDBSAM_USER_PREFIX, name)]
522         user = SAMUser(name)
523     
524         def unpack_string(data):
525             (length, ) = struct.unpack("<L", data[:4])
526             data = data[4:]
527             if length == 0:
528                 return (None, data)
529             return (data[:length].rstrip("\0"), data[length:])
530
531         def unpack_int32(data):
532             (value, ) = struct.unpack("<l", data[:4])
533             return (value, data[4:])
534
535         def unpack_uint32(data):
536             (value, ) = struct.unpack("<L", data[:4])
537             return (value, data[4:])
538
539         def unpack_uint16(data):
540             (value, ) = struct.unpack("<H", data[:2])
541             return (value, data[2:])
542
543         (logon_time, data) = unpack_int32(data)
544         (logoff_time, data) = unpack_int32(data)
545         (kickoff_time, data) = unpack_int32(data)
546
547         if self.version > 0:
548             (bad_password_time, data) = unpack_int32(data)
549             if bad_password_time != 0:
550                 user.bad_password_time = bad_password_time
551         (pass_last_set_time, data) = unpack_int32(data)
552         (pass_can_change_time, data) = unpack_int32(data)
553         (pass_must_change_time, data) = unpack_int32(data)
554
555         if logon_time != 0:
556             user.logon_time = logon_time
557         user.logoff_time = logoff_time
558         user.kickoff_time = kickoff_time
559         if pass_last_set_time != 0:
560             user.pass_last_set_time = pass_last_set_time
561         user.pass_can_change_time = pass_can_change_time
562
563         (user.username, data) = unpack_string(data)
564         (user.domain, data) = unpack_string(data)
565         (user.nt_username, data) = unpack_string(data)
566         (user.fullname, data) = unpack_string(data)
567         (user.homedir, data) = unpack_string(data)
568         (user.dir_drive, data) = unpack_string(data)
569         (user.logon_script, data) = unpack_string(data)
570         (user.profile_path, data) = unpack_string(data)
571         (user.acct_desc, data) = unpack_string(data)
572         (user.workstations, data) = unpack_string(data)
573         (user.unknown_str, data) = unpack_string(data)
574         (user.munged_dial, data) = unpack_string(data)
575
576         (user.user_rid, data) = unpack_int32(data)
577         (user.group_rid, data) = unpack_int32(data)
578
579         (user.lm_password, data) = unpack_string(data)
580         (user.nt_password, data) = unpack_string(data)
581
582         if self.version > 1:
583             (user.nt_password_history, data) = unpack_string(data)
584
585         (user.acct_ctrl, data) = unpack_uint16(data)
586         (_, data) = unpack_uint32(data) # remove_me field
587         (user.logon_divs, data) = unpack_uint16(data)
588         (hours, data) = unpack_string(data)
589         user.hours = []
590         for entry in hours:
591             for i in range(8):
592                 user.hours.append(ord(entry) & (2 ** i) == (2 ** i))
593         (user.bad_password_count, data) = unpack_uint16(data)
594         (user.logon_count, data) = unpack_uint16(data)
595         (user.unknown_6, data) = unpack_uint32(data)
596         assert len(data) == 0
597         return user
598
599
600 def shellsplit(text):
601     """Very simple shell-like line splitting.
602     
603     :param text: Text to split.
604     :return: List with parts of the line as strings.
605     """
606     ret = list()
607     inquotes = False
608     current = ""
609     for c in text:
610         if c == "\"":
611             inquotes = not inquotes
612         elif c in ("\t", "\n", " ") and not inquotes:
613             ret.append(current)
614             current = ""
615         else:
616             current += c
617     if current != "":
618         ret.append(current)
619     return ret
620
621
622 class WinsDatabase(object):
623     """Samba 3 WINS database reader."""
624     def __init__(self, file):
625         self.entries = {}
626         f = open(file, 'r')
627         assert f.readline().rstrip("\n") == "VERSION 1 0"
628         for l in f.readlines():
629             if l[0] == "#": # skip comments
630                 continue
631             entries = shellsplit(l.rstrip("\n"))
632             name = entries[0]
633             ttl = int(entries[1])
634             i = 2
635             ips = []
636             while "." in entries[i]:
637                 ips.append(entries[i])
638                 i+=1
639             nb_flags = int(entries[i][:-1], 16)
640             assert not name in self.entries, "Name %s exists twice" % name
641             self.entries[name] = (ttl, ips, nb_flags)
642         f.close()
643
644     def __getitem__(self, name):
645         return self.entries[name]
646
647     def __len__(self):
648         return len(self.entries)
649
650     def __iter__(self):
651         return iter(self.entries)
652
653     def items(self):
654         """Return the entries in this WINS database."""
655         return self.entries.items()
656
657     def close(self): # for consistency
658         pass
659
660
661 class ParamFile(object):
662     """Simple smb.conf-compatible file parser
663
664     Does not use a parameter table, unlike the "normal".
665     """
666
667     def __init__(self, sections=None):
668         self._sections = sections or {}
669
670     def _sanitize_name(self, name):
671         return name.strip().lower().replace(" ","")
672
673     def __repr__(self):
674         return "ParamFile(%r)" % self._sections
675
676     def read(self, filename):
677         """Read a file.
678
679         :param filename: Path to the file
680         """
681         section = None
682         for i, l in enumerate(open(filename, 'r').xreadlines()):
683             l = l.strip()
684             if not l or l[0] == '#' or l[0] == ';':
685                 continue
686             if l[0] == "[" and l[-1] == "]":
687                 section = self._sanitize_name(l[1:-1])
688                 self._sections.setdefault(section, {})
689             elif "=" in l:
690                (k, v) = l.split("=", 1) 
691                self._sections[section][self._sanitize_name(k)] = v
692             else:
693                 raise Exception("Unable to parser line %d: %r" % (i+1,l))
694
695     def get(self, param, section=None):
696         """Return the value of a parameter.
697
698         :param param: Parameter name
699         :param section: Section name, defaults to "global"
700         :return: parameter value as string if found, None otherwise.
701         """
702         if section is None:
703             section = "global"
704         section = self._sanitize_name(section)
705         if not section in self._sections:
706             return None
707         param = self._sanitize_name(param)
708         if not param in self._sections[section]:
709             return None
710         return self._sections[section][param].strip()
711
712     def __getitem__(self, section):
713         return self._sections[section]
714
715     def get_section(self, section):
716         return self._sections.get(section)
717
718     def add_section(self, section):
719         self._sections[self._sanitize_name(section)] = {}
720
721     def set_string(self, name, value):
722         self._sections["global"][name] = value
723
724     def get_string(self, name):
725         return self._sections["global"].get(name)
726
727
728 class Samba3(object):
729     """Samba 3 configuration and state data reader."""
730     def __init__(self, libdir, smbconfpath):
731         """Open the configuration and data for a Samba 3 installation.
732
733         :param libdir: Library directory
734         :param smbconfpath: Path to the smb.conf file.
735         """
736         self.smbconfpath = smbconfpath
737         self.libdir = libdir
738         self.lp = ParamFile()
739         self.lp.read(self.smbconfpath)
740
741     def libdir_path(self, path):
742         if path[0] == "/" or path[0] == ".":
743             return path
744         return os.path.join(self.libdir, path)
745
746     def get_conf(self):
747         return self.lp
748
749     def get_sam_db(self):
750         lp = self.get_conf()
751         backends = (lp.get("passdb backend") or "").split(" ")
752         if ":" in backends[0]:
753             (name, location) = backends[0].split(":", 2)
754         else:
755             name = backends[0]
756             location = None
757         if name == "smbpasswd":
758             return SmbpasswdFile(self.libdir_path(location or "smbpasswd"))
759         elif name == "tdbsam":
760             return TdbSam(self.libdir_path(location or "passdb.tdb"))
761         elif name == "ldapsam":
762             if location is not None:
763                 return LdapSam("ldap:%s" % location)
764             return LdapSam(lp.get("ldap server"))
765         else:
766             raise NotImplementedError("unsupported passdb backend %s" % backends[0])
767
768     def get_policy_db(self):
769         return PolicyDatabase(self.libdir_path("account_policy.tdb"))
770
771     def get_registry(self):
772         return Registry(self.libdir_path("registry.tdb"))
773
774     def get_secrets_db(self):
775         return SecretsDatabase(self.libdir_path("secrets.tdb"))
776
777     def get_shareinfo_db(self):
778         return ShareInfoDatabase(self.libdir_path("share_info.tdb"))
779
780     def get_idmap_db(self):
781         return IdmapDatabase(self.libdir_path("winbindd_idmap.tdb"))
782
783     def get_wins_db(self):
784         return WinsDatabase(self.libdir_path("wins.dat"))
785
786     def get_shares(self):
787         return Shares(self.get_conf(), self.get_shareinfo_db())
788
789     def get_groupmapping_db(self):
790         return GroupMappingDatabase(self.libdir_path("group_mapping.tdb"))