s3:idmap_tdb: rename idmap_tdb_alloc_init->idmap_tdb_init_hwm and use db from idmap_t...
[amitay/samba.git] / source3 / winbindd / idmap_tdb.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    idmap TDB backend
5
6    Copyright (C) Tim Potter 2000
7    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
8    Copyright (C) Jeremy Allison 2006
9    Copyright (C) Simo Sorce 2003-2006
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 "winbindd.h"
27
28 #undef DBGC_CLASS
29 #define DBGC_CLASS DBGC_IDMAP
30
31 /* idmap version determines auto-conversion - this is the database
32    structure version specifier. */
33
34 #define IDMAP_VERSION 2
35
36 struct idmap_tdb_context {
37         struct db_context *db;
38 };
39
40 /* High water mark keys */
41 #define HWM_GROUP  "GROUP HWM"
42 #define HWM_USER   "USER HWM"
43
44 static struct idmap_tdb_state {
45
46         /* User and group id pool */
47         uid_t low_uid, high_uid;               /* Range of uids to allocate */
48         gid_t low_gid, high_gid;               /* Range of gids to allocate */
49
50 } idmap_tdb_state;
51
52 struct convert_fn_state {
53         struct db_context *db;
54         bool failed;
55 };
56
57 /*****************************************************************************
58  For idmap conversion: convert one record to new format
59  Ancient versions (eg 2.2.3a) of winbindd_idmap.tdb mapped DOMAINNAME/rid
60  instead of the SID.
61 *****************************************************************************/
62 static int convert_fn(struct db_record *rec, void *private_data)
63 {
64         struct winbindd_domain *domain;
65         char *p;
66         NTSTATUS status;
67         struct dom_sid sid;
68         uint32 rid;
69         fstring keystr;
70         fstring dom_name;
71         TDB_DATA key2;
72         struct convert_fn_state *s = (struct convert_fn_state *)private_data;
73
74         DEBUG(10,("Converting %s\n", (const char *)rec->key.dptr));
75
76         p = strchr((const char *)rec->key.dptr, '/');
77         if (!p)
78                 return 0;
79
80         *p = 0;
81         fstrcpy(dom_name, (const char *)rec->key.dptr);
82         *p++ = '/';
83
84         domain = find_domain_from_name(dom_name);
85         if (domain == NULL) {
86                 /* We must delete the old record. */
87                 DEBUG(0,("Unable to find domain %s\n", dom_name ));
88                 DEBUG(0,("deleting record %s\n", (const char *)rec->key.dptr ));
89
90                 status = rec->delete_rec(rec);
91                 if (!NT_STATUS_IS_OK(status)) {
92                         DEBUG(0, ("Unable to delete record %s:%s\n",
93                                 (const char *)rec->key.dptr,
94                                 nt_errstr(status)));
95                         s->failed = true;
96                         return -1;
97                 }
98
99                 return 0;
100         }
101
102         rid = atoi(p);
103
104         sid_compose(&sid, &domain->sid, rid);
105
106         sid_to_fstring(keystr, &sid);
107         key2 = string_term_tdb_data(keystr);
108
109         status = dbwrap_store(s->db, key2, rec->value, TDB_INSERT);
110         if (!NT_STATUS_IS_OK(status)) {
111                 DEBUG(0,("Unable to add record %s:%s\n",
112                         (const char *)key2.dptr,
113                         nt_errstr(status)));
114                 s->failed = true;
115                 return -1;
116         }
117
118         status = dbwrap_store(s->db, rec->value, key2, TDB_REPLACE);
119         if (!NT_STATUS_IS_OK(status)) {
120                 DEBUG(0,("Unable to update record %s:%s\n",
121                         (const char *)rec->value.dptr,
122                         nt_errstr(status)));
123                 s->failed = true;
124                 return -1;
125         }
126
127         status = rec->delete_rec(rec);
128         if (!NT_STATUS_IS_OK(status)) {
129                 DEBUG(0,("Unable to delete record %s:%s\n",
130                         (const char *)rec->key.dptr,
131                         nt_errstr(status)));
132                 s->failed = true;
133                 return -1;
134         }
135
136         return 0;
137 }
138
139 /*****************************************************************************
140  Convert the idmap database from an older version.
141 *****************************************************************************/
142
143 static bool idmap_tdb_upgrade(struct idmap_domain *dom, struct db_context *db)
144 {
145         int32 vers;
146         bool bigendianheader;
147         struct convert_fn_state s;
148
149         DEBUG(0, ("Upgrading winbindd_idmap.tdb from an old version\n"));
150
151         bigendianheader = (db->get_flags(db) & TDB_BIGENDIAN) ? True : False;
152
153         vers = dbwrap_fetch_int32(db, "IDMAP_VERSION");
154
155         if (((vers == -1) && bigendianheader) || (IREV(vers) == IDMAP_VERSION)) {
156                 /* Arrggghh ! Bytereversed or old big-endian - make order independent ! */
157                 /*
158                  * high and low records were created on a
159                  * big endian machine and will need byte-reversing.
160                  */
161
162                 int32 wm;
163
164                 wm = dbwrap_fetch_int32(db, HWM_USER);
165
166                 if (wm != -1) {
167                         wm = IREV(wm);
168                 }  else {
169                         wm = dom->low_id;
170                 }
171
172                 if (dbwrap_store_int32(db, HWM_USER, wm) == -1) {
173                         DEBUG(0, ("Unable to byteswap user hwm in idmap database\n"));
174                         return False;
175                 }
176
177                 wm = dbwrap_fetch_int32(db, HWM_GROUP);
178                 if (wm != -1) {
179                         wm = IREV(wm);
180                 } else {
181                         wm = dom->low_id;
182                 }
183
184                 if (dbwrap_store_int32(db, HWM_GROUP, wm) == -1) {
185                         DEBUG(0, ("Unable to byteswap group hwm in idmap database\n"));
186                         return False;
187                 }
188         }
189
190         s.db = db;
191         s.failed = false;
192
193         /* the old format stored as DOMAIN/rid - now we store the SID direct */
194         db->traverse(db, convert_fn, &s);
195
196         if (s.failed) {
197                 DEBUG(0, ("Problem during conversion\n"));
198                 return False;
199         }
200
201         if (dbwrap_store_int32(db, "IDMAP_VERSION", IDMAP_VERSION) == -1) {
202                 DEBUG(0, ("Unable to store idmap version in databse\n"));
203                 return False;
204         }
205
206         return True;
207 }
208
209 static NTSTATUS idmap_tdb_load_ranges(void)
210 {
211         uid_t low_uid = 0;
212         uid_t high_uid = 0;
213         gid_t low_gid = 0;
214         gid_t high_gid = 0;
215
216         if (!lp_idmap_uid(&low_uid, &high_uid)) {
217                 DEBUG(1, ("idmap uid missing\n"));
218                 return NT_STATUS_UNSUCCESSFUL;
219         }
220
221         if (!lp_idmap_gid(&low_gid, &high_gid)) {
222                 DEBUG(1, ("idmap gid missing\n"));
223                 return NT_STATUS_UNSUCCESSFUL;
224         }
225
226         idmap_tdb_state.low_uid = low_uid;
227         idmap_tdb_state.high_uid = high_uid;
228         idmap_tdb_state.low_gid = low_gid;
229         idmap_tdb_state.high_gid = high_gid;
230
231         if (idmap_tdb_state.high_uid <= idmap_tdb_state.low_uid) {
232                 DEBUG(1, ("idmap uid range missing or invalid\n"));
233                 return NT_STATUS_UNSUCCESSFUL;
234         }
235
236         if (idmap_tdb_state.high_gid <= idmap_tdb_state.low_gid) {
237                 DEBUG(1, ("idmap gid range missing or invalid\n"));
238                 return NT_STATUS_UNSUCCESSFUL;
239         }
240
241         return NT_STATUS_OK;
242 }
243
244 static NTSTATUS idmap_tdb_open_db(TALLOC_CTX *memctx,
245                                   bool check_config,
246                                   struct db_context **dbctx)
247 {
248         NTSTATUS ret;
249         TALLOC_CTX *ctx;
250         char *tdbfile = NULL;
251         struct db_context *db = NULL;
252         int32_t version;
253         bool config_error = false;
254
255         ret = idmap_tdb_load_ranges();
256         if (!NT_STATUS_IS_OK(ret)) {
257                 config_error = true;
258                 if (check_config) {
259                         return ret;
260                 }
261         }
262
263         /* use our own context here */
264         ctx = talloc_stackframe();
265
266         /* use the old database if present */
267         tdbfile = state_path("winbindd_idmap.tdb");
268         if (!tdbfile) {
269                 DEBUG(0, ("Out of memory!\n"));
270                 ret = NT_STATUS_NO_MEMORY;
271                 goto done;
272         }
273
274         DEBUG(10,("Opening tdbfile %s\n", tdbfile ));
275
276         /* Open idmap repository */
277         db = db_open(ctx, tdbfile, 0, TDB_DEFAULT, O_RDWR | O_CREAT, 0644);
278         if (!db) {
279                 DEBUG(0, ("Unable to open idmap database\n"));
280                 ret = NT_STATUS_UNSUCCESSFUL;
281                 goto done;
282         }
283
284         /* check against earlier versions */
285         version = dbwrap_fetch_int32(db, "IDMAP_VERSION");
286         if (version != IDMAP_VERSION) {
287                 if (config_error) {
288                         DEBUG(0,("Upgrade of IDMAP_VERSION from %d to %d is not "
289                                  "possible with incomplete configuration\n",
290                                  version, IDMAP_VERSION));
291                         ret = NT_STATUS_UNSUCCESSFUL;
292                         goto done;
293                 }
294                 if (db->transaction_start(db) != 0) {
295                         DEBUG(0, ("Unable to start upgrade transaction!\n"));
296                         ret = NT_STATUS_INTERNAL_DB_ERROR;
297                         goto done;
298                 }
299
300                 if (!idmap_tdb_upgrade(dom, db)) {
301                         db->transaction_cancel(db);
302                         DEBUG(0, ("Unable to open idmap database, it's in an old format, and upgrade failed!\n"));
303                         ret = NT_STATUS_INTERNAL_DB_ERROR;
304                         goto done;
305                 }
306
307                 if (db->transaction_commit(db) != 0) {
308                         DEBUG(0, ("Unable to commit upgrade transaction!\n"));
309                         ret = NT_STATUS_INTERNAL_DB_ERROR;
310                         goto done;
311                 }
312         }
313
314         *dbctx = talloc_move(memctx, &db);
315         ret = NT_STATUS_OK;
316
317 done:
318         talloc_free(ctx);
319         return ret;
320 }
321
322 /**********************************************************************
323  IDMAP ALLOC TDB BACKEND
324 **********************************************************************/
325  
326 static struct db_context *idmap_alloc_db;
327
328 /**********************************
329  Initialise idmap alloc database. 
330 **********************************/
331
332 static NTSTATUS idmap_tdb_init_hwm(struct idmap_domain *dom)
333 {
334         int ret;
335         uint32_t low_uid;
336         uint32_t low_gid;
337         bool update_uid = false;
338         bool update_gid = false;
339         struct idmap_tdb_context *ctx;
340
341         ctx = talloc_get_type(dom->private_data, struct idmap_tdb_context);
342
343         low_uid = dbwrap_fetch_int32(ctx->db, HWM_USER);
344         if (low_uid == -1 || low_uid < dom->low_id) {
345                 update_uid = true;
346         }
347
348         low_gid = dbwrap_fetch_int32(ctx->db, HWM_GROUP);
349         if (low_gid == -1 || low_gid < dom->low_id) {
350                 update_gid = true;
351         }
352
353         if (!update_uid && !update_gid) {
354                 return NT_STATUS_OK;
355         }
356
357         if (ctx->db->transaction_start(ctx->db) != 0) {
358                 DEBUG(0, ("Unable to start upgrade transaction!\n"));
359                 return NT_STATUS_INTERNAL_DB_ERROR;
360         }
361
362         if (update_uid) {
363                 ret = dbwrap_store_int32(ctx->db, HWM_USER, dom->low_id);
364                 if (ret == -1) {
365                         ctx->db->transaction_cancel(ctx->db);
366                         DEBUG(0, ("Unable to initialise user hwm in idmap "
367                                   "database\n"));
368                         return NT_STATUS_INTERNAL_DB_ERROR;
369                 }
370         }
371
372         if (update_gid) {
373                 ret = dbwrap_store_int32(ctx->db, HWM_GROUP, dom->low_id);
374                 if (ret == -1) {
375                         ctx->db->transaction_cancel(ctx->db);
376                         DEBUG(0, ("Unable to initialise group hwm in idmap "
377                                   "database\n"));
378                         return NT_STATUS_INTERNAL_DB_ERROR;
379                 }
380         }
381
382         if (ctx->db->transaction_commit(ctx->db) != 0) {
383                 DEBUG(0, ("Unable to commit upgrade transaction!\n"));
384                 return NT_STATUS_INTERNAL_DB_ERROR;
385         }
386
387         return NT_STATUS_OK;
388 }
389
390 /**********************************
391  Allocate a new id. 
392 **********************************/
393
394 struct idmap_tdb_allocate_id_context {
395         const char *hwmkey;
396         const char *hwmtype;
397         uint32_t high_hwm;
398         uint32_t hwm;
399 };
400
401 static NTSTATUS idmap_tdb_allocate_id_action(struct db_context *db,
402                                              void *private_data)
403 {
404         NTSTATUS ret;
405         struct idmap_tdb_allocate_id_context *state;
406         uint32_t hwm;
407
408         state = (struct idmap_tdb_allocate_id_context *)private_data;
409
410         hwm = dbwrap_fetch_int32(db, state->hwmkey);
411         if (hwm == -1) {
412                 ret = NT_STATUS_INTERNAL_DB_ERROR;
413                 goto done;
414         }
415
416         /* check it is in the range */
417         if (hwm > state->high_hwm) {
418                 DEBUG(1, ("Fatal Error: %s range full!! (max: %lu)\n",
419                           state->hwmtype, (unsigned long)state->high_hwm));
420                 ret = NT_STATUS_UNSUCCESSFUL;
421                 goto done;
422         }
423
424         /* fetch a new id and increment it */
425         ret = dbwrap_trans_change_uint32_atomic(db, state->hwmkey, &hwm, 1);
426         if (!NT_STATUS_IS_OK(ret)) {
427                 DEBUG(0, ("Fatal error while fetching a new %s value: %s\n!",
428                           state->hwmtype, nt_errstr(ret)));
429                 goto done;
430         }
431
432         /* recheck it is in the range */
433         if (hwm > state->high_hwm) {
434                 DEBUG(1, ("Fatal Error: %s range full!! (max: %lu)\n",
435                           state->hwmtype, (unsigned long)state->high_hwm));
436                 ret = NT_STATUS_UNSUCCESSFUL;
437                 goto done;
438         }
439
440         ret = NT_STATUS_OK;
441         state->hwm = hwm;
442
443 done:
444         return ret;
445 }
446
447 static NTSTATUS idmap_tdb_allocate_id(struct unixid *xid)
448 {
449         const char *hwmkey;
450         const char *hwmtype;
451         uint32_t high_hwm;
452         uint32_t hwm = 0;
453         NTSTATUS status;
454         struct idmap_tdb_allocate_id_context state;
455
456         /* Get current high water mark */
457         switch (xid->type) {
458
459         case ID_TYPE_UID:
460                 hwmkey = HWM_USER;
461                 hwmtype = "UID";
462                 high_hwm = idmap_tdb_state.high_uid;
463                 break;
464
465         case ID_TYPE_GID:
466                 hwmkey = HWM_GROUP;
467                 hwmtype = "GID";
468                 high_hwm = idmap_tdb_state.high_gid;
469                 break;
470
471         default:
472                 DEBUG(2, ("Invalid ID type (0x%x)\n", xid->type));
473                 return NT_STATUS_INVALID_PARAMETER;
474         }
475
476         state.hwm = hwm;
477         state.high_hwm = high_hwm;
478         state.hwmtype = hwmtype;
479         state.hwmkey = hwmkey;
480
481         status = dbwrap_trans_do(idmap_alloc_db, idmap_tdb_allocate_id_action,
482                                  &state);
483
484         if (NT_STATUS_IS_OK(status)) {
485                 xid->id = state.hwm;
486                 DEBUG(10,("New %s = %d\n", hwmtype, state.hwm));
487         } else {
488                 DEBUG(1, ("Error allocating a new %s\n", hwmtype));
489         }
490
491         return status;
492 }
493
494 /**
495  * Allocate a new unix-ID.
496  * For now this is for the default idmap domain only.
497  * Should be extended later on.
498  */
499 static NTSTATUS idmap_tdb_get_new_id(struct idmap_domain *dom,
500                                      struct unixid *id)
501 {
502         NTSTATUS ret;
503
504         if (!strequal(dom->name, "*")) {
505                 DEBUG(3, ("idmap_tdb_get_new_id: "
506                           "Refusing allocation of a new unixid for domain'%s'. "
507                           "Currently only supported for the default "
508                           "domain \"*\".\n",
509                            dom->name));
510                 return NT_STATUS_NOT_IMPLEMENTED;
511         }
512
513         ret = idmap_tdb_allocate_id(id);
514
515         return ret;
516 }
517
518 /**********************************
519  Close the alloc tdb 
520 **********************************/
521
522 static NTSTATUS idmap_tdb_alloc_close(void)
523 {
524         TALLOC_FREE(idmap_alloc_db);
525         return NT_STATUS_OK;
526 }
527
528 /**********************************************************************
529  IDMAP MAPPING TDB BACKEND
530 **********************************************************************/
531
532 /*****************************
533  Initialise idmap database. 
534 *****************************/
535
536 static NTSTATUS idmap_tdb_db_init(struct idmap_domain *dom, const char *params)
537 {
538         NTSTATUS ret;
539         struct idmap_tdb_context *ctx;
540
541         DEBUG(10, ("idmap_tdb_db_init called for domain '%s'\n", dom->name));
542
543         ctx = talloc(dom, struct idmap_tdb_context);
544         if ( ! ctx) {
545                 DEBUG(0, ("Out of memory!\n"));
546                 return NT_STATUS_NO_MEMORY;
547         }
548
549         /* load backend specific configuration here: */
550 #if 0
551         if (strequal(dom->name, "*")) {
552         } else {
553         }
554 #endif
555
556         ret = idmap_tdb_open_db(ctx, false, &ctx->db);
557         if ( ! NT_STATUS_IS_OK(ret)) {
558                 goto failed;
559         }
560
561         dom->private_data = ctx;
562
563         return NT_STATUS_OK;
564
565 failed:
566         talloc_free(ctx);
567         return ret;
568 }
569
570 /**********************************
571  Single id to sid lookup function. 
572 **********************************/
573
574 static NTSTATUS idmap_tdb_id_to_sid(struct idmap_domain *dom, struct id_map *map)
575 {
576         NTSTATUS ret;
577         TDB_DATA data;
578         char *keystr;
579         struct idmap_tdb_context *ctx;
580
581         if (!dom || !map) {
582                 return NT_STATUS_INVALID_PARAMETER;
583         }
584
585         ctx = talloc_get_type(dom->private_data, struct idmap_tdb_context);
586
587         /* apply filters before checking */
588         if (!idmap_unix_id_is_in_range(map->xid.id, dom)) {
589                 DEBUG(5, ("Requested id (%u) out of range (%u - %u). Filtered!\n",
590                                 map->xid.id, dom->low_id, dom->high_id));
591                 return NT_STATUS_NONE_MAPPED;
592         }
593
594         switch (map->xid.type) {
595
596         case ID_TYPE_UID:
597                 keystr = talloc_asprintf(ctx, "UID %lu", (unsigned long)map->xid.id);
598                 break;
599                 
600         case ID_TYPE_GID:
601                 keystr = talloc_asprintf(ctx, "GID %lu", (unsigned long)map->xid.id);
602                 break;
603
604         default:
605                 DEBUG(2, ("INVALID unix ID type: 0x02%x\n", map->xid.type));
606                 return NT_STATUS_INVALID_PARAMETER;
607         }
608
609         /* final SAFE_FREE safe */
610         data.dptr = NULL;
611
612         if (keystr == NULL) {
613                 DEBUG(0, ("Out of memory!\n"));
614                 ret = NT_STATUS_NO_MEMORY;
615                 goto done;
616         }
617
618         DEBUG(10,("Fetching record %s\n", keystr));
619
620         /* Check if the mapping exists */
621         data = dbwrap_fetch_bystring(ctx->db, NULL, keystr);
622
623         if (!data.dptr) {
624                 DEBUG(10,("Record %s not found\n", keystr));
625                 ret = NT_STATUS_NONE_MAPPED;
626                 goto done;
627         }
628                 
629         if (!string_to_sid(map->sid, (const char *)data.dptr)) {
630                 DEBUG(10,("INVALID SID (%s) in record %s\n",
631                         (const char *)data.dptr, keystr));
632                 ret = NT_STATUS_INTERNAL_DB_ERROR;
633                 goto done;
634         }
635
636         DEBUG(10,("Found record %s -> %s\n", keystr, (const char *)data.dptr));
637         ret = NT_STATUS_OK;
638
639 done:
640         talloc_free(data.dptr);
641         talloc_free(keystr);
642         return ret;
643 }
644
645 /**********************************
646  Single sid to id lookup function. 
647 **********************************/
648
649 static NTSTATUS idmap_tdb_sid_to_id(struct idmap_domain *dom, struct id_map *map)
650 {
651         NTSTATUS ret;
652         TDB_DATA data;
653         char *keystr;
654         unsigned long rec_id = 0;
655         struct idmap_tdb_context *ctx;
656         TALLOC_CTX *tmp_ctx = talloc_stackframe();
657
658         ctx = talloc_get_type(dom->private_data, struct idmap_tdb_context);
659
660         keystr = sid_string_talloc(tmp_ctx, map->sid);
661         if (keystr == NULL) {
662                 DEBUG(0, ("Out of memory!\n"));
663                 ret = NT_STATUS_NO_MEMORY;
664                 goto done;
665         }
666
667         DEBUG(10,("Fetching record %s\n", keystr));
668
669         /* Check if sid is present in database */
670         data = dbwrap_fetch_bystring(ctx->db, tmp_ctx, keystr);
671         if (!data.dptr) {
672                 DEBUG(10,("Record %s not found\n", keystr));
673                 ret = NT_STATUS_NONE_MAPPED;
674                 goto done;
675         }
676
677         /* What type of record is this ? */
678         if (sscanf((const char *)data.dptr, "UID %lu", &rec_id) == 1) { /* Try a UID record. */
679                 map->xid.id = rec_id;
680                 map->xid.type = ID_TYPE_UID;
681                 DEBUG(10,("Found uid record %s -> %s \n", keystr, (const char *)data.dptr ));
682                 ret = NT_STATUS_OK;
683
684         } else if (sscanf((const char *)data.dptr, "GID %lu", &rec_id) == 1) { /* Try a GID record. */
685                 map->xid.id = rec_id;
686                 map->xid.type = ID_TYPE_GID;
687                 DEBUG(10,("Found gid record %s -> %s \n", keystr, (const char *)data.dptr ));
688                 ret = NT_STATUS_OK;
689
690         } else { /* Unknown record type ! */
691                 DEBUG(2, ("Found INVALID record %s -> %s\n", keystr, (const char *)data.dptr));
692                 ret = NT_STATUS_INTERNAL_DB_ERROR;
693                 goto done;
694         }
695
696         /* apply filters before returning result */
697         if (!idmap_unix_id_is_in_range(map->xid.id, dom)) {
698                 DEBUG(5, ("Requested id (%u) out of range (%u - %u). Filtered!\n",
699                                 map->xid.id, dom->low_id, dom->high_id));
700                 ret = NT_STATUS_NONE_MAPPED;
701         }
702
703 done:
704         talloc_free(tmp_ctx);
705         return ret;
706 }
707
708 /**********************************
709  lookup a set of unix ids. 
710 **********************************/
711
712 static NTSTATUS idmap_tdb_unixids_to_sids(struct idmap_domain *dom, struct id_map **ids)
713 {
714         struct idmap_tdb_context *ctx;
715         NTSTATUS ret;
716         int i;
717
718         /* initialize the status to avoid suprise */
719         for (i = 0; ids[i]; i++) {
720                 ids[i]->status = ID_UNKNOWN;
721         }
722         
723         ctx = talloc_get_type(dom->private_data, struct idmap_tdb_context);
724
725         for (i = 0; ids[i]; i++) {
726                 ret = idmap_tdb_id_to_sid(dom, ids[i]);
727                 if ( ! NT_STATUS_IS_OK(ret)) {
728
729                         /* if it is just a failed mapping continue */
730                         if (NT_STATUS_EQUAL(ret, NT_STATUS_NONE_MAPPED)) {
731
732                                 /* make sure it is marked as unmapped */
733                                 ids[i]->status = ID_UNMAPPED;
734                                 continue;
735                         }
736                         
737                         /* some fatal error occurred, return immediately */
738                         goto done;
739                 }
740
741                 /* all ok, id is mapped */
742                 ids[i]->status = ID_MAPPED;
743         }
744
745         ret = NT_STATUS_OK;
746
747 done:
748         return ret;
749 }
750
751 /**********************************
752  lookup a set of sids. 
753 **********************************/
754
755 static NTSTATUS idmap_tdb_sids_to_unixids(struct idmap_domain *dom, struct id_map **ids)
756 {
757         struct idmap_tdb_context *ctx;
758         NTSTATUS ret;
759         int i;
760
761         /* initialize the status to avoid suprise */
762         for (i = 0; ids[i]; i++) {
763                 ids[i]->status = ID_UNKNOWN;
764         }
765         
766         ctx = talloc_get_type(dom->private_data, struct idmap_tdb_context);
767
768         for (i = 0; ids[i]; i++) {
769                 ret = idmap_tdb_sid_to_id(dom, ids[i]);
770                 if ( ! NT_STATUS_IS_OK(ret)) {
771
772                         /* if it is just a failed mapping continue */
773                         if (NT_STATUS_EQUAL(ret, NT_STATUS_NONE_MAPPED)) {
774
775                                 /* make sure it is marked as unmapped */
776                                 ids[i]->status = ID_UNMAPPED;
777                                 continue;
778                         }
779                         
780                         /* some fatal error occurred, return immediately */
781                         goto done;
782                 }
783
784                 /* all ok, id is mapped */
785                 ids[i]->status = ID_MAPPED;
786         }
787
788         ret = NT_STATUS_OK;
789
790 done:
791         return ret;
792 }
793
794 /**********************************
795  set a mapping.
796 **********************************/
797
798 static NTSTATUS idmap_tdb_set_mapping(struct idmap_domain *dom,
799                                       const struct id_map *map)
800 {
801         struct idmap_tdb_context *ctx;
802         NTSTATUS ret;
803         TDB_DATA ksid, kid;
804         char *ksidstr, *kidstr;
805         fstring tmp;
806
807         if (!map || !map->sid) {
808                 return NT_STATUS_INVALID_PARAMETER;
809         }
810
811         ksidstr = kidstr = NULL;
812
813         /* TODO: should we filter a set_mapping using low/high filters ? */
814
815         ctx = talloc_get_type(dom->private_data, struct idmap_tdb_context);
816
817         switch (map->xid.type) {
818
819         case ID_TYPE_UID:
820                 kidstr = talloc_asprintf(ctx, "UID %lu",
821                                          (unsigned long)map->xid.id);
822                 break;
823
824         case ID_TYPE_GID:
825                 kidstr = talloc_asprintf(ctx, "GID %lu",
826                                          (unsigned long)map->xid.id);
827                 break;
828
829         default:
830                 DEBUG(2, ("INVALID unix ID type: 0x02%x\n", map->xid.type));
831                 return NT_STATUS_INVALID_PARAMETER;
832         }
833
834         if (kidstr == NULL) {
835                 DEBUG(0, ("ERROR: Out of memory!\n"));
836                 ret = NT_STATUS_NO_MEMORY;
837                 goto done;
838         }
839
840         if ((ksidstr = talloc_asprintf(
841                      ctx, "%s", sid_to_fstring(tmp, map->sid))) == NULL) {
842                 DEBUG(0, ("Out of memory!\n"));
843                 ret = NT_STATUS_NO_MEMORY;
844                 goto done;
845         }
846
847         DEBUG(10, ("Storing %s <-> %s map\n", ksidstr, kidstr));
848         kid = string_term_tdb_data(kidstr);
849         ksid = string_term_tdb_data(ksidstr);
850
851         if (ctx->db->transaction_start(ctx->db) != 0) {
852                 DEBUG(0, ("Failed to start transaction for %s\n",
853                           ksidstr));
854                 ret = NT_STATUS_INTERNAL_DB_ERROR;
855                 goto done;
856         }
857
858         ret = dbwrap_store(ctx->db, ksid, kid, TDB_REPLACE);
859         if (!NT_STATUS_IS_OK(ret)) {
860                 ctx->db->transaction_cancel(ctx->db);
861                 DEBUG(0, ("Error storing SID -> ID (%s -> %s): %s\n",
862                           ksidstr, kidstr, nt_errstr(ret)));
863                 goto done;
864         }
865         ret = dbwrap_store(ctx->db, kid, ksid, TDB_REPLACE);
866         if (!NT_STATUS_IS_OK(ret)) {
867                 ctx->db->transaction_cancel(ctx->db);
868                 DEBUG(0, ("Error storing ID -> SID (%s -> %s): %s\n",
869                           kidstr, ksidstr, nt_errstr(ret)));
870                 goto done;
871         }
872
873         if (ctx->db->transaction_commit(ctx->db) != 0) {
874                 DEBUG(0, ("Failed to commit transaction for (%s -> %s)\n",
875                           ksidstr, kidstr));
876                 ret = NT_STATUS_INTERNAL_DB_ERROR;
877                 goto done;
878         }
879
880         DEBUG(10,("Stored %s <-> %s\n", ksidstr, kidstr));
881         ret = NT_STATUS_OK;
882
883 done:
884         talloc_free(ksidstr);
885         talloc_free(kidstr);
886         return ret;
887 }
888
889 /**********************************
890  Close the idmap tdb instance
891 **********************************/
892
893 static NTSTATUS idmap_tdb_close(struct idmap_domain *dom)
894 {
895         struct idmap_tdb_context *ctx;
896
897         if (dom->private_data) {
898                 ctx = talloc_get_type(dom->private_data, struct idmap_tdb_context);
899
900                 TALLOC_FREE(ctx->db);
901         }
902         return NT_STATUS_OK;
903 }
904
905 static struct idmap_methods db_methods = {
906         .init = idmap_tdb_db_init,
907         .unixids_to_sids = idmap_tdb_unixids_to_sids,
908         .sids_to_unixids = idmap_tdb_sids_to_unixids,
909         .allocate_id = idmap_tdb_get_new_id,
910         .close_fn = idmap_tdb_close
911 };
912
913 NTSTATUS idmap_tdb_init(void)
914 {
915         DEBUG(10, ("calling idmap_tdb_init\n"));
916
917         return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "tdb", &db_methods);
918 }