* directory or online at http://www.openafs.org/dl/license10.html
*/
+#include <afsconfig.h>
#ifdef KERNEL
#include "../afs/param.h"
#else
#include <afs/param.h>
#endif
-#include <afsconfig.h>
RCSID("$Header$");
#include "rx_globals.h"
#include <lwp.h>
#include "rx_internal.h"
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#else
#ifdef HAVE_STRING_H
#include <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
#endif
#endif
#ifdef HAVE_UNISTD_H
r = resid;
while ((resid > 0) && (i < packet->niovecs)) {
j = MIN (resid, packet->wirevec[i].iov_len - (offset - l));
- bcopy ((char *)(packet->wirevec[i].iov_base) + (offset - l), out, j);
+ memcpy(out, (char *)(packet->wirevec[i].iov_base) + (offset - l), j);
resid -= j;
l += packet->wirevec[i].iov_len;
i++;
b = (char*)(packet->wirevec[i].iov_base) + (offset - l);
j = MIN (resid, packet->wirevec[i].iov_len - (offset - l));
- bcopy (in, b, j);
+ memcpy(b, in, j);
resid -= j;
l += packet->wirevec[i].iov_len;
i++;
rx_nFreePackets--;
c = queue_First(&rx_freePacketQueue, rx_packet);
queue_Remove(c);
- if (c->header.flags != RX_FREE_PACKET)
+ if (!(c->flags & RX_PKTFLAG_FREE))
osi_Panic("rxi_AllocPacket: packet not free\n");
+ c->flags = 0; /* clear RX_PKTFLAG_FREE, initialize the rest */
c->header.flags = 0;
#ifdef KERNEL
p = rx_mallocedP = (struct rx_packet *) osi_Alloc(getme);
PIN(p, getme); /* XXXXX */
- bzero((char *)p, getme);
+ memset((char *)p, 0, getme);
NETPRI;
AFS_RXGLOCK();
MUTEX_ENTER(&rx_freePktQ_lock);
p->wirevec[0].iov_len = RX_HEADER_SIZE;
p->wirevec[1].iov_base = (char *) (p->localdata);
p->wirevec[1].iov_len = RX_FIRSTBUFFERSIZE;
- p->header.flags = RX_FREE_PACKET;
+ p->flags |= RX_PKTFLAG_FREE;
p->niovecs = 2;
queue_Append(&rx_freePacketQueue, p);
getme = apackets * sizeof(struct rx_packet);
p = rx_mallocedP = (struct rx_packet *) osi_Alloc(getme);
- bzero((char *)p, getme);
+ memset((char *)p, 0, getme);
for (e = p + apackets; p<e; p++) {
p->wirevec[0].iov_base = (char *) (p->wirehead);
p->wirevec[0].iov_len = RX_HEADER_SIZE;
p->wirevec[1].iov_base = (char *) (p->localdata);
p->wirevec[1].iov_len = RX_FIRSTBUFFERSIZE;
- p->header.flags = RX_FREE_PACKET;
+ p->flags |= RX_PKTFLAG_FREE;
p->niovecs = 2;
queue_Append(&rx_freePacketQueue, p);
{
dpf(("Free %x\n", p));
- if (p->header.flags & RX_FREE_PACKET)
+ if (p->flags & RX_PKTFLAG_FREE)
osi_Panic("rxi_FreePacketNoLock: packet already free\n");
rx_nFreePackets++;
- p->header.flags = RX_FREE_PACKET;
+ p->flags |= RX_PKTFLAG_FREE;
queue_Append(&rx_freePacketQueue, p);
}
rx_nFreePackets--;
p = queue_First(&rx_freePacketQueue, rx_packet);
- if (p->header.flags != RX_FREE_PACKET)
+ if (!(p->flags & RX_PKTFLAG_FREE))
osi_Panic("rxi_AllocPacket: packet not free\n");
dpf(("Alloc %x, class %d\n", p, class));
queue_Remove(p);
+ p->flags = 0; /* clear RX_PKTFLAG_FREE, initialize the rest */
p->header.flags = 0;
/* have to do this here because rx_FlushWrite fiddles with the iovs in
* our problems caused by the lack of a length field in the rx header.
* Use the extra buffer that follows the localdata in each packet
* structure. */
- savelen = p->wirevec[p->niovecs].iov_len;
- p->wirevec[p->niovecs].iov_len += RX_EXTRABUFFERSIZE;
+ savelen = p->wirevec[p->niovecs-1].iov_len;
+ p->wirevec[p->niovecs-1].iov_len += RX_EXTRABUFFERSIZE;
- bzero((char *)&msg, sizeof(msg));
+ memset((char *)&msg, 0, sizeof(msg));
msg.msg_name = (char *) &from;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_iov = p->wirevec;
nbytes = rxi_Recvmsg(socket, &msg, 0);
/* restore the vec to its correct state */
- p->wirevec[p->niovecs].iov_len = savelen;
+ p->wirevec[p->niovecs-1].iov_len = savelen;
p->length = (nbytes - RX_HEADER_SIZE);
if ((nbytes > tlen) || (p->length & 0x8000)) { /* Bogus packet */
return -1;
}
n = MIN(len, (mp->b_wptr - mp->b_rptr));
- bcopy((char *)mp->b_rptr, cp, n);
+ memcpy(cp, (char *)mp->b_rptr, n);
cp += n;
len -= n;
mp->b_rptr += n;
t = iovs[i].iov_len;
}
m = MIN(n,t);
- bcopy((char *)mp->b_rptr, iovs[i].iov_base + o, m);
+ memcpy(iovs[i].iov_base + o, (char *)mp->b_rptr, m);
mp->b_rptr += m;
o += m;
t -= m;
while (len) {
t = MIN(l1, MIN(l2, (unsigned int)len));
- bcopy (p1, p2, t);
+ memcpy(p2, p1, t);
p1 += t; p2 += t;
l1 -= t; l2 -= t;
len -= t;
afs_int32 tl;
struct rx_serverQueueEntry *np, *nqe;
+ /*
+ * Only respond to client-initiated Rx debug packets,
+ * and clear the client flag in the response.
+ */
+ if (ap->header.flags & RX_CLIENT_INITIATED) {
+ ap->header.flags = ap->header.flags & ~RX_CLIENT_INITIATED;
+ rxi_EncodePacketHeader(ap);
+ } else {
+ return ap;
+ }
+
rx_packetread(ap, 0, sizeof(struct rx_debugIn), (char *)&tin);
/* all done with packet, now set length to the truth, so we can
* reuse this packet */
struct rx_debugStats tstat;
/* get basic stats */
- bzero ((char *)&tstat, sizeof(tstat)); /* make sure spares are zero */
+ memset((char *)&tstat, 0, sizeof(tstat)); /* make sure spares are zero */
tstat.version = RX_DEBUGI_VERSION;
#ifndef RX_ENABLE_LOCKS
tstat.waitingForPackets = rx_waitingForPackets;
if (tl > 0)
return ap;
- bzero ((char *)&tconn, sizeof(tconn)); /* make sure spares are zero */
+ memset((char *)&tconn, 0, sizeof(tconn)); /* make sure spares are zero */
/* get N'th (maybe) "interesting" connection info */
for(i=0;i<rx_hashTableSize;i++) {
#if !defined(KERNEL)
if (tl > 0)
return ap;
- bzero ((char *)&tpeer, sizeof(tpeer));
+ memset((char *)&tpeer, 0, sizeof(tpeer));
for(i=0;i<rx_hashTableSize;i++) {
#if !defined(KERNEL)
/* the time complexity of the algorithm used here
register struct rx_packet *ap;
int istack;
{
- afs_int32 tl;
- rx_packetwrite(ap, 0, 65, cml_version_number+4);
- tl = ap->length;
+ afs_int32 tl;
+
+ /*
+ * Only respond to client-initiated version requests, and
+ * clear that flag in the response.
+ */
+ if (ap->header.flags & RX_CLIENT_INITIATED) {
+ char buf[66];
+
+ ap->header.flags = ap->header.flags & ~RX_CLIENT_INITIATED;
+ rxi_EncodePacketHeader(ap);
+ memset(buf, 0, sizeof(buf));
+ strncpy(buf, cml_version_number+4, sizeof(buf)-1);
+ rx_packetwrite(ap, 0, 65, buf);
+ tl = ap->length;
ap->length = 65;
rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
- ap->length = tl;
- return ap;
+ ap->length = tl;
+ }
+
+ return ap;
}
{
register afs_uint32 *buf = (afs_uint32 *)(p->wirevec[0].iov_base); /* MTUXXX */
- bzero((char *)buf, RX_HEADER_SIZE);
+ memset((char *)buf, 0, RX_HEADER_SIZE);
*buf++ = htonl(p->header.epoch);
*buf++ = htonl(p->header.cid);
*buf++ = htonl(p->header.callNumber);
int i, j;
ssize_t len; /* len must be a signed type; it can go negative */
- p->acked = 0;
+ p->flags &= ~RX_PKTFLAG_ACKED;
p->header.cid = (conn->cid | call->channel);
p->header.serviceId = conn->serviceId;
p->header.securityIndex = conn->securityIndex;
git://git.openafs.org / openafs.git / blobdiff