自学教程：C++ yp_match函数代码示例

static struct hostent *_yp_gethostnamadr(int type, const void *data){	static char	*domain = NULL;	struct hostent	*h = NULL;	const char	*name;	char		 buf[MAXHOSTNAMELEN];	char		*res = NULL;	int		 r, len;	if (!domain && _yp_check(&domain) == 0) {		errno = 0; /* ignore yp_bind errors */		return (NULL);	}	if (type == ASR_GETHOSTBYNAME) {		name = data;		len = strlen(name);		r = yp_match(domain, "hosts.byname", name, len, &res, &len);	}	else {		if (inet_ntop(AF_INET, data, buf, sizeof buf) == NULL)			return (NULL);		len = strlen(buf);		r = yp_match(domain, "hosts.byaddr", buf, len, &res, &len);	}	if (r == 0) {		h = hostent_from_yp(AF_INET, res);	} else {		errno = 0; /* ignore error if not found */	}	if (res)		free(res);	return (h);}

struct passwd *ypgetpwnam(char *nam){	static struct passwd pwent;	int reason, vallen, secure = 0;	char *val;	/*	 * Get local domain	 */	if (!domain && (reason = yp_get_default_domain(&domain))) {		fprintf(stderr, "%s: can't get local YP domain. Reason: %s/n",		    __progname, yperr_string(reason));		exit(1);	}	if (!yp_match(domain, "master.passwd.byname", nam, strlen(nam),	    &val, &vallen))		secure = 1;	else if (yp_match(domain, "passwd.byname", nam, strlen(nam),	    &val, &vallen))		return (NULL);	val[vallen] = '/0';	if (__yplin)		free(__yplin);	if (!(__yplin = malloc(vallen + 1)))		err(1, NULL);	strlcpy(__yplin, val, vallen + 1);	free(val);	return(interpret(&pwent, __yplin, secure));}

struct passwd *ypgetpwuid(uid_t uid){	static struct passwd pwent;	int reason, vallen, secure = 0;	char namebuf[16], *val;	if (!domain && (reason = yp_get_default_domain(&domain))) {		fprintf(stderr, "%s: can't get local YP domain. Reason: %s/n",		    __progname, yperr_string(reason));		exit(1);	}	snprintf(namebuf, sizeof namebuf, "%u", (u_int)uid);	if (!yp_match(domain, "master.passwd.byuid", namebuf, strlen(namebuf),	    &val, &vallen))		secure = 1;	else if (yp_match(domain, "passwd.byuid", namebuf, strlen(namebuf),	    &val, &vallen))		return (NULL);	val[vallen] = '/0';	if (__yplin)		free(__yplin);	if (!(__yplin = malloc(vallen + 1)))		err(1, NULL);	strlcpy(__yplin, val, vallen + 1);	free(val);	return(interpret(&pwent, __yplin, secure));}

static intypgetpwnam(const char *nam, struct passwd *pwd){	char *val;	int reason, vallen, namlen = (int)strlen(nam);	int flags;	int ok;		flags = ok = 0;	val = NULL;	reason = yp_match(domain, "master.passwd.byname", nam, namlen,	    &val, &vallen);	if (reason == YPERR_MAP) {		reason = yp_match(domain, "passwd.byname", nam, namlen,		    &val, &vallen);		flags = _PASSWORD_OLDFMT;	}	if (reason != 0)		goto out;	if (pw_scan(val, pwd, &flags) == 0)		goto out;	ok = 1;	val = NULL;	/* Don't free the memory, it is still in use */out:	if (val)		free(val);	return ok;}

