66192bdf54f9ec8c8c51c121518731fb7e0aea33
[samba.git] / source3 / rpc_client / 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) Rafal Szczesniak                       2002
7    Copyright (C) Jeremy Allison                         2005.
8    Copyright (C) Michael Adam                           2007.
9    Copyright (C) Guenther Deschner                      2008.
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 3 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, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "includes.h"
26 #include "rpc_client/rpc_client.h"
27 #include "../librpc/gen_ndr/ndr_lsa_c.h"
28 #include "rpc_client/cli_lsarpc.h"
29 #include "rpc_client/init_lsa.h"
30 #include "../libcli/security/security.h"
31
32 /** @defgroup lsa LSA - Local Security Architecture
33  *  @ingroup rpc_client
34  *
35  * @{
36  **/
37
38 /**
39  * @file cli_lsarpc.c
40  *
41  * RPC client routines for the LSA RPC pipe.  LSA means "local
42  * security authority", which is half of a password database.
43  **/
44
45 NTSTATUS dcerpc_lsa_open_policy(struct dcerpc_binding_handle *h,
46                                 TALLOC_CTX *mem_ctx,
47                                 bool sec_qos,
48                                 uint32_t des_access,
49                                 struct policy_handle *pol,
50                                 NTSTATUS *result)
51 {
52         struct lsa_ObjectAttribute attr;
53         struct lsa_QosInfo qos;
54         uint16_t system_name = '\\';
55
56         ZERO_STRUCT(attr);
57
58         attr.len        = 0x18;
59
60         if (sec_qos) {
61                 qos.len                 = 0xc;
62                 qos.impersonation_level = 2;
63                 qos.context_mode        = 1;
64                 qos.effective_only      = 0;
65
66                 attr.sec_qos            = &qos;
67         }
68
69         return dcerpc_lsa_OpenPolicy(h,
70                                      mem_ctx,
71                                      &system_name,
72                                      &attr,
73                                      des_access,
74                                      pol,
75                                      result);
76 }
77
78 /** Open a LSA policy handle
79  *
80  * @param cli Handle on an initialised SMB connection */
81
82 NTSTATUS rpccli_lsa_open_policy(struct rpc_pipe_client *cli,
83                                 TALLOC_CTX *mem_ctx,
84                                 bool sec_qos, uint32 des_access,
85                                 struct policy_handle *pol)
86 {
87         NTSTATUS status;
88         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
89
90         status = dcerpc_lsa_open_policy(cli->binding_handle,
91                                         mem_ctx,
92                                         sec_qos,
93                                         des_access,
94                                         pol,
95                                         &result);
96         if (!NT_STATUS_IS_OK(status)) {
97                 return status;
98         }
99
100         return result;
101 }
102
103 NTSTATUS dcerpc_lsa_open_policy2(struct dcerpc_binding_handle *h,
104                                  TALLOC_CTX *mem_ctx,
105                                  const char *srv_name_slash,
106                                  bool sec_qos,
107                                  uint32_t des_access,
108                                  struct policy_handle *pol,
109                                  NTSTATUS *result)
110 {
111         struct lsa_ObjectAttribute attr;
112         struct lsa_QosInfo qos;
113
114         ZERO_STRUCT(attr);
115
116         attr.len        = 0x18;
117
118         if (sec_qos) {
119                 qos.len                 = 0xc;
120                 qos.impersonation_level = 2;
121                 qos.context_mode        = 1;
122                 qos.effective_only      = 0;
123
124                 attr.sec_qos            = &qos;
125         }
126
127         return dcerpc_lsa_OpenPolicy2(h,
128                                       mem_ctx,
129                                       srv_name_slash,
130                                       &attr,
131                                       des_access,
132                                       pol,
133                                       result);
134 }
135
136 /** Open a LSA policy handle
137   *
138   * @param cli Handle on an initialised SMB connection
139   */
140
141 NTSTATUS rpccli_lsa_open_policy2(struct rpc_pipe_client *cli,
142                                  TALLOC_CTX *mem_ctx, bool sec_qos,
143                                  uint32 des_access, struct policy_handle *pol)
144 {
145         NTSTATUS status;
146         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
147
148         status = dcerpc_lsa_open_policy2(cli->binding_handle,
149                                          mem_ctx,
150                                          cli->srv_name_slash,
151                                          sec_qos,
152                                          des_access,
153                                          pol,
154                                          &result);
155         if (!NT_STATUS_IS_OK(status)) {
156                 return status;
157         }
158
159         return result;
160 }
161
162 /* Lookup a list of sids
163  *
164  * internal version withOUT memory allocation of the target arrays.
165  * this assumes sufficiently sized arrays to store domains, names and types. */
166
167 static NTSTATUS dcerpc_lsa_lookup_sids_noalloc(struct dcerpc_binding_handle *h,
168                                                TALLOC_CTX *mem_ctx,
169                                                struct policy_handle *pol,
170                                                int num_sids,
171                                                const struct dom_sid *sids,
172                                                char **domains,
173                                                char **names,
174                                                enum lsa_SidType *types,
175                                                bool use_lookupsids3,
176                                                NTSTATUS *presult)
177 {
178         NTSTATUS status = NT_STATUS_OK;
179         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
180         struct lsa_SidArray sid_array;
181         struct lsa_RefDomainList *ref_domains = NULL;
182         struct lsa_TransNameArray lsa_names;
183         enum lsa_LookupNamesLevel level = LSA_LOOKUP_NAMES_ALL;
184         uint32_t count = 0;
185         int i;
186
187         ZERO_STRUCT(lsa_names);
188
189         sid_array.num_sids = num_sids;
190         sid_array.sids = talloc_array(mem_ctx, struct lsa_SidPtr, num_sids);
191         if (sid_array.sids == NULL) {
192                 return NT_STATUS_NO_MEMORY;
193         }
194
195         for (i = 0; i<num_sids; i++) {
196                 sid_array.sids[i].sid = dom_sid_dup(mem_ctx, &sids[i]);
197                 if (!sid_array.sids[i].sid) {
198                         return NT_STATUS_NO_MEMORY;
199                 }
200         }
201
202         if (use_lookupsids3) {
203                 struct lsa_TransNameArray2 lsa_names2;
204                 uint32_t n;
205
206                 ZERO_STRUCT(lsa_names2);
207
208                 status = dcerpc_lsa_LookupSids3(h,
209                                                 mem_ctx,
210                                                 &sid_array,
211                                                 &ref_domains,
212                                                 &lsa_names2,
213                                                 level,
214                                                 &count,
215                                                 LSA_LOOKUP_OPTION_SEARCH_ISOLATED_NAMES,
216                                                 LSA_CLIENT_REVISION_2,
217                                                 &result);
218                 if (!NT_STATUS_IS_OK(status)) {
219                         return status;
220                 }
221
222                 if(!NT_STATUS_IS_ERR(result)) {
223                         lsa_names.count = lsa_names2.count;
224                         lsa_names.names = talloc_array(mem_ctx,
225                                                        struct lsa_TranslatedName,
226                                                        lsa_names.count);
227                         if (lsa_names.names == NULL) {
228                                 return NT_STATUS_NO_MEMORY;
229                         }
230                         for (n=0; n < lsa_names.count; n++) {
231                                 lsa_names.names[n].sid_type     = lsa_names2.names[n].sid_type;
232                                 lsa_names.names[n].name         = lsa_names2.names[n].name;
233                                 lsa_names.names[n].sid_index    = lsa_names2.names[n].sid_index;
234                         }
235                 }
236
237         } else {
238                 status = dcerpc_lsa_LookupSids(h,
239                                                mem_ctx,
240                                                pol,
241                                                &sid_array,
242                                                &ref_domains,
243                                                &lsa_names,
244                                                level,
245                                                &count,
246                                                &result);
247         }
248
249         DEBUG(10, ("LSA_LOOKUPSIDS returned status: '%s', result: '%s', "
250                    "mapped count = %d'\n",
251                    nt_errstr(status), nt_errstr(result), count));
252
253         if (!NT_STATUS_IS_OK(status)) {
254                 return status;
255         }
256
257         if (!NT_STATUS_IS_OK(result) &&
258             !NT_STATUS_EQUAL(result, NT_STATUS_NONE_MAPPED) &&
259             !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
260         {
261                 *presult = result;
262                 return status;
263         }
264
265         /* Return output parameters */
266         if (NT_STATUS_EQUAL(result, NT_STATUS_NONE_MAPPED) ||
267             (count == 0))
268         {
269                 for (i = 0; i < num_sids; i++) {
270                         (names)[i] = NULL;
271                         (domains)[i] = NULL;
272                         (types)[i] = SID_NAME_UNKNOWN;
273                 }
274                 *presult = NT_STATUS_NONE_MAPPED;
275                 return status;
276         }
277
278         for (i = 0; i < num_sids; i++) {
279                 const char *name, *dom_name;
280                 uint32_t dom_idx = lsa_names.names[i].sid_index;
281
282                 /* Translate optimised name through domain index array */
283
284                 if (dom_idx != 0xffffffff) {
285
286                         dom_name = ref_domains->domains[dom_idx].name.string;
287                         name = lsa_names.names[i].name.string;
288
289                         if (name) {
290                                 (names)[i] = talloc_strdup(names, name);
291                                 if ((names)[i] == NULL) {
292                                         DEBUG(0, ("cli_lsa_lookup_sids_noalloc(): out of memory\n"));
293                                         *presult = NT_STATUS_UNSUCCESSFUL;
294                                         return status;
295                                 }
296                         } else {
297                                 (names)[i] = NULL;
298                         }
299                         domains[i] = talloc_strdup(domains,
300                                                    dom_name ? dom_name : "");
301                         (types)[i] = lsa_names.names[i].sid_type;
302                         if (((domains)[i] == NULL)) {
303                                 DEBUG(0, ("cli_lsa_lookup_sids_noalloc(): out of memory\n"));
304                                 *presult = NT_STATUS_UNSUCCESSFUL;
305                                 return status;
306                         }
307
308                 } else {
309                         (names)[i] = NULL;
310                         (domains)[i] = NULL;
311                         (types)[i] = SID_NAME_UNKNOWN;
312                 }
313         }
314
315         *presult = NT_STATUS_OK;
316         return status;
317 }
318
319 /* Lookup a list of sids
320  *
321  * do it the right way: there is a limit (of 20480 for w2k3) entries
322  * returned by this call. when the sids list contains more entries,
323  * empty lists are returned. This version of lsa_lookup_sids passes
324  * the list of sids in hunks of LOOKUP_SIDS_HUNK_SIZE to the lsa call. */
325
326 /* This constant defines the limit of how many sids to look up
327  * in one call (maximum). the limit from the server side is
328  * at 20480 for win2k3, but we keep it at a save 1000 for now. */
329 #define LOOKUP_SIDS_HUNK_SIZE 1000
330
331 static NTSTATUS dcerpc_lsa_lookup_sids_generic(struct dcerpc_binding_handle *h,
332                                                TALLOC_CTX *mem_ctx,
333                                                struct policy_handle *pol,
334                                                int num_sids,
335                                                const struct dom_sid *sids,
336                                                char ***pdomains,
337                                                char ***pnames,
338                                                enum lsa_SidType **ptypes,
339                                                bool use_lookupsids3,
340                                                NTSTATUS *presult)
341 {
342         NTSTATUS status = NT_STATUS_OK;
343         NTSTATUS result = NT_STATUS_OK;
344         int sids_left = 0;
345         int sids_processed = 0;
346         const struct dom_sid *hunk_sids = sids;
347         char **hunk_domains;
348         char **hunk_names;
349         enum lsa_SidType *hunk_types;
350         char **domains = NULL;
351         char **names = NULL;
352         enum lsa_SidType *types = NULL;
353         bool have_mapped = false;
354         bool have_unmapped = false;
355
356         if (num_sids) {
357                 if (!(domains = talloc_array(mem_ctx, char *, num_sids))) {
358                         DEBUG(0, ("rpccli_lsa_lookup_sids(): out of memory\n"));
359                         status = NT_STATUS_NO_MEMORY;
360                         goto fail;
361                 }
362
363                 if (!(names = talloc_array(mem_ctx, char *, num_sids))) {
364                         DEBUG(0, ("rpccli_lsa_lookup_sids(): out of memory\n"));
365                         status = NT_STATUS_NO_MEMORY;
366                         goto fail;
367                 }
368
369                 if (!(types = talloc_array(mem_ctx, enum lsa_SidType, num_sids))) {
370                         DEBUG(0, ("rpccli_lsa_lookup_sids(): out of memory\n"));
371                         status = NT_STATUS_NO_MEMORY;
372                         goto fail;
373                 }
374         }
375
376         sids_left = num_sids;
377         hunk_domains = domains;
378         hunk_names = names;
379         hunk_types = types;
380
381         while (sids_left > 0) {
382                 int hunk_num_sids;
383                 NTSTATUS hunk_result = NT_STATUS_UNSUCCESSFUL;
384
385                 hunk_num_sids = ((sids_left > LOOKUP_SIDS_HUNK_SIZE)
386                                 ? LOOKUP_SIDS_HUNK_SIZE
387                                 : sids_left);
388
389                 DEBUG(10, ("rpccli_lsa_lookup_sids: processing items "
390                            "%d -- %d of %d.\n",
391                            sids_processed,
392                            sids_processed + hunk_num_sids - 1,
393                            num_sids));
394
395                 status = dcerpc_lsa_lookup_sids_noalloc(h,
396                                                         mem_ctx,
397                                                         pol,
398                                                         hunk_num_sids,
399                                                         hunk_sids,
400                                                         hunk_domains,
401                                                         hunk_names,
402                                                         hunk_types,
403                                                         use_lookupsids3,
404                                                         &hunk_result);
405                 if (!NT_STATUS_IS_OK(status)) {
406                         goto fail;
407                 }
408
409                 if (!NT_STATUS_IS_OK(hunk_result) &&
410                     !NT_STATUS_EQUAL(hunk_result, STATUS_SOME_UNMAPPED) &&
411                     !NT_STATUS_EQUAL(hunk_result, NT_STATUS_NONE_MAPPED))
412                 {
413                         /* An actual error occured */
414                         *presult = hunk_result;
415                         goto fail;
416                 }
417
418                 if (NT_STATUS_IS_OK(hunk_result)) {
419                         have_mapped = true;
420                 }
421                 if (NT_STATUS_EQUAL(hunk_result, NT_STATUS_NONE_MAPPED)) {
422                         have_unmapped = true;
423                 }
424                 if (NT_STATUS_EQUAL(hunk_result, STATUS_SOME_UNMAPPED)) {
425                         int i;
426                         for (i=0; i<hunk_num_sids; i++) {
427                                 if (hunk_types[i] == SID_NAME_UNKNOWN) {
428                                         have_unmapped = true;
429                                 } else {
430                                         have_mapped = true;
431                                 }
432                         }
433                 }
434
435                 sids_left -= hunk_num_sids;
436                 sids_processed += hunk_num_sids; /* only used in DEBUG */
437                 hunk_sids += hunk_num_sids;
438                 hunk_domains += hunk_num_sids;
439                 hunk_names += hunk_num_sids;
440                 hunk_types += hunk_num_sids;
441         }
442
443         *pdomains = domains;
444         *pnames = names;
445         *ptypes = types;
446
447         if (!have_mapped) {
448                 result = NT_STATUS_NONE_MAPPED;
449         }
450         if (have_unmapped) {
451                 result = STATUS_SOME_UNMAPPED;
452         }
453         *presult = result;
454
455         return status;
456
457 fail:
458         TALLOC_FREE(domains);
459         TALLOC_FREE(names);
460         TALLOC_FREE(types);
461
462         return status;
463 }
464
465 NTSTATUS dcerpc_lsa_lookup_sids(struct dcerpc_binding_handle *h,
466                                 TALLOC_CTX *mem_ctx,
467                                 struct policy_handle *pol,
468                                 int num_sids,
469                                 const struct dom_sid *sids,
470                                 char ***pdomains,
471                                 char ***pnames,
472                                 enum lsa_SidType **ptypes,
473                                 NTSTATUS *result)
474 {
475         return dcerpc_lsa_lookup_sids_generic(h,
476                                               mem_ctx,
477                                               pol,
478                                               num_sids,
479                                               sids,
480                                               pdomains,
481                                               pnames,
482                                               ptypes,
483                                               false,
484                                               result);
485 }
486
487 NTSTATUS rpccli_lsa_lookup_sids(struct rpc_pipe_client *cli,
488                                 TALLOC_CTX *mem_ctx,
489                                 struct policy_handle *pol,
490                                 int num_sids,
491                                 const struct dom_sid *sids,
492                                 char ***pdomains,
493                                 char ***pnames,
494                                 enum lsa_SidType **ptypes)
495 {
496         NTSTATUS status;
497         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
498
499         status = dcerpc_lsa_lookup_sids_generic(cli->binding_handle,
500                                                 mem_ctx,
501                                                 pol,
502                                                 num_sids,
503                                                 sids,
504                                                 pdomains,
505                                                 pnames,
506                                                 ptypes,
507                                                 false,
508                                                 &result);
509         if (!NT_STATUS_IS_OK(status)) {
510                 return status;
511         }
512
513         return result;
514 }
515
516 NTSTATUS dcerpc_lsa_lookup_sids3(struct dcerpc_binding_handle *h,
517                                  TALLOC_CTX *mem_ctx,
518                                  struct policy_handle *pol,
519                                  int num_sids,
520                                  const struct dom_sid *sids,
521                                  char ***pdomains,
522                                  char ***pnames,
523                                  enum lsa_SidType **ptypes,
524                                  NTSTATUS *result)
525 {
526         return dcerpc_lsa_lookup_sids_generic(h,
527                                               mem_ctx,
528                                               pol,
529                                               num_sids,
530                                               sids,
531                                               pdomains,
532                                               pnames,
533                                               ptypes,
534                                               true,
535                                               result);
536 }
537
538 NTSTATUS rpccli_lsa_lookup_sids3(struct rpc_pipe_client *cli,
539                                  TALLOC_CTX *mem_ctx,
540                                  struct policy_handle *pol,
541                                  int num_sids,
542                                  const struct dom_sid *sids,
543                                  char ***pdomains,
544                                  char ***pnames,
545                                  enum lsa_SidType **ptypes)
546 {
547         NTSTATUS status;
548         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
549
550         status = dcerpc_lsa_lookup_sids_generic(cli->binding_handle,
551                                                 mem_ctx,
552                                                 pol,
553                                                 num_sids,
554                                                 sids,
555                                                 pdomains,
556                                                 pnames,
557                                                 ptypes,
558                                                 true,
559                                                 &result);
560         if (!NT_STATUS_IS_OK(status)) {
561                 return status;
562         }
563
564         return result;
565 }
566
567 /** Lookup a list of names */
568
569 static NTSTATUS dcerpc_lsa_lookup_names_generic(struct dcerpc_binding_handle *h,
570                                                 TALLOC_CTX *mem_ctx,
571                                                 struct policy_handle *pol,
572                                                 uint32_t num_names,
573                                                 const char **names,
574                                                 const char ***dom_names,
575                                                 enum lsa_LookupNamesLevel level,
576                                                 struct dom_sid **sids,
577                                                 enum lsa_SidType **types,
578                                                 bool use_lookupnames4,
579                                                 NTSTATUS *presult)
580 {
581         NTSTATUS status;
582         struct lsa_String *lsa_names = NULL;
583         struct lsa_RefDomainList *domains = NULL;
584         struct lsa_TransSidArray sid_array;
585         struct lsa_TransSidArray3 sid_array3;
586         uint32_t count = 0;
587         uint32_t i;
588
589         ZERO_STRUCT(sid_array);
590         ZERO_STRUCT(sid_array3);
591
592         lsa_names = talloc_array(mem_ctx, struct lsa_String, num_names);
593         if (lsa_names == NULL) {
594                 return NT_STATUS_NO_MEMORY;
595         }
596
597         for (i = 0; i < num_names; i++) {
598                 init_lsa_String(&lsa_names[i], names[i]);
599         }
600
601         if (use_lookupnames4) {
602                 status = dcerpc_lsa_LookupNames4(h,
603                                                  mem_ctx,
604                                                  num_names,
605                                                  lsa_names,
606                                                  &domains,
607                                                  &sid_array3,
608                                                  level,
609                                                  &count,
610                                                  LSA_LOOKUP_OPTION_SEARCH_ISOLATED_NAMES,
611                                                  LSA_CLIENT_REVISION_2,
612                                                  presult);
613         } else {
614                 status = dcerpc_lsa_LookupNames(h,
615                                                 mem_ctx,
616                                                 pol,
617                                                 num_names,
618                                                 lsa_names,
619                                                 &domains,
620                                                 &sid_array,
621                                                 level,
622                                                 &count,
623                                                 presult);
624         }
625         if (!NT_STATUS_IS_OK(status)) {
626                 goto done;
627         }
628
629         if (!NT_STATUS_IS_OK(*presult) &&
630             !NT_STATUS_EQUAL(*presult, STATUS_SOME_UNMAPPED)) {
631                 /* An actual error occured */
632                 goto done;
633         }
634
635         /* Return output parameters */
636         if (count == 0) {
637                 *presult = NT_STATUS_NONE_MAPPED;
638                 goto done;
639         }
640
641         if (num_names) {
642                 if (!((*sids = talloc_array(mem_ctx, struct dom_sid, num_names)))) {
643                         DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
644                         *presult = NT_STATUS_NO_MEMORY;
645                         goto done;
646                 }
647
648                 if (!((*types = talloc_array(mem_ctx, enum lsa_SidType, num_names)))) {
649                         DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
650                         *presult = NT_STATUS_NO_MEMORY;
651                         goto done;
652                 }
653
654                 if (dom_names != NULL) {
655                         *dom_names = talloc_array(mem_ctx, const char *, num_names);
656                         if (*dom_names == NULL) {
657                                 DEBUG(0, ("cli_lsa_lookup_sids(): out of memory\n"));
658                                 *presult = NT_STATUS_NO_MEMORY;
659                                 goto done;
660                         }
661                 }
662         } else {
663                 *sids = NULL;
664                 *types = NULL;
665                 if (dom_names != NULL) {
666                         *dom_names = NULL;
667                 }
668         }
669
670         for (i = 0; i < num_names; i++) {
671                 uint32_t dom_idx;
672                 struct dom_sid *sid = &(*sids)[i];
673
674                 if (use_lookupnames4) {
675                         dom_idx         = sid_array3.sids[i].sid_index;
676                         (*types)[i]     = sid_array3.sids[i].sid_type;
677                 } else {
678                         dom_idx         = sid_array.sids[i].sid_index;
679                         (*types)[i]     = sid_array.sids[i].sid_type;
680                 }
681
682                 /* Translate optimised sid through domain index array */
683
684                 if (dom_idx == 0xffffffff) {
685                         /* Nothing to do, this is unknown */
686                         ZERO_STRUCTP(sid);
687                         (*types)[i] = SID_NAME_UNKNOWN;
688                         continue;
689                 }
690
691                 if (use_lookupnames4) {
692                         sid_copy(sid, sid_array3.sids[i].sid);
693                 } else {
694                         sid_copy(sid, domains->domains[dom_idx].sid);
695
696                         if (sid_array.sids[i].rid != 0xffffffff) {
697                                 sid_append_rid(sid, sid_array.sids[i].rid);
698                         }
699                 }
700
701                 if (dom_names == NULL) {
702                         continue;
703                 }
704
705                 (*dom_names)[i] = domains->domains[dom_idx].name.string;
706         }
707
708  done:
709         return status;
710 }
711
712 NTSTATUS dcerpc_lsa_lookup_names(struct dcerpc_binding_handle *h,
713                                  TALLOC_CTX *mem_ctx,
714                                  struct policy_handle *pol,
715                                  uint32_t num_names,
716                                  const char **names,
717                                  const char ***dom_names,
718                                  enum lsa_LookupNamesLevel level,
719                                  struct dom_sid **sids,
720                                  enum lsa_SidType **types,
721                                  NTSTATUS *result)
722 {
723         return dcerpc_lsa_lookup_names_generic(h,
724                                                mem_ctx,
725                                                pol,
726                                                num_names,
727                                                names,
728                                                dom_names,
729                                                level,
730                                                sids,
731                                                types,
732                                                false,
733                                                result);
734 }
735
736 NTSTATUS rpccli_lsa_lookup_names(struct rpc_pipe_client *cli,
737                                  TALLOC_CTX *mem_ctx,
738                                  struct policy_handle *pol,
739                                  int num_names,
740                                  const char **names,
741                                  const char ***dom_names,
742                                  int level,
743                                  struct dom_sid **sids,
744                                  enum lsa_SidType **types)
745 {
746         NTSTATUS status;
747         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
748
749         status = dcerpc_lsa_lookup_names(cli->binding_handle,
750                                          mem_ctx,
751                                          pol,
752                                          num_names,
753                                          names,
754                                          dom_names,
755                                          level,
756                                          sids,
757                                          types,
758                                          &result);
759         if (!NT_STATUS_IS_OK(status)) {
760                 return status;
761         }
762
763         return result;
764 }
765
766 NTSTATUS dcerpc_lsa_lookup_names4(struct dcerpc_binding_handle *h,
767                                   TALLOC_CTX *mem_ctx,
768                                   struct policy_handle *pol,
769                                   uint32_t num_names,
770                                   const char **names,
771                                   const char ***dom_names,
772                                   enum lsa_LookupNamesLevel level,
773                                   struct dom_sid **sids,
774                                   enum lsa_SidType **types,
775                                   NTSTATUS *result)
776 {
777         return dcerpc_lsa_lookup_names_generic(h,
778                                                mem_ctx,
779                                                pol,
780                                                num_names,
781                                                names,
782                                                dom_names,
783                                                level,
784                                                sids,
785                                                types,
786                                                true,
787                                                result);
788 }
789
790 NTSTATUS rpccli_lsa_lookup_names4(struct rpc_pipe_client *cli,
791                                   TALLOC_CTX *mem_ctx,
792                                   struct policy_handle *pol,
793                                   int num_names,
794                                   const char **names,
795                                   const char ***dom_names,
796                                   int level,
797                                   struct dom_sid **sids,
798                                   enum lsa_SidType **types)
799 {
800         NTSTATUS status;
801         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
802
803         status = dcerpc_lsa_lookup_names4(cli->binding_handle,
804                                           mem_ctx,
805                                           pol,
806                                           num_names,
807                                           names,
808                                           dom_names,
809                                           level,
810                                           sids,
811                                           types,
812                                           &result);
813         if (!NT_STATUS_IS_OK(status)) {
814                 return status;
815         }
816
817         return result;
818 }