2 Unix SMB/CIFS implementation.
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
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.
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.
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/>.
29 #define DBGC_CLASS DBGC_IDMAP
31 /* High water mark keys */
32 #define HWM_GROUP "GROUP HWM"
33 #define HWM_USER "USER HWM"
35 static struct idmap_tdb_state
{
37 /* User and group id pool */
38 uid_t low_uid
, high_uid
; /* Range of uids to allocate */
39 gid_t low_gid
, high_gid
; /* Range of gids to allocate */
43 /*****************************************************************************
44 For idmap conversion: convert one record to new format
45 Ancient versions (eg 2.2.3a) of winbindd_idmap.tdb mapped DOMAINNAME/rid
47 *****************************************************************************/
48 static int convert_fn(TDB_CONTEXT
*tdb
, TDB_DATA key
, TDB_DATA data
, void *state
)
50 struct winbindd_domain
*domain
;
57 bool *failed
= (bool *)state
;
59 DEBUG(10,("Converting %s\n", (const char *)key
.dptr
));
61 p
= strchr((const char *)key
.dptr
, '/');
66 fstrcpy(dom_name
, (const char *)key
.dptr
);
69 domain
= find_domain_from_name(dom_name
);
71 /* We must delete the old record. */
72 DEBUG(0,("Unable to find domain %s\n", dom_name
));
73 DEBUG(0,("deleting record %s\n", (const char *)key
.dptr
));
75 if (tdb_delete(tdb
, key
) != 0) {
76 DEBUG(0, ("Unable to delete record %s\n", (const char *)key
.dptr
));
86 sid_copy(&sid
, &domain
->sid
);
87 sid_append_rid(&sid
, rid
);
89 sid_to_string(keystr
, &sid
);
90 key2
= string_term_tdb_data(keystr
);
92 if (tdb_store(tdb
, key2
, data
, TDB_INSERT
) != 0) {
93 DEBUG(0,("Unable to add record %s\n", (const char *)key2
.dptr
));
98 if (tdb_store(tdb
, data
, key2
, TDB_REPLACE
) != 0) {
99 DEBUG(0,("Unable to update record %s\n", (const char *)data
.dptr
));
104 if (tdb_delete(tdb
, key
) != 0) {
105 DEBUG(0,("Unable to delete record %s\n", (const char *)key
.dptr
));
113 /*****************************************************************************
114 Convert the idmap database from an older version.
115 *****************************************************************************/
117 static bool idmap_tdb_upgrade(const char *idmap_name
)
120 bool bigendianheader
;
122 TDB_CONTEXT
*idmap_tdb
;
124 DEBUG(0, ("Upgrading winbindd_idmap.tdb from an old version\n"));
126 if (!(idmap_tdb
= tdb_open_log(idmap_name
, 0,
129 DEBUG(0, ("Unable to open idmap database\n"));
133 bigendianheader
= (tdb_get_flags(idmap_tdb
) & TDB_BIGENDIAN
) ? True
: False
;
135 vers
= tdb_fetch_int32(idmap_tdb
, "IDMAP_VERSION");
137 if (((vers
== -1) && bigendianheader
) || (IREV(vers
) == IDMAP_VERSION
)) {
138 /* Arrggghh ! Bytereversed or old big-endian - make order independent ! */
140 * high and low records were created on a
141 * big endian machine and will need byte-reversing.
146 wm
= tdb_fetch_int32(idmap_tdb
, HWM_USER
);
151 wm
= idmap_tdb_state
.low_uid
;
154 if (tdb_store_int32(idmap_tdb
, HWM_USER
, wm
) == -1) {
155 DEBUG(0, ("Unable to byteswap user hwm in idmap database\n"));
156 tdb_close(idmap_tdb
);
160 wm
= tdb_fetch_int32(idmap_tdb
, HWM_GROUP
);
164 wm
= idmap_tdb_state
.low_gid
;
167 if (tdb_store_int32(idmap_tdb
, HWM_GROUP
, wm
) == -1) {
168 DEBUG(0, ("Unable to byteswap group hwm in idmap database\n"));
169 tdb_close(idmap_tdb
);
174 /* the old format stored as DOMAIN/rid - now we store the SID direct */
175 tdb_traverse(idmap_tdb
, convert_fn
, &failed
);
178 DEBUG(0, ("Problem during conversion\n"));
179 tdb_close(idmap_tdb
);
183 if (tdb_store_int32(idmap_tdb
, "IDMAP_VERSION", IDMAP_VERSION
) == -1) {
184 DEBUG(0, ("Unable to dtore idmap version in databse\n"));
185 tdb_close(idmap_tdb
);
189 tdb_close(idmap_tdb
);
193 /* WARNING: We can't open a tdb twice inthe same process, for that reason
194 * I'm going to use a hack with open ref counts to open the winbindd_idmap.tdb
195 * only once. We will later decide whether to split the db in multiple files
196 * or come up with a better solution to share them. */
198 static TDB_CONTEXT
*idmap_tdb_common_ctx
;
199 static int idmap_tdb_open_ref_count
= 0;
201 static NTSTATUS
idmap_tdb_open_db(TALLOC_CTX
*memctx
, TDB_CONTEXT
**tdbctx
)
205 SMB_STRUCT_STAT stbuf
;
206 char *tdbfile
= NULL
;
208 bool tdb_is_new
= False
;
210 if (idmap_tdb_open_ref_count
) { /* the tdb has already been opened */
211 idmap_tdb_open_ref_count
++;
212 *tdbctx
= idmap_tdb_common_ctx
;
216 /* use our own context here */
217 ctx
= talloc_new(memctx
);
219 DEBUG(0, ("Out of memory!\n"));
220 return NT_STATUS_NO_MEMORY
;
223 /* use the old database if present */
224 tdbfile
= talloc_strdup(ctx
, state_path("winbindd_idmap.tdb"));
226 DEBUG(0, ("Out of memory!\n"));
227 ret
= NT_STATUS_NO_MEMORY
;
231 if (!file_exist(tdbfile
, &stbuf
)) {
235 DEBUG(10,("Opening tdbfile %s\n", tdbfile
));
237 /* Open idmap repository */
238 if (!(idmap_tdb_common_ctx
= tdb_open_log(tdbfile
, 0, TDB_DEFAULT
, O_RDWR
| O_CREAT
, 0644))) {
239 DEBUG(0, ("Unable to open idmap database\n"));
240 ret
= NT_STATUS_UNSUCCESSFUL
;
245 /* the file didn't existed before opening it, let's
246 * store idmap version as nobody else yet opened and
247 * stored it. I do not like this method but didn't
248 * found a way to understand if an opened tdb have
249 * been just created or not --- SSS */
250 tdb_store_int32(idmap_tdb_common_ctx
, "IDMAP_VERSION", IDMAP_VERSION
);
253 /* check against earlier versions */
254 version
= tdb_fetch_int32(idmap_tdb_common_ctx
, "IDMAP_VERSION");
255 if (version
!= IDMAP_VERSION
) {
257 /* backup_tdb expects the tdb not to be open */
258 tdb_close(idmap_tdb_common_ctx
);
260 if ( ! idmap_tdb_upgrade(tdbfile
)) {
262 DEBUG(0, ("Unable to open idmap database, it's in an old formati, and upgrade failed!\n"));
263 ret
= NT_STATUS_INTERNAL_DB_ERROR
;
267 /* Re-Open idmap repository */
268 if (!(idmap_tdb_common_ctx
= tdb_open_log(tdbfile
, 0, TDB_DEFAULT
, O_RDWR
| O_CREAT
, 0644))) {
269 DEBUG(0, ("Unable to open idmap database\n"));
270 ret
= NT_STATUS_UNSUCCESSFUL
;
275 *tdbctx
= idmap_tdb_common_ctx
;
276 idmap_tdb_open_ref_count
++;
284 /* NEVER use tdb_close() except for the conversion routines that are guaranteed
285 * to run only when the database is opened the first time, always use this function. */
287 bool idmap_tdb_tdb_close(TDB_CONTEXT
*tdbctx
)
289 if (tdbctx
!= idmap_tdb_common_ctx
) {
290 DEBUG(0, ("ERROR: Invalid tdb context!"));
294 idmap_tdb_open_ref_count
--;
295 if (idmap_tdb_open_ref_count
) {
299 return tdb_close(idmap_tdb_common_ctx
);
302 /**********************************************************************
303 IDMAP ALLOC TDB BACKEND
304 **********************************************************************/
306 static TDB_CONTEXT
*idmap_alloc_tdb
;
308 /**********************************
309 Initialise idmap alloc database.
310 **********************************/
312 static NTSTATUS
idmap_tdb_alloc_init( const char *params
)
322 /* use our own context here */
323 ctx
= talloc_new(NULL
);
325 DEBUG(0, ("Out of memory!\n"));
326 return NT_STATUS_NO_MEMORY
;
329 ret
= idmap_tdb_open_db(ctx
, &idmap_alloc_tdb
);
330 if ( ! NT_STATUS_IS_OK(ret
)) {
338 idmap_tdb_state
.low_uid
= 0;
339 idmap_tdb_state
.high_uid
= 0;
340 idmap_tdb_state
.low_gid
= 0;
341 idmap_tdb_state
.high_gid
= 0;
343 range
= lp_parm_const_string(-1, "idmap alloc config", "range", NULL
);
344 if (range
&& range
[0]) {
345 unsigned low_id
, high_id
;
347 if (sscanf(range
, "%u - %u", &low_id
, &high_id
) == 2) {
348 if (low_id
< high_id
) {
349 idmap_tdb_state
.low_gid
= idmap_tdb_state
.low_uid
= low_id
;
350 idmap_tdb_state
.high_gid
= idmap_tdb_state
.high_uid
= high_id
;
352 DEBUG(1, ("ERROR: invalid idmap alloc range [%s]", range
));
355 DEBUG(1, ("ERROR: invalid syntax for idmap alloc config:range [%s]", range
));
359 /* Create high water marks for group and user id */
360 if (lp_idmap_uid(&low_uid
, &high_uid
)) {
361 idmap_tdb_state
.low_uid
= low_uid
;
362 idmap_tdb_state
.high_uid
= high_uid
;
365 if (lp_idmap_gid(&low_gid
, &high_gid
)) {
366 idmap_tdb_state
.low_gid
= low_gid
;
367 idmap_tdb_state
.high_gid
= high_gid
;
370 if (idmap_tdb_state
.high_uid
<= idmap_tdb_state
.low_uid
) {
371 DEBUG(1, ("idmap uid range missing or invalid\n"));
372 DEBUGADD(1, ("idmap will be unable to map foreign SIDs\n"));
373 return NT_STATUS_UNSUCCESSFUL
;
377 if (((low_id
= tdb_fetch_int32(idmap_alloc_tdb
, HWM_USER
)) == -1) ||
378 (low_id
< idmap_tdb_state
.low_uid
)) {
379 if (tdb_store_int32(idmap_alloc_tdb
, HWM_USER
, idmap_tdb_state
.low_uid
) == -1) {
380 DEBUG(0, ("Unable to initialise user hwm in idmap database\n"));
381 return NT_STATUS_INTERNAL_DB_ERROR
;
386 if (idmap_tdb_state
.high_gid
<= idmap_tdb_state
.low_gid
) {
387 DEBUG(1, ("idmap gid range missing or invalid\n"));
388 DEBUGADD(1, ("idmap will be unable to map foreign SIDs\n"));
389 return NT_STATUS_UNSUCCESSFUL
;
393 if (((low_id
= tdb_fetch_int32(idmap_alloc_tdb
, HWM_GROUP
)) == -1) ||
394 (low_id
< idmap_tdb_state
.low_gid
)) {
395 if (tdb_store_int32(idmap_alloc_tdb
, HWM_GROUP
, idmap_tdb_state
.low_gid
) == -1) {
396 DEBUG(0, ("Unable to initialise group hwm in idmap database\n"));
397 return NT_STATUS_INTERNAL_DB_ERROR
;
405 /**********************************
407 **********************************/
409 static NTSTATUS
idmap_tdb_allocate_id(struct unixid
*xid
)
417 /* Get current high water mark */
423 high_hwm
= idmap_tdb_state
.high_uid
;
429 high_hwm
= idmap_tdb_state
.high_gid
;
433 DEBUG(2, ("Invalid ID type (0x%x)\n", xid
->type
));
434 return NT_STATUS_INVALID_PARAMETER
;
437 if ((hwm
= tdb_fetch_int32(idmap_alloc_tdb
, hwmkey
)) == -1) {
438 return NT_STATUS_INTERNAL_DB_ERROR
;
441 /* check it is in the range */
442 if (hwm
> high_hwm
) {
443 DEBUG(1, ("Fatal Error: %s range full!! (max: %lu)\n",
444 hwmtype
, (unsigned long)high_hwm
));
445 return NT_STATUS_UNSUCCESSFUL
;
448 /* fetch a new id and increment it */
449 ret
= tdb_change_uint32_atomic(idmap_alloc_tdb
, hwmkey
, &hwm
, 1);
451 DEBUG(1, ("Fatal error while fetching a new %s value\n!", hwmtype
));
452 return NT_STATUS_UNSUCCESSFUL
;
455 /* recheck it is in the range */
456 if (hwm
> high_hwm
) {
457 DEBUG(1, ("Fatal Error: %s range full!! (max: %lu)\n",
458 hwmtype
, (unsigned long)high_hwm
));
459 return NT_STATUS_UNSUCCESSFUL
;
463 DEBUG(10,("New %s = %d\n", hwmtype
, hwm
));
468 /**********************************
469 Get current highest id.
470 **********************************/
472 static NTSTATUS
idmap_tdb_get_hwm(struct unixid
*xid
)
479 /* Get current high water mark */
485 high_hwm
= idmap_tdb_state
.high_uid
;
491 high_hwm
= idmap_tdb_state
.high_gid
;
495 return NT_STATUS_INVALID_PARAMETER
;
498 if ((hwm
= tdb_fetch_int32(idmap_alloc_tdb
, hwmkey
)) == -1) {
499 return NT_STATUS_INTERNAL_DB_ERROR
;
504 /* Warn if it is out of range */
505 if (hwm
>= high_hwm
) {
506 DEBUG(0, ("Warning: %s range full!! (max: %lu)\n",
507 hwmtype
, (unsigned long)high_hwm
));
513 /**********************************
515 **********************************/
517 static NTSTATUS
idmap_tdb_set_hwm(struct unixid
*xid
)
524 /* Get current high water mark */
530 high_hwm
= idmap_tdb_state
.high_uid
;
536 high_hwm
= idmap_tdb_state
.high_gid
;
540 return NT_STATUS_INVALID_PARAMETER
;
545 if ((hwm
= tdb_store_int32(idmap_alloc_tdb
, hwmkey
, hwm
)) == -1) {
546 return NT_STATUS_INTERNAL_DB_ERROR
;
549 /* Warn if it is out of range */
550 if (hwm
>= high_hwm
) {
551 DEBUG(0, ("Warning: %s range full!! (max: %lu)\n",
552 hwmtype
, (unsigned long)high_hwm
));
558 /**********************************
560 **********************************/
562 static NTSTATUS
idmap_tdb_alloc_close(void)
564 if (idmap_alloc_tdb
) {
565 if (idmap_tdb_tdb_close(idmap_alloc_tdb
) == 0) {
568 return NT_STATUS_UNSUCCESSFUL
;
574 /**********************************************************************
575 IDMAP MAPPING TDB BACKEND
576 **********************************************************************/
578 struct idmap_tdb_context
{
580 uint32_t filter_low_id
;
581 uint32_t filter_high_id
;
584 /*****************************
585 Initialise idmap database.
586 *****************************/
588 static NTSTATUS
idmap_tdb_db_init(struct idmap_domain
*dom
)
591 struct idmap_tdb_context
*ctx
;
592 char *config_option
= NULL
;
595 ctx
= talloc(dom
, struct idmap_tdb_context
);
597 DEBUG(0, ("Out of memory!\n"));
598 return NT_STATUS_NO_MEMORY
;
601 config_option
= talloc_asprintf(ctx
, "idmap config %s", dom
->name
);
602 if ( ! config_option
) {
603 DEBUG(0, ("Out of memory!\n"));
604 ret
= NT_STATUS_NO_MEMORY
;
608 ret
= idmap_tdb_open_db(ctx
, &ctx
->tdb
);
609 if ( ! NT_STATUS_IS_OK(ret
)) {
613 range
= lp_parm_const_string(-1, config_option
, "range", NULL
);
615 (sscanf(range
, "%u - %u", &ctx
->filter_low_id
, &ctx
->filter_high_id
) != 2) ||
616 (ctx
->filter_low_id
> ctx
->filter_high_id
)) {
617 ctx
->filter_low_id
= 0;
618 ctx
->filter_high_id
= 0;
621 dom
->private_data
= ctx
;
622 dom
->initialized
= True
;
624 talloc_free(config_option
);
632 /**********************************
633 Single id to sid lookup function.
634 **********************************/
636 static NTSTATUS
idmap_tdb_id_to_sid(struct idmap_tdb_context
*ctx
, struct id_map
*map
)
643 return NT_STATUS_INVALID_PARAMETER
;
646 /* apply filters before checking */
647 if ((ctx
->filter_low_id
&& (map
->xid
.id
< ctx
->filter_low_id
)) ||
648 (ctx
->filter_high_id
&& (map
->xid
.id
> ctx
->filter_high_id
))) {
649 DEBUG(5, ("Requested id (%u) out of range (%u - %u). Filtered!\n",
650 map
->xid
.id
, ctx
->filter_low_id
, ctx
->filter_high_id
));
651 return NT_STATUS_NONE_MAPPED
;
654 switch (map
->xid
.type
) {
657 keystr
= talloc_asprintf(ctx
, "UID %lu", (unsigned long)map
->xid
.id
);
661 keystr
= talloc_asprintf(ctx
, "GID %lu", (unsigned long)map
->xid
.id
);
665 DEBUG(2, ("INVALID unix ID type: 0x02%x\n", map
->xid
.type
));
666 return NT_STATUS_INVALID_PARAMETER
;
669 /* final SAFE_FREE safe */
672 if (keystr
== NULL
) {
673 DEBUG(0, ("Out of memory!\n"));
674 ret
= NT_STATUS_NO_MEMORY
;
678 DEBUG(10,("Fetching record %s\n", keystr
));
680 /* Check if the mapping exists */
681 data
= tdb_fetch_bystring(ctx
->tdb
, keystr
);
684 DEBUG(10,("Record %s not found\n", keystr
));
685 ret
= NT_STATUS_NONE_MAPPED
;
689 if (!string_to_sid(map
->sid
, (const char *)data
.dptr
)) {
690 DEBUG(10,("INVALID SID (%s) in record %s\n",
691 (const char *)data
.dptr
, keystr
));
692 ret
= NT_STATUS_INTERNAL_DB_ERROR
;
696 DEBUG(10,("Found record %s -> %s\n", keystr
, (const char *)data
.dptr
));
700 SAFE_FREE(data
.dptr
);
705 /**********************************
706 Single sid to id lookup function.
707 **********************************/
709 static NTSTATUS
idmap_tdb_sid_to_id(struct idmap_tdb_context
*ctx
, struct id_map
*map
)
714 unsigned long rec_id
= 0;
716 if ((keystr
= talloc_asprintf(ctx
, "%s", sid_string_static(map
->sid
))) == NULL
) {
717 DEBUG(0, ("Out of memory!\n"));
718 ret
= NT_STATUS_NO_MEMORY
;
722 DEBUG(10,("Fetching record %s\n", keystr
));
724 /* Check if sid is present in database */
725 data
= tdb_fetch_bystring(ctx
->tdb
, keystr
);
727 DEBUG(10,("Record %s not found\n", keystr
));
728 ret
= NT_STATUS_NONE_MAPPED
;
732 /* What type of record is this ? */
733 if (sscanf((const char *)data
.dptr
, "UID %lu", &rec_id
) == 1) { /* Try a UID record. */
734 map
->xid
.id
= rec_id
;
735 map
->xid
.type
= ID_TYPE_UID
;
736 DEBUG(10,("Found uid record %s -> %s \n", keystr
, (const char *)data
.dptr
));
739 } else if (sscanf((const char *)data
.dptr
, "GID %lu", &rec_id
) == 1) { /* Try a GID record. */
740 map
->xid
.id
= rec_id
;
741 map
->xid
.type
= ID_TYPE_GID
;
742 DEBUG(10,("Found gid record %s -> %s \n", keystr
, (const char *)data
.dptr
));
745 } else { /* Unknown record type ! */
746 DEBUG(2, ("Found INVALID record %s -> %s\n", keystr
, (const char *)data
.dptr
));
747 ret
= NT_STATUS_INTERNAL_DB_ERROR
;
750 SAFE_FREE(data
.dptr
);
752 /* apply filters before returning result */
753 if ((ctx
->filter_low_id
&& (map
->xid
.id
< ctx
->filter_low_id
)) ||
754 (ctx
->filter_high_id
&& (map
->xid
.id
> ctx
->filter_high_id
))) {
755 DEBUG(5, ("Requested id (%u) out of range (%u - %u). Filtered!\n",
756 map
->xid
.id
, ctx
->filter_low_id
, ctx
->filter_high_id
));
757 ret
= NT_STATUS_NONE_MAPPED
;
765 /**********************************
766 lookup a set of unix ids.
767 **********************************/
769 static NTSTATUS
idmap_tdb_unixids_to_sids(struct idmap_domain
*dom
, struct id_map
**ids
)
771 struct idmap_tdb_context
*ctx
;
775 /* make sure we initialized */
776 if ( ! dom
->initialized
) {
777 ret
= idmap_tdb_db_init(dom
);
778 if ( ! NT_STATUS_IS_OK(ret
)) {
783 ctx
= talloc_get_type(dom
->private_data
, struct idmap_tdb_context
);
785 for (i
= 0; ids
[i
]; i
++) {
786 ret
= idmap_tdb_id_to_sid(ctx
, ids
[i
]);
787 if ( ! NT_STATUS_IS_OK(ret
)) {
789 /* if it is just a failed mapping continue */
790 if (NT_STATUS_EQUAL(ret
, NT_STATUS_NONE_MAPPED
)) {
792 /* make sure it is marked as unmapped */
793 ids
[i
]->status
= ID_UNMAPPED
;
797 /* some fatal error occurred, return immediately */
801 /* all ok, id is mapped */
802 ids
[i
]->status
= ID_MAPPED
;
811 /**********************************
812 lookup a set of sids.
813 **********************************/
815 static NTSTATUS
idmap_tdb_sids_to_unixids(struct idmap_domain
*dom
, struct id_map
**ids
)
817 struct idmap_tdb_context
*ctx
;
821 /* make sure we initialized */
822 if ( ! dom
->initialized
) {
823 ret
= idmap_tdb_db_init(dom
);
824 if ( ! NT_STATUS_IS_OK(ret
)) {
829 ctx
= talloc_get_type(dom
->private_data
, struct idmap_tdb_context
);
831 for (i
= 0; ids
[i
]; i
++) {
832 ret
= idmap_tdb_sid_to_id(ctx
, ids
[i
]);
833 if ( ! NT_STATUS_IS_OK(ret
)) {
835 /* if it is just a failed mapping continue */
836 if (NT_STATUS_EQUAL(ret
, NT_STATUS_NONE_MAPPED
)) {
838 /* make sure it is marked as unmapped */
839 ids
[i
]->status
= ID_UNMAPPED
;
843 /* some fatal error occurred, return immediately */
847 /* all ok, id is mapped */
848 ids
[i
]->status
= ID_MAPPED
;
857 /**********************************
859 **********************************/
861 static NTSTATUS
idmap_tdb_set_mapping(struct idmap_domain
*dom
, const struct id_map
*map
)
863 struct idmap_tdb_context
*ctx
;
865 TDB_DATA ksid
, kid
, data
;
866 char *ksidstr
, *kidstr
;
868 /* make sure we initialized */
869 if ( ! dom
->initialized
) {
870 ret
= idmap_tdb_db_init(dom
);
871 if ( ! NT_STATUS_IS_OK(ret
)) {
876 if (!map
|| !map
->sid
) {
877 return NT_STATUS_INVALID_PARAMETER
;
880 ksidstr
= kidstr
= NULL
;
883 /* TODO: should we filter a set_mapping using low/high filters ? */
885 ctx
= talloc_get_type(dom
->private_data
, struct idmap_tdb_context
);
887 switch (map
->xid
.type
) {
890 kidstr
= talloc_asprintf(ctx
, "UID %lu", (unsigned long)map
->xid
.id
);
894 kidstr
= talloc_asprintf(ctx
, "GID %lu", (unsigned long)map
->xid
.id
);
898 DEBUG(2, ("INVALID unix ID type: 0x02%x\n", map
->xid
.type
));
899 return NT_STATUS_INVALID_PARAMETER
;
902 if (kidstr
== NULL
) {
903 DEBUG(0, ("ERROR: Out of memory!\n"));
904 ret
= NT_STATUS_NO_MEMORY
;
908 if ((ksidstr
= talloc_asprintf(ctx
, "%s", sid_string_static(map
->sid
))) == NULL
) {
909 DEBUG(0, ("Out of memory!\n"));
910 ret
= NT_STATUS_NO_MEMORY
;
914 DEBUG(10, ("Storing %s <-> %s map\n", ksidstr
, kidstr
));
915 kid
= string_term_tdb_data(kidstr
);
916 ksid
= string_term_tdb_data(ksidstr
);
918 /* *DELETE* previous mappings if any.
919 * This is done both SID and [U|G]ID passed in */
921 /* Lock the record for this SID. */
922 if (tdb_chainlock(ctx
->tdb
, ksid
) != 0) {
923 DEBUG(10,("Failed to lock record %s. Error %s\n",
924 ksidstr
, tdb_errorstr(ctx
->tdb
) ));
925 return NT_STATUS_UNSUCCESSFUL
;
928 data
= tdb_fetch(ctx
->tdb
, ksid
);
930 DEBUG(10, ("Deleting existing mapping %s <-> %s\n", (const char *)data
.dptr
, ksidstr
));
931 tdb_delete(ctx
->tdb
, data
);
932 tdb_delete(ctx
->tdb
, ksid
);
933 SAFE_FREE(data
.dptr
);
936 data
= tdb_fetch(ctx
->tdb
, kid
);
938 DEBUG(10,("Deleting existing mapping %s <-> %s\n", (const char *)data
.dptr
, kidstr
));
939 tdb_delete(ctx
->tdb
, data
);
940 tdb_delete(ctx
->tdb
, kid
);
941 SAFE_FREE(data
.dptr
);
944 if (tdb_store(ctx
->tdb
, ksid
, kid
, TDB_INSERT
) == -1) {
945 DEBUG(0, ("Error storing SID -> ID: %s\n", tdb_errorstr(ctx
->tdb
)));
946 tdb_chainunlock(ctx
->tdb
, ksid
);
947 ret
= NT_STATUS_UNSUCCESSFUL
;
950 if (tdb_store(ctx
->tdb
, kid
, ksid
, TDB_INSERT
) == -1) {
951 DEBUG(0, ("Error stroing ID -> SID: %s\n", tdb_errorstr(ctx
->tdb
)));
952 /* try to remove the previous stored SID -> ID map */
953 tdb_delete(ctx
->tdb
, ksid
);
954 tdb_chainunlock(ctx
->tdb
, ksid
);
955 ret
= NT_STATUS_UNSUCCESSFUL
;
959 tdb_chainunlock(ctx
->tdb
, ksid
);
960 DEBUG(10,("Stored %s <-> %s\n", ksidstr
, kidstr
));
964 talloc_free(ksidstr
);
966 SAFE_FREE(data
.dptr
);
970 /**********************************
972 **********************************/
974 static NTSTATUS
idmap_tdb_remove_mapping(struct idmap_domain
*dom
, const struct id_map
*map
)
976 struct idmap_tdb_context
*ctx
;
978 TDB_DATA ksid
, kid
, data
;
979 char *ksidstr
, *kidstr
;
981 /* make sure we initialized */
982 if ( ! dom
->initialized
) {
983 ret
= idmap_tdb_db_init(dom
);
984 if ( ! NT_STATUS_IS_OK(ret
)) {
989 if (!map
|| !map
->sid
) {
990 return NT_STATUS_INVALID_PARAMETER
;
993 ksidstr
= kidstr
= NULL
;
996 /* TODO: should we filter a remove_mapping using low/high filters ? */
998 ctx
= talloc_get_type(dom
->private_data
, struct idmap_tdb_context
);
1000 switch (map
->xid
.type
) {
1003 kidstr
= talloc_asprintf(ctx
, "UID %lu", (unsigned long)map
->xid
.id
);
1007 kidstr
= talloc_asprintf(ctx
, "GID %lu", (unsigned long)map
->xid
.id
);
1011 DEBUG(2, ("INVALID unix ID type: 0x02%x\n", map
->xid
.type
));
1012 return NT_STATUS_INVALID_PARAMETER
;
1015 if (kidstr
== NULL
) {
1016 DEBUG(0, ("ERROR: Out of memory!\n"));
1017 ret
= NT_STATUS_NO_MEMORY
;
1021 if ((ksidstr
= talloc_asprintf(ctx
, "%s", sid_string_static(map
->sid
))) == NULL
) {
1022 DEBUG(0, ("Out of memory!\n"));
1023 ret
= NT_STATUS_NO_MEMORY
;
1027 DEBUG(10, ("Checking %s <-> %s map\n", ksidstr
, kidstr
));
1028 ksid
= string_term_tdb_data(ksidstr
);
1029 kid
= string_term_tdb_data(kidstr
);
1031 /* Lock the record for this SID. */
1032 if (tdb_chainlock(ctx
->tdb
, ksid
) != 0) {
1033 DEBUG(10,("Failed to lock record %s. Error %s\n",
1034 ksidstr
, tdb_errorstr(ctx
->tdb
) ));
1035 return NT_STATUS_UNSUCCESSFUL
;
1038 /* Check if sid is present in database */
1039 data
= tdb_fetch(ctx
->tdb
, ksid
);
1041 DEBUG(10,("Record %s not found\n", ksidstr
));
1042 tdb_chainunlock(ctx
->tdb
, ksid
);
1043 ret
= NT_STATUS_NONE_MAPPED
;
1047 /* Check if sid is mapped to the specified ID */
1048 if ((data
.dsize
!= kid
.dsize
) ||
1049 (memcmp(data
.dptr
, kid
.dptr
, data
.dsize
) != 0)) {
1050 DEBUG(10,("Specified SID does not map to specified ID\n"));
1051 DEBUGADD(10,("Actual mapping is %s -> %s\n", ksidstr
, (const char *)data
.dptr
));
1052 tdb_chainunlock(ctx
->tdb
, ksid
);
1053 ret
= NT_STATUS_NONE_MAPPED
;
1057 DEBUG(10, ("Removing %s <-> %s map\n", ksidstr
, kidstr
));
1059 /* Delete previous mappings. */
1061 DEBUG(10, ("Deleting existing mapping %s -> %s\n", ksidstr
, kidstr
));
1062 tdb_delete(ctx
->tdb
, ksid
);
1064 DEBUG(10,("Deleting existing mapping %s -> %s\n", kidstr
, ksidstr
));
1065 tdb_delete(ctx
->tdb
, kid
);
1067 tdb_chainunlock(ctx
->tdb
, ksid
);
1071 talloc_free(ksidstr
);
1072 talloc_free(kidstr
);
1073 SAFE_FREE(data
.dptr
);
1077 /**********************************
1078 Close the idmap tdb instance
1079 **********************************/
1081 static NTSTATUS
idmap_tdb_close(struct idmap_domain
*dom
)
1083 struct idmap_tdb_context
*ctx
;
1085 if (dom
->private_data
) {
1086 ctx
= talloc_get_type(dom
->private_data
, struct idmap_tdb_context
);
1088 if (idmap_tdb_tdb_close(ctx
->tdb
) == 0) {
1089 return NT_STATUS_OK
;
1091 return NT_STATUS_UNSUCCESSFUL
;
1094 return NT_STATUS_OK
;
1099 struct id_map
**maps
;
1104 static int idmap_tdb_dump_one_entry(TDB_CONTEXT
*tdb
, TDB_DATA key
, TDB_DATA value
, void *pdata
)
1106 struct dump_data
*data
= talloc_get_type(pdata
, struct dump_data
);
1107 struct id_map
*maps
;
1108 int num_maps
= *data
->num_maps
;
1110 /* ignore any record but the ones with a SID as key */
1111 if (strncmp((const char *)key
.dptr
, "S-", 2) == 0) {
1113 maps
= talloc_realloc(NULL
, *data
->maps
, struct id_map
, num_maps
+1);
1115 DEBUG(0, ("Out of memory!\n"));
1116 data
->ret
= NT_STATUS_NO_MEMORY
;
1120 maps
[num_maps
].sid
= talloc(maps
, DOM_SID
);
1121 if ( ! maps
[num_maps
].sid
) {
1122 DEBUG(0, ("Out of memory!\n"));
1123 data
->ret
= NT_STATUS_NO_MEMORY
;
1127 if (!string_to_sid(maps
[num_maps
].sid
, (const char *)key
.dptr
)) {
1128 DEBUG(10,("INVALID record %s\n", (const char *)key
.dptr
));
1129 /* continue even with errors */
1133 /* Try a UID record. */
1134 if (sscanf((const char *)value
.dptr
, "UID %u", &(maps
[num_maps
].xid
.id
)) == 1) {
1135 maps
[num_maps
].xid
.type
= ID_TYPE_UID
;
1136 maps
[num_maps
].status
= ID_MAPPED
;
1137 *data
->num_maps
= num_maps
+ 1;
1139 /* Try a GID record. */
1141 if (sscanf((const char *)value
.dptr
, "GID %u", &(maps
[num_maps
].xid
.id
)) == 1) {
1142 maps
[num_maps
].xid
.type
= ID_TYPE_GID
;
1143 maps
[num_maps
].status
= ID_MAPPED
;
1144 *data
->num_maps
= num_maps
+ 1;
1146 /* Unknown record type ! */
1148 maps
[num_maps
].status
= ID_UNKNOWN
;
1149 DEBUG(2, ("Found INVALID record %s -> %s\n",
1150 (const char *)key
.dptr
, (const char *)value
.dptr
));
1151 /* do not increment num_maps */
1158 /**********************************
1159 Dump all mappings out
1160 **********************************/
1162 static NTSTATUS
idmap_tdb_dump_data(struct idmap_domain
*dom
, struct id_map
**maps
, int *num_maps
)
1164 struct idmap_tdb_context
*ctx
;
1165 struct dump_data
*data
;
1166 NTSTATUS ret
= NT_STATUS_OK
;
1168 /* make sure we initialized */
1169 if ( ! dom
->initialized
) {
1170 ret
= idmap_tdb_db_init(dom
);
1171 if ( ! NT_STATUS_IS_OK(ret
)) {
1176 ctx
= talloc_get_type(dom
->private_data
, struct idmap_tdb_context
);
1178 data
= TALLOC_ZERO_P(ctx
, struct dump_data
);
1180 DEBUG(0, ("Out of memory!\n"));
1181 return NT_STATUS_NO_MEMORY
;
1184 data
->num_maps
= num_maps
;
1185 data
->ret
= NT_STATUS_OK
;
1187 tdb_traverse(ctx
->tdb
, idmap_tdb_dump_one_entry
, data
);
1189 if ( ! NT_STATUS_IS_OK(data
->ret
)) {
1197 static struct idmap_methods db_methods
= {
1199 .init
= idmap_tdb_db_init
,
1200 .unixids_to_sids
= idmap_tdb_unixids_to_sids
,
1201 .sids_to_unixids
= idmap_tdb_sids_to_unixids
,
1202 .set_mapping
= idmap_tdb_set_mapping
,
1203 .remove_mapping
= idmap_tdb_remove_mapping
,
1204 .dump_data
= idmap_tdb_dump_data
,
1205 .close_fn
= idmap_tdb_close
1208 static struct idmap_alloc_methods db_alloc_methods
= {
1210 .init
= idmap_tdb_alloc_init
,
1211 .allocate_id
= idmap_tdb_allocate_id
,
1212 .get_id_hwm
= idmap_tdb_get_hwm
,
1213 .set_id_hwm
= idmap_tdb_set_hwm
,
1214 .close_fn
= idmap_tdb_alloc_close
1217 NTSTATUS
idmap_alloc_tdb_init(void)
1219 return smb_register_idmap_alloc(SMB_IDMAP_INTERFACE_VERSION
, "tdb", &db_alloc_methods
);
1222 NTSTATUS
idmap_tdb_init(void)
1226 /* FIXME: bad hack to actually register also the alloc_tdb module without changining configure.in */
1227 ret
= idmap_alloc_tdb_init();
1228 if (! NT_STATUS_IS_OK(ret
)) {
1231 return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION
, "tdb", &db_methods
);