rx-dewarnify-20041202

FIXES 16277

dewarnify rx

diff --git a/src/rx/LINUX/rx_knet.c b/src/rx/LINUX/rx_knet.c
index d03f485..dba89e9 100644 (file)
--- a/src/rx/LINUX/rx_knet.c
+++ b/src/rx/LINUX/rx_knet.c
@@ -67,7 +67,8 @@ rxk_NewSocketHost(afs_uint32 ahost, short aport)
     }
 
     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;
 }
@@ -208,8 +209,6 @@ osi_StopListener(void)
     read_unlock(&tasklist_lock);
 #endif
     while (rxk_ListenerPid) {
-       struct task_struct *p;
-
        flush_signals(listener);
        force_sig(SIGKILL, listener);
        afs_osi_Sleep(&rxk_ListenerPid);

diff --git a/src/rx/rx.c b/src/rx/rx.c
index c7299d8..bcdb837 100644 (file)
--- a/src/rx/rx.c
+++ b/src/rx/rx.c
@@ -1788,10 +1788,10 @@ rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
  */
 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;
@@ -1823,7 +1823,7 @@ rx_EndCall(register struct rx_call *call, afs_int32 rc)
        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
@@ -3188,8 +3188,8 @@ rxi_ReceiveDataPacket(register struct rx_call *call,
             * (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 */
@@ -3869,7 +3869,7 @@ rxi_ReceiveAckPacket(register struct rx_call *call, struct rx_packet *np,
        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;
 }
@@ -4374,8 +4374,8 @@ rxi_ResetCall(register struct rx_call *call, register int newcall)
     /* 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) {
@@ -4907,10 +4907,10 @@ rxi_SendXmitList(struct rx_call *call, struct rx_packet **list, int len,
 /* 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 */
@@ -4921,7 +4921,8 @@ rxi_StartUnlocked(struct rxevent *event, register struct rx_call *call,
  * 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 */
@@ -5196,12 +5197,12 @@ rxi_Start(struct rxevent *event, register struct rx_call *call, int istack)
 #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 */
                    }
                }
@@ -5472,9 +5473,8 @@ rxi_SendDelayedCallAbort(struct rxevent *event, register struct rx_call *call,
  * 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;
@@ -5514,8 +5514,8 @@ rxi_ChallengeEvent(struct rxevent *event, register struct rx_connection *conn,
        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));
     }
 }
 
@@ -5530,7 +5530,7 @@ rxi_ChallengeOn(register struct rx_connection *conn)
 {
     if (!conn->challengeEvent) {
        RXS_CreateChallenge(conn->securityObject, conn);
-       rxi_ChallengeEvent(NULL, conn, (void *)RX_CHALLENGE_MAXTRIES);
+       rxi_ChallengeEvent(NULL, conn, 0, RX_CHALLENGE_MAXTRIES);
     };
 }
 

