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