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

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,					 "t#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 = PyString_FromStringAndSize (match, len);	free (match);	return res;}

static enum nss_statusinternal_nis_setservent (void){  char *domainname;  struct ypall_callback ypcb;  enum nss_status status;  if (yp_get_default_domain (&domainname))    return NSS_STATUS_UNAVAIL;  internal_nis_endservent ();  ypcb.foreach = _nis_saveit;  ypcb.data = (char *) &intern;  status = yperr2nss (yp_all (domainname, "services.byname", &ypcb));  /* Mark the last buffer as full.  */  if (intern.next != NULL)    intern.next->size = intern.offset;  intern.next = intern.start;  intern.offset = 0;  return status;}

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_ParseTuple(args, "t#s:match", &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;}

static PyObject *nis_cat (PyObject *self, PyObject *args){	char *domain;	char *map;	struct ypall_callback cb;	struct ypcallback_data data;	PyObject *dict;	int err;	if (!PyArg_ParseTuple(args, "s:cat", &map))		return NULL;	if ((err = yp_get_default_domain(&domain)) != 0)		return nis_error(err);	dict = PyDict_New ();	if (dict == NULL)		return NULL;	cb.foreach = (foreachfunc)nis_foreach;	data.dict = dict;	map = nis_mapname (map, &data.fix);	cb.data = (char *)&data;	Py_BEGIN_ALLOW_THREADS	err = yp_all (domain, map, &cb);	Py_END_ALLOW_THREADS	if (err != 0) {		Py_DECREF(dict);		return nis_error(err);	}	return dict;}

static intnetgroup_match(const char *group, const char *machine, const char *user){#if 0  /* original code */#ifdef NIS    static char *mydomain = 0;    if (mydomain == 0)	yp_get_default_domain(&mydomain);    return (innetgr(group, machine, user, mydomain));#else    syslog(LOG_ERR, "NIS netgroup support not configured");    return (NO);#endif#else  /* works better with glibc? */	static char *mydomain = 0;	if (mydomain == 0) {		static char domain[MAXHOSTNAMELEN+1];		getdomainname(domain, MAXHOSTNAMELEN);		mydomain = domain;	}	return innetgr(group, machine, user, mydomain);#endif}

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;  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;}

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;}

static PyObject *nis_maps (PyObject *self, PyObject *args, PyObject *kwdict){	char *domain = NULL;	nismaplist *maps;	PyObject *list;        int err;	static char *kwlist[] = {"domain", NULL};	if (!PyArg_ParseTupleAndKeywords(args, kwdict,					 "|s:maps", kwlist, &domain))		return NULL;	if (!domain && ((err = yp_get_default_domain (&domain)) != 0)) {		nis_error(err);		return NULL;	}	if ((maps = nis_maplist (domain)) == NULL)		return NULL;	if ((list = PyList_New(0)) == NULL)		return NULL;	for (maps = maps; maps; maps = maps->next) {		PyObject *str = PyString_FromString(maps->map);		if (!str || PyList_Append(list, str) < 0)		{			Py_DECREF(list);			list = NULL;			break;		}		Py_DECREF(str);	}	/* XXX Shouldn't we free the list of maps now? */	return list;}

static PyObject *nis_cat (PyObject *self, PyObject *args, PyObject *kwdict){	char *domain = NULL;	char *map;	struct ypall_callback cb;	struct ypcallback_data data;	PyObject *dict;	int err;	static char *kwlist[] = {"map", "domain", NULL};	if (!PyArg_ParseTupleAndKeywords(args, kwdict, "s|s:cat",				         kwlist, &map, &domain))		return NULL;	if (!domain && ((err = yp_get_default_domain(&domain)) != 0))		return nis_error(err);	dict = PyDict_New ();	if (dict == NULL)		return NULL;	cb.foreach = (foreachfunc)nis_foreach;	data.dict = dict;	map = nis_mapname (map, &data.fix);	cb.data = (char *)&data;	data.state = PyEval_SaveThread();	err = yp_all (domain, map, &cb);	PyEval_RestoreThread(data.state);	if (err != 0) {		Py_DECREF(dict);		return nis_error(err);	}	return dict;}

