path: root/src/format.c

#include <sys/types.h>
#include <rpcsvc/yp.h>
#include <fnmatch.h>
#include <regex.h>
#include <stdlib.h>
#include "defaults.h"
#include "format.h"
#include "plugin.h"

static int format_expand(struct plugin_state *state,
			 Slapi_PBlock *pb, Slapi_Entry *e,
			 const char *fmt,
			 char *outbuf, int outbuf_len,
			 char ***visited_ndns, PRBool literal);

void
format_free_data(char *data)
{
	if (data != NULL) {
		free(data);
	}
}

void
format_free_ndn_list(char **ndn_list)
{
	if (ndn_list != NULL) {
		free(ndn_list);
	}
}

/* Parse an argument list. */
static void
format_free_parsed_args(char **argv)
{
	free(argv);
}
static int
format_parse_args(struct plugin_state *state, const char *args,
		  int *pargc, char ***pargv)
{
	int i, dq, argc;
	char *out, **argv;
	*pargc = 0;
	*pargv = NULL;
	argv = malloc((sizeof(char *) + 1) * (strlen(args) + 1));
	if (argv == NULL) {
		return -1;
	}
	memset(argv, 0, (sizeof(char *) + 1) * (strlen(args) + 1));
	out = (char *) argv;
	out += sizeof(char *) * (strlen(args) + 1);
	argc = 0;
	i = 0;
	dq = 0;
	while (args[i] != '\0') {
		switch (args[i]) {
		case '"':
			dq = !dq;
			if (dq) {
				argv[argc++] = out;
			} else {
				*out++ = '\0';
			}
			i++;
			break;
		case '\\':
			i++;
			/* fall through */
		default:
			*out++ = args[i++];
			break;
		}
	}
	argv[argc] = NULL;
	*out = '\0';
	out = malloc(argc * 3 + strlen(args));
	if (out != NULL) {
		*out = '\0';
		for (i = 0; i < argc; i++) {
			if (i > 0) {
				strcat(out, ",");
			}
			strcat(out, "'");
			strcat(out, argv[i]);
			strcat(out, "'");
		}
		free(out);
	}
	*pargc = argc;
	*pargv = argv;
	return 0;
}

/* Echo the parameter text. */
static int
format_echo(struct plugin_state *state, Slapi_PBlock *pb, Slapi_Entry *e,
	    const char *args, char *outbuf, int outbuf_len,
	    char ***visited_ndns)
{
	int ret, i, argc, len;
	char **argv;
	ret = format_parse_args(state, args, &argc, &argv);
	if (ret != 0) {
		slapi_log_error(SLAPI_LOG_PLUGIN, state->plugin_desc->spd_id,
				"echo: error parsing arguments\n");
		return -1;
	}
	for (i = 0, ret = 0; i < argc; i++) {
		/* Get the length of this argument. */
		len = strlen(argv[i]);
		/* Check that we've got space for this argument. */
		if (ret + len > outbuf_len) {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"echo: out of space\n");
			return -1;
		}
		/* Append the text of the argument. */
		memcpy(outbuf + ret, argv[i], len);
		ret += len;
	}
	format_free_parsed_args(argv);
	return ret;
}

/* Create a list of the values of the attributes which are passed as arguments,
 * joined by a separator given as the first argument. */
