rx-no-more-register-20090128
authorJeffrey Altman <jaltman@your-file-system.com>
Wed, 28 Jan 2009 22:33:17 +0000 (22:33 +0000)
committerDerrick Brashear <shadow@dementia.org>
Wed, 28 Jan 2009 22:33:17 +0000 (22:33 +0000)
LICENSE BSD

kill off use of register in rx

27 files changed:
src/rx/rx.c
src/rx/rx.h
src/rx/rx_event.c
src/rx/rx_globals.h
src/rx/rx_kcommon.c
src/rx/rx_lwp.c
src/rx/rx_misc.c
src/rx/rx_multi.c
src/rx/rx_multi.h
src/rx/rx_packet.c
src/rx/rx_packet.h
src/rx/rx_prototypes.h
src/rx/rx_pthread.c
src/rx/rx_rdwr.c
src/rx/xdr.c
src/rx/xdr_array.c
src/rx/xdr_arrayn.c
src/rx/xdr_float.c
src/rx/xdr_int32.c
src/rx/xdr_int64.c
src/rx/xdr_mem.c
src/rx/xdr_prototypes.h
src/rx/xdr_rec.c
src/rx/xdr_refernce.c
src/rx/xdr_rx.c
src/rx/xdr_stdio.c
src/rx/xdr_update.c

index 62d6f90..70649e2 100644 (file)
@@ -124,9 +124,9 @@ int (*swapNameProgram) (PROCESS, const char *, char *) = 0;
 #endif
 
 /* Local static routines */
-static void rxi_DestroyConnectionNoLock(register struct rx_connection *conn);
+static void rxi_DestroyConnectionNoLock(struct rx_connection *conn);
 #ifdef RX_ENABLE_LOCKS
-static void rxi_SetAcksInTransmitQueue(register struct rx_call *call);
+static void rxi_SetAcksInTransmitQueue(struct rx_call *call);
 #endif
 
 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
@@ -606,7 +606,7 @@ rx_Init(u_int port)
  * rx_serverPool_lock is held.  Return quota using ReturnToServerPool().
  */
 static int
