src/rx/rx_kcommon.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * rx_kcommon.c - Common kernel RX code for all system types.
  12  */
  13
  14 #include <afsconfig.h>
  15 #include "../afs/param.h"
  16
  17 RCSID("$Header$");
  18
  19 #include "../rx/rx_kcommon.h"
  20
  21 #ifdef AFS_HPUX110_ENV
  22 #include "../h/tihdr.h"
  23 #include <xti.h>
  24 #endif
  25 #include "../afsint/afsint.h"
  26
  27 #ifdef AFS_DARWIN60_ENV
  28 struct ifnet *rxi_FindIfnet(afs_uint32 addr, struct ifaddr **pifad);
  29 #else
  30 struct ifnet *rxi_FindIfnet(afs_uint32 addr, struct in_ifaddr **pifad);
  31 #endif
  32
  33 #ifndef RXK_LISTENER_ENV
  34 int (*rxk_PacketArrivalProc)(register struct rx_packet *ahandle,
  35         register struct sockaddr_in *afrom, char *arock,
  36         afs_int32 asize); /* set to packet allocation procedure */
  37 int (*rxk_GetPacketProc)(char **ahandle, int asize);
  38 #endif
  39
  40 extern  struct interfaceAddr afs_cb_interface;
  41
  42 rxk_ports_t rxk_ports;
  43 rxk_portRocks_t rxk_portRocks;
  44
  45 int rxk_initDone=0;
  46
  47 /* add a port to the monitored list, port # is in network order */
  48 static int rxk_AddPort(u_short aport, char * arock)
  49 {
  50     int i;
  51     unsigned short *tsp, ts;
  52     int zslot;
  53
  54     zslot = -1;     /* look for an empty slot simultaneously */
  55     for(i=0,tsp=rxk_ports;i<MAXRXPORTS;i++,tsp++) {
  56         if (((ts = *tsp) == 0) && (zslot == -1))
  57             zslot = i;
  58         if (ts == aport) {
  59             return 0;
  60         }
  61     }
  62     /* otherwise allocate a new port slot */
  63     if (zslot < 0) return E2BIG; /* all full */
  64     rxk_ports[zslot] = aport;
  65     rxk_portRocks[zslot] = arock;
  66     return 0;
  67 }
  68
  69 /* remove as port from the monitored list, port # is in network order */
  70 int rxk_DelPort(u_short aport)
  71 {
  72     register int i;
  73     register unsigned short *tsp;
  74
  75     for(i=0,tsp=rxk_ports;i<MAXRXPORTS;i++,tsp++) {
  76         if (*tsp == aport) {
  77             /* found it, adjust ref count and free the port reference if all gone */
  78             *tsp = 0;
  79             return 0;
  80         }
  81     }
  82     /* otherwise port not found */
  83     return ENOENT;
  84 }
  85
  86 void rxk_shutdownPorts(void)
  87 {
  88     int i;
  89     for (i=0; i<MAXRXPORTS;i++) {
  90         if (rxk_ports[i]) {
  91             rxk_ports[i] = 0;
  92 #if ! defined(AFS_SUN5_ENV) && ! defined(UKERNEL) && ! defined(RXK_LISTENER_ENV)
  93             soclose((struct socket *)rxk_portRocks[i]);
  94 #endif
  95             rxk_portRocks[i] = NULL;
  96         }
  97     }
  98 }
  99
 100 osi_socket rxi_GetUDPSocket(u_short port)
 101 {
 102     struct osi_socket *sockp;
 103     sockp = (struct osi_socket *) rxk_NewSocket(port);
 104     if (sockp == (struct osi_socket *) 0) return OSI_NULLSOCKET;
 105     rxk_AddPort(port, (char *) sockp);
 106     return (osi_socket)sockp;
 107 }
 108
 109
 110 void osi_Panic(msg, a1, a2, a3)
 111 char *msg;
 112 {
 113     if (!msg)
 114         msg = "Unknown AFS panic";
 115
 116     printf(msg, a1, a2, a3);
 117 #ifdef AFS_LINUX20_ENV
 118     *((char*)0xffffffff) = 42;
 119 #else
 120     panic(msg);
 121 #endif
 122 }
 123
 124 /*
 125  * osi_utoa() - write the NUL-terminated ASCII decimal form of the given
 126  * unsigned long value into the given buffer.  Returns 0 on success,
 127  * and a value less than 0 on failure.  The contents of the buffer is
 128  * defined only on success.
 129  */
 130
 131 int osi_utoa(char *buf, size_t len, unsigned long val)
 132 {
 133         long k; /* index of first byte of string value */
 134
 135         /* we definitely need room for at least one digit and NUL */
 136
 137         if (len < 2) {
 138                 return -1;
 139         }
 140
 141         /* compute the string form from the high end of the buffer */
 142
 143         buf[len - 1] = '\0';
 144         for (k = len - 2; k >= 0; k--) {
 145                 buf[k] = val % 10 + '0';
 146                 val /= 10;
 147
 148                 if (val == 0)
 149                         break;
 150         }
 151
 152         /* did we finish converting val to string form? */
 153
 154         if (val != 0) {
 155                 return -2;
 156         }
 157
 158         /* this should never happen */
 159
 160         if (k < 0) {
 161                 return -3;
 162         }
 163
 164         /* this should never happen */
 165
 166         if (k >= len) {
 167                 return -4;
 168         }
 169
 170         /* if necessary, relocate string to beginning of buf[] */
 171
 172         if (k > 0) {
 173
 174                 /*
 175                  * We need to achieve the effect of calling
 176                  *
 177                  * memmove(buf, &buf[k], len - k);
 178                  *
 179                  * However, since memmove() is not available in all
 180                  * kernels, we explicitly do an appropriate copy.
 181                  */
 182
 183                 char *dst = buf;
 184                 char *src = buf+k;
 185
 186                 while((*dst++ = *src++) != '\0')
 187                         continue;
 188         }
 189
 190         return 0;
 191 }
 192
 193 /*
 194  * osi_AssertFailK() -- used by the osi_Assert() macro.
 195  *
 196  * It essentially does
 197  *
 198  * osi_Panic("assertion failed: %s, file: %s, line: %d", expr, file, line);
 199  *
 200  * Since the kernel version of osi_Panic() only passes its first
 201  * argument to the native panic(), we construct a single string and hand
 202  * that to osi_Panic().
 203  */
 204 void osi_AssertFailK(const char *expr, const char *file, int line)
 205 {
 206         static const char msg0[] = "assertion failed: ";
 207         static const char msg1[] = ", file: ";
 208         static const char msg2[] = ", line: ";
 209         static const char msg3[] = "\n";
 210
 211         /*
 212          * These buffers add up to 1K, which is a pleasantly nice round
 213          * value, but probably not vital.
 214          */
 215         char buf[1008];
 216         char linebuf[16];
 217
 218         /* check line number conversion */
 219
 220         if (osi_utoa(linebuf, sizeof linebuf, line) < 0) {
 221                 osi_Panic("osi_AssertFailK: error in osi_utoa()\n");
 222         }
 223
 224         /* okay, panic */
 225
 226 #define ADDBUF(BUF, STR)                                        \
 227         if (strlen(BUF) + strlen((char *)(STR)) + 1 <= sizeof BUF) {    \
 228                 strcat(BUF, (char *)(STR));                             \
 229         }
 230
 231         buf[0] = '\0';
 232         ADDBUF(buf, msg0);
 233         ADDBUF(buf, expr);
 234         ADDBUF(buf, msg1);
 235         ADDBUF(buf, file);
 236         ADDBUF(buf, msg2);
 237         ADDBUF(buf, linebuf);
 238         ADDBUF(buf, msg3);
 239
 240 #undef ADDBUF
 241
 242         osi_Panic(buf);
 243 }
 244
 245 #ifndef UKERNEL
 246 /* This is the server process request loop. Kernel server
 247  * processes never become listener threads */
 248 void rx_ServerProc(void)
 249 {
 250     int threadID;
 251
 252     rxi_MorePackets(rx_maxReceiveWindow+2); /* alloc more packets */
 253     rxi_dataQuota += rx_initSendWindow; /* Reserve some pkts for hard times */
 254     /* threadID is used for making decisions in GetCall.  Get it by bumping
 255      * number of threads handling incoming calls */
 256     threadID = rxi_availProcs++;
 257
 258 #ifdef RX_ENABLE_LOCKS
 259     AFS_GUNLOCK();
 260 #endif /* RX_ENABLE_LOCKS */
 261     rxi_ServerProc(threadID, NULL, NULL);
 262 #ifdef RX_ENABLE_LOCKS
 263     AFS_GLOCK();
 264 #endif /* RX_ENABLE_LOCKS */
 265 }
 266 #endif /* !UKERNEL */
 267
 268 #ifndef RXK_LISTENER_ENV
 269 /* asize includes the Rx header */
 270 static int MyPacketProc(char **ahandle, int asize)
 271 {
 272     register struct rx_packet *tp;
 273
 274     /* If this is larger than we expected, increase rx_maxReceiveDataSize */
 275     /* If we can't scrounge enough cbufs, then we have to drop the packet,
 276      * but we should set a flag so we magic up some more at our leisure.
 277      */
 278
 279     if ((asize >= 0) && (asize <= RX_MAX_PACKET_SIZE)) {
 280       tp = rxi_AllocPacket(RX_PACKET_CLASS_RECEIVE);
 281       if (tp && (tp->length + RX_HEADER_SIZE) < asize ) {
 282         if (0 < rxi_AllocDataBuf(tp, asize - (tp->length + RX_HEADER_SIZE),
 283                                  RX_PACKET_CLASS_RECV_CBUF)) {
 284           rxi_FreePacket(tp);
 285           tp = NULL;
 286           MUTEX_ENTER(&rx_stats_mutex);
 287           rx_stats.noPacketBuffersOnRead++;
 288           MUTEX_EXIT(&rx_stats_mutex);
 289         }
 290       }
 291     } else {
 292       /*
 293        * XXX if packet is too long for our buffer,
 294        * should do this at a higher layer and let other
 295        * end know we're losing.
 296        */
 297       MUTEX_ENTER(&rx_stats_mutex);
 298       rx_stats.bogusPacketOnRead++;
 299       MUTEX_EXIT(&rx_stats_mutex);
 300       /* I DON"T LIKE THIS PRINTF -- PRINTFS MAKE THINGS VERY VERY SLOOWWW */
 301       printf("rx: packet dropped: bad ulen=%d\n", asize);
 302       tp = NULL;
 303     }
 304
 305     if (!tp) return -1;
 306     /* otherwise we have a packet, set appropriate values */
 307     *ahandle = (char *) tp;
 308     return 0;
 309 }
 310
 311 static int MyArrivalProc(register struct rx_packet *ahandle,
 312         register struct sockaddr_in *afrom, char *arock,
 313         afs_int32 asize)
 314 {
 315     /* handle basic rx packet */
 316     ahandle->length = asize - RX_HEADER_SIZE;
 317     rxi_DecodePacketHeader(ahandle);
 318     ahandle = rxi_ReceivePacket(ahandle, (struct socket *) arock,
 319                                 afrom->sin_addr.s_addr, afrom->sin_port,
 320                                 NULL, NULL);
 321
 322     /* free the packet if it has been returned */
 323     if (ahandle) rxi_FreePacket(ahandle);
 324     return 0;
 325 }
 326 #endif /* !RXK_LISTENER_ENV */
 327
 328 void rxi_StartListener(void)
 329 {
 330     /* if kernel, give name of appropriate procedures */
 331 #ifndef RXK_LISTENER_ENV
 332     rxk_GetPacketProc = MyPacketProc;
 333     rxk_PacketArrivalProc = MyArrivalProc;
 334     rxk_init();
 335 #endif
 336 }
 337
 338 /* Called from rxi_FindPeer, when initializing a clear rx_peer structure,
 339   to get interesting information. */
 340 void rxi_InitPeerParams(register struct rx_peer *pp)
 341 {
 342 #ifdef  ADAPT_MTU
 343     u_short rxmtu;
 344     afs_int32 i, mtu;
 345
 346 #ifndef AFS_SUN5_ENV
 347 #ifdef AFS_USERSPACE_IP_ADDR
 348     i = rxi_Findcbi(pp->host);
 349     if (i == -1) {
 350        pp->timeout.sec = 3;
 351        /* pp->timeout.usec = 0; */
 352        pp->ifMTU = RX_REMOTE_PACKET_SIZE;
 353     } else {
 354        pp->timeout.sec = 2;
 355        /* pp->timeout.usec = 0; */
 356        pp->ifMTU = MIN(RX_MAX_PACKET_SIZE, rx_MyMaxSendSize);
 357     }
 358     if (i != -1) {
 359         mtu = ntohl(afs_cb_interface.mtu[i]);
 360         /* Diminish the packet size to one based on the MTU given by
 361          * the interface. */
 362         if (mtu > (RX_IPUDP_SIZE + RX_HEADER_SIZE)) {
 363             rxmtu = mtu - RX_IPUDP_SIZE;
 364             if (rxmtu < pp->ifMTU) pp->ifMTU = rxmtu;
 365         }
 366     }
 367     else {   /* couldn't find the interface, so assume the worst */
 368       pp->ifMTU = RX_REMOTE_PACKET_SIZE;
 369     }
 370 #else /* AFS_USERSPACE_IP_ADDR */
 371 #ifdef AFS_DARWIN60_ENV
 372     struct ifaddr *ifad = (struct ifaddr *) 0;
 373 #else
 374     struct in_ifaddr *ifad = (struct in_ifaddr *) 0;
 375 #endif
 376     struct ifnet *ifn;
 377
 378     /* At some time we need to iterate through rxi_FindIfnet() to find the
 379      * global maximum.
 380      */
 381     ifn = rxi_FindIfnet(pp->host, &ifad);
 382     if (ifn == NULL) {  /* not local */
 383         pp->timeout.sec = 3;
 384         /* pp->timeout.usec = 0; */
 385         pp->ifMTU = RX_REMOTE_PACKET_SIZE;
 386     } else {
 387         pp->timeout.sec = 2;
 388         /* pp->timeout.usec = 0; */
 389         pp->ifMTU = MIN(RX_MAX_PACKET_SIZE, rx_MyMaxSendSize);
 390     }
 391     if (ifn) {
 392 #ifdef IFF_POINTOPOINT
 393         if (ifn->if_flags & IFF_POINTOPOINT) {
 394             /* wish we knew the bit rate and the chunk size, sigh. */
 395             pp->timeout.sec = 4;
 396             pp->ifMTU = RX_PP_PACKET_SIZE;
 397         }
 398 #endif /* IFF_POINTOPOINT */
 399         /* Diminish the packet size to one based on the MTU given by
 400          * the interface. */
 401         if (ifn->if_mtu > (RX_IPUDP_SIZE + RX_HEADER_SIZE)) {
 402             rxmtu = ifn->if_mtu - RX_IPUDP_SIZE;
 403             if (rxmtu < pp->ifMTU) pp->ifMTU = rxmtu;
 404         }
 405     }
 406     else {   /* couldn't find the interface, so assume the worst */
 407       pp->ifMTU = RX_REMOTE_PACKET_SIZE;
 408     }
 409 #endif/* else AFS_USERSPACE_IP_ADDR */
 410 #else /* AFS_SUN5_ENV */
 411     mtu = rxi_FindIfMTU(pp->host);
 412
 413     if (mtu <= 0) {
 414         pp->timeout.sec = 3;
 415         /* pp->timeout.usec = 0; */
 416         pp->ifMTU = RX_REMOTE_PACKET_SIZE;
 417     } else {
 418         pp->timeout.sec = 2;
 419         /* pp->timeout.usec = 0; */
 420         pp->ifMTU = MIN(RX_MAX_PACKET_SIZE, rx_MyMaxSendSize);
 421     }
 422
 423     if (mtu > 0) {
 424         /* Diminish the packet size to one based on the MTU given by
 425          * the interface. */
 426         if (mtu > (RX_IPUDP_SIZE + RX_HEADER_SIZE)) {
 427             rxmtu = mtu - RX_IPUDP_SIZE;
 428             if (rxmtu < pp->ifMTU) pp->ifMTU = rxmtu;
 429         }
 430     } else {   /* couldn't find the interface, so assume the worst */
 431         pp->ifMTU = RX_REMOTE_PACKET_SIZE;
 432     }
 433 #endif /* AFS_SUN5_ENV */
 434 #else /* ADAPT_MTU */
 435     pp->rateFlag = 2;   /* start timing after two full packets */
 436     pp->timeout.sec = 2;
 437     pp->ifMTU = OLD_MAX_PACKET_SIZE;
 438 #endif /* else ADAPT_MTU */
 439     pp->ifMTU = rxi_AdjustIfMTU(pp->ifMTU);
 440     pp->maxMTU = OLD_MAX_PACKET_SIZE;  /* for compatibility with old guys */
 441     pp->natMTU = MIN(pp->ifMTU, OLD_MAX_PACKET_SIZE);
 442     pp->ifDgramPackets = MIN(rxi_nDgramPackets,
 443                              rxi_AdjustDgramPackets(RX_MAX_FRAGS, pp->ifMTU));
 444     pp->maxDgramPackets = 1;
 445
 446     /* Initialize slow start parameters */
 447     pp->MTU = MIN(pp->natMTU, pp->maxMTU);
 448     pp->cwind = 1;
 449     pp->nDgramPackets = 1;
 450     pp->congestSeq = 0;
 451 }
 452
 453
 454 /* The following code is common to several system types, but not all. The
 455  * separate ones are found in the system specific subdirectories.
 456  */
 457
 458
 459 #if ! defined(AFS_AIX_ENV) && ! defined(AFS_SUN5_ENV) && ! defined(UKERNEL) && ! defined(AFS_LINUX20_ENV) && !defined (AFS_DARWIN_ENV) && !defined (AFS_XBSD_ENV)
 460 /* Routine called during the afsd "-shutdown" process to put things back to
 461  * the initial state.
 462  */
 463 static struct protosw parent_proto;     /* udp proto switch */
 464
 465 void shutdown_rxkernel(void)
 466 {
 467     register struct protosw *tpro, *last;
 468     last = inetdomain.dom_protoswNPROTOSW;
 469     for (tpro = inetdomain.dom_protosw; tpro < last; tpro++)
 470         if (tpro->pr_protocol == IPPROTO_UDP) {
 471             /* restore original udp protocol switch */
 472             memcpy((void *)tpro, (void *)&parent_proto, sizeof(parent_proto));
 473             memset((void *)&parent_proto, 0, sizeof(parent_proto));
 474             rxk_initDone = 0;
 475             rxk_shutdownPorts();
 476             return;
 477         }
 478     printf("shutdown_rxkernel: no udp proto");
 479 }
 480 #endif /* !AIX && !SUN && !NCR  && !UKERNEL */
 481
 482 #if !defined(AFS_SUN5_ENV) && !defined(AFS_SGI62_ENV)
 483 /* Determine what the network interfaces are for this machine. */
 484
 485 #define ADDRSPERSITE 16
 486 static afs_uint32 myNetAddrs[ADDRSPERSITE];
 487 static int myNetMTUs[ADDRSPERSITE];
 488 static int numMyNetAddrs = 0;
 489
 490 #ifdef AFS_USERSPACE_IP_ADDR
 491 int rxi_GetcbiInfo(void)
 492 {
 493    int     i, j, different = 0;
 494    int     rxmtu, maxmtu;
 495    afs_uint32 ifinaddr;
 496    afs_uint32 addrs[ADDRSPERSITE];
 497    int     mtus[ADDRSPERSITE];
 498
 499    memset((void *)addrs, 0, sizeof(addrs));
 500    memset((void *)mtus, 0, sizeof(mtus));
 501
 502    for (i=0; i<afs_cb_interface.numberOfInterfaces; i++) {
 503       rxmtu    = (ntohl(afs_cb_interface.mtu[i]) - RX_IPUDP_SIZE);
 504       ifinaddr = ntohl(afs_cb_interface.addr_in[i]);
 505       if (myNetAddrs[i] != ifinaddr) different++;
 506
 507       mtus[i]    = rxmtu;
 508       rxmtu      = rxi_AdjustIfMTU(rxmtu);
 509       maxmtu     = rxmtu * rxi_nRecvFrags + ((rxi_nRecvFrags-1) * UDP_HDR_SIZE);
 510       maxmtu     = rxi_AdjustMaxMTU(rxmtu, maxmtu);
 511       addrs[i++] = ifinaddr;
 512       if ( ( ifinaddr != 0x7f000001 ) && (maxmtu > rx_maxReceiveSize) ) {
 513          rx_maxReceiveSize = MIN( RX_MAX_PACKET_SIZE, maxmtu);
 514          rx_maxReceiveSize = MIN( rx_maxReceiveSize, rx_maxReceiveSizeUser);
 515       }
 516    }
 517
 518    rx_maxJumboRecvSize = RX_HEADER_SIZE +
 519                          ( rxi_nDgramPackets    * RX_JUMBOBUFFERSIZE) +
 520                          ((rxi_nDgramPackets-1) * RX_JUMBOHEADERSIZE);
 521    rx_maxJumboRecvSize = MAX(rx_maxJumboRecvSize, rx_maxReceiveSize);
 522
 523    if (different) {
 524       for (j=0; j<i; j++) {
 525          myNetMTUs[j]  = mtus[j];
 526          myNetAddrs[j] = addrs[j];
 527       }
 528    }
 529    return different;
 530 }
 531
 532
 533 /* Returns the afs_cb_interface inxex which best matches address.
 534  * If none is found, we return -1.
 535  */
 536 afs_int32 rxi_Findcbi(afs_uint32 addr)
 537 {
 538    int j;
 539    afs_uint32 myAddr, thisAddr, netMask, subnetMask;
 540    afs_int32 rvalue = -1;
 541    int match_value = 0;
 542
 543   if (numMyNetAddrs == 0)
 544     (void) rxi_GetcbiInfo();
 545
 546    myAddr = ntohl(addr);
 547
 548    if      ( IN_CLASSA(myAddr) ) netMask = IN_CLASSA_NET;
 549    else if ( IN_CLASSB(myAddr) ) netMask = IN_CLASSB_NET;
 550    else if ( IN_CLASSC(myAddr) ) netMask = IN_CLASSC_NET;
 551    else                          netMask = 0;
 552
 553    for (j=0; j<afs_cb_interface.numberOfInterfaces; j++) {
 554       thisAddr   = ntohl(afs_cb_interface.addr_in[j]);
 555       subnetMask = ntohl(afs_cb_interface.subnetmask[j]);
 556       if ((myAddr & netMask) == (thisAddr & netMask)) {
 557          if ((myAddr & subnetMask) == (thisAddr & subnetMask)) {
 558             if (myAddr == thisAddr) {
 559                match_value = 4;
 560                rvalue = j;
 561                break;
 562             }
 563             if (match_value < 3) {
 564                match_value = 3;
 565                rvalue = j;
 566             }
 567          } else {
 568             if (match_value < 2) {
 569                match_value = 2;
 570                rvalue = j;
 571             }
 572          }
 573       }
 574    }
 575
 576    return(rvalue);
 577 }
 578
 579 #else /* AFS_USERSPACE_IP_ADDR */
 580
 581 #if !defined(AFS_AIX41_ENV) && !defined(AFS_DUX40_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
 582 #define IFADDR2SA(f) (&((f)->ifa_addr))
 583 #else /* AFS_AIX41_ENV */
 584 #define IFADDR2SA(f) ((f)->ifa_addr)
 585 #endif
 586
 587 int rxi_GetIFInfo(void)
 588 {
 589     int i = 0;
 590     int different = 0;
 591
 592     register struct ifnet *ifn;
 593     register int rxmtu, maxmtu;
 594     afs_uint32 addrs[ADDRSPERSITE];
 595     int mtus[ADDRSPERSITE];
 596     struct ifaddr *ifad;  /* ifnet points to a if_addrlist of ifaddrs */
 597     afs_uint32 ifinaddr;
 598
 599     memset(addrs, 0, sizeof(addrs));
 600     memset(mtus, 0, sizeof(mtus));
 601
 602 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 603     TAILQ_FOREACH(ifn, &ifnet, if_link) {
 604       if (i >= ADDRSPERSITE) break;
 605 #else
 606     for (ifn = ifnet; ifn != NULL && i < ADDRSPERSITE; ifn = ifn->if_next) {
 607 #endif
 608       rxmtu = (ifn->if_mtu - RX_IPUDP_SIZE);
 609 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 610       TAILQ_FOREACH(ifad, &ifn->if_addrhead, ifa_link) {
 611       if (i >= ADDRSPERSITE) break;
 612 #else
 613       for (ifad = ifn->if_addrlist; ifad != NULL && i < ADDRSPERSITE;
 614            ifad = ifad->ifa_next){
 615 #endif
 616         if (IFADDR2SA(ifad)->sa_family == AF_INET) {
 617           ifinaddr = ntohl(((struct sockaddr_in *) IFADDR2SA(ifad))->sin_addr.s_addr);
 618           if (myNetAddrs[i] != ifinaddr) {
 619             different++;
 620           }
 621           mtus[i] = rxmtu;
 622           rxmtu = rxi_AdjustIfMTU(rxmtu);
 623           maxmtu = rxmtu * rxi_nRecvFrags + ((rxi_nRecvFrags-1) * UDP_HDR_SIZE);
 624           maxmtu = rxi_AdjustMaxMTU(rxmtu, maxmtu);
 625           addrs[i++] = ifinaddr;
 626           if ( ( ifinaddr != 0x7f000001 ) &&
 627               (maxmtu > rx_maxReceiveSize) ) {
 628             rx_maxReceiveSize = MIN( RX_MAX_PACKET_SIZE, maxmtu);
 629             rx_maxReceiveSize = MIN( rx_maxReceiveSize, rx_maxReceiveSizeUser);
 630           }
 631         }
 632       }
 633     }
 634
 635     rx_maxJumboRecvSize = RX_HEADER_SIZE
 636                           + rxi_nDgramPackets * RX_JUMBOBUFFERSIZE
 637                           + (rxi_nDgramPackets-1) * RX_JUMBOHEADERSIZE;
 638     rx_maxJumboRecvSize = MAX(rx_maxJumboRecvSize, rx_maxReceiveSize);
 639
 640     if (different) {
 641       int j;
 642       for (j=0; j< i; j++) {
 643         myNetMTUs[j] = mtus[j];
 644         myNetAddrs[j] = addrs[j];
 645       }
 646     }
 647    return different;
 648 }
 649 #ifdef AFS_DARWIN60_ENV
 650 /* Returns ifnet which best matches address */
 651 struct ifnet *
 652 rxi_FindIfnet(addr, pifad)
 653      afs_uint32 addr;
 654      struct ifaddr **pifad;
 655 {
 656   struct sockaddr_in s;
 657
 658   if (numMyNetAddrs == 0)
 659     (void) rxi_GetIFInfo();
 660
 661   s.sin_family=AF_INET;
 662   s.sin_addr.s_addr=addr;
 663   *pifad=ifa_ifwithnet((struct sockaddr *)&s);
 664  done:
 665   return (*pifad ?  (*pifad)->ifa_ifp : NULL );
 666 }
 667 #else
 668 /* Returns ifnet which best matches address */
 669 struct ifnet *rxi_FindIfnet(afs_uint32 addr, struct in_ifaddr **pifad)
 670 {
 671   afs_uint32 ppaddr;
 672   int match_value = 0;
 673   extern struct in_ifaddr *in_ifaddr;
 674   struct in_ifaddr *ifa;
 675   struct sockaddr_in *sin;
 676
 677   if (numMyNetAddrs == 0)
 678     (void) rxi_GetIFInfo();
 679
 680   ppaddr = ntohl(addr);
 681
 682   /* if we're given an address, skip everything until we find it */
 683   if (!*pifad)
 684 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 685     *pifad = TAILQ_FIRST(&in_ifaddrhead);
 686 #else
 687     *pifad = in_ifaddr;
 688 #endif
 689   else {
 690     if (((ppaddr & (*pifad)->ia_subnetmask) == (*pifad)->ia_subnet))
 691       match_value = 2; /* don't find matching nets, just subnets */
 692 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 693     *pifad = TAILQ_NEXT(*pifad, ia_link);
 694 #else
 695     *pifad = (*pifad)->ia_next;
 696 #endif
 697   }
 698
 699 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 700   for (ifa = *pifad; ifa; ifa = TAILQ_NEXT(ifa, ia_link) ) {
 701 #else
 702   for (ifa = *pifad; ifa; ifa = ifa->ia_next ) {
 703 #endif
 704     if ((ppaddr & ifa->ia_netmask) == ifa->ia_net) {
 705       if ((ppaddr & ifa->ia_subnetmask) == ifa->ia_subnet) {
 706         sin=IA_SIN(ifa);
 707         if ( sin->sin_addr.s_addr == ppaddr) {   /* ie, ME!!!  */
 708           match_value = 4;
 709           *pifad = ifa;
 710           goto done;
 711         }
 712         if (match_value < 3) {
 713           *pifad = ifa;
 714           match_value = 3;
 715         }
 716       }
 717       else {
 718         if (match_value < 2) {
 719           *pifad = ifa;
 720           match_value = 2;
 721         }
 722       }
 723     } /* if net matches */
 724   } /* for all in_ifaddrs */
 725
 726  done:
 727   return (*pifad ?  (*pifad)->ia_ifp : NULL );
 728 }
 729 #endif
 730 #endif /* else AFS_USERSPACE_IP_ADDR */
 731 #endif /* !SUN5 && !SGI62 */
 732
 733
 734 /* rxk_NewSocket, rxk_FreeSocket and osi_NetSend are from the now defunct
 735  * afs_osinet.c. One could argue that rxi_NewSocket could go into the
 736  * system specific subdirectories for all systems. But for the moment,
 737  * most of it is simple to follow common code.
 738  */
 739 #if !defined(UKERNEL)
 740 #if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV)
 741 /* rxk_NewSocket creates a new socket on the specified port. The port is
 742  * in network byte order.
 743  */
 744 struct osi_socket *rxk_NewSocket(short aport)
 745 {
 746     register afs_int32 code;
 747     struct socket *newSocket;
 748     register struct mbuf *nam;
 749     struct sockaddr_in myaddr;
 750     int wow;
 751 #ifdef AFS_HPUX110_ENV
 752     /* prototype copied from kernel source file streams/str_proto.h */
 753     extern MBLKP allocb_wait(int, int);
 754     MBLKP bindnam;
 755     int addrsize = sizeof(struct sockaddr_in);
 756 #endif
 757 #ifdef AFS_SGI65_ENV
 758     bhv_desc_t bhv;
 759 #endif
 760
 761     AFS_STATCNT(osi_NewSocket);
 762 #if (defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)) && defined(KERNEL_FUNNEL)
 763     thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
 764 #endif
 765 #if     defined(AFS_HPUX102_ENV)
 766 #if     defined(AFS_HPUX110_ENV)
 767     /* blocking socket */
 768     code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0, 0);
 769 #else      /* AFS_HPUX110_ENV */
 770     code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0, SS_NOWAIT);
 771 #endif     /* else AFS_HPUX110_ENV */
 772 #else
 773 #ifdef AFS_SGI65_ENV
 774     code = socreate(AF_INET, &newSocket, SOCK_DGRAM,IPPROTO_UDP);
 775 #elif defined(AFS_XBSD_ENV)
 776     code = socreate(AF_INET, &newSocket, SOCK_DGRAM,IPPROTO_UDP, curproc);
 777 #else
 778     code = socreate(AF_INET, &newSocket, SOCK_DGRAM, 0);
 779 #endif /* AFS_SGI65_ENV */
 780 #endif /* AFS_HPUX102_ENV */
 781     if (code) goto bad;
 782
 783     myaddr.sin_family = AF_INET;
 784     myaddr.sin_port = aport;
 785     myaddr.sin_addr.s_addr = 0;
 786 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
 787     myaddr.sin_len = sizeof(myaddr);
 788 #endif
 789
 790 #ifdef AFS_HPUX110_ENV
 791     bindnam = allocb_wait((addrsize+SO_MSGOFFSET+1), BPRI_MED);
 792     if (!bindnam) {
 793        setuerror(ENOBUFS);
 794        goto bad;
 795     }
 796     memcpy((caddr_t)bindnam->b_rptr+SO_MSGOFFSET, (caddr_t)&myaddr, addrsize);
 797     bindnam->b_wptr = bindnam->b_rptr + (addrsize+SO_MSGOFFSET+1);
 798
 799     code = sobind(newSocket, bindnam, addrsize);
 800     if (code) {
 801        soclose(newSocket);
 802        m_freem(nam);
 803        goto bad;
 804     }
 805
 806     freeb(bindnam);
 807 #else /* AFS_HPUX110_ENV */
 808     code = soreserve(newSocket, 50000, 50000);
 809     if (code) {
 810         code = soreserve(newSocket, 32766, 32766);
 811         if (code)
 812             osi_Panic("osi_NewSocket: last attempt to reserve 32K failed!\n");
 813     }
 814 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 815 #if defined(AFS_XBSD_ENV)
 816     code = sobind(newSocket, (struct sockaddr *)&myaddr, curproc);
 817 #else
 818     code = sobind(newSocket, (struct sockaddr *)&myaddr);
 819 #endif
 820     if (code) {
 821         printf("sobind fails\n");
 822         soclose(newSocket);
 823         goto bad;
 824     }
 825 #else
 826 #ifdef  AFS_OSF_ENV
 827     nam = m_getclr(M_WAIT, MT_SONAME);
 828 #else   /* AFS_OSF_ENV */
 829     nam = m_get(M_WAIT, MT_SONAME);
 830 #endif
 831     if (nam == NULL) {
 832 #if !defined(AFS_SUN5_ENV) && !defined(AFS_OSF_ENV) && !defined(AFS_SGI64_ENV) && !defined(AFS_XBSD_ENV)
 833         setuerror(ENOBUFS);
 834 #endif
 835         goto bad;
 836     }
 837     nam->m_len = sizeof(myaddr);
 838 #ifdef  AFS_OSF_ENV
 839     myaddr.sin_len = nam->m_len;
 840 #endif  /* AFS_OSF_ENV */
 841     memcpy(mtod(nam, caddr_t), &myaddr, sizeof(myaddr));
 842 #ifdef AFS_SGI65_ENV
 843     BHV_PDATA(&bhv) = (void*)newSocket;
 844     code = sobind(&bhv, nam);
 845     m_freem(nam);
 846 #elif defined(AFS_XBSD_ENV)
 847     code = sobind(newSocket, nam, curproc);
 848 #else
 849     code = sobind(newSocket, nam);
 850 #endif
 851     if (code) {
 852         soclose(newSocket);
 853 #ifndef AFS_SGI65_ENV
 854         m_freem(nam);
 855 #endif
 856         goto bad;
 857     }
 858 #endif /* else AFS_DARWIN_ENV */
 859 #endif /* else AFS_HPUX110_ENV */
 860
 861 #if defined(AFS_DARWIN_ENV) && defined(KERNEL_FUNNEL)
 862     thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);
 863 #endif
 864     return (struct osi_socket *) newSocket;
 865
 866 bad:
 867 #if defined(AFS_DARWIN_ENV) && defined(KERNEL_FUNNEL)
 868     thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);
 869 #endif
 870     return (struct osi_socket *) 0;
 871 }
 872
 873
 874 /* free socket allocated by rxk_NewSocket */
 875 int rxk_FreeSocket(register struct socket *asocket)
 876 {
 877     AFS_STATCNT(osi_FreeSocket);
 878 #if defined(AFS_DARWIN_ENV) && defined(KERNEL_FUNNEL)
 879     thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
 880 #endif
 881     soclose(asocket);
 882 #if defined(AFS_DARWIN_ENV) && defined(KERNEL_FUNNEL)
 883     thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);
 884 #endif
 885     return 0;
 886 }
 887 #endif /* !SUN5 && !LINUX20 */
 888
 889 #if defined(RXK_LISTENER_ENV) || defined(AFS_SUN5_ENV)
 890 /*
 891  * Run RX event daemon every second (5 times faster than rest of systems)
 892  */
 893 void afs_rxevent_daemon(void)
 894 {
 895     struct clock temp;
 896     SPLVAR;
 897
 898     while (1) {
 899 #ifdef RX_ENABLE_LOCKS
 900         AFS_GUNLOCK();
 901 #endif /* RX_ENABLE_LOCKS */
 902         NETPRI;
 903         AFS_RXGLOCK();
 904         rxevent_RaiseEvents(&temp);
 905         AFS_RXGUNLOCK();
 906         USERPRI;
 907 #ifdef RX_ENABLE_LOCKS
 908         AFS_GLOCK();
 909 #endif /* RX_ENABLE_LOCKS */
 910         afs_osi_Wait(500, NULL, 0);
 911         if (afs_termState == AFSOP_STOP_RXEVENT )
 912         {
 913 #ifdef RXK_LISTENER_ENV
 914                 afs_termState = AFSOP_STOP_RXK_LISTENER;
 915 #else
 916                 afs_termState = AFSOP_STOP_COMPLETE;
 917 #endif
 918                 afs_osi_Wakeup(&afs_termState);
 919                 return;
 920         }
 921     }
 922 }
 923 #endif
 924
 925 #ifdef RXK_LISTENER_ENV
 926
 927 /* rxk_ReadPacket returns 1 if valid packet, 0 on error. */
 928 int rxk_ReadPacket(osi_socket so, struct rx_packet *p, int *host, int *port)
 929 {
 930     int code;
 931     struct sockaddr_in from;
 932     int nbytes;
 933     afs_int32 rlen;
 934     register afs_int32 tlen;
 935     afs_int32 savelen;            /* was using rlen but had aliasing problems */
 936     rx_computelen(p, tlen);
 937     rx_SetDataSize(p, tlen);  /* this is the size of the user data area */
 938
 939     tlen += RX_HEADER_SIZE;   /* now this is the size of the entire packet */
 940     rlen = rx_maxJumboRecvSize; /* this is what I am advertising.  Only check
 941                                  * it once in order to avoid races.  */
 942     tlen = rlen - tlen;
 943     if (tlen > 0) {
 944       tlen = rxi_AllocDataBuf(p, tlen, RX_PACKET_CLASS_RECV_CBUF);
 945       if (tlen >0) {
 946         tlen = rlen - tlen;
 947       }
 948       else tlen = rlen;
 949     }
 950     else tlen = rlen;
 951
 952    /* add some padding to the last iovec, it's just to make sure that the
 953     * read doesn't return more data than we expect, and is done to get around
 954     * our problems caused by the lack of a length field in the rx header. */
 955     savelen = p->wirevec[p->niovecs-1].iov_len;
 956     p->wirevec[p->niovecs-1].iov_len = savelen + RX_EXTRABUFFERSIZE;
 957
 958     nbytes = tlen + sizeof(afs_int32);
 959     code = osi_NetReceive(rx_socket, &from, p->wirevec, p->niovecs,
 960                             &nbytes);
 961
 962    /* restore the vec to its correct state */
 963     p->wirevec[p->niovecs-1].iov_len = savelen;
 964
 965     if (!code) {
 966         p->length = nbytes - RX_HEADER_SIZE;;
 967         if ((nbytes > tlen) || (p->length & 0x8000)) {  /* Bogus packet */
 968             if (nbytes > 0)
 969                 rxi_MorePackets(rx_initSendWindow);
 970             else {
 971                 MUTEX_ENTER(&rx_stats_mutex);
 972                 rx_stats.bogusPacketOnRead++;
 973                 rx_stats.bogusHost = from.sin_addr.s_addr;
 974                 MUTEX_EXIT(&rx_stats_mutex);
 975                 dpf(("B: bogus packet from [%x,%d] nb=%d", from.sin_addr.s_addr,
 976                      from.sin_port,nbytes));
 977             }
 978             return  -1;
 979         }
 980         else {
 981             /* Extract packet header. */
 982             rxi_DecodePacketHeader(p);
 983
 984             *host = from.sin_addr.s_addr;
 985             *port = from.sin_port;
 986             if (p->header.type > 0 && p->header.type < RX_N_PACKET_TYPES) {
 987                 MUTEX_ENTER(&rx_stats_mutex);
 988                 rx_stats.packetsRead[p->header.type-1]++;
 989                 MUTEX_EXIT(&rx_stats_mutex);
 990             }
 991
 992             /* Free any empty packet buffers at the end of this packet */
 993             rxi_TrimDataBufs(p, 1);
 994
 995             return  0;
 996         }
 997     }
 998     else
 999         return code;
1000 }
1001
1002 /* rxk_Listener()
1003  *
1004  * Listen for packets on socket. This thread is typically started after
1005  * rx_Init has called rxi_StartListener(), but nevertheless, ensures that
1006  * the start state is set before proceeding.
1007  *
1008  * Note that this thread is outside the AFS global lock for much of
1009  * it's existence.
1010  *
1011  * In many OS's, the socket receive code sleeps interruptibly. That's not what
1012  * we want here. So we need to either block all signals (including SIGKILL
1013  * and SIGSTOP) or reset the thread's signal state to unsignalled when the
1014  * OS's socket receive routine returns as a result of a signal.
1015  */
1016 int rxk_ListenerPid; /* Used to signal process to wakeup at shutdown */
1017
1018 #ifdef AFS_SUN5_ENV
1019 /*
1020  * Run the listener as a kernel thread.
1021  */
1022 void rxk_Listener(void)
1023 {
1024     extern id_t syscid;
1025     void rxk_ListenerProc(void);
1026     if (thread_create(NULL, DEFAULTSTKSZ, rxk_ListenerProc,
1027         0, 0, &p0, TS_RUN, minclsyspri) == NULL)
1028         osi_Panic("rxk_Listener: failed to start listener thread!\n");
1029 }
1030
1031 void rxk_ListenerProc(void)
1032 #else /* AFS_SUN5_ENV */
1033 void rxk_Listener(void)
1034 #endif /* AFS_SUN5_ENV */
1035 {
1036     struct rx_packet *rxp = NULL;
1037     int code;
1038     int host, port;
1039
1040 #ifdef AFS_LINUX20_ENV
1041     rxk_ListenerPid = current->pid;
1042 #endif
1043 #ifdef AFS_SUN5_ENV
1044     rxk_ListenerPid = 1;        /* No PID, just a flag that we're alive */
1045 #endif /* AFS_SUN5_ENV */
1046 #ifdef AFS_FBSD_ENV
1047     rxk_ListenerPid = curproc->p_pid;
1048 #endif /* AFS_FBSD_ENV */
1049 #if defined(AFS_DARWIN_ENV)
1050     rxk_ListenerPid = current_proc()->p_pid;
1051 #endif
1052 #if defined(RX_ENABLE_LOCKS) && !defined(AFS_SUN5_ENV)
1053     AFS_GUNLOCK();
1054 #endif /* RX_ENABLE_LOCKS && !AFS_SUN5_ENV */
1055
1056     while (afs_termState != AFSOP_STOP_RXK_LISTENER) {
1057         if (rxp) {
1058             rxi_RestoreDataBufs(rxp);
1059         }
1060         else {
1061             rxp = rxi_AllocPacket(RX_PACKET_CLASS_RECEIVE);
1062             if (!rxp)
1063                 osi_Panic("rxk_Listener: No more Rx buffers!\n");
1064         }
1065         if (!(code = rxk_ReadPacket(rx_socket, rxp, &host, &port))) {
1066             AFS_RXGLOCK();
1067             rxp = rxi_ReceivePacket(rxp, rx_socket, host, port, 0, 0);
1068             AFS_RXGUNLOCK();
1069         }
1070     }
1071
1072 #ifdef RX_ENABLE_LOCKS
1073     AFS_GLOCK();
1074 #endif /* RX_ENABLE_LOCKS */
1075     if (afs_termState == AFSOP_STOP_RXK_LISTENER) {
1076         afs_termState = AFSOP_STOP_COMPLETE;
1077         afs_osi_Wakeup(&afs_termState);
1078     }
1079     rxk_ListenerPid = 0;
1080 #if defined(AFS_LINUX22_ENV) || defined(AFS_SUN5_ENV)
1081     afs_osi_Wakeup(&rxk_ListenerPid);
1082 #endif
1083 #ifdef AFS_SUN5_ENV
1084     AFS_GUNLOCK();
1085 #endif /* AFS_SUN5_ENV */
1086 }
1087
1088 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_SUN5_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_XBSD_ENV)
1089 /* The manner of stopping the rx listener thread may vary. Most unix's should
1090  * be able to call soclose.
1091  */
1092 void osi_StopListener(void)
1093 {
1094     soclose(rx_socket);
1095 }
1096 #endif
1097 #endif /* RXK_LISTENER_ENV */
1098
1099 #endif /* !NCR && !UKERNEL */