* Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California.
* %sccs.include.redist.c%
* @(#)uipc_socket2.c 7.19 (Berkeley) %G%
#include <sys/socketvar.h>
* Primitive routines for operating on sockets and socket buffers
/* strings for sleep message: */
char netcon
[] = "netcon";
char netcls
[] = "netcls";
u_long sb_max
= SB_MAX
; /* patchable */
* Procedures to manipulate state flags of socket
* and do appropriate wakeups. Normal sequence from the
* active (originating) side is that soisconnecting() is
* called during processing of connect() call,
* resulting in an eventual call to soisconnected() if/when the
* connection is established. When the connection is torn down
* soisdisconnecting() is called during processing of disconnect() call,
* and soisdisconnected() is called when the connection to the peer
* is totally severed. The semantics of these routines are such that
* connectionless protocols can call soisconnected() and soisdisconnected()
* only, bypassing the in-progress calls when setting up a ``connection''
* From the passive side, a socket is created with
* two queues of sockets: so_q0 for connections in progress
* and so_q for connections already made and awaiting user acceptance.
* As a protocol is preparing incoming connections, it creates a socket
* structure queued on so_q0 by calling sonewconn(). When the connection
* is established, soisconnected() is called, and transfers the
* socket structure to so_q, making it available to accept().
* If a socket is closed with sockets on either
* so_q0 or so_q, these sockets are dropped.
* If higher level protocols are implemented in
* the kernel, the wakeups done here will sometimes
* cause software-interrupt process scheduling.
register struct socket
*so
;
so
->so_state
&= ~(SS_ISCONNECTED
|SS_ISDISCONNECTING
);
so
->so_state
|= SS_ISCONNECTING
;
register struct socket
*so
;
register struct socket
*head
= so
->so_head
;
so
->so_state
&= ~(SS_ISCONNECTING
|SS_ISDISCONNECTING
|SS_ISCONFIRMING
);
so
->so_state
|= SS_ISCONNECTED
;
if (head
&& soqremque(so
, 0)) {
wakeup((caddr_t
)&head
->so_timeo
);
wakeup((caddr_t
)&so
->so_timeo
);
register struct socket
*so
;
so
->so_state
&= ~SS_ISCONNECTING
;
so
->so_state
|= (SS_ISDISCONNECTING
|SS_CANTRCVMORE
|SS_CANTSENDMORE
);
wakeup((caddr_t
)&so
->so_timeo
);
register struct socket
*so
;
so
->so_state
&= ~(SS_ISCONNECTING
|SS_ISCONNECTED
|SS_ISDISCONNECTING
);
so
->so_state
|= (SS_CANTRCVMORE
|SS_CANTSENDMORE
);
wakeup((caddr_t
)&so
->so_timeo
);
* When an attempt at a new connection is noted on a socket
* which accepts connections, sonewconn is called. If the
* connection is possible (subject to space constraints, etc.)
* then we allocate a new structure, propoerly linked into the
* data structure of the original socket, and return this.
* Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
* Currently, sonewconn() is defined as sonewconn1() in socketvar.h
* to catch calls that are missing the (new) second parameter.
sonewconn1(head
, connstatus
)
register struct socket
*head
;
register struct socket
*so
;
int soqueue
= connstatus
? 1 : 0;
if (head
->so_qlen
+ head
->so_q0len
> 3 * head
->so_qlimit
/ 2)
return ((struct socket
*)0);
MALLOC(so
, struct socket
*, sizeof(*so
), M_SOCKET
, M_DONTWAIT
);
return ((struct socket
*)0);
bzero((caddr_t
)so
, sizeof(*so
));
so
->so_type
= head
->so_type
;
so
->so_options
= head
->so_options
&~ SO_ACCEPTCONN
;
so
->so_linger
= head
->so_linger
;
so
->so_state
= head
->so_state
| SS_NOFDREF
;
so
->so_proto
= head
->so_proto
;
so
->so_timeo
= head
->so_timeo
;
so
->so_pgid
= head
->so_pgid
;
(void) soreserve(so
, head
->so_snd
.sb_hiwat
, head
->so_rcv
.sb_hiwat
);
soqinsque(head
, so
, soqueue
);
if ((*so
->so_proto
->pr_usrreq
)(so
, PRU_ATTACH
,
(struct mbuf
*)0, (struct mbuf
*)0, (struct mbuf
*)0)) {
(void) soqremque(so
, soqueue
);
(void) free((caddr_t
)so
, M_SOCKET
);
return ((struct socket
*)0);
wakeup((caddr_t
)&head
->so_timeo
);
so
->so_state
|= connstatus
;
register struct socket
*head
, *so
;
register struct socket
**prev
;
for (prev
= &(head
->so_q0
); *prev
; )
prev
= &((*prev
)->so_q0
);
for (prev
= &(head
->so_q
); *prev
; )
register struct socket
*so
;
register struct socket
*head
, *prev
, *next
;
next
= q
? prev
->so_q
: prev
->so_q0
;
prev
->so_q0
= next
->so_q0
;
next
->so_q0
= next
->so_q
= 0;
* Socantsendmore indicates that no more data will be sent on the
* socket; it would normally be applied to a socket when the user
* informs the system that no more data is to be sent, by the protocol
* code (in case PRU_SHUTDOWN). Socantrcvmore indicates that no more data
* will be received, and will normally be applied to the socket by a
* protocol when it detects that the peer will send no more data.
* Data queued for reading in the socket may yet be read.
so
->so_state
|= SS_CANTSENDMORE
;
so
->so_state
|= SS_CANTRCVMORE
;
* Wait for data to arrive at/drain from a socket buffer.
return (tsleep((caddr_t
)&sb
->sb_cc
,
(sb
->sb_flags
& SB_NOINTR
) ? PSOCK
: PSOCK
| PCATCH
, netio
,
* Lock a sockbuf already known to be locked;
* return any error returned from sleep (EINTR).
register struct sockbuf
*sb
;
while (sb
->sb_flags
& SB_LOCK
) {
if (error
= tsleep((caddr_t
)&sb
->sb_flags
,
(sb
->sb_flags
& SB_NOINTR
) ? PSOCK
: PSOCK
|PCATCH
,
* Wakeup processes waiting on a socket buffer.
* Do asynchronous notification via SIGIO
* if the socket has the SS_ASYNC flag set.
register struct socket
*so
;
register struct sockbuf
*sb
;
if (sb
->sb_flags
& SB_WAIT
) {
sb
->sb_flags
&= ~SB_WAIT
;
wakeup((caddr_t
)&sb
->sb_cc
);
if (so
->so_state
& SS_ASYNC
) {
gsignal(-so
->so_pgid
, SIGIO
);
else if (so
->so_pgid
> 0 && (p
= pfind(so
->so_pgid
)) != 0)
* Socket buffer (struct sockbuf) utility routines.
* Each socket contains two socket buffers: one for sending data and
* one for receiving data. Each buffer contains a queue of mbufs,
* information about the number of mbufs and amount of data in the
* queue, and other fields allowing select() statements and notification
* on data availability to be implemented.
* Data stored in a socket buffer is maintained as a list of records.
* Each record is a list of mbufs chained together with the m_next
* field. Records are chained together with the m_nextpkt field. The upper
* level routine soreceive() expects the following conventions to be
* observed when placing information in the receive buffer:
* 1. If the protocol requires each message be preceded by the sender's
* name, then a record containing that name must be present before
* any associated data (mbuf's must be of type MT_SONAME).
* 2. If the protocol supports the exchange of ``access rights'' (really
* just additional data associated with the message), and there are
* ``rights'' to be received, then a record containing this data
* should be present (mbuf's must be of type MT_RIGHTS).
* 3. If a name or rights record exists, then it must be followed by
* a data record, perhaps of zero length.
* Before using a new socket structure it is first necessary to reserve
* buffer space to the socket, by calling sbreserve(). This should commit
* some of the available buffer space in the system buffer pool for the
* socket (currently, it does nothing but enforce limits). The space
* should be released by calling sbrelease() when the socket is destroyed.
soreserve(so
, sndcc
, rcvcc
)
register struct socket
*so
;
if (sbreserve(&so
->so_snd
, sndcc
) == 0)
if (sbreserve(&so
->so_rcv
, rcvcc
) == 0)
if (so
->so_rcv
.sb_lowat
== 0)
if (so
->so_snd
.sb_lowat
== 0)
so
->so_snd
.sb_lowat
= MCLBYTES
;
if (so
->so_snd
.sb_lowat
> so
->so_snd
.sb_hiwat
)
so
->so_snd
.sb_lowat
= so
->so_snd
.sb_hiwat
;
* Allot mbufs to a sockbuf.
* Attempt to scale mbmax so that mbcnt doesn't become limiting
* if buffering efficiency is near the normal case.
if (cc
> sb_max
* MCLBYTES
/ (MSIZE
+ MCLBYTES
))
sb
->sb_mbmax
= min(cc
* 2, sb_max
);
if (sb
->sb_lowat
> sb
->sb_hiwat
)
sb
->sb_lowat
= sb
->sb_hiwat
;
* Free mbufs held by a socket, and reserved mbuf space.
sb
->sb_hiwat
= sb
->sb_mbmax
= 0;
* Routines to add and remove
* data from an mbuf queue.
* The routines sbappend() or sbappendrecord() are normally called to
* append new mbufs to a socket buffer, after checking that adequate
* space is available, comparing the function sbspace() with the amount
* of data to be added. sbappendrecord() differs from sbappend() in
* that data supplied is treated as the beginning of a new record.
* To place a sender's address, optional access rights, and data in a
* socket receive buffer, sbappendaddr() should be used. To place
* access rights and data in a socket receive buffer, sbappendrights()
* should be used. In either case, the new data begins a new record.
* Note that unlike sbappend() and sbappendrecord(), these routines check
* for the caller that there will be enough space to store the data.
* Each fails if there is not enough space, or if it cannot find mbufs
* to store additional information in.
* Reliable protocols may use the socket send buffer to hold data
* awaiting acknowledgement. Data is normally copied from a socket
* send buffer in a protocol with m_copy for output to a peer,
* and then removing the data from the socket buffer with sbdrop()
* or sbdroprecord() when the data is acknowledged by the peer.
* Append mbuf chain m to the last record in the
* socket buffer sb. The additional space associated
* the mbuf chain is recorded in sb. Empty mbufs are
* discarded and mbufs are compacted where possible.
register struct mbuf
*n
, *n0
;
register struct sockbuf
*sb
;
register int len
= 0, mbcnt
= 0;
for (m
= sb
->sb_mb
; m
; m
= m
->m_next
) {
mbcnt
+= m
->m_ext
.ext_size
;
panic("sbcheck nextpkt");
if (len
!= sb
->sb_cc
|| mbcnt
!= sb
->sb_mbcnt
) {
printf("cc %d != %d || mbcnt %d != %d\n", len
, sb
->sb_cc
,
* As above, except the mbuf chain
register struct sockbuf
*sb
;
register struct mbuf
*m0
;
* Put the first mbuf on the queue.
* Note this permits zero length records.
* As above except that OOB data
* is inserted at the beginning of the sockbuf,
* but after any other OOB data.
register struct sockbuf
*sb
;
register struct mbuf
*m0
;
register struct mbuf
**mp
;
for (mp
= &sb
->sb_mb
; m
= *mp
; mp
= &((*mp
)->m_nextpkt
)) {
continue; /* WANT next train */
goto again
; /* inspect THIS train further */
* Put the first mbuf on the queue.
* Note this permits zero length records.
for (m
= m0
; m
; m
= m
->m_next
)
* Append address and data, and optionally, control (ancillary) data
* to the receive queue of a socket. If present,
* m0 must include a packet header with total length.
* Returns 0 if no space in sockbuf or insufficient mbufs.
sbappendaddr(sb
, asa
, m0
, control
)
register struct sockbuf
*sb
;
struct mbuf
*m0
, *control
;
register struct mbuf
*m
, *n
;
int space
= asa
->sa_len
, eor
= 0;
if (m0
&& (m0
->m_flags
& M_PKTHDR
) == 0)
space
+= m0
->m_pkthdr
.len
;
for (n
= control
; n
; n
= n
->m_next
) {
if (n
->m_next
== 0) /* keep pointer to last control buf */
MGET(m
, M_DONTWAIT
, MT_SONAME
);
bcopy((caddr_t
)asa
, mtod(m
, caddr_t
), asa
->sa_len
);
n
->m_next
= m0
; /* concatenate data to control */
for (n
= m
; n
; n
= n
->m_next
) {
eor
|= n
->m_flags
& M_EOR
;
sbappendcontrol(sb
, m0
, control
)
struct mbuf
*control
, *m0
;
register struct mbuf
*m
, *n
;
panic("sbappendcontrol");
for (m
= control
; ; m
= m
->m_next
) {
n
= m
; /* save pointer to last control buffer */
for (m
= m0
; m
; m
= m
->m_next
)
n
->m_next
= m0
; /* concatenate data to control */
for (m
= control
; m
; m
= m
->m_next
) {
eor
|= m
->m_flags
& M_EOR
;
* Compress mbuf chain m into the socket
* buffer sb following mbuf n. If n
* is null, the buffer is presumed empty.
register struct sockbuf
*sb
;
register struct mbuf
*n
= n0
;
eor
|= m
->m_flags
& M_EOR
;
if (eor
== 0 || m
->m_next
|| n
) {
if (n
&& (n
->m_flags
& M_EXT
) == 0 &&
(n
->m_data
+ n
->m_len
+ m
->m_len
) < &n
->m_dat
[MLEN
] &&
n
->m_type
== m
->m_type
) {
bcopy(mtod(m
, caddr_t
), mtod(n
, caddr_t
) + n
->m_len
,
/*m->m_flags &= ~M_EOR;*/
* Free all mbufs in a sockbuf.
* Check that all resources are reclaimed.
register struct sockbuf
*sb
;
if (sb
->sb_flags
& SB_LOCK
)
sbdrop(sb
, (int)sb
->sb_cc
);
if (sb
->sb_cc
|| sb
->sb_mb
)
* Drop data from (the front of) a sockbuf.
register struct sockbuf
*sb
;
register struct mbuf
*m
, *mn
;
next
= (m
= sb
->sb_mb
) ? m
->m_nextpkt
: 0;
while (m
&& m
->m_len
== 0) {
* Drop a record off the front of a sockbuf
* and move the next record to the front.
register struct sockbuf
*sb
;
register struct mbuf
*m
, *mn
;
sb
->sb_mb
= m
->m_nextpkt
;