Register types rather than constructors, display structs as classes.
[jelmer/samba4-debian.git] / source / winbind / idmap.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    Map SIDs to unixids and back
5
6    Copyright (C) Kai Blin 2008
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "auth/auth.h"
24 #include "librpc/gen_ndr/lsa.h"
25 #include "librpc/gen_ndr/samr.h"
26 #include "librpc/gen_ndr/ndr_security.h"
27 #include "lib/ldb/include/ldb.h"
28 #include "lib/ldb/include/ldb_errors.h"
29 #include "lib/ldb_wrap.h"
30 #include "param/param.h"
31 #include "winbind/idmap.h"
32 #include "libcli/security/proto.h"
33 #include "libcli/ldap/ldap_ndr.h"
34
35 /**
36  * Get uid/gid bounds from idmap database
37  *
38  * \param idmap_ctx idmap context to use
39  * \param low lower uid/gid bound is stored here
40  * \param high upper uid/gid bound is stored here
41  * \return 0 on success, nonzero on failure
42  */
43 static int idmap_get_bounds(struct idmap_context *idmap_ctx, uint32_t *low,
44                 uint32_t *high)
45 {
46         int ret = -1;
47         struct ldb_context *ldb = idmap_ctx->ldb_ctx;
48         struct ldb_dn *dn;
49         struct ldb_result *res = NULL;
50         TALLOC_CTX *tmp_ctx = talloc_new(idmap_ctx);
51         uint32_t lower_bound = (uint32_t) -1;
52         uint32_t upper_bound = (uint32_t) -1;
53
54         dn = ldb_dn_new(tmp_ctx, ldb, "CN=CONFIG");
55         if (dn == NULL) goto failed;
56
57         ret = ldb_search(ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
58         if (ret != LDB_SUCCESS) goto failed;
59
60         talloc_steal(tmp_ctx, res);
61
62         if (res->count != 1) {
63                 ret = -1;
64                 goto failed;
65         }
66
67         lower_bound = ldb_msg_find_attr_as_uint(res->msgs[0], "lowerBound", -1);
68         if (lower_bound != (uint32_t) -1) {
69                 ret = LDB_SUCCESS;
70         } else {
71                 ret = -1;
72                 goto failed;
73         }
74
75         upper_bound = ldb_msg_find_attr_as_uint(res->msgs[0], "upperBound", -1);
76         if (upper_bound != (uint32_t) -1) {
77                 ret = LDB_SUCCESS;
78         } else {
79                 ret = -1;
80         }
81
82 failed:
83         talloc_free(tmp_ctx);
84         *low  = lower_bound;
85         *high = upper_bound;
86         return ret;
87 }
88
89 /**
90  * Add a dom_sid structure to a ldb_message
91  * \param idmap_ctx idmap context to use
92  * \param mem_ctx talloc context to use
93  * \param ldb_message ldb message to add dom_sid to
94  * \param attr_name name of the attribute to store the dom_sid in
95  * \param sid dom_sid to store
96  * \return 0 on success, an ldb error code on failure.
97  */
98 static int idmap_msg_add_dom_sid(struct idmap_context *idmap_ctx,
99                 TALLOC_CTX *mem_ctx, struct ldb_message *msg,
100                 const char *attr_name, const struct dom_sid *sid)
101 {
102         struct ldb_val val;
103         enum ndr_err_code ndr_err;
104
105         ndr_err = ndr_push_struct_blob(&val, mem_ctx,
106                                        lp_iconv_convenience(idmap_ctx->lp_ctx),
107                                        sid,
108                                        (ndr_push_flags_fn_t)ndr_push_dom_sid);
109
110         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
111                 return -1;
112         }
113
114         return ldb_msg_add_value(msg, attr_name, &val, NULL);
115 }
116
117 /**
118  * Get a dom_sid structure from a ldb message.
119  *
120  * \param mem_ctx talloc context to allocate dom_sid memory in
121  * \param msg ldb_message to get dom_sid from
122  * \param attr_name key that has the dom_sid as data
123  * \return dom_sid structure on success, NULL on failure
124  */
125 static struct dom_sid *idmap_msg_get_dom_sid(TALLOC_CTX *mem_ctx,
126                 struct ldb_message *msg, const char *attr_name)
127 {
128         struct dom_sid *sid;
129         const struct ldb_val *val;
130         enum ndr_err_code ndr_err;
131
132         val = ldb_msg_find_ldb_val(msg, attr_name);
133         if (val == NULL) {
134                 return NULL;
135         }
136
137         sid = talloc(mem_ctx, struct dom_sid);
138         if (sid == NULL) {
139                 return NULL;
140         }
141
142         ndr_err = ndr_pull_struct_blob(val, sid, NULL, sid,
143                                        (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
144         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
145                 talloc_free(sid);
146                 return NULL;
147         }
148
149         return sid;
150 }
151
152 /**
153  * Initialize idmap context
154  *
155  * talloc_free to close.
156  *
157  * \param mem_ctx talloc context to use.
158  * \return allocated idmap_context on success, NULL on error
159  */
160 struct idmap_context *idmap_init(TALLOC_CTX *mem_ctx,
161                 struct loadparm_context *lp_ctx)
162 {
163         struct idmap_context *idmap_ctx;
164
165         idmap_ctx = talloc(mem_ctx, struct idmap_context);
166         if (idmap_ctx == NULL) {
167                 return NULL;
168         }
169
170         idmap_ctx->lp_ctx = lp_ctx;
171
172         idmap_ctx->ldb_ctx = ldb_wrap_connect(mem_ctx, lp_ctx,
173                                               lp_idmap_url(lp_ctx),
174                                               system_session(mem_ctx, lp_ctx),
175                                               NULL, 0, NULL);
176         if (idmap_ctx->ldb_ctx == NULL) {
177                 return NULL;
178         }
179
180         idmap_ctx->unix_groups_sid = dom_sid_parse_talloc(mem_ctx, "S-1-22-2");
181         if (idmap_ctx->unix_groups_sid == NULL) {
182                 return NULL;
183         }
184
185         idmap_ctx->unix_users_sid = dom_sid_parse_talloc(mem_ctx, "S-1-22-1");
186         if (idmap_ctx->unix_users_sid == NULL) {
187                 return NULL;
188         }
189
190         return idmap_ctx;
191 }
192
193 /**
194  * Convert an unixid to the corresponding SID
195  *
196  * \param idmap_ctx idmap context to use
197  * \param mem_ctx talloc context the memory for the struct dom_sid is allocated
198  * from.
199  * \param unixid pointer to a unixid struct to convert
200  * \param sid pointer that will take the struct dom_sid pointer if the mapping
201  * succeeds.
202  * \return NT_STATUS_OK on success, NT_STATUS_NONE_MAPPED if mapping not
203  * possible or some other NTSTATUS that is more descriptive on failure.
204  */
205
206 NTSTATUS idmap_xid_to_sid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
207                 const struct unixid *unixid, struct dom_sid **sid)
208 {
209         int ret;
210         NTSTATUS status = NT_STATUS_NONE_MAPPED;
211         struct ldb_context *ldb = idmap_ctx->ldb_ctx;
212         struct ldb_result *res = NULL;
213         struct dom_sid *unix_sid, *new_sid;
214         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
215         const char *id_type;
216
217         switch (unixid->type) {
218                 case ID_TYPE_UID:
219                         id_type = "ID_TYPE_UID";
220                         break;
221                 case ID_TYPE_GID:
222                         id_type = "ID_TYPE_GID";
223                         break;
224                 default:
225                         DEBUG(1, ("unixid->type must be type gid or uid\n"));
226                         status = NT_STATUS_NONE_MAPPED;
227                         goto failed;
228         }
229
230         ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
231                                  NULL, "(&(|(type=ID_TYPE_BOTH)(type=%s))"
232                                  "(xidNumber=%u))", id_type, unixid->id);
233         if (ret != LDB_SUCCESS) {
234                 DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
235                 status = NT_STATUS_NONE_MAPPED;
236                 goto failed;
237         }
238
239         if (res->count == 1) {
240                 *sid = idmap_msg_get_dom_sid(mem_ctx, res->msgs[0],
241                                              "objectSid");
242                 if (*sid == NULL) {
243                         DEBUG(1, ("Failed to get sid from db: %u\n", ret));
244                         status = NT_STATUS_NONE_MAPPED;
245                         goto failed;
246                 }
247                 talloc_free(tmp_ctx);
248                 return NT_STATUS_OK;
249         }
250
251         DEBUG(6, ("xid not found in idmap db, create S-1-22- SID.\n"));
252
253         /* For local users/groups , we just create a rid = uid/gid */
254         if (unixid->type == ID_TYPE_UID) {
255                 unix_sid = dom_sid_parse_talloc(tmp_ctx, "S-1-22-1");
256         } else {
257                 unix_sid = dom_sid_parse_talloc(tmp_ctx, "S-1-22-2");
258         }
259         if (unix_sid == NULL) {
260                 status = NT_STATUS_NO_MEMORY;
261                 goto failed;
262         }
263
264         new_sid = dom_sid_add_rid(mem_ctx, unix_sid, unixid->id);
265         if (new_sid == NULL) {
266                 status = NT_STATUS_NO_MEMORY;
267                 goto failed;
268         }
269
270         *sid = new_sid;
271         talloc_free(tmp_ctx);
272         return NT_STATUS_OK;
273
274 failed:
275         talloc_free(tmp_ctx);
276         return status;
277 }
278
279
280 /**
281  * Map a SID to an unixid struct.
282  *
283  * If no mapping exists, a new mapping will be created.
284  *
285  * \todo Check if SIDs can be resolved if lp_idmap_trusted_only() == true
286  * \todo Fix backwards compatibility for Samba3
287  *
288  * \param idmap_ctx idmap context to use
289  * \param mem_ctx talloc context to use
290  * \param sid SID to map to an unixid struct
291  * \param unixid pointer to a unixid struct pointer
292  * \return NT_STATUS_OK on success, NT_STATUS_INVALID_SID if the sid is not from
293  * a trusted domain and idmap trusted only = true, NT_STATUS_NONE_MAPPED if the
294  * mapping failed.
295  */
296 NTSTATUS idmap_sid_to_xid(struct idmap_context *idmap_ctx, TALLOC_CTX *mem_ctx,
297                 const struct dom_sid *sid, struct unixid **unixid)
298 {
299         int ret;
300         NTSTATUS status = NT_STATUS_NONE_MAPPED;
301         struct ldb_context *ldb = idmap_ctx->ldb_ctx;
302         struct ldb_dn *dn;
303         struct ldb_message *hwm_msg, *map_msg;
304         struct ldb_result *res = NULL;
305         int trans;
306         uint32_t low, high, hwm, new_xid;
307         char *sid_string, *unixid_string, *hwm_string;
308         bool hwm_entry_exists;
309         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
310
311         if (dom_sid_in_domain(idmap_ctx->unix_users_sid, sid)) {
312                 uint32_t rid;
313                 DEBUG(6, ("This is a local unix uid, just calculate that.\n"));
314                 status = dom_sid_split_rid(tmp_ctx, sid, NULL, &rid);
315                 if (!NT_STATUS_IS_OK(status)) goto failed;
316
317                 *unixid = talloc(mem_ctx, struct unixid);
318                 if (*unixid == NULL) {
319                         status = NT_STATUS_NO_MEMORY;
320                         goto failed;
321                 }
322                 (*unixid)->id = rid;
323                 (*unixid)->type = ID_TYPE_UID;
324
325                 talloc_free(tmp_ctx);
326                 return NT_STATUS_OK;
327         }
328
329         if (dom_sid_in_domain(idmap_ctx->unix_groups_sid, sid)) {
330                 uint32_t rid;
331                 DEBUG(6, ("This is a local unix gid, just calculate that.\n"));
332                 status = dom_sid_split_rid(tmp_ctx, sid, NULL, &rid);
333                 if (!NT_STATUS_IS_OK(status)) goto failed;
334
335                 *unixid = talloc(mem_ctx, struct unixid);
336                 if (*unixid == NULL) {
337                         status = NT_STATUS_NO_MEMORY;
338                         goto failed;
339                 }
340                 (*unixid)->id = rid;
341                 (*unixid)->type = ID_TYPE_GID;
342
343                 talloc_free(tmp_ctx);
344                 return NT_STATUS_OK;
345          }
346
347         ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
348                                  NULL, "(&(objectClass=sidMap)(objectSid=%s))",
349                                  ldap_encode_ndr_dom_sid(tmp_ctx, sid));
350         if (ret != LDB_SUCCESS) {
351                 DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
352                 status = NT_STATUS_NONE_MAPPED;
353                 goto failed;
354         }
355
356         if (res->count == 1) {
357                 const char *type = ldb_msg_find_attr_as_string(res->msgs[0],
358                                                                "type", NULL);
359                 new_xid = ldb_msg_find_attr_as_uint(res->msgs[0], "xidNumber",
360                                                     -1);
361                 if (new_xid == (uint32_t) -1) {
362                         DEBUG(1, ("Invalid xid mapping.\n"));
363                         status = NT_STATUS_NONE_MAPPED;
364                         goto failed;
365                 }
366
367                 if (type == NULL) {
368                         DEBUG(1, ("Invalid type for mapping entry.\n"));
369                         status = NT_STATUS_NONE_MAPPED;
370                         goto failed;
371                 }
372
373                 *unixid = talloc(mem_ctx, struct unixid);
374                 if (*unixid == NULL) {
375                         status = NT_STATUS_NO_MEMORY;
376                         goto failed;
377                 }
378
379                 (*unixid)->id = new_xid;
380
381                 if (strcmp(type, "ID_TYPE_BOTH") == 0) {
382                         (*unixid)->type = ID_TYPE_BOTH;
383                 } else if (strcmp(type, "ID_TYPE_UID") == 0) {
384                         (*unixid)->type = ID_TYPE_UID;
385                 } else {
386                         (*unixid)->type = ID_TYPE_GID;
387                 }
388
389                 talloc_free(tmp_ctx);
390                 return NT_STATUS_OK;
391         }
392
393         DEBUG(6, ("No existing mapping found, attempting to create one.\n"));
394
395         trans = ldb_transaction_start(ldb);
396         if (trans != LDB_SUCCESS) {
397                 status = NT_STATUS_NONE_MAPPED;
398                 goto failed;
399         }
400
401         /* Redo the search to make sure noone changed the mapping while we
402          * weren't looking */
403         ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
404                                  NULL, "(&(objectClass=sidMap)(objectSid=%s))",
405                                  ldap_encode_ndr_dom_sid(tmp_ctx, sid));
406         if (ret != LDB_SUCCESS) {
407                 DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
408                 status = NT_STATUS_NONE_MAPPED;
409                 goto failed;
410         }
411
412         if (res->count > 0) {
413                 DEBUG(1, ("Database changed while trying to add a sidmap.\n"));
414                 status = NT_STATUS_RETRY;
415                 goto failed;
416         }
417
418         /*FIXME: if lp_idmap_trusted_only() == true, check if SID can be
419          * resolved here. */
420
421         ret = idmap_get_bounds(idmap_ctx, &low, &high);
422         if (ret != LDB_SUCCESS) {
423                 status = NT_STATUS_NONE_MAPPED;
424                 goto failed;
425         }
426
427         dn = ldb_dn_new(tmp_ctx, ldb, "CN=CONFIG");
428         if (dn == NULL) {
429                 status = NT_STATUS_NO_MEMORY;
430                 goto failed;
431         }
432
433         ret = ldb_search(ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
434         if (ret != LDB_SUCCESS) {
435                 DEBUG(1, ("Search failed: %s\n", ldb_errstring(ldb)));
436                 status = NT_STATUS_NONE_MAPPED;
437                 goto failed;
438         }
439
440         talloc_steal(tmp_ctx, res);
441
442         if (res->count != 1) {
443                 DEBUG(1, ("No CN=CONFIG record, idmap database is broken.\n"));
444                 status = NT_STATUS_NONE_MAPPED;
445                 goto failed;
446         }
447
448         hwm = ldb_msg_find_attr_as_uint(res->msgs[0], "xidNumber", -1);
449         if (hwm == (uint32_t)-1) {
450                 hwm = low;
451                 hwm_entry_exists = false;
452         } else {
453                 hwm_entry_exists = true;
454         }
455
456         if (hwm > high) {
457                 DEBUG(1, ("Out of xids to allocate.\n"));
458                 status = NT_STATUS_NONE_MAPPED;
459                 goto failed;
460         }
461
462         hwm_msg = ldb_msg_new(tmp_ctx);
463         if (hwm_msg == NULL) {
464                 DEBUG(1, ("Out of memory when creating ldb_message\n"));
465                 status = NT_STATUS_NO_MEMORY;
466                 goto failed;
467         }
468
469         hwm_msg->dn = dn;
470
471         new_xid = hwm;
472         hwm++;
473
474         hwm_string = talloc_asprintf(tmp_ctx, "%u", hwm);
475         if (hwm_string == NULL) {
476                 status = NT_STATUS_NO_MEMORY;
477                 goto failed;
478         }
479
480         sid_string = dom_sid_string(tmp_ctx, sid);
481         if (sid_string == NULL) {
482                 status = NT_STATUS_NO_MEMORY;
483                 goto failed;
484         }
485
486         unixid_string = talloc_asprintf(tmp_ctx, "%u", new_xid);
487         if (unixid_string == NULL) {
488                 status = NT_STATUS_NO_MEMORY;
489                 goto failed;
490         }
491
492         if (hwm_entry_exists) {
493                 struct ldb_message_element *els;
494                 struct ldb_val *vals;
495
496                 /* We're modifying the entry, not just adding a new one. */
497                 els = talloc_array(tmp_ctx, struct ldb_message_element, 2);
498                 if (els == NULL) {
499                         status = NT_STATUS_NO_MEMORY;
500                         goto failed;
501                 }
502
503                 vals = talloc_array(tmp_ctx, struct ldb_val, 2);
504                 if (els == NULL) {
505                         status = NT_STATUS_NO_MEMORY;
506                         goto failed;
507                 }
508
509                 hwm_msg->num_elements = 2;
510                 hwm_msg->elements = els;
511
512                 els[0].num_values = 1;
513                 els[0].values = &vals[0];
514                 els[0].flags = LDB_FLAG_MOD_DELETE;
515                 els[0].name = talloc_strdup(tmp_ctx, "xidNumber");
516                 if (els[0].name == NULL) {
517                         status = NT_STATUS_NO_MEMORY;
518                         goto failed;
519                 }
520
521                 els[1].num_values = 1;
522                 els[1].values = &vals[1];
523                 els[1].flags = LDB_FLAG_MOD_ADD;
524                 els[1].name = els[0].name;
525
526                 vals[0].data = (uint8_t *)unixid_string;
527                 vals[0].length = strlen(unixid_string);
528                 vals[1].data = (uint8_t *)hwm_string;
529                 vals[1].length = strlen(hwm_string);
530         } else {
531                 ret = ldb_msg_add_empty(hwm_msg, "xidNumber", LDB_FLAG_MOD_ADD,
532                                         NULL);
533                 if (ret != LDB_SUCCESS) {
534                         status = NT_STATUS_NONE_MAPPED;
535                         goto failed;
536                 }
537
538                 ret = ldb_msg_add_string(hwm_msg, "xidNumber", hwm_string);
539                 if (ret != LDB_SUCCESS)
540                 {
541                         status = NT_STATUS_NONE_MAPPED;
542                         goto failed;
543                 }
544         }
545
546         ret = ldb_modify(ldb, hwm_msg);
547         if (ret != LDB_SUCCESS) {
548                 DEBUG(1, ("Updating the xid high water mark failed: %s\n",
549                           ldb_errstring(ldb)));
550                 status = NT_STATUS_NONE_MAPPED;
551                 goto failed;
552         }
553
554         map_msg = ldb_msg_new(tmp_ctx);
555         if (map_msg == NULL) {
556                 status = NT_STATUS_NO_MEMORY;
557                 goto failed;
558         }
559
560         map_msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s", sid_string);
561         if (map_msg->dn == NULL) {
562                 status = NT_STATUS_NO_MEMORY;
563                 goto failed;
564         }
565
566         ret = ldb_msg_add_string(map_msg, "xidNumber", unixid_string);
567         if (ret != LDB_SUCCESS) {
568                 status = NT_STATUS_NONE_MAPPED;
569                 goto failed;
570         }
571
572         ret = idmap_msg_add_dom_sid(idmap_ctx, tmp_ctx, map_msg, "objectSid",
573                         sid);
574         if (ret != LDB_SUCCESS) {
575                 status = NT_STATUS_NONE_MAPPED;
576                 goto failed;
577         }
578
579         ret = ldb_msg_add_string(map_msg, "objectClass", "sidMap");
580         if (ret != LDB_SUCCESS) {
581                 status = NT_STATUS_NONE_MAPPED;
582                 goto failed;
583         }
584
585         ret = ldb_msg_add_string(map_msg, "type", "ID_TYPE_BOTH");
586         if (ret != LDB_SUCCESS) {
587                 status = NT_STATUS_NONE_MAPPED;
588                 goto failed;
589         }
590
591         ret = ldb_msg_add_string(map_msg, "cn", sid_string);
592         if (ret != LDB_SUCCESS) {
593                 status = NT_STATUS_NONE_MAPPED;
594                 goto failed;
595         }
596
597         ret = ldb_add(ldb, map_msg);
598         if (ret != LDB_SUCCESS) {
599                 DEBUG(1, ("Adding a sidmap failed: %s\n", ldb_errstring(ldb)));
600                 status = NT_STATUS_NONE_MAPPED;
601                 goto failed;
602         }
603
604         trans = ldb_transaction_commit(ldb);
605         if (trans != LDB_SUCCESS) {
606                 DEBUG(1, ("Transaction failed: %s\n", ldb_errstring(ldb)));
607                 status = NT_STATUS_NONE_MAPPED;
608                 goto failed;
609         }
610
611         *unixid = talloc(mem_ctx, struct unixid);
612         if (*unixid == NULL) {
613                 status = NT_STATUS_NO_MEMORY;
614                 goto failed;
615         }
616
617         (*unixid)->id = new_xid;
618         (*unixid)->type = ID_TYPE_BOTH;
619         talloc_free(tmp_ctx);
620         return NT_STATUS_OK;
621
622 failed:
623         if (trans == LDB_SUCCESS) ldb_transaction_cancel(ldb);
624         talloc_free(tmp_ctx);
625         return status;
626 }
627
628 /**
629  * Convert an array of unixids to the corresponding array of SIDs
630  *
631  * \param idmap_ctx idmap context to use
632  * \param mem_ctx talloc context the memory for the dom_sids is allocated
633  * from.
634  * \param count length of id_mapping array.
635  * \param id array of id_mappings.
636  * \return NT_STATUS_OK on success, NT_STATUS_NONE_MAPPED if mapping is not
637  * possible at all, NT_STATUS_SOME_UNMAPPED if some mappings worked and some
638  * did not.
639  */
640
641 NTSTATUS idmap_xids_to_sids(struct idmap_context *idmap_ctx,
642                             TALLOC_CTX *mem_ctx, int count,
643                             struct id_mapping *id)
644 {
645         int i;
646         int error_count = 0;
647
648         for (i = 0; i < count; ++i) {
649                 id[i].status = idmap_xid_to_sid(idmap_ctx, mem_ctx,
650                                                 id[i].unixid, &id[i].sid);
651                 if (NT_STATUS_EQUAL(id[i].status, NT_STATUS_RETRY)) {
652                         id[i].status = idmap_xid_to_sid(idmap_ctx, mem_ctx,
653                                                         id[i].unixid,
654                                                         &id[i].sid);
655                 }
656                 if (!NT_STATUS_IS_OK(id[i].status)) {
657                         DEBUG(1, ("idmapping failed for id[%d]\n", i));
658                         error_count++;
659                 }
660         }
661
662         if (error_count == count) {
663                 /* Mapping did not work at all. */
664                 return NT_STATUS_NONE_MAPPED;
665         } else if (error_count > 0) {
666                 /* Some mappings worked, some did not. */
667                 return STATUS_SOME_UNMAPPED;
668         } else {
669                 return NT_STATUS_OK;
670         }
671 }
672
673 /**
674  * Convert an array of SIDs to the corresponding array of unixids
675  *
676  * \param idmap_ctx idmap context to use
677  * \param mem_ctx talloc context the memory for the unixids is allocated
678  * from.
679  * \param count length of id_mapping array.
680  * \param id array of id_mappings.
681  * \return NT_STATUS_OK on success, NT_STATUS_NONE_MAPPED if mapping is not
682  * possible at all, NT_STATUS_SOME_UNMAPPED if some mappings worked and some
683  * did not.
684  */
685
686 NTSTATUS idmap_sids_to_xids(struct idmap_context *idmap_ctx,
687                             TALLOC_CTX *mem_ctx, int count,
688                             struct id_mapping *id)
689 {
690         int i;
691         int error_count = 0;
692
693         for (i = 0; i < count; ++i) {
694                 id[i].status = idmap_sid_to_xid(idmap_ctx, mem_ctx,
695                                                 id[i].sid, &id[i].unixid);
696                 if (NT_STATUS_EQUAL(id[i].status, NT_STATUS_RETRY)) {
697                         id[i].status = idmap_sid_to_xid(idmap_ctx, mem_ctx,
698                                                         id[i].sid,
699                                                         &id[i].unixid);
700                 }
701                 if (!NT_STATUS_IS_OK(id[i].status)) {
702                         DEBUG(1, ("idmapping failed for id[%d]\n", i));
703                         error_count++;
704                 }
705         }
706
707         if (error_count == count) {
708                 /* Mapping did not work at all. */
709                 return NT_STATUS_NONE_MAPPED;
710         } else if (error_count > 0) {
711                 /* Some mappings worked, some did not. */
712                 return STATUS_SOME_UNMAPPED;
713         } else {
714                 return NT_STATUS_OK;
715         }
716 }
717