dvec.iov_base = tp1;
dvec.iov_len = len;
AFS_GUNLOCK();
- (void)osi_NetSend(afs_server->socket, (struct sockaddr_storage *) &taddr,
- sizeof(taddr), &dvec, 1, len, 0);
+ (void)osi_NetSend(afs_server->socket, &taddr, &dvec, 1, len, 0);
AFS_GLOCK();
osi_FreeSmallSpace(tp1);
} /*afs_MarinerLogFetch */
dvec.iov_base = buf;
dvec.iov_len = tp - buf;
AFS_GUNLOCK();
- (void)osi_NetSend(afs_server->socket, (struct sockaddr_storage *) &taddr,
- sizeof(taddr), &dvec, 1, tp - buf, 0);
+ (void)osi_NetSend(afs_server->socket, &taddr, &dvec, 1, tp - buf, 0);
AFS_GLOCK();
osi_FreeSmallSpace(buf);
} /*afs_MarinerLog */
tconn = rx_ConnectionOf(acall);
tpeer = rx_PeerOf(tconn);
- printf("From %s: %s <%d>\n", rx_AddrStringOf(tpeer), amessage, acode);
+ printf("From %08x: %s <%d>\n", tpeer->host, amessage, acode);
return 0;
}
{
afs_int32 code, rcode = 0;
afs_int32 count;
- char *server;
+ afs_int32 server;
char name[MAXKTCNAMELEN];
char instance[MAXKTCNAMELEN];
code = ubik_CallIter(KAM_Unlock, conn, 0, &count, (long) name, (long) instance,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
if (code && (code != UNOSERVERS)) {
- server = "<unknown>";
+ server = 0;
if (conn && conn->conns[count - 1]
&& conn->conns[count - 1]->peer) {
- server = rx_AddrStringOf(conn->conns[count - 1]->peer);
+ server = conn->conns[count - 1]->peer->host;
}
com_err(whoami, code,
- "so %s.%s may still be locked (on server %s)",
- name, instance, server);
+ "so %s.%s may still be locked (on server %d.%d.%d.%d)",
+ name, instance, ((server >> 24) & 0xFF),
+ ((server >> 16) & 0xFF), ((server >> 8) & 0xFF),
+ (server & 0xFF));
if (!rcode) {
rcode = code;
}
/* log a ticket usage */
-void
-kalog_log(char *principal, char *instance, char *sprincipal, char *sinstance,
- char *realm, int hostaddr, int type)
+kalog_log(principal, instance, sprincipal, sinstance, realm, hostaddr, type)
+ char *principal, *instance, *sprincipal, *sinstance, *realm;
+ int hostaddr, type;
{
char keybuf[512]; /* not random! 63 . 63 , 63 . 63 max key */
datum key, data;
dbm_store(kalog_db, key, data, DBM_REPLACE);
- ViceLog(verbose_track, ("%s from %s\n", keybuf, afs_inet_ntoa(hostaddr)));
+ ViceLog(verbose_track, ("%s from %x\n", keybuf, hostaddr));
}
break;
}
- ViceLog(verbose_track, ("%s from %s\n", logbuf, afs_inet_ntoa(hostaddr)));
+ ViceLog(verbose_track, ("%s from %x\n", logbuf, hostaddr));
}
#endif
#endif /* AUTH_DBM_LOG */
-void ka_log(char *principal, char *instance, char *sprincipal, char *sinstance,
- char *realm, int hostaddr, int type);
#ifdef AUTH_DBM_LOG
-void kalog_log(char *principal, char *instance, char *sprincipal,
- char *sinstance, char *realm, int hostaddr, int type);
#define KALOG(a,b,c,d,e,f,g) kalog_log(a,b,c,d,e,f,g)
#else
#define KALOG(a,b,c,d,e,f,g) ka_log(a,b,c,d,e,f,g)
return code;
}
code = ubik_EndTrans(tt);
- KALOG(aname, ainstance, NULL, NULL, NULL,
- rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))),
+ KALOG(aname, ainstance, NULL, NULL, NULL, call->conn->peer->host,
LOG_CRUSER);
return code;
}
goto abort;
code = ubik_EndTrans(tt);
- KALOG(aname, ainstance, NULL, NULL, NULL,
- rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_CHPASSWD);
+ KALOG(aname, ainstance, NULL, NULL, NULL, call->conn->peer->host,
+ LOG_CHPASSWD);
return code;
abort:
des_pcbc_encrypt(oanswer->SeqBody, oanswer->SeqBody, oanswer->SeqLen,
user_schedule, &tentry.key, ENCRYPT);
code = ubik_EndTrans(tt);
- KALOG(aname, ainstance, sname, sinst, NULL,
- rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_AUTHENTICATE);
+ KALOG(aname, ainstance, sname, sinst, NULL, call->conn->peer->host,
+ LOG_AUTHENTICATE);
return code;
abort:
COUNT_ABO;
ubik_AbortTrans(tt);
- KALOG(aname, ainstance, sname, sinst, NULL,
- rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_AUTHFAILED);
+ KALOG(aname, ainstance, sname, sinst, NULL, call->conn->peer->host,
+ LOG_AUTHFAILED);
return code;
}
goto abort;
code = ubik_EndTrans(tt);
- KALOG(aname, ainstance, NULL, NULL, NULL,
- rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_SETFIELDS);
+ KALOG(aname, ainstance, NULL, NULL, NULL, call->conn->peer->host,
+ LOG_SETFIELDS);
return code;
abort:
goto abort;
code = ubik_EndTrans(tt);
- KALOG(aname, ainstance, NULL, NULL, NULL,
- rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_DELUSER);
+ KALOG(aname, ainstance, NULL, NULL, NULL, call->conn->peer->host,
+ LOG_DELUSER);
return code;
}
schedule, &authSessionKey, ENCRYPT);
code = ubik_EndTrans(tt);
KALOG(name, instance, sname, sinstance, (import ? authDomain : NULL),
- rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_GETTICKET);
+ call->conn->peer->host, LOG_GETTICKET);
return code;
abort:
kaux_write(to, 0, 0); /* zero failure counters at this offset */
code = ubik_EndTrans(tt);
- KALOG(aname, ainstance, NULL, NULL, NULL,
- rx_HostOf(rx_PeerOf(rx_ConnectionOf(call))), LOG_UNLOCK);
+ KALOG(aname, ainstance, NULL, NULL, NULL, call->conn->peer->host,
+ LOG_UNLOCK);
goto exit;
abort:
#endif
int
-osi_NetReceive(osi_socket so, struct sockaddr_storage *saddr, int *slen,
- struct iovec *dvec, int nvecs, int *alength)
+osi_NetReceive(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
+ int nvecs, int *alength)
{
#ifdef AFS_DARWIN80_ENV
socket_t asocket = (socket_t)so;
struct msghdr msg;
+ struct sockaddr_storage ss;
int rlen;
mbuf_t m;
#else
#if 1
resid = *alength;
memset(&msg, 0, sizeof(struct msghdr));
- msg.msg_name = saddr;
+ msg.msg_name = &ss;
msg.msg_namelen = sizeof(struct sockaddr_storage);
- sa =(struct sockaddr *) saddr;
+ sa =(struct sockaddr *) &ss;
code = sock_receivembuf(asocket, &msg, &m, 0, alength);
if (!code) {
size_t offset=0,sz;
}
int
-osi_NetSend(osi_socket so, struct sockaddr_storage *saddr, int salen,
- struct iovec *dvec, int nvecs, afs_int32 alength, int istack)
+osi_NetSend(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
+ int nvecs, afs_int32 alength, int istack)
{
#ifdef AFS_DARWIN80_ENV
socket_t asocket = (socket_t)so;
for (i = 0; i < nvecs; i++)
iov[i] = dvec[i];
- saddr->ss_len = saddr->ss_family == AF_INET6 ?
- sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+ addr->sin_len = sizeof(struct sockaddr_in);
if (haveGlock)
AFS_GUNLOCK();
#endif
#ifdef AFS_DARWIN80_ENV
memset(&msg, 0, sizeof(struct msghdr));
- msg.msg_name = saddr;
- msg.msg_namelen = saddr->ss_len;
+ msg.msg_name = addr;
+ msg.msg_namelen = ((struct sockaddr *)addr)->sa_len;
msg.msg_iov = &iov[0];
msg.msg_iovlen = nvecs;
code = sock_send(asocket, &msg, 0, &slen);
#ifdef RXK_LISTENER_ENV
int
-osi_NetReceive(osi_socket asocket, struct sockaddr_storage *saddr, int *slen,
+osi_NetReceive(osi_socket asocket, struct sockaddr_in *addr,
struct iovec *dvec, int nvecs, int *alength)
{
struct uio u;
*alength -= u.uio_resid;
if (sa) {
if (sa->sa_family == AF_INET) {
- if (saddr) {
- memcpy(saddr, sa, sa->sa_len);
- *slen = sa->sa_len;
- }
+ if (addr)
+ *addr = *(struct sockaddr_in *)sa;
} else
printf("Unknown socket family %d in NetReceive\n", sa->sa_family);
FREE(sa, M_SONAME);
}
int
-osi_NetSend(osi_socket asocket, struct sockaddr_storage *saddr, int salen,
- struct iovec *dvec, int nvecs, afs_int32 alength, int istack)
+osi_NetSend(osi_socket asocket, struct sockaddr_in *addr, struct iovec *dvec,
+ int nvecs, afs_int32 alength, int istack)
{
register afs_int32 code;
int i;
u.uio_procp = NULL;
#endif
- saddr->ss_len = saddr->ss_family == AF_INET6 ?
- sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
+ addr->sin_len = sizeof(struct sockaddr_in);
if (haveGlock)
AFS_GUNLOCK();
#endif
#ifdef AFS_FBSD50_ENV
code =
- sosend(asocket, (struct sockaddr *)saddr, &u, NULL, NULL, 0,
+ sosend(asocket, (struct sockaddr *)addr, &u, NULL, NULL, 0,
curthread);
#else
code =
- sosend(asocket, (struct sockaddr *)saddr, &u, NULL, NULL, 0, curproc);
+ sosend(asocket, (struct sockaddr *)addr, &u, NULL, NULL, 0, curproc);
#endif
#if KNET_DEBUG
if (code) {
#include "../rx/rx_kcommon.h"
int
-osi_NetReceive(osi_socket asocket, struct sockaddr_storage *saddr, int *slen,
+osi_NetReceive(osi_socket asocket, struct sockaddr_in *addr,
struct iovec *dvec, int nvecs, int *alength)
{
struct uio u;
if (haveGlock)
AFS_GUNLOCK();
- code = soreceive(asocket, (saddr ? &nam : NULL), &u, NULL, NULL, NULL);
+ code = soreceive(asocket, (addr ? &nam : NULL), &u, NULL, NULL, NULL);
if (haveGlock)
AFS_GLOCK();
}
*alength -= u.uio_resid;
- if (saddr && nam) {
- memcpy(saddr, mtod(nam, caddr_t), nam->m_len);
- *slen = nam->m_len;
+ if (addr && nam) {
+ memcpy(addr, mtod(nam, caddr_t), nam->m_len);
m_freem(nam);
}
*/
int
-osi_NetSend(osi_socket asocket, struct sockaddr_storage *addr, int slen,
- struct iovec *dvec, int nvecs, afs_int32 alength, int istack)
+osi_NetSend(osi_socket asocket, struct sockaddr_in *addr, struct iovec *dvec,
+ int nvecs, afs_int32 alength, int istack)
{
int i, code;
struct iovec iov[RX_MAXIOVECS];
nam = m_get(M_DONTWAIT, MT_SONAME);
if (!nam)
return ENOBUFS;
- nam->m_len = slen;
- memcpy(mtod(nam, caddr_t), addr, slen);
+ nam->m_len = addr->sin_len = sizeof(struct sockaddr_in);
+ memcpy(mtod(nam, caddr_t), addr, addr->sin_len);
if (haveGlock)
AFS_GUNLOCK();
/* Allocate a new socket at specified port in network byte order. */
osi_socket *
-rxk_NewSocketHost(struct sockaddr_storage *addr, int salen)
+rxk_NewSocketHost(afs_uint32 ahost, short aport)
{
vnode_t *accessvp;
struct sonode *so;
+ struct sockaddr_in addr;
int error;
int len;
return NULL;
}
- error = sockfs_sobind(so, (struct sockaddr *)addr, salen, 0, 0);
+ addr.sin_family = AF_INET;
+ addr.sin_port = aport;
+ addr.sin_addr.s_addr = ahost; /* I wonder what the odds are on
+ needing to unbyteswap this */
+ error = sockfs_sobind(so, (struct sockaddr *)&addr, sizeof(addr), 0, 0);
if (error != 0) {
return NULL;
}
dvec.iov_len = 1;
while (rxk_ListenerPid) {
- osi_NetSend(rx_socket, &taddr, sizeof(taddr), &dvec, 1, 1, 0);
+ osi_NetSend(rx_socket, &taddr, &dvec, 1, 1, 0);
afs_osi_Sleep(&rxk_ListenerPid);
}
}
int
-osi_NetSend(osi_socket asocket, struct sockaddr_storage *saddr, int slen,
- struct iovec *dvec, int nvecs, afs_int32 asize, int istack)
+osi_NetSend(osi_socket asocket, struct sockaddr_in *addr, struct iovec *dvec,
+ int nvecs, afs_int32 asize, int istack)
{
struct sonode *so = (struct sonode *)asocket;
struct nmsghdr msg;
osi_Panic("osi_NetSend: %d: Too many iovecs.\n", nvecs);
}
- msg.msg_name = (struct sockaddr *) saddr;
- msg.msg_namelen = slen;
+ msg.msg_name = (struct sockaddr *)addr;
+ msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_iov = dvec;
msg.msg_iovlen = nvecs;
msg.msg_control = NULL;
}
int
-osi_NetReceive(osi_socket so, struct sockaddr_storage *saddr, int *slen,
- struct iovec *dvec, int nvecs, int *alength)
+osi_NetReceive(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
+ int nvecs, int *alength)
{
struct sonode *asocket = (struct sonode *)so;
struct nmsghdr msg;
}
msg.msg_name = NULL;
- msg.msg_namelen = *slen;
+ msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_iov = NULL;
msg.msg_iovlen = 0;
msg.msg_control = NULL;
if (msg.msg_name == NULL) {
error = -1;
} else {
- memcpy(saddr, msg.msg_name, msg.msg_namelen);
- *slen = msg.msg_namelen;
+ memcpy(addr, msg.msg_name, msg.msg_namelen);
kmem_free(msg.msg_name, msg.msg_namelen);
*alength = *alength - uio.uio_resid;
}
rxi_ListenerProc(osi_socket usockp, int *tnop, struct rx_call **newcallp)
{
struct rx_packet *tp;
- struct sockaddr_storage saddr;
- int slen;
+ afs_uint32 host;
u_short port;
int rc;
while (1) {
tp = rxi_AllocPacket(RX_PACKET_CLASS_RECEIVE);
usr_assert(tp != NULL);
- rc = rxi_ReadPacket(usockp, tp, &saddr, &slen);
+ rc = rxi_ReadPacket(usockp, tp, &host, &port);
if (rc != 0) {
- tp = rxi_ReceivePacket(tp, usockp, &saddr, slen, tnop, newcallp);
+ tp = rxi_ReceivePacket(tp, usockp, host, port, tnop, newcallp);
if (newcallp && *newcallp) {
if (tp) {
rxi_FreePacket(tp);
}
int
-osi_NetSend(osi_socket sockp, struct sockaddr_storage *addr, int addrlen,
- struct iovec *iov, int nio, afs_int32 size, int stack)
+osi_NetSend(osi_socket sockp, struct sockaddr_in *addr, struct iovec *iov,
+ int nio, afs_int32 size, int stack)
{
int rc;
int i;
memset(&msg, 0, sizeof(msg));
msg.msg_name = (void *)addr;
- msg.msg_namelen = addrlen;
+ msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_iov = &tmpiov[0];
msg.msg_iovlen = nio;
#define UNLOCK_RX_INIT
#endif
-/*
- * Now, rx_InitHost is just a stub for rx_InitAddrs
- * Parameters are in network byte order.
- */
-
int
rx_InitHost(u_int host, u_int port)
{
- struct sockaddr_storage saddr;
- int type = SOCK_DGRAM, len = sizeof(struct sockaddr_in);
-
- memset((void *) &saddr, 0, sizeof(saddr));
- rx_ssfamily(&saddr) = AF_INET;
- ((struct sockaddr_in *) &saddr)->sin_addr.s_addr = host;
- ((struct sockaddr_in *) &saddr)->sin_port = (u_short)port;
-#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
- ((struct sockaddr_in *) &saddr)->sin_len = sizeof(struct sockaddr_in);
-#endif
- return rx_InitAddrs(&saddr, &type, &len, 1);
-}
-
-/*
- * New API: rx_InitAddrs(struct sockaddr_storage *, int *, int)
- *
- * Arguments:
- *
- * struct sockaddr_storage - array of struct sockaddr_storage elements,
- * each one listing an interface/protocol to
- * be listened on.
- * int * - array of integers listing the socket type
- * (SOCK_STREAM or SOCK_DGRAM) to be used
- * by the corresponding struct sockaddr_storage
- * int * - array of integers listing saddr sizes
- * int - Number of elements in sockaddr_storage array.
- *
- * Note that in general only servers should call this function; clients
- * should (for now) continue to call rx_Init().
- */
-
-int rx_InitAddrs(struct sockaddr_storage *saddrs, int *types, int *salens,
- int nelem)
-{
#ifdef KERNEL
osi_timeval_t tv;
#else /* KERNEL */
struct timeval tv;
#endif /* KERNEL */
char *htable, *ptable;
- int tmp_status, i;
-
+ int tmp_status;
+
SPLVAR;
-
+
INIT_PTHREAD_LOCKS;
LOCK_RX_INIT;
if (rxinit_status == 0) {
if (afs_winsockInit() < 0)
return -1;
#endif
-
+
#ifndef KERNEL
/*
* Initialize anything necessary to provide a non-premptive threading
*/
rxi_InitializeThreadSupport();
#endif
-
+
/* Allocate and initialize a socket for client and perhaps server
* connections. */
-
- rx_socket = OSI_NULLSOCKET;
- rx_port = 0;
-
- for (i = 0; i < nelem; i++) {
- switch (types[i]) {
- case SOCK_DGRAM:
- rx_socket = rxi_GetHostUDPSocket(&saddrs[i], salens[i]);
- if (rx_socket == OSI_NULLSOCKET) {
- UNLOCK_RX_INIT;
- return RX_ADDRINUSE;
- }
- rx_port = rx_ss2pn(&saddrs[i]);
- break;
- default:
- return RX_INVALID_OPERATION;
- }
-
+
+ rx_socket = rxi_GetHostUDPSocket(host, (u_short) port);
+ if (rx_socket == OSI_NULLSOCKET) {
+ UNLOCK_RX_INIT;
+ return RX_ADDRINUSE;
}
-
#ifdef RX_ENABLE_LOCKS
#ifdef RX_LOCKS_DB
rxdb_init();
#else
osi_GetTime(&tv);
#endif
-
- if (! rx_port) {
+ if (port) {
+ rx_port = port;
+ } else {
#if defined(KERNEL) && !defined(UKERNEL)
/* Really, this should never happen in a real kernel */
rx_port = 0;
#else
- struct sockaddr_storage sn;
- socklen_t addrlen = sizeof(sn);
- if (getsockname((int)rx_socket, (struct sockaddr *)&sn, &addrlen)) {
+ struct sockaddr_in addr;
+ int addrlen = sizeof(addr);
+ if (getsockname((int)rx_socket, (struct sockaddr *)&addr, &addrlen)) {
rx_Finalize();
return -1;
}
- rx_port = rx_ss2pn(&sn);
+ rx_port = addr.sin_port;
#endif
}
rx_stats.minRtt.sec = 9999999;
return rx_InitHost(htonl(INADDR_ANY), port);
}
-
/* called with unincremented nRequestsRunning to see if it is OK to start
* a new thread in this service. Could be "no" for two reasons: over the
* max quota, or would prevent others from reaching their min quota.
return;
}
-/*
- * Now, rx_NewConnection is just a stub for rx_NewConnectionAddrs()
- */
-
+/* Create a new client connection to the specified service, using the
+ * specified security object to implement the security model for this
+ * connection. */
struct rx_connection *
rx_NewConnection(register afs_uint32 shost, u_short sport, u_short sservice,
register struct rx_securityClass *securityObject,
int serviceSecurityIndex)
{
- struct sockaddr_in sin;
- int len = sizeof(sin), type = SOCK_DGRAM;
-
- memset((void *) &sin, 0, sizeof(sin));
-
- sin.sin_family = AF_INET;
- sin.sin_addr.s_addr = shost;
- sin.sin_port = sport;
-
- return rx_NewConnectionAddrs((struct sockaddr_storage *) &sin, &type,
- &len, 1, sservice, securityObject,
- serviceSecurityIndex);
-}
-
-/* Create a new client connection to the specified service, using the
- * specified security object to implement the security model for this
- * connection
- *
- * This follows the same logic as rx_InitAddrs() for the first four
- * arguments.
- */
-struct rx_connection *
-rx_NewConnectionAddrs(struct sockaddr_storage *saddr, int *type, int *slen,
- int nelem, u_short sservice,
- struct rx_securityClass *securityObject,
- int serviceSecurityIndex)
-{
- int hashindex, i;
+ int hashindex;
afs_int32 cid;
register struct rx_connection *conn;
SPLVAR;
clock_NewTime();
- dpf(("rx_NewConnection(host %x, port %u, service %u, securityObject %x, serviceSecurityIndex %d)\n", ntohl(rx_ss2v4addr(saddr)), ntohs(rx_ss2pn(saddr)), sservice, securityObject, serviceSecurityIndex));
+ dpf(("rx_NewConnection(host %x, port %u, service %u, securityObject %x, serviceSecurityIndex %d)\n", ntohl(shost), ntohs(sport), sservice, securityObject, serviceSecurityIndex));
/* Vasilsi said: "NETPRI protects Cid and Alloc", but can this be true in
* the case of kmem_alloc? */
conn->type = RX_CLIENT_CONNECTION;
conn->cid = cid;
conn->epoch = rx_epoch;
- /*
- * Right now we're going to just call rxi_FindPeer for UDP connections
- * We're only going to support one.
- */
- for (i = 0; i < nelem; i++) {
- if (type[i] == SOCK_DGRAM) {
- conn->peer = rxi_FindPeer(&saddr[i], slen[i], type[i], 0, 1);
- break;
- }
- }
+ conn->peer = rxi_FindPeer(shost, sport, 0, 1);
conn->serviceId = sservice;
conn->securityObject = securityObject;
/* This doesn't work in all compilers with void (they're buggy), so fake it
if (socket == OSI_NULLSOCKET) {
/* If we don't already have a socket (from another
* service on same port) get a new one */
- struct sockaddr_in sin;
-
- memset((void *) &sin, 0, sizeof(sin));
- sin.sin_family = AF_INET;
- sin.sin_addr.s_addr = htonl(INADDR_ANY);
- sin.sin_port = port;
-#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
- sin.sin_len = sizeof(sin);
-#endif
- socket = rxi_GetHostUDPSocket((struct sockaddr_storage *) &sin,
- sizeof(sin));
+ socket = rxi_GetHostUDPSocket(htonl(INADDR_ANY), port);
if (socket == OSI_NULLSOCKET) {
USERPRI;
rxi_FreeService(tservice);
* refcount will be be decremented. This is used to replace the peer
* structure hanging off a connection structure */
struct rx_peer *
-rxi_FindPeer(struct sockaddr_storage *saddr, int slen, int stype,
- struct rx_peer *origPeer, int create)
+rxi_FindPeer(register afs_uint32 host, register u_short port,
+ struct rx_peer *origPeer, int create)
{
register struct rx_peer *pp;
- int hashIndex, i, j;
- for (i = 0, j = 0; i < slen; i++)
- j += ((unsigned char *) saddr)[i];
- hashIndex = j % rx_hashTableSize;
+ int hashIndex;
+ hashIndex = PEER_HASH(host, port);
MUTEX_ENTER(&rx_peerHashTable_lock);
for (pp = rx_peerHashTable[hashIndex]; pp; pp = pp->next) {
- if (memcmp(saddr, &pp->saddr, slen) == 0 && stype == pp->socktype)
- break;
+ if ((pp->host == host) && (pp->port == port))
+ break;
}
if (!pp) {
- if (create) {
- pp = rxi_AllocPeer(); /* This bzero's *pp */
- memcpy(&pp->saddr, saddr, slen);
- pp->saddrlen = slen;
- pp->socktype = stype;
- switch (rx_ssfamily(saddr)) {
- case AF_INET:
- /*
- * Should be enough storage for a dotted quad
- */
- snprintf(pp->addrstring, sizeof pp->addrstring, "%d.%d.%d.%d",
- rx_ss2addrp(saddr)[0], rx_ss2addrp(saddr)[1],
- rx_ss2addrp(saddr)[2], rx_ss2addrp(saddr)[3]);
- break;
-#ifdef AF_INET6
- case AF_INET6:
- /*
- * This gets more complicated, unfortunately
- */
- if (IN6_IS_ADDR_V4COMPAT(&(rx_ss2sin6(saddr)->sin6_addr))) {
- snprintf(pp->addrstring,
- sizeof pp->addrstring, "%d.%d.%d.%d",
- rx_ss2addrp(saddr)[12], rx_ss2addrp(saddr)[13],
- rx_ss2addrp(saddr)[14], rx_ss2addrp(saddr)[15]);
- } else {
- snprintf(pp->addrstring,
- sizeof pp->addrstring, "%x:%x:%x:%x:%x:%x:%x:%x",
- ntohs(rx_ss2addrp6(saddr)[0]),
- ntohs(rx_ss2addrp6(saddr)[1]),
- ntohs(rx_ss2addrp6(saddr)[2]),
- ntohs(rx_ss2addrp6(saddr)[3]),
- ntohs(rx_ss2addrp6(saddr)[4]),
- ntohs(rx_ss2addrp6(saddr)[5]),
- ntohs(rx_ss2addrp6(saddr)[6]),
- ntohs(rx_ss2addrp6(saddr)[7]));
- }
- break;
-#endif /* AF_INET6 */
- default:
- strcpy(pp->addrstring, "??.??.??.??");
- break;
- }
+ if (create) {
+ pp = rxi_AllocPeer(); /* This bzero's *pp */
+ pp->host = host; /* set here or in InitPeerParams is zero */
+ pp->port = port;
MUTEX_INIT(&pp->peer_lock, "peer_lock", MUTEX_DEFAULT, 0);
queue_Init(&pp->congestionQueue);
queue_Init(&pp->rpcStats);
* 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, struct sockaddr_storage *saddr,
- int slen, int socktype, u_short serviceId, afs_uint32 cid,
+rxi_FindConnection(osi_socket socket, register afs_int32 host,
+ register u_short port, u_short serviceId, afs_uint32 cid,
afs_uint32 epoch, int type, u_int securityIndex)
{
int hashindex, flag;
MUTEX_EXIT(&rx_connHashTable_lock);
return (struct rx_connection *)0;
}
- if (memcmp(&pp->saddr, saddr, slen) == 0 &&
- socktype == pp->socktype)
+ if (pp->host == host && pp->port == port)
break;
- if (type == RX_CLIENT_CONNECTION &&
- rx_ss2pn(&pp->saddr) == rx_ss2pn(saddr))
+ if (type == RX_CLIENT_CONNECTION && pp->port == port)
break;
/* So what happens when it's a callback connection? */
if ( /*type == RX_CLIENT_CONNECTION && */
CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
conn->next = rx_connHashTable[hashindex];
rx_connHashTable[hashindex] = conn;
- conn->peer = rxi_FindPeer(saddr, slen, socktype, 0, 1);
+ conn->peer = rxi_FindPeer(host, port, 0, 1);
conn->type = RX_SERVER_CONNECTION;
conn->lastSendTime = clock_Sec(); /* don't GC immediately */
conn->epoch = epoch;
struct rx_packet *
rxi_ReceivePacket(register struct rx_packet *np, osi_socket socket,
- struct sockaddr_storage *saddr, int slen, int *tnop,
+ afs_uint32 host, u_short port, int *tnop,
struct rx_call **newcallp)
{
register struct rx_call *call;
packetType = (np->header.type > 0 && np->header.type < RX_N_PACKET_TYPES)
? rx_packetTypes[np->header.type - 1] : "*UNKNOWN*";
dpf(("R %d %s: %x.%d.%d.%d.%d.%d.%d flags %d, packet %x",
- np->header.serial, packetType, ntohl(rx_ss2v4addr(saddr)),
- ntohs(rx_ss2pn(saddr)), np->header.serviceId,
+ np->header.serial, packetType, ntohl(host), ntohs(port), np->header.serviceId,
np->header.epoch, np->header.cid, np->header.callNumber,
np->header.seq, np->header.flags, np));
#endif
if (np->header.type == RX_PACKET_TYPE_VERSION) {
- return rxi_ReceiveVersionPacket(np, socket, saddr, slen, 1);
+ return rxi_ReceiveVersionPacket(np, socket, host, port, 1);
}
if (np->header.type == RX_PACKET_TYPE_DEBUG) {
- return rxi_ReceiveDebugPacket(np, socket, saddr, slen, 1);
+ return rxi_ReceiveDebugPacket(np, socket, host, port, 1);
}
#ifdef RXDEBUG
/* If an input tracer function is defined, call it with the packet and
* network address. Note this function may modify its arguments. */
if (rx_justReceived) {
- struct sockaddr_in *addr = (struct sockaddr_in *) saddr;
+ struct sockaddr_in addr;
int drop;
- drop = (*rx_justReceived) (np, addr);
+ addr.sin_family = AF_INET;
+ addr.sin_port = port;
+ addr.sin_addr.s_addr = host;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ addr.sin_len = sizeof(addr);
+#endif /* AFS_OSF_ENV */
+ drop = (*rx_justReceived) (np, &addr);
/* drop packet if return value is non-zero */
if (drop)
return np;
+ port = addr.sin_port; /* in case fcn changed addr */
+ host = addr.sin_addr.s_addr;
}
#endif
/* Find the connection (or fabricate one, if we're the server & if
* necessary) associated with this packet */
conn =
- rxi_FindConnection(socket, saddr, slen, SOCK_DGRAM,
- np->header.serviceId, np->header.cid,
- np->header.epoch, type, np->header.securityIndex);
+ rxi_FindConnection(socket, host, port, np->header.serviceId,
+ np->header.cid, np->header.epoch, type,
+ np->header.securityIndex);
if (!conn) {
/* If no connection found or fabricated, just ignore the packet.
MUTEX_EXIT(&conn->conn_call_lock);
*call->callNumber = np->header.callNumber;
if (np->header.callNumber == 0)
- dpf(("RecPacket call 0 %d %s: %s.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", np->header.serial, rx_packetTypes[np->header.type - 1], rx_AddrStringOf(conn->peer), ntohs(rx_PortOf(conn->peer)), np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq, np->header.flags, (unsigned long)np, np->retryTime.sec, np->retryTime.usec / 1000, np->length));
+ dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port), np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq, np->header.flags, (unsigned long)np, np->retryTime.sec, np->retryTime.usec / 1000, np->length));
call->state = RX_STATE_PRECALL;
clock_GetTime(&call->queueTime);
rxi_ResetCall(call, 0);
*call->callNumber = np->header.callNumber;
if (np->header.callNumber == 0)
- dpf(("RecPacket call 0 %d %s: %s.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", np->header.serial, rx_packetTypes[np->header.type - 1], rx_AddrStringOf(conn->peer), ntohs(rx_PortOf(conn->peer)), np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq, np->header.flags, (unsigned long)np, np->retryTime.sec, np->retryTime.usec / 1000, np->length));
+ dpf(("RecPacket call 0 %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", np->header.serial, rx_packetTypes[np->header.type - 1], ntohl(conn->peer->host), ntohs(conn->peer->port), np->header.serial, np->header.epoch, np->header.cid, np->header.callNumber, np->header.seq, np->header.flags, (unsigned long)np, np->retryTime.sec, np->retryTime.usec / 1000, np->length));
call->state = RX_STATE_PRECALL;
clock_GetTime(&call->queueTime);
/* Now do packet type-specific processing */
switch (np->header.type) {
case RX_PACKET_TYPE_DATA:
- np = rxi_ReceiveDataPacket(call, np, 1, socket, saddr, slen, tnop,
+ np = rxi_ReceiveDataPacket(call, np, 1, socket, host, port, tnop,
newcallp);
break;
case RX_PACKET_TYPE_ACK:
struct rx_packet *
rxi_ReceiveDataPacket(register struct rx_call *call,
register struct rx_packet *np, int istack,
- osi_socket socket, struct sockaddr_storage *saddr,
- int slen, int *tnop, struct rx_call **newcallp)
+ osi_socket socket, afs_uint32 host, u_short port,
+ int *tnop, struct rx_call **newcallp)
{
int ackNeeded = 0; /* 0 means no, otherwise ack_reason */
int newPackets = 0;
/* The RX_JUMBO_PACKET is set in all but the last packet in each
* AFS 3.5 jumbogram. */
if (flags & RX_JUMBO_PACKET) {
- tnp = rxi_SplitJumboPacket(np, saddr, slen, isFirst);
+ tnp = rxi_SplitJumboPacket(np, host, port, isFirst);
} else {
tnp = NULL;
}
void
rx_PrintPeerStats(FILE * file, struct rx_peer *peer)
{
-/* fprintf(file, "Peer %x.%d. " "Burst size %d, " "burst wait %u.%d.\n",
+ fprintf(file, "Peer %x.%d. " "Burst size %d, " "burst wait %u.%d.\n",
ntohl(peer->host), (int)peer->port, (int)peer->burstSize,
- (int)peer->burstWait.sec, (int)peer->burstWait.usec); */
+ (int)peer->burstWait.sec, (int)peer->burstWait.usec);
fprintf(file,
" Rtt %d, " "retry time %u.%06d, " "total sent %d, "
afs_uint32 currentFunc, afs_uint32 totalFunc,
struct clock *queueTime, struct clock *execTime,
afs_hyper_t * bytesSent, afs_hyper_t * bytesRcvd, int isServer,
- struct sockaddr_storage *saddr,
+ afs_uint32 remoteHost, afs_uint32 remotePort,
int addToPeerList, unsigned int *counter)
{
int rc = 0;
}
*counter += totalFunc;
for (i = 0; i < totalFunc; i++) {
- switch (rx_ssfamily(saddr)) {
- case AF_INET:
- rpc_stat->stats[i].remote_peer =
- rx_ss2sin(saddr)->sin_addr.s_addr;
- break;
- default:
-#ifdef AF_INET6
- case AF_INET6:
- rpc_stat->stats[i].remote_peer = 0xffffffff;
- break;
-#endif /* AF_INET6 */
- }
- rpc_stat->stats[i].remote_port = rx_ss2pn(saddr);
+ rpc_stat->stats[i].remote_peer = remoteHost;
+ rpc_stat->stats[i].remote_port = remotePort;
rpc_stat->stats[i].remote_is_server = isServer;
rpc_stat->stats[i].interfaceId = rxInterface;
rpc_stat->stats[i].func_total = totalFunc;
if (rxi_monitor_peerStats) {
rxi_AddRpcStat(&peer->rpcStats, rxInterface, currentFunc, totalFunc,
queueTime, execTime, bytesSent, bytesRcvd, isServer,
- &peer->saddr, 1, &rxi_rpc_peer_stat_cnt);
+ peer->host, peer->port, 1, &rxi_rpc_peer_stat_cnt);
}
if (rxi_monitor_processStats) {
- struct sockaddr_in sin;
- sin.sin_family = AF_INET;
- sin.sin_addr.s_addr = 0xffffffff;
- sin.sin_port = 0xffff;
rxi_AddRpcStat(&processStats, rxInterface, currentFunc, totalFunc,
queueTime, execTime, bytesSent, bytesRcvd, isServer,
- (struct sockaddr_storage *) &sin, 0,
- &rxi_rpc_process_stat_cnt);
+ 0xffffffff, 0xffffffff, 0, &rxi_rpc_process_stat_cnt);
}
MUTEX_EXIT(&peer->peer_lock);
#ifndef KERNEL
typedef void (*rx_destructor_t) (void *);
int rx_KeyCreate(rx_destructor_t);
-osi_socket rxi_GetHostUDPSocket(struct sockaddr_storage *saddr, int salen);
+osi_socket rxi_GetHostUDPSocket(u_int host, u_short port);
osi_socket rxi_GetUDPSocket(u_short port);
#endif /* KERNEL */
#define rx_ConnectionOf(call) ((call)->conn)
#define rx_PeerOf(conn) ((conn)->peer)
-#ifdef AF_INET6
-#define rx_HostOf(peer) ((peer)->saddr.ss_family == AF_INET ? \
- ((struct sockaddr_in *) &(peer)->saddr)->sin_addr.s_addr : \
- 0xffffffff)
-#define rx_PortOf(peer) ((peer)->saddr.ss_family == AF_INET ? \
- ((struct sockaddr_in *) &(peer)->saddr)->sin_port : \
- ((struct sockaddr_in6 *) &(peer)->saddr)->sin6_port)
-#else /* AF_INET6 */
-#define rx_HostOf(peer) (((struct sockaddr_in *) &(peer)->saddr)->sin_addr.saddr)
-#define rx_PortOf(peer) (((struct sockaddr_in *) &(peer)->saddr)->sin_port)
-#endif /* AF_INET6 */
-#define rx_AddrStringOf(peer) ((peer)->addrstring)
+#define rx_HostOf(peer) ((peer)->host)
+#define rx_PortOf(peer) ((peer)->port)
#define rx_SetLocalStatus(call, status) ((call)->localStatus = (status))
#define rx_GetLocalStatus(call, status) ((call)->localStatus)
#define rx_GetRemoteStatus(call) ((call)->remoteStatus)
osi_socket *socketp;
};
-/* If we don't support IPv6, use this as a fallback */
-#ifndef INET6_ADDRSTRLEN
-#define INET6_ADDRSTRLEN 46
-#endif /* INET6_ADDRSTRLEN */
/* A peer refers to a peer process, specified by a (host,port) pair. There may be more than one peer on a given host. */
#ifdef KDUMP_RX_LOCK
#ifdef RX_ENABLE_LOCKS
afs_kmutex_t peer_lock; /* Lock peer */
#endif /* RX_ENABLE_LOCKS */
- struct sockaddr_storage saddr; /* Remote address structure */
- int saddrlen; /* Length of saddr */
- int socktype; /* Socket type (SOCK_DGRAM, etc) */
- char addrstring[INET6_ADDRSTRLEN]; /* Printable address format */
+ afs_uint32 host; /* Remote IP address, in net byte order */
+ u_short port; /* Remote UDP port, in net byte order */
/* interface mtu probably used for this host - includes RX Header */
u_short ifMTU; /* doesn't include IP header */
#define RX_STATS_SERVICE_ID 409
-/*
- * Definitions for handling struct sockaddr_storage casts, and IPv6
- */
-#ifdef AF_INET6
-#define rx_ss2pn(x) ((x)->ss_family == AF_INET6 ? \
- ((struct sockaddr_in6 *) (x))->sin6_port : \
- ((struct sockaddr_in *) (x))->sin_port)
-#define rx_ss2sin6(x) ((struct sockaddr_in6 *) (x))
-#define rx_ssfamily(x) ((x)->ss_family)
-#define rx_ss2addrp6(x) ((afs_uint16 *) &(((struct sockaddr_in6 *) (x))->sin6_addr.s6_addr))
-#define rx_ss2v4addr(x) ((x)->ss_family == AF_INET ? \
- ((struct sockaddr_in *) (x))->sin_addr.s_addr : \
- 0xffffffff)
-#else /* AF_INET6 */
-#define rx_ss2pn(x) (((struct sockaddr_in *) (x))->sin_port)
-#define rx_ssfamily(x) (((struct sockaddr_in *) (x))->sin_family)
-#define rx_ss2v4addr(x) (((struct sockaddr_in *) (x))->sin_addr.s_addr)
-#endif /* AF_INET6 */
-#define rx_ss2sin(x) ((struct sockaddr_in *) (x))
-#define rx_ss2addrp(x) ((unsigned char *) &(((struct sockaddr_in *) (x))->sin_addr.s_addr))
#endif /* _RX_ End of rx.h */
#define CONN_HASH(host, port, cid, epoch, type) ((((cid)>>RX_CIDSHIFT)%rx_hashTableSize))
-#if 0
#define PEER_HASH(host, port) ((host ^ port) % rx_hashTableSize)
-#endif
/* Forward definitions of internal procedures */
#define rxi_ChallengeOff(conn) rxevent_Cancel((conn)->challengeEvent, (struct rx_call*)0, 0);
int (*rxk_GetPacketProc) (struct rx_packet **ahandle, int asize);
#endif
-osi_socket *rxk_NewSocketHost(struct sockaddr_storage *saddr, int salen);
+osi_socket *rxk_NewSocketHost(afs_uint32 ahost, short aport);
extern struct interfaceAddr afs_cb_interface;
rxk_ports_t rxk_ports;
}
osi_socket
-rxi_GetHostUDPSocket(struct sockaddr_storage *saddr, int salen)
+rxi_GetHostUDPSocket(u_int host, u_short port)
{
osi_socket *sockp;
- sockp = (osi_socket *)rxk_NewSocketHost(saddr, salen);
+ sockp = (osi_socket *)rxk_NewSocketHost(host, port);
if (sockp == (osi_socket *)0)
return OSI_NULLSOCKET;
- rxk_AddPort(rx_ss2pn(saddr), (char *)sockp);
+ rxk_AddPort(port, (char *)sockp);
return (osi_socket) sockp;
}
osi_socket
rxi_GetUDPSocket(u_short port)
{
- struct sockaddr_storage saddr;
- struct sockaddr_in *sin = (struct sockaddr_in *) &saddr;
-
- memset((void *) &saddr, 0, sizeof(saddr));
-
- sin->sin_family = AF_INET;
- sin->sin_addr.s_addr = htonl(INADDR_ANY);
- sin->sin_port = port;
-
- return rxi_GetHostUDPSocket(&saddr, sizeof(struct sockaddr_in));
+ return rxi_GetHostUDPSocket(htonl(INADDR_ANY), port);
}
#if !defined(AFS_LINUX26_ENV)
ahandle->length = asize - RX_HEADER_SIZE;
rxi_DecodePacketHeader(ahandle);
ahandle =
- rxi_ReceivePacket(ahandle, arock, (struct sockaddr_storage *) afrom,
- NULL, NULL);
+ rxi_ReceivePacket(ahandle, arock,
+ afrom->sin_addr.s_addr, afrom->sin_port, NULL,
+ NULL);
/* free the packet if it has been returned */
if (ahandle)
#ifdef ADAPT_MTU
#ifndef AFS_SUN5_ENV
#ifdef AFS_USERSPACE_IP_ADDR
- i = rxi_Findcbi(rx_HostOf(pp));
+ i = rxi_Findcbi(pp->host);
if (i == -1) {
pp->timeout.sec = 3;
/* pp->timeout.usec = 0; */
(void)rxi_GetIFInfo();
#endif
- ifn = rxi_FindIfnet(rx_HostOf(pp), NULL);
+ ifn = rxi_FindIfnet(pp->host, NULL);
if (ifn) {
pp->timeout.sec = 2;
/* pp->timeout.usec = 0; */
}
#endif /* else AFS_USERSPACE_IP_ADDR */
#else /* AFS_SUN5_ENV */
- mtu = rxi_FindIfMTU(rx_HostOf(pp));
+ mtu = rxi_FindIfMTU(pp->host);
if (mtu <= 0) {
pp->timeout.sec = 3;
* in network byte order.
*/
osi_socket *
-rxk_NewSocketHost(struct sockaddr_storage *saddr, int salen)
+rxk_NewSocketHost(afs_uint32 ahost, short aport)
{
register afs_int32 code;
#ifdef AFS_DARWIN80_ENV
#if (!defined(AFS_HPUX1122_ENV) && !defined(AFS_FBSD50_ENV))
struct mbuf *nam;
#endif
+ struct sockaddr_in myaddr;
#ifdef AFS_HPUX110_ENV
/* prototype copied from kernel source file streams/str_proto.h */
extern MBLKP allocb_wait(int, int);
/* we need a file associated with the socket so sosend in NetSend
* will not fail */
/* blocking socket */
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, 0, 0);
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0, 0);
fp = falloc();
if (!fp)
goto bad;
newSocket->so_fp = (void *)fp;
#else /* AFS_HPUX110_ENV */
- code = socreate(rx_ssfamilty(saddr), &newSocket, SOCK_DGRAM, 0, SS_NOWAIT);
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0, SS_NOWAIT);
#endif /* else AFS_HPUX110_ENV */
#elif defined(AFS_SGI65_ENV) || defined(AFS_OBSD_ENV)
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, IPPROTO_UDP);
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, IPPROTO_UDP);
#elif defined(AFS_FBSD50_ENV)
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, IPPROTO_UDP,
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, IPPROTO_UDP,
afs_osi_credp, curthread);
#elif defined(AFS_FBSD40_ENV)
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, IPPROTO_UDP,
- curproc);
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, IPPROTO_UDP, curproc);
#elif defined(AFS_DARWIN80_ENV)
- code = sock_socket(rx_ssfamily(saddr), SOCK_DGRAM, IPPROTO_UDP, NULL, NULL,
- &newSocket);
+ code = sock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, NULL, &newSocket);
#else
- code = socreate(rx_ssfamily(saddr), &newSocket, SOCK_DGRAM, 0);
+ code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0);
#endif /* AFS_HPUX102_ENV */
if (code)
goto bad;
+ memset(&myaddr, 0, sizeof myaddr);
+ myaddr.sin_family = AF_INET;
+ myaddr.sin_port = aport;
+ myaddr.sin_addr.s_addr = ahost;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ myaddr.sin_len = sizeof(myaddr);
+#endif
+
#ifdef AFS_HPUX110_ENV
bindnam = allocb_wait((addrsize + SO_MSGOFFSET + 1), BPRI_MED);
if (!bindnam) {
setuerror(ENOBUFS);
goto bad;
}
- memcpy((caddr_t) bindnam->b_rptr + SO_MSGOFFSET, (caddr_t) addr,
+ memcpy((caddr_t) bindnam->b_rptr + SO_MSGOFFSET, (caddr_t) & myaddr,
addrsize);
bindnam->b_wptr = bindnam->b_rptr + (addrsize + SO_MSGOFFSET + 1);
#endif
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
#if defined(AFS_FBSD50_ENV)
- code = sobind(newSocket, (struct sockaddr *) saddr, curthread);
+ code = sobind(newSocket, (struct sockaddr *)&myaddr, curthread);
#elif defined(AFS_FBSD40_ENV)
- code = sobind(newSocket, (struct sockaddr *) saddr, curproc);
+ code = sobind(newSocket, (struct sockaddr *)&myaddr, curproc);
#else
- code = sobind(newSocket, (struct sockaddr *) saddr);
+ code = sobind(newSocket, (struct sockaddr *)&myaddr);
#endif
if (code) {
dpf(("sobind fails (%d)\n", (int)code));
#endif
goto bad;
}
- nam->m_len = salen;
- memcpy(mtod(nam, caddr_t), saddr, salen);
+ nam->m_len = sizeof(myaddr);
+ memcpy(mtod(nam, caddr_t), &myaddr, sizeof(myaddr));
#ifdef AFS_SGI65_ENV
BHV_PDATA(&bhv) = (void *)newSocket;
code = sobind(&bhv, nam);
osi_socket *
rxk_NewSocket(short aport)
{
- struct sockaddr_storage saddr;
- struct sockaddr_in *sin = (struct sockaddr_in *) &saddr;
-
- memset((void *) &saddr, 0, sizeof(saddr));
-
- sin->sin_family = AF_INET;
- sin->sin_addr.s_addr = 0;
- sin->sin_port = aport;
-
- return rxk_NewSocketHost(&saddr, sizeof(struct sockaddr_in));
+ return rxk_NewSocketHost(0, aport);
}
/* free socket allocated by rxk_NewSocket */
/* rxk_ReadPacket returns 1 if valid packet, 0 on error. */
int
-rxk_ReadPacket(osi_socket so, struct rx_packet *p,
- struct sockaddr_storage *saddr, int *slen)
+rxk_ReadPacket(osi_socket so, struct rx_packet *p, int *host, int *port)
{
int code;
+ struct sockaddr_in from;
int nbytes;
afs_int32 rlen;
register afs_int32 tlen;
AFS_GUNLOCK();
}
#endif
- code = osi_NetReceive(rx_socket, saddr, slen, p->wirevec, p->niovecs,
- &nbytes);
+ code = osi_NetReceive(rx_socket, &from, p->wirevec, p->niovecs, &nbytes);
#ifdef RX_KERNEL_TRACE
if (ICL_SETACTIVE(afs_iclSetp)) {
if (nbytes <= 0) {
MUTEX_ENTER(&rx_stats_mutex);
rx_stats.bogusPacketOnRead++;
- switch (rx_ssfamily(saddr)) {
- case AF_INET:
- rx_stats.bogusHost = rx_ss2sin(saddr)->sin_addr.s_addr;
- break;
- default:
-#ifdef AF_INET6
- case AF_INET6:
-#endif /* AF_INET6 */
- rx_stats.bogusHost = 0xffffffff;
- }
+ rx_stats.bogusHost = from.sin_addr.s_addr;
MUTEX_EXIT(&rx_stats_mutex);
dpf(("B: bogus packet from [%x,%d] nb=%d",
- ntohl(rx_ss2v4addr(saddr)), ntohs(rx_ss2pn(saddr)),
- nbytes));
+ from.sin_addr.s_addr, from.sin_port, nbytes));
}
return -1;
} else {
/* Extract packet header. */
rxi_DecodePacketHeader(p);
+ *host = from.sin_addr.s_addr;
+ *port = from.sin_port;
if (p->header.type > 0 && p->header.type < RX_N_PACKET_TYPES) {
MUTEX_ENTER(&rx_stats_mutex);
rx_stats.packetsRead[p->header.type - 1]++;
#endif /* AFS_SUN5_ENV */
{
struct rx_packet *rxp = NULL;
- struct sockaddr_storage saddr;
- int code, slen;
+ int code;
+ int host, port;
#ifdef AFS_LINUX20_ENV
rxk_ListenerPid = current->pid;
if (!rxp)
osi_Panic("rxk_Listener: No more Rx buffers!\n");
}
- if (!(code = rxk_ReadPacket(rx_socket, rxp, &saddr, &slen))) {
- rxp = rxi_ReceivePacket(rxp, rx_socket, &saddr, slen, 0, 0);
+ if (!(code = rxk_ReadPacket(rx_socket, rxp, &host, &port))) {
+ rxp = rxi_ReceivePacket(rxp, rx_socket, host, port, 0, 0);
}
}
static void
rxi_ListenerProc(fd_set * rfds, int *tnop, struct rx_call **newcallp)
{
- struct sockaddr_storage saddr;
- int slen;
+ afs_uint32 host;
+ u_short port;
register struct rx_packet *p = (struct rx_packet *)0;
osi_socket socket;
struct clock cv;
#ifdef AFS_NT40_ENV
for (i = 0; p && i < rfds->fd_count; i++) {
socket = rfds->fd_array[i];
- slen = sizeof(saddr);
- if (rxi_ReadPacket(socket, p, &saddr, &slen)) {
+ if (rxi_ReadPacket(socket, p, &host, &port)) {
*newcallp = NULL;
- p = rxi_ReceivePacket(p, socket, &saddr, slen, tnop,
+ p = rxi_ReceivePacket(p, socket, host, port, tnop,
newcallp);
if (newcallp && *newcallp) {
if (p) {
p && socket <= rx_maxSocketNumber; socket++) {
if (!FD_ISSET(socket, rfds))
continue;
- slen = sizeof(saddr);
- if (rxi_ReadPacket(socket, p, &saddr, &slen)) {
- p = rxi_ReceivePacket(p, socket, &saddr, slen, tnop,
+ if (rxi_ReadPacket(socket, p, &host, &port)) {
+ p = rxi_ReceivePacket(p, socket, host, port, tnop,
newcallp);
if (newcallp && *newcallp) {
if (p) {
static int AllocPacketBufs(int class, int num_pkts, struct rx_queue *q);
static void rxi_SendDebugPacket(struct rx_packet *apacket, osi_socket asocket,
- struct sockaddr_storage *saddr, int slen,
+ afs_int32 ahost, short aport,
afs_int32 istack);
static int rxi_FreeDataBufsToQueue(struct rx_packet *p, int first,
* 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,
- struct sockaddr_storage *saddr, int *slen)
+rxi_ReadPacket(osi_socket socket, register struct rx_packet *p, afs_uint32 * host,
+ u_short * port)
{
+ struct sockaddr_in from;
int nbytes;
afs_int32 rlen;
register afs_int32 tlen, savelen;
p->wirevec[p->niovecs - 1].iov_len += RX_EXTRABUFFERSIZE;
memset((char *)&msg, 0, sizeof(msg));
- msg.msg_name = (char *)saddr;
- msg.msg_namelen = *slen;
+ msg.msg_name = (char *)&from;
+ msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_iov = p->wirevec;
msg.msg_iovlen = p->niovecs;
nbytes = rxi_Recvmsg(socket, &msg, 0);
- *slen = msg.msg_namelen;
/* restore the vec to its correct state */
p->wirevec[p->niovecs - 1].iov_len = savelen;
} else if (nbytes <= 0) {
MUTEX_ENTER(&rx_stats_mutex);
rx_stats.bogusPacketOnRead++;
- switch (rx_ssfamily(saddr)) {
- case AF_INET:
- rx_stats.bogusHost = rx_ss2sin(saddr)->sin_addr.s_addr;
- break;
- default:
-#ifdef AF_INET6
- case AF_INET6:
-#endif /* AF_INET6 */
- rx_stats.bogusHost = 0xffffffff;
- break;
- }
+ rx_stats.bogusHost = from.sin_addr.s_addr;
MUTEX_EXIT(&rx_stats_mutex);
- dpf(("B: bogus packet from [%x,%d] nb=%d",
- ntohl(rx_ss2v4addr(saddr)), ntohs(rx_ss2pn(saddr)), nbytes));
+ dpf(("B: bogus packet from [%x,%d] nb=%d", ntohl(from.sin_addr.s_addr),
+ ntohs(from.sin_port), nbytes));
}
return 0;
}
&& (random() % 100 < rx_intentionallyDroppedOnReadPer100)) {
rxi_DecodePacketHeader(p);
+ *host = from.sin_addr.s_addr;
+ *port = from.sin_port;
+
dpf(("Dropped %d %s: %x.%u.%u.%u.%u.%u.%u flags %d len %d",
- p->header.serial, rx_packetTypes[p->header.type - 1], ntohl(rx_ss2v4addr(saddr)), ntohs(rx_ss2pn(saddr)), p->header.serial,
+ 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));
rxi_TrimDataBufs(p, 1);
/* Extract packet header. */
rxi_DecodePacketHeader(p);
+ *host = from.sin_addr.s_addr;
+ *port = from.sin_port;
if (p->header.type > 0 && p->header.type < RX_N_PACKET_TYPES) {
struct rx_peer *peer;
MUTEX_ENTER(&rx_stats_mutex);
* and this packet was an rxdebug packet, the peer structure would
* never be cleaned up.
*/
- peer = rxi_FindPeer(saddr, *slen, SOCK_DGRAM, 0, 0);
+ peer = rxi_FindPeer(*host, *port, 0, 0);
/* Since this may not be associated with a connection,
* it may have no refCount, meaning we could race with
* ReapConnections
* last two pad bytes. */
struct rx_packet *
-rxi_SplitJumboPacket(register struct rx_packet *p,
- struct sockaddr_storage *saddr, int slen, int first)
+rxi_SplitJumboPacket(register struct rx_packet *p, afs_int32 host, short port,
+ int first)
{
struct rx_packet *np;
struct rx_jumboHeader *jp;
#ifndef KERNEL
/* Send a udp datagram */
int
-osi_NetSend(osi_socket socket, void *addr, int addrlen, struct iovec *dvec,
- int nvecs, int length, int istack)
+osi_NetSend(osi_socket socket, void *addr, struct iovec *dvec, int nvecs,
+ int length, int istack)
{
struct msghdr msg;
int ret;
msg.msg_iov = dvec;
msg.msg_iovlen = nvecs;
msg.msg_name = addr;
- msg.msg_namelen = addrlen;
+ msg.msg_namelen = sizeof(struct sockaddr_in);
ret = rxi_Sendmsg(socket, &msg, 0);
struct rx_packet *
rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
- struct sockaddr_storage *saddr, int slen, int istack)
+ afs_int32 ahost, short aport, int istack)
{
struct rx_debugIn tin;
afs_int32 tl;
rx_packetwrite(ap, 0, sizeof(struct rx_debugStats),
(char *)&tstat);
ap->length = sizeof(struct rx_debugStats);
- rxi_SendDebugPacket(ap, asocket, saddr, slen, istack);
+ rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
rx_computelen(ap, ap->length);
}
break;
for (tc = rx_connHashTable[i]; tc; tc = tc->next) {
if ((all || rxi_IsConnInteresting(tc))
&& tin.index-- <= 0) {
- switch (rx_ssfamily(&tc->peer->saddr)) {
- case AF_INET:
- tconn.host = rx_ss2sin(&tc->peer->saddr)->sin_addr.s_addr;
- break;
- default:
-#ifdef AF_INET6
- case AF_INET6:
-#endif /* AF_INET6 */
- tconn.host = 0xffffffff;
- break;
- }
- tconn.port = rx_ss2pn(&tc->peer->saddr);
+ tconn.host = tc->peer->host;
+ tconn.port = tc->peer->port;
tconn.cid = htonl(tc->cid);
tconn.epoch = htonl(tc->epoch);
tconn.serial = htonl(tc->serial);
(char *)&tconn);
tl = ap->length;
ap->length = sizeof(struct rx_debugConn);
- rxi_SendDebugPacket(ap, asocket, saddr, slen,
+ rxi_SendDebugPacket(ap, asocket, ahost, aport,
istack);
ap->length = tl;
return ap;
(char *)&tconn);
tl = ap->length;
ap->length = sizeof(struct rx_debugConn);
- rxi_SendDebugPacket(ap, asocket, saddr, slen, istack);
+ rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
ap->length = tl;
break;
}
MUTEX_ENTER(&rx_peerHashTable_lock);
for (tp = rx_peerHashTable[i]; tp; tp = tp->next) {
if (tin.index-- <= 0) {
- switch (rx_ssfamily(&tp->saddr)) {
- case AF_INET:
- tpeer.host = rx_ss2sin(&tp->saddr)->sin_addr.s_addr;
- break;
- default:
-#ifdef AF_INET6
- case AF_INET6:
-#endif /* AF_INET6 */
- tpeer.host = 0xffffffff;
- break;
- }
- tpeer.port = rx_ss2pn(&tp->saddr);
+ tpeer.host = tp->host;
+ tpeer.port = tp->port;
tpeer.ifMTU = htons(tp->ifMTU);
tpeer.idleWhen = htonl(tp->idleWhen);
tpeer.refCount = htons(tp->refCount);
(char *)&tpeer);
tl = ap->length;
ap->length = sizeof(struct rx_debugPeer);
- rxi_SendDebugPacket(ap, asocket, saddr, slen,
+ rxi_SendDebugPacket(ap, asocket, ahost, aport,
istack);
ap->length = tl;
return ap;
(char *)&tpeer);
tl = ap->length;
ap->length = sizeof(struct rx_debugPeer);
- rxi_SendDebugPacket(ap, asocket, saddr, slen, istack);
+ rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
ap->length = tl;
break;
}
tl = ap->length;
ap->length = sizeof(rx_stats);
MUTEX_EXIT(&rx_stats_mutex);
- rxi_SendDebugPacket(ap, asocket, saddr, slen, istack);
+ rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
ap->length = tl;
break;
}
rx_packetwrite(ap, 0, sizeof(struct rx_debugIn), (char *)&tin);
tl = ap->length;
ap->length = sizeof(struct rx_debugIn);
- rxi_SendDebugPacket(ap, asocket, saddr, slen, istack);
+ rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
ap->length = tl;
break;
}
struct rx_packet *
rxi_ReceiveVersionPacket(register struct rx_packet *ap, osi_socket asocket,
- struct sockaddr_storage *saddr, int slen, int istack)
+ afs_int32 ahost, short aport, int istack)
{
afs_int32 tl;
rx_packetwrite(ap, 0, 65, buf);
tl = ap->length;
ap->length = 65;
- rxi_SendDebugPacket(ap, asocket, saddr, slen, istack);
+ rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
ap->length = tl;
}
/* send a debug packet back to the sender */
static void
rxi_SendDebugPacket(struct rx_packet *apacket, osi_socket asocket,
- struct sockaddr_storage *saddr, int slen, afs_int32 istack)
+ afs_int32 ahost, short aport, afs_int32 istack)
{
+ struct sockaddr_in taddr;
int i;
int nbytes;
int saven = 0;
int waslocked = ISAFS_GLOCK();
#endif
+ taddr.sin_family = AF_INET;
+ taddr.sin_port = aport;
+ taddr.sin_addr.s_addr = ahost;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ taddr.sin_len = sizeof(struct sockaddr_in);
+#endif
+
/* We need to trim the niovecs. */
nbytes = apacket->length;
for (i = 1; i < apacket->niovecs; i++) {
#endif
#endif
/* debug packets are not reliably delivered, hence the cast below. */
- (void)osi_NetSend(asocket, saddr, slen, apacket->wirevec, apacket->niovecs,
+ (void)osi_NetSend(asocket, &taddr, apacket->wirevec, apacket->niovecs,
apacket->length + RX_HEADER_SIZE, istack);
#ifdef KERNEL
#ifdef RX_KERNEL_TRACE
int waslocked;
#endif
int code;
+ struct sockaddr_in addr;
register struct rx_peer *peer = conn->peer;
osi_socket socket;
#ifdef RXDEBUG
char deliveryType = 'S';
#endif
+ /* The address we're sending the packet to */
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_port = peer->port;
+ addr.sin_addr.s_addr = peer->host;
+
/* This stuff should be revamped, I think, so that most, if not
* all, of the header stuff is always added here. We could
* probably do away with the encode/decode routines. XXXXX */
/* If an output tracer function is defined, call it with the packet and
* network address. Note this function may modify its arguments. */
if (rx_almostSent) {
- int drop = (*rx_almostSent) (p, &peer->saddr);
+ int drop = (*rx_almostSent) (p, &addr);
/* drop packet if return value is non-zero? */
if (drop)
deliveryType = 'D'; /* Drop the packet */
#endif
#endif
if ((code =
- osi_NetSend(socket, &peer->saddr, peer->saddrlen, p->wirevec,
- p->niovecs, p->length + RX_HEADER_SIZE,
- istack)) != 0) {
+ osi_NetSend(socket, &addr, p->wirevec, p->niovecs,
+ p->length + RX_HEADER_SIZE, istack)) != 0) {
/* send failed, so let's hurry up the resend, eh? */
MUTEX_ENTER(&rx_stats_mutex);
rx_stats.netSendFailures++;
#endif
#ifdef RXDEBUG
}
- dpf(("%c %d %s: %s.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], rx_AddrStringOf(peer), ntohs(rx_PortOf(peer)), p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (unsigned long)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
+ dpf(("%c %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], ntohl(peer->host), ntohs(peer->port), p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (unsigned long)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
#endif
MUTEX_ENTER(&rx_stats_mutex);
rx_stats.packetsSent[p->header.type - 1]++;
#if defined(AFS_SUN5_ENV) && defined(KERNEL)
int waslocked;
#endif
+ struct sockaddr_in addr;
register struct rx_peer *peer = conn->peer;
osi_socket socket;
struct rx_packet *p = NULL;
#ifdef RXDEBUG
char deliveryType = 'S';
#endif
+ /* The address we're sending the packet to */
+ addr.sin_family = AF_INET;
+ addr.sin_port = peer->port;
+ addr.sin_addr.s_addr = peer->host;
if (len + 1 > RX_MAXIOVECS) {
osi_Panic("rxi_SendPacketList, len > RX_MAXIOVECS\n");
/* If an output tracer function is defined, call it with the packet and
* network address. Note this function may modify its arguments. */
if (rx_almostSent) {
- int drop = (*rx_almostSent) (p, &peer->saddr);
+ int drop = (*rx_almostSent) (p, &addr);
/* drop packet if return value is non-zero? */
if (drop)
deliveryType = 'D'; /* Drop the packet */
AFS_GUNLOCK();
#endif
if ((code =
- osi_NetSend(socket, &peer->saddr, peer->saddrlen, &wirevec[0],
- len + 1, length, istack)) != 0) {
+ osi_NetSend(socket, &addr, &wirevec[0], len + 1, length,
+ istack)) != 0) {
/* send failed, so let's hurry up the resend, eh? */
MUTEX_ENTER(&rx_stats_mutex);
rx_stats.netSendFailures++;
assert(p != NULL);
- dpf(("%c %d %s: %s.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], rx_AddrStringOf(peer), ntohs(rx_PortOf(peer)), p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (unsigned long)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
+ dpf(("%c %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], ntohl(peer->host), ntohs(peer->port), p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (unsigned long)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
#endif
MUTEX_ENTER(&rx_stats_mutex);
extern void rx_SetEpoch(afs_uint32 epoch);
extern int rx_Init(u_int port);
extern int rx_InitHost(u_int host, u_int port);
-extern int rx_InitAddrs(struct sockaddr_storage *saddrs, int *types,
- int *salens, int nelem);
#ifdef AFS_NT40_ENV
extern void rx_DebugOnOff(int on);
#endif
register struct rx_securityClass
*securityObject,
int serviceSecurityIndex);
-extern struct rx_connection *rx_NewConnectionAddrs(struct sockaddr_storage *,
- int *types, int *salens,
- int nelem, u_short,
- struct rx_securityClass *,
- int);
extern void rx_SetConnDeadTime(register struct rx_connection *conn,
register int seconds);
extern void rxi_CleanupConnection(struct rx_connection *conn);
extern char *rxi_Alloc(register size_t size);
extern void rxi_Free(void *addr, register size_t size);
-extern struct rx_peer *rxi_FindPeer(struct sockaddr_storage *saddr, int slen,
- int stype, struct rx_peer *origPeer,
- int create);
+extern struct rx_peer *rxi_FindPeer(register afs_uint32 host,
+ register u_short port,
+ struct rx_peer *origPeer, int create);
extern struct rx_connection *rxi_FindConnection(osi_socket socket,
- struct sockaddr_storage *saddr,
- int slen, int socktype,
+ register afs_int32 host,
+ register 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,
- osi_socket socket,
- struct sockaddr_storage *saddr,
- int slen, int *tnop,
+ 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,
int istack, osi_socket socket,
- struct sockaddr_storage *saddr,
- int slen, int *tnop,
+ afs_uint32 host, u_short port,
+ int *tnop,
struct rx_call **newcallp);
extern struct rx_packet *rxi_ReceiveAckPacket(register struct rx_call *call,
struct rx_packet *np,
extern int rxk_DelPort(u_short aport);
extern void rxk_shutdownPorts(void);
extern osi_socket rxi_GetUDPSocket(u_short port);
-extern osi_socket rxi_GetHostUDPSocket(struct sockaddr_storage *saddr,
- int salen);
+extern osi_socket rxi_GetHostUDPSocket(u_int host, u_short port);
#if defined(KERNEL) && defined(AFS_LINUX26_ENV)
#define osi_Panic(msg...) do { printk(KERN_CRIT "openafs: " msg); BUG(); } while (0)
#undef osi_Assert
extern osi_socket *rxk_NewSocket(short aport);
#endif
#endif
-extern int rxk_ReadPacket(osi_socket so, struct rx_packet *p,
- struct sockaddr_storage *saddr, int *slen);
+extern int rxk_ReadPacket(osi_socket so, struct rx_packet *p, int *host,
+ int *port);
#ifdef UKERNEL
extern void rx_ServerProc(void);
#endif
/* ARCH/rx_knet.c */
#if defined(KERNEL) && !defined(AFS_SGI_ENV)
-extern int osi_NetSend(osi_socket asocket, struct sockaddr_storage *addr,
- int addrlen, struct iovec *dvec, int nvecs,
- afs_int32 asize, int istack);
+extern int osi_NetSend(osi_socket asocket, struct sockaddr_in *addr,
+ struct iovec *dvec, int nvecs, afs_int32 asize,
+ int istack);
#endif
-extern int osi_NetReceive(osi_socket so, struct sockaddr_storage *saddr,
- int *slen, struct iovec *dvec, int nvecs,
- int *lengthp);
+extern int osi_NetReceive(osi_socket so, struct sockaddr_in *addr,
+ struct iovec *dvec, int nvecs, int *lengthp);
extern void osi_StopListener(void);
extern int rxi_FindIfMTU(afs_uint32 addr);
#ifndef RXK_LISTENER_ENV
extern struct rx_packet *rxi_AllocSendPacket(register struct rx_call *call,
int want);
extern int rxi_ReadPacket(osi_socket socket, register struct rx_packet *p,
- struct sockaddr_storage *saddr, int *slen);
+ afs_uint32 * host, u_short * port);
extern struct rx_packet *rxi_SplitJumboPacket(register struct rx_packet *p,
- struct sockaddr_storage *saddr,
- int slen, int first);
+ afs_int32 host, short port,
+ int first);
#ifndef KERNEL
-extern int osi_NetSend(osi_socket socket, void *addr, int addrlen,
- struct iovec *dvec, int nvecs, int length, int istack);
+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,
osi_socket asocket,
- struct sockaddr_storage *saddr,
- int slen, int istack);
+ afs_int32 ahost, short aport,
+ int istack);
extern struct rx_packet *rxi_ReceiveVersionPacket(register struct rx_packet
*ap, osi_socket asocket,
- struct sockaddr_storage *,
- int slen, int istack);
+ afs_int32 ahost,
+ short aport, int istack);
extern void rxi_SendPacket(struct rx_call *call, struct rx_connection *conn,
struct rx_packet *p, int istack);
extern void rxi_SendPacketList(struct rx_call *call,
static void
rxi_ListenerProc(int sock, int *tnop, struct rx_call **newcallp)
{
- struct sockaddr_storage saddr;
- int slen;
+ unsigned int host;
+ u_short port;
register struct rx_packet *p = (struct rx_packet *)0;
assert(pthread_mutex_lock(&listener_mutex) == 0);
}
}
- slen = sizeof(saddr);
- if (rxi_ReadPacket(sock, p, &saddr, &slen)) {
+ if (rxi_ReadPacket(sock, p, &host, &port)) {
clock_NewTime();
- p = rxi_ReceivePacket(p, sock, &saddr, slen, tnop, newcallp);
+ p = rxi_ReceivePacket(p, sock, host, port, tnop, newcallp);
if (newcallp && *newcallp) {
if (p)
rxi_FreePacket(p);
* failure. Port must be in network byte order.
*/
osi_socket
-rxi_GetHostUDPSocket(struct sockaddr_storage *saddr, int salen)
+rxi_GetHostUDPSocket(u_int ahost, u_short port)
{
int binds, code = 0;
osi_socket socketFd = OSI_NULLSOCKET;
+ struct sockaddr_in taddr;
char *name = "rxi_GetUDPSocket: ";
#ifdef AFS_LINUX22_ENV
int pmtu=IP_PMTUDISC_DONT;
#endif
-#if 0
#if !defined(AFS_NT40_ENV)
if (ntohs(port) >= IPPORT_RESERVED && ntohs(port) < IPPORT_USERRESERVED) {
/* (osi_Msg "%s*WARNING* port number %d is not a reserved port number. Use port numbers above %d\n", name, port, IPPORT_USERRESERVED);
goto error;
}
#endif
-#endif
- socketFd = socket(rx_ssfamily(saddr), SOCK_DGRAM, 0);
+ socketFd = socket(AF_INET, SOCK_DGRAM, 0);
if (socketFd < 0) {
perror("socket");
goto error;
}
+ taddr.sin_addr.s_addr = ahost;
+ taddr.sin_family = AF_INET;
+ taddr.sin_port = (u_short) port;
+#ifdef STRUCT_SOCKADDR_HAS_SA_LEN
+ taddr.sin_len = sizeof(struct sockaddr_in);
+#endif
#define MAX_RX_BINDS 10
for (binds = 0; binds < MAX_RX_BINDS; binds++) {
if (binds)
rxi_Delay(10);
- code = bind(socketFd, (struct sockaddr *) saddr, salen);
+ code = bind(socketFd, (struct sockaddr *)&taddr, sizeof(taddr));
if (!code)
break;
}
osi_socket
rxi_GetUDPSocket(u_short port)
{
- struct sockaddr_storage saddr;
- struct sockaddr_in *sin = (struct sockaddr_in *) &saddr;
-
- memset((void *) &saddr, 0, sizeof(saddr));
-
- sin->sin_family = AF_INET;
- sin->sin_addr.s_addr = htonl(INADDR_ANY);
- sin->sin_port = port;
-
- return rxi_GetHostUDPSocket(&saddr, sizeof(struct sockaddr_in));
+ return rxi_GetHostUDPSocket(htonl(INADDR_ANY), port);
}
void
rxi_InitPeerParams(struct rx_peer *pp)
{
afs_uint32 ppaddr;
- u_short rxmtu, maxmtu = 0;
+ u_short rxmtu;
int ix;
LOCK_IF_INIT;
#ifdef ADAPT_MTU
/* try to second-guess IP, and identify which link is most likely to
* be used for traffic to/from this host. */
- switch (rx_ssfamily(&pp->saddr)) {
- case AF_INET:
- ppaddr = ntohl(((struct sockaddr_in * ) &pp->saddr)->sin_addr.s_addr);
-
- pp->ifMTU = 0;
- pp->timeout.sec = 2;
- pp->rateFlag = 2; /* start timing after two full packets */
- /* I don't initialize these, because I presume they are bzero'd...
- * pp->burstSize pp->burst pp->burstWait.sec pp->burstWait.usec
- * pp->timeout.usec */
-
- LOCK_IF;
- for (ix = 0; ix < rxi_numNetAddrs; ++ix) {
- if (maxmtu < myNetMTUs[ix])
- maxmtu = myNetMTUs[ix] - RX_IPUDP_SIZE;
- if ((rxi_NetAddrs[ix] & myNetMasks[ix]) ==
- (ppaddr & myNetMasks[ix])) {
+ ppaddr = ntohl(pp->host);
+
+ pp->ifMTU = 0;
+ pp->timeout.sec = 2;
+ pp->rateFlag = 2; /* start timing after two full packets */
+ /* I don't initialize these, because I presume they are bzero'd...
+ * pp->burstSize pp->burst pp->burstWait.sec pp->burstWait.usec
+ * pp->timeout.usec */
+
+ LOCK_IF;
+ for (ix = 0; ix < rxi_numNetAddrs; ++ix) {
+ if ((rxi_NetAddrs[ix] & myNetMasks[ix]) == (ppaddr & myNetMasks[ix])) {
#ifdef IFF_POINTOPOINT
- if (myNetFlags[ix] & IFF_POINTOPOINT)
- pp->timeout.sec = 4;
+ if (myNetFlags[ix] & IFF_POINTOPOINT)
+ pp->timeout.sec = 4;
#endif /* IFF_POINTOPOINT */
- rxmtu = myNetMTUs[ix] - RX_IPUDP_SIZE;
- if (rxmtu < RX_MIN_PACKET_SIZE)
- rxmtu = RX_MIN_PACKET_SIZE;
- }
- }
- UNLOCK_IF;
- if (rxmtu)
- pp->ifMTU = MIN(rx_MyMaxSendSize, rxmtu);
- if (!pp->ifMTU) { /* not local */
- pp->timeout.sec = 3;
- pp->ifMTU = MIN(rx_MyMaxSendSize, maxmtu ? maxmtu : RX_REMOTE_PACKET_SIZE);
+ rxmtu = myNetMTUs[ix] - RX_IPUDP_SIZE;
+ if (rxmtu < RX_MIN_PACKET_SIZE)
+ rxmtu = RX_MIN_PACKET_SIZE;
+ if (pp->ifMTU < rxmtu)
+ pp->ifMTU = MIN(rx_MyMaxSendSize, rxmtu);
}
- break;
-#ifdef AF_INET6
- case AF_INET6:
-#endif
- default:
- pp->rateFlag = 2; /* start timing after two full packets */
- pp->timeout.sec = 2;
- pp->ifMTU = MIN(rx_MyMaxSendSize, OLD_MAX_PACKET_SIZE);
- break;
+ }
+ UNLOCK_IF;
+ if (!pp->ifMTU) { /* not local */
+ pp->timeout.sec = 3;
+ pp->ifMTU = MIN(rx_MyMaxSendSize, RX_REMOTE_PACKET_SIZE);
}
#else /* ADAPT_MTU */
pp->rateFlag = 2; /* start timing after two full packets */
if (BreakDelayedCallBacks_r(thost)) {
ViceLog(0,
("BreakDelayedCallbacks FAILED for host %s:%d which IS UP. Connection from %s:%d. Possible network or routing failure.\n",
- afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), rxr_AddrStringOf(*tconn),
+ afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), afs_inet_ntoa_r(rxr_HostOf(*tconn), hoststr2),
ntohs(rxr_PortOf(*tconn))));
if (MultiProbeAlternateAddress_r(thost)) {
ViceLog(0,
if (BreakDelayedCallBacks_r(thost)) {
ViceLog(0,
("BreakDelayedCallbacks FAILED AGAIN for host %s:%d which IS UP. Connection from %s:%d. Possible network or routing failure.\n",
- afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), rxr_AddrStringOf(*tconn),
+ afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), afs_inet_ntoa_r(rxr_HostOf(*tconn), hoststr2),
ntohs(rxr_PortOf(*tconn))));
code = -1;
}
struct host *thost;
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
#if FS_STATS_DETAILED
struct fs_stats_opTimingData *opP; /* Ptr to this op's timing struct */
struct fs_stats_xferData *xferP; /* Ptr to this op's byte size struct */
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(5,
("SRXAFS_FetchData, Fid = %u.%u.%u, Host %s:%d, Id %d\n",
- Fid->Volume, Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Volume, Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
/*
* Get volume/vnode for the fetched file; caller's access rights to
struct rx_connection *tcon = rx_ConnectionOf(acall);
struct host *thost;
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
#if FS_STATS_DETAILED
struct fs_stats_opTimingData *opP; /* Ptr to this op's timing struct */
struct timeval opStartTime, opStopTime; /* Start/stop times for RPC op */
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(5,
("SAFS_FetchACL, Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
- Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
AccessList->AFSOpaque_len = 0;
struct client *client = 0; /* pointer to the client data */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_FetchStatus, Fid = %u.%u.%u, Host %s:%d, Id %d\n",
- Fid->Volume, Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Volume, Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.FetchStatus++, AFSCallStats.TotalCalls++;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon;
struct host *thost;
#if FS_STATS_DETAILED
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(5,
("StoreData: Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
- Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
/*
struct rx_connection *tcon;
struct host *thost;
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
#if FS_STATS_DETAILED
struct fs_stats_opTimingData *opP; /* Ptr to this op's timing struct */
struct timeval opStartTime, opStopTime; /* Start/stop times for RPC op */
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_StoreACL, Fid = %u.%u.%u, ACL=%s, Host %s:%d, Id %d\n",
Fid->Volume, Fid->Vnode, Fid->Unique, AccessList->AFSOpaque_val,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.StoreACL++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client = NULL; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_StoreStatus, Fid = %u.%u.%u, Host %s:%d, Id %d\n",
- Fid->Volume, Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Volume, Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.StoreStatus++, AFSCallStats.TotalCalls++;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_RemoveFile %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.RemoveFile++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_CreateFile %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.CreateFile++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
int doDelete; /* deleted the rename target (ref count now 0) */
int code;
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&olddir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_Rename %s to %s, Fid = %u.%u.%u to %u.%u.%u, Host %s:%d, Id %d\n",
OldName, NewName, OldDirFid->Volume, OldDirFid->Vnode,
OldDirFid->Unique, NewDirFid->Volume, NewDirFid->Vnode,
- NewDirFid->Unique, rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ NewDirFid->Unique, inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.Rename++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
FdHandle_t *fdP;
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_Symlink %s to %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
LinkContents, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.Symlink++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_Link %s, Did = %u.%u.%u, Fid = %u.%u.%u, Host %s:%d, Id %d\n",
Name, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
ExistingFid->Volume, ExistingFid->Vnode, ExistingFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.Link++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_MakeDir %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.MakeDir++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
afs_int32 rights, anyrights; /* rights for this and any user */
Vnode debugvnode1, debugvnode2;
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
FidZero(&dir);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_RemoveDir %s, Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
DirFid->Volume, DirFid->Vnode, DirFid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.RemoveDir++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
static char *locktype[4] = { "LockRead", "LockWrite", "LockExtend", "LockRelease" };
struct rx_connection *tcon = rx_ConnectionOf(acall);
}
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_SetLock type = %s Fid = %u.%u.%u, Host %s:%d, Id %d\n",
locktype[(int)type], Fid->Volume, Fid->Vnode, Fid->Unique,
- rxr_AddrStringOf(tcon), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.SetLock++, AFSCallStats.TotalCalls++;
FS_UNLOCK;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_ExtendLock Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
- Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.ExtendLock++, AFSCallStats.TotalCalls++;
struct client *client = 0; /* pointer to client structure */
afs_int32 rights, anyrights; /* rights for this and any user */
struct client *t_client; /* tmp ptr to client data */
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
struct rx_connection *tcon = rx_ConnectionOf(acall);
/* Get ptr to client data for user Id for logging */
t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
+ logHostAddr.s_addr = rxr_HostOf(tcon);
ViceLog(1,
("SAFS_ReleaseLock Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
- Fid->Vnode, Fid->Unique, rxr_AddrStringOf(tcon),
+ Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
ntohs(rxr_PortOf(tcon)), t_client->ViceId));
FS_LOCK;
AFSCallStats.ReleaseLock++, AFSCallStats.TotalCalls++;
if (!FidArray && !CallBackArray) {
ViceLog(1,
- ("SAFS_GiveUpAllCallBacks: host=%s\n",
- (tcon->peer ? rx_AddrStringOf(tcon->peer) : "<unknown>")));
+ ("SAFS_GiveUpAllCallBacks: host=%x\n",
+ (tcon->peer ? tcon->peer->host : 0)));
errorCode = GetClient(tcon, &client);
if (!errorCode) {
DeleteAllCallBacks_r(client->host, 1);
} else {
if (FidArray->AFSCBFids_len < CallBackArray->AFSCBs_len) {
ViceLog(0,
- ("GiveUpCallBacks: #Fids %d < #CallBacks %d, host=%s\n",
+ ("GiveUpCallBacks: #Fids %d < #CallBacks %d, host=%x\n",
FidArray->AFSCBFids_len, CallBackArray->AFSCBs_len,
- (tcon->peer ? rx_AddrStringOf(tcon->peer) : "<unknown>")));
+ (tcon->peer ? tcon->peer->host : 0)));
errorCode = EINVAL;
goto Bad_GiveUpCallBacks;
}
afs_sfsize_t adjustSize; /* bytes to call VAdjust... with */
int linkCount; /* link count on inode */
FdHandle_t *fdP;
+ struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
#if FS_STATS_DETAILED
/*
if (Pos == -1 || VN_GET_INO(targetptr) == 0) {
/* the inode should have been created in Alloc_NewVnode */
+ logHostAddr.s_addr = rxr_HostOf(rx_ConnectionOf(Call));
ViceLog(0,
("StoreData_RXStyle : Inode non-existent Fid = %u.%u.%u, inode = %llu, Pos %llu Host %s:%d\n",
Fid->Volume, Fid->Vnode, Fid->Unique,
(afs_uintmax_t) VN_GET_INO(targetptr), (afs_uintmax_t) Pos,
- rxr_AddrStringOf(rx_ConnectionOf(Call)),
- ntohs(rxr_PortOf(rx_ConnectionOf(Call)))));
+ inet_ntoa(logHostAddr), ntohs(rxr_PortOf(rx_ConnectionOf(Call)))));
return ENOENT; /* is this proper error code? */
} else {
/*
if (created) {
ViceLog(0, ("FindClient: stillborn client %x(%x); conn %x (host %s:%d) had client %x(%x)\n",
client, client->sid, tcon,
- rxr_AddrStringOf(tcon),
+ afs_inet_ntoa_r(rxr_HostOf(tcon), hoststr),
ntohs(rxr_PortOf(tcon)),
oldClient, oldClient->sid));
if ((client->ViceId != ANONYMOUSID) && client->CPS.prlist_val)
} else {
ViceLog(0, ("FindClient: deleted client %x(%x) already had conn %x (host %s:%d), stolen by client %x(%x)\n",
oldClient, oldClient->sid, tcon,
- rxr_AddrStringOf(tcon),
+ afs_inet_ntoa_r(rxr_HostOf(tcon), hoststr),
ntohs(rxr_PortOf(tcon)),
client, client->sid));
/* rx_SetSpecific will be done immediately below */
client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
if (client == NULL) {
ViceLog(0,
- ("GetClient: no client in conn %x (host %s:%d), VBUSYING\n",
- tcon, rxr_AddrStringOf(tcon),ntohs(rxr_PortOf(tcon))));
+ ("GetClient: no client in conn %x (host %x:%d), VBUSYING\n",
+ tcon, rxr_HostOf(tcon),ntohs(rxr_PortOf(tcon))));
H_UNLOCK;
return VBUSY;
}
#define rxr_HostOf(aconn) \
rx_HostOf(rx_PeerOf((struct rx_connection *)(aconn)))
-#define rxr_AddrStringOf(aconn) \
- rx_AddrStringOf(rx_PeerOf((struct rx_connection *)(aconn)))
-
#define HCPS_INPROGRESS 0x01 /*set when CPS is being updated */
#define HCPS_WAITING 0x02 /*waiting for CPS to get updated */
#define ALTADDR 0x04 /*InitCallBack is being done */
git://git.openafs.org / openafs.git / commitdiff