uipc_socket.c revision 1.20 1 1.20 mycroft /* $NetBSD: uipc_socket.c,v 1.20 1995/08/12 23:59:11 mycroft Exp $ */
2 1.16 cgd
3 1.1 cgd /*
4 1.15 mycroft * Copyright (c) 1982, 1986, 1988, 1990, 1993
5 1.15 mycroft * The Regents of the University of California. All rights reserved.
6 1.1 cgd *
7 1.1 cgd * Redistribution and use in source and binary forms, with or without
8 1.1 cgd * modification, are permitted provided that the following conditions
9 1.1 cgd * are met:
10 1.1 cgd * 1. Redistributions of source code must retain the above copyright
11 1.1 cgd * notice, this list of conditions and the following disclaimer.
12 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
13 1.1 cgd * notice, this list of conditions and the following disclaimer in the
14 1.1 cgd * documentation and/or other materials provided with the distribution.
15 1.1 cgd * 3. All advertising materials mentioning features or use of this software
16 1.1 cgd * must display the following acknowledgement:
17 1.1 cgd * This product includes software developed by the University of
18 1.1 cgd * California, Berkeley and its contributors.
19 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
20 1.1 cgd * may be used to endorse or promote products derived from this software
21 1.1 cgd * without specific prior written permission.
22 1.1 cgd *
23 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 1.1 cgd * SUCH DAMAGE.
34 1.1 cgd *
35 1.16 cgd * @(#)uipc_socket.c 8.3 (Berkeley) 4/15/94
36 1.1 cgd */
37 1.1 cgd
38 1.9 mycroft #include <sys/param.h>
39 1.9 mycroft #include <sys/systm.h>
40 1.9 mycroft #include <sys/proc.h>
41 1.9 mycroft #include <sys/file.h>
42 1.9 mycroft #include <sys/malloc.h>
43 1.9 mycroft #include <sys/mbuf.h>
44 1.9 mycroft #include <sys/domain.h>
45 1.9 mycroft #include <sys/kernel.h>
46 1.9 mycroft #include <sys/protosw.h>
47 1.9 mycroft #include <sys/socket.h>
48 1.9 mycroft #include <sys/socketvar.h>
49 1.9 mycroft #include <sys/resourcevar.h>
50 1.1 cgd
51 1.1 cgd /*
52 1.1 cgd * Socket operation routines.
53 1.1 cgd * These routines are called by the routines in
54 1.1 cgd * sys_socket.c or from a system process, and
55 1.1 cgd * implement the semantics of socket operations by
56 1.1 cgd * switching out to the protocol specific routines.
57 1.1 cgd */
58 1.1 cgd /*ARGSUSED*/
59 1.3 andrew int
60 1.1 cgd socreate(dom, aso, type, proto)
61 1.11 mycroft int dom;
62 1.1 cgd struct socket **aso;
63 1.1 cgd register int type;
64 1.1 cgd int proto;
65 1.1 cgd {
66 1.1 cgd struct proc *p = curproc; /* XXX */
67 1.1 cgd register struct protosw *prp;
68 1.1 cgd register struct socket *so;
69 1.1 cgd register int error;
70 1.1 cgd
71 1.1 cgd if (proto)
72 1.1 cgd prp = pffindproto(dom, proto, type);
73 1.1 cgd else
74 1.1 cgd prp = pffindtype(dom, type);
75 1.15 mycroft if (prp == 0 || prp->pr_usrreq == 0)
76 1.1 cgd return (EPROTONOSUPPORT);
77 1.1 cgd if (prp->pr_type != type)
78 1.1 cgd return (EPROTOTYPE);
79 1.1 cgd MALLOC(so, struct socket *, sizeof(*so), M_SOCKET, M_WAIT);
80 1.1 cgd bzero((caddr_t)so, sizeof(*so));
81 1.1 cgd so->so_type = type;
82 1.1 cgd if (p->p_ucred->cr_uid == 0)
83 1.1 cgd so->so_state = SS_PRIV;
84 1.1 cgd so->so_proto = prp;
85 1.1 cgd error =
86 1.17 cgd (*prp->pr_usrreq)(so, PRU_ATTACH, (struct mbuf *)0,
87 1.17 cgd (struct mbuf *)(long)proto, (struct mbuf *)0);
88 1.1 cgd if (error) {
89 1.1 cgd so->so_state |= SS_NOFDREF;
90 1.1 cgd sofree(so);
91 1.1 cgd return (error);
92 1.1 cgd }
93 1.10 deraadt #ifdef COMPAT_SUNOS
94 1.18 christos {
95 1.18 christos extern struct emul emul_sunos;
96 1.18 christos if (p->p_emul == &emul_sunos && type == SOCK_DGRAM)
97 1.18 christos so->so_options |= SO_BROADCAST;
98 1.18 christos }
99 1.10 deraadt #endif
100 1.1 cgd *aso = so;
101 1.1 cgd return (0);
102 1.1 cgd }
103 1.1 cgd
104 1.3 andrew int
105 1.1 cgd sobind(so, nam)
106 1.1 cgd struct socket *so;
107 1.1 cgd struct mbuf *nam;
108 1.1 cgd {
109 1.20 mycroft int s = splsoftnet();
110 1.1 cgd int error;
111 1.1 cgd
112 1.1 cgd error =
113 1.1 cgd (*so->so_proto->pr_usrreq)(so, PRU_BIND,
114 1.1 cgd (struct mbuf *)0, nam, (struct mbuf *)0);
115 1.1 cgd splx(s);
116 1.1 cgd return (error);
117 1.1 cgd }
118 1.1 cgd
119 1.3 andrew int
120 1.1 cgd solisten(so, backlog)
121 1.1 cgd register struct socket *so;
122 1.1 cgd int backlog;
123 1.1 cgd {
124 1.20 mycroft int s = splsoftnet(), error;
125 1.1 cgd
126 1.1 cgd error =
127 1.1 cgd (*so->so_proto->pr_usrreq)(so, PRU_LISTEN,
128 1.1 cgd (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);
129 1.1 cgd if (error) {
130 1.1 cgd splx(s);
131 1.1 cgd return (error);
132 1.1 cgd }
133 1.1 cgd if (so->so_q == 0)
134 1.1 cgd so->so_options |= SO_ACCEPTCONN;
135 1.1 cgd if (backlog < 0)
136 1.1 cgd backlog = 0;
137 1.1 cgd so->so_qlimit = min(backlog, SOMAXCONN);
138 1.1 cgd splx(s);
139 1.1 cgd return (0);
140 1.1 cgd }
141 1.1 cgd
142 1.3 andrew int
143 1.1 cgd sofree(so)
144 1.1 cgd register struct socket *so;
145 1.1 cgd {
146 1.1 cgd
147 1.1 cgd if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0)
148 1.1 cgd return;
149 1.1 cgd if (so->so_head) {
150 1.1 cgd if (!soqremque(so, 0) && !soqremque(so, 1))
151 1.1 cgd panic("sofree dq");
152 1.1 cgd so->so_head = 0;
153 1.1 cgd }
154 1.1 cgd sbrelease(&so->so_snd);
155 1.1 cgd sorflush(so);
156 1.1 cgd FREE(so, M_SOCKET);
157 1.1 cgd }
158 1.1 cgd
159 1.1 cgd /*
160 1.1 cgd * Close a socket on last file table reference removal.
161 1.1 cgd * Initiate disconnect if connected.
162 1.1 cgd * Free socket when disconnect complete.
163 1.1 cgd */
164 1.3 andrew int
165 1.1 cgd soclose(so)
166 1.1 cgd register struct socket *so;
167 1.1 cgd {
168 1.20 mycroft int s = splsoftnet(); /* conservative */
169 1.1 cgd int error = 0;
170 1.1 cgd
171 1.1 cgd if (so->so_options & SO_ACCEPTCONN) {
172 1.1 cgd while (so->so_q0)
173 1.1 cgd (void) soabort(so->so_q0);
174 1.1 cgd while (so->so_q)
175 1.1 cgd (void) soabort(so->so_q);
176 1.1 cgd }
177 1.1 cgd if (so->so_pcb == 0)
178 1.1 cgd goto discard;
179 1.1 cgd if (so->so_state & SS_ISCONNECTED) {
180 1.1 cgd if ((so->so_state & SS_ISDISCONNECTING) == 0) {
181 1.1 cgd error = sodisconnect(so);
182 1.1 cgd if (error)
183 1.1 cgd goto drop;
184 1.1 cgd }
185 1.1 cgd if (so->so_options & SO_LINGER) {
186 1.1 cgd if ((so->so_state & SS_ISDISCONNECTING) &&
187 1.1 cgd (so->so_state & SS_NBIO))
188 1.1 cgd goto drop;
189 1.1 cgd while (so->so_state & SS_ISCONNECTED)
190 1.1 cgd if (error = tsleep((caddr_t)&so->so_timeo,
191 1.1 cgd PSOCK | PCATCH, netcls, so->so_linger))
192 1.1 cgd break;
193 1.1 cgd }
194 1.1 cgd }
195 1.1 cgd drop:
196 1.1 cgd if (so->so_pcb) {
197 1.1 cgd int error2 =
198 1.1 cgd (*so->so_proto->pr_usrreq)(so, PRU_DETACH,
199 1.1 cgd (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);
200 1.1 cgd if (error == 0)
201 1.1 cgd error = error2;
202 1.1 cgd }
203 1.1 cgd discard:
204 1.1 cgd if (so->so_state & SS_NOFDREF)
205 1.1 cgd panic("soclose: NOFDREF");
206 1.1 cgd so->so_state |= SS_NOFDREF;
207 1.1 cgd sofree(so);
208 1.1 cgd splx(s);
209 1.1 cgd return (error);
210 1.1 cgd }
211 1.1 cgd
212 1.1 cgd /*
213 1.20 mycroft * Must be called at splsoftnet...
214 1.1 cgd */
215 1.3 andrew int
216 1.1 cgd soabort(so)
217 1.1 cgd struct socket *so;
218 1.1 cgd {
219 1.1 cgd
220 1.1 cgd return (
221 1.1 cgd (*so->so_proto->pr_usrreq)(so, PRU_ABORT,
222 1.1 cgd (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0));
223 1.1 cgd }
224 1.1 cgd
225 1.3 andrew int
226 1.1 cgd soaccept(so, nam)
227 1.1 cgd register struct socket *so;
228 1.1 cgd struct mbuf *nam;
229 1.1 cgd {
230 1.20 mycroft int s = splsoftnet();
231 1.1 cgd int error;
232 1.1 cgd
233 1.1 cgd if ((so->so_state & SS_NOFDREF) == 0)
234 1.1 cgd panic("soaccept: !NOFDREF");
235 1.1 cgd so->so_state &= ~SS_NOFDREF;
236 1.1 cgd error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT,
237 1.1 cgd (struct mbuf *)0, nam, (struct mbuf *)0);
238 1.1 cgd splx(s);
239 1.1 cgd return (error);
240 1.1 cgd }
241 1.1 cgd
242 1.3 andrew int
243 1.1 cgd soconnect(so, nam)
244 1.1 cgd register struct socket *so;
245 1.1 cgd struct mbuf *nam;
246 1.1 cgd {
247 1.1 cgd int s;
248 1.1 cgd int error;
249 1.1 cgd
250 1.1 cgd if (so->so_options & SO_ACCEPTCONN)
251 1.1 cgd return (EOPNOTSUPP);
252 1.20 mycroft s = splsoftnet();
253 1.1 cgd /*
254 1.1 cgd * If protocol is connection-based, can only connect once.
255 1.1 cgd * Otherwise, if connected, try to disconnect first.
256 1.1 cgd * This allows user to disconnect by connecting to, e.g.,
257 1.1 cgd * a null address.
258 1.1 cgd */
259 1.1 cgd if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
260 1.1 cgd ((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
261 1.1 cgd (error = sodisconnect(so))))
262 1.1 cgd error = EISCONN;
263 1.1 cgd else
264 1.1 cgd error = (*so->so_proto->pr_usrreq)(so, PRU_CONNECT,
265 1.1 cgd (struct mbuf *)0, nam, (struct mbuf *)0);
266 1.1 cgd splx(s);
267 1.1 cgd return (error);
268 1.1 cgd }
269 1.1 cgd
270 1.3 andrew int
271 1.1 cgd soconnect2(so1, so2)
272 1.1 cgd register struct socket *so1;
273 1.1 cgd struct socket *so2;
274 1.1 cgd {
275 1.20 mycroft int s = splsoftnet();
276 1.1 cgd int error;
277 1.1 cgd
278 1.1 cgd error = (*so1->so_proto->pr_usrreq)(so1, PRU_CONNECT2,
279 1.1 cgd (struct mbuf *)0, (struct mbuf *)so2, (struct mbuf *)0);
280 1.1 cgd splx(s);
281 1.1 cgd return (error);
282 1.1 cgd }
283 1.1 cgd
284 1.3 andrew int
285 1.1 cgd sodisconnect(so)
286 1.1 cgd register struct socket *so;
287 1.1 cgd {
288 1.20 mycroft int s = splsoftnet();
289 1.1 cgd int error;
290 1.1 cgd
291 1.1 cgd if ((so->so_state & SS_ISCONNECTED) == 0) {
292 1.1 cgd error = ENOTCONN;
293 1.1 cgd goto bad;
294 1.1 cgd }
295 1.1 cgd if (so->so_state & SS_ISDISCONNECTING) {
296 1.1 cgd error = EALREADY;
297 1.1 cgd goto bad;
298 1.1 cgd }
299 1.1 cgd error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT,
300 1.1 cgd (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);
301 1.1 cgd bad:
302 1.1 cgd splx(s);
303 1.1 cgd return (error);
304 1.1 cgd }
305 1.1 cgd
306 1.15 mycroft #define SBLOCKWAIT(f) (((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
307 1.1 cgd /*
308 1.1 cgd * Send on a socket.
309 1.1 cgd * If send must go all at once and message is larger than
310 1.1 cgd * send buffering, then hard error.
311 1.1 cgd * Lock against other senders.
312 1.1 cgd * If must go all at once and not enough room now, then
313 1.1 cgd * inform user that this would block and do nothing.
314 1.1 cgd * Otherwise, if nonblocking, send as much as possible.
315 1.1 cgd * The data to be sent is described by "uio" if nonzero,
316 1.1 cgd * otherwise by the mbuf chain "top" (which must be null
317 1.1 cgd * if uio is not). Data provided in mbuf chain must be small
318 1.1 cgd * enough to send all at once.
319 1.1 cgd *
320 1.1 cgd * Returns nonzero on error, timeout or signal; callers
321 1.1 cgd * must check for short counts if EINTR/ERESTART are returned.
322 1.1 cgd * Data and control buffers are freed on return.
323 1.1 cgd */
324 1.3 andrew int
325 1.1 cgd sosend(so, addr, uio, top, control, flags)
326 1.1 cgd register struct socket *so;
327 1.1 cgd struct mbuf *addr;
328 1.1 cgd struct uio *uio;
329 1.1 cgd struct mbuf *top;
330 1.1 cgd struct mbuf *control;
331 1.1 cgd int flags;
332 1.1 cgd {
333 1.15 mycroft struct proc *p = curproc; /* XXX */
334 1.1 cgd struct mbuf **mp;
335 1.1 cgd register struct mbuf *m;
336 1.1 cgd register long space, len, resid;
337 1.1 cgd int clen = 0, error, s, dontroute, mlen;
338 1.1 cgd int atomic = sosendallatonce(so) || top;
339 1.1 cgd
340 1.1 cgd if (uio)
341 1.1 cgd resid = uio->uio_resid;
342 1.1 cgd else
343 1.1 cgd resid = top->m_pkthdr.len;
344 1.7 cgd /*
345 1.7 cgd * In theory resid should be unsigned.
346 1.7 cgd * However, space must be signed, as it might be less than 0
347 1.7 cgd * if we over-committed, and we must use a signed comparison
348 1.7 cgd * of space and resid. On the other hand, a negative resid
349 1.7 cgd * causes us to loop sending 0-length segments to the protocol.
350 1.7 cgd */
351 1.7 cgd if (resid < 0)
352 1.7 cgd return (EINVAL);
353 1.1 cgd dontroute =
354 1.1 cgd (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
355 1.1 cgd (so->so_proto->pr_flags & PR_ATOMIC);
356 1.12 mycroft p->p_stats->p_ru.ru_msgsnd++;
357 1.1 cgd if (control)
358 1.1 cgd clen = control->m_len;
359 1.1 cgd #define snderr(errno) { error = errno; splx(s); goto release; }
360 1.1 cgd
361 1.1 cgd restart:
362 1.15 mycroft if (error = sblock(&so->so_snd, SBLOCKWAIT(flags)))
363 1.1 cgd goto out;
364 1.1 cgd do {
365 1.20 mycroft s = splsoftnet();
366 1.1 cgd if (so->so_state & SS_CANTSENDMORE)
367 1.1 cgd snderr(EPIPE);
368 1.1 cgd if (so->so_error)
369 1.1 cgd snderr(so->so_error);
370 1.1 cgd if ((so->so_state & SS_ISCONNECTED) == 0) {
371 1.1 cgd if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
372 1.1 cgd if ((so->so_state & SS_ISCONFIRMING) == 0 &&
373 1.1 cgd !(resid == 0 && clen != 0))
374 1.1 cgd snderr(ENOTCONN);
375 1.1 cgd } else if (addr == 0)
376 1.1 cgd snderr(EDESTADDRREQ);
377 1.1 cgd }
378 1.1 cgd space = sbspace(&so->so_snd);
379 1.1 cgd if (flags & MSG_OOB)
380 1.1 cgd space += 1024;
381 1.11 mycroft if (atomic && resid > so->so_snd.sb_hiwat ||
382 1.11 mycroft clen > so->so_snd.sb_hiwat)
383 1.11 mycroft snderr(EMSGSIZE);
384 1.11 mycroft if (space < resid + clen && uio &&
385 1.1 cgd (atomic || space < so->so_snd.sb_lowat || space < clen)) {
386 1.1 cgd if (so->so_state & SS_NBIO)
387 1.1 cgd snderr(EWOULDBLOCK);
388 1.1 cgd sbunlock(&so->so_snd);
389 1.1 cgd error = sbwait(&so->so_snd);
390 1.1 cgd splx(s);
391 1.1 cgd if (error)
392 1.1 cgd goto out;
393 1.1 cgd goto restart;
394 1.1 cgd }
395 1.1 cgd splx(s);
396 1.1 cgd mp = ⊤
397 1.1 cgd space -= clen;
398 1.1 cgd do {
399 1.1 cgd if (uio == NULL) {
400 1.1 cgd /*
401 1.1 cgd * Data is prepackaged in "top".
402 1.1 cgd */
403 1.1 cgd resid = 0;
404 1.1 cgd if (flags & MSG_EOR)
405 1.1 cgd top->m_flags |= M_EOR;
406 1.1 cgd } else do {
407 1.1 cgd if (top == 0) {
408 1.1 cgd MGETHDR(m, M_WAIT, MT_DATA);
409 1.1 cgd mlen = MHLEN;
410 1.1 cgd m->m_pkthdr.len = 0;
411 1.1 cgd m->m_pkthdr.rcvif = (struct ifnet *)0;
412 1.1 cgd } else {
413 1.1 cgd MGET(m, M_WAIT, MT_DATA);
414 1.1 cgd mlen = MLEN;
415 1.1 cgd }
416 1.15 mycroft if (resid >= MINCLSIZE && space >= MCLBYTES) {
417 1.1 cgd MCLGET(m, M_WAIT);
418 1.1 cgd if ((m->m_flags & M_EXT) == 0)
419 1.1 cgd goto nopages;
420 1.1 cgd mlen = MCLBYTES;
421 1.15 mycroft #ifdef MAPPED_MBUFS
422 1.15 mycroft len = min(MCLBYTES, resid);
423 1.15 mycroft #else
424 1.15 mycroft if (atomic && top == 0) {
425 1.15 mycroft len = min(MCLBYTES - max_hdr, resid);
426 1.15 mycroft m->m_data += max_hdr;
427 1.15 mycroft } else
428 1.15 mycroft len = min(MCLBYTES, resid);
429 1.15 mycroft #endif
430 1.15 mycroft space -= MCLBYTES;
431 1.1 cgd } else {
432 1.1 cgd nopages:
433 1.1 cgd len = min(min(mlen, resid), space);
434 1.15 mycroft space -= len;
435 1.1 cgd /*
436 1.1 cgd * For datagram protocols, leave room
437 1.1 cgd * for protocol headers in first mbuf.
438 1.1 cgd */
439 1.1 cgd if (atomic && top == 0 && len < mlen)
440 1.1 cgd MH_ALIGN(m, len);
441 1.1 cgd }
442 1.1 cgd error = uiomove(mtod(m, caddr_t), (int)len, uio);
443 1.1 cgd resid = uio->uio_resid;
444 1.1 cgd m->m_len = len;
445 1.1 cgd *mp = m;
446 1.1 cgd top->m_pkthdr.len += len;
447 1.1 cgd if (error)
448 1.1 cgd goto release;
449 1.1 cgd mp = &m->m_next;
450 1.1 cgd if (resid <= 0) {
451 1.1 cgd if (flags & MSG_EOR)
452 1.1 cgd top->m_flags |= M_EOR;
453 1.1 cgd break;
454 1.1 cgd }
455 1.1 cgd } while (space > 0 && atomic);
456 1.1 cgd if (dontroute)
457 1.1 cgd so->so_options |= SO_DONTROUTE;
458 1.20 mycroft s = splsoftnet(); /* XXX */
459 1.1 cgd error = (*so->so_proto->pr_usrreq)(so,
460 1.1 cgd (flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND,
461 1.1 cgd top, addr, control);
462 1.1 cgd splx(s);
463 1.1 cgd if (dontroute)
464 1.1 cgd so->so_options &= ~SO_DONTROUTE;
465 1.1 cgd clen = 0;
466 1.1 cgd control = 0;
467 1.1 cgd top = 0;
468 1.1 cgd mp = ⊤
469 1.1 cgd if (error)
470 1.1 cgd goto release;
471 1.1 cgd } while (resid && space > 0);
472 1.1 cgd } while (resid);
473 1.1 cgd
474 1.1 cgd release:
475 1.1 cgd sbunlock(&so->so_snd);
476 1.1 cgd out:
477 1.1 cgd if (top)
478 1.1 cgd m_freem(top);
479 1.1 cgd if (control)
480 1.1 cgd m_freem(control);
481 1.1 cgd return (error);
482 1.1 cgd }
483 1.1 cgd
484 1.1 cgd /*
485 1.1 cgd * Implement receive operations on a socket.
486 1.1 cgd * We depend on the way that records are added to the sockbuf
487 1.1 cgd * by sbappend*. In particular, each record (mbufs linked through m_next)
488 1.1 cgd * must begin with an address if the protocol so specifies,
489 1.1 cgd * followed by an optional mbuf or mbufs containing ancillary data,
490 1.1 cgd * and then zero or more mbufs of data.
491 1.1 cgd * In order to avoid blocking network interrupts for the entire time here,
492 1.1 cgd * we splx() while doing the actual copy to user space.
493 1.1 cgd * Although the sockbuf is locked, new data may still be appended,
494 1.1 cgd * and thus we must maintain consistency of the sockbuf during that time.
495 1.1 cgd *
496 1.1 cgd * The caller may receive the data as a single mbuf chain by supplying
497 1.1 cgd * an mbuf **mp0 for use in returning the chain. The uio is then used
498 1.1 cgd * only for the count in uio_resid.
499 1.1 cgd */
500 1.3 andrew int
501 1.1 cgd soreceive(so, paddr, uio, mp0, controlp, flagsp)
502 1.1 cgd register struct socket *so;
503 1.1 cgd struct mbuf **paddr;
504 1.1 cgd struct uio *uio;
505 1.1 cgd struct mbuf **mp0;
506 1.1 cgd struct mbuf **controlp;
507 1.1 cgd int *flagsp;
508 1.1 cgd {
509 1.1 cgd register struct mbuf *m, **mp;
510 1.1 cgd register int flags, len, error, s, offset;
511 1.1 cgd struct protosw *pr = so->so_proto;
512 1.1 cgd struct mbuf *nextrecord;
513 1.1 cgd int moff, type;
514 1.3 andrew int orig_resid = uio->uio_resid;
515 1.1 cgd
516 1.1 cgd mp = mp0;
517 1.1 cgd if (paddr)
518 1.1 cgd *paddr = 0;
519 1.1 cgd if (controlp)
520 1.1 cgd *controlp = 0;
521 1.1 cgd if (flagsp)
522 1.1 cgd flags = *flagsp &~ MSG_EOR;
523 1.1 cgd else
524 1.1 cgd flags = 0;
525 1.1 cgd if (flags & MSG_OOB) {
526 1.1 cgd m = m_get(M_WAIT, MT_DATA);
527 1.17 cgd error = (*pr->pr_usrreq)(so, PRU_RCVOOB, m,
528 1.17 cgd (struct mbuf *)(long)(flags & MSG_PEEK), (struct mbuf *)0);
529 1.1 cgd if (error)
530 1.1 cgd goto bad;
531 1.1 cgd do {
532 1.1 cgd error = uiomove(mtod(m, caddr_t),
533 1.1 cgd (int) min(uio->uio_resid, m->m_len), uio);
534 1.1 cgd m = m_free(m);
535 1.1 cgd } while (uio->uio_resid && error == 0 && m);
536 1.1 cgd bad:
537 1.1 cgd if (m)
538 1.1 cgd m_freem(m);
539 1.1 cgd return (error);
540 1.1 cgd }
541 1.1 cgd if (mp)
542 1.1 cgd *mp = (struct mbuf *)0;
543 1.1 cgd if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)
544 1.1 cgd (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
545 1.1 cgd (struct mbuf *)0, (struct mbuf *)0);
546 1.1 cgd
547 1.1 cgd restart:
548 1.15 mycroft if (error = sblock(&so->so_rcv, SBLOCKWAIT(flags)))
549 1.1 cgd return (error);
550 1.20 mycroft s = splsoftnet();
551 1.1 cgd
552 1.1 cgd m = so->so_rcv.sb_mb;
553 1.1 cgd /*
554 1.1 cgd * If we have less data than requested, block awaiting more
555 1.1 cgd * (subject to any timeout) if:
556 1.15 mycroft * 1. the current count is less than the low water mark,
557 1.1 cgd * 2. MSG_WAITALL is set, and it is possible to do the entire
558 1.15 mycroft * receive operation at once if we block (resid <= hiwat), or
559 1.15 mycroft * 3. MSG_DONTWAIT is not set.
560 1.1 cgd * If MSG_WAITALL is set but resid is larger than the receive buffer,
561 1.1 cgd * we have to do the receive in sections, and thus risk returning
562 1.1 cgd * a short count if a timeout or signal occurs after we start.
563 1.1 cgd */
564 1.15 mycroft if (m == 0 || ((flags & MSG_DONTWAIT) == 0 &&
565 1.15 mycroft so->so_rcv.sb_cc < uio->uio_resid) &&
566 1.1 cgd (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
567 1.1 cgd ((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
568 1.3 andrew m->m_nextpkt == 0 && (pr->pr_flags & PR_ATOMIC) == 0) {
569 1.1 cgd #ifdef DIAGNOSTIC
570 1.1 cgd if (m == 0 && so->so_rcv.sb_cc)
571 1.1 cgd panic("receive 1");
572 1.1 cgd #endif
573 1.1 cgd if (so->so_error) {
574 1.1 cgd if (m)
575 1.15 mycroft goto dontblock;
576 1.1 cgd error = so->so_error;
577 1.1 cgd if ((flags & MSG_PEEK) == 0)
578 1.1 cgd so->so_error = 0;
579 1.1 cgd goto release;
580 1.1 cgd }
581 1.1 cgd if (so->so_state & SS_CANTRCVMORE) {
582 1.1 cgd if (m)
583 1.15 mycroft goto dontblock;
584 1.1 cgd else
585 1.1 cgd goto release;
586 1.1 cgd }
587 1.1 cgd for (; m; m = m->m_next)
588 1.1 cgd if (m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)) {
589 1.1 cgd m = so->so_rcv.sb_mb;
590 1.1 cgd goto dontblock;
591 1.1 cgd }
592 1.1 cgd if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
593 1.1 cgd (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
594 1.1 cgd error = ENOTCONN;
595 1.1 cgd goto release;
596 1.1 cgd }
597 1.1 cgd if (uio->uio_resid == 0)
598 1.1 cgd goto release;
599 1.15 mycroft if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)) {
600 1.1 cgd error = EWOULDBLOCK;
601 1.1 cgd goto release;
602 1.1 cgd }
603 1.1 cgd sbunlock(&so->so_rcv);
604 1.1 cgd error = sbwait(&so->so_rcv);
605 1.1 cgd splx(s);
606 1.1 cgd if (error)
607 1.1 cgd return (error);
608 1.1 cgd goto restart;
609 1.1 cgd }
610 1.1 cgd dontblock:
611 1.15 mycroft #ifdef notyet /* XXXX */
612 1.15 mycroft if (uio->uio_procp)
613 1.15 mycroft uio->uio_procp->p_stats->p_ru.ru_msgrcv++;
614 1.15 mycroft #endif
615 1.1 cgd nextrecord = m->m_nextpkt;
616 1.1 cgd if (pr->pr_flags & PR_ADDR) {
617 1.1 cgd #ifdef DIAGNOSTIC
618 1.1 cgd if (m->m_type != MT_SONAME)
619 1.1 cgd panic("receive 1a");
620 1.1 cgd #endif
621 1.3 andrew orig_resid = 0;
622 1.1 cgd if (flags & MSG_PEEK) {
623 1.1 cgd if (paddr)
624 1.1 cgd *paddr = m_copy(m, 0, m->m_len);
625 1.1 cgd m = m->m_next;
626 1.1 cgd } else {
627 1.1 cgd sbfree(&so->so_rcv, m);
628 1.1 cgd if (paddr) {
629 1.1 cgd *paddr = m;
630 1.1 cgd so->so_rcv.sb_mb = m->m_next;
631 1.1 cgd m->m_next = 0;
632 1.1 cgd m = so->so_rcv.sb_mb;
633 1.1 cgd } else {
634 1.1 cgd MFREE(m, so->so_rcv.sb_mb);
635 1.1 cgd m = so->so_rcv.sb_mb;
636 1.1 cgd }
637 1.1 cgd }
638 1.1 cgd }
639 1.1 cgd while (m && m->m_type == MT_CONTROL && error == 0) {
640 1.1 cgd if (flags & MSG_PEEK) {
641 1.1 cgd if (controlp)
642 1.1 cgd *controlp = m_copy(m, 0, m->m_len);
643 1.1 cgd m = m->m_next;
644 1.1 cgd } else {
645 1.1 cgd sbfree(&so->so_rcv, m);
646 1.1 cgd if (controlp) {
647 1.1 cgd if (pr->pr_domain->dom_externalize &&
648 1.1 cgd mtod(m, struct cmsghdr *)->cmsg_type ==
649 1.1 cgd SCM_RIGHTS)
650 1.1 cgd error = (*pr->pr_domain->dom_externalize)(m);
651 1.1 cgd *controlp = m;
652 1.1 cgd so->so_rcv.sb_mb = m->m_next;
653 1.1 cgd m->m_next = 0;
654 1.1 cgd m = so->so_rcv.sb_mb;
655 1.1 cgd } else {
656 1.1 cgd MFREE(m, so->so_rcv.sb_mb);
657 1.1 cgd m = so->so_rcv.sb_mb;
658 1.1 cgd }
659 1.1 cgd }
660 1.3 andrew if (controlp) {
661 1.3 andrew orig_resid = 0;
662 1.1 cgd controlp = &(*controlp)->m_next;
663 1.3 andrew }
664 1.1 cgd }
665 1.1 cgd if (m) {
666 1.1 cgd if ((flags & MSG_PEEK) == 0)
667 1.1 cgd m->m_nextpkt = nextrecord;
668 1.1 cgd type = m->m_type;
669 1.1 cgd if (type == MT_OOBDATA)
670 1.1 cgd flags |= MSG_OOB;
671 1.1 cgd }
672 1.1 cgd moff = 0;
673 1.1 cgd offset = 0;
674 1.1 cgd while (m && uio->uio_resid > 0 && error == 0) {
675 1.1 cgd if (m->m_type == MT_OOBDATA) {
676 1.1 cgd if (type != MT_OOBDATA)
677 1.1 cgd break;
678 1.1 cgd } else if (type == MT_OOBDATA)
679 1.1 cgd break;
680 1.1 cgd #ifdef DIAGNOSTIC
681 1.1 cgd else if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
682 1.1 cgd panic("receive 3");
683 1.1 cgd #endif
684 1.1 cgd so->so_state &= ~SS_RCVATMARK;
685 1.1 cgd len = uio->uio_resid;
686 1.1 cgd if (so->so_oobmark && len > so->so_oobmark - offset)
687 1.1 cgd len = so->so_oobmark - offset;
688 1.1 cgd if (len > m->m_len - moff)
689 1.1 cgd len = m->m_len - moff;
690 1.1 cgd /*
691 1.1 cgd * If mp is set, just pass back the mbufs.
692 1.1 cgd * Otherwise copy them out via the uio, then free.
693 1.1 cgd * Sockbuf must be consistent here (points to current mbuf,
694 1.1 cgd * it points to next record) when we drop priority;
695 1.1 cgd * we must note any additions to the sockbuf when we
696 1.1 cgd * block interrupts again.
697 1.1 cgd */
698 1.1 cgd if (mp == 0) {
699 1.1 cgd splx(s);
700 1.1 cgd error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio);
701 1.20 mycroft s = splsoftnet();
702 1.1 cgd } else
703 1.1 cgd uio->uio_resid -= len;
704 1.1 cgd if (len == m->m_len - moff) {
705 1.1 cgd if (m->m_flags & M_EOR)
706 1.1 cgd flags |= MSG_EOR;
707 1.1 cgd if (flags & MSG_PEEK) {
708 1.1 cgd m = m->m_next;
709 1.1 cgd moff = 0;
710 1.1 cgd } else {
711 1.1 cgd nextrecord = m->m_nextpkt;
712 1.1 cgd sbfree(&so->so_rcv, m);
713 1.1 cgd if (mp) {
714 1.1 cgd *mp = m;
715 1.1 cgd mp = &m->m_next;
716 1.1 cgd so->so_rcv.sb_mb = m = m->m_next;
717 1.1 cgd *mp = (struct mbuf *)0;
718 1.1 cgd } else {
719 1.1 cgd MFREE(m, so->so_rcv.sb_mb);
720 1.1 cgd m = so->so_rcv.sb_mb;
721 1.1 cgd }
722 1.1 cgd if (m)
723 1.1 cgd m->m_nextpkt = nextrecord;
724 1.1 cgd }
725 1.1 cgd } else {
726 1.1 cgd if (flags & MSG_PEEK)
727 1.1 cgd moff += len;
728 1.1 cgd else {
729 1.1 cgd if (mp)
730 1.1 cgd *mp = m_copym(m, 0, len, M_WAIT);
731 1.1 cgd m->m_data += len;
732 1.1 cgd m->m_len -= len;
733 1.1 cgd so->so_rcv.sb_cc -= len;
734 1.1 cgd }
735 1.1 cgd }
736 1.1 cgd if (so->so_oobmark) {
737 1.1 cgd if ((flags & MSG_PEEK) == 0) {
738 1.1 cgd so->so_oobmark -= len;
739 1.1 cgd if (so->so_oobmark == 0) {
740 1.1 cgd so->so_state |= SS_RCVATMARK;
741 1.1 cgd break;
742 1.1 cgd }
743 1.7 cgd } else {
744 1.1 cgd offset += len;
745 1.7 cgd if (offset == so->so_oobmark)
746 1.7 cgd break;
747 1.7 cgd }
748 1.1 cgd }
749 1.1 cgd if (flags & MSG_EOR)
750 1.1 cgd break;
751 1.1 cgd /*
752 1.1 cgd * If the MSG_WAITALL flag is set (for non-atomic socket),
753 1.1 cgd * we must not quit until "uio->uio_resid == 0" or an error
754 1.1 cgd * termination. If a signal/timeout occurs, return
755 1.1 cgd * with a short count but without error.
756 1.1 cgd * Keep sockbuf locked against other readers.
757 1.1 cgd */
758 1.1 cgd while (flags & MSG_WAITALL && m == 0 && uio->uio_resid > 0 &&
759 1.3 andrew !sosendallatonce(so) && !nextrecord) {
760 1.1 cgd if (so->so_error || so->so_state & SS_CANTRCVMORE)
761 1.1 cgd break;
762 1.1 cgd error = sbwait(&so->so_rcv);
763 1.1 cgd if (error) {
764 1.1 cgd sbunlock(&so->so_rcv);
765 1.1 cgd splx(s);
766 1.1 cgd return (0);
767 1.1 cgd }
768 1.1 cgd if (m = so->so_rcv.sb_mb)
769 1.1 cgd nextrecord = m->m_nextpkt;
770 1.1 cgd }
771 1.1 cgd }
772 1.3 andrew
773 1.3 andrew if (m && pr->pr_flags & PR_ATOMIC) {
774 1.3 andrew flags |= MSG_TRUNC;
775 1.3 andrew if ((flags & MSG_PEEK) == 0)
776 1.3 andrew (void) sbdroprecord(&so->so_rcv);
777 1.3 andrew }
778 1.1 cgd if ((flags & MSG_PEEK) == 0) {
779 1.1 cgd if (m == 0)
780 1.1 cgd so->so_rcv.sb_mb = nextrecord;
781 1.1 cgd if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
782 1.1 cgd (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
783 1.17 cgd (struct mbuf *)(long)flags, (struct mbuf *)0,
784 1.1 cgd (struct mbuf *)0);
785 1.1 cgd }
786 1.3 andrew if (orig_resid == uio->uio_resid && orig_resid &&
787 1.3 andrew (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
788 1.3 andrew sbunlock(&so->so_rcv);
789 1.3 andrew splx(s);
790 1.3 andrew goto restart;
791 1.3 andrew }
792 1.3 andrew
793 1.1 cgd if (flagsp)
794 1.1 cgd *flagsp |= flags;
795 1.1 cgd release:
796 1.1 cgd sbunlock(&so->so_rcv);
797 1.1 cgd splx(s);
798 1.1 cgd return (error);
799 1.1 cgd }
800 1.1 cgd
801 1.14 mycroft int
802 1.1 cgd soshutdown(so, how)
803 1.1 cgd register struct socket *so;
804 1.1 cgd register int how;
805 1.1 cgd {
806 1.1 cgd register struct protosw *pr = so->so_proto;
807 1.1 cgd
808 1.1 cgd how++;
809 1.1 cgd if (how & FREAD)
810 1.1 cgd sorflush(so);
811 1.1 cgd if (how & FWRITE)
812 1.1 cgd return ((*pr->pr_usrreq)(so, PRU_SHUTDOWN,
813 1.1 cgd (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0));
814 1.1 cgd return (0);
815 1.1 cgd }
816 1.1 cgd
817 1.14 mycroft void
818 1.1 cgd sorflush(so)
819 1.1 cgd register struct socket *so;
820 1.1 cgd {
821 1.1 cgd register struct sockbuf *sb = &so->so_rcv;
822 1.1 cgd register struct protosw *pr = so->so_proto;
823 1.1 cgd register int s;
824 1.1 cgd struct sockbuf asb;
825 1.1 cgd
826 1.1 cgd sb->sb_flags |= SB_NOINTR;
827 1.15 mycroft (void) sblock(sb, M_WAITOK);
828 1.1 cgd s = splimp();
829 1.1 cgd socantrcvmore(so);
830 1.1 cgd sbunlock(sb);
831 1.1 cgd asb = *sb;
832 1.1 cgd bzero((caddr_t)sb, sizeof (*sb));
833 1.1 cgd splx(s);
834 1.1 cgd if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose)
835 1.1 cgd (*pr->pr_domain->dom_dispose)(asb.sb_mb);
836 1.1 cgd sbrelease(&asb);
837 1.1 cgd }
838 1.1 cgd
839 1.14 mycroft int
840 1.1 cgd sosetopt(so, level, optname, m0)
841 1.1 cgd register struct socket *so;
842 1.1 cgd int level, optname;
843 1.1 cgd struct mbuf *m0;
844 1.1 cgd {
845 1.1 cgd int error = 0;
846 1.1 cgd register struct mbuf *m = m0;
847 1.1 cgd
848 1.1 cgd if (level != SOL_SOCKET) {
849 1.1 cgd if (so->so_proto && so->so_proto->pr_ctloutput)
850 1.1 cgd return ((*so->so_proto->pr_ctloutput)
851 1.1 cgd (PRCO_SETOPT, so, level, optname, &m0));
852 1.1 cgd error = ENOPROTOOPT;
853 1.1 cgd } else {
854 1.1 cgd switch (optname) {
855 1.1 cgd
856 1.1 cgd case SO_LINGER:
857 1.1 cgd if (m == NULL || m->m_len != sizeof (struct linger)) {
858 1.1 cgd error = EINVAL;
859 1.1 cgd goto bad;
860 1.1 cgd }
861 1.1 cgd so->so_linger = mtod(m, struct linger *)->l_linger;
862 1.1 cgd /* fall thru... */
863 1.1 cgd
864 1.1 cgd case SO_DEBUG:
865 1.1 cgd case SO_KEEPALIVE:
866 1.1 cgd case SO_DONTROUTE:
867 1.1 cgd case SO_USELOOPBACK:
868 1.1 cgd case SO_BROADCAST:
869 1.1 cgd case SO_REUSEADDR:
870 1.15 mycroft case SO_REUSEPORT:
871 1.1 cgd case SO_OOBINLINE:
872 1.1 cgd if (m == NULL || m->m_len < sizeof (int)) {
873 1.1 cgd error = EINVAL;
874 1.1 cgd goto bad;
875 1.1 cgd }
876 1.1 cgd if (*mtod(m, int *))
877 1.1 cgd so->so_options |= optname;
878 1.1 cgd else
879 1.1 cgd so->so_options &= ~optname;
880 1.1 cgd break;
881 1.1 cgd
882 1.1 cgd case SO_SNDBUF:
883 1.1 cgd case SO_RCVBUF:
884 1.1 cgd case SO_SNDLOWAT:
885 1.1 cgd case SO_RCVLOWAT:
886 1.1 cgd if (m == NULL || m->m_len < sizeof (int)) {
887 1.1 cgd error = EINVAL;
888 1.1 cgd goto bad;
889 1.1 cgd }
890 1.1 cgd switch (optname) {
891 1.1 cgd
892 1.1 cgd case SO_SNDBUF:
893 1.1 cgd case SO_RCVBUF:
894 1.1 cgd if (sbreserve(optname == SO_SNDBUF ?
895 1.1 cgd &so->so_snd : &so->so_rcv,
896 1.1 cgd (u_long) *mtod(m, int *)) == 0) {
897 1.1 cgd error = ENOBUFS;
898 1.1 cgd goto bad;
899 1.1 cgd }
900 1.1 cgd break;
901 1.1 cgd
902 1.1 cgd case SO_SNDLOWAT:
903 1.1 cgd so->so_snd.sb_lowat = *mtod(m, int *);
904 1.1 cgd break;
905 1.1 cgd case SO_RCVLOWAT:
906 1.1 cgd so->so_rcv.sb_lowat = *mtod(m, int *);
907 1.1 cgd break;
908 1.1 cgd }
909 1.1 cgd break;
910 1.1 cgd
911 1.1 cgd case SO_SNDTIMEO:
912 1.1 cgd case SO_RCVTIMEO:
913 1.1 cgd {
914 1.1 cgd struct timeval *tv;
915 1.1 cgd short val;
916 1.1 cgd
917 1.1 cgd if (m == NULL || m->m_len < sizeof (*tv)) {
918 1.1 cgd error = EINVAL;
919 1.1 cgd goto bad;
920 1.1 cgd }
921 1.1 cgd tv = mtod(m, struct timeval *);
922 1.19 cgd if (tv->tv_sec * hz + tv->tv_usec / tick > SHRT_MAX) {
923 1.1 cgd error = EDOM;
924 1.1 cgd goto bad;
925 1.1 cgd }
926 1.1 cgd val = tv->tv_sec * hz + tv->tv_usec / tick;
927 1.1 cgd
928 1.1 cgd switch (optname) {
929 1.1 cgd
930 1.1 cgd case SO_SNDTIMEO:
931 1.1 cgd so->so_snd.sb_timeo = val;
932 1.1 cgd break;
933 1.1 cgd case SO_RCVTIMEO:
934 1.1 cgd so->so_rcv.sb_timeo = val;
935 1.1 cgd break;
936 1.1 cgd }
937 1.1 cgd break;
938 1.1 cgd }
939 1.1 cgd
940 1.1 cgd default:
941 1.1 cgd error = ENOPROTOOPT;
942 1.1 cgd break;
943 1.1 cgd }
944 1.15 mycroft if (error == 0 && so->so_proto && so->so_proto->pr_ctloutput) {
945 1.15 mycroft (void) ((*so->so_proto->pr_ctloutput)
946 1.15 mycroft (PRCO_SETOPT, so, level, optname, &m0));
947 1.15 mycroft m = NULL; /* freed by protocol */
948 1.15 mycroft }
949 1.1 cgd }
950 1.1 cgd bad:
951 1.1 cgd if (m)
952 1.1 cgd (void) m_free(m);
953 1.1 cgd return (error);
954 1.1 cgd }
955 1.1 cgd
956 1.14 mycroft int
957 1.1 cgd sogetopt(so, level, optname, mp)
958 1.1 cgd register struct socket *so;
959 1.1 cgd int level, optname;
960 1.1 cgd struct mbuf **mp;
961 1.1 cgd {
962 1.1 cgd register struct mbuf *m;
963 1.1 cgd
964 1.1 cgd if (level != SOL_SOCKET) {
965 1.1 cgd if (so->so_proto && so->so_proto->pr_ctloutput) {
966 1.1 cgd return ((*so->so_proto->pr_ctloutput)
967 1.1 cgd (PRCO_GETOPT, so, level, optname, mp));
968 1.1 cgd } else
969 1.1 cgd return (ENOPROTOOPT);
970 1.1 cgd } else {
971 1.1 cgd m = m_get(M_WAIT, MT_SOOPTS);
972 1.1 cgd m->m_len = sizeof (int);
973 1.1 cgd
974 1.1 cgd switch (optname) {
975 1.1 cgd
976 1.1 cgd case SO_LINGER:
977 1.1 cgd m->m_len = sizeof (struct linger);
978 1.1 cgd mtod(m, struct linger *)->l_onoff =
979 1.1 cgd so->so_options & SO_LINGER;
980 1.1 cgd mtod(m, struct linger *)->l_linger = so->so_linger;
981 1.1 cgd break;
982 1.1 cgd
983 1.1 cgd case SO_USELOOPBACK:
984 1.1 cgd case SO_DONTROUTE:
985 1.1 cgd case SO_DEBUG:
986 1.1 cgd case SO_KEEPALIVE:
987 1.1 cgd case SO_REUSEADDR:
988 1.15 mycroft case SO_REUSEPORT:
989 1.1 cgd case SO_BROADCAST:
990 1.1 cgd case SO_OOBINLINE:
991 1.1 cgd *mtod(m, int *) = so->so_options & optname;
992 1.1 cgd break;
993 1.1 cgd
994 1.1 cgd case SO_TYPE:
995 1.1 cgd *mtod(m, int *) = so->so_type;
996 1.1 cgd break;
997 1.1 cgd
998 1.1 cgd case SO_ERROR:
999 1.1 cgd *mtod(m, int *) = so->so_error;
1000 1.1 cgd so->so_error = 0;
1001 1.1 cgd break;
1002 1.1 cgd
1003 1.1 cgd case SO_SNDBUF:
1004 1.1 cgd *mtod(m, int *) = so->so_snd.sb_hiwat;
1005 1.1 cgd break;
1006 1.1 cgd
1007 1.1 cgd case SO_RCVBUF:
1008 1.1 cgd *mtod(m, int *) = so->so_rcv.sb_hiwat;
1009 1.1 cgd break;
1010 1.1 cgd
1011 1.1 cgd case SO_SNDLOWAT:
1012 1.1 cgd *mtod(m, int *) = so->so_snd.sb_lowat;
1013 1.1 cgd break;
1014 1.1 cgd
1015 1.1 cgd case SO_RCVLOWAT:
1016 1.1 cgd *mtod(m, int *) = so->so_rcv.sb_lowat;
1017 1.1 cgd break;
1018 1.1 cgd
1019 1.1 cgd case SO_SNDTIMEO:
1020 1.1 cgd case SO_RCVTIMEO:
1021 1.1 cgd {
1022 1.1 cgd int val = (optname == SO_SNDTIMEO ?
1023 1.1 cgd so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
1024 1.1 cgd
1025 1.1 cgd m->m_len = sizeof(struct timeval);
1026 1.1 cgd mtod(m, struct timeval *)->tv_sec = val / hz;
1027 1.1 cgd mtod(m, struct timeval *)->tv_usec =
1028 1.1 cgd (val % hz) / tick;
1029 1.1 cgd break;
1030 1.1 cgd }
1031 1.1 cgd
1032 1.1 cgd default:
1033 1.1 cgd (void)m_free(m);
1034 1.1 cgd return (ENOPROTOOPT);
1035 1.1 cgd }
1036 1.1 cgd *mp = m;
1037 1.1 cgd return (0);
1038 1.1 cgd }
1039 1.1 cgd }
1040 1.1 cgd
1041 1.14 mycroft void
1042 1.1 cgd sohasoutofband(so)
1043 1.1 cgd register struct socket *so;
1044 1.1 cgd {
1045 1.1 cgd struct proc *p;
1046 1.1 cgd
1047 1.1 cgd if (so->so_pgid < 0)
1048 1.1 cgd gsignal(-so->so_pgid, SIGURG);
1049 1.1 cgd else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
1050 1.1 cgd psignal(p, SIGURG);
1051 1.2 cgd selwakeup(&so->so_rcv.sb_sel);
1052 1.1 cgd }
1053