enum nss_status_nss_nis_getntohost_r (const struct ether_addr *addr, struct etherent *eth,		       char *buffer, size_t buflen, int *errnop){  if (addr == NULL)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  char *domain;  if (__glibc_unlikely (yp_get_default_domain (&domain)))    return NSS_STATUS_UNAVAIL;  char buf[33];  int nlen = snprintf (buf, sizeof (buf), "%x:%x:%x:%x:%x:%x",		      (int) addr->ether_addr_octet[0],		      (int) addr->ether_addr_octet[1],		      (int) addr->ether_addr_octet[2],		      (int) addr->ether_addr_octet[3],		      (int) addr->ether_addr_octet[4],		      (int) addr->ether_addr_octet[5]);  char *result;  int len;  int yperr = yp_match (domain, "ethers.byaddr", buf, nlen, &result, &len);  if (__glibc_unlikely (yperr != YPERR_SUCCESS))    {      enum nss_status retval = yperr2nss (yperr);      if (retval == NSS_STATUS_TRYAGAIN)        *errnop = errno;      return retval;    }  if (__glibc_unlikely ((size_t) (len + 1) > buflen))    {      free (result);      *errnop = ERANGE;      return NSS_STATUS_TRYAGAIN;    }  char *p = strncpy (buffer, result, len);  buffer[len] = '/0';  while (isspace (*p))    ++p;  free (result);  int parse_res = _nss_files_parse_etherent (p, eth, (void *) buffer, buflen,					     errnop);  if (__glibc_unlikely (parse_res < 1))    {      if (parse_res == -1)	return NSS_STATUS_TRYAGAIN;      else	return NSS_STATUS_NOTFOUND;    }  return NSS_STATUS_SUCCESS;}

struct passwd *ypgetpwnam(char *nam, int secure){	static struct passwd pwent;	int reason, vallen;	char *val;	reason = yp_match(domain,	    secure ? "master.passwd.byname" : "passwd.byname",	    nam, strlen(nam), &val, &vallen);	switch (reason) {	case 0:		break;	default:		return (NULL);	}	val[vallen] = '/0';	if (__yplin)		free(__yplin);	__yplin = (char *)malloc(vallen + 1);	if (__yplin == NULL)		pw_error(NULL, 1, 1);	strlcpy(__yplin, val, vallen + 1);	free(val);	return (interpret(&pwent, __yplin, secure));}

static int_getservbyname_yp(struct servent_data *sed){	char *result;	int resultlen;	char buf[YPMAXRECORD + 2];	if(!sed->yp_domain) {		if(yp_get_default_domain(&sed->yp_domain))			return (0);	}	snprintf(buf, sizeof(buf), "%s/%s", sed->yp_name, sed->yp_proto);	sed->yp_name = 0;	sed->yp_proto = NULL;	if (yp_match(sed->yp_domain, "services.byname", buf, strlen(buf),	    &result, &resultlen)) {		return(0);	}			/* getservent() expects lines terminated with /n -- make it happy */	snprintf(sed->line, sizeof sed->line, "%.*s/n", resultlen, result);	free(result);	return(1);}

static PyObject *nis_match (PyObject *self, PyObject *args, PyObject *kwdict){	char *match;	char *domain = NULL;	int keylen, len;	char *key, *map;	int err;	PyObject *res;	int fix;	static char *kwlist[] = {"key", "map", "domain", NULL};	if (!PyArg_ParseTupleAndKeywords(args, kwdict,					 "s#s|s:match", kwlist,					 &key, &keylen, &map, &domain))		return NULL;	if (!domain && ((err = yp_get_default_domain(&domain)) != 0))		return nis_error(err);	map = nis_mapname (map, &fix);	if (fix)	    keylen++;	Py_BEGIN_ALLOW_THREADS	err = yp_match (domain, map, key, keylen, &match, &len);	Py_END_ALLOW_THREADS	if (fix)	    len--;	if (err != 0)		return nis_error(err);	res = PyUnicode_FromStringAndSize (match, len);	free (match);	return res;}

static PyObject *nis_match (PyObject *self, PyObject *args){	char *match;	char *domain;	int keylen, len;	char *key, *map;	int err;	PyObject *res;	int fix;	if (!PyArg_Parse(args, "(t#s)", &key, &keylen, &map))		return NULL;	if ((err = yp_get_default_domain(&domain)) != 0)		return nis_error(err);	map = nis_mapname (map, &fix);	if (fix)	    keylen++;	Py_BEGIN_ALLOW_THREADS	err = yp_match (domain, map, key, keylen, &match, &len);	Py_END_ALLOW_THREADS	if (fix)	    len--;	if (err != 0)		return nis_error(err);	res = PyString_FromStringAndSize (match, len);	free (match);	return res;}

