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