AFS
view release on metacpan or search on metacpan
m_addrp = (afs_int32 *) m_addrs.bulkaddrs_val;
for (j = 0; j < m_nentries; j++, m_addrp++) {
*m_addrp = htonl(*m_addrp);
#ifdef OpenAFS
if (noresolve) {
char hoststr[16];
sprintf(buf, "%s", afs_inet_ntoa_r(*m_addrp, hoststr));
av_push(IPs, newSVpv(buf, strlen(buf)));
}
else {
#endif
sprintf(buf, "%s", (char *) hostutil_GetNameByINet(*m_addrp));
av_push(names, newSVpv(buf, strlen(buf)));
#ifdef OpenAFS
}
#endif
} /* for loop */
if (j == 0) {
printf("<unknown>\n");
av_push(names, newSVpv(NULL, 0));
av_push(IPs, newSVpv(NULL, 0));
}
continue;
safe_hv_store(addr, "IP", 2, newRV_inc((SV *) (IPs)), 0);
safe_hv_store(addr, "name", 4, newRV_inc((SV *) (names)), 0);
}
}
/* Otherwise, it is a non-multihomed entry and contains
* the IP address of the server - print it.
*/
*addrp = htonl(*addrp);
#ifdef OpenAFS
if (noresolve) {
char hoststr[16];
sprintf(key, "IP-%d", j);
sprintf(buf, "%s", afs_inet_ntoa_r(*addrp, hoststr));
safe_hv_store(addr, key, 4, newSVpv(buf, strlen(buf)), 0);
}
else {
#endif
sprintf(key, "name-%d", j);
sprintf(buf, "%s", (char *) hostutil_GetNameByINet(*addrp));
safe_hv_store(addr, key, 6, newSVpv(buf, strlen(buf)), 0);
#ifdef OpenAFS
}
#endif
} /* for loop */
return;
}
static void GetServerAndPart(entry, voltype, server, part, previdx)
struct nvldbentry *entry;
afs_int32 *server, *part;
int voltype;
int *previdx;
{
int i, istart, vtype;
*server = -1;
*part = -1;
/* Doesn't check for non-existance of backup volume */
if ((voltype == RWVOL) || (voltype == BACKVOL)) {
vtype = ITSRWVOL;
istart = 0; /* seach the entire entry */
}
else {
vtype = ITSROVOL;
/* Seach from beginning of entry or pick up where we left off */
istart = ((*previdx < 0) ? 0 : *previdx + 1);
}
for (i = istart; i < entry->nServers; i++) {
if (entry->serverFlags[i] & vtype) {
*server = entry->serverNumber[i];
*part = entry->serverPartition[i];
*previdx = i;
return;
}
}
/* Didn't find any, return -1 */
*previdx = -1;
return;
}
/* end of helper functions for VLDB class */
/* helper functions for BOS class */
#ifndef OpenAFS
/* is this a digit or a digit-like thing? */
static int ismeta(ac, abase)
register int abase;
register int ac;
{
/* if (ac == '-' || ac == 'x' || ac == 'X') return 1; */
if (ac >= '0' && ac <= '7')
return 1;
if (abase <= 8)
return 0;
if (ac >= '8' && ac <= '9')
return 1;
if (abase <= 10)
return 0;
if (ac >= 'a' && ac <= 'f')
return 1;
if (ac >= 'A' && ac <= 'F')
return 1;
return 0;
}
/* given that this is a digit or a digit-like thing, compute its value */
static int getmeta(ac)
register int ac;
{
if (ac >= '0' && ac <= '9')
return ac - '0';
if (ac >= 'a' && ac <= 'f')
return ac - 'a' + 10;
if (ac >= 'A' && ac <= 'F')
return ac - 'A' + 10;
return 0;
}
afs_uint32 GetUInt32(as, aval)
register char *as;
afs_uint32 *aval;
{
register afs_uint32 total;
register int tc;
int base;
char *is1, *is2, *is3, *is4; /* instance strings */
char info[255];
tp = buffer;
code = BOZO_GetInstanceInfo(aconn, aname, &tp, &istatus);
if (code) {
char buf[256];
sprintf(buf, "AFS::BOS: failed to get instance info for '%s' (%s)\n",
aname, em(code));
BSETCODE(code, buf);
return -1;
}
if (firstTime && aint32p && (istatus.flags & BOZO_BADDIRACCESS)) {
char buf[256];
sprintf(buf, "Bosserver reports inappropriate access on server directories\n");
BSETCODE(-1, buf);
}
/*printf("Instance %s, ", aname); */
if (aint32p) {
/* printf("(type is %s) ", buffer); */
safe_hv_store(stats, "type", 4, newSVpv(buffer, strlen(buffer)), 0);
}
sprintf(info, "%s", "");
if (istatus.fileGoal == istatus.goal) {
if (!istatus.goal)
sprintf(info, "%s", "disabled");
}
else {
if (istatus.fileGoal)
sprintf(info, "%s", "temporarily disabled");
else
sprintf(info, "%s", "temporarily enabled");
}
safe_hv_store(stats, "info", 4, newSVpv(info, strlen(info)), 0);
safe_hv_store(stats, "goal", 4, newSViv(istatus.goal), 0);
safe_hv_store(stats, "fileGoal", 8, newSViv(istatus.fileGoal), 0);
if (istatus.flags & BOZO_ERRORSTOP) {
/* printf("stopped for too many errors, "); */
safe_hv_store(stats, "status", 6, newSViv(BOZO_ERRORSTOP), 0);
}
if (istatus.flags & BOZO_HASCORE) {
/* printf("has core file, "); */
safe_hv_store(stats, "status", 6, newSViv(BOZO_HASCORE), 0);
}
safe_hv_store(stats, "flags", 5, newSViv(istatus.flags), 0);
tp = buffer;
code = BOZO_GetStatus(aconn, aname, &temp, &tp);
if (code) {
char buf[256];
sprintf(buf, "AFS::BOS: failed to get status for instance '%s' (%s)\n",
aname, em(code));
BSETCODE(code, buf);
}
else {
/* printf("currently ", aname); */
/* if (temp == BSTAT_NORMAL) printf("running normally.\n"); */
/* else if (temp == BSTAT_SHUTDOWN) printf("shutdown.\n"); */
/* else if (temp == BSTAT_STARTINGUP) printf("starting up.\n"); */
/* else if (temp == BSTAT_SHUTTINGDOWN) printf("shutting down.\n"); */
safe_hv_store(stats, "status", 6, newSViv(temp), 0);
if (buffer[0] != 0) {
/* printf(" Auxiliary status is: %s.\n", buffer); */
safe_hv_store(stats, "aux_status", 10, newSVpv(buffer, strlen(buffer)), 0);
}
}
/* are we done yet? */
if (!aint32p)
return 0;
if (istatus.procStartTime) {
/* printf(" Process last started at %s (%d proc starts)\n", */
/* DateOf(istatus.procStartTime), istatus.procStarts); */
safe_hv_store(stats, "procStartTime", 13, newSViv(istatus.procStartTime), 0);
safe_hv_store(stats, "procStarts", 10, newSViv(istatus.procStarts), 0);
}
if (istatus.lastAnyExit) {
/* printf(" Last exit at %s\n", DateOf(istatus.lastAnyExit)); */
safe_hv_store(stats, "lastAnyExit", 11, newSViv(istatus.lastAnyExit), 0);
}
if (istatus.lastErrorExit) {
is1 = is2 = is3 = is4 = (char *) 0;
/* printf(" Last error exit at %s, ", DateOf(istatus.lastErrorExit)); */
safe_hv_store(stats, "lastErrorExit", 13, newSViv(istatus.lastErrorExit), 0);
code = BOZO_GetInstanceStrings(aconn, aname, &is1, &is2, &is3, &is4);
/* don't complain about failing call, since could simply mean
* interface mismatch.
*/
if (code == 0) {
if (*is1 != 0) {
/* non-null instance string */
/* printf("by %s, ", is1); */
safe_hv_store(stats, "by", 2, newSVpv(is1, strlen(is1)), 0);
}
if (is1)
free(is1);
if (is2)
free(is2);
if (is3)
free(is3);
if (is4)
free(is4);
}
if (istatus.errorSignal) {
/* if (istatus.errorSignal == SIGTERM) */
/* printf("due to shutdown request\n"); */
/* else */
/* printf("due to signal %d\n", istatus.errorSignal); */
safe_hv_store(stats, "errorSignal", 11, newSViv(istatus.errorSignal), 0);
}
else {
/* printf("by exiting with code %d\n", istatus.errorCode); */
safe_hv_store(stats, "errorCode", 9, newSViv(istatus.errorCode), 0);
}
}
if (aint32p > 1) {
AV *av = (AV *) sv_2mortal((SV *) newAV());
/* try to display all the parms */
for (i = 0;; i++) {
tp = buffer;
code = BOZO_GetInstanceParm(aconn, aname, i, &tp);
if (code)
break;
/* fprintf(stderr, " Command %d is '%s'\n", i+1, buffer); */
av_push(av, newSVpv(buffer, strlen(buffer)));
}
safe_hv_store(stats, "command", 7, newRV_inc((SV *) (av)), 0);
tp = buffer;
code = BOZO_GetInstanceParm(aconn, aname, 999, &tp);
/* add the orphans option if given */
if (orphans != (char *) 0) {
if ((strlen(tbuffer) + 10 + strlen(orphans) + 1) > BOZO_BSSIZE) {
char buffer[256];
sprintf(buffer, "AFS::BOS: command line too big\n");
BSETCODE(E2BIG, buffer);
return (E2BIG);
}
strcat(tbuffer, " -orphans ");
strcat(tbuffer, orphans);
}
if (mrafsParm.Optdebug)
strcat(tbuffer, " -debug");
if (mrafsParm.Optnowrite)
strcat(tbuffer, " -nowrite");
if (mrafsParm.Optforce)
strcat(tbuffer, " -force");
if (mrafsParm.Optoktozap)
strcat(tbuffer, " -oktozap");
if (mrafsParm.Optrootfiles)
strcat(tbuffer, " -rootfiles");
if (mrafsParm.Optsalvagedirs)
strcat(tbuffer, " -salvagedirs");
if (mrafsParm.Optblockreads)
strcat(tbuffer, " -blockreads");
if (mrafsParm.OptListResidencies)
strcat(tbuffer, " -ListResidencies");
if (mrafsParm.OptSalvageRemote)
strcat(tbuffer, " -SalvageRemote");
if (mrafsParm.OptSalvageArchival)
strcat(tbuffer, " -SalvageArchival");
if (mrafsParm.OptIgnoreCheck)
strcat(tbuffer, " -IgnoreCheck");
if (mrafsParm.OptForceOnLine)
strcat(tbuffer, " -ForceOnLine");
if (mrafsParm.OptUseRootDirACL)
strcat(tbuffer, " -UseRootDirACL");
if (mrafsParm.OptTraceBadLinkCounts)
strcat(tbuffer, " -TraceBadLinkCounts");
if (mrafsParm.OptDontAskFS)
strcat(tbuffer, " -DontAskFS");
if (mrafsParm.OptLogLevel) {
sprintf(pbuffer, " -LogLevel %d", mrafsParm.OptLogLevel);
strcat(tbuffer, pbuffer);
}
if (mrafsParm.OptRxDebug)
strcat(tbuffer, " -rxdebug");
if (mrafsParm.OptResidencies) {
sprintf(pbuffer, " -Residencies %u", mrafsParm.OptResidencies);
strcat(tbuffer, pbuffer);
}
parms[0] = tbuffer;
parms[1] = "now"; /* when to do it */
code = BOZO_CreateBnode(aconn, "cron", "salvage-tmp", parms[0], parms[1],
parms[2], parms[3], parms[4], notifier);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to start 'salvager' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
/* now wait for bnode to disappear */
while (1) {
#ifdef AFS_PTHREAD_ENV
sleep(5);
#else
IOMGR_Sleep(5);
#endif /* AFS_PTHREAD_ENV*/
tp = tbuffer;
code = BOZO_GetInstanceInfo(aconn, "salvage-tmp", &tp, &istatus);
if (code)
break;
/* fprintf(stderr, "AFS::BOS: waiting for salvage to complete.\n"); */
}
if (code != BZNOENT) {
char buffer[256];
sprintf(buffer, "AFS::BOS: salvage failed (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
code = 0;
/* now print the log file to the output file */
/* fprintf(stderr, "AFS::BOS: salvage completed\n"); */
if (aoutName || showlog) {
fprintf(outFile, "SalvageLog:\n");
tcall = rx_NewCall(aconn);
/* MUST pass canonical (wire-format) salvager log path to bosserver */
code = StartBOZO_GetLog(tcall, AFSDIR_CANONICAL_SERVER_SLVGLOG_FILEPATH);
if (code) {
rx_EndCall(tcall, code);
goto done;
}
/* copy data */
while (1) {
code = rx_Read(tcall, &buffer, 1);
if (code != 1)
break;
putc(buffer, outFile);
if (buffer == 0)
break; /* the end delimeter */
}
code = rx_EndCall(tcall, 0);
/* fall through into cleanup code */
}
done:
if (closeIt && outFile)
fclose(outFile);
return code;
}
/* end of helper functions for BOS class */
/* helper functions for FS class: */
static int32 isafs(path, follow)
char *path;
else if (status->Type == ReadWrite)
strcpy(type, "ReadWrite");
else
sprintf(type, "%d", status->Type);
safe_hv_store(stats, "Type", 4, newSVpv(type, strlen(type)), 0);
safe_hv_store(stats, "MinQuota", 8, newSViv(status->MinQuota), 0);
safe_hv_store(stats, "MaxQuota", 8, newSViv(status->MaxQuota), 0);
safe_hv_store(stats, "BlocksInUse", 11, newSViv(status->BlocksInUse), 0);
safe_hv_store(stats, "PartBlocksAvail", 15, newSViv(status->PartBlocksAvail), 0);
safe_hv_store(stats, "PartMaxBlocks", 13, newSViv(status->PartMaxBlocks), 0);
return 1;
}
/* end of helper functions for FS class: */
/* helper functions for KAS class: */
static int parse_kaentryinfo(stats, ka)
HV *stats;
struct kaentryinfo *ka;
{
char buffer[sizeof(struct kaident)];
sprintf(buffer, "%s%s%s", ka->modification_user.name,
ka->modification_user.instance[0] ? "." : "", ka->modification_user.instance);
safe_hv_store(stats, "modification_user", 17, newSVpv(buffer, strlen(buffer)), 0);
safe_hv_store(stats, "minor_version", 13, newSViv(ka->minor_version), 0);
safe_hv_store(stats, "flags", 5, newSViv(ka->flags), 0);
safe_hv_store(stats, "user_expiration", 15, newSViv(ka->user_expiration), 0);
safe_hv_store(stats, "modification_time", 17, newSViv(ka->modification_time), 0);
safe_hv_store(stats, "change_password_time", 20, newSViv(ka->change_password_time), 0);
safe_hv_store(stats, "max_ticket_lifetime", 19, newSViv(ka->max_ticket_lifetime), 0);
safe_hv_store(stats, "key_version", 11, newSViv(ka->key_version), 0);
safe_hv_store(stats, "keyCheckSum", 11, newSVuv(ka->keyCheckSum), 0);
safe_hv_store(stats, "misc_auth_bytes", 15, newSVuv(ka->misc_auth_bytes), 0);
safe_hv_store(stats, "passwd_reuse", 12, newSViv(ka->reserved3), 0);
/* 1234567890123456789012345 */
return 1;
}
static int parse_ka_getstats(stats, dstats, kas, kad)
HV *stats;
HV *dstats;
struct kasstats *kas;
struct kadstats *kad;
{
safe_hv_store(stats, "minor_version", 13, newSViv(kas->minor_version), 0);
safe_hv_store(stats, "allocs", 6, newSViv(kas->allocs), 0);
safe_hv_store(stats, "frees", 5, newSViv(kas->frees), 0);
safe_hv_store(stats, "cpws", 4, newSViv(kas->cpws), 0);
safe_hv_store(stats, "reserved1", 9, newSViv(kas->reserved1), 0);
safe_hv_store(stats, "reserved2", 9, newSViv(kas->reserved2), 0);
safe_hv_store(stats, "reserved3", 9, newSViv(kas->reserved3), 0);
safe_hv_store(stats, "reserved4", 9, newSViv(kas->reserved4), 0);
/* dynamic stats */
safe_hv_store(dstats, "minor_version", 13, newSViv(kad->minor_version), 0);
safe_hv_store(dstats, "host", 4, newSViv(kad->host), 0);
safe_hv_store(dstats, "start_time", 10, newSViv(kad->start_time), 0);
safe_hv_store(dstats, "hashTableUtilization", 20, newSViv(kad->hashTableUtilization), 0);
safe_hv_store(dstats, "string_checks", 13, newSViv(kad->string_checks), 0);
safe_hv_store(dstats, "reserved1", 9, newSViv(kad->reserved1), 0);
safe_hv_store(dstats, "reserved2", 9, newSViv(kad->reserved2), 0);
safe_hv_store(dstats, "reserved3", 9, newSViv(kad->reserved3), 0);
safe_hv_store(dstats, "reserved4", 9, newSViv(kad->reserved4), 0);
safe_hv_store(dstats, "Authenticate_requests", 21, newSViv(kad->Authenticate.requests), 0);
safe_hv_store(dstats, "Authenticate_aborts", 19, newSViv(kad->Authenticate.aborts), 0);
safe_hv_store(dstats, "ChangePassword_requests", 23,
newSViv(kad->ChangePassword.requests), 0);
safe_hv_store(dstats, "ChangePassword_aborts", 21, newSViv(kad->ChangePassword.aborts), 0);
safe_hv_store(dstats, "GetTicket_requests", 18, newSViv(kad->GetTicket.requests), 0);
safe_hv_store(dstats, "GetTicket_aborts", 16, newSViv(kad->GetTicket.aborts), 0);
safe_hv_store(dstats, "CreateUser_requests", 19, newSViv(kad->CreateUser.requests), 0);
safe_hv_store(dstats, "CreateUser_aborts", 17, newSViv(kad->CreateUser.aborts), 0);
safe_hv_store(dstats, "SetPassword_requests", 20, newSViv(kad->SetPassword.requests), 0);
safe_hv_store(dstats, "SetPassword_aborts", 18, newSViv(kad->SetPassword.aborts), 0);
safe_hv_store(dstats, "SetFields_requests", 18, newSViv(kad->SetFields.requests), 0);
safe_hv_store(dstats, "SetFields_aborts", 16, newSViv(kad->SetFields.aborts), 0);
safe_hv_store(dstats, "DeleteUser_requests", 19, newSViv(kad->DeleteUser.requests), 0);
safe_hv_store(dstats, "DeleteUser_aborts", 17, newSViv(kad->DeleteUser.aborts), 0);
safe_hv_store(dstats, "GetEntry_requests", 17, newSViv(kad->GetEntry.requests), 0);
safe_hv_store(dstats, "GetEntry_aborts", 15, newSViv(kad->GetEntry.aborts), 0);
safe_hv_store(dstats, "ListEntry_requests", 18, newSViv(kad->ListEntry.requests), 0);
safe_hv_store(dstats, "ListEntry_aborts", 16, newSViv(kad->ListEntry.aborts), 0);
safe_hv_store(dstats, "GetStats_requests", 17, newSViv(kad->GetStats.requests), 0);
safe_hv_store(dstats, "GetStats_aborts", 15, newSViv(kad->GetStats.aborts), 0);
safe_hv_store(dstats, "GetPassword_requests", 20, newSViv(kad->GetPassword.requests), 0);
safe_hv_store(dstats, "GetPassword_aborts", 18, newSViv(kad->GetPassword.aborts), 0);
safe_hv_store(dstats, "GetRandomKey_requests", 21, newSViv(kad->GetRandomKey.requests), 0);
safe_hv_store(dstats, "GetRandomKey_aborts", 19, newSViv(kad->GetRandomKey.aborts), 0);
safe_hv_store(dstats, "Debug_requests", 14, newSViv(kad->Debug.requests), 0);
safe_hv_store(dstats, "Debug_aborts", 12, newSViv(kad->Debug.aborts), 0);
safe_hv_store(dstats, "UAuthenticate_requests", 22,
newSViv(kad->UAuthenticate.requests), 0);
safe_hv_store(dstats, "UAuthenticate_aborts", 20, newSViv(kad->UAuthenticate.aborts), 0);
safe_hv_store(dstats, "UGetTicket_requests", 19, newSViv(kad->UGetTicket.requests), 0);
safe_hv_store(dstats, "UGetTicket_aborts", 17, newSViv(kad->UGetTicket.aborts), 0);
safe_hv_store(dstats, "Unlock_requests", 15, newSViv(kad->Unlock.requests), 0);
safe_hv_store(dstats, "Unlock_aborts", 13, newSViv(kad->Unlock.aborts), 0);
safe_hv_store(dstats, "LockStatus_requests", 19, newSViv(kad->LockStatus.requests), 0);
safe_hv_store(dstats, "LockStatus_aborts", 17, newSViv(kad->LockStatus.aborts), 0);
/* 1234567890123456789012345 */
return 1;
}
static int parse_ka_debugInfo(stats, ka)
HV *stats;
struct ka_debugInfo *ka;
{
char buff[1024];
int i;
safe_hv_store(stats, "lastOperation", 13,
newSVpv(ka->lastOperation, strlen(ka->lastOperation)), 0);
safe_hv_store(stats, "lastAuth", 7, newSVpv(ka->lastAuth, strlen(ka->lastAuth)), 0);
safe_hv_store(stats, "lastUAuth", 9, newSVpv(ka->lastUAuth, strlen(ka->lastUAuth)), 0);
safe_hv_store(stats, "lastTGS", 7, newSVpv(ka->lastTGS, strlen(ka->lastTGS)), 0);
safe_hv_store(stats, "lastUTGS", 8, newSVpv(ka->lastUTGS, strlen(ka->lastUTGS)), 0);
safe_hv_store(stats, "lastAdmin", 9, newSVpv(ka->lastAdmin, strlen(ka->lastAdmin)), 0);
safe_hv_store(stats, "lastTGSServer", 13,
newSVpv(ka->lastTGSServer, strlen(ka->lastTGSServer)), 0);
safe_hv_store(stats, "lastUTGSServer", 14,
newSVpv(ka->lastUTGSServer, strlen(ka->lastUTGSServer)), 0);
safe_hv_store(stats, "minorVersion", 12, newSViv(ka->minorVersion), 0);
safe_hv_store(stats, "host", 4, newSViv(ka->host), 0);
safe_hv_store(stats, "startTime", 9, newSViv(ka->startTime), 0);
safe_hv_store(stats, "noAuth", 6, newSViv(ka->noAuth), 0);
safe_hv_store(stats, "lastTrans", 9, newSViv(ka->lastTrans), 0);
safe_hv_store(stats, "nextAutoCPW", 11, newSViv(ka->nextAutoCPW), 0);
safe_hv_store(stats, "updatesRemaining", 16, newSViv(ka->updatesRemaining), 0);
safe_hv_store(stats, "dbHeaderRead", 12, newSViv(ka->dbHeaderRead), 0);
safe_hv_store(stats, "dbVersion", 9, newSViv(ka->dbVersion), 0);
safe_hv_store(stats, "dbFreePtr", 9, newSViv(ka->dbFreePtr), 0);
safe_hv_store(stats, "dbEofPtr", 8, newSViv(ka->dbEofPtr), 0);
safe_hv_store(stats, "dbKvnoPtr", 9, newSViv(ka->dbKvnoPtr), 0);
safe_hv_store(stats, "dbSpecialKeysVersion", 20, newSViv(ka->dbSpecialKeysVersion), 0);
safe_hv_store(stats, "cheader_lock", 12, newSViv(ka->cheader_lock), 0);
safe_hv_store(stats, "keycache_lock", 13, newSViv(ka->keycache_lock), 0);
safe_hv_store(stats, "kcVersion", 9, newSViv(ka->kcVersion), 0);
safe_hv_store(stats, "kcSize", 6, newSViv(ka->kcSize), 0);
safe_hv_store(stats, "reserved1", 9, newSViv(ka->reserved1), 0);
safe_hv_store(stats, "reserved2", 9, newSViv(ka->reserved2), 0);
safe_hv_store(stats, "reserved3", 9, newSViv(ka->reserved3), 0);
safe_hv_store(stats, "reserved4", 9, newSViv(ka->reserved4), 0);
if (ka->kcUsed > KADEBUGKCINFOSIZE) {
safe_hv_store(stats, "actual_kcUsed", 13, newSViv(ka->kcUsed), 0);
ka->kcUsed = KADEBUGKCINFOSIZE;
}
safe_hv_store(stats, "kcUsed", 6, newSViv(ka->kcUsed), 0);
for (i = 0; i < ka->kcUsed; i++) {
sprintf(buff, "kcInfo_used%d", i);
safe_hv_store(stats, buff, strlen(buff), newSViv(ka->kcInfo[i].used), 0);
sprintf(buff, "kcInfo_kvno%d", i);
safe_hv_store(stats, buff, strlen(buff), newSViv(ka->kcInfo[i].kvno), 0);
sprintf(buff, "kcInfo_primary%d", i);
safe_hv_store(stats, buff, strlen(buff),
newSViv((unsigned char) ka->kcInfo[i].primary), 0);
sprintf(buff, "kcInfo_keycksum%d", i);
safe_hv_store(stats, buff, strlen(buff),
newSViv((unsigned char) ka->kcInfo[i].keycksum), 0);
sprintf(buff, "kcInfo_principal%d", i);
safe_hv_store(stats, buff, strlen(buff),
newSVpv(ka->kcInfo[i].principal, strlen(ka->kcInfo[i].principal)), 0);
}
/* 1234567890123456789012345 */
return 1;
}
/* end of helper functions for KAS class: */
/************************ Start of XS stuff **************************/
/* PROTOTYPES: DISABLE added by leg@andrew, 10/7/96 */
MODULE = AFS PACKAGE = AFS PREFIX = fs_
if (code == 0) {
EXTEND(sp, 1);
PUSHs(sv_2mortal(newSVpv(p->instance, strlen(p->instance))));
}
}
void
ktcp_cell(p,cell=0)
AFS::KTC_PRINCIPAL p
char * cell
PPCODE:
{
int32 code = 0;
if (cell != 0) {
int clen = strlen(cell);
if (clen > MAXKTCREALMLEN - 1)
code = KABADNAME;
else
strcpy(p->cell, cell);
SETCODE(code);
}
if (code == 0) {
EXTEND(sp, 1);
PUSHs(sv_2mortal(newSVpv(p->cell, strlen(p->cell))));
}
}
void
ktcp_principal(p)
AFS::KTC_PRINCIPAL p
PPCODE:
{
int32 code = 0;
char buffer[MAXKTCNAMELEN + MAXKTCNAMELEN + MAXKTCREALMLEN + 3];
sprintf(buffer, "%s%s%s%s%s", p->name,
p->instance[0] ? "." : "", p->instance, p->cell[0] ? "@" : "", p->cell);
EXTEND(sp, 1);
PUSHs(sv_2mortal(newSVpv(buffer, strlen(buffer))));
SETCODE(code);
}
MODULE = AFS PACKAGE = AFS::KTC_TOKEN PREFIX = ktct_
int32
ktct_DESTROY(t)
AFS::KTC_TOKEN t
CODE:
{
if (t && t != &the_null_token) safefree(t);
# SETCODE(0); this spoils the ERROR code
RETVAL = 1;
}
OUTPUT:
RETVAL
int32
ktct_startTime(t)
AFS::KTC_TOKEN t
PPCODE:
{
EXTEND(sp,1);
PUSHs(sv_2mortal(newSViv(t->startTime)));
}
int32
ktct_endTime(t)
AFS::KTC_TOKEN t
PPCODE:
{
EXTEND(sp,1);
PUSHs(sv_2mortal(newSViv(t->endTime)));
}
int32
ktct_kvno(t)
AFS::KTC_TOKEN t
PPCODE:
{
EXTEND(sp,1);
PUSHs(sv_2mortal(newSViv(t->kvno)));
}
int32
ktct_ticketLen(t)
AFS::KTC_TOKEN t
PPCODE:
{
EXTEND(sp,1);
PUSHs(sv_2mortal(newSViv(t->ticketLen)));
}
void
ktct_ticket(t)
AFS::KTC_TOKEN t
PPCODE:
{
EXTEND(sp,1);
PUSHs(sv_2mortal(newSVpv(t->ticket,t->ticketLen)));
}
void
ktct_sessionKey(t)
AFS::KTC_TOKEN t
PPCODE:
{
struct ktc_encryptionKey *key;
SV *sv;
key = (struct ktc_encryptionKey *) safemalloc(sizeof(*key));
*key = t->sessionKey;
sv = sv_newmortal();
EXTEND(sp, 1);
sv_setref_pv(sv, "AFS::KTC_EKEY", (void *) key);
PUSHs(sv);
}
void
ktct_string(t)
AFS::KTC_TOKEN t
PPCODE:
{
EXTEND(sp,1);
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
int32
bos__create(self, name, type, object, notifier=NULL)
AFS::BOS self
char *name
char *type
SV *object
char *notifier
PREINIT:
int32 i, len, code = 0;
char *parms[6];
AV *av; SV *sv;
STRLEN namelen;
CODE:
{
if (SvTYPE(SvRV(object)) != SVt_PVAV) {
code = -1;
BSETCODE(code, "AFS::BOS COMMAND not an array reference\n");
goto done;
}
for (i = 0; i < 6; i++)
parms[i] = "";
av = (AV *) SvRV(object);
len = av_len(av);
if (len != -1) {
for (i = 0; i <= len && i < 6; i++) {
sv = *av_fetch(av, i, 0);
if (sv)
parms[i] = SvPV(sv, namelen);
}
}
if (notifier == NULL)
notifier = NONOTIFIER;
code = BOZO_CreateBnode(self, type, name, parms[0], parms[1], parms[2],
parms[3], parms[4], notifier);
if (code) {
char buffer[256];
sprintf(buffer,
"AFS::BOS: failed to create new server instance %s of type '%s' (%s)\n", name,
type, em(code));
BSETCODE(code, buffer);
goto done;
}
SETCODE(code);
done:
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
int32
bos__restart(self, bosserver=0, all=0, object=NULL)
AFS::BOS self
int bosserver
int all
SV *object
PREINIT:
int32 code = 0;
CODE:
{
if (bosserver) {
if (object != NULL) {
char buffer[256];
sprintf(buffer,
"AFS::BOS: can't specify both 'bosserver' and specific servers to restart.\n");
BSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
code = BOZO_ReBozo(self);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to restart bosserver (%s)\n", em(code));
BSETCODE(code, buffer);
}
RETVAL = (code == 0);
goto done;
}
if (object == NULL) {
if (all) {
code = BOZO_RestartAll(self);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to restart servers (%s)\n", em(code));
BSETCODE(code, buffer);
}
}
else {
char buffer[256];
sprintf(buffer, "AFS::BOS: To restart all processes please specify 'all'\n");
BSETCODE(-1, buffer);
}
RETVAL = (code == 0);
goto done;
}
else {
if (all) {
char buffer[256];
sprintf(buffer, "AFS::BOS: Can't use 'all' along with individual instances\n");
BSETCODE(-1, buffer);
RETVAL = 0;
goto done;
}
else {
AV *av;
SV *sv;
STRLEN namelen;
char *instance;
int i, len;
if (SvTYPE(SvRV(object)) != SVt_PVAV) {
BSETCODE(-1, "AFS::BOS: SERVER not an array reference\n");
RETVAL = 0;
goto done;
}
av = (AV *) SvRV(object);
len = av_len(av);
if (len != -1) {
for (i = 0; i <= len && i < 6; i++) {
sv = *av_fetch(av, i, 0);
if (sv) {
instance = (char *) safemalloc(BOZO_BSSIZE);
instance = SvPV(sv, namelen);
code = BOZO_Restart(self, instance);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to restart instance %s (%s)\n",
instance, em(code));
BSETCODE(code, buffer);
}
}
} /* for loop */
SETCODE(code);
RETVAL = (code == 0);
}
}
}
done:
;
}
OUTPUT:
RETVAL
int32
bos_setrestart(self, time, general=Nullsv, newbinary=Nullsv)
AFS::BOS self
char *time
SV * general
SV * newbinary
PREINIT:
int32 code = 0, count = 0;
struct ktime restartTime;
afs_int32 type;
int igeneral;
int inewbinary;
CODE:
{
if (!general) {
general = newSViv(0);
}
if (!SvIOKp(general)) {
char buffer[256];
sprintf(buffer, "AFS::BOS: Flag \"general\" should be numeric.\n");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
if (!newbinary) {
newbinary = newSViv(0);
}
if (!SvIOKp(newbinary)) {
char buffer[256];
sprintf(buffer, "AFS::BOS: Flag \"newbinary\" should be numeric.\n");
BSETCODE(-1, buffer);
XSRETURN_UNDEF;
}
igeneral = SvIV(general);
inewbinary = SvIV(newbinary);
if (igeneral) {
count++;
type = 1;
}
if (inewbinary) {
count++;
type = 2;
}
if (count > 1) {
char buffer[80];
sprintf(buffer, "AFS::BOS: can't specify more than one restart time at a time\n");
BSETCODE(-1, buffer);
goto done;
}
if (count == 0)
type = 1; /* by default set general restart time */
if (code = ktime_ParsePeriodic(time, &restartTime)) {
char buffer[240];
sprintf(buffer, "AFS::BOS: failed to parse '%s' as periodic restart time(%s)\n",
time, em(code));
BSETCODE(code, buffer);
goto done;
}
code = BOZO_SetRestartTime(self, type, &restartTime);
if (code) {
char buffer[240];
sprintf(buffer, "AFS::BOS: failed to set restart time at server (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
code = 0;
SETCODE(code);
done:
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
void
bos_getrestart(self)
AFS::BOS self
PREINIT:
int32 code = 0;
struct ktime generalTime, newBinaryTime;
char messageBuffer[256];
PPCODE:
{
code = BOZO_GetRestartTime(self, 1, &generalTime);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to retrieve restart information (%s)\n", em(code));
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
code = BOZO_GetRestartTime(self, 2, &newBinaryTime);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to retrieve restart information (%s)\n", em(code));
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
code = ktime_DisplayString(&generalTime, messageBuffer);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to decode restart time (%s)\n", em(code));
BSETCODE(code, buffer);
strcpy(messageBuffer, "");
}
XPUSHs(sv_2mortal(newSVpv(messageBuffer, strlen(messageBuffer))));
code = ktime_DisplayString(&newBinaryTime, messageBuffer);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to decode restart time (%s)\n", em(code));
BSETCODE(code, buffer);
strcpy(messageBuffer, "");
}
XPUSHs(sv_2mortal(newSVpv(messageBuffer, strlen(messageBuffer))));
XSRETURN(2);
}
void
bos_listusers(self)
AFS::BOS self
PREINIT:
int i;
int32 code = 0;
char tbuffer[256];
char *tp;
PPCODE:
{
for (i = 0;; i++) {
tp = tbuffer;
code = BOZO_ListSUsers(self, i, &tp);
if (code)
break;
XPUSHs(sv_2mortal(newSVpv(tbuffer, strlen(tbuffer))));
}
if (code != 1) {
/* a real error code, instead of scanned past end */
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to retrieve super-user list (%s)\n", em(code));
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
else {
SETCODE(0);
XSRETURN(i);
}
}
void
bos_listhosts(self)
AFS::BOS self
PREINIT:
int32 i, code = 0;
char tbuffer[256];
char *tp;
AV *av = (AV*)sv_2mortal((SV*)newAV());
PPCODE:
{
tp = tbuffer;
code = BOZO_GetCellName(self, &tp);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to get cell name (%s)\n", em(code));
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
/* printf("Cell name is %s\n", tbuffer); */
XPUSHs(sv_2mortal(newSVpv(tbuffer, strlen(tbuffer))));
/* printf("DEBUG-bos-delete-9 \n"); */
done:
RETVAL = (code == 0);
/* printf("DEBUG-bos-delete-10 \n"); */
/* if (name) */
/* Safefree(name); */
/* printf("DEBUG-bos-delete-11 \n"); */
}
OUTPUT:
RETVAL
void
bos_getlog(self, file)
AFS::BOS self
char* file
PREINIT:
register struct rx_call *tcall;
int32 code = 0;
char buf, c[255];
int error, num = 0, i = 0;
PPCODE:
{
tcall = rx_NewCall(self);
code = StartBOZO_GetLog(tcall, file);
if (code) {
char buffer[256];
rx_EndCall(tcall, code);
sprintf(buffer, "AFS::BOS error %d (while reading log)\n", code);
BSETCODE(code, buffer);
XSRETURN_UNDEF;
}
/* copy data */
error = 0;
while (1) {
code = rx_Read(tcall, &buf, 1);
if (code != 1) {
error = EIO;
break;
}
if (buf == 0)
break; /* the end delimeter */
/* putchar(buf); */
c[i++] = buf;
if (buf == '\n') {
XPUSHs(sv_2mortal(newSVpv(c, i)));
i = 0;
num++;
}
}
code = rx_EndCall(tcall, error);
#if (tcall)
# Safefree(tcall);
/* fall through into cleanup code */
XSRETURN(num);
}
int32
bos__start(self, object=NULL)
AFS::BOS self
SV * object
PREINIT:
int32 code = 0;
CODE:
{
if (object && (! (SvTYPE(SvRV(object)) == SVt_PVAV))) {
code = -1;
BSETCODE(code, "AFS::BOS: SERVER not an array reference\n");
goto done;
}
if (object && (SvTYPE(SvRV(object)) == SVt_PVAV)) {
AV *av;
SV *sv;
char *instance;
STRLEN namelen;
int i, len;
av = (AV *) SvRV(object);
len = av_len(av);
if (len != -1) {
for (i = 0; i <= len; i++) {
sv = *av_fetch(av, i, 0);
if (sv) {
/* instance = (char *) safemalloc(BOZO_BSSIZE); */
Newx(instance, BOZO_BSSIZE, char);
instance = SvPV(sv, namelen);
code = BOZO_SetStatus(self, instance, BSTAT_NORMAL);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to start instance %s (%s)\n",
instance, em(code));
BSETCODE(code, buffer);
goto done;
}
/*if (instance) */
/* Safefree(instance); */
}
} /* for loop */
}
}
SETCODE(code);
done:
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
int32
bos__startup(self, object=NULL)
AFS::BOS self
SV * object
PREINIT:
int32 code = 0;
CODE:
{
if (object && (! (SvTYPE(SvRV(object)) == SVt_PVAV))) {
code = -1;
BSETCODE(code, "AFS::BOS: SERVER not an array reference\n");
goto done;
}
if (object && (SvTYPE(SvRV(object)) == SVt_PVAV)) {
AV *av;
SV *sv;
char *instance;
STRLEN namelen;
int i, len;
av = (AV *) SvRV(object);
len = av_len(av);
if (len != -1) {
for (i = 0; i <= len; i++) {
sv = *av_fetch(av, i, 0);
if (sv) {
/* instance = (char *) safemalloc(BOZO_BSSIZE); */
Newx(instance, BOZO_BSSIZE, char);
instance = SvPV(sv, namelen);
code = BOZO_SetTStatus(self, instance, BSTAT_NORMAL);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to start instance %s (%s)\n",
instance, em(code));
BSETCODE(code, buffer);
goto done;
}
/*if (instance) */
/* Safefree(instance); */
}
} /* for loop */
}
}
else {
code = BOZO_StartupAll(self);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to startup servers (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
}
SETCODE(code);
done:
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
int32
bos__stop(self, object=NULL, wait=0)
AFS::BOS self
SV * object
int wait
PREINIT:
int32 code = 0;
CODE:
{
/* printf("DEBUG-XS-bos-stop-1 \n"); */
if (object && (! (SvTYPE(SvRV(object)) == SVt_PVAV))) {
code = -1;
BSETCODE(code, "AFS::BOS: SERVER not an array reference\n");
goto done;
}
/* printf("DEBUG-XS-bos-stop-2 \n"); */
if (object && (SvTYPE(SvRV(object)) == SVt_PVAV)) {
AV *av;
SV *sv;
char *instance;
STRLEN namelen;
int i, len;
/* printf("DEBUG-XS-bos-stop-3 \n"); */
av = (AV *) SvRV(object);
len = av_len(av);
if (len != -1) {
for (i = 0; i <= len; i++) {
sv = *av_fetch(av, i, 0);
if (sv) {
/* instance = (char *) safemalloc(BOZO_BSSIZE); */
Newx(instance, BOZO_BSSIZE, char);
instance = SvPV(sv, namelen);
/* printf("DEBUG-XS-bos-stop-3-1 %d %s\n", len, instance); */
code = BOZO_SetStatus(self, instance, BSTAT_SHUTDOWN);
/* printf("DEBUG-XS-bos-stop-3-2 %d \n", code); */
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to change stop instance %s (%s)\n",
instance, em(code));
BSETCODE(code, buffer);
goto done;
}
/*if (instance) */
/* Safefree(instance); */
}
} /* for loop */
sprintf(buffer,
"Can't specify -Residencies with -SalvageRemote or -SalvageArchival\n");
BSETCODE(EINVAL, buffer);
goto done;
}
/* muss naeher ueberprueft werden !!! */
/* #if defined(OpenAFS_1_2) */
/* code = GetUInt32(Residencies, &mrafsParm.OptResidencies); */
/* #else */
/* #if defined(OpenAFS_1_3) || defined(OpenAFS_1_4) || defined(OpenAFS_1_5) */
/* code = util_GetUInt32(Residencies, &mrafsParm.OptResidencies); */
/* #endif */
/* #endif */
/* if (code) { */
/* char buffer[256]; */
/* sprintf(buffer, "AFS::BOS: '%d' is not a valid residency mask.\n", TraceBadLinkCounts); /\* this doesn't really make sense to me AW *\/ */
/* BSETCODE(code, buffer); */
/* goto done; */
/* } */
/* muss naeher ueberprueft werden !!! */
mrafsParm.OptResidencies = Residencies;
}
}
else {
if (debug || nowrite || force || oktozap || rootfiles || salvagedirs || blockreads ||
ListResidencies || SalvageRemote || SalvageArchival || IgnoreCheck ||
ForceOnLine || UseRootDirACL || TraceBadLinkCounts || DontAskFS || LogLevel ||
rxdebug || Residencies) {
char buffer[256];
sprintf(buffer, "Parameter only possible for MR-AFS fileserver.\n");
BSETCODE(-1, buffer);
goto done;
}
}
if (all) {
/* salvage whole enchilada */
curGoal = GetServerGoal(self, "fs");
if (curGoal == BSTAT_NORMAL) {
fprintf(stderr, "AFS::BOS: shutting down fs.\n");
code = BOZO_SetTStatus(self, "fs", BSTAT_SHUTDOWN);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to stop 'fs' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
code = BOZO_WaitAll(self); /* wait for shutdown to complete */
if (code) {
char buffer[256];
sprintf(buffer,
"AFS::BOS: failed to wait for file server shutdown, continuing.\n");
BSETCODE(code, buffer);
}
}
/* now do the salvage operation */
/* fprintf(stderr, "Starting salvage of everything.\n"); */
rc = DoSalvage(self, (char *) 0, (char *) 0, outName, showlog, parallel, tmpDir,
orphans);
if (curGoal == BSTAT_NORMAL) {
/* fprintf(stderr, "AFS::BOS: restarting fs.\n"); */
code = BOZO_SetTStatus(self, "fs", BSTAT_NORMAL);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to restart 'fs' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
}
if (rc) {
code = rc;
goto done;
}
}
else if (!volume) {
if (!partition) {
char buffer[256];
sprintf(buffer, "AFS::BOS: must specify ALL switch to salvage all partitions.\n");
BSETCODE(-1, buffer);
goto done;
}
if (volutil_GetPartitionID(partition) < 0) {
/* can't parse volume ID, so complain before shutting down
* file server.
*/
char buffer[256];
sprintf(buffer, "AFS::BOS: can't interpret %s as partition ID.\n", partition);
BSETCODE(-1, buffer);
goto done;
}
curGoal = GetServerGoal(self, "fs");
/* salvage a whole partition (specified by parms[1]) */
if (curGoal == BSTAT_NORMAL) {
/* fprintf(stderr, "AFS::BOS: shutting down fs.\n"); */
code = BOZO_SetTStatus(self, "fs", BSTAT_SHUTDOWN);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: can't stop 'fs' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
code = BOZO_WaitAll(self); /* wait for shutdown to complete */
if (code) {
char buffer[256];
sprintf(buffer,
"AFS::BOS: failed to wait for file server shutdown, continuing.\n");
BSETCODE(code, buffer);
}
}
/* now do the salvage operation */
/* fprintf(stderr, "Starting salvage of partition %s.\n", partition); */
rc = DoSalvage(self, partition, (char *) 0,
outName, showlog, parallel, tmpDir, orphans);
if (curGoal == BSTAT_NORMAL) {
/* fprintf(stderr, "AFS::BOS: restarting fs.\n"); */
code = BOZO_SetTStatus(self, "fs", BSTAT_NORMAL);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to restart 'fs' (%s)\n", em(code));
BSETCODE(code, buffer);
goto done;
}
}
if (rc) {
code = rc;
goto done;
}
}
else {
/* salvage individual volume (don't shutdown fs first), just use
* single-shot cron bnode. Must leave server running when using this
* option, since salvager will ask file server for the volume */
afs_int32 err;
const char *confdir;
confdir = (localauth ? AFSDIR_SERVER_ETC_DIRPATH : AFSDIR_CLIENT_ETC_DIRPATH);
code = internal_vsu_ClientInit( /* noauth */ 1, confdir, tmpname,
/* server auth */ 0, &cstruct, (int (*)()) 0);
if (code == 0) {
newID = vsu_GetVolumeID(volume, cstruct, &err);
if (newID == 0) {
char buffer[256];
sprintf(buffer, "AFS::BOS: can't interpret %s as volume name or ID\n",
volume);
BSETCODE(-1, buffer);
goto done;
}
sprintf(tname, "%u", newID);
}
else {
char buffer[256];
sprintf(buffer,
"AFS::BOS: can't initialize volume system client (code %d), trying anyway.\n",
code);
BSETCODE(code, buffer);
strncpy(tname, volume, sizeof(tname));
}
if (volutil_GetPartitionID(partition) < 0) {
/* can't parse volume ID, so complain before shutting down
* file server.
*/
char buffer[256];
sprintf(buffer, "AFS::BOS: can't interpret %s as partition ID.\n", partition);
BSETCODE(-1, buffer);
goto done;
}
/* fprintf(stderr, "Starting salvage of volume %d on partition %s.\n",
newID, partition); */
rc = DoSalvage(self, partition, tname, outName, showlog, parallel, tmpDir, orphans);
if (rc) {
code = rc;
goto done;
}
}
code = 0;
SETCODE(code);
done:
PPCODE:
{
int32 code;
struct kaident ki;
code = ubik_Call(KAM_ListEntry, server, 0, previous, &index, &count, &ki);
sv_setiv(ST(2), (IV) index);
sv_setiv(ST(3), (IV) count);
SETCODE(code);
if (code == 0 && count >= 0) {
EXTEND(sp, 2);
PUSHs(sv_2mortal(newSVpv(ki.name, strlen(ki.name))));
PUSHs(sv_2mortal(newSVpv(ki.instance, strlen(ki.instance))));
}
}
void
kas_KAM_SetFields(server,name,instance,flags,user_expire,max_ticket_life, maxAssoc, misc_auth_bytes, spare2=0)
AFS::KAS server
char * name
char * instance
int32 flags
int32 user_expire
int32 max_ticket_life
int32 maxAssoc
uint32 misc_auth_bytes
int32 spare2
PPCODE:
{
int32 code;
# tpf nog 03/29/99
# wrong argument list: max_ticket_life was missing
# code = ubik_Call(KAM_SetFields, server, 0, name, instance,
# flags, user_expire, maxAssoc, spare1,spare2);
code = ubik_Call(KAM_SetFields, server, 0, name, instance,
flags, user_expire, max_ticket_life, maxAssoc, misc_auth_bytes, spare2);
SETCODE(code);
EXTEND(sp, 1);
PUSHs(sv_2mortal(newSViv(code == 0)));
}
void
kas_ka_ChangePassword(server,name,instance,oldkey,newkey)
AFS::KAS server
char * name
char * instance
AFS::KTC_EKEY oldkey
AFS::KTC_EKEY newkey
PPCODE:
{
int32 code;
code = ka_ChangePassword(name, instance, server, oldkey, newkey);
SETCODE(code);
EXTEND(sp, 1);
PUSHs(sv_2mortal(newSViv(code == 0)));
}
void
kas_ka_GetToken(server,name,instance,start,end,auth_token,auth_domain="")
AFS::KAS server
char * name
char * instance
int32 start
int32 end
AFS::KTC_TOKEN auth_token
char * auth_domain
PPCODE:
{
int32 code;
struct ktc_token *t;
#if defined(AFS_3_4)
#else
char *cname = NULL;
char *cinst = NULL;
char *cell = NULL;
#endif
t = (struct ktc_token *) safemalloc(sizeof(struct ktc_token));
#if defined(AFS_3_4)
code = ka_GetToken(name, instance, server, start, end, auth_token, auth_domain, t);
#else
if (cell == 0) {
cell = internal_GetLocalCell(&code);
if (code)
XSRETURN_UNDEF;
}
code = ka_GetToken(name, instance, cell, cname, cinst, server,
start, end, auth_token, auth_domain, t);
#endif
if (code == 0) {
SV *st;
EXTEND(sp, 1);
st = sv_newmortal();
sv_setref_pv(st, "AFS::KTC_TOKEN", (void *) t);
PUSHs(st);
XSRETURN(1);
}
else {
char buffer[256];
sprintf(buffer, "AFS::KTC_TOKEN: ");
KSETCODE(code, buffer);
safefree(t);
XSRETURN_UNDEF;
}
}
void
kas_ka_Authenticate(server,name,instance,service,key,start,end,pwexpires=-1)
AFS::KAS server
char * name
char * instance
int32 service
AFS::KTC_EKEY key
int32 start
int32 end
int32 pwexpires
PPCODE:
{
int32 code;
int32 pw;
struct ktc_token *t;
#if defined(AFS_3_4)
#else
char *cell = NULL;
#endif
t = (struct ktc_token *) safemalloc(sizeof(struct ktc_token));
#if defined(AFS_3_4)
code = ka_Authenticate(name, instance, server, service, key, start, end, t, &pw);
#else
if (cell == 0) {
cell = internal_GetLocalCell(&code);
if (code)
XSRETURN_UNDEF;
}
code = ka_Authenticate(name, instance, cell, server, service, key, start, end, t, &pw);
#endif
if (code == 0) {
SV *st;
EXTEND(sp, 1);
st = sv_newmortal();
sv_setref_pv(st, "AFS::KTC_TOKEN", (void *) t);
PUSHs(st);
if (pwexpires != -1)
sv_setiv(ST(7), (IV) pw);
XSRETURN(1);
}
else {
char buffer[256];
sprintf(buffer, "AFS::KTC_TOKEN: ");
KSETCODE(code, buffer);
safefree(t);
XSRETURN_UNDEF;
}
}
MODULE = AFS PACKAGE = AFS PREFIX = afs_
BOOT:
initialize_bz_error_table();
initialize_vols_error_table();
initialize_vl_error_table();
initialize_u_error_table();
initialize_pt_error_table();
initialize_ka_error_table();
initialize_acfg_error_table();
initialize_ktc_error_table();
initialize_rxk_error_table();
/* initialize_cmd_error_table(); */
/* initialize_budb_error_table(); */
/* initialize_butm_error_table(); */
/* initialize_butc_error_table(); */
void
afs__finalize()
CODE:
{
if (rx_initialized) {
rx_Finalize();
/* printf("AFS DEBUG rx_Finalize\n"); */
}
}
int32
afs_ascii2ptsaccess(access)
char * access
CODE:
{
int32 code, flags;
code = parse_pts_setfields(access, &flags);
SETCODE(code);
if (code != 0)
flags = 0;
( run in 0.728 second using v1.01-cache-2.11-cpan-39bf76dae61 )