enum nss_status_nss_nis_setnetgrent (const char *group, struct __netgrent *netgrp){  char *domain;  int len;  enum nss_status status;  status = NSS_STATUS_SUCCESS;  if (group == NULL || group[0] == '/0')    return NSS_STATUS_UNAVAIL;  if (yp_get_default_domain (&domain))    return NSS_STATUS_UNAVAIL;  internal_nis_endnetgrent (netgrp);  status = yperr2nss (yp_match (domain, "netgroup", group, strlen (group),				&netgrp->data, &len));  if (status == NSS_STATUS_SUCCESS)    {      /* Our implementation of yp_match already allocates a buffer	 which is one byte larger than the value in LEN specifies	 and the last byte is filled with NUL.  So we can simply	 use that buffer.  */      assert (len > 0);      assert (malloc_usable_size (netgrp->data) >= len + 1);      assert (netgrp->data[len] == '/0');      netgrp->data_size = len;      netgrp->cursor = netgrp->data;    }  return status;}

/** Return IP address given host name 'host'.* If 'host' is "", set to INADDR_ANY.*/struct in_addr host2ip(char *host){  struct in_addr in;  register struct hostent *hep;  /* Check whether this is a dotted decimal. */  if (!host || *host == '/0') {    in.s_addr = INADDR_ANY;  }  else if ((in.s_addr = inet_addr(host)) != -1) {  }  /* Attempt to resolve host name via DNS. */  else if ((hep = gethostbyname(host))) {    in = *(struct in_addr *)(hep->h_addr_list[0]);  }  /* As a last resort, try YP. */  else {    static char *domain = 0;  /* YP domain */    char *value;              /* key value */    int value_len;            /* length of returned value */    if (!domain) yp_get_default_domain(&domain);    if (yp_match(domain, "hosts.byname", host, strlen(host), &value, &value_len) == 0) {      in.s_addr = inet_addr(value);    }  }  return in;} /* host2ip */

