githubmirror/adcli

library/adldap.c
518 строк11 KB
Stef Walter
Add some annotations for clang analyzer
02 май 2013, 14:55
02 май 2013, 14:55cb0332f
/*
 * adcli
 *
 * Copyright (C) 2012 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301 USA
 *
 * Author: Stef Walter <stefw@gnome.org>
 */

#include "config.h"

#include "adcli.h"
#include "adprivate.h"

#include <gssapi/gssapi_krb5.h>
#include <krb5/krb5.h>
#include <ldap.h>
#include <sasl/sasl.h>

#include <assert.h>
#include <ctype.h>

adcli_result
_adcli_ldap_handle_failure (LDAP *ldap,
                            adcli_result defres,
                            const char *desc,
                            ...)
{
	va_list va;
	char *message;
	char *info;
	int code;

	if (ldap_get_option (ldap, LDAP_OPT_RESULT_CODE, &code) != 0)
		return_unexpected_if_reached ();

	if (code == LDAP_NO_MEMORY)
		return_unexpected_if_reached ();

	if (ldap_get_option (ldap, LDAP_OPT_DIAGNOSTIC_MESSAGE, (void*)&info) != 0)
		info = NULL;

	va_start (va, desc);
	if (vasprintf (&message, desc, va) < 0)
		return_unexpected_if_reached ();
	va_end (va);

	_adcli_err ("%s: %s",
	            message,
	            info ? info : ldap_err2string (code));

	free (message);
	return defres;
}


char *
_adcli_ldap_parse_value (LDAP *ldap,
                         LDAPMessage *results,
                         const char *attr_name)
{
	LDAPMessage *entry;
	struct berval **bvs;
	char *val = NULL;

	entry = ldap_first_entry (ldap, results);
	if (entry != NULL) {
		bvs = ldap_get_values_len (ldap, entry, attr_name);
		if (bvs != NULL) {
			if (bvs[0]) {
				val = _adcli_str_dupn (bvs[0]->bv_val, bvs[0]->bv_len);
				return_val_if_fail (val != NULL, NULL);
			}
			ldap_value_free_len (bvs);
		}
	}

	return val;
}

char **
_adcli_ldap_parse_values (LDAP *ldap,
                          LDAPMessage *results,
                          const char *attr_name)
{
	LDAPMessage *entry;
	struct berval **bvs;
	char **vals = NULL;
	int length = 0;
	char *val;
	int i;

	entry = ldap_first_entry (ldap, results);
	if (entry != NULL) {
		bvs = ldap_get_values_len (ldap, entry, attr_name);
		if (bvs != NULL) {
			for (i = 0; bvs[i] != NULL; i++) {
				val = _adcli_str_dupn (bvs[i]->bv_val,
				                       bvs[i]->bv_len);
				if (val != NULL)
					vals = _adcli_strv_add (vals, val, &length);
			}
			ldap_value_free_len (bvs);
		}
	}

	return vals;
}

char *
_adcli_ldap_parse_dn (LDAP *ldap,
                      LDAPMessage *results)
{
	LDAPMessage *entry;
	const char *dn;
	char *ret = NULL;

	entry = ldap_first_entry (ldap, results);
	if (entry != NULL) {
		dn = ldap_get_dn (ldap, entry);
		if (dn != NULL) {
			ret = strdup (dn);
			return_val_if_fail (ret != NULL, NULL);
		}
	}

	return ret;
}

int
_adcli_ldap_ber_case_equal (struct berval *one,
                            struct berval *two)
{
	int i;

	if (one->bv_len != two->bv_len)
		return 0;

	for (i = 0; i < one->bv_len; i++) {
		if (toupper (one->bv_val[i]) != toupper (two->bv_val[i]))
			return 0;
	}

	return 1;
}

int
_adcli_ldap_have_vals (struct berval **want,
                       struct berval **have)
{
	int i, j;

	for (i = 0; want[i] != NULL; i++) {
		int found = 0;
		for (j = 0; have[j] != NULL; j++) {
			if (_adcli_ldap_ber_case_equal (want[i], have[j])) {
				found = 1;
				break;
			}
		}
		if (!found)
			return 0;
	}

	return 1;
}

int
_adcli_ldap_have_in_mod (LDAPMod *mod,
                         struct berval **have)
{
	struct berval *vals;
	struct berval **pvals;
	int count = 0;
	int i;

	/* Already in berval format, just compare */
	if (mod->mod_op & LDAP_MOD_BVALUES)
		return _adcli_ldap_have_vals (mod->mod_vals.modv_bvals, have);

	/* Count number of values */
	for (i = 0; mod->mod_vals.modv_strvals[i] != 0; i++)
		count++;

	vals = alloca (sizeof (struct berval) * (count + 1));
	pvals = alloca (sizeof (struct berval *) * (count + 1));
	for (i = 0; i < count; i++) {
		vals[i].bv_val = mod->mod_vals.modv_strvals[i];
		vals[i].bv_len = strlen (vals[i].bv_val);
		pvals[i] = vals + i;
	}