static int
format_list(struct plugin_state *state, Slapi_PBlock *pb, Slapi_Entry *e,
	    const char *args, char *outbuf, int outbuf_len,
	    char ***visited_ndns)
{
	int ret, i, j, len, slen, count, argc;
	Slapi_ValueSet *values;
	Slapi_Value *value;
	char **argv, *actual_attr;
	const char *cvalue;
	int disposition, buffer_flags;
	ret = format_parse_args(state, args, &argc, &argv);
	if (ret != 0) {
		slapi_log_error(SLAPI_LOG_PLUGIN, state->plugin_desc->spd_id,
				"list: error parsing arguments\n");
		return -1;
	}
	for (i = 1, ret = 0, count = 0; i < argc; i++) {
		/* Get the list of values for this attribute. */
		if (slapi_vattr_values_get(e, argv[i], &values, &disposition,
					   &actual_attr, 0,
					   &buffer_flags) != 0) {
			continue;
		}
		for (j = slapi_valueset_first_value(values, &value);
		     j != -1;
		     j = slapi_valueset_next_value(values, j, &value)) {
			/* Get the length of the value. */
			cvalue = slapi_value_get_string(value);
			len = strlen(cvalue);
			/* Check if we have space for the value. */
			if (ret + len > outbuf_len) {
				slapi_log_error(SLAPI_LOG_PLUGIN,
						state->plugin_desc->spd_id,
						"list: out of space\n");
				slapi_vattr_values_free(&values, &actual_attr,
							buffer_flags);
				format_free_parsed_args(argv);
				return -1;
			}
			/* If the value is empty, skip it. */
			if (len == 0) {
				continue;
			}
			/* If we've already added values, add the separator. */
			if (count > 0) {
				/* Get the length of the separator. */
				slen = strlen(argv[0]);
				/* Check if we have space for the separator. */
				if (ret + len + slen > outbuf_len) {
					slapi_log_error(SLAPI_LOG_PLUGIN,
						     state->plugin_desc->spd_id,
						     "list: out of space\n");
					slapi_vattr_values_free(&values,
								&actual_attr,
								buffer_flags);
					format_free_parsed_args(argv);
					return -1;
				}
				/* Copy in the separator. */
				memcpy(outbuf + ret, argv[0], slen);
				ret += slen;
			}
			/* Copy in the value. */
			memcpy(outbuf + ret, cvalue, len);
			ret += len;
			count++;
		}
		/* Free the value set for this attribute. */
		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
	}
	format_free_parsed_args(argv);
	return ret;
}

/* Look up the entry matching a DN stored in the attribute named by the first
 * argument, pull out the values for the attribute named by the second
 * argument, and create a list separated by either "," or the third argument,
 * if a third argument is given. */
