path: root/usr.sbin/ldapd/attributes.c

/*	$OpenBSD: attributes.c,v 1.7 2021/12/20 13:26:11 claudio Exp $ */

/*
 * Copyright (c) 2009 Martin Hedenfalk <martin@bzero.se>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/queue.h>
#include <sys/types.h>

#include <assert.h>
#include <string.h>
#include <time.h>

#include "ldapd.h"
#include "log.h"

struct ber_element *
ldap_get_attribute(struct ber_element *entry, const char *attr)
{
	char			*s;
	struct ber_element	*elm, *a;

	assert(entry);
	assert(attr);
	if (entry->be_encoding != BER_TYPE_SEQUENCE)
		return NULL;

	for (elm = entry->be_sub; elm != NULL; elm = elm->be_next) {
		a = elm->be_sub;
		if (a && ober_get_string(a, &s) == 0 && strcasecmp(s, attr) == 0)
			return a;
	}

	return NULL;
}

struct ber_element *
ldap_find_attribute(struct ber_element *entry, struct attr_type *at)
{
	struct ber_element	*elm = NULL;
	struct name		*an;

	SLIST_FOREACH(an, at->names, next) {
		if ((elm = ldap_get_attribute(entry, an->name)) != NULL)
			return elm;
	}
	if (an == NULL)
		elm = ldap_get_attribute(entry, at->oid);

	return elm;
}

struct ber_element *
ldap_find_value(struct ber_element *elm, const char *value)
{
	char			*s;
	struct ber_element	*a;

	if (elm == NULL)
		return NULL;

	for (a = elm->be_sub; a != NULL; a = a->be_next) {
		if (ober_get_string(a, &s) == 0 && strcasecmp(s, value) == 0)
			return a;
	}

	return NULL;
}

struct ber_element *
ldap_add_attribute(struct ber_element *entry, const char *attr,
	struct ber_element *value_set)
{
	struct ber_element	*elm, *a, *last;

	assert(entry);
	assert(attr);
	assert(value_set);

	if (entry->be_encoding != BER_TYPE_SEQUENCE) {
		log_warnx("entries should be a sequence");
		return NULL;
	}

	if (value_set->be_type != BER_TYPE_SET) {
		log_warnx("values should be a set");
		return NULL;
	}

	last = entry->be_sub;
	if (last == NULL)
		last = entry;
	else while (last != NULL && last->be_next != NULL)
		last = last->be_next;

	if ((elm = ober_add_sequence(last)) == NULL)
		return NULL;
	if ((a = ober_add_string(elm, attr)) == NULL) {
		ober_free_elements(elm);
		return NULL;
	}
	ober_link_elements(a, value_set);

	return elm;
}

int
ldap_set_values(struct ber_element *elm, struct ber_element *vals)
{
	char			*attr;
	struct ber_element	*old_vals;

	assert(elm);
	assert(vals);
	assert(vals->be_sub);

	if (ober_scanf_elements(elm, "se(", &attr, &old_vals) != 0) {
		log_warnx("failed to parse element");
		return -1;
	}

	ober_free_elements(old_vals->be_sub);
	old_vals->be_sub = NULL;
	ober_link_elements(old_vals, vals->be_sub);

	vals->be_sub = NULL;
	ober_free_elements(vals);

	return 0;
}

int
ldap_merge_values(struct ber_element *elm, struct ber_element *vals)
{
	char			*attr;
	struct ber_element	*old_vals, *last;

	assert(elm);
	assert(vals);
	assert(vals->be_type == BER_TYPE_SET);
	assert(vals->be_sub);

	if (ober_scanf_elements(elm, "se(", &attr, &old_vals) != 0) {
		log_warnx("failed to parse element");
		return -1;
	}

	last = old_vals->be_sub;
	while (last && last->be_next)
		last = last->be_next;

	ober_link_elements(last, vals->be_sub);

	vals->be_sub = NULL;
	ober_free_elements(vals);

	return 0;
}


int
ldap_del_attribute(struct ber_element *entry, const char *attrdesc)
{
	struct ber_element	*attr, *prev = NULL;
	char			*s;

	assert(entry);
	assert(attrdesc);

	attr = entry->be_sub;
	while (attr) {
		if (ober_scanf_elements(attr, "{s", &s) != 0) {
			log_warnx("failed to parse attribute");
			return -1;
		}

		if (strcasecmp(s, attrdesc) == 0) {
			if (prev == NULL)
				entry->be_sub = attr->be_next;
			else
				prev->be_next = attr->be_next;
			attr->be_next = NULL;
			ober_free_elements(attr);
			break;
		}

		prev = attr;
		attr = attr->be_next;
	}

	return 0;
}

int
ldap_del_values(struct ber_element *elm, struct ber_element *vals)
{
	char			*attr;
	struct ber_element	*old_vals, *v, *x, *prev, *next;
	struct ber_element	*removed;
	int			removed_p;
	assert(elm);
	assert(vals);
	assert(vals->be_sub);

	if (ober_scanf_elements(elm, "se(", &attr, &old_vals) != 0) {
		log_warnx("failed to parse element");
		return -1;
	}

	prev = old_vals;
	removed_p = 0;
	for (v = old_vals->be_sub; v; v = next) {
		next = v->be_next;

		for (x = vals->be_sub; x; x = x->be_next) {
			if (x && v->be_len == x->be_len &&
			    memcmp(v->be_val, x->be_val, x->be_len) == 0) {
				removed = ober_unlink_elements(prev);
				ober_link_elements(prev, removed->be_next);
				ober_free_element(removed);
				removed_p = 1;
				break;
			}
		}
		if (removed_p) {
			removed_p = 0;
		} else {
			prev = v;
		}
	}

	if (old_vals->be_sub == NULL)
		return 1;

	return 0;
}

char *
ldap_strftime(time_t tm)
{
	static char	 tmbuf[16];
	struct tm	*gmt = gmtime(&tm);

	strftime(tmbuf, sizeof(tmbuf), "%Y%m%d%H%M%SZ", gmt);
	return tmbuf;
}

char *
ldap_now(void)
{
	return ldap_strftime(time(0));
}