-QuotaOK(register struct rx_service *aservice)
+QuotaOK(struct rx_service *aservice)
 {
     /* check if over max quota */
     if (aservice->nRequestsRunning >= aservice->maxProcs) {
@@ -636,7 +636,7 @@ QuotaOK(register struct rx_service *aservice)
 }
 
 static void
-ReturnToServerPool(register struct rx_service *aservice)
+ReturnToServerPool(struct rx_service *aservice)
 {
     aservice->nRequestsRunning--;
     MUTEX_ENTER(&rx_quota_mutex);
@@ -648,7 +648,7 @@ ReturnToServerPool(register struct rx_service *aservice)
 
 #else /* RX_ENABLE_LOCKS */
 static int
-QuotaOK(register struct rx_service *aservice)
+QuotaOK(struct rx_service *aservice)
 {
     int rc = 0;
     /* under min quota, we're OK */
@@ -675,8 +675,8 @@ QuotaOK(register struct rx_service *aservice)
 void
 rxi_StartServerProcs(int nExistingProcs)
 {
-    register struct rx_service *service;
-    register int i;
+    struct rx_service *service;
+    int i;
     int maxdiff = 0;
     int nProcs = 0;
 
@@ -724,8 +724,8 @@ rx_StartClientThread(void)
 void
 rx_StartServer(int donateMe)
 {
-    register struct rx_service *service;
-    register int i;
+    struct rx_service *service;
+    int i;
     SPLVAR;
     clock_NewTime();
 
@@ -955,9 +955,9 @@ rxi_CleanupConnection(struct rx_connection *conn)
 
 /* Destroy the specified connection */
 void
-rxi_DestroyConnection(register struct rx_connection *conn)
+rxi_DestroyConnection(struct rx_connection *conn)
 {
-    register struct rx_connection *tconn, *dtconn;
+    struct rx_connection *tconn, *dtconn;
     
     MUTEX_ENTER(&rx_connHashTable_lock);
     
@@ -1002,10 +1002,10 @@ rxi_DestroyConnection(register struct rx_connection *conn)
 }
 
 static void
-rxi_DestroyConnectionNoLock(register struct rx_connection *conn)
+rxi_DestroyConnectionNoLock(struct rx_connection *conn)
 {
-    register struct rx_connection **conn_ptr;
-    register int havecalls = 0;
+    struct rx_connection **conn_ptr;
+    int havecalls = 0;
     struct rx_packet *packet;
     int i;
     SPLVAR;
@@ -1043,7 +1043,7 @@ rxi_DestroyConnectionNoLock(register struct rx_connection *conn)
 
     /* Check for extant references to this connection */
     for (i = 0; i < RX_MAXCALLS; i++) {
-       register struct rx_call *call = conn->call[i];
+       struct rx_call *call = conn->call[i];
        if (call) {
            havecalls = 1;
            if (conn->type == RX_CLIENT_CONNECTION) {
@@ -1128,7 +1128,7 @@ rxi_DestroyConnectionNoLock(register struct rx_connection *conn)
 
 /* Externally available version */
 void
-rx_DestroyConnection(register struct rx_connection *conn)
+rx_DestroyConnection(struct rx_connection *conn)
 {
     SPLVAR;
 
@@ -1138,7 +1138,7 @@ rx_DestroyConnection(register struct rx_connection *conn)
 }
 
 void
-rx_GetConnection(register struct rx_connection *conn)
+rx_GetConnection(struct rx_connection *conn)
 {
     SPLVAR;
 
@@ -1178,10 +1178,10 @@ static void rxi_WaitforTQBusy(struct rx_call *call) {
  * state and before we go to sleep.
  */
 struct rx_call *
-rx_NewCall(register struct rx_connection *conn)
+rx_NewCall(struct rx_connection *conn)
 {
-    register int i;
-    register struct rx_call *call;
+    int i;
+    struct rx_call *call;
     struct clock queueTime;
     SPLVAR;
 
@@ -1227,7 +1227,7 @@ rx_NewCall(register struct rx_connection *conn)
     /* search for next free call on this connection or 
      * its clones, if any */
     for (;;) {
-       register struct rx_connection *tconn;
+       struct rx_connection *tconn;
        
        for (tconn = conn; tconn; tconn = tconn->next_clone) {
            for (i = 0; i < RX_MAXCALLS; i++) {
@@ -1315,10 +1315,10 @@ rx_NewCall(register struct rx_connection *conn)
 }                              /* rx_NewCall */
 
 int
-rxi_HasActiveCalls(register struct rx_connection *aconn)
+rxi_HasActiveCalls(struct rx_connection *aconn)
 {
-    register int i;
-    register struct rx_call *tcall;
+    int i;
+    struct rx_call *tcall;
     SPLVAR;
 
     NETPRI;
@@ -1336,11 +1336,11 @@ rxi_HasActiveCalls(register struct rx_connection *aconn)
 }
 
 int
-rxi_GetCallNumberVector(register struct rx_connection *aconn,
-                       register afs_int32 * aint32s)
+rxi_GetCallNumberVector(struct rx_connection *aconn,
+                       afs_int32 * aint32s)
 {
-    register int i;
-    register struct rx_call *tcall;
+    int i;
+    struct rx_call *tcall;
     SPLVAR;
 
     NETPRI;
@@ -1355,11 +1355,11 @@ rxi_GetCallNumberVector(register struct rx_connection *aconn,
 }
 
 int
-rxi_SetCallNumberVector(register struct rx_connection *aconn,
-                       register afs_int32 * aint32s)
+rxi_SetCallNumberVector(struct rx_connection *aconn,
+                       afs_int32 * aint32s)
 {
-    register int i;
-    register struct rx_call *tcall;
+    int i;
+    struct rx_call *tcall;
     SPLVAR;
 
     NETPRI;
@@ -1387,8 +1387,8 @@ rx_NewServiceHost(afs_uint32 host, u_short port, u_short serviceId,
                  afs_int32(*serviceProc) (struct rx_call * acall))
 {
     osi_socket socket = OSI_NULLSOCKET;
-    register struct rx_service *tservice;
-    register int i;
+    struct rx_service *tservice;
+    int i;
     SPLVAR;
 
     clock_NewTime();
@@ -1413,7 +1413,7 @@ rx_NewServiceHost(afs_uint32 host, u_short port, u_short serviceId,
     tservice = rxi_AllocService();
     NETPRI;
     for (i = 0; i < RX_MAX_SERVICES; i++) {
-       register struct rx_service *service = rx_services[i];
+       struct rx_service *service = rx_services[i];
        if (service) {
            if (port == service->servicePort && host == service->serviceHost) {
                if (service->serviceId == serviceId) {
@@ -1503,9 +1503,9 @@ rx_NewService(u_short port, u_short serviceId, char *serviceName,
 void
 rxi_ServerProc(int threadID, struct rx_call *newcall, osi_socket * socketp)
 {
-    register struct rx_call *call;
-    register afs_int32 code;
-    register struct rx_service *tservice = NULL;
+    struct rx_call *call;
+    afs_int32 code;
+    struct rx_service *tservice = NULL;
 
     for (;;) {
        if (newcall) {
@@ -1638,7 +1638,7 @@ struct rx_call *
 rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
 {
     struct rx_serverQueueEntry *sq;
-    register struct rx_call *call = (struct rx_call *)0;
+    struct rx_call *call = (struct rx_call *)0;
     struct rx_service *service = NULL;
     SPLVAR;
 
@@ -1661,7 +1661,7 @@ rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
     }
     while (1) {
        if (queue_IsNotEmpty(&rx_incomingCallQueue)) {
-           register struct rx_call *tcall, *ncall, *choice2 = NULL;
+           struct rx_call *tcall, *ncall, *choice2 = NULL;
 
            /* Scan for eligible incoming calls.  A call is not eligible
             * if the maximum number of calls for its service type are
@@ -1808,7 +1808,7 @@ struct rx_call *
 rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
 {
     struct rx_serverQueueEntry *sq;
-    register struct rx_call *call = (struct rx_call *)0, *choice2;
+    struct rx_call *call = (struct rx_call *)0, *choice2;
     struct rx_service *service = NULL;
     SPLVAR;
 
@@ -1834,7 +1834,7 @@ rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
        rxi_availProcs++;
     }
     if (queue_IsNotEmpty(&rx_incomingCallQueue)) {
-       register struct rx_call *tcall, *ncall;
+       struct rx_call *tcall, *ncall;
        /* Scan for eligible incoming calls.  A call is not eligible
         * if the maximum number of calls for its service type are
         * already executing */
@@ -1971,11 +1971,11 @@ rx_GetCall(int tno, struct rx_service *cur_service, osi_socket * socketp)
  * and (2) only use it once.  Other uses currently void your warranty
  */
 void
-rx_SetArrivalProc(register struct rx_call *call,
-                 register void (*proc) (register struct rx_call * call,
-                                       register void * mh,
-                                       register int index),
-                 register void * handle, register int arg)
+rx_SetArrivalProc(struct rx_call *call,
+                 void (*proc) (struct rx_call * call,
+                                       void * mh,
+                                       int index),
+                 void * handle, int arg)
 {
     call->arrivalProc = proc;
     call->arrivalProcHandle = handle;
@@ -1987,10 +1987,10 @@ rx_SetArrivalProc(register struct rx_call *call,
  * to the caller */
 
 afs_int32
-rx_EndCall(register struct rx_call *call, afs_int32 rc)
+rx_EndCall(struct rx_call *call, afs_int32 rc)
 {
-    register struct rx_connection *conn = call->conn;
-    register struct rx_service *service;
+    struct rx_connection *conn = call->conn;
+    struct rx_service *service;
     afs_int32 error;
     SPLVAR;
 
@@ -2133,7 +2133,7 @@ rx_EndCall(register struct rx_call *call, afs_int32 rc)
 void
 rx_Finalize(void)
 {
-    register struct rx_connection **conn_ptr, **conn_end;
+    struct rx_connection **conn_ptr, **conn_end;
 
     INIT_PTHREAD_LOCKS;
     LOCK_RX_INIT;
@@ -2213,9 +2213,9 @@ rxi_PacketsUnWait(void)
 /* Return this process's service structure for the
  * specified socket and service */
 struct rx_service *
-rxi_FindService(register osi_socket socket, register u_short serviceId)
+rxi_FindService(osi_socket socket, u_short serviceId)
 {
-    register struct rx_service **sp;
+    struct rx_service **sp;
     for (sp = &rx_services[0]; *sp; sp++) {
        if ((*sp)->serviceId == serviceId && (*sp)->socket == socket)
            return *sp;
@@ -2235,12 +2235,12 @@ static struct rx_call *rx_allCallsp = 0;
  * supplied connection.  The mode and state of the call must be set by
  * the caller. Returns the call with mutex locked. */
 struct rx_call *
-rxi_NewCall(register struct rx_connection *conn, register int channel)
+rxi_NewCall(struct rx_connection *conn, int channel)
 {
-    register struct rx_call *call;
+    struct rx_call *call;
 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
-    register struct rx_call *cp;       /* Call pointer temp */
-    register struct rx_call *nxp;      /* Next call pointer, for queue_Scan */
+    struct rx_call *cp;        /* Call pointer temp */
+    struct rx_call *nxp;       /* Next call pointer, for queue_Scan */
 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
 
     dpf(("rxi_NewCall(conn %x, channel %d)\n", conn, channel));
@@ -2335,14 +2335,14 @@ rxi_NewCall(register struct rx_connection *conn, register int channel)
  */
 #ifdef RX_ENABLE_LOCKS
 void
-rxi_FreeCall(register struct rx_call *call, int haveCTLock)
+rxi_FreeCall(struct rx_call *call, int haveCTLock)
 #else /* RX_ENABLE_LOCKS */
 void
-rxi_FreeCall(register struct rx_call *call)
+rxi_FreeCall(struct rx_call *call)
 #endif                         /* RX_ENABLE_LOCKS */
 {
-    register int channel = call->channel;
-    register struct rx_connection *conn = call->conn;
+    int channel = call->channel;
+    struct rx_connection *conn = call->conn;
 
 
     if (call->state == RX_STATE_DALLY || call->state == RX_STATE_HOLD)
@@ -2395,9 +2395,9 @@ rxi_FreeCall(register struct rx_call *call)
 
 afs_int32 rxi_Alloccnt = 0, rxi_Allocsize = 0;
 char *
-rxi_Alloc(register size_t size)
+rxi_Alloc(size_t size)
 {
-    register char *p;
+    char *p;
 
     if (rx_stats_active)
         rx_MutexAdd1Increment2(rxi_Allocsize, (afs_int32)size, rxi_Alloccnt, rx_stats_mutex);
@@ -2415,7 +2415,7 @@ p = (char *)
 }
 
 void
-rxi_Free(void *addr, register size_t size)
+rxi_Free(void *addr, size_t size)
 {
     if (rx_stats_active)
         rx_MutexAdd1Decrement2(rxi_Allocsize, -(afs_int32)size, rxi_Alloccnt, rx_stats_mutex);
@@ -2423,7 +2423,7 @@ rxi_Free(void *addr, register size_t size)
 }
 
 void 
-rxi_SetPeerMtu(register afs_uint32 host, register afs_uint32 port, int mtu)
+rxi_SetPeerMtu(afs_uint32 host, afs_uint32 port, int mtu)
 {
     struct rx_peer **peer_ptr, **peer_end;
     int hashIndex;
@@ -2466,10 +2466,10 @@ rxi_SetPeerMtu(register afs_uint32 host, register afs_uint32 port, int mtu)
  * refcount will be be decremented. This is used to replace the peer
  * structure hanging off a connection structure */
 struct rx_peer *
-rxi_FindPeer(register afs_uint32 host, register u_short port,
+rxi_FindPeer(afs_uint32 host, u_short port,
              struct rx_peer *origPeer, int create)
 {
-    register struct rx_peer *pp;
+    struct rx_peer *pp;
     int hashIndex;
     hashIndex = PEER_HASH(host, port);
     MUTEX_ENTER(&rx_peerHashTable_lock);
@@ -2515,12 +2515,12 @@ rxi_FindPeer(register afs_uint32 host, register u_short port,
  * server connection is created, it will be created using the supplied
  * index, if the index is valid for this service */
 struct rx_connection *
-rxi_FindConnection(osi_socket socket, register afs_int32 host,
-                  register u_short port, u_short serviceId, afs_uint32 cid,
+rxi_FindConnection(osi_socket socket, afs_int32 host,
+                  u_short port, u_short serviceId, afs_uint32 cid,
                   afs_uint32 epoch, int type, u_int securityIndex)
 {
     int hashindex, flag, i;
-    register struct rx_connection *conn;
+    struct rx_connection *conn;
     hashindex = CONN_HASH(host, port, cid, epoch, type);
     MUTEX_ENTER(&rx_connHashTable_lock);
     rxLastConn ? (conn = rxLastConn, flag = 0) : (conn =
@@ -2529,7 +2529,7 @@ rxi_FindConnection(osi_socket socket, register afs_int32 host,
     for (; conn;) {
        if ((conn->type == type) && ((cid & RX_CIDMASK) == conn->cid)
            && (epoch == conn->epoch)) {
-           register struct rx_peer *pp = conn->peer;
+           struct rx_peer *pp = conn->peer;
            if (securityIndex != conn->securityIndex) {
                /* this isn't supposed to happen, but someone could forge a packet
                 * like this, and there seems to be some CM bug that makes this
@@ -2628,12 +2628,12 @@ int (*rx_almostSent) (struct rx_packet *, struct sockaddr_in *) = 0;
  * it, rather than de-allocating it, just as a small performance hack */
 
 struct rx_packet *
-rxi_ReceivePacket(register struct rx_packet *np, osi_socket socket,
+rxi_ReceivePacket(struct rx_packet *np, osi_socket socket,
                  afs_uint32 host, u_short port, int *tnop,
                  struct rx_call **newcallp)
 {
-    register struct rx_call *call;
-    register struct rx_connection *conn;
+    struct rx_call *call;
+    struct rx_connection *conn;
     int channel;
     afs_uint32 currentCallNumber;
     int type;
@@ -3011,7 +3011,7 @@ rxi_ReceivePacket(register struct rx_packet *np, osi_socket socket,
     conn->lastSerial = np->header.serial;
     MUTEX_EXIT(&conn->conn_data_lock);
     if (skew > 0) {
-       register struct rx_peer *peer;
+       struct rx_peer *peer;
        peer = conn->peer;
        if (skew > peer->inPacketSkew) {
            dpf(("*** In skew changed from %d to %d\n", peer->inPacketSkew,
@@ -3101,8 +3101,8 @@ rxi_ReceivePacket(register struct rx_packet *np, osi_socket socket,
 int
 rxi_IsConnInteresting(struct rx_connection *aconn)
 {
-    register int i;
-    register struct rx_call *tcall;
+    int i;
+    struct rx_call *tcall;
 
     if (aconn->flags & (RX_CONN_MAKECALL_WAITING | RX_CONN_DESTROY_ME))
        return 1;
@@ -3238,8 +3238,8 @@ rxi_CheckConnReach(struct rx_connection *conn, struct rx_call *call)
 
 /* try to attach call, if authentication is complete */
 static void
-TryAttach(register struct rx_call *acall, register osi_socket socket,
-         register int *tnop, register struct rx_call **newcallp,
+TryAttach(struct rx_call *acall, osi_socket socket,
+         int *tnop, struct rx_call **newcallp,
          int reachOverride)
 {
     struct rx_connection *conn = acall->conn;
@@ -3264,8 +3264,8 @@ TryAttach(register struct rx_call *acall, register osi_socket socket,
  * routine can return a packet to the caller, for re-use */
 
 struct rx_packet *
-rxi_ReceiveDataPacket(register struct rx_call *call,
-                     register struct rx_packet *np, int istack,
+rxi_ReceiveDataPacket(struct rx_call *call,
+                     struct rx_packet *np, int istack,
                      osi_socket socket, afs_uint32 host, u_short port,
                      int *tnop, struct rx_call **newcallp)
 {
@@ -3695,14 +3695,14 @@ rxi_ComputePeerNetStats(struct rx_call *call, struct rx_packet *p,
 
 /* The real smarts of the whole thing.  */
 struct rx_packet *
-rxi_ReceiveAckPacket(register struct rx_call *call, struct rx_packet *np,
+rxi_ReceiveAckPacket(struct rx_call *call, struct rx_packet *np,
                     int istack)
 {
     struct rx_ackPacket *ap;
     int nAcks;
-    register struct rx_packet *tp;
-    register struct rx_packet *nxp;    /* Next packet pointer for queue_Scan */
-    register struct rx_connection *conn = call->conn;
+    struct rx_packet *tp;
+    struct rx_packet *nxp;     /* Next packet pointer for queue_Scan */
+    struct rx_connection *conn = call->conn;
     struct rx_peer *peer = conn->peer;
     afs_uint32 first;
     afs_uint32 serial;
@@ -4153,8 +4153,8 @@ rxi_ReceiveAckPacket(register struct rx_call *call, struct rx_packet *np,
 
 /* Received a response to a challenge packet */
 struct rx_packet *
-rxi_ReceiveResponsePacket(register struct rx_connection *conn,
-                         register struct rx_packet *np, int istack)
+rxi_ReceiveResponsePacket(struct rx_connection *conn,
+                         struct rx_packet *np, int istack)
 {
     int error;
 
@@ -4210,8 +4210,8 @@ rxi_ReceiveResponsePacket(register struct rx_connection *conn,
  * challenge if it fails to get a response. */
 
 struct rx_packet *
-rxi_ReceiveChallengePacket(register struct rx_connection *conn,
-                          register struct rx_packet *np, int istack)
+rxi_ReceiveChallengePacket(struct rx_connection *conn,
+                          struct rx_packet *np, int istack)
 {
     int error;
 
@@ -4248,13 +4248,13 @@ rxi_ReceiveChallengePacket(register struct rx_connection *conn,
  * the given call structure.  If one isn't available, queue up this
  * call so it eventually gets one */
 void
-rxi_AttachServerProc(register struct rx_call *call,
-                    register osi_socket socket, register int *tnop,
-                    register struct rx_call **newcallp)
+rxi_AttachServerProc(struct rx_call *call,
+                    osi_socket socket, int *tnop,
+                    struct rx_call **newcallp)
 {
-    register struct rx_serverQueueEntry *sq;
-    register struct rx_service *service = call->conn->service;
-    register int haveQuota = 0;
+    struct rx_serverQueueEntry *sq;
+    struct rx_service *service = call->conn->service;
+    int haveQuota = 0;
 
     /* May already be attached */
     if (call->state == RX_STATE_ACTIVE)
@@ -4348,7 +4348,7 @@ rxi_AttachServerProc(register struct rx_call *call,
  * is being prepared (in the case of a server).  Rather than sending
  * an ack packet, an ACKALL packet is sent. */
 void
-rxi_AckAll(struct rxevent *event, register struct rx_call *call, char *dummy)
+rxi_AckAll(struct rxevent *event, struct rx_call *call, char *dummy)
 {
 #ifdef RX_ENABLE_LOCKS
     if (event) {
@@ -4395,9 +4395,9 @@ rxi_SendDelayedAck(struct rxevent *event, void *arg1, void *unused)
  * clearing them out.
  */
 static void
-rxi_SetAcksInTransmitQueue(register struct rx_call *call)
+rxi_SetAcksInTransmitQueue(struct rx_call *call)
 {
-    register struct rx_packet *p, *tp;
+    struct rx_packet *p, *tp;
     int someAcked = 0;
 
     for (queue_Scan(&call->tq, p, tp, rx_packet)) {
@@ -4426,10 +4426,10 @@ rxi_SetAcksInTransmitQueue(register struct rx_call *call)
 /* Clear out the transmit queue for the current call (all packets have
  * been received by peer) */
 void
-rxi_ClearTransmitQueue(register struct rx_call *call, register int force)
+rxi_ClearTransmitQueue(struct rx_call *call, int force)
 {
 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
-    register struct rx_packet *p, *tp;
+    struct rx_packet *p, *tp;
 
     if (!force && (call->flags & RX_CALL_TQ_BUSY)) {
        int someAcked = 0;
@@ -4468,7 +4468,7 @@ rxi_ClearTransmitQueue(register struct rx_call *call, register int force)
 }
 
 void
-rxi_ClearReceiveQueue(register struct rx_call *call)
+rxi_ClearReceiveQueue(struct rx_call *call)
 {
     if (queue_IsNotEmpty(&call->rq)) {
         u_short count;
@@ -4489,7 +4489,7 @@ rxi_ClearReceiveQueue(register struct rx_call *call)
 
 /* Send an abort packet for the specified call */
 struct rx_packet *
-rxi_SendCallAbort(register struct rx_call *call, struct rx_packet *packet,
+rxi_SendCallAbort(struct rx_call *call, struct rx_packet *packet,
                  int istack, int force)
 {
     afs_int32 error;
@@ -4539,7 +4539,7 @@ rxi_SendCallAbort(register struct rx_call *call, struct rx_packet *packet,
  *       to send the abort packet.
  */
 struct rx_packet *
-rxi_SendConnectionAbort(register struct rx_connection *conn,
+rxi_SendConnectionAbort(struct rx_connection *conn,
                        struct rx_packet *packet, int istack, int force)
 {
     afs_int32 error;
@@ -4583,11 +4583,11 @@ rxi_SendConnectionAbort(register struct rx_connection *conn,
  * rejected. 
  */
 void
-rxi_ConnectionError(register struct rx_connection *conn,
-                   register afs_int32 error)
+rxi_ConnectionError(struct rx_connection *conn,
+                   afs_int32 error)
 {
     if (error) {
-       register int i;
+       int i;
         struct rx_connection *tconn;
 
        dpf(("rxi_ConnectionError conn %x error %d", conn, error));
@@ -4622,7 +4622,7 @@ rxi_ConnectionError(register struct rx_connection *conn,
 }
 
 void
-rxi_CallError(register struct rx_call *call, afs_int32 error)
+rxi_CallError(struct rx_call *call, afs_int32 error)
 {
 #ifdef DEBUG
     osirx_AssertMine(&call->lock, "rxi_CallError");
@@ -4653,10 +4653,10 @@ rxi_CallError(register struct rx_call *call, afs_int32 error)
 #endif /* ADAPT_WINDOW */
 
 void
-rxi_ResetCall(register struct rx_call *call, register int newcall)
+rxi_ResetCall(struct rx_call *call, int newcall)
 {
-    register int flags;
-    register struct rx_peer *peer;
+    int flags;
+    struct rx_peer *peer;
     struct rx_packet *packet;
 #ifdef DEBUG
     osirx_AssertMine(&call->lock, "rxi_ResetCall");
@@ -4840,7 +4840,7 @@ rxi_ResetCall(register struct rx_call *call, register int newcall)
  * ignored by mundanes, which indicates the maximum size packet this 
  * host can swallow.  */
 /*
-    register struct rx_packet *optionalPacket;  use to send ack (or null) 
+    struct rx_packet *optionalPacket;  use to send ack (or null) 
     int        seq;                     Sequence number of the packet we are acking 
     int        serial;                  Serial number of the packet 
     int        pflags;                  Flags field from packet header 
@@ -4848,14 +4848,14 @@ rxi_ResetCall(register struct rx_call *call, register int newcall)
 */
 
 struct rx_packet *
-rxi_SendAck(register struct rx_call *call,
-           register struct rx_packet *optionalPacket, int serial, int reason,
+rxi_SendAck(struct rx_call *call,
+           struct rx_packet *optionalPacket, int serial, int reason,
            int istack)
 {
     struct rx_ackPacket *ap;
-    register struct rx_packet *rqp;
-    register struct rx_packet *nxp;    /* For queue_Scan */
-    register struct rx_packet *p;
+    struct rx_packet *rqp;
+    struct rx_packet *nxp;     /* For queue_Scan */
+    struct rx_packet *p;
     u_char offset;
     afs_int32 templ;
 #ifdef RX_ENABLE_TSFPQ
@@ -5037,11 +5037,11 @@ rxi_SendAck(register struct rx_call *call,
 #endif /* AFS_NT40_ENV */
 #endif
     {
-       register int i, nbytes = p->length;
+       int i, nbytes = p->length;
 
        for (i = 1; i < p->niovecs; i++) {      /* vec 0 is ALWAYS header */
            if (nbytes <= p->wirevec[i].iov_len) {
-               register int savelen, saven;
+               int savelen, saven;
 
                savelen = p->wirevec[i].iov_len;
                saven = p->niovecs;
@@ -5295,7 +5295,7 @@ rxi_Start(struct rxevent *event,
     struct rx_call *call = arg0;
     
     struct rx_packet *p;
-    register struct rx_packet *nxp;    /* Next pointer for queue_Scan */
+    struct rx_packet *nxp;     /* Next pointer for queue_Scan */
     struct rx_peer *peer = call->conn->peer;
     struct clock now, usenow, retryTime;
     int haveEvent;
@@ -5518,7 +5518,7 @@ rxi_Start(struct rxevent *event,
                }
 #ifdef RX_ENABLE_LOCKS
                if (call->flags & RX_CALL_TQ_SOME_ACKED) {
-                   register int missing;
+                   int missing;
                    call->flags &= ~RX_CALL_TQ_SOME_ACKED;
                    /* Some packets have received acks. If they all have, we can clear
                     * the transmit queue.
@@ -5621,10 +5621,10 @@ rxi_Start(struct rxevent *event,
  * that we have just sent a packet (so keep alives aren't sent
  * immediately) */
 void
-rxi_Send(register struct rx_call *call, register struct rx_packet *p,
+rxi_Send(struct rx_call *call, struct rx_packet *p,
         int istack)
 {
-    register struct rx_connection *conn = call->conn;
+    struct rx_connection *conn = call->conn;
 
     /* Stamp each packet with the user supplied status */
     p->header.userStatus = call->localStatus;
@@ -5663,13 +5663,13 @@ rxi_Send(register struct rx_call *call, register struct rx_packet *p,
  */
 #ifdef RX_ENABLE_LOCKS
 int
-rxi_CheckCall(register struct rx_call *call, int haveCTLock)
+rxi_CheckCall(struct rx_call *call, int haveCTLock)
 #else /* RX_ENABLE_LOCKS */
 int
-rxi_CheckCall(register struct rx_call *call)
+rxi_CheckCall(struct rx_call *call)
 #endif                         /* RX_ENABLE_LOCKS */
 {
-    register struct rx_connection *conn = call->conn;
+    struct rx_connection *conn = call->conn;
     afs_uint32 now;
     afs_uint32 deadTime;
 
@@ -5817,7 +5817,7 @@ rxi_KeepAliveEvent(struct rxevent *event, void *arg1, void *dummy)
 
 
 void
-rxi_ScheduleKeepAliveEvent(register struct rx_call *call)
+rxi_ScheduleKeepAliveEvent(struct rx_call *call)
 {
     if (!call->keepAliveEvent) {
        struct clock when, now;
@@ -5832,7 +5832,7 @@ rxi_ScheduleKeepAliveEvent(register struct rx_call *call)
 
 /* N.B. rxi_KeepAliveOff:  is defined earlier as a macro */
 void
-rxi_KeepAliveOn(register struct rx_call *call)
+rxi_KeepAliveOn(struct rx_call *call)
 {
     /* Pretend last packet received was received now--i.e. if another
      * packet isn't received within the keep alive time, then the call
@@ -5907,7 +5907,7 @@ rxi_ChallengeEvent(struct rxevent *event,
     
     conn->challengeEvent = NULL;
     if (RXS_CheckAuthentication(conn->securityObject, conn) != 0) {
-       register struct rx_packet *packet;
+       struct rx_packet *packet;
        struct clock when, now;
 
        if (tries <= 0) {
@@ -5957,7 +5957,7 @@ rxi_ChallengeEvent(struct rxevent *event,
  * the challenge at this time.  N.B.  rxi_ChallengeOff is a macro,
  * defined earlier. */
 void
-rxi_ChallengeOn(register struct rx_connection *conn)
+rxi_ChallengeOn(struct rx_connection *conn)
 {
     if (!conn->challengeEvent) {
        RXS_CreateChallenge(conn->securityObject, conn);
@@ -5972,13 +5972,13 @@ rxi_ChallengeOn(register struct rx_connection *conn)
 /* rxi_ComputeRoundTripTime is called with peer locked. */
 /* sentp and/or peer may be null */
 void
-rxi_ComputeRoundTripTime(register struct rx_packet *p,
-                        register struct clock *sentp,
-                        register struct rx_peer *peer)
+rxi_ComputeRoundTripTime(struct rx_packet *p,
+                        struct clock *sentp,
+                        struct rx_peer *peer)
 {
     struct clock thisRtt, *rttp = &thisRtt;
 
-    register int rtt_timeout;
+    int rtt_timeout;
 
     clock_GetTime(rttp);
 
@@ -6007,7 +6007,7 @@ rxi_ComputeRoundTripTime(register struct rx_packet *p,
 
     /* Apply VanJacobson round-trip estimations */
     if (peer->rtt) {
-       register int delta;
+       int delta;
 
        /*
         * srtt (peer->rtt) is in units of one-eighth-milliseconds.
@@ -6254,11 +6254,11 @@ rxs_Release(struct rx_securityClass *aobj)
  */
 
 static void
-rxi_ComputeRate(register struct rx_peer *peer, register struct rx_call *call,
+rxi_ComputeRate(struct rx_peer *peer, struct rx_call *call,
                struct rx_packet *p, struct rx_packet *ackp, u_char ackReason)
 {
     afs_int32 xferSize, xferMs;
-    register afs_int32 minTime;
+    afs_int32 minTime;
     struct clock newTO;
 
     /* Count down packets */
@@ -6638,7 +6638,7 @@ MakeDebugCall(osi_socket socket, afs_uint32 remoteAddr, afs_uint16 remotePort,
     time_t waitTime, waitCount, startTime;
     struct rx_header theader;
     char tbuffer[1500];
-    register afs_int32 code;
+    afs_int32 code;
     struct timeval tv_now, tv_wake, tv_delta;
     struct sockaddr_in taddr, faddr;
 #ifdef AFS_NT40_ENV
@@ -6647,7 +6647,7 @@ MakeDebugCall(osi_socket socket, afs_uint32 remoteAddr, afs_uint16 remotePort,
     socklen_t faddrLen;
 #endif
     fd_set imask;
-    register char *tp;
+    char *tp;
 
     startTime = time(0);
     waitTime = 1;
@@ -7011,10 +7011,10 @@ void
 shutdown_rx(void)
 {
     struct rx_serverQueueEntry *np;
-    register int i, j;
+    int i, j;
 #ifndef KERNEL
-    register struct rx_call *call;
-    register struct rx_serverQueueEntry *sq;
+    struct rx_call *call;
+    struct rx_serverQueueEntry *sq;
 #endif /* KERNEL */
 
     LOCK_RX_INIT;
@@ -7089,7 +7089,7 @@ shutdown_rx(void)
            rxi_Free(rx_services[i], sizeof(*rx_services[i]));
     }
     for (i = 0; i < rx_hashTableSize; i++) {
-       register struct rx_connection *tc, *ntc;
+       struct rx_connection *tc, *ntc;
        MUTEX_ENTER(&rx_connHashTable_lock);
        for (tc = rx_connHashTable[i]; tc; tc = ntc) {
            ntc = tc->next;
index bfe8c6a..687b11b 100644 (file)
@@ -564,7 +564,7 @@ struct rx_call {
     u_int lastSendTime;                /* Last time a packet was sent on this call */
     u_int lastReceiveTime;     /* Last time a packet was received for this call */
     u_int lastSendData;                /* Last time a nonping was sent on this call */
-    void (*arrivalProc) (register struct rx_call * call, register void * mh, register int index);      /* Procedure to call when reply is received */
+    void (*arrivalProc) (struct rx_call * call, void * mh, int index); /* Procedure to call when reply is received */
     void *arrivalProcHandle;   /* Handle to pass to replyFunc */
     int arrivalProcArg;         /* Additional arg to pass to reply Proc */
     afs_uint32 lastAcked;      /* last packet "hard" acked by receiver */
@@ -589,10 +589,19 @@ struct rx_call {
 #ifdef RX_REFCOUNT_CHECK
     short refCDebug[RX_CALL_REFCOUNT_MAX];
 #endif                         /* RX_REFCOUNT_CHECK */
+
+    /* 
+     * iov, iovNBytes, iovMax, and iovNext are set in rxi_ReadvProc()
+     * and adjusted by rxi_FillReadVec().  iov does not own the buffers
+     * it refers to.  The buffers belong to the packets stored in iovq.
+     * Only one call to rx_ReadvProc() can be active at a time.
+     */
+
     int iovNBytes;             /* byte count for current iovec */
     int iovMax;                        /* number elements in current iovec */
     int iovNext;               /* next entry in current iovec */
     struct iovec *iov;         /* current iovec */
+
     struct clock queueTime;    /* time call was queued */
     struct clock startTime;    /* time call was started */
     afs_hyper_t bytesSent;     /* Number bytes sent */
index 2f8f27e..b6669df 100644 (file)
@@ -220,8 +220,8 @@ _rxevent_Post(struct clock *when, struct clock *now,
              void (*func) (struct rxevent *, void *, void *, int), 
              void *arg, void *arg1, int arg2, int newargs)
 {
-    register struct rxevent *ev, *evqe, *evqpr;
-    register struct rxepoch *ep, *epqe, *epqpr;
+    struct rxevent *ev, *evqe, *evqpr;
+    struct rxepoch *ep, *epqe, *epqpr;
     int isEarliest = 0;
 
     MUTEX_ENTER(&rxevent_lock);
@@ -270,7 +270,7 @@ _rxevent_Post(struct clock *when, struct clock *now,
     /* If we're short on free event entries, create a block of new ones and add
      * them to the free queue */
     if (queue_IsEmpty(&rxevent_free)) {
-       register int i;
+       int i;
 #if    defined(AFS_AIX32_ENV) && defined(KERNEL)
        ev = (struct rxevent *)rxi_Alloc(sizeof(struct rxevent));
        queue_Append(&rxevent_free, &ev[0]), rxevent_nFree++;
@@ -395,8 +395,8 @@ int rxevent_Cancel_type = 0;
 #endif
 
 void
-rxevent_Cancel_1(register struct rxevent *ev, register struct rx_call *call,
-                register int type)
+rxevent_Cancel_1(struct rxevent *ev, struct rx_call *call,
+                int type)
 {
 #ifdef RXDEBUG
     if (rx_Log_event) {
@@ -450,8 +450,8 @@ rxevent_Cancel_1(register struct rxevent *ev, register struct rx_call *call,
 int
 rxevent_RaiseEvents(struct clock *next)
 {
-    register struct rxepoch *ep;
-    register struct rxevent *ev;
+    struct rxepoch *ep;
+    struct rxevent *ev;
     volatile struct clock now;
     MUTEX_ENTER(&rxevent_lock);
 
index 5e07a2b..b134cd3 100644 (file)
@@ -271,7 +271,7 @@ void rxi_FlushLocalPacketsTSFPQ(void); /* flush all thread-local packets to glob
  */
 #define RX_TS_FPQ_COMPUTE_LIMITS \
     do { \
-        register int newmax, newglob; \
+        int newmax, newglob; \
         newmax = (rx_nPackets * 9) / (10 * rx_TSFPQMaxProcs); \
         newmax = (newmax >= 15) ? newmax : 15; \
         newglob = newmax / 5; \
@@ -297,9 +297,9 @@ void rxi_FlushLocalPacketsTSFPQ(void); /* flush all thread-local packets to glob
    rx_freePktQ_lock must be held. default is to reduce the queue size to 40% ofmax */
 #define RX_TS_FPQ_LTOG(rx_ts_info_p) \
     do { \
-        register int i; \
-        register struct rx_packet * p; \
-        register int tsize = (rx_ts_info_p)->_FPQ.len - rx_TSFPQLocalMax + 3 *  rx_TSFPQGlobSize; \
+        int i; \
+        struct rx_packet * p; \
+        int tsize = (rx_ts_info_p)->_FPQ.len - rx_TSFPQLocalMax + 3 *  rx_TSFPQGlobSize; \
        if (tsize <= 0) break; \
         for (i=0,p=queue_Last(&((rx_ts_info_p)->_FPQ), rx_packet); \
              i < tsize; i++,p=queue_Prev(p, rx_packet)); \
@@ -318,8 +318,8 @@ void rxi_FlushLocalPacketsTSFPQ(void); /* flush all thread-local packets to glob
 /* same as above, except user has direct control over number to transfer */
 #define RX_TS_FPQ_LTOG2(rx_ts_info_p,num_transfer) \
     do { \
-        register int i; \
-        register struct rx_packet * p; \
+        int i; \
+        struct rx_packet * p; \
         if (num_transfer <= 0) break; \
         for (i=0,p=queue_Last(&((rx_ts_info_p)->_FPQ), rx_packet); \
             i < (num_transfer); i++,p=queue_Prev(p, rx_packet)); \
@@ -339,8 +339,8 @@ void rxi_FlushLocalPacketsTSFPQ(void); /* flush all thread-local packets to glob
    rx_freePktQ_lock must be held. */
 #define RX_TS_FPQ_GTOL(rx_ts_info_p) \
     do { \
-        register int i, tsize; \
-        register struct rx_packet * p; \
+        int i, tsize; \
+        struct rx_packet * p; \
         tsize = (rx_TSFPQGlobSize <= rx_nFreePackets) ? \
                  rx_TSFPQGlobSize : rx_nFreePackets; \
         for (i=0,p=queue_First(&rx_freePacketQueue, rx_packet); \
@@ -354,8 +354,8 @@ void rxi_FlushLocalPacketsTSFPQ(void); /* flush all thread-local packets to glob
 /* same as above, except user has direct control over number to transfer */
 #define RX_TS_FPQ_GTOL2(rx_ts_info_p,num_transfer) \
     do { \
-        register int i, tsize; \
-        register struct rx_packet * p; \
+        int i, tsize; \
+        struct rx_packet * p; \
         tsize = (num_transfer); \
         if (tsize > rx_nFreePackets) tsize = rx_nFreePackets; \
         for (i=0,p=queue_First(&rx_freePacketQueue, rx_packet); \
@@ -381,8 +381,8 @@ void rxi_FlushLocalPacketsTSFPQ(void); /* flush all thread-local packets to glob
  */
 #define RX_TS_FPQ_QCHECKOUT(rx_ts_info_p,num_transfer,q) \
     do { \
-        register int i; \
-        register struct rx_packet *p; \
+        int i; \
+        struct rx_packet *p; \
         if (num_transfer > (rx_ts_info_p)->_FPQ.len) num_transfer = (rx_ts_info_p)->_FPQ.len; \
         for (i=0, p=queue_First(&((rx_ts_info_p)->_FPQ), rx_packet); \
              i < num_transfer; \
@@ -409,7 +409,7 @@ void rxi_FlushLocalPacketsTSFPQ(void); /* flush all thread-local packets to glob
  * since caller already knows length of (q) for other reasons */
 #define RX_TS_FPQ_QCHECKIN(rx_ts_info_p,num_transfer,q) \
     do { \
-        register struct rx_packet *p, *np; \
+        struct rx_packet *p, *np; \
         for (queue_Scan((q), p, np, rx_packet)) { \
             RX_FPQ_MARK_FREE(p); \
         } \
index 9dac112..7eb0cd5 100644 (file)
@@ -78,8 +78,8 @@ rxk_AddPort(u_short aport, char *arock)
 int
 rxk_DelPort(u_short aport)
 {
-    register int i;
-    register unsigned short *tsp;
+    int i;
+    unsigned short *tsp;
 
     for (i = 0, tsp = rxk_ports; i < MAXRXPORTS; i++, tsp++) {
        if (*tsp == aport) {
@@ -406,7 +406,7 @@ rxi_StartListener(void)
 /* Called from rxi_FindPeer, when initializing a clear rx_peer structure,
   to get interesting information. */
 void
-rxi_InitPeerParams(register struct rx_peer *pp)
+rxi_InitPeerParams(struct rx_peer *pp)
 {
     u_short rxmtu;
     afs_int32 i, mtu;
@@ -529,7 +529,7 @@ static struct protosw parent_proto; /* udp proto switch */
 void
 shutdown_rxkernel(void)
 {
-    register struct protosw *tpro, *last;
+    struct protosw *tpro, *last;
     last = inetdomain.dom_protoswNPROTOSW;
     for (tpro = inetdomain.dom_protosw; tpro < last; tpro++)
        if (tpro->pr_protocol == IPPROTO_UDP) {
@@ -662,7 +662,7 @@ rxi_GetIFInfo(void)
     int i = 0;
     int different = 0;
 
-    register int rxmtu, maxmtu;
+    int rxmtu, maxmtu;
     afs_uint32 addrs[ADDRSPERSITE];
     int mtus[ADDRSPERSITE];
     afs_uint32 ifinaddr;
@@ -677,7 +677,7 @@ rxi_GetIFInfo(void)
     struct in_addr pin;
 #else
     struct ifaddr *ifad;       /* ifnet points to a if_addrlist of ifaddrs */
-    register struct ifnet *ifn;
+    struct ifnet *ifn;
 #endif
 
     memset(addrs, 0, sizeof(addrs));
@@ -878,7 +878,7 @@ rxi_FindIfnet(afs_uint32 addr, afs_uint32 * maskp)
 osi_socket *
 rxk_NewSocketHost(afs_uint32 ahost, short aport)
 {
-    register afs_int32 code;
+    afs_int32 code;
 #ifdef AFS_DARWIN80_ENV
     socket_t newSocket;
 #else
@@ -1063,7 +1063,7 @@ rxk_NewSocket(short aport)
 
 /* free socket allocated by rxk_NewSocket */
 int
-rxk_FreeSocket(register struct socket *asocket)
+rxk_FreeSocket(struct socket *asocket)
 {
     AFS_STATCNT(osi_FreeSocket);
 #if defined(AFS_DARWIN_ENV) && defined(KERNEL_FUNNEL)
@@ -1145,7 +1145,7 @@ rxk_ReadPacket(osi_socket so, struct rx_packet *p, int *host, int *port)
     struct sockaddr_in from;
     int nbytes;
     afs_int32 rlen;
-    register afs_int32 tlen;
+    afs_int32 tlen;
     afs_int32 savelen;         /* was using rlen but had aliasing problems */
     rx_computelen(p, tlen);
     rx_SetDataSize(p, tlen);   /* this is the size of the user data area */
@@ -1216,9 +1216,10 @@ rxk_ReadPacket(osi_socket so, struct rx_packet *p, int *host, int *port)
                     rx_AtomicIncrement(rx_stats.packetsRead[p->header.type - 1], rx_stats_mutex);
            }
 
+#ifdef RX_TRIMDATABUFS
            /* Free any empty packet buffers at the end of this packet */
            rxi_TrimDataBufs(p, 1);
-
+#endif
            return 0;
        }
     } else
index f4c80a9..2e8fc43 100644 (file)
@@ -163,7 +163,7 @@ rxi_ListenerProc(fd_set * rfds, int *tnop, struct rx_call **newcallp)
 {
     afs_uint32 host;
     u_short port;
-    register struct rx_packet *p = (struct rx_packet *)0;
+    struct rx_packet *p = (struct rx_packet *)0;
     osi_socket socket;
     struct clock cv;
     afs_int32 nextPollTime;    /* time to next poll FD before sleeping */
index d58885e..0c29c45 100644 (file)
@@ -53,9 +53,9 @@ RCSID
  * (network) system error code.
  */
 int
-hton_syserr_conv(register afs_int32 code)
+hton_syserr_conv(afs_int32 code)
 {
-    register afs_int32 err;
+    afs_int32 err;
 
     if (code == ENOSPC)
        err = VDISKFULL;
@@ -76,7 +76,7 @@ hton_syserr_conv(register afs_int32 code)
 int
 ntoh_syserr_conv(int code)
 {
-    register afs_int32 err;
+    afs_int32 err;
 
     if (code == VDISKFULL)
        err = ENOSPC;
index 9201081..7992a20 100644 (file)
@@ -30,12 +30,12 @@ RCSID
  */
 
 struct multi_handle *
-multi_Init(struct rx_connection **conns, register int nConns)
+multi_Init(struct rx_connection **conns, int nConns)
 {
-    register struct rx_call **calls;
-    register short *ready;
-    register struct multi_handle *mh;
-    register int i;
+    struct rx_call **calls;
+    short *ready;
+    struct multi_handle *mh;
+    int i;
 
     /*
      * Note: all structures that are possibly referenced by other
@@ -58,7 +58,7 @@ multi_Init(struct rx_connection **conns, register int nConns)
     CV_INIT(&mh->cv, "rx_multi_cv", CV_DEFAULT, 0);
 #endif /* RX_ENABLE_LOCKS */
     for (i = 0; i < nConns; i++) {
-       register struct rx_call *call;
+       struct rx_call *call;
        call = mh->calls[i] = rx_NewCall(conns[i]);
        rx_SetArrivalProc(call, multi_Ready, (void *) mh, i);
     }
@@ -67,7 +67,7 @@ multi_Init(struct rx_connection **conns, register int nConns)
 
 /* Return the user's connection index of the most recently ready call; that is, a call that has received at least one reply packet */
 int
-multi_Select(register struct multi_handle *mh)
+multi_Select(struct multi_handle *mh)
 {
     int index;
     SPLVAR;
@@ -100,10 +100,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 void *amh,
-           register int index)
+multi_Ready(struct rx_call *call, void *amh,
+           int index)
 {
-    register struct multi_handle *mh = (struct multi_handle *)amh;
+    struct multi_handle *mh = (struct multi_handle *)amh;
 #ifdef RX_ENABLE_LOCKS
     MUTEX_ENTER(&mh->lock);
 #endif /* RX_ENABLE_LOCKS */
@@ -119,12 +119,12 @@ multi_Ready(register struct rx_call *call, register void *amh,
 
 /* Called when the multi rx call is over, or when the user aborts it (by using the macro multi_Abort) */
 void
-multi_Finalize(register struct multi_handle *mh)
+multi_Finalize(struct multi_handle *mh)
 {
-    register int i;
-    register int nCalls = mh->nConns;
+    int i;
+    int nCalls = mh->nConns;
     for (i = 0; i < nCalls; i++) {
-       register struct rx_call *call = mh->calls[i];
+       struct rx_call *call = mh->calls[i];
        if (call)
            rx_EndCall(call, RX_USER_ABORT);
     }
@@ -139,12 +139,12 @@ multi_Finalize(register struct multi_handle *mh)
 
 /* ignores all remaining multiRx calls */
 void
-multi_Finalize_Ignore(register struct multi_handle *mh)
+multi_Finalize_Ignore(struct multi_handle *mh)
 {
-    register int i;
-    register int nCalls = mh->nConns;
+    int i;
+    int nCalls = mh->nConns;
     for (i = 0; i < nCalls; i++) {
-       register struct rx_call *call = mh->calls[i];
+       struct rx_call *call = mh->calls[i];
        if (call)
            rx_EndCall(call, 0);
     }
index 82fb38f..56e2cc7 100644 (file)
@@ -25,9 +25,9 @@ struct multi_handle {
 
 #define multi_Rx(conns, nConns) \
     do {\
-       register struct multi_handle *multi_h;\
-       register int multi_i;\
-       register struct rx_call *multi_call;\
+       struct multi_handle *multi_h;\
+       int multi_i;\
+       struct rx_call *multi_call;\
        multi_h = multi_Init(conns, nConns);\
        for (multi_i = 0; multi_i < nConns; multi_i++)
 
@@ -37,7 +37,7 @@ struct multi_handle {
        rx_FlushWrite(multi_call);\
        }\
        while ((multi_i = multi_Select(multi_h)) >= 0) {\
-           register afs_int32 multi_error;\
+           afs_int32 multi_error;\
            multi_call = multi_h->calls[multi_i];\
            multi_error = rx_EndCall(multi_call, endProc);\
            multi_h->calls[multi_i] = (struct rx_call *) 0
index 10fb2e3..f189fab 100644 (file)
@@ -251,7 +251,7 @@ rx_SlowWritePacket(struct rx_packet * packet, int offset, int resid, char *in)
 int
 rxi_AllocPackets(int class, int num_pkts, struct rx_queue * q)
 {
-    register struct rx_packet *p, *np;
+    struct rx_packet *p, *np;
 
     num_pkts = AllocPacketBufs(class, num_pkts, q);
 
@@ -266,7 +266,7 @@ rxi_AllocPackets(int class, int num_pkts, struct rx_queue * q)
 static int
 AllocPacketBufs(int class, int num_pkts, struct rx_queue * q)
 {
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_ts_info_t * rx_ts_info;
     int transfer;
     SPLVAR;
 
@@ -375,8 +375,8 @@ AllocPacketBufs(int class, int num_pkts, struct rx_queue * q)
 int
 rxi_FreePackets(int num_pkts, struct rx_queue * q)
 {
-    register struct rx_ts_info_t * rx_ts_info;
-    register struct rx_packet *c, *nc;
+    struct rx_ts_info_t * rx_ts_info;
+    struct rx_packet *c, *nc;
     SPLVAR;
 
     osi_Assert(num_pkts >= 0);
@@ -417,7 +417,7 @@ int
 rxi_FreePackets(int num_pkts, struct rx_queue *q)
 {
     struct rx_queue cbs;
-    register struct rx_packet *p, *np;
+    struct rx_packet *p, *np;
     int qlen = 0;
     SPLVAR;
 
@@ -502,7 +502,7 @@ rxi_AllocDataBuf(struct rx_packet *p, int nb, int class)
 {
     int i, nv;
     struct rx_queue q;
-    register struct rx_packet *cb, *ncb;
+    struct rx_packet *cb, *ncb;
 
     /* compute the number of cbuf's we need */
     nv = nb / RX_CBUFFERSIZE;
@@ -537,7 +537,7 @@ void
 rxi_MorePackets(int apackets)
 {
     struct rx_packet *p, *e;
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_ts_info_t * rx_ts_info;
     int getme;
     SPLVAR;
 
@@ -631,7 +631,7 @@ void
 rxi_MorePacketsTSFPQ(int apackets, int flush_global, int num_keep_local)
 {
     struct rx_packet *p, *e;
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_ts_info_t * rx_ts_info;
     int getme;
     SPLVAR;
 
@@ -687,7 +687,7 @@ void
 rxi_MorePacketsNoLock(int apackets)
 {
 #ifdef RX_ENABLE_TSFPQ
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_ts_info_t * rx_ts_info;
 #endif /* RX_ENABLE_TSFPQ */
     struct rx_packet *p, *e;
     int getme;
@@ -751,8 +751,8 @@ rxi_FreeAllPackets(void)
 void
 rxi_AdjustLocalPacketsTSFPQ(int num_keep_local, int allow_overcommit)
 {
-    register struct rx_ts_info_t * rx_ts_info;
-    register int xfer;
+    struct rx_ts_info_t * rx_ts_info;
+    int xfer;
     SPLVAR;
 
     RX_TS_INFO_GET(rx_ts_info);
@@ -814,7 +814,7 @@ rx_CheckPackets(void)
 void
 rxi_FreePacketNoLock(struct rx_packet *p)
 {
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_ts_info_t * rx_ts_info;
     dpf(("Free %lx\n", (unsigned long)p));
 
     RX_TS_INFO_GET(rx_ts_info);
@@ -839,7 +839,7 @@ rxi_FreePacketNoLock(struct rx_packet *p)
 void
 rxi_FreePacketTSFPQ(struct rx_packet *p, int flush_global)
 {
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_ts_info_t * rx_ts_info;
     dpf(("Free %lx\n", (unsigned long)p));
 
     RX_TS_INFO_GET(rx_ts_info);
@@ -937,7 +937,7 @@ static int
 rxi_FreeDataBufsTSFPQ(struct rx_packet *p, afs_uint32 first, int flush_global)
 {
     struct iovec *iov;
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_ts_info_t * rx_ts_info;
 
     RX_TS_INFO_GET(rx_ts_info);
 
@@ -997,7 +997,7 @@ rxi_TrimDataBufs(struct rx_packet *p, int first)
 {
     int length;
     struct iovec *iov, *end;
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_ts_info_t * rx_ts_info;
     SPLVAR;
 
     if (first != 1)
@@ -1116,8 +1116,8 @@ rxi_FreePacket(struct rx_packet *p)
 struct rx_packet *
 rxi_AllocPacketNoLock(int class)
 {
-    register struct rx_packet *p;
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_packet *p;
+    struct rx_ts_info_t * rx_ts_info;
 
     RX_TS_INFO_GET(rx_ts_info);
 
@@ -1179,7 +1179,7 @@ rxi_AllocPacketNoLock(int class)
 struct rx_packet *
 rxi_AllocPacketNoLock(int class)
 {
-    register struct rx_packet *p;
+    struct rx_packet *p;
 
 #ifdef KERNEL
     if (rxi_OverQuota(class)) {
@@ -1239,8 +1239,8 @@ rxi_AllocPacketNoLock(int class)
 struct rx_packet *
 rxi_AllocPacketTSFPQ(int class, int pull_global)
 {
-    register struct rx_packet *p;
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_packet *p;
+    struct rx_ts_info_t * rx_ts_info;
 
     RX_TS_INFO_GET(rx_ts_info);
 
@@ -1276,7 +1276,7 @@ rxi_AllocPacketTSFPQ(int class, int pull_global)
 struct rx_packet *
 rxi_AllocPacket(int class)
 {
-    register struct rx_packet *p;
+    struct rx_packet *p;
 
     p = rxi_AllocPacketTSFPQ(class, RX_TS_FPQ_PULL_GLOBAL);
     return p;
@@ -1285,7 +1285,7 @@ rxi_AllocPacket(int class)
 struct rx_packet *
 rxi_AllocPacket(int class)
 {
-    register struct rx_packet *p;
+    struct rx_packet *p;
 
     MUTEX_ENTER(&rx_freePktQ_lock);
     p = rxi_AllocPacketNoLock(class);
@@ -1300,11 +1300,11 @@ rxi_AllocPacket(int class)
  * Called with call locked.
  */
 struct rx_packet *
-rxi_AllocSendPacket(register struct rx_call *call, int want)
+rxi_AllocSendPacket(struct rx_call *call, int want)
 {
-    register struct rx_packet *p = (struct rx_packet *)0;
-    register int mud;
-    register unsigned delta;
+    struct rx_packet *p = (struct rx_packet *)0;
+    int mud;
+    unsigned delta;
 
     SPLVAR;
     mud = call->MTU - RX_HEADER_SIZE;
@@ -1391,11 +1391,11 @@ rxi_AllocSendPacket(register struct rx_call *call, int want)
 #else
 /* count the number of used FDs */
 static int
-CountFDs(register int amax)
+CountFDs(int amax)
 {
     struct stat tstat;
-    register int i, code;
-    register int count;
+    int i, code;
+    int count;
 
     count = 0;
     for (i = 0; i < amax; i++) {
@@ -1420,13 +1420,13 @@ CountFDs(register int amax)
  * the data length of the packet is stored in the packet structure.
  * The header is decoded. */
 int
-rxi_ReadPacket(osi_socket socket, register struct rx_packet *p, afs_uint32 * host,
+rxi_ReadPacket(osi_socket socket, struct rx_packet *p, afs_uint32 * host,
               u_short * port)
 {
     struct sockaddr_in from;
     int nbytes;
     afs_int32 rlen;
-    register afs_int32 tlen, savelen;
+    afs_int32 tlen, savelen;
     struct msghdr msg;
     rx_computelen(p, tlen);
     rx_SetDataSize(p, tlen);   /* this is the size of the user data area */
@@ -1491,7 +1491,9 @@ rxi_ReadPacket(osi_socket socket, register struct rx_packet *p, afs_uint32 * hos
              p->header.serial, rx_packetTypes[p->header.type - 1], ntohl(*host), ntohs(*port), p->header.serial, 
              p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, 
              p->length));
+#ifdef RX_TRIMDATABUFS
        rxi_TrimDataBufs(p, 1);
+#endif
        return 0;
     } 
 #endif
@@ -1528,9 +1530,10 @@ rxi_ReadPacket(osi_socket socket, register struct rx_packet *p, afs_uint32 * hos
            }
        }
 
+#ifdef RX_TRIMDATABUFS
        /* Free any empty packet buffers at the end of this packet */
        rxi_TrimDataBufs(p, 1);
-
+#endif 
        return 1;
     }
 }
@@ -1546,7 +1549,7 @@ rxi_ReadPacket(osi_socket socket, register struct rx_packet *p, afs_uint32 * hos
  * last two pad bytes. */
 
 struct rx_packet *
-rxi_SplitJumboPacket(register struct rx_packet *p, afs_int32 host, short port,
+rxi_SplitJumboPacket(struct rx_packet *p, afs_int32 host, short port,
                     int first)
 {
     struct rx_packet *np;
@@ -1639,9 +1642,9 @@ osi_NetSend(osi_socket socket, void *addr, struct iovec *dvec, int nvecs,
  * The message is NOT changed.
  */
 static int
-cpytoc(mblk_t * mp, register int off, register int len, register char *cp)
+cpytoc(mblk_t * mp, int off, int len, char *cp)
 {
-    register int n;
+    int n;
 
     for (; mp && len > 0; mp = mp->b_cont) {
        if (mp->b_datap->db_type != M_DATA) {
@@ -1661,10 +1664,10 @@ cpytoc(mblk_t * mp, register int off, register int len, register char *cp)
  * This sucks, anyway, do it like m_cpy.... below 
  */
 static int
-cpytoiovec(mblk_t * mp, int off, int len, register struct iovec *iovs,
+cpytoiovec(mblk_t * mp, int off, int len, struct iovec *iovs,
           int niovs)
 {
-    register int m, n, o, t, i;
+    int m, n, o, t, i;
 
     for (i = -1, t = 0; i < niovs && mp && len > 0; mp = mp->b_cont) {
        if (mp->b_datap->db_type != M_DATA) {
@@ -1760,7 +1763,7 @@ rx_mb_to_packet(amb, free, hdr_len, data_len, phandle)
      struct rx_packet *phandle;
      int hdr_len, data_len;
 {
-    register int code;
+    int code;
 
     code =
        m_cpytoiovec(amb, hdr_len, data_len, phandle->wirevec,
@@ -1776,7 +1779,7 @@ rx_mb_to_packet(amb, free, hdr_len, data_len, phandle)
 /* send a response to a debug packet */
 
 struct rx_packet *
-rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
+rxi_ReceiveDebugPacket(struct rx_packet *ap, osi_socket asocket,
                       afs_int32 ahost, short aport, int istack)
 {
     struct rx_debugIn tin;
@@ -1840,7 +1843,7 @@ rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
     case RX_DEBUGI_GETALLCONN:
     case RX_DEBUGI_GETCONN:{
            int i, j;
-           register struct rx_connection *tc;
+           struct rx_connection *tc;
            struct rx_call *tcall;
            struct rx_debugConn tconn;
            int all = (tin.type == RX_DEBUGI_GETALLCONN);
@@ -1949,7 +1952,7 @@ rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
 
     case RX_DEBUGI_GETPEER:{
            int i;
-           register struct rx_peer *tp;
+           struct rx_peer *tp;
            struct rx_debugPeer tpeer;
 
 
@@ -2078,7 +2081,7 @@ rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
 }
 
 struct rx_packet *
-rxi_ReceiveVersionPacket(register struct rx_packet *ap, osi_socket asocket,
+rxi_ReceiveVersionPacket(struct rx_packet *ap, osi_socket asocket,
                         afs_int32 ahost, short aport, int istack)
 {
     afs_int32 tl;
@@ -2187,7 +2190,7 @@ rxi_SendPacket(struct rx_call *call, struct rx_connection *conn,
 #endif
     int code;
     struct sockaddr_in addr;
-    register struct rx_peer *peer = conn->peer;
+    struct rx_peer *peer = conn->peer;
     osi_socket socket;
 #ifdef RXDEBUG
     char deliveryType = 'S';
@@ -2331,7 +2334,7 @@ rxi_SendPacketList(struct rx_call *call, struct rx_connection *conn,
     int waslocked;
 #endif
     struct sockaddr_in addr;
-    register struct rx_peer *peer = conn->peer;
+    struct rx_peer *peer = conn->peer;
     osi_socket socket;
     struct rx_packet *p = NULL;
     struct iovec wirevec[RX_MAXIOVECS];
@@ -2515,14 +2518,14 @@ rxi_SendPacketList(struct rx_call *call, struct rx_connection *conn,
  * in rx.h.  Bug: there's a lot of duplication between this and other
  * routines.  This needs to be cleaned up. */
 struct rx_packet *
-rxi_SendSpecial(register struct rx_call *call,
-               register struct rx_connection *conn,
+rxi_SendSpecial(struct rx_call *call,
+               struct rx_connection *conn,
                struct rx_packet *optionalPacket, int type, char *data,
                int nbytes, int istack)
 {
     /* Some of the following stuff should be common code for all
      * packet sends (it's repeated elsewhere) */
-    register struct rx_packet *p;
+    struct rx_packet *p;
     unsigned int i = 0;
     int savelen = 0, saven = 0;
     int channel, callNumber;
@@ -2591,9 +2594,9 @@ rxi_SendSpecial(register struct rx_call *call,
  * the net byte order representation in the wire representation of the
  * packet, which is what is actually sent out on the wire) */
 void
-rxi_EncodePacketHeader(register struct rx_packet *p)
+rxi_EncodePacketHeader(struct rx_packet *p)
 {
-    register afs_uint32 *buf = (afs_uint32 *) (p->wirevec[0].iov_base);        /* MTUXXX */
+    afs_uint32 *buf = (afs_uint32 *) (p->wirevec[0].iov_base); /* MTUXXX */
 
     memset((char *)buf, 0, RX_HEADER_SIZE);
     *buf++ = htonl(p->header.epoch);
@@ -2610,9 +2613,9 @@ rxi_EncodePacketHeader(register struct rx_packet *p)
 
 /* Decode the packet's header (from net byte order to a struct header) */
 void
-rxi_DecodePacketHeader(register struct rx_packet *p)
+rxi_DecodePacketHeader(struct rx_packet *p)
 {
-    register afs_uint32 *buf = (afs_uint32 *) (p->wirevec[0].iov_base);        /* MTUXXX */
+    afs_uint32 *buf = (afs_uint32 *) (p->wirevec[0].iov_base); /* MTUXXX */
     afs_uint32 temp;
 
     p->header.epoch = ntohl(*buf);
@@ -2644,10 +2647,10 @@ rxi_DecodePacketHeader(register struct rx_packet *p)
 }
 
 void
-rxi_PrepareSendPacket(register struct rx_call *call,
-                     register struct rx_packet *p, register int last)
+rxi_PrepareSendPacket(struct rx_call *call,
+                     struct rx_packet *p, int last)
 {
-    register struct rx_connection *conn = call->conn;
+    struct rx_connection *conn = call->conn;
     int i;
     ssize_t len;               /* len must be a signed type; it can go negative */
 
index 1bee7ee..f476bc9 100644 (file)
@@ -256,7 +256,8 @@ struct rx_packet {
     afs_uint32 firstSerial;    /* Original serial number of this packet */
     struct clock firstSent;    /* When this packet was transmitted first */
     struct rx_header header;   /* The internal packet header */
-    unsigned int niovecs;
+    unsigned int niovecs;       /* # of iovecs that potentially have data */
+    unsigned int aiovecs;       /* # of allocated iovecs */
     struct iovec wirevec[RX_MAXWVECS + 1];     /* the new form of the packet */
 
     u_char flags;              /* Flags for local state of this packet */
@@ -267,10 +268,17 @@ struct rx_packet {
      * The jumbo datagram code also relies on the next two being
      * physically adjacent.
      * The Linux port uses this knowledge as well in osi_NetSend.
+     *
+     * The extradata field is padding in case the recvmsg implementation
+     * writes beyond the end of the final iovec buffer.  We do not know 
+     * what platforms had this problem so we are reluctant to remove it.
+     * the extradata must be adjacent to localdata.
+     * See rxk_ReadPacket and rxi_ReadPacket.
      */
     afs_uint32 wirehead[RX_HEADER_SIZE / sizeof(afs_int32)];
     afs_uint32 localdata[RX_CBUFFERSIZE / sizeof(afs_int32)];
     afs_uint32 extradata[RX_EXTRABUFFERSIZE / sizeof(afs_int32)];
+
 #ifdef RXDEBUG_PACKET
     /* For debugging */
     struct rx_packet *allNextp; /* A list of all packets */
@@ -336,7 +344,7 @@ struct rx_packet {
     rx_SlowReadPacket(p, off, len, (char*)(out)) :             \
     ((memcpy((char *)(out), (char*)((p)->wirevec[1].iov_base)+(off), (len))),0))
 
-#define rx_computelen(p,l) { register int i; \
+#define rx_computelen(p,l) { int i; \
    for (l=0, i=1; i < p->niovecs; i++ ) l += p->wirevec[i].iov_len; }
 
 /* return what the actual contiguous space is: should be min(length,size) */
index 5f99d2b..5ca81fb 100644 (file)
@@ -32,23 +32,23 @@ extern void rx_StatsOnOff(int on);
 extern void rxi_StartServerProcs(int nExistingProcs);
 #endif
 extern void rx_StartServer(int donateMe);
-extern struct rx_connection *rx_NewConnection(register afs_uint32 shost,
+extern struct rx_connection *rx_NewConnection(afs_uint32 shost,
                                              u_short sport, u_short sservice,
-                                             register struct rx_securityClass
+                                             struct rx_securityClass
                                              *securityObject,
                                              int serviceSecurityIndex);
-extern void rx_SetConnDeadTime(register struct rx_connection *conn,
-                              register int seconds);
+extern void rx_SetConnDeadTime(struct rx_connection *conn,
+                              int seconds);
 extern void rxi_CleanupConnection(struct rx_connection *conn);
-extern void rxi_DestroyConnection(register struct rx_connection *conn);
-extern void rx_GetConnection(register struct rx_connection *conn);
-extern void rx_DestroyConnection(register struct rx_connection *conn);
-extern struct rx_call *rx_NewCall(register struct rx_connection *conn);
-extern int rxi_HasActiveCalls(register struct rx_connection *aconn);
-extern int rxi_GetCallNumberVector(register struct rx_connection *aconn,
-                                  register afs_int32 * aint32s);
-extern int rxi_SetCallNumberVector(register struct rx_connection *aconn,
-                                  register afs_int32 * aint32s);
+extern void rxi_DestroyConnection(struct rx_connection *conn);
+extern void rx_GetConnection(struct rx_connection *conn);
+extern void rx_DestroyConnection(struct rx_connection *conn);
+extern struct rx_call *rx_NewCall(struct rx_connection *conn);
+extern int rxi_HasActiveCalls(struct rx_connection *aconn);
+extern int rxi_GetCallNumberVector(struct rx_connection *aconn,
+                                  afs_int32 * aint32s);
+extern int rxi_SetCallNumberVector(struct rx_connection *aconn,
+                                  afs_int32 * aint32s);
 extern struct rx_service *rx_NewService(u_short port, u_short serviceId,
                                        char *serviceName,
                                        struct rx_securityClass
@@ -71,105 +71,105 @@ extern void rxi_ServerProc(int threadID, struct rx_call *newcall,
 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 *
+extern void rx_SetArrivalProc(struct rx_call *call,
+                             void (*proc) (struct rx_call *
                                                    call,
-                                                   register void * mh,
-                                                   register int index),
-                             register void * handle, register int arg);
-extern afs_int32 rx_EndCall(register struct rx_call *call, afs_int32 rc);
+                                                   void * mh,
+                                                   int index),
+                             void * handle, int arg);
+extern afs_int32 rx_EndCall(struct rx_call *call, afs_int32 rc);
 extern void rx_Finalize(void);
 extern void rxi_PacketsUnWait(void);
-extern struct rx_service *rxi_FindService(register osi_socket socket,
-                                         register u_short serviceId);
-extern struct rx_call *rxi_NewCall(register struct rx_connection *conn,
-                                  register int channel);
+extern struct rx_service *rxi_FindService(osi_socket socket,
+                                         u_short serviceId);
+extern struct rx_call *rxi_NewCall(struct rx_connection *conn,
+                                  int channel);
 
 /* Don't like this - change source at some point to make calls identical */
 #ifdef RX_ENABLE_LOCKS
-extern void rxi_FreeCall(register struct rx_call *call, int haveCTLock);
+extern void rxi_FreeCall(struct rx_call *call, int haveCTLock);
 #else /* RX_ENABLE_LOCKS */
-extern void rxi_FreeCall(register struct rx_call *call);
+extern void rxi_FreeCall(struct rx_call *call);
 #endif /* RX_ENABLE_LOCKS */
 
-extern char *rxi_Alloc(register size_t size);
-extern void rxi_Free(void *addr, register size_t size);
-extern void rxi_SetPeerMtu(register afs_uint32 host, register afs_uint32 port,
+extern char *rxi_Alloc(size_t size);
+extern void rxi_Free(void *addr, size_t size);
+extern void rxi_SetPeerMtu(afs_uint32 host, afs_uint32 port,
             int mtu);
-extern struct rx_peer *rxi_FindPeer(register afs_uint32 host,
-                                   register u_short port,
+extern struct rx_peer *rxi_FindPeer(afs_uint32 host,
+                                   u_short port,
                                    struct rx_peer *origPeer, int create);
 extern struct rx_connection *rxi_FindConnection(osi_socket socket,
-                                               register afs_int32 host,
-                                               register u_short port,
+                                               afs_int32 host,
+                                               u_short port,
                                                u_short serviceId,
                                                afs_uint32 cid,
                                                afs_uint32 epoch, int type,
                                                u_int securityIndex);
-extern struct rx_packet *rxi_ReceivePacket(register struct rx_packet *np,
+extern struct rx_packet *rxi_ReceivePacket(struct rx_packet *np,
                                           osi_socket socket, afs_uint32 host,
                                           u_short port, int *tnop,
                                           struct rx_call **newcallp);
 extern int rxi_IsConnInteresting(struct rx_connection *aconn);
-extern struct rx_packet *rxi_ReceiveDataPacket(register struct rx_call *call,
-                                              register struct rx_packet *np,
+extern struct rx_packet *rxi_ReceiveDataPacket(struct rx_call *call,
+                                              struct rx_packet *np,
                                               int istack, osi_socket socket,
                                               afs_uint32 host, u_short port,
                                               int *tnop,
                                               struct rx_call **newcallp);
-extern struct rx_packet *rxi_ReceiveAckPacket(register struct rx_call *call,
+extern struct rx_packet *rxi_ReceiveAckPacket(struct rx_call *call,
                                              struct rx_packet *np,
                                              int istack);
-extern struct rx_packet *rxi_ReceiveResponsePacket(register struct
-                                                  rx_connection *conn, register struct rx_packet
+extern struct rx_packet *rxi_ReceiveResponsePacket(struct
+                                                  rx_connection *conn, struct rx_packet
                                                   *np, int istack);
-extern struct rx_packet *rxi_ReceiveChallengePacket(register struct
-                                                   rx_connection *conn, register struct rx_packet
+extern struct rx_packet *rxi_ReceiveChallengePacket(struct
+                                                   rx_connection *conn, struct rx_packet
                                                    *np, int istack);
-extern void rxi_AttachServerProc(register struct rx_call *call,
-                                register osi_socket socket,
-                                register int *tnop,
-                                register struct rx_call **newcallp);
-extern void rxi_AckAll(struct rxevent *event, register struct rx_call *call,
+extern void rxi_AttachServerProc(struct rx_call *call,
+                                osi_socket socket,
+                                int *tnop,
+                                struct rx_call **newcallp);
+extern void rxi_AckAll(struct rxevent *event, struct rx_call *call,
                       char *dummy);
 extern void rxi_SendDelayedAck(struct rxevent *event,
                               void *call /* struct rx_call *call */, void *dummy);
-extern void rxi_ClearTransmitQueue(register struct rx_call *call,
-                                  register int force);
-extern void rxi_ClearReceiveQueue(register struct rx_call *call);
-extern struct rx_packet *rxi_SendCallAbort(register struct rx_call *call,
+extern void rxi_ClearTransmitQueue(struct rx_call *call,
+                                  int force);
+extern void rxi_ClearReceiveQueue(struct rx_call *call);
+extern struct rx_packet *rxi_SendCallAbort(struct rx_call *call,
                                           struct rx_packet *packet,
                                           int istack, int force);
-extern struct rx_packet *rxi_SendConnectionAbort(register struct rx_connection
+extern struct rx_packet *rxi_SendConnectionAbort(struct rx_connection
                                                 *conn,
                                                 struct rx_packet *packet,
                                                 int istack, int force);
-extern void rxi_ConnectionError(register struct rx_connection *conn,
-                               register afs_int32 error);
-extern void rxi_CallError(register struct rx_call *call, afs_int32 error);
-extern void rxi_ResetCall(register struct rx_call *call,
-                         register int newcall);
-extern struct rx_packet *rxi_SendAck(register struct rx_call *call, register struct rx_packet
+extern void rxi_ConnectionError(struct rx_connection *conn,
+                               afs_int32 error);
+extern void rxi_CallError(struct rx_call *call, afs_int32 error);
+extern void rxi_ResetCall(struct rx_call *call,
+                         int newcall);
+extern struct rx_packet *rxi_SendAck(struct rx_call *call, struct rx_packet
                                     *optionalPacket, int serial, int reason,
                                     int istack);
 extern void rxi_StartUnlocked(struct rxevent *event,
-                             void *call, /* register struct rx_call */
+                             void *call, /* struct rx_call */
                              void *arg1, int istack);
 extern void rxi_Start(struct rxevent *event, 
-                     void *call, /* register struct rx_call */
+                     void *call, /* struct rx_call */
                      void *arg1, int istack);
-extern void rxi_Send(register struct rx_call *call,
-                    register struct rx_packet *p, int istack);
+extern void rxi_Send(struct rx_call *call,
+                    struct rx_packet *p, int istack);
 #ifdef RX_ENABLE_LOCKS
-extern int rxi_CheckCall(register struct rx_call *call, int haveCTLock);
+extern int rxi_CheckCall(struct rx_call *call, int haveCTLock);
 #else /* RX_ENABLE_LOCKS */
-extern int rxi_CheckCall(register struct rx_call *call);
+extern int rxi_CheckCall(struct rx_call *call);
 #endif /* RX_ENABLE_LOCKS */
 extern void rxi_KeepAliveEvent(struct rxevent *event,
                               void *call /* struct rx_call *call */, 
                               void *dummy);
-extern void rxi_ScheduleKeepAliveEvent(register struct rx_call *call);
-extern void rxi_KeepAliveOn(register struct rx_call *call);
+extern void rxi_ScheduleKeepAliveEvent(struct rx_call *call);
+extern void rxi_KeepAliveOn(struct rx_call *call);
 extern void rxi_SendDelayedConnAbort(struct rxevent *event,
                                     void *conn, /* struct rx_connection *conn */
                                     void *dummy);
@@ -179,10 +179,10 @@ extern void rxi_SendDelayedCallAbort(struct rxevent *event,
 extern void rxi_ChallengeEvent(struct rxevent *event,
                               void *conn, /* struct rx_connection *conn */
                               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,
-                                    register struct rx_peer *peer);
+extern void rxi_ChallengeOn(struct rx_connection *conn);
+extern void rxi_ComputeRoundTripTime(struct rx_packet *p,
+                                    struct clock *sentp,
+                                    struct rx_peer *peer);
 extern void rxi_ReapConnections(struct rxevent *unused, void *unused1, 
                                void *unused2);
 extern int rxs_Release(struct rx_securityClass *aobj);
@@ -323,9 +323,9 @@ extern struct rxevent *rxevent_PostNow2(struct clock *when, struct clock *now,
 extern void shutdown_rxevent(void);
 extern struct rxepoch *rxepoch_Allocate(struct clock *when);
 extern void rxevent_Init(int nEvents, void (*scheduler) (void));
-extern void rxevent_Cancel_1(register struct rxevent *ev,
-                            register struct rx_call *call,
-                            register int type);
+extern void rxevent_Cancel_1(struct rxevent *ev,
+                            struct rx_call *call,
+                            int type);
 extern int rxevent_RaiseEvents(struct clock *next);
 
 
@@ -370,7 +370,7 @@ extern void osi_Panic(char *fmt, ...);
 #endif
 #endif
 extern int osi_utoa(char *buf, size_t len, unsigned long val);
-extern void rxi_InitPeerParams(register struct rx_peer *pp);
+extern void rxi_InitPeerParams(struct rx_peer *pp);
 extern void shutdown_rxkernel(void);
 #ifdef AFS_USERSPACE_IP_ADDR
 extern int rxi_GetcbiInfo(void);
@@ -380,7 +380,7 @@ extern int rxi_GetIFInfo(void);
 #endif
 #ifndef UKERNEL
 #if 0
-extern int rxk_FreeSocket(register struct socket *asocket);
+extern int rxk_FreeSocket(struct socket *asocket);
 #endif
 #ifndef AFS_NT40_ENV
 extern osi_socket *rxk_NewSocket(short aport);
@@ -467,18 +467,18 @@ extern char *osi_alloc(afs_int32 x);
 #ifndef osi_free
 extern int osi_free(char *x, afs_int32 size);
 #endif
-extern int hton_syserr_conv(register afs_int32 code);
+extern int hton_syserr_conv(afs_int32 code);
 extern int ntoh_syserr_conv(int code);
 
 
 /* rx_multi.c */
 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 void *mh, register int index);
-extern void multi_Finalize(register struct multi_handle *mh);
-extern void multi_Finalize_Ignore(register struct multi_handle *mh);
+                                      int nConns);
+extern int multi_Select(struct multi_handle *mh);
+extern void multi_Ready(struct rx_call *call,
+                       void *mh, int index);
+extern void multi_Finalize(struct multi_handle *mh);
+extern void multi_Finalize_Ignore(struct multi_handle *mh);
 
 
 
@@ -509,22 +509,22 @@ extern struct rx_packet *rxi_AllocPacketNoLock(int cla_ss);
 extern struct rx_packet *rxi_AllocPacket(int cla_ss);
 extern int rxi_AllocPackets(int cla_ss, int num_pkts, struct rx_queue *q);
 extern int rxi_FreePackets(int num_pkts, struct rx_queue *q);
-extern struct rx_packet *rxi_AllocSendPacket(register struct rx_call *call,
+extern struct rx_packet *rxi_AllocSendPacket(struct rx_call *call,
                                             int want);
-extern int rxi_ReadPacket(osi_socket socket, register struct rx_packet *p,
+extern int rxi_ReadPacket(osi_socket socket, struct rx_packet *p,
                          afs_uint32 * host, u_short * port);
-extern struct rx_packet *rxi_SplitJumboPacket(register struct rx_packet *p,
+extern struct rx_packet *rxi_SplitJumboPacket(struct rx_packet *p,
                                              afs_int32 host, short port,
                                              int first);
 #ifndef KERNEL
 extern int osi_NetSend(osi_socket socket, void *addr, struct iovec *dvec,
                       int nvecs, int length, int istack);
 #endif
-extern struct rx_packet *rxi_ReceiveDebugPacket(register struct rx_packet *ap,
+extern struct rx_packet *rxi_ReceiveDebugPacket(struct rx_packet *ap,
                                                osi_socket asocket,
                                                afs_int32 ahost, short aport,
                                                int istack);
-extern struct rx_packet *rxi_ReceiveVersionPacket(register struct rx_packet
+extern struct rx_packet *rxi_ReceiveVersionPacket(struct rx_packet
                                                  *ap, osi_socket asocket,
                                                  afs_int32 ahost,
                                                  short aport, int istack);
@@ -533,16 +533,16 @@ extern void rxi_SendPacket(struct rx_call *call, struct rx_connection *conn,
 extern void rxi_SendPacketList(struct rx_call *call,
                               struct rx_connection *conn,
                               struct rx_packet **list, int len, int istack);
-extern struct rx_packet *rxi_SendSpecial(register struct rx_call *call,
-                                        register struct rx_connection *conn,
+extern struct rx_packet *rxi_SendSpecial(struct rx_call *call,
+                                        struct rx_connection *conn,
                                         struct rx_packet *optionalPacket,
                                         int type, char *data, int nbytes,
                                         int istack);
-extern void rxi_EncodePacketHeader(register struct rx_packet *p);
-extern void rxi_DecodePacketHeader(register struct rx_packet *p);
-extern void rxi_PrepareSendPacket(register struct rx_call *call,
-                                 register struct rx_packet *p,
-                                 register int last);
+extern void rxi_EncodePacketHeader(struct rx_packet *p);
+extern void rxi_DecodePacketHeader(struct rx_packet *p);
+extern void rxi_PrepareSendPacket(struct rx_call *call,
+                                 struct rx_packet *p,
+                                 int last);
 extern int rxi_AdjustIfMTU(int mtu);
 extern int rxi_AdjustMaxMTU(int mtu, int peerMaxMTU);
 extern int rxi_AdjustDgramPackets(int frags, int mtu);
@@ -566,8 +566,8 @@ extern int rxi_Sendmsg(osi_socket socket, struct msghdr *msg_p, int flags);
 
 
 /* rx_rdwr.c */
-extern int rxi_ReadProc(register struct rx_call *call, register char *buf,
-                       register int nbytes);
+extern int rxi_ReadProc(struct rx_call *call, char *buf,
+                       int nbytes);
 extern int rx_ReadProc(struct rx_call *call, char *buf, int nbytes);
 extern int rx_ReadProc32(struct rx_call *call, afs_int32 * value);
 extern int rxi_FillReadVec(struct rx_call *call, afs_uint32 serial);
@@ -575,11 +575,11 @@ extern int rxi_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio,
                         int maxio, int nbytes);
 extern int rx_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio,
                        int maxio, int nbytes);
-extern int rxi_WriteProc(register struct rx_call *call, register char *buf,
-                        register int nbytes);
+extern int rxi_WriteProc(struct rx_call *call, char *buf,
+                        int nbytes);
 extern int rx_WriteProc(struct rx_call *call, char *buf, int nbytes);
-extern int rx_WriteProc32(register struct rx_call *call,
-                         register afs_int32 * value);
+extern int rx_WriteProc32(struct rx_call *call,
+                         afs_int32 * value);
 extern int rxi_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio,
                           int maxio, int nbytes);
 extern int rx_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio,
@@ -588,7 +588,7 @@ extern int rxi_WritevProc(struct rx_call *call, struct iovec *iov, int nio,
                          int nbytes);
 extern int rx_WritevProc(struct rx_call *call, struct iovec *iov, int nio,
                         int nbytes);
-extern void rxi_FlushWrite(register struct rx_call *call);
+extern void rxi_FlushWrite(struct rx_call *call);
 extern void rx_FlushWrite(struct rx_call *call);
 
 /* rx_trace.c */
index c7e96ef..c780423 100644 (file)
@@ -216,7 +216,7 @@ rxi_ListenerProc(osi_socket sock, int *tnop, struct rx_call **newcallp)
 {
     unsigned int host;
     u_short port;
-    register struct rx_packet *p = (struct rx_packet *)0;
+    struct rx_packet *p = (struct rx_packet *)0;
 
     MUTEX_ENTER(&listener_mutex);
     while (!listeners_started) {
@@ -445,7 +445,7 @@ rxi_Sendmsg(osi_socket socket, struct msghdr *msg_p, int flags)
 }
 
 struct rx_ts_info_t * rx_ts_info_init() {
-    register struct rx_ts_info_t * rx_ts_info;
+    struct rx_ts_info_t * rx_ts_info;
     rx_ts_info = (rx_ts_info_t *) malloc(sizeof(rx_ts_info_t));
     assert(rx_ts_info != NULL && pthread_setspecific(rx_ts_info_key, rx_ts_info) == 0);
     memset(rx_ts_info, 0, sizeof(rx_ts_info_t));
index d450eeb..4f5bf06 100644 (file)
@@ -103,13 +103,13 @@ static int rxdb_fileID = RXDB_FILE_RX_RDWR;
  * LOCKS USED -- called at netpri with rx global lock and call->lock held.
  */
 int
-rxi_ReadProc(register struct rx_call *call, register char *buf,
-            register int nbytes)
+rxi_ReadProc(struct rx_call *call, char *buf,
+            int nbytes)
 {
-    register struct rx_packet *cp = call->currentPacket;
-    register struct rx_packet *rp;
-    register int requestCount;
-    register unsigned int t;
+    struct rx_packet *cp = call->currentPacket;
+    struct rx_packet *rp;
+    int requestCount;
+    unsigned int t;
 
 /* XXXX took out clock_NewTime from here.  Was it needed? */
     requestCount = nbytes;
@@ -140,7 +140,7 @@ rxi_ReadProc(register struct rx_call *call, register char *buf,
                    rp = queue_First(&call->rq, rx_packet);
                    if (rp->header.seq == call->rnext) {
                        afs_int32 error;
-                       register struct rx_connection *conn = call->conn;
+                       struct rx_connection *conn = call->conn;
                        queue_Remove(rp);
                        rp->flags &= ~RX_PKTFLAG_RQ;
 #ifdef RXDEBUG_PACKET
@@ -225,9 +225,13 @@ rxi_ReadProc(register struct rx_call *call, register char *buf,
                    }
                }
 
-/*
-MTUXXX  doesn't there need to be an "else" here ??? 
-*/
+                /* 
+                 * If we reach this point either we have no packets in the
+                 * receive queue or the next packet in the queue is not the
+                 * one we are looking for.  There is nothing else for us to
+                 * do but wait for another packet to arrive.
+                 */
+
                /* Are there ever going to be any more packets? */
                if (call->flags & RX_CALL_RECEIVE_DONE) {
                    return requestCount - nbytes;
@@ -434,7 +438,7 @@ rxi_FillReadVec(struct rx_call *call, afs_uint32 serial)
 {
     int didConsume = 0;
     int didHardAck = 0;
-    register unsigned int t;
+    unsigned int t;
     struct rx_packet *rp;
     struct rx_packet *curp;
     struct iovec *call_iov;
@@ -454,7 +458,7 @@ rxi_FillReadVec(struct rx_call *call, afs_uint32 serial)
                rp = queue_First(&call->rq, rx_packet);
                if (rp->header.seq == call->rnext) {
                    afs_int32 error;
-                   register struct rx_connection *conn = call->conn;
+                   struct rx_connection *conn = call->conn;
                    queue_Remove(rp);
                    rp->flags &= ~RX_PKTFLAG_RQ;
 #ifdef RXDEBUG_PACKET
@@ -690,12 +694,12 @@ rx_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
  * LOCKS USED -- called at netpri with rx global lock and call->lock held. */
 
 int
-rxi_WriteProc(register struct rx_call *call, register char *buf,
-             register int nbytes)
+rxi_WriteProc(struct rx_call *call, char *buf,
+             int nbytes)
 {
     struct rx_connection *conn = call->conn;
-    register struct rx_packet *cp = call->currentPacket;
-    register unsigned int t;
+    struct rx_packet *cp = call->currentPacket;
+    unsigned int t;
     int requestCount = nbytes;
 
     /* Free any packets from the last call to ReadvProc/WritevProc */
@@ -818,7 +822,7 @@ rxi_WriteProc(register struct rx_call *call, register char *buf,
 
        if (cp && (int)call->nFree < nbytes) {
            /* Try to extend the current buffer */
-           register int len, mud;
+           int len, mud;
            len = cp->length;
            mud = rx_MaxUserDataSize(call);
            if (mud > len) {
@@ -922,7 +926,7 @@ rx_WriteProc(struct rx_call *call, char *buf, int nbytes)
 
 /* Optimization for marshalling 32 bit arguments */
 int
-rx_WriteProc32(register struct rx_call *call, register afs_int32 * value)
+rx_WriteProc32(struct rx_call *call, afs_int32 * value)
 {
     int bytes;
     int tcurlen;
@@ -1029,7 +1033,7 @@ rxi_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
     tcurpos = call->curpos;
     tcurlen = call->curlen;
     do {
-       register unsigned int t;
+       unsigned int t;
 
        if (tnFree == 0) {
            /* current packet is full, allocate a new one */
@@ -1054,7 +1058,7 @@ rxi_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
 
        if (tnFree < nbytes) {
            /* try to extend the current packet */
-           register int len, mud;
+           int len, mud;
            len = cp->length;
            mud = rx_MaxUserDataSize(call);
            if (mud > len) {
@@ -1316,9 +1320,9 @@ rx_WritevProc(struct rx_call *call, struct iovec *iov, int nio, int nbytes)
 /* Flush any buffered data to the stream, switch to read mode
  * (clients) or to EOF mode (servers) */
 void
-rxi_FlushWrite(register struct rx_call *call)
+rxi_FlushWrite(struct rx_call *call)
 {
-    register struct rx_packet *cp = NULL;
+    struct rx_packet *cp = NULL;
 
     /* Free any packets from the last call to ReadvProc/WritevProc */
     if (queue_IsNotEmpty(&call->iovq)) {
index b2779db..776c2a1 100644 (file)
@@ -87,7 +87,7 @@ xdr_void(void)
  * XDR integers
  */
 bool_t
-xdr_int(register XDR * xdrs, int *ip)
+xdr_int(XDR * xdrs, int *ip)
 {
     afs_int32 l;
 
@@ -114,7 +114,7 @@ xdr_int(register XDR * xdrs, int *ip)
  * XDR unsigned integers
  */
 bool_t
-xdr_u_int(register XDR * xdrs, u_int * uip)
+xdr_u_int(XDR * xdrs, u_int * uip)
 {
     afs_uint32 l;
 
@@ -142,7 +142,7 @@ xdr_u_int(register XDR * xdrs, u_int * uip)
  * XDR long integers
  */
 bool_t
-xdr_long(register XDR * xdrs, long *lp)
+xdr_long(XDR * xdrs, long *lp)
 {
     afs_int32 l;
 
@@ -169,7 +169,7 @@ xdr_long(register XDR * xdrs, long *lp)
  * XDR unsigned long integers
  */
 bool_t
-xdr_u_long(register XDR * xdrs, u_long * ulp)
+xdr_u_long(XDR * xdrs, u_long * ulp)
 {
     afs_uint32 l;
 
@@ -197,7 +197,7 @@ xdr_u_long(register XDR * xdrs, u_long * ulp)
  * XDR chars
  */
 bool_t
-xdr_char(register XDR * xdrs, char *sp)
+xdr_char(XDR * xdrs, char *sp)
 {
     afs_int32 l;
 
@@ -224,7 +224,7 @@ xdr_char(register XDR * xdrs, char *sp)
  * XDR unsigned chars
  */
 bool_t
-xdr_u_char(register XDR * xdrs, u_char * usp)
+xdr_u_char(XDR * xdrs, u_char * usp)
 {
     afs_uint32 l;
 
@@ -252,7 +252,7 @@ xdr_u_char(register XDR * xdrs, u_char * usp)
  * XDR short integers
  */
 bool_t
-xdr_short(register XDR * xdrs, short *sp)
+xdr_short(XDR * xdrs, short *sp)
 {
     afs_int32 l;
 
@@ -279,7 +279,7 @@ xdr_short(register XDR * xdrs, short *sp)
  * XDR unsigned short integers
  */
 bool_t
-xdr_u_short(register XDR * xdrs, u_short * usp)
+xdr_u_short(XDR * xdrs, u_short * usp)
 {
     afs_uint32 l;
 
@@ -307,7 +307,7 @@ xdr_u_short(register XDR * xdrs, u_short * usp)
  * XDR booleans
  */
 bool_t
-xdr_bool(register XDR * xdrs, bool_t * bp)
+xdr_bool(XDR * xdrs, bool_t * bp)
 {
     afs_int32 lb;
 
@@ -334,7 +334,7 @@ xdr_bool(register XDR * xdrs, bool_t * bp)
  * XDR enumerations
  */
 bool_t
-xdr_enum(register XDR * xdrs, enum_t * ep)
+xdr_enum(XDR * xdrs, enum_t * ep)
 {
     enum sizecheck { SIZEVAL };        /* used to find the size of an enum */
 
@@ -352,9 +352,9 @@ xdr_enum(register XDR * xdrs, enum_t * ep)
  * cp points to the opaque object and cnt gives the byte length.
  */
 bool_t
-xdr_opaque(register XDR * xdrs, caddr_t cp, register u_int cnt)
+xdr_opaque(XDR * xdrs, caddr_t cp, u_int cnt)
 {
-    register u_int rndup;
+    u_int rndup;
     int crud[BYTES_PER_XDR_UNIT];
     char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
 
@@ -402,11 +402,11 @@ xdr_opaque(register XDR * xdrs, caddr_t cp, register u_int cnt)
  * If *cpp is NULL maxsize bytes are allocated
  */
 bool_t
-xdr_bytes(register XDR * xdrs, char **cpp, register u_int * sizep,
+xdr_bytes(XDR * xdrs, char **cpp, u_int * sizep,
          u_int maxsize)
 {
-    register char *sp = *cpp;  /* sp is the actual string pointer */
-    register u_int nodesize;
+    char *sp = *cpp;   /* sp is the actual string pointer */
+    u_int nodesize;
 
     /*
      * first deal with the length since xdr bytes are counted
@@ -464,10 +464,10 @@ xdr_bytes(register XDR * xdrs, char **cpp, register u_int * sizep,
        xdrproc_t dfault;       * default xdr routine *
 */
 bool_t
-xdr_union(register XDR * xdrs, enum_t * dscmp, caddr_t unp,
+xdr_union(XDR * xdrs, enum_t * dscmp, caddr_t unp,
          struct xdr_discrim * choices, xdrproc_t dfault)
 {
-    register enum_t dscm;
+    enum_t dscm;
 
     /*
      * we deal with the discriminator;  it's an enum
@@ -509,9 +509,9 @@ xdr_union(register XDR * xdrs, enum_t * dscmp, caddr_t unp,
  * of the string as specified by a protocol.
  */
 bool_t
-xdr_string(register XDR * xdrs, char **cpp, u_int maxsize)
+xdr_string(XDR * xdrs, char **cpp, u_int maxsize)
 {
-    register char *sp = *cpp;  /* sp is the actual string pointer */
+    char *sp = *cpp;   /* sp is the actual string pointer */
     u_int size;
     u_int nodesize;
 
@@ -576,7 +576,7 @@ xdr_string(register XDR * xdrs, char **cpp, u_int maxsize)
  */
 #ifndef        KERNEL
 bool_t
-xdr_wrapstring(register XDR * xdrs, char **cpp)
+xdr_wrapstring(XDR * xdrs, char **cpp)
 {
     if (xdr_string(xdrs, cpp, BUFSIZ)) {
        return (TRUE);
index ff7183b..35a6d7a 100644 (file)
@@ -82,14 +82,14 @@ RCSID
 */
 
 bool_t
-xdr_array(register XDR * xdrs, caddr_t * addrp, u_int * sizep, u_int maxsize,
+xdr_array(XDR * xdrs, caddr_t * addrp, u_int * sizep, u_int maxsize,
          u_int elsize, xdrproc_t elproc)
 {
-    register u_int i;
-    register caddr_t target = *addrp;
-    register u_int c;          /* the actual element count */
-    register bool_t stat = TRUE;
-    register u_int nodesize;
+    u_int i;
+    caddr_t target = *addrp;
+    u_int c;           /* the actual element count */
+    bool_t stat = TRUE;
+    u_int nodesize;
 
     /* FIXME: this does not look correct: MSVC 6 computes -1 / elsize here */
     i = ((~0) >> 1) / elsize;
index 0860afe..79907d1 100644 (file)
@@ -83,14 +83,14 @@ RCSID
 */
 #ifdef KERNEL
 bool_t
-xdr_arrayN(register XDR * xdrs, caddr_t * addrp, u_int * sizep, u_int maxsize,
+xdr_arrayN(XDR * xdrs, caddr_t * addrp, u_int * sizep, u_int maxsize,
           u_int elsize, xdrproc_t elproc)
 {
-    register u_int i;
-    register caddr_t target = *addrp;
-    register u_int c;          /* the actual element count */
-    register bool_t stat = TRUE;
-    register u_int nodesize;
+    u_int i;
+    caddr_t target = *addrp;
+    u_int c;           /* the actual element count */
+    bool_t stat = TRUE;
+    u_int nodesize;
 
     i = ((~0) >> 1) / elsize;
     if (maxsize > i)
index eef3bdf..6f2047d 100644 (file)
@@ -54,7 +54,7 @@ RCSID
  */
 
 bool_t
-xdr_float(register XDR * xdrs, register float *fp)
+xdr_float(XDR * xdrs, float *fp)
 {
 #ifdef AFS_NT40_ENV
     return (FALSE);
@@ -75,7 +75,7 @@ xdr_float(register XDR * xdrs, register float *fp)
 }
 
 bool_t
-xdr_double(register XDR * xdrs, double *dp)
+xdr_double(XDR * xdrs, double *dp)
 {
 #ifdef AFS_NT40_ENV
     return (FALSE);
index 58231df..a39273c 100644 (file)
@@ -51,7 +51,7 @@ RCSID
  * same as xdr_u_long - open coded to save a proc call!
  */
 bool_t
-xdr_afs_int32(register XDR * xdrs, afs_int32 * lp)
+xdr_afs_int32(XDR * xdrs, afs_int32 * lp)
 {
 
     if (xdrs->x_op == XDR_ENCODE)
@@ -71,7 +71,7 @@ xdr_afs_int32(register XDR * xdrs, afs_int32 * lp)
  * same as xdr_long - open coded to save a proc call!
  */
 bool_t
-xdr_afs_uint32(register XDR * xdrs, afs_uint32 * ulp)
+xdr_afs_uint32(XDR * xdrs, afs_uint32 * ulp)
 {
 
     if (xdrs->x_op == XDR_DECODE)
index 460cf39..2b9eb9f 100644 (file)
@@ -26,13 +26,13 @@ RCSID
  * XDR afs_int64 integers
  */
 bool_t
-xdr_int64(register XDR * xdrs, afs_int64 * ulp)
+xdr_int64(XDR * xdrs, afs_int64 * ulp)
 {
     return xdr_afs_int64(xdrs, ulp);
 }
 
 bool_t
-xdr_afs_int64(register XDR * xdrs, afs_int64 * ulp)
+xdr_afs_int64(XDR * xdrs, afs_int64 * ulp)
 {
     afs_int32 high;
     afs_uint32 low;
@@ -63,13 +63,13 @@ xdr_afs_int64(register XDR * xdrs, afs_int64 * ulp)
  * XDR afs_int64 integers
  */
 bool_t
-xdr_uint64(register XDR * xdrs, afs_uint64 * ulp)
+xdr_uint64(XDR * xdrs, afs_uint64 * ulp)
 {
     return xdr_afs_uint64(xdrs, ulp);
 }
 
 bool_t
-xdr_afs_uint64(register XDR * xdrs, afs_uint64 * ulp)
+xdr_afs_uint64(XDR * xdrs, afs_uint64 * ulp)
 {
     afs_uint32 high;
     afs_uint32 low;
@@ -101,13 +101,13 @@ xdr_afs_uint64(register XDR * xdrs, afs_uint64 * ulp)
  * XDR afs_int64 integers
  */
 bool_t
-xdr_int64(register XDR * xdrs, afs_int64 * ulp)
+xdr_int64(XDR * xdrs, afs_int64 * ulp)
 {
     return xdr_afs_int64(xdrs, ulp);
 }
 
 bool_t
-xdr_afs_int64(register XDR * xdrs, afs_int64 * ulp)
+xdr_afs_int64(XDR * xdrs, afs_int64 * ulp)
 {
     if (xdrs->x_op == XDR_DECODE) {
        if (!XDR_GETINT32(xdrs, (afs_int32 *) & ulp->high))
@@ -128,13 +128,13 @@ xdr_afs_int64(register XDR * xdrs, afs_int64 * ulp)
  * XDR afs_uint64 integers
  */
 bool_t
-xdr_uint64(register XDR * xdrs, afs_uint64 * ulp)
+xdr_uint64(XDR * xdrs, afs_uint64 * ulp)
 {
     return xdr_afs_uint64(xdrs, ulp);
 }
 
 bool_t
-xdr_afs_uint64(register XDR * xdrs, afs_uint64 * ulp)
+xdr_afs_uint64(XDR * xdrs, afs_uint64 * ulp)
 {
     if (xdrs->x_op == XDR_DECODE) {
        if (!XDR_GETINT32(xdrs, (afs_uint32 *) & ulp->high))
index 14c8a63..a45fce4 100644 (file)
@@ -77,7 +77,7 @@ static struct xdr_ops xdrmem_ops = {
  * memory buffer.  
  */
 void
-xdrmem_create(register XDR * xdrs, caddr_t addr, u_int size, enum xdr_op op)
+xdrmem_create(XDR * xdrs, caddr_t addr, u_int size, enum xdr_op op)
 {
     xdrs->x_op = op;
     xdrs->x_ops = &xdrmem_ops;
@@ -91,7 +91,7 @@ xdrmem_destroy(void)
 }
 
 static bool_t
-xdrmem_getint32(register XDR * xdrs, afs_int32 * lp)
+xdrmem_getint32(XDR * xdrs, afs_int32 * lp)
 {
     if (xdrs->x_handy < sizeof(afs_int32))
        return (FALSE);
@@ -103,7 +103,7 @@ xdrmem_getint32(register XDR * xdrs, afs_int32 * lp)
 }
 
 static bool_t
-xdrmem_putint32(register XDR * xdrs, afs_int32 * lp)
+xdrmem_putint32(XDR * xdrs, afs_int32 * lp)
 {
     if (xdrs->x_handy < sizeof(afs_int32))
        return (FALSE);
@@ -115,7 +115,7 @@ xdrmem_putint32(register XDR * xdrs, afs_int32 * lp)
 }
 
 static bool_t
-xdrmem_getbytes(register XDR * xdrs, caddr_t addr, register u_int len)
+xdrmem_getbytes(XDR * xdrs, caddr_t addr, u_int len)
 {
     if (xdrs->x_handy < len)
        return (FALSE);
@@ -127,7 +127,7 @@ xdrmem_getbytes(register XDR * xdrs, caddr_t addr, register u_int len)
 }
 
 static bool_t
-xdrmem_putbytes(register XDR * xdrs, caddr_t addr, register u_int len)
+xdrmem_putbytes(XDR * xdrs, caddr_t addr, u_int len)
 {
     if (xdrs->x_handy < len)
        return (FALSE);
@@ -139,16 +139,16 @@ xdrmem_putbytes(register XDR * xdrs, caddr_t addr, register u_int len)
 }
 
 static u_int
-xdrmem_getpos(register XDR * xdrs)
+xdrmem_getpos(XDR * xdrs)
 {
     return ((u_int)(xdrs->x_private - xdrs->x_base));
 }
 
 static bool_t
-xdrmem_setpos(register XDR * xdrs, u_int pos)
+xdrmem_setpos(XDR * xdrs, u_int pos)
 {
-    register caddr_t newaddr = xdrs->x_base + pos;
-    register caddr_t lastaddr = xdrs->x_private + xdrs->x_handy;
+    caddr_t newaddr = xdrs->x_base + pos;
+    caddr_t lastaddr = xdrs->x_private + xdrs->x_handy;
 
     if (newaddr > lastaddr)
        return (FALSE);
@@ -158,7 +158,7 @@ xdrmem_setpos(register XDR * xdrs, u_int pos)
 }
 
 static afs_int32 *
-xdrmem_inline(register XDR * xdrs, int len)
+xdrmem_inline(XDR * xdrs, int len)
 {
     afs_int32 *buf = 0;
 
index c13186c..ef53d87 100644 (file)
@@ -16,61 +16,61 @@ struct rx_call;
 extern int xdr_afsUUID(XDR * xdrs, afsUUID * objp);
 
 /* xdr_int32.c */
-extern bool_t xdr_afs_int32(register XDR * xdrs, afs_int32 * ip);
-extern bool_t xdr_afs_uint32(register XDR * xdrs, afs_uint32 * up);
+extern bool_t xdr_afs_int32(XDR * xdrs, afs_int32 * ip);
+extern bool_t xdr_afs_uint32(XDR * xdrs, afs_uint32 * up);
 
 /* xdr_int64.c */
-extern bool_t xdr_int64(register XDR * xdrs, afs_int64 * ulp);
-extern bool_t xdr_afs_int64(register XDR * xdrs, afs_int64 * ulp);
-extern bool_t xdr_uint64(register XDR * xdrs, afs_uint64 * ulp);
-extern bool_t xdr_afs_uint64(register XDR * xdrs, afs_uint64 * ulp);
+extern bool_t xdr_int64(XDR * xdrs, afs_int64 * ulp);
+extern bool_t xdr_afs_int64(XDR * xdrs, afs_int64 * ulp);
+extern bool_t xdr_uint64(XDR * xdrs, afs_uint64 * ulp);
+extern bool_t xdr_afs_uint64(XDR * xdrs, afs_uint64 * ulp);
 
 /* xdr_rx.c */
-extern void xdrrx_create(register XDR * xdrs, register struct rx_call *call,
-                        register enum xdr_op op);
+extern void xdrrx_create(XDR * xdrs, struct rx_call *call,
+                        enum xdr_op op);
 
 #ifndef XDR_AFS_DECLS_ONLY
 
 /* xdr_array.c */
-extern bool_t xdr_array(register XDR * xdrs, caddr_t * addrp, u_int * sizep,
+extern bool_t xdr_array(XDR * xdrs, caddr_t * addrp, u_int * sizep,
                        u_int maxsize, u_int elsize, xdrproc_t elproc);
 
 /* xdr_arrayn.c */
-extern bool_t xdr_arrayN(register XDR * xdrs, caddr_t * addrp, u_int * sizep,
+extern bool_t xdr_arrayN(XDR * xdrs, caddr_t * addrp, u_int * sizep,
                         u_int maxsize, u_int elsize, xdrproc_t elproc);
 
 /* xdr.c */
 extern bool_t xdr_void(void);
-extern bool_t xdr_long(register XDR * xdrs, long *lp);
-extern bool_t xdr_u_long(register XDR * xdrs, u_long * ulp);
-extern bool_t xdr_int(register XDR * xdrs, int *ip);
-extern bool_t xdr_u_int(register XDR * xdrs, u_int * up);
-extern bool_t xdr_char(register XDR * xdrs, char *sp);
-extern bool_t xdr_u_char(register XDR * xdrs, u_char * usp);
-extern bool_t xdr_short(register XDR * xdrs, short *sp);
-extern bool_t xdr_u_short(register XDR * xdrs, u_short * usp);
-extern bool_t xdr_bool(register XDR * xdrs, bool_t * bp);
-extern bool_t xdr_enum(register XDR * xdrs, enum_t * ep);
-extern bool_t xdr_opaque(register XDR * xdrs, caddr_t cp, register u_int cnt);
-extern bool_t xdr_bytes(register XDR * xdrs, char **cpp,
-                       register u_int * sizep, u_int maxsize);
-extern bool_t xdr_union(register XDR * xdrs, enum_t * dscmp, caddr_t unp,
+extern bool_t xdr_long(XDR * xdrs, long *lp);
+extern bool_t xdr_u_long(XDR * xdrs, u_long * ulp);
+extern bool_t xdr_int(XDR * xdrs, int *ip);
+extern bool_t xdr_u_int(XDR * xdrs, u_int * up);
+extern bool_t xdr_char(XDR * xdrs, char *sp);
+extern bool_t xdr_u_char(XDR * xdrs, u_char * usp);
+extern bool_t xdr_short(XDR * xdrs, short *sp);
+extern bool_t xdr_u_short(XDR * xdrs, u_short * usp);
+extern bool_t xdr_bool(XDR * xdrs, bool_t * bp);
+extern bool_t xdr_enum(XDR * xdrs, enum_t * ep);
+extern bool_t xdr_opaque(XDR * xdrs, caddr_t cp, u_int cnt);
+extern bool_t xdr_bytes(XDR * xdrs, char **cpp,
+                       u_int * sizep, u_int maxsize);
+extern bool_t xdr_union(XDR * xdrs, enum_t * dscmp, caddr_t unp,
                        struct xdr_discrim *choices, xdrproc_t dfault);
-extern bool_t xdr_string(register XDR * xdrs, char **cpp, u_int maxsize);
-extern bool_t xdr_wrapstring(register XDR * xdrs, char **cpp);
+extern bool_t xdr_string(XDR * xdrs, char **cpp, u_int maxsize);
+extern bool_t xdr_wrapstring(XDR * xdrs, char **cpp);
 
 
 /* xdr_float.c */
-extern bool_t xdr_float(register XDR * xdrs, register float *fp);
-extern bool_t xdr_double(register XDR * xdrs, double *dp);
+extern bool_t xdr_float(XDR * xdrs, float *fp);
+extern bool_t xdr_double(XDR * xdrs, double *dp);
 
 /* xdr_mem.c */
-extern void xdrmem_create(register XDR * xdrs, caddr_t addr, u_int size,
+extern void xdrmem_create(XDR * xdrs, caddr_t addr, u_int size,
                          enum xdr_op op);
 
 
 /* xdr_rec.c */
-extern void xdrrec_create(register XDR * xdrs, u_int sendsize, u_int recvsize,
+extern void xdrrec_create(XDR * xdrs, u_int sendsize, u_int recvsize,
                          caddr_t tcp_handle,
                          int (*readit) (caddr_t tcp_handle, caddr_t out_base,
                                         int len),
@@ -90,11 +90,11 @@ extern bool_t xdr_reference(XDR *xdrs, caddr_t *pp, u_int size,
 
 
 /* xdr_update.c */
-extern bool_t xdr_pointer(register XDR * xdrs, char **objpp, u_int obj_size,
+extern bool_t xdr_pointer(XDR * xdrs, char **objpp, u_int obj_size,
                          xdrproc_t xdr_obj);
-extern bool_t xdr_vector(register XDR * xdrs, register char *basep,
-                        register u_int nelem, register u_int elemsize,
-                        register xdrproc_t xdr_elem);
+extern bool_t xdr_vector(XDR * xdrs, char *basep,
+                        u_int nelem, u_int elemsize,
+                        xdrproc_t xdr_elem);
 
 
 #endif
index ff2a453..cfdc764 100644 (file)
@@ -102,21 +102,21 @@ typedef struct rec_strm {
 /* Prototypes for static routines */
 static bool_t xdrrec_getint32(XDR * xdrs, afs_int32 * lp);
 static bool_t xdrrec_putint32(XDR * xdrs, afs_int32 * lp);
-static bool_t xdrrec_getbytes(XDR * xdrs, register caddr_t addr,
-                             register u_int len);
-static bool_t xdrrec_putbytes(XDR * xdrs, register caddr_t addr,
-                             register u_int len);
-static u_int xdrrec_getpos(register XDR * xdrs);
-static bool_t xdrrec_setpos(register XDR * xdrs, u_int pos);
-static afs_int32 *xdrrec_inline(register XDR * xdrs, u_int len);
-static void xdrrec_destroy(register XDR * xdrs);
-static bool_t flush_out(register RECSTREAM * rstrm, bool_t eor);
-static bool_t fill_input_buf(register RECSTREAM * rstrm);
-static bool_t get_input_bytes(register RECSTREAM * rstrm,
-                             register caddr_t addr, register int len);
-static bool_t set_input_fragment(register RECSTREAM * rstrm);
-static bool_t skip_input_bytes(register RECSTREAM * rstrm, int cnt);
-static u_int fix_buf_size(register u_int s);
+static bool_t xdrrec_getbytes(XDR * xdrs, caddr_t addr,
+                             u_int len);
+static bool_t xdrrec_putbytes(XDR * xdrs, caddr_t addr,
+                             u_int len);
+static u_int xdrrec_getpos(XDR * xdrs);
+static bool_t xdrrec_setpos(XDR * xdrs, u_int pos);
+static afs_int32 *xdrrec_inline(XDR * xdrs, u_int len);
+static void xdrrec_destroy(XDR * xdrs);
+static bool_t flush_out(RECSTREAM * rstrm, bool_t eor);
+static bool_t fill_input_buf(RECSTREAM * rstrm);
+static bool_t get_input_bytes(RECSTREAM * rstrm,
+                             caddr_t addr, int len);
+static bool_t set_input_fragment(RECSTREAM * rstrm);
+static bool_t skip_input_bytes(RECSTREAM * rstrm, int cnt);
+static u_int fix_buf_size(u_int s);
 
 static struct xdr_ops xdrrec_ops = {
     xdrrec_getint32,
@@ -142,12 +142,12 @@ static struct xdr_ops xdrrec_ops = {
        int (*writeit)();  * like write, but pass it a tcp_handle, not sock *
 */
 void
-xdrrec_create(register XDR * xdrs, u_int sendsize, u_int recvsize,
+xdrrec_create(XDR * xdrs, u_int sendsize, u_int recvsize,
              caddr_t tcp_handle, int (*readit) (caddr_t tcp_handle,
                                                 caddr_t out_base, int len),
              int (*writeit) (caddr_t tcp_handle, caddr_t out_base, int len))
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) osi_alloc(sizeof(RECSTREAM));
+    RECSTREAM *rstrm = (RECSTREAM *) osi_alloc(sizeof(RECSTREAM));
 
     if (rstrm == NULL) {
        /* 
@@ -189,8 +189,8 @@ xdrrec_create(register XDR * xdrs, u_int sendsize, u_int recvsize,
 static bool_t
 xdrrec_getint32(XDR * xdrs, afs_int32 * lp)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
-    register afs_int32 *buflp = (afs_int32 *) (rstrm->in_finger);
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    afs_int32 *buflp = (afs_int32 *) (rstrm->in_finger);
     afs_int32 myint32;
 
     /* first try the inline, fast case */
@@ -210,8 +210,8 @@ xdrrec_getint32(XDR * xdrs, afs_int32 * lp)
 static bool_t
 xdrrec_putint32(XDR * xdrs, afs_int32 * lp)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
-    register afs_int32 *dest_lp = ((afs_int32 *) (rstrm->out_finger));
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    afs_int32 *dest_lp = ((afs_int32 *) (rstrm->out_finger));
 
     if ((rstrm->out_finger += sizeof(afs_int32)) > rstrm->out_boundry) {
        /*
@@ -230,10 +230,10 @@ xdrrec_putint32(XDR * xdrs, afs_int32 * lp)
 }
 
 static bool_t
-xdrrec_getbytes(XDR * xdrs, register caddr_t addr, register u_int len)
+xdrrec_getbytes(XDR * xdrs, caddr_t addr, u_int len)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
-    register int current;
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    int current;
 
     while (len > 0) {
        current = rstrm->fbtbc;
@@ -255,10 +255,10 @@ xdrrec_getbytes(XDR * xdrs, register caddr_t addr, register u_int len)
 }
 
 static bool_t
-xdrrec_putbytes(XDR * xdrs, register caddr_t addr, register u_int len)
+xdrrec_putbytes(XDR * xdrs, caddr_t addr, u_int len)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
-    register int current;
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    int current;
 
     while (len > 0) {
        current = (u_int) (rstrm->out_boundry - rstrm->out_finger);
@@ -277,10 +277,10 @@ xdrrec_putbytes(XDR * xdrs, register caddr_t addr, register u_int len)
 }
 
 static u_int
-xdrrec_getpos(register XDR * xdrs)
+xdrrec_getpos(XDR * xdrs)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
-    register u_int pos;
+    RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+    u_int pos;
 
     pos = (u_int) lseek((int)rstrm->tcp_handle, 0, 1);
     if ((int)pos != -1)
@@ -302,9 +302,9 @@ xdrrec_getpos(register XDR * xdrs)
 }
 
 static bool_t
-xdrrec_setpos(register XDR * xdrs, u_int pos)
+xdrrec_setpos(XDR * xdrs, u_int pos)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+    RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
     u_int currpos = xdrrec_getpos(xdrs);
     int delta = currpos - pos;
     caddr_t newpos;
@@ -335,9 +335,9 @@ xdrrec_setpos(register XDR * xdrs, u_int pos)
 }
 
 static afs_int32 *
-xdrrec_inline(register XDR * xdrs, u_int len)
+xdrrec_inline(XDR * xdrs, u_int len)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+    RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
     afs_int32 *buf = NULL;
 
     switch (xdrs->x_op) {
@@ -362,9 +362,9 @@ xdrrec_inline(register XDR * xdrs, u_int len)
 }
 
 static void
-xdrrec_destroy(register XDR * xdrs)
+xdrrec_destroy(XDR * xdrs)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
+    RECSTREAM *rstrm = (RECSTREAM *) xdrs->x_private;
 
     osi_free(rstrm->out_base, rstrm->sendsize);
     osi_free(rstrm->in_base, rstrm->recvsize);
@@ -383,7 +383,7 @@ xdrrec_destroy(register XDR * xdrs)
 bool_t
 xdrrec_skiprecord(XDR * xdrs)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
 
     while (rstrm->fbtbc > 0 || (!rstrm->last_frag)) {
        if (!skip_input_bytes(rstrm, rstrm->fbtbc))
@@ -404,7 +404,7 @@ xdrrec_skiprecord(XDR * xdrs)
 bool_t
 xdrrec_eof(XDR * xdrs)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
 
     while (rstrm->fbtbc > 0 || (!rstrm->last_frag)) {
        if (!skip_input_bytes(rstrm, rstrm->fbtbc))
@@ -427,8 +427,8 @@ xdrrec_eof(XDR * xdrs)
 bool_t
 xdrrec_endofrecord(XDR * xdrs, bool_t sendnow)
 {
-    register RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
-    register afs_uint32 len;   /* fragment length */
+    RECSTREAM *rstrm = (RECSTREAM *) (xdrs->x_private);
+    afs_uint32 len;    /* fragment length */
 
     if (sendnow || rstrm->frag_sent
        || ((afs_uint32) (rstrm->out_finger + sizeof(afs_uint32)) >=
@@ -450,10 +450,10 @@ xdrrec_endofrecord(XDR * xdrs, bool_t sendnow)
  * Internal useful routines
  */
 static bool_t
-flush_out(register RECSTREAM * rstrm, bool_t eor)
+flush_out(RECSTREAM * rstrm, bool_t eor)
 {
-    register afs_uint32 eormask = (eor == TRUE) ? LAST_FRAG : 0;
-    register afs_uint32 len =
+    afs_uint32 eormask = (eor == TRUE) ? LAST_FRAG : 0;
+    afs_uint32 len =
        (afs_uint32) (rstrm->out_finger - (caddr_t)rstrm->frag_header) -
        sizeof(afs_uint32);
 
@@ -468,10 +468,10 @@ flush_out(register RECSTREAM * rstrm, bool_t eor)
 }
 
 static bool_t
-fill_input_buf(register RECSTREAM * rstrm)
+fill_input_buf(RECSTREAM * rstrm)
 {
-    register caddr_t where = rstrm->in_base;
-    register int len = rstrm->in_size;
+    caddr_t where = rstrm->in_base;
+    int len = rstrm->in_size;
     u_int adjust = (u_int) ((size_t)rstrm->in_boundry % BYTES_PER_XDR_UNIT);
 
     /* Bump the current position out to the next alignment boundary */
@@ -487,10 +487,10 @@ fill_input_buf(register RECSTREAM * rstrm)
 }
 
 static bool_t
-get_input_bytes(register RECSTREAM * rstrm, register caddr_t addr,
-               register int len)
+get_input_bytes(RECSTREAM * rstrm, caddr_t addr,
+               int len)
 {
-    register int current;
+    int current;
 
     while (len > 0) {
        current = (int)(rstrm->in_boundry - rstrm->in_finger);
@@ -510,7 +510,7 @@ get_input_bytes(register RECSTREAM * rstrm, register caddr_t addr,
 
 /* next two bytes of the input stream are treated as a header */
 static bool_t
-set_input_fragment(register RECSTREAM * rstrm)
+set_input_fragment(RECSTREAM * rstrm)
 {
     afs_uint32 header;
 
@@ -524,9 +524,9 @@ set_input_fragment(register RECSTREAM * rstrm)
 
 /* consumes input bytes; knows nothing about records! */
 static bool_t
-skip_input_bytes(register RECSTREAM * rstrm, int cnt)
+skip_input_bytes(RECSTREAM * rstrm, int cnt)
 {
-    register int current;
+    int current;
 
     while (cnt > 0) {
        current = (int)(rstrm->in_boundry - rstrm->in_finger);
@@ -543,7 +543,7 @@ skip_input_bytes(register RECSTREAM * rstrm, int cnt)
 }
 
 static u_int
-fix_buf_size(register u_int s)
+fix_buf_size(u_int s)
 {
 
     if (s < 100)
index 1485bbe..8a363f5 100644 (file)
@@ -60,13 +60,13 @@ RCSID
  * proc is the routine to handle the referenced structure.
  */
 bool_t
-xdr_reference(register XDR *xdrs, 
+xdr_reference(XDR *xdrs, 
              caddr_t *pp, /* the pointer to work on */
              u_int size, /* size of the object pointed to */
              xdrproc_t proc)  /* xdr routine to handle the object */
 {
-    register caddr_t loc = *pp;
-    register bool_t stat;
+    caddr_t loc = *pp;
+    bool_t stat;
 
     if (loc == NULL)
        switch (xdrs->x_op) {
index 79e2d36..4e815a1 100644 (file)
@@ -106,12 +106,12 @@ 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(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(AFS_XDRS_T axdrs, register caddr_t addr,
-                            register u_int len);
-static AFS_RPC_INLINE_T *xdrrx_inline(AFS_XDRS_T axdrs, register u_int len);
+static bool_t xdrrx_putint32(AFS_XDRS_T axdrs, afs_int32 * lp);
+static bool_t xdrrx_getbytes(AFS_XDRS_T axdrs, caddr_t addr,
+                            u_int len);
+static bool_t xdrrx_putbytes(AFS_XDRS_T axdrs, caddr_t addr,
+                            u_int len);
+static AFS_RPC_INLINE_T *xdrrx_inline(AFS_XDRS_T axdrs, u_int len);
 
 
 /*
@@ -144,8 +144,8 @@ static struct xdr_ops xdrrx_ops = {
  * Call must have been returned by rx_MakeCall or rx_GetCall.
  */
 void
-xdrrx_create(register XDR * xdrs, register struct rx_call *call,
-            register enum xdr_op op)
+xdrrx_create(XDR * xdrs, struct rx_call *call,
+            enum xdr_op op)
 {
     xdrs->x_op = op;
     xdrs->x_ops = &xdrrx_ops;
@@ -162,7 +162,7 @@ static bool_t
 xdrrx_getint64(AFS_XDRS_T axdrs, long *lp)
 {
     XDR * xdrs = (XDR *)axdrs;
-    register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
+    struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
     afs_int32 i;
 
     if (rx_Read32(call, &i) == sizeof(i)) {
@@ -177,7 +177,7 @@ 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);
+    struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
 
     code = (rx_Write32(call, &i) == sizeof(i));
     return code;
@@ -189,7 +189,7 @@ 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);
+    struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
 #if    defined(KERNEL) && defined(AFS_AIX32_ENV)
     char *saddr = (char *)&l;
     saddr -= STACK_TO_PIN;
@@ -224,11 +224,11 @@ xdrrx_getint32(AFS_XDRS_T axdrs, afs_int32 * lp)
 }
 
 static bool_t
-xdrrx_putint32(register AFS_XDRS_T axdrs, register afs_int32 * lp)
+xdrrx_putint32(AFS_XDRS_T axdrs, afs_int32 * lp)
 {
     afs_int32 code, l = htonl(*lp);
     XDR * xdrs = (XDR *)axdrs;
-    register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
+    struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
 #if    defined(KERNEL) && defined(AFS_AIX32_ENV)
     char *saddr = (char *)&code;
     saddr -= STACK_TO_PIN;
@@ -255,11 +255,11 @@ xdrrx_putint32(register AFS_XDRS_T axdrs, register afs_int32 * lp)
 }
 
 static bool_t
-xdrrx_getbytes(register AFS_XDRS_T axdrs, register caddr_t addr, register u_int len)
+xdrrx_getbytes(AFS_XDRS_T axdrs, caddr_t addr, u_int len)
 {
     afs_int32 code;
     XDR * xdrs = (XDR *)axdrs;
-    register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
+    struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
 #if    defined(KERNEL) && defined(AFS_AIX32_ENV)
     char *saddr = (char *)&code;
     saddr -= STACK_TO_PIN;
@@ -287,11 +287,11 @@ xdrrx_getbytes(register AFS_XDRS_T axdrs, register caddr_t addr, register u_int
 }
 
 static bool_t
-xdrrx_putbytes(register AFS_XDRS_T axdrs, register caddr_t addr, register u_int len)
+xdrrx_putbytes(AFS_XDRS_T axdrs, caddr_t addr, u_int len)
 {
     afs_int32 code;
     XDR * xdrs = (XDR *)axdrs;
-    register struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
+    struct rx_call *call = ((struct rx_call *)(xdrs)->x_private);
 #if    defined(KERNEL) && defined(AFS_AIX32_ENV)
     char *saddr = (char *)&code;
     saddr -= STACK_TO_PIN;
@@ -320,14 +320,14 @@ xdrrx_putbytes(register AFS_XDRS_T axdrs, register caddr_t addr, register u_int
 
 #ifdef undef                   /* not used */
 static u_int
-xdrrx_getpos(register XDR * xdrs)
+xdrrx_getpos(XDR * xdrs)
 {
     /* Not supported.  What error code should we return? (It doesn't matter:  it will never be called, anyway!) */
     return -1;
 }
 
 static bool_t
-xdrrx_setpos(register XDR * xdrs, u_int pos)
+xdrrx_setpos(XDR * xdrs, u_int pos)
 {
     /* Not supported */
     return FALSE;
@@ -335,7 +335,7 @@ xdrrx_setpos(register XDR * xdrs, u_int pos)
 #endif
 
 static AFS_RPC_INLINE_T *
-xdrrx_inline(AFS_XDRS_T axdrs, register u_int len)
+xdrrx_inline(AFS_XDRS_T axdrs, 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);
index bf82ade..be9c15a 100644 (file)
@@ -77,7 +77,7 @@ static struct xdr_ops xdrstdio_ops = {
  */
 void
 xdrstdio_create(xdrs, file, op)
-     register XDR *xdrs;
+     XDR *xdrs;
      FILE *file;
      enum xdr_op op;
 {
@@ -95,7 +95,7 @@ xdrstdio_create(xdrs, file, op)
  */
 static void
 xdrstdio_destroy(xdrs)
-     register XDR *xdrs;
+     XDR *xdrs;
 {
     (void)fflush((FILE *) xdrs->x_private);
     /* xx should we close the file ?? */
@@ -104,7 +104,7 @@ xdrstdio_destroy(xdrs)
 static bool_t
 xdrstdio_getint32(xdrs, lp)
      XDR *xdrs;
-     register afs_int32 *lp;
+     afs_int32 *lp;
 {
 
     if (fread((caddr_t) lp, sizeof(afs_int32), 1, (FILE *) xdrs->x_private) !=
index e5c6687..8c06ce1 100644 (file)
@@ -43,7 +43,7 @@ RCSID
  *    
  */
 bool_t
-xdr_pointer(register XDR * xdrs, char **objpp, u_int obj_size,
+xdr_pointer(XDR * xdrs, char **objpp, u_int obj_size,
            xdrproc_t xdr_obj)
 {
 
@@ -71,11 +71,11 @@ xdr_pointer(register XDR * xdrs, char **objpp, u_int obj_size,
  * > xdr_elem: routine to XDR each element
  */
 bool_t
-xdr_vector(register XDR * xdrs, register char *basep, register u_int nelem,
-          register u_int elemsize, register xdrproc_t xdr_elem)
+xdr_vector(XDR * xdrs, char *basep, u_int nelem,
+          u_int elemsize, xdrproc_t xdr_elem)
 {
-    register u_int i;
-    register char *elptr;
+    u_int i;
+    char *elptr;
 
     elptr = basep;
     for (i = 0; i < nelem; i++) {