sdap.c revision 796463906a54e259bd5b582ce84af4297a58eafc
/*
SSSD
LDAP Helper routines
Copyright (C) Simo Sorce <ssorce@redhat.com>
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "providers/ldap/ldap_common.h"
/* =Retrieve-Options====================================================== */
struct confdb_ctx *cdb,
const char *conf_path,
struct sdap_attr_map *def_map,
int num_entries,
struct sdap_attr_map **_map)
{
struct sdap_attr_map *map;
char *name;
int i, ret;
if (!map) {
return ENOMEM;
}
for (i = 0; i < num_entries; i++) {
&name);
return EINVAL;
}
if (name) {
return EINVAL;
}
} else {
}
return EINVAL;
}
}
}
return EOK;
}
/* =Parse-msg============================================================= */
{
struct sysdb_attrs *attrs;
struct ldb_val v;
char *str;
int lerrno;
int a, i, ret;
const char *name;
bool store;
lerrno = 0;
if (ret != LDAP_OPT_SUCCESS) {
}
if (!str) {
goto fail;
}
if (_dn) {
if (!*_dn) {
goto fail;
}
}
if (map) {
if (!vals) {
goto fail;
}
for (i = 0; vals[i]; i++) {
/* the objectclass is always the first name in the map */
/* ok it's an entry of the right type */
break;
}
}
if (!vals[i]) {
goto fail;
}
}
if (!str) {
if (map) {
goto fail;
}
}
while (str) {
if (map) {
for (a = 1; a < attrs_num; a++) {
/* check if this attr is valid with the chosen schema */
/* check if it is an attr we are interested in */
}
/* interesting attr */
if (a < attrs_num) {
store = true;
} else {
store = false;
}
} else {
store = true;
}
"which is currently not supported, skipping.\n", str));
store = false;
}
if (store) {
if (!vals) {
if (lerrno != LDAP_SUCCESS) {
goto fail;
}
} else {
if (!vals[0]) {
goto fail;
}
for (i = 0; vals[i]; i++) {
}
}
}
}
if (lerrno) {
goto fail;
}
return EOK;
fail:
return ret;
}
/* This function converts an ldap message into a sysdb_attrs structure.
* It converts only known user attributes, the rest are ignored.
* If the entry is not that of an user an error is returned.
* The original DN is stored as an attribute named originalDN */
{
}
/* This function converts an ldap message into a sysdb_attrs structure.
* It converts only known group attributes, the rest are ignored.
* If the entry is not that of an user an error is returned.
* The original DN is stored as an attribute named originalDN */
{
}
/* Parses an LDAPDerefRes into sdap_deref_attrs structure */
struct sdap_attr_map_info *minfo,
struct sdap_deref_attrs ***_res)
{
const char *orig_dn;
const char **ocs;
struct sdap_attr_map *map;
int num_attrs;
struct ldb_val v;
const char *name;
struct sdap_deref_attrs **res;
if (!res) {
goto done;
}
for (i=0; i < num_maps; i++) {
if (!res[i]) {
goto done;
}
}
goto done;
}
("Dereferenced DN: %s\n", orig_dn));
("Dereferenced entry [%s] has no attributes\n",
orig_dn));
goto done;
}
continue;
}
if (!ocs) {
goto done;
}
for (i=0; i<len; i++) {
if (!ocs[i]) {
goto done;
}
}
break;
}
}
if (!ocs) {
goto done;
}
for (i=0; ocs[i]; i++) {
/* the objectclass is always the first name in the map */
break;
}
}
if (!map) continue;
goto done;
}
orig_dn);
if (ret) {
goto done;
}
for (a = 1; a < num_attrs; a++) {
/* check if this attr is valid with the chosen schema */
/* check if it is an attr we are interested in */
}
/* interesting attr */
if (a < num_attrs) {
} else {
continue;
}
continue;
}
}
}
}
done:
return ret;
}
/* =Get-DN-from-message=================================================== */
{
char *str;
int lerrno;
int ret;
lerrno = 0;
if (ret != LDAP_OPT_SUCCESS) {
}
if (!str) {
return EIO;
}
return EOK;
}
{
int ret;
const char *tls_opt;
if (tls_opt) {
}
}
}
}
}
else {
return EINVAL;
}
/* LDAP_OPT_X_TLS_REQUIRE_CERT has to be set as a global option,
if (ret != LDAP_OPT_SUCCESS) {
return EIO;
}
}
if (tls_opt) {
if (ret != LDAP_OPT_SUCCESS) {
return EIO;
}
}
if (tls_opt) {
if (ret != LDAP_OPT_SUCCESS) {
return EIO;
}
}
if (tls_opt) {
if (ret != LDAP_OPT_SUCCESS) {
return EIO;
}
}
if (tls_opt) {
if (ret != LDAP_OPT_SUCCESS) {
return EIO;
}
}
if (tls_opt) {
if (ret != LDAP_OPT_SUCCESS) {
return EIO;
}
}
return EOK;
}
{
int i;
if (!val) {
return false;
}
for (i = 0; i < l->num_vals; i++) {
continue;
}
return true;
}
return false;
}
{
int i;
return ENOMEM;
}
for (i = 0; i < num; i++) {
return ENOMEM;
}
}
return EOK;
}
struct sdap_handle *sh)
{
int ret;
int i;
if (ret) {
return ret;
}
if (ret) {
return ret;
}
if (ret) {
return ret;
}
}
}
return EOK;
}
struct ldb_message_element *el)
{
if (el->num_values == 0) {
}
} else {
}
return str;
}
struct sysdb_attrs *rootdse)
{
int i;
char *naming_context = NULL;
SDAP_ROOTDSE_ATTR_NAMING_CONTEXTS) == 0) {
}
}
} else {
}
}
}
return naming_context;
}
enum sdap_basic_opt class,
char *naming_context)
{
struct sdap_search_base ***bases;
switch(class) {
case SDAP_SEARCH_BASE:
break;
case SDAP_USER_SEARCH_BASE:
break;
case SDAP_GROUP_SEARCH_BASE:
break;
break;
case SDAP_SUDO_SEARCH_BASE:
break;
case SDAP_SERVICE_SEARCH_BASE:
break;
default:
return EINVAL;
}
("Setting option [%s] to [%s].\n",
goto done;
}
done:
return ret;
}
struct sdap_options *opts)
{
int ret;
char *naming_context = NULL;
if (!opts->search_bases
|| !opts->group_search_bases
|| !opts->sudo_search_bases) {
if (naming_context == NULL) {
goto done;
}
}
/* Default */
if (!opts->search_bases) {
}
/* Users */
if (!opts->user_search_bases) {
}
/* Groups */
if (!opts->group_search_bases) {
}
/* Netgroups */
if (!opts->netgroup_search_bases) {
}
/* Sudo */
if (!opts->sudo_search_bases) {
}
/* Services */
if (!opts->service_search_bases) {
}
done:
return ret;
}
const char *server,
struct sysdb_attrs *rootdse,
struct sdap_options *opts,
struct sdap_server_opts **srv_opts)
{
struct sdap_server_opts *so;
struct {
const char *last_name;
const char *entry_name;
{ SDAP_AD_LAST_USN, SDAP_AD_USN },
const char *last_usn_name;
const char *last_usn_value;
const char *entry_usn_name;
int ret;
int i;
if (!so) {
return ENOMEM;
}
return ENOMEM;
}
if (rootdse) {
if (last_usn_name) {
switch (ret) {
case ENOENT:
break;
case ERANGE:
break;
default:
}
} else {
if (!entry_usn_name) {
} else {
so->supports_usn = true;
} else {
}
}
}
} else {
/* no usn option configure, let's try to autodetect. */
/* Fixate discovered configuration */
so->supports_usn = true;
} else {
}
break;
}
}
}
}
if (!last_usn_name) {
if (!entry_usn_name) {
}
}
}
}
return EOK;
}
struct sdap_server_opts **srv_opts)
{
return;
}
return;
}
/* discard if same as previous so we do not reset max usn values
* unnecessarily */
return;
}
}
struct sdap_attr_map *map,
{
const char **attrs;
int i, j;
/* first attribute is "objectclass" not the specifc one */
/* add the others */
for (i = j = 1; i < size; i++) {
j++;
}
}
return EOK;
}
{
int ret;
if (ret != LDAP_SUCCESS) {
}
} else {
}
return ret;
}