char *get_nis_password(char *user, char *nisdomain, char *nismap){    static char *val = NULL;    char *password = NULL;    int vallen, res;#ifdef DEBUG    printf("Domain is set to %s/n", nisdomain);    printf("YP Map is set to %s/n", nismap);#endif    /* Free last entry */    if (val) {	free(val);	val = NULL;    }    /* Get NIS entry */    res = yp_match(nisdomain, nismap, user, strlen(user), &val, &vallen);    switch (res) {    case NO_YPERR:	/* username = */ (void) strtok(val, ":");	password = strtok(NULL, ",:");	return password;    case YPERR_YPBIND:	syslog(LOG_ERR, "Squid Authentication through ypbind failure: can't communicate with ypbind");	return NULL;    case YPERR_KEY:		/* No such key in map */	return NULL;    default:	return NULL;    }}

void nis_userdbInit(void){    char *data;    int len, yperr;    domainname=rcfg_lookup(conf.cf, "etc.nisdomain");    if(domainname==NULL)    {	yp_get_default_domain(&domainname);    }    yp_bind(domainname);    yperr=yp_match(domainname, conf.userdb, "blah",	  4, &data, &len);    if(yperr==YPERR_MAP)    {	fprintf(stderr,		"Warning, table %s not found in NIS, setting to %s/n",		conf.userdb, NIS_DEFAULTUDB);	conf.userdb=NIS_DEFAULTUDB;    }    conf.udb.u_exists=nis_u_exists;    conf.udb.getuser=nis_getuser;    conf.udb.listusers=nis_listusers;    conf.udb.storeuser=nis_storeuser;    conf.udb.deleteuser=nis_deleteuser;    conf.udb.eraseuserdb=nis_eraseuserdb;    conf.udb.parseusers=nis_parseusers;}

struct user nis_getuser(char *name){    struct user u;    char *data;    int yperr, len, times[2];    memset(&u, 0x00, sizeof(u));    yperr=yp_match(domainname, conf.userdb, name,	  strlen(name), &data, &len);    if(!yperr)    {	strcpy(u.name, strtok(data, ":"));	strcpy(u.passwd, strtok(NULL, ":"));	strcpy(u.pageid, strtok(NULL, ":"));	strcpy(u.statid, strtok(NULL, ":"));	times[0]=atoi(strtok(NULL, ":"));	times[1]=atoi(strtok(NULL, ":"));	u.times=pack_timebits(times[0], times[1]);	free(data);    }    return(u);}

enum nss_status_nss_nis_getsecretkey (const char *netname, char *skey, char *passwd,		       int *errnop){  enum nss_status retval;  char buf[2 * (HEXKEYBYTES + 1)];  char *domain, *result;  int len;  skey[0] = 0;  if (netname == NULL || passwd == NULL)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  domain = strchr (netname, '@');  if (!domain)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  ++domain;  retval = yperr2nss (yp_match (domain, "publickey.byname", netname,				strlen (netname), &result, &len));  if (retval != NSS_STATUS_SUCCESS)    {      if (retval == NSS_STATUS_NOTFOUND)	*errnop = ENOENT;      else if (retval == NSS_STATUS_TRYAGAIN)	*errnop = errno;      return retval;    }  if (result != NULL)    {      char *p = strchr (result, ':');      if (p == NULL)	return NSS_STATUS_SUCCESS;      ++p;      strncpy (buf, p, 2 * (HEXKEYBYTES + 1));      buf[2 * (HEXKEYBYTES + 1)] = '/0';      if (!xdecrypt (buf, passwd))	return NSS_STATUS_SUCCESS;      if (memcmp (buf, &(buf[HEXKEYBYTES]), KEYCHECKSUMSIZE) != 0)	return NSS_STATUS_SUCCESS;      buf[HEXKEYBYTES] = '/0';      strcpy (skey, buf);    }  return NSS_STATUS_SUCCESS;}

static int_getservbyport_yp(struct servent_data *sed){	char *result;	int resultlen;	char buf[YPMAXRECORD + 2];	int rv;	snprintf(buf, sizeof(buf), "%d/%s", ntohs(sed->yp_port),	    sed->yp_proto);	sed->yp_port = 0;	sed->yp_proto = NULL;	if (!sed->yp_domain) {		if (yp_get_default_domain(&sed->yp_domain))			return (0);	}	/*	 * We have to be a little flexible here. Ideally you're supposed	 * to have both a services.byname and a services.byport map, but	 * some systems have only services.byname. FreeBSD cheats a little	 * by putting the services.byport information in the same map as	 * services.byname so that either case will work. We allow for both	 * possibilities here: if there is no services.byport map, we try	 * services.byname instead.	 */	if ((rv = yp_match(sed->yp_domain, "services.byport", buf, strlen(buf),						&result, &resultlen))) {		if (rv == YPERR_MAP) {			if (yp_match(sed->yp_domain, "services.byname", buf,					strlen(buf), &result, &resultlen))			return(0);		} else			return(0);	}			/* getservent() expects lines terminated with /n -- make it happy */	snprintf(sed->line, sizeof sed->line, "%.*s/n", resultlen, result);	free(result);	return(1);}

enum nss_status_nss_nis_getspnam_r (const char *name, struct spwd *sp,		     char *buffer, size_t buflen, int *errnop){  struct parser_data *data = (void *) buffer;  enum nss_status retval;  char *domain, *result, *p;  int len, parse_res;  if (name == NULL)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  if (yp_get_default_domain (&domain))    return NSS_STATUS_UNAVAIL;  retval = yperr2nss (yp_match (domain, "shadow.byname", name,				strlen (name), &result, &len));  if (retval != NSS_STATUS_SUCCESS)    {      if (retval == NSS_STATUS_NOTFOUND)	*errnop = ENOENT;      else if (retval == NSS_STATUS_TRYAGAIN)	*errnop = errno;      return retval;    }  if ((size_t) (len + 1) > buflen)    {      free (result);      *errnop = ERANGE;      return NSS_STATUS_TRYAGAIN;    }  p = strncpy (buffer, result, len);  buffer[len] = '/0';  while (isspace (*p))    ++p;  free (result);  parse_res = _nss_files_parse_spent (p, sp, data, buflen, errnop);  if (parse_res < 1)    {      if (parse_res == -1)	return NSS_STATUS_TRYAGAIN;      else	{	  *errnop = ENOENT;	  return NSS_STATUS_NOTFOUND;	}    }  return NSS_STATUS_SUCCESS;}

enum nss_status_nss_nis_getsecretkey (const char *netname, char *skey, char *passwd,		       int *errnop){  skey[0] = 0;  if (netname == NULL || passwd == NULL)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  char *domain = strchr (netname, '@');  if (domain == NULL)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  ++domain;  char *result;  int len;  int yperr = yp_match (domain, "publickey.byname", netname, strlen (netname),			&result, &len);  if (__builtin_expect (yperr != YPERR_SUCCESS, 0))    {      enum nss_status retval = yperr2nss (yperr);      if (retval == NSS_STATUS_TRYAGAIN)	*errnop = errno;      return retval;    }  if (result != NULL)    {      char *p = strchr (result, ':');      if (p != NULL)	{	  char buf[2 * (HEXKEYBYTES + 1)];	  ++p;	  strncpy (buf, p, 2 * (HEXKEYBYTES + 1));	  buf[2 * HEXKEYBYTES + 1] = '/0';	  if (xdecrypt (buf, passwd)	      && memcmp (buf, &(buf[HEXKEYBYTES]), KEYCHECKSUMSIZE) == 0)	    {	      buf[HEXKEYBYTES] = '/0';	      strcpy (skey, buf);	    }	}      free (result);    }  return NSS_STATUS_SUCCESS;}

enum nss_status_nss_nis_gethostton_r (const char *name, struct etherent *eth,		       char *buffer, size_t buflen, int *errnop){  if (name == NULL)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  char *domain;  if (__glibc_unlikely (yp_get_default_domain (&domain)))    return NSS_STATUS_UNAVAIL;  char *result;  int len;  int yperr = yp_match (domain, "ethers.byname", name, strlen (name), &result,			&len);  if (__glibc_unlikely (yperr != YPERR_SUCCESS))    {      enum nss_status retval = yperr2nss (yperr);      if (retval == NSS_STATUS_TRYAGAIN)        *errnop = errno;      return retval;    }  if (__glibc_unlikely ((size_t) (len + 1) > buflen))    {      free (result);      *errnop = ERANGE;      return NSS_STATUS_TRYAGAIN;    }  char *p = strncpy (buffer, result, len);  buffer[len] = '/0';  while (isspace (*p))    ++p;  free (result);  int parse_res = _nss_files_parse_etherent (p, eth, (void *) buffer, buflen,					     errnop);  if (__glibc_unlikely (parse_res < 1))    {      if (parse_res == -1)	return NSS_STATUS_TRYAGAIN;      else	return NSS_STATUS_NOTFOUND;    }  return NSS_STATUS_SUCCESS;}

char *ypclnt_get(ypclnt_t *ypc, const char *key){	char *value;	int len, r;	r = yp_match(ypc->domain, ypc->map,	    key, (int)strlen(key), &value, &len);	if (r != 0) {		ypclnt_error(ypc, __func__, "%s", yperr_string(r));		return (NULL);	}	return (value);}

enum nss_status_nss_nis_netname2user (char netname[MAXNETNAMELEN + 1], uid_t *uidp,		       gid_t *gidp, int *gidlenp, gid_t *gidlist, int *errnop){  char *domain;  int yperr;  char *lookup;  int len;  domain = strchr (netname, '@');  if (!domain)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  /* Point past the '@' character */  ++domain;  lookup = NULL;  yperr = yp_match (domain, "netid.byname", netname, strlen (netname),		    &lookup, &len);  switch (yperr)    {    case YPERR_SUCCESS:      break;			/* the successful case */    case YPERR_DOMAIN:    case YPERR_KEY:      *errnop = ENOENT;      return NSS_STATUS_NOTFOUND;    case YPERR_MAP:    default:      return NSS_STATUS_UNAVAIL;    }  if (lookup)    {      enum nss_status err;      lookup[len] = '/0';      err = parse_netid_str (lookup, uidp, gidp, gidlenp, gidlist);      free (lookup);      return err;    }  else    {      *errnop = ENOENT;      return NSS_STATUS_NOTFOUND;    }  return NSS_STATUS_SUCCESS;}

enum nss_status_nss_nis_getrpcbynumber_r (int number, struct rpcent *rpc,			   char *buffer, size_t buflen, int *errnop){  char *domain;  if (__glibc_unlikely (yp_get_default_domain (&domain)))    return NSS_STATUS_UNAVAIL;  char buf[32];  int nlen = snprintf (buf, sizeof (buf), "%d", number);  char *result;  int len;  int yperr = yp_match (domain, "rpc.bynumber", buf, nlen, &result, &len);  if (__glibc_unlikely (yperr != YPERR_SUCCESS))    {      enum nss_status retval = yperr2nss (yperr);      if (retval == NSS_STATUS_TRYAGAIN)	*errnop = errno;      return retval;    }  if (__glibc_unlikely ((size_t) (len + 1) > buflen))    {      free (result);      *errnop = ERANGE;      return NSS_STATUS_TRYAGAIN;    }  char *p = strncpy (buffer, result, len);  buffer[len] = '/0';  while (isspace (*p))    ++p;  free (result);  int parse_res = _nss_files_parse_rpcent (p, rpc, (void  *) buffer, buflen,					   errnop);  if (__glibc_unlikely (parse_res < 1))    {      if (parse_res == -1)	return NSS_STATUS_TRYAGAIN;      else	return NSS_STATUS_NOTFOUND;    }  else    return NSS_STATUS_SUCCESS;}

enum nss_status_nss_nis_getgrgid_r (gid_t gid, struct group *grp,		     char *buffer, size_t buflen, int *errnop){  char *domain;  if (__builtin_expect (yp_get_default_domain (&domain), 0))    return NSS_STATUS_UNAVAIL;  char buf[32];  int nlen = sprintf (buf, "%lu", (unsigned long int) gid);  char *result;  int len;  int yperr = yp_match (domain, "group.bygid", buf, nlen, &result, &len);  if (__builtin_expect (yperr != YPERR_SUCCESS, 0))    {      enum nss_status retval = yperr2nss (yperr);      if (retval == NSS_STATUS_TRYAGAIN)	*errnop = errno;      return retval;    }  if (__builtin_expect ((size_t) (len + 1) > buflen, 0))    {      free (result);      *errnop = ERANGE;      return NSS_STATUS_TRYAGAIN;    }  char *p = strncpy (buffer, result, len);  buffer[len] = '/0';  while (isspace (*p))    ++p;  free (result);  int parse_res = _nss_files_parse_grent (p, grp, (void *) buffer, buflen,					  errnop);  if (__builtin_expect (parse_res < 1, 0))    {      if (parse_res == -1)	return NSS_STATUS_TRYAGAIN;      else	return NSS_STATUS_NOTFOUND;    }  return NSS_STATUS_SUCCESS;}

/* * Map an EUI-64 to a hostname. Use either /etc/eui64 or NIS/YP. */inteui64_ntohost(char *hostname, size_t len, const struct eui64 *id){	FILE *fp;	char buf[BUFSIZ + 2];	struct eui64 local_eui64;	char local_host[MAXHOSTNAMELEN];#ifdef YP	char *result;	int resultlen;	char eui64_a[24];	char *yp_domain;#endif	if ((fp = fopen(_PATH_EUI64, "re")) == NULL)		return (1);	while (fgets(buf,BUFSIZ,fp)) {		if (buf[0] == '#')			continue;#ifdef YP		if (buf[0] == '+') {			if (yp_get_default_domain(&yp_domain))				continue;			eui64_ntoa(id, eui64_a, sizeof(eui64_a));			if (yp_match(yp_domain, "eui64.byid", eui64_a,				strlen(eui64_a), &result, &resultlen)) {				continue;			}			strncpy(buf, result, resultlen);			buf[resultlen] = '/0';			free(result);		}#endif		if (eui64_line(buf, &local_eui64, local_host,		    sizeof(local_host)) == 0) {			if (bcmp(&local_eui64.octet[0],				&id->octet[0], EUI64_LEN) == 0) {			/* We have a match */				strcpy(hostname, local_host);				fclose(fp);				return(0);			}		}	}	fclose(fp);	return (1);}

static intnis0_find(void *handle, uschar *filename, const uschar *keystring, int length,  uschar **result, uschar **errmsg, uint *do_cache){int rc;uschar *nis_data;int nis_data_length;do_cache = do_cache;   /* Placate picky compilers */if ((rc = yp_match(CCS handle, CCS filename, CCS keystring, length + 1,    CSS &nis_data, &nis_data_length)) == 0)  {  *result = string_copy(nis_data);  (*result)[nis_data_length] = 0;    /* remove final '/n' */  return OK;  }return (rc == YPERR_KEY || rc == YPERR_MAP)? FAIL : DEFER;}

/* * Map an ethernet address to a hostname. Use either /etc/ethers or NIS/YP. */intether_ntohost(char *hostname, const struct ether_addr *e){	FILE *fp;	char buf[BUFSIZ + 2];	struct ether_addr local_ether;	char local_host[MAXHOSTNAMELEN];#ifdef YP	char *result;	int resultlen;	char *ether_a;	char *yp_domain;#endif	if ((fp = fopen(_PATH_ETHERS, "r")) == NULL)		return (1);	while (fgets(buf,BUFSIZ,fp)) {		if (buf[0] == '#')			continue;#ifdef YP		if (buf[0] == '+') {			if (yp_get_default_domain(&yp_domain))				continue;			ether_a = ether_ntoa(e);			if (yp_match(yp_domain, "ethers.byaddr", ether_a,			    strlen(ether_a), &result, &resultlen)) {				continue;			}			strncpy(buf, result, resultlen);			buf[resultlen] = '/0';			free(result);		}#endif		if (!ether_line(buf, &local_ether, local_host)) {			if (!bcmp((char *)&local_ether.octet[0],			    (char *)&e->octet[0], 6)) {				/* We have a match. */				strcpy(hostname, local_host);				fclose(fp);				return(0);			}		}	}	fclose(fp);	return (1);}

/* If we haven't found the entry, we give a SUCCESS and an empty key back.   Solaris docu says: sizeof (pkey) == HEXKEYBYTES + 1.*/enum nss_status_nss_nis_getpublickey (const char *netname, char *pkey, int *errnop){  enum nss_status retval;  char *domain, *result;  int len;  pkey[0] = 0;  if (netname == NULL)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  domain = strchr (netname, '@');  if (!domain)    {      *errnop = EINVAL;      return NSS_STATUS_UNAVAIL;    }  ++domain;  retval = yperr2nss (yp_match (domain, "publickey.byname", netname,				strlen (netname), &result, &len));  if (retval != NSS_STATUS_SUCCESS)    {      if (retval == NSS_STATUS_NOTFOUND)	*errnop = ENOENT;      else if (retval == NSS_STATUS_TRYAGAIN)	*errnop = errno;      return retval;    }  if (result != NULL)    {      char *p = strchr (result, ':');      if (p != NULL)	*p = 0;      strncpy (pkey, result, HEXKEYBYTES + 1);      pkey[HEXKEYBYTES] = '/0';    }  return NSS_STATUS_SUCCESS;}

static int_revnetgr_lookup(char* lookupdom, char* map, const char* str,		 const char* dom, const char* group){	int y, rv, rot;	char key[MAXHOSTNAMELEN];	char *result;	int resultlen;	for (rot = 0; ; rot++) {		switch (rot) {		case 0:			snprintf(key, MAXHOSTNAMELEN, "%s.%s", str,			    dom ? dom : lookupdom);			break;		case 1:			snprintf(key, MAXHOSTNAMELEN, "%s.*", str);			break;		case 2:			snprintf(key, MAXHOSTNAMELEN, "*.%s",			    dom ? dom : lookupdom);			break;		case 3:			snprintf(key, MAXHOSTNAMELEN, "*.*");			break;		default:			return (0);		}		y = yp_match(lookupdom, map, key, strlen(key), &result,		    &resultlen);		if (y == 0) {			rv = _listmatch(result, group, resultlen);			free(result);			if (rv)				return (1);		} else if (y != YPERR_KEY) {			/*			 * If we get an error other than 'no			 * such key in map' then something is			 * wrong and we should stop the search.			 */			return (-1);		}	}}

/* * Map a hostname to an EUI-64 using /etc/eui64 or NIS/YP. */inteui64_hostton(const char *hostname, struct eui64 *id){	FILE *fp;	char buf[BUFSIZ + 2];	struct eui64 local_eui64;	char local_host[MAXHOSTNAMELEN];#ifdef YP	char *result;	int resultlen;	char *yp_domain;#endif	if ((fp = fopen(_PATH_EUI64, "re")) == NULL)		return (1);	while (fgets(buf,BUFSIZ,fp)) {		if (buf[0] == '#')			continue;#ifdef YP		if (buf[0] == '+') {			if (yp_get_default_domain(&yp_domain))				continue;			if (yp_match(yp_domain, "eui64.byname", hostname,				strlen(hostname), &result, &resultlen)) {				continue;			}			strncpy(buf, result, resultlen);			buf[resultlen] = '/0';			free(result);		}#endif		if (eui64_line(buf, &local_eui64, local_host,		    sizeof(local_host)) == 0) {			if (strcmp(hostname, local_host) == 0) {				/* We have a match */				bcopy(&local_eui64, id, sizeof(struct eui64));				fclose(fp);				return(0);			}		}	}	fclose(fp);	return (1);}