AC_CONFIG_MACRO_DIR([m4])

  AM_INIT_AUTOMAKE(foreign)

  LT_INIT([disable-static])

  %endif

  Name:		slapi-nis

  Release:	1%{?dist}

  Summary:	NIS Server and Schema Compatibility plugins for Directory Server

  Group:		System Environment/Daemons

  %{_sbindir}/nisserver-plugin-defs

  %changelog

  * Fri Jan 19 2018 Alexander Bokovoy <abokovoy@redhat.com> - 0.56.2-1

  - New upstream release

  - Use extended SSSD API to signal that an entry should not be cached anymore

  	return state->use_be_txns ? 0 : backend_shr_delete_cb(pb);

  }

  /* Set up our post-op callbacks. */

  #ifdef SLAPI_NIS_SUPPORT_BE_TXNS

  	struct format_choice *next;

  };

  			 const char *group, const char *set,

  			 char *outbuf, int outbuf_len,

  static char *

  xstrndup(const char *start, size_t length)

  }

  static int

  {

  	Slapi_DN *sdn;

  	Slapi_Entry *entry;

  	sdn = slapi_sdn_new_dn_byval(dn);

  	slapi_sdn_free(&sdn);

  	if (entry != NULL) {

  		slapi_entry_free(entry);

  }

  static int

  {

  	int i;

  			if (slapi_sdn_scope_test(sdn,

  						 LDAP_SCOPE_SUBTREE) != 0) {

  				break;

  			}

  		}

  			/* Non-empty list, but no match. */

  			return ENOENT;

  		}

  	}

  			if (slapi_sdn_scope_test(sdn,

  						 LDAP_SCOPE_SUBTREE) != 0) {

  				return ENOENT;

  			}

  }

  static int

  {

  	int ret = ENOENT;

  	Slapi_DN *sdn;

  	sdn = slapi_sdn_new_dn_byref(dn);

  	if (sdn != NULL) {

  		slapi_sdn_free(&sdn);

  	}

  	return ret;

  }

  static void

  			  struct slapi_dn ***list, struct slapi_dn ***list2,

  {

  		format_add_sdn_list(list, list2, dn);

  	}

  }

  	free(argv);

  }

  static int

  		  int *pargc, char ***pargv)

  {

  	int i, dq, argc;

  	return 0;

  }

  /* Choose the first value of the set of results for the first argument, and if

   * we get no results, return the second argument. */

  static int

  	     const char *group, const char *set,

  	     char *outbuf, int outbuf_len,

  {

  	int ret, i, argc, first, common_length;

  	char **argv, **values;

  	const char *value_format, *default_value;

  	unsigned int *lengths;

  	if (ret != 0) {

  				"first: error parsing arguments\n");

  		return -EINVAL;

  	}

  	if (argc < 1) {

  				"first: error parsing arguments\n");

  		format_free_parsed_args(argv);

  		return -EINVAL;

  		default_value = argv[1];

  	}

  	ret = -ENOENT;

  	if (values == NULL) {

  		if (default_value == NULL) {

  			slapi_log_error(SLAPI_LOG_PLUGIN,

  					"first: no values for ->%s<-, "

  					"and no default value provided\n",

  					value_format);

  			ret = -ENOENT;

  		} else {

  					  group, set,

  					  outbuf, outbuf_len,

  			ret = i;

  		}

  	} else {

   * argument, pull out the values for the attribute named by the second

   * argument, and return a list of those values. */

  static int

  	       const char *fname, const char *group, const char *set,

  	       char *ref_attr, char *target_attr,

  	       char *outbuf, int outbuf_len,

  {

  	int i, j;

  	Slapi_Entry *ref;

  	const struct berval *val;

  	struct berval **choices;

  	/* Note that this map cares about this attribute. */

  	}

  	/* Note that the attribute in this entry refers to other entries. */

  	}

  	/* Get the values of the reference attribute from this entry. */

  	if (slapi_vattr_values_get(e, ref_attr, &ref_values,

  		refdn = slapi_sdn_new_dn_byval(cref);

  		if (refdn == NULL) {

  			slapi_log_error(SLAPI_LOG_PLUGIN,

  					"%s: internal error parsing name "

  					"\"%s\"\n", fname, cref);

  			continue;

  		}

  			slapi_log_error(SLAPI_LOG_PLUGIN,

  					"%s: entry \"%s\" is in a location "

  					"where we don't look\n", fname, cref);

  			slapi_sdn_free(&refdn);

  			continue;

  		}

  		if (ref == NULL) {

  			slapi_log_error(SLAPI_LOG_PLUGIN,

  					"%s: failure reading entry \"%s\"\n",

  					fname, slapi_sdn_get_ndn(refdn));

  			slapi_sdn_free(&refdn);

  			continue;

  		}

  		slapi_log_error(SLAPI_LOG_PLUGIN,

  				"%s: reading \"%s\" from \"%s\"\n",

  				fname, target_attr, slapi_sdn_get_ndn(refdn));

  		slapi_sdn_free(&refdn);

  		/* Note that this map cares about this attribute. */

  		}

  		/* Pull out the attribute from the referred-to entry. */

  		if (slapi_vattr_values_get(ref, target_attr, &values,

  }

  static int

  	     const char *group, const char *set,

  	     char *outbuf, int outbuf_len,

  {

  	int argc, ret;

  	char **argv, *ref_attr, *target_attr;

  	if (ret != 0) {

  				"deref: error parsing arguments\n");

  		return -EINVAL;

  	}

  	if (argc != 2) {

  				"deref: requires two arguments\n");

  		format_free_parsed_args(argv);

  		return -EINVAL;

  	}

  	if (outbuf_choices == NULL) {

  				"deref: returns a list, but a list "

  				"would not be appropriate\n");

  		format_free_parsed_args(argv);

  	}

  	ref_attr = argv[0];

  	target_attr = argv[1];

  	format_free_parsed_args(argv);

  	return ret;

  }

  static int

  	       const char *group, const char *set,

  	       char *outbuf, int outbuf_len,

  {

  	int argc, ret;

  	char **argv, *ref_attr, *filter, *target_attr;

  	if (ret != 0) {

  				"deref_f: error parsing arguments\n");

  		return -EINVAL;

  	}

  	if (argc != 3) {

  				"deref_f: requires three arguments\n");

  		format_free_parsed_args(argv);

  		return -EINVAL;

  	}

  	if (outbuf_choices == NULL) {

  				"deref_f: returns a list, but a list "

  				"would not be appropriate\n");

  		format_free_parsed_args(argv);

  	ref_attr = argv[0];

  	filter = argv[1];

  	target_attr = argv[2];

  	format_free_parsed_args(argv);

  	return ret;

  }

   * at last, pull out the values for the attribute named by the last argument,

   * and return a list of those values. */

  static int

  		const char *fname, const char *group, const char *set,

  		const char **attributes, const char **filters,

  		char *outbuf, int outbuf_len,

  {

  	int i, j, k;

  	Slapi_Entry *entry;

  	struct format_ref_attr_list *list;

  	/* Note that this map cares about all of these attributes. */

  		for (i = 0; attributes[i] != NULL; i++) {

  		}

  	}

  	/* Note that this list of attributes is used for pulling up data. */

  				 attributes, filters);

  					 attributes, filters);

  	/* Follow the chain: set up the first link. */

  			dn = slapi_sdn_get_ndn(these[j]);

  			slapi_sdn_get_parent(these[j], parent);

  			slapi_log_error(SLAPI_LOG_PLUGIN,

  					"%s: noting parent "

  					"\"%s\" for \"%s\"\n",

  					fname, slapi_sdn_get_ndn(parent),

  					    slapi_sdn_get_ndn(parent));

  			/* Check if the referred-to entry is in a location that

  			 * we care about. */

  				slapi_log_error(SLAPI_LOG_PLUGIN,

  						"%s: entry \"%s\" is in a location "

  						"where we don't look\n", fname,

  						slapi_sdn_get_ndn(these[j]));

  				continue;

  			}

  			/* Pull up the named entry. */

  			if (entry == NULL) {

  				slapi_log_error(SLAPI_LOG_PLUGIN,

  						"%s: error reading entry "

  						"\"%s\"\n", fname,

  						slapi_sdn_get_dn(these[j]));

  				continue;

  			} else {

  				slapi_log_error(SLAPI_LOG_PLUGIN,

  						"%s: reading entry "

  						"\"%s\" (%d)\n", fname,

  						slapi_sdn_get_dn(these[j]), i);

  						   &actual_attr,

  						   0, &buffer_flags) != 0) {

  				slapi_log_error(SLAPI_LOG_PLUGIN,

  						"%s: entry \"%s\" has no "

  						"values for \"%s\"\n", fname,

  						slapi_entry_get_dn(entry),

  					}

  					/* If it's in an area that we're

  					 * ignoring, then ignore it already. */

  						continue;

  					}

  					/* Let's visit the named entry this

  					 * time, in case we're nesting. */

  								  cvalue,

  					/* We need to visit the named entry

  					 * next time. */

  								  cvalue,

  				} else {

  					/* Get the value. */

  					bval = slapi_value_get_berval(value);

  					}

  					format_add_bv_list(&choices, bval);

  					slapi_log_error(SLAPI_LOG_PLUGIN,

  							"%s: found value "

  							"\"%.*s\" in \"%s\"\n",

  							fname,

  }

  static int

  	       const char *group, const char *set,

  	       char *outbuf, int outbuf_len,

  {

  	int ret, argc;

  	char **argv;

  	if (ret != 0) {

  				"deref_r: error parsing arguments\n");

  		return -EINVAL;

  	}

  	if (argc < 2) {

  				"deref_r: requires at least two arguments\n");

  		format_free_parsed_args(argv);

  		return -EINVAL;

  	}

  	if (outbuf_choices == NULL) {

  				"deref_r: returns a list, but a list "

  				"would not be appropriate\n");

  		format_free_parsed_args(argv);

  		return -EINVAL;

  	}

  			      group, set,

  			      (const char **) argv, NULL,

  			      outbuf, outbuf_len,

  	format_free_parsed_args(argv);

  	return ret;

  }

  static int

  		const char *group, const char *set,

  		char *outbuf, int outbuf_len,

  {

  	int ret, argc, n, i;

  	char **argv, **attrs, **filters;

  	if (ret != 0) {

  				"deref_rf: error parsing arguments\n");

  		return -EINVAL;

  	}

  	if (argc < 3) {

  				"deref_rf: requires at least three "

  				"arguments\n");

  		format_free_parsed_args(argv);

  		return -EINVAL;

  	}

  	if (outbuf_choices == NULL) {

  				"deref_rf: returns a list, but a list "

  				"would not be appropriate\n");

  		format_free_parsed_args(argv);

  	n = (argc + 1) / 2;

  	attrs = malloc(sizeof(char *) * (n + 1));

  	if (attrs == NULL) {

  				"deref_rf: out of memory\n");

  		format_free_parsed_args(argv);

  		return -ENOMEM;

  	memset(attrs, 0, sizeof(char *) * (n + 1));

  	filters = malloc(sizeof(char *) * (n + 1));

  	if (filters == NULL) {

  				"deref_rf: out of memory\n");

  		free(attrs);

  		format_free_parsed_args(argv);

  			filters[i + 1] = argv[i * 2 + 1];

  		}

  	}

  			      group, set,

  			      (const char **) attrs, (const char **) filters,

  			      outbuf, outbuf_len,

  	free(filters);

  	free(attrs);

  	format_free_parsed_args(argv);

   * the values for the attribute named by the third argument, and return a list

   * of those values. */

  struct format_referred_cbdata {

  	char *attr;

  	struct berval **choices;

  };

  	cbdata = callback_data;

  	slapi_log_error(SLAPI_LOG_PLUGIN,

  			"referred: examining \"%s\" in \%s\"\n",

  			cbdata->attr, slapi_entry_get_ndn(e));

  				   &disposition, &actual_attr,

  				   0, &buffer_flags) != 0) {

  		slapi_log_error(SLAPI_LOG_PLUGIN,

  				"referred: no values for \"%s\" in \"%s\"\n",

  				cbdata->attr, slapi_entry_get_ndn(e));

  		return 0;

  			continue;

  		}

  		slapi_log_error(SLAPI_LOG_PLUGIN,

  				"referred: got %d-byte value for \"%s\"\n",

  				(int) val->bv_len, actual_attr);

  		/* Add it to the list of values we've retrieved. */

  	return 0;

  }

  static int

  		const char *group, const char *set,