AFS
view release on metacpan or search on metacpan
if (flags & 0x08)
buff[2] = 'm';
if (flags & 0x10)
buff[2] = 'M';
if (flags & 0x20)
buff[1] = 'O';
if (flags & 0x40)
buff[0] = 's';
if (flags & 0x80)
buff[0] = 'S';
return buff;
}
static int parse_prcheckentry(server, stats, entry, lookupids, convertflags)
struct ubik_client *server;
HV *stats;
struct prcheckentry *entry;
int32 lookupids;
int convertflags;
{
int32 code;
char name[PR_MAXNAMELEN];
safe_hv_store(stats, "id", 2, newSViv(entry->id), 0);
safe_hv_store(stats, "name", 4, newSVpv(entry->name, strlen(entry->name)), 0);
if (convertflags) {
safe_hv_store(stats, "flags", 5, newSVpv(parse_flags_ptsaccess(entry->flags), 5), 0);
}
else {
safe_hv_store(stats, "flags", 5, newSViv(entry->flags), 0);
}
if (lookupids) {
code = internal_pr_name(server, entry->owner, name);
if (code)
safe_hv_store(stats, "owner", 5, newSViv(entry->owner), 0);
else
safe_hv_store(stats, "owner", 5, newSVpv(name, strlen(name)), 0);
code = internal_pr_name(server, entry->creator, name);
if (code)
safe_hv_store(stats, "creator", 7, newSViv(entry->creator), 0);
else
safe_hv_store(stats, "creator", 7, newSVpv(name, strlen(name)), 0);
}
else {
safe_hv_store(stats, "owner", 5, newSViv(entry->owner), 0);
safe_hv_store(stats, "creator", 7, newSViv(entry->creator), 0);
}
safe_hv_store(stats, "ngroups", 7, newSViv(entry->ngroups), 0);
/* safe_hv_store(stats, "nusers",6, newSViv(entry->nusers),0);*/
safe_hv_store(stats, "count", 5, newSViv(entry->count), 0);
/*
safe_hv_store(stats, "reserved0",9, newSViv(entry->reserved[0]),0);
safe_hv_store(stats, "reserved1",9, newSViv(entry->reserved[1]),0);
safe_hv_store(stats, "reserved2",9, newSViv(entry->reserved[2]),0);
safe_hv_store(stats, "reserved3",9, newSViv(entry->reserved[3]),0);
safe_hv_store(stats, "reserved4",9, newSViv(entry->reserved[4]),0);
*/
return 1;
}
static int parse_prdebugentry(server, stats, entry, lookupids, convertflags)
struct ubik_client *server;
HV *stats;
struct prdebugentry *entry;
int32 lookupids;
int convertflags;
{
int32 code;
char name[PR_MAXNAMELEN];
char buff[128];
int i;
safe_hv_store(stats, "id", 2, newSViv(entry->id), 0);
safe_hv_store(stats, "name", 4, newSVpv(entry->name, strlen(entry->name)), 0);
if (convertflags) {
safe_hv_store(stats, "flags", 5, newSVpv(parse_flags_ptsaccess(entry->flags), 5), 0);
}
else {
safe_hv_store(stats, "flags", 5, newSViv(entry->flags), 0);
}
if (lookupids) {
code = internal_pr_name(server, entry->owner, name);
if (code)
safe_hv_store(stats, "owner", 5, newSViv(entry->owner), 0);
else
safe_hv_store(stats, "owner", 5, newSVpv(name, strlen(name)), 0);
code = internal_pr_name(server, entry->creator, name);
if (code)
safe_hv_store(stats, "creator", 7, newSViv(entry->creator), 0);
else
safe_hv_store(stats, "creator", 7, newSVpv(name, strlen(name)), 0);
for (i = 0; i < 10; i++) {
sprintf(buff, "entries%d", i);
code = internal_pr_name(server, entry->entries[i], name);
if (code)
safe_hv_store(stats, buff, strlen(buff), newSViv(entry->entries[i]), 0);
else
safe_hv_store(stats, buff, strlen(buff), newSVpv(name, strlen(name)), 0);
}
}
else {
safe_hv_store(stats, "owner", 5, newSViv(entry->owner), 0);
safe_hv_store(stats, "creator", 7, newSViv(entry->creator), 0);
for (i = 0; i < 10; i++) {
sprintf(buff, "entries%d", i);
safe_hv_store(stats, buff, strlen(buff), newSViv(entry->entries[i]), 0);
}
}
safe_hv_store(stats, "cellid", 6, newSViv(entry->cellid), 0);
safe_hv_store(stats, "next", 4, newSViv(entry->next), 0);
safe_hv_store(stats, "nextID", 6, newSViv(entry->nextID), 0);
safe_hv_store(stats, "nextname", 8, newSViv(entry->nextname), 0);
safe_hv_store(stats, "ngroups", 7, newSViv(entry->ngroups), 0);
safe_hv_store(stats, "nusers", 6, newSViv(entry->nusers), 0);
safe_hv_store(stats, "count", 5, newSViv(entry->count), 0);
safe_hv_store(stats, "instance", 8, newSViv(entry->instance), 0);
safe_hv_store(stats, "owned", 5, newSViv(entry->owned), 0);
/* 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);
if (!code) {
/* Any type of failure is treated as not having a notifier program */
/* printf(" Notifier is '%s'\n", buffer); */
safe_hv_store(stats, "notifier", 8, newSVpv(buffer, strlen(buffer)), 0);
}
/* printf("\n"); */
}
return 0;
}
static afs_int32 GetServerGoal(aconn, aname)
char *aname;
struct rx_connection *aconn;
{
char buffer[500];
char *tp;
register afs_int32 code;
struct bozo_status istatus;
tp = buffer;
code = BOZO_GetInstanceInfo(aconn, aname, &tp, &istatus);
if (code) {
printf("AFS::BOS: failed to get instance info for '%s' (%s)\n", aname, em(code));
/* if we can't get the answer, assume its running */
return BSTAT_NORMAL;
}
if (istatus.goal == 0)
return BSTAT_SHUTDOWN;
else
return BSTAT_NORMAL;
}
#define PARMBUFFERSSIZE 32
static struct SalvageParms {
afs_int32 Optdebug;
afs_int32 Optnowrite;
afs_int32 Optforce;
afs_int32 Optoktozap;
afs_int32 Optrootfiles;
afs_int32 Optsalvagedirs;
afs_int32 Optblockreads;
afs_int32 OptListResidencies;
afs_int32 OptSalvageRemote;
afs_int32 OptSalvageArchival;
afs_int32 OptIgnoreCheck;
afs_int32 OptForceOnLine;
afs_int32 OptUseRootDirACL;
afs_int32 OptTraceBadLinkCounts;
afs_int32 OptDontAskFS;
afs_int32 OptLogLevel;
afs_int32 OptRxDebug;
afs_uint32 OptResidencies;
} mrafsParm;
static int DoSalvage(aconn, aparm1, aparm2, aoutName, showlog, parallel, atmpDir, orphans)
struct rx_connection *aconn;
char *aoutName;
char *aparm1;
char *aparm2;
afs_int32 showlog;
char *parallel;
char *atmpDir;
char *orphans;
{
register afs_int32 code;
char *parms[6];
char buffer;
char tbuffer[BOZO_BSSIZE];
struct bozo_status istatus;
struct rx_call *tcall;
char *tp;
FILE *outFile;
int closeIt = 0;
char partName[20]; /* canonical name for partition */
char pbuffer[PARMBUFFERSSIZE];
afs_int32 partNumber;
char *notifier = NONOTIFIER;
/* if a partition was specified, canonicalize the name, since
the salvager has a stupid partition ID parser */
if (aparm1) {
partNumber = volutil_GetPartitionID(aparm1);
if (partNumber < 0) {
char buffer[256];
sprintf(buffer, "AFS::BOS: could not parse partition ID '%s'\n", aparm1);
BSETCODE(EINVAL, buffer);
return EINVAL;
}
tp = (char *) volutil_PartitionName(partNumber);
if (!tp) {
char buffer[256];
sprintf(buffer, "AFS::BOS: internal error parsing partition ID '%s'\n",
aparm1);
BSETCODE(EINVAL, buffer);
return EINVAL;
if (*aparm2 != 0) {
if ((strlen(tbuffer) + 1 + strlen(partName) + 1 + strlen(aparm2) + 1) >
BOZO_BSSIZE) {
char buffer[256];
sprintf(buffer, "AFS::BOS: command line too big\n");
BSETCODE(E2BIG, buffer);
return (E2BIG);
}
strcat(tbuffer, " ");
strcat(tbuffer, partName);
strcat(tbuffer, " ");
strcat(tbuffer, aparm2);
}
else {
if ((strlen(tbuffer) + 4 + strlen(partName) + 1) > BOZO_BSSIZE) {
char buffer[256];
sprintf(buffer, "AFS::BOS: command line too big\n");
BSETCODE(E2BIG, buffer);
return (E2BIG);
}
strcat(tbuffer, " -f ");
strcat(tbuffer, partName);
}
/* add the parallel option if given */
if (parallel != (char *) 0) {
if ((strlen(tbuffer) + 11 + strlen(parallel) + 1) > BOZO_BSSIZE) {
char buffer[256];
sprintf(buffer, "AFS::BOS: command line too big\n");
BSETCODE(E2BIG, buffer);
return (E2BIG);
}
strcat(tbuffer, " -parallel ");
strcat(tbuffer, parallel);
}
/* add the tmpdir option if given */
if (atmpDir != (char *) 0) {
if ((strlen(tbuffer) + 9 + strlen(atmpDir) + 1) > BOZO_BSSIZE) {
char buffer[256];
sprintf(buffer, "AFS::BOS: command line too big\n");
BSETCODE(E2BIG, buffer);
return (E2BIG);
}
strcat(tbuffer, " -tmpdir ");
strcat(tbuffer, atmpDir);
}
/* 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 */
}
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);
vi.in = (char *) space;
vi.out_size = MAXSIZE;
vi.out = space;
code = pioctl(NULL, VIOCGETCELL, &vi, 1);
SETCODE(code);
if (code == 0) {
struct in_addr *hosts = (struct in_addr *) space;
/* int32 *magic = (int32 *) space; */
struct hostent *ht;
int i;
char *h;
/*if (*magic == 0x12345678) { */
max = MAXHOSTS;
/* hosts++; */
/* } */
h = (char *) hosts + max * sizeof(int32);
XPUSHs(sv_2mortal(newSVpv(h, strlen(h))));
for (i = 0; i < max; i++) {
if (hosts[i].s_addr == 0)
break;
if (ip == 0) {
ht = gethostbyaddr((const char *) &hosts[i], sizeof(struct in_addr), AF_INET);
if (ht == NULL)
h = (char *) inet_ntoa(hosts[i]);
else
h = ht->h_name;
}
else {
h = (char *) inet_ntoa(hosts[i]);
}
XPUSHs(sv_2mortal(newSVpv(h, strlen(h))));
}
}
}
void
fs__get_server_version(port,hostName="localhost",verbose=0)
short port
char *hostName
int32 verbose
CODE:
{
#if defined(AFS_3_4)
not_here("AFS::Utils::get_server_version");
#else
struct sockaddr_in taddr;
struct in_addr hostAddr;
struct hostent *th;
int32 host;
short port_num = htons(port);
int32 length = 64;
int32 code;
char version[64];
int s;
/* lookup host */
if (hostName) {
th = (struct hostent *) hostutil_GetHostByName(hostName);
if (!th) {
warn("rxdebug: host %s not found in host table\n", hostName);
SETCODE(EFAULT);
XSRETURN_UNDEF;
}
/* bcopy(th->h_addr, &host, sizeof(int32)); */
Copy(th->h_addr, &host, th->h_length, char);
}
else
host = htonl(0x7f000001); /* IP localhost */
hostAddr.s_addr = host;
if (verbose)
printf("Trying %s (port %d):\n", inet_ntoa(hostAddr), ntohs(port_num));
s = socket(AF_INET, SOCK_DGRAM, 0);
taddr.sin_family = AF_INET;
taddr.sin_port = 0;
taddr.sin_addr.s_addr = 0;
code = bind(s, (struct sockaddr *) &taddr, sizeof(struct sockaddr_in));
SETCODE(code);
if (code) {
perror("bind");
XSRETURN_UNDEF;
}
code = rx_GetServerVersion(s, host, port_num, length, version);
ST(0) = sv_newmortal();
if (code < 0) {
SETCODE(code);
}
else {
sv_setpv(ST(0), version);
}
#endif
}
void
fs_get_syslib_version()
CODE:
{
extern char *AFSVersion;
ST(0) = sv_newmortal();
sv_setpv(ST(0), AFSVersion);
}
void
fs_XSVERSION()
CODE:
{
ST(0) = sv_newmortal();
sv_setpv(ST(0), xs_version);
}
void
fs_sysname(newname=0)
char * newname
CODE:
{
struct ViceIoctl vi;
code = 0;
}
if (everWorked) {
XSRETURN(2);
}
else {
XSRETURN_EMPTY;
hv_undef(list);
}
}
int32
bos_getrestricted(self)
AFS::BOS self
CODE:
{
#ifdef BOS_RESTRICTED_MODE
int32 val, code;
RETVAL = 0;
code = BOZO_GetRestrictedMode(self, &val);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to get restricted mode (%s)\n", em(code));
BSETCODE(code, buffer);
}
RETVAL = val;
#else
RETVAL = 0;
not_here("AFS::BOS::getrestricted");
#endif
}
OUTPUT:
RETVAL
int32
bos_setrestricted(self, mode)
AFS::BOS self
char *mode
CODE:
{
#ifdef BOS_RESTRICTED_MODE
int32 val, code;
util_GetInt32(mode, &val);
code = BOZO_SetRestrictedMode(self, val);
if (code) {
char buffer[256];
sprintf(buffer, "AFS::BOS: failed to set restricted mode (%s)\n", em(code));
BSETCODE(code, buffer);
}
RETVAL = (code == 0);
#else
RETVAL = 0;
not_here("AFS::BOS::setrestricted");
#endif
}
OUTPUT:
RETVAL
int32
bos_salvage(self, partition=NULL, volume=NULL, all=0, outName=NULL, showlog=0, parallel=NULL, tmpDir=NULL, orphans=NULL, localauth=0, tmpname=NULL, debug=0, nowrite=0, force=0, oktozap=0, rootfiles=0, salvagedirs=0, blockreads=0, ListResidencies=0, S...
AFS::BOS self
char *partition
char *volume
int32 all
char *outName
int32 showlog
char *parallel
char *tmpDir
char *orphans
int32 localauth
char *tmpname
int32 debug
int32 nowrite
int32 force
int32 oktozap
int32 rootfiles
int32 salvagedirs
int32 blockreads
int32 ListResidencies
int32 SalvageRemote
int32 SalvageArchival
int32 IgnoreCheck
int32 ForceOnLine
int32 UseRootDirACL
int32 TraceBadLinkCounts
int32 DontAskFS
int32 LogLevel
int32 rxdebug
int32 Residencies
PREINIT:
afs_int32 code = 0, rc;
char tname[BOZO_BSSIZE];
afs_int32 newID;
extern struct ubik_client *cstruct;
afs_int32 curGoal, mrafs = 0;
char *tp;
CODE:
{
not_here("AFS::BOS::salvage");
if (partition && strlen(partition) == 0)
partition = NULL;
if (volume && strlen(volume) == 0)
volume = NULL;
if (outName && strlen(outName) == 0)
outName = NULL;
if (parallel && strlen(parallel) == 0)
parallel = NULL;
if (tmpDir && strlen(tmpDir) == 0)
tmpDir = NULL;
if (orphans && strlen(orphans) == 0)
orphans = NULL;
Zero(&mrafsParm, 1, mrafsParm);
/* Find out whether fileserver is running MR-AFS (has a scanner instance) */
/* XXX this should really be done some other way, potentially by RPC */
tp = (char *) &tname;
if ((code = BOZO_GetInstanceParm(self, "fs", 3, &tp) == 0))
mrafs = 1;
/* we can do a volume, a partition or the whole thing, but not mixtures
* thereof */
if (!partition && volume) {
char buffer[256];
sprintf(buffer, "AFS::BOS: must specify partition to salvage individual volume.\n");
BSETCODE(-1, buffer);
goto done;
}
if (showlog && outName) {
char buffer[256];
sprintf(buffer, "AFS::BOS: can not specify both -file and -showlog.\n");
BSETCODE(-1, buffer);
goto done;
}
if (all && (partition || volume)) {
char buffer[256];
sprintf(buffer, "AFS::BOS: can not specify ALL with other flags.\n");
BSETCODE(-1, buffer);
goto done;
}
if (orphans && mrafs) {
char buffer[256];
sprintf(buffer, "Can't specify -orphans for MR-AFS fileserver\n");
BSETCODE(EINVAL, buffer);
goto done;
}
if (mrafs) {
if (debug)
mrafsParm.Optdebug = 1;
if (nowrite)
mrafsParm.Optnowrite = 1;
if (force)
mrafsParm.Optforce = 1;
if (oktozap)
mrafsParm.Optoktozap = 1;
if (rootfiles)
mrafsParm.Optrootfiles = 1;
if (salvagedirs)
mrafsParm.Optsalvagedirs = 1;
if (blockreads)
mrafsParm.Optblockreads = 1;
if (ListResidencies)
mrafsParm.OptListResidencies = 1;
if (SalvageRemote)
mrafsParm.OptSalvageRemote = 1;
if (SalvageArchival)
mrafsParm.OptSalvageArchival = 1;
if (IgnoreCheck)
mrafsParm.OptIgnoreCheck = 1;
if (ForceOnLine)
mrafsParm.OptForceOnLine = 1;
if (UseRootDirACL)
mrafsParm.OptUseRootDirACL = 1;
if (TraceBadLinkCounts)
mrafsParm.OptTraceBadLinkCounts = 1;
if (DontAskFS)
mrafsParm.OptDontAskFS = 1;
if (LogLevel)
mrafsParm.OptLogLevel = LogLevel;
if (rxdebug)
mrafsParm.OptRxDebug = 1;
if (Residencies) {
if (SalvageRemote || SalvageArchival) {
char buffer[256];
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);
}
void
pts_listentry(server,name,lookupids=1,convertflags=1)
AFS::PTS server
char * name
int32 lookupids
int32 convertflags
PPCODE:
{
int32 code;
int32 id;
struct prcheckentry entry;
code = internal_pr_id(server, name, &id, 0);
if (code == 0)
code = ubik_Call(PR_ListEntry, server, 0, id, &entry);
SETCODE(code);
if (code == 0) {
HV *stats;
stats = newHV();
parse_prcheckentry(server, stats, &entry, lookupids, convertflags);
EXTEND(sp, 1);
PUSHs(sv_2mortal(newRV_noinc((SV *) stats)));
}
}
void
pts_PR_ListEntry(server,id)
AFS::PTS server
int32 id
PPCODE:
{
int32 code;
struct prcheckentry entry;
code = ubik_Call(PR_ListEntry, server, 0, id, &entry);
SETCODE(code);
if (code == 0) {
HV *stats;
stats = newHV();
parse_prcheckentry(server, stats, &entry, 0, 0);
EXTEND(sp, 1);
PUSHs(sv_2mortal(newRV_noinc((SV *) stats)));
}
}
void
pts_dumpentry(server,pos,lookupids=1,convertflags=1)
AFS::PTS server
int32 pos
int32 lookupids
int32 convertflags
PPCODE:
{
int32 code;
struct prdebugentry entry;
code = ubik_Call(PR_DumpEntry, server, 0, pos, &entry);
SETCODE(code);
if (code == 0) {
HV *stats;
stats = newHV();
parse_prdebugentry(server, stats, &entry, lookupids, convertflags);
EXTEND(sp, 1);
PUSHs(sv_2mortal(newRV_noinc((SV *) stats)));
}
}
void
pts_PR_DumpEntry(server,pos)
AFS::PTS server
int32 pos
PPCODE:
{
int32 code;
struct prdebugentry entry;
code = ubik_Call(PR_DumpEntry, server, 0, pos, &entry);
SETCODE(code);
if (code == 0) {
HV *stats;
stats = newHV();
parse_prdebugentry(server, stats, &entry, 0, 0);
EXTEND(sp, 1);
PUSHs(sv_2mortal(newRV_noinc((SV *) stats)));
}
}
void
pts_rename(server,name,newname)
AFS::PTS server
char * name
char * newname
PPCODE:
{
int32 code;
int32 id;
code = internal_pr_id(server, name, &id, 0);
if (code == 0)
code = ubik_Call(PR_ChangeEntry, server, 0, id, newname, 0, 0);
SETCODE(code);
ST(0) = sv_2mortal(newSViv(code == 0));
XSRETURN(1);
}
void
pts_chown(server,name,owner)
AFS::PTS server
char * name
char * owner
PPCODE:
{
int32 code;
int32 id, oid;
code = internal_pr_id(server, name, &id, 0);
if (code == 0)
code = internal_pr_id(server, owner, &oid, 0);
if (code == 0)
code = ubik_Call(PR_ChangeEntry, server, 0, id, "", oid, 0);
SETCODE(code);
ST(0) = sv_2mortal(newSViv(code == 0));
XSRETURN(1);
}
void
pts_chid(server,name,newid)
AFS::PTS server
char * name
int32 newid
PPCODE:
{
int32 code;
int32 id;
code = internal_pr_id(server, name, &id, 0);
if (code == 0)
code = ubik_Call(PR_ChangeEntry, server, 0, id, "", 0, newid);
SETCODE(code);
ST(0) = sv_2mortal(newSViv(code == 0));
int32 gid
PPCODE:
{
int32 code, flag;
code = ubik_Call(PR_IsAMemberOf, server, 0, uid, gid, &flag);
SETCODE(code);
ST(0) = sv_newmortal();
if (code == 0)
sv_setiv(ST(0), (flag != 0));
XSRETURN(1);
}
MODULE = AFS PACKAGE = AFS::KAS PREFIX = kas_
int32
kas__DESTROY(server)
AFS::KAS server
CODE:
{
int32 code;
code = ubik_ClientDestroy(server);
SETCODE(code);
RETVAL = (code == 0);
}
OUTPUT:
RETVAL
void
kas_KAM_GetEntry(server,user,inst)
AFS::KAS server
char * user
char * inst
PPCODE:
{
int32 code;
struct kaentryinfo entry;
code = ubik_Call(KAM_GetEntry, server, 0, user, inst, KAMAJORVERSION, &entry);
SETCODE(code);
if (code == 0) {
HV *stats = newHV();
if (parse_kaentryinfo(stats, &entry)) {
EXTEND(sp, 1);
PUSHs(sv_2mortal(newRV_noinc((SV *) stats)));
}
else {
hv_undef(stats);
}
}
}
void
kas_KAM_Debug(server,version)
AFS::KAS server
int32 version
PPCODE:
{
int32 code;
struct ka_debugInfo entry;
code = ubik_Call(KAM_Debug, server, 0, version, 0, &entry);
SETCODE(code);
if (code == 0) {
HV *stats = newHV();
if (parse_ka_debugInfo(stats, &entry)) {
EXTEND(sp, 1);
PUSHs(sv_2mortal(newRV_noinc((SV *) stats)));
}
else {
hv_undef(stats);
}
}
}
void
kas_KAM_GetStats(server,version)
AFS::KAS server
int32 version
PPCODE:
{
int32 code;
int32 admin_accounts;
struct kasstats kas;
struct kadstats kad;
code = ubik_Call(KAM_GetStats, server, 0, version, &admin_accounts, &kas, &kad);
SETCODE(code);
if (code == 0) {
HV *stats = newHV();
HV *dstats = newHV();
if (parse_ka_getstats(stats, dstats, &kas, &kad)) {
EXTEND(sp, 3);
PUSHs(sv_2mortal(newSViv(admin_accounts)));
PUSHs(sv_2mortal(newRV_noinc((SV *) stats)));
PUSHs(sv_2mortal(newRV_noinc((SV *) dstats)));
}
else {
hv_undef(stats);
hv_undef(dstats);
}
}
}
void
kas_KAM_GetRandomKey(server)
AFS::KAS server
PPCODE:
{
int32 code;
struct ktc_encryptionKey *key;
key = (struct ktc_encryptionKey *) safemalloc(sizeof(*key));
code = ubik_Call(KAM_GetRandomKey, server, 0, key);
SETCODE(code);
if (code == 0) {
SV *st = sv_newmortal();
sv_setref_pv(st, "AFS::KTC_EKEY", (void *) key);
PUSHs(st);
}
else {
safefree(key);
}
}
( run in 0.915 second using v1.01-cache-2.11-cpan-2ed5026b665 )