embedaddon/sudo/plugins/sudoers/ldap.c - diff

Return to ldap.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / plugins / sudoers

Diff for /embedaddon/sudo/plugins/sudoers/ldap.c between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2012/02/21 16:23:02	version 1.1.1.2, 2012/05/29 12:26:49
Line 80	Line 80
#include "parse.h"	#include "parse.h"
#include "lbuf.h"	#include "lbuf.h"

	/* Older Netscape LDAP SDKs don't prototype ldapssl_set_strength() */
	#if defined(HAVE_LDAPSSL_SET_STRENGTH) && !defined(HAVE_LDAP_SSL_H) && !defined(HAVE_MPS_LDAP_SSL_H)
	extern int ldapssl_set_strength(LDAP *ldap, int strength);
	#endif

#ifndef LDAP_OPT_SUCCESS	#ifndef LDAP_OPT_SUCCESS
# define LDAP_OPT_SUCCESS LDAP_SUCCESS	# define LDAP_OPT_SUCCESS LDAP_SUCCESS
#endif	#endif
Line 119	Line 124
#define CONF_LIST_STR 4	#define CONF_LIST_STR 4
#define CONF_DEREF_VAL 5	#define CONF_DEREF_VAL 5

	#define SUDO_LDAP_CLEAR 0
#define SUDO_LDAP_SSL 1	#define SUDO_LDAP_SSL 1
#define SUDO_LDAP_STARTTLS 2	#define SUDO_LDAP_STARTTLS 2

