src/rx/SOLARIS/rx_knet.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 #include <afsconfig.h>
  11 #include "../afs/param.h"
  12
  13 RCSID("$Header$");
  14
  15 #ifdef AFS_SUN5_ENV
  16 #include "../rx/rx_kcommon.h"
  17
  18
  19 #ifdef AFS_SUN56_ENV
  20
  21 #include "../inet/common.h"
  22 #include "../sys/tiuser.h"
  23 #include "../sys/t_kuser.h"
  24 #include "../sys/stropts.h"
  25 #include "../sys/stream.h"
  26 #include "../sys/tihdr.h"
  27 #include "../sys/fcntl.h"
  28 #ifdef AFS_SUN58_ENV
  29 #include "../netinet/ip6.h"
  30 #define ipif_local_addr ipif_lcl_addr
  31 #ifndef V4_PART_OF_V6
  32 #define V4_PART_OF_V6(v6)       v6.s6_addr32[3]
  33 #endif
  34 #endif
  35 #include "../inet/ip.h"
  36 #include "../inet/ip_if.h"
  37 #include "../netinet/udp.h"
  38
  39 /*
  40  * Function pointers for kernel socket routines
  41  */
  42 struct sonode *(*sockfs_socreate)
  43     (vnode_t *, int, int, int, int, struct sonode *, int *) = NULL;
  44 struct vnode *(*sockfs_solookup)
  45     (int, int, int, char *, int *) = NULL;
  46 int (*sockfs_sobind)
  47     (struct sonode *, struct sockaddr *, int, int, int) = NULL;
  48 int (*sockfs_sorecvmsg)
  49     (struct sonode *, struct nmsghdr *, struct uio *) = NULL;
  50 int (*sockfs_sosendmsg)
  51     (struct sonode *, struct nmsghdr *, struct uio *) = NULL;
  52 int (*sockfs_sosetsockopt)
  53     (struct sonode *, int, int, void *, int) = NULL;
  54 int (*sockfs_sounbind)
  55     (struct sonode *, int);
  56 void (*sockfs_sockfree)
  57     (struct sonode *);
  58
  59 static afs_uint32 myNetAddrs[ADDRSPERSITE];
  60 static int myNetMTUs[ADDRSPERSITE];
  61 static int numMyNetAddrs = 0;
  62
  63 int
  64 rxi_GetIFInfo()
  65 {
  66     int i = 0;
  67     int different = 0;
  68
  69     ill_t *ill;
  70     ipif_t *ipif;
  71     int rxmtu, maxmtu;
  72
  73     int mtus[ADDRSPERSITE];
  74     afs_uint32 addrs[ADDRSPERSITE];
  75     afs_uint32 ifinaddr;
  76
  77     memset(mtus, 0, sizeof(mtus));
  78     memset(addrs, 0, sizeof(addrs));
  79
  80     for (ill = ill_g_head; ill; ill = ill->ill_next) {
  81 #ifdef AFS_SUN58_ENV
  82         /* Make sure this is an IPv4 ILL */
  83         if (ill->ill_isv6) continue;
  84 #endif
  85
  86         /* Iterate over all the addresses on this ILL */
  87         for (ipif = ill->ill_ipif; ipif; ipif = ipif->ipif_next) {
  88             if (i >= ADDRSPERSITE) break;
  89
  90             /* Ignore addresses which are down.. */
  91             if (!(ipif->ipif_flags & IFF_UP)) continue;
  92
  93             /* Compute the Rx interface MTU */
  94             rxmtu = (ipif->ipif_mtu - RX_IPUDP_SIZE);
  95
  96             ifinaddr = ntohl(ipif->ipif_local_addr);
  97             if (myNetAddrs[i] != ifinaddr)
  98                 different++;
  99
 100             /* Copy interface MTU and address; adjust maxmtu */
 101             mtus[i] = rxmtu;
 102             rxmtu = rxi_AdjustIfMTU(rxmtu);
 103             maxmtu = rxmtu * rxi_nRecvFrags + ((rxi_nRecvFrags-1) *
 104                                                UDP_HDR_SIZE);
 105             maxmtu = rxi_AdjustMaxMTU(rxmtu, maxmtu);
 106             addrs[i] = ifinaddr;
 107             i++;
 108
 109             if (ifinaddr != 0x7f000001 && maxmtu > rx_maxReceiveSize) {
 110                 rx_maxReceiveSize = MIN( RX_MAX_PACKET_SIZE, maxmtu);
 111                 rx_maxReceiveSize = MIN( rx_maxReceiveSize,
 112                                          rx_maxReceiveSizeUser);
 113             }
 114         }
 115     }
 116
 117     rx_maxJumboRecvSize = RX_HEADER_SIZE +
 118                           rxi_nDgramPackets * RX_JUMBOBUFFERSIZE +
 119                           (rxi_nDgramPackets-1) * RX_JUMBOHEADERSIZE;
 120     rx_maxJumboRecvSize = MAX(rx_maxJumboRecvSize, rx_maxReceiveSize);
 121
 122     if (different) {
 123         int j;
 124
 125         for (j = 0; j < i; j++) {
 126             myNetMTUs[j] = mtus[j];
 127             myNetAddrs[j] = addrs[j];
 128         }
 129     }
 130
 131     return different;
 132 }
 133
 134 int rxi_FindIfMTU(afs_uint32 addr)
 135 {
 136     ill_t *ill;
 137     ipif_t *ipif;
 138     afs_uint32 myAddr, netMask;
 139     int match_value = 0;
 140     int mtu = -1;
 141
 142     if (numMyNetAddrs == 0)
 143         rxi_GetIFInfo();
 144     myAddr = ntohl(addr);
 145
 146     if      (IN_CLASSA(myAddr)) netMask = IN_CLASSA_NET;
 147     else if (IN_CLASSB(myAddr)) netMask = IN_CLASSB_NET;
 148     else if (IN_CLASSC(myAddr)) netMask = IN_CLASSC_NET;
 149     else                       netMask = 0;
 150
 151     for (ill = ill_g_head; ill; ill = ill->ill_next) {
 152 #ifdef AFS_SUN58_ENV
 153         /* Make sure this is an IPv4 ILL */
 154         if (ill->ill_isv6) continue;
 155 #endif
 156
 157         /* Iterate over all the addresses on this ILL */
 158         for (ipif = ill->ill_ipif; ipif; ipif = ipif->ipif_next) {
 159             afs_uint32 thisAddr, subnetMask;
 160             int thisMtu;
 161
 162             thisAddr   = ipif->ipif_local_addr;
 163             subnetMask = ipif->ipif_net_mask;
 164             thisMtu    = ipif->ipif_mtu;
 165
 166             if ((myAddr & netMask) == (thisAddr & netMask)) {
 167                 if ((myAddr & subnetMask) == (thisAddr & subnetMask)) {
 168                     if (myAddr == thisAddr) {
 169                         match_value = 4;
 170                         mtu = thisMtu;
 171                     }
 172
 173                     if (match_value < 3) {
 174                         match_value = 3;
 175                         mtu = thisMtu;
 176                     }
 177                 }
 178
 179                 if (match_value < 2) {
 180                     match_value = 2;
 181                     mtu = thisMtu;
 182                 }
 183             }
 184         }
 185     }
 186
 187     return mtu;
 188 }
 189
 190 /* rxi_NewSocket, rxi_FreeSocket and osi_NetSend are from the now defunct
 191  * afs_osinet.c.
 192  */
 193
 194 struct sockaddr_in rx_sockaddr;
 195
 196 /* Allocate a new socket at specified port in network byte order. */
 197 struct osi_socket *rxk_NewSocket(short aport)
 198 {
 199     vnode_t *accessvp;
 200     struct sonode *so;
 201     struct sockaddr_in addr;
 202     int error;
 203     int len;
 204
 205     AFS_STATCNT(osi_NewSocket);
 206
 207     if (sockfs_solookup == NULL) {
 208         sockfs_solookup = (struct vnode *(*)())modlookup("sockfs", "solookup");
 209         if (sockfs_solookup == NULL) {
 210             return NULL;
 211         }
 212     }
 213     if (sockfs_socreate == NULL) {
 214         sockfs_socreate = (struct sonode *(*)())modlookup("sockfs", "socreate");
 215         if (sockfs_socreate == NULL) {
 216             return NULL;
 217         }
 218     }
 219     if (sockfs_sobind == NULL) {
 220         sockfs_sobind = (int (*)())modlookup("sockfs", "sobind");
 221         if (sockfs_sobind == NULL) {
 222             return NULL;
 223         }
 224     }
 225     if (sockfs_sosetsockopt == NULL) {
 226         sockfs_sosetsockopt = (int (*)())modlookup("sockfs", "sosetsockopt");
 227         if (sockfs_sosetsockopt == NULL) {
 228             return NULL;
 229         }
 230     }
 231     if (sockfs_sosendmsg == NULL) {
 232         sockfs_sosendmsg = (int (*)())modlookup("sockfs", "sosendmsg");
 233         if (sockfs_sosendmsg == NULL) {
 234             return NULL;
 235         }
 236     }
 237     if (sockfs_sorecvmsg == NULL) {
 238         sockfs_sorecvmsg = (int (*)())modlookup("sockfs", "sorecvmsg");
 239         if (sockfs_sorecvmsg == NULL) {
 240             return NULL;
 241         }
 242     }
 243     if (sockfs_sounbind == NULL) {
 244         sockfs_sounbind = (int (*)())modlookup("sockfs", "sounbind");
 245         if (sockfs_sounbind == NULL)
 246             return NULL;
 247     }
 248     if (sockfs_sockfree == NULL) {
 249         sockfs_sockfree = (void (*)())modlookup("sockfs", "sockfree");
 250         if (sockfs_sockfree == NULL)
 251             return NULL;
 252     }
 253
 254     accessvp = sockfs_solookup(AF_INET, SOCK_DGRAM, 0, "/dev/udp", &error);
 255     if (accessvp == NULL) {
 256         return NULL;
 257     }
 258
 259     so = sockfs_socreate(accessvp, AF_INET, SOCK_DGRAM, 0,
 260                          SOV_STREAM, NULL, &error);
 261     if (so == NULL) {
 262         return NULL;
 263     }
 264
 265     addr.sin_family = AF_INET;
 266     addr.sin_port = aport;
 267     addr.sin_addr.s_addr = INADDR_ANY;
 268     error = sockfs_sobind(so, (struct sockaddr *)&addr, sizeof(addr), 0, 0);
 269     if (error != 0) {
 270         return NULL;
 271     }
 272
 273     len = rx_UdpBufSize;
 274     error = sockfs_sosetsockopt(so, SOL_SOCKET, SO_SNDBUF, &len, sizeof(len));
 275     if (error != 0) {
 276         return NULL;
 277     }
 278
 279     len = rx_UdpBufSize;
 280     error = sockfs_sosetsockopt(so, SOL_SOCKET, SO_RCVBUF, &len, sizeof(len));
 281     if (error != 0) {
 282         return NULL;
 283     }
 284
 285     return (struct osi_socket *)so;
 286 }
 287
 288 int osi_FreeSocket(register struct osi_socket *asocket)
 289 {
 290     extern int rxk_ListenerPid;
 291     struct sonode *so = (struct sonode *)asocket;
 292     struct sockaddr_in taddr;
 293     struct iovec dvec;
 294     char c;
 295
 296     AFS_STATCNT(osi_FreeSocket);
 297
 298     taddr.sin_family = AF_INET;
 299     taddr.sin_port = htons(rx_port);
 300     taddr.sin_addr.s_addr = htonl(0x7f000001);
 301
 302     dvec.iov_base = &c;
 303     dvec.iov_len = 1;
 304
 305     while (rxk_ListenerPid) {
 306         osi_NetSend(rx_socket, &taddr, &dvec, 1, 1, 0);
 307         afs_osi_Sleep(&rxk_ListenerPid);
 308     }
 309
 310     sockfs_sounbind(so, 0);
 311     sockfs_sockfree(so);
 312     return 0;
 313 }
 314
 315 int osi_NetSend(osi_socket asocket, struct sockaddr_in *addr,
 316         struct iovec *dvec, int nvecs, afs_int32 asize, int istack)
 317 {
 318     struct sonode *so = (struct sonode *)asocket;
 319     struct nmsghdr msg;
 320     struct uio uio;
 321     struct iovec iov[RX_MAXIOVECS];
 322     int error;
 323     int i;
 324
 325     if (nvecs > RX_MAXIOVECS) {
 326         osi_Panic("osi_NetSend: %d: Too many iovecs.\n", nvecs);
 327     }
 328
 329     msg.msg_name = (struct sockaddr *)addr;
 330     msg.msg_namelen = sizeof(struct sockaddr_in);
 331     msg.msg_iov = dvec;
 332     msg.msg_iovlen = nvecs;
 333     msg.msg_control = NULL;
 334     msg.msg_controllen = 0;
 335     msg.msg_flags = 0;
 336
 337     for (i = 0 ; i < nvecs ; i++) {
 338         iov[i].iov_base = dvec[i].iov_base;
 339         iov[i].iov_len = dvec[i].iov_len;
 340     }
 341     uio.uio_iov = &iov[0];
 342     uio.uio_iovcnt = nvecs;
 343     uio.uio_loffset = 0;
 344     uio.uio_segflg = UIO_SYSSPACE;
 345     uio.uio_fmode = FREAD|FWRITE;
 346     uio.uio_limit = 0;
 347     uio.uio_resid = asize;
 348
 349     error = sockfs_sosendmsg(so, &msg, &uio);
 350
 351     return error;
 352 }
 353
 354 int osi_NetReceive(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
 355         int nvecs, int *alength)
 356 {
 357     struct sonode *asocket = (struct sonode *)so;
 358     struct nmsghdr msg;
 359     struct uio uio;
 360     struct iovec iov[RX_MAXIOVECS];
 361     int error;
 362     int i;
 363
 364     if (nvecs > RX_MAXIOVECS) {
 365         osi_Panic("osi_NetSend: %d: Too many iovecs.\n", nvecs);
 366     }
 367
 368     msg.msg_name = NULL;
 369     msg.msg_namelen = sizeof(struct sockaddr_in);
 370     msg.msg_iov = NULL;
 371     msg.msg_iovlen = 0;
 372     msg.msg_control = NULL;
 373     msg.msg_controllen = 0;
 374     msg.msg_flags = 0;
 375
 376     for (i = 0 ; i < nvecs ; i++) {
 377         iov[i].iov_base = dvec[i].iov_base;
 378         iov[i].iov_len = dvec[i].iov_len;
 379     }
 380     uio.uio_iov = &iov[0];
 381     uio.uio_iovcnt = nvecs;
 382     uio.uio_loffset = 0;
 383     uio.uio_segflg = UIO_SYSSPACE;
 384     uio.uio_fmode = 0;
 385     uio.uio_limit = 0;
 386     uio.uio_resid = *alength;
 387
 388     error = sockfs_sorecvmsg(asocket, &msg, &uio);
 389     if (error == 0) {
 390         if (msg.msg_name == NULL) {
 391             error = -1;
 392         } else {
 393             memcpy(addr, msg.msg_name, msg.msg_namelen);
 394             kmem_free(msg.msg_name, msg.msg_namelen);
 395             *alength = *alength - uio.uio_resid;
 396         }
 397     }
 398
 399     if (error == EINTR && ISSIG(curthread, FORREAL)) {
 400         klwp_t *lwp = ttolwp(curthread);
 401         proc_t *p = ttoproc(curthread);
 402         int sig = lwp->lwp_cursig;
 403
 404         if (sig == SIGKILL) {
 405             mutex_enter(&p->p_lock);
 406             p->p_flag &= ~SKILLED;
 407             mutex_exit(&p->p_lock);
 408         }
 409         lwp->lwp_cursig = 0;
 410         if (lwp->lwp_curinfo) {
 411             siginfofree(lwp->lwp_curinfo);
 412             lwp->lwp_curinfo = NULL;
 413         }
 414     }
 415
 416     return error;
 417 }
 418
 419 void shutdown_rxkernel(void)
 420 {
 421 }
 422
 423 void osi_StopListener(void)
 424 {
 425     osi_FreeSocket(rx_socket);
 426 }
 427
 428 #else /* AFS_SUN56_ENV */
 429
 430 #include "../inet/common.h"
 431 #include "../sys/tiuser.h"
 432 #include "../sys/t_kuser.h"
 433 #include "../sys/ioctl.h"
 434 #include "../sys/stropts.h"
 435 #include "../sys/stream.h"
 436 #include "../sys/strsubr.h"
 437 #include "../sys/vnode.h"
 438 #include "../sys/stropts.h"
 439 #include "../sys/tihdr.h"
 440 #include "../sys/timod.h"
 441 #include "../sys/fcntl.h"
 442 #include "../sys/debug.h"
 443 #include "../inet/common.h"
 444 #include "../inet/mi.h"
 445 #include "../netinet/udp.h"
 446
 447 extern dev_t afs_udp_rdev;
 448
 449
 450 int rxi_GetIFInfo()
 451 {
 452     return 0;
 453 }
 454
 455
 456 /* rxi_NewSocket, rxi_FreeSocket and osi_NetSend are from the now defunct
 457  * afs_osinet.c.
 458  */
 459
 460 dev_t afs_udp_rdev = (dev_t)0;
 461
 462 /* Allocate a new socket at specified port in network byte order. */
 463 struct osi_socket *rxk_NewSocket(short aport)
 464 {
 465     TIUSER *udp_tiptr;
 466     struct t_bind *reqp, *rspp;
 467     afs_int32 code;
 468     struct sockaddr_in *myaddrp;
 469     struct stdata *stp;
 470     struct queue *q;
 471
 472     AFS_STATCNT(osi_NewSocket);
 473     afs_udp_rdev = makedevice(11 /*CLONE*/, ddi_name_to_major("udp"));
 474     code = t_kopen(NULL, afs_udp_rdev, FREAD|FWRITE, &udp_tiptr, CRED());
 475     if (code) {
 476         return (struct osi_socket *)0;
 477     }
 478
 479     code = t_kalloc(udp_tiptr, T_BIND, T_ADDR, (char **)&reqp);
 480     if (code) {
 481         t_kclose(udp_tiptr, 0);
 482     }
 483     code = t_kalloc(udp_tiptr, T_BIND, T_ADDR, (char **)&rspp);
 484     if (code) {
 485         t_kfree(udp_tiptr, (char *)reqp, T_BIND);
 486         t_kclose(udp_tiptr, 0);
 487         return (struct osi_socket *)0;
 488     }
 489
 490     reqp->addr.len = sizeof(struct sockaddr_in);
 491     myaddrp = (struct sockaddr_in *) reqp->addr.buf;
 492     myaddrp->sin_family = AF_INET;
 493     myaddrp->sin_port = aport;
 494     myaddrp->sin_addr.s_addr = INADDR_ANY;      /* XXX Was 0 XXX */
 495
 496     code = t_kbind(udp_tiptr, reqp, rspp);
 497     if (code) {
 498         t_kfree(udp_tiptr, (char *)reqp, T_BIND);
 499         t_kfree(udp_tiptr, (char *)rspp, T_BIND);
 500         t_kclose(udp_tiptr, 0);
 501         return (struct osi_socket *)0;
 502     }
 503     if (memcmp(reqp->addr.buf, rspp->addr.buf, rspp->addr.len)) {
 504         t_kfree(udp_tiptr, (char *)reqp, T_BIND);
 505         t_kfree(udp_tiptr, (char *)rspp, T_BIND);
 506         t_kclose(udp_tiptr, 0);
 507         return (struct osi_socket *)0;
 508     }
 509     t_kfree(udp_tiptr, (char *)reqp, T_BIND);
 510     t_kfree(udp_tiptr, (char *)rspp, T_BIND);
 511
 512     /*
 513      * Set the send and receive buffer sizes.
 514      */
 515     stp = udp_tiptr->fp->f_vnode->v_stream;
 516     q = stp->sd_wrq;
 517     q->q_hiwat = rx_UdpBufSize;
 518     q->q_next->q_hiwat = rx_UdpBufSize;
 519     RD(q)->q_hiwat = rx_UdpBufSize;
 520
 521     return (struct osi_socket *) udp_tiptr;
 522 }
 523
 524
 525 int osi_FreeSocket(register struct osi_socket *asocket)
 526 {
 527     extern int rxk_ListenerPid;
 528     TIUSER *udp_tiptr = (TIUSER *) asocket;
 529     AFS_STATCNT(osi_FreeSocket);
 530
 531     if (rxk_ListenerPid) {
 532         kill(rxk_ListenerPid, SIGUSR1);
 533         afs_osi_Sleep(&rxk_ListenerPid);
 534     }
 535     return 0;
 536 }
 537
 538
 539 int osi_NetSend(osi_socket asocket, struct sockaddr_in *addr,
 540                 struct iovec *dvec, int nvecs, afs_int32 asize, int istack)
 541 {
 542     int i;
 543     int code;
 544     TIUSER *udp_tiptr = (TIUSER *) asocket;
 545     struct t_kunitdata *udreq;
 546     struct sockaddr_in sin;
 547     mblk_t *bp;
 548     mblk_t *dbp;
 549
 550     /*
 551      * XXX We don't do any checking on the family since it's assumed to be
 552      * AF_INET XXX
 553      */
 554     sin.sin_family = AF_INET;
 555     sin.sin_addr.s_addr = addr->sin_addr.s_addr;
 556     sin.sin_port = addr->sin_port;
 557
 558     /*
 559      * Get a buffer for the RX header
 560      */
 561     if (nvecs < 1) {
 562         osi_Panic("osi_NetSend, nvecs=%d\n", nvecs);
 563     }
 564     while (!(bp = allocb(dvec[0].iov_len, BPRI_LO))) {
 565         if (strwaitbuf(dvec[i].iov_len, BPRI_LO)) {
 566             return (ENOSR);
 567         }
 568     }
 569
 570     /* Copy the data into the buffer */
 571     memcpy((char *)bp->b_wptr, (char *)dvec[0].iov_base, dvec[0].iov_len);
 572     bp->b_datap->db_type = M_DATA;
 573     bp->b_wptr += dvec[0].iov_len;
 574
 575     /*
 576      * Append each element in the iovec to the buffer
 577      */
 578     for (i = 1 ; i < nvecs ; i++) {
 579         /* Get a buffer for the next chunk */
 580         while (!(dbp = allocb(dvec[i].iov_len, BPRI_LO))) {
 581             if (strwaitbuf(dvec[i].iov_len, BPRI_LO)) {
 582                 freeb(bp);
 583                 return (ENOSR);
 584             }
 585         }
 586
 587         /* Copy the data into the buffer */
 588         memcpy((char *)dbp->b_wptr, (char *)dvec[i].iov_base, dvec[i].iov_len);
 589         dbp->b_datap->db_type = M_DATA;
 590         dbp->b_wptr += dvec[i].iov_len;
 591
 592         /* Append it to the message buffer */
 593         linkb(bp, dbp);
 594     }
 595
 596     /*
 597      * Allocate and format the unitdata structure.
 598      */
 599     code = t_kalloc(udp_tiptr, T_UNITDATA, T_UDATA, (char **)&udreq);
 600     if (code) {
 601         freeb(bp);
 602         printf("osi_NetSend: t_kalloc failed %d\n", code);
 603         return code;
 604     }
 605     udreq->addr.len = sizeof(struct sockaddr_in);
 606     udreq->addr.maxlen = sizeof(struct sockaddr_in);
 607     udreq->addr.buf = (char *)kmem_alloc(sizeof(struct sockaddr_in), KM_SLEEP);
 608     udreq->opt.len = 0;
 609     udreq->opt.maxlen = 0;
 610     memcpy(udreq->addr.buf, (char *)&sin, sizeof(struct sockaddr_in));
 611     udreq->udata.udata_mp = bp;
 612     udreq->udata.len = asize;
 613
 614     code = t_ksndudata(udp_tiptr, udreq, NULL);
 615     if (code) {
 616         printf("osi_NetSend: t_ksndudata failed %d\n", code);
 617     }
 618
 619     t_kfree(udp_tiptr, (caddr_t)udreq, T_UNITDATA);
 620     return code;
 621 }
 622
 623
 624 int osi_NetReceive(struct osi_socket *asocket, struct sockaddr_in *addr,
 625         struct iovec *dvec, int nvecs, int *alength)
 626 {
 627     int i;
 628     TIUSER *udp_tiptr = (TIUSER *) asocket;
 629     struct t_kunitdata *udreq;
 630     mblk_t *dbp;
 631     char *phandle;
 632     short sport;
 633     int code = 0;
 634     int length;
 635     int tlen;
 636     int blen;
 637     char *tbase;
 638     int type;
 639     int error;
 640     int events;
 641
 642     /*
 643      * Allocate the unitdata structure.
 644      */
 645     code = t_kalloc(udp_tiptr, T_UNITDATA, T_UDATA, (char **)&udreq);
 646     if (code) {
 647         printf("osi_NetReceive: t_kalloc failed %d\n", code);
 648         return code;
 649     }
 650     udreq->addr.len = sizeof(struct sockaddr_in);
 651     udreq->addr.maxlen = sizeof(struct sockaddr_in);
 652     udreq->addr.buf = (char *)kmem_alloc(sizeof(struct sockaddr_in), KM_SLEEP);
 653     udreq->opt.len = 0;
 654     udreq->opt.maxlen = 0;
 655
 656     /*
 657      * Loop until we get an error or receive some data.
 658      */
 659     while(1) {
 660         /*
 661          * Wait until there is something to do
 662          */
 663         code = t_kspoll(udp_tiptr, -1, READWAIT, &events);
 664         if (events == 0) {
 665             osi_Panic("osi_NetReceive, infinite t_kspoll timed out\n");
 666         }
 667         /*
 668          * If there is a message then read it in
 669          */
 670         if (code == 0) {
 671             code = t_krcvudata(udp_tiptr, udreq, &type, &error);
 672         }
 673
 674         /*
 675          * Block attempts to kill this thread
 676          */
 677         if (code == EINTR && ISSIG(curthread, FORREAL)) {
 678             klwp_t *lwp = ttolwp(curthread);
 679             proc_t *p = ttoproc(curthread);
 680             int sig = lwp->lwp_cursig;
 681
 682             if (sig == SIGKILL) {
 683                 mutex_enter(&p->p_lock);
 684                 p->p_flag &= ~SKILLED;
 685                 mutex_exit(&p->p_lock);
 686             }
 687             lwp->lwp_cursig = 0;
 688             if (lwp->lwp_curinfo) {
 689                 kmem_free((caddr_t)lwp->lwp_curinfo, sizeof(*lwp->lwp_curinfo));
 690                 lwp->lwp_curinfo = NULL;
 691             }
 692         }
 693
 694         if (code) {
 695             break;
 696         }
 697
 698         /*
 699          * Ignore non-data message types
 700          */
 701         if (type != T_DATA) {
 702             continue;
 703         }
 704
 705         /*
 706          * Save the source address
 707          */
 708         memcpy((char *)addr, udreq->addr.buf, sizeof(struct sockaddr_in));
 709
 710         /*
 711          * Copy out the message buffers, take care not to overflow
 712          * the I/O vector.
 713          */
 714         dbp = udreq->udata.udata_mp;
 715         length = *alength;
 716         for (i = 0 ; dbp != NULL && length > 0 && i < nvecs ; i++) {
 717             tlen = dvec[i].iov_len;
 718             tbase = dvec[i].iov_base;
 719             if (tlen > length) {
 720                 tlen = length;
 721             }
 722             while (dbp != NULL && tlen > 0) {
 723                 blen = dbp->b_wptr - dbp->b_rptr;
 724                 if (blen > tlen) {
 725                     memcpy(tbase, (char *)dbp->b_rptr, tlen);
 726                     length -= tlen;
 727                     dbp->b_rptr += tlen;
 728                     tlen = 0;
 729                 } else {
 730                     memcpy(tbase, (char *)dbp->b_rptr, blen);
 731                     length -= blen;
 732                     tlen -= blen;
 733                     tbase += blen;
 734                     dbp = dbp->b_cont;
 735                 }
 736             }
 737         }
 738         *alength = *alength - length;
 739         break;
 740     }
 741
 742     t_kfree(udp_tiptr, (caddr_t)udreq, T_UNITDATA);
 743     return code;
 744 }
 745
 746
 747 void osi_StopListener(void)
 748 {
 749     osi_FreeSocket(rx_socket);
 750 }
 751
 752
 753 void shutdown_rxkernel(void)
 754 {
 755 }
 756
 757
 758 #endif /* AFS_SUN56_ENV */
 759 #endif /* AFS_SUN5_ENV */