source/torture/rpc/handles.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    test suite for behaviour of rpc policy handles
   5
   6    Copyright (C) Andrew Tridgell 2007
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "torture/torture.h"
  25 #include "librpc/gen_ndr/ndr_samr_c.h"
  26 #include "librpc/gen_ndr/ndr_lsa_c.h"
  27 #include "librpc/gen_ndr/ndr_drsuapi_c.h"
  28 #include "torture/rpc/rpc.h"
  29
  30 /*
  31   this tests the use of policy handles between connections
  32 */
  33
  34 static bool test_handles_lsa(struct torture_context *torture)
  35 {
  36         NTSTATUS status;
  37         struct dcerpc_pipe *p1, *p2;
  38         struct policy_handle handle;
  39         struct policy_handle handle2;
  40         struct lsa_ObjectAttribute attr;
  41         struct lsa_QosInfo qos;
  42         struct lsa_OpenPolicy r;
  43         struct lsa_Close c;
  44         uint16_t system_name = '\\';
  45         TALLOC_CTX *mem_ctx = talloc_new(torture);
  46
  47         torture_comment(torture, "RPC-HANDLE-LSARPC\n");
  48
  49         status = torture_rpc_connection(mem_ctx, &p1, &dcerpc_table_lsarpc);
  50         torture_assert_ntstatus_ok(torture, status, "opening lsa pipe1");
  51
  52         status = torture_rpc_connection(mem_ctx, &p2, &dcerpc_table_lsarpc);
  53         torture_assert_ntstatus_ok(torture, status, "opening lsa pipe1");
  54
  55         qos.len = 0;
  56         qos.impersonation_level = 2;
  57         qos.context_mode = 1;
  58         qos.effective_only = 0;
  59
  60         attr.len = 0;
  61         attr.root_dir = NULL;
  62         attr.object_name = NULL;
  63         attr.attributes = 0;
  64         attr.sec_desc = NULL;
  65         attr.sec_qos = &qos;
  66
  67         r.in.system_name = &system_name;
  68         r.in.attr = &attr;
  69         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
  70         r.out.handle = &handle;
  71
  72         status = dcerpc_lsa_OpenPolicy(p1, mem_ctx, &r);
  73         if (!NT_STATUS_IS_OK(status)) {
  74                 torture_comment(torture, "lsa_OpenPolicy not supported - skipping\n");
  75                 talloc_free(mem_ctx);
  76                 return true;
  77         }
  78
  79         c.in.handle = &handle;
  80         c.out.handle = &handle2;
  81
  82         status = dcerpc_lsa_Close(p2, mem_ctx, &c);
  83         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
  84                                       "closing policy handle on p2");
  85         torture_assert_int_equal(torture, p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
  86                                       "closing policy handle on p2");
  87
  88         status = dcerpc_lsa_Close(p1, mem_ctx, &c);
  89         torture_assert_ntstatus_ok(torture, status, "closing policy handle on p1");
  90
  91         status = dcerpc_lsa_Close(p1, mem_ctx, &c);
  92         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
  93                                       "closing policy handle on p1 again");
  94         torture_assert_int_equal(torture, p1->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
  95                                       "closing policy handle on p1 again");
  96
  97         talloc_free(mem_ctx);
  98
  99         return true;
 100 }
 101
 102 static bool test_handles_lsa_shared(struct torture_context *torture)
 103 {
 104         NTSTATUS status;
 105         struct dcerpc_pipe *p1, *p2, *p3, *p4, *p5;
 106         struct policy_handle handle;
 107         struct policy_handle handle2;
 108         struct lsa_ObjectAttribute attr;
 109         struct lsa_QosInfo qos;
 110         struct lsa_OpenPolicy r;
 111         struct lsa_Close c;
 112         struct lsa_QuerySecurity qsec;
 113         uint16_t system_name = '\\';
 114         TALLOC_CTX *mem_ctx = talloc_new(torture);
 115         enum dcerpc_transport_t transport;
 116         uint32_t assoc_group_id;
 117
 118         torture_comment(torture, "RPC-HANDLE-LSARPC-SHARED\n");
 119
 120         if (lp_parm_bool(-1, "torture", "samba4", False)) {
 121                 torture_comment(torture, "LSA shared-policy-handle test against Samba4 - skipping\n");
 122                 return true;
 123         }
 124
 125         torture_comment(torture, "connect lsa pipe1\n");
 126         status = torture_rpc_connection(mem_ctx, &p1, &dcerpc_table_lsarpc);
 127         torture_assert_ntstatus_ok(torture, status, "opening lsa pipe1");
 128
 129         transport       = p1->conn->transport.transport,
 130         assoc_group_id  = p1->assoc_group_id;
 131
 132         torture_comment(torture, "use assoc_group_id[0x%08X] for new connections\n", assoc_group_id);
 133
 134         torture_comment(torture, "connect lsa pipe2\n");
 135         status = torture_rpc_connection_transport(mem_ctx, &p2, &dcerpc_table_lsarpc,
 136                                                   transport,
 137                                                   assoc_group_id);
 138         torture_assert_ntstatus_ok(torture, status, "opening lsa pipe2");
 139
 140         qos.len = 0;
 141         qos.impersonation_level = 2;
 142         qos.context_mode = 1;
 143         qos.effective_only = 0;
 144
 145         attr.len = 0;
 146         attr.root_dir = NULL;
 147         attr.object_name = NULL;
 148         attr.attributes = 0;
 149         attr.sec_desc = NULL;
 150         attr.sec_qos = &qos;
 151
 152         r.in.system_name = &system_name;
 153         r.in.attr = &attr;
 154         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
 155         r.out.handle = &handle;
 156
 157         torture_comment(torture, "open lsa policy handle\n");
 158         status = dcerpc_lsa_OpenPolicy(p1, mem_ctx, &r);
 159         if (!NT_STATUS_IS_OK(status)) {
 160                 torture_comment(torture, "lsa_OpenPolicy not supported - skipping\n");
 161                 talloc_free(mem_ctx);
 162                 return true;
 163         }
 164
 165         /*
 166          * connect p3 after the policy handle is opened
 167          */
 168         torture_comment(torture, "connect lsa pipe3 after the policy handle is opened\n");
 169         status = torture_rpc_connection_transport(mem_ctx, &p3, &dcerpc_table_lsarpc,
 170                                                   transport,
 171                                                   assoc_group_id);
 172         torture_assert_ntstatus_ok(torture, status, "opening lsa pipe3");
 173
 174         qsec.in.handle          = &handle;
 175         qsec.in.sec_info        = 0;
 176         c.in.handle = &handle;
 177         c.out.handle = &handle2;
 178
 179         /*
 180          * use policy handle on all 3 connections
 181          */
 182         torture_comment(torture, "use the policy handle on p1,p2,p3\n");
 183         status = dcerpc_lsa_QuerySecurity(p1, mem_ctx, &qsec);
 184         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 185                                       "use policy handle on p1");
 186
 187         status = dcerpc_lsa_QuerySecurity(p2, mem_ctx, &qsec);
 188         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 189                                       "use policy handle on p2");
 190
 191         status = dcerpc_lsa_QuerySecurity(p3, mem_ctx, &qsec);
 192         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 193                                       "use policy handle on p3");
 194
 195         /*
 196          * close policy handle on connection 2 and the others get a fault
 197          */
 198         torture_comment(torture, "close the policy handle on p2 others get a fault\n");
 199         status = dcerpc_lsa_Close(p2, mem_ctx, &c);
 200         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 201                                       "closing policy handle on p2");
 202
 203         status = dcerpc_lsa_Close(p1, mem_ctx, &c);
 204         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 205                                       "closing policy handle on p1 again");
 206         torture_assert_int_equal(torture, p1->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 207                                       "closing policy handle on p1 again");
 208
 209         status = dcerpc_lsa_Close(p3, mem_ctx, &c);
 210         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 211                                       "closing policy handle on p3");
 212         torture_assert_int_equal(torture, p1->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 213                                       "closing policy handle on p3");
 214
 215         status = dcerpc_lsa_Close(p2, mem_ctx, &c);
 216         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 217                                       "closing policy handle on p2 again");
 218         torture_assert_int_equal(torture, p1->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 219                                       "closing policy handle on p2 again");
 220
 221         /*
 222          * open a new policy handle on p3
 223          */
 224         torture_comment(torture, "open a new policy handle on p3\n");
 225         status = dcerpc_lsa_OpenPolicy(p3, mem_ctx, &r);
 226         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 227                                       "open policy handle on p3");
 228
 229         /*
 230          * use policy handle on all 3 connections
 231          */
 232         torture_comment(torture, "use the policy handle on p1,p2,p3\n");
 233         status = dcerpc_lsa_QuerySecurity(p1, mem_ctx, &qsec);
 234         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 235                                       "use policy handle on p1");
 236
 237         status = dcerpc_lsa_QuerySecurity(p2, mem_ctx, &qsec);
 238         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 239                                       "use policy handle on p2");
 240
 241         status = dcerpc_lsa_QuerySecurity(p3, mem_ctx, &qsec);
 242         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 243                                       "use policy handle on p3");
 244
 245         /*
 246          * close policy handle on connection 2 and the others get a fault
 247          */
 248         torture_comment(torture, "close the policy handle on p2 others get a fault\n");
 249         status = dcerpc_lsa_Close(p2, mem_ctx, &c);
 250         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 251                                       "closing policy handle on p2");
 252
 253         status = dcerpc_lsa_Close(p1, mem_ctx, &c);
 254         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 255                                       "closing policy handle on p1 again");
 256         torture_assert_int_equal(torture, p1->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 257                                       "closing policy handle on p1 again");
 258
 259         status = dcerpc_lsa_Close(p3, mem_ctx, &c);
 260         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 261                                       "closing policy handle on p3");
 262         torture_assert_int_equal(torture, p1->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 263                                       "closing policy handle on p3");
 264
 265         status = dcerpc_lsa_Close(p2, mem_ctx, &c);
 266         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 267                                       "closing policy handle on p2 again");
 268         torture_assert_int_equal(torture, p1->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 269                                       "closing policy handle on p2 again");
 270
 271         /*
 272          * open a new policy handle
 273          */
 274         torture_comment(torture, "open a new policy handle on p1 and use it\n");
 275         status = dcerpc_lsa_OpenPolicy(p1, mem_ctx, &r);
 276         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 277                                       "open 2nd policy handle on p1");
 278
 279         status = dcerpc_lsa_QuerySecurity(p1, mem_ctx, &qsec);
 280         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 281                                       "QuerySecurity handle on p1");
 282
 283         /* close first connection */
 284         torture_comment(torture, "disconnect p1\n");
 285         talloc_free(p1);
 286         msleep(5);
 287
 288         /*
 289          * and it's still available on p2,p3
 290          */
 291         torture_comment(torture, "use policy handle on p2,p3\n");
 292         status = dcerpc_lsa_QuerySecurity(p2, mem_ctx, &qsec);
 293         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 294                                       "QuerySecurity handle on p2 after p1 was disconnected");
 295
 296         status = dcerpc_lsa_QuerySecurity(p3, mem_ctx, &qsec);
 297         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 298                                       "QuerySecurity handle on p3 after p1 was disconnected");
 299
 300         /*
 301          * now open p4
 302          * and use the handle on it
 303          */
 304         torture_comment(torture, "connect lsa pipe4 and use policy handle\n");
 305         status = torture_rpc_connection_transport(mem_ctx, &p4, &dcerpc_table_lsarpc,
 306                                                   transport,
 307                                                   assoc_group_id);
 308         torture_assert_ntstatus_ok(torture, status, "opening lsa pipe4");
 309
 310         status = dcerpc_lsa_QuerySecurity(p4, mem_ctx, &qsec);
 311         torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
 312                                       "using policy handle on p4");
 313
 314         /*
 315          * now close p2,p3,p4
 316          * without closing the policy handle
 317          */
 318         torture_comment(torture, "disconnect p2,p3,p4\n");
 319         talloc_free(p2);
 320         talloc_free(p3);
 321         talloc_free(p4);
 322         msleep(10);
 323
 324         /*
 325          * now open p5
 326          */
 327         torture_comment(torture, "connect lsa pipe5 - should fail\n");
 328         status = torture_rpc_connection_transport(mem_ctx, &p5, &dcerpc_table_lsarpc,
 329                                                   transport,
 330                                                   assoc_group_id);
 331         torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
 332                                       "opening lsa pipe5");
 333
 334         talloc_free(mem_ctx);
 335
 336         return true;
 337 }
 338
 339
 340 static bool test_handles_samr(struct torture_context *torture)
 341 {
 342         NTSTATUS status;
 343         struct dcerpc_pipe *p1, *p2;
 344         struct policy_handle handle;
 345         struct policy_handle handle2;
 346         struct samr_Connect r;
 347         struct samr_Close c;
 348         TALLOC_CTX *mem_ctx = talloc_new(torture);
 349
 350         torture_comment(torture, "RPC-HANDLE-SAMR\n");
 351
 352         status = torture_rpc_connection(mem_ctx, &p1, &dcerpc_table_samr);
 353         torture_assert_ntstatus_ok(torture, status, "opening samr pipe1");
 354
 355         status = torture_rpc_connection(mem_ctx, &p2, &dcerpc_table_samr);
 356         torture_assert_ntstatus_ok(torture, status, "opening samr pipe1");
 357
 358         r.in.system_name = 0;
 359         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
 360         r.out.connect_handle = &handle;
 361
 362         status = dcerpc_samr_Connect(p1, mem_ctx, &r);
 363         torture_assert_ntstatus_ok(torture, status, "opening policy handle on p1");
 364
 365         c.in.handle = &handle;
 366         c.out.handle = &handle2;
 367
 368         status = dcerpc_samr_Close(p2, mem_ctx, &c);
 369         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 370                                       "closing policy handle on p2");
 371         torture_assert_int_equal(torture, p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 372                                       "closing policy handle on p2");
 373
 374         status = dcerpc_samr_Close(p1, mem_ctx, &c);
 375         torture_assert_ntstatus_ok(torture, status, "closing policy handle on p1");
 376
 377         status = dcerpc_samr_Close(p1, mem_ctx, &c);
 378         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 379                                       "closing policy handle on p1 again");
 380         torture_assert_int_equal(torture, p1->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 381                                       "closing policy handle on p1 again");
 382
 383         talloc_free(mem_ctx);
 384
 385         return true;
 386 }
 387
 388 static bool test_handles_mixed_shared(struct torture_context *torture)
 389 {
 390         NTSTATUS status;
 391         struct dcerpc_pipe *p1, *p2, *p3, *p4, *p5, *p6;
 392         struct policy_handle handle;
 393         struct policy_handle handle2;
 394         struct samr_Connect r;
 395         struct lsa_Close lc;
 396         struct samr_Close sc;
 397         TALLOC_CTX *mem_ctx = talloc_new(torture);
 398         enum dcerpc_transport_t transport;
 399         uint32_t assoc_group_id;
 400
 401         torture_comment(torture, "RPC-HANDLE-MIXED-SHARED\n");
 402
 403         if (lp_parm_bool(-1, "torture", "samba4", False)) {
 404                 torture_comment(torture, "Mixed shared-policy-handle test against Samba4 - skipping\n");
 405                 return true;
 406         }
 407
 408         torture_comment(torture, "connect samr pipe1\n");
 409         status = torture_rpc_connection(mem_ctx, &p1, &dcerpc_table_samr);
 410         torture_assert_ntstatus_ok(torture, status, "opening samr pipe1");
 411
 412         transport       = p1->conn->transport.transport,
 413         assoc_group_id  = p1->assoc_group_id;
 414
 415         torture_comment(torture, "use assoc_group_id[0x%08X] for new connections\n", assoc_group_id);
 416
 417         torture_comment(torture, "connect lsa pipe2\n");
 418         status = torture_rpc_connection_transport(mem_ctx, &p2, &dcerpc_table_lsarpc,
 419                                                   transport,
 420                                                   assoc_group_id);
 421         torture_assert_ntstatus_ok(torture, status, "opening lsa pipe2");
 422
 423         r.in.system_name = 0;
 424         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
 425         r.out.connect_handle = &handle;
 426
 427         torture_comment(torture, "samr_Connect to open a policy handle on samr p1\n");
 428         status = dcerpc_samr_Connect(p1, mem_ctx, &r);
 429         torture_assert_ntstatus_ok(torture, status, "opening policy handle on p1");
 430
 431         lc.in.handle            = &handle;
 432         lc.out.handle           = &handle2;
 433         sc.in.handle            = &handle;
 434         sc.out.handle           = &handle2;
 435
 436         torture_comment(torture, "use policy handle on lsa p2 - should fail\n");
 437         status = dcerpc_lsa_Close(p2, mem_ctx, &lc);
 438         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 439                                       "closing handle on lsa p2");
 440         torture_assert_int_equal(torture, p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 441                                       "closing handle on lsa p2");
 442
 443         torture_comment(torture, "closing policy handle on samr p1\n");
 444         status = dcerpc_samr_Close(p1, mem_ctx, &sc);
 445         torture_assert_ntstatus_ok(torture, status, "closing policy handle on p1");
 446
 447         talloc_free(p1);
 448         talloc_free(p2);
 449         msleep(10);
 450
 451         torture_comment(torture, "connect samr pipe3 - should fail\n");
 452         status = torture_rpc_connection_transport(mem_ctx, &p3, &dcerpc_table_samr,
 453                                                   transport,
 454                                                   assoc_group_id);
 455         torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
 456                                       "opening samr pipe3");
 457
 458         torture_comment(torture, "connect lsa pipe4 - should fail\n");
 459         status = torture_rpc_connection_transport(mem_ctx, &p4, &dcerpc_table_lsarpc,
 460                                                   transport,
 461                                                   assoc_group_id);
 462         torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
 463                                       "opening lsa pipe4");
 464
 465         torture_comment(torture, "connect samr pipe5 with assoc_group_id[0x%08X]- should fail\n", ++assoc_group_id);
 466         status = torture_rpc_connection_transport(mem_ctx, &p5, &dcerpc_table_samr,
 467                                                   transport,
 468                                                   assoc_group_id);
 469         torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
 470                                       "opening samr pipe5");
 471
 472         torture_comment(torture, "connect lsa pipe6 with assoc_group_id[0x%08X]- should fail\n", ++assoc_group_id);
 473         status = torture_rpc_connection_transport(mem_ctx, &p6, &dcerpc_table_lsarpc,
 474                                                   transport,
 475                                                   assoc_group_id);
 476         torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
 477                                       "opening lsa pipe6");
 478
 479         talloc_free(mem_ctx);
 480
 481         return true;
 482 }
 483
 484 static bool test_handles_random_assoc(struct torture_context *torture)
 485 {
 486         NTSTATUS status;
 487         struct dcerpc_pipe *p1, *p2, *p3;
 488         TALLOC_CTX *mem_ctx = talloc_new(torture);
 489         enum dcerpc_transport_t transport;
 490         uint32_t assoc_group_id;
 491
 492         torture_comment(torture, "RPC-HANDLE-RANDOM-ASSOC\n");
 493
 494         torture_comment(torture, "connect samr pipe1\n");
 495         status = torture_rpc_connection(mem_ctx, &p1, &dcerpc_table_samr);
 496         torture_assert_ntstatus_ok(torture, status, "opening samr pipe1");
 497
 498         transport       = p1->conn->transport.transport,
 499         assoc_group_id  = p1->assoc_group_id;
 500
 501         torture_comment(torture, "pip1 use assoc_group_id[0x%08X]\n", assoc_group_id);
 502
 503         torture_comment(torture, "connect samr pipe2 with assoc_group_id[0x%08X]- should fail\n", ++assoc_group_id);
 504         status = torture_rpc_connection_transport(mem_ctx, &p2, &dcerpc_table_samr,
 505                                                   transport,
 506                                                   assoc_group_id);
 507         torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
 508                                       "opening samr pipe2");
 509
 510         torture_comment(torture, "connect samr pipe3 with assoc_group_id[0x%08X]- should fail\n", ++assoc_group_id);
 511         status = torture_rpc_connection_transport(mem_ctx, &p3, &dcerpc_table_samr,
 512                                                   transport,
 513                                                   assoc_group_id);
 514         torture_assert_ntstatus_equal(torture, status, NT_STATUS_UNSUCCESSFUL,
 515                                       "opening samr pipe3");
 516
 517         talloc_free(mem_ctx);
 518
 519         return true;
 520 }
 521
 522
 523 static bool test_handles_drsuapi(struct torture_context *torture)
 524 {
 525         NTSTATUS status;
 526         struct dcerpc_pipe *p1, *p2;
 527         struct policy_handle handle;
 528         struct policy_handle handle2;
 529         struct GUID bind_guid;
 530         struct drsuapi_DsBind r;
 531         struct drsuapi_DsUnbind c;
 532         TALLOC_CTX *mem_ctx = talloc_new(torture);
 533
 534         torture_comment(torture, "RPC-HANDLE-DRSUAPI\n");
 535
 536         status = torture_rpc_connection(mem_ctx, &p1, &dcerpc_table_drsuapi);
 537         torture_assert_ntstatus_ok(torture, status, "opening drsuapi pipe1");
 538
 539         status = torture_rpc_connection(mem_ctx, &p2, &dcerpc_table_drsuapi);
 540         torture_assert_ntstatus_ok(torture, status, "opening drsuapi pipe1");
 541
 542         GUID_from_string(DRSUAPI_DS_BIND_GUID, &bind_guid);
 543
 544         r.in.bind_guid = &bind_guid;
 545         r.in.bind_info = NULL;
 546         r.out.bind_handle = &handle;
 547
 548         status = dcerpc_drsuapi_DsBind(p1, mem_ctx, &r);
 549         if (!NT_STATUS_IS_OK(status)) {
 550                 torture_comment(torture, "drsuapi_DsBind not supported - skipping\n");
 551                 talloc_free(mem_ctx);
 552                 return true;
 553         }
 554
 555         c.in.bind_handle = &handle;
 556         c.out.bind_handle = &handle2;
 557
 558         status = dcerpc_drsuapi_DsUnbind(p2, mem_ctx, &c);
 559         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 560                                       "closing policy handle on p2");
 561         torture_assert_int_equal(torture, p2->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 562                                       "closing policy handle on p2");
 563
 564         status = dcerpc_drsuapi_DsUnbind(p1, mem_ctx, &c);
 565         torture_assert_ntstatus_ok(torture, status, "closing policy handle on p1");
 566
 567         status = dcerpc_drsuapi_DsUnbind(p1, mem_ctx, &c);
 568         torture_assert_ntstatus_equal(torture, status, NT_STATUS_NET_WRITE_FAULT,
 569                                       "closing policy handle on p1 again");
 570         torture_assert_int_equal(torture, p1->last_fault_code, DCERPC_FAULT_CONTEXT_MISMATCH,
 571                                       "closing policy handle on p1 again");
 572
 573         talloc_free(mem_ctx);
 574
 575         return true;
 576 }
 577
 578
 579 struct torture_suite *torture_rpc_handles(void)
 580 {
 581         struct torture_suite *suite;
 582
 583         suite = torture_suite_create(talloc_autofree_context(), "HANDLES");
 584         torture_suite_add_simple_test(suite, "lsarpc", test_handles_lsa);
 585         torture_suite_add_simple_test(suite, "lsarpc-shared", test_handles_lsa_shared);
 586         torture_suite_add_simple_test(suite, "samr", test_handles_samr);
 587         torture_suite_add_simple_test(suite, "mixed-shared", test_handles_mixed_shared);
 588         torture_suite_add_simple_test(suite, "random-assoc", test_handles_random_assoc);
 589         torture_suite_add_simple_test(suite, "drsuapi", test_handles_drsuapi);
 590         return suite;
 591 }