/* uipc_socket2.c 4.35 83/01/13 */
#include "../h/protosw.h"
#include "../h/socketvar.h"
* 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 SO_ACCEPTCONN
* creating 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 SO_ACCEPTCONN socket is closed with sockets on either
* so_q0 or so_q, these sockets are dropped.
* If and when higher level protocols are implemented in
* the kernel, the wakeups done here will sometimes
* be implemented as software-interrupt process scheduling.
so
->so_state
&= ~(SS_ISCONNECTED
|SS_ISDISCONNECTING
);
so
->so_state
|= SS_ISCONNECTING
;
wakeup((caddr_t
)&so
->so_timeo
);
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
);
so
->so_state
&= ~SS_ISCONNECTING
;
so
->so_state
|= (SS_ISDISCONNECTING
|SS_CANTRCVMORE
|SS_CANTSENDMORE
);
wakeup((caddr_t
)&so
->so_timeo
);
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,
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.
* Interface routine to select() system
register struct socket
*so
;
* 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.
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
);
* 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.
* 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
* The routine sbappend() is normally called to append new mbufs
* to a socket buffer, after checking that adequate space is available
* comparing the function spspace() with the amount of data to be added.
* Data is normally removed from a socket buffer in a protocol by
* first calling m_copy on the socket buffer mbuf chain and sending this
* to a peer, and then removing the data from the socket buffer with
* sbdrop when the data is acknowledged by the peer (or immediately
* in the case of unreliable protocols.)
* Protocols which do not require connections place both source address
* and data information in socket buffer queues. The source addresses
* are stored in single mbufs after each data item, and are easily found
* as the data items are all marked with end of record markers. The
* sbappendaddr() routine stores a datum and associated address in
* a socket buffer. Note that, unlike sbappend(), this routine checks
* for the caller that there will be enough space to store the data.
* It fails if there is not enough space, or if it cannot find
* a mbuf to store the address in.
* The higher-level routines sosend and soreceive (in socket.c)
* also add data to, and remove data from socket buffers repectively.
soreserve(so
, sndcc
, rcvcc
)
if (sbreserve(&so
->so_snd
, sndcc
) == 0)
if (sbreserve(&so
->so_rcv
, rcvcc
) == 0)
* Allot mbufs to a sockbuf.
/* someday maybe this routine will fail... */
/* the 2 implies names can be no more than 1 mbuf each */
* Free mbufs held by a socket, and reserved mbuf space.
sb
->sb_hiwat
= sb
->sb_mbmax
= 0;
* Routines to add (at the end) and remove (from the beginning)
* data from a mbuf queue.
* Append mbuf queue m to sockbuf sb.
register struct sockbuf
*sb
;
if (m
->m_len
== 0 && (int)m
->m_act
== 0) {
if (n
&& n
->m_off
<= MMAXOFF
&& m
->m_off
<= MMAXOFF
&&
(int)n
->m_act
== 0 && (int)m
->m_act
== 0 &&
(n
->m_off
+ n
->m_len
+ m
->m_len
) <= MMAXOFF
) {
bcopy(mtod(m
, caddr_t
), mtod(n
, caddr_t
) + n
->m_len
,
* Append data and address.
* Return 0 if no space in sockbuf or if
* can't get mbuf to stuff address in.
sbappendaddr(sb
, asa
, m0
)
register int len
= sizeof (struct sockaddr
);
m
->m_act
= (struct mbuf
*)1;
m
= m_get(M_DONTWAIT
, MT_SONAME
);
m
->m_len
= sizeof (struct sockaddr
);
msa
= mtod(m
, struct sockaddr
*);
m
->m_act
= (struct mbuf
*)1;
register int cnt
= sb
->sb_cc
;
register int mbcnt
= sb
->sb_mbcnt
;
for (m
= sb
->sb_mb
; m
; m
= m
->m_next
) {
printf("cnt %d mbcnt %d\n", cnt
, mbcnt
);
* Free all mbufs on a sockbuf mbuf chain.
* Check that resource allocations return to 0.
if (sb
->sb_flags
& SB_LOCK
)
if (sb
->sb_cc
|| sb
->sb_mbcnt
|| sb
->sb_mb
)
* Drop data from (the front of) a sockbuf chain.
register struct sockbuf
*sb
;
register struct mbuf
*m
= sb
->sb_mb
, *mn
;