Once we distribute socket protocol processing requests to different
[dragonfly.git] / sys / kern / uipc_socket2.c
1 /*
2  * Copyright (c) 1982, 1986, 1988, 1990, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *      @(#)uipc_socket2.c      8.1 (Berkeley) 6/10/93
34  * $FreeBSD: src/sys/kern/uipc_socket2.c,v 1.55.2.17 2002/08/31 19:04:55 dwmalone Exp $
35  * $DragonFly: src/sys/kern/uipc_socket2.c,v 1.7 2004/03/05 16:57:15 hsu Exp $
36  */
37
38 #include "opt_param.h"
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/domain.h>
42 #include <sys/file.h>   /* for maxfiles */
43 #include <sys/kernel.h>
44 #include <sys/proc.h>
45 #include <sys/malloc.h>
46 #include <sys/mbuf.h>
47 #include <sys/protosw.h>
48 #include <sys/resourcevar.h>
49 #include <sys/stat.h>
50 #include <sys/socket.h>
51 #include <sys/socketvar.h>
52 #include <sys/signalvar.h>
53 #include <sys/sysctl.h>
54 #include <sys/aio.h> /* for aio_swake proto */
55 #include <sys/event.h>
56
57 int     maxsockets;
58
59 /*
60  * Primitive routines for operating on sockets and socket buffers
61  */
62
63 u_long  sb_max = SB_MAX;
64 u_long  sb_max_adj =
65     SB_MAX * MCLBYTES / (MSIZE + MCLBYTES); /* adjusted sb_max */
66
67 static  u_long sb_efficiency = 8;       /* parameter for sbreserve() */
68
69 /*
70  * Procedures to manipulate state flags of socket
71  * and do appropriate wakeups.  Normal sequence from the
72  * active (originating) side is that soisconnecting() is
73  * called during processing of connect() call,
74  * resulting in an eventual call to soisconnected() if/when the
75  * connection is established.  When the connection is torn down
76  * soisdisconnecting() is called during processing of disconnect() call,
77  * and soisdisconnected() is called when the connection to the peer
78  * is totally severed.  The semantics of these routines are such that
79  * connectionless protocols can call soisconnected() and soisdisconnected()
80  * only, bypassing the in-progress calls when setting up a ``connection''
81  * takes no time.
82  *
83  * From the passive side, a socket is created with
84  * two queues of sockets: so_incomp for connections in progress
85  * and so_comp for connections already made and awaiting user acceptance.
86  * As a protocol is preparing incoming connections, it creates a socket
87  * structure queued on so_incomp by calling sonewconn().  When the connection
88  * is established, soisconnected() is called, and transfers the
89  * socket structure to so_comp, making it available to accept().
90  *
91  * If a socket is closed with sockets on either
92  * so_incomp or so_comp, these sockets are dropped.
93  *
94  * If higher level protocols are implemented in
95  * the kernel, the wakeups done here will sometimes
96  * cause software-interrupt process scheduling.
97  */
98
99 void
100 soisconnecting(so)
101         struct socket *so;
102 {
103
104         so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
105         so->so_state |= SS_ISCONNECTING;
106 }
107
108 void
109 soisconnected(so)
110         struct socket *so;
111 {
112         struct socket *head = so->so_head;
113
114         so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);
115         so->so_state |= SS_ISCONNECTED;
116         if (head && (so->so_state & SS_INCOMP)) {
117                 if ((so->so_options & SO_ACCEPTFILTER) != 0) {
118                         so->so_upcall = head->so_accf->so_accept_filter->accf_callback;
119                         so->so_upcallarg = head->so_accf->so_accept_filter_arg;
120                         so->so_rcv.sb_flags |= SB_UPCALL;
121                         so->so_options &= ~SO_ACCEPTFILTER;
122                         so->so_upcall(so, so->so_upcallarg, 0);
123                         return;
124                 }
125                 TAILQ_REMOVE(&head->so_incomp, so, so_list);
126                 head->so_incqlen--;
127                 so->so_state &= ~SS_INCOMP;
128                 TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
129                 head->so_qlen++;
130                 so->so_state |= SS_COMP;
131                 sorwakeup(head);
132                 wakeup_one(&head->so_timeo);
133         } else {
134                 wakeup(&so->so_timeo);
135                 sorwakeup(so);
136                 sowwakeup(so);
137         }
138 }
139
140 void
141 soisdisconnecting(so)
142         struct socket *so;
143 {
144
145         so->so_state &= ~SS_ISCONNECTING;
146         so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE);
147         wakeup((caddr_t)&so->so_timeo);
148         sowwakeup(so);
149         sorwakeup(so);
150 }
151
152 void
153 soisdisconnected(so)
154         struct socket *so;
155 {
156
157         so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
158         so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE|SS_ISDISCONNECTED);
159         wakeup((caddr_t)&so->so_timeo);
160         sbdrop(&so->so_snd, so->so_snd.sb_cc);
161         sowwakeup(so);
162         sorwakeup(so);
163 }
164
165 /*
166  * When an attempt at a new connection is noted on a socket
167  * which accepts connections, sonewconn is called.  If the
168  * connection is possible (subject to space constraints, etc.)
169  * then we allocate a new structure, propoerly linked into the
170  * data structure of the original socket, and return this.
171  * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
172  */
173 struct socket *
174 sonewconn(struct socket *head, int connstatus)
175 {
176         struct socket *so;
177         struct pru_attach_info ai;
178
179         if (head->so_qlen > 3 * head->so_qlimit / 2)
180                 return ((struct socket *)0);
181         so = soalloc(0);
182         if (so == NULL)
183                 return ((struct socket *)0);
184         if ((head->so_options & SO_ACCEPTFILTER) != 0)
185                 connstatus = 0;
186         so->so_head = head;
187         so->so_type = head->so_type;
188         so->so_options = head->so_options &~ SO_ACCEPTCONN;
189         so->so_linger = head->so_linger;
190         so->so_state = head->so_state | SS_NOFDREF;
191         so->so_proto = head->so_proto;
192         so->so_timeo = head->so_timeo;
193         so->so_cred = crhold(head->so_cred);
194         ai.sb_rlimit = NULL;
195         ai.p_ucred = NULL;
196         ai.fd_rdir = NULL;              /* jail code cruft XXX JH */
197         if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat, NULL) ||
198             (*so->so_proto->pr_usrreqs->pru_attach)(so, 0, &ai)) {
199                 sodealloc(so);
200                 return ((struct socket *)0);
201         }
202
203         if (connstatus) {
204                 TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
205                 so->so_state |= SS_COMP;
206                 head->so_qlen++;
207         } else {
208                 if (head->so_incqlen > head->so_qlimit) {
209                         struct socket *sp;
210                         sp = TAILQ_FIRST(&head->so_incomp);
211                         (void) soabort(sp);
212                 }
213                 TAILQ_INSERT_TAIL(&head->so_incomp, so, so_list);
214                 so->so_state |= SS_INCOMP;
215                 head->so_incqlen++;
216         }
217         if (connstatus) {
218                 sorwakeup(head);
219                 wakeup((caddr_t)&head->so_timeo);
220                 so->so_state |= connstatus;
221         }
222         return (so);
223 }
224
225 /*
226  * Socantsendmore indicates that no more data will be sent on the
227  * socket; it would normally be applied to a socket when the user
228  * informs the system that no more data is to be sent, by the protocol
229  * code (in case PRU_SHUTDOWN).  Socantrcvmore indicates that no more data
230  * will be received, and will normally be applied to the socket by a
231  * protocol when it detects that the peer will send no more data.
232  * Data queued for reading in the socket may yet be read.
233  */
234
235 void
236 socantsendmore(so)
237         struct socket *so;
238 {
239
240         so->so_state |= SS_CANTSENDMORE;
241         sowwakeup(so);
242 }
243
244 void
245 socantrcvmore(so)
246         struct socket *so;
247 {
248
249         so->so_state |= SS_CANTRCVMORE;
250         sorwakeup(so);
251 }
252
253 /*
254  * Wait for data to arrive at/drain from a socket buffer.
255  */
256 int
257 sbwait(sb)
258         struct sockbuf *sb;
259 {
260
261         sb->sb_flags |= SB_WAIT;
262         return (tsleep((caddr_t)&sb->sb_cc,
263                         ((sb->sb_flags & SB_NOINTR) ? 0 : PCATCH),
264                         "sbwait",
265                         sb->sb_timeo));
266 }
267
268 /*
269  * Lock a sockbuf already known to be locked;
270  * return any error returned from sleep (EINTR).
271  */
272 int
273 sb_lock(sb)
274         struct sockbuf *sb;
275 {
276         int error;
277
278         while (sb->sb_flags & SB_LOCK) {
279                 sb->sb_flags |= SB_WANT;
280                 error = tsleep((caddr_t)&sb->sb_flags,
281                             ((sb->sb_flags & SB_NOINTR) ? 0 : PCATCH),
282                             "sblock", 0);
283                 if (error)
284                         return (error);
285         }
286         sb->sb_flags |= SB_LOCK;
287         return (0);
288 }
289
290 /*
291  * Wakeup processes waiting on a socket buffer.
292  * Do asynchronous notification via SIGIO
293  * if the socket has the SS_ASYNC flag set.
294  */
295 void
296 sowakeup(so, sb)
297         struct socket *so;
298         struct sockbuf *sb;
299 {
300         selwakeup(&sb->sb_sel);
301         sb->sb_flags &= ~SB_SEL;
302         if (sb->sb_flags & SB_WAIT) {
303                 sb->sb_flags &= ~SB_WAIT;
304                 wakeup((caddr_t)&sb->sb_cc);
305         }
306         if ((so->so_state & SS_ASYNC) && so->so_sigio != NULL)
307                 pgsigio(so->so_sigio, SIGIO, 0);
308         if (sb->sb_flags & SB_UPCALL)
309                 (*so->so_upcall)(so, so->so_upcallarg, M_DONTWAIT);
310         if (sb->sb_flags & SB_AIO)
311                 aio_swake(so, sb);
312         KNOTE(&sb->sb_sel.si_note, 0);
313 }
314
315 /*
316  * Socket buffer (struct sockbuf) utility routines.
317  *
318  * Each socket contains two socket buffers: one for sending data and
319  * one for receiving data.  Each buffer contains a queue of mbufs,
320  * information about the number of mbufs and amount of data in the
321  * queue, and other fields allowing select() statements and notification
322  * on data availability to be implemented.
323  *
324  * Data stored in a socket buffer is maintained as a list of records.
325  * Each record is a list of mbufs chained together with the m_next
326  * field.  Records are chained together with the m_nextpkt field. The upper
327  * level routine soreceive() expects the following conventions to be
328  * observed when placing information in the receive buffer:
329  *
330  * 1. If the protocol requires each message be preceded by the sender's
331  *    name, then a record containing that name must be present before
332  *    any associated data (mbuf's must be of type MT_SONAME).
333  * 2. If the protocol supports the exchange of ``access rights'' (really
334  *    just additional data associated with the message), and there are
335  *    ``rights'' to be received, then a record containing this data
336  *    should be present (mbuf's must be of type MT_RIGHTS).
337  * 3. If a name or rights record exists, then it must be followed by
338  *    a data record, perhaps of zero length.
339  *
340  * Before using a new socket structure it is first necessary to reserve
341  * buffer space to the socket, by calling sbreserve().  This should commit
342  * some of the available buffer space in the system buffer pool for the
343  * socket (currently, it does nothing but enforce limits).  The space
344  * should be released by calling sbrelease() when the socket is destroyed.
345  */
346
347 int
348 soreserve(struct socket *so, u_long sndcc, u_long rcvcc, struct rlimit *rl)
349 {
350         if (sbreserve(&so->so_snd, sndcc, so, rl) == 0)
351                 goto bad;
352         if (sbreserve(&so->so_rcv, rcvcc, so, rl) == 0)
353                 goto bad2;
354         if (so->so_rcv.sb_lowat == 0)
355                 so->so_rcv.sb_lowat = 1;
356         if (so->so_snd.sb_lowat == 0)
357                 so->so_snd.sb_lowat = MCLBYTES;
358         if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat)
359                 so->so_snd.sb_lowat = so->so_snd.sb_hiwat;
360         return (0);
361 bad2:
362         sbrelease(&so->so_snd, so);
363 bad:
364         return (ENOBUFS);
365 }
366
367 static int
368 sysctl_handle_sb_max(SYSCTL_HANDLER_ARGS)
369 {
370         int error = 0;
371         u_long old_sb_max = sb_max;
372
373         error = SYSCTL_OUT(req, arg1, sizeof(int));
374         if (error || !req->newptr)
375                 return (error);
376         error = SYSCTL_IN(req, arg1, sizeof(int));
377         if (error)
378                 return (error);
379         if (sb_max < MSIZE + MCLBYTES) {
380                 sb_max = old_sb_max;
381                 return (EINVAL);
382         }
383         sb_max_adj = (u_quad_t)sb_max * MCLBYTES / (MSIZE + MCLBYTES);
384         return (0);
385 }
386         
387 /*
388  * Allot mbufs to a sockbuf.
389  * Attempt to scale mbmax so that mbcnt doesn't become limiting
390  * if buffering efficiency is near the normal case.
391  */
392 int
393 sbreserve(struct sockbuf *sb, u_long cc, struct socket *so, struct rlimit *rl)
394 {
395
396         /*
397          * rl will only be NULL when we're in an interrupt (eg, in tcp_input)
398          * or when called from netgraph (ie, ngd_attach)
399          */
400         if (cc > sb_max_adj)
401                 return (0);
402         if (!chgsbsize(so->so_cred->cr_uidinfo, &sb->sb_hiwat, cc,
403                        rl ? rl->rlim_cur : RLIM_INFINITY)) {
404                 return (0);
405         }
406         sb->sb_mbmax = min(cc * sb_efficiency, sb_max);
407         if (sb->sb_lowat > sb->sb_hiwat)
408                 sb->sb_lowat = sb->sb_hiwat;
409         return (1);
410 }
411
412 /*
413  * Free mbufs held by a socket, and reserved mbuf space.
414  */
415 void
416 sbrelease(sb, so)
417         struct sockbuf *sb;
418         struct socket *so;
419 {
420
421         sbflush(sb);
422         (void)chgsbsize(so->so_cred->cr_uidinfo, &sb->sb_hiwat, 0,
423             RLIM_INFINITY);
424         sb->sb_mbmax = 0;
425 }
426
427 /*
428  * Routines to add and remove
429  * data from an mbuf queue.
430  *
431  * The routines sbappend() or sbappendrecord() are normally called to
432  * append new mbufs to a socket buffer, after checking that adequate
433  * space is available, comparing the function sbspace() with the amount
434  * of data to be added.  sbappendrecord() differs from sbappend() in
435  * that data supplied is treated as the beginning of a new record.
436  * To place a sender's address, optional access rights, and data in a
437  * socket receive buffer, sbappendaddr() should be used.  To place
438  * access rights and data in a socket receive buffer, sbappendrights()
439  * should be used.  In either case, the new data begins a new record.
440  * Note that unlike sbappend() and sbappendrecord(), these routines check
441  * for the caller that there will be enough space to store the data.
442  * Each fails if there is not enough space, or if it cannot find mbufs
443  * to store additional information in.
444  *
445  * Reliable protocols may use the socket send buffer to hold data
446  * awaiting acknowledgement.  Data is normally copied from a socket
447  * send buffer in a protocol with m_copy for output to a peer,
448  * and then removing the data from the socket buffer with sbdrop()
449  * or sbdroprecord() when the data is acknowledged by the peer.
450  */
451
452 /*
453  * Append mbuf chain m to the last record in the
454  * socket buffer sb.  The additional space associated
455  * the mbuf chain is recorded in sb.  Empty mbufs are
456  * discarded and mbufs are compacted where possible.
457  */
458 void
459 sbappend(sb, m)
460         struct sockbuf *sb;
461         struct mbuf *m;
462 {
463         struct mbuf *n;
464
465         if (m == 0)
466                 return;
467         n = sb->sb_mb;
468         if (n) {
469                 while (n->m_nextpkt)
470                         n = n->m_nextpkt;
471                 do {
472                         if (n->m_flags & M_EOR) {
473                                 sbappendrecord(sb, m); /* XXXXXX!!!! */
474                                 return;
475                         }
476                 } while (n->m_next && (n = n->m_next));
477         }
478         sbcompress(sb, m, n);
479 }
480
481 #ifdef SOCKBUF_DEBUG
482 void
483 sbcheck(sb)
484         struct sockbuf *sb;
485 {
486         struct mbuf *m;
487         struct mbuf *n = 0;
488         u_long len = 0, mbcnt = 0;
489
490         for (m = sb->sb_mb; m; m = n) {
491             n = m->m_nextpkt;
492             for (; m; m = m->m_next) {
493                 len += m->m_len;
494                 mbcnt += MSIZE;
495                 if (m->m_flags & M_EXT) /*XXX*/ /* pretty sure this is bogus */
496                         mbcnt += m->m_ext.ext_size;
497             }
498         }
499         if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
500                 printf("cc %ld != %ld || mbcnt %ld != %ld\n", len, sb->sb_cc,
501                     mbcnt, sb->sb_mbcnt);
502                 panic("sbcheck");
503         }
504 }
505 #endif
506
507 /*
508  * As above, except the mbuf chain
509  * begins a new record.
510  */
511 void
512 sbappendrecord(sb, m0)
513         struct sockbuf *sb;
514         struct mbuf *m0;
515 {
516         struct mbuf *m;
517
518         if (m0 == 0)
519                 return;
520         m = sb->sb_mb;
521         if (m)
522                 while (m->m_nextpkt)
523                         m = m->m_nextpkt;
524         /*
525          * Put the first mbuf on the queue.
526          * Note this permits zero length records.
527          */
528         sballoc(sb, m0);
529         if (m)
530                 m->m_nextpkt = m0;
531         else
532                 sb->sb_mb = m0;
533         m = m0->m_next;
534         m0->m_next = 0;
535         if (m && (m0->m_flags & M_EOR)) {
536                 m0->m_flags &= ~M_EOR;
537                 m->m_flags |= M_EOR;
538         }
539         sbcompress(sb, m, m0);
540 }
541
542 /*
543  * As above except that OOB data
544  * is inserted at the beginning of the sockbuf,
545  * but after any other OOB data.
546  */
547 void
548 sbinsertoob(sb, m0)
549         struct sockbuf *sb;
550         struct mbuf *m0;
551 {
552         struct mbuf *m;
553         struct mbuf **mp;
554
555         if (m0 == 0)
556                 return;
557         for (mp = &sb->sb_mb; *mp ; mp = &((*mp)->m_nextpkt)) {
558             m = *mp;
559             again:
560                 switch (m->m_type) {
561
562                 case MT_OOBDATA:
563                         continue;               /* WANT next train */
564
565                 case MT_CONTROL:
566                         m = m->m_next;
567                         if (m)
568                                 goto again;     /* inspect THIS train further */
569                 }
570                 break;
571         }
572         /*
573          * Put the first mbuf on the queue.
574          * Note this permits zero length records.
575          */
576         sballoc(sb, m0);
577         m0->m_nextpkt = *mp;
578         *mp = m0;
579         m = m0->m_next;
580         m0->m_next = 0;
581         if (m && (m0->m_flags & M_EOR)) {
582                 m0->m_flags &= ~M_EOR;
583                 m->m_flags |= M_EOR;
584         }
585         sbcompress(sb, m, m0);
586 }
587
588 /*
589  * Append address and data, and optionally, control (ancillary) data
590  * to the receive queue of a socket.  If present,
591  * m0 must include a packet header with total length.
592  * Returns 0 if no space in sockbuf or insufficient mbufs.
593  */
594 int
595 sbappendaddr(sb, asa, m0, control)
596         struct sockbuf *sb;
597         struct sockaddr *asa;
598         struct mbuf *m0, *control;
599 {
600         struct mbuf *m, *n;
601         int space = asa->sa_len;
602
603         if (m0 && (m0->m_flags & M_PKTHDR) == 0)
604                 panic("sbappendaddr");
605
606         if (m0)
607                 space += m0->m_pkthdr.len;
608         for (n = control; n; n = n->m_next) {
609                 space += n->m_len;
610                 if (n->m_next == 0)     /* keep pointer to last control buf */
611                         break;
612         }
613         if (space > sbspace(sb))
614                 return (0);
615         if (asa->sa_len > MLEN)
616                 return (0);
617         MGET(m, M_DONTWAIT, MT_SONAME);
618         if (m == 0)
619                 return (0);
620         m->m_len = asa->sa_len;
621         bcopy((caddr_t)asa, mtod(m, caddr_t), asa->sa_len);
622         if (n)
623                 n->m_next = m0;         /* concatenate data to control */
624         else
625                 control = m0;
626         m->m_next = control;
627         for (n = m; n; n = n->m_next)
628                 sballoc(sb, n);
629         n = sb->sb_mb;
630         if (n) {
631                 while (n->m_nextpkt)
632                         n = n->m_nextpkt;
633                 n->m_nextpkt = m;
634         } else
635                 sb->sb_mb = m;
636         return (1);
637 }
638
639 int
640 sbappendcontrol(sb, m0, control)
641         struct sockbuf *sb;
642         struct mbuf *control, *m0;
643 {
644         struct mbuf *m, *n;
645         int space = 0;
646
647         if (control == 0)
648                 panic("sbappendcontrol");
649         for (m = control; ; m = m->m_next) {
650                 space += m->m_len;
651                 if (m->m_next == 0)
652                         break;
653         }
654         n = m;                  /* save pointer to last control buffer */
655         for (m = m0; m; m = m->m_next)
656                 space += m->m_len;
657         if (space > sbspace(sb))
658                 return (0);
659         n->m_next = m0;                 /* concatenate data to control */
660         for (m = control; m; m = m->m_next)
661                 sballoc(sb, m);
662         n = sb->sb_mb;
663         if (n) {
664                 while (n->m_nextpkt)
665                         n = n->m_nextpkt;
666                 n->m_nextpkt = control;
667         } else
668                 sb->sb_mb = control;
669         return (1);
670 }
671
672 /*
673  * Compress mbuf chain m into the socket
674  * buffer sb following mbuf n.  If n
675  * is null, the buffer is presumed empty.
676  */
677 void
678 sbcompress(sb, m, n)
679         struct sockbuf *sb;
680         struct mbuf *m, *n;
681 {
682         int eor = 0;
683         struct mbuf *o;
684
685         while (m) {
686                 eor |= m->m_flags & M_EOR;
687                 if (m->m_len == 0 &&
688                     (eor == 0 ||
689                      (((o = m->m_next) || (o = n)) &&
690                       o->m_type == m->m_type))) {
691                         m = m_free(m);
692                         continue;
693                 }
694                 if (n && (n->m_flags & M_EOR) == 0 &&
695                     M_WRITABLE(n) &&
696                     m->m_len <= MCLBYTES / 4 && /* XXX: Don't copy too much */
697                     m->m_len <= M_TRAILINGSPACE(n) &&
698                     n->m_type == m->m_type) {
699                         bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,
700                             (unsigned)m->m_len);
701                         n->m_len += m->m_len;
702                         sb->sb_cc += m->m_len;
703                         m = m_free(m);
704                         continue;
705                 }
706                 if (n)
707                         n->m_next = m;
708                 else
709                         sb->sb_mb = m;
710                 sballoc(sb, m);
711                 n = m;
712                 m->m_flags &= ~M_EOR;
713                 m = m->m_next;
714                 n->m_next = 0;
715         }
716         if (eor) {
717                 if (n)
718                         n->m_flags |= eor;
719                 else
720                         printf("semi-panic: sbcompress\n");
721         }
722 }
723
724 /*
725  * Free all mbufs in a sockbuf.
726  * Check that all resources are reclaimed.
727  */
728 void
729 sbflush(sb)
730         struct sockbuf *sb;
731 {
732
733         if (sb->sb_flags & SB_LOCK)
734                 panic("sbflush: locked");
735         while (sb->sb_mbcnt) {
736                 /*
737                  * Don't call sbdrop(sb, 0) if the leading mbuf is non-empty:
738                  * we would loop forever. Panic instead.
739                  */
740                 if (!sb->sb_cc && (sb->sb_mb == NULL || sb->sb_mb->m_len))
741                         break;
742                 sbdrop(sb, (int)sb->sb_cc);
743         }
744         if (sb->sb_cc || sb->sb_mb || sb->sb_mbcnt)
745                 panic("sbflush: cc %ld || mb %p || mbcnt %ld", sb->sb_cc, (void *)sb->sb_mb, sb->sb_mbcnt);
746 }
747
748 /*
749  * Drop data from (the front of) a sockbuf.
750  */
751 void
752 sbdrop(sb, len)
753         struct sockbuf *sb;
754         int len;
755 {
756         struct mbuf *m;
757         struct mbuf *next;
758
759         next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
760         while (len > 0) {
761                 if (m == 0) {
762                         if (next == 0)
763                                 panic("sbdrop");
764                         m = next;
765                         next = m->m_nextpkt;
766                         continue;
767                 }
768                 if (m->m_len > len) {
769                         m->m_len -= len;
770                         m->m_data += len;
771                         sb->sb_cc -= len;
772                         break;
773                 }
774                 len -= m->m_len;
775                 sbfree(sb, m);
776                 m = m_free(m);
777         }
778         while (m && m->m_len == 0) {
779                 sbfree(sb, m);
780                 m = m_free(m);
781         }
782         if (m) {
783                 sb->sb_mb = m;
784                 m->m_nextpkt = next;
785         } else
786                 sb->sb_mb = next;
787 }
788
789 /*
790  * Drop a record off the front of a sockbuf
791  * and move the next record to the front.
792  */
793 void
794 sbdroprecord(sb)
795         struct sockbuf *sb;
796 {
797         struct mbuf *m;
798
799         m = sb->sb_mb;
800         if (m) {
801                 sb->sb_mb = m->m_nextpkt;
802                 do {
803                         sbfree(sb, m);
804                         m = m_free(m);
805                 } while (m);
806         }
807 }
808
809 /*
810  * Create a "control" mbuf containing the specified data
811  * with the specified type for presentation on a socket buffer.
812  */
813 struct mbuf *
814 sbcreatecontrol(p, size, type, level)
815         caddr_t p;
816         int size;
817         int type, level;
818 {
819         struct cmsghdr *cp;
820         struct mbuf *m;
821
822         if (CMSG_SPACE((u_int)size) > MCLBYTES)
823                 return ((struct mbuf *) NULL);
824         if ((m = m_get(M_DONTWAIT, MT_CONTROL)) == NULL)
825                 return ((struct mbuf *) NULL);
826         if (CMSG_SPACE((u_int)size) > MLEN) {
827                 MCLGET(m, M_DONTWAIT);
828                 if ((m->m_flags & M_EXT) == 0) {
829                         m_free(m);
830                         return ((struct mbuf *) NULL);
831                 }
832         }
833         cp = mtod(m, struct cmsghdr *);
834         m->m_len = 0;
835         KASSERT(CMSG_SPACE((u_int)size) <= M_TRAILINGSPACE(m),
836             ("sbcreatecontrol: short mbuf"));
837         if (p != NULL)
838                 (void)memcpy(CMSG_DATA(cp), p, size);
839         m->m_len = CMSG_SPACE(size);
840         cp->cmsg_len = CMSG_LEN(size);
841         cp->cmsg_level = level;
842         cp->cmsg_type = type;
843         return (m);
844 }
845
846 /*
847  * Some routines that return EOPNOTSUPP for entry points that are not
848  * supported by a protocol.  Fill in as needed.
849  */
850 int
851 pru_accept_notsupp(struct socket *so, struct sockaddr **nam)
852 {
853         return EOPNOTSUPP;
854 }
855
856 int
857 pru_connect_notsupp(struct socket *so, struct sockaddr *nam, struct thread *td)
858 {
859         return EOPNOTSUPP;
860 }
861
862 int
863 pru_connect2_notsupp(struct socket *so1, struct socket *so2)
864 {
865         return EOPNOTSUPP;
866 }
867
868 int
869 pru_control_notsupp(struct socket *so, u_long cmd, caddr_t data,
870                     struct ifnet *ifp, struct thread *td)
871 {
872         return EOPNOTSUPP;
873 }
874
875 int
876 pru_listen_notsupp(struct socket *so, struct thread *td)
877 {
878         return EOPNOTSUPP;
879 }
880
881 int
882 pru_rcvd_notsupp(struct socket *so, int flags)
883 {
884         return EOPNOTSUPP;
885 }
886
887 int
888 pru_rcvoob_notsupp(struct socket *so, struct mbuf *m, int flags)
889 {
890         return EOPNOTSUPP;
891 }
892
893 /*
894  * This isn't really a ``null'' operation, but it's the default one
895  * and doesn't do anything destructive.
896  */
897 int
898 pru_sense_null(struct socket *so, struct stat *sb)
899 {
900         sb->st_blksize = so->so_snd.sb_hiwat;
901         return 0;
902 }
903
904 /*
905  * Make a copy of a sockaddr in a malloced buffer of type M_SONAME.
906  */
907 struct sockaddr *
908 dup_sockaddr(sa, canwait)
909         struct sockaddr *sa;
910         int canwait;
911 {
912         struct sockaddr *sa2;
913
914         MALLOC(sa2, struct sockaddr *, sa->sa_len, M_SONAME, 
915                canwait ? M_WAITOK : M_NOWAIT);
916         if (sa2)
917                 bcopy(sa, sa2, sa->sa_len);
918         return sa2;
919 }
920
921 /*
922  * Create an external-format (``xsocket'') structure using the information
923  * in the kernel-format socket structure pointed to by so.  This is done
924  * to reduce the spew of irrelevant information over this interface,
925  * to isolate user code from changes in the kernel structure, and
926  * potentially to provide information-hiding if we decide that
927  * some of this information should be hidden from users.
928  */
929 void
930 sotoxsocket(struct socket *so, struct xsocket *xso)
931 {
932         xso->xso_len = sizeof *xso;
933         xso->xso_so = so;
934         xso->so_type = so->so_type;
935         xso->so_options = so->so_options;
936         xso->so_linger = so->so_linger;
937         xso->so_state = so->so_state;
938         xso->so_pcb = so->so_pcb;
939         xso->xso_protocol = so->so_proto->pr_protocol;
940         xso->xso_family = so->so_proto->pr_domain->dom_family;
941         xso->so_qlen = so->so_qlen;
942         xso->so_incqlen = so->so_incqlen;
943         xso->so_qlimit = so->so_qlimit;
944         xso->so_timeo = so->so_timeo;
945         xso->so_error = so->so_error;
946         xso->so_pgid = so->so_sigio ? so->so_sigio->sio_pgid : 0;
947         xso->so_oobmark = so->so_oobmark;
948         sbtoxsockbuf(&so->so_snd, &xso->so_snd);
949         sbtoxsockbuf(&so->so_rcv, &xso->so_rcv);
950         xso->so_uid = so->so_cred->cr_uid;
951 }
952
953 /*
954  * This does the same for sockbufs.  Note that the xsockbuf structure,
955  * since it is always embedded in a socket, does not include a self
956  * pointer nor a length.  We make this entry point public in case
957  * some other mechanism needs it.
958  */
959 void
960 sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb)
961 {
962         xsb->sb_cc = sb->sb_cc;
963         xsb->sb_hiwat = sb->sb_hiwat;
964         xsb->sb_mbcnt = sb->sb_mbcnt;
965         xsb->sb_mbmax = sb->sb_mbmax;
966         xsb->sb_lowat = sb->sb_lowat;
967         xsb->sb_flags = sb->sb_flags;
968         xsb->sb_timeo = sb->sb_timeo;
969 }
970
971 /*
972  * Here is the definition of some of the basic objects in the kern.ipc
973  * branch of the MIB.
974  */
975 SYSCTL_NODE(_kern, KERN_IPC, ipc, CTLFLAG_RW, 0, "IPC");
976
977 /* This takes the place of kern.maxsockbuf, which moved to kern.ipc. */
978 static int dummy;
979 SYSCTL_INT(_kern, KERN_DUMMY, dummy, CTLFLAG_RW, &dummy, 0, "");
980 SYSCTL_OID(_kern_ipc, KIPC_MAXSOCKBUF, maxsockbuf, CTLTYPE_INT|CTLFLAG_RW, 
981     &sb_max, 0, sysctl_handle_sb_max, "I", "Maximum socket buffer size");
982 SYSCTL_INT(_kern_ipc, OID_AUTO, maxsockets, CTLFLAG_RD, 
983     &maxsockets, 0, "Maximum number of sockets avaliable");
984 SYSCTL_INT(_kern_ipc, KIPC_SOCKBUF_WASTE, sockbuf_waste_factor, CTLFLAG_RW,
985     &sb_efficiency, 0, "");
986
987 /*
988  * Initialise maxsockets 
989  */
990 static void init_maxsockets(void *ignored)
991 {
992     TUNABLE_INT_FETCH("kern.ipc.maxsockets", &maxsockets);
993     maxsockets = imax(maxsockets, imax(maxfiles, nmbclusters));
994 }
995 SYSINIT(param, SI_SUB_TUNABLES, SI_ORDER_ANY, init_maxsockets, NULL);