2 * Unix SMB/CIFS implementation.
4 * Id mapping using LDAP records as defined in RFC 2307
6 * The SID<->uid/gid mapping is performed in two steps: 1) Query the
7 * AD server for the name<->sid mapping. 2) Query an LDAP server
8 * according to RFC 2307 for the name<->uid/gid mapping.
10 * Copyright (C) Christof Schmitt 2012,2013
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.
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.
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/>.
31 #include "nsswitch/winbind_client.h"
32 #include "lib/winbind_util.h"
35 * Config and connection info per domain.
37 struct idmap_rfc2307_context {
38 const char *bind_path_user;
39 const char *bind_path_group;
40 const char *ldap_domain;
46 * Pointer to ldap struct in ads or smbldap_state, has to be
47 * updated after connecting to server
51 /* Optional function to check connection to server */
52 NTSTATUS (*check_connection)(struct idmap_domain *dom);
54 /* Issue ldap query */
55 NTSTATUS (*search)(struct idmap_rfc2307_context *ctx,
56 const char *bind_path, const char *expr,
57 const char **attrs, LDAPMessage **res);
59 /* Access to LDAP in AD server */
62 /* Access to stand-alone LDAP server */
63 struct smbldap_state *smbldap_state;
67 * backend functions for LDAP queries through ADS
70 static NTSTATUS idmap_rfc2307_ads_check_connection(struct idmap_domain *dom)
72 struct idmap_rfc2307_context *ctx;
73 const char *dom_name = dom->name;
76 DEBUG(10, ("ad_idmap_cached_connection: called for domain '%s'\n",
79 ctx = talloc_get_type(dom->private_data, struct idmap_rfc2307_context);
80 dom_name = ctx->ldap_domain ? ctx->ldap_domain : dom->name;
82 status = ads_idmap_cached_connection(&ctx->ads, dom_name);
83 if (ADS_ERR_OK(status)) {
84 ctx->ldap = ctx->ads->ldap.ld;
86 ctx->realm = ctx->ads->server.realm;
89 DEBUG(1, ("Could not connect to domain %s: %s\n", dom->name,
93 return ads_ntstatus(status);
96 static NTSTATUS idmap_rfc2307_ads_search(struct idmap_rfc2307_context *ctx,
97 const char *bind_path,
100 LDAPMessage **result)
104 status = ads_do_search_retry(ctx->ads, bind_path,
105 LDAP_SCOPE_SUBTREE, expr, attrs, result);
106 return ads_ntstatus(status);
109 static NTSTATUS idmap_rfc2307_init_ads(struct idmap_rfc2307_context *ctx,
112 const char *ldap_domain;
114 ctx->search = idmap_rfc2307_ads_search;
115 ctx->check_connection = idmap_rfc2307_ads_check_connection;
117 ldap_domain = lp_parm_const_string(-1, cfg_opt, "ldap_domain",
120 ctx->ldap_domain = talloc_strdup(ctx, ldap_domain);
121 if (ctx->ldap_domain == NULL) {
122 return NT_STATUS_NO_MEMORY;
130 * backend function for LDAP queries through stand-alone LDAP server
133 static NTSTATUS idmap_rfc2307_ldap_search(struct idmap_rfc2307_context *ctx,
134 const char *bind_path,
137 LDAPMessage **result)
141 ret = smbldap_search(ctx->smbldap_state, bind_path, LDAP_SCOPE_SUBTREE,
142 expr, attrs, 0, result);
143 ctx->ldap = ctx->smbldap_state->ldap_struct;
145 if (ret == LDAP_SUCCESS) {
149 return NT_STATUS_LDAP(ret);
152 static bool idmap_rfc2307_get_uint32(LDAP *ldap, LDAPMessage *entry,
153 const char *field, uint32 *value)
158 b = smbldap_get_single_attribute(ldap, entry, field, str, sizeof(str));
167 static NTSTATUS idmap_rfc2307_init_ldap(struct idmap_rfc2307_context *ctx,
168 struct idmap_domain *dom,
169 const char *config_option)
174 const char *ldap_url, *user_dn, *ldap_realm;
175 TALLOC_CTX *mem_ctx = ctx;
177 ldap_url = lp_parm_const_string(-1, config_option, "ldap_url", NULL);
179 DEBUG(1, ("ERROR: missing idmap ldap url\n"));
180 return NT_STATUS_UNSUCCESSFUL;
183 url = talloc_strdup(talloc_tos(), ldap_url);
185 user_dn = lp_parm_const_string(-1, config_option, "ldap_user_dn", NULL);
187 secret = idmap_fetch_secret("ldap", dom->name, user_dn);
189 ret = NT_STATUS_ACCESS_DENIED;
194 /* assume anonymous if we don't have a specified user */
195 ret = smbldap_init(mem_ctx, winbind_event_context(), url,
196 (user_dn == NULL), user_dn, secret,
197 &ctx->smbldap_state);
199 if (!NT_STATUS_IS_OK(ret)) {
200 DEBUG(1, ("ERROR: smbldap_init (%s) failed!\n", url));
204 ctx->search = idmap_rfc2307_ldap_search;
207 ldap_realm = lp_parm_const_string(-1, config_option,
210 DEBUG(1, ("ERROR: cn_realm set, "
211 "but ldap_realm is missing\n"));
212 ret = NT_STATUS_UNSUCCESSFUL;
215 ctx->realm = talloc_strdup(mem_ctx, ldap_realm);
217 ret = NT_STATUS_NO_MEMORY;
227 * common code for stand-alone LDAP and ADS
230 static void idmap_rfc2307_map_sid_results(struct idmap_rfc2307_context *ctx,
234 const char *dom_name,
235 const char **attrs, int type)
240 count = ldap_count_entries(ctx->ldap, result);
242 for (i = 0; i < count; i++) {
244 enum lsa_SidType lsa_type;
250 entry = ldap_first_entry(ctx->ldap, result);
252 entry = ldap_next_entry(ctx->ldap, result);
255 DEBUG(2, ("Unable to fetch entry.\n"));
259 name = smbldap_talloc_single_attribute(ctx->ldap, entry,
262 DEBUG(1, ("Could not get user name\n"));
266 b = idmap_rfc2307_get_uint32(ctx->ldap, entry, attrs[1], &id);
268 DEBUG(1, ("Could not pull id for record %s\n", name));
272 map = idmap_find_map_by_id(ids, type, id);
274 DEBUG(1, ("Could not find id %d, name %s\n", id, name));
279 /* Strip @realm from user or group name */
282 delim = strchr(name, '@');
288 /* by default calls to winbindd are disabled
289 the following call will not recurse so this is safe */
291 /* Lookup name from PDC using lsa_lookup_names() */
292 b = winbind_lookup_name(dom_name, name, map->sid, &lsa_type);
296 DEBUG(1, ("SID lookup failed for id %d, %s\n",
301 if (type == ID_TYPE_UID && lsa_type != SID_NAME_USER) {
302 DEBUG(1, ("Wrong type %d for user name %s\n",
307 if (type == ID_TYPE_GID && lsa_type != SID_NAME_DOM_GRP &&
308 lsa_type != SID_NAME_ALIAS &&
309 lsa_type != SID_NAME_WKN_GRP) {
310 DEBUG(1, ("Wrong type %d for group name %s\n",
315 map->status = ID_MAPPED;
320 * Map unixids to names and then to sids.
322 static NTSTATUS idmap_rfc2307_unixids_to_sids(struct idmap_domain *dom,
325 struct idmap_rfc2307_context *ctx;
326 char *fltr_usr = NULL, *fltr_grp = NULL;
328 int cnt_usr = 0, cnt_grp = 0, idx = 0, bidx = 0;
329 LDAPMessage *result = NULL;
332 ctx = talloc_get_type(dom->private_data, struct idmap_rfc2307_context);
333 mem_ctx = talloc_new(ctx);
335 return NT_STATUS_NO_MEMORY;
338 if (ctx->check_connection) {
339 ret = ctx->check_connection(dom);
340 if (!NT_STATUS_IS_OK(ret)) {
349 /* prepare new user query, see getpwuid() in RFC2307 */
350 fltr_usr = talloc_asprintf(mem_ctx,
351 "(&(objectClass=posixAccount)(|");
355 /* prepare new group query, see getgrgid() in RFC2307 */
356 fltr_grp = talloc_asprintf(mem_ctx,
357 "(&(objectClass=posixGroup)(|");
360 if (!fltr_usr || !fltr_grp) {
361 ret = NT_STATUS_NO_MEMORY;
365 while (cnt_usr < IDMAP_LDAP_MAX_IDS &&
366 cnt_grp < IDMAP_LDAP_MAX_IDS && ids[idx]) {
368 switch (ids[idx]->xid.type) {
370 fltr_usr = talloc_asprintf_append_buffer(fltr_usr,
371 "(uidNumber=%d)", ids[idx]->xid.id);
375 fltr_grp = talloc_asprintf_append_buffer(fltr_grp,
376 "(gidNumber=%d))", ids[idx]->xid.id);
380 DEBUG(3, ("Error: unknown ID type %d\n",
381 ids[idx]->xid.type));
382 ret = NT_STATUS_UNSUCCESSFUL;
386 if (!fltr_usr || !fltr_grp) {
387 ret = NT_STATUS_NO_MEMORY;
394 if (cnt_usr == IDMAP_LDAP_MAX_IDS || (cnt_usr != 0 && !ids[idx])) {
395 const char *attrs[] = { NULL, /* uid or cn */
399 fltr_usr = talloc_strdup_append(fltr_usr, "))");
401 ret = NT_STATUS_NO_MEMORY;
405 attrs[0] = ctx->user_cn ? "cn" : "uid";
406 ret = ctx->search(ctx, ctx->bind_path_user, fltr_usr, attrs,
408 if (!NT_STATUS_IS_OK(ret)) {
412 idmap_rfc2307_map_sid_results(ctx, mem_ctx, &ids[bidx], result,
413 dom->name, attrs, ID_TYPE_UID);
415 TALLOC_FREE(fltr_usr);
418 if (cnt_grp == IDMAP_LDAP_MAX_IDS || (cnt_grp != 0 && !ids[idx])) {
419 const char *attrs[] = { "cn", "gidNumber", NULL };
421 fltr_grp = talloc_strdup_append(fltr_grp, "))");
423 ret = NT_STATUS_NO_MEMORY;
426 ret = ctx->search(ctx, ctx->bind_path_group, fltr_grp, attrs,
428 if (!NT_STATUS_IS_OK(ret)) {
432 idmap_rfc2307_map_sid_results(ctx, mem_ctx, &ids[bidx], result,
433 dom->name, attrs, ID_TYPE_GID);
435 TALLOC_FREE(fltr_grp);
445 talloc_free(mem_ctx);
449 struct idmap_rfc2307_map {
456 * Lookup names for SIDS and store the data in the local mapping
459 static NTSTATUS idmap_rfc_2307_sids_to_names(TALLOC_CTX *mem_ctx,
461 struct idmap_rfc2307_map *maps,
462 struct idmap_rfc2307_context *ctx)
466 for (i = 0; ids[i]; i++) {
467 const char *domain, *name;
468 enum lsa_SidType lsa_type;
469 struct id_map *id = ids[i];
470 struct idmap_rfc2307_map *map = &maps[i];
473 /* by default calls to winbindd are disabled
474 the following call will not recurse so this is safe */
476 b = winbind_lookup_sid(mem_ctx, ids[i]->sid, &domain, &name,
481 DEBUG(1, ("Lookup sid %s failed.\n",
482 sid_string_dbg(ids[i]->sid)));
488 id->xid.type = map->type = ID_TYPE_UID;
489 if (ctx->user_cn && ctx->cn_realm) {
490 name = talloc_asprintf(mem_ctx, "%s@%s",
493 id->xid.type = map->type = ID_TYPE_UID;
496 case SID_NAME_DOM_GRP:
498 case SID_NAME_WKN_GRP:
500 name = talloc_asprintf(mem_ctx, "%s@%s",
503 id->xid.type = map->type = ID_TYPE_GID;
507 DEBUG(1, ("Unknown lsa type %d for sid %s\n",
508 lsa_type, sid_string_dbg(id->sid)));
509 id->status = ID_UNMAPPED;
514 id->status = ID_UNKNOWN;
515 map->name = strupper_talloc(mem_ctx, name);
518 return NT_STATUS_NO_MEMORY;
526 * Find id_map entry by looking up the name in the internal
529 static struct id_map* idmap_rfc2307_find_map(struct idmap_rfc2307_map *maps,
535 DEBUG(10, ("Looking for name %s, type %d\n", name, type));
537 for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
538 if (maps[i].map == NULL) { /* end of the run */
541 DEBUG(10, ("Entry %d: name %s, type %d\n",
542 i, maps[i].name, maps[i].type));
543 if (type == maps[i].type && strcmp(name, maps[i].name) == 0) {
551 static void idmap_rfc2307_map_xid_results(struct idmap_rfc2307_context *ctx,
554 struct idmap_rfc2307_map *maps,
556 struct idmap_domain *dom,
557 const char **attrs, enum id_type type)
562 count = ldap_count_entries(ctx->ldap, result);
564 for (i = 0; i < count; i++) {
568 struct id_map *id_map;
571 entry = ldap_first_entry(ctx->ldap, result);
573 entry = ldap_next_entry(ctx->ldap, result);
576 DEBUG(2, ("Unable to fetch entry.\n"));
580 name = smbldap_talloc_single_attribute(ctx->ldap, entry,
583 DEBUG(1, ("Could not get user name\n"));
587 b = idmap_rfc2307_get_uint32(ctx->ldap, entry, attrs[1], &id);
589 DEBUG(5, ("Could not pull id for record %s\n", name));
593 if (!idmap_unix_id_is_in_range(id, dom)) {
594 DEBUG(5, ("Requested id (%u) out of range (%u - %u).\n",
595 id, dom->low_id, dom->high_id));
599 if (!strupper_m(name)) {
600 DEBUG(5, ("Could not convert %s to uppercase\n", name));
603 id_map = idmap_rfc2307_find_map(maps, type, name);
605 DEBUG(0, ("Could not find mapping entry for name %s\n",
611 id_map->status = ID_MAPPED;
616 * Map sids to names and then to unixids.
618 static NTSTATUS idmap_rfc2307_sids_to_unixids(struct idmap_domain *dom,
621 struct idmap_rfc2307_context *ctx;
623 struct idmap_rfc2307_map *int_maps;
624 int cnt_usr = 0, cnt_grp = 0, idx = 0, bidx = 0;
625 char *fltr_usr = NULL, *fltr_grp = NULL;
629 ctx = talloc_get_type(dom->private_data, struct idmap_rfc2307_context);
630 mem_ctx = talloc_new(talloc_tos());
632 return NT_STATUS_NO_MEMORY;
635 if (ctx->check_connection) {
636 ret = ctx->check_connection(dom);
637 if (!NT_STATUS_IS_OK(ret)) {
642 for (i = 0; ids[i]; i++);
643 int_maps = talloc_zero_array(mem_ctx, struct idmap_rfc2307_map, i);
645 ret = NT_STATUS_NO_MEMORY;
649 ret = idmap_rfc_2307_sids_to_names(mem_ctx, ids, int_maps, ctx);
650 if (!NT_STATUS_IS_OK(ret)) {
656 /* prepare new user query, see getpwuid() in RFC2307 */
657 fltr_usr = talloc_asprintf(mem_ctx,
658 "(&(objectClass=posixAccount)(|");
662 /* prepare new group query, see getgrgid() in RFC2307 */
663 fltr_grp = talloc_asprintf(mem_ctx,
664 "(&(objectClass=posixGroup)(|");
667 if (!fltr_usr || !fltr_grp) {
668 ret = NT_STATUS_NO_MEMORY;
672 while (cnt_usr < IDMAP_LDAP_MAX_IDS &&
673 cnt_grp < IDMAP_LDAP_MAX_IDS && ids[idx]) {
674 struct id_map *id = ids[idx];
675 struct idmap_rfc2307_map *map = &int_maps[idx];
677 switch(id->xid.type) {
679 fltr_usr = talloc_asprintf_append_buffer(fltr_usr,
680 "(%s=%s)", (ctx->user_cn ? "cn" : "uid"),
686 fltr_grp = talloc_asprintf_append_buffer(fltr_grp,
687 "(cn=%s)", map->name);
692 DEBUG(10, ("Nothing to do for SID %s, "
693 "previous name lookup failed\n",
694 sid_string_dbg(map->map->sid)));
697 if (!fltr_usr || !fltr_grp) {
698 ret = NT_STATUS_NO_MEMORY;
705 if (cnt_usr == IDMAP_LDAP_MAX_IDS || (cnt_usr != 0 && !ids[idx])) {
706 const char *attrs[] = { NULL, /* uid or cn */
711 fltr_usr = talloc_strdup_append(fltr_usr, "))");
713 ret = NT_STATUS_NO_MEMORY;
717 attrs[0] = ctx->user_cn ? "cn" : "uid";
718 ret = ctx->search(ctx, ctx->bind_path_user, fltr_usr, attrs,
720 if (!NT_STATUS_IS_OK(ret)) {
724 idmap_rfc2307_map_xid_results(ctx, mem_ctx, &ids[bidx],
725 int_maps, result, dom,
729 TALLOC_FREE(fltr_usr);
732 if (cnt_grp == IDMAP_LDAP_MAX_IDS || (cnt_grp != 0 && !ids[idx])) {
733 const char *attrs[] = {"cn", "gidNumber", NULL };
736 fltr_grp = talloc_strdup_append(fltr_grp, "))");
738 ret = NT_STATUS_NO_MEMORY;
742 ret = ctx->search(ctx, ctx->bind_path_group, fltr_grp, attrs,
744 if (!NT_STATUS_IS_OK(ret)) {
748 idmap_rfc2307_map_xid_results(ctx, mem_ctx, &ids[bidx],
749 int_maps, result, dom,
752 TALLOC_FREE(fltr_grp);
762 talloc_free(mem_ctx);
766 static int idmap_rfc2307_context_destructor(struct idmap_rfc2307_context *ctx)
768 if (ctx->ads != NULL) {
769 /* we own this ADS_STRUCT so make sure it goes away */
770 ctx->ads->is_mine = True;
771 ads_destroy( &ctx->ads );
775 if (ctx->smbldap_state != NULL) {
776 smbldap_free_struct(&ctx->smbldap_state);
782 static NTSTATUS idmap_rfc2307_initialize(struct idmap_domain *domain)
784 struct idmap_rfc2307_context *ctx;
786 const char *bind_path_user, *bind_path_group, *ldap_server;
789 ctx = talloc_zero(domain, struct idmap_rfc2307_context);
791 return NT_STATUS_NO_MEMORY;
793 talloc_set_destructor(ctx, idmap_rfc2307_context_destructor);
795 cfg_opt = talloc_asprintf(ctx, "idmap config %s", domain->name);
796 if (cfg_opt == NULL) {
797 status = NT_STATUS_NO_MEMORY;
801 bind_path_user = lp_parm_const_string(-1, cfg_opt, "bind_path_user",
803 if (bind_path_user) {
804 ctx->bind_path_user = talloc_strdup(ctx, bind_path_user);
805 if (ctx->bind_path_user == NULL) {
806 status = NT_STATUS_NO_MEMORY;
810 status = NT_STATUS_INVALID_PARAMETER;
814 bind_path_group = lp_parm_const_string(-1, cfg_opt, "bind_path_group",
816 if (bind_path_group) {
817 ctx->bind_path_group = talloc_strdup(ctx, bind_path_group);
818 if (ctx->bind_path_group == NULL) {
819 status = NT_STATUS_NO_MEMORY;
823 status = NT_STATUS_INVALID_PARAMETER;
827 ldap_server = lp_parm_const_string(-1, cfg_opt, "ldap_server", NULL);
829 status = NT_STATUS_INVALID_PARAMETER;
833 if (strcmp(ldap_server, "stand-alone") == 0) {
834 status = idmap_rfc2307_init_ldap(ctx, domain, cfg_opt);
836 } else if (strcmp(ldap_server, "ad") == 0) {
837 status = idmap_rfc2307_init_ads(ctx, cfg_opt);
840 status = NT_STATUS_INVALID_PARAMETER;
843 if (!NT_STATUS_IS_OK(status)) {
847 ctx->cn_realm = lp_parm_bool(-1, cfg_opt, "cn_realm", false);
848 ctx->user_cn = lp_parm_bool(-1, cfg_opt, "user_cn", false);
850 domain->private_data = ctx;
851 talloc_free(cfg_opt);
855 talloc_free(cfg_opt);
860 static struct idmap_methods rfc2307_methods = {
861 .init = idmap_rfc2307_initialize,
862 .unixids_to_sids = idmap_rfc2307_unixids_to_sids,
863 .sids_to_unixids = idmap_rfc2307_sids_to_unixids,
866 NTSTATUS idmap_rfc2307_init(void)
868 return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "rfc2307",