/* This file is part of GNU Dico. Copyright (C) 2008-2024 Sergey Poznyakoff GNU Dico is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GNU Dico is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Dico. If not, see . */ #include #include #include #include #include #include #include struct _dico_ldap_handle { LDAP *ldap; const char *url; char *base; char *binddn; char *passwd; int tls; /* FIXME: sasl */ int debug; char *user_filter; char *group_filter; }; void free_ldap_handle(struct _dico_ldap_handle *lp) { free(lp->base); free(lp->binddn); free(lp->passwd); free(lp->user_filter); free(lp->group_filter); free(lp); } static int _dico_conn_setup(struct _dico_ldap_handle *lp) { int rc; LDAP *ld = NULL; int protocol = LDAP_VERSION3; /* FIXME: must be configurable */ if (lp->debug) { if (ber_set_option(NULL, LBER_OPT_DEBUG_LEVEL, &lp->debug) != LBER_OPT_SUCCESS ) dico_log(L_ERR, 0, _("cannot set LBER_OPT_DEBUG_LEVEL %d"), lp->debug); if (ldap_set_option(NULL, LDAP_OPT_DEBUG_LEVEL, &lp->debug) != LDAP_OPT_SUCCESS ) dico_log(L_ERR, 0, _("could not set LDAP_OPT_DEBUG_LEVEL %d"), lp->debug); } rc = ldap_initialize(&ld, lp->url); if (rc != LDAP_SUCCESS) { dico_log(L_ERR, 0, _("cannot create LDAP session handle for URI=%s (%d): %s"), lp->url, rc, ldap_err2string(rc)); return 1; } if (lp->tls) { rc = ldap_start_tls_s(ld, NULL, NULL); if (rc != LDAP_SUCCESS) { dico_log(L_ERR, 0, _("ldap_start_tls failed: %s"), ldap_err2string(rc)); return 1; } } ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &protocol); /* FIXME: Timeouts, SASL, etc. */ lp->ldap = ld; return 0; } static int _dico_ldap_bind(struct _dico_ldap_handle *lp) { int msgid, err, rc; LDAPMessage *result; LDAPControl **ctrls; char msgbuf[256]; char *matched = NULL; char *info = NULL; char **refs = NULL; static struct berval passwd; passwd.bv_val = lp->passwd; passwd.bv_len = passwd.bv_val ? strlen (passwd.bv_val) : 0; msgbuf[0] = 0; rc = ldap_sasl_bind(lp->ldap, lp->binddn, LDAP_SASL_SIMPLE, &passwd, NULL, NULL, &msgid); if (msgid == -1) { dico_log(L_ERR, 0, "ldap_sasl_bind(SIMPLE) failed: %s", ldap_err2string(rc)); return 1; } if (ldap_result(lp->ldap, msgid, LDAP_MSG_ALL, NULL, &result) == -1) { dico_log(L_ERR, 0, "ldap_result failed"); return 1; } rc = ldap_parse_result(lp->ldap, result, &err, &matched, &info, &refs, &ctrls, 1); if (rc != LDAP_SUCCESS) { dico_log(L_ERR, 0, "ldap_parse_result failed: %s", ldap_err2string(rc)); return 1; } if (ctrls) ldap_controls_free(ctrls); if (err != LDAP_SUCCESS || msgbuf[0] || (matched && matched[0]) || (info && info[0]) || refs) { dico_log(L_ERR, 0, "ldap_bind: %s (%d)%s", ldap_err2string(err), err, msgbuf); if (matched && *matched) dico_log(L_ERR, 0, "matched DN: %s", matched); if (info && *info) dico_log(L_ERR, 0, "additional info: %s", info); if (refs && *refs) { int i; dico_log(L_ERR, 0, "referrals:"); for (i = 0; refs[i]; i++) dico_log(L_ERR, 0, "%s", refs[i]); } } if (matched) ber_memfree(matched); if (info) ber_memfree(info); if (refs) ber_memvfree((void **)refs); return err != LDAP_SUCCESS; } static void _dico_ldap_unbind(struct _dico_ldap_handle *lp) { if (lp->ldap) { ldap_set_option(lp->ldap, LDAP_OPT_SERVER_CONTROLS, NULL); ldap_unbind_ext(lp->ldap, NULL, NULL); } } static int db_open(void **phandle, dico_url_t url, const char *options) { struct _dico_ldap_handle hstr, *handle; int rc; long debug = 0; struct dico_option option[] = { { DICO_OPTSTR(base), dico_opt_string, &hstr.base }, { DICO_OPTSTR(binddn), dico_opt_string, &hstr.binddn }, { DICO_OPTSTR(passwd), dico_opt_string, &hstr.passwd }, { DICO_OPTSTR(tls), dico_opt_bool, &hstr.tls }, { DICO_OPTSTR(debug), dico_opt_long, &debug }, { DICO_OPTSTR(user-filter), dico_opt_string, &hstr.user_filter }, { DICO_OPTSTR(group-filter), dico_opt_string, &hstr.group_filter }, { NULL } }; memset(&hstr, 0, sizeof(hstr)); if (options) { struct wordsplit ws; if (wordsplit(options, &ws, WRDSF_DEFFLAGS)) { dico_log(L_ERR, 0, _("cannot parse options `%s': %s"), options, wordsplit_strerror(&ws)); return 1; } rc = dico_parseopt(option, ws.ws_wordc, ws.ws_wordv, DICO_PARSEOPT_PARSE_ARGV0, NULL); wordsplit_free(&ws); if (rc) return 1; hstr.debug = debug; } hstr.url = url->string; handle = malloc(sizeof(*handle)); if (!handle) { dico_log(L_ERR, errno, _("cannot allocate handle")); return 1; } *handle = hstr; rc = _dico_conn_setup(handle) || _dico_ldap_bind(handle); if (rc) { free_ldap_handle(handle); } else { *phandle = handle; } return rc; } int db_close(void *handle) { struct _dico_ldap_handle *lp = handle; _dico_ldap_unbind(lp); free_ldap_handle(lp); return 0; } char * _dico_ldap_expand_user(const char *query, const char *user) { struct wordsplit ws; const char *env[3]; char *res; env[0] = "user"; env[1] = user; env[2] = NULL; ws.ws_env = env; if (wordsplit(query, &ws, WRDSF_NOSPLIT | WRDSF_NOCMD | WRDSF_ENV | WRDSF_ENV_KV)) { dico_log(L_ERR, 0, _("cannot expand query `%s': %s"), query, wordsplit_strerror(&ws)); return NULL; } res = ws.ws_wordv[0]; ws.ws_wordv[0] = NULL; wordsplit_free(&ws); return res; } static LDAPMessage * _dico_ldap_search(struct _dico_ldap_handle *lp, const char *filter_pat, const char *attr, const char *user) { int rc; char *filter; LDAPMessage *res; ber_int_t msgid; char *attrs[2]; attrs[0] = (char*) attr; attrs[1] = NULL; if (filter_pat) { filter = _dico_ldap_expand_user(filter_pat, user); if (!filter) { DICO_LOG_MEMERR(); return NULL; } } else filter = NULL; rc = ldap_search_ext(lp->ldap, lp->base, LDAP_SCOPE_SUBTREE, filter, attrs, 0, NULL, NULL, NULL, -1, &msgid); if (filter) free(filter); if (rc != LDAP_SUCCESS) { dico_log(L_ERR, 0, "ldap_search_ext: %s", ldap_err2string(rc)); /*if (rc == LDAP_NO_SUCH_OBJECT)*/ return NULL; } rc = ldap_result(lp->ldap, msgid, LDAP_MSG_ALL, NULL, &res); if (rc < 0) { dico_log(L_ERR, 0, "ldap_result failed"); return NULL; } return res; } static int db_get_pass(void *handle, const char *qpw, const char *key, char **ppass) { struct _dico_ldap_handle *lp = handle; LDAPMessage *res, *msg; int rc; struct berval **values; res = _dico_ldap_search(lp, lp->user_filter, qpw, key); if (!res) return 1; rc = ldap_count_entries(lp->ldap, res); if (rc == 0) { dico_log(L_ERR, 0, "not enough entires"); ldap_msgfree(res); return 1; } msg = ldap_first_entry(lp->ldap, res); values = ldap_get_values_len(lp->ldap, msg, qpw); if (ldap_count_values_len(values) == 0) { dico_log(L_ERR, 0, "not enough entires"); ldap_msgfree(res); return 1; } *ppass = strdup(values[0]->bv_val); rc = *ppass == NULL; if (rc) dico_log(L_ERR, 0, "not enough memory"); ldap_value_free_len(values); ldap_msgfree(res); return rc; } static int _free_group(void *item, void *data) { free(item); return 0; } static int db_get_groups(void *handle, const char *qgr, const char *key, dico_list_t *pgroups) { struct _dico_ldap_handle *lp = handle; LDAPMessage *res, *msg; int rc; dico_list_t groups = NULL; res = _dico_ldap_search(lp, lp->group_filter, qgr, key); if (!res) return 1; rc = ldap_count_entries(lp->ldap, res); if (rc == 0) { dico_log(L_INFO, 0, "no groups containing %s", key); ldap_msgfree(res); *pgroups = NULL; return 0; } groups = dico_list_create(); dico_list_set_free_item(groups, _free_group, NULL); *pgroups = groups; rc = 0; for (msg = ldap_first_entry(lp->ldap, res); msg; msg = ldap_next_entry(lp->ldap, msg)) { struct berval **values; size_t i, count; values = ldap_get_values_len(lp->ldap, msg, qgr); count = ldap_count_values_len(values); for (i = 0; i < count; i++) { char *s = strdup(values[i]->bv_val); dico_list_append(groups, s); } ldap_value_free_len(values); } ldap_msgfree(res); return rc; } static struct dico_udb_def ldap_udb_def = { "ldap", db_open, db_close, db_get_pass, db_get_groups }; static int dico_ldap_init(int argc, char **argv) { return dico_udb_define(&ldap_udb_def); } struct dico_database_module DICO_EXPORT(ldap, module) = { DICO_MODULE_VERSION, DICO_CAPA_NODB, dico_ldap_init, };