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_status
internal_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 int
netgroup_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;
}
int
main(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);
}
int
main(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;
}
enum nss_status
_nss_nis_getnetbyname_r (const char *name, struct netent *net,
char *buffer, size_t buflen, int *herrnop)
{
enum nss_status retval;
struct parser_data *data = (void *) buffer;
char *domain, *result, *p;
int len, parse_res;
if (name == NULL)
{
__set_errno (EINVAL);
*herrnop = NETDB_INTERNAL;
return NSS_STATUS_UNAVAIL;
}
if (yp_get_default_domain (&domain))
return NSS_STATUS_UNAVAIL;
retval = yperr2nss (yp_match (domain, "networks.byname", name,
strlen (name), &result, &len));
if (retval != NSS_STATUS_SUCCESS)
{
if (retval == NSS_STATUS_TRYAGAIN)
{
__set_errno (EAGAIN);
*herrnop = NETDB_INTERNAL;
}
return retval;
}
if ((size_t) (len + 1) > buflen)
{
free (result);
__set_errno (ERANGE);
*herrnop = NETDB_INTERNAL;
return NSS_STATUS_TRYAGAIN;
}
p = strncpy (buffer, result, len);
buffer[len] = '\0';
while (isspace (*p))
++p;
free (result);
parse_res = _nss_files_parse_netent (p, net, data, buflen);
if (!parse_res)
{
*herrnop = NETDB_INTERNAL;
if (errno == ERANGE)
return NSS_STATUS_TRYAGAIN;
else
return NSS_STATUS_NOTFOUND;
}
else
return NSS_STATUS_SUCCESS;
}
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;
}
static enum nss_status
internal_nis_getetherent_r (struct ether *eth, char *buffer, size_t buflen)
{
struct parser_data *data = (void *) buffer;
char *domain, *result, *outkey;
int len, keylen, parse_res;
if (yp_get_default_domain (&domain))
return NSS_STATUS_UNAVAIL;
/* Get the next entry until we found a correct one. */
do
{
enum nss_status retval;
char *p;
if (new_start)
retval = yperr2nss (yp_first (domain, "ethers.byaddr",
&outkey, &keylen, &result, &len));
else
retval = yperr2nss ( yp_next (domain, "ethers.byaddr",
oldkey, oldkeylen,
&outkey, &keylen, &result, &len));
if (retval != NSS_STATUS_SUCCESS)
{
if (retval == NSS_STATUS_TRYAGAIN)
__set_errno (EAGAIN);
return retval;
}
if ((size_t) (len + 1) > buflen)
{
free (result);
__set_errno (ERANGE);
return NSS_STATUS_TRYAGAIN;
}
p = strncpy (buffer, result, len);
buffer[len] = '\0';
while (isspace (*p))
++p;
free (result);
parse_res = _nss_files_parse_etherent (p, eth, data, buflen);
if (!parse_res && errno == ERANGE)
return NSS_STATUS_TRYAGAIN;
free (oldkey);
oldkey = outkey;
oldkeylen = keylen;
new_start = 0;
}
while (!parse_res);
return NSS_STATUS_SUCCESS;
}
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;
}
VALUE
rb_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;
}
static
int 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.
*/
int
eui64_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);
}
