static char outline[maxlinesize];
static struct macro *macrohashtable[macrohashsize];
-static
-error(a0, a1)
- char *a0, *a1;
+static int
+error(char *a0, char *a1)
{
fprintf(stderr, a0, a1);
putc('\n', stderr);
exit(1);
}
-static
-fileerror(a0, a1)
- char *a0, *a1;
+static int
+fileerror(char *a0, char *a1);
{
fprintf(stderr, "%s; line %d: ", filep->name, filep->lineno);
error(a0, a1);
}
-static char *
-strsav(s)
- char *s;
-{
- char *p;
-
- if ((p = malloc(strlen(s) + 1)) == NULL)
- error("Out of Memory");
- strcpy(p, s);
- return p;
-}
-
static struct macro **
-macrolookup(name)
- char *name;
+macrolookup(char *name)
{
register struct macro **mpp, *mp;
register char *cp;
return mpp;
}
-static
-macroundefine(name)
- char *name;
+static void
+macroundefine(char *name)
{
register struct macro **mpp, *mp;
}
}
-static
-macrodefine(name, value, mode)
- char *name;
- char *value;
- enum macromode mode;
+static void
+macrodefine(char *name, char *value, enum macromode mode)
{
register struct macro **mpp, *mp;
} else {
if ((mp = (struct macro *)malloc(sizeof(struct macro))) == 0)
error("Out of memory");
- mp->name = strsav(name);
+ mp->name = strdup(name);
mp->next = 0;
*mpp = mp;
}
mp->mode = mode;
- mp->value = strsav(value);
+ mp->value = strdup(value);
}
static char *
-macroexpand(dst, src)
- register char *dst, *src;
+macroexpand(register char *dst, register char *src)
{
char name[macronamesize];
register char *np;
-static
-readline(line)
- char *line;
+static int
+readline(char *line)
{
while (filep >= &files[0]) {
filep->lineno++;
return 0;
}
-static
-writeline(line)
- char *line;
+static void
+writeline(char *line)
{
fputs(line, stdout);
}
-static
-directive(what)
- char *what;
+static int
+directive(char *what)
{
char *arg[3], *cp;
int n;
filep--;
fileerror("Can't open %s", arg[1]);
}
- filep->name = strsav(arg[1]);
+ filep->name = strdup(arg[1]);
filep->lineno = 0;
return 1;
}
fileerror("Unknown directive %s", arg[0]);
}
-expandfile(name)
- char *name;
+void
+expandfile(char *name)
{
if (strcmp(name, "-") == 0) {
filep->stream = stdin;
- filep->name = strsav("(stdin)");
+ filep->name = strdup("(stdin)");
} else {
if ((filep->stream = fopen(name, "r")) == NULL) {
fileerror("Can't open %s", name);
exit(1);
}
- filep->name = strsav(name);
+ filep->name = strdup(name);
}
filep->lineno = 0;
while (readline(inline)) {
}
}
-static
+static int
usage()
{
fprintf(stderr, "Usage: mpp [-cC][-s][-Dname=value][-Uname][-][files]\n");
#include "AFS_component_version_number.c"
-main(argc, argv)
- int argc;
- char **argv;
+int
+main(int argc, char **argv)
{
argv++, argc--;
if (argc == 0)
* May exit from package.
*------------------------------------------------------------------------*/
-static
-CheckMount(path)
- char *path;
-
+static void
+CheckMount(char *path)
{ /*CheckMount */
-
struct stat stb; /*Parent's stat block */
struct stat stb2; /*Child's stat block */
char dir[MAXPATHLEN]; /*Pathname of candidate mount point */
* verbose, tell everyone.
*/
verbose_message("Found Unix mountpoint %s", dir);
-
} /*CheckMount */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-check(np, path)
- register CTREEPTR np;
- char *path;
-
+check(register CTREEPTR np, char *path)
{ /*check */
register CTREEPTR np2; /*Node ptr for np's child */
*/
(void)closedir(dp);
return (retval);
-
} /*check */
*------------------------------------------------------------------------*/
static int
-namehash(name)
- register char *name;
-
+namehash(register char *name)
{ /*namehash */
register int hash;
*------------------------------------------------------------------------*/
static int
-ValidUpdtSpec(ftype, uspec)
- u_short ftype;
- u_short uspec;
-
+ValidUpdtSpec(u_short ftype, u_short uspec)
{ /*ValidUpdtSpec */
register struct updatetype *u;
*------------------------------------------------------------------------*/
static int
-ValidateUserName(name, uidp)
- register char *name;
- register short *uidp;
-
+ValidateUserName(register char *name, register short *uidp)
{ /*ValidateUserName */
register afs_int32 uid;
*------------------------------------------------------------------------*/
static int
-ValidateGroupName(name, gidp)
- register char *name;
- register short *gidp;
-
+ValidateGroupName(register char *name, register short *gidp)
{ /*ValidateGroupName */
register afs_int32 gid;
*------------------------------------------------------------------------*/
CTREEPTR
-LocateChildNode(dp, name, lmode)
- register CTREEPTR dp;
- register char *name;
- register int lmode;
-
+LocateChildNode(register CTREEPTR dp, register char *name, register int lmode)
{ /*LocateChildNode */
register int hash; /*Hash value for given name */
*------------------------------------------------------------------------*/
CTREEPTR
-LocatePathNode(dp, path, lmode)
- register CTREEPTR dp;
- register char *path;
- register int lmode;
-
+LocatePathNode(register CTREEPTR dp, register char *path, register int lmode)
{ /*LocatePathNode */
-
register char *name; /*Points to start of new subdir/file in path */
register char savech; /*Saves chars being murdered during search */
* just return it.
*/
return (dp);
-
} /*LocatePathNode */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-BuildConfigTree(f)
- FILE *f;
-
+BuildConfigTree(FILE *f)
{ /*BuildConfigTree */
-
int ret;
yyin = f;
ret = yyparse();
return (ret);
-
} /*BuildConfigTree */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-AddEntry(filetype, updtspec, filename, prototype, ownershipinfo, mode)
- u_short filetype;
- u_short updtspec;
- char *filename;
- PROTOTYPE prototype;
- OWNER ownershipinfo;
- MODE mode;
-
+AddEntry(u_short filetype, u_short updtspec, char *filename, PROTOTYPE prototype, OWNER ownershipinfo, MODE mode)
{ /*AddEntry */
-
CTREEPTR np; /*Ptr to config tree node holding info on filename */
short uid, gid; /*Uid, gid returned from validation functions */
*------------------------------------------------------------------------*/
void
-ApplyConfigTree(func)
- int (*func) ();
-
+ApplyConfigTree(int (*func) ())
{ /*ApplyConfigTree */
char *path; /*Path to pass on down */
* Whatever func might do.
*------------------------------------------------------------------------*/
-TraverseConfigTree(np, path, func)
- register CTREEPTR np;
- char *path;
- int (*func) ();
-
+void
+TraverseConfigTree(register CTREEPTR np, char *path, int (*func) ())
{ /*TraverseConfigTree */
-
register char *endp; /*Marks the end of a string */
register ENTRYPTR ep; /*Current entry pointer */
register int len; /*Length of the pathname */
* the path properly before returning.
*/
*--endp = 0;
-
} /*TraverseConfigTree */
*------------------------------------------------------------------------*/
char *
-emalloc(size)
- unsigned size;
-
+emalloc(unsigned int size)
{ /*emalloc */
char *malloc();
exit(ERR_OUTOFMEMORY);
} else
return (ptr);
-
} /*emalloc */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
char *
-ecalloc(nelem, size)
- unsigned nelem;
- unsigned size;
-
+ecalloc(unsigned int nelem, unsigned int size)
{ /*ecalloc */
char *calloc();
*------------------------------------------------------------------------*/
FILE *
-efopen(filename, type)
- char *filename;
- char *type;
-
+efopen(char *filename, char *type)
{ /*efopen */
FILE *f;
static char *
-putnum(dp, n, b)
- register char *dp;
- register unsigned n;
- register int b;
-
+putnum(register char *dp, register unsigned n, register int b)
{ /*putnum */
register int s;
} /*putnum */
static char *
-putstr(dp, s)
- register char *dp;
- register char *s;
-
+putstr(register char *dp, register char *s)
{ /*putstr */
while (*s)
} /*putstr */
static char *
-putformat(dp, fp, ap)
- register char *dp;
- register char *fp;
- register va_list ap;
-
+putformat(register char *dp, register char *fp, register va_list ap)
{ /*putformat */
while (*fp) {
return 1;
}
-sprint(s)
- char *s;
+void
+sprint(char *s)
{
printf("sprint - %s", s);
}
-allprint(i)
- int i;
+void
+allprint(int i)
{
printf("allprint - %d\n", i);
}
*------------------------------------------------------------------------*/
static int
-packageInit(as, arock)
- struct cmd_syndesc *as;
- char *arock;
-
+packageInit(struct cmd_syndesc *as, char *arock)
{ /*packageInit */
-
systype = getsystype();
/*
#include "AFS_component_version_number.c"
-main(argc, argv)
- int argc;
- char **argv;
-
+int
+main(int argc, char **argv)
{ /*main */
register afs_int32 code; /*Return code */
#include "AFS_component_version_number.c"
-main(argc, argv)
- int argc;
- char **argv;
-
+int
+main(int argc, char **argv)
{ /*main */
-
int code; /*Return code */
if (argc > 1)
test_linecounter);
if (yyin != stdin)
fclose(yyin);
-
} /*main */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-AddRegEntry(f, p, o, m, u)
- char *f;
- PROTOTYPE p;
- OWNER o;
- MODE m;
- u_short u;
+AddRegEntry(char *f, PROTOTYPE p, OWNER o, MODE m, u_short u)
{ /*AddRegEntry */
-
printf("F");
echo_updateoptions(u);
printf("%s", f);
echo_ownerinfo(o);
echo_modeinfo(m);
return (0);
-
} /*AddRegEntry */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-AddDirEntry(f, p, o, m, u)
- char *f;
- PROTOTYPE p;
- OWNER o;
- MODE m;
- u_short u;
-
+AddDirEntry(char *f, PROTOTYPE p, OWNER o, MODE m, u_short u)
{ /*AddDirEntry */
printf("D");
*------------------------------------------------------------------------*/
int
-AddLnkEntry(f, p, o, m, u)
- char *f;
- PROTOTYPE p;
- OWNER o;
- MODE m;
- u_short u;
-
+AddLnkEntry(char *f, PROTOTYPE p, OWNER o, MODE m, u_short u)
{ /*AddLnkEntry */
-
printf("L");
echo_updateoptions(u);
printf("%s", f);
echo_ownerinfo(o);
echo_modeinfo(m);
return (0);
-
} /*AddLnkEntry */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-AddBlkEntry(f, p, o, m, u)
- char *f;
- PROTOTYPE p;
- OWNER o;
- MODE m;
- u_short u;
-
+AddBlkEntry(char *f, PROTOTYPE p, OWNER o, MODE m, u_short u)
{ /*AddBlkEntry */
-
printf("B");
echo_updateoptions(u);
printf("%s", f);
echo_ownerinfo(o);
echo_modeinfo(m);
return (0);
-
} /*AddBlkEntry */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-AddChrEntry(f, p, o, m, u)
- char *f;
- PROTOTYPE p;
- OWNER o;
- MODE m;
- u_short u;
-
+AddChrEntry(char *f, PROTOTYPE p, OWNER o, MODE m, u_short u)
{ /*AddChrEntry */
-
printf("C");
echo_updateoptions(u);
printf("%s", f);
echo_ownerinfo(o);
echo_modeinfo(m);
return (0);
-
} /*AddChrEntry */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-AddSktEntry(f)
- char *f;
-
+AddSktEntry(char *f)
{ /*AddSktEntry */
printf("S");
*------------------------------------------------------------------------*/
int
-AddPipeEntry(f, p, o, m, u)
- char *f;
- PROTOTYPE p;
- OWNER o;
- MODE m;
- u_short u;
-
+AddPipeEntry(char *f, PROTOTYPE p, OWNER o, MODE m, u_short u)
{ /*AddPipeEntry */
-
printf("P");
echo_updateoptions(u);
printf("\t%s\n", f);
echo_ownerinfo(o);
echo_modeinfo(m);
return (0);
-
} /*AddPipeEntry */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-echo_updateoptions(u)
- u_short u;
-
+echo_updateoptions(u_short u)
{ /*echo_updateoptions */
-
if (u & U_LOSTFOUND)
printf("X");
if (u & U_RMEXTRA)
printf("Q");
printf("\t");
return (0);
-
} /*echo_updateoptions */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-echo_prototypeinfo(p)
- PROTOTYPE p;
-
+echo_prototypeinfo(PROTOTYPE p)
{ /*echo_prototypeinfo */
-
switch (p.flag) {
case P_FILE:
printf("\t%s", p.info.path);
printf("\t[Neither file nor device]");
break;
}
-
} /*echo_prototypeinfo */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-echo_ownerinfo(o)
- OWNER o;
-
+echo_ownerinfo(OWNER o)
{ /*echo_ownerinfo */
-
if (o.username != NULL)
printf("\t%s", o.username);
else
printf("\t%s", o.groupname);
else
printf("\t[No group info]");
-
} /*echo_ownerinfo */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-echo_modeinfo(m)
- MODE m;
-
+echo_modeinfo(MODE m)
{ /*echo_modeinfo */
-
if (m.inherit_flag != TRUE)
printf("\t%o", m.modeval);
else
printf("\t[Inherited mode]");
printf("\n");
-
} /*echo_modeinfo */
/*------------------------------------------------------------------------
*------------------------------------------------------------------------*/
int
-testAddEntry(a_ftype, a_updspecs, a_filename, a_proto, a_owner, a_mode)
- u_short a_ftype;
- u_short a_updspecs;
- char *a_filename;
- PROTOTYPE a_proto;
- OWNER a_owner;
- MODE a_mode;
-
+testAddEntry(u_short a_ftype, u_short a_updspecs, char *a_filename, PROTOTYPE a_proto, OWNER a_owner, MODE a_mode)
{ /*testAddEntry */
-
switch (a_ftype) {
case S_IFREG: /*Regular file */
AddRegEntry(a_filename, a_proto, a_owner, a_mode, a_updspecs);
break;
} /*switch a_ftype */
-
} /*testAddEntry */
/* $$important: these will have to be fixed with an error recovery mechanism */
int
-update(np, path)
- CTREEPTR np;
- char *path;
-
+update(CTREEPTR np, char *path)
{ /*update */
switch (np->type) {
} /*update */
-static
-UpdateSock(np, path)
- CTREEPTR np;
- char *path;
-
+static void
+UpdateSock(CTREEPTR np, char *path)
{ /*UpdateSock */
(void)dochtyp(np, path);
} /*UpdateSock */
-static
-UpdateDev(np, path)
- CTREEPTR np;
- char *path;
-
+static void
+UpdateDev(CTREEPTR np, char *path)
{ /*UpdateDev */
register int ret;
} /*UpdateDev */
-static
-UpdatePipe(np, path)
- CTREEPTR np;
- char *path;
-
+static void
+UpdatePipe(CTREEPTR np, char *path)
{ /*UpdatePipe */
register int ret;
} /*UpdatePipe */
-static
-UpdateLnk(np, path)
- CTREEPTR np;
- char *path;
-
+static void
+UpdateLnk(CTREEPTR np, char *path)
{ /*UpdateLnk */
register int ret;
} /*UpdateLnk */
-static
-UpdateDir(np, path)
- CTREEPTR np;
- char *path;
-
+static void
+UpdateDir(CTREEPTR np, char *path)
{ /*UpdateDir */
register int ret;
} /*UpdateDir */
-static
-UpdateReg(np, path)
- CTREEPTR np;
- char *path;
-
+static void
+UpdateReg(CTREEPTR np, char *path)
{ /*UpdateReg */
register int ret;
* reboot scenario is true), we return 0.
*/
-static
-dochtyp(np, path)
- CTREEPTR np;
- char *path;
-
+static int
+dochtyp(CTREEPTR np, char *path)
{ /*dochtyp */
-
if (lstat(path, &stb) < 0)
return -1;
#ifdef KFLAG
rm(path);
return -1;
}
-
} /*dochtyp */
-static
-dochmod(np, path)
- CTREEPTR np;
- char *path;
-
+static void
+dochmod(CTREEPTR np, char *path)
{ /*dochmod */
-
if ((np->flag & F_MODE) == 0)
return;
if ((np->mode & ~S_IFMT) == (stb.st_mode & ~S_IFMT))
loudonly_message("chmod %s %o", path, np->mode & ~S_IFMT);
if (!opt_lazy && chmod(path, (int)np->mode & ~S_IFMT) < 0)
message("chmod %s; %m", path);
-
} /*dochmod */
-static
-dochown(np, path)
- CTREEPTR np;
- char *path;
-
+static void
+dochown(CTREEPTR np, char *path)
{ /*dochown */
-
if ((np->flag & F_UID) == 0)
np->uid = stb.st_uid;
if ((np->flag & F_GID) == 0)
loudonly_message("chown %s %d %d", path, np->uid, np->gid);
if (!opt_lazy && chown(path, np->uid, np->gid) < 0)
message("chown %s; %m", path);
-
} /*dochown */
-static
-dochtim(np, path)
- CTREEPTR np;
- char *path;
-
+static void
+dochtim(CTREEPTR np, char *path)
{ /*dochtim */
-
struct timeval tm[2];
if (np->mtime == stb.st_mtime
}
if (!opt_lazy && utimes(path, tm) < 0)
message("utimes %s; %m", path);
-
} /*dochtim */
static int
-FixLostFoundDir(path)
- char *path;
-
+FixLostFoundDir(char *path)
{ /*FixLostFoundDir */
-
if (stb.st_size >= 3584)
return 0;
return mklostfound(path);
-
} /*FixLostFoundDir */
static int
-FixDir(np, path)
- CTREEPTR np;
- char *path;
-
+FixDir(CTREEPTR np, char *path)
{ /*FixDir */
-
register DIR *dp;
register struct dirent *de;
register char *endp;
*--endp = 0;
(void)closedir(dp);
return 0;
-
} /*FixDir */
-static
-FixReg(np, path)
- CTREEPTR np;
- char *path;
-
+static int
+FixReg(CTREEPTR np, char *path)
{ /*FixReg */
-
char new[MAXPATHLEN], old[MAXPATHLEN], temp[MAXPATHLEN];
if (!opt_reboot && (np->updtspec & U_REBOOT)) {
if (np->updtspec & U_REBOOT)
status = status_reboot;
return 0;
-
} /*FixReg */
#define UBIK_HEADERSIZE 64
afs_int32
-printheader(h)
- struct prheader *h;
+printheader(struct prheader *h)
{
printf("Version = %d\n", ntohl(h->version));
printf("Header Size = %d\n", ntohl(h->headerSize));
}
static afs_int32
-pr_Read(pos, buff, len)
- afs_int32 pos;
- char *buff;
- afs_int32 len;
+pr_Read(afs_int32 pos, char *buff, afs_int32 len)
{
afs_int32 code;
}
static afs_int32
-IDHash(x)
- afs_int32 x;
+IDHash(afs_int32 x)
{
/* returns hash bucket for x */
return ((abs(x)) % HASHSIZE);
}
static afs_int32
-NameHash(aname)
- register unsigned char *aname;
+NameHash(register unsigned char *aname)
{
/* returns hash bucket for aname */
register unsigned int hash = 0;
#endif
int
-readUbikHeader(misc)
- struct misc_data *misc;
+readUbikHeader(struct misc_data *misc)
{
int offset, r;
struct ubik_hdr uheader;
}
afs_int32
-ConvertDiskAddress(ea, eiP)
- afs_uint32 ea;
- int *eiP;
+ConvertDiskAddress(afs_uint32 ea, int *eiP)
{
int i;
}
int
-PrintEntryError(misc, ea, e, indent)
- struct misc_data *misc;
- afs_int32 ea;
- struct prentry *e;
- int indent;
+PrintEntryError(struct misc_data *misc, afs_int32 ea, struct prentry *e, int indent)
{
pr_PrintEntry(stderr, /*net order */ 0, ea, e, indent);
}
afs_int32
-WalkHashTable(hashtable, hashType, map, misc)
- afs_int32 hashtable[]; /* hash table to walk */
- int hashType; /* hash function to use */
- char map[]; /* one byte per db entry */
- struct misc_data *misc; /* stuff to keep track of */
+WalkHashTable(afs_int32 hashtable[], /* hash table to walk */
+ int hashType, /* hash function to use */
+ char map[], /* one byte per db entry */
+ struct misc_data *misc) /* stuff to keep track of */
{
afs_int32 code;
int hi; /* index in hash table */
}
afs_int32
-WalkNextChain(map, misc, ea, e)
- char map[]; /* one byte per db entry */
- struct misc_data *misc; /* stuff to keep track of */
- afs_int32 ea;
- struct prentry *e;
+WalkNextChain(char map[], /* one byte per db entry */
+ struct misc_data *misc, /* stuff to keep track of */
+ afs_int32 ea, struct prentry *e)
{
afs_int32 head;
int bit;
}
afs_int32
-WalkOwnedChain(map, misc, ea, e)
- char map[]; /* one byte per db entry */
- struct misc_data *misc; /* stuff to keep track of */
- afs_int32 ea;
- struct prentry *e;
+WalkOwnedChain(char map[], /* one byte per db entry */
+ struct misc_data *misc, /* stuff to keep track of */
+ afs_int32 ea, struct prentry *e)
{
afs_int32 head;
afs_int32 code;
}
afs_int32
-WalkChains(map, misc)
- char map[]; /* one byte per db entry */
- struct misc_data *misc; /* stuff to keep track of */
+WalkChains(char map[], /* one byte per db entry */
+ struct misc_data *misc) /* stuff to keep track of */
{
afs_int32 code;
int ei;
}
afs_int32
-GC(map, misc)
- char map[];
- struct misc_data *misc;
+GC(char map[], struct misc_data *misc)
{
afs_int32 code;
int ei;
id = ntohl(e.id);
#if defined(SUPERGROUPS)
if ((id != ANONYMOUSID)
- && ((refCount = idcount(&misc->idmap, id)) != ntohl(e.count))) {
+ && ((refCount = idcount(&misc->idmap, id)) != ntohl(e.count)))
#else
if ((id >= misc->minId) && (id <= misc->maxId)
&& (id != ANONYMOUSID)
&& ((refCount = misc->idmap[id - misc->minId]) !=
- ntohl(e.count))) {
+ ntohl(e.count)))
#endif /* SUPERGROUPS */
+ {
afs_int32 na;
fprintf(stderr,
"Entry membership count is inconsistent: %d entries refer to this one\n",
}
char *
-QuoteName(s)
- char *s;
+QuoteName(char *s)
{
char *qs;
if (strpbrk(s, " \t")) {
}
afs_int32
-DumpRecreate(map, misc)
- char map[];
- struct misc_data *misc;
+DumpRecreate(char map[], struct misc_data *misc)
{
afs_int32 code;
int ei;
/* check for duplicate id. This may still lead to duplicate
* names. */
#if defined(SUPERGROUPS)
- if (idcount(&idmap, id)) {
+ if (idcount(&idmap, id))
#else
- if (idmap[id - misc->minId]) {
+ if (idmap[id - misc->minId])
#endif
+ {
fprintf(stderr, "Skipping entry with duplicate id %di\n",
id);
goto user_done;
owner = ntohl(e.owner);
#if defined(SUPERGROUPS)
- if (!idcount(&idmap, owner)) {
+ if (!idcount(&idmap, owner))
#else
- if (idmap[owner - misc->minId] == 0) {
+ if (idmap[owner - misc->minId] == 0)
#endif
+ {
fprintf(stderr,
"Skipping chown of '%s' to non-existant owner %di\n",
e.name, owner);
}
afs_int32
-CheckPrDatabase(misc)
- struct misc_data *misc; /* info & statistics */
+CheckPrDatabase(struct misc_data *misc) /* info & statistics */
{
afs_int32 code;
afs_int32 eof;
free(map);
return code;
}
-
+
#include "AFS_component_version_number.c"
-WorkerBee(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+WorkerBee(struct cmd_syndesc *as, char *arock)
{
afs_int32 code;
char *recreateFile;
exit(0);
}
-main(argc, argv)
- int argc;
- char *argv[];
+int
+main(int argc, char *argv[])
{
struct cmd_syndesc *ts;
/* new routines to deal with very large ID numbers */
void
-zeromap(idmap)
- struct idused *idmap;
+zeromap(struct idused *idmap)
{
while (idmap) {
bzero((char *)idmap->idcount, sizeof idmap->idcount);
}
int
-idcount(idmapp, id)
- struct idused **idmapp;
+idcount(struct idused **idmapp, int id)
{
struct idused *idmap;
}
return 0;
}
-
#endif /* SUPERGROUPS */
#define host(a) (hostOrder ? (a) : ntohl(a))
static void
-PrintEntries(f, hostOrder, indent, e, n)
- FILE *f;
- int hostOrder; /* structures in host order */
- int indent;
- struct prentry *e;
- int n;
+PrintEntries(FILE *f, int hostOrder, int indent, struct prentry *e, int n)
{
int i;
int newline;
}
int
-pr_PrintEntry(f, hostOrder, ea, e, indent)
- FILE *f;
- int hostOrder; /* structures in host order */
- afs_int32 ea;
- struct prentry *e;
- int indent;
+pr_PrintEntry(FILE *f, int hostOrder, afs_int32 ea, struct prentry *e, int indent)
{
int i;
#define Aflag (debug_mask & (1L<<('Z'-'@')))
extern int debug_mask;
-#if __STDC__
int
in_map(struct map *parm, long node)
-#else
-int
-in_map(parm, node)
- struct map *parm;
- long node;
-#endif
{
struct bitmap *map;
long bit;
}
void
-free_map(parm)
- struct map *parm;
+free_map(struct map *parm)
{
struct bitmap *map, *next;
#ifdef MAP_DEBUG
}
struct map *
-add_map(parm, node)
- struct map *parm;
- long node;
+add_map(struct map *parm, long node)
{
struct bitmap *map;
long bit;
}
struct bitmap *
-simplify_bitmap(map)
- struct bitmap *map;
+simplify_bitmap(struct bitmap *map)
{
struct bitmap **mpp, *mp2;
int i;
}
struct bitmap *
-or_bitmap(left, right)
- struct bitmap *left, *right;
+or_bitmap(struct bitmap *left, struct bitmap *right)
{
struct bitmap **rightmp, *lmap, *rmap;
int i;
}
struct bitmap *
-and_bitmap(left, right)
- struct bitmap *left, *right;
+and_bitmap(struct bitmap *left, struct bitmap *right)
{
struct bitmap **rightmp, *lmap, *rmap, **leftmp;
int i;
/* bit set in left, but not in right */
struct bitmap *
-bic_bitmap(left, right)
- struct bitmap *left, *right;
+bic_bitmap(struct bitmap *left, struct bitmap *right)
{
struct bitmap **rightmp, *lmap, *rmap, **leftmp;
int i;
}
struct map *
-and_map(mp1, mp2)
- struct map *mp1, *mp2;
+and_map(struct map *mp1, struct map *mp2)
{
#ifdef MAP_DEBUG
if (Mflag) {
}
struct map *
-or_map(mp1, mp2)
- struct map *mp1, *mp2;
+or_map(struct map *mp1, struct map *mp2)
{
#ifdef MAP_DEBUG
if (Mflag) {
}
struct map *
-not_map(map)
- struct map *map;
+not_map(struct map *map)
{
#ifdef MAP_DEBUG
if (Mflag) {
}
struct map *
-copy_map(parm)
- struct map *parm;
+copy_map(struct map *parm)
{
struct bitmap *result, **mpp, *map;
#ifdef MAP_DEBUG
}
long
-count_map(parm)
- struct map *parm;
+count_map(struct map *parm)
{
long nf;
struct bitmap *map;
}
long
-next_map(parm, node)
- struct map *parm;
- long node;
+next_map(struct map *parm, long node)
{
struct bitmap *map, *lowest;
long bit, mask;
}
long
-first_map(parm)
- struct map *parm;
+first_map(struct map *parm)
{
return next_map(parm, -9999);
}
long
-prev_map(parm, node)
- struct map *parm;
- long node;
+prev_map(struct map *parm, long node)
{
struct bitmap *map, *lowest;
long bit, mask;
}
long
-last_map(parm)
- struct map *parm;
+last_map(struct map *parm)
{
return prev_map(parm, 0x7fffffff);
}
struct map *
-negative_map(map)
- struct map *map;
+negative_map(struct map *map)
{
return (struct map *)NEGMAP(map);
}
struct map *
-bic_map(mp1, mp2)
- struct map *mp1, *mp2;
+bic_map(struct map *mp1, struct map *mp2)
{
#ifdef MAP_DEBUG
if (Mflag) {
}
#ifdef PRINT_MAP_ERROR
-print_map(parm)
- struct map *parm;
+void
+print_map(struct map *parm)
{
struct bitmap *map;
int i, j;
#ifdef NEED_READ_WRITE
struct map *
-read_map(f, arg)
- int (*f) ();
- char *arg;
+read_map(int (*f) (), char *arg)
{
struct bitmap *map, *result, **mp;
int page;
return (struct map *)result;
}
-write_map(parm, f, arg)
- struct map *parm;
- int (*f) ();
- char *arg;
+int
+write_map(struct map *parm, int (*f) (), char *arg)
{
struct bitmap *map;
int page;
int wflag = 0;
int flags = 0;
-main(argc, argv)
- int argc;
- char **argv;
+int
+main(int argc, char **argv)
{
register struct cmd_syndesc *cs; /*Command line syntax descriptor */
}
int
-CommandProc(a_as)
- register struct cmd_syndesc *a_as;
+CommandProc(register struct cmd_syndesc *a_as)
{
register int i;
register long code;
}
int
-display_entry(offset)
- int offset;
+display_entry(int offset)
{
register int i;
}
void
-add_group(id)
- long id;
+add_group(long id)
{
struct grp_list *g;
register long i;
}
void
-display_group(id)
- int id;
+display_group(int id)
{
register int i, offset;
int print_grp = 0;
}
void
-fix_pre(pre)
- struct prentry *pre;
+fix_pre(struct prentry *pre)
{
register int i;
}
char *
-id_to_name(id)
- int id;
+id_to_name(int id)
{
register int offset;
static struct prentry pre;
}
char *
-checkin(pre)
- struct prentry *pre;
+checkin(struct prentry *pre)
{
struct hash_entry *he, *last;
register int id;
}
char *
-check_core(id)
- register int id;
+check_core(register int id)
{
struct hash_entry *he;
he = hat[IDHash(id)];
} *shead;
int
-Interactive(as)
- register struct cmd_syndesc *as;
+Interactive(register struct cmd_syndesc *as)
{
finished = 0;
return 0;
}
int
-Quit(as)
- register struct cmd_syndesc *as;
+Quit(register struct cmd_syndesc *as)
{
finished = 1;
return 0;
}
int
-Source(as)
- register struct cmd_syndesc *as;
+Source(register struct cmd_syndesc *as)
{
FILE *fd;
struct sourcestack *sp;
}
int
-Sleep(as)
- register struct cmd_syndesc *as;
+Sleep(register struct cmd_syndesc *as)
{
int delay;
if (!as->parms[0].items) {
}
int
-GetGlobals(as)
- register struct cmd_syndesc *as;
+GetGlobals(register struct cmd_syndesc *as)
{
register afs_int32 code;
char *cell;
}
int
-CleanUp(as)
- register struct cmd_syndesc *as;
+CleanUp(register struct cmd_syndesc *as)
{
#if defined(SUPERGROUPS)
if (as && !strcmp(as->name, "help"))
return 0;
}
-CreateGroup(as)
- register struct cmd_syndesc *as;
+int
+CreateGroup(register struct cmd_syndesc *as)
{
register afs_int32 code;
afs_int32 id;
return 0;
}
-CreateUser(as)
- register struct cmd_syndesc *as;
+int
+CreateUser(register struct cmd_syndesc *as)
{
register afs_int32 code;
afs_int32 id;
#ifdef notdef
int
-GetNameOrId(as, lids, lnames)
- register struct cmd_syndesc *as;
- struct idlist *lids;
- struct namelist *lnames;
+GetNameOrId(register struct cmd_syndesc *as, struct idlist *lids, struct namelist *lnames)
{
register afs_int32 code = 0;
int n = 0;
int
-GetNameOrId(as, lids, lnames)
- register struct cmd_syndesc *as;
- struct idlist *lids;
- struct namelist *lnames;
+GetNameOrId(register struct cmd_syndesc *as, struct idlist *lids, struct namelist *lnames)
{
register afs_int32 code = 0;
int n = 0, nd = 0, nm = 0, id, x;
}
-AddToGroup(as)
- register struct cmd_syndesc *as;
+int
+AddToGroup(register struct cmd_syndesc *as)
{
register afs_int32 code;
struct cmd_item *u, *g;
return 0;
}
-RemoveFromGroup(as)
- register struct cmd_syndesc *as;
+int
+RemoveFromGroup(register struct cmd_syndesc *as)
{
register afs_int32 code;
struct cmd_item *u, *g;
return 0;
}
-ListMembership(as)
- register struct cmd_syndesc *as;
+int
+ListMembership(register struct cmd_syndesc *as)
{
register afs_int32 code;
idlist ids;
return 0;
}
-Delete(as)
- register struct cmd_syndesc *as;
+int
+Delete(register struct cmd_syndesc *as)
{
register afs_int32 code;
idlist ids;
char *flags_dncase = "s mar"; /* legal member acces values */
int flags_shift[5] = { 2, 1, 2, 2, 1 }; /* bits for each */
-CheckEntry(as)
- register struct cmd_syndesc *as;
+int
+CheckEntry(register struct cmd_syndesc *as)
{
register afs_int32 code;
afs_int32 rcode = 1;
return (rcode);
}
-ListEntries(as)
- struct cmd_syndesc *as;
+int
+ListEntries(struct cmd_syndesc *as)
{
afs_int32 code = 0;
afs_int32 flag, startindex, nentries, nextstartindex;
return code;
}
-ChownGroup(as)
- register struct cmd_syndesc *as;
+int
+ChownGroup(register struct cmd_syndesc *as)
{
register afs_int32 code;
char *name;
return code;
}
-ChangeName(as)
- register struct cmd_syndesc *as;
+int
+ChangeName(register struct cmd_syndesc *as)
{
register afs_int32 code;
char *oldname;
return code;
}
-ListMax(as)
- register struct cmd_syndesc *as;
+int
+ListMax(register struct cmd_syndesc *as)
{
register afs_int32 code;
afs_int32 maxUser, maxGroup;
return code;
}
-SetMax(as)
- register struct cmd_syndesc *as;
+int
+SetMax(register struct cmd_syndesc *as)
{
register afs_int32 code;
afs_int32 maxid;
return code;
}
-SetFields(as)
- register struct cmd_syndesc *as;
+int
+SetFields(register struct cmd_syndesc *as)
{
register afs_int32 code;
idlist ids;
return 0;
}
-ListOwned(as)
- register struct cmd_syndesc *as;
+int
+ListOwned(register struct cmd_syndesc *as)
{
register afs_int32 code;
idlist ids;
}
static void
-add_std_args(ts)
- register struct cmd_syndesc *ts;
+add_std_args(register struct cmd_syndesc *ts)
{
char test_help[AFSDIR_PATH_MAX];
#include "AFS_component_version_number.c"
int
-main(argc, argv)
- int argc;
- char **argv;
+main(int argc, char **argv)
{
register afs_int32 code;
register struct cmd_syndesc *ts;
/* check whether caller is authorized to manage RX statistics */
int
-pr_rxstat_userok(call)
- struct rx_call *call;
+pr_rxstat_userok(struct rx_call *call)
{
return afsconf_SuperUser(prdir, call, NULL);
}
static char *whoami = "libprot";
afs_int32
-pr_Initialize(secLevel, confDir, cell)
- IN afs_int32 secLevel;
- IN char *confDir;
- IN char *cell;
+pr_Initialize(IN afs_int32 secLevel, IN char *confDir, IN char *cell)
{
afs_int32 code;
struct rx_connection *serverconns[MAXSERVERS];
return code;
}
-
+int
pr_End()
{
int code = 0;
-pr_CreateUser(name, id)
- char name[PR_MAXNAMELEN];
- afs_int32 *id;
+int
+pr_CreateUser(char name[PR_MAXNAMELEN], afs_int32 *id)
{
register afs_int32 code;
}
-pr_CreateGroup(name, owner, id)
- char name[PR_MAXNAMELEN];
- char owner[PR_MAXNAMELEN];
- afs_int32 *id;
+int
+pr_CreateGroup(char name[PR_MAXNAMELEN], char owner[PR_MAXNAMELEN], afs_int32 *id)
{
register afs_int32 code;
afs_int32 oid = 0;
}
}
-pr_Delete(name)
- char *name;
+int
+pr_Delete(char *name)
{
register afs_int32 code;
afs_int32 id;
return code;
}
-pr_DeleteByID(id)
- afs_int32 id;
+int
+pr_DeleteByID(afs_int32 id)
{
register afs_int32 code;
return code;
}
-pr_AddToGroup(user, group)
- char *user;
- char *group;
+int
+pr_AddToGroup(char *user, char *group)
{
register afs_int32 code;
namelist lnames;
return code;
}
-pr_RemoveUserFromGroup(user, group)
- char *user;
- char *group;
+int
+pr_RemoveUserFromGroup(char *user, char *group)
{
register afs_int32 code;
namelist lnames;
}
-pr_NameToId(names, ids)
- namelist *names;
- idlist *ids;
+int
+pr_NameToId(namelist *names, idlist *ids)
{
register afs_int32 code;
register afs_int32 i;
return code;
}
-pr_SNameToId(name, id)
- char name[PR_MAXNAMELEN];
- afs_int32 *id;
+int
+pr_SNameToId(char name[PR_MAXNAMELEN], afs_int32 *id)
{
namelist lnames;
idlist lids;
return code;
}
-
-
-pr_IdToName(ids, names)
- idlist *ids;
- namelist *names;
+int
+pr_IdToName(idlist *ids, namelist *names)
{
register afs_int32 code;
return code;
}
-pr_SIdToName(id, name)
- afs_int32 id;
- char name[PR_MAXNAMELEN];
+int
+pr_SIdToName(afs_int32 id, char name[PR_MAXNAMELEN])
{
namelist lnames;
idlist lids;
return code;
}
-
-
-pr_GetCPS(id, CPS)
- afs_int32 id;
- prlist *CPS;
+int
+pr_GetCPS(afs_int32 id, prlist *CPS)
{
register afs_int32 code;
afs_int32 over;
return 0;
}
-
-pr_GetCPS2(id, host, CPS)
- afs_int32 id;
- afs_int32 host;
- prlist *CPS;
+int
+pr_GetCPS2(afs_int32 id, afs_int32 host, prlist *CPS)
{
register afs_int32 code;
afs_int32 over;
return 0;
}
-pr_GetHostCPS(host, CPS)
- afs_int32 host;
- prlist *CPS;
+int
+pr_GetHostCPS(afs_int32 host, prlist *CPS)
{
register afs_int32 code;
afs_int32 over;
return 0;
}
-
-pr_ListMembers(group, lnames)
- char *group;
- namelist *lnames;
+int
+pr_ListMembers(char *group, namelist *lnames)
{
register afs_int32 code;
afs_int32 gid;
return code;
}
-pr_ListOwned(oid, lnames, moreP)
- afs_int32 oid;
- namelist *lnames;
- afs_int32 *moreP;
+int
+pr_ListOwned(afs_int32 oid, namelist *lnames, afs_int32 *moreP)
{
register afs_int32 code;
prlist alist;
return PRSUCCESS;
}
-pr_IDListMembers(gid, lnames)
- afs_int32 gid;
- namelist *lnames;
+int
+pr_IDListMembers(afs_int32 gid, namelist *lnames)
{
register afs_int32 code;
prlist alist;
return PRSUCCESS;
}
-
-pr_ListEntry(id, aentry)
- afs_int32 id;
- struct prcheckentry *aentry;
+int
+pr_ListEntry(afs_int32 id, struct prcheckentry *aentry)
{
register afs_int32 code;
}
afs_int32
-pr_ListEntries(flag, startindex, nentries, entries, nextstartindex)
- afs_int32 startindex;
- afs_int32 *nentries;
- struct prlistentries **entries;
- afs_int32 *nextstartindex;
+pr_ListEntries(int flag, afs_int32 startindex, afs_int32 *nentries, struct prlistentries **entries, afs_int32 *nextstartindex)
{
afs_int32 code;
prentries bulkentries;
return code;
}
-pr_CheckEntryByName(name, id, owner, creator)
- char *name;
- afs_int32 *id;
- char *owner;
- char *creator;
+int
+pr_CheckEntryByName(char *name, afs_int32 *id, char *owner, char *creator)
{
/* struct prcheckentry returns other things, which aren't useful to show at this time. */
register afs_int32 code;
return PRSUCCESS;
}
-pr_CheckEntryById(name, id, owner, creator)
- char *name;
- afs_int32 id;
- char *owner;
- char *creator;
+int
+pr_CheckEntryById(char *name, afs_int32 id, char *owner, char *creator)
{
/* struct prcheckentry returns other things, which aren't useful to show at this time. */
register afs_int32 code;
return PRSUCCESS;
}
-pr_ChangeEntry(oldname, newname, newid, newowner)
- char *oldname;
- char *newname;
- afs_int32 *newid;
- char *newowner;
+int
+pr_ChangeEntry(char *oldname, char *newname, afs_int32 *newid, char *newowner)
{
register afs_int32 code;
afs_int32 id;
return code;
}
-pr_IsAMemberOf(uname, gname, flag)
- char *uname;
- char *gname;
- afs_int32 *flag;
+int
+pr_IsAMemberOf(char *uname, char *gname, afs_int32 *flag)
{
register afs_int32 code;
namelist lnames;
return code;
}
-
-pr_ListMaxUserId(mid)
- afs_int32 *mid;
+int
+pr_ListMaxUserId(afs_int32 *mid)
{
register afs_int32 code;
afs_int32 gid;
return code;
}
-pr_SetMaxUserId(mid)
- afs_int32 mid;
+int
+pr_SetMaxUserId(afs_int32 mid)
{
register afs_int32 code;
afs_int32 flag = 0;
return code;
}
-pr_ListMaxGroupId(mid)
- afs_int32 *mid;
+int
+pr_ListMaxGroupId(afs_int32 *mid)
{
register afs_int32 code;
afs_int32 id;
return code;
}
-pr_SetMaxGroupId(mid)
- afs_int32 mid;
+int
+pr_SetMaxGroupId(afs_int32 mid)
{
register afs_int32 code;
afs_int32 flag = 0;
}
afs_int32
-pr_SetFieldsEntry(id, mask, flags, ngroups, nusers)
- afs_int32 id;
- afs_int32 mask;
- afs_int32 flags, ngroups, nusers;
+pr_SetFieldsEntry(afs_int32 id, afs_int32 mask, afs_int32 flags, afs_int32 ngroups, afs_int32 nusers)
{
register afs_int32 code;
return code;
}
-
int
-stolower(s)
- char *s;
+stolower(char *s)
{
while (*s) {
if (isupper(*s))
int (*pt_save_dbase_write) ();
int
-pt_mywrite(tdb, fno, bp, pos, count)
- struct ubik_dbase *tdb;
- afs_int32 fno, pos, count;
- char *bp;
+pt_mywrite(struct ubik_dbase *tdb, afs_int32 fno, char *bp, afs_int32 pos, afs_int32 count)
{
afs_uint32 headersize = ntohl(cheader.headerSize);
* just after ubik_ServerInit.
*/
+void
pt_hook_write()
{
extern struct ubik_dbase *ubik_dbase;
* return one if name is OK and zero if name is bogus. */
static int
-CorrectUserName(name)
- char *name;
+CorrectUserName(char *name)
{
extern int pr_realmNameLen;
* rename, which then compares the correct name with the requested new name. */
static afs_int32
-CorrectGroupName(ut, aname, cid, oid, cname)
- struct ubik_trans *ut;
- char aname[PR_MAXNAMELEN]; /* name for group */
- afs_int32 cid; /* caller id */
- afs_int32 oid; /* owner of group */
- char cname[PR_MAXNAMELEN]; /* correct name for group */
+CorrectGroupName(struct ubik_trans *ut, char aname[PR_MAXNAMELEN], /* name for group */
+ afs_int32 cid, /* caller id */
+ afs_int32 oid, /* owner of group */
+ char cname[PR_MAXNAMELEN]) /* correct name for group */
{
afs_int32 code;
int admin;
}
int
-AccessOK(ut, cid, tentry, mem, any)
- struct ubik_trans *ut;
- afs_int32 cid; /* caller id */
- struct prentry *tentry; /* object being accessed */
- int mem; /* check membership in aid, if group */
- int any; /* if set return true */
+AccessOK(struct ubik_trans *ut, afs_int32 cid, /* caller id */
+ struct prentry *tentry, /* object being accessed */
+ int mem, /* check membership in aid, if group */
+ int any) /* if set return true */
{
afs_int32 flags;
afs_int32 oid;
}
afs_int32
-CreateEntry(at, aname, aid, idflag, flag, oid, creator)
- struct ubik_trans *at;
- char aname[PR_MAXNAMELEN];
- afs_int32 *aid;
- afs_int32 idflag;
- afs_int32 flag;
- afs_int32 oid;
- afs_int32 creator;
+CreateEntry(struct ubik_trans *at, char aname[PR_MAXNAMELEN], afs_int32 *aid, afs_int32 idflag, afs_int32 flag, afs_int32 oid, afs_int32 creator)
{
/* get and init a new entry */
afs_int32 code;
* entry if appropriate */
afs_int32
-RemoveFromEntry(at, aid, bid)
- struct ubik_trans *at;
- afs_int32 aid;
- afs_int32 bid;
+RemoveFromEntry(struct ubik_trans *at, afs_int32 aid, afs_int32 bid)
{
afs_int32 code;
struct prentry tentry;
* entry if appropriate */
afs_int32
-ChangeIDEntry(at, aid, newid, bid)
- register struct ubik_trans *at;
- register afs_int32 aid;
- register afs_int32 bid;
- afs_int32 newid;
+ChangeIDEntry(register struct ubik_trans *at, register afs_int32 aid, afs_int32 newid, register afs_int32 bid)
{
register afs_int32 code;
struct prentry tentry;
* continuation entry if appropriate */
afs_int32
-RemoveFromSGEntry(at, aid, bid)
- register struct ubik_trans *at;
- register afs_int32 aid;
- register afs_int32 bid;
+RemoveFromSGEntry(register struct ubik_trans *at, register afs_int32 aid, register afs_int32 bid)
{
register afs_int32 code;
struct prentry tentry;
* groups, putting groups owned by it on orphan chain, and freeing the space */
afs_int32
-DeleteEntry(at, tentry, loc)
- struct ubik_trans *at;
- struct prentry *tentry;
- afs_int32 loc;
+DeleteEntry(struct ubik_trans *at, struct prentry *tentry, afs_int32 loc)
{
afs_int32 code;
struct contentry centry;
* Note the entry is written out by this routine. */
afs_int32
-AddToEntry(tt, entry, loc, aid)
- struct ubik_trans *tt;
- struct prentry *entry;
- afs_int32 loc;
- afs_int32 aid;
+AddToEntry(struct ubik_trans *tt, struct prentry *entry, afs_int32 loc, afs_int32 aid)
{
afs_int32 code;
afs_int32 i;
* Note the entry is written out by this routine. */
afs_int32
-AddToSGEntry(tt, entry, loc, aid)
- struct ubik_trans *tt;
- struct prentry *entry;
- afs_int32 loc;
- afs_int32 aid;
+AddToSGEntry(struct ubik_trans *tt, struct prentry *entry, afs_int32 loc, afs_int32 aid)
{
register afs_int32 code;
afs_int32 i;
#endif /* SUPERGROUPS */
afs_int32
-AddToPRList(alist, sizeP, id)
- prlist *alist;
- int *sizeP;
- afs_int32 id;
+AddToPRList(prlist *alist, int *sizeP, afs_int32 id)
{
char *tmp;
int count;
}
afs_int32
-GetList(at, tentry, alist, add)
- struct ubik_trans *at;
- struct prentry *tentry;
- prlist *alist;
- afs_int32 add;
+GetList(struct ubik_trans *at, struct prentry *tentry, prlist *alist, afs_int32 add)
{
afs_int32 code;
afs_int32 i;
afs_int32
-GetList2(at, tentry, tentry2, alist, add)
- struct ubik_trans *at;
- struct prentry *tentry;
- struct prentry *tentry2;
- prlist *alist;
- afs_int32 add;
+GetList2(struct ubik_trans *at, struct prentry *tentry, struct prentry *tentry2, prlist *alist, afs_int32 add)
{
afs_int32 code = 0;
afs_int32 i;
#if defined(SUPERGROUPS)
afs_int32
-GetListSG2(at, gid, alist, sizeP, depth)
- struct ubik_trans *at;
- afs_int32 gid;
- prlist *alist;
- afs_int32 depth;
- afs_int32 *sizeP;
+GetListSG2(struct ubik_trans *at, afs_int32 gid, prlist *alist, afs_int32 *sizeP, afs_int32 depth)
{
register afs_int32 code;
struct prentry tentry;
}
afs_int32
-GetSGList(at, tentry, alist)
- struct ubik_trans *at;
- struct prentry *tentry;
- prlist *alist;
+GetSGList(struct ubik_trans *at, struct prentry *tentry, prlist *alist)
{
register afs_int32 code;
afs_int32 i;
#endif /* SUPERGROUPS */
afs_int32
-GetOwnedChain(ut, next, alist)
- struct ubik_trans *ut;
- afs_int32 *next;
- prlist *alist;
+GetOwnedChain(struct ubik_trans *ut, afs_int32 *next, prlist *alist)
{
afs_int32 code;
struct prentry tentry;
}
afs_int32
-GetMax(at, uid, gid)
- struct ubik_trans *at;
- afs_int32 *uid;
- afs_int32 *gid;
+GetMax(struct ubik_trans *at, afs_int32 *uid, afs_int32 *gid)
{
*uid = ntohl(cheader.maxID);
*gid = ntohl(cheader.maxGroup);
}
afs_int32
-SetMax(at, id, flag)
- struct ubik_trans *at;
- afs_int32 id;
- afs_int32 flag;
+SetMax(struct ubik_trans *at, afs_int32 id, afs_int32 flag)
{
afs_int32 code;
if (flag & PRGRP) {
}
afs_int32
-read_DbHeader(tt)
- struct ubik_trans *tt;
+read_DbHeader(struct ubik_trans *tt)
{
afs_int32 code;
}
afs_int32
-ChangeEntry(at, aid, cid, name, oid, newid)
- struct ubik_trans *at;
- afs_int32 aid;
- afs_int32 cid;
- char *name;
- afs_int32 oid;
- afs_int32 newid;
+ChangeEntry(struct ubik_trans *at, afs_int32 aid, afs_int32 cid, char *name, afs_int32 oid, afs_int32 newid)
{
afs_int32 code;
afs_int32 i, nptr, pos;
}
-AddAuthGroup(tentry, alist, size)
- struct prentry *tentry;
- prlist *alist;
- afs_int32 *size;
+int
+AddAuthGroup(struct prentry *tentry, prlist *alist, afs_int32 *size)
{
if (!(strchr(tentry->name, '@')))
return (AddToPRList(alist, size, AUTHUSERID));
void skip();
void
-report_error(code, name, gname)
- afs_int32 code;
- char *name;
- char *gname;
+report_error(afs_int32 code, char *name, char *gname)
{
if (code == 0) {
if (verbose)
#include "AFS_component_version_number.c"
-main(argc, argv)
- afs_int32 argc;
- char **argv;
+int
+main(int argc, char **argv)
{
register afs_int32 code;
char name[PR_MAXNAMELEN];
}
void
-skip(s)
- char **s;
+skip(char **s)
{
while (**s != ' ' && **s != '\t' && **s != '\0')
(*s)++;
#include "AFS_component_version_number.c"
-main(argc, argv)
- afs_int32 argc;
- char **argv;
+int
+main(afs_int32 argc, char **argv)
{
register afs_int32 code;
static char conf_dir[100];
static char lcell[MAXCELLCHARS];
-ListUsedIds(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+ListUsedIds(struct cmd_syndesc *as, char *arock)
{
afs_int32 code;
namelist lnames;
int nUsers, nGroups, nAdds, nRems, nUDels, nGDels;
int
-IdCmp(a, b)
- afs_int32 *a;
- afs_int32 *b;
+IdCmp(afs_int32 *a, afs_int32 *b)
{
if (*a > *b) {
return 1;
}
static int
-sqr(n)
- int n;
+sqr(int n)
{
return n * n;
}
static int
-GetGroupLimit(N, x)
- int N;
- int x;
+GetGroupLimit(int N, int x)
{
int y;
double sqrt();
}
void
-CreateUser(u)
- int u;
+CreateUser(int u)
{
afs_int32 code;
char name[16];
}
void
-CreateGroup(g)
- int g;
+CreateGroup(int g)
{
afs_int32 code;
char name[16];
}
int
-DeleteRandomId(list)
- afs_int32 *list;
+DeleteRandomId(afs_int32 *list)
{
afs_int32 code;
afs_int32 id;
}
void
-AddUser(u, g)
- int u, g;
+AddUser(int u, int g)
{
afs_int32 code;
afs_int32 ui, gi;
}
void
-RemUser(u, g)
- int u, g;
+RemUser(int u, int g)
{
afs_int32 code;
afs_int32 ui, gi;
nRems++;
}
-TestManyMembers(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+TestManyMembers(struct cmd_syndesc *as, char *arock)
{
char *filled; /* users filled up */
char *cleaned; /* users cleaned up */
/* Converts a byte string to ascii. Return the number of unconverted bytes. */
static int
-ka_ConvertBytes(ascii, alen, bs, bl)
- char *ascii; /* output buffer */
- int alen; /* buffer length */
- char bs[]; /* byte string */
- int bl; /* number of bytes */
+ka_ConvertBytes(char *ascii, /* output buffer */
+ int alen, /* buffer length */
+ char bs[], /* byte string */
+ int bl) /* number of bytes */
{
int i;
unsigned char c;
* must be correct.
*/
-TestPrServ(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+int
+TestPrServ(struct cmd_syndesc *as, char *arock)
{
afs_int32 id;
char name[PR_MAXNAMELEN + 1];
static char tmp_noauth_file[128] = "";
static int
-MyAfterProc(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+MyAfterProc(struct cmd_syndesc *as, char *arock)
{
if (strlen(tmp_conf_file))
unlink(tmp_conf_file);
}
static int
-MyBeforeProc(as, arock)
- struct cmd_syndesc *as;
- char *arock;
+MyBeforeProc(struct cmd_syndesc *as, char *arock)
{
afs_int32 code;
int i;
}
static void
-add_std_args(ts)
- register struct cmd_syndesc *ts;
+add_std_args(register struct cmd_syndesc *ts)
{
cmd_Seek(ts, 12);
cmd_AddParm(ts, "-confdir", CMD_SINGLE, CMD_OPTIONAL,
#include "AFS_component_version_number.c"
-main(argc, argv)
- int argc;
- char *argv[];
+int
+main(int argc, char *argv[])
{
afs_int32 code;
struct cmd_syndesc *ts; /* ptr to parsed command line syntax */
#endif
afs_int32
-IDHash(x)
- afs_int32 x;
+IDHash(afs_int32 x)
{
/* returns hash bucket for x */
return ((abs(x)) % HASHSIZE);
}
afs_int32
-NameHash(aname)
- register unsigned char *aname;
+NameHash(register unsigned char *aname)
{
/* returns hash bucket for aname */
register unsigned int hash = 0;
afs_int32
-pr_Write(tt, afd, pos, buff, len)
- struct ubik_trans *tt;
- afs_int32 afd;
- afs_int32 pos;
- char *buff;
- afs_int32 len;
+pr_Write(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, char *buff, afs_int32 len)
{
/* package up seek and write into one procedure for ease of use */
afs_int32 code;
}
afs_int32
-pr_Read(tt, afd, pos, buff, len)
- struct ubik_trans *tt;
- afs_int32 afd;
- afs_int32 pos;
- char *buff;
- afs_int32 len;
+pr_Read(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, char *buff, afs_int32 len)
{
/* same thing for read */
afs_int32 code;
return code;
}
-pr_WriteEntry(tt, afd, pos, tentry)
- struct ubik_trans *tt;
- afs_int32 afd;
- afs_int32 pos;
- struct prentry *tentry;
+int
+pr_WriteEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct prentry *tentry)
{
afs_int32 code;
register afs_int32 i;
return (code);
}
-pr_ReadEntry(tt, afd, pos, tentry)
- struct ubik_trans *tt;
- afs_int32 afd;
- afs_int32 pos;
- struct prentry *tentry;
+int
+pr_ReadEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct prentry *tentry)
{
afs_int32 code;
register afs_int32 i;
return (code);
}
-pr_WriteCoEntry(tt, afd, pos, tentry)
- struct ubik_trans *tt;
- afs_int32 afd;
- afs_int32 pos;
- struct contentry *tentry;
+int
+pr_WriteCoEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct contentry *tentry)
{
afs_int32 code;
register afs_int32 i;
return (code);
}
-pr_ReadCoEntry(tt, afd, pos, tentry)
- struct ubik_trans *tt;
- afs_int32 afd;
- afs_int32 pos;
- struct contentry *tentry;
+int
+pr_ReadCoEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct contentry *tentry)
{
afs_int32 code;
register afs_int32 i;
* new entry */
afs_int32
-AllocBlock(at)
- register struct ubik_trans *at;
+AllocBlock(register struct ubik_trans *at)
{
register afs_int32 code;
afs_int32 temp;
}
afs_int32
-FreeBlock(at, pos)
- register struct ubik_trans *at;
- afs_int32 pos;
+FreeBlock(register struct ubik_trans *at, afs_int32 pos)
{
/* add a block of storage to the free list */
register afs_int32 code;
}
afs_int32
-FindByID(at, aid)
- register struct ubik_trans *at;
- afs_int32 aid;
+FindByID(register struct ubik_trans *at, afs_int32 aid)
{
/* returns address of entry if found, 0 otherwise */
register afs_int32 code;
return 0;
}
-
-
afs_int32
-FindByName(at, aname, tentryp)
- register struct ubik_trans *at;
- char aname[PR_MAXNAMELEN];
- struct prentry *tentryp;
+FindByName(register struct ubik_trans *at, char aname[PR_MAXNAMELEN], struct prentry *tentryp)
{
/* ditto */
register afs_int32 code;
}
afs_int32
-AllocID(at, flag, aid)
- register struct ubik_trans *at;
- afs_int32 flag;
- afs_int32 *aid;
+AllocID(register struct ubik_trans *at, afs_int32 flag, afs_int32 *aid)
{
/* allocs an id from the proper area of address space, based on flag */
register afs_int32 code = 1;
}
afs_int32
-IDToName(at, aid, aname)
- register struct ubik_trans *at;
- afs_int32 aid;
- char aname[PR_MAXNAMELEN];
+IDToName(register struct ubik_trans *at, afs_int32 aid, char aname[PR_MAXNAMELEN])
{
afs_int32 temp;
struct prentry tentry;
}
afs_int32
-NameToID(at, aname, aid)
- register struct ubik_trans *at;
- char aname[PR_MAXNAMELEN];
- afs_int32 *aid;
+NameToID(register struct ubik_trans *at, char aname[PR_MAXNAMELEN], afs_int32 *aid)
{
afs_int32 temp;
struct prentry tentry;
}
int
-IDCmp(a, b)
- afs_int32 *a;
- afs_int32 *b;
+IDCmp(afs_int32 *a, afs_int32 *b)
{
/* used to sort CPS's so that comparison with acl's is easier */
if (*a > *b) {
}
afs_int32
-RemoveFromIDHash(tt, aid, loc)
- struct ubik_trans *tt;
- afs_int32 aid;
- afs_int32 *loc; /* ??? in case ID hashed twice ??? */
+RemoveFromIDHash(struct ubik_trans *tt, afs_int32 aid, afs_int32 *loc) /* ??? in case ID hashed twice ??? */
{
/* remove entry designated by aid from id hash table */
register afs_int32 code;
}
afs_int32
-AddToIDHash(tt, aid, loc)
- struct ubik_trans *tt;
- afs_int32 aid;
- afs_int32 loc; /* ??? */
+AddToIDHash(struct ubik_trans *tt, afs_int32 aid, afs_int32 loc)
{
/* add entry at loc designated by aid to id hash table */
register afs_int32 code;
}
afs_int32
-RemoveFromNameHash(tt, aname, loc)
- struct ubik_trans *tt;
- char *aname;
- afs_int32 *loc;
+RemoveFromNameHash(struct ubik_trans *tt, char *aname, afs_int32 *loc)
{
/* remove from name hash */
register afs_int32 code;
}
afs_int32
-AddToNameHash(tt, aname, loc)
- struct ubik_trans *tt;
- char *aname;
- afs_int32 loc;
+AddToNameHash(struct ubik_trans *tt, char *aname, afs_int32 loc)
{
/* add to name hash */
register afs_int32 code;
}
afs_int32
-AddToOwnerChain(at, gid, oid)
- struct ubik_trans *at;
- afs_int32 gid;
- afs_int32 oid;
+AddToOwnerChain(struct ubik_trans *at, afs_int32 gid, afs_int32 oid)
{
/* add entry designated by gid to owner chain of entry designated by oid */
register afs_int32 code;
/* RemoveFromOwnerChain - remove gid from owner chain for oid */
afs_int32
-RemoveFromOwnerChain(at, gid, oid)
- struct ubik_trans *at;
- afs_int32 gid;
- afs_int32 oid;
+RemoveFromOwnerChain(struct ubik_trans *at, afs_int32 gid, afs_int32 oid)
{
register afs_int32 code;
afs_int32 nptr;
/* AddToOrphan - add gid to orphan list, as it's owner has died */
afs_int32
-AddToOrphan(at, gid)
- struct ubik_trans *at;
- afs_int32 gid;
+AddToOrphan(struct ubik_trans *at, afs_int32 gid)
{
register afs_int32 code;
afs_int32 loc;
}
afs_int32
-RemoveFromOrphan(at, gid)
- struct ubik_trans *at;
- afs_int32 gid;
+RemoveFromOrphan(struct ubik_trans *at, afs_int32 gid)
{
/* remove gid from the orphan list */
register afs_int32 code;
}
afs_int32
-IsOwnerOf(at, aid, gid)
- struct ubik_trans *at;
- afs_int32 aid;
- afs_int32 gid;
+IsOwnerOf(struct ubik_trans *at, afs_int32 aid, afs_int32 gid)
{
/* returns 1 if aid is the owner of gid, 0 otherwise */
register afs_int32 code;
}
afs_int32
-OwnerOf(at, gid)
- struct ubik_trans *at;
- afs_int32 gid;
+OwnerOf(struct ubik_trans *at, afs_int32 gid)
{
/* returns the owner of gid */
register afs_int32 code;
afs_int32
-IsAMemberOf(at, aid, gid)
- struct ubik_trans *at;
- afs_int32 aid;
- afs_int32 gid;
+IsAMemberOf(struct ubik_trans *at, afs_int32 aid, afs_int32 gid)
{
/* returns true if aid is a member of gid */
#if !defined(SUPERGROUPS)
#if defined(SUPERGROUPS)
-
afs_int32
-IsAMemberOfSG(at, aid, gid, depth)
- struct ubik_trans *at;
- afs_int32 aid;
- afs_int32 gid;
- afs_int32 depth;
+IsAMemberOfSG(struct ubik_trans *at, afs_int32 aid, afs_int32 gid, afs_int32 depth)
{
/* returns true if aid is a member of gid */
struct prentry tentry;
}
return 0; /* actually, should never get here */
}
-
#endif /* SUPERGROUPS */
}
return 0;
}
+
+rxkad_level
+rxkad_StringToLevel(char *name)
+{
+ if (strcmp(name, "clear") == 0)
+ return rxkad_clear;
+ if (strcmp(name, "auth") == 0)
+ return rxkad_auth;
+ if (strcmp(name, "crypt") == 0)
+ return rxkad_crypt;
+ return -1;
+}
+
+char *
+rxkad_LevelToString(rxkad_level level)
+{
+ if (level == rxkad_clear)
+ return "clear";
+ if (level == rxkad_auth)
+ return "auth";
+ if (level == rxkad_crypt)
+ return "crypt";
+ return "unknown";
+}
extern int rxkad_GetStats(struct rx_securityClass *aobj,
struct rx_connection *aconn,
struct rx_securityObjectStats *astats);
+extern rxkad_level rxkad_StringToLevel(char *string);
+extern char *rxkad_LevelToString(rxkad_level level);
/* rxkad_errs.c */
#include <afs/cellconfig.h>
#include <afs/afsutil.h>
#include <afs/fileutil.h>
+#ifdef AFS_AIX_ENV
+#include <sys/statfs.h>
+#endif
#include "update.h"
#include "global.h"
static int PathsAreEquivalent(char *path1, char *path2);
afs_int32
-GetServer(aname)
- char *aname;
+GetServer(char *aname)
{
register struct hostent *th;
afs_int32 addr;
#endif
int
-main(argc, argv)
- int argc;
- char **argv;
+main(int argc, char **argv)
{
struct rx_connection *conn;
struct rx_call *call;
}
/* returns 1 if the file is upto date else returns 0*/
+/*check the dir case more carefully */
int
-IsCompatible(filename, time, length) /*check the dir case more carefully */
- char *filename;
- afs_int32 time, length;
+IsCompatible(char *filename, afs_int32 time, afs_int32 length)
{
struct stat status;
afs_int32 error;
free(localname);
if (error == -1)
- return 0; /*a non-existent file, has to be fetched fresh */
+ return 0; /*a non-existent file, has to be fetched fresh */
if ((status.st_mode & S_IFMT) == S_IFDIR
|| ((status.st_mtime == time) && (status.st_size == length)))
return (1);
}
int
-FetchFile(call, remoteFile, localFile, dirFlag)
- struct rx_call *call;
- char *localFile, *remoteFile;
- int dirFlag;
+FetchFile(struct rx_call *call, char *remoteFile, char *localFile, int dirFlag)
{
int fd = -1, error = 0;
struct stat status;
int
-update_ReceiveFile(fd, call, status)
- register int fd;
- register struct rx_call *call;
- register struct stat *status;
+update_ReceiveFile(register int fd, register struct rx_call *call, register struct stat *status)
{
register char *buffer = (char *)0;
afs_int32 length;
-#ifdef notdef
- XDR xdr;
-#endif
register int blockSize;
afs_int32 error = 0, len;
#ifdef AFS_AIX_ENV
-#include <sys/statfs.h>
struct statfs tstatfs;
#endif
-#ifdef notdef
- xdrrx_create(&xdr, call, XDR_DECODE);
- if (!xdr_afs_int32(&xdr, &length))
- return UPDATE_ERROR;
-#else
len = rx_Read(call, &length, sizeof(afs_int32));
length = ntohl(length);
if (len != sizeof(afs_int32))
return UPDATE_ERROR;
-#endif
#ifdef AFS_AIX_ENV
/* Unfortunately in AIX valuable fields such as st_blksize are gone from the stat structure!! */
fstatfs(fd, &tstatfs);
* deleted on client site) else it returns 0 */
int
-NotOnHost(filename, okhostfiles)
- char *filename;
- struct filestr *okhostfiles;
+NotOnHost(char *filename, struct filestr *okhostfiles)
{
int i, rc;
struct stat status;
* and the uid, gid, file mode, access and modification times will be set to
* the passed in values.
*/
-static
- int
+static int
GetFileFromUpServer(struct rx_connection *conn, /* handle for upserver */
char *filename, /* name of file to be fetched */
short uid, short gid, /* uid/gid for fetched file */
#include <afs/cellconfig.h>
#include <afs/afsutil.h>
#include <afs/fileutil.h>
+#ifdef AFS_AIX_ENV
+#include <sys/statfs.h>
+#endif
#include "update.h"
#include "global.h"
extern int UPDATE_ExecuteRequest();
-extern rxkad_level StringToLevel(char *name);
static int AddObject(char **expPath, char *dir);
static int PathInDirectory(char *dir, char *path);
/* check whether caller is authorized to manage RX statistics */
int
-update_rxstat_userok(call)
- struct rx_call *call;
+update_rxstat_userok(struct rx_call *call)
{
return afsconf_SuperUser(cdir, call, NULL);
}
return inDir;
}
-
int
-AuthOkay(call, name)
- struct rx_call *call;
- char *name;
+AuthOkay(struct rx_call *call, char *name)
{
int i;
rxkad_level level;
#endif
int
-main(argc, argv)
- int argc;
- char *argv[];
+main(int argc, char *argv[])
{
struct rx_securityClass *securityObjects[3];
struct rx_service *service;
if (argv[a][0] == '-') { /* parse options */
char arg[256];
lcstring(arg, argv[a], sizeof(arg));
- newLevel = StringToLevel(&argv[a][1]);
+ newLevel = rxkad_StringToLevel(&argv[a][1]);
if (newLevel != -1) {
level = newLevel; /* set new level */
continue;
/* fetch the file name and send it to the remote requester specified by call */
int
-UPDATE_FetchFile(call, name)
- struct rx_call *call;
- char *name;
+UPDATE_FetchFile(struct rx_call *call, char *name)
{
int fd = -1;
int error = 0;
/* fetch dir info about directory name and send it to remote host associated
with call. */
int
-UPDATE_FetchInfo(call, name)
- struct rx_call *call;
- char *name;
+UPDATE_FetchInfo(struct rx_call *call, char *name)
{
int error = 0;
struct stat status;
}
int
-update_SendFile(fd, call, status)
- register int fd;
- register struct rx_call *call;
- register struct stat *status;
+update_SendFile(register int fd, register struct rx_call *call, register struct stat *status)
{
char *buffer = (char *)0;
int blockSize;
afs_int32 length, tlen;
-#ifdef notdef
- XDR xdr;
-#endif
#ifdef AFS_AIX_ENV
-#include <sys/statfs.h>
struct statfs tstatfs;
#endif
printf("malloc failed\n");
return UPDATE_ERROR;
}
-#ifdef notdef
- xdrrx_create(&xdr, call, XDR_ENCODE);
- if (!xdr_afs_int32(&xdr, &length))
- error = UPDATE_ERROR;
-#else
tlen = htonl(length);
rx_Write(call, &tlen, sizeof(afs_int32)); /* send length on fetch */
-#endif
while (!error && length) {
register int nbytes = (length > blockSize ? blockSize : length);
nbytes = read(fd, buffer, nbytes);
/* Enumerate dir (name) and write dir entry info into temp file.
*/
int
-update_SendDirInfo(name, call, status, origDir)
- char *name; /* Name of dir to enumerate */
- register struct rx_call *call; /* rx call */
- register struct stat *status; /* stat struct for dir */
- char *origDir; /* orig name of dir before being localized */
+update_SendDirInfo(char *name, /* Name of dir to enumerate */
+ register struct rx_call *call, /* rx call */
+ register struct stat *status, /* stat struct for dir */
+ char *origDir) /* orig name of dir before being localized */
{
DIR *dirp;
struct dirent *dp;
#include <stdlib.h>
int
-AddToList(ah, aname)
- struct filestr **ah;
- char *aname;
+AddToList(struct filestr **ah, char *aname)
{
register struct filestr *tf;
tf = (struct filestr *)malloc(sizeof(struct filestr));
}
int
-ZapList(ah)
- struct filestr **ah;
+ZapList(struct filestr **ah)
{
register struct filestr *tf, *nf;
for (tf = *ah; tf; tf = nf) {
*ah = NULL;
return 0;
}
-
-/* StringToLevel - converts the name of an rxkad security level to a integer
- * suitable for calling rxkad_New*SecurityObject. */
-
-rxkad_level
-StringToLevel(name)
- char *name;
-{
- if (strcmp(name, "clear") == 0)
- return rxkad_clear;
- if (strcmp(name, "auth") == 0)
- return rxkad_auth;
- if (strcmp(name, "crypt") == 0)
- return rxkad_crypt;
- return -1;
-}
#define THELOGSIZE 5120
static afs_int32 theLog[THELOGSIZE];
static afs_int32 vnLogPtr = 0;
+void
VNLog(aop, anparms, av1, av2, av3, av4)
afs_int32 aop, anparms;
afs_int32 av1, av2, av3, av4;
}
}
-
+int
main(int argc, char **argv)
{
register struct cmd_syndesc *ts;
git://git.openafs.org / openafs.git / commitdiff