Line 171 struct ldap_result {	Line 177 struct ldap_result {

struct ldap_config_table {	struct ldap_config_table {
const char conf_str; / config file string */	const char conf_str; / config file string */
short type; /* CONF_BOOL, CONF_INT, CONF_STR */	int type; /* CONF_BOOL, CONF_INT, CONF_STR */
short connected; /* connection-specific value? */
int opt_val; /* LDAP_OPT_* (or -1 for sudo internal) */	int opt_val; /* LDAP_OPT_* (or -1 for sudo internal) */
void valp; / pointer into ldap_conf */	void valp; / pointer into ldap_conf */
};	};
Line 217 static struct ldap_config {	Line 222 static struct ldap_config {
char *krb5_ccname;	char *krb5_ccname;
} ldap_conf;	} ldap_conf;

static struct ldap_config_table ldap_conf_table[] = {	static struct ldap_config_table ldap_conf_global[] = {
{ "sudoers_debug", CONF_INT, FALSE, -1, &ldap_conf.debug },	{ "sudoers_debug", CONF_INT, -1, &ldap_conf.debug },
{ "host", CONF_STR, FALSE, -1, &ldap_conf.host },	{ "host", CONF_STR, -1, &ldap_conf.host },
{ "port", CONF_INT, FALSE, -1, &ldap_conf.port },	{ "port", CONF_INT, -1, &ldap_conf.port },
{ "ssl", CONF_STR, FALSE, -1, &ldap_conf.ssl },	{ "ssl", CONF_STR, -1, &ldap_conf.ssl },
{ "sslpath", CONF_STR, FALSE, -1, &ldap_conf.tls_certfile },	{ "sslpath", CONF_STR, -1, &ldap_conf.tls_certfile },
{ "uri", CONF_LIST_STR, FALSE, -1, &ldap_conf.uri },	{ "uri", CONF_LIST_STR, -1, &ldap_conf.uri },
#ifdef LDAP_OPT_DEBUG_LEVEL	#ifdef LDAP_OPT_DEBUG_LEVEL
{ "debug", CONF_INT, FALSE, LDAP_OPT_DEBUG_LEVEL, &ldap_conf.ldap_debug },	{ "debug", CONF_INT, LDAP_OPT_DEBUG_LEVEL, &ldap_conf.ldap_debug },
#endif	#endif
#ifdef LDAP_OPT_PROTOCOL_VERSION
{ "ldap_version", CONF_INT, TRUE, LDAP_OPT_PROTOCOL_VERSION,
&ldap_conf.version },
#endif
#ifdef LDAP_OPT_X_TLS_REQUIRE_CERT	#ifdef LDAP_OPT_X_TLS_REQUIRE_CERT
{ "tls_checkpeer", CONF_BOOL, FALSE, LDAP_OPT_X_TLS_REQUIRE_CERT,	{ "tls_checkpeer", CONF_BOOL, LDAP_OPT_X_TLS_REQUIRE_CERT,
&ldap_conf.tls_checkpeer },	&ldap_conf.tls_checkpeer },
#else	#else
{ "tls_checkpeer", CONF_BOOL, FALSE, -1, &ldap_conf.tls_checkpeer },	{ "tls_checkpeer", CONF_BOOL, -1, &ldap_conf.tls_checkpeer },
#endif	#endif
#ifdef LDAP_OPT_X_TLS_CACERTFILE	#ifdef LDAP_OPT_X_TLS_CACERTFILE
{ "tls_cacertfile", CONF_STR, FALSE, LDAP_OPT_X_TLS_CACERTFILE,	{ "tls_cacertfile", CONF_STR, LDAP_OPT_X_TLS_CACERTFILE,
&ldap_conf.tls_cacertfile },	&ldap_conf.tls_cacertfile },
{ "tls_cacert", CONF_STR, FALSE, LDAP_OPT_X_TLS_CACERTFILE,	{ "tls_cacert", CONF_STR, LDAP_OPT_X_TLS_CACERTFILE,
&ldap_conf.tls_cacertfile },	&ldap_conf.tls_cacertfile },
#endif	#endif
#ifdef LDAP_OPT_X_TLS_CACERTDIR	#ifdef LDAP_OPT_X_TLS_CACERTDIR
{ "tls_cacertdir", CONF_STR, FALSE, LDAP_OPT_X_TLS_CACERTDIR,	{ "tls_cacertdir", CONF_STR, LDAP_OPT_X_TLS_CACERTDIR,
&ldap_conf.tls_cacertdir },	&ldap_conf.tls_cacertdir },
#endif	#endif
#ifdef LDAP_OPT_X_TLS_RANDOM_FILE	#ifdef LDAP_OPT_X_TLS_RANDOM_FILE
{ "tls_randfile", CONF_STR, FALSE, LDAP_OPT_X_TLS_RANDOM_FILE,	{ "tls_randfile", CONF_STR, LDAP_OPT_X_TLS_RANDOM_FILE,
&ldap_conf.tls_random_file },	&ldap_conf.tls_random_file },
#endif	#endif
#ifdef LDAP_OPT_X_TLS_CIPHER_SUITE	#ifdef LDAP_OPT_X_TLS_CIPHER_SUITE
{ "tls_ciphers", CONF_STR, FALSE, LDAP_OPT_X_TLS_CIPHER_SUITE,	{ "tls_ciphers", CONF_STR, LDAP_OPT_X_TLS_CIPHER_SUITE,
&ldap_conf.tls_cipher_suite },	&ldap_conf.tls_cipher_suite },
#endif	#endif
#ifdef LDAP_OPT_X_TLS_CERTFILE	#ifdef LDAP_OPT_X_TLS_CERTFILE
{ "tls_cert", CONF_STR, FALSE, LDAP_OPT_X_TLS_CERTFILE,	{ "tls_cert", CONF_STR, LDAP_OPT_X_TLS_CERTFILE,
&ldap_conf.tls_certfile },	&ldap_conf.tls_certfile },
#else	#else
{ "tls_cert", CONF_STR, FALSE, -1, &ldap_conf.tls_certfile },	{ "tls_cert", CONF_STR, -1, &ldap_conf.tls_certfile },
#endif	#endif
#ifdef LDAP_OPT_X_TLS_KEYFILE	#ifdef LDAP_OPT_X_TLS_KEYFILE
{ "tls_key", CONF_STR, FALSE, LDAP_OPT_X_TLS_KEYFILE,	{ "tls_key", CONF_STR, LDAP_OPT_X_TLS_KEYFILE,
&ldap_conf.tls_keyfile },	&ldap_conf.tls_keyfile },
#else	#else
{ "tls_key", CONF_STR, FALSE, -1, &ldap_conf.tls_keyfile },	{ "tls_key", CONF_STR, -1, &ldap_conf.tls_keyfile },
#endif	#endif
	{ "binddn", CONF_STR, -1, &ldap_conf.binddn },
	{ "bindpw", CONF_STR, -1, &ldap_conf.bindpw },
	{ "rootbinddn", CONF_STR, -1, &ldap_conf.rootbinddn },
	{ "sudoers_base", CONF_LIST_STR, -1, &ldap_conf.base },
	{ "sudoers_timed", CONF_BOOL, -1, &ldap_conf.timed },
	{ "sudoers_search_filter", CONF_STR, -1, &ldap_conf.search_filter },
	#ifdef HAVE_LDAP_SASL_INTERACTIVE_BIND_S
	{ "use_sasl", CONF_BOOL, -1, &ldap_conf.use_sasl },
	{ "sasl_auth_id", CONF_STR, -1, &ldap_conf.sasl_auth_id },
	{ "rootuse_sasl", CONF_BOOL, -1, &ldap_conf.rootuse_sasl },
	{ "rootsasl_auth_id", CONF_STR, -1, &ldap_conf.rootsasl_auth_id },
	{ "krb5_ccname", CONF_STR, -1, &ldap_conf.krb5_ccname },
	#endif /* HAVE_LDAP_SASL_INTERACTIVE_BIND_S */
	{ NULL }
	};

	static struct ldap_config_table ldap_conf_conn[] = {
	#ifdef LDAP_OPT_PROTOCOL_VERSION
	{ "ldap_version", CONF_INT, LDAP_OPT_PROTOCOL_VERSION,
	&ldap_conf.version },
	#endif
#ifdef LDAP_OPT_NETWORK_TIMEOUT	#ifdef LDAP_OPT_NETWORK_TIMEOUT
{ "bind_timelimit", CONF_INT, TRUE, -1 /* needs timeval, set manually */,	{ "bind_timelimit", CONF_INT, -1 /* needs timeval, set manually */,
&ldap_conf.bind_timelimit },	&ldap_conf.bind_timelimit },
{ "network_timeout", CONF_INT, TRUE, -1 /* needs timeval, set manually */,	{ "network_timeout", CONF_INT, -1 /* needs timeval, set manually */,
&ldap_conf.bind_timelimit },	&ldap_conf.bind_timelimit },
#elif defined(LDAP_X_OPT_CONNECT_TIMEOUT)	#elif defined(LDAP_X_OPT_CONNECT_TIMEOUT)
{ "bind_timelimit", CONF_INT, TRUE, LDAP_X_OPT_CONNECT_TIMEOUT,	{ "bind_timelimit", CONF_INT, LDAP_X_OPT_CONNECT_TIMEOUT,
&ldap_conf.bind_timelimit },	&ldap_conf.bind_timelimit },
{ "network_timeout", CONF_INT, TRUE, LDAP_X_OPT_CONNECT_TIMEOUT,	{ "network_timeout", CONF_INT, LDAP_X_OPT_CONNECT_TIMEOUT,
&ldap_conf.bind_timelimit },	&ldap_conf.bind_timelimit },
#endif	#endif
{ "timelimit", CONF_INT, TRUE, LDAP_OPT_TIMELIMIT, &ldap_conf.timelimit },	{ "timelimit", CONF_INT, LDAP_OPT_TIMELIMIT, &ldap_conf.timelimit },
#ifdef LDAP_OPT_TIMEOUT	#ifdef LDAP_OPT_TIMEOUT
{ "timeout", CONF_INT, TRUE, -1 /* needs timeval, set manually */,	{ "timeout", CONF_INT, -1 /* needs timeval, set manually */,
&ldap_conf.timeout },	&ldap_conf.timeout },
#endif	#endif
#ifdef LDAP_OPT_DEREF	#ifdef LDAP_OPT_DEREF
{ "deref", CONF_DEREF_VAL, TRUE, LDAP_OPT_DEREF, &ldap_conf.deref },	{ "deref", CONF_DEREF_VAL, LDAP_OPT_DEREF, &ldap_conf.deref },
#endif	#endif
{ "binddn", CONF_STR, FALSE, -1, &ldap_conf.binddn },	#ifdef LDAP_OPT_X_SASL_SECPROPS
{ "bindpw", CONF_STR, FALSE, -1, &ldap_conf.bindpw },	{ "sasl_secprops", CONF_STR, LDAP_OPT_X_SASL_SECPROPS,
{ "rootbinddn", CONF_STR, FALSE, -1, &ldap_conf.rootbinddn },
{ "sudoers_base", CONF_LIST_STR, FALSE, -1, &ldap_conf.base },
{ "sudoers_timed", CONF_BOOL, FALSE, -1, &ldap_conf.timed },
{ "sudoers_search_filter", CONF_STR, FALSE, -1, &ldap_conf.search_filter },
#ifdef HAVE_LDAP_SASL_INTERACTIVE_BIND_S
{ "use_sasl", CONF_BOOL, FALSE, -1, &ldap_conf.use_sasl },
{ "sasl_auth_id", CONF_STR, FALSE, -1, &ldap_conf.sasl_auth_id },
{ "rootuse_sasl", CONF_BOOL, FALSE, -1, &ldap_conf.rootuse_sasl },
{ "rootsasl_auth_id", CONF_STR, FALSE, -1, &ldap_conf.rootsasl_auth_id },
# ifdef LDAP_OPT_X_SASL_SECPROPS
{ "sasl_secprops", CONF_STR, TRUE, LDAP_OPT_X_SASL_SECPROPS,
&ldap_conf.sasl_secprops },	&ldap_conf.sasl_secprops },
# endif	#endif
{ "krb5_ccname", CONF_STR, FALSE, -1, &ldap_conf.krb5_ccname },
#endif /* HAVE_LDAP_SASL_INTERACTIVE_BIND_S */
{ NULL }	{ NULL }
};	};

Line 362 sudo_ldap_conf_add_ports(void)	Line 371 sudo_ldap_conf_add_ports(void)

char host, port, defport[13];	char host, port, defport[13];
char hostbuf[LINE_MAX * 2];	char hostbuf[LINE_MAX * 2];
	debug_decl(sudo_ldap_conf_add_ports, SUDO_DEBUG_LDAP)

hostbuf[0] = '\0';	hostbuf[0] = '\0';
if (snprintf(defport, sizeof(defport), ":%d", ldap_conf.port) >= sizeof(defport))	if (snprintf(defport, sizeof(defport), ":%d", ldap_conf.port) >= sizeof(defport))
Line 385 sudo_ldap_conf_add_ports(void)	Line 395 sudo_ldap_conf_add_ports(void)

efree(ldap_conf.host);	efree(ldap_conf.host);
ldap_conf.host = estrdup(hostbuf);	ldap_conf.host = estrdup(hostbuf);
return;	debug_return;

toobig:	toobig:
errorx(1, _("sudo_ldap_conf_add_ports: out of space expanding hostbuf"));	errorx(1, _("sudo_ldap_conf_add_ports: out of space expanding hostbuf"));
Line 405 sudo_ldap_parse_uri(const struct ldap_config_list_str	Line 415 sudo_ldap_parse_uri(const struct ldap_config_list_str
char hostbuf[LINE_MAX];	char hostbuf[LINE_MAX];
int nldap = 0, nldaps = 0;	int nldap = 0, nldaps = 0;
int rc = -1;	int rc = -1;
	debug_decl(sudo_ldap_parse_uri, SUDO_DEBUG_LDAP)

do {	do {
buf = estrdup(uri_list->val);	buf = estrdup(uri_list->val);
Line 446 sudo_ldap_parse_uri(const struct ldap_config_list_str	Line 457 sudo_ldap_parse_uri(const struct ldap_config_list_str
}	}
}	}
if (hostbuf[0] == '\0') {	if (hostbuf[0] == '\0') {
warningx(_("invalid uri: %s"), uri_list);	warningx(_("invalid uri: %s"), uri_list->val);
goto done;	goto done;
}	}

Line 472 sudo_ldap_parse_uri(const struct ldap_config_list_str	Line 483 sudo_ldap_parse_uri(const struct ldap_config_list_str

done:	done:
efree(buf);	efree(buf);
return rc;	debug_return_int(rc);

toobig:	toobig:
errorx(1, _("sudo_ldap_parse_uri: out of space building hostbuf"));	errorx(1, _("sudo_ldap_parse_uri: out of space building hostbuf"));
Line 484 sudo_ldap_join_uri(struct ldap_config_list_str *uri_li	Line 495 sudo_ldap_join_uri(struct ldap_config_list_str *uri_li
struct ldap_config_list_str *uri;	struct ldap_config_list_str *uri;
size_t len = 0;	size_t len = 0;
char buf, cp;	char buf, cp;
	debug_decl(sudo_ldap_join_uri, SUDO_DEBUG_LDAP)

/* Usually just a single entry. */	/* Usually just a single entry. */
if (uri_list->next == NULL)	if (uri_list->next == NULL)
return estrdup(uri_list->val);	debug_return_str(estrdup(uri_list->val));

for (uri = uri_list; uri != NULL; uri = uri->next) {	for (uri = uri_list; uri != NULL; uri = uri->next) {
len += strlen(uri->val) + 1;	len += strlen(uri->val) + 1;
Line 499 sudo_ldap_join_uri(struct ldap_config_list_str *uri_li	Line 511 sudo_ldap_join_uri(struct ldap_config_list_str *uri_li
*cp++ = ' ';	*cp++ = ' ';
}	}
cp[-1] = '\0';	cp[-1] = '\0';
return buf;	debug_return_str(buf);
}	}
#endif /* HAVE_LDAP_INITIALIZE */	#endif /* HAVE_LDAP_INITIALIZE */

Line 508 sudo_ldap_init(LDAP *ldp, const char host, int port)	Line 520 sudo_ldap_init(LDAP *ldp, const char host, int port)
{	{
LDAP *ld = NULL;	LDAP *ld = NULL;
int rc = LDAP_CONNECT_ERROR;	int rc = LDAP_CONNECT_ERROR;
	debug_decl(sudo_ldap_init, SUDO_DEBUG_LDAP)

#ifdef HAVE_LDAPSSL_INIT	#ifdef HAVE_LDAPSSL_INIT
if (ldap_conf.ssl_mode == SUDO_LDAP_SSL) {	if (ldap_conf.ssl_mode != SUDO_LDAP_CLEAR) {
	const int defsecure = ldap_conf.ssl_mode == SUDO_LDAP_SSL;
DPRINTF(("ldapssl_clientauth_init(%s, %s)",	DPRINTF(("ldapssl_clientauth_init(%s, %s)",
ldap_conf.tls_certfile ? ldap_conf.tls_certfile : "NULL",	ldap_conf.tls_certfile ? ldap_conf.tls_certfile : "NULL",
ldap_conf.tls_keyfile ? ldap_conf.tls_keyfile : "NULL"), 2);	ldap_conf.tls_keyfile ? ldap_conf.tls_keyfile : "NULL"), 2);
rc = ldapssl_clientauth_init(ldap_conf.tls_certfile, NULL,	rc = ldapssl_clientauth_init(ldap_conf.tls_certfile, NULL,
ldap_conf.tls_keyfile != NULL, ldap_conf.tls_keyfile, NULL);	ldap_conf.tls_keyfile != NULL, ldap_conf.tls_keyfile, NULL);
/*	/*
* Mozilla-derived SDKs have a bug starting with version 5.0	* Starting with version 5.0, Mozilla-derived LDAP SDKs require
* where the path can no longer be a file name and must be a dir.	* the cert and key paths to be a directory, not a file.
	* If the user specified a file and it fails, try the parent dir.
*/	*/
if (rc != LDAP_SUCCESS) {	if (rc != LDAP_SUCCESS) {
char *cp;	bool retry = false;
if (ldap_conf.tls_certfile) {	if (ldap_conf.tls_certfile != NULL) {
cp = strrchr(ldap_conf.tls_certfile, '/');	char *cp = strrchr(ldap_conf.tls_certfile, '/');
if (cp != NULL && strncmp(cp + 1, "cert", 4) == 0)	if (cp != NULL && strncmp(cp + 1, "cert", 4) == 0) {
*cp = '\0';	*cp = '\0';
	retry = true;
	}
}	}
if (ldap_conf.tls_keyfile) {	if (ldap_conf.tls_keyfile != NULL) {
cp = strrchr(ldap_conf.tls_keyfile, '/');	char *cp = strrchr(ldap_conf.tls_keyfile, '/');
if (cp != NULL && strncmp(cp + 1, "key", 3) == 0)	if (cp != NULL && strncmp(cp + 1, "key", 3) == 0) {
*cp = '\0';	*cp = '\0';
	retry = true;
	}
}	}
DPRINTF(("ldapssl_clientauth_init(%s, %s)",	if (retry) {
ldap_conf.tls_certfile ? ldap_conf.tls_certfile : "NULL",	DPRINTF(("ldapssl_clientauth_init(%s, %s)",
ldap_conf.tls_keyfile ? ldap_conf.tls_keyfile : "NULL"), 2);	ldap_conf.tls_certfile ? ldap_conf.tls_certfile : "NULL",
rc = ldapssl_clientauth_init(ldap_conf.tls_certfile, NULL,	ldap_conf.tls_keyfile ? ldap_conf.tls_keyfile : "NULL"), 2);
ldap_conf.tls_keyfile != NULL, ldap_conf.tls_keyfile, NULL);	rc = ldapssl_clientauth_init(ldap_conf.tls_certfile, NULL,
if (rc != LDAP_SUCCESS) {	ldap_conf.tls_keyfile != NULL, ldap_conf.tls_keyfile, NULL);
warningx(_("unable to initialize SSL cert and key db: %s"),
ldapssl_err2string(rc));
goto done;
}	}
}	}
	if (rc != LDAP_SUCCESS) {
	warningx(_("unable to initialize SSL cert and key db: %s"),
	ldapssl_err2string(rc));
	if (ldap_conf.tls_certfile == NULL)
	warningx(_("you must set TLS_CERT in %s to use SSL"),
	_PATH_LDAP_CONF);
	goto done;
	}

DPRINTF(("ldapssl_init(%s, %d, 1)", host, port), 2);	DPRINTF(("ldapssl_init(%s, %d, %d)", host, port, defsecure), 2);
if ((ld = ldapssl_init(host, port, 1)) != NULL)	if ((ld = ldapssl_init(host, port, defsecure)) != NULL)
rc = LDAP_SUCCESS;	rc = LDAP_SUCCESS;
} else	} else
#endif	#endif
Line 565 sudo_ldap_init(LDAP *ldp, const char host, int port)	Line 589 sudo_ldap_init(LDAP *ldp, const char host, int port)

done:	done:
*ldp = ld;	*ldp = ld;
return rc;	debug_return_int(rc);
}	}

/*	/*
* Walk through search results and return TRUE if we have a matching	* Walk through search results and return true if we have a matching
* netgroup, else FALSE.	* netgroup, else false.
*/	*/
static int	static bool
sudo_ldap_check_user_netgroup(LDAP ld, LDAPMessage entry, char *user)	sudo_ldap_check_user_netgroup(LDAP ld, LDAPMessage entry, char *user)
{	{
struct berval bv, p;	struct berval bv, p;
char *val;	char *val;
int ret = FALSE;	int ret = false;
	debug_decl(sudo_ldap_check_user_netgroup, SUDO_DEBUG_LDAP)

if (!entry)	if (!entry)
return ret;	debug_return_bool(ret);

/* get the values from the entry */	/* get the values from the entry */
bv = ldap_get_values_len(ld, entry, "sudoUser");	bv = ldap_get_values_len(ld, entry, "sudoUser");
if (bv == NULL)	if (bv == NULL)
return ret;	debug_return_bool(ret);

/* walk through values */	/* walk through values */
for (p = bv; *p != NULL && !ret; p++) {	for (p = bv; *p != NULL && !ret; p++) {
val = (*p)->bv_val;	val = (*p)->bv_val;
/* match any */	/* match any */
if (netgr_matches(val, NULL, NULL, user))	if (netgr_matches(val, NULL, NULL, user))
ret = TRUE;	ret = true;
DPRINTF(("ldap sudoUser netgroup '%s' ... %s", val,	DPRINTF(("ldap sudoUser netgroup '%s' ... %s", val,
ret ? "MATCH!" : "not"), 2 + ((ret) ? 0 : 1));	ret ? "MATCH!" : "not"), 2 + ((ret) ? 0 : 1));
}	}

ldap_value_free_len(bv); /* cleanup */	ldap_value_free_len(bv); /* cleanup */

return ret;	debug_return_bool(ret);
}	}

/*	/*
* Walk through search results and return TRUE if we have a	* Walk through search results and return true if we have a
* host match, else FALSE.	* host match, else false.
*/	*/
static int	static bool
sudo_ldap_check_host(LDAP ld, LDAPMessage entry)	sudo_ldap_check_host(LDAP ld, LDAPMessage entry)
{	{
struct berval bv, p;	struct berval bv, p;
char *val;	char *val;
int ret = FALSE;	bool ret = false;
	debug_decl(sudo_ldap_check_host, SUDO_DEBUG_LDAP)

if (!entry)	if (!entry)
return ret;	debug_return_bool(ret);

/* get the values from the entry */	/* get the values from the entry */
bv = ldap_get_values_len(ld, entry, "sudoHost");	bv = ldap_get_values_len(ld, entry, "sudoHost");
if (bv == NULL)	if (bv == NULL)
return ret;	debug_return_bool(ret);

/* walk through values */	/* walk through values */
for (p = bv; *p != NULL && !ret; p++) {	for (p = bv; *p != NULL && !ret; p++) {
Line 628 sudo_ldap_check_host(LDAP ld, LDAPMessage entry)	Line 654 sudo_ldap_check_host(LDAP ld, LDAPMessage entry)
if (!strcmp(val, "ALL") \|\| addr_matches(val) \|\|	if (!strcmp(val, "ALL") \|\| addr_matches(val) \|\|
netgr_matches(val, user_host, user_shost, NULL) \|\|	netgr_matches(val, user_host, user_shost, NULL) \|\|
hostname_matches(user_shost, user_host, val))	hostname_matches(user_shost, user_host, val))
ret = TRUE;	ret = true;
DPRINTF(("ldap sudoHost '%s' ... %s", val,	DPRINTF(("ldap sudoHost '%s' ... %s", val,
ret ? "MATCH!" : "not"), 2);	ret ? "MATCH!" : "not"), 2);
}	}

ldap_value_free_len(bv); /* cleanup */	ldap_value_free_len(bv); /* cleanup */

return ret;	debug_return_bool(ret);
}	}

static int	static int
Line 643 sudo_ldap_check_runas_user(LDAP ld, LDAPMessage entr	Line 669 sudo_ldap_check_runas_user(LDAP ld, LDAPMessage entr
{	{
struct berval bv, p;	struct berval bv, p;
char *val;	char *val;
int ret = FALSE;	bool ret = false;
	debug_decl(sudo_ldap_check_runas_user, SUDO_DEBUG_LDAP)

if (!runas_pw)	if (!runas_pw)
return UNSPEC;	debug_return_bool(UNSPEC);

/* get the runas user from the entry */	/* get the runas user from the entry */
bv = ldap_get_values_len(ld, entry, "sudoRunAsUser");	bv = ldap_get_values_len(ld, entry, "sudoRunAsUser");
Line 675 sudo_ldap_check_runas_user(LDAP ld, LDAPMessage entr	Line 702 sudo_ldap_check_runas_user(LDAP ld, LDAPMessage entr
* what the user specified on the command line.	* what the user specified on the command line.
*/	*/
if (bv == NULL)	if (bv == NULL)
return !strcasecmp(runas_pw->pw_name, def_runas_default);	debug_return_bool(!strcasecmp(runas_pw->pw_name, def_runas_default));

/* walk through values returned, looking for a match */	/* walk through values returned, looking for a match */
for (p = bv; *p != NULL && !ret; p++) {	for (p = bv; *p != NULL && !ret; p++) {
Line 683 sudo_ldap_check_runas_user(LDAP ld, LDAPMessage entr	Line 710 sudo_ldap_check_runas_user(LDAP ld, LDAPMessage entr
switch (val[0]) {	switch (val[0]) {
case '+':	case '+':
if (netgr_matches(val, NULL, NULL, runas_pw->pw_name))	if (netgr_matches(val, NULL, NULL, runas_pw->pw_name))
ret = TRUE;	ret = true;
break;	break;
case '%':	case '%':
if (usergr_matches(val, runas_pw->pw_name, runas_pw))	if (usergr_matches(val, runas_pw->pw_name, runas_pw))
ret = TRUE;	ret = true;
break;	break;
case 'A':	case 'A':
if (strcmp(val, "ALL") == 0) {	if (strcmp(val, "ALL") == 0) {
ret = TRUE;	ret = true;
break;	break;
}	}
/* FALLTHROUGH */	/* FALLTHROUGH */
default:	default:
if (strcasecmp(val, runas_pw->pw_name) == 0)	if (strcasecmp(val, runas_pw->pw_name) == 0)
ret = TRUE;	ret = true;
break;	break;
}	}
DPRINTF(("ldap sudoRunAsUser '%s' ... %s", val,	DPRINTF(("ldap sudoRunAsUser '%s' ... %s", val,
Line 706 sudo_ldap_check_runas_user(LDAP ld, LDAPMessage entr	Line 733 sudo_ldap_check_runas_user(LDAP ld, LDAPMessage entr

ldap_value_free_len(bv); /* cleanup */	ldap_value_free_len(bv); /* cleanup */

return ret;	debug_return_bool(ret);
}	}

static int	static int
Line 714 sudo_ldap_check_runas_group(LDAP ld, LDAPMessage ent	Line 741 sudo_ldap_check_runas_group(LDAP ld, LDAPMessage ent
{	{
struct berval bv, p;	struct berval bv, p;
char *val;	char *val;
int ret = FALSE;	bool ret = false;
	debug_decl(sudo_ldap_check_runas_group, SUDO_DEBUG_LDAP)

/* runas_gr is only set if the user specified the -g flag */	/* runas_gr is only set if the user specified the -g flag */
if (!runas_gr)	if (!runas_gr)
return UNSPEC;	debug_return_bool(UNSPEC);

/* get the values from the entry */	/* get the values from the entry */
bv = ldap_get_values_len(ld, entry, "sudoRunAsGroup");	bv = ldap_get_values_len(ld, entry, "sudoRunAsGroup");
if (bv == NULL)	if (bv == NULL)
return ret;	debug_return_bool(ret);

/* walk through values returned, looking for a match */	/* walk through values returned, looking for a match */
for (p = bv; *p != NULL && !ret; p++) {	for (p = bv; *p != NULL && !ret; p++) {
val = (*p)->bv_val;	val = (*p)->bv_val;
if (strcmp(val, "ALL") == 0 \|\| group_matches(val, runas_gr))	if (strcmp(val, "ALL") == 0 \|\| group_matches(val, runas_gr))
ret = TRUE;	ret = true;
DPRINTF(("ldap sudoRunAsGroup '%s' ... %s", val,	DPRINTF(("ldap sudoRunAsGroup '%s' ... %s", val,
ret ? "MATCH!" : "not"), 2);	ret ? "MATCH!" : "not"), 2);
}	}

ldap_value_free_len(bv); /* cleanup */	ldap_value_free_len(bv); /* cleanup */

return ret;	debug_return_bool(ret);
}	}

/*	/*
* Walk through search results and return TRUE if we have a runas match,	* Walk through search results and return true if we have a runas match,
* else FALSE. RunAs info is optional.	* else false. RunAs info is optional.
*/	*/
static int	static bool
sudo_ldap_check_runas(LDAP ld, LDAPMessage entry)	sudo_ldap_check_runas(LDAP ld, LDAPMessage entry)
{	{
int ret;	bool ret;
	debug_decl(sudo_ldap_check_runas, SUDO_DEBUG_LDAP)

if (!entry)	if (!entry)
return FALSE;	debug_return_bool(false);

ret = sudo_ldap_check_runas_user(ld, entry) != FALSE &&	ret = sudo_ldap_check_runas_user(ld, entry) != false &&
sudo_ldap_check_runas_group(ld, entry) != FALSE;	sudo_ldap_check_runas_group(ld, entry) != false;

return ret;	debug_return_bool(ret);
}	}

/*	/*
* Walk through search results and return TRUE if we have a command match,	* Walk through search results and return true if we have a command match,
* FALSE if disallowed and UNSPEC if not matched.	* false if disallowed and UNSPEC if not matched.
*/	*/
static int	static int
sudo_ldap_check_command(LDAP ld, LDAPMessage entry, int *setenv_implied)	sudo_ldap_check_command(LDAP ld, LDAPMessage entry, int *setenv_implied)
{	{
struct berval bv, p;	struct berval bv, p;
char allowed_cmnd, allowed_args, *val;	char allowed_cmnd, allowed_args, *val;
int foundbang, ret = UNSPEC;	bool foundbang;
	int ret = UNSPEC;
	debug_decl(sudo_ldap_check_command, SUDO_DEBUG_LDAP)

if (!entry)	if (!entry)
return ret;	debug_return_bool(ret);

bv = ldap_get_values_len(ld, entry, "sudoCommand");	bv = ldap_get_values_len(ld, entry, "sudoCommand");
if (bv == NULL)	if (bv == NULL)
return ret;	debug_return_bool(ret);

for (p = bv; *p != NULL && ret != FALSE; p++) {	for (p = bv; *p != NULL && ret != false; p++) {
val = (*p)->bv_val;	val = (*p)->bv_val;
/* Match against ALL ? */	/* Match against ALL ? */
if (!strcmp(val, "ALL")) {	if (!strcmp(val, "ALL")) {
ret = TRUE;	ret = true;
if (setenv_implied != NULL)	if (setenv_implied != NULL)
*setenv_implied = TRUE;	*setenv_implied = true;
DPRINTF(("ldap sudoCommand '%s' ... MATCH!", val), 2);	DPRINTF(("ldap sudoCommand '%s' ... MATCH!", val), 2);
continue;	continue;
}	}

/* check for !command */	/* check for !command */
if (*val == '!') {	if (*val == '!') {
foundbang = TRUE;	foundbang = true;
allowed_cmnd = estrdup(1 + val); /* !command */	allowed_cmnd = estrdup(1 + val); /* !command */
} else {	} else {
foundbang = FALSE;	foundbang = false;
allowed_cmnd = estrdup(val); /* command */	allowed_cmnd = estrdup(val); /* command */
}	}

Line 806 sudo_ldap_check_command(LDAP ld, LDAPMessage entry,	Line 837 sudo_ldap_check_command(LDAP ld, LDAPMessage entry,
* If allowed (no bang) set ret but keep on checking.	* If allowed (no bang) set ret but keep on checking.
* If disallowed (bang), exit loop.	* If disallowed (bang), exit loop.
*/	*/
ret = foundbang ? FALSE : TRUE;	ret = foundbang ? false : true;
}	}
DPRINTF(("ldap sudoCommand '%s' ... %s", val,	DPRINTF(("ldap sudoCommand '%s' ... %s", val,
ret == TRUE ? "MATCH!" : "not"), 2);	ret == true ? "MATCH!" : "not"), 2);

efree(allowed_cmnd); /* cleanup */	efree(allowed_cmnd); /* cleanup */
}	}

ldap_value_free_len(bv); /* more cleanup */	ldap_value_free_len(bv); /* more cleanup */

return ret;	debug_return_bool(ret);
}	}

/*	/*
* Search for boolean "option" in sudoOption.	* Search for boolean "option" in sudoOption.
* Returns TRUE if found and allowed, FALSE if negated, else UNSPEC.	* Returns true if found and allowed, false if negated, else UNSPEC.
*/	*/
static int	static int
sudo_ldap_check_bool(LDAP ld, LDAPMessage entry, char *option)	sudo_ldap_check_bool(LDAP ld, LDAPMessage entry, char *option)
Line 829 sudo_ldap_check_bool(LDAP ld, LDAPMessage entry, cha	Line 860 sudo_ldap_check_bool(LDAP ld, LDAPMessage entry, cha
struct berval bv, p;	struct berval bv, p;
char ch, *var;	char ch, *var;
int ret = UNSPEC;	int ret = UNSPEC;
	debug_decl(sudo_ldap_check_bool, SUDO_DEBUG_LDAP)

if (entry == NULL)	if (entry == NULL)
return UNSPEC;	debug_return_bool(ret);

bv = ldap_get_values_len(ld, entry, "sudoOption");	bv = ldap_get_values_len(ld, entry, "sudoOption");
if (bv == NULL)	if (bv == NULL)
return ret;	debug_return_bool(ret);

/* walk through options */	/* walk through options */
for (p = bv; *p != NULL; p++) {	for (p = bv; *p != NULL; p++) {
Line 850 sudo_ldap_check_bool(LDAP ld, LDAPMessage entry, cha	Line 882 sudo_ldap_check_bool(LDAP ld, LDAPMessage entry, cha

ldap_value_free_len(bv);	ldap_value_free_len(bv);

return ret;	debug_return_bool(ret);
}	}

/*	/*
Line 862 sudo_ldap_parse_options(LDAP ld, LDAPMessage entry)	Line 894 sudo_ldap_parse_options(LDAP ld, LDAPMessage entry)
{	{
struct berval bv, p;	struct berval bv, p;
char op, var, val;	char op, var, val;
	debug_decl(sudo_ldap_parse_options, SUDO_DEBUG_LDAP)

if (entry == NULL)	if (entry == NULL)
return;	debug_return;

bv = ldap_get_values_len(ld, entry, "sudoOption");	bv = ldap_get_values_len(ld, entry, "sudoOption");
if (bv == NULL)	if (bv == NULL)
return;	debug_return;

/* walk through options */	/* walk through options */
for (p = bv; *p != NULL; p++) {	for (p = bv; *p != NULL; p++) {
Line 886 sudo_ldap_parse_options(LDAP ld, LDAPMessage entry)	Line 919 sudo_ldap_parse_options(LDAP ld, LDAPMessage entry)
set_default(var, val, (int) op);	set_default(var, val, (int) op);
} else {	} else {
/* case var=val */	/* case var=val */
set_default(var, val, TRUE);	set_default(var, val, true);
}	}
} else if (*var == '!') {	} else if (*var == '!') {
/* case !var Boolean False */	/* case !var Boolean False */
set_default(var + 1, NULL, FALSE);	set_default(var + 1, NULL, false);
} else {	} else {
/* case var Boolean True */	/* case var Boolean True */
set_default(var, NULL, TRUE);	set_default(var, NULL, true);
}	}
efree(var);	efree(var);
}	}

ldap_value_free_len(bv);	ldap_value_free_len(bv);

	debug_return;
}	}

/*	/*
Line 930 sudo_ldap_timefilter(char *buffer, size_t buffersize)	Line 965 sudo_ldap_timefilter(char *buffer, size_t buffersize)
time_t now;	time_t now;
char timebuffer[16];	char timebuffer[16];
int bytes = 0;	int bytes = 0;
	debug_decl(sudo_ldap_timefilter, SUDO_DEBUG_LDAP)

/* Make sure we have a formatted timestamp for __now__. */	/* Make sure we have a formatted timestamp for __now__. */
time(&now);	time(&now);
Line 953 sudo_ldap_timefilter(char *buffer, size_t buffersize)	Line 989 sudo_ldap_timefilter(char *buffer, size_t buffersize)
}	}

done:	done:
return bytes;	debug_return_int(bytes);
}	}

/*	/*
* Builds up a filter to search for default settings	* Builds up a filter to search for default settings
*/	*/
static char *	static char *
sudo_ldap_build_default_filter()	sudo_ldap_build_default_filter(void)
{	{
char *filt;	char *filt;
	debug_decl(sudo_ldap_build_default_filter, SUDO_DEBUG_LDAP)

if (ldap_conf.search_filter)	if (ldap_conf.search_filter)
easprintf(&filt, "(&%s(cn=defaults))", ldap_conf.search_filter);	easprintf(&filt, "(&%s(cn=defaults))", ldap_conf.search_filter);
else	else
filt = estrdup("cn=defaults");	filt = estrdup("cn=defaults");
return filt;	debug_return_str(filt);
}	}

/*	/*
	* Determine length of query value after escaping characters
	* as per RFC 4515.
	*/
	static size_t
	sudo_ldap_value_len(const char *value)
	{
	const char *s;
	size_t len = 0;

	for (s = value; *s != '\0'; s++) {
	switch (*s) {
	case '\\':
	case '(':
	case ')':
	case '*':
	len += 2;
	break;
	}
	}
	len += (size_t)(s - value);
	return len;
	}

	/*
	* Like strlcat() but escapes characters as per RFC 4515.
	*/
	static size_t
	sudo_ldap_value_cat(char dst, const char src, size_t size)
	{
	char *d = dst;
	const char *s = src;
	size_t n = size;
	size_t dlen;

	/* Find the end of dst and adjust bytes left but don't go past end */
	while (n-- != 0 && *d != '\0')
	d++;
	dlen = d - dst;
	n = size - dlen;

	if (n == 0)
	return dlen + strlen(s);
	while (*s != '\0') {
	switch (*s) {
	case '\\':
	if (n < 3)
	goto done;
	*d++ = '\\';
	*d++ = '5';
	*d++ = 'c';
	n -= 3;
	break;
	case '(':
	if (n < 3)
	goto done;
	*d++ = '\\';
	*d++ = '2';
	*d++ = '8';
	n -= 3;
	break;
	case ')':
	if (n < 3)
	goto done;
	*d++ = '\\';
	*d++ = '2';
	*d++ = '9';
	n -= 3;
	break;
	case '*':
	if (n < 3)
	goto done;
	*d++ = '\\';
	*d++ = '2';
	*d++ = 'a';
	n -= 3;
	break;
	default:
	if (n < 1)
	goto done;
	d++ = s;
	n--;
	break;
	}
	s++;
	}
	done:
	*d = '\0';
	while (*s != '\0')
	s++;
	return dlen + (s - src); /* count does not include NUL */
	}

	/*
* Builds up a filter to check against LDAP.	* Builds up a filter to check against LDAP.
*/	*/
static char *	static char *
sudo_ldap_build_pass1(struct passwd *pw)	sudo_ldap_build_pass1(struct passwd *pw)
{	{
struct group *grp;	struct group *grp;
char *buf, timebuffer[TIMEFILTER_LENGTH];	char *buf, timebuffer[TIMEFILTER_LENGTH], gidbuf[MAX_UID_T_LEN];
struct group_list *grlist;	struct group_list *grlist;
size_t sz = 0;	size_t sz = 0;
int i;	int i;
	debug_decl(sudo_ldap_build_pass1, SUDO_DEBUG_LDAP)

/* Start with LDAP search filter length + 3 */	/* Start with LDAP search filter length + 3 */
if (ldap_conf.search_filter)	if (ldap_conf.search_filter)
sz += strlen(ldap_conf.search_filter) + 3;	sz += strlen(ldap_conf.search_filter) + 3;

/* Then add (\|(sudoUser=USERNAME)(sudoUser=ALL)) + NUL */	/* Then add (\|(sudoUser=USERNAME)(sudoUser=ALL)) + NUL */
sz += 29 + strlen(pw->pw_name);	sz += 29 + sudo_ldap_value_len(pw->pw_name);

/* Add space for primary and supplementary groups */	/* Add space for primary and supplementary groups and gids */
if ((grp = sudo_getgrgid(pw->pw_gid)) != NULL) {	if ((grp = sudo_getgrgid(pw->pw_gid)) != NULL) {
sz += 12 + strlen(grp->gr_name);	sz += 12 + sudo_ldap_value_len(grp->gr_name);
}	}
	sz += 13 + MAX_UID_T_LEN;
if ((grlist = get_group_list(pw)) != NULL) {	if ((grlist = get_group_list(pw)) != NULL) {
for (i = 0; i < grlist->ngroups; i++) {	for (i = 0; i < grlist->ngroups; i++) {
if (grp != NULL && strcasecmp(grlist->groups[i], grp->gr_name) == 0)	if (grp != NULL && strcasecmp(grlist->groups[i], grp->gr_name) == 0)
continue;	continue;
sz += 12 + strlen(grlist->groups[i]);	sz += 12 + sudo_ldap_value_len(grlist->groups[i]);
}	}
	for (i = 0; i < grlist->ngids; i++) {
	if (pw->pw_gid == grlist->gids[i])
	continue;
	sz += 13 + MAX_UID_T_LEN;
	}
}	}

/* If timed, add space for time limits. */	/* If timed, add space for time limits. */
Line 1020 sudo_ldap_build_pass1(struct passwd *pw)	Line 1157 sudo_ldap_build_pass1(struct passwd *pw)

/* Global OR + sudoUser=user_name filter */	/* Global OR + sudoUser=user_name filter */
(void) strlcat(buf, "(\|(sudoUser=", sz);	(void) strlcat(buf, "(\|(sudoUser=", sz);
(void) strlcat(buf, pw->pw_name, sz);	(void) sudo_ldap_value_cat(buf, pw->pw_name, sz);
(void) strlcat(buf, ")", sz);	(void) strlcat(buf, ")", sz);

/* Append primary group */	/* Append primary group and gid */
if (grp != NULL) {	if (grp != NULL) {
(void) strlcat(buf, "(sudoUser=%", sz);	(void) strlcat(buf, "(sudoUser=%", sz);
(void) strlcat(buf, grp->gr_name, sz);	(void) sudo_ldap_value_cat(buf, grp->gr_name, sz);
(void) strlcat(buf, ")", sz);	(void) strlcat(buf, ")", sz);
}	}
	(void) snprintf(gidbuf, sizeof(gidbuf), "%u", (unsigned int)pw->pw_gid);
	(void) strlcat(buf, "(sudoUser=%#", sz);
	(void) strlcat(buf, gidbuf, sz);
	(void) strlcat(buf, ")", sz);

/* Append supplementary groups */	/* Append supplementary groups and gids */
if (grlist != NULL) {	if (grlist != NULL) {
for (i = 0; i < grlist->ngroups; i++) {	for (i = 0; i < grlist->ngroups; i++) {
if (grp != NULL && strcasecmp(grlist->groups[i], grp->gr_name) == 0)	if (grp != NULL && strcasecmp(grlist->groups[i], grp->gr_name) == 0)
continue;	continue;
(void) strlcat(buf, "(sudoUser=%", sz);	(void) strlcat(buf, "(sudoUser=%", sz);
(void) strlcat(buf, grlist->groups[i], sz);	(void) sudo_ldap_value_cat(buf, grlist->groups[i], sz);
(void) strlcat(buf, ")", sz);	(void) strlcat(buf, ")", sz);
}	}
	for (i = 0; i < grlist->ngids; i++) {
	if (pw->pw_gid == grlist->gids[i])
	continue;
	(void) snprintf(gidbuf, sizeof(gidbuf), "%u",
	(unsigned int)grlist->gids[i]);
	(void) strlcat(buf, "(sudoUser=%#", sz);
	(void) strlcat(buf, gidbuf, sz);
	(void) strlcat(buf, ")", sz);
	}
}	}

/* Done with groups. */	/* Done with groups. */
Line 1061 sudo_ldap_build_pass1(struct passwd *pw)	Line 1211 sudo_ldap_build_pass1(struct passwd *pw)
}	}
strlcat(buf, ")", sz); /* closes the global OR or the global AND */	strlcat(buf, ")", sz); /* closes the global OR or the global AND */

return buf;	debug_return_str(buf);
}	}

/*	/*
Line 1071 static char *	Line 1221 static char *
sudo_ldap_build_pass2(void)	sudo_ldap_build_pass2(void)
{	{
char *filt, timebuffer[TIMEFILTER_LENGTH];	char *filt, timebuffer[TIMEFILTER_LENGTH];
	debug_decl(sudo_ldap_build_pass2, SUDO_DEBUG_LDAP)

if (ldap_conf.timed)	if (ldap_conf.timed)
sudo_ldap_timefilter(timebuffer, sizeof(timebuffer));	sudo_ldap_timefilter(timebuffer, sizeof(timebuffer));
Line 1086 sudo_ldap_build_pass2(void)	Line 1237 sudo_ldap_build_pass2(void)
ldap_conf.timed ? timebuffer : "",	ldap_conf.timed ? timebuffer : "",
(ldap_conf.timed \|\| ldap_conf.search_filter) ? ")" : "");	(ldap_conf.timed \|\| ldap_conf.search_filter) ? ")" : "");

return filt;	debug_return_str(filt);
}	}

static void	static void
Line 1094 sudo_ldap_read_secret(const char *path)	Line 1245 sudo_ldap_read_secret(const char *path)
{	{
FILE *fp;	FILE *fp;
char buf[LINE_MAX], *cp;	char buf[LINE_MAX], *cp;
	debug_decl(sudo_ldap_read_secret, SUDO_DEBUG_LDAP)

if ((fp = fopen(_PATH_LDAP_SECRET, "r")) != NULL) {	if ((fp = fopen(_PATH_LDAP_SECRET, "r")) != NULL) {
if (fgets(buf, sizeof(buf), fp) != NULL) {	if (fgets(buf, sizeof(buf), fp) != NULL) {
Line 1108 sudo_ldap_read_secret(const char *path)	Line 1260 sudo_ldap_read_secret(const char *path)
}	}
fclose(fp);	fclose(fp);
}	}
	debug_return;
}	}

static int	/*
	* Look up keyword in config tables.
	* Returns true if found, else false.
	*/
	static bool
	sudo_ldap_parse_keyword(const char keyword, const char value,
	struct ldap_config_table *table)
	{
	struct ldap_config_table *cur;
	debug_decl(sudo_ldap_parse_keyword, SUDO_DEBUG_LDAP)

	/* Look up keyword in config tables */
	for (cur = table; cur->conf_str != NULL; cur++) {
	if (strcasecmp(keyword, cur->conf_str) == 0) {
	switch (cur->type) {
	case CONF_DEREF_VAL:
	if (strcasecmp(value, "searching") == 0)
	(int )(cur->valp) = LDAP_DEREF_SEARCHING;
	else if (strcasecmp(value, "finding") == 0)
	(int )(cur->valp) = LDAP_DEREF_FINDING;
	else if (strcasecmp(value, "always") == 0)
	(int )(cur->valp) = LDAP_DEREF_ALWAYS;
	else
	(int )(cur->valp) = LDAP_DEREF_NEVER;
	break;
	case CONF_BOOL:
	(int )(cur->valp) = atobool(value) == true;
	break;
	case CONF_INT:
	(int )(cur->valp) = atoi(value);
	break;
	case CONF_STR:
	efree((char *)(cur->valp));
	(char *)(cur->valp) = estrdup(value);
	break;
	case CONF_LIST_STR:
	{
	struct ldap_config_list_str **p;
	size_t len = strlen(value);

	if (len > 0) {
	p = (struct ldap_config_list_str **)cur->valp;
	while (*p != NULL)
	p = &(*p)->next;
	*p = emalloc(sizeof(struct ldap_config_list_str) + len);
	memcpy((*p)->val, value, len + 1);
	(*p)->next = NULL;
	}
	}
	break;
	}
	debug_return_bool(true);
	}
	}
	debug_return_bool(false);
	}

	static bool
sudo_ldap_read_config(void)	sudo_ldap_read_config(void)
{	{
FILE *fp;	FILE *fp;
char cp, keyword, *value;	char cp, keyword, *value;
struct ldap_config_table *cur;	debug_decl(sudo_ldap_read_config, SUDO_DEBUG_LDAP)

/* defaults */	/* defaults */
ldap_conf.version = 3;	ldap_conf.version = 3;
Line 1129 sudo_ldap_read_config(void)	Line 1339 sudo_ldap_read_config(void)
ldap_conf.deref = -1;	ldap_conf.deref = -1;

if ((fp = fopen(_PATH_LDAP_CONF, "r")) == NULL)	if ((fp = fopen(_PATH_LDAP_CONF, "r")) == NULL)
return FALSE;	debug_return_bool(false);

while ((cp = sudo_parseln(fp)) != NULL) {	while ((cp = sudo_parseln(fp)) != NULL) {
if (*cp == '\0')	if (*cp == '\0')
Line 1147 sudo_ldap_read_config(void)	Line 1357 sudo_ldap_read_config(void)
cp++;	cp++;
value = cp;	value = cp;

/* Look up keyword in config table. */	/* Look up keyword in config tables */
for (cur = ldap_conf_table; cur->conf_str != NULL; cur++) {	if (!sudo_ldap_parse_keyword(keyword, value, ldap_conf_global))
if (strcasecmp(keyword, cur->conf_str) == 0) {	sudo_ldap_parse_keyword(keyword, value, ldap_conf_conn);
switch (cur->type) {
case CONF_DEREF_VAL:
if (strcasecmp(value, "searching") == 0)
(int )(cur->valp) = LDAP_DEREF_SEARCHING;
else if (strcasecmp(value, "finding") == 0)
(int )(cur->valp) = LDAP_DEREF_FINDING;
else if (strcasecmp(value, "always") == 0)
(int )(cur->valp) = LDAP_DEREF_ALWAYS;
else
(int )(cur->valp) = LDAP_DEREF_NEVER;
break;
case CONF_BOOL:
(int )(cur->valp) = atobool(value) == TRUE;
break;
case CONF_INT:
(int )(cur->valp) = atoi(value);
break;
case CONF_STR:
efree((char *)(cur->valp));
(char *)(cur->valp) = estrdup(value);
break;
case CONF_LIST_STR:
{
struct ldap_config_list_str **p;
size_t len = strlen(value);

if (len > 0) {
p = (struct ldap_config_list_str **)cur->valp;
while (*p != NULL)
p = &(*p)->next;
*p = emalloc(sizeof(struct ldap_config_list_str) + len);
memcpy((*p)->val, value, len + 1);
(*p)->next = NULL;
}
}
break;
}
break;
}
}
}	}
fclose(fp);	fclose(fp);

Line 1294 sudo_ldap_read_config(void)	Line 1464 sudo_ldap_read_config(void)
sudo_printf(SUDO_CONV_ERROR_MSG, "===================\n");	sudo_printf(SUDO_CONV_ERROR_MSG, "===================\n");
}	}
if (!ldap_conf.base)	if (!ldap_conf.base)
return FALSE; /* if no base is defined, ignore LDAP */	debug_return_bool(false); /* if no base is defined, ignore LDAP */

if (ldap_conf.bind_timelimit > 0)	if (ldap_conf.bind_timelimit > 0)
ldap_conf.bind_timelimit = 1000; / convert to ms */	ldap_conf.bind_timelimit = 1000; / convert to ms */
Line 1305 sudo_ldap_read_config(void)	Line 1475 sudo_ldap_read_config(void)
if (ldap_conf.ssl != NULL) {	if (ldap_conf.ssl != NULL) {
if (strcasecmp(ldap_conf.ssl, "start_tls") == 0)	if (strcasecmp(ldap_conf.ssl, "start_tls") == 0)
ldap_conf.ssl_mode = SUDO_LDAP_STARTTLS;	ldap_conf.ssl_mode = SUDO_LDAP_STARTTLS;
else if (atobool(ldap_conf.ssl) == TRUE)	else if (atobool(ldap_conf.ssl) == true)
ldap_conf.ssl_mode = SUDO_LDAP_SSL;	ldap_conf.ssl_mode = SUDO_LDAP_SSL;
}	}

Line 1321 sudo_ldap_read_config(void)	Line 1491 sudo_ldap_read_config(void)
if (ldap_conf.uri) {	if (ldap_conf.uri) {
struct ldap_config_list_str *uri = ldap_conf.uri;	struct ldap_config_list_str *uri = ldap_conf.uri;
if (sudo_ldap_parse_uri(uri) != 0)	if (sudo_ldap_parse_uri(uri) != 0)
return FALSE;	debug_return_bool(false);
do {	do {
ldap_conf.uri = uri->next;	ldap_conf.uri = uri->next;
efree(uri);	efree(uri);
Line 1383 sudo_ldap_read_config(void)	Line 1553 sudo_ldap_read_config(void)
}	}
}	}
#endif	#endif
return TRUE;	debug_return_bool(true);
}	}

/*	/*
Line 1395 sudo_ldap_get_first_rdn(LDAP ld, LDAPMessage entry)	Line 1565 sudo_ldap_get_first_rdn(LDAP ld, LDAPMessage entry)
#ifdef HAVE_LDAP_STR2DN	#ifdef HAVE_LDAP_STR2DN
char dn, rdn = NULL;	char dn, rdn = NULL;
LDAPDN tmpDN;	LDAPDN tmpDN;
	debug_decl(sudo_ldap_get_first_rdn, SUDO_DEBUG_LDAP)

if ((dn = ldap_get_dn(ld, entry)) == NULL)	if ((dn = ldap_get_dn(ld, entry)) == NULL)
return NULL;	debug_return_str(NULL);
if (ldap_str2dn(dn, &tmpDN, LDAP_DN_FORMAT_LDAP) == LDAP_SUCCESS) {	if (ldap_str2dn(dn, &tmpDN, LDAP_DN_FORMAT_LDAP) == LDAP_SUCCESS) {
ldap_rdn2str(tmpDN[0], &rdn, LDAP_DN_FORMAT_UFN);	ldap_rdn2str(tmpDN[0], &rdn, LDAP_DN_FORMAT_UFN);
ldap_dnfree(tmpDN);	ldap_dnfree(tmpDN);
}	}
ldap_memfree(dn);	ldap_memfree(dn);
return rdn;	debug_return_str(rdn);
#else	#else
char dn, *edn;	char dn, *edn;
	debug_decl(sudo_ldap_get_first_rdn, SUDO_DEBUG_LDAP)

if ((dn = ldap_get_dn(ld, entry)) == NULL)	if ((dn = ldap_get_dn(ld, entry)) == NULL)
return NULL;	return NULL;
edn = ldap_explode_dn(dn, 1);	edn = ldap_explode_dn(dn, 1);
ldap_memfree(dn);	ldap_memfree(dn);
return edn ? edn[0] : NULL;	debug_return_str(edn ? edn[0] : NULL);
#endif	#endif
}	}

Line 1430 sudo_ldap_display_defaults(struct sudo_nss *nss, struc	Line 1602 sudo_ldap_display_defaults(struct sudo_nss *nss, struc
LDAPMessage entry, result;	LDAPMessage entry, result;
char prefix, filt;	char prefix, filt;
int rc, count = 0;	int rc, count = 0;
	debug_decl(sudo_ldap_display_defaults, SUDO_DEBUG_LDAP)

if (handle == NULL \|\| handle->ld == NULL)	if (handle == NULL \|\| handle->ld == NULL)
goto done;	goto done;
Line 1465 sudo_ldap_display_defaults(struct sudo_nss *nss, struc	Line 1638 sudo_ldap_display_defaults(struct sudo_nss *nss, struc
}	}
efree(filt);	efree(filt);
done:	done:
return count;	debug_return_int(count);
}	}

/*	/*
Line 1475 static int	Line 1648 static int
sudo_ldap_display_bound_defaults(struct sudo_nss nss, struct passwd pw,	sudo_ldap_display_bound_defaults(struct sudo_nss nss, struct passwd pw,
struct lbuf *lbuf)	struct lbuf *lbuf)
{	{
return 0;	debug_decl(sudo_ldap_display_bound_defaults, SUDO_DEBUG_LDAP)
	debug_return_int(0);
}	}

/*	/*
Line 1486 sudo_ldap_display_entry_short(LDAP ld, LDAPMessage e	Line 1660 sudo_ldap_display_entry_short(LDAP ld, LDAPMessage e
{	{
struct berval bv, p;	struct berval bv, p;
int count = 0;	int count = 0;
	debug_decl(sudo_ldap_display_entry_short, SUDO_DEBUG_LDAP)

lbuf_append(lbuf, " (");	lbuf_append(lbuf, " (");

Line 1543 sudo_ldap_display_entry_short(LDAP ld, LDAPMessage e	Line 1718 sudo_ldap_display_entry_short(LDAP ld, LDAPMessage e
}	}
lbuf_append(lbuf, "\n");	lbuf_append(lbuf, "\n");

return count;	debug_return_int(count);
}	}

/*	/*
Line 1555 sudo_ldap_display_entry_long(LDAP ld, LDAPMessage en	Line 1730 sudo_ldap_display_entry_long(LDAP ld, LDAPMessage en
struct berval bv, p;	struct berval bv, p;
char *rdn;	char *rdn;
int count = 0;	int count = 0;
	debug_decl(sudo_ldap_display_entry_long, SUDO_DEBUG_LDAP)

/* extract the dn, only show the first rdn */	/* extract the dn, only show the first rdn */
rdn = sudo_ldap_get_first_rdn(ld, entry);	rdn = sudo_ldap_get_first_rdn(ld, entry);
Line 1624 sudo_ldap_display_entry_long(LDAP ld, LDAPMessage en	Line 1800 sudo_ldap_display_entry_long(LDAP ld, LDAPMessage en
ldap_value_free_len(bv);	ldap_value_free_len(bv);
}	}

return count;	debug_return_int(count);
}	}

/*	/*
Line 1639 sudo_ldap_display_privs(struct sudo_nss *nss, struct p	Line 1815 sudo_ldap_display_privs(struct sudo_nss *nss, struct p
struct ldap_result *lres;	struct ldap_result *lres;
LDAPMessage *entry;	LDAPMessage *entry;
int i, count = 0;	int i, count = 0;
	debug_decl(sudo_ldap_display_privs, SUDO_DEBUG_LDAP)

if (handle == NULL \|\| handle->ld == NULL)	if (handle == NULL \|\| handle->ld == NULL)
goto done;	goto done;
Line 1657 sudo_ldap_display_privs(struct sudo_nss *nss, struct p	Line 1834 sudo_ldap_display_privs(struct sudo_nss *nss, struct p
}	}

done:	done:
return count;	debug_return_int(count);
}	}

static int	static int
Line 1667 sudo_ldap_display_cmnd(struct sudo_nss *nss, struct pa	Line 1844 sudo_ldap_display_cmnd(struct sudo_nss *nss, struct pa
LDAP *ld;	LDAP *ld;
struct ldap_result *lres;	struct ldap_result *lres;
LDAPMessage *entry;	LDAPMessage *entry;
int i, found = FALSE;	bool found = false;
	int i;
	debug_decl(sudo_ldap_display_cmnd, SUDO_DEBUG_LDAP)

if (handle == NULL \|\| handle->ld == NULL)	if (handle == NULL \|\| handle->ld == NULL)
goto done;	goto done;
Line 1683 sudo_ldap_display_cmnd(struct sudo_nss *nss, struct pa	Line 1862 sudo_ldap_display_cmnd(struct sudo_nss *nss, struct pa
entry = lres->entries[i].entry;	entry = lres->entries[i].entry;
if (sudo_ldap_check_command(ld, entry, NULL) &&	if (sudo_ldap_check_command(ld, entry, NULL) &&
sudo_ldap_check_runas(ld, entry)) {	sudo_ldap_check_runas(ld, entry)) {
found = TRUE;	found = true;
goto done;	goto done;
}	}
}	}
Line 1692 done:	Line 1871 done:
if (found)	if (found)
printf("%s%s%s\n", safe_cmnd ? safe_cmnd : user_cmnd,	printf("%s%s%s\n", safe_cmnd ? safe_cmnd : user_cmnd,
user_args ? " " : "", user_args ? user_args : "");	user_args ? " " : "", user_args ? user_args : "");
return !found;	debug_return_bool(!found);
}	}

#ifdef HAVE_LDAP_SASL_INTERACTIVE_BIND_S	#ifdef HAVE_LDAP_SASL_INTERACTIVE_BIND_S
Line 1702 sudo_ldap_sasl_interact(LDAP *ld, unsigned int flags,	Line 1881 sudo_ldap_sasl_interact(LDAP *ld, unsigned int flags,
{	{
char auth_id = (char )_auth_id;	char auth_id = (char )_auth_id;
sasl_interact_t interact = (sasl_interact_t )_interact;	sasl_interact_t interact = (sasl_interact_t )_interact;
	debug_decl(sudo_ldap_sasl_interact, SUDO_DEBUG_LDAP)

for (; interact->id != SASL_CB_LIST_END; interact++) {	for (; interact->id != SASL_CB_LIST_END; interact++) {
if (interact->id != SASL_CB_USER)	if (interact->id != SASL_CB_USER)
return LDAP_PARAM_ERROR;	debug_return_int(LDAP_PARAM_ERROR);

if (auth_id != NULL)	if (auth_id != NULL)
interact->result = auth_id;	interact->result = auth_id;
Line 1719 sudo_ldap_sasl_interact(LDAP *ld, unsigned int flags,	Line 1899 sudo_ldap_sasl_interact(LDAP *ld, unsigned int flags,
interact->result = estrdup(interact->result);	interact->result = estrdup(interact->result);
#endif /* SASL_VERSION_MAJOR < 2 */	#endif /* SASL_VERSION_MAJOR < 2 */
}	}
return LDAP_SUCCESS;	debug_return_int(LDAP_SUCCESS);
}	}
#endif /* HAVE_LDAP_SASL_INTERACTIVE_BIND_S */	#endif /* HAVE_LDAP_SASL_INTERACTIVE_BIND_S */


/*	/*
* Set LDAP options based on the config table.	* Set LDAP options from the specified options table
*/	*/
static int	static int
sudo_ldap_set_options(LDAP *ld)	sudo_ldap_set_options_table(LDAP ld, struct ldap_config_table table)
{	{
struct ldap_config_table *cur;	struct ldap_config_table *cur;
int rc;	int ival, rc;
	char *sval;
	debug_decl(sudo_ldap_set_options_table, SUDO_DEBUG_LDAP)

/* Set ber options */	for (cur = table; cur->conf_str != NULL; cur++) {
#ifdef LBER_OPT_DEBUG_LEVEL
if (ldap_conf.ldap_debug)
ber_set_option(NULL, LBER_OPT_DEBUG_LEVEL, &ldap_conf.ldap_debug);
#endif

/* Set simple LDAP options */
for (cur = ldap_conf_table; cur->conf_str != NULL; cur++) {
LDAP *conn;
int ival;
char *sval;

if (cur->opt_val == -1)	if (cur->opt_val == -1)
continue;	continue;

conn = cur->connected ? ld : NULL;
switch (cur->type) {	switch (cur->type) {
case CONF_BOOL:	case CONF_BOOL:
case CONF_INT:	case CONF_INT:
ival = (int )(cur->valp);	ival = (int )(cur->valp);
if (ival >= 0) {	if (ival >= 0) {
rc = ldap_set_option(conn, cur->opt_val, &ival);	rc = ldap_set_option(ld, cur->opt_val, &ival);
if (rc != LDAP_OPT_SUCCESS) {	if (rc != LDAP_OPT_SUCCESS) {
warningx("ldap_set_option: %s -> %d: %s",	warningx("ldap_set_option: %s -> %d: %s",
cur->conf_str, ival, ldap_err2string(rc));	cur->conf_str, ival, ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_set_option: %s -> %d", cur->conf_str, ival), 1);	DPRINTF(("ldap_set_option: %s -> %d", cur->conf_str, ival), 1);
}	}
Line 1765 sudo_ldap_set_options(LDAP *ld)	Line 1936 sudo_ldap_set_options(LDAP *ld)
case CONF_STR:	case CONF_STR:
sval = (char *)(cur->valp);	sval = (char *)(cur->valp);
if (sval != NULL) {	if (sval != NULL) {
rc = ldap_set_option(conn, cur->opt_val, sval);	rc = ldap_set_option(ld, cur->opt_val, sval);
if (rc != LDAP_OPT_SUCCESS) {	if (rc != LDAP_OPT_SUCCESS) {
warningx("ldap_set_option: %s -> %s: %s",	warningx("ldap_set_option: %s -> %s: %s",
cur->conf_str, sval, ldap_err2string(rc));	cur->conf_str, sval, ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_set_option: %s -> %s", cur->conf_str, sval), 1);	DPRINTF(("ldap_set_option: %s -> %s", cur->conf_str, sval), 1);
}	}
break;	break;
}	}
}	}
	debug_return_int(0);
	}

	/*
	* Set LDAP options based on the global config table.
	*/
	static int
	sudo_ldap_set_options_global(void)
	{
	int rc;
	debug_decl(sudo_ldap_set_options_global, SUDO_DEBUG_LDAP)

	/* Set ber options */
	#ifdef LBER_OPT_DEBUG_LEVEL
	if (ldap_conf.ldap_debug)
	ber_set_option(NULL, LBER_OPT_DEBUG_LEVEL, &ldap_conf.ldap_debug);
	#endif

	/* Parse global LDAP options table. */
	rc = sudo_ldap_set_options_table(NULL, ldap_conf_global);
	if (rc == -1)
	debug_return_int(-1);
	debug_return_int(0);
	}

	/*
	* Set LDAP options based on the per-connection config table.
	*/
	static int
	sudo_ldap_set_options_conn(LDAP *ld)
	{
	int rc;
	debug_decl(sudo_ldap_set_options_conn, SUDO_DEBUG_LDAP)

	/* Parse per-connection LDAP options table. */
	rc = sudo_ldap_set_options_table(ld, ldap_conf_conn);
	if (rc == -1)
	debug_return_int(-1);

#ifdef LDAP_OPT_TIMEOUT	#ifdef LDAP_OPT_TIMEOUT
/* Convert timeout to a timeval */	/* Convert timeout to a timeval */
if (ldap_conf.timeout > 0) {	if (ldap_conf.timeout > 0) {
Line 1787 sudo_ldap_set_options(LDAP *ld)	Line 1996 sudo_ldap_set_options(LDAP *ld)
if (rc != LDAP_OPT_SUCCESS) {	if (rc != LDAP_OPT_SUCCESS) {
warningx("ldap_set_option(TIMEOUT, %ld): %s",	warningx("ldap_set_option(TIMEOUT, %ld): %s",
(long)tv.tv_sec, ldap_err2string(rc));	(long)tv.tv_sec, ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_set_option(LDAP_OPT_TIMEOUT, %ld)",	DPRINTF(("ldap_set_option(LDAP_OPT_TIMEOUT, %ld)",
(long)tv.tv_sec), 1);	(long)tv.tv_sec), 1);
Line 1803 sudo_ldap_set_options(LDAP *ld)	Line 2012 sudo_ldap_set_options(LDAP *ld)
if (rc != LDAP_OPT_SUCCESS) {	if (rc != LDAP_OPT_SUCCESS) {
warningx("ldap_set_option(NETWORK_TIMEOUT, %ld): %s",	warningx("ldap_set_option(NETWORK_TIMEOUT, %ld): %s",
(long)tv.tv_sec, ldap_err2string(rc));	(long)tv.tv_sec, ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_set_option(LDAP_OPT_NETWORK_TIMEOUT, %ld)",	DPRINTF(("ldap_set_option(LDAP_OPT_NETWORK_TIMEOUT, %ld)",
(long)tv.tv_sec), 1);	(long)tv.tv_sec), 1);
Line 1817 sudo_ldap_set_options(LDAP *ld)	Line 2026 sudo_ldap_set_options(LDAP *ld)
if (rc != LDAP_SUCCESS) {	if (rc != LDAP_SUCCESS) {
warningx("ldap_set_option(LDAP_OPT_X_TLS, LDAP_OPT_X_TLS_HARD): %s",	warningx("ldap_set_option(LDAP_OPT_X_TLS, LDAP_OPT_X_TLS_HARD): %s",
ldap_err2string(rc));	ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_set_option(LDAP_OPT_X_TLS, LDAP_OPT_X_TLS_HARD)"), 1);	DPRINTF(("ldap_set_option(LDAP_OPT_X_TLS, LDAP_OPT_X_TLS_HARD)"), 1);
}	}
#endif	#endif
return 0;	debug_return_int(0);
}	}

/*	/*
Line 1832 static struct ldap_result *	Line 2041 static struct ldap_result *
sudo_ldap_result_alloc(void)	sudo_ldap_result_alloc(void)
{	{
struct ldap_result *result;	struct ldap_result *result;
	debug_decl(sudo_ldap_result_alloc, SUDO_DEBUG_LDAP)

result = emalloc(sizeof(*result));	debug_return_ptr(ecalloc(1, sizeof(*result)));
result->searches = NULL;
result->nentries = 0;
result->entries = NULL;
result->allocated_entries = 0;
result->user_matches = FALSE;
result->host_matches = FALSE;
return result;
}	}

/*	/*
Line 1850 static void	Line 2053 static void
sudo_ldap_result_free(struct ldap_result *lres)	sudo_ldap_result_free(struct ldap_result *lres)
{	{
struct ldap_search_list *s;	struct ldap_search_list *s;
	debug_decl(sudo_ldap_result_free, SUDO_DEBUG_LDAP)

if (lres != NULL) {	if (lres != NULL) {
if (lres->nentries) {	if (lres->nentries) {
Line 1865 sudo_ldap_result_free(struct ldap_result *lres)	Line 2069 sudo_ldap_result_free(struct ldap_result *lres)
}	}
efree(lres);	efree(lres);
}	}
	debug_return;
}	}

/*	/*
Line 1875 sudo_ldap_result_add_search(struct ldap_result *lres,	Line 2080 sudo_ldap_result_add_search(struct ldap_result *lres,
LDAPMessage *searchresult)	LDAPMessage *searchresult)
{	{
struct ldap_search_list s, news;	struct ldap_search_list s, news;
	debug_decl(sudo_ldap_result_add_search, SUDO_DEBUG_LDAP)

news = emalloc(sizeof(struct ldap_search_list));	news = ecalloc(1, sizeof(struct ldap_search_list));
news->next = NULL;
news->ldap = ldap;	news->ldap = ldap;
news->searchresult = searchresult;	news->searchresult = searchresult;
	/* news->next = NULL; */

/* Add entry to the end of the chain (XXX - tailq instead?). */	/* Add entry to the end of the chain (XXX - tailq instead?). */
if (lres->searches) {	if (lres->searches) {
Line 1889 sudo_ldap_result_add_search(struct ldap_result *lres,	Line 2095 sudo_ldap_result_add_search(struct ldap_result *lres,
} else {	} else {
lres->searches = news;	lres->searches = news;
}	}
return news;	debug_return_ptr(news);
}	}

/*	/*
Line 1905 sudo_ldap_bind_s(LDAP *ld)	Line 2111 sudo_ldap_bind_s(LDAP *ld)
unsigned int status;	unsigned int status;
# endif	# endif
#endif	#endif
	debug_decl(sudo_ldap_bind_s, SUDO_DEBUG_LDAP)

#ifdef HAVE_LDAP_SASL_INTERACTIVE_BIND_S	#ifdef HAVE_LDAP_SASL_INTERACTIVE_BIND_S
if (ldap_conf.rootuse_sasl == TRUE \|\|	if (ldap_conf.rootuse_sasl == true \|\|
(ldap_conf.rootuse_sasl != FALSE && ldap_conf.use_sasl == TRUE)) {	(ldap_conf.rootuse_sasl != false && ldap_conf.use_sasl == true)) {
void *auth_id = ldap_conf.rootsasl_auth_id ?	void *auth_id = ldap_conf.rootsasl_auth_id ?
ldap_conf.rootsasl_auth_id : ldap_conf.sasl_auth_id;	ldap_conf.rootsasl_auth_id : ldap_conf.sasl_auth_id;

Line 1920 sudo_ldap_bind_s(LDAP *ld)	Line 2127 sudo_ldap_bind_s(LDAP *ld)
DPRINTF(("gss_krb5_ccache_name() failed: %d", status), 1);	DPRINTF(("gss_krb5_ccache_name() failed: %d", status), 1);
}	}
# else	# else
setenv("KRB5CCNAME", ldap_conf.krb5_ccname, TRUE);	sudo_setenv("KRB5CCNAME", ldap_conf.krb5_ccname, true);
# endif	# endif
}	}
rc = ldap_sasl_interactive_bind_s(ld, ldap_conf.binddn, "GSSAPI",	rc = ldap_sasl_interactive_bind_s(ld, ldap_conf.binddn, "GSSAPI",
Line 1931 sudo_ldap_bind_s(LDAP *ld)	Line 2138 sudo_ldap_bind_s(LDAP *ld)
DPRINTF(("gss_krb5_ccache_name() failed: %d", status), 1);	DPRINTF(("gss_krb5_ccache_name() failed: %d", status), 1);
# else	# else
if (old_ccname != NULL)	if (old_ccname != NULL)
setenv("KRB5CCNAME", old_ccname, TRUE);	sudo_setenv("KRB5CCNAME", old_ccname, true);
else	else
unsetenv("KRB5CCNAME");	sudo_unsetenv("KRB5CCNAME");
# endif	# endif
}	}
if (rc != LDAP_SUCCESS) {	if (rc != LDAP_SUCCESS) {
warningx("ldap_sasl_interactive_bind_s(): %s",	warningx("ldap_sasl_interactive_bind_s(): %s",
ldap_err2string(rc));	ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_sasl_interactive_bind_s() ok"), 1);	DPRINTF(("ldap_sasl_interactive_bind_s() ok"), 1);
} else	} else
Line 1955 sudo_ldap_bind_s(LDAP *ld)	Line 2162 sudo_ldap_bind_s(LDAP *ld)
NULL, NULL, NULL);	NULL, NULL, NULL);
if (rc != LDAP_SUCCESS) {	if (rc != LDAP_SUCCESS) {
warningx("ldap_sasl_bind_s(): %s", ldap_err2string(rc));	warningx("ldap_sasl_bind_s(): %s", ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_sasl_bind_s() ok"), 1);	DPRINTF(("ldap_sasl_bind_s() ok"), 1);
}	}
Line 1964 sudo_ldap_bind_s(LDAP *ld)	Line 2171 sudo_ldap_bind_s(LDAP *ld)
rc = ldap_simple_bind_s(ld, ldap_conf.binddn, ldap_conf.bindpw);	rc = ldap_simple_bind_s(ld, ldap_conf.binddn, ldap_conf.bindpw);
if (rc != LDAP_SUCCESS) {	if (rc != LDAP_SUCCESS) {
warningx("ldap_simple_bind_s(): %s", ldap_err2string(rc));	warningx("ldap_simple_bind_s(): %s", ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_simple_bind_s() ok"), 1);	DPRINTF(("ldap_simple_bind_s() ok"), 1);
}	}
#endif	#endif
return 0;	debug_return_int(0);
}	}

/*	/*
Line 1980 static int	Line 2187 static int
sudo_ldap_open(struct sudo_nss *nss)	sudo_ldap_open(struct sudo_nss *nss)
{	{
LDAP *ld;	LDAP *ld;
int rc, ldapnoinit = FALSE;	int rc;
struct sudo_ldap_handle *handle;	bool ldapnoinit = false;
	struct sudo_ldap_handle *handle;
	debug_decl(sudo_ldap_open, SUDO_DEBUG_LDAP)

if (!sudo_ldap_read_config())	if (!sudo_ldap_read_config())
return -1;	debug_return_int(-1);

/* Prevent reading of user ldaprc and system defaults. */	/* Prevent reading of user ldaprc and system defaults. */
if (getenv("LDAPNOINIT") == NULL) {	if (sudo_getenv("LDAPNOINIT") == NULL) {
ldapnoinit = TRUE;	ldapnoinit = true;
setenv("LDAPNOINIT", "1", TRUE);	sudo_setenv("LDAPNOINIT", "1", true);
}	}

	/* Set global LDAP options */
	if (sudo_ldap_set_options_global() < 0)
	debug_return_int(-1);

/* Connect to LDAP server */	/* Connect to LDAP server */
#ifdef HAVE_LDAP_INITIALIZE	#ifdef HAVE_LDAP_INITIALIZE
if (ldap_conf.uri != NULL) {	if (ldap_conf.uri != NULL) {
Line 1999 sudo_ldap_open(struct sudo_nss *nss)	Line 2212 sudo_ldap_open(struct sudo_nss *nss)
DPRINTF(("ldap_initialize(ld, %s)", buf), 2);	DPRINTF(("ldap_initialize(ld, %s)", buf), 2);
rc = ldap_initialize(&ld, buf);	rc = ldap_initialize(&ld, buf);
efree(buf);	efree(buf);
	if (rc != LDAP_SUCCESS)
	warningx(_("unable to initialize LDAP: %s"), ldap_err2string(rc));
} else	} else
#endif	#endif
rc = sudo_ldap_init(&ld, ldap_conf.host, ldap_conf.port);	rc = sudo_ldap_init(&ld, ldap_conf.host, ldap_conf.port);
if (rc != LDAP_SUCCESS) {	if (rc != LDAP_SUCCESS)
warningx(_("unable to initialize LDAP: %s"), ldap_err2string(rc));	debug_return_int(-1);
return -1;
}

	/* Set LDAP per-connection options */
	if (sudo_ldap_set_options_conn(ld) < 0)
	debug_return_int(-1);

if (ldapnoinit)	if (ldapnoinit)
unsetenv("LDAPNOINIT");	sudo_unsetenv("LDAPNOINIT");

/* Set LDAP options */
if (sudo_ldap_set_options(ld) < 0)
return -1;

if (ldap_conf.ssl_mode == SUDO_LDAP_STARTTLS) {	if (ldap_conf.ssl_mode == SUDO_LDAP_STARTTLS) {
#if defined(HAVE_LDAP_START_TLS_S)	#if defined(HAVE_LDAP_START_TLS_S)
rc = ldap_start_tls_s(ld, NULL, NULL);	rc = ldap_start_tls_s(ld, NULL, NULL);
if (rc != LDAP_SUCCESS) {	if (rc != LDAP_SUCCESS) {
warningx("ldap_start_tls_s(): %s", ldap_err2string(rc));	warningx("ldap_start_tls_s(): %s", ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_start_tls_s() ok"), 1);	DPRINTF(("ldap_start_tls_s() ok"), 1);
#elif defined(HAVE_LDAP_SSL_CLIENT_INIT) && defined(HAVE_LDAP_START_TLS_S_NP)	#elif defined(HAVE_LDAP_SSL_CLIENT_INIT) && defined(HAVE_LDAP_START_TLS_S_NP)
if (ldap_ssl_client_init(NULL, NULL, 0, &rc) != LDAP_SUCCESS) {	if (ldap_ssl_client_init(NULL, NULL, 0, &rc) != LDAP_SUCCESS) {
warningx("ldap_ssl_client_init(): %s", ldap_err2string(rc));	warningx("ldap_ssl_client_init(): %s", ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
rc = ldap_start_tls_s_np(ld, NULL);	rc = ldap_start_tls_s_np(ld, NULL);
if (rc != LDAP_SUCCESS) {	if (rc != LDAP_SUCCESS) {
warningx("ldap_start_tls_s_np(): %s", ldap_err2string(rc));	warningx("ldap_start_tls_s_np(): %s", ldap_err2string(rc));
return -1;	debug_return_int(-1);
}	}
DPRINTF(("ldap_start_tls_s_np() ok"), 1);	DPRINTF(("ldap_start_tls_s_np() ok"), 1);
#else	#else
Line 2040 sudo_ldap_open(struct sudo_nss *nss)	Line 2253 sudo_ldap_open(struct sudo_nss *nss)

/* Actually connect */	/* Actually connect */
if (sudo_ldap_bind_s(ld) != 0)	if (sudo_ldap_bind_s(ld) != 0)
return -1;	debug_return_int(-1);

/* Create a handle container. */	/* Create a handle container. */
handle = emalloc(sizeof(struct sudo_ldap_handle));	handle = ecalloc(1, sizeof(struct sudo_ldap_handle));
handle->ld = ld;	handle->ld = ld;
handle->result = NULL;	/* handle->result = NULL; */
handle->username = NULL;	/* handle->username = NULL; */
handle->grlist = NULL;	/* handle->grlist = NULL; */
nss->handle = handle;	nss->handle = handle;

return 0;	debug_return_int(0);
}	}

static int	static int
Line 2063 sudo_ldap_setdefs(struct sudo_nss *nss)	Line 2276 sudo_ldap_setdefs(struct sudo_nss *nss)
LDAPMessage entry, result;	LDAPMessage entry, result;
char *filt;	char *filt;
int rc;	int rc;
	debug_decl(sudo_ldap_setdefs, SUDO_DEBUG_LDAP)

if (handle == NULL \|\| handle->ld == NULL)	if (handle == NULL \|\| handle->ld == NULL)
return -1;	debug_return_int(-1);
ld = handle->ld;	ld = handle->ld;

filt = sudo_ldap_build_default_filter();	filt = sudo_ldap_build_default_filter();
Line 2091 sudo_ldap_setdefs(struct sudo_nss *nss)	Line 2305 sudo_ldap_setdefs(struct sudo_nss *nss)
}	}
efree(filt);	efree(filt);

return 0;	debug_return_int(0);
}	}

/*	/*
Line 2105 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw	Line 2319 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw
LDAPMessage *entry;	LDAPMessage *entry;
int i, rc, setenv_implied;	int i, rc, setenv_implied;
struct ldap_result *lres = NULL;	struct ldap_result *lres = NULL;
	debug_decl(sudo_ldap_lookup, SUDO_DEBUG_LDAP)

if (handle == NULL \|\| handle->ld == NULL)	if (handle == NULL \|\| handle->ld == NULL)
return ret;	debug_return_int(ret);
ld = handle->ld;	ld = handle->ld;

/* Fetch list of sudoRole entries that match user and host. */	/* Fetch list of sudoRole entries that match user and host. */
Line 2126 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw	Line 2341 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw
DPRINTF(("perform search for pwflag %d", pwflag), 1);	DPRINTF(("perform search for pwflag %d", pwflag), 1);
for (i = 0; i < lres->nentries; i++) {	for (i = 0; i < lres->nentries; i++) {
entry = lres->entries[i].entry;	entry = lres->entries[i].entry;
if ((pwcheck == any && doauth != FALSE) \|\|	if ((pwcheck == any && doauth != false) \|\|
(pwcheck == all && doauth == FALSE)) {	(pwcheck == all && doauth == false)) {
doauth = sudo_ldap_check_bool(ld, entry, "authenticate");	doauth = sudo_ldap_check_bool(ld, entry, "authenticate");
}	}
/* Only check the command when listing another user. */	/* Only check the command when listing another user. */
if (user_uid == 0 \|\| list_pw == NULL \|\|	if (user_uid == 0 \|\| list_pw == NULL \|\|
user_uid == list_pw->pw_uid \|\|	user_uid == list_pw->pw_uid \|\|
sudo_ldap_check_command(ld, entry, NULL)) {	sudo_ldap_check_command(ld, entry, NULL)) {
matched = TRUE;	matched = true;
break;	break;
}	}
}	}
Line 2148 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw	Line 2363 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw
break;	break;
case all:	case all:
case any:	case any:
if (doauth == FALSE)	if (doauth == false)
def_authenticate = FALSE;	def_authenticate = false;
break;	break;
case never:	case never:
def_authenticate = FALSE;	def_authenticate = false;
break;	break;
default:	default:
break;	break;
Line 2164 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw	Line 2379 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw

DPRINTF(("searching LDAP for sudoers entries"), 1);	DPRINTF(("searching LDAP for sudoers entries"), 1);

setenv_implied = FALSE;	setenv_implied = false;
for (i = 0; i < lres->nentries; i++) {	for (i = 0; i < lres->nentries; i++) {
entry = lres->entries[i].entry;	entry = lres->entries[i].entry;
if (!sudo_ldap_check_runas(ld, entry))	if (!sudo_ldap_check_runas(ld, entry))
Line 2172 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw	Line 2387 sudo_ldap_lookup(struct sudo_nss *nss, int ret, int pw
rc = sudo_ldap_check_command(ld, entry, &setenv_implied);	rc = sudo_ldap_check_command(ld, entry, &setenv_implied);
if (rc != UNSPEC) {	if (rc != UNSPEC) {
/* We have a match. */	/* We have a match. */
DPRINTF(("Command %sallowed", rc == TRUE ? "" : "NOT "), 1);	DPRINTF(("Command %sallowed", rc == true ? "" : "NOT "), 1);
if (rc == TRUE) {	if (rc == true) {
DPRINTF(("LDAP entry: %p", entry), 1);	DPRINTF(("LDAP entry: %p", entry), 1);
/* Apply entry-specific options. */	/* Apply entry-specific options. */
if (setenv_implied)	if (setenv_implied)
def_setenv = TRUE;	def_setenv = true;
sudo_ldap_parse_options(ld, entry);	sudo_ldap_parse_options(ld, entry);
#ifdef HAVE_SELINUX	#ifdef HAVE_SELINUX
/* Set role and type if not specified on command line. */	/* Set role and type if not specified on command line. */
Line 2212 done:	Line 2427 done:
CLR(ret, FLAG_NO_HOST);	CLR(ret, FLAG_NO_HOST);
DPRINTF(("sudo_ldap_lookup(%d)=0x%02x", pwflag, ret), 1);	DPRINTF(("sudo_ldap_lookup(%d)=0x%02x", pwflag, ret), 1);

return ret;	debug_return_int(ret);
}	}

/*	/*
Line 2223 ldap_entry_compare(const void a, const void b)	Line 2438 ldap_entry_compare(const void a, const void b)
{	{
const struct ldap_entry_wrapper *aw = a;	const struct ldap_entry_wrapper *aw = a;
const struct ldap_entry_wrapper *bw = b;	const struct ldap_entry_wrapper *bw = b;
	debug_decl(ldap_entry_compare, SUDO_DEBUG_LDAP)

return bw->order < aw->order ? -1 :	debug_return_int(bw->order < aw->order ? -1 :
(bw->order > aw->order ? 1 : 0);	(bw->order > aw->order ? 1 : 0));
}	}

/*	/*
Line 2237 static struct ldap_search_list *	Line 2453 static struct ldap_search_list *
sudo_ldap_result_last_search(struct ldap_result *lres)	sudo_ldap_result_last_search(struct ldap_result *lres)
{	{
struct ldap_search_list *result = lres->searches;	struct ldap_search_list *result = lres->searches;
	debug_decl(sudo_ldap_result_last_search, SUDO_DEBUG_LDAP)

if (result) {	if (result) {
while (result->next)	while (result->next)
result = result->next;	result = result->next;
}	}
return result;	debug_return_ptr(result);
}	}

/*	/*
Line 2255 sudo_ldap_result_add_entry(struct ldap_result *lres, L	Line 2472 sudo_ldap_result_add_entry(struct ldap_result *lres, L
struct berval **bv;	struct berval **bv;
double order = 0.0;	double order = 0.0;
char *ep;	char *ep;
	debug_decl(sudo_ldap_result_add_entry, SUDO_DEBUG_LDAP)

/* Determine whether the entry has the sudoOrder attribute. */	/* Determine whether the entry has the sudoOrder attribute. */
last = sudo_ldap_result_last_search(lres);	last = sudo_ldap_result_last_search(lres);
Line 2287 sudo_ldap_result_add_entry(struct ldap_result *lres, L	Line 2505 sudo_ldap_result_add_entry(struct ldap_result *lres, L
lres->entries[lres->nentries - 1].entry = entry;	lres->entries[lres->nentries - 1].entry = entry;
lres->entries[lres->nentries - 1].order = order;	lres->entries[lres->nentries - 1].order = order;

return &lres->entries[lres->nentries - 1];	debug_return_ptr(&lres->entries[lres->nentries - 1]);
}	}

/*	/*
Line 2297 static void	Line 2515 static void
sudo_ldap_result_free_nss(struct sudo_nss *nss)	sudo_ldap_result_free_nss(struct sudo_nss *nss)
{	{
struct sudo_ldap_handle *handle = nss->handle;	struct sudo_ldap_handle *handle = nss->handle;
	debug_decl(sudo_ldap_result_free_nss, SUDO_DEBUG_LDAP)

if (handle->result != NULL) {	if (handle->result != NULL) {
DPRINTF(("removing reusable search result"), 1);	DPRINTF(("removing reusable search result"), 1);
Line 2308 sudo_ldap_result_free_nss(struct sudo_nss *nss)	Line 2527 sudo_ldap_result_free_nss(struct sudo_nss *nss)
handle->grlist = NULL;	handle->grlist = NULL;
handle->result = NULL;	handle->result = NULL;
}	}
	debug_return;
}	}

/*	/*
Line 2325 sudo_ldap_result_get(struct sudo_nss *nss, struct pass	Line 2545 sudo_ldap_result_get(struct sudo_nss *nss, struct pass
LDAP *ld = handle->ld;	LDAP *ld = handle->ld;
int do_netgr, rc;	int do_netgr, rc;
char *filt;	char *filt;
	debug_decl(sudo_ldap_result_get, SUDO_DEBUG_LDAP)

/*	/*
* If we already have a cached result, return it so we don't have to	* If we already have a cached result, return it so we don't have to
Line 2335 sudo_ldap_result_get(struct sudo_nss *nss, struct pass	Line 2556 sudo_ldap_result_get(struct sudo_nss *nss, struct pass
strcmp(pw->pw_name, handle->username) == 0) {	strcmp(pw->pw_name, handle->username) == 0) {
DPRINTF(("reusing previous result (user %s) with %d entries",	DPRINTF(("reusing previous result (user %s) with %d entries",
handle->username, handle->result->nentries), 1);	handle->username, handle->result->nentries), 1);
return handle->result;	debug_return_ptr(handle->result);
}	}
/* User mismatch, cached result cannot be used. */	/* User mismatch, cached result cannot be used. */
DPRINTF(("removing result (user %s), new search (user %s)",	DPRINTF(("removing result (user %s), new search (user %s)",
Line 2379 sudo_ldap_result_get(struct sudo_nss *nss, struct pass	Line 2600 sudo_ldap_result_get(struct sudo_nss *nss, struct pass
DPRINTF(("nothing found for '%s'", filt), 1);	DPRINTF(("nothing found for '%s'", filt), 1);
continue;	continue;
}	}
lres->user_matches = TRUE;	lres->user_matches = true;

/* Add the seach result to list of search results. */	/* Add the seach result to list of search results. */
DPRINTF(("adding search result"), 1);	DPRINTF(("adding search result"), 1);
Line 2388 sudo_ldap_result_get(struct sudo_nss *nss, struct pass	Line 2609 sudo_ldap_result_get(struct sudo_nss *nss, struct pass
if ((!do_netgr \|\|	if ((!do_netgr \|\|
sudo_ldap_check_user_netgroup(ld, entry, pw->pw_name)) &&	sudo_ldap_check_user_netgroup(ld, entry, pw->pw_name)) &&
sudo_ldap_check_host(ld, entry)) {	sudo_ldap_check_host(ld, entry)) {
lres->host_matches = TRUE;	lres->host_matches = true;
sudo_ldap_result_add_entry(lres, entry);	sudo_ldap_result_add_entry(lres, entry);
}	}
}	}
Line 2407 sudo_ldap_result_get(struct sudo_nss *nss, struct pass	Line 2628 sudo_ldap_result_get(struct sudo_nss *nss, struct pass
handle->username = estrdup(pw->pw_name);	handle->username = estrdup(pw->pw_name);
handle->grlist = user_group_list;	handle->grlist = user_group_list;

return lres;	debug_return_ptr(lres);
}	}

/*	/*
Line 2417 static int	Line 2638 static int
sudo_ldap_close(struct sudo_nss *nss)	sudo_ldap_close(struct sudo_nss *nss)
{	{
struct sudo_ldap_handle *handle = nss->handle;	struct sudo_ldap_handle *handle = nss->handle;
	debug_decl(sudo_ldap_close, SUDO_DEBUG_LDAP)

if (handle != NULL) {	if (handle != NULL) {
/* Free the result before unbinding; it may use the LDAP connection. */	/* Free the result before unbinding; it may use the LDAP connection. */
Line 2432 sudo_ldap_close(struct sudo_nss *nss)	Line 2654 sudo_ldap_close(struct sudo_nss *nss)
efree(nss->handle);	efree(nss->handle);
nss->handle = NULL;	nss->handle = NULL;
}	}
return 0;	debug_return_int(0);
}	}

/*	/*

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1.1.1
changed lines
	Added in v.1.1.1.2