#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
* 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) {
}
static void
-ReturnToServerPool(register struct rx_service *aservice)
+ReturnToServerPool(struct rx_service *aservice)
{
aservice->nRequestsRunning--;
MUTEX_ENTER(&rx_quota_mutex);
#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 */
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;
void
rx_StartServer(int donateMe)
{
- register struct rx_service *service;
- register int i;
+ struct rx_service *service;
+ int i;
SPLVAR;
clock_NewTime();
/* 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);
}
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;
/* 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) {
/* Externally available version */
void
-rx_DestroyConnection(register struct rx_connection *conn)
+rx_DestroyConnection(struct rx_connection *conn)
{
SPLVAR;
}
void
-rx_GetConnection(register struct rx_connection *conn)
+rx_GetConnection(struct rx_connection *conn)
{
SPLVAR;
* 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;
/* 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++) {
} /* 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;
}
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;
}
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;
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();
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) {
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) {
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;
}
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
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;
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 */
* 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;
* 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;
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;
/* 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;
* 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));
*/
#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)
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);
}
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);
}
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;
* 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);
* 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 =
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
* 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;
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,
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;
/* 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;
* 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)
{
/* 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;
/* 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;
* 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;
* 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)
* 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) {
* 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)) {
/* 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;
}
void
-rxi_ClearReceiveQueue(register struct rx_call *call)
+rxi_ClearReceiveQueue(struct rx_call *call)
{
if (queue_IsNotEmpty(&call->rq)) {
u_short count;
/* 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;
* 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;
* 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));
}
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");
#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");
* 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
*/
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
#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;
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;
}
#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.
* 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;
*/
#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;
void
-rxi_ScheduleKeepAliveEvent(register struct rx_call *call)
+rxi_ScheduleKeepAliveEvent(struct rx_call *call)
{
if (!call->keepAliveEvent) {
struct clock when, now;
/* 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
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) {
* 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);
/* 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);
/* Apply VanJacobson round-trip estimations */
if (peer->rtt) {
- register int delta;
+ int delta;
/*
* srtt (peer->rtt) is in units of one-eighth-milliseconds.
*/
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 */
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
socklen_t faddrLen;
#endif
fd_set imask;
- register char *tp;
+ char *tp;
startTime = time(0);
waitTime = 1;
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;
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;
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 */
#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 */
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);
/* 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++;
#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) {
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);
*/
#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; \
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)); \
/* 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)); \
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); \
/* 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); \
*/
#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; \
* 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); \
} \
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) {
/* 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;
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) {
int i = 0;
int different = 0;
- register int rxmtu, maxmtu;
+ int rxmtu, maxmtu;
afs_uint32 addrs[ADDRSPERSITE];
int mtus[ADDRSPERSITE];
afs_uint32 ifinaddr;
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));
osi_socket *
rxk_NewSocketHost(afs_uint32 ahost, short aport)
{
- register afs_int32 code;
+ afs_int32 code;
#ifdef AFS_DARWIN80_ENV
socket_t newSocket;
#else
/* 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)
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 */
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
{
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 */
* (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;
int
ntoh_syserr_conv(int code)
{
- register afs_int32 err;
+ afs_int32 err;
if (code == VDISKFULL)
err = ENOSPC;
*/
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
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);
}
/* 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;
/* 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 */
/* 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);
}
/* 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);
}
#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++)
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
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);
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;
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);
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;
{
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;
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;
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;
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;
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);
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);
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);
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);
{
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)
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);
struct rx_packet *
rxi_AllocPacketNoLock(int class)
{
- register struct rx_packet *p;
+ struct rx_packet *p;
#ifdef KERNEL
if (rxi_OverQuota(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);
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;
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);
* 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;
#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++) {
* 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 */
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
}
}
+#ifdef RX_TRIMDATABUFS
/* Free any empty packet buffers at the end of this packet */
rxi_TrimDataBufs(p, 1);
-
+#endif
return 1;
}
}
* 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;
* 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) {
* 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) {
struct rx_packet *phandle;
int hdr_len, data_len;
{
- register int code;
+ int code;
code =
m_cpytoiovec(amb, hdr_len, data_len, phandle->wirevec,
/* 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;
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);
case RX_DEBUGI_GETPEER:{
int i;
- register struct rx_peer *tp;
+ struct rx_peer *tp;
struct rx_debugPeer tpeer;
}
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;
#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';
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];
* 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;
* 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);
/* 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);
}
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 */
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 */
* 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 */
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) */
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
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);
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);
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);
#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);
#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);
#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);
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);
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);
/* 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);
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,
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 */
{
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) {
}
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));
* 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;
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
}
}
-/*
-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;
{
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;
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
* 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 */
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) {
/* 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;
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 */
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) {
/* 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)) {
* XDR integers
*/
bool_t
-xdr_int(register XDR * xdrs, int *ip)
+xdr_int(XDR * xdrs, int *ip)
{
afs_int32 l;
* 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;
* XDR long integers
*/
bool_t
-xdr_long(register XDR * xdrs, long *lp)
+xdr_long(XDR * xdrs, long *lp)
{
afs_int32 l;
* 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;
* XDR chars
*/
bool_t
-xdr_char(register XDR * xdrs, char *sp)
+xdr_char(XDR * xdrs, char *sp)
{
afs_int32 l;
* 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;
* XDR short integers
*/
bool_t
-xdr_short(register XDR * xdrs, short *sp)
+xdr_short(XDR * xdrs, short *sp)
{
afs_int32 l;
* 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;
* XDR booleans
*/
bool_t
-xdr_bool(register XDR * xdrs, bool_t * bp)
+xdr_bool(XDR * xdrs, bool_t * bp)
{
afs_int32 lb;
* 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 */
* 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 };
* 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
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
* 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;
*/
#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);
*/
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;
*/
#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)
*/
bool_t
-xdr_float(register XDR * xdrs, register float *fp)
+xdr_float(XDR * xdrs, float *fp)
{
#ifdef AFS_NT40_ENV
return (FALSE);
}
bool_t
-xdr_double(register XDR * xdrs, double *dp)
+xdr_double(XDR * xdrs, double *dp)
{
#ifdef AFS_NT40_ENV
return (FALSE);
* 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)
* 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)
* 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;
* 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;
* 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))
* 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))
* 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;
}
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);
}
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);
}
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);
}
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);
}
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);
}
static afs_int32 *
-xdrmem_inline(register XDR * xdrs, int len)
+xdrmem_inline(XDR * xdrs, int len)
{
afs_int32 *buf = 0;
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),
/* 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
/* 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,
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) {
/*
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 */
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) {
/*
}
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;
}
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);
}
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)
}
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;
}
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) {
}
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);
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))
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))
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)) >=
* 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);
}
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 */
}
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);
/* 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;
/* 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);
}
static u_int
-fix_buf_size(register u_int s)
+fix_buf_size(u_int s)
{
if (s < 100)
* 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) {
#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);
/*
* 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;
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)) {
{
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;
{
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;
}
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;
}
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;
}
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;
#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;
#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);
*/
void
xdrstdio_create(xdrs, file, op)
- register XDR *xdrs;
+ XDR *xdrs;
FILE *file;
enum xdr_op op;
{
*/
static void
xdrstdio_destroy(xdrs)
- register XDR *xdrs;
+ XDR *xdrs;
{
(void)fflush((FILE *) xdrs->x_private);
/* xx should we close the file ?? */
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) !=
*
*/
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)
{
* > 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++) {
git://git.openafs.org / openafs.git / commitdiff