	pvals[count] = NULL;
	return _adcli_ldap_have_vals (pvals, have);
}

int
_adcli_ldap_filter_for_add (void *unused,
                            void *value)
{
	LDAPMod *mod = value;

	/* No need to care about this */
	if ((mod->mod_op & LDAP_MOD_OP) == LDAP_MOD_DELETE)
		return -1;

	if (mod->mod_op & LDAP_MOD_BVALUES) {
		if (mod->mod_vals.modv_bvals == NULL ||
		    mod->mod_vals.modv_bvals[0] == NULL)
			return -1;
		mod->mod_op = LDAP_MOD_ADD | LDAP_MOD_BVALUES;
	} else {
		if (mod->mod_vals.modv_strvals == NULL ||
		    mod->mod_vals.modv_strvals[0] == NULL)
			return -1;
		mod->mod_op = LDAP_MOD_ADD;
	}

	return 0;
}

#define LDAP_NO_ESCAPE "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-_0123456789"
#define LDAP_HEX "0123456789abcdef"

char *
_adcli_ldap_escape_filter (const char *value)
{
	const char *in;
	char *out, *result;
	size_t pos;
	size_t len;

	assert (value != NULL);

	len = strlen (value);
	result = malloc ((len * 3) + 1);
	return_val_if_fail (result != NULL, NULL);

	in = value;
	out = result;

	while (*in != '\0') {
		pos = strspn (in, LDAP_NO_ESCAPE);
		if (pos > 0) {
			memcpy (out, in, pos);
			in += pos;
			out += pos;
		}

		while (*in != '\0' && !strchr (LDAP_NO_ESCAPE, *in)) {
			*(out++) = '\\';
			*(out++) = LDAP_HEX[*in >> 4 & 0xf];
			*(out++) = LDAP_HEX[*in & 0xf];
			in++;
		}
	}

	*out = 0;
	return result;
}

static int
berval_case_equals (const struct berval *v1,
                    const struct berval *v2)
{
	return (v1->bv_len == v2->bv_len &&
	        strncasecmp (v1->bv_val, v2->bv_val, v1->bv_len) == 0);
}

int
_adcli_ldap_dn_has_ancestor (const char *dn,
                             const char *ancestor)
{
	LDAPDN ld_dn;
	LDAPDN ld_suffix;
	LDAPRDN r_dn;
	LDAPRDN r_suffix;
	int ln_dn;
	int ln_suffix;
	int match = 0;
	int rc;
	int i, j;

	rc = ldap_str2dn (dn, &ld_dn, LDAP_DN_FORMAT_LDAPV3);
	return_val_if_fail (rc == LDAP_SUCCESS, 0);

	/* This is usually provided by user, be less whiny about formatting issues */
	rc = ldap_str2dn (ancestor, &ld_suffix, LDAP_DN_FORMAT_LDAPV3);
	if (rc != LDAP_SUCCESS)
		return 0;

	/* Calculate length of both */
	for (i = 0, ln_dn = 0; ld_dn[i] != NULL; i++)
		ln_dn++;
	for (i = 0, ln_suffix = 0; ld_suffix[i] != NULL; i++)
		ln_suffix++;

	match = (ln_suffix < ln_dn);
	for (i = 1; match && i <= ln_suffix; i++) {
		r_dn = ld_dn[ln_dn - i];
		r_suffix = ld_suffix[ln_suffix - i];
		for (j = 0; match && r_dn[j] != NULL && r_suffix[j] != NULL; j++) {
			if (!berval_case_equals (&(r_dn[j]->la_attr), &(r_suffix[j]->la_attr)) ||
			    !berval_case_equals (&(r_dn[j]->la_value), &(r_suffix[j]->la_value)))
				match = 0;
		}
	}

	ldap_dnfree (ld_dn);
	ldap_dnfree (ld_suffix);

	return match;
}

int
_adcli_ldap_mod_compar (void *match,
                        void *mod)
{
	return strcmp (((LDAPMod *)match)->mod_type,
	               ((LDAPMod *)mod)->mod_type);
}

LDAPMod *
_adcli_ldap_mod_new (int mod_op,
                     const char *type,
                     const char **values)
{
	LDAPMod *mod;

	mod = calloc (1, sizeof (LDAPMod));
	return_val_if_fail (mod != NULL, NULL);

	mod->mod_op = mod_op;
	mod->mod_type = strdup (type);
	return_val_if_fail (mod->mod_type != NULL, NULL);

	if (values) {
		mod->mod_vals.modv_strvals = _adcli_strv_dup ((char **)values);
		return_val_if_fail (mod->mod_vals.modv_strvals != NULL, NULL);
	}

	return mod;
}

