/*
* 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 <string.h>
+#include <afs/kautils.h>
#include "bnode.h"
#include "bosint.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(acall, atype, aktime)
- struct rx_call *acall;
- afs_int32 atype;
- struct bozo_netKTime *aktime;
+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(acall, atype, aktime)
- struct rx_call *acall;
- afs_int32 atype;
- struct bozo_netKTime *aktime;
+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 */
}
afs_int32
-SBOZO_Exec(acall, acmd)
- struct rx_call *acall;
- char *acmd;
+SBOZO_Exec(struct rx_call *acall, char *acmd)
{
char caller[MAXKTCNAMELEN];
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(acall, aname, atime, abakTime, aoldTime)
- struct rx_call *acall;
- char *aname;
- afs_int32 *atime, *abakTime, *aoldTime;
+SBOZO_GetDates(struct rx_call *acall, char *aname, afs_int32 *atime,
+ afs_int32 *abakTime, afs_int32 *aoldTime)
{
struct stat tstat;
char *strp;
}
afs_int32
-SBOZO_UnInstall(acall, aname)
- 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)) {
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);
}
afs_int32
-SBOZO_Install(acall, aname, asize, mode, amtime)
- struct rx_call *acall;
- char *aname;
- afs_int32 asize;
- afs_int32 amtime;
- afs_int32 mode;
+SBOZO_Install(struct rx_call *acall, char *aname, afs_int32 asize, afs_int32 mode, afs_int32 amtime)
{
afs_int32 code;
int fd;
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)) {
}
afs_int32
-SBOZO_SetCellName(acall, aname)
- struct rx_call *acall;
- char *aname;
+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(acall, aname)
- struct rx_call *acall;
- char **aname;
+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));
*aname = (char *)malloc(1);
**aname = 0;
} else {
- *aname = (char *)malloc(strlen(tname) + 1);
- strcpy(*aname, tname);
+ *aname = strdup(tname);
}
return code;
}
afs_int32
-SBOZO_GetCellHost(acall, awhich, aname)
- struct rx_call *acall;
- afs_uint32 awhich;
- char **aname;
+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:
}
afs_int32
-SBOZO_DeleteCellHost(acall, aname)
- struct rx_call *acall;
- char *aname;
+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(acall, aname)
- struct rx_call *acall;
- char *aname;
+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(acall, an, akvno, akey, akeyinfo)
- struct rx_call *acall;
- afs_int32 an;
- afs_int32 *akvno;
- struct bozo_keyInfo *akeyinfo;
- struct bozo_key *akey;
+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;
+ int noauth = 0;
char caller[MAXKTCNAMELEN];
rxkad_level enc_level = rxkad_clear;
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
*/
}
afs_int32
-SBOZO_AddKey(acall, an, akey)
- struct rx_call *acall;
- afs_int32 an;
- struct bozo_key *akey;
+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(acall, aflag)
- 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(acall, an)
- struct rx_call *acall;
- afs_int32 an;
+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(acall, an, aname)
- 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 = 0; /* in case getnthuser doesn't null-terminate the string */
}
afs_int32
-SBOZO_AddSUser(acall, aname)
- struct rx_call *acall;
- char *aname;
+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(acall, aname)
- struct rx_call *acall;
- char *aname;
+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(acall, atype, ainstance, ap1, ap2, ap3, ap4, ap5, notifier)
- struct rx_call *acall;
- char *atype;
- char *ainstance;
- char *ap1, *ap2, *ap3, *ap4, *ap5;
- char *notifier;
+SBOZO_CreateBnode(struct rx_call *acall, char *atype, char *ainstance,
+ char *ap1, char *ap2, char *ap3, char *ap4, char *ap5,
+ char *notifier)
{
struct bnode *tb;
afs_int32 code;
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(acall)
- 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(acall, ainstance)
- struct rx_call *acall;
- char *ainstance;
+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);
return code;
}
-static
-swproc(abnode, arock)
- register struct bnode *abnode;
- char *arock;
+static int
+swproc(struct bnode *abnode, void *arock)
{
if (abnode->goal == BSTAT_NORMAL)
return 0; /* this one's not shutting down */
return 0; /* don't stop apply function early, no matter what */
}
-static
-stproc(abnode, arock)
- struct bnode *abnode;
- char *arock;
+static int
+stproc(struct bnode *abnode, void *arock)
{
if (abnode->fileGoal == BSTAT_SHUTDOWN)
return 0; /* don't do these guys */
bnode_Hold(abnode);
+ bnode_ResetErrorCount(abnode);
bnode_SetStat(abnode, BSTAT_NORMAL);
bnode_Release(abnode);
return 0;
}
-static
-sdproc(abnode, arock)
- struct bnode *abnode;
- char *arock;
+static int
+sdproc(struct bnode *abnode, void *arock)
{
bnode_Hold(abnode);
bnode_SetStat(abnode, BSTAT_SHUTDOWN);
/* shutdown and leave down */
afs_int32
-SBOZO_ShutdownAll(acall)
- struct rx_call *acall;
+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 */
/* shutdown and restart */
afs_int32
-SBOZO_RestartAll(acall)
- struct rx_call *acall;
+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(acall)
- register struct rx_call *acall;
+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 */
/* make sure all are running */
afs_int32
-SBOZO_StartupAll(acall)
- struct rx_call *acall;
+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(acall, ainstance)
- 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)) {
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);
/* set temp status */
afs_int32
-SBOZO_SetTStatus(acall, ainstance, astatus)
- struct rx_call *acall;
- char *ainstance;
- afs_int32 astatus;
+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(acall, ainstance, astatus)
- struct rx_call *acall;
- char *ainstance;
- afs_int32 astatus;
+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(acall, ainstance, astat, astatDescr)
- struct rx_call *acall;
- char *ainstance;
- afs_int32 *astat;
- char **astatDescr;
+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) {
int counter;
};
-static
-eifunc(abnode, arock)
- struct bnode *abnode;
- struct eidata *arock;
+static int
+eifunc(struct bnode *abnode, void *param)
{
+ struct eidata *arock = (struct eidata *)param;
+
if (arock->counter-- == 0) {
/* done */
strcpy(arock->iname, abnode->name);
}
}
-static
-ZapFile(adir, aname)
- register char *adir;
- register char *aname;
+static int
+ZapFile(const char *adir, const char *aname)
{
char tbuffer[256];
- strcpy(tbuffer, adir);
- strcat(tbuffer, "/");
- strcat(tbuffer, aname);
- return unlink(tbuffer);
+ if (snprintf(tbuffer, 256, "%s/%s", adir, aname)<256)
+ return unlink(tbuffer);
+ else
+ return -1;
}
afs_int32
-SBOZO_Prune(acall, aflags)
- struct rx_call *acall;
- afs_int32 aflags;
+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(acall, anum, ainstance)
- struct rx_call *acall;
- afs_int32 anum;
- char **ainstance;
+SBOZO_EnumerateInstance(struct rx_call *acall, afs_int32 anum,
+ char **ainstance)
{
struct eidata tdata;
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.
* The other fields in the struct are however, statically initialized.
*/
int
-initBosEntryStats()
+initBosEntryStats(void)
{
bozo_bosEntryStats[0].path = AFSDIR_SERVER_AFS_DIRPATH;
bozo_bosEntryStats[1].path = AFSDIR_SERVER_ETC_DIRPATH;
* read. */
static int
-StatEachEntry(stats)
- IN struct bozo_bosEntryStats *stats;
+StatEachEntry(IN struct bozo_bosEntryStats *stats)
{
struct stat info;
if (stat(stats->path, &info)) {
* this check more often than every 5 seconds. */
int
-DirAccessOK()
+DirAccessOK(void)
{
#ifdef AFS_NT40_ENV
/* underlying filesystem may not support directory protection */
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;
}
int
-GetRequiredDirPerm(path)
- IN char *path;
+GetRequiredDirPerm(const char *path)
{
int i;
for (i = 0; i < bozo_nbosEntryStats; i++)
}
afs_int32
-SBOZO_GetInstanceInfo(acall, ainstance, atype, astatus)
- IN struct rx_call *acall;
- IN char *ainstance;
- OUT char **atype;
- OUT struct bozo_status *astatus;
+SBOZO_GetInstanceInfo(IN struct rx_call *acall,
+ IN char *ainstance,
+ OUT char **atype,
+ OUT struct bozo_status *astatus)
{
- register struct bnode *tb;
+ struct bnode *tb;
tb = bnode_FindInstance(ainstance);
*atype = (char *)malloc(BOZO_BSSIZE);
}
afs_int32
-SBOZO_GetInstanceParm(acall, ainstance, anum, aparm)
- struct rx_call *acall;
- char *ainstance;
- afs_int32 anum;
- char **aparm;
+SBOZO_GetInstanceParm(struct rx_call *acall,
+ char *ainstance,
+ 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);
*aparm = tp;
}
afs_int32
-SBOZO_GetLog(acall, aname)
- 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(acall, abnodeName, as1, as2, as3, as4)
- struct rx_call *acall;
- char *abnodeName;
- char **as1, **as2, **as3, **as4;
+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 = 0;
/* 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 = 0;
return BZNOENT;
}
-#ifdef BOS_RESTRICTED_MODE
afs_int32
-SBOZO_GetRestrictedMode(acall, arestmode)
- struct rx_call *acall;
- afs_int32 *arestmode;
+SBOZO_GetRestrictedMode(struct rx_call *acall, afs_int32 *arestmode)
{
*arestmode = bozo_isrestricted;
return 0;
}
afs_int32
-SBOZO_SetRestrictedMode(acall, arestmode)
- struct rx_call *acall;
- afs_int32 arestmode;
+SBOZO_SetRestrictedMode(struct rx_call *acall, afs_int32 arestmode)
{
afs_int32 code;
char caller[MAXKTCNAMELEN];
}
bozo_isrestricted = arestmode;
code = WriteBozoFile(0);
- fail:
- return code;
-}
-#else
-afs_int32
-SBOZO_GetRestrictedMode(acall, arestmode)
- struct rx_call *acall;
- afs_int32 *arestmode;
-{
- return RXGEN_OPCODE;
-}
-afs_int32
-SBOZO_SetRestrictedMode(acall, arestmode)
- 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