}
TO_USER_SPACE();
- sockp->ops->setsockopt(sockp, SOL_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu));
+ sockp->ops->setsockopt(sockp, SOL_IP, IP_MTU_DISCOVER, (char *)&pmtu,
+ sizeof(pmtu));
TO_KERNEL_SPACE();
return (struct osi_socket *)sockp;
}
read_unlock(&tasklist_lock);
#endif
while (rxk_ListenerPid) {
- struct task_struct *p;
-
flush_signals(listener);
force_sig(SIGKILL, listener);
afs_osi_Sleep(&rxk_ListenerPid);
*/
void
rx_SetArrivalProc(register struct rx_call *call,
- register VOID(*proc) (register struct rx_call * call,
- register struct multi_handle * mh,
+ register void (*proc) (register struct rx_call * call,
+ register VOID * mh,
register int index),
- register VOID * handle, register VOID * arg)
+ register VOID * handle, register int arg)
{
call->arrivalProc = proc;
call->arrivalProcHandle = handle;
call->abortCount = 0;
}
- call->arrivalProc = (VOID(*)())0;
+ call->arrivalProc = (void (*)())0;
if (rc && call->error == 0) {
rxi_CallError(call, rc);
/* Send an abort message to the peer if this error code has
* (e.g. multi rx) */
if (call->arrivalProc) {
(*call->arrivalProc) (call, call->arrivalProcHandle,
- (int)call->arrivalProcArg);
- call->arrivalProc = (VOID(*)())0;
+ call->arrivalProcArg);
+ call->arrivalProc = (void (*)())0;
}
/* Update last packet received */
call->state = RX_STATE_DALLY;
rxi_ClearTransmitQueue(call, 0);
} else if (!queue_IsEmpty(&call->tq)) {
- rxi_Start(0, call, istack);
+ rxi_Start(0, call, 0, istack);
}
return np;
}
/* Notify anyone who is waiting for asynchronous packet arrival */
if (call->arrivalProc) {
(*call->arrivalProc) (call, call->arrivalProcHandle,
- (int)call->arrivalProcArg);
- call->arrivalProc = (VOID(*)())0;
+ call->arrivalProcArg);
+ call->arrivalProc = (void (*)())0;
}
if (call->delayedAbortEvent) {
/* Call rxi_Start, below, but with the call lock held. */
void
rxi_StartUnlocked(struct rxevent *event, register struct rx_call *call,
- int istack)
+ void *arg1, int istack)
{
MUTEX_ENTER(&call->lock);
- rxi_Start(event, call, istack);
+ rxi_Start(event, call, arg1, istack);
MUTEX_EXIT(&call->lock);
}
#endif /* RX_ENABLE_LOCKS */
* better optimized for new packets, the usual case, now that we've
* got rid of queues of send packets. XXXXXXXXXXX */
void
-rxi_Start(struct rxevent *event, register struct rx_call *call, int istack)
+rxi_Start(struct rxevent *event, register struct rx_call *call,
+ void *arg1, int istack)
{
struct rx_packet *p;
register struct rx_packet *nxp; /* Next pointer for queue_Scan */
#ifdef RX_ENABLE_LOCKS
CALL_HOLD(call, RX_CALL_REFCOUNT_RESEND);
call->resendEvent =
- rxevent_Post(&retryTime, rxi_StartUnlocked,
- (void *)call, (void *)istack);
+ rxevent_Post2(&retryTime, rxi_StartUnlocked,
+ (void *)call, 0, istack);
#else /* RX_ENABLE_LOCKS */
call->resendEvent =
- rxevent_Post(&retryTime, rxi_Start, (void *)call,
- (void *)istack);
+ rxevent_Post2(&retryTime, rxi_Start, (void *)call,
+ 0, istack);
#endif /* RX_ENABLE_LOCKS */
}
}
* security object associated with the connection */
void
rxi_ChallengeEvent(struct rxevent *event, register struct rx_connection *conn,
- void *atries)
+ void *arg1, int tries)
{
- int tries = (int)atries;
conn->challengeEvent = NULL;
if (RXS_CheckAuthentication(conn->securityObject, conn) != 0) {
register struct rx_packet *packet;
clock_GetTime(&when);
when.sec += RX_CHALLENGE_TIMEOUT;
conn->challengeEvent =
- rxevent_Post(&when, rxi_ChallengeEvent, conn,
- (void *)(tries - 1));
+ rxevent_Post2(&when, rxi_ChallengeEvent, conn, 0,
+ (tries - 1));
}
}
{
if (!conn->challengeEvent) {
RXS_CreateChallenge(conn->securityObject, conn);
- rxi_ChallengeEvent(NULL, conn, (void *)RX_CHALLENGE_MAXTRIES);
+ rxi_ChallengeEvent(NULL, conn, 0, RX_CHALLENGE_MAXTRIES);
};
}
int abortCount; /* number of times last error was sent */
u_int lastSendTime; /* Last time a packet was sent on this call */
u_int lastReceiveTime; /* Last time a packet was received for this call */
- VOID(*arrivalProc) (register struct rx_call * call, register struct multi_handle * mh, register int index); /* Procedure to call when reply is received */
+ void (*arrivalProc) (register struct rx_call * call, register VOID * mh, register int index); /* Procedure to call when reply is received */
VOID *arrivalProcHandle; /* Handle to pass to replyFunc */
- VOID *arrivalProcArg; /* Additional arg to pass to reply Proc */
+ int arrivalProcArg; /* Additional arg to pass to reply Proc */
afs_uint32 lastAcked; /* last packet "hard" acked by receiver */
afs_uint32 startWait; /* time server began waiting for input data/send quota */
struct clock traceWait; /* time server began waiting for input data/send quota */
struct rx_connection * conn,
struct rx_call * acall), void *arg, void *arg1)
#else
-struct rxevent *
-rxevent_Post(struct clock *when, void (*func) (), void *arg, void *arg1)
+static struct rxevent *
+_rxevent_Post(struct clock *when, void (*func) (), void *arg, void *arg1,
+ int arg2, int newargs)
#endif
{
register struct rxevent *ev, *evqe, *evqpr;
if (rx_Log_event) {
struct clock now;
clock_GetTime(&now);
- fprintf(rx_Log_event, "%d.%d: rxevent_Post(%d.%d, %x, %x)\n",
+ fprintf(rx_Log_event, "%d.%d: rxevent_Post(%d.%d, %lx, %lx, %lx, %d)\n",
(int)now.sec, (int)now.usec, (int)when->sec, (int)when->usec,
- (unsigned int)func, (unsigned int)arg);
+ (unsigned long)func, (unsigned long)arg,
+ (unsigned long)arg1, arg2);
}
#endif
ev->func = func;
ev->arg = arg;
ev->arg1 = arg1;
+ ev->arg2 = arg2;
+ ev->newargs = newargs;
rxevent_nPosted += 1; /* Rather than ++, to shut high-C up
* regarding never-set variables
*/
return ev;
}
+struct rxevent *
+rxevent_Post(struct clock *when, void (*func) (), void *arg, void *arg1)
+{
+ return _rxevent_Post(when, func, arg, arg1, 0, 0);
+}
+
+struct rxevent *
+rxevent_Post2(struct clock *when, void (*func) (), void *arg, void *arg1,
+ int arg2)
+{
+ return _rxevent_Post(when, func, arg, arg1, arg2, 1);
+}
+
/* Cancel an event by moving it from the event queue to the free list.
* Warning, the event must be on the event queue! If not, this should core
* dump (reference through 0). This routine should be called using the macro
if (rx_Log_event) {
struct clock now;
clock_GetTime(&now);
- fprintf(rx_Log_event, "%d.%d: rxevent_Cancel_1(%d.%d, %x, %x)\n",
+ fprintf(rx_Log_event, "%d.%d: rxevent_Cancel_1(%d.%d, %lx, %lx)\n",
(int)now.sec, (int)now.usec, (int)ev->eventTime.sec,
- (int)ev->eventTime.usec, (unsigned int)ev->func,
- (unsigned int)ev->arg);
+ (int)ev->eventTime.usec, (unsigned long)ev->func,
+ (unsigned long)ev->arg);
}
#endif
/* Append it to the free list (rather than prepending) to keep the free
queue_Remove(ev);
rxevent_nPosted--;
MUTEX_EXIT(&rxevent_lock);
- ev->func(ev, ev->arg, ev->arg1);
+ if (ev->newargs) {
+ ev->func(ev, ev->arg, ev->arg1, ev->arg2);
+ } else {
+ ev->func(ev, ev->arg, ev->arg1);
+ }
MUTEX_ENTER(&rxevent_lock);
queue_Append(&rxevent_free, ev);
rxevent_nFree++;
void (*func) (); /* Function to call when this expires */
char *arg; /* Argument to the function */
char *arg1; /* Another argument */
+ int arg2; /* An integer argument */
+ int newargs; /* Nonzero if new-form arguments should be used */
};
/* We used to maintain a sorted list of events, but the amount of CPU
* Its value should be as large as the maximum file descriptor limit we
* are likely to run into on any platform. Right now, that is 65536
* which is the default hard fd limit on Solaris 9 */
-#ifndef _WIN32
+#if !defined(_WIN32) && !defined(KERNEL)
#define FD_SETSIZE 65536
#endif
}
PROCESS rx_listenerPid = 0; /* LWP process id of socket listener process */
-static void rx_ListenerProc(void *dummy);
+static int rx_ListenerProc(void *dummy);
/*
* Delay the current thread the specified number of seconds.
char name[32];
sprintf(name, "srv_%d", ++number);
- LWP_CreateProcess(proc, stacksize, RX_PROCESS_PRIORITY, (void *)0,
+ LWP_CreateProcess((int (*)(void *))proc, stacksize, RX_PROCESS_PRIORITY, (void *)0,
"rx_ServerProc", &scratchPid);
if (registerProgram)
(*registerProgram) (scratchPid, name);
/* 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
+static int
rx_ListenerProc(void *dummy)
{
int threadID;
for (i = 0; i < nConns; i++) {
register struct rx_call *call;
call = mh->calls[i] = rx_NewCall(conns[i]);
- rx_SetArrivalProc(call, multi_Ready, (VOID *) mh, (VOID *) i);
+ rx_SetArrivalProc(call, multi_Ready, (VOID *) mh, i);
}
return mh;
}
/* Called by Rx when the first reply packet of a call is received, or the call is aborted. */
void
-multi_Ready(register struct rx_call *call, register struct multi_handle *mh,
+multi_Ready(register struct rx_call *call, register VOID *amh,
register int index)
{
+ register struct multi_handle *mh = (struct multi_handle *)amh;
#ifdef RX_ENABLE_LOCKS
MUTEX_ENTER(&mh->lock);
#endif /* RX_ENABLE_LOCKS */
void
rxi_FreePacketNoLock(struct rx_packet *p)
{
- dpf(("Free %x\n", (int)p));
+ dpf(("Free %lx\n", (unsigned long)p));
if (p->flags & RX_PKTFLAG_FREE)
osi_Panic("rxi_FreePacketNoLock: packet already free\n");
if (!(p->flags & RX_PKTFLAG_FREE))
osi_Panic("rxi_AllocPacket: packet not free\n");
- dpf(("Alloc %x, class %d\n", (int)p, class));
+ dpf(("Alloc %lx, class %d\n", (unsigned long)p, class));
queue_Remove(p);
p->flags = 0; /* clear RX_PKTFLAG_FREE, initialize the rest */
AFS_RXGLOCK();
#ifdef RXDEBUG
}
- dpf(("%c %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %x resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], peer->host, peer->port, p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (int)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
+ dpf(("%c %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], peer->host, peer->port, p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (unsigned long)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
#endif
MUTEX_ENTER(&rx_stats_mutex);
rx_stats.packetsSent[p->header.type - 1]++;
assert(p != NULL);
- dpf(("%c %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %x resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], peer->host, peer->port, p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (int)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
+ dpf(("%c %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], peer->host, peer->port, p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (unsigned long)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
#endif
MUTEX_ENTER(&rx_stats_mutex);
/* rx.c */
extern void rx_SetEpoch(afs_uint32 epoch);
extern int rx_Init(u_int port);
+extern int rx_InitHost(u_int host, u_int port);
#ifndef KERNEL
extern void rxi_StartServerProcs(int nExistingProcs);
#endif
extern struct rx_call *rx_GetCall(int tno, struct rx_service *cur_service,
osi_socket * socketp);
extern void rx_SetArrivalProc(register struct rx_call *call,
- register VOID(*proc) (register struct rx_call *
+ register void (*proc) (register struct rx_call *
call,
- register struct
- multi_handle * mh,
+ register VOID * mh,
register int index),
- register VOID * handle, register VOID * arg);
+ register VOID * handle, register int arg);
extern afs_int32 rx_EndCall(register struct rx_call *call, afs_int32 rc);
extern void rx_Finalize(void);
extern void rxi_PacketsUnWait(void);
*optionalPacket, int serial, int reason,
int istack);
extern void rxi_StartUnlocked(struct rxevent *event,
- register struct rx_call *call, int istack);
+ register struct rx_call *call,
+ void *arg1, int istack);
extern void rxi_Start(struct rxevent *event, register struct rx_call *call,
- int istack);
+ void *arg1, int istack);
extern void rxi_Send(register struct rx_call *call,
register struct rx_packet *p, int istack);
#ifdef RX_ENABLE_LOCKS
char *dummy);
extern void rxi_ChallengeEvent(struct rxevent *event,
register struct rx_connection *conn,
- void *atries);
+ void *arg1, int atries);
extern void rxi_ChallengeOn(register struct rx_connection *conn);
extern void rxi_ComputeRoundTripTime(register struct rx_packet *p,
register struct clock *sentp,
#else
extern struct rxevent *rxevent_Post(struct clock *when, void (*func) (),
void *arg, void *arg1);
+extern struct rxevent *rxevent_Post2(struct clock *when, void (*func) (),
+ void *arg, void *arg1, int arg2);
#endif
extern void shutdown_rxevent(void);
extern struct rxepoch *rxepoch_Allocate(struct clock *when);
register int nConns);
extern int multi_Select(register struct multi_handle *mh);
extern void multi_Ready(register struct rx_call *call,
- register struct multi_handle *mh, register int index);
+ register VOID *mh, register int index);
extern void multi_Finalize(register struct multi_handle *mh);
extern void multi_Finalize_Ignore(register struct multi_handle *mh);
(call->
flags & (RX_CALL_FAST_RECOVER |
RX_CALL_FAST_RECOVER_WAIT))) {
- rxi_Start(0, call, 0);
+ rxi_Start(0, call, 0, 0);
}
}
/* Wait for transmit window to open up */
}
if (!(call->flags & (RX_CALL_FAST_RECOVER | RX_CALL_FAST_RECOVER_WAIT))) {
- rxi_Start(0, call, 0);
+ rxi_Start(0, call, 0, 0);
}
/* Wait for the length of the transmit queue to fall below call->twind */
if (!
(call->
flags & (RX_CALL_FAST_RECOVER | RX_CALL_FAST_RECOVER_WAIT))) {
- rxi_Start(0, call, 0);
+ rxi_Start(0, call, 0, 0);
}
}
}
return (TRUE);
}
-#if !defined(AFS_OSF20_ENV) && !defined(AFS_SGI61_ENV)
/*
- * XDR afs_int32 integers
- * same as xdr_u_long - open coded to save a proc call!
+ * XDR integers
*/
bool_t
xdr_int(register XDR * xdrs, int *ip)
{
+ afs_int32 l;
- if (xdrs->x_op == XDR_ENCODE)
- return (XDR_PUTINT32(xdrs, (long *)ip));
+ switch (xdrs->x_op) {
- if (xdrs->x_op == XDR_DECODE)
- return (XDR_GETINT32(xdrs, (long *)ip));
+ case XDR_ENCODE:
+ l = (afs_int32) * ip;
+ return (XDR_PUTINT32(xdrs, &l));
- if (xdrs->x_op == XDR_FREE)
+ case XDR_DECODE:
+ if (!XDR_GETINT32(xdrs, &l)) {
+ return (FALSE);
+ }
+ *ip = (int)l;
return (TRUE);
- return (FALSE);
-}
-
-/*
- * XDR unsigned afs_int32 integers
- * same as xdr_long - open coded to save a proc call!
- */
-bool_t
-xdr_u_int(register XDR * xdrs, u_int * up)
-{
-
- if (xdrs->x_op == XDR_DECODE)
- return (XDR_GETINT32(xdrs, (long *)up));
-
- if (xdrs->x_op == XDR_ENCODE)
- return (XDR_PUTINT32(xdrs, (long *)up));
-
- if (xdrs->x_op == XDR_FREE)
+ case XDR_FREE:
return (TRUE);
-
+ }
return (FALSE);
}
-#else
/*
- * XDR afs_int32 integers
- * same as xdr_u_long - open coded to save a proc call!
+ * XDR unsigned integers
*/
bool_t
-xdr_int(register XDR * xdrs, int *lp)
+xdr_u_int(register XDR * xdrs, u_int * uip)
{
+ afs_uint32 l;
- if (xdrs->x_op == XDR_ENCODE)
- return (XDR_PUTINT32(xdrs, (long *)lp));
+ switch (xdrs->x_op) {
- if (xdrs->x_op == XDR_DECODE)
- return (XDR_GETINT32(xdrs, (long *)lp));
+ case XDR_ENCODE:
+ l = (afs_uint32) * uip;
+ return (XDR_PUTINT32(xdrs, &l));
- if (xdrs->x_op == XDR_FREE)
+ case XDR_DECODE:
+ if (!XDR_GETINT32(xdrs, &l)) {
+ return (FALSE);
+ }
+ *uip = (u_int) l;
return (TRUE);
+ case XDR_FREE:
+ return (TRUE);
+ }
return (FALSE);
}
+
/*
- * XDR unsigned afs_int32 integers
- * same as xdr_long - open coded to save a proc call!
+ * XDR long integers
*/
bool_t
-xdr_u_int(register XDR * xdrs, u_int * ulp)
+xdr_long(register XDR * xdrs, long *lp)
{
+ afs_int32 l;
- if (xdrs->x_op == XDR_DECODE)
- return (XDR_GETINT32(xdrs, (long *)ulp));
+ switch (xdrs->x_op) {
- if (xdrs->x_op == XDR_ENCODE)
- return (XDR_PUTINT32(xdrs, (long *)ulp));
+ case XDR_ENCODE:
+ l = (afs_int32) * lp;
+ return (XDR_PUTINT32(xdrs, &l));
- if (xdrs->x_op == XDR_FREE)
+ case XDR_DECODE:
+ if (!XDR_GETINT32(xdrs, &l)) {
+ return (FALSE);
+ }
+ *lp = (long)l;
return (TRUE);
+ case XDR_FREE:
+ return (TRUE);
+ }
return (FALSE);
}
-#endif
/*
- * XDR afs_int32 integers
- * same as xdr_u_long - open coded to save a proc call!
+ * XDR unsigned long integers
*/
bool_t
-xdr_long(register XDR * xdrs, long *lp)
+xdr_u_long(register XDR * xdrs, u_long * ulp)
{
+ afs_uint32 l;
- if (xdrs->x_op == XDR_ENCODE)
- return (XDR_PUTINT32(xdrs, lp));
+ switch (xdrs->x_op) {
- if (xdrs->x_op == XDR_DECODE)
- return (XDR_GETINT32(xdrs, lp));
+ case XDR_ENCODE:
+ l = (afs_uint32) * ulp;
+ return (XDR_PUTINT32(xdrs, &l));
- if (xdrs->x_op == XDR_FREE)
+ case XDR_DECODE:
+ if (!XDR_GETINT32(xdrs, &l)) {
+ return (FALSE);
+ }
+ *ulp = (u_long) l;
return (TRUE);
- return (FALSE);
-}
-
-/*
- * XDR unsigned afs_int32 integers
- * same as xdr_long - open coded to save a proc call!
- */
-bool_t
-xdr_u_long(register XDR * xdrs, u_long * ulp)
-{
-
- if (xdrs->x_op == XDR_DECODE)
- return (XDR_GETINT32(xdrs, ulp));
- if (xdrs->x_op == XDR_ENCODE)
- return (XDR_PUTINT32(xdrs, ulp));
- if (xdrs->x_op == XDR_FREE)
+ case XDR_FREE:
return (TRUE);
+ }
return (FALSE);
}
+
/*
* XDR chars
*/
}
if (rndup == 0)
return (TRUE);
- return (XDR_GETBYTES(xdrs, crud, rndup));
+ return (XDR_GETBYTES(xdrs, (caddr_t)crud, rndup));
}
if (xdrs->x_op == XDR_ENCODE) {
case XDR_ENCODE:
size = strlen(sp);
break;
+ case XDR_DECODE:
+ break;
}
if (!xdr_u_int(xdrs, &size)) {
if (!xdr_char(xdrs, &objp->clock_seq_low)) {
return (FALSE);
}
- if (!xdr_vector(xdrs, (char *)objp->node, 6, sizeof(char), xdr_char)) {
+ /* Cast needed here because xdrproc_t officially takes 3 args :-( */
+ if (!xdr_vector(xdrs, (char *)objp->node, 6, sizeof(char), (xdrproc_t)xdr_char)) {
return (FALSE);
}
return (TRUE);
case XDR_FREE:
return (TRUE);
+
+ case XDR_ENCODE:
+ break;
}
/*
case XDR_FREE:
return (TRUE);
+
+ case XDR_ENCODE:
+ break;
}
/*
{
if (xdrs->x_op == XDR_ENCODE)
- return (XDR_PUTINT32(xdrs, (long *)lp));
+ return (XDR_PUTINT32(xdrs, lp));
if (xdrs->x_op == XDR_DECODE)
- return (XDR_GETINT32(xdrs, (long *)lp));
+ return (XDR_GETINT32(xdrs, lp));
if (xdrs->x_op == XDR_FREE)
return (TRUE);
{
if (xdrs->x_op == XDR_DECODE)
- return (XDR_GETINT32(xdrs, (long *)ulp));
+ return (XDR_GETINT32(xdrs, (afs_int32 *)ulp));
if (xdrs->x_op == XDR_ENCODE)
- return (XDR_PUTINT32(xdrs, (long *)ulp));
+ return (XDR_PUTINT32(xdrs, (afs_int32 *)ulp));
if (xdrs->x_op == XDR_FREE)
return (TRUE);
return (FALSE);
#if defined(KERNEL)
/*
* kernel version needs to agree with <rpc/xdr.h>
+ * except on Linux which does XDR differently from everyone else
*/
+# if defined(AFS_LINUX20_ENV) && !defined(UKERNEL)
+# define AFS_XDRS_T void *
+# else
+# define AFS_XDRS_T XDR *
+# endif
# if defined(AFS_SUN57_ENV)
# define AFS_RPC_INLINE_T rpc_inline_t
# elif defined(AFS_DUX40_ENV)
# define AFS_RPC_INLINE_T int
+# elif defined(AFS_LINUX20_ENV) && !defined(UKERNEL)
+# define AFS_RPC_INLINE_T afs_int32
+# elif defined(AFS_LINUX20_ENV)
+# define AFS_RPC_INLINE_T int32_t *
# else
# define AFS_RPC_INLINE_T long
# endif
/*
* user version needs to agree with "xdr.h", i.e. <rx/xdr.h>
*/
+# define AFS_XDRS_T void *
# define AFS_RPC_INLINE_T afs_int32
#endif /* KERNEL */
/* Static prototypes */
#if (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG != _MIPS_SZINT)) || defined(AFS_HPUX_64BIT_ENV)
-static bool_t xdrrx_getint64(XDR * xdrs, long *lp);
-static bool_t xdrrx_putint64(XDR * xdrs, long *lp);
+static bool_t xdrrx_getint64(AFS_XDRS_T axdrs, long *lp);
+static bool_t xdrrx_putint64(AFS_XDRS_T axdrs, long *lp);
#endif /* (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG != _MIPS_SZINT)) || defined(AFS_HPUX_64BIT_ENV) */
-static bool_t xdrrx_getint32(XDR * xdrs, afs_int32 * lp);
-static bool_t xdrrx_putint32(register XDR * xdrs, register afs_int32 * lp);
-static bool_t xdrrx_getbytes(register XDR * xdrs, register caddr_t addr,
+static bool_t xdrrx_getint32(AFS_XDRS_T axdrs, afs_int32 * lp);
+static bool_t xdrrx_putint32(AFS_XDRS_T axdrs, register afs_int32 * lp);
+static bool_t xdrrx_getbytes(AFS_XDRS_T axdrs, register caddr_t addr,
register u_int len);
-static bool_t xdrrx_putbytes(register XDR * xdrs, register caddr_t addr,
+static bool_t xdrrx_putbytes(AFS_XDRS_T axdrs, register caddr_t addr,
register u_int len);
-static AFS_RPC_INLINE_T *xdrrx_inline(register XDR * xdrs,
- register u_int len);
+static AFS_RPC_INLINE_T *xdrrx_inline(AFS_XDRS_T axdrs, register u_int len);
/*
#if (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG != _MIPS_SZINT)) || defined(AFS_HPUX_64BIT_ENV)
static bool_t
-xdrrx_getint64(XDR * xdrs, long *lp)
+xdrrx_getint64(AFS_XDRS_T axdrs, long *lp)
{
+ XDR * xdrs = (XDR *)axdrs;
register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
afs_int32 i;
}
static bool_t
-xdrrx_putint64(XDR * xdrs, long *lp)
+xdrrx_putint64(AFS_XDRS_T axdrs, long *lp)
{
+ XDR * xdrs = (XDR *)axdrs;
afs_int32 code, i = htonl(*lp);
register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
#endif /* (defined(AFS_SGI61_ENV) && (_MIPS_SZLONG != _MIPS_SZINT)) || defined(AFS_HPUX_64BIT_ENV) */
static bool_t
-xdrrx_getint32(XDR * xdrs, afs_int32 * lp)
+xdrrx_getint32(AFS_XDRS_T axdrs, afs_int32 * lp)
{
afs_int32 l;
+ XDR * xdrs = (XDR *)axdrs;
register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
#if defined(KERNEL) && defined(AFS_AIX32_ENV)
char *saddr = (char *)&l;
}
static bool_t
-xdrrx_putint32(register XDR * xdrs, register afs_int32 * lp)
+xdrrx_putint32(register AFS_XDRS_T axdrs, register afs_int32 * lp)
{
afs_int32 code, l = htonl(*lp);
+ XDR * xdrs = (XDR *)axdrs;
register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
#if defined(KERNEL) && defined(AFS_AIX32_ENV)
char *saddr = (char *)&code;
}
static bool_t
-xdrrx_getbytes(register XDR * xdrs, register caddr_t addr, register u_int len)
+xdrrx_getbytes(register AFS_XDRS_T axdrs, register caddr_t addr, register u_int len)
{
afs_int32 code;
+ XDR * xdrs = (XDR *)axdrs;
register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
#if defined(KERNEL) && defined(AFS_AIX32_ENV)
char *saddr = (char *)&code;
}
static bool_t
-xdrrx_putbytes(register XDR * xdrs, register caddr_t addr, register u_int len)
+xdrrx_putbytes(register AFS_XDRS_T axdrs, register caddr_t addr, register u_int len)
{
afs_int32 code;
+ XDR * xdrs = (XDR *)axdrs;
register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
#if defined(KERNEL) && defined(AFS_AIX32_ENV)
char *saddr = (char *)&code;
#endif
static AFS_RPC_INLINE_T *
-xdrrx_inline(register XDR * xdrs, register u_int len)
+xdrrx_inline(AFS_XDRS_T axdrs, register u_int len)
{
/* I don't know what this routine is supposed to do, but the stdio module returns null, so we will, too */
return (0);
#endif
/* variable initialization for the benefit of darwin compiler; if it causes
problems elsewhere, conditionalize for darwin or fc_test compile breaks */
-struct rxkad_stats rxkad_stats = { 0 };
+struct rxkad_stats rxkad_stats = { { 0 } };
/* static prototypes */
static afs_int32 ComputeSum(struct rx_packet *apacket,
fc_KeySchedule *schedule;
fc_InitializationVector *ivec;
int len;
- int nlen;
+ int nlen = 0;
int word;
afs_int32 code;
afs_int32 *preSeq;
extern void rxkad_ResetState(void);
/* rxkad_common.c */
-#if 0
-/* can't prototype these due to types */
+struct rxkad_endpoint;
extern int rxkad_SetupEndpoint(struct rx_connection *aconnp,
struct rxkad_endpoint *aendpointp);
+struct rxkad_v2ChallengeResponse;
extern afs_uint32 rxkad_CksumChallengeResponse(struct
rxkad_v2ChallengeResponse
*v2r);
-#endif
extern int rxkad_DeriveXORInfo(struct rx_connection *aconnp,
fc_KeySchedule * aschedule, char *aivec,
char *aresult);