?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r15152: Fix a case when target is offline. Jerry, this needs to be in 3.0.23pre1
[Samba.git] / source / rpc_client / cli_samr.c
blob07b876cc22c4bc6a50c0b66e2c9adbf755703134
1 /*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4 Copyright (C) Tim Potter 2000-2001,
5 Copyright (C) Andrew Tridgell 1992-1997,2000,
6 Copyright (C) Rafal Szczesniak 2002.
7 Copyright (C) Jeremy Allison 2005.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25
26 /* Connect to SAMR database */
27
28 NTSTATUS rpccli_samr_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
29 uint32 access_mask, POLICY_HND *connect_pol)
30 {
31 prs_struct qbuf, rbuf;
32 SAMR_Q_CONNECT q;
33 SAMR_R_CONNECT r;
34 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
35
36 DEBUG(10,("cli_samr_connect to %s\n", cli->cli->desthost));
37
38 ZERO_STRUCT(q);
39 ZERO_STRUCT(r);
40
41 /* Marshall data and send request */
42
43 init_samr_q_connect(&q, cli->cli->desthost, access_mask);
44
45 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CONNECT,
46 q, r,
47 qbuf, rbuf,
48 samr_io_q_connect,
49 samr_io_r_connect,
50 NT_STATUS_UNSUCCESSFUL);
51 /* Return output parameters */
52
53 if (NT_STATUS_IS_OK(result = r.status)) {
54 *connect_pol = r.connect_pol;
55 #ifdef __INSURE__
56 connect_pol->marker = malloc(1);
57 #endif
58 }
59
60 return result;
61 }
62
63 /* Connect to SAMR database */
64
65 NTSTATUS rpccli_samr_connect4(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
66 uint32 access_mask, POLICY_HND *connect_pol)
67 {
68 prs_struct qbuf, rbuf;
69 SAMR_Q_CONNECT4 q;
70 SAMR_R_CONNECT4 r;
71 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
72
73 ZERO_STRUCT(q);
74 ZERO_STRUCT(r);
75
76 /* Marshall data and send request */
77
78 init_samr_q_connect4(&q, cli->cli->desthost, access_mask);
79
80 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CONNECT4,
81 q, r,
82 qbuf, rbuf,
83 samr_io_q_connect4,
84 samr_io_r_connect4,
85 NT_STATUS_UNSUCCESSFUL);
86
87 /* Return output parameters */
88
89 if (NT_STATUS_IS_OK(result = r.status)) {
90 *connect_pol = r.connect_pol;
91 #ifdef __INSURE__
92 connect_pol->marker = malloc(1);
93 #endif
94 }
95
96 return result;
97 }
98
99 /* Close SAMR handle */
100
101 NTSTATUS rpccli_samr_close(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
102 POLICY_HND *connect_pol)
103 {
104 prs_struct qbuf, rbuf;
105 SAMR_Q_CLOSE_HND q;
106 SAMR_R_CLOSE_HND r;
107 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
108
109 DEBUG(10,("cli_samr_close\n"));
110
111 ZERO_STRUCT(q);
112 ZERO_STRUCT(r);
113
114 /* Marshall data and send request */
115
116 init_samr_q_close_hnd(&q, connect_pol);
117
118 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CLOSE_HND,
119 q, r,
120 qbuf, rbuf,
121 samr_io_q_close_hnd,
122 samr_io_r_close_hnd,
123 NT_STATUS_UNSUCCESSFUL);
124
125 /* Return output parameters */
126
127 if (NT_STATUS_IS_OK(result = r.status)) {
128 #ifdef __INSURE__
129 SAFE_FREE(connect_pol->marker);
130 #endif
131 *connect_pol = r.pol;
132 }
133
134 return result;
135 }
136
137 /* Open handle on a domain */
138
139 NTSTATUS rpccli_samr_open_domain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
140 POLICY_HND *connect_pol, uint32 access_mask,
141 const DOM_SID *domain_sid,
142 POLICY_HND *domain_pol)
143 {
144 prs_struct qbuf, rbuf;
145 SAMR_Q_OPEN_DOMAIN q;
146 SAMR_R_OPEN_DOMAIN r;
147 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
148
149 DEBUG(10,("cli_samr_open_domain with sid %s\n", sid_string_static(domain_sid) ));
150
151 ZERO_STRUCT(q);
152 ZERO_STRUCT(r);
153
154 /* Marshall data and send request */
155
156 init_samr_q_open_domain(&q, connect_pol, access_mask, domain_sid);
157
158 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_DOMAIN,
159 q, r,
160 qbuf, rbuf,
161 samr_io_q_open_domain,
162 samr_io_r_open_domain,
163 NT_STATUS_UNSUCCESSFUL);
164
165 /* Return output parameters */
166
167 if (NT_STATUS_IS_OK(result = r.status)) {
168 *domain_pol = r.domain_pol;
169 #ifdef __INSURE__
170 domain_pol->marker = malloc(1);
171 #endif
172 }
173
174 return result;
175 }
176
177 NTSTATUS rpccli_samr_open_user(struct rpc_pipe_client *cli,
178 TALLOC_CTX *mem_ctx,
179 POLICY_HND *domain_pol, uint32 access_mask,
180 uint32 user_rid, POLICY_HND *user_pol)
181 {
182 prs_struct qbuf, rbuf;
183 SAMR_Q_OPEN_USER q;
184 SAMR_R_OPEN_USER r;
185 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
186
187 DEBUG(10,("cli_samr_open_user with rid 0x%x\n", user_rid ));
188
189 ZERO_STRUCT(q);
190 ZERO_STRUCT(r);
191
192 /* Marshall data and send request */
193
194 init_samr_q_open_user(&q, domain_pol, access_mask, user_rid);
195
196 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_USER,
197 q, r,
198 qbuf, rbuf,
199 samr_io_q_open_user,
200 samr_io_r_open_user,
201 NT_STATUS_UNSUCCESSFUL);
202
203 /* Return output parameters */
204
205 if (NT_STATUS_IS_OK(result = r.status)) {
206 *user_pol = r.user_pol;
207 #ifdef __INSURE__
208 user_pol->marker = malloc(1);
209 #endif
210 }
211
212 return result;
213 }
214
215 /* Open handle on a group */
216
217 NTSTATUS rpccli_samr_open_group(struct rpc_pipe_client *cli,
218 TALLOC_CTX *mem_ctx,
219 POLICY_HND *domain_pol, uint32 access_mask,
220 uint32 group_rid, POLICY_HND *group_pol)
221 {
222 prs_struct qbuf, rbuf;
223 SAMR_Q_OPEN_GROUP q;
224 SAMR_R_OPEN_GROUP r;
225 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
226
227 DEBUG(10,("cli_samr_open_group with rid 0x%x\n", group_rid ));
228
229 ZERO_STRUCT(q);
230 ZERO_STRUCT(r);
231
232 /* Marshall data and send request */
233
234 init_samr_q_open_group(&q, domain_pol, access_mask, group_rid);
235
236 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_GROUP,
237 q, r,
238 qbuf, rbuf,
239 samr_io_q_open_group,
240 samr_io_r_open_group,
241 NT_STATUS_UNSUCCESSFUL);
242
243 /* Return output parameters */
244
245 if (NT_STATUS_IS_OK(result = r.status)) {
246 *group_pol = r.pol;
247 #ifdef __INSURE__
248 group_pol->marker = malloc(1);
249 #endif
250 }
251
252 return result;
253 }
254
255 /* Create domain group */
256
257 NTSTATUS rpccli_samr_create_dom_group(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
258 POLICY_HND *domain_pol,
259 const char *group_name,
260 uint32 access_mask, POLICY_HND *group_pol)
261 {
262 prs_struct qbuf, rbuf;
263 SAMR_Q_CREATE_DOM_GROUP q;
264 SAMR_R_CREATE_DOM_GROUP r;
265 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
266
267 DEBUG(10,("cli_samr_create_dom_group\n"));
268
269 ZERO_STRUCT(q);
270 ZERO_STRUCT(r);
271
272 /* Marshall data and send request */
273
274 init_samr_q_create_dom_group(&q, domain_pol, group_name, access_mask);
275
276 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_DOM_GROUP,
277 q, r,
278 qbuf, rbuf,
279 samr_io_q_create_dom_group,
280 samr_io_r_create_dom_group,
281 NT_STATUS_UNSUCCESSFUL);
282
283 /* Return output parameters */
284
285 result = r.status;
286
287 if (NT_STATUS_IS_OK(result))
288 *group_pol = r.pol;
289
290 return result;
291 }
292
293 /* Add a domain group member */
294
295 NTSTATUS rpccli_samr_add_groupmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
296 POLICY_HND *group_pol, uint32 rid)
297 {
298 prs_struct qbuf, rbuf;
299 SAMR_Q_ADD_GROUPMEM q;
300 SAMR_R_ADD_GROUPMEM r;
301 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
302
303 DEBUG(10,("cli_samr_add_groupmem\n"));
304
305 ZERO_STRUCT(q);
306 ZERO_STRUCT(r);
307
308 /* Marshall data and send request */
309
310 init_samr_q_add_groupmem(&q, group_pol, rid);
311
312 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ADD_GROUPMEM,
313 q, r,
314 qbuf, rbuf,
315 samr_io_q_add_groupmem,
316 samr_io_r_add_groupmem,
317 NT_STATUS_UNSUCCESSFUL);
318
319 /* Return output parameters */
320
321 result = r.status;
322
323 return result;
324 }
325
326 /* Delete a domain group member */
327
328 NTSTATUS rpccli_samr_del_groupmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
329 POLICY_HND *group_pol, uint32 rid)
330 {
331 prs_struct qbuf, rbuf;
332 SAMR_Q_DEL_GROUPMEM q;
333 SAMR_R_DEL_GROUPMEM r;
334 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
335
336 DEBUG(10,("cli_samr_del_groupmem\n"));
337
338 ZERO_STRUCT(q);
339 ZERO_STRUCT(r);
340
341 /* Marshall data and send request */
342
343 init_samr_q_del_groupmem(&q, group_pol, rid);
344
345 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DEL_GROUPMEM,
346 q, r,
347 qbuf, rbuf,
348 samr_io_q_del_groupmem,
349 samr_io_r_del_groupmem,
350 NT_STATUS_UNSUCCESSFUL);
351
352 /* Return output parameters */
353
354 result = r.status;
355
356 return result;
357 }
358
359 /* Query user info */
360
361 NTSTATUS rpccli_samr_query_userinfo(struct rpc_pipe_client *cli,
362 TALLOC_CTX *mem_ctx,
363 const POLICY_HND *user_pol,
364 uint16 switch_value,
365 SAM_USERINFO_CTR **ctr)
366 {
367 prs_struct qbuf, rbuf;
368 SAMR_Q_QUERY_USERINFO q;
369 SAMR_R_QUERY_USERINFO r;
370 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
371
372 DEBUG(10,("cli_samr_query_userinfo\n"));
373
374 ZERO_STRUCT(q);
375 ZERO_STRUCT(r);
376
377 /* Marshall data and send request */
378
379 init_samr_q_query_userinfo(&q, user_pol, switch_value);
380
381 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERINFO,
382 q, r,
383 qbuf, rbuf,
384 samr_io_q_query_userinfo,
385 samr_io_r_query_userinfo,
386 NT_STATUS_UNSUCCESSFUL);
387
388 /* Return output parameters */
389
390 result = r.status;
391 *ctr = r.ctr;
392
393 return result;
394 }
395
396 /* Set group info */
397
398 NTSTATUS rpccli_samr_set_groupinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
399 POLICY_HND *group_pol, GROUP_INFO_CTR *ctr)
400 {
401 prs_struct qbuf, rbuf;
402 SAMR_Q_SET_GROUPINFO q;
403 SAMR_R_SET_GROUPINFO r;
404 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
405
406 DEBUG(10,("cli_samr_set_groupinfo\n"));
407
408 ZERO_STRUCT(q);
409 ZERO_STRUCT(r);
410
411 /* Marshall data and send request */
412
413 init_samr_q_set_groupinfo(&q, group_pol, ctr);
414
415 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_GROUPINFO,
416 q, r,
417 qbuf, rbuf,
418 samr_io_q_set_groupinfo,
419 samr_io_r_set_groupinfo,
420 NT_STATUS_UNSUCCESSFUL);
421
422 /* Return output parameters */
423
424 result = r.status;
425
426 return result;
427 }
428
429 /* Query group info */
430
431 NTSTATUS rpccli_samr_query_groupinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
432 POLICY_HND *group_pol, uint32 info_level,
433 GROUP_INFO_CTR **ctr)
434 {
435 prs_struct qbuf, rbuf;
436 SAMR_Q_QUERY_GROUPINFO q;
437 SAMR_R_QUERY_GROUPINFO r;
438 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
439
440 DEBUG(10,("cli_samr_query_groupinfo\n"));
441
442 ZERO_STRUCT(q);
443 ZERO_STRUCT(r);
444
445 /* Marshall data and send request */
446
447 init_samr_q_query_groupinfo(&q, group_pol, info_level);
448
449 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_GROUPINFO,
450 q, r,
451 qbuf, rbuf,
452 samr_io_q_query_groupinfo,
453 samr_io_r_query_groupinfo,
454 NT_STATUS_UNSUCCESSFUL);
455
456 *ctr = r.ctr;
457
458 /* Return output parameters */
459
460 result = r.status;
461
462 return result;
463 }
464
465 /* Query user groups */
466
467 NTSTATUS rpccli_samr_query_usergroups(struct rpc_pipe_client *cli,
468 TALLOC_CTX *mem_ctx,
469 POLICY_HND *user_pol,
470 uint32 *num_groups,
471 DOM_GID **gid)
472 {
473 prs_struct qbuf, rbuf;
474 SAMR_Q_QUERY_USERGROUPS q;
475 SAMR_R_QUERY_USERGROUPS r;
476 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
477
478 DEBUG(10,("cli_samr_query_usergroups\n"));
479
480 ZERO_STRUCT(q);
481 ZERO_STRUCT(r);
482
483 /* Marshall data and send request */
484
485 init_samr_q_query_usergroups(&q, user_pol);
486
487 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERGROUPS,
488 q, r,
489 qbuf, rbuf,
490 samr_io_q_query_usergroups,
491 samr_io_r_query_usergroups,
492 NT_STATUS_UNSUCCESSFUL);
493
494 /* Return output parameters */
495
496 if (NT_STATUS_IS_OK(result = r.status)) {
497 *num_groups = r.num_entries;
498 *gid = r.gid;
499 }
500
501 return result;
502 }
503
504 /* Set alias info */
505
506 NTSTATUS rpccli_samr_set_aliasinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
507 POLICY_HND *alias_pol, ALIAS_INFO_CTR *ctr)
508 {
509 prs_struct qbuf, rbuf;
510 SAMR_Q_SET_ALIASINFO q;
511 SAMR_R_SET_ALIASINFO r;
512 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
513
514 DEBUG(10,("cli_samr_set_aliasinfo\n"));
515
516 ZERO_STRUCT(q);
517 ZERO_STRUCT(r);
518
519 /* Marshall data and send request */
520
521 init_samr_q_set_aliasinfo(&q, alias_pol, ctr);
522
523 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_ALIASINFO,
524 q, r,
525 qbuf, rbuf,
526 samr_io_q_set_aliasinfo,
527 samr_io_r_set_aliasinfo,
528 NT_STATUS_UNSUCCESSFUL);
529
530 /* Return output parameters */
531
532 result = r.status;
533
534 return result;
535 }
536
537 /* Query user aliases */
538
539 NTSTATUS rpccli_samr_query_useraliases(struct rpc_pipe_client *cli,
540 TALLOC_CTX *mem_ctx,
541 POLICY_HND *dom_pol, uint32 num_sids,
542 DOM_SID2 *sid,
543 uint32 *num_aliases, uint32 **als_rids)
544 {
545 prs_struct qbuf, rbuf;
546 SAMR_Q_QUERY_USERALIASES q;
547 SAMR_R_QUERY_USERALIASES r;
548 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
549 int i;
550 uint32 *sid_ptrs;
551
552 DEBUG(10,("cli_samr_query_useraliases\n"));
553
554 ZERO_STRUCT(q);
555 ZERO_STRUCT(r);
556
557 sid_ptrs = TALLOC_ARRAY(mem_ctx, uint32, num_sids);
558 if (sid_ptrs == NULL)
559 return NT_STATUS_NO_MEMORY;
560
561 for (i=0; i<num_sids; i++)
562 sid_ptrs[i] = 1;
563
564 /* Marshall data and send request */
565
566 init_samr_q_query_useraliases(&q, dom_pol, num_sids, sid_ptrs, sid);
567
568 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_USERALIASES,
569 q, r,
570 qbuf, rbuf,
571 samr_io_q_query_useraliases,
572 samr_io_r_query_useraliases,
573 NT_STATUS_UNSUCCESSFUL);
574
575 /* Return output parameters */
576
577 if (NT_STATUS_IS_OK(result = r.status)) {
578 *num_aliases = r.num_entries;
579 *als_rids = r.rid;
580 }
581
582 return result;
583 }
584
585 /* Query user groups */
586
587 NTSTATUS rpccli_samr_query_groupmem(struct rpc_pipe_client *cli,
588 TALLOC_CTX *mem_ctx,
589 POLICY_HND *group_pol, uint32 *num_mem,
590 uint32 **rid, uint32 **attr)
591 {
592 prs_struct qbuf, rbuf;
593 SAMR_Q_QUERY_GROUPMEM q;
594 SAMR_R_QUERY_GROUPMEM r;
595 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
596
597 DEBUG(10,("cli_samr_query_groupmem\n"));
598
599 ZERO_STRUCT(q);
600 ZERO_STRUCT(r);
601
602 /* Marshall data and send request */
603
604 init_samr_q_query_groupmem(&q, group_pol);
605
606 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_GROUPMEM,
607 q, r,
608 qbuf, rbuf,
609 samr_io_q_query_groupmem,
610 samr_io_r_query_groupmem,
611 NT_STATUS_UNSUCCESSFUL);
612
613 /* Return output parameters */
614
615 if (NT_STATUS_IS_OK(result = r.status)) {
616 *num_mem = r.num_entries;
617 *rid = r.rid;
618 *attr = r.attr;
619 }
620
621 return result;
622 }
623
624 /**
625 * Enumerate domain users
626 *
627 * @param cli client state structure
628 * @param mem_ctx talloc context
629 * @param pol opened domain policy handle
630 * @param start_idx starting index of enumeration, returns context for
631 next enumeration
632 * @param acb_mask account control bit mask (to enumerate some particular
633 * kind of accounts)
634 * @param size max acceptable size of response
635 * @param dom_users returned array of domain user names
636 * @param rids returned array of domain user RIDs
637 * @param num_dom_users numer returned entries
638 *
639 * @return NTSTATUS returned in rpc response
640 **/
641
642 NTSTATUS rpccli_samr_enum_dom_users(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
643 POLICY_HND *pol, uint32 *start_idx, uint32 acb_mask,
644 uint32 size, char ***dom_users, uint32 **rids,
645 uint32 *num_dom_users)
646 {
647 prs_struct qbuf;
648 prs_struct rbuf;
649 SAMR_Q_ENUM_DOM_USERS q;
650 SAMR_R_ENUM_DOM_USERS r;
651 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
652 int i;
653
654 DEBUG(10,("cli_samr_enum_dom_users starting at index %u\n", (unsigned int)*start_idx));
655
656 ZERO_STRUCT(q);
657 ZERO_STRUCT(r);
658
659 /* always init this */
660 *num_dom_users = 0;
661
662 /* Fill query structure with parameters */
663
664 init_samr_q_enum_dom_users(&q, pol, *start_idx, acb_mask, size);
665
666 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_USERS,
667 q, r,
668 qbuf, rbuf,
669 samr_io_q_enum_dom_users,
670 samr_io_r_enum_dom_users,
671 NT_STATUS_UNSUCCESSFUL);
672
673 result = r.status;
674
675 if (!NT_STATUS_IS_OK(result) &&
676 NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES))
677 goto done;
678
679 *start_idx = r.next_idx;
680 *num_dom_users = r.num_entries2;
681
682 if (r.num_entries2) {
683 /* allocate memory needed to return received data */
684 *rids = TALLOC_ARRAY(mem_ctx, uint32, r.num_entries2);
685 if (!*rids) {
686 DEBUG(0, ("Error in cli_samr_enum_dom_users(): out of memory\n"));
687 return NT_STATUS_NO_MEMORY;
688 }
689
690 *dom_users = TALLOC_ARRAY(mem_ctx, char*, r.num_entries2);
691 if (!*dom_users) {
692 DEBUG(0, ("Error in cli_samr_enum_dom_users(): out of memory\n"));
693 return NT_STATUS_NO_MEMORY;
694 }
695
696 /* fill output buffers with rpc response */
697 for (i = 0; i < r.num_entries2; i++) {
698 fstring conv_buf;
699
700 (*rids)[i] = r.sam[i].rid;
701 unistr2_to_ascii(conv_buf, &(r.uni_acct_name[i]), sizeof(conv_buf) - 1);
702 (*dom_users)[i] = talloc_strdup(mem_ctx, conv_buf);
703 }
704 }
705
706 done:
707 return result;
708 }
709
710 /* Enumerate domain groups */
711
712 NTSTATUS rpccli_samr_enum_dom_groups(struct rpc_pipe_client *cli,
713 TALLOC_CTX *mem_ctx,
714 POLICY_HND *pol, uint32 *start_idx,
715 uint32 size, struct acct_info **dom_groups,
716 uint32 *num_dom_groups)
717 {
718 prs_struct qbuf, rbuf;
719 SAMR_Q_ENUM_DOM_GROUPS q;
720 SAMR_R_ENUM_DOM_GROUPS r;
721 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
722 uint32 name_idx, i;
723
724 DEBUG(10,("cli_samr_enum_dom_groups starting at index %u\n", (unsigned int)*start_idx));
725
726 ZERO_STRUCT(q);
727 ZERO_STRUCT(r);
728
729 /* Marshall data and send request */
730
731 init_samr_q_enum_dom_groups(&q, pol, *start_idx, size);
732
733 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_GROUPS,
734 q, r,
735 qbuf, rbuf,
736 samr_io_q_enum_dom_groups,
737 samr_io_r_enum_dom_groups,
738 NT_STATUS_UNSUCCESSFUL);
739
740 /* Return output parameters */
741
742 result = r.status;
743
744 if (!NT_STATUS_IS_OK(result) &&
745 NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES))
746 goto done;
747
748 *num_dom_groups = r.num_entries2;
749
750 if (*num_dom_groups == 0)
751 goto done;
752
753 if (!((*dom_groups) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_dom_groups))) {
754 result = NT_STATUS_NO_MEMORY;
755 goto done;
756 }
757
758 memset(*dom_groups, 0, sizeof(struct acct_info) * (*num_dom_groups));
759
760 name_idx = 0;
761
762 for (i = 0; i < *num_dom_groups; i++) {
763
764 (*dom_groups)[i].rid = r.sam[i].rid;
765
766 if (r.sam[i].hdr_name.buffer) {
767 unistr2_to_ascii((*dom_groups)[i].acct_name,
768 &r.uni_grp_name[name_idx],
769 sizeof(fstring) - 1);
770 name_idx++;
771 }
772
773 *start_idx = r.next_idx;
774 }
775
776 done:
777 return result;
778 }
779
780 /* Enumerate domain groups */
781
782 NTSTATUS rpccli_samr_enum_als_groups(struct rpc_pipe_client *cli,
783 TALLOC_CTX *mem_ctx,
784 POLICY_HND *pol, uint32 *start_idx,
785 uint32 size, struct acct_info **dom_aliases,
786 uint32 *num_dom_aliases)
787 {
788 prs_struct qbuf, rbuf;
789 SAMR_Q_ENUM_DOM_ALIASES q;
790 SAMR_R_ENUM_DOM_ALIASES r;
791 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
792 uint32 name_idx, i;
793
794 DEBUG(10,("cli_samr_enum_als_groups starting at index %u\n", (unsigned int)*start_idx));
795
796 ZERO_STRUCT(q);
797 ZERO_STRUCT(r);
798
799 /* Marshall data and send request */
800
801 init_samr_q_enum_dom_aliases(&q, pol, *start_idx, size);
802
803 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ENUM_DOM_ALIASES,
804 q, r,
805 qbuf, rbuf,
806 samr_io_q_enum_dom_aliases,
807 samr_io_r_enum_dom_aliases,
808 NT_STATUS_UNSUCCESSFUL);
809
810 /* Return output parameters */
811
812 result = r.status;
813
814 if (!NT_STATUS_IS_OK(result) &&
815 NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
816 goto done;
817 }
818
819 *num_dom_aliases = r.num_entries2;
820
821 if (*num_dom_aliases == 0)
822 goto done;
823
824 if (!((*dom_aliases) = TALLOC_ARRAY(mem_ctx, struct acct_info, *num_dom_aliases))) {
825 result = NT_STATUS_NO_MEMORY;
826 goto done;
827 }
828
829 memset(*dom_aliases, 0, sizeof(struct acct_info) * *num_dom_aliases);
830
831 name_idx = 0;
832
833 for (i = 0; i < *num_dom_aliases; i++) {
834
835 (*dom_aliases)[i].rid = r.sam[i].rid;
836
837 if (r.sam[i].hdr_name.buffer) {
838 unistr2_to_ascii((*dom_aliases)[i].acct_name,
839 &r.uni_grp_name[name_idx],
840 sizeof(fstring) - 1);
841 name_idx++;
842 }
843
844 *start_idx = r.next_idx;
845 }
846
847 done:
848 return result;
849 }
850
851 /* Query alias members */
852
853 NTSTATUS rpccli_samr_query_aliasmem(struct rpc_pipe_client *cli,
854 TALLOC_CTX *mem_ctx,
855 POLICY_HND *alias_pol, uint32 *num_mem,
856 DOM_SID **sids)
857 {
858 prs_struct qbuf, rbuf;
859 SAMR_Q_QUERY_ALIASMEM q;
860 SAMR_R_QUERY_ALIASMEM r;
861 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
862 uint32 i;
863
864 DEBUG(10,("cli_samr_query_aliasmem\n"));
865
866 ZERO_STRUCT(q);
867 ZERO_STRUCT(r);
868
869 /* Marshall data and send request */
870
871 init_samr_q_query_aliasmem(&q, alias_pol);
872
873 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_ALIASMEM,
874 q, r,
875 qbuf, rbuf,
876 samr_io_q_query_aliasmem,
877 samr_io_r_query_aliasmem,
878 NT_STATUS_UNSUCCESSFUL);
879
880 /* Return output parameters */
881
882 if (!NT_STATUS_IS_OK(result = r.status)) {
883 goto done;
884 }
885
886 *num_mem = r.num_sids;
887
888 if (*num_mem == 0) {
889 *sids = NULL;
890 result = NT_STATUS_OK;
891 goto done;
892 }
893
894 if (!(*sids = TALLOC_ARRAY(mem_ctx, DOM_SID, *num_mem))) {
895 result = NT_STATUS_UNSUCCESSFUL;
896 goto done;
897 }
898
899 for (i = 0; i < *num_mem; i++) {
900 (*sids)[i] = r.sid[i].sid;
901 }
902
903 done:
904 return result;
905 }
906
907 /* Open handle on an alias */
908
909 NTSTATUS rpccli_samr_open_alias(struct rpc_pipe_client *cli,
910 TALLOC_CTX *mem_ctx,
911 POLICY_HND *domain_pol, uint32 access_mask,
912 uint32 alias_rid, POLICY_HND *alias_pol)
913 {
914 prs_struct qbuf, rbuf;
915 SAMR_Q_OPEN_ALIAS q;
916 SAMR_R_OPEN_ALIAS r;
917 NTSTATUS result;
918
919 DEBUG(10,("cli_samr_open_alias with rid 0x%x\n", alias_rid));
920
921 ZERO_STRUCT(q);
922 ZERO_STRUCT(r);
923
924 /* Marshall data and send request */
925
926 init_samr_q_open_alias(&q, domain_pol, access_mask, alias_rid);
927
928 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_OPEN_ALIAS,
929 q, r,
930 qbuf, rbuf,
931 samr_io_q_open_alias,
932 samr_io_r_open_alias,
933 NT_STATUS_UNSUCCESSFUL);
934
935 /* Return output parameters */
936
937 if (NT_STATUS_IS_OK(result = r.status)) {
938 *alias_pol = r.pol;
939 #ifdef __INSURE__
940 alias_pol->marker = malloc(1);
941 #endif
942 }
943
944 return result;
945 }
946
947 /* Create an alias */
948
949 NTSTATUS rpccli_samr_create_dom_alias(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
950 POLICY_HND *domain_pol, const char *name,
951 POLICY_HND *alias_pol)
952 {
953 prs_struct qbuf, rbuf;
954 SAMR_Q_CREATE_DOM_ALIAS q;
955 SAMR_R_CREATE_DOM_ALIAS r;
956 NTSTATUS result;
957
958 DEBUG(10,("cli_samr_create_dom_alias named %s\n", name));
959
960 ZERO_STRUCT(q);
961 ZERO_STRUCT(r);
962
963 /* Marshall data and send request */
964
965 init_samr_q_create_dom_alias(&q, domain_pol, name);
966
967 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_DOM_ALIAS,
968 q, r,
969 qbuf, rbuf,
970 samr_io_q_create_dom_alias,
971 samr_io_r_create_dom_alias,
972 NT_STATUS_UNSUCCESSFUL);
973
974 /* Return output parameters */
975
976 if (NT_STATUS_IS_OK(result = r.status)) {
977 *alias_pol = r.alias_pol;
978 }
979
980 return result;
981 }
982
983 /* Add an alias member */
984
985 NTSTATUS rpccli_samr_add_aliasmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
986 POLICY_HND *alias_pol, DOM_SID *member)
987 {
988 prs_struct qbuf, rbuf;
989 SAMR_Q_ADD_ALIASMEM q;
990 SAMR_R_ADD_ALIASMEM r;
991 NTSTATUS result;
992
993 DEBUG(10,("cli_samr_add_aliasmem"));
994
995 ZERO_STRUCT(q);
996 ZERO_STRUCT(r);
997
998 /* Marshall data and send request */
999
1000 init_samr_q_add_aliasmem(&q, alias_pol, member);
1001
1002 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_ADD_ALIASMEM,
1003 q, r,
1004 qbuf, rbuf,
1005 samr_io_q_add_aliasmem,
1006 samr_io_r_add_aliasmem,
1007 NT_STATUS_UNSUCCESSFUL);
1008
1009 result = r.status;
1010
1011 return result;
1012 }
1013
1014 /* Delete an alias member */
1015
1016 NTSTATUS rpccli_samr_del_aliasmem(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1017 POLICY_HND *alias_pol, DOM_SID *member)
1018 {
1019 prs_struct qbuf, rbuf;
1020 SAMR_Q_DEL_ALIASMEM q;
1021 SAMR_R_DEL_ALIASMEM r;
1022 NTSTATUS result;
1023
1024 DEBUG(10,("cli_samr_del_aliasmem"));
1025
1026 ZERO_STRUCT(q);
1027 ZERO_STRUCT(r);
1028
1029 /* Marshall data and send request */
1030
1031 init_samr_q_del_aliasmem(&q, alias_pol, member);
1032
1033 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DEL_ALIASMEM,
1034 q, r,
1035 qbuf, rbuf,
1036 samr_io_q_del_aliasmem,
1037 samr_io_r_del_aliasmem,
1038 NT_STATUS_UNSUCCESSFUL);
1039
1040 result = r.status;
1041
1042 return result;
1043 }
1044
1045 /* Query alias info */
1046
1047 NTSTATUS rpccli_samr_query_alias_info(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1048 POLICY_HND *alias_pol, uint16 switch_value,
1049 ALIAS_INFO_CTR *ctr)
1050 {
1051 prs_struct qbuf, rbuf;
1052 SAMR_Q_QUERY_ALIASINFO q;
1053 SAMR_R_QUERY_ALIASINFO r;
1054 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1055
1056 DEBUG(10,("cli_samr_query_alias_info\n"));
1057
1058 ZERO_STRUCT(q);
1059 ZERO_STRUCT(r);
1060
1061 /* Marshall data and send request */
1062
1063 init_samr_q_query_aliasinfo(&q, alias_pol, switch_value);
1064
1065 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_ALIASINFO,
1066 q, r,
1067 qbuf, rbuf,
1068 samr_io_q_query_aliasinfo,
1069 samr_io_r_query_aliasinfo,
1070 NT_STATUS_UNSUCCESSFUL);
1071
1072 /* Return output parameters */
1073
1074 if (!NT_STATUS_IS_OK(result = r.status)) {
1075 goto done;
1076 }
1077
1078 *ctr = *r.ctr;
1079
1080 done:
1081
1082 return result;
1083 }
1084
1085 /* Query domain info */
1086
1087 NTSTATUS rpccli_samr_query_dom_info(struct rpc_pipe_client *cli,
1088 TALLOC_CTX *mem_ctx,
1089 POLICY_HND *domain_pol,
1090 uint16 switch_value,
1091 SAM_UNK_CTR *ctr)
1092 {
1093 prs_struct qbuf, rbuf;
1094 SAMR_Q_QUERY_DOMAIN_INFO q;
1095 SAMR_R_QUERY_DOMAIN_INFO r;
1096 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1097
1098 DEBUG(10,("cli_samr_query_dom_info\n"));
1099
1100 ZERO_STRUCT(q);
1101 ZERO_STRUCT(r);
1102
1103 /* Marshall data and send request */
1104
1105 init_samr_q_query_dom_info(&q, domain_pol, switch_value);
1106
1107 r.ctr = ctr;
1108
1109 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DOMAIN_INFO,
1110 q, r,
1111 qbuf, rbuf,
1112 samr_io_q_query_dom_info,
1113 samr_io_r_query_dom_info,
1114 NT_STATUS_UNSUCCESSFUL);
1115
1116 /* Return output parameters */
1117
1118 if (!NT_STATUS_IS_OK(result = r.status)) {
1119 goto done;
1120 }
1121
1122 done:
1123
1124 return result;
1125 }
1126
1127 /* Set domain info */
1128
1129 NTSTATUS rpccli_samr_set_domain_info(struct rpc_pipe_client *cli,
1130 TALLOC_CTX *mem_ctx,
1131 POLICY_HND *domain_pol,
1132 uint16 switch_value,
1133 SAM_UNK_CTR *ctr)
1134 {
1135 prs_struct qbuf, rbuf;
1136 SAMR_Q_SET_DOMAIN_INFO q;
1137 SAMR_R_SET_DOMAIN_INFO r;
1138 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1139
1140 DEBUG(10,("cli_samr_set_domain_info\n"));
1141
1142 ZERO_STRUCT(q);
1143 ZERO_STRUCT(r);
1144
1145 /* Marshall data and send request */
1146
1147 init_samr_q_set_domain_info(&q, domain_pol, switch_value, ctr);
1148
1149 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_DOMAIN_INFO,
1150 q, r,
1151 qbuf, rbuf,
1152 samr_io_q_set_domain_info,
1153 samr_io_r_set_domain_info,
1154 NT_STATUS_UNSUCCESSFUL);
1155
1156 /* Return output parameters */
1157
1158 if (!NT_STATUS_IS_OK(result = r.status)) {
1159 goto done;
1160 }
1161
1162 done:
1163
1164 return result;
1165 }
1166
1167 /* User change password */
1168
1169 NTSTATUS rpccli_samr_chgpasswd_user(struct rpc_pipe_client *cli,
1170 TALLOC_CTX *mem_ctx,
1171 const char *username,
1172 const char *newpassword,
1173 const char *oldpassword )
1174 {
1175 prs_struct qbuf, rbuf;
1176 SAMR_Q_CHGPASSWD_USER q;
1177 SAMR_R_CHGPASSWD_USER r;
1178 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1179
1180 uchar new_nt_password[516];
1181 uchar new_lm_password[516];
1182 uchar old_nt_hash[16];
1183 uchar old_lanman_hash[16];
1184 uchar old_nt_hash_enc[16];
1185 uchar old_lanman_hash_enc[16];
1186
1187 uchar new_nt_hash[16];
1188 uchar new_lanman_hash[16];
1189
1190 char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
1191
1192 DEBUG(10,("rpccli_samr_chgpasswd_user\n"));
1193
1194 ZERO_STRUCT(q);
1195 ZERO_STRUCT(r);
1196
1197 /* Calculate the MD4 hash (NT compatible) of the password */
1198 E_md4hash(oldpassword, old_nt_hash);
1199 E_md4hash(newpassword, new_nt_hash);
1200
1201 if (lp_client_lanman_auth()
1202 && E_deshash(newpassword, new_lanman_hash)
1203 && E_deshash(oldpassword, old_lanman_hash)) {
1204 /* E_deshash returns false for 'long' passwords (> 14
1205 DOS chars). This allows us to match Win2k, which
1206 does not store a LM hash for these passwords (which
1207 would reduce the effective password length to 14) */
1208
1209 encode_pw_buffer(new_lm_password, newpassword, STR_UNICODE);
1210
1211 SamOEMhash( new_lm_password, old_nt_hash, 516);
1212 E_old_pw_hash( new_nt_hash, old_lanman_hash, old_lanman_hash_enc);
1213 } else {
1214 ZERO_STRUCT(new_lm_password);
1215 ZERO_STRUCT(old_lanman_hash_enc);
1216 }
1217
1218 encode_pw_buffer(new_nt_password, newpassword, STR_UNICODE);
1219
1220 SamOEMhash( new_nt_password, old_nt_hash, 516);
1221 E_old_pw_hash( new_nt_hash, old_nt_hash, old_nt_hash_enc);
1222
1223 /* Marshall data and send request */
1224
1225 init_samr_q_chgpasswd_user(&q, srv_name_slash, username,
1226 new_nt_password,
1227 old_nt_hash_enc,
1228 new_lm_password,
1229 old_lanman_hash_enc);
1230
1231 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER,
1232 q, r,
1233 qbuf, rbuf,
1234 samr_io_q_chgpasswd_user,
1235 samr_io_r_chgpasswd_user,
1236 NT_STATUS_UNSUCCESSFUL);
1237
1238 /* Return output parameters */
1239
1240 if (!NT_STATUS_IS_OK(result = r.status)) {
1241 goto done;
1242 }
1243
1244 done:
1245
1246 return result;
1247 }
1248
1249 /* change password 3 */
1250
1251 NTSTATUS rpccli_samr_chgpasswd3(struct rpc_pipe_client *cli,
1252 TALLOC_CTX *mem_ctx,
1253 const char *username,
1254 const char *newpassword,
1255 const char *oldpassword,
1256 SAM_UNK_INFO_1 *info,
1257 SAMR_CHANGE_REJECT *reject)
1258 {
1259 prs_struct qbuf, rbuf;
1260 SAMR_Q_CHGPASSWD_USER3 q;
1261 SAMR_R_CHGPASSWD_USER3 r;
1262
1263 uchar new_nt_password[516];
1264 uchar new_lm_password[516];
1265 uchar old_nt_hash[16];
1266 uchar old_lanman_hash[16];
1267 uchar old_nt_hash_enc[16];
1268 uchar old_lanman_hash_enc[16];
1269
1270 uchar new_nt_hash[16];
1271 uchar new_lanman_hash[16];
1272
1273 char *srv_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", cli->cli->desthost);
1274
1275 DEBUG(10,("rpccli_samr_chgpasswd_user3\n"));
1276
1277 ZERO_STRUCT(q);
1278 ZERO_STRUCT(r);
1279
1280 /* Calculate the MD4 hash (NT compatible) of the password */
1281 E_md4hash(oldpassword, old_nt_hash);
1282 E_md4hash(newpassword, new_nt_hash);
1283
1284 if (lp_client_lanman_auth()
1285 && E_deshash(newpassword, new_lanman_hash)
1286 && E_deshash(oldpassword, old_lanman_hash)) {
1287 /* E_deshash returns false for 'long' passwords (> 14
1288 DOS chars). This allows us to match Win2k, which
1289 does not store a LM hash for these passwords (which
1290 would reduce the effective password length to 14) */
1291
1292 encode_pw_buffer(new_lm_password, newpassword, STR_UNICODE);
1293
1294 SamOEMhash( new_lm_password, old_nt_hash, 516);
1295 E_old_pw_hash( new_nt_hash, old_lanman_hash, old_lanman_hash_enc);
1296 } else {
1297 ZERO_STRUCT(new_lm_password);
1298 ZERO_STRUCT(old_lanman_hash_enc);
1299 }
1300
1301 encode_pw_buffer(new_nt_password, newpassword, STR_UNICODE);
1302
1303 SamOEMhash( new_nt_password, old_nt_hash, 516);
1304 E_old_pw_hash( new_nt_hash, old_nt_hash, old_nt_hash_enc);
1305
1306 /* Marshall data and send request */
1307
1308 init_samr_q_chgpasswd_user3(&q, srv_name_slash, username,
1309 new_nt_password,
1310 old_nt_hash_enc,
1311 new_lm_password,
1312 old_lanman_hash_enc);
1313 r.info = info;
1314 r.reject = reject;
1315
1316 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CHGPASSWD_USER3,
1317 q, r,
1318 qbuf, rbuf,
1319 samr_io_q_chgpasswd_user3,
1320 samr_io_r_chgpasswd_user3,
1321 NT_STATUS_UNSUCCESSFUL);
1322
1323 /* Return output parameters */
1324
1325 return r.status;
1326 }
1327
1328 /* This function returns the bizzare set of (max_entries, max_size) required
1329 for the QueryDisplayInfo RPC to actually work against a domain controller
1330 with large (10k and higher) numbers of users. These values were
1331 obtained by inspection using ethereal and NT4 running User Manager. */
1332
1333 void get_query_dispinfo_params(int loop_count, uint32 *max_entries,
1334 uint32 *max_size)
1335 {
1336 switch(loop_count) {
1337 case 0:
1338 *max_entries = 512;
1339 *max_size = 16383;
1340 break;
1341 case 1:
1342 *max_entries = 1024;
1343 *max_size = 32766;
1344 break;
1345 case 2:
1346 *max_entries = 2048;
1347 *max_size = 65532;
1348 break;
1349 case 3:
1350 *max_entries = 4096;
1351 *max_size = 131064;
1352 break;
1353 default: /* loop_count >= 4 */
1354 *max_entries = 4096;
1355 *max_size = 131071;
1356 break;
1357 }
1358 }
1359
1360 /* Query display info */
1361
1362 NTSTATUS rpccli_samr_query_dispinfo(struct rpc_pipe_client *cli,
1363 TALLOC_CTX *mem_ctx,
1364 POLICY_HND *domain_pol, uint32 *start_idx,
1365 uint16 switch_value, uint32 *num_entries,
1366 uint32 max_entries, uint32 max_size,
1367 SAM_DISPINFO_CTR *ctr)
1368 {
1369 prs_struct qbuf, rbuf;
1370 SAMR_Q_QUERY_DISPINFO q;
1371 SAMR_R_QUERY_DISPINFO r;
1372 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1373
1374 DEBUG(10,("cli_samr_query_dispinfo for start_idx = %u\n", *start_idx));
1375
1376 ZERO_STRUCT(q);
1377 ZERO_STRUCT(r);
1378
1379 *num_entries = 0;
1380
1381 /* Marshall data and send request */
1382
1383 init_samr_q_query_dispinfo(&q, domain_pol, switch_value,
1384 *start_idx, max_entries, max_size);
1385
1386 r.ctr = ctr;
1387
1388 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_DISPINFO,
1389 q, r,
1390 qbuf, rbuf,
1391 samr_io_q_query_dispinfo,
1392 samr_io_r_query_dispinfo,
1393 NT_STATUS_UNSUCCESSFUL);
1394
1395 /* Return output parameters */
1396
1397 result = r.status;
1398
1399 if (!NT_STATUS_IS_OK(result) &&
1400 NT_STATUS_V(result) != NT_STATUS_V(STATUS_MORE_ENTRIES)) {
1401 goto done;
1402 }
1403
1404 *num_entries = r.num_entries;
1405 *start_idx += r.num_entries; /* No next_idx in this structure! */
1406
1407 done:
1408 return result;
1409 }
1410
1411 /* Lookup rids. Note that NT4 seems to crash if more than ~1000 rids are
1412 looked up in one packet. */
1413
1414 NTSTATUS rpccli_samr_lookup_rids(struct rpc_pipe_client *cli,
1415 TALLOC_CTX *mem_ctx,
1416 POLICY_HND *domain_pol,
1417 uint32 num_rids, uint32 *rids,
1418 uint32 *num_names, char ***names,
1419 uint32 **name_types)
1420 {
1421 prs_struct qbuf, rbuf;
1422 SAMR_Q_LOOKUP_RIDS q;
1423 SAMR_R_LOOKUP_RIDS r;
1424 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1425 uint32 i;
1426
1427 DEBUG(10,("cli_samr_lookup_rids\n"));
1428
1429 if (num_rids > 1000) {
1430 DEBUG(2, ("cli_samr_lookup_rids: warning: NT4 can crash if "
1431 "more than ~1000 rids are looked up at once.\n"));
1432 }
1433
1434 ZERO_STRUCT(q);
1435 ZERO_STRUCT(r);
1436
1437 /* Marshall data and send request */
1438
1439 init_samr_q_lookup_rids(mem_ctx, &q, domain_pol, 1000, num_rids, rids);
1440
1441 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_RIDS,
1442 q, r,
1443 qbuf, rbuf,
1444 samr_io_q_lookup_rids,
1445 samr_io_r_lookup_rids,
1446 NT_STATUS_UNSUCCESSFUL);
1447
1448 /* Return output parameters */
1449
1450 result = r.status;
1451
1452 if (!NT_STATUS_IS_OK(result) &&
1453 !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
1454 goto done;
1455
1456 if (r.num_names1 == 0) {
1457 *num_names = 0;
1458 *names = NULL;
1459 goto done;
1460 }
1461
1462 *num_names = r.num_names1;
1463 *names = TALLOC_ARRAY(mem_ctx, char *, r.num_names1);
1464 *name_types = TALLOC_ARRAY(mem_ctx, uint32, r.num_names1);
1465
1466 for (i = 0; i < r.num_names1; i++) {
1467 fstring tmp;
1468
1469 unistr2_to_ascii(tmp, &r.uni_name[i], sizeof(tmp) - 1);
1470 (*names)[i] = talloc_strdup(mem_ctx, tmp);
1471 (*name_types)[i] = r.type[i];
1472 }
1473
1474 done:
1475
1476 return result;
1477 }
1478
1479 /* Lookup names */
1480
1481 NTSTATUS rpccli_samr_lookup_names(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1482 POLICY_HND *domain_pol, uint32 flags,
1483 uint32 num_names, const char **names,
1484 uint32 *num_rids, uint32 **rids,
1485 uint32 **rid_types)
1486 {
1487 prs_struct qbuf, rbuf;
1488 SAMR_Q_LOOKUP_NAMES q;
1489 SAMR_R_LOOKUP_NAMES r;
1490 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1491 uint32 i;
1492
1493 DEBUG(10,("cli_samr_lookup_names\n"));
1494
1495 ZERO_STRUCT(q);
1496 ZERO_STRUCT(r);
1497
1498 /* Marshall data and send request */
1499
1500 init_samr_q_lookup_names(mem_ctx, &q, domain_pol, flags,
1501 num_names, names);
1502
1503 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_NAMES,
1504 q, r,
1505 qbuf, rbuf,
1506 samr_io_q_lookup_names,
1507 samr_io_r_lookup_names,
1508 NT_STATUS_UNSUCCESSFUL);
1509
1510 /* Return output parameters */
1511
1512 if (!NT_STATUS_IS_OK(result = r.status)) {
1513 goto done;
1514 }
1515
1516 if (r.num_rids1 == 0) {
1517 *num_rids = 0;
1518 goto done;
1519 }
1520
1521 *num_rids = r.num_rids1;
1522 *rids = TALLOC_ARRAY(mem_ctx, uint32, r.num_rids1);
1523 *rid_types = TALLOC_ARRAY(mem_ctx, uint32, r.num_rids1);
1524
1525 for (i = 0; i < r.num_rids1; i++) {
1526 (*rids)[i] = r.rids[i];
1527 (*rid_types)[i] = r.types[i];
1528 }
1529
1530 done:
1531
1532 return result;
1533 }
1534
1535 /* Create a domain user */
1536
1537 NTSTATUS rpccli_samr_create_dom_user(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1538 POLICY_HND *domain_pol, const char *acct_name,
1539 uint32 acb_info, uint32 unknown,
1540 POLICY_HND *user_pol, uint32 *rid)
1541 {
1542 prs_struct qbuf, rbuf;
1543 SAMR_Q_CREATE_USER q;
1544 SAMR_R_CREATE_USER r;
1545 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1546
1547 DEBUG(10,("cli_samr_create_dom_user %s\n", acct_name));
1548
1549 ZERO_STRUCT(q);
1550 ZERO_STRUCT(r);
1551
1552 /* Marshall data and send request */
1553
1554 init_samr_q_create_user(&q, domain_pol, acct_name, acb_info, unknown);
1555
1556 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_CREATE_USER,
1557 q, r,
1558 qbuf, rbuf,
1559 samr_io_q_create_user,
1560 samr_io_r_create_user,
1561 NT_STATUS_UNSUCCESSFUL);
1562
1563 /* Return output parameters */
1564
1565 if (!NT_STATUS_IS_OK(result = r.status)) {
1566 goto done;
1567 }
1568
1569 if (user_pol)
1570 *user_pol = r.user_pol;
1571
1572 if (rid)
1573 *rid = r.user_rid;
1574
1575 done:
1576
1577 return result;
1578 }
1579
1580 /* Set userinfo */
1581
1582 NTSTATUS rpccli_samr_set_userinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1583 const POLICY_HND *user_pol, uint16 switch_value,
1584 DATA_BLOB *sess_key, SAM_USERINFO_CTR *ctr)
1585 {
1586 prs_struct qbuf, rbuf;
1587 SAMR_Q_SET_USERINFO q;
1588 SAMR_R_SET_USERINFO r;
1589 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1590
1591 DEBUG(10,("cli_samr_set_userinfo\n"));
1592
1593 ZERO_STRUCT(q);
1594 ZERO_STRUCT(r);
1595
1596 if (!sess_key->length) {
1597 DEBUG(1, ("No user session key\n"));
1598 return NT_STATUS_NO_USER_SESSION_KEY;
1599 }
1600
1601 /* Initialise parse structures */
1602
1603 prs_init(&qbuf, RPC_MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1604 prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1605
1606 /* Marshall data and send request */
1607
1608 q.ctr = ctr;
1609
1610 init_samr_q_set_userinfo(&q, user_pol, sess_key, switch_value,
1611 ctr->info.id);
1612
1613 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_USERINFO,
1614 q, r,
1615 qbuf, rbuf,
1616 samr_io_q_set_userinfo,
1617 samr_io_r_set_userinfo,
1618 NT_STATUS_UNSUCCESSFUL);
1619
1620 /* Return output parameters */
1621
1622 if (!NT_STATUS_IS_OK(result = r.status)) {
1623 goto done;
1624 }
1625
1626 done:
1627
1628 return result;
1629 }
1630
1631 /* Set userinfo2 */
1632
1633 NTSTATUS rpccli_samr_set_userinfo2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1634 const POLICY_HND *user_pol, uint16 switch_value,
1635 DATA_BLOB *sess_key, SAM_USERINFO_CTR *ctr)
1636 {
1637 prs_struct qbuf, rbuf;
1638 SAMR_Q_SET_USERINFO2 q;
1639 SAMR_R_SET_USERINFO2 r;
1640 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1641
1642 DEBUG(10,("cli_samr_set_userinfo2\n"));
1643
1644 if (!sess_key->length) {
1645 DEBUG(1, ("No user session key\n"));
1646 return NT_STATUS_NO_USER_SESSION_KEY;
1647 }
1648
1649 ZERO_STRUCT(q);
1650 ZERO_STRUCT(r);
1651
1652 /* Marshall data and send request */
1653
1654 init_samr_q_set_userinfo2(&q, user_pol, sess_key, switch_value, ctr);
1655
1656 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_USERINFO2,
1657 q, r,
1658 qbuf, rbuf,
1659 samr_io_q_set_userinfo2,
1660 samr_io_r_set_userinfo2,
1661 NT_STATUS_UNSUCCESSFUL);
1662
1663 /* Return output parameters */
1664
1665 if (!NT_STATUS_IS_OK(result = r.status)) {
1666 goto done;
1667 }
1668
1669 done:
1670
1671 return result;
1672 }
1673
1674 /* Delete domain group */
1675
1676 NTSTATUS rpccli_samr_delete_dom_group(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1677 POLICY_HND *group_pol)
1678 {
1679 prs_struct qbuf, rbuf;
1680 SAMR_Q_DELETE_DOM_GROUP q;
1681 SAMR_R_DELETE_DOM_GROUP r;
1682 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1683
1684 DEBUG(10,("cli_samr_delete_dom_group\n"));
1685
1686 ZERO_STRUCT(q);
1687 ZERO_STRUCT(r);
1688
1689 /* Marshall data and send request */
1690
1691 init_samr_q_delete_dom_group(&q, group_pol);
1692
1693 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_GROUP,
1694 q, r,
1695 qbuf, rbuf,
1696 samr_io_q_delete_dom_group,
1697 samr_io_r_delete_dom_group,
1698 NT_STATUS_UNSUCCESSFUL);
1699
1700 /* Return output parameters */
1701
1702 result = r.status;
1703
1704 return result;
1705 }
1706
1707 /* Delete domain alias */
1708
1709 NTSTATUS rpccli_samr_delete_dom_alias(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1710 POLICY_HND *alias_pol)
1711 {
1712 prs_struct qbuf, rbuf;
1713 SAMR_Q_DELETE_DOM_ALIAS q;
1714 SAMR_R_DELETE_DOM_ALIAS r;
1715 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1716
1717 DEBUG(10,("cli_samr_delete_dom_alias\n"));
1718
1719 ZERO_STRUCT(q);
1720 ZERO_STRUCT(r);
1721
1722 /* Marshall data and send request */
1723
1724 init_samr_q_delete_dom_alias(&q, alias_pol);
1725
1726 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_ALIAS,
1727 q, r,
1728 qbuf, rbuf,
1729 samr_io_q_delete_dom_alias,
1730 samr_io_r_delete_dom_alias,
1731 NT_STATUS_UNSUCCESSFUL);
1732
1733 /* Return output parameters */
1734
1735 result = r.status;
1736
1737 return result;
1738 }
1739
1740 /* Delete domain user */
1741
1742 NTSTATUS rpccli_samr_delete_dom_user(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1743 POLICY_HND *user_pol)
1744 {
1745 prs_struct qbuf, rbuf;
1746 SAMR_Q_DELETE_DOM_USER q;
1747 SAMR_R_DELETE_DOM_USER r;
1748 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1749
1750 DEBUG(10,("cli_samr_delete_dom_user\n"));
1751
1752 ZERO_STRUCT(q);
1753 ZERO_STRUCT(r);
1754
1755 /* Marshall data and send request */
1756
1757 init_samr_q_delete_dom_user(&q, user_pol);
1758
1759 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_DELETE_DOM_USER,
1760 q, r,
1761 qbuf, rbuf,
1762 samr_io_q_delete_dom_user,
1763 samr_io_r_delete_dom_user,
1764 NT_STATUS_UNSUCCESSFUL);
1765
1766 /* Return output parameters */
1767
1768 result = r.status;
1769
1770 return result;
1771 }
1772
1773 /* Remove foreign SID */
1774
1775 NTSTATUS rpccli_samr_remove_sid_foreign_domain(struct rpc_pipe_client *cli,
1776 TALLOC_CTX *mem_ctx,
1777 POLICY_HND *user_pol,
1778 DOM_SID *sid)
1779 {
1780 prs_struct qbuf, rbuf;
1781 SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN q;
1782 SAMR_R_REMOVE_SID_FOREIGN_DOMAIN r;
1783 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1784
1785 DEBUG(10,("cli_samr_remove_sid_foreign_domain\n"));
1786
1787 ZERO_STRUCT(q);
1788 ZERO_STRUCT(r);
1789
1790 /* Marshall data and send request */
1791
1792 init_samr_q_remove_sid_foreign_domain(&q, user_pol, sid);
1793
1794 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_REMOVE_SID_FOREIGN_DOMAIN,
1795 q, r,
1796 qbuf, rbuf,
1797 samr_io_q_remove_sid_foreign_domain,
1798 samr_io_r_remove_sid_foreign_domain,
1799 NT_STATUS_UNSUCCESSFUL);
1800
1801 /* Return output parameters */
1802
1803 result = r.status;
1804
1805 return result;
1806 }
1807
1808 /* Query user security object */
1809
1810 NTSTATUS rpccli_samr_query_sec_obj(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1811 POLICY_HND *user_pol, uint32 sec_info,
1812 TALLOC_CTX *ctx, SEC_DESC_BUF **sec_desc_buf)
1813 {
1814 prs_struct qbuf, rbuf;
1815 SAMR_Q_QUERY_SEC_OBJ q;
1816 SAMR_R_QUERY_SEC_OBJ r;
1817 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1818
1819 DEBUG(10,("cli_samr_query_sec_obj\n"));
1820
1821 ZERO_STRUCT(q);
1822 ZERO_STRUCT(r);
1823
1824 /* Marshall data and send request */
1825
1826 init_samr_q_query_sec_obj(&q, user_pol, sec_info);
1827
1828 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_QUERY_SEC_OBJECT,
1829 q, r,
1830 qbuf, rbuf,
1831 samr_io_q_query_sec_obj,
1832 samr_io_r_query_sec_obj,
1833 NT_STATUS_UNSUCCESSFUL);
1834
1835 /* Return output parameters */
1836
1837 result = r.status;
1838 *sec_desc_buf=dup_sec_desc_buf(ctx, r.buf);
1839
1840 return result;
1841 }
1842
1843 /* Set user security object */
1844
1845 NTSTATUS rpccli_samr_set_sec_obj(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1846 POLICY_HND *user_pol, uint32 sec_info,
1847 SEC_DESC_BUF *sec_desc_buf)
1848 {
1849 prs_struct qbuf, rbuf;
1850 SAMR_Q_SET_SEC_OBJ q;
1851 SAMR_R_SET_SEC_OBJ r;
1852 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1853
1854 DEBUG(10,("cli_samr_set_sec_obj\n"));
1855
1856 ZERO_STRUCT(q);
1857 ZERO_STRUCT(r);
1858
1859 /* Marshall data and send request */
1860
1861 init_samr_q_set_sec_obj(&q, user_pol, sec_info, sec_desc_buf);
1862
1863 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_SET_SEC_OBJECT,
1864 q, r,
1865 qbuf, rbuf,
1866 samr_io_q_set_sec_obj,
1867 samr_io_r_set_sec_obj,
1868 NT_STATUS_UNSUCCESSFUL);
1869
1870 /* Return output parameters */
1871
1872 result = r.status;
1873
1874 return result;
1875 }
1876
1877
1878 /* Get domain password info */
1879
1880 NTSTATUS rpccli_samr_get_dom_pwinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1881 uint16 *min_pwd_length, uint32 *password_properties)
1882 {
1883 prs_struct qbuf, rbuf;
1884 SAMR_Q_GET_DOM_PWINFO q;
1885 SAMR_R_GET_DOM_PWINFO r;
1886 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1887
1888 DEBUG(10,("cli_samr_get_dom_pwinfo\n"));
1889
1890 ZERO_STRUCT(q);
1891 ZERO_STRUCT(r);
1892
1893 /* Marshall data and send request */
1894
1895 init_samr_q_get_dom_pwinfo(&q, cli->cli->desthost);
1896
1897 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_DOM_PWINFO,
1898 q, r,
1899 qbuf, rbuf,
1900 samr_io_q_get_dom_pwinfo,
1901 samr_io_r_get_dom_pwinfo,
1902 NT_STATUS_UNSUCCESSFUL);
1903
1904 /* Return output parameters */
1905
1906 result = r.status;
1907
1908 if (NT_STATUS_IS_OK(result)) {
1909 if (min_pwd_length)
1910 *min_pwd_length = r.min_pwd_length;
1911 if (password_properties)
1912 *password_properties = r.password_properties;
1913 }
1914
1915 return result;
1916 }
1917
1918 /* Get domain password info */
1919
1920 NTSTATUS rpccli_samr_get_usrdom_pwinfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1921 POLICY_HND *pol, uint16 *min_pwd_length,
1922 uint32 *password_properties, uint32 *unknown1)
1923 {
1924 prs_struct qbuf, rbuf;
1925 SAMR_Q_GET_USRDOM_PWINFO q;
1926 SAMR_R_GET_USRDOM_PWINFO r;
1927 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1928
1929 DEBUG(10,("cli_samr_get_usrdom_pwinfo\n"));
1930
1931 ZERO_STRUCT(q);
1932 ZERO_STRUCT(r);
1933
1934 /* Marshall data and send request */
1935
1936 init_samr_q_get_usrdom_pwinfo(&q, pol);
1937
1938 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_GET_USRDOM_PWINFO,
1939 q, r,
1940 qbuf, rbuf,
1941 samr_io_q_get_usrdom_pwinfo,
1942 samr_io_r_get_usrdom_pwinfo,
1943 NT_STATUS_UNSUCCESSFUL);
1944
1945 /* Return output parameters */
1946
1947 result = r.status;
1948
1949 if (NT_STATUS_IS_OK(result)) {
1950 if (min_pwd_length)
1951 *min_pwd_length = r.min_pwd_length;
1952 if (password_properties)
1953 *password_properties = r.password_properties;
1954 if (unknown1)
1955 *unknown1 = r.unknown_1;
1956 }
1957
1958 return result;
1959 }
1960
1961
1962 /* Lookup Domain Name */
1963
1964 NTSTATUS rpccli_samr_lookup_domain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1965 POLICY_HND *user_pol, char *domain_name,
1966 DOM_SID *sid)
1967 {
1968 prs_struct qbuf, rbuf;
1969 SAMR_Q_LOOKUP_DOMAIN q;
1970 SAMR_R_LOOKUP_DOMAIN r;
1971 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1972
1973 DEBUG(10,("cli_samr_lookup_domain\n"));
1974
1975 ZERO_STRUCT(q);
1976 ZERO_STRUCT(r);
1977
1978 /* Marshall data and send request */
1979
1980 init_samr_q_lookup_domain(&q, user_pol, domain_name);
1981
1982 CLI_DO_RPC(cli, mem_ctx, PI_SAMR, SAMR_LOOKUP_DOMAIN,
1983 q, r,
1984 qbuf, rbuf,
1985 samr_io_q_lookup_domain,
1986 samr_io_r_lookup_domain,
1987 NT_STATUS_UNSUCCESSFUL);
1988
1989 /* Return output parameters */
1990
1991 result = r.status;
1992
1993 if (NT_STATUS_IS_OK(result))
1994 sid_copy(sid, &r.dom_sid.sid);
1995
1996 return result;
1997 }
Samba GIT mirror