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