r6540: Implement a bunch more SAMR functions.
[samba.git] / source4 / scripting / swig / samr.py
1 import dcerpc
2
3 def sid_to_string(sid):
4     """Convert a Python dictionary SID to a string SID."""
5
6     result = 'S-%d' % sid.sid_rev_num
7
8     result = result + '-%u' % \
9              (dcerpc.uint8_array_getitem(sid.id_auth, 5) +
10               (dcerpc.uint8_array_getitem(sid.id_auth, 4) << 8) + 
11               (dcerpc.uint8_array_getitem(sid.id_auth, 3) << 16) +
12               (dcerpc.uint8_array_getitem(sid.id_auth, 2) << 24))
13     
14     for i in range(0, sid.num_auths):
15         result = result + '-%u' % \
16                  dcerpc.uint32_array_getitem(sid.sub_auths, i)
17
18     return result
19
20 def string_to_sid(string):
21     """Convert a string SID to a Python dictionary SID.  Throws a
22     ValueError if the SID string was badly formed."""
23
24     if string[0] != 'S':
25         raise ValueError('Bad SID format')
26
27     string = string[1:]
28
29     import re
30
31     match = re.match('-\d+', string)
32
33     if not match:
34         raise ValueError('Bad SID format')
35
36     try:
37         sid_rev_num = int(string[match.start()+1:match.end()])
38     except ValueError:
39         raise ValueError('Bad SID format')
40
41     string = string[match.end():]
42
43     match = re.match('-\d+', string)
44
45     if not match:
46         raise ValueError('Bad SID format')
47
48     try:
49         ia = int(string[match.start()+1:match.end()])
50     except ValueError:
51         raise ValueError('Bad SID format')
52
53     string = string[match.end():]
54
55     id_auth = [0, 0, (ia >> 24) & 0xff, (ia >> 16) & 0xff,
56                (ia >> 8) & 0xff, ia & 0xff]
57
58     num_auths = 0
59     sub_auths = []
60     
61     while len(string):
62
63         match = re.match('-\d+', string)
64
65         if not match:
66             raise ValueError('Bad SID format')
67
68         try:
69             sa = int(string[match.start() + 1 : match.end()])
70         except ValueError:
71             raise ValueError('Bad SID format')
72
73         num_auths = num_auths + 1
74         sub_auths.append(int(sa))
75
76         string = string[match.end():]
77
78     sid = dcerpc.dom_sid()
79     sid.sid_rev_num = sid_rev_num
80     sid.id_auth = dcerpc.new_uint8_array(6)
81     for i in range(6):
82         dcerpc.uint8_array_setitem(sid.id_auth, i, id_auth[i])
83     sid.num_auths = num_auths
84     sid.sub_auths = dcerpc.new_uint32_array(num_auths)
85     for i in range(num_auths):
86         dcerpc.uint32_array_setitem(sid.sub_auths, i, sub_auths[i])
87
88     return sid
89
90 def call_fn(fn, pipe, args):
91     """Wrap up a RPC call and throw an exception is an error was returned."""
92     
93     result = fn(pipe, args);
94
95     if result & 0xc0000000L:
96         raise dcerpc.NTSTATUS(result, dcerpc.nt_errstr(result));
97
98     return result;
99    
100 class SamrHandle:
101
102     def __init__(self, pipe, handle):
103
104         self.pipe = pipe
105         self.handle = handle
106
107     def __del__(self):
108
109         if self.handle is not None:
110             self.Close()
111
112     def Close(self):
113                     
114         r = dcerpc.samr_Close()
115         r.data_in.handle = self.handle
116
117         call_fn(dcerpc.dcerpc_samr_Close, self.pipe, r)
118
119         self.handle = None
120
121     def QuerySecurity(self, sec_info = 7):
122
123         r = dcerpc.samr_QuerySecurity()
124         r.data_in.handle = self.handle
125         r.data_in.sec_info = sec_info
126
127         call_fn(dcerpc.dcerpc_samr_QuerySecurity, self.pipe, r)
128
129         return r.data_out.sdbuf
130
131     def SetSecurity(self, sdbuf, sec_info = 7):
132
133         r = dcerpc.samr_SetSecurity()
134         r.data_in.handle = self.handle
135         r.data_in.sec_info = sec_info
136         r.data_in.sdbuf = sdbuf
137
138         call_fn(dcerpc.dcerpc_samr_SetSecurity, self.pipe, r)
139         
140 class ConnectHandle(SamrHandle):
141
142     def EnumDomains(self):
143
144         r = dcerpc.samr_EnumDomains()
145         r.data_in.connect_handle = self.handle
146         r.data_in.resume_handle = 0
147         r.data_in.buf_size = -1
148
149         domains = []
150
151         while 1:
152
153             call_fn(dcerpc.dcerpc_samr_EnumDomains, self.pipe, r)
154
155             for i in range(r.data_out.sam.count):
156                 domains.append(dcerpc.samr_SamEntry_array_getitem(
157                     r.data_out.sam.entries, i).name.string)
158
159             # TODO: Handle more entries here
160
161             break
162
163         return domains
164
165     def LookupDomain(self, domain_name):
166
167         r = dcerpc.samr_LookupDomain()
168         r.data_in.connect_handle = self.handle
169         r.data_in.domain_name = dcerpc.samr_String()
170         r.data_in.domain_name.string = domain_name
171
172         call_fn(dcerpc.dcerpc_samr_LookupDomain, self.pipe, r)
173
174         return sid_to_string(r.data_out.sid);
175
176     def OpenDomain(self, domain_sid, access_mask = 0x02000000):
177
178         r = dcerpc.samr_OpenDomain()
179         r.data_in.connect_handle = self.handle
180         r.data_in.access_mask = access_mask
181         r.data_in.sid = string_to_sid(domain_sid)
182
183         call_fn(dcerpc.dcerpc_samr_OpenDomain, self.pipe, r)
184
185         return DomainHandle(self.pipe, r.data_out.domain_handle)
186
187     def Shutdown(self):
188
189         r = dcerpc.samr_Shutdown()
190         r.data_in.connect_handle = self.handle
191
192         call_fn(dcerpc.dcerpc_samr_Shutdown, self.pipe, r)
193
194     def GetDomPwInfo(self, domain_name):
195
196         r = dcerpc.samr_GetDomPwInfo()
197         r.data_in.domain_name = dcerpc.samr_String()
198         r.data_in.domain_name.string = domain_name
199
200         call_fn(dcerpc.dcerpc_samr_GetDomPwInfo, self.pipe, r)
201
202         return r.data_out.info
203
204
205     def SetBootKeyInformation(self, unknown1, unknown2, unknown3):
206         
207         r = dcerpc.samr_GetBootKeyInformation()
208         r.data_in.connect_handle = self.handle
209         r.data_in.unknown1 = unknown1
210         r.data_in.unknown2 = unknown2
211         r.data_in.unknown3 = unknown3
212
213         call_fn(dcerpc.dcerpc_samr_SetBootKeyInformation, self.pipe, r)
214
215 class DomainHandle(SamrHandle):
216
217     def QueryDomainInfo(self, level = 2):
218
219         r = dcerpc.samr_QueryDomainInfo()
220         r.data_in.domain_handle = self.handle
221         r.data_in.level = level
222
223         call_fn(dcerpc.dcerpc_samr_QueryDomainInfo, self.pipe, r)
224
225         return getattr(r.data_out.info, 'info%d' % level)
226
227     def QueryDomainInfo2(self, level = 2):
228
229         r = dcerpc.samr_QueryDomainInfo2()
230         r.data_in.domain_handle = self.handle
231         r.data_in.level = level
232
233         call_fn(dcerpc.dcerpc_samr_QueryDomainInfo2, self.pipe, r)
234
235         return getattr(r.data_out.info, 'info%d' % level)       
236
237     def SetDomainInfo(self, level, info):
238
239         r = dcerpc.samr_SetDomainInfo()
240         r.data_in.domain_handle = self.handle
241         r.data_in.level = level
242         r.data_in.info = dcerpc.samr_DomainInfo()
243         setattr(r.data_in.info, 'info%d' % level, info)
244
245         call_fn(dcerpc.dcerpc_samr_SetDomainInfo, self.pipe, r)
246
247     def EnumDomainGroups(self):
248
249         r = dcerpc.samr_EnumDomainGroups()
250         r.data_in.domain_handle = self.handle
251         r.data_in.resume_handle = 0
252         r.data_in.max_size = 1000
253
254         call_fn(dcerpc.dcerpc_samr_EnumDomainGroups, self.pipe, r)
255
256         groups = []
257
258         if r.data_out.sam.entries:
259             for i in range(r.data_out.sam.count):
260                 groups.append(dcerpc.samr_SamEntry_array_getitem(
261                     r.data_out.sam.entries, i).name.string)
262
263         return groups
264
265     def EnumDomainAliases(self):
266
267         r = dcerpc.samr_EnumDomainAliases()
268         r.data_in.domain_handle = self.handle
269         r.data_in.resume_handle = 0
270         # acct_flags in SamrEnumerateAliasesInDomain has probably
271         # no meaning so use 0xffffffff like W2K
272         r.data_in.acct_flags = 0xffffffffL
273
274         call_fn(dcerpc.dcerpc_samr_EnumDomainAliases, self.pipe, r)
275
276         aliases = []
277
278         if r.data_out.sam.entries:
279             for i in range(r.data_out.sam.count):
280                 aliases.append(dcerpc.samr_SamEntry_array_getitem(
281                     r.data_out.sam.entries, i).name.string)
282
283         return aliases
284
285     def EnumDomainUsers(self, user_account_flags = 16):
286
287         r = dcerpc.samr_EnumDomainUsers()
288         r.data_in.domain_handle = self.handle
289         r.data_in.resume_handle = 0
290         r.data_in.acct_flags = user_account_flags
291         r.data_in.max_size = 1000
292
293         call_fn(dcerpc.dcerpc_samr_EnumDomainUsers, self.pipe, r)
294
295         users = []
296
297         if r.data_out.sam.entries:
298             for i in range(r.data_out.sam.count):
299                 users.append(dcerpc.samr_SamEntry_array_getitem(
300                     r.data_out.sam.entries, i).name.string)
301
302         return users
303
304     def CreateUser(self, account_name, access_mask = 0x02000000):
305
306         r = dcerpc.samr_CreateUser()
307         r.data_in.domain_handle = self.handle
308         r.data_in.account_name = dcerpc.samr_String()
309         r.data_in.account_name.string = account_name
310         r.data_in.access_mask = access_mask
311
312         call_fn(dcerpc.dcerpc_samr_CreateUser, self.pipe, r)
313
314         return (r.data_out.user_handle,
315                 dcerpc.uint32_array_getitem(r.data_out.rid, 0))
316
317     def CreateUser2(self, account_name, acct_flags = 0x00000010,
318                     access_mask = 0x02000000):
319
320         r = dcerpc.samr_CreateUser2()
321         r.data_in.domain_handle = self.handle
322         r.data_in.account_name = dcerpc.samr_String()
323         r.data_in.account_name.string = account_name
324         r.data_in.acct_flags = acct_flags
325         r.data_in.access_mask = access_mask
326
327         call_fn(dcerpc.dcerpc_samr_CreateUser2, self.pipe, r)
328
329         return (r.data_out.user_handle,
330                 dcerpc.uint32_array_getitem(r.data_out.access_granted, 0),
331                 dcerpc.uint32_array_getitem(r.data_out.rid, 0))
332
333     def OpenUser(self, rid, access_mask = 0x02000000):
334
335         r = dcerpc.samr_OpenUser()
336         r.data_in.domain_handle = self.handle
337         r.data_in.access_mask = access_mask
338         r.data_in.rid = rid
339
340         call_fn(dcerpc.dcerpc_samr_OpenUser, self.pipe, r)
341
342         return UserHandle(self.pipe, r.data_out.user_handle)
343
344     def OpenGroup(self, rid, access_mask = 0x02000000):
345
346         r = dcerpc.samr_OpenGroup()
347         r.data_in.domain_handle = self.handle
348         r.data_in.access_mask = access_mask
349         r.data_in.rid = rid
350
351         call_fn(dcerpc.dcerpc_samr_OpenGroup, self.pipe, r)
352
353         return GroupHandle(self.pipe, r.data_out.group_handle)
354
355     def OpenAlias(self, rid, access_mask = 0x02000000):
356
357         r = dcerpc.samr_OpenAlias()
358         r.data_in.domain_handle = self.handle
359         r.data_in.access_mask = access_mask
360         r.data_in.rid = rid
361
362         call_fn(dcerpc.dcerpc_samr_OpenAlias, self.pipe, r)
363
364         return AliasHandle(self.pipe, r.data_out.alias_handle)
365
366     def CreateDomAlias(self, alias_name, access_mask = 0x02000000):
367
368         r = dcerpc.samr_CreateDomAlias()
369         r.data_in.domain_handle = self.handle
370         r.data_in.alias_name = dcerpc.samr_String()
371         r.data_in.alias_name.string = alias_name
372         r.data_in.access_mask = access_mask
373
374         call_fn(dcerpc.dcerpc_samr_CreateDomAlias, self.pipe, r)
375
376         return (AliasHandle(self.pipe, r.data_out.alias_handle),
377                 r.data_out.rid)    
378
379     def RidToSid(self, rid):
380
381         r = dcerpc.samr_RidToSid()
382         r.data_in.domain_handle = self.handle
383         r.data_in.rid = rid
384
385         call_fn(dcerpc.dcerpc_samr_RidToSid, self.pipe, r)
386
387         return sid_to_string(r.data_out.sid)
388
389     def RemoveMemberFromForeignDomain(self, sid):
390
391         r = dcerpc.samr_RemoveMemberFromForeignDomain()
392         r.data_in.domain_handle = self.handle
393         r.data_in.sid = sid
394
395         call_fn(dcerpc.dcerpc_samr_RemoveMemberFromForeignDomain, self.pipe, r)
396
397     def LookupNames(self, names):
398
399         r = dcerpc.samr_LookupNames()
400         r.data_in.domain_handle = self.handle
401         r.data_in.num_names = len(names)
402         r.data_in.names = dcerpc.new_samr_String_array(len(names))
403
404         for i in range(len(names)):
405             s = dcerpc.samr_String()
406             s.string = names[i]
407             dcerpc.samr_String_array_setitem(r.data_in.names, i, s)
408
409         call_fn(dcerpc.dcerpc_samr_LookupNames, self.pipe, r)
410
411         return ([dcerpc.uint32_array_getitem(r.data_out.rids.ids, i)
412                  for i in range(r.data_out.rids.count)],
413                 [dcerpc.uint32_array_getitem(r.data_out.types.ids, i)
414                  for i in range(r.data_out.types.count)])
415
416     def CreateDomainGroup(self, domain_name, access_mask = 0x02000000):
417
418         r = dcerpc.samr_CreateDomainGroup()
419         r.data_in.domain_handle = self.handle
420         r.data_in.name = dcerpc.samr_String()
421         r.data_in.name.string = domain_name
422         r.data_in.access_mask = access_mask
423
424         call_fn(dcerpc.dcerpc_samr_CreateDomainGroup, self.pipe, r)
425
426     def GetAliasMembership(self, sids):
427
428         r = dcerpc.samr_GetAliasMembership()
429         r.data_in.domain_handle = self.handle
430         r.data_in.sids = dcerpc.lsa_SidArray()
431         r.data_in.sids.num_sids = len(sids)
432         r.data_in.sids.sids = dcerpc.new_lsa_SidPtr_array(len(sids))
433
434         for i in range(len(sids)):
435             s = dcerpc.lsa_SidPtr()
436             s.sid = string_to_sid(sids[i])
437             dcerpc.lsa_SidPtr_array_setitem(r.data_in.sids.sids, i, s)
438
439         call_fn(dcerpc.dcerpc_samr_GetAliasMembership, self.pipe, r)
440
441         return [r.ids[x] for x in range(r.count)]
442
443     def QueryDisplayInfo(self, level):
444
445         # TODO: Handle more data returns
446
447         r = dcerpc.samr_QueryDisplayInfo()
448         r.data_in.domain_handle = self.handle
449         r.data_in.level = level
450         r.data_in.start_idx = 0
451         r.data_in.max_entries = 1000
452         r.data_in.buf_size = -1
453
454         call_fn(dcerpc.dcerpc_samr_QueryDisplayInfo, self.pipe, r)
455
456         # TODO: Return a mapping of the various samr_DispInfo
457         # structures here.
458
459         return getattr(r.data_out.info, 'info%d' % level)
460     
461     def QueryDisplayInfo2(self, level):
462
463         # TODO: Handle more data returns
464
465         r = dcerpc.samr_QueryDisplayInfo2()
466         r.data_in.domain_handle = self.handle
467         r.data_in.level = level
468         r.data_in.start_idx = 0
469         r.data_in.max_entries = 1000
470         r.data_in.buf_size = -1
471
472         call_fn(dcerpc.dcerpc_samr_QueryDisplayInfo2, self.pipe, r)
473
474         # TODO: Return a mapping of the various samr_DispInfo
475         # structures here.
476
477         return getattr(r.data_out.info, 'info%d' % level)
478
479     def QueryDisplayInfo3(self, level):
480
481         # TODO: Handle more data returns
482
483         r = dcerpc.samr_QueryDisplayInfo3()
484         r.data_in.domain_handle = self.handle
485         r.data_in.level = level
486         r.data_in.start_idx = 0
487         r.data_in.max_entries = 1000
488         r.data_in.buf_size = -1
489
490         call_fn(dcerpc.dcerpc_samr_QueryDisplayInfo3, self.pipe, r)
491
492         # TODO: Return a mapping of the various samr_DispInfo
493         # structures here.
494
495         return getattr(r.data_out.info, 'info%d' % level)
496
497     def GetBootKeyInformation(self):
498
499         r = dcerpc.samr_GetBootKeyInformation()
500         r.data_in.domain_handle = self.handle
501
502         call_fn(dcerpc.dcerpc_samr_GetBootKeyInformation, self.pipe, r)
503
504         return r.data_out.unknown
505
506     def SetBootKeyInformation(self):
507
508         r = dcerpc.samr_GetBootKeyInformation()
509         r.data_in.domain_handle = self.handle
510
511         call_fn(dcerpc.dcerpc_samr_GetBootKeyInformation, self.pipe, r)
512
513     def TestPrivateFunctionsDomain(self):
514
515         r = dcerpc.samr_TestPrivateFunctionsDomain()
516         r.data_in.domain_handle = self.handle
517
518         call_fn(dcerpc.dcerpc_samr_TestPrivateFunctionsDomain, self.pipe, r)
519
520 class UserHandle(SamrHandle):
521
522     def DeleteUser(self):
523
524         r = dcerpc.samr_DeleteUser()
525         r.data_in.user_handle = self.handle
526         
527         call_fn(dcerpc.dcerpc_samr_DeleteUser, self.pipe, r)
528
529         self.handle = None
530
531     def GetUserPwInfo(self):
532
533         r = dcerpc.samr_GetUserPwInfo()
534         r.data_in.user_handle = self.handle
535
536         call_fn(dcerpc.dcerpc_samr_GetUserPwInfo, self.pipe, r)
537
538         return r.data_out.info
539
540     def QueryUserInfo(self, level):
541
542         r = dcerpc.samr_QueryUserInfo()
543         r.data_in.user_handle = self.handle
544         r.data_in.level = level
545
546         call_fn(dcerpc.dcerpc_samr_QueryUserInfo, self.pipe, r)
547
548         return r.data_out.info
549
550     def QueryUserInfo2(self, level):
551
552         r = dcerpc.samr_QueryUserInfo2()
553         r.data_in.user_handle = self.handle
554         r.data_in.level = level
555
556         call_fn(dcerpc.dcerpc_samr_QueryUserInfo2, self.pipe, r)
557
558         return r.data_out.info
559
560     def GetGroupsForUser(self):
561
562         r = dcerpc.samr_GetGroupsForUser()
563         r.data_in.user_handle = self.handle
564
565         call_fn(dcerpc.dcerpc_samr_GetGroupsForUser, self.pipe, r)
566
567         rid_types = [dcerpc.samr_RidType_array_getitem(r.data_out.rids.rid, x)
568                      for x in range(r.data_out.rids.count)]
569
570         return [(x.rid, x.type) for x in rid_types]
571
572     def TestPrivateFunctionsUser(self):
573
574         r = dcerpc.samr_TestPrivateFunctionsUser()
575         r.data_in.user_handle = self.handle
576
577         call_fn(dcerpc.dcerpc_samr_TestPrivateFunctionsUser, self.pipe, r)
578             
579 class GroupHandle(SamrHandle):
580
581     def QueryGroupInfo(self, level):
582
583         r = dcerpc.samr_QueryGroupInfo()
584         r.data_in.group_handle = self.handle
585         r.data_in.level = level
586
587         call_fn(dcerpc.dcerpc_samr_QueryGroupInfo, self.pipe, r)
588
589         return r.data_out.info
590
591     def SetGroupInfo(self, level, info):
592
593         r = dcerpc.samr_SetGroupInfo()
594         r.data_in.group_handle = self.handle
595         r.data_in.level = level
596         r.data_in.info = info
597
598         call_fn(dcerpc.dcerpc_samr_SetGroupInfo, self.pipe, r)
599
600     def QueryGroupMember(self):
601
602         r = dcerpc.samr_QueryGroupMember()
603         r.data_in.group_handle = self.handle
604
605         call_fn(dcerpc.dcerpc_samr_QueryGroupMember, self.pipe, r)
606
607         return [(dcerpc.uint32_array_getitem(r.data_out.rids.rids, x),
608                  dcerpc.uint32_array_getitem(r.data_out.rids.unknown, x))
609                 for x in range(r.data_out.rids.count)]
610     
611 class AliasHandle(SamrHandle):
612
613     def DeleteDomAlias(self):
614
615         r = dcerpc.samr_DeleteDomAlias()
616         r.data_in.alias_handle = self.handle
617
618         call_fn(dcerpc.dcerpc_samr_DeleteDomAlias, self.pipe, r)
619
620         self.handle = None
621
622     def QueryAliasInfo(self, level = 1):
623
624         r = dcerpc.samr_QueryAliasInfo()
625         r.data_in.alias_handle = self.handle
626         r.data_in.level = level
627
628         call_fn(dcerpc.dcerpc_samr_QueryAliasInfo, self.pipe, r)
629
630         return r.data_out.info
631
632     def SetAliasInfo(self, level, info):
633
634         r = dcerpc.samr_SetAliasInfo()
635         r.data_in.alias_handle = self.handle
636         r.data_in.level = level
637         r.data_in.info = info
638
639         call_fn(dcerpc.dcerpc_samr_SetAliasInfo, self.pipe, r)
640
641     def AddAliasMember(self, sid):
642
643         r = dcerpc.samr_AddAliasMember()
644         r.data_in.alias_handle = self.handle
645         r.data_in.sid = string_to_sid(sid)
646
647         call_fn(dcerpc.dcerpc_samr_AddAliasMember, self.pipe, r)
648
649     def AddMultipleMembersToAlias(self, sids):
650
651         r = dcerpc.samr_AddMultipleMembersToAlias()
652         r.data_in.alias_handle = self.handle
653         r.data_in.sids = dcerpc.lsa_SidArray()
654         r.data_in.sids.num_sids = len(sids)
655         r.data_in.sids.sids = dcerpc.new_lsa_SidPtr_array(len(sids))
656
657         for i in range(len(sids)):
658             s = dcerpc.lsa_SidPtr()
659             s.sid = string_to_sid(sids[i])
660             dcerpc.lsa_SidPtr_array_setitem(r.data_in.sids.sids, i, s)
661
662         call_fn(dcerpc.dcerpc_samr_AddMultipleMembersToAlias, self.pipe, r)
663
664     def GetMembersInAlias(self):
665
666         r = dcerpc.samr_GetMembersInAlias()
667         r.data_in.alias_handle = self.handle
668
669         call_fn(dcerpc.dcerpc_samr_GetMembersInAlias, self.pipe, r)
670
671         return [
672             sid_to_string(
673                 dcerpc.lsa_SidPtr_array_getitem(r.data_out.sids.sids, x).sid)
674             for x in range(r.data_out.sids.num_sids)]
675
676 def Connect(pipe, access_mask = 0x02000000):
677
678     r = dcerpc.samr_Connect()
679     r.data_in.system_name = dcerpc.new_uint16_array(1)
680     dcerpc.uint16_array_setitem(r.data_in.system_name, 0, ord('\\'))
681     r.data_in.access_mask = access_mask
682
683     call_fn(dcerpc.dcerpc_samr_Connect, pipe, r)
684
685     return ConnectHandle(pipe, r.data_out.connect_handle)
686
687 def Connect2(pipe, system_name = '', access_mask = 0x02000000):
688     """Connect to the SAMR pipe."""
689
690     r = dcerpc.samr_Connect2()
691     r.data_in.system_name = system_name
692     r.data_in.access_mask = access_mask
693
694     call_fn(dcerpc.dcerpc_samr_Connect2, pipe, r)
695
696     return ConnectHandle(pipe, r.data_out.connect_handle)
697
698 def Connect3(pipe, system_name = '', access_mask = 0x02000000):
699
700     r = dcerpc.samr_Connect3()
701     r.data_in.system_name = system_name
702     r.data_in.unknown = 0
703     r.data_in.access_mask = access_mask
704
705     call_fn(dcerpc.dcerpc_samr_Connect3, pipe, r)
706
707     return ConnectHandle(pipe, r.data_out.connect_handle)
708
709
710 def Connect4(pipe, system_name = '', access_mask = 0x02000000):
711
712     r = dcerpc.samr_Connect4()
713     r.data_in.system_name = system_name
714     r.data_in.unknown = 0
715     r.data_in.access_mask = access_mask
716
717     call_fn(dcerpc.dcerpc_samr_Connect4, pipe, r)
718
719     return ConnectHandle(pipe, r.data_out.connect_handle)
720
721 def Connect5(pipe, system_name = '', access_mask = 0x02000000):
722
723     r = dcerpc.samr_Connect5()
724     r.data_in.system_name = system_name
725     r.data_in.access_mask = access_mask
726     r.data_in.level = 1
727     r.data_in.info = dcerpc.new_samr_ConnectInfo_array(1)
728     r.data_in.info.unknown1 = 0
729     r.data_in.info.unknown2 = 0
730
731     call_fn(dcerpc.dcerpc_samr_Connect5, pipe, r)
732
733     return ConnectHandle(pipe, r.data_out.connect_handle)
734     
735 # AddGroupMember
736 # DeleteDomainGroup
737 # DeleteGroupMember
738 # SetMemberAttributesofGroup
739 # AddAliasMember
740 # DeleteAliasMember
741 # GetMembersinAlias
742 # SetUserInfo
743 # ChangePasswordUser
744 # GetDisplayEnumerationIndex
745 # RemoveMemberFromForeignDomain
746 # GetDisplayEnumerationIndex2
747 # RemoveMultipleMembersFromAlias
748 # OemChangePasswordUser2
749 # ChangePasswordUser2
750 # SetUserInfo2
751 # ChangePasswordUser3
752 # SetDsrmPassword
753 # ValidatePassword