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