* Copyright (c) 1982, 1986 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
* @(#)uipc_socket2.c 7.1 (Berkeley) %G%
* Primitive routines for operating on sockets and socket buffers
* 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
;
wakeup((caddr_t
)&so
->so_timeo
);
register struct socket
*so
;
register struct socket
*head
= so
->so_head
;
if (soqremque(so
, 0) == 0)
wakeup((caddr_t
)&head
->so_timeo
);
so
->so_state
&= ~(SS_ISCONNECTING
|SS_ISDISCONNECTING
);
so
->so_state
|= SS_ISCONNECTED
;
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.
register struct socket
*head
;
register struct socket
*so
;
if (head
->so_qlen
+ head
->so_q0len
> 3 * head
->so_qlimit
/ 2)
m
= m_getclr(M_DONTWAIT
, MT_SOCKET
);
so
= mtod(m
, struct socket
*);
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_pgrp
= head
->so_pgrp
;
if ((*so
->so_proto
->pr_usrreq
)(so
, PRU_ATTACH
,
(struct mbuf
*)0, (struct mbuf
*)0, (struct mbuf
*)0)) {
return ((struct socket
*)0);
register struct socket
*head
, *so
;
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
;
* Socket select/wakeup routines.
* Queue a process for a select on a socket buffer.
if ((p
= sb
->sb_sel
) && p
->p_wchan
== (caddr_t
)&selwait
)
* Wait for data to arrive at/drain from a socket buffer.
sleep((caddr_t
)&sb
->sb_cc
, PZERO
+1);
* Wakeup processes waiting on a socket buffer.
register struct sockbuf
*sb
;
selwakeup(sb
->sb_sel
, sb
->sb_flags
& SB_COLL
);
sb
->sb_flags
&= ~SB_COLL
;
if (sb
->sb_flags
& SB_WAIT
) {
sb
->sb_flags
&= ~SB_WAIT
;
wakeup((caddr_t
)&sb
->sb_cc
);
* Wakeup socket readers and writers.
* Do asynchronous notification via SIGIO
* if the socket has the SS_ASYNC flag set.
register struct socket
*so
;
if (so
->so_state
& SS_ASYNC
) {
gsignal(-so
->so_pgrp
, SIGIO
);
else if (so
->so_pgrp
> 0 && (p
= pfind(so
->so_pgrp
)) != 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_act 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 commits
* some of the available buffer space in the system buffer pool for the
* socket. The space should be released by calling sbrelease() when the
soreserve(so
, sndcc
, rcvcc
)
register struct socket
*so
;
if (sbreserve(&so
->so_snd
, sndcc
) == 0)
if (sbreserve(&so
->so_rcv
, rcvcc
) == 0)
* Allot mbufs to a sockbuf.
* Attempt to scale cc so that mbcnt doesn't become limiting
* if buffering efficiency is near the normal case.
if ((unsigned) cc
> (unsigned)SB_MAX
* CLBYTES
/ (2 * MSIZE
+ CLBYTES
))
sb
->sb_mbmax
= MIN(cc
* 2, SB_MAX
);
* 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.
* 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.
* Append address and data, and optionally, rights
* to the receive queue of a socket. Return 0 if
* no space in sockbuf or insufficient mbufs.
sbappendaddr(sb
, asa
, m0
, rights0
)
register struct sockbuf
*sb
;
struct mbuf
*rights0
, *m0
;
register struct mbuf
*m
, *n
;
int space
= sizeof (*asa
);
for (m
= m0
; m
; m
= m
->m_next
)
MGET(m
, M_DONTWAIT
, MT_SONAME
);
*mtod(m
, struct sockaddr
*) = *asa
;
m
->m_len
= sizeof (*asa
);
if (rights0
&& rights0
->m_len
) {
m
->m_next
= m_copy(rights0
, 0, rights0
->m_len
);
sbappendrights(sb
, m0
, rights
)
struct mbuf
*rights
, *m0
;
register struct mbuf
*m
, *n
;
for (m
= m0
; m
; m
= m
->m_next
)
m
= m_copy(rights
, 0, rights
->m_len
);
* 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
*m
, *n
;
if (n
&& n
->m_off
<= MMAXOFF
&& m
->m_off
<= MMAXOFF
&&
(n
->m_off
+ n
->m_len
+ m
->m_len
) <= MMAXOFF
&&
n
->m_type
== m
->m_type
) {
bcopy(mtod(m
, caddr_t
), mtod(n
, caddr_t
) + n
->m_len
,
* 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_mbcnt
|| 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_act
: 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
;