waffle

ldap.c (6427B)

---

 /* See LICENSE file for copyright and license details. */
 #include <ctype.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <ldap.h>
 #include "waffle.h"
 
 struct ldap_config {
 	char *host;
 	int port;
 	int version;
 	char *uri;
 	char *rootbinddn;
 	char *binddn;
 	char *bindpw;
 	char *base;
 	int debug;
 };
 
 static LDAP *ld;
 static struct ldap_config ldap_conf;
 
 static void
 free_config(void)
 {
 	free(ldap_conf.host);
 	free(ldap_conf.uri);
 	free(ldap_conf.rootbinddn);
 	free(ldap_conf.binddn);
 	free(ldap_conf.bindpw);
 	free(ldap_conf.base);
 	memset(&ldap_conf, 0, sizeof(ldap_conf));
 }
 
 static int
 parse_config(void)
 {
 	FILE *fp;
 	char buf[BUFSIZ], *p;
 	char *key, *val;
 	char *end;
 
 	fp = fopen(LDAP_CFG_PATH, "r");
 	while (fp && fgets(buf, sizeof(buf), fp)) {
 		p = buf;
 		if (*p == '#' || *p == '\n' || !*p)
 			continue;
 
 		/* strip leading whitespace before key */
 		while(isspace(*p))
 			p++;
 		key = p;
 
 		/* null-terminate key */
 		while (*p && !isspace(*p)) p++;
 		if (*p)
 			*p++ = '\0';
 
 		/* strip leading whitespace before val */
 		while (isspace(*p))
 			p++;
 		val = p;
 
 		/* strip trailing whitespace after val */
 		while (*p)
 			p++;
 		while (--p > val && isspace(*p))
 			*p = '\0';
 
 		if (!strcmp(key, "host")) {
 			ldap_conf.host = strdup(val);
 			if (!ldap_conf.host)
 				goto out;
 		} else if (!strcmp(key, "port")) {
 			errno = 0;
 			ldap_conf.port = strtol(val, &end, 10);
 			if (*end || errno)
 				goto out;
 		} else if (!strcmp(key, "ldap_version")) {
 			errno = 0;
 			ldap_conf.version = strtol(val, &end, 10);
 			if (*end || errno)
 				goto out;
 		} else if (!strcmp(key, "uri")) {
 			ldap_conf.uri = strdup(val);
 			if (!ldap_conf.uri)
 				goto out;
 		} else if (!strcmp(key, "rootbinddn")) {
 			ldap_conf.rootbinddn = strdup(val);
 			if (!ldap_conf.rootbinddn)
 				goto out;
 		} else if (!strcmp(key, "binddn")) {
 			ldap_conf.binddn = strdup(val);
 			if (!ldap_conf.binddn)
 				goto out;
 		} else if (!strcmp(key, "bindpw")) {
 			ldap_conf.bindpw = strdup(val);
 			if (!ldap_conf.bindpw)
 				goto out;
 		} else if (!strcmp(key, "base")) {
 			ldap_conf.base = strdup(val);
 			if (!ldap_conf.base)
 				goto out;
 		} else if (!strcmp(key, "debug")) {
 			errno = 0;
 			ldap_conf.debug = strtol(val, &end, 10);
 			if (*end || errno)
 				goto out;
 		} else {
 			logwarn("unknown keyword in ldap.conf: %s\n",
 			        key);
 		}
 	}
 	if (fp)
 		fclose(fp);
 	if (!ldap_conf.host)
 		ldap_conf.host = strdup("localhost");
 	if (!ldap_conf.port)
 		ldap_conf.port = 389;
 	if (!ldap_conf.version)
 		ldap_conf.version = 3;
 	if (!ldap_conf.base)
 		goto out;
 	return 0;
 out:
 	free_config();
 	return -1;
 }
 
 static int
 init(void)
 {
 	int version = LDAP_VERSION3;
 	int r;
 
 	if (parse_config() < 0)
 		return -1;
 	if (ldap_conf.version != 3) {
 		logwarn("unsupported LDAP version: %d\n", ldap_conf.version);
 		goto out1;
 	}
 
 	if (ldap_conf.uri) {
 		r = ldap_initialize(&ld, ldap_conf.uri);
 		if (r != LDAP_SUCCESS) {
 			logwarn("ldap_initialize: %s\n", strerror(errno));
 			goto out1;
 		}
 	} else if (ldap_conf.host) {
 		ld = ldap_init(ldap_conf.host, ldap_conf.port);
 		if (!ld) {
 			logwarn("ldap_init: %s\n", strerror(errno));
 			goto out1;
 		}
 	}
 
 	r = ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, &version);
 	if (r != LDAP_SUCCESS) {
 		logwarn("ldap_set_option: %s\n", ldap_err2string(r));
 		goto out2;
 	}
 
 	r = ldap_bind_s(ld, ldap_conf.rootbinddn, ldap_conf.bindpw,
 	                LDAP_AUTH_SIMPLE);
 	if (r != LDAP_SUCCESS) {
 		logwarn("ldap_simple_bind_s: %s\n", ldap_err2string(r));
 		goto out2;
 	}
 
 	return 0;
 out2:
 	ldap_destroy(ld);
 	ld = NULL;
 out1:
 	free_config();
 	return -1;
 }
 
 static void
 term(void)
 {
 	if (ld) {
 		ldap_unbind(ld);
 		ldap_destroy(ld);
 		ld = NULL;
 	}
 	free_config();
 }
 
 static int
 pw_query(const char *name, const char *filter, struct passwd *pw)
 {
 	LDAPMessage *result = NULL, *e = NULL;
 	BerElement *ber = NULL;
 	struct berval **bv;
 	char *a;
 	char *end;
 	int r;
 
 	r = ldap_search_s(ld, ldap_conf.base, LDAP_SCOPE_SUBTREE,
 	                  filter, NULL, 0, &result);
 	if (r != LDAP_SUCCESS) {
 		logwarn("ldap_search_s: %s\n", ldap_err2string(r));
 		return -1;
 	}
 
 	e = ldap_first_entry(ld, result);
 	if (!e) {
 		ldap_msgfree(result);
 		return -1;
 	}
 
 	for (a = ldap_first_attribute(ld, e, &ber); a;
 	     a = ldap_next_attribute(ld, e, ber)) {
 		if (!(bv = ldap_get_values_len(ld, e, a)))
 			goto out;
 		if (!strcmp(a, "uid")) {
 			pw->pw_name = strdup(bv[0]->bv_val);
 			if (!pw->pw_name) {
 				ldap_value_free_len(bv);
 				goto out;
 			}
 		} else if (!strcmp(a, "userPassword")) {
 			pw->pw_passwd = strdup(bv[0]->bv_val);
 			if (!pw->pw_passwd) {
 				ldap_value_free_len(bv);
 				goto out;
 			}
 		} else if (!strcmp(a, "uidNumber")) {
 			errno = 0;
 			pw->pw_uid = strtol(bv[0]->bv_val, &end, 10);
 			if (*end || errno) {
 				ldap_value_free_len(bv);
 				goto out;
 			}
 		} else if (!strcmp(a, "gidNumber")) {
 			errno = 0;
 			pw->pw_gid = strtol(bv[0]->bv_val, &end, 10);
 			if (*end || errno) {
 				ldap_value_free_len(bv);
 				goto out;
 			}
 		} else if (!strcmp(a, "gecos")) {
 			pw->pw_gecos = strdup(bv[0]->bv_val);
 			if (!pw->pw_gecos) {
 				ldap_value_free_len(bv);
 				goto out;
 			}
 		} else if (!strcmp(a, "homeDirectory")) {
 			pw->pw_dir = strdup(bv[0]->bv_val);
 			if (!pw->pw_dir) {
 				ldap_value_free_len(bv);
 				goto out;
 			}
 		} else if (!strcmp(a, "loginShell")) {
 			pw->pw_shell = strdup(bv[0]->bv_val);
 			if (!pw->pw_shell) {
 				ldap_value_free_len(bv);
 				goto out;
 			}
 		}
 		ldap_value_free_len(bv);
 	}
 	ber_free(ber, 0);
 	ldap_msgfree(result);
 	return 0;
 out:
 	ber_free(ber, 0);
 	ldap_msgfree(result);
 	return -1;
 }
 
 static int
 pwbyname(const char *name, struct passwd *pw)
 {
 	char filter[strlen("uid=") + LOGIN_NAME_MAX];
 	snprintf(filter, sizeof(filter), "uid=%s", name);
 	return pw_query(name, filter, pw);
 }
 
 static int
 pwbyuid(uid_t uid, struct passwd *pw)
 {
 	char key[11]; /* max digits in 2^32 + null-terminator */
 	char filter[strlen("uidNumber=") + 11];
 
 	snprintf(filter, sizeof(filter), "uidNumber=%d", uid);
 	snprintf(key, sizeof(key), "%d", uid);
 	return pw_query(key, filter, pw);
 }
 
 static int
 grbyname(const char *name, struct group *gr)
 {
 	return -1;
 }
 
 static int
 grbygid(gid_t gid, struct group *gr)
 {
 	return -1;
 }
 
 struct backend_ops ldap_ops = {
 	.init = init,
 	.term = term,
 	.pwbyname = pwbyname,
 	.pwbyuid = pwbyuid,
 	.grbyname = grbyname,
 	.grbygid = grbygid,
 };