void FillPolicyTable(void)
{
struct OsdList l;
afs_int32 code;
afs_uint32 db_revision;
if (!osddb_client) {
#ifdef BUILDING_CLIENT_COMMAND
osddb_client = init_osddb_client(cellPtr, 0);
#else
osddb_client = init_osddb_client(NULL);
#endif
if (!osddb_client)
return;
}
code = ubik_Call((int(*)(struct rx_connection*,...))OSDDB_GetPoliciesRevision, osddb_client, 0, &db_revision);
if (code == RXGEN_OPCODE)
code = ubik_Call((int(*)(struct rx_connection*,...))OSDDB_GetPoliciesRevision68, osddb_client, 0, &db_revision);
if ( code ) {
ViceLog(0, ("failed to query for policy revision, error %d\n", code));
return;
}
ViceLog(1, ("OSDDB policy revision: %d, local revision: %d\n", db_revision,
policies_revision));
if ( db_revision == policies_revision )
return;
l.OsdList_len = 0;
l.OsdList_val = 0;
code = ubik_Call((int(*)(struct rx_connection*,...))OSDDB_PolicyList, osddb_client, 0, &l);
if (code == RXGEN_OPCODE)
code = ubik_Call((int(*)(struct rx_connection*,...))OSDDB_PolicyList66, osddb_client, 0, &l);
if (!code) {
buildPolicyIndex(&l);
/* the very policy structures are in the new index now */
if ( l.OsdList_val)
free(l.OsdList_val);
OSDDB_LOCK;
policies_revision = db_revision;
OSDDB_UNLOCK;
}
}
int
main(int argc, char **argv)
{
char **av = argv;
struct sockaddr_in host;
afs_int32 code;
struct hostent *hp;
char hnamebuf[200];
struct timeval tv;
int noAuth = 1; /* Default is authenticated connections */
argc--, av++;
if (argc < 1) {
printf("usage: pxclient <serverHost>\n");
exit(1);
}
memset(&host, 0, sizeof(struct sockaddr_in));
host.sin_family = AF_INET;
host.sin_addr.s_addr = inet_addr(av[0]);
#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
host.sin_len = sizeof(struct sockaddr_in);
#endif
if (host.sin_addr.s_addr != -1) {
strcpy(hnamebuf, av[0]);
} else {
hp = gethostbyname(av[0]);
if (hp) {
host.sin_family = hp->h_addrtype;
memcpy((caddr_t) & host.sin_addr, hp->h_addr, hp->h_length);
} else {
printf("unknown server host %s\n", av[0]);
exit(1);
}
}
if ((code = pxclient_Initialize(noAuth, host.sin_addr.s_addr)) != 0) {
printf("Couldn't initialize fs library (code=%d).\n", code);
exit(1);
}
code = ubik_Call(RXAFS_GetTime, cstruct, 0, &tv.tv_sec, &tv.tv_usec);
if (!code)
printf("AFS_GetTime on %s sec=%ld, usec=%ld\n", av[0], tv.tv_sec,
(long int)tv.tv_usec);
else
printf("return code is %d\n", code);
#ifdef notdef
while (1) {
char line[500];
int nargs;
printf("fs> ");
if (fgets(line, 499, stdin) != NULL) {
char *oper;
char **argp = args;
GetArgs(line, argp, &nargs);
oper = &argp[0][0];
++argp, --nargs;
if (!strcmp(oper, "probe")) {
code =
ubik_Call(RXAFS_GetTime, cstruct, 0, &tv.tv_sec,
&tv.tv_usec);
printf("return code is %d\n", code);
if (!code)
printf("sec=%d\n", tv.tv_sec);
} else if (!strcmp(oper, "fsstats")) {
struct afsStatistics stats;
code = ubik_AFS_GetStatistics(cstruct, 0, &stats);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "fd")) {
code = FetchData(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "fs")) {
code = FetchStatus(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "fa")) {
code = FetchACL(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "sd")) {
code = StoreData(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "ss")) {
code = StoreStatus(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "sa")) {
code = StoreACL(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "cf")) {
code = CreateFile(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "rf")) {
code = RemoveFile(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "rn")) {
code = Rename(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "sl")) {
code = Symlink(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "hl")) {
code = HardLink(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "md")) {
code = MakeDir(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "rd")) {
code = RemoveDir(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "rdd")) {
code = Readdir(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "mm")) {
code = MakeMountPoint(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "rt")) {
code = ReleaseTokens(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "bs")) {
code = BulkStatus(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "lk")) {
code = Lookup(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "gt")) {
code = GetToken(argp);
printf("return code is %d\n", code);
} else if (!strcmp(oper, "ka")) {
code = KeepAlive(argp);
printf("return code is %d\n", code);
} else if ((!strcmp(oper, "q")) || !strcmp(oper, "quit"))
exit(0);
else {
printf("Unknown oper! Available operations: \n\n");
printf("fd <vnode> <unique> <pos> <len>\n");
printf("fs <vnode> <unique>\n");
printf("fa <vnode> <unique>\n");
printf
("sd <vnode> <unique> <pos> <len> <flen> [<mode>|-1] [<owner>|-1] [<length>|-1] <string>\n");
printf
("ss <vnode> <unique> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
printf("sa <vnode> <unique> <string>\n");
printf("rf <vnode> <unique> <name>\n");
printf
("cf <vnode> <unique> <name> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
printf
("rn <ovnode> <ounique> <oname> <nvnode> <nunique> <nname>\n");
printf
("sl <vnode> <unique> <name> <contents> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
printf("hl <dvnode> <dunique> <name> <evnode> <eunique>\n");
printf
("md <vnode> <unique> <name> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
printf("rd <vnode> <unique> <name>\n");
printf("rdd <vnode> <unique> <pos> <len>\n");
printf("lk <vnode> <unique> <name>\n");
printf("gt <vnode> <unique> <tokenID>\n");
printf("ka <vol.l> <vnode> <unique> <isExec> <kaTime>\n");
}
}
}
#endif
return 0;
}
static int
Main(struct cmd_syndesc *as, void *arock)
{
int code;
char name[MAXKTCNAMELEN];
char instance[MAXKTCNAMELEN];
char newCell[MAXKTCREALMLEN];
char *cell;
long serverList[MAXSERVERS];
extern struct passwd *getpwuid();
struct passwd *pw;
struct ktc_encryptionKey key;
char passwd[BUFSIZ];
int cellSpecified;
int i;
int verbose = (as->parms[1].items != 0);
int hostUsage = (as->parms[2].items != 0);
int waitReap = (as->parms[4].items != 0);
int doAuth = (as->parms[5].items != 0);
int number; /* number of iterations */
int callsPerSecond; /* to allow conn GC to run */
unsigned long lo, hi; /* mem usage */
unsigned long highWater; /* mem usage after reap period */
unsigned long lastWater; /* mem usage after last msg */
int serversUse[MAXSERVERS]; /* usage of each server */
long serversHost[MAXSERVERS]; /* host addr */
unsigned long startTime;
unsigned long now;
lo = 0;
whoami = as->a0name;
newCell[0] = 0;
if (as->parms[0].items)
number = atoi(as->parms[0].items->data);
else
number = 100;
if (as->parms[3].items)
callsPerSecond = atoi(as->parms[3].items->data);
else
callsPerSecond = 1;
if (doAuth && hostUsage) {
fprintf(stderr,
"Can't report host usage when calling UserAuthenticate\n");
return -1;
}
if (as->parms[12].items) { /* if username specified */
code =
ka_ParseLoginName(as->parms[12].items->data, name, instance,
newCell);
if (code) {
afs_com_err(whoami, code, "parsing user's name '%s'",
as->parms[12].items->data);
return code;
}
if (strlen(newCell) > 0)
cellSpecified = 1;
} else {
/* No explicit name provided: use Unix uid. */
pw = getpwuid(getuid());
if (pw == 0) {
printf("Can't figure out your name from your user id.\n");
return KABADCMD;
}
strncpy(name, pw->pw_name, sizeof(name));
strcpy(instance, "");
strcpy(newCell, "");
}
if (strcmp(as->parms[14].name, "-cell") == 0) {
if (as->parms[14].items) { /* if cell specified */
if (cellSpecified)
printf("Duplicate cell specification not allowed\n");
else
strncpy(newCell, as->parms[14].items->data, sizeof(newCell));
}
}
code = ka_ExpandCell(newCell, newCell, 0 /*local */ );
if (code) {
afs_com_err(whoami, code, "Can't expand cell name");
return code;
}
cell = newCell;
if (as->parms[13].items) { /* if password specified */
strncpy(passwd, as->parms[13].items->data, sizeof(passwd));
memset(as->parms[13].items->data, 0,
strlen(as->parms[13].items->data));
} else {
char msg[sizeof(name) + 15];
if (as->parms[12].items)
strcpy(msg, "Admin Password: "******"Password for %s: ", name);
code = read_pw_string(passwd, sizeof(passwd), msg, 0);
if (code)
code = KAREADPW;
else if (strlen(passwd) == 0)
code = KANULLPASSWORD;
if (code) {
afs_com_err(whoami, code, "reading password");
return code;
}
}
if (as->parms[15].items) {
struct cmd_item *ip;
char *ap[MAXSERVERS + 2];
for (ip = as->parms[15].items, i = 2; ip; ip = ip->next, i++)
ap[i] = ip->data;
ap[0] = "";
ap[1] = "-servers";
code = ubik_ParseClientList(i, ap, serverList);
if (code) {
afs_com_err(whoami, code, "could not parse server list");
return code;
}
ka_ExplicitCell(cell, serverList);
}
if (!doAuth) {
ka_StringToKey(passwd, cell, &key);
memset(passwd, 0, sizeof(passwd));
}
if (hostUsage) {
memset(serversUse, 0, sizeof(serversUse));
memset(serversHost, 0, sizeof(serversHost));
}
startTime = time(0);
for (i = 0; i < number; i++) {
if (doAuth) {
char *reason;
code =
ka_UserAuthenticateLife(0, name, instance, cell, passwd, 0,
&reason);
if (code) {
fprintf(stderr, "Unable to authenticate to AFS because %s.\n",
reason);
return code;
}
} else {
struct ktc_token token;
struct ktc_token *pToken;
struct ubik_client *ubikConn;
struct kaentryinfo tentry;
int c;
code =
ka_GetAdminToken(name, instance, cell, &key, 3600, &token,
1 /*new */ );
if (code) {
afs_com_err(whoami, code, "getting admin token");
return code;
}
pToken = &token;
if (token.ticketLen == 0) {
fprintf("Can't get admin token\n");
return -1;
}
code =
ka_AuthServerConn(cell, KA_MAINTENANCE_SERVICE, pToken,
&ubikConn);
if (code) {
afs_com_err(whoami, code, "Getting AuthServer ubik conn");
return code;
}
if (verbose)
for (c = 0; c < MAXSERVERS; c++) {
struct rx_connection *rxConn =
ubik_GetRPCConn(ubikConn, c);
struct rx_peer *peer;
if (rxConn == 0)
break;
peer = rx_PeerOf(rxConn);
printf("conn to %s:%d secObj:%x\n",
inet_ntoa(rx_HostOf(peer)), ntohs(rx_PortOf(peer)),
rxConn->securityObject);
}
code =
ubik_Call(KAM_GetEntry, ubikConn, 0, name, instance,
KAMAJORVERSION, &tentry);
if (code) {
afs_com_err(whoami, code, "getting information for %s.%s", name,
instance);
return code;
}
for (c = 0; c < MAXSERVERS; c++) {
struct rx_connection *rxConn = ubik_GetRPCConn(ubikConn, c);
int d;
if (rxConn == 0)
break;
if (rxConn->serial > 0) {
long host = rx_HostOf(rx_PeerOf(rxConn));
for (d = 0; d < MAXSERVERS; d++) {
if (serversHost[d] == 0)
serversHost[d] = host;
if (host == serversHost[d]) {
serversUse[d]++;
break;
}
}
}
if (verbose)
printf("serial is %d\n", rxConn->serial);
}
ubik_ClientDestroy(ubikConn);
}
now = time(0);
if (!lo)
lo = sbrk(0);
if (i && ((i & 0x3f) == 0)) {
unsigned long this = sbrk(0);
printf(" mem after %d: lo=%x, cur=%x => %d (@ %d)\n", i, lo,
this, this - lo, (this - lo) / i);
if (highWater && (lastWater != this)) {
lastWater = this;
printf(" core leaking (after %d) should be %x, is %x\n", i,
highWater, this);
}
}
if ((highWater == 0) && ((now - startTime) > 61)) {
highWater = sbrk(0);
lastWater = highWater;
printf(" mem highWater mark (after %d) should be %x\n", i,
highWater);
}
if (callsPerSecond) {
long target;
if (callsPerSecond > 0)
target = i / callsPerSecond;
else /* if negative interpret as seconds per call */
target = i * (-callsPerSecond);
target = (startTime + target) - now;
if (target > 0)
IOMGR_Sleep(target);
}
}