diff --git a/src/rx/rx.h b/src/rx/rx.h
index 6778bbc..e34ff3e 100644 (file)
--- a/src/rx/rx.h
+++ b/src/rx/rx.h
@@ -507,9 +507,9 @@ struct rx_call {
     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 */

diff --git a/src/rx/rx_event.c b/src/rx/rx_event.c
index 3d78a3b..ca1365a 100644 (file)
--- a/src/rx/rx_event.c
+++ b/src/rx/rx_event.c
@@ -188,8 +188,9 @@ rxevent_Post(struct clock *when,
                           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;
@@ -202,9 +203,10 @@ rxevent_Post(struct clock *when, void (*func) (), void *arg, void *arg1)
     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
 
@@ -262,6 +264,8 @@ rxevent_Post(struct clock *when, void (*func) (), void *arg, void *arg1)
     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
                                 */
@@ -291,6 +295,19 @@ rxevent_Post(struct clock *when, void (*func) (), void *arg, void *arg1)
     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
@@ -311,10 +328,10 @@ rxevent_Cancel_1(register struct rxevent *ev, register struct rx_call *call,
     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
@@ -395,7 +412,11 @@ rxevent_RaiseEvents(struct clock *next)
            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++;

diff --git a/src/rx/rx_event.h b/src/rx/rx_event.h
index 662a2fb..4907b51 100644 (file)
--- a/src/rx/rx_event.h
+++ b/src/rx/rx_event.h
@@ -28,6 +28,8 @@ struct rxevent {
     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

diff --git a/src/rx/rx_globals.c b/src/rx/rx_globals.c
index a189820..437a1a5 100644 (file)
--- a/src/rx/rx_globals.c
+++ b/src/rx/rx_globals.c
@@ -14,7 +14,7 @@
  * 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
 

diff --git a/src/rx/rx_lwp.c b/src/rx/rx_lwp.c
index b40ed1e..9748b7d 100644 (file)
--- a/src/rx/rx_lwp.c
+++ b/src/rx/rx_lwp.c
@@ -75,7 +75,7 @@ rxi_Wakeup(void *addr)
 }
 
 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.
@@ -126,7 +126,7 @@ rxi_StartServerProc(void (*proc) (void), int stacksize)
     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);
@@ -320,7 +320,7 @@ rxi_ListenerProc(fd_set * rfds, int *tnop, struct rx_call **newcallp)
 /* 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;

diff --git a/src/rx/rx_multi.c b/src/rx/rx_multi.c
index 46b7a55..b482e92 100644 (file)
--- a/src/rx/rx_multi.c
+++ b/src/rx/rx_multi.c
@@ -55,7 +55,7 @@ multi_Init(struct rx_connection **conns, register int nConns)
     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;
 }
@@ -95,9 +95,10 @@ multi_Select(register struct multi_handle *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 */

diff --git a/src/rx/rx_packet.c b/src/rx/rx_packet.c
index 2185d43..6d81190 100644 (file)
--- a/src/rx/rx_packet.c
+++ b/src/rx/rx_packet.c
@@ -480,7 +480,7 @@ rx_CheckPackets(void)
 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");
@@ -652,7 +652,7 @@ rxi_AllocPacketNoLock(int class)
     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 */
@@ -1653,7 +1653,7 @@ rxi_SendPacket(struct rx_call *call, struct rx_connection *conn,
        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]++;
@@ -1832,7 +1832,7 @@ rxi_SendPacketList(struct rx_call *call, struct rx_connection *conn,
 
     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);

diff --git a/src/rx/rx_prototypes.h b/src/rx/rx_prototypes.h
index 8516431..823b022 100644 (file)
--- a/src/rx/rx_prototypes.h
+++ b/src/rx/rx_prototypes.h
@@ -13,6 +13,7 @@
 /* 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
@@ -48,12 +49,11 @@ extern void rx_WakeupServerProcs(void);
 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);
@@ -128,9 +128,10 @@ extern struct rx_packet *rxi_SendAck(register struct rx_call *call, register str
                                     *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
@@ -150,7 +151,7 @@ extern void rxi_SendDelayedCallAbort(struct rxevent *event,
                                     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,
@@ -286,6 +287,8 @@ at another time. */
 #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);
@@ -418,7 +421,7 @@ extern struct multi_handle *multi_Init(struct rx_connection **conns,
                                       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);
 

diff --git a/src/rx/rx_rdwr.c b/src/rx/rx_rdwr.c
index f31548b..449289f 100644 (file)
--- a/src/rx/rx_rdwr.c
+++ b/src/rx/rx_rdwr.c
@@ -724,7 +724,7 @@ rxi_WriteProc(register struct rx_call *call, register char *buf,
                    (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 */
@@ -1196,7 +1196,7 @@ rxi_WritevProc(struct rx_call *call, struct iovec *iov, int nio, int nbytes)
     }
 
     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 */
@@ -1312,7 +1312,7 @@ rxi_FlushWrite(register struct rx_call *call)
        if (!
            (call->
             flags & (RX_CALL_FAST_RECOVER | RX_CALL_FAST_RECOVER_WAIT))) {
-           rxi_Start(0, call, 0);
+           rxi_Start(0, call, 0, 0);
        }
     }
 }

diff --git a/src/rx/xdr.c b/src/rx/xdr.c
index c8c98c6..469352a 100644 (file)
--- a/src/rx/xdr.c
+++ b/src/rx/xdr.c
@@ -80,126 +80,116 @@ xdr_void(void)
     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
  */
@@ -384,7 +374,7 @@ xdr_opaque(register XDR * xdrs, caddr_t cp, register u_int cnt)
        }
        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) {
@@ -538,6 +528,8 @@ xdr_string(register XDR * xdrs, char **cpp, u_int maxsize)
     case XDR_ENCODE:
        size = strlen(sp);
        break;
+    case XDR_DECODE:
+       break;
     }
 
     if (!xdr_u_int(xdrs, &size)) {

diff --git a/src/rx/xdr_afsuuid.c b/src/rx/xdr_afsuuid.c
index f748500..fac8d69 100644 (file)
--- a/src/rx/xdr_afsuuid.c
+++ b/src/rx/xdr_afsuuid.c
@@ -55,7 +55,8 @@ xdr_afsUUID(XDR * xdrs, afsUUID * objp)
     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);

