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 int ypgetpwnam(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_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; }
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. */ 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); }
static int nis0_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. */ int ether_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. */ int eui64_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); }