int
yp_master_host(CLIENT *client, char *indomain, char *inmap, char **outname)
{
struct ypresp_master yprm;
struct ypreq_nokey yprnk;
struct timeval tv;
int r;
tv.tv_sec = _yplib_host_timeout;
tv.tv_usec = 0;
yprnk.domain = indomain;
yprnk.map = inmap;
memset(&yprm, 0, sizeof yprm);
r = clnt_call(client, YPPROC_MASTER,
(xdrproc_t)xdr_ypreq_nokey, &yprnk,
(xdrproc_t)xdr_ypresp_master, &yprm, tv);
if (r != RPC_SUCCESS)
clnt_perror(client, "yp_master: clnt_call");
if (!(r = ypprot_err(yprm.stat)))
*outname = strdup(yprm.peer);
xdr_free((xdrproc_t)xdr_ypresp_master, (char *)&yprm);
return (r);
}
/* {{{ php_foreach_cat
*/
static int php_foreach_cat (int instatus, char *inkey, int inkeylen, char *inval, int invallen, char *indata)
{
int err;
err = ypprot_err (instatus);
if (!err)
{
if (inkeylen) {
char *key = emalloc(inkeylen+1);
strlcpy(key, inkey, inkeylen+1);
add_assoc_stringl_ex((zval *) indata, key, inkeylen+1, inval, invallen, 1);
efree(key);
}
return 0;
}
if (err != YPERR_NOMORE)
{
TSRMLS_FETCH();
YP(error) = err;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", yperr_string (err));
}
return 0;
}
int
yp_maplist(const char *indomain, struct ypmaplist **outmaplist)
{
struct dom_binding *ysd;
struct ypresp_maplist ypml;
struct timeval tv;
int tries = 0, r;
again:
if (_yp_dobind(indomain, &ysd) != 0)
return YPERR_DOMAIN;
tv.tv_sec = _yplib_timeout;
tv.tv_usec = 0;
memset(&ypml, 0, sizeof ypml);
r = clnt_call(ysd->dom_client, YPPROC_MAPLIST,
xdr_domainname, &indomain, xdr_ypresp_maplist, &ypml, tv);
if (r != RPC_SUCCESS) {
if (tries++)
clnt_perror(ysd->dom_client, "yp_maplist: clnt_call");
ysd->dom_vers = -1;
goto again;
}
*outmaplist = ypml.maps;
/* NO: xdr_free(xdr_ypresp_maplist, &ypml); */
_yp_unbind(ysd);
return ypprot_err(ypml.stat);
}
int
yp_match_host(CLIENT *client, char *indomain, char *inmap, const char *inkey,
int inkeylen, char **outval, int *outvallen)
{
struct ypresp_val yprv;
struct ypreq_key yprk;
struct timeval tv;
int r;
*outval = NULL;
*outvallen = 0;
tv.tv_sec = _yplib_host_timeout;
tv.tv_usec = 0;
yprk.domain = indomain;
yprk.map = inmap;
yprk.key.keydat_val = (char *)inkey;
yprk.key.keydat_len = inkeylen;
memset(&yprv, 0, sizeof yprv);
r = clnt_call(client, YPPROC_MATCH,
xdr_ypreq_key, &yprk, xdr_ypresp_val, &yprv, tv);
if (r != RPC_SUCCESS)
clnt_perror(client, "yp_match_host: clnt_call");
if ( !(r = ypprot_err(yprv.stat)) ) {
*outvallen = yprv.val.valdat_len;
*outval = malloc(*outvallen+1);
memcpy(*outval, yprv.val.valdat_val, *outvallen);
(*outval)[*outvallen] = '\0';
}
xdr_free(xdr_ypresp_val, (char *)&yprv);
return r;
}
int
yp_match_host(CLIENT *client, char *indomain, char *inmap, const char *inkey,
int inkeylen, char **outval, int *outvallen)
{
struct ypresp_val yprv;
struct ypreq_key yprk;
int r;
*outval = NULL;
*outvallen = 0;
yprk.domain = indomain;
yprk.map = inmap;
yprk.keydat.dptr = __UNCONST(inkey);
yprk.keydat.dsize = inkeylen;
memset(&yprv, 0, sizeof yprv);
r = clnt_call(client, YPPROC_MATCH, xdr_ypreq_key, &yprk,
xdr_ypresp_val, &yprv, _yplib_host_timeout);
if(r != RPC_SUCCESS)
clnt_perror(client, "yp_match_host: clnt_call");
if(!(r=ypprot_err(yprv.status)) ) {
*outvallen = yprv.valdat.dsize;
*outval = (char *)malloc(*outvallen+1);
memcpy(*outval, yprv.valdat.dptr, *outvallen);
(*outval)[*outvallen] = '\0';
}
xdr_free((xdrproc_t)xdr_ypresp_val, (char *)&yprv);
return r;
}
int
yp_first_host(CLIENT *client, char *indomain, char *inmap, char **outkey,
int *outkeylen, char **outval, int *outvallen)
{
struct ypresp_key_val yprkv;
struct ypreq_nokey yprnk;
int r;
*outkey = *outval = NULL;
*outkeylen = *outvallen = 0;
yprnk.domain = indomain;
yprnk.map = inmap;
memset(&yprkv, 0, sizeof yprkv);
r = clnt_call(client, YPPROC_FIRST, xdr_ypreq_nokey, &yprnk,
xdr_ypresp_key_val, &yprkv, _yplib_host_timeout);
if (r != RPC_SUCCESS)
clnt_perror(client, "yp_first_host: clnt_call");
if(!(r=ypprot_err(yprkv.status)) ) {
*outkeylen = yprkv.keydat.dsize;
*outkey = (char *)malloc(*outkeylen+1);
memcpy(*outkey, yprkv.keydat.dptr, *outkeylen);
(*outkey)[*outkeylen] = '\0';
*outvallen = yprkv.valdat.dsize;
*outval = (char *)malloc(*outvallen+1);
memcpy(*outval, yprkv.valdat.dptr, *outvallen);
(*outval)[*outvallen] = '\0';
}
xdr_free((xdrproc_t)xdr_ypresp_key_val, (char *)&yprkv);
return r;
}
int
yp_order_host(CLIENT *client, char *indomain, char *inmap, u_int32_t *outorder)
{
struct ypresp_order ypro;
struct ypreq_nokey yprnk;
struct timeval tv;
int r;
tv.tv_sec = _yplib_host_timeout;
tv.tv_usec = 0;
yprnk.domain = indomain;
yprnk.map = inmap;
memset(&ypro, 0, sizeof ypro);
r = clnt_call(client, YPPROC_ORDER,
(xdrproc_t)xdr_ypreq_nokey, &yprnk,
(xdrproc_t)xdr_ypresp_order, &ypro, tv);
if (r != RPC_SUCCESS)
clnt_perror(client, "yp_order_host: clnt_call");
*outorder = ypro.ordernum;
xdr_free((xdrproc_t)xdr_ypresp_order, (char *)&ypro);
return ypprot_err(ypro.stat);
}
int
nis_reload(mnt_map *m, char *map, void (*fn)())
{
struct ypall_callback cbinfo;
int error;
struct nis_callback_data data;
if (!domain) {
error = determine_nis_domain();
if (error)
return error;
}
data.ncd_m = m;
data.ncd_map = map;
data.ncd_fn = fn;
cbinfo.data = (void *)&data;
cbinfo.foreach = (void *)&callback;
error = yp_all(domain, map, &cbinfo);
if (error)
plog(XLOG_ERROR, "error grabbing nis map of %s: %s",
map, yperr_string(ypprot_err(error)));
return error;
}
int
yp_next(const char *indomain, const char *inmap, const char *inkey,
int inkeylen, char **outkey, int *outkeylen, char **outval, int *outvallen)
{
struct ypresp_key_val yprkv;
struct ypreq_key yprk;
struct dom_binding *ysd;
struct timeval tv;
int tries = 0, r;
if (indomain == NULL || *indomain == '\0' ||
strlen(indomain) > YPMAXDOMAIN || inmap == NULL ||
*inmap == '\0' || strlen(inmap) > YPMAXMAP ||
inkeylen == 0 || inkeylen >= YPMAXRECORD)
return YPERR_BADARGS;
*outkey = *outval = NULL;
*outkeylen = *outvallen = 0;
again:
if (_yp_dobind(indomain, &ysd) != 0)
return YPERR_DOMAIN;
tv.tv_sec = _yplib_timeout;
tv.tv_usec = 0;
yprk.domain = (char *)indomain;
yprk.map = (char *)inmap;
yprk.key.keydat_val = (char *)inkey;
yprk.key.keydat_len = inkeylen;
(void)memset(&yprkv, 0, sizeof yprkv);
r = clnt_call(ysd->dom_client, YPPROC_NEXT,
xdr_ypreq_key, &yprk, xdr_ypresp_key_val, &yprkv, tv);
if (r != RPC_SUCCESS) {
if (tries++)
clnt_perror(ysd->dom_client, "yp_next: clnt_call");
ysd->dom_vers = -1;
goto again;
}
if (!(r = ypprot_err(yprkv.stat))) {
*outkeylen = yprkv.key.keydat_len;
*outvallen = yprkv.val.valdat_len;
if ((*outkey = malloc(*outkeylen + 1)) == NULL ||
(*outval = malloc(*outvallen + 1)) == NULL) {
free(*outkey);
r = YPERR_RESRC;
} else {
(void)memcpy(*outkey, yprkv.key.keydat_val, *outkeylen);
(*outkey)[*outkeylen] = '\0';
(void)memcpy(*outval, yprkv.val.valdat_val, *outvallen);
(*outval)[*outvallen] = '\0';
}
}
xdr_free(xdr_ypresp_key_val, (char *) &yprkv);
_yp_unbind(ysd);
return r;
}
int
yp_master(const char *indomain, const char *inmap, char **outname)
{
struct dom_binding *ysd;
struct ypresp_master yprm;
struct ypreq_nokey yprnk;
int r, nerrs = 0;
if (outname == NULL)
return YPERR_BADARGS;
*outname = NULL;
if (_yp_invalid_domain(indomain))
return YPERR_BADARGS;
if (inmap == NULL || *inmap == '\0'
|| strlen(inmap) > YPMAXMAP)
return YPERR_BADARGS;
again:
if (_yp_dobind(indomain, &ysd) != 0)
return YPERR_DOMAIN;
yprnk.domain = indomain;
yprnk.map = inmap;
(void)memset(&yprm, 0, sizeof yprm);
r = clnt_call(ysd->dom_client, (rpcproc_t)YPPROC_MASTER,
(xdrproc_t)xdr_ypreq_nokey, &yprnk,
(xdrproc_t)xdr_ypresp_master, &yprm, _yplib_timeout);
if (r != RPC_SUCCESS) {
if (_yplib_bindtries <= 0 && ++nerrs == _yplib_nerrs) {
clnt_perror(ysd->dom_client, "yp_master: clnt_call");
nerrs = 0;
} else if (_yplib_bindtries > 0 && ++nerrs == _yplib_bindtries)
return YPERR_YPSERV;
ysd->dom_vers = -1;
goto again;
}
if (!(r = ypprot_err(yprm.status))) {
if ((*outname = strdup(yprm.master)) == NULL)
r = YPERR_RESRC;
}
xdr_free((xdrproc_t)xdr_ypresp_master, (char *)(void *)&yprm);
__yp_unbind(ysd);
if (r != 0) {
if (*outname) {
free(*outname);
*outname = NULL;
}
}
return r;
}
static int
putin_(int status, char *inkey, int inkeylen, char *inval, int invallen, char *indata)
{
if (ypprot_err(status) != 0)
return TRUE;
inkey[inkeylen] = '\0';
if (strcmp(inkey, "/-") == 0)
return FALSE;
h_addEnt_(&hashTab, inkey, 0);
return FALSE;
}
static int
putin_ (int status, char *inkey, int inkeylen, char *inval, int invallen,
char *indata)
{
#if !defined(__CYGWIN__)
if (ypprot_err (status) != 0)
return TRUE;
#endif
inkey[inkeylen] = '\0';
if (strcmp (inkey, "/-") == 0)
return FALSE;
h_addEnt_ (&hashTab, inkey, 0);
return FALSE;
}
int
yp_maplist_host(CLIENT *client, char *indomain, struct ypmaplist **outmaplist)
{
struct ypresp_maplist ypml;
int r;
memset(&ypml, 0, sizeof ypml);
r = clnt_call(client, YPPROC_MAPLIST, xdr_ypdomain_wrap_string,
indomain, xdr_ypresp_maplist, &ypml, _yplib_host_timeout);
if (r != RPC_SUCCESS)
clnt_perror(client, "yp_maplist: clnt_call");
*outmaplist = ypml.list;
/* NO: xdr_free(xdr_ypresp_maplist, &ypml);*/
return ypprot_err(ypml.status);
}
int
yp_all(const char *indomain, const char *inmap, struct ypall_callback *incallback)
{
struct ypreq_nokey yprnk;
struct dom_binding *ysd;
struct timeval tv;
struct sockaddr_in clnt_sin;
CLIENT *clnt;
u_long status;
int clnt_sock;
int r = 0;
if (indomain == NULL || *indomain == '\0' ||
strlen(indomain) > YPMAXDOMAIN || inmap == NULL ||
*inmap == '\0' || strlen(inmap) > YPMAXMAP || incallback == NULL)
return YPERR_BADARGS;
if (_yp_dobind(indomain, &ysd) != 0)
return YPERR_DOMAIN;
tv.tv_sec = _yplib_timeout;
tv.tv_usec = 0;
clnt_sock = RPC_ANYSOCK;
clnt_sin = ysd->dom_server_addr;
clnt_sin.sin_port = 0;
clnt = clnttcp_create(&clnt_sin, YPPROG, YPVERS, &clnt_sock, 0, 0);
if (clnt == NULL) {
printf("clnttcp_create failed\n");
r = YPERR_PMAP;
goto out;
}
yprnk.domain = (char *)indomain;
yprnk.map = (char *)inmap;
ypresp_allfn = incallback->foreach;
ypresp_data = (void *) incallback->data;
(void) clnt_call(clnt, YPPROC_ALL,
xdr_ypreq_nokey, &yprnk, xdr_ypresp_all_seq, &status, tv);
clnt_destroy(clnt);
if (status != YP_FALSE)
r = ypprot_err(status);
out:
_yp_unbind(ysd);
return r;
}
int
yp_master(const char *indomain, const char *inmap, char **outname)
{
struct dom_binding *ysd;
struct ypresp_master yprm;
struct ypreq_nokey yprnk;
struct timeval tv;
int tries = 0, r;
if (indomain == NULL || *indomain == '\0' ||
strlen(indomain) > YPMAXDOMAIN || inmap == NULL ||
*inmap == '\0' || strlen(inmap) > YPMAXMAP || outname == NULL)
return YPERR_BADARGS;
again:
if (_yp_dobind(indomain, &ysd) != 0)
return YPERR_DOMAIN;
tv.tv_sec = _yplib_timeout;
tv.tv_usec = 0;
yprnk.domain = (char *)indomain;
yprnk.map = (char *)inmap;
(void)memset(&yprm, 0, sizeof yprm);
r = clnt_call(ysd->dom_client, YPPROC_MASTER,
xdr_ypreq_nokey, &yprnk, xdr_ypresp_master, &yprm, tv);
if (r != RPC_SUCCESS) {
if (tries++)
clnt_perror(ysd->dom_client, "yp_master: clnt_call");
ysd->dom_vers = -1;
goto again;
}
if (!(r = ypprot_err(yprm.stat))) {
if ((*outname = strdup(yprm.peer)) == NULL)
r = YPERR_RESRC;
}
xdr_free(xdr_ypresp_master, (char *) &yprm);
_yp_unbind(ysd);
return r;
}
int
yp_maplist_host(CLIENT *client, char *indomain, struct ypmaplist **outmaplist)
{
struct ypresp_maplist ypml;
struct timeval tv;
int r;
tv.tv_sec = _yplib_host_timeout;
tv.tv_usec = 0;
memset(&ypml, 0, sizeof ypml);
r = clnt_call(client, YPPROC_MAPLIST,
xdr_domainname, &indomain, xdr_ypresp_maplist, &ypml, tv);
if (r != RPC_SUCCESS)
clnt_perror(client, "yp_maplist: clnt_call");
*outmaplist = ypml.maps;
/* NO: xdr_free(xdr_ypresp_maplist, &ypml);*/
return ypprot_err(ypml.stat);
}
int
yp_all_host(CLIENT *client, char *indomain, char *inmap,
struct ypall_callback *incallback)
{
struct ypreq_nokey yprnk;
struct timeval tv;
u_long status;
tv.tv_sec = _yplib_host_timeout;
tv.tv_usec = 0;
yprnk.domain = indomain;
yprnk.map = inmap;
ypresp_allfn = incallback->foreach;
ypresp_data = (void *)incallback->data;
(void) clnt_call(client, YPPROC_ALL,
xdr_ypreq_nokey, &yprnk, xdr_ypresp_all_seq, &status, tv);
if (status != YP_FALSE)
return ypprot_err(status);
return 0;
}
/*
* Callback from yp_all
*/
static int
callback(int status, char *key, int kl, char *val,
int vl, struct nis_callback_data *data)
{
if (status == YP_TRUE) {
/*
* Add to list of maps
*/
char *kp = strnsave(key, kl);
char *vp = strnsave(val, vl);
(*data->ncd_fn)(data->ncd_m, kp, vp);
/*
* We want more ...
*/
return FALSE;
} else {
/*
* NOMORE means end of map - otherwise log error
*/
if (status != YP_NOMORE) {
/*
* Check what went wrong
*/
int e = ypprot_err(status);
#ifdef DEBUG
plog(XLOG_ERROR, "yp enumeration of %s: %s, status=%d, e=%d",
data->ncd_map, yperr_string(e), status, e);
#else
plog(XLOG_ERROR, "yp enumeration of %s: %s",
data->ncd_map, yperr_string(e));
#endif
}
return TRUE;
}
}
int
yp_master_host(CLIENT *client, char *indomain, char *inmap, char **outname)
{
struct ypresp_master yprm;
struct ypreq_nokey yprnk;
int r;
yprnk.domain = indomain;
yprnk.map = inmap;
memset(&yprm, 0, sizeof yprm);
r = clnt_call(client, YPPROC_MASTER, xdr_ypreq_nokey, &yprnk,
xdr_ypresp_master, &yprm, _yplib_host_timeout);
if (r != RPC_SUCCESS)
clnt_perror(client, "yp_master: clnt_call");
if (!(r = ypprot_err(yprm.status))) {
*outname = (char *)strdup(yprm.master);
}
xdr_free((xdrproc_t)xdr_ypresp_master, (char *)&yprm);
return r;
}
int
yp_match(const char *indomain, const char *inmap, const char *inkey,
int inkeylen, char **outval, int *outvallen)
{
struct dom_binding *ysd;
struct ypresp_val yprv;
struct timeval tv;
struct ypreq_key yprk;
int tries = 0, r;
if (indomain == NULL || *indomain == '\0' ||
strlen(indomain) > YPMAXDOMAIN || inmap == NULL ||
*inmap == '\0' || strlen(inmap) > YPMAXMAP ||
inkey == NULL || inkeylen == 0 || inkeylen >= YPMAXRECORD)
return YPERR_BADARGS;
*outval = NULL;
*outvallen = 0;
again:
if (_yp_dobind(indomain, &ysd) != 0)
return YPERR_DOMAIN;
#ifdef YPMATCHCACHE
if (!strcmp(_yp_domain, indomain) && ypmatch_find(inmap, inkey,
inkeylen, &yprv.val.valdat_val, &yprv.val.valdat_len)) {
*outvallen = yprv.val.valdat_len;
if ((*outval = malloc(*outvallen + 1)) == NULL) {
_yp_unbind(ysd);
return YPERR_RESRC;
}
(void)memcpy(*outval, yprv.val.valdat_val, *outvallen);
(*outval)[*outvallen] = '\0';
_yp_unbind(ysd);
return 0;
}
#endif
tv.tv_sec = _yplib_timeout;
tv.tv_usec = 0;
yprk.domain = (char *)indomain;
yprk.map = (char *)inmap;
yprk.key.keydat_val = (char *) inkey;
yprk.key.keydat_len = inkeylen;
memset(&yprv, 0, sizeof yprv);
r = clnt_call(ysd->dom_client, YPPROC_MATCH,
xdr_ypreq_key, &yprk, xdr_ypresp_val, &yprv, tv);
if (r != RPC_SUCCESS) {
if (tries++)
clnt_perror(ysd->dom_client, "yp_match: clnt_call");
ysd->dom_vers = -1;
goto again;
}
if (!(r = ypprot_err(yprv.stat))) {
*outvallen = yprv.val.valdat_len;
if ((*outval = malloc(*outvallen + 1)) == NULL) {
r = YPERR_RESRC;
goto out;
}
(void)memcpy(*outval, yprv.val.valdat_val, *outvallen);
(*outval)[*outvallen] = '\0';
#ifdef YPMATCHCACHE
if (strcmp(_yp_domain, indomain) == 0)
(void)ypmatch_add(inmap, inkey, inkeylen,
*outval, *outvallen);
#endif
}
out:
xdr_free(xdr_ypresp_val, (char *) &yprv);
_yp_unbind(ysd);
return r;
}
/*
* ypdb_open_db
*/
DBM *
ypdb_open_db(const char *domain, const char *map, u_int *status,
struct opt_map **map_info)
{
static const char *domain_key = YP_INTERDOMAIN_KEY;
static const char *secure_key = YP_SECURE_KEY;
char map_path[MAXPATHLEN];
struct stat finfo;
struct opt_domain *d = NULL;
struct opt_map *m = NULL;
DBM *db;
datum k, v;
*status = YP_TRUE; /* defaults to true */
/*
* check for illegal domain and map names
*/
if (_yp_invalid_domain(domain)) {
*status = YP_NODOM;
return (NULL);
}
if (_yp_invalid_map(map)) {
*status = YP_NOMAP;
return (NULL);
}
/*
* check for domain, file.
*/
(void)snprintf(map_path, sizeof(map_path), "%s/%s", YP_DB_PATH, domain);
if (stat(map_path, &finfo) < 0 || !S_ISDIR(finfo.st_mode)) {
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_open_db: no domain %s (map=%s)", domain, map);
#endif
*status = YP_NODOM;
} else {
(void)snprintf(map_path, sizeof(map_path), "%s/%s/%s%s",
YP_DB_PATH, domain, map, YPDB_SUFFIX);
if (stat(map_path, &finfo) < 0) {
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_open_db: no map %s (domain=%s)", map,
domain);
#endif
*status = YP_NOMAP;
}
}
/*
* check for preloaded domain, map
*/
for (d = doms.lh_first; d != NULL; d = d->domsl.le_next)
if (strcmp(domain, d->domain) == 0)
break;
if (d)
for (m = d->dmaps.lh_first; m != NULL; m = m->mapsl.le_next)
if (strcmp(map, m->map) == 0)
break;
/*
* map found open?
*/
if (m) {
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_open_db: cached open: domain=%s, map=%s, db=%p,",
domain, map, m->db);
syslog(LOG_DEBUG,
"\tdbdev %d new %d; dbino %d new %d; dbmtime %ld new %ld",
m->dbdev, finfo.st_dev, m->dbino, finfo.st_ino,
(long) m->dbmtime, (long) finfo.st_mtime);
#endif
/*
* if status != YP_TRUE, then this cached database is now
* non-existent
*/
if (*status != YP_TRUE) {
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_open_db: cached db is now unavailable - "
"closing: status %s",
yperr_string(ypprot_err(*status)));
#endif
ypdb_close_map(m);
return (NULL);
}
/*
* is this the same db?
*/
if (finfo.st_dev == m->dbdev && finfo.st_ino == m->dbino &&
finfo.st_mtime == m->dbmtime) {
CIRCLEQ_REMOVE(&maps, m, mapsq); /* adjust LRU queue */
CIRCLEQ_INSERT_HEAD(&maps, m, mapsq);
if (map_info)
*map_info = m;
return (m->db);
} else {
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_open_db: db changed; closing");
#endif
ypdb_close_map(m);
m = NULL;
}
}
/*
* not cached and non-existent, return
*/
if (*status != YP_TRUE)
return (NULL);
/*
* open map
*/
(void)snprintf(map_path, sizeof(map_path), "%s/%s/%s",
YP_DB_PATH, domain, map);
#ifdef OPTIMIZE_DB
retryopen:
#endif /* OPTIMIZE_DB */
db = ypdb_open(map_path);
#ifdef OPTIMIZE_DB
if (db == NULL) {
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_open_db: errno %d (%s)", errno, strerror(errno));
#endif /* DEBUG */
if ((errno == ENFILE) || (errno == EMFILE)) {
ypdb_close_last();
goto retryopen;
}
}
#endif /* OPTIMIZE_DB */
*status = YP_NOMAP; /* see note below */
if (db == NULL) {
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_open_db: ypdb_open FAILED: map %s (domain=%s)",
map, domain);
#endif
return (NULL);
}
/*
* note: status now YP_NOMAP
*/
if (d == NULL) { /* allocate new domain? */
d = (struct opt_domain *) malloc(sizeof(*d));
if (d)
d->domain = strdup(domain);
if (d == NULL || d->domain == NULL) {
syslog(LOG_ERR,
"ypdb_open_db: MALLOC failed");
ypdb_close(db);
if (d)
free(d);
return (NULL);
}
LIST_INIT(&d->dmaps);
LIST_INSERT_HEAD(&doms, d, domsl);
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_open_db: NEW DOMAIN %s", domain);
#endif
}
/*
* m must be NULL since we couldn't find a map. allocate new one
*/
m = (struct opt_map *) malloc(sizeof(*m));
if (m)
m->map = strdup(map);
if (m == NULL || m->map == NULL) {
if (m)
free(m);
syslog(LOG_ERR, "ypdb_open_db: MALLOC failed");
ypdb_close(db);
return (NULL);
}
m->db = db;
m->dom = d;
m->host_lookup = FALSE;
m->dbdev = finfo.st_dev;
m->dbino = finfo.st_ino;
m->dbmtime = finfo.st_mtime;
CIRCLEQ_INSERT_HEAD(&maps, m, mapsq);
LIST_INSERT_HEAD(&d->dmaps, m, mapsl);
if (strcmp(map, YP_HOSTNAME) == 0 || strcmp(map, YP_HOSTADDR) == 0) {
if (!usedns) {
k.dptr = domain_key;
k.dsize = YP_INTERDOMAIN_LEN;
v = ypdb_fetch(db, k);
if (v.dptr)
m->host_lookup = TRUE;
} else
m->host_lookup = TRUE;
}
m->secure = FALSE;
k.dptr = secure_key;
k.dsize = YP_SECURE_LEN;
v = ypdb_fetch(db, k);
if (v.dptr != NULL)
m->secure = TRUE;
*status = YP_TRUE;
if (map_info)
*map_info = m;
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_open_db: NEW MAP domain=%s, map=%s, hl=%d, s=%d, db=%p",
domain, map, m->host_lookup, m->secure, m->db);
#endif
return (m->db);
}
int
yp_match(const char *indomain, const char *inmap, const char *inkey,
int inkeylen, char **outval, int *outvallen)
{
struct dom_binding *ysd;
struct ypresp_val yprv;
struct ypreq_key yprk;
int r, nerrs = 0;
if (outval == NULL || outvallen == NULL)
return YPERR_BADARGS;
*outval = NULL;
*outvallen = 0;
if (_yp_invalid_domain(indomain))
return YPERR_BADARGS;
if (inmap == NULL || *inmap == '\0'
|| strlen(inmap) > YPMAXMAP)
return YPERR_BADARGS;
if (inkey == NULL || inkeylen == 0)
return YPERR_BADARGS;
again:
if (_yp_dobind(indomain, &ysd) != 0)
return YPERR_DOMAIN;
#ifdef YPMATCHCACHE
if (!strcmp(_yp_domain, indomain) && ypmatch_find(inmap, inkey,
inkeylen, &yprv.valdat.dptr, &yprv.valdat.dsize)) {
*outvallen = yprv.valdat.dsize;
if ((*outval = malloc((size_t)(*outvallen + 1))) == NULL)
return YPERR_YPERR;
(void)memcpy(*outval, yprv.valdat.dptr, (size_t)*outvallen);
(*outval)[*outvallen] = '\0';
return 0;
}
#endif
yprk.domain = indomain;
yprk.map = inmap;
yprk.keydat.dptr = __UNCONST(inkey);
yprk.keydat.dsize = inkeylen;
memset(&yprv, 0, sizeof yprv);
r = clnt_call(ysd->dom_client, (rpcproc_t)YPPROC_MATCH,
(xdrproc_t)xdr_ypreq_key, &yprk,
(xdrproc_t)xdr_ypresp_val, &yprv,
_yplib_timeout);
if (r != RPC_SUCCESS) {
if (_yplib_bindtries <= 0 && ++nerrs == _yplib_nerrs) {
clnt_perror(ysd->dom_client, "yp_match: clnt_call");
nerrs = 0;
}
else if (_yplib_bindtries > 0 && ++nerrs == _yplib_bindtries) {
return YPERR_YPSERV;
}
ysd->dom_vers = -1;
goto again;
}
if (!(r = ypprot_err(yprv.status))) {
*outvallen = yprv.valdat.dsize;
if ((*outval = malloc((size_t)(*outvallen + 1))) == NULL)
return YPERR_YPERR;
(void)memcpy(*outval, yprv.valdat.dptr, (size_t)*outvallen);
(*outval)[*outvallen] = '\0';
#ifdef YPMATCHCACHE
if (strcmp(_yp_domain, indomain) == 0)
if (!ypmatch_add(inmap, inkey, inkeylen,
*outval, *outvallen))
r = YPERR_RESRC;
#endif
}
xdr_free((xdrproc_t)xdr_ypresp_val, (char *)(void *)&yprv);
__yp_unbind(ysd);
if (r != 0) {
if (*outval) {
free(*outval);
*outval = NULL;
}
}
return r;
}
static int
get_remote_info(const char *indomain, const char *inmap, const char *server,
int *outorder, char **outname, int tcp)
{
struct ypresp_order ypro;
struct ypresp_master yprm;
struct ypreq_nokey yprnk;
struct timeval tv;
int r;
struct sockaddr_in rsrv_sin;
CLIENT *client;
struct hostent *h;
(void)memset(&rsrv_sin, 0, sizeof(rsrv_sin));
rsrv_sin.sin_len = sizeof rsrv_sin;
rsrv_sin.sin_family = AF_INET;
h = gethostbyname(server);
if (h == NULL) {
if (inet_aton(server, &rsrv_sin.sin_addr) == 0)
errx(1, "unknown host %s", server);
} else
(void)memcpy(&rsrv_sin.sin_addr.s_addr, h->h_addr,
(size_t)h->h_length);
client = mkclient(&rsrv_sin, YPPROG, YPVERS, tcp);
if (client == NULL)
errx(1, "clnt%s_create: no contact with host %s.",
tcp ? "tcp" : "udp", server);
yprnk.domain = indomain;
yprnk.map = inmap;
(void)memset(&ypro, 0, sizeof(ypro));
tv.tv_sec = 10;
tv.tv_usec = 0;
r = clnt_call(client, (unsigned int)YPPROC_ORDER, xdr_ypreq_nokey,
&yprnk, xdr_ypresp_order, &ypro, tv);
if (r != RPC_SUCCESS)
clnt_perror(client, "yp_order: clnt_call");
*outorder = ypro.ordernum;
xdr_free((xdrproc_t)xdr_ypresp_order, (void *)&ypro);
r = ypprot_err(ypro.status);
if (r == RPC_SUCCESS) {
(void)memset(&yprm, 0, sizeof(yprm));
r = clnt_call(client, (unsigned int)YPPROC_MASTER,
xdr_ypreq_nokey, &yprnk, xdr_ypresp_master, &yprm, tv);
if (r != RPC_SUCCESS)
clnt_perror(client, "yp_master: clnt_call");
r = ypprot_err(yprm.status);
if (r == 0)
*outname = (char *)strdup(yprm.master);
xdr_free((xdrproc_t)xdr_ypresp_master, (void *)&yprm);
}
clnt_destroy(client);
return r;
}