LDAPMod *
_adcli_ldap_mod_new1 (int mod_op,
                      const char *type,
                      const char *value)
{
	const char *values[] = { value, NULL };
	return _adcli_ldap_mod_new (mod_op, type, values);
}

void
_adcli_ldap_mod_free (void *value)
{
	LDAPMod *mod = value;

	if (mod == NULL)
		return;

	free (mod->mod_type);

	if (mod->mod_op & LDAP_MOD_BVALUES)
		ldap_value_free_len (mod->mod_vals.modv_bvals);
	else
		_adcli_strv_free (mod->mod_vals.modv_strvals);
	free (mod);
}

char *
_adcli_ldap_mods_to_string (LDAPMod **mods)
{
	char **names;
	int names_len;
	char *string;
	int i;

	names = NULL;
	names_len = 0;

	for (i = 0; mods[i] != NULL; i++)
		names = _adcli_strv_add (names, strdup (mods[i]->mod_type), &names_len);
	string = _adcli_strv_join (names, ", ");

	_adcli_strv_free (names);
	return string;
}

#ifdef LDAP_TESTS

#include "seq.h"
#include "test.h"

static void
test_compar (void)
{
	LDAPMod one = { LDAP_MOD_ADD, "one" };
	LDAPMod two = { LDAP_MOD_ADD, "two" };
	LDAPMod same = { LDAP_MOD_REPLACE, "one" };

	assert (_adcli_ldap_mod_compar (&one, &two) < 0);
	assert (_adcli_ldap_mod_compar (&two, &one) > 0);
	assert (_adcli_ldap_mod_compar (&one, &one) == 0);
	assert (_adcli_ldap_mod_compar (&one, &same) == 0);
}

static void
test_new_free (void)
{
	const char *values[] = { "value", "two", "three", NULL };
	LDAPMod *mod;

	mod = _adcli_ldap_mod_new (LDAP_MOD_ADD, "test", values);
	assert (mod != NULL);

	assert (mod->mod_op == LDAP_MOD_ADD);
	assert_str_eq (mod->mod_type, "test");
	assert_num_eq (seq_count (mod->mod_vals.modv_strvals), 3);
	assert_str_eq (mod->mod_vals.modv_strvals[0], "value");
	assert_str_eq (mod->mod_vals.modv_strvals[1], "two");
	assert_str_eq (mod->mod_vals.modv_strvals[2], "three");
	assert (mod->mod_vals.modv_strvals[3] == NULL);

	_adcli_ldap_mod_free (mod);
}

static void
test_new1 (void)
{
	LDAPMod *mod;

	mod = _adcli_ldap_mod_new1 (LDAP_MOD_ADD, "test", "one");
	assert (mod != NULL);

	assert (mod->mod_op == LDAP_MOD_ADD);
	assert_str_eq (mod->mod_type, "test");
	assert_num_eq (seq_count (mod->mod_vals.modv_strvals), 1);
	assert_str_eq (mod->mod_vals.modv_strvals[0], "one");
	assert (mod->mod_vals.modv_strvals[1] == NULL);

	_adcli_ldap_mod_free (mod);
}

static void
test_new_null (void)
{
	LDAPMod *mod;

	mod = _adcli_ldap_mod_new (LDAP_MOD_ADD, "test", NULL);
	assert (mod != NULL);

	assert (mod->mod_op == LDAP_MOD_ADD);
	assert_str_eq (mod->mod_type, "test");
	assert_num_eq (seq_count (mod->mod_vals.modv_strvals), 0);
	assert (mod->mod_vals.modv_strvals == NULL);

	_adcli_ldap_mod_free (mod);
}

static void
test_free_null (void)
{
	_adcli_ldap_mod_free (NULL);
}

static void
test_to_string (void)
{
	char *vals_objectClass[] = { "computer", NULL };
	LDAPMod objectClass = { 0, "objectClass", { vals_objectClass, } };
	char *vals_sAMAccountName[] = { "value", NULL };
	LDAPMod sAMAccountName = { 0, "sAMAccountName", { vals_sAMAccountName, } };
	char *vals_userAccountControl[] = { "69632", NULL };
	LDAPMod userAccountControl = { 0, "userAccountControl", { vals_userAccountControl, } };

	LDAPMod *mods[] = {
		&objectClass,
		&sAMAccountName,
		&userAccountControl,
		NULL,
	};

	char *string;

	string = _adcli_ldap_mods_to_string (mods);
	assert_str_eq (string, "objectClass, sAMAccountName, userAccountControl");
	free (string);
}

int
main (int argc,
      char *argv[])
{
	test_func (test_compar, "/ldap/compar");
	test_func (test_new_free, "/ldap/new_free");
	test_func (test_new1, "/ldap/new1");
	test_func (test_new_null, "/ldap/new_null");
	test_func (test_free_null, "/ldap/free_null");
	test_func (test_to_string, "/ldap/to_string");
	return test_run (argc, argv);
}

#endif /* LDAP_TESTS */