src/rx/OBSD/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 #include "../rx/rx_kcommon.h"
  16
  17 int osi_NetReceive(osi_socket asocket, struct sockaddr_in *addr, struct iovec *dvec,
  18                    int nvecs, int *alength)
  19 {
  20     struct uio u;
  21     int i, code;
  22     struct iovec iov[RX_MAXIOVECS];
  23     struct mbuf *nam = NULL;
  24
  25     int haveGlock = ISAFS_GLOCK();
  26
  27     if (nvecs > RX_MAXIOVECS)
  28         osi_Panic("osi_NetReceive: %d: too many iovecs\n", nvecs);
  29
  30     for (i = 0 ; i < nvecs ; i++) {
  31         iov[i].iov_base = dvec[i].iov_base;
  32         iov[i].iov_len = dvec[i].iov_len;
  33     }
  34
  35     u.uio_iov = &iov[0];
  36     u.uio_iovcnt = nvecs;
  37     u.uio_offset = 0;
  38     u.uio_resid = *alength;
  39     u.uio_segflg = UIO_SYSSPACE;
  40     u.uio_rw = UIO_READ;
  41     u.uio_procp = NULL;
  42
  43     if (haveGlock)
  44         AFS_GUNLOCK();
  45     code = soreceive(asocket, (addr ? &nam : NULL), &u, NULL, NULL, NULL);
  46     if (haveGlock)
  47         AFS_GLOCK();
  48
  49     if (code && afs_termState != AFSOP_STOP_RXK_LISTENER) {
  50         afs_osi_Sleep(&afs_termState);
  51         return code;
  52     }
  53
  54     *alength -= u.uio_resid;
  55     if (addr && nam) {
  56         memcpy(addr, mtod(nam, caddr_t), nam->m_len);
  57         m_freem(nam);
  58     }
  59
  60     return code;
  61 }
  62
  63 extern int rxk_ListenerPid;
  64 void osi_StopListener(void)
  65 {
  66    struct proc *p;
  67
  68    soclose(rx_socket);
  69    p = pfind(rxk_ListenerPid);
  70    if (p)
  71        psignal(p, SIGUSR1);
  72 }
  73
  74 /* rx_NetSend - send asize bytes at adata from asocket to host at addr.
  75  *
  76  * Now, why do we allocate a new buffer when we could theoretically use the one
  77  * pointed to by adata?  Because PRU_SEND returns after queueing the message,
  78  * not after sending it.  If the sender changes the data after queueing it,
  79  * we'd see the already-queued data change.  One attempt to fix this without
  80  * adding a copy would be to have this function wait until the datagram is
  81  * sent; however this doesn't work well.  In particular, if a host is down, and
  82  * an ARP fails to that host, this packet will be queued until the ARP request
  83  * comes back, which could be hours later.  We can't block in this routine that
  84  * long, since it prevents RPC timeouts from happening.
  85  */
  86 /* XXX In the brave new world, steal the data bufs out of the rx_packet iovec,
  87  * and just queue those.  XXX
  88  */
  89
  90
  91 int osi_NetSend(osi_socket asocket, struct sockaddr_in *addr,
  92                 struct iovec *dvec, int nvecs, afs_int32 alength, int istack)
  93 {
  94     int i, code;
  95     struct iovec iov[RX_MAXIOVECS];
  96     struct uio u;
  97     struct mbuf *nam;
  98     int haveGlock = ISAFS_GLOCK();
  99
 100     AFS_STATCNT(osi_NetSend);
 101     if (nvecs > RX_MAXIOVECS)
 102         osi_Panic("osi_NetSend: %d: Too many iovecs.\n", nvecs);
 103
 104     for (i = 0; i < nvecs; i++) {
 105         iov[i].iov_base = dvec[i].iov_base;
 106         iov[i].iov_len = dvec[i].iov_len;
 107     }
 108
 109     u.uio_iov = &iov[0];
 110     u.uio_iovcnt = nvecs;
 111     u.uio_offset = 0;
 112     u.uio_resid = alength;
 113     u.uio_segflg = UIO_SYSSPACE;
 114     u.uio_rw = UIO_WRITE;
 115     u.uio_procp = NULL;
 116
 117     nam = m_get(M_DONTWAIT, MT_SONAME);
 118     if (!nam)
 119         return ENOBUFS;
 120     nam->m_len = addr->sin_len = sizeof(struct sockaddr_in);
 121     memcpy(mtod(nam, caddr_t), addr, addr->sin_len);
 122
 123     if (haveGlock)
 124         AFS_GUNLOCK();
 125     code = sosend(asocket, nam, &u, NULL, NULL, 0);
 126     if (haveGlock)
 127         AFS_GLOCK();
 128     m_freem(nam);
 129
 130     return code;
 131 }