static int
format_deref(struct plugin_state *state, Slapi_PBlock *pb, Slapi_Entry *e,
	     const char *args, char *outbuf, int outbuf_len,
	     char ***visited_ndns)
{
	int i, j, len, slen, ret, count, argc;
	Slapi_Entry *ref;
	Slapi_DN *refdn;
	Slapi_ValueSet *ref_values, *values;
	Slapi_Value *ref_value, *value;
	int disposition, ref_disposition, buffer_flags, ref_buffer_flags;
	char **argv, *attrs[3], *actual_attr, *actual_ref_attr;
	const char *sep, *cvalue, *cref;
	ret = format_parse_args(state, args, &argc, &argv);
	if (ret != 0) {
		slapi_log_error(SLAPI_LOG_PLUGIN, state->plugin_desc->spd_id,
				"deref: error parsing arguments\n");
		return -1;
	}
	if (argc < 2) {
		slapi_log_error(SLAPI_LOG_PLUGIN, state->plugin_desc->spd_id,
				"deref: requires 2 arguments\n");
		format_free_parsed_args(argv);
		return -1;
	}
	/* Get the names of the references. */
	if (slapi_vattr_values_get(e, argv[0], &ref_values,
				   &ref_disposition, &actual_ref_attr,
				   0, &ref_buffer_flags) != 0) {
		/* No references. */
		format_free_parsed_args(argv);
		return 0;
	}
	/* Retrieve these attributes from the referred-to entries. */
	attrs[0] = argv[0];
	attrs[1] = argv[1];
	attrs[2] = NULL;
	/* Iterate through the names of the referred-to entries. */
	count = 0;
	for (i = slapi_valueset_first_value(ref_values, &ref_value);
	     i != -1;
	     i = slapi_valueset_next_value(ref_values, i, &ref_value)) {
		/* Pull up the referred-to entry. */
		cref = slapi_value_get_string(ref_value);
		if (cref == NULL) {
			continue;
		}
		refdn = slapi_sdn_new_dn_byval(cref);
		if (refdn == NULL) {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"deref: internal error reading \"%s\"",
					cref);
			continue;
		}
		ref = NULL;
		slapi_search_internal_get_entry(refdn, attrs, &ref,
						state->plugin_identity);
		if (ref == NULL) {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"deref: failure reading entry \"%s\"",
					slapi_sdn_get_ndn(refdn));
			slapi_sdn_free(&refdn);
			continue;
		}
		slapi_sdn_free(&refdn);
		/* Pull out the attribute from the referred-to entry. */
		if (slapi_vattr_values_get(ref, argv[1], &values,
					   &disposition, &actual_attr,
					   0, &buffer_flags) != 0) {
			slapi_entry_free(ref);
			continue;
		}
		for (j = slapi_valueset_first_value(values, &value);
		     j != -1;
		     j = slapi_valueset_next_value(values, j, &value)) {
			/* Get the length of the value. */
			cvalue = slapi_value_get_string(value);
			len = strlen(cvalue);
			/* Check if there's space for the value. */
			if (ret + len > outbuf_len) {
				slapi_log_error(SLAPI_LOG_PLUGIN,
						state->plugin_desc->spd_id,
						"deref: out of space\n");
				slapi_vattr_values_free(&values,
							&actual_attr,
							buffer_flags);
				slapi_entry_free(ref);
				slapi_vattr_values_free(&ref_values,
							&actual_ref_attr,
							ref_buffer_flags);
				format_free_parsed_args(argv);
				return -1;
			}
			/* If the value is empty, skip it. */
			if (len == 0) {
				continue;
			}
			/* If we need to, add the separator. */
			if (count > 0) {
				/* Get the length of the separator. */
				sep = (argc > 2) ? argv[2] : ",";
				slen = strlen(sep);
				/* Check if there's space for the separator. */
				if (ret + len + slen > outbuf_len) {
					slapi_log_error(SLAPI_LOG_PLUGIN,
						     state->plugin_desc->spd_id,
						     "deref: out of space\n");
					slapi_vattr_values_free(&values,
								&actual_attr,
								buffer_flags);
					slapi_entry_free(ref);
					slapi_vattr_values_free(&ref_values,
								&actual_ref_attr,
								ref_buffer_flags);
					format_free_parsed_args(argv);
					return -1;
				}
				/* Append the separator. */
				memcpy(outbuf + ret, sep, slen);
				ret += slen;
			}
			/* Append the value. */
			memcpy(outbuf + ret, cvalue, len);
			ret += len;
			count++;
		}
		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
		slapi_entry_free(ref);
	}
	slapi_vattr_values_free(&ref_values,
				&actual_ref_attr,
				ref_buffer_flags);
	format_free_parsed_args(argv);
	return ret;
}

/* Evaluate each argument, after the first, in turn, and merge them, using the
 * first argument as a separator. */
