rx: Convert rxinit_status to rx_IsRunning()
[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
14 #include "rx/rx_kcommon.h"
15 #include "rx/rx_atomic.h"
16 #include "rx/rx_internal.h"
17 #include "rx/rx_packet.h"
18 #include "rx/rx_stats.h"
19
20 #ifdef AFS_DARWIN80_ENV
21 #define soclose sock_close
22 #endif
23
24 #ifdef RXK_UPCALL_ENV
25 void
26 rx_upcall(socket_t so, void *arg, __unused int waitflag)
27 {
28     mbuf_t m;
29     int error = 0;
30     int i, flags = 0;
31     struct msghdr msg;
32     struct sockaddr_storage ss;
33     struct sockaddr *sa = NULL;
34     struct sockaddr_in from;
35     struct rx_packet *p;
36     afs_int32 rlen;
37     afs_int32 tlen;
38     afs_int32 savelen;          /* was using rlen but had aliasing problems */
39     size_t nbytes, resid, noffset;
40
41     /* we stopped rx but the socket isn't closed yet */
42     if (!rxi_IsRunning())
43         return;
44
45     /* See if a check for additional packets was issued */
46     rx_CheckPackets();
47
48     p = rxi_AllocPacket(RX_PACKET_CLASS_RECEIVE);
49     rx_computelen(p, tlen);
50     rx_SetDataSize(p, tlen);    /* this is the size of the user data area */
51     tlen += RX_HEADER_SIZE;     /* now this is the size of the entire packet */
52     rlen = rx_maxJumboRecvSize; /* this is what I am advertising.  Only check
53                                  * it once in order to avoid races.  */
54     tlen = rlen - tlen;
55     if (tlen > 0) {
56         tlen = rxi_AllocDataBuf(p, tlen, RX_PACKET_CLASS_RECV_CBUF);
57         if (tlen > 0) {
58             tlen = rlen - tlen;
59         } else
60             tlen = rlen;
61     } else
62         tlen = rlen;
63     /* add some padding to the last iovec, it's just to make sure that the
64      * read doesn't return more data than we expect, and is done to get around
65      * our problems caused by the lack of a length field in the rx header. */
66     savelen = p->wirevec[p->niovecs - 1].iov_len;
67     p->wirevec[p->niovecs - 1].iov_len = savelen + RX_EXTRABUFFERSIZE;
68
69     resid = nbytes = tlen + sizeof(afs_int32);
70
71     memset(&msg, 0, sizeof(struct msghdr));
72     msg.msg_name = &ss;
73     msg.msg_namelen = sizeof(struct sockaddr_storage);
74     sa =(struct sockaddr *) &ss;
75
76     do {
77         m = NULL;
78         error = sock_receivembuf(so, &msg, &m, MSG_DONTWAIT, &nbytes);
79         if (!error) {
80             size_t sz, offset = 0;
81             noffset = 0;
82             resid = nbytes;
83             for (i=0;i<p->niovecs && resid;i++) {
84                 sz=MIN(resid, p->wirevec[i].iov_len);
85                 error = mbuf_copydata(m, offset, sz, p->wirevec[i].iov_base);
86                 if (error)
87                     break;
88                 resid-=sz;
89                 offset+=sz;
90                 noffset += sz;
91             }
92         }
93     } while (0);
94
95     mbuf_freem(m);
96
97     /* restore the vec to its correct state */
98     p->wirevec[p->niovecs - 1].iov_len = savelen;
99
100     if (error == EWOULDBLOCK && noffset > 0)
101         error = 0;
102
103     if (!error) {
104         int host, port;
105
106         nbytes -= resid;
107
108         if (sa->sa_family == AF_INET)
109             from = *(struct sockaddr_in *)sa;
110
111         p->length = nbytes - RX_HEADER_SIZE;;
112         if ((nbytes > tlen) || (p->length & 0x8000)) {  /* Bogus packet */
113             if (nbytes <= 0) {
114                 if (rx_stats_active) {
115                     MUTEX_ENTER(&rx_stats_mutex);
116                     rx_atomic_inc(&rx_stats.bogusPacketOnRead);
117                     rx_stats.bogusHost = from.sin_addr.s_addr;
118                     MUTEX_EXIT(&rx_stats_mutex);
119                 }
120                 dpf(("B: bogus packet from [%x,%d] nb=%d",
121                      from.sin_addr.s_addr, from.sin_port, nbytes));
122             }
123             return;
124         } else {
125             /* Extract packet header. */
126             rxi_DecodePacketHeader(p);
127
128             host = from.sin_addr.s_addr;
129             port = from.sin_port;
130             if (p->header.type > 0 && p->header.type < RX_N_PACKET_TYPES) {
131                 if (rx_stats_active) {
132                     rx_atomic_inc(&rx_stats.packetsRead[p->header.type - 1]);
133                 }
134             }
135
136 #ifdef RX_TRIMDATABUFS
137             /* Free any empty packet buffers at the end of this packet */
138             rxi_TrimDataBufs(p, 1);
139 #endif
140             /* receive pcket */
141             p = rxi_ReceivePacket(p, so, host, port, 0, 0);
142         }
143     }
144     /* free packet? */
145     if (p)
146         rxi_FreePacket(p);
147
148     return;
149 }
150
151 /* in listener env, the listener shutdown does this. we have no listener */
152 void
153 osi_StopNetIfPoller(void)
154 {
155     shutdown_rx();
156     soclose(rx_socket);
157     if (afs_termState == AFSOP_STOP_NETIF) {
158         afs_termState = AFSOP_STOP_COMPLETE;
159         osi_rxWakeup(&afs_termState);
160     }
161 }
162 #elif defined(RXK_LISTENER_ENV)
163 int
164 osi_NetReceive(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
165                int nvecs, int *alength)
166 {
167     int i;
168     struct iovec iov[RX_MAXIOVECS];
169     struct sockaddr *sa = NULL;
170     int code;
171     size_t resid;
172
173     int haveGlock = ISAFS_GLOCK();
174
175 #ifdef AFS_DARWIN80_ENV
176     socket_t asocket = (socket_t)so;
177     struct msghdr msg;
178     struct sockaddr_storage ss;
179     int rlen;
180     mbuf_t m;
181 #else
182     struct socket *asocket = (struct socket *)so;
183     struct uio u;
184     memset(&u, 0, sizeof(u));
185 #endif
186     memset(&iov, 0, sizeof(iov));
187     /*AFS_STATCNT(osi_NetReceive); */
188
189     if (nvecs > RX_MAXIOVECS)
190         osi_Panic("osi_NetReceive: %d: Too many iovecs.\n", nvecs);
191
192     for (i = 0; i < nvecs; i++)
193         iov[i] = dvec[i];
194
195     if ((afs_termState == AFSOP_STOP_RXK_LISTENER) ||
196         (afs_termState == AFSOP_STOP_COMPLETE))
197         return -1;
198
199     if (haveGlock)
200         AFS_GUNLOCK();
201 #if defined(KERNEL_FUNNEL)
202     thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
203 #endif
204 #ifdef AFS_DARWIN80_ENV
205     resid = *alength;
206     memset(&msg, 0, sizeof(struct msghdr));
207     msg.msg_name = &ss;
208     msg.msg_namelen = sizeof(struct sockaddr_storage);
209     sa =(struct sockaddr *) &ss;
210     code = sock_receivembuf(asocket, &msg, &m, 0, alength);
211     if (!code) {
212         size_t offset=0,sz;
213         resid = *alength;
214         for (i=0;i<nvecs && resid;i++) {
215             sz=MIN(resid, iov[i].iov_len);
216             code = mbuf_copydata(m, offset, sz, iov[i].iov_base);
217             if (code)
218                 break;
219             resid-=sz;
220             offset+=sz;
221         }
222     }
223     mbuf_freem(m);
224 #else
225
226     u.uio_iov = &iov[0];
227     u.uio_iovcnt = nvecs;
228     u.uio_offset = 0;
229     u.uio_resid = *alength;
230     u.uio_segflg = UIO_SYSSPACE;
231     u.uio_rw = UIO_READ;
232     u.uio_procp = NULL;
233     code = soreceive(asocket, &sa, &u, NULL, NULL, NULL);
234     resid = u.uio_resid;
235 #endif
236
237 #if defined(KERNEL_FUNNEL)
238     thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);
239 #endif
240     if (haveGlock)
241         AFS_GLOCK();
242
243     if (code)
244         return code;
245     *alength -= resid;
246     if (sa) {
247         if (sa->sa_family == AF_INET) {
248             if (addr)
249                 *addr = *(struct sockaddr_in *)sa;
250         } else
251             printf("Unknown socket family %d in NetReceive\n", sa->sa_family);
252 #ifndef AFS_DARWIN80_ENV
253         FREE(sa, M_SONAME);
254 #endif
255     }
256     return code;
257 }
258
259 extern int rxk_ListenerPid;
260 void
261 osi_StopListener(void)
262 {
263     struct proc *p;
264
265 #if defined(KERNEL_FUNNEL)
266     thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
267 #endif
268     soclose(rx_socket);
269 #if defined(KERNEL_FUNNEL)
270     thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);
271 #endif
272 #ifndef AFS_DARWIN80_ENV
273     p = pfind(rxk_ListenerPid);
274     if (p)
275         psignal(p, SIGUSR1);
276 #endif
277 }
278 #else
279 #error need upcall or listener
280 #endif
281
282 int
283 osi_NetSend(osi_socket so, struct sockaddr_in *addr, struct iovec *dvec,
284             int nvecs, afs_int32 alength, int istack)
285 {
286     afs_int32 code;
287     int i;
288     struct iovec iov[RX_MAXIOVECS];
289     int haveGlock = ISAFS_GLOCK();
290 #ifdef AFS_DARWIN80_ENV
291     socket_t asocket = (socket_t)so;
292     struct msghdr msg;
293     size_t slen;
294 #else
295     struct socket *asocket = (struct socket *)so;
296     struct uio u;
297     memset(&u, 0, sizeof(u));
298 #endif
299     memset(&iov, 0, sizeof(iov));
300
301     AFS_STATCNT(osi_NetSend);
302     if (nvecs > RX_MAXIOVECS)
303         osi_Panic("osi_NetSend: %d: Too many iovecs.\n", nvecs);
304
305     for (i = 0; i < nvecs; i++)
306         iov[i] = dvec[i];
307
308     addr->sin_len = sizeof(struct sockaddr_in);
309
310     if ((afs_termState == AFSOP_STOP_RXK_LISTENER) ||
311         (afs_termState == AFSOP_STOP_COMPLETE))
312         return -1;
313
314     if (haveGlock)
315         AFS_GUNLOCK();
316
317 #if defined(KERNEL_FUNNEL)
318     thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
319 #endif
320 #ifdef AFS_DARWIN80_ENV
321     memset(&msg, 0, sizeof(struct msghdr));
322     msg.msg_name = addr;
323     msg.msg_namelen = ((struct sockaddr *)addr)->sa_len;
324     msg.msg_iov = &iov[0];
325     msg.msg_iovlen = nvecs;
326     code = sock_send(asocket, &msg, 0, &slen);
327 #else
328     u.uio_iov = &iov[0];
329     u.uio_iovcnt = nvecs;
330     u.uio_offset = 0;
331     u.uio_resid = alength;
332     u.uio_segflg = UIO_SYSSPACE;
333     u.uio_rw = UIO_WRITE;
334     u.uio_procp = NULL;
335     code = sosend(asocket, (struct sockaddr *)addr, &u, NULL, NULL, 0);
336 #endif
337
338 #if defined(KERNEL_FUNNEL)
339     thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);
340 #endif
341     if (haveGlock)
342         AFS_GLOCK();
343     return code;
344 }