360 lines
8.7 KiB
C
360 lines
8.7 KiB
C
/*
|
|
YPS-0.2, NIS-Server for Linux
|
|
Copyright (C) 1994 Tobias Reber
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
Modified for use with FreeBSD 2.x by Bill Paul (wpaul@ctr.columbia.edu)
|
|
|
|
$Id: ypxfr.c,v 1.1 1995/01/31 09:28:47 wpaul Exp $
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <sys/socket.h>
|
|
#include <paths.h>
|
|
#include <rpc/rpc.h>
|
|
#include <sys/types.h>
|
|
#include <db.h>
|
|
#include <limits.h>
|
|
#include <sys/stat.h>
|
|
|
|
DB *db;
|
|
|
|
#ifndef _PATH_YP
|
|
#define _PATH_YP "/var/yp"
|
|
#endif
|
|
|
|
#define PERM_SECURE (S_IRUSR|S_IWUSR)
|
|
HASHINFO openinfo = {
|
|
4096, /* bsize */
|
|
32, /* ffactor */
|
|
256, /* nelem */
|
|
2048 * 1024, /* cachesize */
|
|
NULL, /* hash */
|
|
0 /* lorder */
|
|
};
|
|
|
|
#include <rpcsvc/yp.h>
|
|
|
|
struct dom_binding {
|
|
struct dom_binding *dom_pnext;
|
|
char dom_domain[YPMAXDOMAIN + 1];
|
|
struct sockaddr_in dom_server_addr;
|
|
u_short dom_server_port;
|
|
int dom_socket;
|
|
CLIENT *dom_client;
|
|
u_short dom_local_port;
|
|
long dom_vers;
|
|
};
|
|
|
|
#define DATUM /* Otherwise ypclnt.h redefines datum */
|
|
#include <rpcsvc/ypclnt.h>
|
|
/*
|
|
* These are hooks to the ypclnt library in ../lib
|
|
*/
|
|
extern int _yp_bind(struct sockaddr_in *, char *);
|
|
extern int _yp_clear( char *);
|
|
#include <netdb.h>
|
|
#include <fcntl.h>
|
|
#include <ctype.h>
|
|
#include <arpa/inet.h>
|
|
|
|
extern int optind;
|
|
extern char *optarg;
|
|
|
|
static char *SourceHost=NULL, *TargetDomain=NULL, *SourceDomain=NULL;
|
|
static struct in_addr IpAddress;
|
|
static int Force=0, NoClear=0, TaskId=0, ProgramNumber=0,
|
|
PortNumber=0;
|
|
|
|
static char *
|
|
ypxfr_err_string(enum ypxfrstat y) {
|
|
switch(y) {
|
|
case YPXFR_SUCC: return "Success";
|
|
case YPXFR_AGE: return "Master's version not newer";
|
|
case YPXFR_NOMAP: return "Can't find server for map";
|
|
case YPXFR_NODOM: return "Domain not supported";
|
|
case YPXFR_RSRC: return "Local resource alloc failure";
|
|
case YPXFR_RPC: return "RPC failure talking to server";
|
|
case YPXFR_MADDR: return "Can't get master address";
|
|
case YPXFR_YPERR: return "YP server/map db error";
|
|
case YPXFR_BADARGS: return "Request arguments bad";
|
|
case YPXFR_DBM: return "Local dbm operation failed";
|
|
case YPXFR_FILE: return "Local file I/O operation failed";
|
|
case YPXFR_SKEW: return "Map version skew during transfer";
|
|
case YPXFR_CLEAR: return "Can't send \"Clear\" req to local ypserv";
|
|
case YPXFR_FORCE: return "No local order number in map use -f flag.";
|
|
case YPXFR_XFRERR: return "ypxfr error";
|
|
case YPXFR_REFUSED: return "Transfer request refused by ypserv";
|
|
}
|
|
}
|
|
|
|
ypxfr_foreach(int status, char *key, int keylen, char *val, int vallen,
|
|
int *data)
|
|
{
|
|
|
|
DBT outKey, outData;
|
|
|
|
if (status==YP_NOMORE)
|
|
return 0;
|
|
if (status!=YP_TRUE) {
|
|
int s=ypprot_err(status);
|
|
fprintf(stderr, "%s\n", yperr_string(s));
|
|
return 1;
|
|
}
|
|
|
|
outKey.data=key; outKey.size=(size_t)keylen;
|
|
outData.data=val; outData.size=(size_t)vallen;
|
|
(db->put)(db,&outKey,&outData,0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static enum ypxfrstat
|
|
ypxfr(char *mapName) {
|
|
|
|
int localOrderNum=0;
|
|
int masterOrderNum=0;
|
|
char *masterName;
|
|
struct sockaddr_in localHost;
|
|
struct sockaddr_in masterHost;
|
|
struct ypall_callback callback;
|
|
char dbName[1024];
|
|
char dbName2[1024];
|
|
int y, masterSock;
|
|
CLIENT *masterClient;
|
|
|
|
memset(&localHost, '\0', sizeof localHost);
|
|
localHost.sin_family=AF_INET;
|
|
localHost.sin_addr.s_addr=htonl(INADDR_LOOPBACK);
|
|
|
|
|
|
if (!SourceHost) {
|
|
if ((y=yp_master(SourceDomain, mapName, &masterName)))
|
|
return YPXFR_MADDR;
|
|
SourceHost=masterName;
|
|
}
|
|
|
|
memset(&masterHost, '\0', sizeof masterHost);
|
|
masterHost.sin_family=AF_INET;
|
|
{
|
|
struct hostent *h=gethostbyname(SourceHost);
|
|
if (!h) {
|
|
return YPXFR_MADDR;
|
|
}
|
|
memcpy(&masterHost.sin_addr, h->h_addr,
|
|
sizeof masterHost.sin_addr);
|
|
}
|
|
|
|
if ((y=_yp_bind(&masterHost, SourceDomain))) return YPXFR_RPC;
|
|
|
|
masterSock=RPC_ANYSOCK;
|
|
masterClient=clnttcp_create(&masterHost, YPPROG, YPVERS, &masterSock, 0, 0);
|
|
if (masterClient==NULL) {
|
|
clnt_pcreateerror("");
|
|
return YPXFR_RPC;
|
|
}
|
|
{
|
|
static struct timeval tv = { 25, 0 };
|
|
struct ypreq_nokey req;
|
|
struct ypresp_order resp;
|
|
int y;
|
|
|
|
req.domain=SourceDomain;
|
|
req.map=mapName;
|
|
y=clnt_call(masterClient, YPPROC_ORDER, xdr_ypreq_nokey,
|
|
&req, xdr_ypresp_order, &resp, tv);
|
|
if (y!=RPC_SUCCESS) {
|
|
clnt_perror(masterClient, "masterOrderNum");
|
|
masterOrderNum=0x7fffffff;
|
|
} else {
|
|
masterOrderNum=resp.ordernum;
|
|
}
|
|
xdr_free(xdr_ypresp_order, (char *)&resp);
|
|
}
|
|
|
|
if (!Force) {
|
|
DBT inKey, inVal;
|
|
sprintf(dbName, "%s/%s/%s", _PATH_YP, TargetDomain, mapName);
|
|
if ((db = dbopen(dbName,O_RDWR|O_EXCL, PERM_SECURE,
|
|
DB_HASH, &openinfo)) == NULL) {
|
|
perror("dbopen");
|
|
fprintf(stderr, "%s: cannot open - ignored.\n", dbName);
|
|
localOrderNum=0;
|
|
} else {
|
|
inKey.data="YP_LAST_MODIFIED"; inKey.size=strlen(inKey.data);
|
|
(db->get)(db,&inKey,&inVal,0);
|
|
if (inVal.data) {
|
|
int i;
|
|
char *d=inVal.data;
|
|
for (i=0; i<inVal.size; i++, d++) {
|
|
if (!isdigit(*d)) {
|
|
(void)(db->close)(db);
|
|
return YPXFR_SKEW;
|
|
}
|
|
}
|
|
localOrderNum=atoi(inVal.data);
|
|
}
|
|
(void)(db->close)(db);
|
|
}
|
|
if (localOrderNum>=masterOrderNum) return YPXFR_AGE;
|
|
}
|
|
|
|
sprintf(dbName, "%s/%s/%s~", _PATH_YP, TargetDomain, mapName);
|
|
if ((db = dbopen(dbName,O_RDWR|O_EXCL|O_CREAT, PERM_SECURE, DB_HASH,
|
|
&openinfo)) == NULL) {
|
|
fprintf(stderr, "%s: Cannot open\n", dbName);
|
|
return YPXFR_DBM;
|
|
}
|
|
|
|
{
|
|
DBT outKey, outData;
|
|
char orderNum[12];
|
|
outKey.data="YP_MASTER_NAME"; outKey.size=strlen(outKey.data);
|
|
outData.data=SourceHost; outData.size=strlen(outData.data);
|
|
(db->put)(db,&outKey,&outData,0);
|
|
sprintf(orderNum, "%d", masterOrderNum);
|
|
outKey.data="YP_LAST_MODIFIED"; outKey.size=strlen(outKey.data);
|
|
outData.data=orderNum; outData.size=strlen(outData.data);
|
|
(db->put)(db,&outKey,&outData,0);
|
|
}
|
|
|
|
|
|
callback.foreach = ypxfr_foreach;
|
|
callback.data = NULL;
|
|
y=__yp_all(SourceDomain, mapName, &callback);
|
|
|
|
(void)(db->close)(db);
|
|
sprintf(dbName, "%s/%s/%s~", _PATH_YP, TargetDomain, mapName);
|
|
sprintf(dbName2, "%s/%s/%s", _PATH_YP, TargetDomain, mapName);
|
|
unlink(dbName2);
|
|
rename(dbName, dbName2);
|
|
|
|
if (!NoClear) {
|
|
memset(&localHost, '\0', sizeof localHost);
|
|
localHost.sin_family=AF_INET;
|
|
localHost.sin_addr.s_addr=htonl(INADDR_LOOPBACK);
|
|
if (_yp_bind(&localHost, TargetDomain) ||
|
|
_yp_clear(TargetDomain)) return YPXFR_CLEAR;
|
|
}
|
|
return y==0?YPXFR_SUCC:YPXFR_YPERR;
|
|
}
|
|
|
|
void usage(progname)
|
|
char *progname;
|
|
{
|
|
fprintf(stderr, "usage: %s [-f] [-c] [-d target domain] \
|
|
[-h source host]\n [-s source domain] \
|
|
[-C taskid program-number ipaddr port] mapname\n", progname);
|
|
}
|
|
|
|
void
|
|
main (int argc, char **argv)
|
|
{
|
|
|
|
if (argc < 2)
|
|
{
|
|
usage(argv[0]);
|
|
exit(1);
|
|
}
|
|
|
|
while(1) {
|
|
int c=getopt(argc, argv, "fcd:h:s:C:S");
|
|
if (c==EOF) break;
|
|
switch (c) {
|
|
case 'f':
|
|
Force++;
|
|
break;
|
|
case 'c':
|
|
NoClear++;
|
|
break;
|
|
case 'd':
|
|
TargetDomain=optarg;
|
|
break;
|
|
case 'h':
|
|
SourceHost=optarg;
|
|
break;
|
|
case 's':
|
|
SourceDomain=optarg;
|
|
break;
|
|
case 'C':
|
|
TaskId=atoi(optarg);
|
|
ProgramNumber=atoi(argv[optind++]);
|
|
IpAddress.s_addr=inet_addr(argv[optind++]);
|
|
PortNumber=atoi(argv[optind++]);
|
|
break;
|
|
default:
|
|
usage(argv[0]);
|
|
exit(1);
|
|
}
|
|
}
|
|
argc-=optind;
|
|
argv+=optind;
|
|
|
|
if (!TargetDomain) {
|
|
yp_get_default_domain(&TargetDomain);
|
|
}
|
|
if (!SourceDomain) {
|
|
SourceDomain=TargetDomain;
|
|
}
|
|
|
|
for (; *argv; argv++) {
|
|
enum ypxfrstat y;
|
|
if ((y=ypxfr(*argv))!=YPXFR_SUCC) {
|
|
fprintf(stderr, "%s\n", ypxfr_err_string(y));
|
|
}
|
|
if (TaskId) {
|
|
struct sockaddr_in addr;
|
|
struct timeval wait;
|
|
CLIENT *clnt;
|
|
int s;
|
|
ypresp_xfr resp;
|
|
static struct timeval tv={0,0};
|
|
|
|
memset(&addr, '\0', sizeof addr);
|
|
addr.sin_addr=IpAddress;
|
|
addr.sin_port=htons(PortNumber);
|
|
addr.sin_family=AF_INET;
|
|
wait.tv_sec=25; wait.tv_usec=0;
|
|
s=RPC_ANYSOCK;
|
|
|
|
clnt=clntudp_create(&addr, ProgramNumber, 1, wait, &s);
|
|
if (!clnt) {
|
|
clnt_pcreateerror("ypxfr_callback");
|
|
continue;
|
|
}
|
|
|
|
resp.transid=TaskId;
|
|
resp.xfrstat=y;
|
|
switch (clnt_call(clnt, 1, xdr_ypresp_xfr, &resp,
|
|
xdr_void, NULL, tv)) {
|
|
case RPC_SUCCESS:
|
|
case RPC_TIMEDOUT:
|
|
break;
|
|
default:
|
|
clnt_perror(clnt, "ypxfr_callback");
|
|
}
|
|
|
|
clnt_destroy(clnt);
|
|
}
|
|
}
|
|
|
|
exit(0);
|
|
|
|
}
|