static int
format_merge(struct plugin_state *state, Slapi_PBlock *pb, Slapi_Entry *e,
	     const char *args, char *outbuf, int outbuf_len,
	     char ***visited_ndns)
{
	int ret, i, argc, len, slen, count;
	char scratch[LINE_MAX];
	char **argv;
	ret = format_parse_args(state, args, &argc, &argv);
	if (ret != 0) {
		slapi_log_error(SLAPI_LOG_PLUGIN, state->plugin_desc->spd_id,
				"merge: error parsing arguments\n");
		return -1;
	}
	for (i = 1, ret = 0, count = 0; i < argc; i++) {
		/* Expand this argument. */
		slapi_log_error(SLAPI_LOG_PLUGIN,
				state->plugin_desc->spd_id,
				"merge: expanding ->%s<-\n",
				argv[i]);
		len = format_expand(state, pb, e, argv[i],
				    scratch, sizeof(scratch),
				    visited_ndns, TRUE);
		/* Check that we've got space for this value. */
		if (len < 0) {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"merge: failed to expand ->%s<-\n",
					argv[i]);
			continue;
		}
		if (ret + len > outbuf_len) {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"merge: out of space\n");
			format_free_parsed_args(argv);
			return -1;
		}
		slapi_log_error(SLAPI_LOG_PLUGIN,
				state->plugin_desc->spd_id,
				"merge: expanded ->%s<- to ->%.*s<-\n",
				argv[i], len, scratch);
		/* If the value is empty, skip it. */
		if (len == 0) {
			continue;
		}
		/* Add the separator if we need to add it. */
		if (count > 0) {
			/* Check that we've got space for the separator. */
			slen = strlen(argv[0]);
			/* Check that we've got space for the separator. */
			if (ret + len + slen > outbuf_len) {
				slapi_log_error(SLAPI_LOG_PLUGIN,
						state->plugin_desc->spd_id,
						"merge: out of space\n");
				format_free_parsed_args(argv);
				return -1;
			}
			/* Append the separator. */
			memcpy(outbuf + ret, argv[0], slen);
			ret += slen;
		}
		/* Append the text of the expansion. */
		memcpy(outbuf + ret, scratch, len);
		ret += len;
		count++;
	}
	format_free_parsed_args(argv);
	return ret;
}

/* Look up the entry's values for the attribute named by the first argument,
 * and use the callback to check if they match the second argument.  If we find
 * exactly one match, store it in the output buffer, otherwise store the text
 * of the third argument if given, or return an error if no third argument was
 * given. */
static int
format_match_generic(struct plugin_state *state,
		     Slapi_PBlock *pb, Slapi_Entry *e,
		     const char *args, char *outbuf, int outbuf_len,
		     char ***visited_ndns,
		     const char *fnname,
		     PRBool (*match_fn)(const char *pattern, const char *value))
{
	Slapi_ValueSet *values;
	Slapi_Value *value;
	const char *cvalue, *matched;
	char *actual_attr, **argv;
	int i, count, argc, disposition, buffer_flags, ret, len;

	ret = format_parse_args(state, args, &argc, &argv);
	if (ret != 0) {
		slapi_log_error(SLAPI_LOG_PLUGIN, state->plugin_desc->spd_id,
				"%s: error parsing arguments\n", fnname);
		return -1;
	}
	if (argc < 2) {
		slapi_log_error(SLAPI_LOG_PLUGIN, state->plugin_desc->spd_id,
				"%s: requires at least 2 arguments\n", fnname);
		format_free_parsed_args(argv);
		return -1;
	}
	/* Walk the list of values for the attribute. */
	matched = NULL;
	count = 0;
	values = NULL;
	if (slapi_vattr_values_get(e, argv[0], &values,
				   &disposition, &actual_attr,
				   0, &buffer_flags) == 0) {
		for (i = slapi_valueset_first_value(values, &value);
		     i != -1;
		     i = slapi_valueset_next_value(values, i, &value)) {
			cvalue = slapi_value_get_string(value);
			if (match_fn(argv[1], cvalue)) {
				count++;
				if (count > 1) {
					break;
				}
				matched = cvalue;
			}
		}
	} else {
		if (argv[2] != NULL) {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"%s: no values found for "
					"\"%s\", using default value \"%s\"\n",
					fnname, argv[1], argv[2]);
			count = 1;
			matched = argv[2];
		} else {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"%s: no values found for "
					"\"%s\", and no default value\n",
					fnname, argv[1]);
		}
	}
	/* Make sure matched is either the single match, the default, or NULL
	 * if we had no default. */
	switch (count) {
	case 0:
		/* No matches. */
		if (argv[2] != NULL) {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"%s: no matching values for "
					"\"%s\", using default value \"%s\"\n",
					fnname, argv[1], argv[2]);
			matched = argv[2];
		} else {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"%s: no matching values for "
					"\"%s\", and no default value \"%s\"\n",
					fnname, argv[1]);
			if (values != NULL) {
				slapi_vattr_values_free(&values, &actual_attr,
							buffer_flags);
			}
			format_free_parsed_args(argv);
			return -1;
		}
		break;
	case 1:
		/* No errors. */
		break;
	default:
		/* Too many matches. */
		if (argv[2] != NULL) {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"%s: too many matching values for "
					"\"%s\", using default value \"%s\"\n",
					fnname, argv[1], argv[2]);
			matched = argv[2];
		} else {
			slapi_log_error(SLAPI_LOG_PLUGIN,
					state->plugin_desc->spd_id,
					"%s: too many matching values for "
					"\"%s\", and no default value \"%s\"\n",
					fnname, argv[1]);
			if (values != NULL) {
				slapi_vattr_values_free(&values, &actual_attr,
							buffer_flags);
			}
			format_free_parsed_args(argv);
			return -1;
		}
		break;
	}
	len = strlen(matched);
	if (len > outbuf_len) {
		slapi_log_error(SLAPI_LOG_PLUGIN, state->plugin_desc->spd_id,
				"%s: out of space\n", fnname);
		if (values != NULL) {
			slapi_vattr_values_free(&values, &actual_attr,
						buffer_flags);
		}
		format_free_parsed_args(argv);
		return -1;
	}
	memcpy(outbuf, matched, len);
	if (values != NULL) {
		slapi_vattr_values_free(&values, &actual_attr, buffer_flags);
	}
	format_free_parsed_args(argv);
	return len;
}

