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