#ifdef AFS_HPUX110_ENV
#include "../h/tihdr.h"
#include <xti.h>
-#include "../afs/hpux_110.h"
#endif
#include "../afsint/afsint.h"
-afs_int32 rxi_Findcbi();
-extern struct interfaceAddr afs_cb_interface;
+#ifdef AFS_DARWIN60_ENV
+struct ifnet *rxi_FindIfnet(afs_uint32 addr, struct ifaddr **pifad);
+#else
+struct ifnet *rxi_FindIfnet(afs_uint32 addr, struct in_ifaddr **pifad);
+#endif
#ifndef RXK_LISTENER_ENV
-int (*rxk_GetPacketProc)(); /* set to packet allocation procedure */
-int (*rxk_PacketArrivalProc)();
+int (*rxk_PacketArrivalProc)(register struct rx_packet *ahandle,
+ register struct sockaddr_in *afrom, char *arock,
+ afs_int32 asize); /* set to packet allocation procedure */
+int (*rxk_GetPacketProc)(char **ahandle, int asize);
#endif
+extern struct interfaceAddr afs_cb_interface;
+
rxk_ports_t rxk_ports;
rxk_portRocks_t rxk_portRocks;
}
/* remove as port from the monitored list, port # is in network order */
-rxk_DelPort(aport)
-u_short aport; {
+int rxk_DelPort(u_short aport)
+{
register int i;
register unsigned short *tsp;
#if ! defined(AFS_SUN5_ENV) && ! defined(UKERNEL) && ! defined(RXK_LISTENER_ENV)
soclose((struct socket *)rxk_portRocks[i]);
#endif
- rxk_portRocks[i] = (char *)0;
+ rxk_portRocks[i] = NULL;
}
}
}
-osi_socket rxi_GetUDPSocket(port)
- u_short port;
+osi_socket rxi_GetUDPSocket(u_short port)
{
struct osi_socket *sockp;
sockp = (struct osi_socket *) rxk_NewSocket(port);
* defined only on success.
*/
-int
-osi_utoa(char *buf, size_t len, unsigned long val)
+int osi_utoa(char *buf, size_t len, unsigned long val)
{
long k; /* index of first byte of string value */
* argument to the native panic(), we construct a single string and hand
* that to osi_Panic().
*/
-void
-osi_AssertFailK(const char *expr, const char *file, int line)
+void osi_AssertFailK(const char *expr, const char *file, int line)
{
static const char msg0[] = "assertion failed: ";
static const char msg1[] = ", file: ";
#ifndef UKERNEL
/* This is the server process request loop. Kernel server
* processes never become listener threads */
-void rx_ServerProc()
+void rx_ServerProc(void)
{
int threadID;
#endif /* !UKERNEL */
#ifndef RXK_LISTENER_ENV
-static int MyPacketProc(ahandle, asize)
-int asize; /* this includes the Rx header */
-char **ahandle;
+/* asize includes the Rx header */
+static int MyPacketProc(char **ahandle, int asize)
{
register struct rx_packet *tp;
return 0;
}
-static int MyArrivalProc(ahandle, afrom, arock, asize)
-register struct rx_packet *ahandle;
-register struct sockaddr_in *afrom;
-char *arock;
-afs_int32 asize; {
+static int MyArrivalProc(register struct rx_packet *ahandle,
+ register struct sockaddr_in *afrom, char *arock,
+ afs_int32 asize)
+{
/* handle basic rx packet */
ahandle->length = asize - RX_HEADER_SIZE;
rxi_DecodePacketHeader(ahandle);
}
#endif /* !RXK_LISTENER_ENV */
-void
-rxi_StartListener() {
+void rxi_StartListener(void)
+{
/* if kernel, give name of appropriate procedures */
#ifndef RXK_LISTENER_ENV
rxk_GetPacketProc = MyPacketProc;
/* Called from rxi_FindPeer, when initializing a clear rx_peer structure,
to get interesting information. */
-void rxi_InitPeerParams(pp)
-register struct rx_peer *pp;
+void rxi_InitPeerParams(register struct rx_peer *pp)
{
#ifdef ADAPT_MTU
u_short rxmtu;
afs_int32 i, mtu;
+#ifndef AFS_SUN5_ENV
#ifdef AFS_USERSPACE_IP_ADDR
i = rxi_Findcbi(pp->host);
if (i == -1) {
pp->ifMTU = RX_REMOTE_PACKET_SIZE;
}
#else /* AFS_USERSPACE_IP_ADDR */
+#ifdef AFS_DARWIN60_ENV
+ struct ifaddr *ifad = (struct ifaddr *) 0;
+#else
struct in_ifaddr *ifad = (struct in_ifaddr *) 0;
+#endif
struct ifnet *ifn;
/* At some time we need to iterate through rxi_FindIfnet() to find the
pp->ifMTU = RX_REMOTE_PACKET_SIZE;
}
#endif/* else AFS_USERSPACE_IP_ADDR */
+#else /* AFS_SUN5_ENV */
+ mtu = rxi_FindIfMTU(pp->host);
+
+ if (mtu <= 0) {
+ pp->timeout.sec = 3;
+ /* pp->timeout.usec = 0; */
+ pp->ifMTU = RX_REMOTE_PACKET_SIZE;
+ } else {
+ pp->timeout.sec = 2;
+ /* pp->timeout.usec = 0; */
+ pp->ifMTU = MIN(RX_MAX_PACKET_SIZE, rx_MyMaxSendSize);
+ }
+
+ if (mtu > 0) {
+ /* Diminish the packet size to one based on the MTU given by
+ * the interface. */
+ if (mtu > (RX_IPUDP_SIZE + RX_HEADER_SIZE)) {
+ rxmtu = mtu - RX_IPUDP_SIZE;
+ if (rxmtu < pp->ifMTU) pp->ifMTU = rxmtu;
+ }
+ } else { /* couldn't find the interface, so assume the worst */
+ pp->ifMTU = RX_REMOTE_PACKET_SIZE;
+ }
+#endif /* AFS_SUN5_ENV */
#else /* ADAPT_MTU */
pp->rateFlag = 2; /* start timing after two full packets */
pp->timeout.sec = 2;
*/
-#if ! defined(AFS_AIX_ENV) && ! defined(AFS_SUN5_ENV) && ! defined(UKERNEL) && ! defined(AFS_LINUX20_ENV) && !defined (AFS_DARWIN_ENV) && !defined (AFS_FBSD_ENV)
+#if ! defined(AFS_AIX_ENV) && ! defined(AFS_SUN5_ENV) && ! defined(UKERNEL) && ! defined(AFS_LINUX20_ENV) && !defined (AFS_DARWIN_ENV) && !defined (AFS_XBSD_ENV)
/* Routine called during the afsd "-shutdown" process to put things back to
* the initial state.
*/
for (tpro = inetdomain.dom_protosw; tpro < last; tpro++)
if (tpro->pr_protocol == IPPROTO_UDP) {
/* restore original udp protocol switch */
- bcopy((void *)&parent_proto, (void *)tpro, sizeof(parent_proto));
- bzero((void *)&parent_proto, sizeof(parent_proto));
+ memcpy((void *)tpro, (void *)&parent_proto, sizeof(parent_proto));
+ memset((void *)&parent_proto, 0, sizeof(parent_proto));
rxk_initDone = 0;
rxk_shutdownPorts();
return;
#define ADDRSPERSITE 16
static afs_uint32 myNetAddrs[ADDRSPERSITE];
static int myNetMTUs[ADDRSPERSITE];
-static int myNetFlags[ADDRSPERSITE];
static int numMyNetAddrs = 0;
#ifdef AFS_USERSPACE_IP_ADDR
-int rxi_GetcbiInfo()
+int rxi_GetcbiInfo(void)
{
int i, j, different = 0;
int rxmtu, maxmtu;
afs_uint32 addrs[ADDRSPERSITE];
int mtus[ADDRSPERSITE];
- bzero((void *)addrs, sizeof(addrs));
- bzero((void *)mtus, sizeof(mtus));
+ memset((void *)addrs, 0, sizeof(addrs));
+ memset((void *)mtus, 0, sizeof(mtus));
for (i=0; i<afs_cb_interface.numberOfInterfaces; i++) {
rxmtu = (ntohl(afs_cb_interface.mtu[i]) - RX_IPUDP_SIZE);
/* Returns the afs_cb_interface inxex which best matches address.
* If none is found, we return -1.
*/
-afs_int32 rxi_Findcbi(addr)
- afs_uint32 addr;
+afs_int32 rxi_Findcbi(afs_uint32 addr)
{
int j;
afs_uint32 myAddr, thisAddr, netMask, subnetMask;
}
}
- done:
return(rvalue);
}
#else /* AFS_USERSPACE_IP_ADDR */
-#if !defined(AFS_AIX41_ENV) && !defined(AFS_DUX40_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
+#if !defined(AFS_AIX41_ENV) && !defined(AFS_DUX40_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
#define IFADDR2SA(f) (&((f)->ifa_addr))
#else /* AFS_AIX41_ENV */
#define IFADDR2SA(f) ((f)->ifa_addr)
#endif
-int rxi_GetIFInfo()
+int rxi_GetIFInfo(void)
{
int i = 0;
int different = 0;
struct ifaddr *ifad; /* ifnet points to a if_addrlist of ifaddrs */
afs_uint32 ifinaddr;
- bzero(addrs, sizeof(addrs));
- bzero(mtus, sizeof(mtus));
+ memset(addrs, 0, sizeof(addrs));
+ memset(mtus, 0, sizeof(mtus));
#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
TAILQ_FOREACH(ifn, &ifnet, if_link) {
if (i >= ADDRSPERSITE) break;
-#else
+#else
+#if defined(AFS_OBSD_ENV)
+ for (ifn = ifnet.tqh_first; i < ADDRSPERSITE && ifn != NULL; ifn = ifn->if_list.tqe_next) {
+#else
for (ifn = ifnet; ifn != NULL && i < ADDRSPERSITE; ifn = ifn->if_next) {
#endif
+#endif
rxmtu = (ifn->if_mtu - RX_IPUDP_SIZE);
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
TAILQ_FOREACH(ifad, &ifn->if_addrhead, ifa_link) {
if (i >= ADDRSPERSITE) break;
#else
}
return different;
}
-
+#ifdef AFS_DARWIN60_ENV
/* Returns ifnet which best matches address */
struct ifnet *
rxi_FindIfnet(addr, pifad)
afs_uint32 addr;
- struct in_ifaddr **pifad;
+ struct ifaddr **pifad;
+{
+ struct sockaddr_in s;
+
+ if (numMyNetAddrs == 0)
+ (void) rxi_GetIFInfo();
+
+ s.sin_family=AF_INET;
+ s.sin_addr.s_addr=addr;
+ *pifad=ifa_ifwithnet((struct sockaddr *)&s);
+ done:
+ return (*pifad ? (*pifad)->ifa_ifp : NULL );
+}
+#else
+/* Returns ifnet which best matches address */
+struct ifnet *rxi_FindIfnet(afs_uint32 addr, struct in_ifaddr **pifad)
{
afs_uint32 ppaddr;
int match_value = 0;
/* if we're given an address, skip everything until we find it */
if (!*pifad)
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
*pifad = TAILQ_FIRST(&in_ifaddrhead);
#else
*pifad = in_ifaddr;
else {
if (((ppaddr & (*pifad)->ia_subnetmask) == (*pifad)->ia_subnet))
match_value = 2; /* don't find matching nets, just subnets */
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
*pifad = TAILQ_NEXT(*pifad, ia_link);
#else
*pifad = (*pifad)->ia_next;
#endif
}
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
for (ifa = *pifad; ifa; ifa = TAILQ_NEXT(ifa, ia_link) ) {
#else
for (ifa = *pifad; ifa; ifa = ifa->ia_next ) {
done:
return (*pifad ? (*pifad)->ia_ifp : NULL );
}
+#endif
#endif /* else AFS_USERSPACE_IP_ADDR */
#endif /* !SUN5 && !SGI62 */
#endif
AFS_STATCNT(osi_NewSocket);
-#if (defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)) && defined(KERNEL_FUNNEL)
+#if (defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)) && defined(KERNEL_FUNNEL)
thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
#endif
#if defined(AFS_HPUX102_ENV)
#else
#ifdef AFS_SGI65_ENV
code = socreate(AF_INET, &newSocket, SOCK_DGRAM,IPPROTO_UDP);
-#elif defined(AFS_FBSD_ENV)
+#elif defined(AFS_XBSD_ENV)
code = socreate(AF_INET, &newSocket, SOCK_DGRAM,IPPROTO_UDP, curproc);
#else
code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0);
myaddr.sin_family = AF_INET;
myaddr.sin_port = aport;
myaddr.sin_addr.s_addr = 0;
+#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);
setuerror(ENOBUFS);
goto bad;
}
- bcopy((caddr_t)&myaddr, (caddr_t)bindnam->b_rptr+SO_MSGOFFSET, addrsize);
+ memcpy((caddr_t)bindnam->b_rptr+SO_MSGOFFSET, (caddr_t)&myaddr, addrsize);
bindnam->b_wptr = bindnam->b_rptr + (addrsize+SO_MSGOFFSET+1);
code = sobind(newSocket, bindnam, addrsize);
if (code)
osi_Panic("osi_NewSocket: last attempt to reserve 32K failed!\n");
}
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
- myaddr.sin_len = sizeof(myaddr);
-#if defined(AFS_FBSD_ENV)
+#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
+#if defined(AFS_XBSD_ENV)
code = sobind(newSocket, (struct sockaddr *)&myaddr, curproc);
#else
code = sobind(newSocket, (struct sockaddr *)&myaddr);
nam = m_get(M_WAIT, MT_SONAME);
#endif
if (nam == NULL) {
-#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_FBSD_ENV)
+#if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_XBSD_ENV)
setuerror(ENOBUFS);
#endif
goto bad;
#ifdef AFS_OSF_ENV
myaddr.sin_len = nam->m_len;
#endif /* AFS_OSF_ENV */
- bcopy(&myaddr, mtod(nam, caddr_t), sizeof(myaddr));
+ memcpy(mtod(nam, caddr_t), &myaddr, sizeof(myaddr));
#ifdef AFS_SGI65_ENV
BHV_PDATA(&bhv) = (void*)newSocket;
code = sobind(&bhv, nam);
m_freem(nam);
-#elif defined(AFS_FBSD_ENV)
+#elif defined(AFS_XBSD_ENV)
code = sobind(newSocket, nam, curproc);
#else
code = sobind(newSocket, nam);
/* free socket allocated by rxk_NewSocket */
-int rxk_FreeSocket(asocket)
- register struct socket *asocket;
+int rxk_FreeSocket(register struct socket *asocket)
{
AFS_STATCNT(osi_FreeSocket);
#if defined(AFS_DARWIN_ENV) && defined(KERNEL_FUNNEL)
/*
* Run RX event daemon every second (5 times faster than rest of systems)
*/
-afs_rxevent_daemon()
+void afs_rxevent_daemon(void)
{
- int s, code;
struct clock temp;
SPLVAR;
#ifdef RX_ENABLE_LOCKS
AFS_GLOCK();
#endif /* RX_ENABLE_LOCKS */
- afs_osi_Wait(500, (char *)0, 0);
+#ifdef RX_KERNEL_TRACE
+ afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+ ICL_TYPE_STRING, "before afs_osi_Wait()");
+#endif
+ afs_osi_Wait(500, NULL, 0);
+#ifdef RX_KERNEL_TRACE
+ afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+ ICL_TYPE_STRING, "after afs_osi_Wait()");
+#endif
if (afs_termState == AFSOP_STOP_RXEVENT )
{
#ifdef RXK_LISTENER_ENV
#else
afs_termState = AFSOP_STOP_COMPLETE;
#endif
- afs_osi_Wakeup(&afs_termState);
+ osi_rxWakeup(&afs_termState);
return;
}
}
p->wirevec[p->niovecs-1].iov_len = savelen + RX_EXTRABUFFERSIZE;
nbytes = tlen + sizeof(afs_int32);
+#ifdef RX_KERNEL_TRACE
+ AFS_GLOCK();
+ afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+ ICL_TYPE_STRING, "before osi_NetRecive()");
+ AFS_GUNLOCK();
+#endif
code = osi_NetReceive(rx_socket, &from, p->wirevec, p->niovecs,
&nbytes);
+#ifdef RX_KERNEL_TRACE
+ AFS_GLOCK();
+ afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP,
+ ICL_TYPE_STRING, "after osi_NetRecive()");
+ AFS_GUNLOCK();
+#endif
/* restore the vec to its correct state */
p->wirevec[p->niovecs-1].iov_len = savelen;
#ifdef AFS_SUN5_ENV
/*
- * Run the listener as a kernel process.
+ * Run the listener as a kernel thread.
*/
void rxk_Listener(void)
{
extern id_t syscid;
void rxk_ListenerProc(void);
- if (newproc(rxk_ListenerProc, syscid, 59))
- osi_Panic("rxk_Listener: failed to fork listener process!\n");
+ if (thread_create(NULL, DEFAULTSTKSZ, rxk_ListenerProc,
+ 0, 0, &p0, TS_RUN, minclsyspri) == NULL)
+ osi_Panic("rxk_Listener: failed to start listener thread!\n");
}
void rxk_ListenerProc(void)
rxk_ListenerPid = current->pid;
#endif
#ifdef AFS_SUN5_ENV
- rxk_ListenerPid = ttoproc(curthread)->p_pidp->pid_id;
+ rxk_ListenerPid = 1; /* No PID, just a flag that we're alive */
#endif /* AFS_SUN5_ENV */
-#if defined(AFS_DARWIN_ENV) || defined(AFS_FBSD_ENV)
+#ifdef AFS_XBSD_ENV
+ rxk_ListenerPid = curproc->p_pid;
+#endif /* AFS_FBSD_ENV */
+#if defined(AFS_DARWIN_ENV)
rxk_ListenerPid = current_proc()->p_pid;
#endif
#if defined(RX_ENABLE_LOCKS) && !defined(AFS_SUN5_ENV)
}
if (!(code = rxk_ReadPacket(rx_socket, rxp, &host, &port))) {
AFS_RXGLOCK();
- rxp = rxi_ReceivePacket(rxp, rx_socket, host, port);
+ rxp = rxi_ReceivePacket(rxp, rx_socket, host, port, 0, 0);
AFS_RXGUNLOCK();
}
- if (afs_termState == AFSOP_STOP_RXK_LISTENER)
- break;
-
}
#ifdef RX_ENABLE_LOCKS
#endif /* RX_ENABLE_LOCKS */
if (afs_termState == AFSOP_STOP_RXK_LISTENER) {
afs_termState = AFSOP_STOP_COMPLETE;
- afs_osi_Wakeup(&afs_termState);
+ osi_rxWakeup(&afs_termState);
}
rxk_ListenerPid = 0;
-#ifdef AFS_LINUX24_ENV
- afs_osi_Wakeup(&rxk_ListenerPid);
+#if defined(AFS_LINUX22_ENV) || defined(AFS_SUN5_ENV)
+ osi_rxWakeup(&rxk_ListenerPid);
#endif
#ifdef AFS_SUN5_ENV
AFS_GUNLOCK();
#endif /* AFS_SUN5_ENV */
}
-#if !defined(AFS_LINUX20_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
+#if !defined(AFS_LINUX20_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
/* The manner of stopping the rx listener thread may vary. Most unix's should
* be able to call soclose.
*/
git://git.openafs.org / openafs.git / blobdiff