/* Check for glob-style matched values. */
static PRBool
format_match_cb(const char *pattern, const char *value)
{
	return fnmatch(pattern, value, 0) == 0;
}
static int
format_match(struct plugin_state *state,
	     Slapi_PBlock *pb, Slapi_Entry *e,
	     const char *args, char *outbuf, int outbuf_len,
	     char ***visited_ndns)
{
	return format_match_generic(state, pb, e, args,
				    outbuf, outbuf_len, visited_ndns,
				    "format_match", format_match_cb);
}

/* Check for a regex match. */
static PRBool
format_regmatch_cb(const char *pattern, const char *value)
{
	regex_t reg;
	regmatch_t matches;
	PRBool matched;
	memset(&reg, 0, sizeof(reg));
	if (regcomp(&reg, pattern, REG_NOSUB) != 0) {
		return PR_FALSE;
	}
	matched = (regexec(&reg, value, 1, &matches, 0) == 0);
	regfree(&reg);
	return matched;
}
static int
format_regmatch(struct plugin_state *state,
	        Slapi_PBlock *pb, Slapi_Entry *e,
	        const char *args, char *outbuf, int outbuf_len,
	        char ***visited_ndns)
{
	return format_match_generic(state, pb, e, args,
				    outbuf, outbuf_len, visited_ndns,
				    "format_regmatch", format_regmatch_cb);
}

/* Choose a formatting function by name. */
static void *
format_lookup_fn(const char *fnname)
{
	unsigned int i;
	struct {
		const char *name;
		int (*fct_ptr)(struct plugin_state *state,
			       Slapi_PBlock *pb, Slapi_Entry *e,
			       const char *args,
			       char *outbuf, int outbuf_len,
			       char ***visited_ndns);
	} fns[] = {
		{"echo", format_echo},
		{"list", format_list},
		{"deref", format_deref},
		{"merge", format_merge},
		{"match", format_match},
		{"regmatch", format_regmatch},
	};
	for (i = 0; i < sizeof(fns) / sizeof(fns[0]); i++) {
		if ((fns[i].name != NULL) &&
		    (strcmp(fns[i].name, fnname) == 0)) {
			return fns[i].fct_ptr;
		}
	}
	return NULL;
}

/* Retrieve a single value for an attribute.  If there are no values, or more
 * than one, fail. */
