Return to util.c CVS log

Up to [local] / src / usr.sbin / ldapd

include unistd.h directly rather than pulling it in via zlib's zconf.h
(needed for getdtablecount).

/*	$OpenBSD: util.c,v 1.14 2021/12/15 20:43:31 tb 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 <sys/socket.h>
#include <sys/resource.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <zlib.h>

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

int
bsnprintf(char *str, size_t size, const char *format, ...)
{
	int ret;
	va_list ap;

	va_start(ap, format);
	ret = vsnprintf(str, size, format, ap);
	va_end(ap);
	if (ret < 0 || (size_t)ret >= size)
		return 0;

	return 1;
}

/* Normalize a DN in preparation for searches.
 * Modifies its argument.
 * Currently only made lowercase, and spaces around comma is removed.
 * TODO: unescape backslash escapes, handle UTF-8.
 */
void
normalize_dn(char *dn)
{
	size_t		 n;
	char		*s, *p;

	for (s = p = dn; *s != '\0'; s++) {
		if (*s == ' ') {
			if (p == dn || p[-1] == ',')
				continue;
			n = strspn(s, " ");
			if (s[n] == '\0' || s[n] == ',')
				continue;
		}
		*p++ = tolower((unsigned char)*s);
	}
	*p = '\0';
}

/* Returns true (1) if key ends with suffix.
 */
int
has_suffix(struct btval *key, const char *suffix)
{
	size_t		slen;

	slen = strlen(suffix);

	if (key->size < slen)
		return 0;
	return (bcmp((char *)key->data + key->size - slen, suffix, slen) == 0);
}

/* Returns true (1) if key begins with prefix.
 */
int
has_prefix(struct btval *key, const char *prefix)
{
	size_t		 pfxlen;

	pfxlen = strlen(prefix);
	if (pfxlen > key->size)
		return 0;
	return (memcmp(key->data, prefix, pfxlen) == 0);
}

int
ber2db(struct ber_element *root, struct btval *val, int compression_level)
{
	int			 rc;
	ssize_t			 len;
	uLongf			 destlen;
	Bytef			*dest;
	void			*buf;
	struct ber		 ber;

	memset(val, 0, sizeof(*val));

	memset(&ber, 0, sizeof(ber));
	ober_write_elements(&ber, root);

	if ((len = ober_get_writebuf(&ber, &buf)) == -1)
		return -1;

	if (compression_level > 0) {
		val->size = compressBound(len);
		val->data = malloc(val->size + sizeof(uint32_t));
		if (val->data == NULL) {
			log_warn("malloc(%zu)", val->size + sizeof(uint32_t));
			ober_free(&ber);
			return -1;
		}
		dest = (char *)val->data + sizeof(uint32_t);
		destlen = val->size - sizeof(uint32_t);
		if ((rc = compress2(dest, &destlen, buf, len,
		    compression_level)) != Z_OK) {
			log_warn("compress returned %d", rc);
			free(val->data);
			ober_free(&ber);
			return -1;
		}
		log_debug("compressed entry from %zd -> %lu byte",
		    len, destlen + sizeof(uint32_t));

		*(uint32_t *)val->data = len;
		val->size = destlen + sizeof(uint32_t);
		val->free_data = 1;
	} else {
		val->data = buf;
		val->size = len;
		val->free_data = 1;	/* XXX: take over internal br_wbuf */
		ber.br_wbuf = NULL;
	}

	ober_free(&ber);

	return 0;
}

struct ber_element *
db2ber(struct btval *val, int compression_level)
{
	int			 rc;
	uLongf			 len;
	void			*buf;
	Bytef			*src;
	uLong			 srclen;
	struct ber_element	*elm;
	struct ber		 ber;

	assert(val != NULL);

	memset(&ber, 0, sizeof(ber));

	if (compression_level > 0) {
		if (val->size < sizeof(uint32_t))
			return NULL;

		len = *(uint32_t *)val->data;
		if ((buf = malloc(len)) == NULL) {
			log_warn("malloc(%lu)", len);
			return NULL;
		}

		src = (char *)val->data + sizeof(uint32_t);
		srclen = val->size - sizeof(uint32_t);
		rc = uncompress(buf, &len, src, srclen);
		if (rc != Z_OK) {
			log_warnx("dbt_to_ber: uncompress returned %d", rc);
			free(buf);
			return NULL;
		}

		log_debug("uncompressed entry from %zu -> %lu byte",
		    val->size, len);

		ober_set_readbuf(&ber, buf, len);
		elm = ober_read_elements(&ber, NULL);
		free(buf);
		return elm;
	} else {
		ober_set_readbuf(&ber, val->data, val->size);
		return ober_read_elements(&ber, NULL);
	}
}

int
accept_reserve(int sockfd, struct sockaddr *addr, socklen_t *addrlen,
    int reserve)
{
	if (getdtablecount() + reserve >= getdtablesize()) {
		errno = EMFILE;
		return -1;
	}

	return accept4(sockfd, addr, addrlen, SOCK_NONBLOCK);
}