intmain(int argc, char *argv[]){	char *domain = NULL, *inmap;	struct ypall_callback ypcb;	extern char *optarg;	extern int optind;	int notrans, c, r, i;	notrans = key = 0;	while ((c=getopt(argc, argv, "xd:kt")) != -1)		switch (c) {		case 'x':			for (i=0; i<sizeof ypaliases/sizeof ypaliases[0]; i++)				printf("Use /"%s/" for /"%s/"/n",				    ypaliases[i].alias, ypaliases[i].name);			exit(0);		case 'd':			domain = optarg;			break;		case 't':			notrans++;			break;		case 'k':			key++;			break;		default:			usage();		}	if (optind + 1 != argc )		usage();	if (!domain)		yp_get_default_domain(&domain);	inmap = argv[optind];	if (!notrans) {		for (i=0; i<sizeof ypaliases/sizeof ypaliases[0]; i++)			if (strcmp(inmap, ypaliases[i].alias) == 0)				inmap = ypaliases[i].name;	}	ypcb.foreach = printit;	ypcb.data = NULL;	r = yp_all(domain, inmap, &ypcb);	switch (r) {	case 0:		break;	case YPERR_YPBIND:		fprintf(stderr, "ypcat: not running ypbind/n");		exit(1);	default:		fprintf(stderr, "No such map %s. Reason: %s/n",		    inmap, yperr_string(r));		exit(1);	}	exit(0);}

intmain(int  argc, char *argv[]){	char *domainname;	char *hostname = NULL;	char *inmap, *master;	int order;	int c, r, tcp = 0;	(void)yp_get_default_domain(&domainname);	while ((c = getopt(argc, argv, "Th:d:")) != -1) {		switch (c) {		case 'T':			tcp = 1;			break;		case 'd':			domainname = optarg;			break;		case 'h':			hostname = optarg;			break;		default:			usage();			/*NOTREACHED*/		}	}	if (domainname == NULL)		errx(1, "YP domain name not set");	argc -= optind;	argv += optind;	if (argc != 1)		usage();	inmap = argv[0];	if (hostname != NULL)		r = get_remote_info(domainname, inmap, hostname,		    &order, &master, tcp);	else {		r = yp_order(domainname, inmap, &order);		if (r == 0)			r = yp_master(domainname, inmap, &master);	}	if (r != 0)		errx(1, "no such map %s. Reason: %s",		    inmap, yperr_string(r));	(void)printf("Map %s has order number %d. %s", inmap, order,	    ctime((void *)&order));	(void)printf("The master server is %s./n", master);	return 0;}

static int bind_nis (void){	if (yp_get_default_domain (&nis_domain))		return -1;	nis_bound = 1;	return 0;}

static int bind_nis (void){	if (yp_get_default_domain (&nis_domain)) {		return -1;	}	nis_bound = true;	return 0;}

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;}

VALUErb_yp_get_default_domain(VALUE self){    char *domainname;    int err;    if((err = yp_get_default_domain(&domainname)) != 0) {        rb_raise(rb_eYPError, yperr_string(err));    };    return rb_tainted_str_new2(domainname);};

static void *nis_open(uschar *filename, uschar **errmsg){char *nis_domain;if (yp_get_default_domain(&nis_domain) != 0)  {  *errmsg = string_sprintf("failed to get default NIS domain");  return NULL;  }return nis_domain;}

/*! @decl string default_domain() *! *! Returns the default yp-domain. */static void f_default_domain(INT32 args){  int err;  char *ret;  err = yp_get_default_domain(&ret);  YPERROR( err );  pop_n_elems( args );  push_text( ret );}

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;}

staticint getMap_(void){    char *domain;    struct ypall_callback incallback;    int i;    h_initTab_(&hashTab, 64);    incallback.foreach = putin_;    if ((i = yp_get_default_domain(&domain)) != 0)	return(i);    return (yp_all(domain, "auto.master", &incallback));}

static PyObject *nis_get_default_domain (PyObject *self){	char *domain;	int err;	PyObject *res;	if ((err = yp_get_default_domain(&domain)) != 0)		return nis_error(err);	res = PyUnicode_FromStringAndSize (domain, strlen(domain));	return res;}

static void dict_nis_init(void){    const char *myname = "dict_nis_init";    if (yp_get_default_domain(&dict_nis_domain) != 0	|| dict_nis_domain == 0 || *dict_nis_domain == 0	|| strcasecmp(dict_nis_domain, "(none)") == 0) {	dict_nis_domain = dict_nis_disabled;	msg_warn("%s: NIS domain name not set - NIS lookups disabled", myname);    }    if (msg_verbose)	msg_info("%s: NIS domain %s", myname, dict_nis_domain);}