static char *
format_single(Slapi_PBlock *pb, Slapi_Entry *e, const char *attr,
	      char ***visited_ndns)
{
	Slapi_ValueSet *value_set;
	Slapi_Value *value;
	char *ret, *actual_attr;
	const char *cret;
	int count, disposition, buffer_flags;
	if (slapi_vattr_values_get(e, (char *) attr, &value_set,
				   &disposition, &actual_attr,
				   0, &buffer_flags) != 0) {
		return NULL;
	}
	count = slapi_valueset_count(value_set);
	ret = NULL;
	if (count == 1) {
		if (slapi_valueset_first_value(value_set, &value) == 0) {
			cret = slapi_value_get_string(value);
			if (cret != NULL) {
				ret = strdup(cret);
			}
		}
	}
	slapi_vattr_values_free(&value_set, &actual_attr, buffer_flags);
	return ret;
}

/* Find the matching closing marker. */
static const char *
format_find_closer(const char *pair, const char *pattern)
{
	int i, dq, level = 0;
	for (i = 0, dq = 0; pattern[i] != '\0'; i++) {
		if (pattern[i] == '\\') {
			i += 2;
			continue;
		}
		if (pattern[i] == '"') {
			dq = !dq;
			continue;
		}
		if (!dq) {
			if (pattern[i] == pair[0]) {
				level++;
			} else {
				if (pattern[i] == pair[1]) {
					level--;
				}
			}
		}
		if (level == 0) {
			return &pattern[i];
		}
	}
	return NULL;
}

/* Recursively expand the expression into the output buffer, adding any entries
 * we visit (other than e) to the list of visited NDNs.  Unless it's a literal,
 * treat the entire input format specifier as an expression. */
