afs_int32
SBOZO_ReBozo(struct rx_call *acall)
{
afs_int32 code;
char caller[MAXKTCNAMELEN];
/* acall is null if called internally to restart bosserver */
if (acall && !afsconf_SuperUser(bozo_confdir, acall, caller)) {
code = BZACCESS;
goto fail;
}
if (DoLogging)
bozo_Log("%s is executing ReBozo\n", caller);
/* start shutdown of all processes */
code = bnode_ApplyInstance(sdproc, NULL);
if (code)
goto fail;
/* wait for all done */
code = bnode_ApplyInstance(swproc, NULL);
if (code)
goto fail;
if (acall)
osi_auditU(acall, BOS_RebozoEvent, code, AUD_END);
else
osi_audit(BOS_RebozoIntEvent, code, AUD_END);
if (acall)
rx_EndCall(acall, 0); /* try to get it done */
rx_Finalize();
bozo_ReBozo(); /* this reexecs us, and doesn't return, of course */
fail:
/* Differentiate between external and internal ReBozo; prevents AFS_Aud_NoCall event */
if (acall)
osi_auditU(acall, BOS_RebozoEvent, code, AUD_END);
else
osi_audit(BOS_RebozoIntEvent, code, AUD_END);
return code; /* should only get here in unusual circumstances */
}
int
main(int argc, char **argv)
{
afs_int32 code;
struct cmd_syndesc *ts;
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
#endif
/* try to find volume location information */
ts = cmd_CreateSyntax(NULL, Twiddle, NULL, "adjust rx parms");
cmd_AddParm(ts, "-initReceiveWindow ", CMD_SINGLE, CMD_OPTIONAL, "16");
cmd_AddParm(ts, "-maxReceiveWindow ", CMD_SINGLE, CMD_OPTIONAL, "16");
cmd_AddParm(ts, "-initSendWindow ", CMD_SINGLE, CMD_OPTIONAL, "8");
cmd_AddParm(ts, "-maxSendWindow ", CMD_SINGLE, CMD_OPTIONAL, "16");
cmd_AddParm(ts, "-nSendFrags ", CMD_SINGLE, CMD_OPTIONAL, "4");
cmd_AddParm(ts, "-nRecvFrags ", CMD_SINGLE, CMD_OPTIONAL, "4");
cmd_AddParm(ts, "-OrphanFragSize ", CMD_SINGLE, CMD_OPTIONAL, "512");
cmd_AddParm(ts, "-maxReceiveSize ", CMD_SINGLE, CMD_OPTIONAL, "");
cmd_AddParm(ts, "-MyMaxSendSize ", CMD_SINGLE, CMD_OPTIONAL, "");
code = cmd_Dispatch(argc, argv);
if (rxInitDone)
rx_Finalize();
exit(code);
}
void *
bozo_ShutdownAndExit(void *param)
{
int asignal = (intptr_t)param;
int code;
bozo_Log
("Shutdown of BOS server and processes in response to signal %d\n",
asignal);
/* start shutdown of all processes */
if ((code = bnode_ApplyInstance(sdproc, NULL)) == 0) {
/* wait for shutdown to complete */
code = bnode_ApplyInstance(swproc, NULL);
}
if (code) {
bozo_Log("Shutdown incomplete (code = %d); manual cleanup required\n",
code);
}
rx_Finalize();
exit(code);
}
static void
sigint(int foo)
{
rx_Finalize();
exit(2); /* XXX profiler */
}
static void
do_client(const char *server, short port, char *filename, afs_int32 command,
afs_int32 times, afs_int32 bytes, afs_int32 sendbytes, afs_int32 readbytes,
int dumpstats, int nojumbo, int maxmtu, int maxwsize, int minpeertimeout,
int udpbufsz, int nostats, int hotthread, int threads)
{
struct rx_connection *conn;
afs_uint32 addr;
struct rx_securityClass *secureobj;
int secureindex;
int ret;
char stamp[2048];
struct client_data *params;
#ifdef AFS_PTHREAD_ENV
int i;
pthread_t thread[MAX_THREADS];
pthread_attr_t tattr;
void *status;
#endif
params = calloc(1, sizeof(struct client_data));
#ifdef AFS_NT40_ENV
if (afs_winsockInit() < 0) {
printf("Can't initialize winsock.\n");
exit(1);
}
#endif
if (hotthread)
rx_EnableHotThread();
if (nostats)
rx_enable_stats = 0;
addr = str2addr(server);
rx_SetUdpBufSize(udpbufsz);
ret = rx_Init(0);
if (ret)
errx(1, "rx_Init failed");
if (nojumbo)
rx_SetNoJumbo();
if (maxmtu)
rx_SetMaxMTU(maxmtu);
if (maxwsize) {
rx_SetMaxReceiveWindow(maxwsize);
rx_SetMaxSendWindow(maxwsize);
}
if (minpeertimeout)
rx_SetMinPeerTimeout(minpeertimeout);
get_sec(0, &secureobj, &secureindex);
switch (command) {
case RX_PERF_RPC:
sprintf(stamp, "RPC: threads\t%d, times\t%d, write bytes\t%d, read bytes\t%d",
threads, times, sendbytes, readbytes);
break;
case RX_PERF_RECV:
sprintf(stamp, "RECV: threads\t%d, times\t%d, bytes\t%d",
threads, times, bytes);
break;
case RX_PERF_SEND:
sprintf(stamp, "SEND: threads\t%d, times\t%d, bytes\t%d",
threads, times, bytes);
break;
case RX_PERF_FILE:
sprintf(stamp, "FILE %s: threads\t%d, times\t%d, bytes\t%d",
filename, threads, times, bytes);
break;
}
conn = rx_NewConnection(addr, htons(port), RX_SERVER_ID, secureobj, secureindex);
if (conn == NULL)
errx(1, "failed to contact server");
#ifdef AFS_PTHREAD_ENV
pthread_attr_init(&tattr);
pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_JOINABLE);
#endif
params->conn = conn;
params->filename = filename;
params->command = command;
params->times = times;
params->bytes = bytes;
params->sendbytes = sendbytes;
params->readbytes = readbytes;
start_timer();
#ifdef AFS_PTHREAD_ENV
for ( i=0; i<threads; i++) {
pthread_create(&thread[i], &tattr, client_thread, params);
if ( (i + 1) % RX_MAXCALLS == 0 ) {
conn = rx_NewConnection(addr, htons(port), RX_SERVER_ID, secureobj, secureindex);
if (conn != NULL) {
struct client_data *new_params = malloc(sizeof(struct client_data));
memcpy(new_params, params, sizeof(struct client_data));
new_params->conn = conn;
params = new_params;
}
}
}
#else
client_thread(params);
#endif
#ifdef AFS_PTHREAD_ENV
for ( i=0; i<threads; i++)
pthread_join(thread[i], &status);
#endif
switch (command) {
case RX_PERF_RPC:
end_and_print_timer(stamp, (long long)threads*times*(sendbytes+readbytes));
break;
case RX_PERF_RECV:
case RX_PERF_SEND:
case RX_PERF_FILE:
end_and_print_timer(stamp, (long long)threads*times*bytes);
break;
}
DBFPRINT(("done for good\n"));
if (dumpstats) {
rx_PrintStats(stdout);
rx_PrintPeerStats(stdout, rx_PeerOf(conn));
}
rx_Finalize();
#ifdef AFS_PTHREAD_ENV
pthread_attr_destroy(&tattr);
#endif
free(params);
}
afs_int32
ka_UserAuthenticateGeneral(afs_int32 flags, char *name, char *instance,
char *realm, char *password, Date lifetime,
afs_int32 * password_expires, /* days 'til, or don't change if not set */
afs_int32 spare2, char **reasonP)
{
int remainingTime = 0;
struct ktc_encryptionKey key;
afs_int32 code, dosetpag = 0;
if (reasonP)
*reasonP = "";
if ((flags & KA_USERAUTH_VERSION_MASK) != KA_USERAUTH_VERSION)
return KAOLDINTERFACE;
if ((strcmp(name, "root") == 0) && (instance == 0)) {
if (reasonP)
*reasonP = "root is only authenticated locally";
return KANOENT;
}
code = ka_Init(0);
if (code)
return code;
ka_StringToKey(password, realm, &key);
/*
* alarm is set by kpasswd only so ignore for
* NT
*/
#ifndef AFS_NT40_ENV
{ /* Rx uses timers, save to be safe */
if (rx_socket) {
/* don't reset alarms, rx already running */
remainingTime = 0;
} else
remainingTime = alarm(0);
}
#endif
#if !defined(AFS_NT40_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_USR_LINUX20_ENV) && (!defined(AFS_XBSD_ENV) || defined(AFS_FBSD_ENV))
/* handle smoothly the case where no AFS system calls exists (yet) */
(void)signal(SIGSYS, SIG_IGN);
#endif
#ifdef AFS_DECOSF_ENV
(void)signal(SIGTRAP, SIG_IGN);
#endif /* AFS_DECOSF_ENV */
if (instance == 0)
instance = "";
if (flags & KA_USERAUTH_ONLY_VERIFY) {
code = ka_VerifyUserToken(name, instance, realm, &key);
if (code == KABADREQUEST) {
DES_string_to_key(password, ktc_to_cblockptr(&key));
code = ka_VerifyUserToken(name, instance, realm, &key);
}
} else {
#ifdef AFS_DUX40_ENV
if (flags & KA_USERAUTH_DOSETPAG)
afs_setpag();
#else
#if !defined(UKERNEL) && !defined(AFS_NT40_ENV)
if (flags & KA_USERAUTH_DOSETPAG)
setpag();
#endif
#endif
if (flags & KA_USERAUTH_DOSETPAG2)
dosetpag = 1;
#ifdef AFS_KERBEROS_ENV
if ((flags & KA_USERAUTH_DOSETPAG) || dosetpag)
ktc_newpag();
#endif
if (lifetime == 0)
lifetime = MAXKTCTICKETLIFETIME;
code =
GetTickets(name, instance, realm, &key, lifetime,
password_expires, dosetpag);
if (code == KABADREQUEST) {
DES_string_to_key(password, ktc_to_cblockptr(&key));
code =
GetTickets(name, instance, realm, &key, lifetime,
password_expires, dosetpag);
}
}
#ifndef AFS_NT40_ENV
if (remainingTime) {
pr_End();
rx_Finalize();
alarm(remainingTime); /* restore timer, if any */
}
#endif
if (code && reasonP)
switch (code) {
case KABADREQUEST:
*reasonP = "password was incorrect";
break;
case KAUBIKCALL:
*reasonP = "Authentication Server was unavailable";
break;
default:
*reasonP = (char *)afs_error_message(code);
}
return code;
}
int
RunTheTest(struct cmd_syndesc *a_s, void *arock)
{ /*RunTheTest */
static char rn[] = "RunTheTest"; /*Routine name */
int code; /*Return code */
int numCMs; /*# Cache Managers to monitor */
int numCollIDs; /*# collections to fetch */
int currCM; /*Loop index */
int currCollIDIdx; /*Index of current collection ID */
afs_int32 *collIDP; /*Ptr to array of collection IDs */
afs_int32 *currCollIDP; /*Ptr to current collection ID */
struct cmd_item *curr_item; /*Current CM cmd line record */
struct sockaddr_in *CMSktArray; /*Cache Manager socket array */
struct hostent *he; /*Host entry */
int initFlags; /*Flags passed to the init fcn */
int freq; /*Frequency of polls */
int period; /*Time in minutes of data collection */
opr_softsig_Init();
/*
* Are we doing one-shot measurements?
*/
if (a_s->parms[P_ONESHOT].items != 0)
one_shot = 1;
/*
* Are we doing debugging output?
*/
if (a_s->parms[P_DEBUG].items != 0)
debugging_on = 1;
/*
* Pull out the number of Cache Managers to watch and the number of
* collections to get.
*/
numCMs = CountListItems(a_s->parms[P_CM_NAMES].items);
numCollIDs = CountListItems(a_s->parms[P_COLL_IDS].items);
/* Get the polling frequency */
if (a_s->parms[P_FREQUENCY].items != 0)
freq = atoi(a_s->parms[P_FREQUENCY].items->data);
else
freq = 30; /* default to 30 seconds */
/* Get the time duration to run the tests */
if (a_s->parms[P_PERIOD].items != 0)
period = atoi(a_s->parms[P_PERIOD].items->data);
else
period = 10; /* default to 10 minutes */
/*
* Allocate the socket array.
*/
if (debugging_on)
printf("%s: Allocating socket array for %d Cache Manager(s)\n", rn,
numCMs);
if (numCMs > 0) {
CMSktArray = calloc(numCMs, sizeof(struct sockaddr_in));
if (CMSktArray == NULL) {
printf("%s: Can't allocate socket array for %d Cache Managers\n",
rn, numCMs);
exit(1);
}
} else {
CMSktArray = NULL;
}
/*
* Fill in the socket array for each of the Cache Managers listed.
*/
curr_item = a_s->parms[P_CM_NAMES].items;
for (currCM = 0; currCM < numCMs; currCM++) {
CMSktArray[currCM].sin_family = AF_INET;
CMSktArray[currCM].sin_port = htons(7001); /* Cache Manager port */
he = hostutil_GetHostByName(curr_item->data);
if (he == NULL) {
fprintf(stderr, "[%s] Can't get host info for '%s'\n", rn,
curr_item->data);
exit(-1);
}
memcpy(&(CMSktArray[currCM].sin_addr.s_addr), he->h_addr, 4);
/*
* Move to the next CM name.
*/
curr_item = curr_item->next;
} /*Get socket info for each Cache Manager */
/*
* Create and fill up the array of desired collection IDs.
*/
if (debugging_on)
printf("Allocating %d long(s) for coll ID\n", numCollIDs);
if (numCollIDs > 0)
collIDP = calloc(numCollIDs, sizeof(afs_int32));
else
collIDP = NULL;
currCollIDP = collIDP;
curr_item = a_s->parms[P_COLL_IDS].items;
for (currCollIDIdx = 0; currCollIDIdx < numCollIDs; currCollIDIdx++) {
*currCollIDP = (afs_int32) (atoi(curr_item->data));
if (debugging_on)
printf("CollID at index %d is %d\n", currCollIDIdx, *currCollIDP);
curr_item = curr_item->next;
currCollIDP++;
};
/*
* Crank up the Cache Manager prober, then sit back and have fun.
*/
printf("\nStarting up the xstat_cm service, ");
initFlags = 0;
if (debugging_on) {
initFlags |= XSTAT_CM_INITFLAG_DEBUGGING;
printf("debugging enabled, ");
} else
printf("no debugging, ");
if (one_shot) {
initFlags |= XSTAT_CM_INITFLAG_ONE_SHOT;
printf("one-shot operation\n");
} else
printf("continuous operation\n");
code = xstat_cm_Init(numCMs, /*Num CMs */
CMSktArray, /*File Server socket array */
freq, /*Probe every 30 seconds */
CM_Handler, /*Handler routine */
initFlags, /*Initialization flags */
numCollIDs, /*Number of collection IDs */
collIDP); /*Ptr to collection ID array */
if (code) {
fprintf(stderr, "[%s] Error returned by xstat_cm_Init: %d\n", rn,
code);
xstat_cm_Cleanup(1); /*Get rid of malloc'ed structures */
exit(-1);
}
/* Wait for the collection complete. */
xstat_cm_Wait(60 * period);
/*
* We're all done. Clean up, put the last nail in Rx, then
* exit happily.
*/
if (debugging_on)
printf("\nYawn, main thread just woke up. Cleaning things out...\n");
xstat_cm_Cleanup(1); /*Get rid of malloc'ed data */
rx_Finalize();
return (0);
} /*RunTheTest */
int
main(int argc, char **argv)
{
char scell[MAXCELLCHARS], dcell[MAXCELLCHARS];
afs_uint32 ssrv, dsrv;
char *databuffer, *srcf = NULL, *destd = NULL, *destf = NULL, *destpath = NULL;
struct stat statbuf;
struct AFSStoreStatus sst;
struct AFSFetchStatus fst, dfst;
struct AFSVolSync vs;
struct AFSCallBack scb, dcb;
struct AFSFid sf, dd, df;
int filesz = 0;
int ch, blksize, bytesremaining, bytes;
struct timeval start, finish;
struct timezone tz;
struct rx_securityClass *ssc = 0, *dsc = 0;
int sscindex, dscindex;
struct rx_connection *sconn = NULL, *dconn = NULL;
struct rx_call *scall = NULL, *dcall = NULL;
int code = 0, fetchcode, storecode, printcallerrs = 0;
int slcl = 0, dlcl = 0, unlock = 0;
int sfd = 0, dfd = 0, unauth = 0;
struct AFSCBFids theFids;
struct AFSCBs theCBs;
blksize = 8 * 1024;
while ((ch = getopt(argc, argv, "iouUb:")) != -1) {
switch (ch) {
case 'b':
blksize = atoi(optarg);
break;
case 'i':
slcl = 1;
break;
case 'o':
dlcl = 1;
break;
case 'u':
unauth = 1;
break;
case 'U':
unlock = 1;
break;
default:
printf("Unknown option '%c'\n", ch);
exit(1);
}
}
if (argc - optind + unlock < 2) {
fprintf(stderr,
"Usage: afscp [-i|-o]] [-b xfersz] [-u] [-U] source [dest]\n");
fprintf(stderr, " -b Set block size\n");
fprintf(stderr, " -i Source is local (copy into AFS)\n");
fprintf(stderr, " -o Dest is local (copy out of AFS)\n");
fprintf(stderr, " -u Run unauthenticated\n");
fprintf(stderr, " -U Send an unlock request for source. (dest path not required)\n");
fprintf(stderr, "source and dest can be paths or specified as:\n");
fprintf(stderr, " @afs:cellname:servername:volume:vnode:uniq\n");
exit(1);
}
srcf = argv[optind++];
if (!unlock) {
destpath = argv[optind++];
destd = strdup(destpath);
if (!destd) {
perror("strdup");
exit(1);
}
if ((destf = strrchr(destd, '/'))) {
*destf++ = 0;
} else {
destf = destd;
destd = ".";
}
} else if (slcl) {
fprintf(stderr, "-i and -U cannot be used together\n");
}
if (!slcl && statfile(srcf, scell, &ssrv, &sf)) {
fprintf(stderr, "Cannot get attributes of %s\n", srcf);
exit(1);
}
if (!unlock && !dlcl && statfile(destd, dcell, &dsrv, &dd)) {
fprintf(stderr, "Cannot get attributes of %s\n", destd);
exit(1);
}
if ((databuffer = malloc(blksize)) == NULL) {
perror("malloc");
exit(1);
}
if (do_rx_Init())
exit(1);
if (start_cb_server()) {
printf("Cannot start callback service\n");
goto Fail_rx;
}
if (!slcl) {
sscindex = scindex_RXKAD;
if (unauth || (ssc = get_sc(scell)) == NULL) {
ssc = rxnull_NewClientSecurityObject();
sscindex = scindex_NULL;
/*printf("Cannot get authentication for cell %s; running unauthenticated\n", scell); */
}
sscindex = scindex_NULL;
if ((sconn =
rx_NewConnection(ssrv, htons(AFSCONF_FILEPORT), 1, ssc,
sscindex))
== NULL) {
struct in_addr s;
s.s_addr = ssrv;
printf("Cannot initialize rx connection to source server (%s)\n",
inet_ntoa(s));
goto Fail_sc;
}
}
if (!dlcl && !unlock) {
if (!slcl && ssrv == dsrv) {
dconn = sconn;
dsc = NULL;
} else {
if (slcl || strcmp(scell, dcell)) {
dscindex = scindex_RXKAD;
if (unauth || (dsc = get_sc(dcell)) == NULL) {
dsc = rxnull_NewClientSecurityObject();
dscindex = scindex_NULL;
/*printf("Cannot get authentication for cell %s; running unauthenticated\n", dcell); */
}
dscindex = scindex_NULL;
} else {
dsc = ssc;
dscindex = sscindex;
}
if ((dconn =
rx_NewConnection(dsrv, htons(AFSCONF_FILEPORT), 1, dsc,
dscindex))
== NULL) {
struct in_addr s;
s.s_addr = dsrv;
printf
("Cannot initialize rx connection to dest server (%s)\n",
inet_ntoa(s));
goto Fail_sconn;
}
}
}
memset(&sst, 0, sizeof(struct AFSStoreStatus));
if (dlcl && !unlock) {
dfd = open(destpath, O_RDWR | O_CREAT | O_EXCL, 0666);
if (dfd < 0 && errno == EEXIST) {
printf("%s already exists, overwriting\n", destpath);
dfd = open(destpath, O_RDWR | O_TRUNC, 0666);
if (dfd < 0) {
fprintf(stderr, "Cannot open %s (%s)\n", destpath,
afs_error_message(errno));
goto Fail_dconn;
}
} else if (dfd < 0) {
fprintf(stderr, "Cannot open %s (%s)\n", destpath,
afs_error_message(errno));
goto Fail_dconn;
}
} else if (!unlock) {
if ((code =
RXAFS_CreateFile(dconn, &dd, destf, &sst, &df, &fst, &dfst, &dcb,
&vs))) {
if (code == EEXIST) {
printf("%s already exits, overwriting\n", destpath);
if (statfile(destpath, dcell, &dsrv, &df))
fprintf(stderr, "Cannot get attributes of %s\n",
destpath);
else
code = 0;
} else {
printf("Cannot create %s (%s)\n", destpath,
afs_error_message(code));
if (code)
goto Fail_dconn;
}
}
}
if (slcl) {
sfd = open(srcf, O_RDONLY, 0);
if (sfd < 0) {
fprintf(stderr, "Cannot open %s (%s)\n", srcf,
afs_error_message(errno));
goto Fail_dconn;
}
if (fstat(sfd, &statbuf) < 0) {
fprintf(stderr, "Cannot stat %s (%s)\n", srcf,
afs_error_message(errno));
close(sfd);
goto Fail_dconn;
}
} else {
if ((code = RXAFS_FetchStatus(sconn, &sf, &fst, &scb, &vs))) {
printf("Cannot fetchstatus of %d.%d (%s)\n", sf.Volume, sf.Vnode,
afs_error_message(code));
goto Fail_dconn;
}
}
if (slcl) {
filesz = statbuf.st_size;
} else {
filesz = fst.Length;
}
printcallerrs = 0;
fetchcode = 0;
storecode = 0;
if (!slcl && !unlock)
scall = rx_NewCall(sconn);
if (!dlcl && !unlock)
dcall = rx_NewCall(dconn);
gettimeofday(&start, &tz);
if (unlock) {
if (fst.lockCount) {
printf("Sending 1 unlock for %s (%d locks)\n", srcf, fst.lockCount);
if ((code = RXAFS_ReleaseLock(sconn, &sf, &vs))) {
printf("Unable to unlock %s (%s)\n", srcf,
afs_error_message(code));
}
} else {
printf("No locks for %s\n", srcf);
}
fetchcode = code;
goto Finish;
}
if (!slcl) {
if ((code = StartRXAFS_FetchData(scall, &sf, 0, filesz))) {
printf("Unable to fetch data from %s (%s)\n", srcf,
afs_error_message(code));
goto Fail_call;
}
}
if (!dlcl) {
if (slcl) {
sst.Mask = AFS_SETMODTIME | AFS_SETMODE;
sst.ClientModTime = statbuf.st_mtime;
sst.UnixModeBits =
statbuf.st_mode & ~(S_IFMT | S_ISUID | S_ISGID);
} else {
sst.Mask = AFS_SETMODTIME | AFS_SETMODE;
sst.ClientModTime = fst.ClientModTime;
sst.UnixModeBits =
fst.UnixModeBits & ~(S_IFMT | S_ISUID | S_ISGID);
}
if ((code =
StartRXAFS_StoreData(dcall, &df, &sst, 0, filesz, filesz))) {
printf("Unable to store data to %s (%s)\n", destpath,
afs_error_message(code));
goto Fail_call;
}
}
if (slcl) {
bytesremaining = statbuf.st_size;
} else {
rx_Read(scall, (char *)&bytesremaining, sizeof(afs_int32));
bytesremaining = ntohl(bytesremaining);
}
while (bytesremaining > 0) {
/*printf("%d bytes remaining\n",bytesremaining); */
if (slcl) {
if ((bytes =
read(sfd, databuffer, min(blksize, bytesremaining))) <= 0) {
fetchcode = errno;
break;
}
} else {
if ((bytes =
rx_Read(scall, databuffer,
min(blksize, bytesremaining))) <= 0)
break;
}
if (dlcl) {
if (write(dfd, databuffer, bytes) != bytes) {
storecode = errno;
break;
}
} else {
if (rx_Write(dcall, databuffer, bytes) != bytes)
break;
}
bytesremaining -= bytes;
/*printf("%d bytes copied\n",bytes); */
}
if (bytesremaining > 0) {
printf("Some network error occured while copying data\n");
goto Fail_call;
}
if (!slcl)
fetchcode = EndRXAFS_FetchData(scall, &fst, &scb, &vs);
if (!dlcl)
storecode = EndRXAFS_StoreData(dcall, &fst, &vs);
printcallerrs = 1;
Fail_call:
if (slcl) {
if (close(sfd) && !fetchcode)
fetchcode = errno;
} else {
fetchcode = rx_EndCall(scall, fetchcode);
}
if (fetchcode && printcallerrs)
printf("Error returned from fetch: %s\n", afs_error_message(fetchcode));
if (dlcl) {
if (close(dfd) && !storecode)
storecode = errno;
} else if (!unlock) {
storecode = rx_EndCall(dcall, storecode);
}
if (storecode && printcallerrs)
printf("Error returned from store: %s\n", afs_error_message(storecode));
Finish:
gettimeofday(&finish, &tz);
if (!slcl) {
theFids.AFSCBFids_len = 1;
theFids.AFSCBFids_val = &sf;
theCBs.AFSCBs_len = 1;
theCBs.AFSCBs_val = &scb;
scb.CallBackType = CB_DROPPED;
if ((code = RXAFS_GiveUpCallBacks(sconn, &theFids, &theCBs)))
printf("Could not give up source callback: %s\n",
afs_error_message(code));
}
if (!dlcl) {
theFids.AFSCBFids_len = 1;
theFids.AFSCBFids_val = &df;
theCBs.AFSCBs_len = 1;
theCBs.AFSCBs_val = &dcb;
dcb.CallBackType = CB_DROPPED;
if ((code = RXAFS_GiveUpCallBacks(dconn, &theFids, &theCBs)))
printf("Could not give up target callback: %s\n",
afs_error_message(code));
}
if (code == 0)
code = storecode;
if (code == 0)
code = fetchcode;
Fail_dconn:
if (!dlcl && !unlock && (slcl || dconn != sconn))
rx_DestroyConnection(dconn);
Fail_sconn:
if (!slcl)
rx_DestroyConnection(sconn);
Fail_sc:
if (dsc && dsc != ssc)
RXS_Close(dsc);
if (ssc)
RXS_Close(ssc);
Fail_rx:
rx_Finalize();
free(databuffer);
if (printcallerrs && !unlock) {
double rate, size, time;
if (finish.tv_sec == start.tv_sec) {
printf("Copied %d bytes in %d microseconds\n", filesz,
(int)(finish.tv_usec - start.tv_usec));
} else {
printf("Copied %d bytes in %d seconds\n", filesz,
(int)(finish.tv_sec - start.tv_sec));
}
size = filesz / 1024.0;
time =
finish.tv_sec - start.tv_sec + (finish.tv_usec -
start.tv_usec) / 1e+06;
rate = size / time;
printf("Transfer rate %g Kbytes/sec\n", rate);
}
exit(code != 0);
}
long
rxkst_StartClient(struct clientParms *parms)
{
long code;
long host;
long scIndex;
struct rx_securityClass *sc;
whoami = parms->whoami; /* set this global variable */
host = GetServer(parms->server);
if (parms->authentication >= 0) {
long kvno = 0;
char ticket[MAXKTCTICKETLEN];
int ticketLen;
struct ktc_encryptionKey Ksession;
if (parms->useTokens)
code =
GetToken(&kvno, &Ksession, &ticketLen, ticket, parms->cell);
else
code =
GetTicket(&kvno, &Ksession, &ticketLen, ticket, parms->cell);
if (code)
return code;
/* next, we have ticket, kvno and session key, authenticate the conn */
sc = (struct rx_securityClass *)
rxkad_NewClientSecurityObject(parms->authentication, &Ksession,
kvno, ticketLen, ticket);
assert(sc);
scIndex = RX_SECIDX_KAD;
} else {
/* unauthenticated connection */
sc = rxnull_NewClientSecurityObject();
assert(sc);
scIndex = RX_SECIDX_NULL;
}
code = 0;
if (!code && parms->callTest) {
code = RunCallTest(parms, host, sc, scIndex);
}
if (!code && parms->hijackTest) {
code = RunHijackTest(parms, host, sc, scIndex);
}
if (!code
&& (parms->printTiming || parms->fastCalls || parms->slowCalls
|| parms->copiousCalls)) {
struct rx_connection *conn;
conn =
rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID,
sc, scIndex);
if (conn) {
code = RepeatLoadTest(parms, conn);
rx_DestroyConnection(conn);
} else
code = RXKST_NEWCONNFAILED;
}
if (!code && parms->stopServer) {
struct rx_connection *conn;
conn =
rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID,
sc, scIndex);
if (conn) {
code = RXKST_Kill(conn);
if (code) {
afs_com_err(whoami, code, "trying to stop server");
}
rx_DestroyConnection(conn);
} else
code = RXKST_NEWCONNFAILED;
}
if (parms->printStats) {
rx_PrintStats(stdout);
#if 0
/* use rxdebug style iteration here */
rx_PrintPeerStats(stdout, rx_PeerOf(conn));
#endif
}
rxs_Release(sc);
rx_Finalize();
if (code) {
afs_com_err(parms->whoami, code, "test fails");
exit(13);
} else {
printf("Test Okay\n");
if (!parms->noExit)
exit(0);
}
return 0;
}
int
main(int argc, char **argv)
{ /*Main routine */
static char rn[] = "fsprobe_test"; /*Routine name */
afs_int32 code; /*Return code */
struct sockaddr_in FSSktArray[3]; /*socket array */
struct hostent *he; /*Host entry */
int sleep_secs; /*Number of seconds to sleep */
printf("\n\nTest of the fsprobe facility.\n\n");
/*
* Fill in the socket array for bigbird, vice1, and vice2.
*/
FSSktArray[0].sin_family = AF_INET;
FSSktArray[0].sin_port = htons(7000); /* FileServer port */
he = hostutil_GetHostByName("servername1");
if (he == NULL) {
fprintf(stderr, "[%s] Can't get host info for servername1\n", rn);
exit(-1);
}
memcpy(&(FSSktArray[0].sin_addr.s_addr), he->h_addr, 4);
FSSktArray[1].sin_family = AF_INET;
FSSktArray[1].sin_port = htons(7000); /* FileServer port */
he = hostutil_GetHostByName("servername2");
if (he == NULL) {
fprintf(stderr, "[%s] Can't get host info for servername2\n", rn);
exit(-1);
}
memcpy(&(FSSktArray[1].sin_addr.s_addr), he->h_addr, 4);
FSSktArray[2].sin_family = AF_INET;
FSSktArray[2].sin_port = htons(7000); /* FileServer port */
he = hostutil_GetHostByName("servername3");
if (he == NULL) {
fprintf(stderr, "[%s] Can't get host info for servername3\n", rn);
exit(-1);
}
memcpy(&(FSSktArray[2].sin_addr.s_addr), he->h_addr, 4);
printf("Sockets for the 3 AFS FileServers to be probed:\n");
printf("\t Host servername1: IP addr 0x%x, port %d\n",
FSSktArray[0].sin_addr.s_addr, FSSktArray[0].sin_port);
printf("\t Host servername2: IP addr 0x%x, port %d\n",
FSSktArray[1].sin_addr.s_addr, FSSktArray[1].sin_port);
printf("\t Host servername3: IP addr 0x%x, port %d\n",
FSSktArray[2].sin_addr.s_addr, FSSktArray[2].sin_port);
/*
* Crank up the FileServer prober, then sit back and have fun.
*/
printf("Starting up the fsprobe service\n");
code = fsprobe_Init(3, /*Num servers */
FSSktArray, /*FileServer socket array */
30, /*Probe every 30 seconds */
FS_Handler, /*Handler routine */
1); /*Turn debugging output on */
if (code) {
fprintf(stderr, "[%s] Error returned by fsprobe_Init: %d\n", rn,
code);
fsprobe_Cleanup(1); /*Get rid of malloc'ed structures */
exit(-1);
}
sleep_secs = 60 * 10; /*Allow 10 minutes of data collection */
printf
("Fsprobe service started, main thread sleeping for %d seconds...\n",
sleep_secs);
fsprobe_Wait(sleep_secs);
/*
* We're all done. Clean up, put the last nail in Rx, then
* exit happily.
*/
printf("Yawn, main thread just woke up. Cleaning things out...\n");
code = fsprobe_Cleanup(1); /*Get rid of malloc'ed data */
rx_Finalize();
exit(0);
} /*Main routine */
static
void probeComplete()
{
fsprobe_Cleanup(1);
rx_Finalize();
}
int
CommandProc(struct cmd_syndesc *as, void *arock)
{
char name[MAXKTCNAMELEN] = "";
char instance[MAXKTCNAMELEN] = "";
char cell[MAXKTCREALMLEN] = "";
char realm[MAXKTCREALMLEN] = "";
afs_int32 serverList[MAXSERVERS];
char *lcell; /* local cellname */
int code;
int i;
struct ubik_client *conn = 0;
struct ktc_encryptionKey key;
struct ktc_encryptionKey mitkey;
struct ktc_encryptionKey newkey;
struct ktc_encryptionKey newmitkey;
struct ktc_token token;
struct passwd pwent;
struct passwd *pw = &pwent;
int insist; /* insist on good password quality */
int lexplicit = 0; /* servers specified explicitly */
int local; /* explicit cell is same a local cell */
int foundPassword = 0; /*Not yet, anyway */
int foundNewPassword = 0; /*Not yet, anyway */
int foundExplicitCell = 0; /*Not yet, anyway */
#ifdef DEFAULT_MITV4_STRINGTOKEY
int dess2k = 1;
#elif DEFAULT_AFS_STRINGTOKEY
int dess2k = 0;
#else
int dess2k = -1;
#endif
/* blow away command line arguments */
for (i = 1; i < zero_argc; i++)
memset(zero_argv[i], 0, strlen(zero_argv[i]));
zero_argc = 0;
/* first determine quiet flag based on -pipe switch */
Pipe = (as->parms[aPIPE].items ? 1 : 0);
#if TIMEOUT
signal(SIGALRM, timedout);
alarm(30);
#endif
code = ka_Init(0);
if (code || !(lcell = ka_LocalCell())) {
#ifndef AFS_FREELANCE_CLIENT
if (!Pipe)
afs_com_err(rn, code, "Can't get local cell name!");
exit(1);
#endif
}
code = rx_Init(0);
if (code) {
if (!Pipe)
afs_com_err(rn, code, "Failed to initialize Rx");
exit(1);
}
strcpy(instance, "");
/* Parse our arguments. */
if (as->parms[aCELL].items) {
/*
* cell name explicitly mentioned; take it in if no other cell name
* has already been specified and if the name actually appears. If
* the given cell name differs from our own, we don't do a lookup.
*/
foundExplicitCell = 1;
strncpy(realm, as->parms[aCELL].items->data, sizeof(realm));
}
if (as->parms[aSERVERS].items) {
/* explicit server list */
int i;
struct cmd_item *ip;
char *ap[MAXSERVERS + 2];
for (ip = as->parms[aSERVERS].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) {
if (!Pipe)
afs_com_err(rn, code, "could not parse server list");
return code;
}
lexplicit = 1;
}
if (as->parms[aPRINCIPAL].items) {
ka_ParseLoginName(as->parms[aPRINCIPAL].items->data, name, instance,
cell);
if (strlen(instance) > 0)
if (!Pipe)
fprintf(stderr,
"Non-null instance (%s) may cause strange behavior.\n",
instance);
if (strlen(cell) > 0) {
if (foundExplicitCell) {
if (!Pipe)
fprintf(stderr,
"%s: May not specify an explicit cell twice.\n",
rn);
return -1;
}
foundExplicitCell = 1;
strncpy(realm, cell, sizeof(realm));
}
pw->pw_name = name;
} else {
/* No explicit name provided: use Unix uid. */
#ifdef AFS_NT40_ENV
userNameLen = 128;
if (GetUserName(userName, &userNameLen) == 0) {
if (!Pipe) {
fprintf(stderr,
"Can't figure out your name in local cell %s from your user id.\n",
lcell);
fprintf(stderr, "Try providing the user name.\n");
}
exit(1);
}
pw->pw_name = userName;
#else
pw = getpwuid(getuid());
if (pw == 0) {
if (!Pipe) {
fprintf(stderr,
"Can't figure out your name in local cell %s from your user id.\n",
lcell);
fprintf(stderr, "Try providing the user name.\n");
}
exit(1);
}
#endif
}
if (as->parms[aPASSWORD].items) {
/*
* Current argument is the desired password string. Remember it in
* our local buffer, and zero out the argument string - anyone can
* see it there with ps!
*/
foundPassword = 1;
strncpy(passwd, as->parms[aPASSWORD].items->data, sizeof(passwd));
memset(as->parms[aPASSWORD].items->data, 0,
strlen(as->parms[aPASSWORD].items->data));
}
if (as->parms[aNEWPASSWORD].items) {
/*
* Current argument is the new password string. Remember it in
* our local buffer, and zero out the argument string - anyone can
* see it there with ps!
*/
foundNewPassword = 1;
strncpy(npasswd, as->parms[aNEWPASSWORD].items->data,
sizeof(npasswd));
memset(as->parms[aNEWPASSWORD].items->data, 0,
strlen(as->parms[aNEWPASSWORD].items->data));
}
#ifdef AFS_FREELANCE_CLIENT
if (!foundExplicitCell && !lcell) {
if (!Pipe)
afs_com_err(rn, code, "no cell name provided");
exit(1);
}
#else
if (!foundExplicitCell)
strcpy(realm, lcell);
#endif /* freelance */
if ((code = ka_CellToRealm(realm, realm, &local))) {
if (!Pipe)
afs_com_err(rn, code, "Can't convert cell to realm");
exit(1);
}
lcstring(cell, realm, sizeof(cell));
ka_PrintUserID("Changing password for '", pw->pw_name, instance, "'");
printf(" in cell '%s'.\n", cell);
/* Get the password if it wasn't provided. */
if (!foundPassword) {
if (Pipe)
getpipepass(passwd, sizeof(passwd));
else {
code = read_pass(passwd, sizeof(passwd), "Old password: "******"reading password");
exit(1);
}
}
}
ka_StringToKey(passwd, realm, &key);
des_string_to_key(passwd, ktc_to_cblockptr(&mitkey));
give_to_child(passwd);
/* Get new password if it wasn't provided. */
insist = 0;
if (!foundNewPassword) {
if (Pipe)
getpipepass(npasswd, sizeof(npasswd));
else {
do {
code =
read_pass(npasswd, sizeof(npasswd),
"New password (RETURN to abort): ", 0);
if (code || (strlen(npasswd) == 0)) {
if (code)
code = KAREADPW;
goto no_change;
}
} while (password_bad(npasswd));
code =
read_pass(verify, sizeof(verify), "Retype new password: "******"Mismatch - ");
goto no_change;
}
memset(verify, 0, sizeof(verify));
}
}
if ((code = password_bad(npasswd))) { /* assmt here! */
goto no_change_no_msg;
}
#if TRUNCATEPASSWORD
if (strlen(npasswd) > 8) {
npasswd[8] = 0;
fprintf(stderr,
"%s: password too long, only the first 8 chars will be used.\n",
rn);
} else
npasswd[8] = 0; /* in case the password was exactly 8 chars long */
#endif
ka_StringToKey(npasswd, realm, &newkey);
des_string_to_key(npasswd, ktc_to_cblockptr(&newmitkey));
memset(npasswd, 0, sizeof(npasswd));
if (lexplicit)
ka_ExplicitCell(realm, serverList);
/* Get an connection to kaserver's admin service in desired cell. Set the
* lifetime above the time uncertainty so that badly skewed clocks are
* reported when the ticket is decrypted. Then give us 10 seconds to
* actually get our work done if the clocks are skewed by only 14:59.
* NOTE: Kerberos lifetime encoding will round this up to next 5 minute
* interval, namely 20 minutes. */
#define ADMIN_LIFETIME (KTC_TIME_UNCERTAINTY+1)
code =
ka_GetAdminToken(pw->pw_name, instance, realm, &key, ADMIN_LIFETIME,
&token, /*!new */ 0);
if (code == KABADREQUEST) {
code =
ka_GetAdminToken(pw->pw_name, instance, realm, &mitkey,
ADMIN_LIFETIME, &token, /*!new */ 0);
if ((code == KABADREQUEST) && (strlen(passwd) > 8)) {
/* try with only the first 8 characters incase they set their password
* with an old style passwd program. */
char pass8[9];
strncpy(pass8, passwd, 8);
pass8[8] = 0;
ka_StringToKey(pass8, realm, &key);
memset(pass8, 0, sizeof(pass8));
memset(passwd, 0, sizeof(passwd));
code = ka_GetAdminToken(pw->pw_name, instance, realm, &key, ADMIN_LIFETIME, &token, /*!new */
0);
#ifdef notdef
/* the folks in testing really *hate* this message */
if (code == 0) {
fprintf(stderr,
"Warning: only the first 8 characters of your old password were significant.\n");
}
#endif
if (code == 0) {
if (dess2k == -1)
dess2k = 0;
}
} else {
if (dess2k == -1)
dess2k = 1;
}
} else {
if (dess2k == -1)
dess2k = 0;
}
memset(&mitkey, 0, sizeof(mitkey));
memset(&key, 0, sizeof(key));
if (code == KAUBIKCALL)
afs_com_err(rn, code, "(Authentication Server unavailable, try later)");
else if (code) {
if (code == KABADREQUEST)
fprintf(stderr, "%s: Incorrect old password.\n", rn);
else
afs_com_err(rn, code, "so couldn't change password");
} else {
code =
ka_AuthServerConn(realm, KA_MAINTENANCE_SERVICE, &token, &conn);
if (code)
afs_com_err(rn, code, "contacting Admin Server");
else {
if (dess2k == 1)
code =
ka_ChangePassword(pw->pw_name, instance, conn, 0,
&newmitkey);
else
code =
ka_ChangePassword(pw->pw_name, instance, conn, 0,
&newkey);
memset(&newkey, 0, sizeof(newkey));
memset(&newmitkey, 0, sizeof(newmitkey));
if (code) {
char *reason;
reason = (char *)afs_error_message(code);
fprintf(stderr, "%s: Password was not changed because %s\n",
rn, reason);
} else
printf("Password changed.\n\n");
}
}
memset(&newkey, 0, sizeof(newkey));
memset(&newmitkey, 0, sizeof(newmitkey));
/* Might need to close down the ubik_Client connection */
if (conn) {
ubik_ClientDestroy(conn);
conn = 0;
}
rx_Finalize();
terminate_child();
exit(code);
no_change: /* yuck, yuck, yuck */
if (code)
afs_com_err(rn, code, "getting new password");
no_change_no_msg:
memset(&key, 0, sizeof(key));
memset(npasswd, 0, sizeof(npasswd));
printf("Password for '%s' in cell '%s' unchanged.\n\n", pw->pw_name,
cell);
terminate_child();
exit(code ? code : 1);
}
