{
/* initiate our pool of osi_linux_mem structs */
al_mem_pool = afs_atomlist_create(sizeof(struct osi_linux_mem),
- sizeof(long)*1024, vmalloc, local_free);
+ sizeof(long)*1024, (void *)vmalloc,
+ local_free);
if (!al_mem_pool) {
printf("afs_osi_Alloc: Error in initialization(atomlist_create)\n");
return 0;
}
/* initialize the hash table to hold references to alloc'ed chunks */
- lh_mem_htab = afs_lhash_create(hash_equal, vmalloc, local_free);
+ lh_mem_htab = afs_lhash_create(hash_equal, (void *)vmalloc, local_free);
if (!lh_mem_htab) {
printf("afs_osi_Alloc: Error in initialization(lhash_create)\n");
return 0;
{
int code;
cred_t *cr = crref();
- int junk;
+ afs_uint32 junk;
int old_pag;
lock_kernel();
#if defined(AFS_GLOBAL_SUNLOCK)
static int osi_TimedSleep(char *event, afs_int32 ams, int aintok);
+#endif
+
void afs_osi_Wakeup(char *event);
void afs_osi_Sleep(char *event);
-#endif
static char waitV;
afs_globalVFS = afsp;
afsp->vfs_bsize = 8192;
afsp->vfs_fsid.val[0] = AFS_VFSMAGIC; /* magic */
- afsp->vfs_fsid.val[1] = AFS_VFSFSID;
+ afsp->vfs_fsid.val[1] = (afs_int32) AFS_VFSFSID;
return 0;
}
abp->f_type = 0;
abp->f_bsize = afsp->vfs_bsize;
abp->f_fsid.val[0] = AFS_VFSMAGIC; /* magic */
- abp->f_fsid.val[1] = AFS_VFSFSID;
+ abp->f_fsid.val[1] = (afs_int32) AFS_VFSFSID;
return 0;
}
#define EXCL usr_EXCL
#define NONEXCL usr_NONEXCL
#define uio_rw usr_uio_rw
+#ifdef ino_t
+#undef ino_t
+#endif
#define ino_t usr_ino_t
#define offset_t usr_offset_t
#define getpid() usr_getpid()
#define setpag(A,B,C,D) usr_setpag((A),(B),(C),(D))
+#ifdef pid_t
+#undef pid_t
+#endif
#define pid_t int
enum usr_vcexcl { usr_NONEXCL, usr_EXCL };
}
#else /* AFS_HPUX_ENV */
code = afs_readdir_move(ode, avc, auio, o_slen,
-#ifdef defined(AFS_SUN5_ENV)
+#if defined(AFS_SUN5_ENV)
len, origOffset);
#else
auio->afsio_resid, origOffset);
{
extern short afs_brsDaemons;
extern afs_int32 afs_CheckServerDaemonStarted;
- extern struct osi_WaitHandle AFS_WaitHandler, AFS_CSWaitHandler;
+ extern struct afs_osi_WaitHandle AFS_WaitHandler, AFS_CSWaitHandler;
extern struct osi_file *afs_cacheInodep;
AFS_STATCNT(afs_shutdown);
#ifdef AFS_LINUX22_ENV
code = gop_lookupname((char *)ab->parm[0], AFS_UIOSYS, 1, (struct vnode **) 0, &dp);
if (dp)
- tvn = (struct vcache*)dp->d_inode;
+ tvn = (struct vnode*)dp->d_inode;
#else
code = gop_lookupname((char *)ab->parm[0], AFS_UIOSYS, 1, (struct vnode **) 0, (struct vnode **)&tvn);
#endif
#ifdef AFS_LINUX22_ENV
code = gop_lookupname(path, AFS_UIOUSER, follow, (struct vnode **) 0, &dp);
if (!code)
- vp = (struct vcache *)dp->d_inode;
+ vp = (struct vnode *)dp->d_inode;
#else
code = gop_lookupname(path, AFS_UIOUSER, follow, (struct vnode **) 0, &vp);
#endif /* AFS_LINUX22_ENV */
/* Note that it doesn't have a cell yet... */
if (!matches) {
afs_uint32 temp = sp->host.s_addr;
- srvr = afs_GetServer(&temp, 1, NULL, (vlonly ? AFS_VLPORT : AFS_FSPORT),
+ srvr = afs_GetServer(&temp, 1, 0, (vlonly ? AFS_VLPORT : AFS_FSPORT),
WRITE_LOCK, (afsUUID *)0,0);
srvr->addr->sa_iprank = sp->rank + afs_randomMod15();
afs_PutServer(srvr, WRITE_LOCK);
clients. This is probably OK, but I don't want to see too much of it.
*/
-#define ranstage(x) (x)= (afs_uint32) (3141592621*((afs_uint32)x)+1)
+#define ranstage(x) (x)= (afs_uint32) (3141592621U*((afs_uint32)x)+1)
extern afs_int32 rxi_getaddr();
unsigned int afs_random()
static ParseHostLine();
static ParseCellLine();
+static afsconf_OpenInternal();
+static afsconf_CloseInternal();
+static afsconf_Reopen();
static struct afsconf_servPair serviceTable [] = {
"afs", 7000,
#ifdef AFS_NT40_ENV
return _utime(tbuffer, NULL);
#else
- gettimeofday(&tvp[0], (char *) 0);
+ gettimeofday(&tvp[0], NULL);
tvp[1] = tvp[0];
return utimes(tbuffer, tvp);
#endif /* AFS_NT40_ENV */
#include <netdb.h>
#include <errno.h>
#include <string.h>
+#include <unistd.h>
#include <time.h>
#if defined(AIX)
#include <sys/syslog.h>
static char **shells, *strings;
static char **curshell = NULL;
-extern char **initshells();
+static char **initshells();
/*
* Get a list of shells from SHELLS, if it exists.
curshell = NULL;
}
-setusershell()
-{
-
- curshell = initshells();
-}
-
static char **
initshells()
{
(void)fclose(fp);
return (shells);
}
+
+setusershell()
+{
+
+ curshell = initshells();
+}
+
+
+
+
+
+
static char *strend(register char *);
int gethdir(char *);
+static addpath();
+static rscan();
#ifdef notdef
static addpath(char);
fprintf(stderr, "Unable to get time of day\n");
return (0L);
}
- return (htonl((afs_int32)tv.tv_sec + 2208988800));
+ return (htonl((afs_int32)tv.tv_sec + 2208988800U));
}
/* ARGSUSED */
if ((!ka_KeyIsZero((char *) &tentry.key, sizeof(tentry.key))) &&
(showkey)) {
printf (" key (%d):", tentry.key_version);
- ka_PrintBytes (&tentry.key, sizeof(tentry.key));
+ ka_PrintBytes ((char *)&tentry.key, sizeof(tentry.key));
}
else {
if (tentry.keyCheckSum == 0)
printf ("Converting %s in realm '%s' yields key='",
as->parms[0].items->data, realm);
- ka_PrintBytes (&key, sizeof(key));
+ ka_PrintBytes ((char *)&key, sizeof(key));
printf ("'.\n");
return 0;
ka_StringToKey (as->parms[1].items->data, realm, &key);
}
else if (as->parms[2].items) {
- if (ka_ReadBytes (as->parms[2].items->data, &key, sizeof(key)) != 8) {
+ if (ka_ReadBytes (as->parms[2].items->data, (char *)&key, sizeof(key))
+ != 8) {
printf ("Key must be 8 bytes: '%s' was too long\n",
- as->parms[2].items->data);
+ as->parms[2].items->data);
return KABADCMD;
}
}
}
if (verbose) {
printf ("SessionKey: ");
- ka_PrintBytes (&token.sessionKey, sizeof(token.sessionKey));
+ ka_PrintBytes ((char *)&token.sessionKey, sizeof(token.sessionKey));
printf ("\nTicket (kvno = %d, len = %d): ", token.kvno,
token.ticketLen);
- ka_PrintBytes (token.ticket, token.ticketLen);
+ ka_PrintBytes ((char *)token.ticket, token.ticketLen);
printf ("\n");
}
return 0;
ubik_ClientDestroy(lpbkConn);
if (code) goto abort;
printf ("Key: ");
- ka_PrintBytes (&key, sizeof(key));
+ ka_PrintBytes ((char *)&key, sizeof(key));
printf ("\n");
return code;
}
else {
int i;
printf ("Key: ");
- ka_PrintBytes (&key, sizeof(key));
+ ka_PrintBytes ((char *)&key, sizeof(key));
printf (" (");
for (i=0; i<sizeof(key); i++) {
printf ("%0.2x", ((char *)&key)[i] & 0xff);
return 0;
}
-void MyAfterProc(
+int MyAfterProc(
struct cmd_syndesc *as)
{
if (!strcmp(as->name,"help")) return;
conn = 0;
}
- return;
+ return 0;
}
int init = 0, noauth;
&key, 0, 0);
if (code == 0) {
des_init_random_number_generator (&key);
- ka_ConvertBytes (buf, sizeof(buf), &key, sizeof(key));
+ ka_ConvertBytes (buf, sizeof(buf), (char *)&key,
+ sizeof(key));
es_Report ("New Admin key is %s\n", buf);
} else {
es_Report ("in get_time: set_password failed because: %d\n", code);
des_fixup_key_parity (&key);
code = set_password (tt, KA_TGS_NAME, lrealm, &key, 0, 0);
if (code == 0) {
- ka_ConvertBytes (buf, sizeof(buf), &key, sizeof(key));
+ ka_ConvertBytes (buf, sizeof(buf), (char *)&key,
+ sizeof(key));
es_Report ("New TGS key is %s\n", buf);
} else {
es_Report ("in get_time: set_password failed because: %s\n", error_message (code));
if (!bcmp(password, &(tentry->key), sizeof(EncryptionKey)))
return KAREUSED;
- code = ka_KeyCheckSum (password, &newsum);
+ code = ka_KeyCheckSum ((char *)password, &newsum);
if (code)
return code;
/* do nothing, no limits */ ;
}
else {
- code = ka_KeyCheckSum (&(tentry.key), &newsum);
+ code = ka_KeyCheckSum ((char *)&(tentry.key), &newsum);
if (code)
return code;
for (i=npwSums-1; i ; i--)
(callerIsAdmin && enc_level == rxkad_crypt))
bcopy (&tentry.key, &aentry->key, sizeof(struct ktc_encryptionKey));
else bzero (&aentry->key, sizeof(aentry->key));
- code = ka_KeyCheckSum (&tentry.key, &aentry->keyCheckSum);
+ code = ka_KeyCheckSum ((char *)&tentry.key, &aentry->keyCheckSum);
if (!tentry.pwsums[0] && npwSums > 1 && !tentry.pwsums[1]) {
aentry->reserved3 = 0x12340000;
} else {
printf(" Key Version = %d\n", entry->key_version);
printf(" Key = ");
- ka_PrintBytes (&entry->key, sizeof(entry->key));
+ ka_PrintBytes ((char *)&entry->key, sizeof(entry->key));
printf("\n");
/* What about asServer structs and such and misc_ath_bytes */
fprintf(out, "create -name %s", EntryName(entryp));
- ka_ConvertBytes (key, sizeof(key), &entryp->key, sizeof(entryp->key));
+ ka_ConvertBytes (key, sizeof(key), (char *)&entryp->key,
+ sizeof(entryp->key));
fprintf(out, " -initial_password foo\n", key);
strcpy(flags,"");
temp -> misc = NULL; /* currently unused */
temp -> next = NULL;
temp -> prev = NULL;
- temp -> lwp_rused = NULL;
+ temp -> lwp_rused = 0;
temp -> level = 1; /* non-preemptable */
}
}
/* Check and see if database exists and is approximately OK. */
if (ntohl(cheader.headerSize) != sizeof(cheader) ||
- ntohl(cheader.eofPtr) == NULL) {
+ ntohl(cheader.eofPtr) == 0) {
if (code) return code;
com_err (whoami, PRDBBAD, "header is bad");
return PRDBBAD;
afs_int32 listElements(), listOwned(), isAMemberOf(), idToName();
static stolower();
+extern afs_int32 IDCmp();
/* When abort, reset initd so that the header is read in on next call.
* Abort the transarction and return the code.
/* Delete each continuation block as a separate transaction so that no one
* transaction become to large to complete. */
nptr = tentry.next;
- while (nptr != NULL) {
+ while (nptr != (afs_int32)NULL) {
struct contentry centry;
int i;
* transaction, we start a new transaction every 50 entries. */
count = 0;
nptr = tentry.owned;
- while (nptr != NULL) {
+ while (nptr != (afs_int32)NULL) {
struct prentry nentry;
code = pr_ReadEntry (tt, 0, nptr, &nentry);
afs_int32 hostid;
int size = 0, i, code;
int added = 0;
- extern afs_int32 IDCmp();
while (host = (host & wild)) {
wild = htonl ( ntohl(wild) << 8) ;
return code;
}
-void CleanUp (as)
+int CleanUp (as)
register struct cmd_syndesc *as;
{
if (!strcmp(as->name,"help")) return;
/* Need to shutdown the ubik_client & other connections */
pr_End();
rx_Finalize();
+
+ return 0;
}
CreateGroup (as)
extern struct ubik_dbase *dbase;
extern struct afsconf_dir *prdir;
extern int pr_noAuth;
+extern afs_int32 IDCmp();
extern afs_int32 AddToEntry();
static char *whoami = "ptserver";
}
hloc = 0;
nptr = tentry.next;
- while (nptr != NULL) {
+ while (nptr != 0) {
code = pr_ReadCoEntry(at,0,nptr,¢ry);
if (code != 0) return code;
if ((centry.id != bid) || !(centry.flags & PRCONT)) return PRDBBAD;
if (code) return code;
}
nptr = tentry->next;
- while (nptr != NULL) {
+ while (nptr != (afs_int32)NULL) {
code = pr_ReadCoEntry(at,0,nptr,¢ry);
if (code != 0) return PRDBFAIL;
for (i=0;i<COSIZE;i++) {
}
last = 0;
nptr = entry->next;
- while (nptr != NULL) {
+ while (nptr != (afs_int32)NULL) {
code = pr_ReadCoEntry(tt,0,nptr,&nentry);
if (code != 0) return code;
last = nptr;
bzero(&aentry,sizeof(aentry));
aentry.flags |= PRCONT;
aentry.id = entry->id;
- aentry.next = NULL;
+ aentry.next = 0;
aentry.entries[0] = aid;
code = pr_WriteCoEntry(tt,0,nptr,&aentry);
if (code != 0) return code;
afs_int32 nptr;
int size;
int count = 0;
- extern afs_int32 IDCmp();
size = 0;
alist->prlist_val = 0;
if (code) return code;
}
- for (nptr = tentry->next; nptr != NULL; nptr = centry.next) {
+ for (nptr = tentry->next; nptr != 0; nptr = centry.next) {
/* look through cont entries */
code = pr_ReadCoEntry(at,0,nptr,¢ry);
if (code != 0) return code;
afs_int32 nptr;
afs_int32 size;
int count = 0;
- extern afs_int32 IDCmp();
size = 0;
alist->prlist_val = 0;
}
nptr = tentry->next;
- while (nptr != NULL) {
+ while (nptr != (afs_uint32)NULL) {
/* look through cont entries */
code = pr_ReadCoEntry(at,0,nptr,¢ry);
if (code != 0) return code;
if (!code) {
nptr = tentry2->next;
- while (nptr != NULL) {
+ while (nptr != (afs_uint32)NULL) {
/* look through cont entries */
code = pr_ReadCoEntry(at,0,nptr,¢ry);
if (code != 0) break;
struct prentry tentry;
int size;
int count = 0;
- extern afs_int32 IDCmp();
size = 0;
alist->prlist_val = 0;
}
if ((ntohl(cheader.version) == PRDBVERSION) &&
ntohl(cheader.headerSize) == sizeof(cheader) &&
- ntohl(cheader.eofPtr) != NULL &&
+ ntohl(cheader.eofPtr) != (afs_uint32)NULL &&
FindByID(tt,ANONYMOUSID) != 0){
/* database exists, so we don't have to build it */
code = ubik_EndTrans(tt);
*/
if ((ntohl(cheader.version) == PRDBVERSION) &&
ntohl(cheader.headerSize) == sizeof(cheader) &&
- ntohl(cheader.eofPtr) != NULL &&
+ ntohl(cheader.eofPtr) != (afs_uint32)NULL &&
FindByID(tt,ANONYMOUSID) != 0){
/* database exists, so we don't have to build it */
code = ubik_EndTrans(tt);
static char tmp_cell_file[128] = "";
static char tmp_noauth_file[128] = "";
-static afs_int32 MyAfterProc (as, arock)
+static int MyAfterProc (as, arock)
struct cmd_syndesc *as;
char *arock;
{ afs_int32 code;
return 0;
}
-static afs_int32 MyBeforeProc (as, arock)
+static int MyBeforeProc (as, arock)
struct cmd_syndesc *as;
char *arock;
{ afs_int32 code;
if (code != 0) return 0;
if (aid == tentry.id) return entry;
entry = tentry.nextID;
- while (entry != NULL) {
+ while (entry != 0) {
bzero(&tentry,sizeof(tentry));
code = pr_ReadEntry(at,0,entry,&tentry);
if (code != 0) return 0;
if (code != 0) return 0;
if ((strncmp(aname,tentryp->name,PR_MAXNAMELEN)) == 0) return entry;
entry = tentryp->nextName;
- while (entry != NULL) {
+ while (entry != 0) {
bzero(tentryp, sizeof(struct prentry));
code = pr_ReadEntry(at,0,entry, tentryp);
if (code != 0) return 0;
bzero(&tentry,sizeof(tentry));
bzero(&bentry,sizeof(bentry));
trail = 0;
- if (current == NULL) return PRSUCCESS; /* already gone */
+ if (current == 0) return PRSUCCESS; /* already gone */
code = pr_ReadEntry(tt,0,current,&tentry);
if (code) return PRDBFAIL;
while (aid != tentry.id) {
trail = current;
current = tentry.nextID;
- if (current == NULL) break;
+ if (current == 0) break;
code = pr_ReadEntry(tt,0,current,&tentry);
if (code) return PRDBFAIL;
}
- if (current == NULL) return PRSUCCESS; /* we didn't find him, so he's already gone */
- if (trail == NULL) {
+ if (current == 0) return PRSUCCESS; /* we didn't find him, so he's already gone */
+ if (trail == 0) {
/* it's the first entry! */
cheader.idHash[i] = htonl(tentry.nextID);
code = pr_Write(tt,0,72+HASHSIZE*4+i*4,(char *)&cheader.idHash[i],sizeof(cheader.idHash[i]));
bzero(&tentry,sizeof(tentry));
bzero(&bentry,sizeof(bentry));
trail = 0;
- if (current == NULL) return PRSUCCESS; /* already gone */
+ if (current == 0) return PRSUCCESS; /* already gone */
code = pr_ReadEntry(tt,0,current,&tentry);
if (code) return PRDBFAIL;
while (strcmp(aname,tentry.name)) {
trail = current;
current = tentry.nextName;
- if (current == NULL) break;
+ if (current == 0) break;
code = pr_ReadEntry(tt,0,current,&tentry);
if (code) return PRDBFAIL;
}
- if (current == NULL) return PRSUCCESS; /* we didn't find him, already gone */
- if (trail == NULL) {
+ if (current == 0) return PRSUCCESS; /* we didn't find him, already gone */
+ if (trail == 0) {
/* it's the first entry! */
cheader.nameHash[i] = htonl(tentry.nextName);
code = pr_Write(tt,0,72+i*4,(char *)&cheader.nameHash[i],sizeof(cheader.nameHash[i]));
le = &thisEntry;
lastLoc = 0;
nptr = thisEntry.owned;
- while (nptr != NULL) {
+ while (nptr != 0) {
if (nptr == lastLoc) te = le;
else {
if (&thisEntry == le) te = &thatEntry;
nptr = ntohl(cheader.orphan);
bzero(&bentry,sizeof(bentry));
loc = 0;
- while (nptr != NULL) {
+ while (nptr != 0) {
code = pr_ReadEntry(at,0,nptr,&tentry);
if (code != 0) return PRDBFAIL;
if (gid == tentry.id) {
nodomain = 1;
return(0);
}
- ldomain[MAXHOSTNAMELEN] = NULL;
+ ldomain[MAXHOSTNAMELEN] = '\0';
if ((domainp = index(ldomain, '.')) == (char *)NULL) {
nodomain = 1;
return(0);
struct rx_call *rxi_NewCall();
void rxi_FreeCall();
struct rx_call *rxi_FindCall();
-void rx_ListenerProc();
int rxi_ReadPacket();
struct rx_packet *rxi_ReceivePacket();
struct rx_packet *rxi_ReceiveDataPacket();
}
PROCESS rx_listenerPid; /* LWP process id of socket listener process */
-void rx_ListenerProc();
+static void rx_ListenerProc(void *dummy);
/*
* Delay the current thread the specified number of seconds.
/* This is the listener process request loop. The listener process loop
* becomes a server thread when rxi_ListenerProc returns, and stays
* server thread until rxi_ServerProc returns. */
-static void rx_ListenerProc()
+static void rx_ListenerProc(void *dummy)
{
int threadID;
int sock;
*/
static int rx_pthread_event_rescheduled = 0;
+static void rx_ListenerProc(void *);
+
/*
* We supply an event handling thread for Rx's event processing.
* The condition variable is used to wakeup the thread whenever a new
static def_package();
static def_prefix();
static def_startingopcode();
+static def_statindex();
static def_split();
static customize_struct();
static def_special();
static void init_random_int32 ()
{ struct timeval key;
- gettimeofday (&key, (char *) 0);
+ gettimeofday (&key, NULL);
LOCK_RM
fc_keysched (&key, random_int32_schedule);
UNLOCK_RM
{
struct rx_connection *conn;
clientcred creds;
- afs_int32 errorcode, groups[NGROUPS_MAX], errornumber, ins= data->in_size;
+ afs_int32 errorcode, errornumber, ins= data->in_size;
+ afs_uint32 groups[NGROUPS_MAX];
rmtbulk InData, OutData;
char pathname[256], *pathp = pathname, *inbuffer;
#if 0/*ndef HAVE_GETCWD*/ /* XXX enable when autoconf happens */
* use time and pid to try to get some initial randomness.
*/
#if !defined(UKERNEL)
-#define ranstage(x) (x)= (afs_uint32) (3141592621*((afs_uint32)x)+1)
+#define ranstage(x) (x)= (afs_uint32) (3141592621U*((afs_uint32)x)+1)
unsigned int afs_random(void)
{
static int usd_FileRead(
usd_handle_t usd,
char *buf,
- u_int nbytes,
- u_int *xferdP)
+ afs_uint32 nbytes,
+ afs_uint32 *xferdP)
{
int fd = (int)(usd->handle);
int got;
static int usd_FileWrite(
usd_handle_t usd,
char *buf,
- u_int nbytes,
- u_int *xferdP)
+ afs_uint32 nbytes,
+ afs_uint32 *xferdP)
{
int fd = (int)(usd->handle);
int sent;
int smallMem = 0;
int rxJumbograms = 1; /* default is to send and receive jumbo grams */
-CheckSignal_Signal() {IOMGR_SoftSig(CheckSignal, 0);}
+static void CheckSignal_Signal() {IOMGR_SoftSig(CheckSignal, 0);}
static CheckSignal()
{
void showlog(void);
int UseTheForceLuke(char *path);
-
+static int IsVnodeOrphaned(VnodeId vnode);
/* Uniquifier stored in the Inode */
static Unique IUnique(u)
#include <sys/time.h>
#endif /* ITIMER_REAL */
#endif /* AFS_NT40_ENV */
-#if defined(AFS_SUN5_ENV) || defined(AFS_NT40_ENV)
+#if defined(AFS_SUN5_ENV) || defined(AFS_NT40_ENV) || defined(AFS_LINUX20_ENV)
#include <string.h>
#else
#include <strings.h>
#ifdef AFS_AIX_ENV
#include <sys/lockf.h>
#endif
-#if defined(AFS_SUN5_ENV) || defined(AFS_NT40_ENV)
+#if defined(AFS_SUN5_ENV) || defined(AFS_NT40_ENV) || defined(AFS_LINUX20_ENV)
#include <string.h>
#else
#include <strings.h>
if (!code) code = DumpString(iodp, 'n',V_name(vp));
dumpTimes[0] = fromtime;
dumpTimes[1] = V_backupDate(vp); /* Until the time the clone was made */
- if (!code) code = DumpArrayInt32(iodp, 't', (unsigned int *)dumpTimes, 2);
+ if (!code) code = DumpArrayInt32(iodp, 't', (afs_uint32 *)dumpTimes, 2);
return code;
}
register Volume *vp;
struct iod iod;
register struct iod *iodp = &iod;
- int *b1=0, *b2=0;
+ afs_int32 *b1=0, *b2=0;
int s1=0, s2=0, delo=0, tdelo;
int tag;
while (tag == D_VNODE) {
int haveStuff = 0;
bzero(buf, sizeof (buf));
- if (!ReadInt32(iodp, (unsigned int *)&vnodeNumber))
+ if (!ReadInt32(iodp, (afs_uint32 *)&vnodeNumber))
break;
ReadInt32(iodp, &vnode->uniquifier);
ReadInt32(iodp, &vnode->owner);
break;
case 'g':
- ReadInt32(iodp, (unsigned int *)&vnode->group);
+ ReadInt32(iodp, (afs_uint32 *)&vnode->group);
break;
case 'b': {
unsigned short modeBits;
register tag;
afs_uint32 beginMagic;
if (iod_getc(iodp) != D_DUMPHEADER || !ReadInt32(iodp, &beginMagic)
- || !ReadInt32(iodp, (unsigned int *)&hp->version)
+ || !ReadInt32(iodp, (afs_uint32 *)&hp->version)
|| beginMagic != DUMPBEGINMAGIC
) return 0;
hp->volumeId = 0;
return 0;
hp->nDumpTimes = (arrayLength >> 1);
for (i = 0; i<hp->nDumpTimes; i++)
- if (!ReadInt32(iodp, (unsigned int *)&hp->dumpTimes[i].from) || !ReadInt32(iodp, (unsigned int *)&hp->dumpTimes[i].to))
+ if (!ReadInt32(iodp, (afs_uint32 *)&hp->dumpTimes[i].from)
+ || !ReadInt32(iodp, (afs_uint32 *)&hp->dumpTimes[i].to))
return 0;
break;
}