diff --git a/src/rx/xdr_array.c b/src/rx/xdr_array.c
index de63f66..b1d6715 100644 (file)
--- a/src/rx/xdr_array.c
+++ b/src/rx/xdr_array.c
@@ -119,6 +119,9 @@ xdr_array(register XDR * xdrs, caddr_t * addrp, u_int * sizep, u_int maxsize,
 
        case XDR_FREE:
            return (TRUE);
+
+       case XDR_ENCODE:
+           break;
        }
 
     /*

diff --git a/src/rx/xdr_arrayn.c b/src/rx/xdr_arrayn.c
index bceb7dd..cf4f7ca 100644 (file)
--- a/src/rx/xdr_arrayn.c
+++ b/src/rx/xdr_arrayn.c
@@ -123,6 +123,9 @@ xdr_arrayN(register XDR * xdrs, caddr_t * addrp, u_int * sizep, u_int maxsize,
 
        case XDR_FREE:
            return (TRUE);
+
+       case XDR_ENCODE:
+           break;
        }
 
     /*

diff --git a/src/rx/xdr_int32.c b/src/rx/xdr_int32.c
index 8a30863..58231df 100644 (file)
--- a/src/rx/xdr_int32.c
+++ b/src/rx/xdr_int32.c
@@ -55,10 +55,10 @@ xdr_afs_int32(register XDR * xdrs, afs_int32 * lp)
 {
 
     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);
@@ -75,9 +75,9 @@ xdr_afs_uint32(register XDR * xdrs, afs_uint32 * ulp)
 {
 
     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);

diff --git a/src/rx/xdr_rx.c b/src/rx/xdr_rx.c
index 2c75258..514c3ed 100644 (file)
--- a/src/rx/xdr_rx.c
+++ b/src/rx/xdr_rx.c
@@ -73,11 +73,21 @@ RCSID
 #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
@@ -85,23 +95,23 @@ RCSID
 /*
  * 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);
 
 
 /*
@@ -149,8 +159,9 @@ int rx_pin_failed = 0;
 
 #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;
 
@@ -162,8 +173,9 @@ xdrrx_getint64(XDR * xdrs, long *lp)
 }
 
 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);
 
@@ -173,9 +185,10 @@ xdrrx_putint64(XDR * xdrs, 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)
+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;
@@ -211,9 +224,10 @@ xdrrx_getint32(XDR * xdrs, afs_int32 * lp)
 }
 
 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;
@@ -241,9 +255,10 @@ xdrrx_putint32(register XDR * xdrs, register afs_int32 * lp)
 }
 
 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;
@@ -272,9 +287,10 @@ xdrrx_getbytes(register XDR * xdrs, register caddr_t addr, register u_int len)
 }
 
 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;
@@ -319,7 +335,7 @@ xdrrx_setpos(register XDR * xdrs, u_int pos)
 #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);

diff --git a/src/rxkad/rxkad_common.c b/src/rxkad/rxkad_common.c
index e062ff4..2e073f8 100644 (file)
--- a/src/rxkad/rxkad_common.c
+++ b/src/rxkad/rxkad_common.c
@@ -83,7 +83,7 @@ RCSID
 #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,
@@ -421,7 +421,7 @@ rxkad_PreparePacket(struct rx_securityClass *aobj, struct rx_call *acall,
     fc_KeySchedule *schedule;
     fc_InitializationVector *ivec;
     int len;
-    int nlen;
+    int nlen = 0;
     int word;
     afs_int32 code;
     afs_int32 *preSeq;

diff --git a/src/rxkad/rxkad_prototypes.h b/src/rxkad/rxkad_prototypes.h
index 471b8ac..b7ce307 100644 (file)
--- a/src/rxkad/rxkad_prototypes.h
+++ b/src/rxkad/rxkad_prototypes.h
@@ -50,14 +50,13 @@ extern int rxkad_GetResponse(struct rx_securityClass *aobj,
 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);