source4/scripting/swig/torture/torture_samr.py

   1 #!/usr/bin/python
   2
   3 import sys
   4 import dcerpc, samr
   5
   6 def test_Connect(pipe):
   7
   8     print 'testing Connect'
   9
  10     handle = samr.Connect(pipe)
  11     handle = samr.Connect2(pipe)
  12     handle = samr.Connect3(pipe)
  13     handle = samr.Connect4(pipe)
  14     handle = samr.Connect5(pipe)
  15
  16     return handle
  17
  18 def test_QuerySecurity(pipe, handle):
  19
  20     print 'testing QuerySecurity'
  21
  22     sdbuf = handle.QuerySecurity()
  23     handle.SetSecurity(sdbuf)
  24
  25
  26 def test_GetDomPwInfo(pipe, handle, domain):
  27
  28     print 'testing GetDomPwInfo'
  29
  30     handle.GetDomPwInfo(domain)
  31     handle.GetDomPwInfo('__NONAME__')
  32     handle.GetDomPwInfo('Builtin')
  33
  34 def test_RemoveMemberFromForeignDomain(pipe, domain_handle):
  35
  36     print 'test RemoveMemberFromForeignDomain'
  37
  38     sid = samr.string_to_sid('S-1-5-32-12-34-56-78-9')
  39
  40     domain_handle.RemoveMemberFromForeignDomain(sid)
  41
  42 def test_CreateUser2(pipe, domain_handle):
  43
  44     print 'test CreateUser2'
  45
  46     username = 'samrtorturemach$'
  47
  48     try:
  49         return domain_handle.CreateUser2(username, 0x0080) # WSTRUST
  50     except dcerpc.NTSTATUS, arg:
  51         if arg[0] == 0x0c0000063L:
  52             domain_handle.OpenUser(username).DeleteUser()
  53             return domain_handle.CreateUser2(username)
  54         raise
  55
  56 def test_LookupName(pipe, domain_handle, name):
  57
  58     print 'test samr_LookupNames'
  59
  60     r = {}
  61     r['domain_handle'] = domain_handle
  62     r['num_names'] = 1
  63     r['names'] = []
  64     r['names'].append({'name': name})
  65
  66     result = dcerpc.samr_LookupNames(pipe, r)
  67
  68     rid = result['rids']['ids'][0]
  69
  70     r['num_names'] = 2
  71     r['names'].append({'name': 'xxNONAMExx'})
  72
  73
  74     try:
  75         dcerpc.samr_LookupNames(pipe, r)
  76     except dcerpc.NTSTATUS, arg:
  77         if arg[0] != dcerpc.STATUS_SOME_UNMAPPED:
  78             raise dcerpc.NTSTATUS(arg)
  79
  80     r['num_names'] = 0
  81
  82     dcerpc.samr_LookupNames(pipe, r)
  83
  84     return rid
  85
  86 def test_OpenUser_byname(pipe, domain_handle, user_name):
  87
  88     rid = test_LookupName(pipe, domain_handle, user_name)
  89
  90     r = {}
  91     r['domain_handle'] = domain_handle
  92     r['access_mask'] = 0x02000000
  93     r['rid'] = rid
  94
  95     result = dcerpc.samr_OpenUser(pipe, r)
  96
  97     return result['user_handle']
  98
  99 def test_DeleteUser_byname(pipe, domain_handle, user_name):
 100
 101     user_handle = test_OpenUser_byname(pipe, domain_handle, user_name)
 102
 103     r = {}
 104     r['user_handle'] = user_handle
 105
 106     dcerpc.samr_DeleteUser(pipe, r)
 107
 108 def test_QueryUserInfo(pipe, user_handle):
 109
 110     print 'test samr_QueryUserInfo'
 111
 112     levels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 20, 21]
 113
 114     for level in levels:
 115         r = {}
 116         r['user_handle'] = user_handle
 117         r['level'] = level
 118
 119         dcerpc.samr_QueryUserInfo(pipe, r)
 120
 121 def test_QueryUserInfo2(pipe, user_handle):
 122
 123     print 'test samr_QueryUserInfo2'
 124
 125     levels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 20, 21]
 126
 127     for level in levels:
 128         r = {}
 129         r['user_handle'] = user_handle
 130         r['level'] = level
 131
 132         dcerpc.samr_QueryUserInfo2(pipe, r)
 133
 134 def test_SetUserInfo(pipe, user_handle):
 135
 136     r = {}
 137     r['user_handle'] = user_handle
 138     r['level'] = 2
 139     r['info'] = {}
 140     r['info']['info2'] = {}
 141     r['info']['info2']['comment'] = {}
 142     r['info']['info2']['comment']['name'] = 'hello'
 143     r['info']['info2']['unknown'] = {}
 144     r['info']['info2']['unknown']['name'] = None
 145     r['info']['info2']['country_code'] = 0
 146     r['info']['info2']['code_page'] = 0
 147
 148     dcerpc.samr_SetUserInfo(pipe, r)
 149
 150 def test_GetUserPwInfo(pipe, user_handle):
 151
 152     print 'test samr_GetUserpwInfo'
 153
 154     r = {}
 155     r['user_handle'] = user_handle
 156
 157     dcerpc.samr_GetUserPwInfo(pipe, r)
 158
 159 def test_TestPrivateFunctionsUser(pipe, user_handle):
 160
 161     print 'test samr.TestPrivateFunctionsUser'
 162
 163     r = {}
 164     r['user_handle'] = user_handle
 165
 166     try:
 167         dcerpc.samr_TestPrivateFunctionsUser(pipe, r)
 168     except dcerpc.NTSTATUS, arg:
 169         if arg[0] != dcerpc.NT_STATUS_NOT_IMPLEMENTED:
 170             raise dcerpc.NTSTATUS(arg)
 171
 172 def test_user_ops(pipe, user_handle):
 173
 174     test_QuerySecurity(pipe, user_handle)
 175
 176     test_QueryUserInfo(pipe, user_handle)
 177
 178     test_QueryUserInfo2(pipe, user_handle)
 179
 180     test_SetUserInfo(pipe, user_handle)
 181
 182     test_GetUserPwInfo(pipe, user_handle)
 183
 184     test_TestPrivateFunctionsUser(pipe, user_handle)
 185
 186 def test_CreateUser(pipe, domain_handle):
 187
 188     print 'test samr_CreateUser'
 189
 190     r = {}
 191     r['domain_handle'] = domain_handle
 192     r['account_name'] = {}
 193     r['account_name']['name'] = 'samrtorturetest'
 194     r['access_mask'] = 0x02000000
 195
 196     try:
 197         result = dcerpc.samr_CreateUser(pipe, r)
 198     except dcerpc.NTSTATUS, arg:
 199         if arg[0] == dcerpc.NT_STATUS_ACCESS_DENIED:
 200             return
 201         elif arg[0] == dcerpc.NT_STATUS_USER_EXISTS:
 202             test_DeleteUser_byname(pipe, domain_handle, 'samrtorturetest')
 203             result = dcerpc.samr_CreateUser(pipe, r)
 204         else:
 205             raise dcerpc.NTSTATUS(arg)
 206
 207     user_handle = result['user_handle']
 208
 209     q = {}
 210     q['user_handle'] = user_handle
 211     q['level'] = 16
 212
 213     dcerpc.samr_QueryUserInfo(pipe, q)
 214
 215     test_user_ops(pipe, user_handle)
 216
 217     return user_handle
 218
 219 def test_DeleteAlias_byname(pipe, domain_handle, alias_name):
 220
 221     rid = test_LookupName(pipe, domain_handle, alias_name)
 222
 223     r = {}
 224     r['domain_handle'] = domain_handle
 225     r['access_mask'] = 0x02000000
 226     r['rid'] = rid
 227
 228     result = dcerpc.samr_OpenAlias(pipe, r)
 229
 230     s = {}
 231     s['alias_handle'] = result['alias_handle']
 232
 233     dcerpc.samr_DeleteDomAlias(pipe, s)
 234
 235 def test_QueryAliasInfo(pipe, alias_handle):
 236
 237     levels = [1, 2, 3]
 238
 239     for i in range(0, len(levels)):
 240
 241         r = {}
 242         r['alias_handle'] = alias_handle
 243         r['level']  = levels[i]
 244
 245         dcerpc.samr_QueryAliasInfo(pipe, r)
 246
 247 def test_SetAliasInfo(pipe, alias_handle):
 248
 249     r = {}
 250     r['alias_handle'] = alias_handle
 251     r['level'] = 2
 252     r['info'] = {}
 253     r['info']['name'] = {}
 254     r['info']['name']['name'] = 'hello'
 255
 256     dcerpc.samr_SetAliasInfo(pipe, r)
 257
 258     del(r['info']['name'])
 259
 260     r['level'] = 3
 261     r['info']['description'] = {}
 262     r['info']['description']['name'] = 'this is a description'
 263
 264     dcerpc.samr_SetAliasInfo(pipe, r)
 265
 266 def test_AddMemberToAlias(pipe, alias_handle, domain_sid):
 267
 268     r = {}
 269     r['alias_handle'] = alias_handle
 270     r['sid'] = domain_sid
 271
 272     r['sid']['num_auths'] = r['sid']['num_auths'] + 1
 273     r['sid']['sub_auths'].append(512)
 274
 275     dcerpc.samr_AddAliasMember(pipe, r)
 276
 277     dcerpc.samr_DeleteAliasMember(pipe, r)
 278
 279 def test_AddMultipleMembersToAlias(pipe, alias_handle):
 280
 281     r = {}
 282     r['alias_handle'] = alias_handle
 283     r['sids'] = {}
 284     r['sids']['num_sids'] = 2
 285     r['sids']['sids'] = []
 286
 287     for i in range(0,2):
 288         sid = {}
 289         sid['sid_rev_num'] = 1
 290         sid['id_auth'] = [0, 0, 0, 0, 0, 5]
 291         sid['num_auths'] = 5
 292         sid['sub_auths'] = [21, 737922324, -1292160505, 1285293260, 512 + i]
 293
 294         r['sids']['sids'].append({'sid': sid})
 295
 296     dcerpc.samr_AddMultipleMembersToAlias(pipe, r)
 297
 298     dcerpc.samr_RemoveMultipleMembersFromAlias(pipe, r)
 299
 300 def test_alias_ops(pipe, alias_handle, domain_sid):
 301
 302     test_QuerySecurity(pipe, alias_handle)
 303
 304     test_QueryAliasInfo(pipe, alias_handle)
 305
 306     test_SetAliasInfo(pipe, alias_handle)
 307
 308     test_AddMemberToAlias(pipe, alias_handle, domain_sid)
 309
 310     test_AddMultipleMembersToAlias(pipe, alias_handle)
 311
 312 def test_CreateAlias(pipe, domain_handle, domain_sid):
 313
 314     print 'test samr_CreateAlias'
 315
 316     alias_name = 'samrtorturetestalias'
 317
 318     r = {}
 319     r['domain_handle'] = domain_handle
 320     r['aliasname'] = {}
 321     r['aliasname']['name'] = alias_name
 322     r['access_mask'] = 0x02000000
 323
 324     try:
 325         result = dcerpc.samr_CreateDomAlias(pipe, r)
 326     except dcerpc.NTSTATUS, arg:
 327         if arg[0] == dcerpc.NT_STATUS_ACCESS_DENIED:
 328             return
 329         if arg[0] != dcerpc.NT_STATUS_USER_EXISTS:
 330             raise dcerpc.NTSTATUS(arg)
 331         test_DeleteAlias_byname(pipe, domain_handle, alias_name)
 332         result = dcerpc.samr_CreateDomAlias(pipe, r)
 333
 334     alias_handle = result['alias_handle']
 335
 336     test_alias_ops(pipe, alias_handle, domain_sid)
 337
 338     return alias_handle
 339
 340 def test_DeleteGroup_byname(pipe, domain_handle, group_name):
 341
 342     rid = test_LookupName(pipe, domain_handle, group_name)
 343
 344     r = {}
 345     r['domain_handle'] = domain_handle
 346     r['access_mask'] = 0x02000000
 347     r['rid'] = rid
 348
 349     result = dcerpc.samr_OpenGroup(pipe, r)
 350
 351     s = {}
 352     s['group_handle'] = result['group_handle']
 353
 354     dcerpc.samr_DeleteDomainGroup(pipe, s)
 355
 356 def test_CreateDomainGroup(pipe, domain_handle):
 357
 358     print 'testing samr_CreateDomainGroup'
 359
 360     r = {}
 361     r['domain_handle'] = domain_handle
 362     r['name'] = {}
 363     r['name']['name'] = 'samrtorturetestgroup'
 364     r['access_mask'] = 0x02000000
 365
 366     try:
 367         result = dcerpc.samr_CreateDomainGroup(pipe, r)
 368     except dcerpc.NTSTATUS, arg:
 369         if arg[0] == dcerpc.NT_STATUS_ACCESS_DENIED:
 370             return
 371         if arg[0] != dcerpc.NT_STATUS_GROUP_EXISTS:
 372             raise dcerpc.NTSTATUS(arg)
 373
 374         test_DeleteGroup_byname(pipe, domain_handle, 'samrtorturetestgroup')
 375
 376         result = dcerpc.samr_CreateDomainGroup(pipe, r)
 377
 378     return result['group_handle']
 379
 380 def test_QueryDomainInfo(pipe, domain_handle):
 381
 382     print 'testing samr_QueryDomainInfo'
 383
 384     levels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13]
 385     set_ok = [1, 0, 1, 1, 0, 1, 1, 0, 1,  0,  1,  0]
 386
 387     for i in range(0, len(levels)):
 388
 389         r = {}
 390         r['domain_handle'] = domain_handle
 391         r['level'] = levels[i]
 392
 393         result = dcerpc.samr_QueryDomainInfo(pipe, r)
 394
 395         s = {}
 396         s['domain_handle'] = domain_handle
 397         s['level'] = levels[i]
 398         s['info'] = result['info']
 399
 400         try:
 401             dcerpc.samr_SetDomainInfo(pipe, s)
 402         except dcerpc.NTSTATUS, arg:
 403             if set_ok[i]:
 404                 raise dcerpc.NTSTATUS(arg)
 405             if arg[0] != dcerpc.NT_STATUS_INVALID_INFO_CLASS:
 406                 raise dcerpc.NTSTATUS(arg)
 407
 408 def test_QueryDomainInfo2(pipe, domain_handle):
 409
 410     print 'testing samr_QueryDomainInfo'
 411
 412     levels = [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13]
 413
 414     for i in range(0, len(levels)):
 415
 416         r = {}
 417         r['domain_handle'] = domain_handle
 418         r['level'] = levels[i]
 419
 420         dcerpc.samr_QueryDomainInfo2(pipe, r)
 421
 422 def test_EnumDomainUsers(pipe, domain_handle):
 423
 424     print 'testing samr_EnumDomainUsers'
 425
 426     r = {}
 427     r['domain_handle'] = domain_handle
 428     r['resume_handle'] = 0
 429     r['acct_flags'] = 0
 430     r['max_size'] = -1
 431
 432     while 1:
 433         result = dcerpc.samr_EnumDomainUsers(pipe, r)
 434         if result['result'] == dcerpc.STATUS_MORE_ENTRIES:
 435             r['resume_handle'] = result['resume_handle']
 436             continue
 437         break
 438
 439 def test_EnumDomainGroups(pipe, domain_handle):
 440
 441     print 'testing samr_EnumDomainGroups'
 442
 443     r = {}
 444     r['domain_handle'] = domain_handle
 445     r['resume_handle'] = 0
 446     r['acct_flags'] = 0
 447     r['max_size'] = -1
 448
 449     while 1:
 450         result = dcerpc.samr_EnumDomainGroups(pipe, r)
 451         if result['result'] == dcerpc.STATUS_MORE_ENTRIES:
 452             r['resume_handle'] = result['resume_handle']
 453             continue
 454         break
 455
 456 def test_EnumDomainAliases(pipe, domain_handle):
 457
 458     print 'testing samr_EnumDomainAliases'
 459
 460     r = {}
 461     r['domain_handle'] = domain_handle
 462     r['resume_handle'] = 0
 463     r['acct_flags'] = 0
 464     r['max_size'] = -1
 465
 466     while 1:
 467         result = dcerpc.samr_EnumDomainAliases(pipe, r)
 468         if result['result'] == dcerpc.STATUS_MORE_ENTRIES:
 469             r['resume_handle'] = result['resume_handle']
 470             continue
 471         break
 472
 473 def test_QueryDisplayInfo(pipe, domain_handle):
 474
 475     print 'testing samr_QueryDisplayInfo'
 476
 477     levels = [1, 2, 3, 4, 5]
 478
 479     for i in range(0, len(levels)):
 480
 481         r = {}
 482         r['domain_handle'] = domain_handle
 483         r['level'] = levels[i]
 484         r['start_idx'] = 0
 485         r['max_entries'] = 1000
 486         r['buf_size'] = -1
 487
 488         dcerpc.samr_QueryDisplayInfo(pipe, r)
 489
 490 def test_QueryDisplayInfo2(pipe, domain_handle):
 491
 492     print 'testing samr_QueryDisplayInfo2'
 493
 494     levels = [1, 2, 3, 4, 5]
 495
 496     for i in range(0, len(levels)):
 497
 498         r = {}
 499         r['domain_handle'] = domain_handle
 500         r['level'] = levels[i]
 501         r['start_idx'] = 0
 502         r['max_entries'] = 1000
 503         r['buf_size'] = -1
 504
 505         dcerpc.samr_QueryDisplayInfo2(pipe, r)
 506
 507 def test_QueryDisplayInfo3(pipe, domain_handle):
 508
 509     print 'testing samr_QueryDisplayInfo3'
 510
 511     levels = [1, 2, 3, 4, 5]
 512
 513     for i in range(0, len(levels)):
 514
 515         r = {}
 516         r['domain_handle'] = domain_handle
 517         r['level'] = levels[i]
 518         r['start_idx'] = 0
 519         r['max_entries'] = 1000
 520         r['buf_size'] = -1
 521
 522         dcerpc.samr_QueryDisplayInfo3(pipe, r)
 523
 524 def test_GetDisplayEnumerationIndex(pipe, domain_handle):
 525
 526     print 'testing samr_GetDisplayEnumerationIndex'
 527
 528     levels = [1, 2, 3, 4, 5]
 529     ok_lvl = [1, 1, 1, 0, 0]
 530
 531     for i in range(0, len(levels)):
 532
 533         r = {}
 534         r['domain_handle'] = domain_handle
 535         r['level'] = levels[i]
 536         r['name'] = {}
 537         r['name']['name'] = 'samrtorturetest'
 538
 539         try:
 540             dcerpc.samr_GetDisplayEnumerationIndex(pipe, r)
 541         except dcerpc.NTSTATUS, arg:
 542             if ok_lvl[i]:
 543                 raise dcerpc.NTSTATUS(arg)
 544
 545         r['name']['name'] = 'zzzzzzzz'
 546
 547         try:
 548             dcerpc.samr_GetDisplayEnumerationIndex(pipe, r)
 549         except dcerpc.NTSTATUS, arg:
 550             if ok_lvl[i]:
 551                 raise dcerpc.NTSTATUS(arg)
 552
 553 def test_GetDisplayEnumerationIndex2(pipe, domain_handle):
 554
 555     print 'testing samr_GetDisplayEnumerationIndex2'
 556
 557     levels = [1, 2, 3, 4, 5]
 558     ok_lvl = [1, 1, 1, 0, 0]
 559
 560     for i in range(0, len(levels)):
 561
 562         r = {}
 563         r['domain_handle'] = domain_handle
 564         r['level'] = levels[i]
 565         r['name'] = {}
 566         r['name']['name'] = 'samrtorturetest'
 567
 568         try:
 569             dcerpc.samr_GetDisplayEnumerationIndex2(pipe, r)
 570         except dcerpc.NTSTATUS, arg:
 571             if ok_lvl[i]:
 572                 raise dcerpc.NTSTATUS(arg)
 573
 574         r['name']['name'] = 'zzzzzzzz'
 575
 576         try:
 577             dcerpc.samr_GetDisplayEnumerationIndex2(pipe, r)
 578         except dcerpc.NTSTATUS, arg:
 579             if ok_lvl[i]:
 580                 raise dcerpc.NTSTATUS(arg)
 581
 582 def test_TestPrivateFunctionsDomain(pipe, domain_handle):
 583
 584     print 'test samr.TestPrivateFunctionsDomain'
 585
 586     r = {}
 587     r['domain_handle'] = domain_handle
 588
 589     try:
 590         dcerpc.samr_TestPrivateFunctionsDomain(pipe, r)
 591     except dcerpc.NTSTATUS, arg:
 592         if arg[0] != dcerpc.NT_STATUS_NOT_IMPLEMENTED:
 593             raise dcerpc.NTSTATUS(arg)
 594
 595 def test_RidToSid(pipe, domain_handle):
 596
 597     print 'testing samr_RidToSid'
 598
 599     r = {}
 600     r['domain_handle'] = domain_handle
 601     r['rid'] = 512
 602
 603     dcerpc.samr_RidToSid(pipe, r)
 604
 605 def test_GetBootKeyInformation(pipe, domain_handle):
 606
 607     print 'testing samr_GetBootKeyInformation'
 608
 609     r = {}
 610     r['domain_handle'] = domain_handle
 611
 612     try:
 613         dcerpc.samr_GetBootKeyInformation(pipe, r)
 614     except dcerpc.NTSTATUS, arg:
 615         pass
 616
 617 def test_DeleteUser(pipe, user_handle):
 618
 619     r = {}
 620     r['user_handle'] = user_handle
 621
 622     dcerpc.samr_DeleteUser(pipe, r)
 623
 624 def test_DeleteAlias(pipe, alias_handle):
 625
 626     r = {}
 627     r['alias_handle'] = alias_handle
 628
 629     dcerpc.samr_DeleteDomAlias(pipe, r)
 630
 631 def test_DeleteDomainGroup(pipe, group_handle):
 632
 633     r = {}
 634     r['group_handle'] = group_handle
 635
 636     dcerpc.samr_DeleteDomainGroup(pipe, r)
 637
 638 def test_Close(pipe, handle):
 639
 640     r = {}
 641     r['handle'] = handle
 642
 643     dcerpc.samr_Close(pipe, r)
 644
 645 def test_OpenDomain(pipe, connect_handle, domain_sid):
 646
 647     print 'testing OpenDomain'
 648
 649     domain_handle = connect_handle.OpenDomain(domain_sid)
 650
 651     test_QuerySecurity(pipe, domain_handle)
 652
 653     test_RemoveMemberFromForeignDomain(pipe, domain_handle)
 654
 655     test_CreateUser2(pipe, domain_handle)
 656
 657     sys.exit(0)
 658
 659     user_handle = test_CreateUser(pipe, domain_handle)
 660
 661     alias_handle = test_CreateAlias(pipe, domain_handle, domain_sid)
 662
 663     group_handle = test_CreateDomainGroup(pipe, domain_handle)
 664
 665     test_QueryDomainInfo(pipe, domain_handle)
 666
 667     test_QueryDomainInfo2(pipe, domain_handle)
 668
 669     test_EnumDomainUsers(pipe, domain_handle)
 670
 671     test_EnumDomainGroups(pipe, domain_handle)
 672
 673     test_EnumDomainAliases(pipe, domain_handle)
 674
 675     test_QueryDisplayInfo(pipe, domain_handle)
 676
 677     test_QueryDisplayInfo2(pipe, domain_handle)
 678
 679     test_QueryDisplayInfo3(pipe, domain_handle)
 680
 681     test_GetDisplayEnumerationIndex(pipe, domain_handle)
 682
 683     test_GetDisplayEnumerationIndex2(pipe, domain_handle)
 684
 685     test_TestPrivateFunctionsDomain(pipe, domain_handle)
 686
 687     test_RidToSid(pipe, domain_handle)
 688
 689     test_GetBootKeyInformation(pipe, domain_handle)
 690
 691     if user_handle != None:
 692         test_DeleteUser(pipe, user_handle)
 693
 694     if alias_handle != None:
 695         test_DeleteAlias(pipe, alias_handle)
 696
 697     if group_handle != None:
 698         test_DeleteDomainGroup(pipe, group_handle)
 699
 700     test_Close(pipe, domain_handle)
 701
 702 def test_LookupDomain(pipe, connect_handle, domain):
 703
 704     print 'testing LookupDomain'
 705
 706     sid = connect_handle.LookupDomain(domain)
 707
 708     try:
 709         connect_handle.LookupDomain('xxNODOMAINxx')
 710     except dcerpc.NTSTATUS, arg:
 711         if arg[0] != 0xC00000DFL:          # NT_STATUS_NO_SUCH_DOMAIN
 712             raise
 713
 714     test_GetDomPwInfo(pipe, connect_handle, domain)
 715     test_OpenDomain(pipe, connect_handle, sid)
 716
 717 def test_EnumDomains(pipe, connect_handle):
 718
 719     print 'testing EnumDomains'
 720
 721     for domain in connect_handle.EnumDomains():
 722         test_LookupDomain(pipe, connect_handle, domain)
 723
 724 def runtests(binding, creds):
 725
 726     print 'Testing SAMR pipe'
 727
 728     pipe = dcerpc.pipe_connect(binding,
 729             dcerpc.DCERPC_SAMR_UUID, int(dcerpc.DCERPC_SAMR_VERSION), creds)
 730
 731     handle = test_Connect(pipe)
 732
 733     test_QuerySecurity(pipe, handle)
 734
 735     test_EnumDomains(pipe, handle)