libcli/security Provide a common, top level libcli/security/security.h
[nivanova/samba-autobuild/.git] / source3 / winbindd / idmap_ldap.c
1 /*
2    Unix SMB/CIFS implementation.
3
4    idmap LDAP backend
5
6    Copyright (C) Tim Potter             2000
7    Copyright (C) Jim McDonough <jmcd@us.ibm.com>        2003
8    Copyright (C) Gerald Carter          2003
9    Copyright (C) Simo Sorce             2003-2007
10    Copyright (C) Michael Adam           2010
11
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 3 of the License, or
15    (at your option) any later version.
16
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
24 */
25
26 #include "includes.h"
27 #include "winbindd.h"
28 #include "secrets.h"
29 #include "idmap.h"
30 #include "idmap_rw.h"
31 #include "../libcli/security/security.h"
32
33 #undef DBGC_CLASS
34 #define DBGC_CLASS DBGC_IDMAP
35
36 #include <lber.h>
37 #include <ldap.h>
38
39 #include "smbldap.h"
40
41 static char *idmap_fetch_secret(const char *backend, bool alloc,
42                                 const char *domain, const char *identity)
43 {
44         char *tmp, *ret;
45         int r;
46
47         if (alloc) {
48                 r = asprintf(&tmp, "IDMAP_ALLOC_%s", backend);
49         } else {
50                 r = asprintf(&tmp, "IDMAP_%s_%s", backend, domain);
51         }
52
53         if (r < 0)
54                 return NULL;
55
56         strupper_m(tmp); /* make sure the key is case insensitive */
57         ret = secrets_fetch_generic(tmp, identity);
58
59         SAFE_FREE(tmp);
60
61         return ret;
62 }
63
64 struct idmap_ldap_alloc_context {
65         struct smbldap_state *smbldap_state;
66         char *url;
67         char *suffix;
68         char *user_dn;
69 };
70
71 struct idmap_ldap_context {
72         struct smbldap_state *smbldap_state;
73         char *url;
74         char *suffix;
75         char *user_dn;
76         bool anon;
77         struct idmap_ldap_alloc_context *alloc;
78         struct idmap_rw_ops *rw_ops;
79 };
80
81 #define CHECK_ALLOC_DONE(mem) do { \
82         if (!mem) { \
83                 DEBUG(0, ("Out of memory!\n")); \
84                 ret = NT_STATUS_NO_MEMORY; \
85                 goto done; \
86         } } while (0)
87
88 /**********************************************************************
89  IDMAP ALLOC TDB BACKEND
90 **********************************************************************/
91
92 /*********************************************************************
93  ********************************************************************/
94
95 static NTSTATUS get_credentials( TALLOC_CTX *mem_ctx,
96                                  struct smbldap_state *ldap_state,
97                                  const char *config_option,
98                                  struct idmap_domain *dom,
99                                  char **dn )
100 {
101         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
102         char *secret = NULL;
103         const char *tmp = NULL;
104         char *user_dn = NULL;
105         bool anon = False;
106
107         /* assume anonymous if we don't have a specified user */
108
109         tmp = lp_parm_const_string(-1, config_option, "ldap_user_dn", NULL);
110
111         if ( tmp ) {
112                 if (!dom) {
113                         /* only the alloc backend can pass in a NULL dom */
114                         secret = idmap_fetch_secret("ldap", True,
115                                                     NULL, tmp);
116                 } else {
117                         secret = idmap_fetch_secret("ldap", False,
118                                                     dom->name, tmp);
119                 }
120
121                 if (!secret) {
122                         DEBUG(0, ("get_credentials: Unable to fetch "
123                                   "auth credentials for %s in %s\n",
124                                   tmp, (dom==NULL)?"ALLOC":dom->name));
125                         ret = NT_STATUS_ACCESS_DENIED;
126                         goto done;
127                 }
128                 *dn = talloc_strdup(mem_ctx, tmp);
129                 CHECK_ALLOC_DONE(*dn);
130         } else {
131                 if (!fetch_ldap_pw(&user_dn, &secret)) {
132                         DEBUG(2, ("get_credentials: Failed to lookup ldap "
133                                   "bind creds. Using anonymous connection.\n"));
134                         anon = True;
135                         *dn = NULL;
136                 } else {
137                         *dn = talloc_strdup(mem_ctx, user_dn);
138                         SAFE_FREE( user_dn );
139                         CHECK_ALLOC_DONE(*dn);
140                 }
141         }
142
143         smbldap_set_creds(ldap_state, anon, *dn, secret);
144         ret = NT_STATUS_OK;
145
146 done:
147         SAFE_FREE(secret);
148
149         return ret;
150 }
151
152
153 /**********************************************************************
154  Verify the sambaUnixIdPool entry in the directory.
155 **********************************************************************/
156
157 static NTSTATUS verify_idpool(struct idmap_domain *dom)
158 {
159         NTSTATUS ret;
160         TALLOC_CTX *mem_ctx;
161         LDAPMessage *result = NULL;
162         LDAPMod **mods = NULL;
163         const char **attr_list;
164         char *filter;
165         int count;
166         int rc;
167         struct idmap_ldap_context *ctx;
168
169         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
170
171         if (!ctx->alloc) {
172                 return NT_STATUS_UNSUCCESSFUL;
173         }
174
175         mem_ctx = talloc_new(ctx->alloc);
176         if (mem_ctx == NULL) {
177                 DEBUG(0, ("Out of memory!\n"));
178                 return NT_STATUS_NO_MEMORY;
179         }
180
181         filter = talloc_asprintf(mem_ctx, "(objectclass=%s)", LDAP_OBJ_IDPOOL);
182         CHECK_ALLOC_DONE(filter);
183
184         attr_list = get_attr_list(mem_ctx, idpool_attr_list);
185         CHECK_ALLOC_DONE(attr_list);
186
187         rc = smbldap_search(ctx->alloc->smbldap_state,
188                                 ctx->alloc->suffix,
189                                 LDAP_SCOPE_SUBTREE,
190                                 filter,
191                                 attr_list,
192                                 0,
193                                 &result);
194
195         if (rc != LDAP_SUCCESS) {
196                 DEBUG(1, ("Unable to verify the idpool, "
197                           "cannot continue initialization!\n"));
198                 return NT_STATUS_UNSUCCESSFUL;
199         }
200
201         count = ldap_count_entries(ctx->alloc->smbldap_state->ldap_struct,
202                                    result);
203
204         ldap_msgfree(result);
205
206         if ( count > 1 ) {
207                 DEBUG(0,("Multiple entries returned from %s (base == %s)\n",
208                         filter, ctx->alloc->suffix));
209                 ret = NT_STATUS_UNSUCCESSFUL;
210                 goto done;
211         }
212         else if (count == 0) {
213                 char *uid_str, *gid_str;
214
215                 uid_str = talloc_asprintf(mem_ctx, "%lu",
216                                 (unsigned long)dom->low_id);
217                 gid_str = talloc_asprintf(mem_ctx, "%lu",
218                                 (unsigned long)dom->low_id);
219
220                 smbldap_set_mod(&mods, LDAP_MOD_ADD,
221                                 "objectClass", LDAP_OBJ_IDPOOL);
222                 smbldap_set_mod(&mods, LDAP_MOD_ADD,
223                                 get_attr_key2string(idpool_attr_list,
224                                                     LDAP_ATTR_UIDNUMBER),
225                                 uid_str);
226                 smbldap_set_mod(&mods, LDAP_MOD_ADD,
227                                 get_attr_key2string(idpool_attr_list,
228                                                     LDAP_ATTR_GIDNUMBER),
229                                 gid_str);
230                 if (mods) {
231                         rc = smbldap_modify(ctx->alloc->smbldap_state,
232                                                 ctx->alloc->suffix,
233                                                 mods);
234                         ldap_mods_free(mods, True);
235                 } else {
236                         ret = NT_STATUS_UNSUCCESSFUL;
237                         goto done;
238                 }
239         }
240
241         ret = (rc == LDAP_SUCCESS)?NT_STATUS_OK:NT_STATUS_UNSUCCESSFUL;
242 done:
243         talloc_free(mem_ctx);
244         return ret;
245 }
246
247 /*****************************************************************************
248  Initialise idmap database.
249 *****************************************************************************/
250
251 static int idmap_ldap_alloc_close_destructor(struct idmap_ldap_alloc_context *ctx)
252 {
253         smbldap_free_struct(&ctx->smbldap_state);
254         DEBUG(5,("The connection to the LDAP server was closed\n"));
255         /* maybe free the results here --metze */
256         return 0;
257 }
258
259 static NTSTATUS idmap_ldap_alloc_init(struct idmap_domain *dom,
260                                       const char *params)
261 {
262         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
263         const char *tmp;
264         struct idmap_ldap_context *ctx;
265
266         /* Only do init if we are online */
267         if (idmap_is_offline()) {
268                 return NT_STATUS_FILE_IS_OFFLINE;
269         }
270
271         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
272
273         ctx->alloc = talloc_zero(ctx, struct idmap_ldap_alloc_context);
274         CHECK_ALLOC_DONE(ctx->alloc);
275
276         if (params && *params) {
277                 /* assume location is the only parameter */
278                 ctx->alloc->url = talloc_strdup(ctx->alloc, params);
279         } else {
280                 tmp = lp_parm_const_string(-1, "idmap alloc config",
281                                            "ldap_url", NULL);
282
283                 if ( ! tmp) {
284                         DEBUG(1, ("ERROR: missing idmap ldap url\n"));
285                         ret = NT_STATUS_UNSUCCESSFUL;
286                         goto done;
287                 }
288
289                 ctx->alloc->url = talloc_strdup(ctx->alloc, tmp);
290         }
291         CHECK_ALLOC_DONE(ctx->alloc->url);
292
293         trim_char(ctx->alloc->url, '\"', '\"');
294
295         tmp = lp_parm_const_string(-1, "idmap alloc config",
296                                    "ldap_base_dn", NULL);
297         if ( ! tmp || ! *tmp) {
298                 tmp = lp_ldap_idmap_suffix();
299                 if ( ! tmp) {
300                         DEBUG(1, ("ERROR: missing idmap ldap suffix\n"));
301                         ret = NT_STATUS_UNSUCCESSFUL;
302                         goto done;
303                 }
304         }
305
306         ctx->alloc->suffix = talloc_strdup(ctx->alloc, tmp);
307         CHECK_ALLOC_DONE(ctx->alloc->suffix);
308
309         ret = smbldap_init(ctx->alloc, winbind_event_context(),
310                            ctx->alloc->url,
311                            &ctx->alloc->smbldap_state);
312         if (!NT_STATUS_IS_OK(ret)) {
313                 DEBUG(1, ("ERROR: smbldap_init (%s) failed!\n",
314                           ctx->alloc->url));
315                 goto done;
316         }
317
318         talloc_set_destructor(ctx->alloc, idmap_ldap_alloc_close_destructor);
319
320         ret = get_credentials(ctx->alloc,
321                               ctx->alloc->smbldap_state,
322                               "idmap alloc config", NULL,
323                               &ctx->alloc->user_dn);
324         if ( !NT_STATUS_IS_OK(ret) ) {
325                 DEBUG(1,("idmap_ldap_alloc_init: Failed to get connection "
326                          "credentials (%s)\n", nt_errstr(ret)));
327                 goto done;
328         }
329
330         /* see if the idmap suffix and sub entries exists */
331
332         ret = verify_idpool(dom);
333
334  done:
335         if ( !NT_STATUS_IS_OK( ret ) )
336                 TALLOC_FREE(ctx->alloc);
337
338         return ret;
339 }
340
341 /********************************
342  Allocate a new uid or gid
343 ********************************/
344
345 static NTSTATUS idmap_ldap_allocate_id(struct idmap_domain *dom,
346                                        struct unixid *xid)
347 {
348         TALLOC_CTX *mem_ctx;
349         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
350         int rc = LDAP_SERVER_DOWN;
351         int count = 0;
352         LDAPMessage *result = NULL;
353         LDAPMessage *entry = NULL;
354         LDAPMod **mods = NULL;
355         char *id_str;
356         char *new_id_str;
357         char *filter = NULL;
358         const char *dn = NULL;
359         const char **attr_list;
360         const char *type;
361         struct idmap_ldap_context *ctx;
362
363         /* Only do query if we are online */
364         if (idmap_is_offline()) {
365                 return NT_STATUS_FILE_IS_OFFLINE;
366         }
367
368         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
369
370         if (!ctx->alloc) {
371                 return NT_STATUS_UNSUCCESSFUL;
372         }
373
374         mem_ctx = talloc_new(ctx->alloc);
375         if (!mem_ctx) {
376                 DEBUG(0, ("Out of memory!\n"));
377                 return NT_STATUS_NO_MEMORY;
378         }
379
380         /* get type */
381         switch (xid->type) {
382
383         case ID_TYPE_UID:
384                 type = get_attr_key2string(idpool_attr_list,
385                                            LDAP_ATTR_UIDNUMBER);
386                 break;
387
388         case ID_TYPE_GID:
389                 type = get_attr_key2string(idpool_attr_list,
390                                            LDAP_ATTR_GIDNUMBER);
391                 break;
392
393         default:
394                 DEBUG(2, ("Invalid ID type (0x%x)\n", xid->type));
395                 return NT_STATUS_INVALID_PARAMETER;
396         }
397
398         filter = talloc_asprintf(mem_ctx, "(objectClass=%s)", LDAP_OBJ_IDPOOL);
399         CHECK_ALLOC_DONE(filter);
400
401         attr_list = get_attr_list(mem_ctx, idpool_attr_list);
402         CHECK_ALLOC_DONE(attr_list);
403
404         DEBUG(10, ("Search of the id pool (filter: %s)\n", filter));
405
406         rc = smbldap_search(ctx->alloc->smbldap_state,
407                                 ctx->alloc->suffix,
408                                LDAP_SCOPE_SUBTREE, filter,
409                                attr_list, 0, &result);
410
411         if (rc != LDAP_SUCCESS) {
412                 DEBUG(0,("%s object not found\n", LDAP_OBJ_IDPOOL));
413                 goto done;
414         }
415
416         talloc_autofree_ldapmsg(mem_ctx, result);
417
418         count = ldap_count_entries(ctx->alloc->smbldap_state->ldap_struct,
419                                    result);
420         if (count != 1) {
421                 DEBUG(0,("Single %s object not found\n", LDAP_OBJ_IDPOOL));
422                 goto done;
423         }
424
425         entry = ldap_first_entry(ctx->alloc->smbldap_state->ldap_struct,
426                                  result);
427
428         dn = smbldap_talloc_dn(mem_ctx,
429                                ctx->alloc->smbldap_state->ldap_struct,
430                                entry);
431         if ( ! dn) {
432                 goto done;
433         }
434
435         id_str = smbldap_talloc_single_attribute(
436                                 ctx->alloc->smbldap_state->ldap_struct,
437                                 entry, type, mem_ctx);
438         if (id_str == NULL) {
439                 DEBUG(0,("%s attribute not found\n", type));
440                 ret = NT_STATUS_UNSUCCESSFUL;
441                 goto done;
442         }
443
444         xid->id = strtoul(id_str, NULL, 10);
445
446         /* make sure we still have room to grow */
447
448         switch (xid->type) {
449         case ID_TYPE_UID:
450                 if (xid->id > dom->high_id) {
451                         DEBUG(0,("Cannot allocate uid above %lu!\n",
452                                  (unsigned long)dom->high_id));
453                         goto done;
454                 }
455                 break;
456
457         case ID_TYPE_GID:
458                 if (xid->id > dom->high_id) {
459                         DEBUG(0,("Cannot allocate gid above %lu!\n",
460                                  (unsigned long)dom->high_id));
461                         goto done;
462                 }
463                 break;
464
465         default:
466                 /* impossible */
467                 goto done;
468         }
469
470         new_id_str = talloc_asprintf(mem_ctx, "%lu", (unsigned long)xid->id + 1);
471         if ( ! new_id_str) {
472                 DEBUG(0,("Out of memory\n"));
473                 ret = NT_STATUS_NO_MEMORY;
474                 goto done;
475         }
476
477         smbldap_set_mod(&mods, LDAP_MOD_DELETE, type, id_str);
478         smbldap_set_mod(&mods, LDAP_MOD_ADD, type, new_id_str);
479
480         if (mods == NULL) {
481                 DEBUG(0,("smbldap_set_mod() failed.\n"));
482                 goto done;
483         }
484
485         DEBUG(10, ("Try to atomically increment the id (%s -> %s)\n",
486                    id_str, new_id_str));
487
488         rc = smbldap_modify(ctx->alloc->smbldap_state, dn, mods);
489
490         ldap_mods_free(mods, True);
491
492         if (rc != LDAP_SUCCESS) {
493                 DEBUG(1,("Failed to allocate new %s. "
494                          "smbldap_modify() failed.\n", type));
495                 goto done;
496         }
497
498         ret = NT_STATUS_OK;
499
500 done:
501         talloc_free(mem_ctx);
502         return ret;
503 }
504
505 /**
506  * Allocate a new unix-ID.
507  * For now this is for the default idmap domain only.
508  * Should be extended later on.
509  */
510 static NTSTATUS idmap_ldap_get_new_id(struct idmap_domain *dom,
511                                       struct unixid *id)
512 {
513         NTSTATUS ret;
514
515         if (!strequal(dom->name, "*")) {
516                 DEBUG(3, ("idmap_ldap_get_new_id: "
517                           "Refusing allocation of a new unixid for domain'%s'. "
518                           "Currently only supported for the default "
519                           "domain \"*\".\n",
520                            dom->name));
521                 return NT_STATUS_NOT_IMPLEMENTED;
522         }
523
524         ret = idmap_ldap_allocate_id(dom, id);
525
526         return ret;
527 }
528
529
530 /**********************************************************************
531  IDMAP MAPPING LDAP BACKEND
532 **********************************************************************/
533
534 static int idmap_ldap_close_destructor(struct idmap_ldap_context *ctx)
535 {
536         smbldap_free_struct(&ctx->smbldap_state);
537         DEBUG(5,("The connection to the LDAP server was closed\n"));
538         /* maybe free the results here --metze */
539
540         return 0;
541 }
542
543 /********************************
544  Initialise idmap database.
545 ********************************/
546
547 static NTSTATUS idmap_ldap_set_mapping(struct idmap_domain *dom,
548                                        const struct id_map *map);
549
550 static NTSTATUS idmap_ldap_db_init(struct idmap_domain *dom,
551                                    const char *params)
552 {
553         NTSTATUS ret;
554         struct idmap_ldap_context *ctx = NULL;
555         char *config_option = NULL;
556         const char *tmp = NULL;
557
558         /* Only do init if we are online */
559         if (idmap_is_offline()) {
560                 return NT_STATUS_FILE_IS_OFFLINE;
561         }
562
563         ctx = TALLOC_ZERO_P(dom, struct idmap_ldap_context);
564         if ( ! ctx) {
565                 DEBUG(0, ("Out of memory!\n"));
566                 return NT_STATUS_NO_MEMORY;
567         }
568
569         if (strequal(dom->name, "*")) {
570                 /* more specific configuration can go here */
571         } else {
572                 config_option = talloc_asprintf(ctx, "idmap config %s", dom->name);
573                 if ( ! config_option) {
574                         DEBUG(0, ("Out of memory!\n"));
575                         ret = NT_STATUS_NO_MEMORY;
576                         goto done;
577                 }
578         }
579
580         if (params != NULL) {
581                 /* assume location is the only parameter */
582                 ctx->url = talloc_strdup(ctx, params);
583         } else {
584                 tmp = lp_parm_const_string(-1, config_option, "ldap_url", NULL);
585
586                 if ( ! tmp) {
587                         DEBUG(1, ("ERROR: missing idmap ldap url\n"));
588                         ret = NT_STATUS_UNSUCCESSFUL;
589                         goto done;
590                 }
591
592                 ctx->url = talloc_strdup(ctx, tmp);
593         }
594         CHECK_ALLOC_DONE(ctx->url);
595
596         trim_char(ctx->url, '\"', '\"');
597
598         tmp = lp_parm_const_string(-1, config_option, "ldap_base_dn", NULL);
599         if ( ! tmp || ! *tmp) {
600                 tmp = lp_ldap_idmap_suffix();
601                 if ( ! tmp) {
602                         DEBUG(1, ("ERROR: missing idmap ldap suffix\n"));
603                         ret = NT_STATUS_UNSUCCESSFUL;
604                         goto done;
605                 }
606         }
607
608         ctx->suffix = talloc_strdup(ctx, tmp);
609         CHECK_ALLOC_DONE(ctx->suffix);
610
611         ctx->rw_ops = talloc_zero(ctx, struct idmap_rw_ops);
612         CHECK_ALLOC_DONE(ctx->rw_ops);
613
614         ctx->rw_ops->get_new_id = idmap_ldap_get_new_id;
615         ctx->rw_ops->set_mapping = idmap_ldap_set_mapping;
616
617         ret = smbldap_init(ctx, winbind_event_context(), ctx->url,
618                            &ctx->smbldap_state);
619         if (!NT_STATUS_IS_OK(ret)) {
620                 DEBUG(1, ("ERROR: smbldap_init (%s) failed!\n", ctx->url));
621                 goto done;
622         }
623
624         ret = get_credentials( ctx, ctx->smbldap_state, config_option,
625                                dom, &ctx->user_dn );
626         if ( !NT_STATUS_IS_OK(ret) ) {
627                 DEBUG(1,("idmap_ldap_db_init: Failed to get connection "
628                          "credentials (%s)\n", nt_errstr(ret)));
629                 goto done;
630         }
631
632         /* set the destructor on the context, so that resource are properly
633            freed if the contexts is released */
634
635         talloc_set_destructor(ctx, idmap_ldap_close_destructor);
636
637         dom->private_data = ctx;
638
639         ret = idmap_ldap_alloc_init(dom, params);
640         if (!NT_STATUS_IS_OK(ret)) {
641                 DEBUG(1, ("idmap_ldap_db_init: Failed to initialize alloc "
642                           "subsystem: %s\n", nt_errstr(ret)));
643                 goto done;
644         }
645
646         talloc_free(config_option);
647         return NT_STATUS_OK;
648
649 /*failed */
650 done:
651         talloc_free(ctx);
652         return ret;
653 }
654
655 /**
656  * set a mapping.
657  */
658
659 /* TODO: change this:  This function cannot be called to modify a mapping,
660  * only set a new one */
661
662 static NTSTATUS idmap_ldap_set_mapping(struct idmap_domain *dom,
663                                        const struct id_map *map)
664 {
665         NTSTATUS ret;
666         TALLOC_CTX *memctx;
667         struct idmap_ldap_context *ctx;
668         LDAPMessage *entry = NULL;
669         LDAPMod **mods = NULL;
670         const char *type;
671         char *id_str;
672         char *sid;
673         char *dn;
674         int rc = -1;
675
676         /* Only do query if we are online */
677         if (idmap_is_offline()) {
678                 return NT_STATUS_FILE_IS_OFFLINE;
679         }
680
681         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
682
683         switch(map->xid.type) {
684         case ID_TYPE_UID:
685                 type = get_attr_key2string(sidmap_attr_list,
686                                            LDAP_ATTR_UIDNUMBER);
687                 break;
688
689         case ID_TYPE_GID:
690                 type = get_attr_key2string(sidmap_attr_list,
691                                            LDAP_ATTR_GIDNUMBER);
692                 break;
693
694         default:
695                 return NT_STATUS_INVALID_PARAMETER;
696         }
697
698         memctx = talloc_new(ctx);
699         if ( ! memctx) {
700                 DEBUG(0, ("Out of memory!\n"));
701                 return NT_STATUS_NO_MEMORY;
702         }
703
704         id_str = talloc_asprintf(memctx, "%lu", (unsigned long)map->xid.id);
705         CHECK_ALLOC_DONE(id_str);
706
707         sid = talloc_strdup(memctx, sid_string_talloc(memctx, map->sid));
708         CHECK_ALLOC_DONE(sid);
709
710         dn = talloc_asprintf(memctx, "%s=%s,%s",
711                         get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
712                         sid,
713                         ctx->suffix);
714         CHECK_ALLOC_DONE(dn);
715
716         smbldap_set_mod(&mods, LDAP_MOD_ADD,
717                         "objectClass", LDAP_OBJ_IDMAP_ENTRY);
718
719         smbldap_make_mod(ctx->smbldap_state->ldap_struct,
720                          entry, &mods, type, id_str);
721
722         smbldap_make_mod(ctx->smbldap_state->ldap_struct, entry, &mods,
723                          get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
724                          sid);
725
726         if ( ! mods) {
727                 DEBUG(2, ("ERROR: No mods?\n"));
728                 ret = NT_STATUS_UNSUCCESSFUL;
729                 goto done;
730         }
731
732         /* TODO: remove conflicting mappings! */
733
734         smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_SID_ENTRY);
735
736         DEBUG(10, ("Set DN %s (%s -> %s)\n", dn, sid, id_str));
737
738         rc = smbldap_add(ctx->smbldap_state, dn, mods);
739         ldap_mods_free(mods, True);
740
741         if (rc != LDAP_SUCCESS) {
742                 char *ld_error = NULL;
743                 ldap_get_option(ctx->smbldap_state->ldap_struct,
744                                 LDAP_OPT_ERROR_STRING, &ld_error);
745                 DEBUG(0,("ldap_set_mapping_internals: Failed to add %s to %lu "
746                          "mapping [%s]\n", sid,
747                          (unsigned long)map->xid.id, type));
748                 DEBUG(0, ("ldap_set_mapping_internals: Error was: %s (%s)\n",
749                         ld_error ? ld_error : "(NULL)", ldap_err2string (rc)));
750                 if (ld_error) {
751                         ldap_memfree(ld_error);
752                 }
753                 ret = NT_STATUS_UNSUCCESSFUL;
754                 goto done;
755         }
756
757         DEBUG(10,("ldap_set_mapping: Successfully created mapping from %s to "
758                   "%lu [%s]\n", sid, (unsigned long)map->xid.id, type));
759
760         ret = NT_STATUS_OK;
761
762 done:
763         talloc_free(memctx);
764         return ret;
765 }
766
767 /**
768  * Create a new mapping for an unmapped SID, also allocating a new ID.
769  * If possible, this should be run inside a transaction to make the
770  * action atomic.
771  */
772 static NTSTATUS idmap_ldap_new_mapping(struct idmap_domain *dom, struct id_map *map)
773 {
774         NTSTATUS ret;
775         struct idmap_ldap_context *ctx;
776
777         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
778
779         ret = idmap_rw_new_mapping(dom, ctx->rw_ops, map);
780
781         return ret;
782 }
783
784
785 /* max number of ids requested per batch query */
786 #define IDMAP_LDAP_MAX_IDS 30
787
788 /**********************************
789  lookup a set of unix ids.
790 **********************************/
791
792 /* this function searches up to IDMAP_LDAP_MAX_IDS entries
793  * in maps for a match */
794 static struct id_map *find_map_by_id(struct id_map **maps,
795                                      enum id_type type,
796                                      uint32_t id)
797 {
798         int i;
799
800         for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
801                 if (maps[i] == NULL) { /* end of the run */
802                         return NULL;
803                 }
804                 if ((maps[i]->xid.type == type) && (maps[i]->xid.id == id)) {
805                         return maps[i];
806                 }
807         }
808
809         return NULL;
810 }
811
812 static NTSTATUS idmap_ldap_unixids_to_sids(struct idmap_domain *dom,
813                                            struct id_map **ids)
814 {
815         NTSTATUS ret;
816         TALLOC_CTX *memctx;
817         struct idmap_ldap_context *ctx;
818         LDAPMessage *result = NULL;
819         LDAPMessage *entry = NULL;
820         const char *uidNumber;
821         const char *gidNumber;
822         const char **attr_list;
823         char *filter = NULL;
824         bool multi = False;
825         int idx = 0;
826         int bidx = 0;
827         int count;
828         int rc;
829         int i;
830
831         /* Only do query if we are online */
832         if (idmap_is_offline()) {
833                 return NT_STATUS_FILE_IS_OFFLINE;
834         }
835
836         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
837
838         memctx = talloc_new(ctx);
839         if ( ! memctx) {
840                 DEBUG(0, ("Out of memory!\n"));
841                 return NT_STATUS_NO_MEMORY;
842         }
843
844         uidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_UIDNUMBER);
845         gidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_GIDNUMBER);
846
847         attr_list = get_attr_list(memctx, sidmap_attr_list);
848
849         if ( ! ids[1]) {
850                 /* if we are requested just one mapping use the simple filter */
851
852                 filter = talloc_asprintf(memctx, "(&(objectClass=%s)(%s=%lu))",
853                                 LDAP_OBJ_IDMAP_ENTRY,
854                                 (ids[0]->xid.type==ID_TYPE_UID)?uidNumber:gidNumber,
855                                 (unsigned long)ids[0]->xid.id);
856                 CHECK_ALLOC_DONE(filter);
857                 DEBUG(10, ("Filter: [%s]\n", filter));
858         } else {
859                 /* multiple mappings */
860                 multi = True;
861         }
862
863         for (i = 0; ids[i]; i++) {
864                 ids[i]->status = ID_UNKNOWN;
865         }
866
867 again:
868         if (multi) {
869
870                 talloc_free(filter);
871                 filter = talloc_asprintf(memctx,
872                                          "(&(objectClass=%s)(|",
873                                          LDAP_OBJ_IDMAP_ENTRY);
874                 CHECK_ALLOC_DONE(filter);
875
876                 bidx = idx;
877                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
878                         filter = talloc_asprintf_append_buffer(filter, "(%s=%lu)",
879                                         (ids[idx]->xid.type==ID_TYPE_UID)?uidNumber:gidNumber,
880                                         (unsigned long)ids[idx]->xid.id);
881                         CHECK_ALLOC_DONE(filter);
882                 }
883                 filter = talloc_asprintf_append_buffer(filter, "))");
884                 CHECK_ALLOC_DONE(filter);
885                 DEBUG(10, ("Filter: [%s]\n", filter));
886         } else {
887                 bidx = 0;
888                 idx = 1;
889         }
890
891         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
892                 filter, attr_list, 0, &result);
893
894         if (rc != LDAP_SUCCESS) {
895                 DEBUG(3,("Failure looking up ids (%s)\n", ldap_err2string(rc)));
896                 ret = NT_STATUS_UNSUCCESSFUL;
897                 goto done;
898         }
899
900         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
901
902         if (count == 0) {
903                 DEBUG(10, ("NO SIDs found\n"));
904         }
905
906         for (i = 0; i < count; i++) {
907                 char *sidstr = NULL;
908                 char *tmp = NULL;
909                 enum id_type type;
910                 struct id_map *map;
911                 uint32_t id;
912
913                 if (i == 0) { /* first entry */
914                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
915                                                  result);
916                 } else { /* following ones */
917                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
918                                                 entry);
919                 }
920                 if ( ! entry) {
921                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
922                                   "from results\n"));
923                         break;
924                 }
925
926                 /* first check if the SID is present */
927                 sidstr = smbldap_talloc_single_attribute(
928                                 ctx->smbldap_state->ldap_struct,
929                                 entry, LDAP_ATTRIBUTE_SID, memctx);
930                 if ( ! sidstr) { /* no sid, skip entry */
931                         DEBUG(2, ("WARNING SID not found on entry\n"));
932                         continue;
933                 }
934
935                 /* now try to see if it is a uid, if not try with a gid
936                  * (gid is more common, but in case both uidNumber and
937                  * gidNumber are returned the SID is mapped to the uid
938                  *not the gid) */
939                 type = ID_TYPE_UID;
940                 tmp = smbldap_talloc_single_attribute(
941                                 ctx->smbldap_state->ldap_struct,
942                                 entry, uidNumber, memctx);
943                 if ( ! tmp) {
944                         type = ID_TYPE_GID;
945                         tmp = smbldap_talloc_single_attribute(
946                                         ctx->smbldap_state->ldap_struct,
947                                         entry, gidNumber, memctx);
948                 }
949                 if ( ! tmp) { /* wow very strange entry, how did it match ? */
950                         DEBUG(5, ("Unprobable match on (%s), no uidNumber, "
951                                   "nor gidNumber returned\n", sidstr));
952                         TALLOC_FREE(sidstr);
953                         continue;
954                 }
955
956                 id = strtoul(tmp, NULL, 10);
957                 if (!idmap_unix_id_is_in_range(id, dom)) {
958                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
959                                   "Filtered!\n", id,
960                                   dom->low_id, dom->high_id));
961                         TALLOC_FREE(sidstr);
962                         TALLOC_FREE(tmp);
963                         continue;
964                 }
965                 TALLOC_FREE(tmp);
966
967                 map = find_map_by_id(&ids[bidx], type, id);
968                 if (!map) {
969                         DEBUG(2, ("WARNING: couldn't match sid (%s) "
970                                   "with requested ids\n", sidstr));
971                         TALLOC_FREE(sidstr);
972                         continue;
973                 }
974
975                 if ( ! string_to_sid(map->sid, sidstr)) {
976                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
977                         TALLOC_FREE(sidstr);
978                         continue;
979                 }
980
981                 if (map->status == ID_MAPPED) {
982                         DEBUG(1, ("WARNING: duplicate %s mapping in LDAP. "
983                               "overwriting mapping %u -> %s with %u -> %s\n",
984                               (type == ID_TYPE_UID) ? "UID" : "GID",
985                               id, sid_string_dbg(map->sid), id, sidstr));
986                 }
987
988                 TALLOC_FREE(sidstr);
989
990                 /* mapped */
991                 map->status = ID_MAPPED;
992
993                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
994                            (unsigned long)map->xid.id, map->xid.type));
995         }
996
997         /* free the ldap results */
998         if (result) {
999                 ldap_msgfree(result);
1000                 result = NULL;
1001         }
1002
1003         if (multi && ids[idx]) { /* still some values to map */
1004                 goto again;
1005         }
1006
1007         ret = NT_STATUS_OK;
1008
1009         /* mark all unknwon/expired ones as unmapped */
1010         for (i = 0; ids[i]; i++) {
1011                 if (ids[i]->status != ID_MAPPED)
1012                         ids[i]->status = ID_UNMAPPED;
1013         }
1014
1015 done:
1016         talloc_free(memctx);
1017         return ret;
1018 }
1019
1020 /**********************************
1021  lookup a set of sids.
1022 **********************************/
1023
1024 /* this function searches up to IDMAP_LDAP_MAX_IDS entries
1025  * in maps for a match */
1026 static struct id_map *find_map_by_sid(struct id_map **maps, struct dom_sid *sid)
1027 {
1028         int i;
1029
1030         for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
1031                 if (maps[i] == NULL) { /* end of the run */
1032                         return NULL;
1033                 }
1034                 if (dom_sid_equal(maps[i]->sid, sid)) {
1035                         return maps[i];
1036                 }
1037         }
1038
1039         return NULL;
1040 }
1041
1042 static NTSTATUS idmap_ldap_sids_to_unixids(struct idmap_domain *dom,
1043                                            struct id_map **ids)
1044 {
1045         LDAPMessage *entry = NULL;
1046         NTSTATUS ret;
1047         TALLOC_CTX *memctx;
1048         struct idmap_ldap_context *ctx;
1049         LDAPMessage *result = NULL;
1050         const char *uidNumber;
1051         const char *gidNumber;
1052         const char **attr_list;
1053         char *filter = NULL;
1054         bool multi = False;
1055         int idx = 0;
1056         int bidx = 0;
1057         int count;
1058         int rc;
1059         int i;
1060
1061         /* Only do query if we are online */
1062         if (idmap_is_offline()) {
1063                 return NT_STATUS_FILE_IS_OFFLINE;
1064         }
1065
1066         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
1067
1068         memctx = talloc_new(ctx);
1069         if ( ! memctx) {
1070                 DEBUG(0, ("Out of memory!\n"));
1071                 return NT_STATUS_NO_MEMORY;
1072         }
1073
1074         uidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_UIDNUMBER);
1075         gidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_GIDNUMBER);
1076
1077         attr_list = get_attr_list(memctx, sidmap_attr_list);
1078
1079         if ( ! ids[1]) {
1080                 /* if we are requested just one mapping use the simple filter */
1081
1082                 filter = talloc_asprintf(memctx, "(&(objectClass=%s)(%s=%s))",
1083                                 LDAP_OBJ_IDMAP_ENTRY,
1084                                 LDAP_ATTRIBUTE_SID,
1085                                 sid_string_talloc(memctx, ids[0]->sid));
1086                 CHECK_ALLOC_DONE(filter);
1087                 DEBUG(10, ("Filter: [%s]\n", filter));
1088         } else {
1089                 /* multiple mappings */
1090                 multi = True;
1091         }
1092
1093         for (i = 0; ids[i]; i++) {
1094                 ids[i]->status = ID_UNKNOWN;
1095         }
1096
1097 again:
1098         if (multi) {
1099
1100                 TALLOC_FREE(filter);
1101                 filter = talloc_asprintf(memctx,
1102                                          "(&(objectClass=%s)(|",
1103                                          LDAP_OBJ_IDMAP_ENTRY);
1104                 CHECK_ALLOC_DONE(filter);
1105
1106                 bidx = idx;
1107                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
1108                         filter = talloc_asprintf_append_buffer(filter, "(%s=%s)",
1109                                         LDAP_ATTRIBUTE_SID,
1110                                         sid_string_talloc(memctx,
1111                                                           ids[idx]->sid));
1112                         CHECK_ALLOC_DONE(filter);
1113                 }
1114                 filter = talloc_asprintf_append_buffer(filter, "))");
1115                 CHECK_ALLOC_DONE(filter);
1116                 DEBUG(10, ("Filter: [%s]", filter));
1117         } else {
1118                 bidx = 0;
1119                 idx = 1;
1120         }
1121
1122         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
1123                 filter, attr_list, 0, &result);
1124
1125         if (rc != LDAP_SUCCESS) {
1126                 DEBUG(3,("Failure looking up sids (%s)\n",
1127                          ldap_err2string(rc)));
1128                 ret = NT_STATUS_UNSUCCESSFUL;
1129                 goto done;
1130         }
1131
1132         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
1133
1134         if (count == 0) {
1135                 DEBUG(10, ("NO SIDs found\n"));
1136         }
1137
1138         for (i = 0; i < count; i++) {
1139                 char *sidstr = NULL;
1140                 char *tmp = NULL;
1141                 enum id_type type;
1142                 struct id_map *map;
1143                 struct dom_sid sid;
1144                 uint32_t id;
1145
1146                 if (i == 0) { /* first entry */
1147                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
1148                                                  result);
1149                 } else { /* following ones */
1150                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
1151                                                 entry);
1152                 }
1153                 if ( ! entry) {
1154                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
1155                                   "from results\n"));
1156                         break;
1157                 }
1158
1159                 /* first check if the SID is present */
1160                 sidstr = smbldap_talloc_single_attribute(
1161                                 ctx->smbldap_state->ldap_struct,
1162                                 entry, LDAP_ATTRIBUTE_SID, memctx);
1163                 if ( ! sidstr) { /* no sid ??, skip entry */
1164                         DEBUG(2, ("WARNING SID not found on entry\n"));
1165                         continue;
1166                 }
1167
1168                 if ( ! string_to_sid(&sid, sidstr)) {
1169                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
1170                         TALLOC_FREE(sidstr);
1171                         continue;
1172                 }
1173
1174                 map = find_map_by_sid(&ids[bidx], &sid);
1175                 if (!map) {
1176                         DEBUG(2, ("WARNING: couldn't find entry sid (%s) "
1177                                   "in ids", sidstr));
1178                         TALLOC_FREE(sidstr);
1179                         continue;
1180                 }
1181
1182                 /* now try to see if it is a uid, if not try with a gid
1183                  * (gid is more common, but in case both uidNumber and
1184                  * gidNumber are returned the SID is mapped to the uid
1185                  * not the gid) */
1186                 type = ID_TYPE_UID;
1187                 tmp = smbldap_talloc_single_attribute(
1188                                 ctx->smbldap_state->ldap_struct,
1189                                 entry, uidNumber, memctx);
1190                 if ( ! tmp) {
1191                         type = ID_TYPE_GID;
1192                         tmp = smbldap_talloc_single_attribute(
1193                                         ctx->smbldap_state->ldap_struct,
1194                                         entry, gidNumber, memctx);
1195                 }
1196                 if ( ! tmp) { /* no ids ?? */
1197                         DEBUG(5, ("no uidNumber, "
1198                                   "nor gidNumber attributes found\n"));
1199                         TALLOC_FREE(sidstr);
1200                         continue;
1201                 }
1202
1203                 id = strtoul(tmp, NULL, 10);
1204                 if (!idmap_unix_id_is_in_range(id, dom)) {
1205                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
1206                                   "Filtered!\n", id,
1207                                   dom->low_id, dom->high_id));
1208                         TALLOC_FREE(sidstr);
1209                         TALLOC_FREE(tmp);
1210                         continue;
1211                 }
1212                 TALLOC_FREE(tmp);
1213
1214                 if (map->status == ID_MAPPED) {
1215                         DEBUG(1, ("WARNING: duplicate %s mapping in LDAP. "
1216                               "overwriting mapping %s -> %u with %s -> %u\n",
1217                               (type == ID_TYPE_UID) ? "UID" : "GID",
1218                               sidstr, map->xid.id, sidstr, id));
1219                 }
1220
1221                 TALLOC_FREE(sidstr);
1222
1223                 /* mapped */
1224                 map->xid.type = type;
1225                 map->xid.id = id;
1226                 map->status = ID_MAPPED;
1227
1228                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
1229                            (unsigned long)map->xid.id, map->xid.type));
1230         }
1231
1232         /* free the ldap results */
1233         if (result) {
1234                 ldap_msgfree(result);
1235                 result = NULL;
1236         }
1237
1238         if (multi && ids[idx]) { /* still some values to map */
1239                 goto again;
1240         }
1241
1242         /*
1243          *  try to create new mappings for unmapped sids
1244          */
1245         for (i = 0; ids[i]; i++) {
1246                 if (ids[i]->status != ID_MAPPED) {
1247                         ids[i]->status = ID_UNMAPPED;
1248                         if (ids[i]->sid != NULL) {
1249                                 ret = idmap_ldap_new_mapping(dom, ids[i]);
1250                                 if (!NT_STATUS_IS_OK(ret)) {
1251                                         goto done;
1252                                 }
1253                         }
1254                 }
1255         }
1256
1257         ret = NT_STATUS_OK;
1258
1259 done:
1260         talloc_free(memctx);
1261         return ret;
1262 }
1263
1264 /**********************************
1265  Close the idmap ldap instance
1266 **********************************/
1267
1268 static NTSTATUS idmap_ldap_close(struct idmap_domain *dom)
1269 {
1270         struct idmap_ldap_context *ctx;
1271
1272         if (dom->private_data) {
1273                 ctx = talloc_get_type(dom->private_data,
1274                                       struct idmap_ldap_context);
1275
1276                 talloc_free(ctx);
1277                 dom->private_data = NULL;
1278         }
1279
1280         return NT_STATUS_OK;
1281 }
1282
1283 static struct idmap_methods idmap_ldap_methods = {
1284
1285         .init = idmap_ldap_db_init,
1286         .unixids_to_sids = idmap_ldap_unixids_to_sids,
1287         .sids_to_unixids = idmap_ldap_sids_to_unixids,
1288         .allocate_id = idmap_ldap_get_new_id,
1289         .close_fn = idmap_ldap_close
1290 };
1291
1292 NTSTATUS idmap_ldap_init(void);
1293 NTSTATUS idmap_ldap_init(void)
1294 {
1295         return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "ldap",
1296                                   &idmap_ldap_methods);
1297 }
1298