8eafc2532b42477695fc6aabdb44ad1d0bf15ce9
[sfrench/samba-autobuild/.git] / source / groupdb / mapping_ldb.c
1 /* 
2  *  Unix SMB/CIFS implementation.
3  *
4  *  group mapping code on top of ldb
5  *
6  *  Copyright (C) Andrew Tridgell              2006
7  *
8  * based on tdb group mapping code from groupdb/mapping.c
9  *  
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 2 of the License, or
13  *  (at your option) any later version.
14  *  
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *  
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, write to the Free Software
22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25 #include "includes.h"
26 #include "groupdb/mapping.h"
27 #include "lib/ldb/include/includes.h"
28 #include "lib/ldb/include/ldb_errors.h"
29
30 static struct ldb_context *ldb;
31
32 static BOOL mapping_upgrade(const char *tdb_path);
33
34 /*
35   connect to the group mapping ldb
36 */
37 static BOOL init_group_mapping(void)
38 {
39         BOOL existed;
40         const char *init_ldif[] = 
41                 { "dn: @ATTRIBUTES\n" \
42                   "ntName: CASE_INSENSITIVE\n" \
43                   "\n",
44                   "dn: @INDEXLIST\n" \
45                   "@IDXATTR: gidNumber\n" \
46                   "@IDXATTR: ntName\n" \
47                   "@IDXATTR: member\n" };
48         const char *db_path, *tdb_path;
49         int ret;
50         int flags = 0;
51
52         if (ldb != NULL) {
53                 return True;
54         }
55
56         /* this is needed as Samba3 doesn't have this globally yet */
57         ldb_global_init();
58
59         db_path = lock_path("group_mapping.ldb");
60
61         ldb = ldb_init(NULL);
62         if (ldb == NULL) goto failed;
63
64         existed = file_exist(db_path, NULL);
65
66         if (lp_parm_bool(-1, "groupmap", "nosync", False)) {
67                 flags |= LDB_FLG_NOSYNC;
68         }
69
70         ret = ldb_connect(ldb, db_path, flags, NULL);
71         if (ret != LDB_SUCCESS) {
72                 goto failed;
73         }
74         
75         if (!existed) {
76                 /* initialise the ldb with an index */
77                 struct ldb_ldif *ldif;
78                 int i;
79                 for (i=0;i<ARRAY_SIZE(init_ldif);i++) {
80                         ldif = ldb_ldif_read_string(ldb, &init_ldif[i]);
81                         if (ldif == NULL) goto failed;
82                         ret = ldb_add(ldb, ldif->msg);
83                         talloc_free(ldif);
84                         if (ret == -1) goto failed;
85                 }
86         }
87
88         /* possibly upgrade */
89         tdb_path = lock_path("group_mapping.tdb");
90         if (file_exist(tdb_path, NULL) && !mapping_upgrade(tdb_path)) {
91                 unlink(lock_path("group_mapping.ldb"));
92                 goto failed;
93         }
94
95         return True;
96
97 failed:
98         DEBUG(0,("Failed to open group mapping ldb '%s' - '%s'\n",
99                  db_path, ldb?ldb_errstring(ldb):strerror(errno)));
100         talloc_free(ldb);
101         ldb = NULL;
102         return False;
103 }
104
105
106 /*
107   form the DN for a mapping entry from a SID
108  */
109 static struct ldb_dn *mapping_dn(TALLOC_CTX *mem_ctx, const DOM_SID *sid)
110 {
111         fstring string_sid;
112         uint32_t rid;
113         DOM_SID domsid;
114
115         sid_copy(&domsid, sid);
116         if (!sid_split_rid(&domsid, &rid)) {
117                 return NULL;
118         }
119         if (!sid_to_string(string_sid, &domsid)) {
120                 return NULL;
121         }
122         /* we split by domain and rid so we can do a subtree search
123            when we only want one domain */
124         return ldb_dn_string_compose(mem_ctx, NULL, "rid=%u,domain=%s", 
125                                      rid, string_sid);
126 }
127
128 /*
129   add a group mapping entry
130  */
131 static BOOL add_mapping_entry(GROUP_MAP *map, int flag)
132 {
133         struct ldb_message *msg;        
134         int ret, i;
135         fstring string_sid;
136
137         msg = ldb_msg_new(ldb);
138         if (msg == NULL) {
139                 return False;
140         }
141
142         msg->dn = mapping_dn(msg, &map->sid);
143         if (msg->dn == NULL) {
144                 goto failed;
145         }
146
147         if (ldb_msg_add_string(msg, "objectClass", "groupMap") != LDB_SUCCESS ||
148             ldb_msg_add_string(msg, "sid", 
149                                sid_to_string(string_sid, &map->sid)) != LDB_SUCCESS ||
150             ldb_msg_add_fmt(msg, "gidNumber", "%u", (unsigned)map->gid) != LDB_SUCCESS ||
151             ldb_msg_add_fmt(msg, "sidNameUse", "%u", (unsigned)map->sid_name_use) != LDB_SUCCESS ||
152             ldb_msg_add_string(msg, "comment", map->comment) != LDB_SUCCESS ||
153             ldb_msg_add_string(msg, "ntName", map->nt_name) != LDB_SUCCESS) {
154                 goto failed;
155         }
156
157         ret = ldb_add(ldb, msg);
158
159         /* if it exists we update it. This is a hangover from the semantics the
160            tdb backend had */
161         if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
162                 for (i=0;i<msg->num_elements;i++) {
163                         msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
164                 }
165                 ret = ldb_modify(ldb, msg);
166         }
167
168         talloc_free(msg);
169
170         return ret == LDB_SUCCESS;
171
172 failed:
173         talloc_free(msg);
174         return False;
175 }
176
177 /*
178   unpack a ldb message into a GROUP_MAP structure
179 */
180 static BOOL msg_to_group_map(struct ldb_message *msg, GROUP_MAP *map)
181 {
182         const char *sidstr;
183
184         map->gid          = ldb_msg_find_attr_as_int(msg, "gidNumber", -1);
185         map->sid_name_use = ldb_msg_find_attr_as_int(msg, "sidNameUse", -1);
186         fstrcpy(map->nt_name, ldb_msg_find_attr_as_string(msg, "ntName", NULL));
187         fstrcpy(map->comment, ldb_msg_find_attr_as_string(msg, "comment", NULL));
188         sidstr = ldb_msg_find_attr_as_string(msg, "sid", NULL);
189
190         if (!string_to_sid(&map->sid, sidstr) ||
191             map->gid == (gid_t)-1 ||
192             map->sid_name_use == (enum lsa_SidType)-1) {
193                 DEBUG(0,("Unable to unpack group mapping\n"));
194                 return False;
195         }
196
197         return True;
198 }
199
200 /*
201  return a group map entry for a given sid
202 */
203 static BOOL get_group_map_from_sid(DOM_SID sid, GROUP_MAP *map)
204 {
205         int ret;
206         struct ldb_dn *dn;
207         struct ldb_result *res=NULL;
208         
209         dn = mapping_dn(ldb, &sid);
210         if (dn == NULL) goto failed;
211
212         ret = ldb_search(ldb, dn, LDB_SCOPE_BASE, NULL, NULL, &res);
213         talloc_steal(dn, res);
214         if (ret != LDB_SUCCESS || res->count != 1) {
215                 goto failed;
216         }
217
218         if (!msg_to_group_map(res->msgs[0], map)) goto failed;
219
220         talloc_free(dn);
221         return True;
222
223 failed:
224         talloc_free(dn);
225         return False;
226 }
227
228 /*
229  return a group map entry for a given gid
230 */
231 static BOOL get_group_map_from_gid(gid_t gid, GROUP_MAP *map)
232 {
233         int ret;
234         char *expr;
235         struct ldb_result *res=NULL;
236
237         expr = talloc_asprintf(ldb, "(&(gidNumber=%u)(objectClass=groupMap))", 
238                                (unsigned)gid);
239         if (expr == NULL) goto failed;
240
241         ret = ldb_search(ldb, NULL, LDB_SCOPE_SUBTREE, expr, NULL, &res);
242         talloc_steal(expr, res);
243         if (ret != LDB_SUCCESS || res->count != 1) goto failed;
244         
245         if (!msg_to_group_map(res->msgs[0], map)) goto failed;
246
247         talloc_free(expr);
248         return True;
249
250 failed:
251         talloc_free(expr);
252         return False;
253 }
254
255 /*
256   Return the sid and the type of the unix group.
257 */
258 static BOOL get_group_map_from_ntname(const char *name, GROUP_MAP *map)
259 {
260         int ret;
261         char *expr;
262         struct ldb_result *res=NULL;
263
264         expr = talloc_asprintf(ldb, "(&(ntName=%s)(objectClass=groupMap))", name);
265         if (expr == NULL) goto failed;
266
267         ret = ldb_search(ldb, NULL, LDB_SCOPE_SUBTREE, expr, NULL, &res);
268         talloc_steal(expr, res);
269         if (ret != LDB_SUCCESS || res->count != 1) goto failed;
270         
271         if (!msg_to_group_map(res->msgs[0], map)) goto failed;
272
273         talloc_free(expr);
274         return True;
275
276 failed:
277         talloc_free(expr);
278         return False;
279 }
280
281 /*
282  Remove a group mapping entry.
283 */
284 static BOOL group_map_remove(const DOM_SID *sid)
285 {
286         struct ldb_dn *dn;
287         int ret;
288         
289         dn = mapping_dn(ldb, sid);
290         if (dn == NULL) {
291                 return False;
292         }
293         ret = ldb_delete(ldb, dn);
294         talloc_free(dn);
295
296         return ret == LDB_SUCCESS;
297 }
298
299
300 /*
301   Enumerate the group mappings for a domain
302 */
303 static BOOL enum_group_mapping(const DOM_SID *domsid, enum lsa_SidType sid_name_use, 
304                                GROUP_MAP **pp_rmap,
305                                size_t *p_num_entries, BOOL unix_only)
306 {
307         int i, ret;
308         char *expr;
309         fstring name;
310         struct ldb_result *res;
311         struct ldb_dn *basedn=NULL;
312         TALLOC_CTX *tmp_ctx;
313
314         tmp_ctx = talloc_new(ldb);
315         if (tmp_ctx == NULL) goto failed;
316
317         if (sid_name_use == SID_NAME_UNKNOWN) {
318                 expr = talloc_asprintf(tmp_ctx, "(&(objectClass=groupMap))");
319         } else {
320                 expr = talloc_asprintf(tmp_ctx, "(&(sidNameUse=%u)(objectClass=groupMap))",
321                                        sid_name_use);
322         }
323         if (expr == NULL) goto failed;
324
325         /* we do a subtree search on the domain */
326         if (domsid != NULL) {
327                 sid_to_string(name, domsid);
328                 basedn = ldb_dn_string_compose(tmp_ctx, NULL, "domain=%s", name);
329                 if (basedn == NULL) goto failed;
330         }
331
332         ret = ldb_search(ldb, basedn, LDB_SCOPE_SUBTREE, expr, NULL, &res);
333         if (ret != LDB_SUCCESS) goto failed;
334
335         (*pp_rmap) = NULL;
336         *p_num_entries = 0;
337
338         for (i=0;i<res->count;i++) {
339                 (*pp_rmap) = SMB_REALLOC_ARRAY((*pp_rmap), GROUP_MAP, 
340                                                (*p_num_entries)+1);
341                 if (!(*pp_rmap)) goto failed;
342
343                 if (!msg_to_group_map(res->msgs[i], &(*pp_rmap)[*p_num_entries])) {
344                         goto failed;
345                 }
346
347                 (*p_num_entries)++;
348         }
349
350         talloc_free(tmp_ctx);
351         return True;
352
353 failed:
354         talloc_free(tmp_ctx);
355         return False;   
356 }
357
358 /* 
359    This operation happens on session setup, so it should better be fast. We
360    store a list of aliases a SID is member of hanging off MEMBEROF/SID. 
361 */
362 static NTSTATUS one_alias_membership(const DOM_SID *member,
363                                      DOM_SID **sids, size_t *num)
364 {
365         const char *attrs[] = {
366                 "sid",
367                 NULL
368         };
369         DOM_SID alias;
370         char *expr;
371         int ret, i;
372         struct ldb_result *res=NULL;
373         fstring string_sid;
374         NTSTATUS status = NT_STATUS_INTERNAL_DB_CORRUPTION;
375
376         if (!sid_to_string(string_sid, member)) {
377                 return NT_STATUS_INVALID_PARAMETER;
378         }
379
380         expr = talloc_asprintf(ldb, "(&(member=%s)(objectClass=groupMap))", 
381                                string_sid);
382         if (expr == NULL) goto failed;
383
384         ret = ldb_search(ldb, NULL, LDB_SCOPE_SUBTREE, expr, attrs, &res);
385         talloc_steal(expr, res);
386         if (ret != LDB_SUCCESS) {
387                 goto failed;
388         }
389
390         for (i=0;i<res->count;i++) {
391                 struct ldb_message_element *el;
392                 el = ldb_msg_find_element(res->msgs[i], "sid");
393                 if (el == NULL || el->num_values != 1) {
394                         status = NT_STATUS_INTERNAL_DB_CORRUPTION;
395                         goto failed;
396                 }
397                 string_to_sid(&alias, (char *)el->values[0].data);
398                 if (!add_sid_to_array_unique(NULL, &alias, sids, num)) {
399                         status = NT_STATUS_NO_MEMORY;
400                         goto failed;
401                 }
402         }
403
404         talloc_free(expr);
405         return NT_STATUS_OK;
406
407 failed:
408         talloc_free(expr);
409         return status;
410 }
411
412 /*
413   add/remove a member field
414 */
415 static NTSTATUS modify_aliasmem(const DOM_SID *alias, const DOM_SID *member,
416                                 int operation)
417 {
418         fstring string_sid;
419         int ret;
420         struct ldb_message msg;
421         struct ldb_message_element el;
422         struct ldb_val val;
423         TALLOC_CTX *tmp_ctx;
424         GROUP_MAP map;
425
426         if (!get_group_map_from_sid(*alias, &map)) {
427                 sid_to_string(string_sid, alias);
428                 return NT_STATUS_NO_SUCH_ALIAS;
429         }
430
431         if ((map.sid_name_use != SID_NAME_ALIAS) &&
432             (map.sid_name_use != SID_NAME_WKN_GRP)) {
433                 DEBUG(0,("sid_name_use=%d\n", map.sid_name_use));
434                 return NT_STATUS_NO_SUCH_ALIAS;
435         }
436
437         tmp_ctx = talloc_new(NULL);
438         if (tmp_ctx == NULL) {
439                 return NT_STATUS_NO_MEMORY;
440         }
441
442         msg.dn = mapping_dn(tmp_ctx, alias);
443         if (msg.dn == NULL) {
444                 return NT_STATUS_NO_MEMORY;
445         }
446         msg.num_elements = 1;
447         msg.elements = &el;
448         el.flags = operation;
449         el.name = talloc_strdup(tmp_ctx, "member");
450         el.num_values = 1;
451         el.values = &val;
452         sid_to_string(string_sid, member);
453         val.data = (uint8_t *)string_sid;
454         val.length = strlen(string_sid);
455
456         ret = ldb_modify(ldb, &msg);
457         talloc_free(tmp_ctx);
458
459         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
460                 return NT_STATUS_NO_SUCH_ALIAS;
461         }
462
463         if (operation == LDB_FLAG_MOD_ADD &&
464             ret == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) {
465                 return NT_STATUS_MEMBER_IN_ALIAS;
466         }
467
468         return (ret == LDB_SUCCESS ? NT_STATUS_OK : NT_STATUS_ACCESS_DENIED);
469 }
470
471 static NTSTATUS add_aliasmem(const DOM_SID *alias, const DOM_SID *member)
472 {
473         return modify_aliasmem(alias, member, LDB_FLAG_MOD_ADD);
474 }
475
476 static NTSTATUS del_aliasmem(const DOM_SID *alias, const DOM_SID *member)
477 {
478         return modify_aliasmem(alias, member, LDB_FLAG_MOD_DELETE);
479 }
480
481
482 /*
483   enumerate sids that have the given alias set in member
484 */
485 static NTSTATUS enum_aliasmem(const DOM_SID *alias, DOM_SID **sids, size_t *num)
486 {
487         const char *attrs[] = {
488                 "member",
489                 NULL
490         };
491         int ret, i;
492         struct ldb_result *res=NULL;
493         struct ldb_dn *dn;
494         struct ldb_message_element *el;
495         
496         *sids = NULL;
497         *num = 0;
498
499         dn = mapping_dn(ldb, alias);
500         if (dn == NULL) {
501                 return NT_STATUS_NO_MEMORY;
502         }
503
504         ret = ldb_search(ldb, dn, LDB_SCOPE_BASE, NULL, attrs, &res);
505         talloc_steal(dn, res);
506         if (ret == LDB_SUCCESS && res->count == 0) {
507                 talloc_free(dn);
508                 return NT_STATUS_OK;
509         }
510         if (ret != LDB_SUCCESS) {
511                 talloc_free(dn);
512                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
513         }
514
515         el = ldb_msg_find_element(res->msgs[0], "member");
516         if (el == NULL) {
517                 talloc_free(dn);
518                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
519         }
520         
521         for (i=0;i<el->num_values;i++) {
522                 DOM_SID sid;
523                 string_to_sid(&sid, (const char *)el->values[i].data);
524                 if (!add_sid_to_array_unique(NULL, &sid, sids, num)) {
525                         talloc_free(dn);
526                         return NT_STATUS_NO_MEMORY;
527                 }
528         }
529         talloc_free(dn);
530
531         return NT_STATUS_OK;
532 }
533
534 /*
535   upgrade one group mapping record from the old tdb format
536 */
537 static int upgrade_map_record(TDB_CONTEXT *tdb_ctx, TDB_DATA key, 
538                               TDB_DATA data, void *state)
539 {
540         int ret;
541         GROUP_MAP map;
542
543         if (strncmp((char *)key.dptr, GROUP_PREFIX, 
544                     MIN(key.dsize, strlen(GROUP_PREFIX))) != 0) {
545                 return 0;
546         }
547
548         if (!string_to_sid(&map.sid, strlen(GROUP_PREFIX) + (const char *)key.dptr)) {
549                 DEBUG(0,("Bad sid key '%s' during upgrade\n", (const char *)key.dptr));
550                 *(int *)state = -1;
551                 return -1;
552         }
553
554         ret = tdb_unpack(data.dptr, data.dsize, "ddff",
555                          &map.gid, &map.sid_name_use, &map.nt_name, &map.comment);
556         if (ret == -1) {
557                 DEBUG(0,("Failed to unpack group map record during upgrade\n"));
558                 *(int *)state = -1;
559                 return -1;
560         }
561
562         if (!add_mapping_entry(&map, 0)) {
563                 DEBUG(0,("Failed to add mapping entry during upgrade\n"));
564                 *(int *)state = -1;
565                 return -1;
566         }
567
568         return 0;
569 }
570
571 /*
572   upgrade one alias record from the old tdb format
573 */
574 static int upgrade_alias_record(TDB_CONTEXT *tdb_ctx, TDB_DATA key, 
575                                 TDB_DATA data, void *state)
576 {
577         const char *p = (const char *)data.dptr;
578         fstring string_sid;
579         DOM_SID member;
580
581         if (strncmp((char *)key.dptr, MEMBEROF_PREFIX, 
582                     MIN(key.dsize, strlen(MEMBEROF_PREFIX))) != 0) {
583                 return 0;
584         }
585
586         if (!string_to_sid(&member, strlen(MEMBEROF_PREFIX) + (const char *)key.dptr)) {
587                 DEBUG(0,("Bad alias key %s during upgrade\n",
588                          (const char *)key.dptr));
589                 *(int *)state = -1;
590         }
591
592         while (next_token(&p, string_sid, " ", sizeof(string_sid))) {
593                 DOM_SID alias;
594                 NTSTATUS status;
595                 string_to_sid(&alias, string_sid);
596                 status = add_aliasmem(&alias, &member);
597                 if (NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_ALIAS)) {
598                         DEBUG(0,("Ignoring orphaned alias record '%s'\n", 
599                                  string_sid));
600                 } else if (!NT_STATUS_IS_OK(status)) {
601                         DEBUG(0,("Failed to add alias member during upgrade - %s\n",
602                                  nt_errstr(status)));
603                         *(int *)state = -1;
604                         return -1;
605                 }
606         }
607
608         return 0;
609 }
610
611 /*
612   upgrade from a old style tdb
613 */
614 static BOOL mapping_upgrade(const char *tdb_path)
615 {
616         static TDB_CONTEXT *tdb;
617         int ret, status=0;
618         pstring old_path;
619         pstring new_path;
620
621         tdb = tdb_open_log(tdb_path, 0, TDB_DEFAULT, O_RDWR, 0600);
622         if (tdb == NULL) goto failed;
623
624         /* we have to do the map records first, as alias records may
625            reference them */
626         ret = tdb_traverse(tdb, upgrade_map_record, &status);
627         if (ret == -1 || status == -1) goto failed;
628
629         ret = tdb_traverse(tdb, upgrade_alias_record, &status);
630         if (ret == -1 || status == -1) goto failed;
631
632         if (tdb) {
633                 tdb_close(tdb);
634                 tdb = NULL;
635         }
636
637         pstrcpy(old_path, tdb_path);
638         pstrcpy(new_path, lock_path("group_mapping.tdb.upgraded"));
639
640         if (rename(old_path, new_path) != 0) {
641                 DEBUG(0,("Failed to rename old group mapping database\n"));
642                 goto failed;
643         }
644         return True;
645
646 failed:
647         DEBUG(0,("Failed to upgrade group mapping database\n"));
648         if (tdb) tdb_close(tdb);
649         return False;
650 }
651
652
653
654 static const struct mapping_backend ldb_backend = {
655         .add_mapping_entry         = add_mapping_entry,
656         .get_group_map_from_sid    = get_group_map_from_sid,
657         .get_group_map_from_gid    = get_group_map_from_gid,
658         .get_group_map_from_ntname = get_group_map_from_ntname,
659         .group_map_remove          = group_map_remove,
660         .enum_group_mapping        = enum_group_mapping,
661         .one_alias_membership      = one_alias_membership,
662         .add_aliasmem              = add_aliasmem,
663         .del_aliasmem              = del_aliasmem,
664         .enum_aliasmem             = enum_aliasmem      
665 };
666
667 /*
668   initialise the ldb mapping backend
669  */
670 const struct mapping_backend *groupdb_ldb_init(void)
671 {
672         if (!init_group_mapping()) {
673                 DEBUG(0,("Failed to initialise ldb mapping backend\n"));
674                 return NULL;
675         }
676
677         return &ldb_backend;
678 }