static int
format_expand(struct plugin_state *state, Slapi_PBlock *pb, Slapi_Entry *e,
	      const char *fmt,
	      char *outbuf, int outbuf_len,
	      char ***visited_ndns,
	      PRBool literal)
{
	int i, j;
	int exp_len, level;
	const char *fmtstart, *fmtend, *match, *attribute;
	char *tmp, *fnname, *spd_id;
	char exp[outbuf_len * 2];
	const char *default_value, *alternate_value, *paramstart, *paramend;
	size_t spn;
	int (*formatfn)(struct plugin_state *state,
		        Slapi_PBlock *pb, Slapi_Entry *e, const char *args,
		        char *outbuf, int outbuf_len, char ***visited_ndns);

	/* First, expand any subexpressions and call any "functions". */
	spd_id = state->plugin_desc->spd_id;
	level = 0;
	i = 0;
	j = 0;
	while (fmt[i] != '\0') {
		switch (fmt[i]) {
		case '%':
			/* This might be a subexpression, a "function" call, or
			 * an escaped character. */
			switch (fmt[i + 1]) {
			case '%':
				/* It's just an escaped "%". */
				exp[j++] = '%';
				i += 2;
				continue;
				break;
			case '{':
				/* Find the beginning of the subexpression. */
				fmtstart = fmt + i;
				/* Find the end of the subexpression. */
				match = format_find_closer("{}", fmtstart + 1);
				if (match == NULL) {
					slapi_log_error(SLAPI_LOG_PLUGIN,
							spd_id,
							"expansion failed: "
							"no closing brace\n");
					return -1;
				} else {
					/* Mark the first character after the
					 * subexpression. */
					fmtend = match + 1;
					/* Make a copy of the subexpression. */
					tmp = malloc(fmtend - fmtstart);
					if (tmp == NULL) {
						slapi_log_error(SLAPI_LOG_PLUGIN,
								spd_id,
								"expansion "
								"failed: out "
								"of memory\n");
						return -1;
					}
					memcpy(tmp, fmtstart + 2,
					       fmtend - fmtstart - 3);
					tmp[fmtend - fmtstart - 3] = '\0';
					/* Recursively expand the
					 * subexpression. */
					exp_len = format_expand(state, pb, e,
								tmp,
								exp + j,
								sizeof(exp) - j,
								visited_ndns,
								FALSE);
					if (exp_len < 0) {
						/* Miscellaneous failure, FAIL.
						 */
						slapi_log_error(SLAPI_LOG_PLUGIN,
								spd_id,
								"error "
								"expanding "
								"->%s<-\n",
								tmp);
						free(tmp);
						return -1;
					}
					free(tmp);
					if (exp_len + j >= (int) sizeof(exp)) {
						/* Out of space, FAIL. */
						slapi_log_error(SLAPI_LOG_PLUGIN,
								spd_id,
								"expansion "
								"failed: result"
								" would be too "
								"big\n");
						return -1;
					} else {
						/* It fit, so keep going. */
						i = (match + 1) - fmt;
						j += exp_len;
					}
				}
				continue;
				break;
			default:
				/* Assume it's a "function" call.  Pick out the
				 * name of the function. */
				paramstart = strpbrk(fmt + i, "{(");
				if (paramstart == NULL) {
					/* No start? Bad format. */
					slapi_log_error(SLAPI_LOG_PLUGIN,
							spd_id,
							"expansion failed: "
							"bad function "
							"invocation\n");
					return -1;
				}
				if (*paramstart == '{') {
					paramend = format_find_closer("{}",
								      paramstart);
				} else {
					paramend = format_find_closer("()",
								      paramstart);
				}
				if (paramend == NULL) {
					/* No matching end? Bad format. */
					slapi_log_error(SLAPI_LOG_PLUGIN,
							spd_id,
							"expansion failed: "
							"bad function "
							"invocation\n");
					return -1;
				}
				fnname = malloc(paramstart - (fmt + i));
				if (fnname == NULL) {
					/* Out of memory, FAIL. */
					slapi_log_error(SLAPI_LOG_PLUGIN,
							spd_id,
							"expansion failed: "
							"out of memory\n");
					return -1;
				}
				memcpy(fnname, fmt + i + 1,
				       paramstart - (fmt + i + 1));
				fnname[paramstart - (fmt + i + 1)] = '\0';
				/* Isolate the parameter string. */
				tmp = malloc(paramend - paramstart);
				if (tmp == NULL) {
					/* Out of memory, FAIL. */
					slapi_log_error(SLAPI_LOG_PLUGIN,
							spd_id,
							"expansion failed: "
							"out of memory\n");
					free(fnname);
					return -1;
				}
				memcpy(tmp, paramstart + 1,
				       paramend - (paramstart + 1));
				tmp[paramend - (paramstart + 1)] = '\0';
				/* Find the "function". */
				formatfn = format_lookup_fn(fnname);
				if (formatfn == NULL) {
					slapi_log_error(SLAPI_LOG_PLUGIN,
							spd_id,
							"expansion "
							"failed: no function "
							"named \"%s\" is "
							"defined\n", fnname);
					free(fnname);
					free(tmp);
					return -1;
				}
				/* Call the "function". */
				exp_len = (*formatfn)(state, pb, e, tmp,
						      exp + j, sizeof(exp) - j,
						      visited_ndns);
				free(tmp);
				if (exp_len < 0) {
					/* Error in function, FAIL. */
					slapi_log_error(SLAPI_LOG_PLUGIN,
							spd_id,
							"expansion "
							"failed: function "
							"'%s' failed\n",
							fnname);
					free(fnname);
					return -1;
				}
				free(fnname);
				if (exp_len + j >= (int) sizeof(exp)) {
					/* We'd be out of space, FAIL. */
					slapi_log_error(SLAPI_LOG_PLUGIN,
							spd_id,
							"expansion "
							"failed: result"
							" would be too "
							"big\n");
					return -1;
				}
				i = (paramend - fmt) + 1;
				j += exp_len;
				continue;
				break;
			}
			break;
		default:
			/* Default is just a literal character. */
			exp[j++] = fmt[i++];
			break;
		}
	}
	exp[j] = '\0';

	if (literal) {
		/* It's a literal string, so we're actually done. */
		i = strlen(exp);
		if (i <= outbuf_len) {
			memcpy(outbuf, exp, i);
		}
		return i;
	} else {
		/* It's an expression, so evaluate it.  Check if it uses a
		 * default/alternate value. */
		spn = strcspn(exp, ":");
		if (spn == strlen(exp)) {
			/* Simple expression: expect it to be a single-valued
			 * attribute. */
			tmp = format_single(pb, e, exp, visited_ndns);
			if (tmp != NULL) {
				/* Copy the string to the output buffer if
				 * there's space for it. */
				i = strlen(tmp);
				if (i <= outbuf_len) {
					memcpy(outbuf, tmp, i);
				}
				free(tmp);
				/* Return the length of the expanded
				 * expression. */
				return i;
			} else {
				/* No value found? FAIL. */
				return -1;
			}
		} else {
			/* Make a copy of the attribute name. */
			exp[spn] = '\0';
			attribute = exp;
			alternate_value = NULL;
			default_value = NULL;
			/* Figure out if there's an alternate or default value
			 * given. */
			switch (exp[spn + 1]) {
			case '+':
				alternate_value = exp + spn + 2;
				break;
			case '-':
				default_value = exp + spn + 2;
				break;
			default:
				default_value = exp + spn + 1;
				break;
			}
			/* Retrieve the value. */
			tmp = format_single(pb, e, attribute, visited_ndns);
			if (tmp == NULL) {
				/* The attribute is undefined, or we're
				 * treating it as if it is. */
				if (default_value != NULL) {
					/* Supply the default value. */
					i = strlen(default_value);
					if (i <= outbuf_len) {
						memcpy(outbuf, default_value,
						       i);
					}
					return i;
				} else {
					/* No value, and no default: FAIL. */
					return -1;
				}
			} else {
				/* There's no value defined (or it's
				 * multi-valued, which is usually trouble). */
				if (alternate_value != NULL) {
					/* Supply the alternate value. */
					i = strlen(alternate_value);
					if (i <= outbuf_len) {
						memcpy(outbuf, alternate_value,
						       i);
					}
					free(tmp);
					return i;
				} else {
					/* Supply the looked-up value. */
					i = strlen(tmp);
					if (i <= outbuf_len) {
						memcpy(outbuf, tmp, i);
					}
					free(tmp);
					return i;
				}
			}
		}
	}
}

