00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "includes.h"
00025
00026
00027
00028 NTSTATUS rpccli_samr_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00029 uint32 access_mask, POLICY_HND *connect_pol)
00030 {
00031 prs_struct qbuf, rbuf;
00032 SAMR_Q_CONNECT q;
00033 SAMR_R_CONNECT r;
00034 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00035
00036 DEBUG(10,("cli_samr_connect to %s\n", cli->cli->desthost));
00037
00038 ZERO_STRUCT(q);
00039 ZERO_STRUCT(r);
00040
00041
00042
00043 init_samr_q_connect(&q, cli->cli->desthost, access_mask);
00044
00045 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CONNECT,
00046 q, r,
00047 qbuf, rbuf,
00048 samr_io_q_connect,
00049 samr_io_r_connect,
00050 NT_STATUS_UNSUCCESSFUL);
00051
00052
00053 if (NT_STATUS_IS_OK(result = r.status)) {
00054 *connect_pol = r.connect_pol;
00055 #ifdef __INSURE__
00056 connect_pol->marker = malloc(1);
00057 #endif
00058 }
00059
00060 return result;
00061 }
00062
00063
00064
00065 NTSTATUS rpccli_samr_connect4(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00066 uint32 access_mask, POLICY_HND *connect_pol)
00067 {
00068 prs_struct qbuf, rbuf;
00069 SAMR_Q_CONNECT4 q;
00070 SAMR_R_CONNECT4 r;
00071 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00072
00073 ZERO_STRUCT(q);
00074 ZERO_STRUCT(r);
00075
00076
00077
00078 init_samr_q_connect4(&q, cli->cli->desthost, access_mask);
00079
00080 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CONNECT4,
00081 q, r,
00082 qbuf, rbuf,
00083 samr_io_q_connect4,
00084 samr_io_r_connect4,
00085 NT_STATUS_UNSUCCESSFUL);
00086
00087
00088
00089 if (NT_STATUS_IS_OK(result = r.status)) {
00090 *connect_pol = r.connect_pol;
00091 #ifdef __INSURE__
00092 connect_pol->marker = malloc(1);
00093 #endif
00094 }
00095
00096 return result;
00097 }
00098
00099
00100
00101 NTSTATUS rpccli_samr_close(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00102 POLICY_HND *connect_pol)
00103 {
00104 prs_struct qbuf, rbuf;
00105 SAMR_Q_CLOSE_HND q;
00106 SAMR_R_CLOSE_HND r;
00107 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00108
00109 DEBUG(10,("cli_samr_close\n"));
00110
00111 ZERO_STRUCT(q);
00112 ZERO_STRUCT(r);
00113
00114
00115
00116 init_samr_q_close_hnd(&q, connect_pol);
00117
00118 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CLOSE_HND,
00119 q, r,
00120 qbuf, rbuf,
00121 samr_io_q_close_hnd,
00122 samr_io_r_close_hnd,
00123 NT_STATUS_UNSUCCESSFUL);
00124
00125
00126
00127 if (NT_STATUS_IS_OK(result = r.status)) {
00128 #ifdef __INSURE__
00129 SAFE_FREE(connect_pol->marker);
00130 #endif
00131 *connect_pol = r.pol;
00132 }
00133
00134 return result;
00135 }
00136
00137
00138
00139 NTSTATUS rpccli_samr_open_domain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00140 POLICY_HND *connect_pol, uint32 access_mask,
00141 const DOM_SID *domain_sid,
00142 POLICY_HND *domain_pol)
00143 {
00144 prs_struct qbuf, rbuf;
00145 SAMR_Q_OPEN_DOMAIN q;
00146 SAMR_R_OPEN_DOMAIN r;
00147 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00148
00149 DEBUG(10,("cli_samr_open_domain with sid %s\n", sid_string_static(domain_sid) ));
00150
00151 ZERO_STRUCT(q);
00152 ZERO_STRUCT(r);
00153
00154
00155
00156 init_samr_q_open_domain(&q, connect_pol, access_mask, domain_sid);
00157
00158 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_DOMAIN,
00159 q, r,
00160 qbuf, rbuf,
00161 samr_io_q_open_domain,
00162 samr_io_r_open_domain,
00163 NT_STATUS_UNSUCCESSFUL);
00164
00165
00166
00167 if (NT_STATUS_IS_OK(result = r.status)) {
00168 *domain_pol = r.domain_pol;
00169 #ifdef __INSURE__
00170 domain_pol->marker = malloc(1);
00171 #endif
00172 }
00173
00174 return result;
00175 }
00176
00177 NTSTATUS rpccli_samr_open_user(struct rpc_pipe_client *cli,
00178 TALLOC_CTX *mem_ctx,
00179 POLICY_HND *domain_pol, uint32 access_mask,
00180 uint32 user_rid, POLICY_HND *user_pol)
00181 {
00182 prs_struct qbuf, rbuf;
00183 SAMR_Q_OPEN_USER q;
00184 SAMR_R_OPEN_USER r;
00185 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00186
00187 DEBUG(10,("cli_samr_open_user with rid 0x%x\n", user_rid ));
00188
00189 ZERO_STRUCT(q);
00190 ZERO_STRUCT(r);
00191
00192
00193
00194 init_samr_q_open_user(&q, domain_pol, access_mask, user_rid);
00195
00196 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_USER,
00197 q, r,
00198 qbuf, rbuf,
00199 samr_io_q_open_user,
00200 samr_io_r_open_user,
00201 NT_STATUS_UNSUCCESSFUL);
00202
00203
00204
00205 if (NT_STATUS_IS_OK(result = r.status)) {
00206 *user_pol = r.user_pol;
00207 #ifdef __INSURE__
00208 user_pol->marker = malloc(1);
00209 #endif
00210 }
00211
00212 return result;
00213 }
00214
00215
00216
00217 NTSTATUS rpccli_samr_open_group(struct rpc_pipe_client *cli,
00218 TALLOC_CTX *mem_ctx,
00219 POLICY_HND *domain_pol, uint32 access_mask,
00220 uint32 group_rid, POLICY_HND *group_pol)
00221 {
00222 prs_struct qbuf, rbuf;
00223 SAMR_Q_OPEN_GROUP q;
00224 SAMR_R_OPEN_GROUP r;
00225 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00226
00227 DEBUG(10,("cli_samr_open_group with rid 0x%x\n", group_rid ));
00228
00229 ZERO_STRUCT(q);
00230 ZERO_STRUCT(r);
00231
00232
00233
00234 init_samr_q_open_group(&q, domain_pol, access_mask, group_rid);
00235
00236 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_GROUP,
00237 q, r,
00238 qbuf, rbuf,
00239 samr_io_q_open_group,
00240 samr_io_r_open_group,
00241 NT_STATUS_UNSUCCESSFUL);
00242
00243
00244
00245 if (NT_STATUS_IS_OK(result = r.status)) {
00246 *group_pol = r.pol;
00247 #ifdef __INSURE__
00248 group_pol->marker = malloc(1);
00249 #endif
00250 }
00251
00252 return result;
00253 }
00254
00255
00256
00257 NTSTATUS rpccli_samr_create_dom_group(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00258 POLICY_HND *domain_pol,
00259 const char *group_name,
00260 uint32 access_mask, POLICY_HND *group_pol)
00261 {
00262 prs_struct qbuf, rbuf;
00263 SAMR_Q_CREATE_DOM_GROUP q;
00264 SAMR_R_CREATE_DOM_GROUP r;
00265 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00266
00267 DEBUG(10,("cli_samr_create_dom_group\n"));
00268
00269 ZERO_STRUCT(q);
00270 ZERO_STRUCT(r);
00271
00272
00273
00274 init_samr_q_create_dom_group(&q, domain_pol, group_name, access_mask);
00275
00276 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_DOM_GROUP,
00277 q, r,
00278 qbuf, rbuf,
00279 samr_io_q_create_dom_group,
00280 samr_io_r_create_dom_group,
00281 NT_STATUS_UNSUCCESSFUL);
00282
00283
00284
00285 result = r.status;
00286
00287 if (NT_STATUS_IS_OK(result))
00288 *group_pol = r.pol;
00289
00290 return result;
00291 }
00292
00293
00294
00295 NTSTATUS rpccli_samr_add_groupmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00296 POLICY_HND *group_pol, uint32 rid)
00297 {
00298 prs_struct qbuf, rbuf;
00299 SAMR_Q_ADD_GROUPMEM q;
00300 SAMR_R_ADD_GROUPMEM r;
00301 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00302
00303 DEBUG(10,("cli_samr_add_groupmem\n"));
00304
00305 ZERO_STRUCT(q);
00306 ZERO_STRUCT(r);
00307
00308
00309
00310 init_samr_q_add_groupmem(&q, group_pol, rid);
00311
00312 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ADD_GROUPMEM,
00313 q, r,
00314 qbuf, rbuf,
00315 samr_io_q_add_groupmem,
00316 samr_io_r_add_groupmem,
00317 NT_STATUS_UNSUCCESSFUL);
00318
00319
00320
00321 result = r.status;
00322
00323 return result;
00324 }
00325
00326
00327
00328 NTSTATUS rpccli_samr_del_groupmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00329 POLICY_HND *group_pol, uint32 rid)
00330 {
00331 prs_struct qbuf, rbuf;
00332 SAMR_Q_DEL_GROUPMEM q;
00333 SAMR_R_DEL_GROUPMEM r;
00334 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00335
00336 DEBUG(10,("cli_samr_del_groupmem\n"));
00337
00338 ZERO_STRUCT(q);
00339 ZERO_STRUCT(r);
00340
00341
00342
00343 init_samr_q_del_groupmem(&q, group_pol, rid);
00344
00345 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DEL_GROUPMEM,
00346 q, r,
00347 qbuf, rbuf,
00348 samr_io_q_del_groupmem,
00349 samr_io_r_del_groupmem,
00350 NT_STATUS_UNSUCCESSFUL);
00351
00352
00353
00354 result = r.status;
00355
00356 return result;
00357 }
00358
00359
00360
00361 NTSTATUS rpccli_samr_query_userinfo(struct rpc_pipe_client *cli,
00362 TALLOC_CTX *mem_ctx,
00363 const POLICY_HND *user_pol,
00364 uint16 switch_value,
00365 SAM_USERINFO_CTR **ctr)
00366 {
00367 prs_struct qbuf, rbuf;
00368 SAMR_Q_QUERY_USERINFO q;
00369 SAMR_R_QUERY_USERINFO r;
00370 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00371
00372 DEBUG(10,("cli_samr_query_userinfo\n"));
00373
00374 ZERO_STRUCT(q);
00375 ZERO_STRUCT(r);
00376
00377
00378
00379 init_samr_q_query_userinfo(&q, user_pol, switch_value);
00380
00381 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERINFO,
00382 q, r,
00383 qbuf, rbuf,
00384 samr_io_q_query_userinfo,
00385 samr_io_r_query_userinfo,
00386 NT_STATUS_UNSUCCESSFUL);
00387
00388
00389
00390 result = r.status;
00391 *ctr = r.ctr;
00392
00393 return result;
00394 }
00395
00396
00397
00398 NTSTATUS rpccli_samr_set_groupinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00399 POLICY_HND *group_pol, GROUP_INFO_CTR *ctr)
00400 {
00401 prs_struct qbuf, rbuf;
00402 SAMR_Q_SET_GROUPINFO q;
00403 SAMR_R_SET_GROUPINFO r;
00404 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00405
00406 DEBUG(10,("cli_samr_set_groupinfo\n"));
00407
00408 ZERO_STRUCT(q);
00409 ZERO_STRUCT(r);
00410
00411
00412
00413 init_samr_q_set_groupinfo(&q, group_pol, ctr);
00414
00415 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_GROUPINFO,
00416 q, r,
00417 qbuf, rbuf,
00418 samr_io_q_set_groupinfo,
00419 samr_io_r_set_groupinfo,
00420 NT_STATUS_UNSUCCESSFUL);
00421
00422
00423
00424 result = r.status;
00425
00426 return result;
00427 }
00428
00429
00430
00431 NTSTATUS rpccli_samr_query_groupinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00432 POLICY_HND *group_pol, uint32 info_level,
00433 GROUP_INFO_CTR **ctr)
00434 {
00435 prs_struct qbuf, rbuf;
00436 SAMR_Q_QUERY_GROUPINFO q;
00437 SAMR_R_QUERY_GROUPINFO r;
00438 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00439
00440 DEBUG(10,("cli_samr_query_groupinfo\n"));
00441
00442 ZERO_STRUCT(q);
00443 ZERO_STRUCT(r);
00444
00445
00446
00447 init_samr_q_query_groupinfo(&q, group_pol, info_level);
00448
00449 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_GROUPINFO,
00450 q, r,
00451 qbuf, rbuf,
00452 samr_io_q_query_groupinfo,
00453 samr_io_r_query_groupinfo,
00454 NT_STATUS_UNSUCCESSFUL);
00455
00456 *ctr = r.ctr;
00457
00458
00459
00460 result = r.status;
00461
00462 return result;
00463 }
00464
00465
00466
00467 NTSTATUS rpccli_samr_query_usergroups(struct rpc_pipe_client *cli,
00468 TALLOC_CTX *mem_ctx,
00469 POLICY_HND *user_pol,
00470 uint32 *num_groups,
00471 DOM_GID **gid)
00472 {
00473 prs_struct qbuf, rbuf;
00474 SAMR_Q_QUERY_USERGROUPS q;
00475 SAMR_R_QUERY_USERGROUPS r;
00476 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00477
00478 DEBUG(10,("cli_samr_query_usergroups\n"));
00479
00480 ZERO_STRUCT(q);
00481 ZERO_STRUCT(r);
00482
00483
00484
00485 init_samr_q_query_usergroups(&q, user_pol);
00486
00487 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERGROUPS,
00488 q, r,
00489 qbuf, rbuf,
00490 samr_io_q_query_usergroups,
00491 samr_io_r_query_usergroups,
00492 NT_STATUS_UNSUCCESSFUL);
00493
00494
00495
00496 if (NT_STATUS_IS_OK(result = r.status)) {
00497 *num_groups = r.num_entries;
00498 *gid = r.gid;
00499 }
00500
00501 return result;
00502 }
00503
00504
00505
00506 NTSTATUS rpccli_samr_set_aliasinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00507 POLICY_HND *alias_pol, ALIAS_INFO_CTR *ctr)
00508 {
00509 prs_struct qbuf, rbuf;
00510 SAMR_Q_SET_ALIASINFO q;
00511 SAMR_R_SET_ALIASINFO r;
00512 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00513
00514 DEBUG(10,("cli_samr_set_aliasinfo\n"));
00515
00516 ZERO_STRUCT(q);
00517 ZERO_STRUCT(r);
00518
00519
00520
00521 init_samr_q_set_aliasinfo(&q, alias_pol, ctr);
00522
00523 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_ALIASINFO,
00524 q, r,
00525 qbuf, rbuf,
00526 samr_io_q_set_aliasinfo,
00527 samr_io_r_set_aliasinfo,
00528 NT_STATUS_UNSUCCESSFUL);
00529
00530
00531
00532 result = r.status;
00533
00534 return result;
00535 }
00536
00537
00538
00539 NTSTATUS rpccli_samr_query_useraliases(struct rpc_pipe_client *cli,
00540 TALLOC_CTX *mem_ctx,
00541 POLICY_HND *dom_pol, uint32 num_sids,
00542 DOM_SID2 *sid,
00543 uint32 *num_aliases, uint32 **als_rids)
00544 {
00545 prs_struct qbuf, rbuf;
00546 SAMR_Q_QUERY_USERALIASES q;
00547 SAMR_R_QUERY_USERALIASES r;
00548 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00549 int i;
00550 uint32 *sid_ptrs;
00551
00552 DEBUG(10,("cli_samr_query_useraliases\n"));
00553
00554 ZERO_STRUCT(q);
00555 ZERO_STRUCT(r);
00556
00557 if (num_sids) {
00558 sid_ptrs = TALLOC_ARRAY(mem_ctx, uint32, num_sids);
00559 if (sid_ptrs == NULL)
00560 return NT_STATUS_NO_MEMORY;
00561 } else {
00562 sid_ptrs = NULL;
00563 }
00564
00565 for (i=0; i<num_sids; i++)
00566 sid_ptrs[i] = 1;
00567
00568
00569
00570 init_samr_q_query_useraliases(&q, dom_pol, num_sids, sid_ptrs, sid);
00571
00572 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERALIASES,
00573 q, r,
00574 qbuf, rbuf,
00575 samr_io_q_query_useraliases,
00576 samr_io_r_query_useraliases,
00577 NT_STATUS_UNSUCCESSFUL);
00578
00579
00580
00581 if (NT_STATUS_IS_OK(result = r.status)) {
00582 *num_aliases = r.num_entries;
00583 *als_rids = r.rid;
00584 }
00585
00586 return result;
00587 }
00588
00589
00590
00591 NTSTATUS rpccli_samr_query_groupmem(struct rpc_pipe_client *cli,
00592 TALLOC_CTX *mem_ctx,
00593 POLICY_HND *group_pol, uint32 *num_mem,
00594 uint32 **rid, uint32 **attr)
00595 {
00596 prs_struct qbuf, rbuf;
00597 SAMR_Q_QUERY_GROUPMEM q;
00598 SAMR_R_QUERY_GROUPMEM r;
00599 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00600
00601 DEBUG(10,("cli_samr_query_groupmem\n"));
00602
00603 ZERO_STRUCT(q);
00604 ZERO_STRUCT(r);
00605
00606
00607
00608 init_samr_q_query_groupmem(&q, group_pol);
00609
00610 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_GROUPMEM,
00611 q, r,
00612 qbuf, rbuf,
00613 samr_io_q_query_groupmem,
00614 samr_io_r_query_groupmem,
00615 NT_STATUS_UNSUCCESSFUL);
00616
00617
00618
00619 if (NT_STATUS_IS_OK(result = r.status)) {
00620 *num_mem = r.num_entries;
00621 *rid = r.rid;
00622 *attr = r.attr;
00623 }
00624
00625 return result;
00626 }
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646 NTSTATUS rpccli_samr_enum_dom_users(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00647 POLICY_HND *pol, uint32 *start_idx, uint32 acb_mask,
00648 uint32 size, char ***dom_users, uint32 **rids,
00649 uint32 *num_dom_users)
00650 {
00651 prs_struct qbuf;
00652 prs_struct rbuf;
00653 SAMR_Q_ENUM_DOM_USERS q;
00654 SAMR_R_ENUM_DOM_USERS r;
00655 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00656 int i;
00657
00658 DEBUG(10,("cli_samr_enum_dom_users starting at index %u\n", (unsigned int)*start_idx));
00659
00660 ZERO_STRUCT(q);
00661 ZERO_STRUCT(r);
00662
00663
00664 *num_dom_users = 0;
00665
00666
00667
00668 init_samr_q_enum_dom_users(&q, pol, *start_idx, acb_mask, size);
00669
00670 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_USERS,
00671 q, r,
00672 qbuf, rbuf,
00673 samr_io_q_enum_dom_users,
00674 samr_io_r_enum_dom_users,
00675 NT_STATUS_UNSUCCESSFUL);
00676
00677 result = r.status;
00678
00679 if (!NT_STATUS_IS_OK(result) &&
00680 NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES))
00681 goto done;
00682
00683 *start_idx = r.next_idx;
00684 *num_dom_users = r.num_entries2;
00685
00686 if (r.num_entries2) {
00687
00688 *rids = TALLOC_ARRAY(mem_ctx, uint32, r.num_entries2);
00689 if (!*rids) {
00690 DEBUG(0, ("Error in cli_samr_enum_dom_users(): out of memory\n"));
00691 return NT_STATUS_NO_MEMORY;
00692 }
00693
00694 *dom_users = TALLOC_ARRAY(mem_ctx, char*, r.num_entries2);
00695 if (!*dom_users) {
00696 DEBUG(0, ("Error in cli_samr_enum_dom_users(): out of memory\n"));
00697 return NT_STATUS_NO_MEMORY;
00698 }
00699
00700
00701 for (i = 0; i < r.num_entries2; i++) {
00702 fstring conv_buf;
00703
00704 (*rids)[i] = r.sam[i].rid;
00705 unistr2_to_ascii(conv_buf, &(r.uni_acct_name[i]), sizeof(conv_buf) - 1);
00706 (*dom_users)[i] = talloc_strdup(mem_ctx, conv_buf);
00707 }
00708 }
00709
00710 done:
00711 return result;
00712 }
00713
00714
00715
00716 NTSTATUS rpccli_samr_enum_dom_groups(struct rpc_pipe_client *cli,
00717 TALLOC_CTX *mem_ctx,
00718 POLICY_HND *pol, uint32 *start_idx,
00719 uint32 size, struct acct_info **dom_groups,
00720 uint32 *num_dom_groups)
00721 {
00722 prs_struct qbuf, rbuf;
00723 SAMR_Q_ENUM_DOM_GROUPS q;
00724 SAMR_R_ENUM_DOM_GROUPS r;
00725 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00726 uint32 name_idx, i;
00727
00728 DEBUG(10,("cli_samr_enum_dom_groups starting at index %u\n", (unsigned int)*start_idx));
00729
00730 ZERO_STRUCT(q);
00731 ZERO_STRUCT(r);
00732
00733
00734
00735 init_samr_q_enum_dom_groups(&q, pol, *start_idx, size);
00736
00737 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_GROUPS,
00738 q, r,
00739 qbuf, rbuf,
00740 samr_io_q_enum_dom_groups,
00741 samr_io_r_enum_dom_groups,
00742 NT_STATUS_UNSUCCESSFUL);
00743
00744
00745
00746 result = r.status;
00747
00748 if (!NT_STATUS_IS_OK(result) &&
00749 NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES))
00750 goto done;
00751
00752 *num_dom_groups = r.num_entries2;
00753
00754 if (*num_dom_groups == 0)
00755 goto done;
00756
00757 if (!((*dom_groups) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_dom_groups))) {
00758 result = NT_STATUS_NO_MEMORY;
00759 goto done;
00760 }
00761
00762 memset(*dom_groups, 0, sizeof(struct acct_info) * (*num_dom_groups));
00763
00764 name_idx = 0;
00765
00766 for (i = 0; i < *num_dom_groups; i++) {
00767
00768 (*dom_groups)[i].rid = r.sam[i].rid;
00769
00770 if (r.sam[i].hdr_name.buffer) {
00771 unistr2_to_ascii((*dom_groups)[i].acct_name,
00772 &r.uni_grp_name[name_idx],
00773 sizeof(fstring) - 1);
00774 name_idx++;
00775 }
00776
00777 *start_idx = r.next_idx;
00778 }
00779
00780 done:
00781 return result;
00782 }
00783
00784
00785
00786 NTSTATUS rpccli_samr_enum_als_groups(struct rpc_pipe_client *cli,
00787 TALLOC_CTX *mem_ctx,
00788 POLICY_HND *pol, uint32 *start_idx,
00789 uint32 size, struct acct_info **dom_aliases,
00790 uint32 *num_dom_aliases)
00791 {
00792 prs_struct qbuf, rbuf;
00793 SAMR_Q_ENUM_DOM_ALIASES q;
00794 SAMR_R_ENUM_DOM_ALIASES r;
00795 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00796 uint32 name_idx, i;
00797
00798 DEBUG(10,("cli_samr_enum_als_groups starting at index %u\n", (unsigned int)*start_idx));
00799
00800 ZERO_STRUCT(q);
00801 ZERO_STRUCT(r);
00802
00803
00804
00805 init_samr_q_enum_dom_aliases(&q, pol, *start_idx, size);
00806
00807 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_ALIASES,
00808 q, r,
00809 qbuf, rbuf,
00810 samr_io_q_enum_dom_aliases,
00811 samr_io_r_enum_dom_aliases,
00812 NT_STATUS_UNSUCCESSFUL);
00813
00814
00815
00816 result = r.status;
00817
00818 if (!NT_STATUS_IS_OK(result) &&
00819 NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
00820 goto done;
00821 }
00822
00823 *num_dom_aliases = r.num_entries2;
00824
00825 if (*num_dom_aliases == 0)
00826 goto done;
00827
00828 if (!((*dom_aliases) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_dom_aliases))) {
00829 result = NT_STATUS_NO_MEMORY;
00830 goto done;
00831 }
00832
00833 memset(*dom_aliases, 0, sizeof(struct acct_info) * *num_dom_aliases);
00834
00835 name_idx = 0;
00836
00837 for (i = 0; i < *num_dom_aliases; i++) {
00838
00839 (*dom_aliases)[i].rid = r.sam[i].rid;
00840
00841 if (r.sam[i].hdr_name.buffer) {
00842 unistr2_to_ascii((*dom_aliases)[i].acct_name,
00843 &r.uni_grp_name[name_idx],
00844 sizeof(fstring) - 1);
00845 name_idx++;
00846 }
00847
00848 *start_idx = r.next_idx;
00849 }
00850
00851 done:
00852 return result;
00853 }
00854
00855
00856
00857 NTSTATUS rpccli_samr_query_aliasmem(struct rpc_pipe_client *cli,
00858 TALLOC_CTX *mem_ctx,
00859 POLICY_HND *alias_pol, uint32 *num_mem,
00860 DOM_SID **sids)
00861 {
00862 prs_struct qbuf, rbuf;
00863 SAMR_Q_QUERY_ALIASMEM q;
00864 SAMR_R_QUERY_ALIASMEM r;
00865 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
00866 uint32 i;
00867
00868 DEBUG(10,("cli_samr_query_aliasmem\n"));
00869
00870 ZERO_STRUCT(q);
00871 ZERO_STRUCT(r);
00872
00873
00874
00875 init_samr_q_query_aliasmem(&q, alias_pol);
00876
00877 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_ALIASMEM,
00878 q, r,
00879 qbuf, rbuf,
00880 samr_io_q_query_aliasmem,
00881 samr_io_r_query_aliasmem,
00882 NT_STATUS_UNSUCCESSFUL);
00883
00884
00885
00886 if (!NT_STATUS_IS_OK(result = r.status)) {
00887 goto done;
00888 }
00889
00890 *num_mem = r.num_sids;
00891
00892 if (*num_mem == 0) {
00893 *sids = NULL;
00894 result = NT_STATUS_OK;
00895 goto done;
00896 }
00897
00898 if (!(*sids = TALLOC_ARRAY(mem_ctx, DOM_SID, *num_mem))) {
00899 result = NT_STATUS_UNSUCCESSFUL;
00900 goto done;
00901 }
00902
00903 for (i = 0; i < *num_mem; i++) {
00904 (*sids)[i] = r.sid[i].sid;
00905 }
00906
00907 done:
00908 return result;
00909 }
00910
00911
00912
00913 NTSTATUS rpccli_samr_open_alias(struct rpc_pipe_client *cli,
00914 TALLOC_CTX *mem_ctx,
00915 POLICY_HND *domain_pol, uint32 access_mask,
00916 uint32 alias_rid, POLICY_HND *alias_pol)
00917 {
00918 prs_struct qbuf, rbuf;
00919 SAMR_Q_OPEN_ALIAS q;
00920 SAMR_R_OPEN_ALIAS r;
00921 NTSTATUS result;
00922
00923 DEBUG(10,("cli_samr_open_alias with rid 0x%x\n", alias_rid));
00924
00925 ZERO_STRUCT(q);
00926 ZERO_STRUCT(r);
00927
00928
00929
00930 init_samr_q_open_alias(&q, domain_pol, access_mask, alias_rid);
00931
00932 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_ALIAS,
00933 q, r,
00934 qbuf, rbuf,
00935 samr_io_q_open_alias,
00936 samr_io_r_open_alias,
00937 NT_STATUS_UNSUCCESSFUL);
00938
00939
00940
00941 if (NT_STATUS_IS_OK(result = r.status)) {
00942 *alias_pol = r.pol;
00943 #ifdef __INSURE__
00944 alias_pol->marker = malloc(1);
00945 #endif
00946 }
00947
00948 return result;
00949 }
00950
00951
00952
00953 NTSTATUS rpccli_samr_create_dom_alias(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00954 POLICY_HND *domain_pol, const char *name,
00955 POLICY_HND *alias_pol)
00956 {
00957 prs_struct qbuf, rbuf;
00958 SAMR_Q_CREATE_DOM_ALIAS q;
00959 SAMR_R_CREATE_DOM_ALIAS r;
00960 NTSTATUS result;
00961
00962 DEBUG(10,("cli_samr_create_dom_alias named %s\n", name));
00963
00964 ZERO_STRUCT(q);
00965 ZERO_STRUCT(r);
00966
00967
00968
00969 init_samr_q_create_dom_alias(&q, domain_pol, name);
00970
00971 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_DOM_ALIAS,
00972 q, r,
00973 qbuf, rbuf,
00974 samr_io_q_create_dom_alias,
00975 samr_io_r_create_dom_alias,
00976 NT_STATUS_UNSUCCESSFUL);
00977
00978
00979
00980 if (NT_STATUS_IS_OK(result = r.status)) {
00981 *alias_pol = r.alias_pol;
00982 }
00983
00984 return result;
00985 }
00986
00987
00988
00989 NTSTATUS rpccli_samr_add_aliasmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
00990 POLICY_HND *alias_pol, DOM_SID *member)
00991 {
00992 prs_struct qbuf, rbuf;
00993 SAMR_Q_ADD_ALIASMEM q;
00994 SAMR_R_ADD_ALIASMEM r;
00995 NTSTATUS result;
00996
00997 DEBUG(10,("cli_samr_add_aliasmem"));
00998
00999 ZERO_STRUCT(q);
01000 ZERO_STRUCT(r);
01001
01002
01003
01004 init_samr_q_add_aliasmem(&q, alias_pol, member);
01005
01006 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ADD_ALIASMEM,
01007 q, r,
01008 qbuf, rbuf,
01009 samr_io_q_add_aliasmem,
01010 samr_io_r_add_aliasmem,
01011 NT_STATUS_UNSUCCESSFUL);
01012
01013 result = r.status;
01014
01015 return result;
01016 }
01017
01018
01019
01020 NTSTATUS rpccli_samr_del_aliasmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01021 POLICY_HND *alias_pol, DOM_SID *member)
01022 {
01023 prs_struct qbuf, rbuf;
01024 SAMR_Q_DEL_ALIASMEM q;
01025 SAMR_R_DEL_ALIASMEM r;
01026 NTSTATUS result;
01027
01028 DEBUG(10,("cli_samr_del_aliasmem"));
01029
01030 ZERO_STRUCT(q);
01031 ZERO_STRUCT(r);
01032
01033
01034
01035 init_samr_q_del_aliasmem(&q, alias_pol, member);
01036
01037 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DEL_ALIASMEM,
01038 q, r,
01039 qbuf, rbuf,
01040 samr_io_q_del_aliasmem,
01041 samr_io_r_del_aliasmem,
01042 NT_STATUS_UNSUCCESSFUL);
01043
01044 result = r.status;
01045
01046 return result;
01047 }
01048
01049
01050
01051 NTSTATUS rpccli_samr_query_alias_info(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01052 POLICY_HND *alias_pol, uint16 switch_value,
01053 ALIAS_INFO_CTR *ctr)
01054 {
01055 prs_struct qbuf, rbuf;
01056 SAMR_Q_QUERY_ALIASINFO q;
01057 SAMR_R_QUERY_ALIASINFO r;
01058 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01059
01060 DEBUG(10,("cli_samr_query_alias_info\n"));
01061
01062 ZERO_STRUCT(q);
01063 ZERO_STRUCT(r);
01064
01065
01066
01067 init_samr_q_query_aliasinfo(&q, alias_pol, switch_value);
01068
01069 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_ALIASINFO,
01070 q, r,
01071 qbuf, rbuf,
01072 samr_io_q_query_aliasinfo,
01073 samr_io_r_query_aliasinfo,
01074 NT_STATUS_UNSUCCESSFUL);
01075
01076
01077
01078 if (!NT_STATUS_IS_OK(result = r.status)) {
01079 goto done;
01080 }
01081
01082 *ctr = *r.ctr;
01083
01084 done:
01085
01086 return result;
01087 }
01088
01089
01090
01091 NTSTATUS rpccli_samr_query_dom_info(struct rpc_pipe_client *cli,
01092 TALLOC_CTX *mem_ctx,
01093 POLICY_HND *domain_pol,
01094 uint16 switch_value,
01095 SAM_UNK_CTR *ctr)
01096 {
01097 prs_struct qbuf, rbuf;
01098 SAMR_Q_QUERY_DOMAIN_INFO q;
01099 SAMR_R_QUERY_DOMAIN_INFO r;
01100 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01101
01102 DEBUG(10,("cli_samr_query_dom_info\n"));
01103
01104 ZERO_STRUCT(q);
01105 ZERO_STRUCT(r);
01106
01107
01108
01109 init_samr_q_query_domain_info(&q, domain_pol, switch_value);
01110
01111 r.ctr = ctr;
01112
01113 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DOMAIN_INFO,
01114 q, r,
01115 qbuf, rbuf,
01116 samr_io_q_query_domain_info,
01117 samr_io_r_query_domain_info,
01118 NT_STATUS_UNSUCCESSFUL);
01119
01120
01121
01122 if (!NT_STATUS_IS_OK(result = r.status)) {
01123 goto done;
01124 }
01125
01126 done:
01127
01128 return result;
01129 }
01130
01131
01132
01133 NTSTATUS rpccli_samr_query_dom_info2(struct rpc_pipe_client *cli,
01134 TALLOC_CTX *mem_ctx,
01135 POLICY_HND *domain_pol,
01136 uint16 switch_value,
01137 SAM_UNK_CTR *ctr)
01138 {
01139 prs_struct qbuf, rbuf;
01140 SAMR_Q_QUERY_DOMAIN_INFO2 q;
01141 SAMR_R_QUERY_DOMAIN_INFO2 r;
01142 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01143
01144 DEBUG(10,("cli_samr_query_dom_info2\n"));
01145
01146 ZERO_STRUCT(q);
01147 ZERO_STRUCT(r);
01148
01149
01150
01151 init_samr_q_query_domain_info2(&q, domain_pol, switch_value);
01152
01153 r.ctr = ctr;
01154
01155 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DOMAIN_INFO2,
01156 q, r,
01157 qbuf, rbuf,
01158 samr_io_q_query_domain_info2,
01159 samr_io_r_query_domain_info2,
01160 NT_STATUS_UNSUCCESSFUL);
01161
01162
01163
01164 if (!NT_STATUS_IS_OK(result = r.status)) {
01165 goto done;
01166 }
01167
01168 done:
01169
01170 return result;
01171 }
01172
01173
01174
01175 NTSTATUS rpccli_samr_set_domain_info(struct rpc_pipe_client *cli,
01176 TALLOC_CTX *mem_ctx,
01177 POLICY_HND *domain_pol,
01178 uint16 switch_value,
01179 SAM_UNK_CTR *ctr)
01180 {
01181 prs_struct qbuf, rbuf;
01182 SAMR_Q_SET_DOMAIN_INFO q;
01183 SAMR_R_SET_DOMAIN_INFO r;
01184 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01185
01186 DEBUG(10,("cli_samr_set_domain_info\n"));
01187
01188 ZERO_STRUCT(q);
01189 ZERO_STRUCT(r);
01190
01191
01192
01193 init_samr_q_set_domain_info(&q, domain_pol, switch_value, ctr);
01194
01195 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_DOMAIN_INFO,
01196 q, r,
01197 qbuf, rbuf,
01198 samr_io_q_set_domain_info,
01199 samr_io_r_set_domain_info,
01200 NT_STATUS_UNSUCCESSFUL);
01201
01202
01203
01204 if (!NT_STATUS_IS_OK(result = r.status)) {
01205 goto done;
01206 }
01207
01208 done:
01209
01210 return result;
01211 }
01212
01213
01214
01215 NTSTATUS rpccli_samr_chgpasswd_user(struct rpc_pipe_client *cli,
01216 TALLOC_CTX *mem_ctx,
01217 const char *username,
01218 const char *newpassword,
01219 const char *oldpassword )
01220 {
01221 prs_struct qbuf, rbuf;
01222 SAMR_Q_CHGPASSWD_USER q;
01223 SAMR_R_CHGPASSWD_USER r;
01224 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01225
01226 uchar new_nt_password[516];
01227 uchar new_lm_password[516];
01228 uchar old_nt_hash[16];
01229 uchar old_lanman_hash[16];
01230 uchar old_nt_hash_enc[16];
01231 uchar old_lanman_hash_enc[16];
01232
01233 uchar new_nt_hash[16];
01234 uchar new_lanman_hash[16];
01235
01236 char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
01237
01238 DEBUG(10,("rpccli_samr_chgpasswd_user\n"));
01239
01240 ZERO_STRUCT(q);
01241 ZERO_STRUCT(r);
01242
01243
01244 E_md4hash(oldpassword, old_nt_hash);
01245 E_md4hash(newpassword, new_nt_hash);
01246
01247 if (lp_client_lanman_auth()
01248 && E_deshash(newpassword, new_lanman_hash)
01249 && E_deshash(oldpassword, old_lanman_hash)) {
01250
01251
01252
01253
01254
01255 encode_pw_buffer(new_lm_password, newpassword, STR_UNICODE);
01256
01257 SamOEMhash( new_lm_password, old_nt_hash, 516);
01258 E_old_pw_hash( new_nt_hash, old_lanman_hash, old_lanman_hash_enc);
01259 } else {
01260 ZERO_STRUCT(new_lm_password);
01261 ZERO_STRUCT(old_lanman_hash_enc);
01262 }
01263
01264 encode_pw_buffer(new_nt_password, newpassword, STR_UNICODE);
01265
01266 SamOEMhash( new_nt_password, old_nt_hash, 516);
01267 E_old_pw_hash( new_nt_hash, old_nt_hash, old_nt_hash_enc);
01268
01269
01270
01271 init_samr_q_chgpasswd_user(&q, srv_name_slash, username,
01272 new_nt_password,
01273 old_nt_hash_enc,
01274 new_lm_password,
01275 old_lanman_hash_enc);
01276
01277 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER,
01278 q, r,
01279 qbuf, rbuf,
01280 samr_io_q_chgpasswd_user,
01281 samr_io_r_chgpasswd_user,
01282 NT_STATUS_UNSUCCESSFUL);
01283
01284
01285
01286 if (!NT_STATUS_IS_OK(result = r.status)) {
01287 goto done;
01288 }
01289
01290 done:
01291
01292 return result;
01293 }
01294
01295
01296
01297 NTSTATUS rpccli_samr_chng_pswd_auth_crap(struct rpc_pipe_client *cli,
01298 TALLOC_CTX *mem_ctx,
01299 const char *username,
01300 DATA_BLOB new_nt_password,
01301 DATA_BLOB old_nt_hash_enc,
01302 DATA_BLOB new_lm_password,
01303 DATA_BLOB old_lm_hash_enc)
01304 {
01305 prs_struct qbuf, rbuf;
01306 SAMR_Q_CHGPASSWD_USER q;
01307 SAMR_R_CHGPASSWD_USER r;
01308 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01309
01310 char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
01311
01312 DEBUG(10,("rpccli_samr_chng_pswd_auth_crap\n"));
01313
01314 ZERO_STRUCT(q);
01315 ZERO_STRUCT(r);
01316
01317
01318
01319 init_samr_q_chgpasswd_user(&q, srv_name_slash, username,
01320 new_nt_password.data,
01321 old_nt_hash_enc.data,
01322 new_lm_password.data,
01323 old_lm_hash_enc.data);
01324
01325 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER,
01326 q, r,
01327 qbuf, rbuf,
01328 samr_io_q_chgpasswd_user,
01329 samr_io_r_chgpasswd_user,
01330 NT_STATUS_UNSUCCESSFUL);
01331
01332
01333
01334 if (!NT_STATUS_IS_OK(result = r.status)) {
01335 goto done;
01336 }
01337
01338 done:
01339
01340 return result;
01341 }
01342
01343
01344
01345
01346 NTSTATUS rpccli_samr_chgpasswd3(struct rpc_pipe_client *cli,
01347 TALLOC_CTX *mem_ctx,
01348 const char *username,
01349 const char *newpassword,
01350 const char *oldpassword,
01351 SAM_UNK_INFO_1 *info,
01352 SAMR_CHANGE_REJECT *reject)
01353 {
01354 prs_struct qbuf, rbuf;
01355 SAMR_Q_CHGPASSWD_USER3 q;
01356 SAMR_R_CHGPASSWD_USER3 r;
01357
01358 uchar new_nt_password[516];
01359 uchar new_lm_password[516];
01360 uchar old_nt_hash[16];
01361 uchar old_lanman_hash[16];
01362 uchar old_nt_hash_enc[16];
01363 uchar old_lanman_hash_enc[16];
01364
01365 uchar new_nt_hash[16];
01366 uchar new_lanman_hash[16];
01367
01368 char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
01369
01370 DEBUG(10,("rpccli_samr_chgpasswd_user3\n"));
01371
01372 ZERO_STRUCT(q);
01373 ZERO_STRUCT(r);
01374
01375
01376 E_md4hash(oldpassword, old_nt_hash);
01377 E_md4hash(newpassword, new_nt_hash);
01378
01379 if (lp_client_lanman_auth()
01380 && E_deshash(newpassword, new_lanman_hash)
01381 && E_deshash(oldpassword, old_lanman_hash)) {
01382
01383
01384
01385
01386
01387 encode_pw_buffer(new_lm_password, newpassword, STR_UNICODE);
01388
01389 SamOEMhash( new_lm_password, old_nt_hash, 516);
01390 E_old_pw_hash( new_nt_hash, old_lanman_hash, old_lanman_hash_enc);
01391 } else {
01392 ZERO_STRUCT(new_lm_password);
01393 ZERO_STRUCT(old_lanman_hash_enc);
01394 }
01395
01396 encode_pw_buffer(new_nt_password, newpassword, STR_UNICODE);
01397
01398 SamOEMhash( new_nt_password, old_nt_hash, 516);
01399 E_old_pw_hash( new_nt_hash, old_nt_hash, old_nt_hash_enc);
01400
01401
01402
01403 init_samr_q_chgpasswd_user3(&q, srv_name_slash, username,
01404 new_nt_password,
01405 old_nt_hash_enc,
01406 new_lm_password,
01407 old_lanman_hash_enc);
01408 r.info = info;
01409 r.reject = reject;
01410
01411 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER3,
01412 q, r,
01413 qbuf, rbuf,
01414 samr_io_q_chgpasswd_user3,
01415 samr_io_r_chgpasswd_user3,
01416 NT_STATUS_UNSUCCESSFUL);
01417
01418
01419
01420 return r.status;
01421 }
01422
01423
01424
01425
01426
01427
01428 void get_query_dispinfo_params(int loop_count, uint32 *max_entries,
01429 uint32 *max_size)
01430 {
01431 switch(loop_count) {
01432 case 0:
01433 *max_entries = 512;
01434 *max_size = 16383;
01435 break;
01436 case 1:
01437 *max_entries = 1024;
01438 *max_size = 32766;
01439 break;
01440 case 2:
01441 *max_entries = 2048;
01442 *max_size = 65532;
01443 break;
01444 case 3:
01445 *max_entries = 4096;
01446 *max_size = 131064;
01447 break;
01448 default:
01449 *max_entries = 4096;
01450 *max_size = 131071;
01451 break;
01452 }
01453 }
01454
01455
01456
01457 NTSTATUS rpccli_samr_query_dispinfo(struct rpc_pipe_client *cli,
01458 TALLOC_CTX *mem_ctx,
01459 POLICY_HND *domain_pol, uint32 *start_idx,
01460 uint16 switch_value, uint32 *num_entries,
01461 uint32 max_entries, uint32 max_size,
01462 SAM_DISPINFO_CTR *ctr)
01463 {
01464 prs_struct qbuf, rbuf;
01465 SAMR_Q_QUERY_DISPINFO q;
01466 SAMR_R_QUERY_DISPINFO r;
01467 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01468
01469 DEBUG(10,("cli_samr_query_dispinfo for start_idx = %u\n", *start_idx));
01470
01471 ZERO_STRUCT(q);
01472 ZERO_STRUCT(r);
01473
01474 *num_entries = 0;
01475
01476
01477
01478 init_samr_q_query_dispinfo(&q, domain_pol, switch_value,
01479 *start_idx, max_entries, max_size);
01480
01481 r.ctr = ctr;
01482
01483 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DISPINFO,
01484 q, r,
01485 qbuf, rbuf,
01486 samr_io_q_query_dispinfo,
01487 samr_io_r_query_dispinfo,
01488 NT_STATUS_UNSUCCESSFUL);
01489
01490
01491
01492 result = r.status;
01493
01494 if (!NT_STATUS_IS_OK(result) &&
01495 NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
01496 goto done;
01497 }
01498
01499 *num_entries = r.num_entries;
01500 *start_idx += r.num_entries;
01501
01502 done:
01503 return result;
01504 }
01505
01506
01507
01508
01509 NTSTATUS rpccli_samr_lookup_rids(struct rpc_pipe_client *cli,
01510 TALLOC_CTX *mem_ctx,
01511 POLICY_HND *domain_pol,
01512 uint32 num_rids, uint32 *rids,
01513 uint32 *num_names, char ***names,
01514 uint32 **name_types)
01515 {
01516 prs_struct qbuf, rbuf;
01517 SAMR_Q_LOOKUP_RIDS q;
01518 SAMR_R_LOOKUP_RIDS r;
01519 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01520 uint32 i;
01521
01522 DEBUG(10,("cli_samr_lookup_rids\n"));
01523
01524 if (num_rids > 1000) {
01525 DEBUG(2, ("cli_samr_lookup_rids: warning: NT4 can crash if "
01526 "more than ~1000 rids are looked up at once.\n"));
01527 }
01528
01529 ZERO_STRUCT(q);
01530 ZERO_STRUCT(r);
01531
01532
01533
01534 init_samr_q_lookup_rids(mem_ctx, &q, domain_pol, 1000, num_rids, rids);
01535
01536 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_RIDS,
01537 q, r,
01538 qbuf, rbuf,
01539 samr_io_q_lookup_rids,
01540 samr_io_r_lookup_rids,
01541 NT_STATUS_UNSUCCESSFUL);
01542
01543
01544
01545 result = r.status;
01546
01547 if (!NT_STATUS_IS_OK(result) &&
01548 !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
01549 goto done;
01550
01551 if (r.num_names1 == 0) {
01552 *num_names = 0;
01553 *names = NULL;
01554 goto done;
01555 }
01556
01557 *num_names = r.num_names1;
01558 *names = TALLOC_ARRAY(mem_ctx, char *, r.num_names1);
01559 *name_types = TALLOC_ARRAY(mem_ctx, uint32, r.num_names1);
01560
01561 if ((*names == NULL) || (*name_types == NULL)) {
01562 TALLOC_FREE(*names);
01563 TALLOC_FREE(*name_types);
01564 return NT_STATUS_NO_MEMORY;
01565 }
01566
01567 for (i = 0; i < r.num_names1; i++) {
01568 fstring tmp;
01569
01570 unistr2_to_ascii(tmp, &r.uni_name[i], sizeof(tmp) - 1);
01571 (*names)[i] = talloc_strdup(mem_ctx, tmp);
01572 (*name_types)[i] = r.type[i];
01573 }
01574
01575 done:
01576
01577 return result;
01578 }
01579
01580
01581
01582 NTSTATUS rpccli_samr_lookup_names(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01583 POLICY_HND *domain_pol, uint32 flags,
01584 uint32 num_names, const char **names,
01585 uint32 *num_rids, uint32 **rids,
01586 uint32 **rid_types)
01587 {
01588 prs_struct qbuf, rbuf;
01589 SAMR_Q_LOOKUP_NAMES q;
01590 SAMR_R_LOOKUP_NAMES r;
01591 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01592 uint32 i;
01593
01594 DEBUG(10,("cli_samr_lookup_names\n"));
01595
01596 ZERO_STRUCT(q);
01597 ZERO_STRUCT(r);
01598
01599
01600
01601 init_samr_q_lookup_names(mem_ctx, &q, domain_pol, flags,
01602 num_names, names);
01603
01604 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_NAMES,
01605 q, r,
01606 qbuf, rbuf,
01607 samr_io_q_lookup_names,
01608 samr_io_r_lookup_names,
01609 NT_STATUS_UNSUCCESSFUL);
01610
01611
01612
01613 if (!NT_STATUS_IS_OK(result = r.status)) {
01614 goto done;
01615 }
01616
01617 if (r.num_rids1 == 0) {
01618 *num_rids = 0;
01619 goto done;
01620 }
01621
01622 *num_rids = r.num_rids1;
01623 *rids = TALLOC_ARRAY(mem_ctx, uint32, r.num_rids1);
01624 *rid_types = TALLOC_ARRAY(mem_ctx, uint32, r.num_rids1);
01625
01626 if ((*rids == NULL) || (*rid_types == NULL)) {
01627 TALLOC_FREE(*rids);
01628 TALLOC_FREE(*rid_types);
01629 return NT_STATUS_NO_MEMORY;
01630 }
01631
01632 for (i = 0; i < r.num_rids1; i++) {
01633 (*rids)[i] = r.rids[i];
01634 (*rid_types)[i] = r.types[i];
01635 }
01636
01637 done:
01638
01639 return result;
01640 }
01641
01642
01643
01644 NTSTATUS rpccli_samr_create_dom_user(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01645 POLICY_HND *domain_pol, const char *acct_name,
01646 uint32 acb_info, uint32 unknown,
01647 POLICY_HND *user_pol, uint32 *rid)
01648 {
01649 prs_struct qbuf, rbuf;
01650 SAMR_Q_CREATE_USER q;
01651 SAMR_R_CREATE_USER r;
01652 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01653
01654 DEBUG(10,("cli_samr_create_dom_user %s\n", acct_name));
01655
01656 ZERO_STRUCT(q);
01657 ZERO_STRUCT(r);
01658
01659
01660
01661 init_samr_q_create_user(&q, domain_pol, acct_name, acb_info, unknown);
01662
01663 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_USER,
01664 q, r,
01665 qbuf, rbuf,
01666 samr_io_q_create_user,
01667 samr_io_r_create_user,
01668 NT_STATUS_UNSUCCESSFUL);
01669
01670
01671
01672 if (!NT_STATUS_IS_OK(result = r.status)) {
01673 goto done;
01674 }
01675
01676 if (user_pol)
01677 *user_pol = r.user_pol;
01678
01679 if (rid)
01680 *rid = r.user_rid;
01681
01682 done:
01683
01684 return result;
01685 }
01686
01687
01688
01689 NTSTATUS rpccli_samr_set_userinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01690 const POLICY_HND *user_pol, uint16 switch_value,
01691 DATA_BLOB *sess_key, SAM_USERINFO_CTR *ctr)
01692 {
01693 prs_struct qbuf, rbuf;
01694 SAMR_Q_SET_USERINFO q;
01695 SAMR_R_SET_USERINFO r;
01696 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01697
01698 DEBUG(10,("cli_samr_set_userinfo\n"));
01699
01700 ZERO_STRUCT(q);
01701 ZERO_STRUCT(r);
01702
01703 if (!sess_key->length) {
01704 DEBUG(1, ("No user session key\n"));
01705 return NT_STATUS_NO_USER_SESSION_KEY;
01706 }
01707
01708
01709
01710 prs_init(&qbuf, RPC_MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
01711 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
01712
01713
01714
01715 q.ctr = ctr;
01716
01717 init_samr_q_set_userinfo(&q, user_pol, sess_key, switch_value,
01718 ctr->info.id);
01719
01720 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_USERINFO,
01721 q, r,
01722 qbuf, rbuf,
01723 samr_io_q_set_userinfo,
01724 samr_io_r_set_userinfo,
01725 NT_STATUS_UNSUCCESSFUL);
01726
01727
01728
01729 if (!NT_STATUS_IS_OK(result = r.status)) {
01730 goto done;
01731 }
01732
01733 done:
01734
01735 return result;
01736 }
01737
01738
01739
01740 NTSTATUS rpccli_samr_set_userinfo2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01741 const POLICY_HND *user_pol, uint16 switch_value,
01742 DATA_BLOB *sess_key, SAM_USERINFO_CTR *ctr)
01743 {
01744 prs_struct qbuf, rbuf;
01745 SAMR_Q_SET_USERINFO2 q;
01746 SAMR_R_SET_USERINFO2 r;
01747 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01748
01749 DEBUG(10,("cli_samr_set_userinfo2\n"));
01750
01751 if (!sess_key->length) {
01752 DEBUG(1, ("No user session key\n"));
01753 return NT_STATUS_NO_USER_SESSION_KEY;
01754 }
01755
01756 ZERO_STRUCT(q);
01757 ZERO_STRUCT(r);
01758
01759
01760
01761 init_samr_q_set_userinfo2(&q, user_pol, sess_key, switch_value, ctr);
01762
01763 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_USERINFO2,
01764 q, r,
01765 qbuf, rbuf,
01766 samr_io_q_set_userinfo2,
01767 samr_io_r_set_userinfo2,
01768 NT_STATUS_UNSUCCESSFUL);
01769
01770
01771
01772 if (!NT_STATUS_IS_OK(result = r.status)) {
01773 goto done;
01774 }
01775
01776 done:
01777
01778 return result;
01779 }
01780
01781
01782
01783 NTSTATUS rpccli_samr_delete_dom_group(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01784 POLICY_HND *group_pol)
01785 {
01786 prs_struct qbuf, rbuf;
01787 SAMR_Q_DELETE_DOM_GROUP q;
01788 SAMR_R_DELETE_DOM_GROUP r;
01789 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01790
01791 DEBUG(10,("cli_samr_delete_dom_group\n"));
01792
01793 ZERO_STRUCT(q);
01794 ZERO_STRUCT(r);
01795
01796
01797
01798 init_samr_q_delete_dom_group(&q, group_pol);
01799
01800 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_GROUP,
01801 q, r,
01802 qbuf, rbuf,
01803 samr_io_q_delete_dom_group,
01804 samr_io_r_delete_dom_group,
01805 NT_STATUS_UNSUCCESSFUL);
01806
01807
01808
01809 result = r.status;
01810
01811 return result;
01812 }
01813
01814
01815
01816 NTSTATUS rpccli_samr_delete_dom_alias(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01817 POLICY_HND *alias_pol)
01818 {
01819 prs_struct qbuf, rbuf;
01820 SAMR_Q_DELETE_DOM_ALIAS q;
01821 SAMR_R_DELETE_DOM_ALIAS r;
01822 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01823
01824 DEBUG(10,("cli_samr_delete_dom_alias\n"));
01825
01826 ZERO_STRUCT(q);
01827 ZERO_STRUCT(r);
01828
01829
01830
01831 init_samr_q_delete_dom_alias(&q, alias_pol);
01832
01833 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_ALIAS,
01834 q, r,
01835 qbuf, rbuf,
01836 samr_io_q_delete_dom_alias,
01837 samr_io_r_delete_dom_alias,
01838 NT_STATUS_UNSUCCESSFUL);
01839
01840
01841
01842 result = r.status;
01843
01844 return result;
01845 }
01846
01847
01848
01849 NTSTATUS rpccli_samr_delete_dom_user(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01850 POLICY_HND *user_pol)
01851 {
01852 prs_struct qbuf, rbuf;
01853 SAMR_Q_DELETE_DOM_USER q;
01854 SAMR_R_DELETE_DOM_USER r;
01855 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01856
01857 DEBUG(10,("cli_samr_delete_dom_user\n"));
01858
01859 ZERO_STRUCT(q);
01860 ZERO_STRUCT(r);
01861
01862
01863
01864 init_samr_q_delete_dom_user(&q, user_pol);
01865
01866 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_USER,
01867 q, r,
01868 qbuf, rbuf,
01869 samr_io_q_delete_dom_user,
01870 samr_io_r_delete_dom_user,
01871 NT_STATUS_UNSUCCESSFUL);
01872
01873
01874
01875 result = r.status;
01876
01877 return result;
01878 }
01879
01880
01881
01882 NTSTATUS rpccli_samr_remove_sid_foreign_domain(struct rpc_pipe_client *cli,
01883 TALLOC_CTX *mem_ctx,
01884 POLICY_HND *user_pol,
01885 DOM_SID *sid)
01886 {
01887 prs_struct qbuf, rbuf;
01888 SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN q;
01889 SAMR_R_REMOVE_SID_FOREIGN_DOMAIN r;
01890 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01891
01892 DEBUG(10,("cli_samr_remove_sid_foreign_domain\n"));
01893
01894 ZERO_STRUCT(q);
01895 ZERO_STRUCT(r);
01896
01897
01898
01899 init_samr_q_remove_sid_foreign_domain(&q, user_pol, sid);
01900
01901 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_REMOVE_SID_FOREIGN_DOMAIN,
01902 q, r,
01903 qbuf, rbuf,
01904 samr_io_q_remove_sid_foreign_domain,
01905 samr_io_r_remove_sid_foreign_domain,
01906 NT_STATUS_UNSUCCESSFUL);
01907
01908
01909
01910 result = r.status;
01911
01912 return result;
01913 }
01914
01915
01916
01917 NTSTATUS rpccli_samr_query_sec_obj(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01918 POLICY_HND *user_pol, uint32 sec_info,
01919 TALLOC_CTX *ctx, SEC_DESC_BUF **sec_desc_buf)
01920 {
01921 prs_struct qbuf, rbuf;
01922 SAMR_Q_QUERY_SEC_OBJ q;
01923 SAMR_R_QUERY_SEC_OBJ r;
01924 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01925
01926 DEBUG(10,("cli_samr_query_sec_obj\n"));
01927
01928 ZERO_STRUCT(q);
01929 ZERO_STRUCT(r);
01930
01931
01932
01933 init_samr_q_query_sec_obj(&q, user_pol, sec_info);
01934
01935 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_SEC_OBJECT,
01936 q, r,
01937 qbuf, rbuf,
01938 samr_io_q_query_sec_obj,
01939 samr_io_r_query_sec_obj,
01940 NT_STATUS_UNSUCCESSFUL);
01941
01942
01943
01944 result = r.status;
01945 *sec_desc_buf=dup_sec_desc_buf(ctx, r.buf);
01946
01947 return result;
01948 }
01949
01950
01951
01952 NTSTATUS rpccli_samr_set_sec_obj(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01953 POLICY_HND *user_pol, uint32 sec_info,
01954 SEC_DESC_BUF *sec_desc_buf)
01955 {
01956 prs_struct qbuf, rbuf;
01957 SAMR_Q_SET_SEC_OBJ q;
01958 SAMR_R_SET_SEC_OBJ r;
01959 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01960
01961 DEBUG(10,("cli_samr_set_sec_obj\n"));
01962
01963 ZERO_STRUCT(q);
01964 ZERO_STRUCT(r);
01965
01966
01967
01968 init_samr_q_set_sec_obj(&q, user_pol, sec_info, sec_desc_buf);
01969
01970 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_SEC_OBJECT,
01971 q, r,
01972 qbuf, rbuf,
01973 samr_io_q_set_sec_obj,
01974 samr_io_r_set_sec_obj,
01975 NT_STATUS_UNSUCCESSFUL);
01976
01977
01978
01979 result = r.status;
01980
01981 return result;
01982 }
01983
01984
01985
01986
01987 NTSTATUS rpccli_samr_get_dom_pwinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
01988 uint16 *min_pwd_length, uint32 *password_properties)
01989 {
01990 prs_struct qbuf, rbuf;
01991 SAMR_Q_GET_DOM_PWINFO q;
01992 SAMR_R_GET_DOM_PWINFO r;
01993 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
01994
01995 DEBUG(10,("cli_samr_get_dom_pwinfo\n"));
01996
01997 ZERO_STRUCT(q);
01998 ZERO_STRUCT(r);
01999
02000
02001
02002 init_samr_q_get_dom_pwinfo(&q, cli->cli->desthost);
02003
02004 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_DOM_PWINFO,
02005 q, r,
02006 qbuf, rbuf,
02007 samr_io_q_get_dom_pwinfo,
02008 samr_io_r_get_dom_pwinfo,
02009 NT_STATUS_UNSUCCESSFUL);
02010
02011
02012
02013 result = r.status;
02014
02015 if (NT_STATUS_IS_OK(result)) {
02016 if (min_pwd_length)
02017 *min_pwd_length = r.min_pwd_length;
02018 if (password_properties)
02019 *password_properties = r.password_properties;
02020 }
02021
02022 return result;
02023 }
02024
02025
02026
02027 NTSTATUS rpccli_samr_get_usrdom_pwinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
02028 POLICY_HND *pol, uint16 *min_pwd_length,
02029 uint32 *password_properties, uint32 *unknown1)
02030 {
02031 prs_struct qbuf, rbuf;
02032 SAMR_Q_GET_USRDOM_PWINFO q;
02033 SAMR_R_GET_USRDOM_PWINFO r;
02034 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
02035
02036 DEBUG(10,("cli_samr_get_usrdom_pwinfo\n"));
02037
02038 ZERO_STRUCT(q);
02039 ZERO_STRUCT(r);
02040
02041
02042
02043 init_samr_q_get_usrdom_pwinfo(&q, pol);
02044
02045 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_USRDOM_PWINFO,
02046 q, r,
02047 qbuf, rbuf,
02048 samr_io_q_get_usrdom_pwinfo,
02049 samr_io_r_get_usrdom_pwinfo,
02050 NT_STATUS_UNSUCCESSFUL);
02051
02052
02053
02054 result = r.status;
02055
02056 if (NT_STATUS_IS_OK(result)) {
02057 if (min_pwd_length)
02058 *min_pwd_length = r.min_pwd_length;
02059 if (password_properties)
02060 *password_properties = r.password_properties;
02061 if (unknown1)
02062 *unknown1 = r.unknown_1;
02063 }
02064
02065 return result;
02066 }
02067
02068
02069
02070
02071 NTSTATUS rpccli_samr_lookup_domain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
02072 POLICY_HND *user_pol, char *domain_name,
02073 DOM_SID *sid)
02074 {
02075 prs_struct qbuf, rbuf;
02076 SAMR_Q_LOOKUP_DOMAIN q;
02077 SAMR_R_LOOKUP_DOMAIN r;
02078 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
02079
02080 DEBUG(10,("cli_samr_lookup_domain\n"));
02081
02082 ZERO_STRUCT(q);
02083 ZERO_STRUCT(r);
02084
02085
02086
02087 init_samr_q_lookup_domain(&q, user_pol, domain_name);
02088
02089 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_DOMAIN,
02090 q, r,
02091 qbuf, rbuf,
02092 samr_io_q_lookup_domain,
02093 samr_io_r_lookup_domain,
02094 NT_STATUS_UNSUCCESSFUL);
02095
02096
02097
02098 result = r.status;
02099
02100 if (NT_STATUS_IS_OK(result))
02101 sid_copy(sid, &r.dom_sid.sid);
02102
02103 return result;
02104 }