struct ypresp_key_val
ypdb_get_next(const char *domain, const char *map, datum key, int ypprivate)
{
static struct ypresp_key_val res;
DBM *db;
datum k, v, n;
(void)memset(&res, 0, sizeof(res));
db = ypdb_open_db(domain, map, &res.status, NULL);
if (db != NULL && (int)res.status >= 0) {
n.dptr = key.dptr;
n.dsize = key.dsize;
v.dptr = NULL;
v.dsize = 0;
k.dptr = NULL;
k.dsize = 0;
n = ypdb_setkey(db, n);
if (n.dptr != NULL)
k = ypdb_nextkey(db);
else
k.dptr = NULL;
if (k.dptr != NULL)
while (yp_private(k, ypprivate))
k = ypdb_nextkey(db);
if (k.dptr == NULL)
res.status = YP_NOMORE;
else {
res.keydat.dptr = k.dptr;
res.keydat.dsize = k.dsize;
v = ypdb_fetch(db, k);
if (v.dptr == NULL)
res.status = YP_NOMORE;
else {
res.valdat.dptr = v.dptr;
res.valdat.dsize = v.dsize;
}
}
}
if (db != NULL)
ypdb_close_db(db);
return (res);
}
struct ypresp_key_val
ypdb_get_first(const char *domain, const char *map, int ypprivate)
{
static struct ypresp_key_val res;
DBM *db;
datum k, v;
(void)memset(&res, 0, sizeof(res));
db = ypdb_open_db(domain, map, &res.status, NULL);
if (db != NULL && (int)res.status >= 0) {
k = ypdb_firstkey(db);
while (yp_private(k, ypprivate))
k = ypdb_nextkey(db);
if (k.dptr == NULL)
res.status = YP_NOKEY;
else {
res.keydat.dptr = k.dptr;
res.keydat.dsize = k.dsize;
v = ypdb_fetch(db, k);
if (v.dptr == NULL)
res.status = YP_NOKEY;
else {
res.valdat.dptr = v.dptr;
res.valdat.dsize = v.dsize;
}
}
}
if (db != NULL)
ypdb_close_db(db);
return (res);
}
int
main(int argc, char *argv[])
{
int eflag = 0, dflag = 0, nflag = 0;
int uflag = 0, vflag = 0, Eflag = 0;
int status, ch, fd;
char *input = NULL, *output = NULL;
DBM *db;
datum key, val;
DBM *new_db = NULL;
static char mapname[] = "ypdbXXXXXXXXXX";
char db_mapname[PATH_MAX], db_outfile[PATH_MAX];
char db_tempname[PATH_MAX];
char user[4096], host[4096]; /* XXX: DB bsize = 4096 in ypdb.c */
char myname[HOST_NAME_MAX+1], datestr[11], *slash;
while ((ch = getopt(argc, argv, "Edensuv")) != -1)
switch (ch) {
case 'E':
eflag = 1; /* Check hostname */
Eflag = 1; /* .. even check MX records */
break;
case 'd':
dflag = 1; /* Don't check DNS hostname */
break;
case 'e':
eflag = 1; /* Check hostname */
break;
case 'n':
nflag = 1; /* Capitalize name parts */
break;
case 's': /* Ignore */
break;
case 'u':
uflag = 1; /* Don't check UUCP hostname */
break;
case 'v':
vflag = 1; /* Verbose */
break;
default:
usage();
break;
}
if (optind == argc)
usage();
input = argv[optind++];
if (optind < argc)
output = argv[optind++];
if (optind < argc)
usage();
db = ypdb_open(input, O_RDONLY, 0444);
if (db == NULL) {
err(1, "Unable to open input database %s", input);
/* NOTREACHED */
}
if (output != NULL) {
if (strlen(output) + strlen(YPDB_SUFFIX) > PATH_MAX) {
errx(1, "%s: file name too long", output);
/* NOTREACHED */
}
snprintf(db_outfile, sizeof(db_outfile),
"%s%s", output, YPDB_SUFFIX);
slash = strrchr(output, '/');
if (slash != NULL)
slash[1] = 0; /* truncate to dir */
else
*output = 0; /* eliminate */
/* note: output is now directory where map goes ! */
if (strlen(output) + strlen(mapname) +
strlen(YPDB_SUFFIX) > PATH_MAX) {
errx(1, "%s: directory name too long", output);
/* NOTREACHED */
}
snprintf(db_tempname, sizeof(db_tempname), "%s%s%s", output,
mapname, YPDB_SUFFIX);
fd = mkstemps(db_tempname, 3);
if (fd == -1)
goto fail;
close(fd);
strncpy(db_mapname, db_tempname, strlen(db_tempname) - 3);
db_mapname[sizeof(db_mapname) - 1] = '\0';
new_db = ypdb_open(db_mapname, O_RDWR|O_TRUNC, 0444);
if (new_db == NULL) {
fail:
if (fd != -1)
unlink(db_tempname);
err(1, "Unable to open output database %s",
db_outfile);
/* NOTREACHED */
}
}
for (key = ypdb_firstkey(db); key.dptr != NULL;
key = ypdb_nextkey(db)) {
val = ypdb_fetch(db, key);
if (val.dptr == NULL)
continue; /* No value */
if (*key.dptr == '@' && key.dsize == 1)
continue; /* Sendmail token */
if (strncmp(key.dptr, "YP_", 3)==0) /* YP token */
continue;
if (memchr(val.dptr, ',', val.dsize))
continue; /* List... */
if (memchr(val.dptr, '|', val.dsize))
continue; /* Pipe... */
if (!(memchr(val.dptr, '@', val.dsize) ||
memchr(val.dptr, '!', val.dsize)))
continue; /* Skip local users */
split_address(val.dptr, val.dsize, user, host);
if (eflag && check_host(val.dptr, val.dsize, host, dflag, uflag, Eflag)) {
warnx("Invalid host %s in %*.*s:%*.*s",
host, key.dsize, key.dsize, key.dptr,
val.dsize, val.dsize, val.dptr);
continue;
}
if (nflag)
capitalize(key.dptr, key.dsize);
if (new_db != NULL) {
status = ypdb_store(new_db, val, key, YPDB_INSERT);
if (status != 0) {
warnx("problem storing %*.*s %*.*s",
val.dsize, val.dsize, val.dptr,
key.dsize, key.dsize, key.dptr);
}
}
if (vflag) {
printf("%*.*s --> %*.*s\n",
val.dsize, val.dsize, val.dptr,
key.dsize, key.dsize, key.dptr);
}
}
if (new_db != NULL) {
snprintf(datestr, sizeof datestr, "%010lld",
(long long)time(NULL));
key.dptr = YP_LAST_KEY;
key.dsize = strlen(YP_LAST_KEY);
val.dptr = datestr;
val.dsize = strlen(datestr);
status = ypdb_store(new_db, key, val, YPDB_INSERT);
if (status != 0) {
warnx("problem storing %*.*s %*.*s",
key.dsize, key.dsize, key.dptr,
val.dsize, val.dsize, val.dptr);
}
}
if (new_db != NULL) {
gethostname(myname, sizeof(myname));
key.dptr = YP_MASTER_KEY;
key.dsize = strlen(YP_MASTER_KEY);
val.dptr = myname;
val.dsize = strlen(myname);
status = ypdb_store(new_db, key, val, YPDB_INSERT);
if (status != 0) {
warnx("problem storing %*.*s %*.*s",
key.dsize, key.dsize, key.dptr,
val.dsize, val.dsize, val.dptr);
}
}
ypdb_close(db);
if (new_db != NULL) {
ypdb_close(new_db);
if (rename(db_tempname, db_outfile) < 0) {
err(1, "rename %s -> %s failed", db_tempname,
db_outfile);
/* NOTREACHED */
}
}
return(0);
}
bool_t
ypdb_xdr_get_all(XDR *xdrs, struct ypreq_nokey *req)
{
static struct ypresp_all resp;
DBM *db;
datum k, v;
(void)memset(&resp, 0, sizeof(resp));
/*
* open db, and advance past any private keys we may see
*/
db = ypdb_open_db(req->domain, req->map,
&resp.ypresp_all_u.val.status, NULL);
if (db == NULL || (int)resp.ypresp_all_u.val.status < 0)
return (FALSE);
k = ypdb_firstkey(db);
while (yp_private(k, FALSE))
k = ypdb_nextkey(db);
for (;;) {
if (k.dptr == NULL)
break;
v = ypdb_fetch(db, k);
if (v.dptr == NULL)
break;
resp.more = TRUE;
resp.ypresp_all_u.val.status = YP_TRUE;
resp.ypresp_all_u.val.keydat.dptr = k.dptr;
resp.ypresp_all_u.val.keydat.dsize = k.dsize;
resp.ypresp_all_u.val.valdat.dptr = v.dptr;
resp.ypresp_all_u.val.valdat.dsize = v.dsize;
if (!xdr_ypresp_all(xdrs, &resp)) {
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_xdr_get_all: xdr_ypresp_all failed");
#endif
return (FALSE);
}
/* advance past private keys */
k = ypdb_nextkey(db);
while (yp_private(k, FALSE))
k = ypdb_nextkey(db);
}
(void)memset(&resp, 0, sizeof(resp));
resp.ypresp_all_u.val.status = YP_NOKEY;
resp.more = FALSE;
if (!xdr_ypresp_all(xdrs, &resp)) {
#ifdef DEBUG
syslog(LOG_DEBUG,
"ypdb_xdr_get_all: final xdr_ypresp_all failed");
#endif
return (FALSE);
}
if (db != NULL)
ypdb_close_db(db);
return (TRUE);
}