static char *
format_format(struct plugin_state *state, Slapi_PBlock *pb, Slapi_Entry *e,
	      const char *fmt, char ***visited_ndns)
{
	char buf[YPMAXRECORD], *tmp;
	const char *match, *fmtstart, *fmtend;
	unsigned int i, j;
	int exp_len;

	i = format_expand(state, pb, e, fmt, buf, sizeof(buf),
			  visited_ndns, TRUE);
	if (i < sizeof(buf)) {
		buf[i] = '\0';
		return strdup(buf);
	} else {
		return NULL;
	}
}

char *
format_get_data(struct plugin_state *state, Slapi_PBlock *pb, Slapi_Entry *e,
		const char *fmt, char ***visited_ndns)
{
	Slapi_PBlock *local_pb;
	char ***ndn_list, **local_ndn_list, *ret;

	/* Supply an NDN list if the caller didn't. */
	if (visited_ndns != NULL) {
		ndn_list = visited_ndns;
	} else {
		ndn_list = &local_ndn_list;
		local_ndn_list = NULL;
	}

	/* Supply a PBlock if the caller didn't. */
	if (pb == NULL) {
		local_pb = slapi_pblock_new();
		pb = local_pb;
	} else {
		local_pb = NULL;
	}

	ret = format_format(state, pb, e, fmt, ndn_list);

	/* If we supplied a PBlock, clean it up. */
	if (pb == local_pb) {
		slapi_pblock_destroy(local_pb);
	}
	/* If we supplied an NDN list, clean it up. */
	if (ndn_list == &local_ndn_list) {
		format_free_ndn_list(local_ndn_list);
	}

	return ret;
}