Given Jeremy's positive response, and a lack of one from tpot, I'll commit
[kai/samba.git] / source3 / libsmb / cli_lsarpc.c
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 /** @defgroup lsa LSA - Local Security Architecture
29  *  @ingroup rpc_client
30  *
31  * @{
32  **/
33
34 /**
35  * @file cli_lsarpc.c
36  *
37  * RPC client routines for the LSA RPC pipe.  LSA means "local
38  * security authority", which is half of a password database.
39  **/
40
41 /** Open a LSA policy handle
42  *
43  * @param cli Handle on an initialised SMB connection */
44
45 NTSTATUS cli_lsa_open_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
46                              BOOL sec_qos, uint32 des_access, POLICY_HND *pol)
47 {
48         prs_struct qbuf, rbuf;
49         LSA_Q_OPEN_POL q;
50         LSA_R_OPEN_POL r;
51         LSA_SEC_QOS qos;
52         NTSTATUS result;
53
54         ZERO_STRUCT(q);
55         ZERO_STRUCT(r);
56
57         /* Initialise parse structures */
58
59         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
60         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
61
62         /* Initialise input parameters */
63
64         if (sec_qos) {
65                 init_lsa_sec_qos(&qos, 2, 1, 0);
66                 init_q_open_pol(&q, '\\', 0, des_access, &qos);
67         } else {
68                 init_q_open_pol(&q, '\\', 0, des_access, NULL);
69         }
70
71         /* Marshall data and send request */
72
73         if (!lsa_io_q_open_pol("", &q, &qbuf, 0) ||
74             !rpc_api_pipe_req(cli, LSA_OPENPOLICY, &qbuf, &rbuf)) {
75                 result = NT_STATUS_UNSUCCESSFUL;
76                 goto done;
77         }
78
79         /* Unmarshall response */
80
81         if (!lsa_io_r_open_pol("", &r, &rbuf, 0)) {
82                 result = NT_STATUS_UNSUCCESSFUL;
83                 goto done;
84         }
85
86         /* Return output parameters */
87
88         if (NT_STATUS_IS_OK(result = r.status)) {
89                 *pol = r.pol;
90 #ifdef __INSURE__
91                 pol->marker = malloc(1);
92 #endif
93         }
94
95  done:
96         prs_mem_free(&qbuf);
97         prs_mem_free(&rbuf);
98
99         return result;
100 }
101
102 /** Open a LSA policy handle
103   *
104   * @param cli Handle on an initialised SMB connection 
105   */
106
107 NTSTATUS cli_lsa_open_policy2(struct cli_state *cli, TALLOC_CTX *mem_ctx,
108                               BOOL sec_qos, uint32 des_access, POLICY_HND *pol)
109 {
110         prs_struct qbuf, rbuf;
111         LSA_Q_OPEN_POL2 q;
112         LSA_R_OPEN_POL2 r;
113         LSA_SEC_QOS qos;
114         NTSTATUS result;
115
116         ZERO_STRUCT(q);
117         ZERO_STRUCT(r);
118
119         /* Initialise parse structures */
120
121         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
122         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
123
124         /* Initialise input parameters */
125
126         if (sec_qos) {
127                 init_lsa_sec_qos(&qos, 2, 1, 0);
128                 init_q_open_pol2(&q, cli->srv_name_slash, 0, des_access, 
129                                  &qos);
130         } else {
131                 init_q_open_pol2(&q, cli->srv_name_slash, 0, des_access, 
132                                  NULL);
133         }
134
135         /* Marshall data and send request */
136
137         if (!lsa_io_q_open_pol2("", &q, &qbuf, 0) ||
138             !rpc_api_pipe_req(cli, LSA_OPENPOLICY2, &qbuf, &rbuf)) {
139                 result = NT_STATUS_UNSUCCESSFUL;
140                 goto done;
141         }
142
143         /* Unmarshall response */
144
145         if (!lsa_io_r_open_pol2("", &r, &rbuf, 0)) {
146                 result = NT_STATUS_UNSUCCESSFUL;
147                 goto done;
148         }
149
150         /* Return output parameters */
151
152         if (NT_STATUS_IS_OK(result = r.status)) {
153                 *pol = r.pol;
154 #ifdef __INSURE__
155                 pol->marker = (char *)malloc(1);
156 #endif
157         }
158
159  done:
160         prs_mem_free(&qbuf);
161         prs_mem_free(&rbuf);
162
163         return result;
164 }
165
166 /** Close a LSA policy handle */
167
168 NTSTATUS cli_lsa_close(struct cli_state *cli, TALLOC_CTX *mem_ctx, 
169                        POLICY_HND *pol)
170 {
171         prs_struct qbuf, rbuf;
172         LSA_Q_CLOSE q;
173         LSA_R_CLOSE r;
174         NTSTATUS result;
175
176         ZERO_STRUCT(q);
177         ZERO_STRUCT(r);
178
179         /* Initialise parse structures */
180
181         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
182         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
183
184         /* Marshall data and send request */
185
186         init_lsa_q_close(&q, pol);
187
188         if (!lsa_io_q_close("", &q, &qbuf, 0) ||
189             !rpc_api_pipe_req(cli, LSA_CLOSE, &qbuf, &rbuf)) {
190                 result = NT_STATUS_UNSUCCESSFUL;
191                 goto done;
192         }
193
194         /* Unmarshall response */
195
196         if (!lsa_io_r_close("", &r, &rbuf, 0)) {
197                 result = NT_STATUS_UNSUCCESSFUL;
198                 goto done;
199         }
200
201         /* Return output parameters */
202
203         if (NT_STATUS_IS_OK(result = r.status)) {
204 #ifdef __INSURE__
205                 SAFE_FREE(pol->marker);
206 #endif
207                 *pol = r.pol;
208         }
209
210  done:
211         prs_mem_free(&qbuf);
212         prs_mem_free(&rbuf);
213
214         return result;
215 }
216
217 /** Lookup a list of sids */
218
219 NTSTATUS cli_lsa_lookup_sids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
220                              POLICY_HND *pol, int num_sids, DOM_SID *sids, 
221                              char ***domains, char ***names, uint32 **types)
222 {
223         prs_struct qbuf, rbuf;
224         LSA_Q_LOOKUP_SIDS q;
225         LSA_R_LOOKUP_SIDS r;
226         DOM_R_REF ref;
227         LSA_TRANS_NAME_ENUM t_names;
228         NTSTATUS result;
229         int i;
230
231         ZERO_STRUCT(q);
232         ZERO_STRUCT(r);
233
234         /* Initialise parse structures */
235
236         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
237         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
238
239         /* Marshall data and send request */
240
241         init_q_lookup_sids(mem_ctx, &q, pol, num_sids, sids, 1);
242
243         if (!lsa_io_q_lookup_sids("", &q, &qbuf, 0) ||
244             !rpc_api_pipe_req(cli, LSA_LOOKUPSIDS, &qbuf, &rbuf)) {
245                 result = NT_STATUS_UNSUCCESSFUL;
246                 goto done;
247         }
248
249         /* Unmarshall response */
250
251         ZERO_STRUCT(ref);
252         ZERO_STRUCT(t_names);
253
254         r.dom_ref = &ref;
255         r.names = &t_names;
256
257         if (!lsa_io_r_lookup_sids("", &r, &rbuf, 0)) {
258                 result = NT_STATUS_UNSUCCESSFUL;
259                 goto done;
260         }
261
262         result = r.status;
263
264         if (!NT_STATUS_IS_OK(result) &&
265             NT_STATUS_V(result) != NT_STATUS_V(STATUS_SOME_UNMAPPED)) {
266           
267                 /* An actual error occured */
268
269                 goto done;
270         }
271
272         /* Return output parameters */
273
274         if (r.mapped_count == 0) {
275                 result = NT_STATUS_NONE_MAPPED;
276                 goto done;
277         }
278
279         if (!((*domains) = (char **)talloc(mem_ctx, sizeof(char *) *
280                                            num_sids))) {
281                 DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
282                 result = NT_STATUS_UNSUCCESSFUL;
283                 goto done;
284         }
285
286         if (!((*names) = (char **)talloc(mem_ctx, sizeof(char *) *
287                                          num_sids))) {
288                 DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
289                 result = NT_STATUS_UNSUCCESSFUL;
290                 goto done;
291         }
292
293         if (!((*types) = (uint32 *)talloc(mem_ctx, sizeof(uint32) *
294                                           num_sids))) {
295                 DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
296                 result = NT_STATUS_UNSUCCESSFUL;
297                 goto done;
298         }
299                 
300         for (i = 0; i < num_sids; i++) {
301                 fstring name, dom_name;
302                 uint32 dom_idx = t_names.name[i].domain_idx;
303
304                 /* Translate optimised name through domain index array */
305
306                 if (dom_idx != 0xffffffff) {
307
308                         rpcstr_pull_unistr2_fstring(
309                                 dom_name, &ref.ref_dom[dom_idx].uni_dom_name);
310                         rpcstr_pull_unistr2_fstring(
311                                 name, &t_names.uni_name[i]);
312
313                         (*names)[i] = talloc_strdup(mem_ctx, name);
314                         (*domains)[i] = talloc_strdup(mem_ctx, dom_name);
315                         (*types)[i] = t_names.name[i].sid_name_use;
316                         
317                         if (((*names)[i] == NULL) || ((*domains)[i] == NULL)) {
318                                 DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
319                                 result = NT_STATUS_UNSUCCESSFUL;
320                                 goto done;
321                         }
322
323                 } else {
324                         (*names)[i] = NULL;
325                         (*types)[i] = SID_NAME_UNKNOWN;
326                 }
327         }
328
329  done:
330         prs_mem_free(&qbuf);
331         prs_mem_free(&rbuf);
332
333         return result;
334 }
335
336 /** Lookup a list of names */
337
338 NTSTATUS cli_lsa_lookup_names(struct cli_state *cli, TALLOC_CTX *mem_ctx,
339                               POLICY_HND *pol, int num_names, 
340                               const char **names, DOM_SID **sids, 
341                               uint32 **types)
342 {
343         prs_struct qbuf, rbuf;
344         LSA_Q_LOOKUP_NAMES q;
345         LSA_R_LOOKUP_NAMES r;
346         DOM_R_REF ref;
347         NTSTATUS result;
348         int i;
349         
350         ZERO_STRUCT(q);
351         ZERO_STRUCT(r);
352
353         /* Initialise parse structures */
354
355         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
356         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
357
358         /* Marshall data and send request */
359
360         init_q_lookup_names(mem_ctx, &q, pol, num_names, names);
361
362         if (!lsa_io_q_lookup_names("", &q, &qbuf, 0) ||
363             !rpc_api_pipe_req(cli, LSA_LOOKUPNAMES, &qbuf, &rbuf)) {
364                 result = NT_STATUS_UNSUCCESSFUL;
365                 goto done;
366         }
367         
368         /* Unmarshall response */
369
370         ZERO_STRUCT(ref);
371         r.dom_ref = &ref;
372
373         if (!lsa_io_r_lookup_names("", &r, &rbuf, 0)) {
374                 result = NT_STATUS_UNSUCCESSFUL;
375                 goto done;
376         }
377
378         result = r.status;
379
380         if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) !=
381             NT_STATUS_V(STATUS_SOME_UNMAPPED)) {
382
383                 /* An actual error occured */
384
385                 goto done;
386         }
387
388         /* Return output parameters */
389
390         if (r.mapped_count == 0) {
391                 result = NT_STATUS_NONE_MAPPED;
392                 goto done;
393         }
394
395         if (!((*sids = (DOM_SID *)talloc(mem_ctx, sizeof(DOM_SID) *
396                                          num_names)))) {
397                 DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
398                 result = NT_STATUS_UNSUCCESSFUL;
399                 goto done;
400         }
401
402         if (!((*types = (uint32 *)talloc(mem_ctx, sizeof(uint32) *
403                                          num_names)))) {
404                 DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
405                 result = NT_STATUS_UNSUCCESSFUL;
406                 goto done;
407         }
408
409         for (i = 0; i < num_names; i++) {
410                 DOM_RID2 *t_rids = r.dom_rid;
411                 uint32 dom_idx = t_rids[i].rid_idx;
412                 uint32 dom_rid = t_rids[i].rid;
413                 DOM_SID *sid = &(*sids)[i];
414
415                 /* Translate optimised sid through domain index array */
416
417                 if (dom_idx != 0xffffffff) {
418
419                         sid_copy(sid, &ref.ref_dom[dom_idx].ref_dom.sid);
420
421                         if (dom_rid != 0xffffffff) {
422                                 sid_append_rid(sid, dom_rid);
423                         }
424
425                         (*types)[i] = t_rids[i].type;
426                 } else {
427                         ZERO_STRUCTP(sid);
428                         (*types)[i] = SID_NAME_UNKNOWN;
429                 }
430         }
431
432  done:
433         prs_mem_free(&qbuf);
434         prs_mem_free(&rbuf);
435
436         return result;
437 }
438
439 /** Query info policy
440  *
441  *  @param domain_sid - returned remote server's domain sid */
442
443 NTSTATUS cli_lsa_query_info_policy(struct cli_state *cli, TALLOC_CTX *mem_ctx,
444                                    POLICY_HND *pol, uint16 info_class, 
445                                    fstring domain_name, DOM_SID *domain_sid)
446 {
447         prs_struct qbuf, rbuf;
448         LSA_Q_QUERY_INFO q;
449         LSA_R_QUERY_INFO r;
450         NTSTATUS result;
451
452         ZERO_STRUCT(q);
453         ZERO_STRUCT(r);
454
455         /* Initialise parse structures */
456
457         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
458         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
459
460         /* Marshall data and send request */
461
462         init_q_query(&q, pol, info_class);
463
464         if (!lsa_io_q_query("", &q, &qbuf, 0) ||
465             !rpc_api_pipe_req(cli, LSA_QUERYINFOPOLICY, &qbuf, &rbuf)) {
466                 result = NT_STATUS_UNSUCCESSFUL;
467                 goto done;
468         }
469
470         /* Unmarshall response */
471
472         if (!lsa_io_r_query("", &r, &rbuf, 0)) {
473                 result = NT_STATUS_UNSUCCESSFUL;
474                 goto done;
475         }
476
477         if (!NT_STATUS_IS_OK(result = r.status)) {
478                 goto done;
479         }
480
481         /* Return output parameters */
482
483         ZERO_STRUCTP(domain_sid);
484         domain_name[0] = '\0';
485
486         switch (info_class) {
487
488         case 3:
489                 if (r.dom.id3.buffer_dom_name != 0) {
490                         unistr2_to_ascii(domain_name,
491                                          &r.dom.id3.
492                                          uni_domain_name,
493                                          sizeof (fstring) - 1);
494                 }
495
496                 if (r.dom.id3.buffer_dom_sid != 0) {
497                         *domain_sid = r.dom.id3.dom_sid.sid;
498                 }
499
500                 break;
501
502         case 5:
503                 
504                 if (r.dom.id5.buffer_dom_name != 0) {
505                         unistr2_to_ascii(domain_name, &r.dom.id5.
506                                          uni_domain_name,
507                                          sizeof (fstring) - 1);
508                 }
509                         
510                 if (r.dom.id5.buffer_dom_sid != 0) {
511                         *domain_sid = r.dom.id5.dom_sid.sid;
512                 }
513
514                 break;
515                 
516         default:
517                 DEBUG(3, ("unknown info class %d\n", info_class));
518                 break;                
519         }
520         
521  done:
522         prs_mem_free(&qbuf);
523         prs_mem_free(&rbuf);
524
525         return result;
526 }
527
528 /**
529  * Enumerate list of trusted domains
530  *
531  * @param cli client state (cli_state) structure of the connection
532  * @param mem_ctx memory context
533  * @param pol opened lsa policy handle
534  * @param enum_ctx enumeration context ie. index of first returned domain entry
535  * @param pref_num_domains preferred max number of entries returned in one response
536  * @param num_domains total number of trusted domains returned by response
537  * @param domain_names returned trusted domain names
538  * @param domain_sids returned trusted domain sids
539  *
540  * @return nt status code of response
541  **/
542
543 NTSTATUS cli_lsa_enum_trust_dom(struct cli_state *cli, TALLOC_CTX *mem_ctx,
544                                 POLICY_HND *pol, uint32 *enum_ctx, 
545                                 uint32 *pref_num_domains, uint32 *num_domains,
546                                 char ***domain_names, DOM_SID **domain_sids)
547 {
548         prs_struct qbuf, rbuf;
549         LSA_Q_ENUM_TRUST_DOM q;
550         LSA_R_ENUM_TRUST_DOM r;
551         NTSTATUS result;
552         int i;
553
554         ZERO_STRUCT(q);
555         ZERO_STRUCT(r);
556
557         /* Initialise parse structures */
558
559         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
560         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
561
562         /* Marshall data and send request */
563
564         init_q_enum_trust_dom(&q, pol, *enum_ctx, *pref_num_domains);
565
566         if (!lsa_io_q_enum_trust_dom("", &q, &qbuf, 0) ||
567             !rpc_api_pipe_req(cli, LSA_ENUMTRUSTDOM, &qbuf, &rbuf)) {
568                 result = NT_STATUS_UNSUCCESSFUL;
569                 goto done;
570         }
571
572         /* Unmarshall response */
573
574         if (!lsa_io_r_enum_trust_dom("", &r, &rbuf, 0)) {
575                 result = NT_STATUS_UNSUCCESSFUL;
576                 goto done;
577         }
578
579         result = r.status;
580
581         if (!NT_STATUS_IS_OK(result) &&
582             !NT_STATUS_EQUAL(result, NT_STATUS_NO_MORE_ENTRIES) &&
583             !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES)) {
584
585                 /* An actual error ocured */
586
587                 goto done;
588         }
589
590         /* Return output parameters */
591
592         if (r.num_domains) {
593
594                 /* Allocate memory for trusted domain names and sids */
595
596                 *domain_names = (char **)talloc(mem_ctx, sizeof(char *) *
597                                                 r.num_domains);
598
599                 if (!*domain_names) {
600                         DEBUG(0, ("cli_lsa_enum_trust_dom(): out of memory\n"));
601                         result = NT_STATUS_UNSUCCESSFUL;
602                         goto done;
603                 }
604
605                 *domain_sids = (DOM_SID *)talloc(mem_ctx, sizeof(DOM_SID) *
606                                                  r.num_domains);
607                 if (!domain_sids) {
608                         DEBUG(0, ("cli_lsa_enum_trust_dom(): out of memory\n"));
609                         result = NT_STATUS_UNSUCCESSFUL;
610                         goto done;
611                 }
612
613                 /* Copy across names and sids */
614
615                 for (i = 0; i < r.num_domains; i++) {
616                         fstring tmp;
617
618                         unistr2_to_ascii(tmp, &r.uni_domain_name[i], 
619                                          sizeof(tmp) - 1);
620                         (*domain_names)[i] = talloc_strdup(mem_ctx, tmp);
621                         sid_copy(&(*domain_sids)[i], &r.domain_sid[i].sid);
622                 }
623         }
624
625         *num_domains = r.num_domains;
626         *enum_ctx = r.enum_context;
627
628  done:
629         prs_mem_free(&qbuf);
630         prs_mem_free(&rbuf);
631
632         return result;
633 }
634
635 /** Enumerate privileges*/
636
637 NTSTATUS cli_lsa_enum_privilege(struct cli_state *cli, TALLOC_CTX *mem_ctx,
638                                 POLICY_HND *pol, uint32 *enum_context, uint32 pref_max_length,
639                                 uint32 *count, char ***privs_name, uint32 **privs_high, uint32 **privs_low)
640 {
641         prs_struct qbuf, rbuf;
642         LSA_Q_ENUM_PRIVS q;
643         LSA_R_ENUM_PRIVS r;
644         NTSTATUS result;
645         int i;
646
647         ZERO_STRUCT(q);
648         ZERO_STRUCT(r);
649
650         /* Initialise parse structures */
651
652         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
653         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
654
655         /* Marshall data and send request */
656
657         init_q_enum_privs(&q, pol, *enum_context, pref_max_length);
658
659         if (!lsa_io_q_enum_privs("", &q, &qbuf, 0) ||
660             !rpc_api_pipe_req(cli, LSA_ENUM_PRIVS, &qbuf, &rbuf)) {
661                 result = NT_STATUS_UNSUCCESSFUL;
662                 goto done;
663         }
664
665         /* Unmarshall response */
666
667         if (!lsa_io_r_enum_privs("", &r, &rbuf, 0)) {
668                 result = NT_STATUS_UNSUCCESSFUL;
669                 goto done;
670         }
671
672         if (!NT_STATUS_IS_OK(result = r.status)) {
673                 goto done;
674         }
675
676         /* Return output parameters */
677
678         *enum_context = r.enum_context;
679         *count = r.count;
680
681         if (!((*privs_name = (char **)talloc(mem_ctx, sizeof(char *) * r.count)))) {
682                 DEBUG(0, ("(cli_lsa_enum_privilege): out of memory\n"));
683                 result = NT_STATUS_UNSUCCESSFUL;
684                 goto done;
685         }
686
687         if (!((*privs_high = (uint32 *)talloc(mem_ctx, sizeof(uint32) * r.count)))) {
688                 DEBUG(0, ("(cli_lsa_enum_privilege): out of memory\n"));
689                 result = NT_STATUS_UNSUCCESSFUL;
690                 goto done;
691         }
692
693         if (!((*privs_low = (uint32 *)talloc(mem_ctx, sizeof(uint32) * r.count)))) {
694                 DEBUG(0, ("(cli_lsa_enum_privilege): out of memory\n"));
695                 result = NT_STATUS_UNSUCCESSFUL;
696                 goto done;
697         }
698
699         for (i = 0; i < r.count; i++) {
700                 fstring name;
701
702                 rpcstr_pull_unistr2_fstring( name, &r.privs[i].name);
703
704                 (*privs_name)[i] = talloc_strdup(mem_ctx, name);
705
706                 (*privs_high)[i] = r.privs[i].luid_high;
707                 (*privs_low)[i] = r.privs[i].luid_low;
708         }
709
710  done:
711         prs_mem_free(&qbuf);
712         prs_mem_free(&rbuf);
713
714         return result;
715 }
716
717 /** Get privilege name */
718
719 NTSTATUS cli_lsa_get_dispname(struct cli_state *cli, TALLOC_CTX *mem_ctx,
720                               POLICY_HND *pol, char *name, uint16 lang_id, uint16 lang_id_sys,
721                               fstring description, uint16 *lang_id_desc)
722 {
723         prs_struct qbuf, rbuf;
724         LSA_Q_PRIV_GET_DISPNAME q;
725         LSA_R_PRIV_GET_DISPNAME r;
726         NTSTATUS result;
727
728         ZERO_STRUCT(q);
729         ZERO_STRUCT(r);
730
731         /* Initialise parse structures */
732
733         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
734         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
735
736         /* Marshall data and send request */
737
738         init_lsa_priv_get_dispname(&q, pol, name, lang_id, lang_id_sys);
739
740         if (!lsa_io_q_priv_get_dispname("", &q, &qbuf, 0) ||
741             !rpc_api_pipe_req(cli, LSA_PRIV_GET_DISPNAME, &qbuf, &rbuf)) {
742                 result = NT_STATUS_UNSUCCESSFUL;
743                 goto done;
744         }
745
746         /* Unmarshall response */
747
748         if (!lsa_io_r_priv_get_dispname("", &r, &rbuf, 0)) {
749                 result = NT_STATUS_UNSUCCESSFUL;
750                 goto done;
751         }
752
753         if (!NT_STATUS_IS_OK(result = r.status)) {
754                 goto done;
755         }
756
757         /* Return output parameters */
758         
759         rpcstr_pull_unistr2_fstring(description , &r.desc);
760         *lang_id_desc = r.lang_id;
761
762  done:
763         prs_mem_free(&qbuf);
764         prs_mem_free(&rbuf);
765
766         return result;
767 }
768
769 /** Enumerate list of SIDs  */
770
771 NTSTATUS cli_lsa_enum_sids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
772                                 POLICY_HND *pol, uint32 *enum_ctx, uint32 pref_max_length, 
773                                 uint32 *num_sids, DOM_SID **sids)
774 {
775         prs_struct qbuf, rbuf;
776         LSA_Q_ENUM_ACCOUNTS q;
777         LSA_R_ENUM_ACCOUNTS r;
778         NTSTATUS result;
779         int i;
780
781         ZERO_STRUCT(q);
782         ZERO_STRUCT(r);
783
784         /* Initialise parse structures */
785
786         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
787         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
788
789         /* Marshall data and send request */
790
791         init_lsa_q_enum_accounts(&q, pol, *enum_ctx, pref_max_length);
792
793         if (!lsa_io_q_enum_accounts("", &q, &qbuf, 0) ||
794             !rpc_api_pipe_req(cli, LSA_ENUM_ACCOUNTS, &qbuf, &rbuf)) {
795                 result = NT_STATUS_UNSUCCESSFUL;
796                 goto done;
797         }
798
799         /* Unmarshall response */
800
801         if (!lsa_io_r_enum_accounts("", &r, &rbuf, 0)) {
802                 result = NT_STATUS_UNSUCCESSFUL;
803                 goto done;
804         }
805
806         result = r.status;
807
808         if (!NT_STATUS_IS_OK(result = r.status)) {
809                 goto done;
810         }
811
812         if (r.sids.num_entries==0)
813                 goto done;
814
815         /* Return output parameters */
816
817         *sids = (DOM_SID *)talloc(mem_ctx, sizeof(DOM_SID) * r.sids.num_entries);
818         if (!*sids) {
819                 DEBUG(0, ("(cli_lsa_enum_sids): out of memory\n"));
820                 result = NT_STATUS_UNSUCCESSFUL;
821                 goto done;
822         }
823
824         /* Copy across names and sids */
825
826         for (i = 0; i < r.sids.num_entries; i++) {
827                 sid_copy(&(*sids)[i], &r.sids.sid[i].sid);
828         }
829
830         *num_sids= r.sids.num_entries;
831         *enum_ctx = r.enum_context;
832
833  done:
834         prs_mem_free(&qbuf);
835         prs_mem_free(&rbuf);
836
837         return result;
838 }
839
840 /** Open a LSA user handle
841  *
842  * @param cli Handle on an initialised SMB connection */
843
844 NTSTATUS cli_lsa_open_account(struct cli_state *cli, TALLOC_CTX *mem_ctx,
845                              POLICY_HND *dom_pol, DOM_SID *sid, uint32 des_access, 
846                              POLICY_HND *user_pol)
847 {
848         prs_struct qbuf, rbuf;
849         LSA_Q_OPENACCOUNT q;
850         LSA_R_OPENACCOUNT r;
851         NTSTATUS result;
852
853         ZERO_STRUCT(q);
854         ZERO_STRUCT(r);
855
856         /* Initialise parse structures */
857
858         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
859         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
860
861         /* Initialise input parameters */
862
863         init_lsa_q_open_account(&q, dom_pol, sid, des_access);
864
865         /* Marshall data and send request */
866
867         if (!lsa_io_q_open_account("", &q, &qbuf, 0) ||
868             !rpc_api_pipe_req(cli, LSA_OPENACCOUNT, &qbuf, &rbuf)) {
869                 result = NT_STATUS_UNSUCCESSFUL;
870                 goto done;
871         }
872
873         /* Unmarshall response */
874
875         if (!lsa_io_r_open_account("", &r, &rbuf, 0)) {
876                 result = NT_STATUS_UNSUCCESSFUL;
877                 goto done;
878         }
879
880         /* Return output parameters */
881
882         if (NT_STATUS_IS_OK(result = r.status)) {
883                 *user_pol = r.pol;
884         }
885
886  done:
887         prs_mem_free(&qbuf);
888         prs_mem_free(&rbuf);
889
890         return result;
891 }
892
893 /** Enumerate user privileges
894  *
895  * @param cli Handle on an initialised SMB connection */
896
897 NTSTATUS cli_lsa_enum_privsaccount(struct cli_state *cli, TALLOC_CTX *mem_ctx,
898                              POLICY_HND *pol, uint32 *count, LUID_ATTR **set)
899 {
900         prs_struct qbuf, rbuf;
901         LSA_Q_ENUMPRIVSACCOUNT q;
902         LSA_R_ENUMPRIVSACCOUNT r;
903         NTSTATUS result;
904         int i;
905
906         ZERO_STRUCT(q);
907         ZERO_STRUCT(r);
908
909         /* Initialise parse structures */
910
911         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
912         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
913
914         /* Initialise input parameters */
915
916         init_lsa_q_enum_privsaccount(&q, pol);
917
918         /* Marshall data and send request */
919
920         if (!lsa_io_q_enum_privsaccount("", &q, &qbuf, 0) ||
921             !rpc_api_pipe_req(cli, LSA_ENUMPRIVSACCOUNT, &qbuf, &rbuf)) {
922                 result = NT_STATUS_UNSUCCESSFUL;
923                 goto done;
924         }
925
926         /* Unmarshall response */
927
928         if (!lsa_io_r_enum_privsaccount("", &r, &rbuf, 0)) {
929                 result = NT_STATUS_UNSUCCESSFUL;
930                 goto done;
931         }
932
933         /* Return output parameters */
934
935         if (!NT_STATUS_IS_OK(result = r.status)) {
936                 goto done;
937         }
938
939         if (r.count == 0)
940                 goto done;
941
942         if (!((*set = (LUID_ATTR *)talloc(mem_ctx, sizeof(LUID_ATTR) * r.count)))) {
943                 DEBUG(0, ("(cli_lsa_enum_privsaccount): out of memory\n"));
944                 result = NT_STATUS_UNSUCCESSFUL;
945                 goto done;
946         }
947
948         for (i=0; i<r.count; i++) {
949                 (*set)[i].luid.low = r.set.set[i].luid.low;
950                 (*set)[i].luid.high = r.set.set[i].luid.high;
951                 (*set)[i].attr = r.set.set[i].attr;
952         }
953
954         *count=r.count;
955  done:
956         prs_mem_free(&qbuf);
957         prs_mem_free(&rbuf);
958
959         return result;
960 }
961
962 /** Get a privilege value given its name */
963
964 NTSTATUS cli_lsa_lookupprivvalue(struct cli_state *cli, TALLOC_CTX *mem_ctx,
965                               POLICY_HND *pol, char *name, LUID *luid)
966 {
967         prs_struct qbuf, rbuf;
968         LSA_Q_LOOKUPPRIVVALUE q;
969         LSA_R_LOOKUPPRIVVALUE r;
970         NTSTATUS result;
971
972         ZERO_STRUCT(q);
973         ZERO_STRUCT(r);
974
975         /* Initialise parse structures */
976
977         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
978         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
979
980         /* Marshall data and send request */
981
982         init_lsa_q_lookupprivvalue(&q, pol, name);
983
984         if (!lsa_io_q_lookupprivvalue("", &q, &qbuf, 0) ||
985             !rpc_api_pipe_req(cli, LSA_LOOKUPPRIVVALUE, &qbuf, &rbuf)) {
986                 result = NT_STATUS_UNSUCCESSFUL;
987                 goto done;
988         }
989
990         /* Unmarshall response */
991
992         if (!lsa_io_r_lookupprivvalue("", &r, &rbuf, 0)) {
993                 result = NT_STATUS_UNSUCCESSFUL;
994                 goto done;
995         }
996
997         if (!NT_STATUS_IS_OK(result = r.status)) {
998                 goto done;
999         }
1000
1001         /* Return output parameters */
1002
1003         (*luid).low=r.luid.low;
1004         (*luid).high=r.luid.high;
1005
1006  done:
1007         prs_mem_free(&qbuf);
1008         prs_mem_free(&rbuf);
1009
1010         return result;
1011 }
1012
1013 /** Query LSA security object */
1014
1015 NTSTATUS cli_lsa_query_secobj(struct cli_state *cli, TALLOC_CTX *mem_ctx,
1016                               POLICY_HND *pol, uint32 sec_info, 
1017                               SEC_DESC_BUF **psdb)
1018 {
1019         prs_struct qbuf, rbuf;
1020         LSA_Q_QUERY_SEC_OBJ q;
1021         LSA_R_QUERY_SEC_OBJ r;
1022         NTSTATUS result;
1023
1024         ZERO_STRUCT(q);
1025         ZERO_STRUCT(r);
1026
1027         /* Initialise parse structures */
1028
1029         prs_init(&qbuf, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL);
1030         prs_init(&rbuf, 0, mem_ctx, UNMARSHALL);
1031
1032         /* Marshall data and send request */
1033
1034         init_q_query_sec_obj(&q, pol, sec_info);
1035
1036         if (!lsa_io_q_query_sec_obj("", &q, &qbuf, 0) ||
1037             !rpc_api_pipe_req(cli, LSA_QUERYSECOBJ, &qbuf, &rbuf)) {
1038                 result = NT_STATUS_UNSUCCESSFUL;
1039                 goto done;
1040         }
1041
1042         /* Unmarshall response */
1043
1044         if (!lsa_io_r_query_sec_obj("", &r, &rbuf, 0)) {
1045                 result = NT_STATUS_UNSUCCESSFUL;
1046                 goto done;
1047         }
1048
1049         if (!NT_STATUS_IS_OK(result = r.status)) {
1050                 goto done;
1051         }
1052
1053         /* Return output parameters */
1054
1055         if (psdb)
1056                 *psdb = r.buf;
1057
1058  done:
1059         prs_mem_free(&qbuf);
1060         prs_mem_free(&rbuf);
1061
1062         return result;
1063 }
1064
1065 #if 0
1066
1067 /** An example of how to use the routines in this file.  Fetch a DOMAIN
1068     sid. Does complete cli setup / teardown anonymously. */
1069
1070 BOOL fetch_domain_sid( char *domain, char *remote_machine, DOM_SID *psid)
1071 {
1072         extern pstring global_myname;
1073         struct cli_state cli;
1074         NTSTATUS result;
1075         POLICY_HND lsa_pol;
1076         BOOL ret = False;
1077  
1078         ZERO_STRUCT(cli);
1079         if(cli_initialise(&cli) == False) {
1080                 DEBUG(0,("fetch_domain_sid: unable to initialize client connection.\n"));
1081                 return False;
1082         }
1083  
1084         if(!resolve_name( remote_machine, &cli.dest_ip, 0x20)) {
1085                 DEBUG(0,("fetch_domain_sid: Can't resolve address for %s\n", remote_machine));
1086                 goto done;
1087         }
1088  
1089         if (!cli_connect(&cli, remote_machine, &cli.dest_ip)) {
1090                 DEBUG(0,("fetch_domain_sid: unable to connect to SMB server on \
1091 machine %s. Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1092                 goto done;
1093         }
1094
1095         if (!attempt_netbios_session_request(&cli, global_myname, remote_machine, &cli.dest_ip)) {
1096                 DEBUG(0,("fetch_domain_sid: machine %s rejected the NetBIOS session request.\n", 
1097                         remote_machine));
1098                 goto done;
1099         }
1100  
1101         cli.protocol = PROTOCOL_NT1;
1102  
1103         if (!cli_negprot(&cli)) {
1104                 DEBUG(0,("fetch_domain_sid: machine %s rejected the negotiate protocol. \
1105 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1106                 goto done;
1107         }
1108  
1109         if (cli.protocol != PROTOCOL_NT1) {
1110                 DEBUG(0,("fetch_domain_sid: machine %s didn't negotiate NT protocol.\n",
1111                         remote_machine));
1112                 goto done;
1113         }
1114  
1115         /*
1116          * Do an anonymous session setup.
1117          */
1118  
1119         if (!cli_session_setup(&cli, "", "", 0, "", 0, "")) {
1120                 DEBUG(0,("fetch_domain_sid: machine %s rejected the session setup. \
1121 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1122                 goto done;
1123         }
1124  
1125         if (!(cli.sec_mode & 1)) {
1126                 DEBUG(0,("fetch_domain_sid: machine %s isn't in user level security mode\n",
1127                         remote_machine));
1128                 goto done;
1129         }
1130
1131         if (!cli_send_tconX(&cli, "IPC$", "IPC", "", 1)) {
1132                 DEBUG(0,("fetch_domain_sid: machine %s rejected the tconX on the IPC$ share. \
1133 Error was : %s.\n", remote_machine, cli_errstr(&cli) ));
1134                 goto done;
1135         }
1136
1137         /* Fetch domain sid */
1138  
1139         if (!cli_nt_session_open(&cli, PIPE_LSARPC)) {
1140                 DEBUG(0, ("fetch_domain_sid: Error connecting to SAM pipe\n"));
1141                 goto done;
1142         }
1143  
1144         result = cli_lsa_open_policy(&cli, cli.mem_ctx, True, SEC_RIGHTS_QUERY_VALUE, &lsa_pol);
1145         if (!NT_STATUS_IS_OK(result)) {
1146                 DEBUG(0, ("fetch_domain_sid: Error opening lsa policy handle. %s\n",
1147                         nt_errstr(result) ));
1148                 goto done;
1149         }
1150  
1151         result = cli_lsa_query_info_policy(&cli, cli.mem_ctx, &lsa_pol, 5, domain, psid);
1152         if (!NT_STATUS_IS_OK(result)) {
1153                 DEBUG(0, ("fetch_domain_sid: Error querying lsa policy handle. %s\n",
1154                         nt_errstr(result) ));
1155                 goto done;
1156         }
1157  
1158         ret = True;
1159
1160   done:
1161
1162         cli_shutdown(&cli);
1163         return ret;
1164 }
1165
1166 #endif
1167
1168 /** @} **/