static int netgroup_match(char *group, char *machine, char *user){#ifdef NIS    static char *mydomain = 0;    if (mydomain == 0)	yp_get_default_domain(&mydomain);    return (innetgr(group, machine, user, mydomain));#else    _log_err("NIS netgroup support not configured");    return (NO);#endif}

/*ARGSUSED*/static int_nis_initshells(void *rv, void *cb_data, va_list ap){	static char *ypdomain;	char	*key, *data;	char	*lastkey;	int	 keylen, datalen;	int	 r;	if (sl)		sl_free(sl, 1);	sl = sl_init();	if (ypdomain == NULL) {		switch (yp_get_default_domain(&ypdomain)) {		case 0:			break;		case YPERR_RESRC:			return NS_TRYAGAIN;		default:			return NS_UNAVAIL;		}	}	/*	 * `key' and `data' point to strings dynamically allocated by	 * the yp_... functions.	 * `data' is directly put into the stringlist of shells.	 */	key = data = NULL;	if (yp_first(ypdomain, "shells", &key, &keylen, &data, &datalen))		return NS_UNAVAIL;	do {		data[datalen] = '/0';		/* clear trailing /n */		sl_add(sl, data);		lastkey = key;		r = yp_next(ypdomain, "shells", lastkey, keylen,		    &key, &keylen, &data, &datalen);		free(lastkey);	} while (r == 0);	if (r == YPERR_NOMORE) {		/*		 * `data' and `key' ought to be NULL - do not try to free them.		 */		return NS_SUCCESS;	}	return NS_UNAVAIL;}

bool user_in_netgroup(TALLOC_CTX *ctx, const char *user, const char *ngname){#ifdef HAVE_NETGROUP	static char *my_yp_domain = NULL;	char *lowercase_user = NULL;	if (my_yp_domain == NULL) {		yp_get_default_domain(&my_yp_domain);	}	if (my_yp_domain == NULL) {		DEBUG(5,("Unable to get default yp domain, "			"let's try without specifying it/n"));	}	DEBUG(5,("looking for user %s of domain %s in netgroup %s/n",		user, my_yp_domain?my_yp_domain:"(ANY)", ngname));	if (innetgr(ngname, NULL, user, my_yp_domain)) {		DEBUG(5,("user_in_netgroup: Found/n"));		return true;	}	/*	 * Ok, innetgr is case sensitive. Try once more with lowercase	 * just in case. Attempt to fix #703. JRA.	 */	lowercase_user = talloc_strdup(ctx, user);	if (!lowercase_user) {		return false;	}	if (!strlower_m(lowercase_user)) {		return false;	}	if (strcmp(user,lowercase_user) == 0) {		/* user name was already lower case! */		return false;	}	DEBUG(5,("looking for user %s of domain %s in netgroup %s/n",		lowercase_user, my_yp_domain?my_yp_domain:"(ANY)", ngname));	if (innetgr(ngname, NULL, lowercase_user, my_yp_domain)) {		DEBUG(5,("user_in_netgroup: Found/n"));		return true;	}#endif /* HAVE_NETGROUP */	return false;}

static char *getNISserver(pam_handle_t *pamh, unsigned int ctrl){	char *master;	char *domainname;	int port, err;#ifdef HAVE_YP_GET_DEFAULT_DOMAIN	if ((err = yp_get_default_domain(&domainname)) != 0) {		pam_syslog(pamh, LOG_WARNING, "can't get local yp domain: %s",			 yperr_string(err));		return NULL;	}#elif defined(HAVE_GETDOMAINNAME)	char domainname_res[256];	if (getdomainname (domainname_res, sizeof (domainname_res)) == 0)	  {	    if (strcmp (domainname_res, "(none)") == 0)	      {		/* If domainname is not set, some systems will return "(none)" */		domainname_res[0] = '/0';	      }	    domainname = domainname_res;	  }	else domainname = NULL;#endif	if ((err = yp_master(domainname, "passwd.byname", &master)) != 0) {		pam_syslog(pamh, LOG_WARNING, "can't find the master ypserver: %s",			 yperr_string(err));		return NULL;	}	port = getrpcport(master, YPPASSWDPROG, YPPASSWDPROC_UPDATE, IPPROTO_UDP);	if (port == 0) {		pam_syslog(pamh, LOG_WARNING,		         "yppasswdd not running on NIS master host");		return NULL;	}	if (port >= IPPORT_RESERVED) {		pam_syslog(pamh, LOG_WARNING,		         "yppasswd daemon running on illegal port");		return NULL;	}	if (on(UNIX_DEBUG, ctrl)) {	  pam_syslog(pamh, LOG_DEBUG, "Use NIS server on %s with port %d",		     master, port);	}	return master;}

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);}