/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
#include <afsconfig.h>
#include <afs/param.h>
+#include <afs/stds.h>
-RCSID
- ("$Header$");
+#include <roken.h>
-#include <afs/stds.h>
-#include <sys/types.h>
#ifdef AFS_NT40_ENV
-#include <io.h>
-#include <fcntl.h>
#include <sys/utime.h>
-#else
-#include <sys/file.h>
-#include <netinet/in.h>
#endif /* AFS_NT40_ENV */
+
#include <rx/xdr.h>
#include <rx/rx.h>
#include <rx/rxkad.h>
-#include <errno.h>
#include <afs/cellconfig.h>
#include <afs/keys.h>
-#include <sys/stat.h>
-#include <des.h>
-#include <dirent.h>
-#include <stdio.h>
#include <afs/afsutil.h>
#include <afs/fileutil.h>
#include <afs/ktime.h>
#include <afs/audit.h>
#include <afs/kautils.h>
-#include <string.h>
#include "bnode.h"
+#include "bnode_internal.h"
#include "bosint.h"
#include "bosprototypes.h"
extern struct afsconf_dir *bozo_confdir;
extern int bozo_newKTs;
extern int DoLogging;
-#ifdef BOS_RESTRICTED_MODE
extern int bozo_isrestricted;
-#endif
afs_int32
SBOZO_GetRestartTime(struct rx_call *acall, afs_int32 atype, struct bozo_netKTime *aktime)
{
- register afs_int32 code;
+ afs_int32 code;
code = 0; /* assume success */
switch (atype) {
afs_int32
SBOZO_SetRestartTime(struct rx_call *acall, afs_int32 atype, struct bozo_netKTime *aktime)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
/* check for proper permissions */
code = BZACCESS;
goto fail;
}
-#ifdef BOS_RESTRICTED_MODE
if (bozo_isrestricted) {
code = BZACCESS;
goto fail;
}
-#endif
if (DoLogging)
bozo_Log("%s is executing the shell command '%s'\n", caller, acmd);
}
afs_int32
-SBOZO_GetDates(struct rx_call *acall, char *aname, afs_int32 *atime,
+SBOZO_GetDates(struct rx_call *acall, char *aname, afs_int32 *atime,
afs_int32 *abakTime, afs_int32 *aoldTime)
{
struct stat tstat;
}
afs_int32
-SBOZO_UnInstall(struct rx_call *acall, register char *aname)
+SBOZO_UnInstall(struct rx_call *acall, char *aname)
{
char *filepath;
char fpOld[AFSDIR_PATH_MAX], fpBak[AFSDIR_PATH_MAX];
osi_auditU(acall, BOS_UnInstallEvent, code, AUD_STR, aname, AUD_END);
return code;
}
-#ifdef BOS_RESTRICTED_MODE
if (bozo_isrestricted) {
code = BZACCESS;
osi_auditU(acall, BOS_UnInstallEvent, code, AUD_STR, aname, AUD_END);
return code;
}
-#endif
/* construct local path from canonical (wire-format) path */
if (ConstructLocalBinPath(aname, &filepath)) {
strcpy(fpOld, filepath);
strcat(fpOld, ".OLD");
- code = renamefile(fpBak, filepath);
+ code = rk_rename(fpBak, filepath);
if (code) {
/* can't find .BAK, try .OLD */
- code = renamefile(fpOld, filepath);
+ code = rk_rename(fpOld, filepath);
if (code && errno == ENOENT) /* If doesn't exist don't fail */
code = 0;
} else {
/* now rename .OLD to .BAK */
if (stat(fpOld, &tstat) == 0)
- code = renamefile(fpOld, fpBak);
+ code = rk_rename(fpOld, fpBak);
}
if (code)
code = errno;
static void
SaveOldFiles(char *aname)
{
- register afs_int32 code;
+ afs_int32 code;
char bbuffer[AFSDIR_PATH_MAX], obuffer[AFSDIR_PATH_MAX];
struct stat tstat;
- register afs_int32 now;
+ afs_int32 now;
afs_int32 oldTime, bakTime;
strcpy(bbuffer, aname);
if (bakTime && (oldTime == 0 || bakTime < now - BOZO_OLDTIME)) {
/* no .OLD file, or .BAK is at least a week old */
- code = renamefile(bbuffer, obuffer);
+ rk_rename(bbuffer, obuffer);
}
/* finally rename to .BAK extension */
- renamefile(aname, bbuffer);
+ rk_rename(aname, bbuffer);
}
afs_int32
if (!afsconf_SuperUser(bozo_confdir, acall, caller))
return BZACCESS;
-#ifdef BOS_RESTRICTED_MODE
if (bozo_isrestricted)
return BZACCESS;
-#endif
/* construct local path from canonical (wire-format) path */
if (ConstructLocalBinPath(aname, &fpp)) {
/* all done, rename to final name */
strcpy(tbuffer, filepath);
strcat(tbuffer, ".NEW");
- code = (renamefile(tbuffer, filepath) ? errno : 0);
+ code = (rk_rename(tbuffer, filepath) ? errno : 0);
/* label file with same time for our sanity */
#ifdef AFS_NT40_ENV
SBOZO_SetCellName(struct rx_call *acall, char *aname)
{
struct afsconf_cell tcell;
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
char clones[MAXHOSTSPERCELL];
code =
afsconf_GetExtendedCellInfo(bozo_confdir, NULL, NULL, &tcell,
- &clones);
+ clones);
if (code)
goto fail;
strcpy(tcell.name, aname);
code =
afsconf_SetExtendedCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATH,
- &tcell, &clones);
+ &tcell, clones);
fail:
osi_auditU(acall, BOS_SetCellEvent, code, AUD_STR, aname, AUD_END);
afs_int32
SBOZO_GetCellName(struct rx_call *acall, char **aname)
{
- register afs_int32 code;
+ afs_int32 code;
char tname[MAXCELLCHARS];
code = afsconf_GetLocalCell(bozo_confdir, tname, sizeof(tname));
if (code) {
/* must set output parameters even if aborting */
- *aname = (char *)malloc(1);
+ *aname = malloc(1);
**aname = 0;
} else {
- *aname = (char *)malloc(strlen(tname) + 1);
- strcpy(*aname, tname);
+ *aname = strdup(tname);
}
return code;
afs_int32
SBOZO_GetCellHost(struct rx_call *acall, afs_uint32 awhich, char **aname)
{
- register afs_int32 code;
+ afs_int32 code;
struct afsconf_cell tcell;
- register char *tp;
+ char *tp;
char clones[MAXHOSTSPERCELL];
code =
afsconf_GetExtendedCellInfo(bozo_confdir, NULL, NULL, &tcell,
- &clones);
+ clones);
if (code)
goto fail;
}
tp = tcell.hostName[awhich];
- *aname = (char *)malloc(strlen(tp) + 3);
if (clones[awhich]) {
- strcpy(*aname, "[");
- strcat(*aname, tp);
- strcat(*aname, "]");
+ asprintf(aname, "[%s]", tp);
} else
- strcpy(*aname, tp);
+ *aname = strdup(tp);
goto done;
fail:
- *aname = (char *)malloc(1); /* return fake string */
+ *aname = malloc(1); /* return fake string */
**aname = 0;
done:
afs_int32
SBOZO_DeleteCellHost(struct rx_call *acall, char *aname)
{
- register afs_int32 code;
+ afs_int32 code;
struct afsconf_cell tcell;
afs_int32 which;
- register int i;
+ int i;
char caller[MAXKTCNAMELEN];
char clones[MAXHOSTSPERCELL];
code =
afsconf_GetExtendedCellInfo(bozo_confdir, NULL, NULL, &tcell,
- &clones);
+ clones);
if (code)
goto fail;
memset(tcell.hostName[which], 0, MAXHOSTCHARS);
code =
afsconf_SetExtendedCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATH,
- &tcell, &clones);
+ &tcell, clones);
fail:
osi_auditU(acall, BOS_DeleteHostEvent, code, AUD_STR, aname, AUD_END);
afs_int32
SBOZO_AddCellHost(struct rx_call *acall, char *aname)
{
- register afs_int32 code;
+ afs_int32 code;
struct afsconf_cell tcell;
afs_int32 which;
- register int i;
+ int i;
char caller[MAXKTCNAMELEN];
char clones[MAXHOSTSPERCELL];
char *n;
code =
afsconf_GetExtendedCellInfo(bozo_confdir, NULL, NULL, &tcell,
- &clones);
+ clones);
if (code)
goto fail;
clones[which] = isClone;
code =
afsconf_SetExtendedCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATH,
- &tcell, &clones);
+ &tcell, clones);
fail:
osi_auditU(acall, BOS_AddHostEvent, code, AUD_STR, aname, AUD_END);
}
afs_int32
-SBOZO_ListKeys(struct rx_call *acall, afs_int32 an, afs_int32 *akvno,
+SBOZO_ListKeys(struct rx_call *acall, afs_int32 an, afs_int32 *akvno,
struct bozo_key *akey, struct bozo_keyInfo *akeyinfo)
{
struct afsconf_keys tkeys;
- register afs_int32 code;
+ afs_int32 code;
struct stat tstat;
int noauth = 0;
char caller[MAXKTCNAMELEN];
memset(akeyinfo, 0, sizeof(struct bozo_keyInfo));
noauth = afsconf_GetNoAuthFlag(bozo_confdir);
- rxkad_GetServerInfo(acall->conn, &enc_level, 0, 0, 0, 0, 0);
- /*
+ rxkad_GetServerInfo(rx_ConnectionOf(acall), &enc_level, 0, 0, 0, 0, 0);
+ /*
* only return actual keys in noauth or if this is an encrypted connection
*/
if (code == 0) {
akeyinfo->mod_sec = tstat.st_mtime;
}
- ka_KeyCheckSum(tkeys.key[an].key, &akeyinfo->keyCheckSum);
- /* only errors is bad key parity */
+
+ /* This will return an error if the key is 'bad' (bad checksum, weak DES
+ * key, etc). But we don't care, since we can still return the other
+ * information about the key, so ignore the result. */
+ (void)ka_KeyCheckSum(tkeys.key[an].key, &akeyinfo->keyCheckSum);
fail:
if (noauth)
afs_int32
SBOZO_AddKey(struct rx_call *acall, afs_int32 an, struct bozo_key *akey)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
rxkad_level enc_level = rxkad_clear;
int noauth;
goto fail;
}
noauth = afsconf_GetNoAuthFlag(bozo_confdir);
- rxkad_GetServerInfo(acall->conn, &enc_level, 0, 0, 0, 0, 0);
+ rxkad_GetServerInfo(rx_ConnectionOf(acall), &enc_level, 0, 0, 0, 0, 0);
if ((!noauth) && (enc_level != rxkad_crypt)) {
code = BZENCREQ;
goto fail;
if (DoLogging)
bozo_Log("%s is executing AddKey\n", caller);
- code = afsconf_AddKey(bozo_confdir, an, akey, 0);
+ code = afsconf_AddKey(bozo_confdir, an, akey->data, 0);
if (code == AFSCONF_KEYINUSE)
code = BZKEYINUSE; /* Unique code for afs rpc calls */
fail:
}
afs_int32
-SBOZO_SetNoAuthFlag(register struct rx_call *acall, afs_int32 aflag)
+SBOZO_SetNoAuthFlag(struct rx_call *acall, afs_int32 aflag)
{
- register afs_int32 code = 0;
+ afs_int32 code = 0;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
afs_int32
SBOZO_DeleteKey(struct rx_call *acall, afs_int32 an)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
afs_int32
-SBOZO_ListSUsers(struct rx_call *acall, afs_int32 an, register char **aname)
+SBOZO_ListSUsers(struct rx_call *acall, afs_int32 an, char **aname)
{
- register afs_int32 code;
- register char *tp;
+ afs_int32 code;
+ char *tp;
- tp = *aname = (char *)malloc(256);
+ tp = *aname = malloc(256);
*tp = 0; /* in case getnthuser doesn't null-terminate the string */
code = afsconf_GetNthUser(bozo_confdir, an, tp, 256);
afs_int32
SBOZO_AddSUser(struct rx_call *acall, char *aname)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
afs_int32
SBOZO_DeleteSUser(struct rx_call *acall, char *aname)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
}
afs_int32
-SBOZO_CreateBnode(struct rx_call *acall, char *atype, char *ainstance,
+SBOZO_CreateBnode(struct rx_call *acall, char *atype, char *ainstance,
char *ap1, char *ap2, char *ap3, char *ap4, char *ap5,
char *notifier)
{
code = BZACCESS;
goto fail;
}
-#ifdef BOS_RESTRICTED_MODE
if (bozo_isrestricted) {
+ const char *salvpath = AFSDIR_CANONICAL_SERVER_SALVAGER_FILEPATH;
+ /* for DAFS, 'bos salvage' will pass "salvageserver -client" instead */
+ const char *salsrvpath = AFSDIR_CANONICAL_SERVER_SALSRV_FILEPATH " -client ";
+
+ /* still allow 'bos salvage' to work */
if (strcmp(atype, "cron") || strcmp(ainstance, "salvage-tmp")
|| strcmp(ap2, "now")
- || strncmp(ap1, AFSDIR_CANONICAL_SERVER_SALVAGER_FILEPATH,
- strlen(AFSDIR_CANONICAL_SERVER_SALVAGER_FILEPATH))) {
+ || (strncmp(ap1, salvpath, strlen(salvpath))
+ && strncmp(ap1, salsrvpath, strlen(salsrvpath)))) {
+
code = BZACCESS;
goto fail;
}
}
-#endif
code =
bnode_Create(atype, ainstance, &tb, ap1, ap2, ap3, ap4, ap5, notifier,
}
afs_int32
-SBOZO_WaitAll(register struct rx_call *acall)
+SBOZO_WaitAll(struct rx_call *acall)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
afs_int32
SBOZO_DeleteBnode(struct rx_call *acall, char *ainstance)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
code = BZACCESS;
goto fail;
}
-#ifdef BOS_RESTRICTED_MODE
if (bozo_isrestricted) {
code = BZACCESS;
goto fail;
}
-#endif
if (DoLogging)
bozo_Log("%s is executing DeleteBnode '%s'\n", caller, ainstance);
}
static int
-swproc(register struct bnode *abnode, void *arock)
+swproc(struct bnode *abnode, void *arock)
{
if (abnode->goal == BSTAT_NORMAL)
return 0; /* this one's not shutting down */
return 0; /* don't do these guys */
bnode_Hold(abnode);
+ bnode_ResetErrorCount(abnode);
bnode_SetStat(abnode, BSTAT_NORMAL);
bnode_Release(abnode);
return 0;
SBOZO_ShutdownAll(struct rx_call *acall)
{
/* iterate over all bnodes, setting the status to temporarily disabled */
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
/* check for authorization */
afs_int32
SBOZO_RestartAll(struct rx_call *acall)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
afs_int32
SBOZO_ReBozo(struct rx_call *acall)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
/* acall is null if called internally to restart bosserver */
afs_int32
SBOZO_StartupAll(struct rx_call *acall)
{
- register afs_int32 code;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
}
afs_int32
-SBOZO_Restart(struct rx_call *acall, register char *ainstance)
+SBOZO_Restart(struct rx_call *acall, char *ainstance)
{
- register struct bnode *tb;
- register afs_int32 code;
+ struct bnode *tb;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
goto fail;
}
- /* setup return code */
- code = 0;
-
bnode_Hold(tb);
bnode_SetStat(tb, BSTAT_SHUTDOWN);
code = bnode_WaitStatus(tb, BSTAT_SHUTDOWN); /* this can fail */
+ bnode_ResetErrorCount(tb);
bnode_SetStat(tb, BSTAT_NORMAL);
bnode_Release(tb);
afs_int32
SBOZO_SetTStatus(struct rx_call *acall, char *ainstance, afs_int32 astatus)
{
- register struct bnode *tb;
- register afs_int32 code;
+ struct bnode *tb;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
goto fail;
}
bnode_Hold(tb);
+ bnode_ResetErrorCount(tb);
code = bnode_SetStat(tb, astatus);
bnode_Release(tb);
afs_int32
SBOZO_SetStatus(struct rx_call *acall, char *ainstance, afs_int32 astatus)
{
- register struct bnode *tb;
- register afs_int32 code;
+ struct bnode *tb;
+ afs_int32 code;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
}
afs_int32
-SBOZO_GetStatus(struct rx_call *acall, char *ainstance, afs_int32 *astat,
+SBOZO_GetStatus(struct rx_call *acall, char *ainstance, afs_int32 *astat,
char **astatDescr)
{
- register struct bnode *tb;
- register afs_int32 code;
+ struct bnode *tb;
+ afs_int32 code;
tb = bnode_FindInstance(ainstance);
if (!tb) {
goto fail;
}
- *astatDescr = (char *)malloc(BOZO_BSSIZE);
+ *astatDescr = malloc(BOZO_BSSIZE);
code = bnode_GetString(tb, *astatDescr, BOZO_BSSIZE);
bnode_Release(tb);
if (code)
return 0;
fail:
- *astatDescr = (char *)malloc(1);
+ *astatDescr = malloc(1);
**astatDescr = 0;
return code;
}
eifunc(struct bnode *abnode, void *param)
{
struct eidata *arock = (struct eidata *)param;
-
+
if (arock->counter-- == 0) {
/* done */
strcpy(arock->iname, abnode->name);
afs_int32
SBOZO_Prune(struct rx_call *acall, afs_int32 aflags)
{
- register afs_int32 code;
+ afs_int32 code;
DIR *dirp;
- register struct dirent *tde;
- register int i;
+ struct dirent *tde;
+ int i;
char caller[MAXKTCNAMELEN];
if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
code = BZACCESS;
goto fail;
}
-#ifdef BOS_RESTRICTED_MODE
if (bozo_isrestricted) {
code = BZACCESS;
goto fail;
}
-#endif
if (DoLogging)
bozo_Log("%s is executing Prune (flags=%d)\n", caller, aflags);
}
afs_int32
-SBOZO_EnumerateInstance(struct rx_call *acall, afs_int32 anum,
+SBOZO_EnumerateInstance(struct rx_call *acall, afs_int32 anum,
char **ainstance)
{
struct eidata tdata;
- *ainstance = (char *)malloc(BOZO_BSSIZE);
+ *ainstance = malloc(BOZO_BSSIZE);
**ainstance = 0;
tdata.counter = anum;
tdata.iname = *ainstance;
sizeof(bozo_bosEntryStats) / sizeof(bozo_bosEntryStats[0]);
/* This function performs initialization of the bozo_bosEntrystats[]
- * array. This array contains the list of dirs that the bosserver
+ * array. This array contains the list of dirs that the bosserver
* is interested in along with their recommended permissions
* NOTE: This initialization is a bit ugly. This was caused because
* the path names require procedural as opposed to static initialization.
if (!StatEachEntry(e)) {
bozo_Log("unhappy with %s which is a %s that should "
"have at least rights %o, at most rights %o %s\n",
- e->path, e->dir ? "dir" : "file", e->reqPerm,
- (~e->proPerm & 0777),
+ e->path, e->dir ? "dir" : "file", e->reqPerm,
+ (~e->proPerm & 0777),
e->rootOwner ? ", owned by root" : "");
result = 0;
break;
OUT char **atype,
OUT struct bozo_status *astatus)
{
- register struct bnode *tb;
+ struct bnode *tb;
tb = bnode_FindInstance(ainstance);
- *atype = (char *)malloc(BOZO_BSSIZE);
+ *atype = malloc(BOZO_BSSIZE);
**atype = 0;
if (!tb)
return BZNOENT;
afs_int32 anum,
char **aparm)
{
- register struct bnode *tb;
- register char *tp;
- register afs_int32 code;
+ struct bnode *tb;
+ char *tp;
+ afs_int32 code;
- tp = (char *)malloc(BOZO_BSSIZE);
+ tp = malloc(BOZO_BSSIZE);
*aparm = tp;
*tp = 0; /* null-terminate string in error case */
tb = bnode_FindInstance(ainstance);
}
afs_int32
-SBOZO_GetLog(register struct rx_call *acall, char *aname)
+SBOZO_GetLog(struct rx_call *acall, char *aname)
{
- register afs_int32 code;
+ afs_int32 code;
FILE *tfile;
int tc;
char *logpath;
code = BZACCESS;
goto fail;
}
-#ifdef BOS_RESTRICTED_MODE
if (bozo_isrestricted && strchr(aname, '/')
&& strcmp(aname, AFSDIR_CANONICAL_SERVER_SLVGLOG_FILEPATH)) {
code = BZACCESS;
goto fail;
}
-#endif
/* construct local path from canonical (wire-format) path */
if (ConstructLocalLogPath(aname, &logpath)) {
}
afs_int32
-SBOZO_GetInstanceStrings(struct rx_call *acall, char *abnodeName,
+SBOZO_GetInstanceStrings(struct rx_call *acall, char *abnodeName,
char **as1, char **as2, char **as3, char **as4)
{
- register struct bnode *tb;
+ struct bnode *tb;
- *as2 = (char *)malloc(1);
+ *as2 = malloc(1);
**as2 = 0;
- *as3 = (char *)malloc(1);
+ *as3 = malloc(1);
**as3 = 0;
- *as4 = (char *)malloc(1);
+ *as4 = malloc(1);
**as4 = 0;
tb = bnode_FindInstance(abnodeName);
if (!tb)
/* now, return the appropriate error string, if any */
if (tb->lastErrorName) {
- *as1 = (char *)malloc(strlen(tb->lastErrorName) + 1);
- strcpy(*as1, tb->lastErrorName);
+ *as1 = strdup(tb->lastErrorName);
} else {
- *as1 = (char *)malloc(1);
+ *as1 = malloc(1);
**as1 = 0;
}
return 0;
fail:
- *as1 = (char *)malloc(1);
+ *as1 = malloc(1);
**as1 = 0;
return BZNOENT;
}
-#ifdef BOS_RESTRICTED_MODE
afs_int32
SBOZO_GetRestrictedMode(struct rx_call *acall, afs_int32 *arestmode)
{
}
bozo_isrestricted = arestmode;
code = WriteBozoFile(0);
- fail:
- return code;
-}
-#else
-afs_int32
-SBOZO_GetRestrictedMode(struct rx_call *acall, afs_int32 *arestmode)
-{
- return RXGEN_OPCODE;
-}
-afs_int32
-SBOZO_SetRestrictedMode(struct rx_call *acall, afs_int32 arestmode)
-{
- return RXGEN_OPCODE;
+ return code;
}
-#endif
void *
bozo_ShutdownAndExit(void *param)
{
- int asignal = (int) param;
+ int asignal = (intptr_t)param;
int code;
bozo_Log
git://git.openafs.org / openafs.git / blobdiff