#define ROUNDUP(a, b) (((a) + ((b) - 1)) & (~((b) - 1)))
#if DEBUG || DEVELOPMENT
-#define DEBUG_KERNEL_ADDRPERM(_v) (_v)
+#define DEBUG_KERNEL_ADDRPERM(_v) (_v)
#else
-#define DEBUG_KERNEL_ADDRPERM(_v) VM_KERNEL_ADDRPERM(_v)
+#define DEBUG_KERNEL_ADDRPERM(_v) VM_KERNEL_ADDRPERM(_v)
#endif
/* TODO: this should be in a header file somewhere */
extern char *proc_name_address(void *p);
-static u_int32_t so_cache_hw; /* High water mark for socache */
-static u_int32_t so_cache_timeouts; /* number of timeouts */
-static u_int32_t so_cache_max_freed; /* max freed per timeout */
-static u_int32_t cached_sock_count = 0;
-STAILQ_HEAD(, socket) so_cache_head;
-int max_cached_sock_count = MAX_CACHED_SOCKETS;
-static u_int32_t so_cache_time;
-static int socketinit_done;
-static struct zone *so_cache_zone;
-
-static lck_grp_t *so_cache_mtx_grp;
-static lck_attr_t *so_cache_mtx_attr;
-static lck_grp_attr_t *so_cache_mtx_grp_attr;
-static lck_mtx_t *so_cache_mtx;
+static u_int32_t so_cache_hw; /* High water mark for socache */
+static u_int32_t so_cache_timeouts; /* number of timeouts */
+static u_int32_t so_cache_max_freed; /* max freed per timeout */
+static u_int32_t cached_sock_count = 0;
+STAILQ_HEAD(, socket) so_cache_head;
+int max_cached_sock_count = MAX_CACHED_SOCKETS;
+static u_int32_t so_cache_time;
+static int socketinit_done;
+static struct zone *so_cache_zone;
+
+static lck_grp_t *so_cache_mtx_grp;
+static lck_attr_t *so_cache_mtx_attr;
+static lck_grp_attr_t *so_cache_mtx_grp_attr;
+static lck_mtx_t *so_cache_mtx;
#include <machine/limits.h>
-static int filt_sorattach(struct knote *kn, struct kevent_internal_s *kev);
-static void filt_sordetach(struct knote *kn);
-static int filt_soread(struct knote *kn, long hint);
-static int filt_sortouch(struct knote *kn, struct kevent_internal_s *kev);
-static int filt_sorprocess(struct knote *kn, struct filt_process_s *data, struct kevent_internal_s *kev);
+static int filt_sorattach(struct knote *kn, struct kevent_internal_s *kev);
+static void filt_sordetach(struct knote *kn);
+static int filt_soread(struct knote *kn, long hint);
+static int filt_sortouch(struct knote *kn, struct kevent_internal_s *kev);
+static int filt_sorprocess(struct knote *kn, struct filt_process_s *data, struct kevent_internal_s *kev);
-static int filt_sowattach(struct knote *kn, struct kevent_internal_s *kev);
-static void filt_sowdetach(struct knote *kn);
-static int filt_sowrite(struct knote *kn, long hint);
-static int filt_sowtouch(struct knote *kn, struct kevent_internal_s *kev);
-static int filt_sowprocess(struct knote *kn, struct filt_process_s *data, struct kevent_internal_s *kev);
+static int filt_sowattach(struct knote *kn, struct kevent_internal_s *kev);
+static void filt_sowdetach(struct knote *kn);
+static int filt_sowrite(struct knote *kn, long hint);
+static int filt_sowtouch(struct knote *kn, struct kevent_internal_s *kev);
+static int filt_sowprocess(struct knote *kn, struct filt_process_s *data, struct kevent_internal_s *kev);
-static int filt_sockattach(struct knote *kn, struct kevent_internal_s *kev);
-static void filt_sockdetach(struct knote *kn);
-static int filt_sockev(struct knote *kn, long hint);
-static int filt_socktouch(struct knote *kn, struct kevent_internal_s *kev);
-static int filt_sockprocess(struct knote *kn, struct filt_process_s *data, struct kevent_internal_s *kev);
+static int filt_sockattach(struct knote *kn, struct kevent_internal_s *kev);
+static void filt_sockdetach(struct knote *kn);
+static int filt_sockev(struct knote *kn, long hint);
+static int filt_socktouch(struct knote *kn, struct kevent_internal_s *kev);
+static int filt_sockprocess(struct knote *kn, struct filt_process_s *data, struct kevent_internal_s *kev);
static int sooptcopyin_timeval(struct sockopt *, struct timeval *);
static int sooptcopyout_timeval(struct sockopt *, const struct timeval *);
SYSCTL_DECL(_kern_ipc);
-#define EVEN_MORE_LOCKING_DEBUG 0
+#define EVEN_MORE_LOCKING_DEBUG 0
int socket_debug = 0;
SYSCTL_INT(_kern_ipc, OID_AUTO, socket_debug,
- CTLFLAG_RW | CTLFLAG_LOCKED, &socket_debug, 0, "");
+ CTLFLAG_RW | CTLFLAG_LOCKED, &socket_debug, 0, "");
static unsigned long sodefunct_calls = 0;
SYSCTL_LONG(_kern_ipc, OID_AUTO, sodefunct_calls, CTLFLAG_LOCKED,
&sodefunct_calls, "");
static int socket_zone = M_SOCKET;
-so_gen_t so_gencnt; /* generation count for sockets */
+so_gen_t so_gencnt; /* generation count for sockets */
MALLOC_DEFINE(M_SONAME, "soname", "socket name");
MALLOC_DEFINE(M_PCB, "pcb", "protocol control block");
-#define DBG_LAYER_IN_BEG NETDBG_CODE(DBG_NETSOCK, 0)
-#define DBG_LAYER_IN_END NETDBG_CODE(DBG_NETSOCK, 2)
-#define DBG_LAYER_OUT_BEG NETDBG_CODE(DBG_NETSOCK, 1)
-#define DBG_LAYER_OUT_END NETDBG_CODE(DBG_NETSOCK, 3)
-#define DBG_FNC_SOSEND NETDBG_CODE(DBG_NETSOCK, (4 << 8) | 1)
-#define DBG_FNC_SOSEND_LIST NETDBG_CODE(DBG_NETSOCK, (4 << 8) | 3)
-#define DBG_FNC_SORECEIVE NETDBG_CODE(DBG_NETSOCK, (8 << 8))
-#define DBG_FNC_SORECEIVE_LIST NETDBG_CODE(DBG_NETSOCK, (8 << 8) | 3)
-#define DBG_FNC_SOSHUTDOWN NETDBG_CODE(DBG_NETSOCK, (9 << 8))
+#define DBG_LAYER_IN_BEG NETDBG_CODE(DBG_NETSOCK, 0)
+#define DBG_LAYER_IN_END NETDBG_CODE(DBG_NETSOCK, 2)
+#define DBG_LAYER_OUT_BEG NETDBG_CODE(DBG_NETSOCK, 1)
+#define DBG_LAYER_OUT_END NETDBG_CODE(DBG_NETSOCK, 3)
+#define DBG_FNC_SOSEND NETDBG_CODE(DBG_NETSOCK, (4 << 8) | 1)
+#define DBG_FNC_SOSEND_LIST NETDBG_CODE(DBG_NETSOCK, (4 << 8) | 3)
+#define DBG_FNC_SORECEIVE NETDBG_CODE(DBG_NETSOCK, (8 << 8))
+#define DBG_FNC_SORECEIVE_LIST NETDBG_CODE(DBG_NETSOCK, (8 << 8) | 3)
+#define DBG_FNC_SOSHUTDOWN NETDBG_CODE(DBG_NETSOCK, (9 << 8))
-#define MAX_SOOPTGETM_SIZE (128 * MCLBYTES)
+#define MAX_SOOPTGETM_SIZE (128 * MCLBYTES)
int somaxconn = SOMAXCONN;
SYSCTL_INT(_kern_ipc, KIPC_SOMAXCONN, somaxconn,
- CTLFLAG_RW | CTLFLAG_LOCKED, &somaxconn, 0, "");
+ CTLFLAG_RW | CTLFLAG_LOCKED, &somaxconn, 0, "");
/* Should we get a maximum also ??? */
static int sosendmaxchain = 65536;
static int sosendminchain = 16384;
static int sorecvmincopy = 16384;
SYSCTL_INT(_kern_ipc, OID_AUTO, sosendminchain,
- CTLFLAG_RW | CTLFLAG_LOCKED, &sosendminchain, 0, "");
+ CTLFLAG_RW | CTLFLAG_LOCKED, &sosendminchain, 0, "");
SYSCTL_INT(_kern_ipc, OID_AUTO, sorecvmincopy,
- CTLFLAG_RW | CTLFLAG_LOCKED, &sorecvmincopy, 0, "");
+ CTLFLAG_RW | CTLFLAG_LOCKED, &sorecvmincopy, 0, "");
/*
* Set to enable jumbo clusters (if available) for large writes when
*/
int sosendjcl = 1;
SYSCTL_INT(_kern_ipc, OID_AUTO, sosendjcl,
- CTLFLAG_RW | CTLFLAG_LOCKED, &sosendjcl, 0, "");
+ CTLFLAG_RW | CTLFLAG_LOCKED, &sosendjcl, 0, "");
/*
* Set this to ignore SOF_MULTIPAGES and use jumbo clusters for large
*/
int sosendjcl_ignore_capab = 0;
SYSCTL_INT(_kern_ipc, OID_AUTO, sosendjcl_ignore_capab,
- CTLFLAG_RW | CTLFLAG_LOCKED, &sosendjcl_ignore_capab, 0, "");
+ CTLFLAG_RW | CTLFLAG_LOCKED, &sosendjcl_ignore_capab, 0, "");
/*
* Set this to ignore SOF1_IF_2KCL and use big clusters for large
*/
int sosendbigcl_ignore_capab = 0;
SYSCTL_INT(_kern_ipc, OID_AUTO, sosendbigcl_ignore_capab,
- CTLFLAG_RW | CTLFLAG_LOCKED, &sosendbigcl_ignore_capab, 0, "");
+ CTLFLAG_RW | CTLFLAG_LOCKED, &sosendbigcl_ignore_capab, 0, "");
int sodefunctlog = 0;
SYSCTL_INT(_kern_ipc, OID_AUTO, sodefunctlog, CTLFLAG_RW | CTLFLAG_LOCKED,
- &sodefunctlog, 0, "");
+ &sodefunctlog, 0, "");
int sothrottlelog = 0;
SYSCTL_INT(_kern_ipc, OID_AUTO, sothrottlelog, CTLFLAG_RW | CTLFLAG_LOCKED,
- &sothrottlelog, 0, "");
+ &sothrottlelog, 0, "");
int sorestrictrecv = 1;
SYSCTL_INT(_kern_ipc, OID_AUTO, sorestrictrecv, CTLFLAG_RW | CTLFLAG_LOCKED,
- &sorestrictrecv, 0, "Enable inbound interface restrictions");
+ &sorestrictrecv, 0, "Enable inbound interface restrictions");
int sorestrictsend = 1;
SYSCTL_INT(_kern_ipc, OID_AUTO, sorestrictsend, CTLFLAG_RW | CTLFLAG_LOCKED,
- &sorestrictsend, 0, "Enable outbound interface restrictions");
+ &sorestrictsend, 0, "Enable outbound interface restrictions");
int soreserveheadroom = 1;
SYSCTL_INT(_kern_ipc, OID_AUTO, soreserveheadroom, CTLFLAG_RW | CTLFLAG_LOCKED,
- &soreserveheadroom, 0, "To allocate contiguous datagram buffers");
+ &soreserveheadroom, 0, "To allocate contiguous datagram buffers");
#if (DEBUG || DEVELOPMENT)
int so_notsent_lowat_check = 1;
-SYSCTL_INT(_kern_ipc, OID_AUTO, notsent_lowat, CTLFLAG_RW|CTLFLAG_LOCKED,
+SYSCTL_INT(_kern_ipc, OID_AUTO, notsent_lowat, CTLFLAG_RW | CTLFLAG_LOCKED,
&so_notsent_lowat_check, 0, "enable/disable notsnet lowat check");
#endif /* DEBUG || DEVELOPMENT */
int so_accept_list_waits = 0;
#if (DEBUG || DEVELOPMENT)
-SYSCTL_INT(_kern_ipc, OID_AUTO, accept_list_waits, CTLFLAG_RW|CTLFLAG_LOCKED,
+SYSCTL_INT(_kern_ipc, OID_AUTO, accept_list_waits, CTLFLAG_RW | CTLFLAG_LOCKED,
&so_accept_list_waits, 0, "number of waits for listener incomp list");
#endif /* DEBUG || DEVELOPMENT */
extern int get_inpcb_str_size(void);
extern int get_tcp_str_size(void);
-vm_size_t so_cache_zone_element_size;
+vm_size_t so_cache_zone_element_size;
static int sodelayed_copy(struct socket *, struct uio *, struct mbuf **,
user_ssize_t *);
* Set to zero to disable further setting of the option
*/
-#define SO_IDLE_BK_IDLE_MAX_PER_PROC 1
-#define SO_IDLE_BK_IDLE_TIME 600
-#define SO_IDLE_BK_IDLE_RCV_HIWAT 131072
+#define SO_IDLE_BK_IDLE_MAX_PER_PROC 1
+#define SO_IDLE_BK_IDLE_TIME 600
+#define SO_IDLE_BK_IDLE_RCV_HIWAT 131072
struct soextbkidlestat soextbkidlestat;
SYSCTL_UINT(_kern_ipc, OID_AUTO, maxextbkidleperproc,
- CTLFLAG_RW | CTLFLAG_LOCKED, &soextbkidlestat.so_xbkidle_maxperproc, 0,
- "Maximum of extended background idle sockets per process");
+ CTLFLAG_RW | CTLFLAG_LOCKED, &soextbkidlestat.so_xbkidle_maxperproc, 0,
+ "Maximum of extended background idle sockets per process");
SYSCTL_UINT(_kern_ipc, OID_AUTO, extbkidletime, CTLFLAG_RW | CTLFLAG_LOCKED,
- &soextbkidlestat.so_xbkidle_time, 0,
- "Time in seconds to keep extended background idle sockets");
+ &soextbkidlestat.so_xbkidle_time, 0,
+ "Time in seconds to keep extended background idle sockets");
SYSCTL_UINT(_kern_ipc, OID_AUTO, extbkidlercvhiwat, CTLFLAG_RW | CTLFLAG_LOCKED,
- &soextbkidlestat.so_xbkidle_rcvhiwat, 0,
- "High water mark for extended background idle sockets");
+ &soextbkidlestat.so_xbkidle_rcvhiwat, 0,
+ "High water mark for extended background idle sockets");
SYSCTL_STRUCT(_kern_ipc, OID_AUTO, extbkidlestat, CTLFLAG_RD | CTLFLAG_LOCKED,
- &soextbkidlestat, soextbkidlestat, "");
+ &soextbkidlestat, soextbkidlestat, "");
int so_set_extended_bk_idle(struct socket *, int);
*/
__private_extern__ u_int32_t sotcdb = 0;
SYSCTL_INT(_kern_ipc, OID_AUTO, sotcdb, CTLFLAG_RW | CTLFLAG_LOCKED,
- &sotcdb, 0, "");
+ &sotcdb, 0, "");
void
socketinit(void)
socketinit_done = 1;
PE_parse_boot_argn("socket_debug", &socket_debug,
- sizeof (socket_debug));
+ sizeof(socket_debug));
/*
* allocate lock group attribute and group for socket cache mutex
}
STAILQ_INIT(&so_cache_head);
- so_cache_zone_element_size = (vm_size_t)(sizeof (struct socket) + 4
+ so_cache_zone_element_size = (vm_size_t)(sizeof(struct socket) + 4
+ get_inpcb_str_size() + 4 + get_tcp_str_size());
so_cache_zone = zinit(so_cache_zone_element_size,
static void
cached_sock_alloc(struct socket **so, int waitok)
{
- caddr_t temp;
+ caddr_t temp;
uintptr_t offset;
lck_mtx_lock(so_cache_mtx);
lck_mtx_unlock(so_cache_mtx);
temp = (*so)->so_saved_pcb;
- bzero((caddr_t)*so, sizeof (struct socket));
+ bzero((caddr_t)*so, sizeof(struct socket));
(*so)->so_saved_pcb = temp;
} else {
-
lck_mtx_unlock(so_cache_mtx);
- if (waitok)
+ if (waitok) {
*so = (struct socket *)zalloc(so_cache_zone);
- else
+ } else {
*so = (struct socket *)zalloc_noblock(so_cache_zone);
+ }
- if (*so == NULL)
+ if (*so == NULL) {
return;
+ }
- bzero((caddr_t)*so, sizeof (struct socket));
+ bzero((caddr_t)*so, sizeof(struct socket));
/*
* Define offsets for extra structures into our
*/
offset = (uintptr_t)*so;
- offset += sizeof (struct socket);
+ offset += sizeof(struct socket);
offset = ALIGN(offset);
static void
cached_sock_free(struct socket *so)
{
-
lck_mtx_lock(so_cache_mtx);
so_cache_time = net_uptime();
lck_mtx_unlock(so_cache_mtx);
zfree(so_cache_zone, so);
} else {
- if (so_cache_hw < cached_sock_count)
+ if (so_cache_hw < cached_sock_count) {
so_cache_hw = cached_sock_count;
+ }
STAILQ_INSERT_TAIL(&so_cache_head, so, so_cache_ent);
* last_pid and last_upid should remain zero for sockets
* created using sock_socket. The check above achieves that
*/
- if (self == PROC_NULL)
+ if (self == PROC_NULL) {
self = current_proc();
+ }
if (so->last_upid != proc_uniqueid(self) ||
so->last_pid != proc_pid(self)) {
so->last_upid = proc_uniqueid(self);
so->last_pid = proc_pid(self);
proc_getexecutableuuid(self, so->last_uuid,
- sizeof (so->last_uuid));
+ sizeof(so->last_uuid));
}
proc_pidoriginatoruuid(so->so_vuuid, sizeof(so->so_vuuid));
}
void
so_update_policy(struct socket *so)
{
- if (SOCK_DOM(so) == PF_INET || SOCK_DOM(so) == PF_INET6)
+ if (SOCK_DOM(so) == PF_INET || SOCK_DOM(so) == PF_INET6) {
(void) inp_update_policy(sotoinpcb(so));
+ }
}
#if NECP
so_update_necp_policy(struct socket *so, struct sockaddr *override_local_addr,
struct sockaddr *override_remote_addr)
{
- if (SOCK_DOM(so) == PF_INET || SOCK_DOM(so) == PF_INET6)
+ if (SOCK_DOM(so) == PF_INET || SOCK_DOM(so) == PF_INET6) {
inp_update_necp_policy(sotoinpcb(so), override_local_addr,
override_remote_addr, 0);
+ }
}
#endif /* NECP */
boolean_t
so_cache_timer(void)
{
- struct socket *p;
- int n_freed = 0;
+ struct socket *p;
+ int n_freed = 0;
boolean_t rc = FALSE;
lck_mtx_lock(so_cache_mtx);
VERIFY(cached_sock_count > 0);
p = STAILQ_FIRST(&so_cache_head);
if ((so_cache_time - p->cache_timestamp) <
- SO_CACHE_TIME_LIMIT)
+ SO_CACHE_TIME_LIMIT) {
break;
+ }
STAILQ_REMOVE_HEAD(&so_cache_head, so_cache_ent);
--cached_sock_count;
}
/* Schedule again if there is more to cleanup */
- if (!STAILQ_EMPTY(&so_cache_head))
+ if (!STAILQ_EMPTY(&so_cache_head)) {
rc = TRUE;
+ }
lck_mtx_unlock(so_cache_mtx);
- return (rc);
+ return rc;
}
/*
if ((dom == PF_INET) && (type == SOCK_STREAM)) {
cached_sock_alloc(&so, waitok);
} else {
- MALLOC_ZONE(so, struct socket *, sizeof (*so), socket_zone,
+ MALLOC_ZONE(so, struct socket *, sizeof(*so), socket_zone,
M_WAITOK);
- if (so != NULL)
- bzero(so, sizeof (*so));
+ if (so != NULL) {
+ bzero(so, sizeof(*so));
+ }
}
if (so != NULL) {
so->so_gencnt = OSIncrementAtomic64((SInt64 *)&so_gencnt);
/* Convert waitok to M_WAITOK/M_NOWAIT for MAC Framework. */
if (mac_socket_label_init(so, !waitok) != 0) {
sodealloc(so);
- return (NULL);
+ return NULL;
}
#endif /* MAC_SOCKET */
}
- return (so);
+ return so;
}
int
VERIFY(aso != NULL);
*aso = NULL;
- if (proto != 0)
+ if (proto != 0) {
prp = pffindproto(dom, proto, type);
- else
+ } else {
prp = pffindtype(dom, type);
+ }
if (prp == NULL || prp->pr_usrreqs->pru_attach == NULL) {
- if (pffinddomain(dom) == NULL)
- return (EAFNOSUPPORT);
+ if (pffinddomain(dom) == NULL) {
+ return EAFNOSUPPORT;
+ }
if (proto != 0) {
- if (pffindprotonotype(dom, proto) != NULL)
- return (EPROTOTYPE);
+ if (pffindprotonotype(dom, proto) != NULL) {
+ return EPROTOTYPE;
+ }
}
- return (EPROTONOSUPPORT);
+ return EPROTONOSUPPORT;
+ }
+ if (prp->pr_type != type) {
+ return EPROTOTYPE;
}
- if (prp->pr_type != type)
- return (EPROTOTYPE);
so = soalloc(1, dom, type);
- if (so == NULL)
- return (ENOBUFS);
+ if (so == NULL) {
+ return ENOBUFS;
+ }
switch (dom) {
- case PF_LOCAL:
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_local_total);
- break;
- case PF_INET:
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_inet_total);
- if (type == SOCK_STREAM) {
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet_stream_total);
- } else {
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet_dgram_total);
- }
- break;
- case PF_ROUTE:
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_route_total);
- break;
- case PF_NDRV:
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_ndrv_total);
- break;
- case PF_KEY:
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_key_total);
- break;
- case PF_INET6:
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_inet6_total);
- if (type == SOCK_STREAM) {
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet6_stream_total);
- } else {
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet6_dgram_total);
- }
- break;
- case PF_SYSTEM:
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_system_total);
- break;
- case PF_MULTIPATH:
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_multipath_total);
- break;
- default:
- INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_other_total);
- break;
+ case PF_LOCAL:
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_local_total);
+ break;
+ case PF_INET:
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_inet_total);
+ if (type == SOCK_STREAM) {
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet_stream_total);
+ } else {
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet_dgram_total);
+ }
+ break;
+ case PF_ROUTE:
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_route_total);
+ break;
+ case PF_NDRV:
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_ndrv_total);
+ break;
+ case PF_KEY:
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_key_total);
+ break;
+ case PF_INET6:
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_inet6_total);
+ if (type == SOCK_STREAM) {
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet6_stream_total);
+ } else {
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_inet6_dgram_total);
+ }
+ break;
+ case PF_SYSTEM:
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_system_total);
+ break;
+ case PF_MULTIPATH:
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_multipath_total);
+ break;
+ default:
+ INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_domain_other_total);
+ break;
}
- if (flags & SOCF_ASYNC)
+ if (flags & SOCF_ASYNC) {
so->so_state |= SS_NBIO;
+ }
TAILQ_INIT(&so->so_incomp);
TAILQ_INIT(&so->so_comp);
so->so_type = type;
so->last_upid = proc_uniqueid(p);
so->last_pid = proc_pid(p);
- proc_getexecutableuuid(p, so->last_uuid, sizeof (so->last_uuid));
+ proc_getexecutableuuid(p, so->last_uuid, sizeof(so->last_uuid));
proc_pidoriginatoruuid(so->so_vuuid, sizeof(so->so_vuuid));
if (ep != PROC_NULL && ep != p) {
so->e_upid = proc_uniqueid(ep);
so->e_pid = proc_pid(ep);
- proc_getexecutableuuid(ep, so->e_uuid, sizeof (so->e_uuid));
+ proc_getexecutableuuid(ep, so->e_uuid, sizeof(so->e_uuid));
so->so_flags |= SOF_DELEGATED;
}
so->so_cred = kauth_cred_proc_ref(p);
- if (!suser(kauth_cred_get(), NULL))
+ if (!suser(kauth_cred_get(), NULL)) {
so->so_state |= SS_PRIV;
+ }
so->so_proto = prp;
so->so_rcv.sb_flags |= SB_RECV;
so->so_state |= SS_NOFDREF;
VERIFY(so->so_usecount > 0);
so->so_usecount--;
- sofreelastref(so, 1); /* will deallocate the socket */
- return (error);
+ sofreelastref(so, 1); /* will deallocate the socket */
+ return error;
}
atomic_add_32(&prp->pr_domain->dom_refs, 1);
/* Attach socket filters for this protocol */
sflt_initsock(so);
#if TCPDEBUG
- if (tcpconsdebug == 2)
+ if (tcpconsdebug == 2) {
so->so_options |= SO_DEBUG;
+ }
#endif
so_set_default_traffic_class(so);
*aso = so;
- return (0);
+ return 0;
}
/*
int
socreate(int dom, struct socket **aso, int type, int proto)
{
- return (socreate_internal(dom, aso, type, proto, current_proc(), 0,
- PROC_NULL));
+ return socreate_internal(dom, aso, type, proto, current_proc(), 0,
+ PROC_NULL);
}
int
* socreate_internal since it calls soalloc with M_WAITOK
*/
done:
- if (ep != PROC_NULL)
+ if (ep != PROC_NULL) {
proc_rele(ep);
+ }
- return (error);
+ return error;
}
/*
struct proc *p = current_proc();
int error = 0;
- if (dolock)
+ if (dolock) {
socket_lock(so, 1);
+ }
so_update_last_owner_locked(so, p);
so_update_policy(so);
/* Socket filter */
error = sflt_bind(so, nam);
- if (error == 0)
+ if (error == 0) {
error = (*so->so_proto->pr_usrreqs->pru_bind)(so, nam, p);
+ }
out:
- if (dolock)
+ if (dolock) {
socket_unlock(so, 1);
+ }
- if (error == EJUSTRETURN)
+ if (error == EJUSTRETURN) {
error = 0;
+ }
- return (error);
+ return error;
}
void
if (so->so_flags1 & SOF1_CACHED_IN_SOCK_LAYER) {
cached_sock_free(so);
} else {
- FREE_ZONE(so, sizeof (*so), so->so_zone);
+ FREE_ZONE(so, sizeof(*so), so->so_zone);
}
}
* reject the request now.
*/
if ((so->so_state &
- (SS_ISCONNECTED|SS_ISCONNECTING|SS_ISDISCONNECTING)) ||
+ (SS_ISCONNECTED | SS_ISCONNECTING | SS_ISDISCONNECTING)) ||
(so->so_flags & SOF_DEFUNCT)) {
error = EINVAL;
if (so->so_flags & SOF_DEFUNCT) {
}
error = sflt_listen(so);
- if (error == 0)
+ if (error == 0) {
error = (*so->so_proto->pr_usrreqs->pru_listen)(so, p);
+ }
if (error) {
- if (error == EJUSTRETURN)
+ if (error == EJUSTRETURN) {
error = 0;
+ }
goto out;
}
- if (TAILQ_EMPTY(&so->so_comp))
+ if (TAILQ_EMPTY(&so->so_comp)) {
so->so_options |= SO_ACCEPTCONN;
+ }
/*
* POSIX: The implementation may have an upper limit on the length of
* the listen queue-either global or per accepting socket. If backlog
* in which case the length of the listen queue may be set to an
* implementation-defined minimum value.
*/
- if (backlog <= 0 || backlog > somaxconn)
+ if (backlog <= 0 || backlog > somaxconn) {
backlog = somaxconn;
+ }
so->so_qlimit = backlog;
out:
socket_unlock(so, 1);
- return (error);
+ return error;
}
/*
if (!(so->so_flags & SOF_PCBCLEARING) || !(so->so_state & SS_NOFDREF)) {
selthreadclear(&so->so_snd.sb_sel);
selthreadclear(&so->so_rcv.sb_sel);
- so->so_rcv.sb_flags &= ~(SB_SEL|SB_UPCALL);
- so->so_snd.sb_flags &= ~(SB_SEL|SB_UPCALL);
+ so->so_rcv.sb_flags &= ~(SB_SEL | SB_UPCALL);
+ so->so_snd.sb_flags &= ~(SB_SEL | SB_UPCALL);
so->so_event = sonullevent;
return;
}
*/
selthreadclear(&so->so_snd.sb_sel);
selthreadclear(&so->so_rcv.sb_sel);
- so->so_rcv.sb_flags &= ~(SB_SEL|SB_UPCALL);
- so->so_snd.sb_flags &= ~(SB_SEL|SB_UPCALL);
+ so->so_rcv.sb_flags &= ~(SB_SEL | SB_UPCALL);
+ so->so_snd.sb_flags &= ~(SB_SEL | SB_UPCALL);
so->so_event = sonullevent;
return;
} else {
if (head->so_proto->pr_getlock != NULL) {
so_release_accept_list(head);
- socket_unlock(head, 1);
- }
+ socket_unlock(head, 1);
+ }
printf("sofree: not queued\n");
}
}
if (so->so_flags & SOF_FLOW_DIVERT) {
flow_divert_detach(so);
}
-#endif /* FLOW_DIVERT */
+#endif /* FLOW_DIVERT */
/* 3932268: disable upcall */
so->so_rcv.sb_flags &= ~SB_UPCALL;
- so->so_snd.sb_flags &= ~(SB_UPCALL|SB_SNDBYTE_CNT);
+ so->so_snd.sb_flags &= ~(SB_UPCALL | SB_SNDBYTE_CNT);
so->so_event = sonullevent;
- if (dealloc)
+ if (dealloc) {
sodealloc(so);
+ }
}
void
{
lck_mtx_t *mutex_held;
- if (so->so_proto->pr_getlock != NULL)
+ if (so->so_proto->pr_getlock != NULL) {
mutex_held = (*so->so_proto->pr_getlock)(so, PR_F_WILLUNLOCK);
- else
+ } else {
mutex_held = so->so_proto->pr_domain->dom_mtx;
+ }
LCK_MTX_ASSERT(mutex_held, LCK_MTX_ASSERT_OWNED);
/*
* Double check here and return if there's no outstanding upcall;
* otherwise proceed further only if SOF_UPCALLCLOSEWAIT is set.
*/
- if (!so->so_upcallusecount || !(so->so_flags & SOF_UPCALLCLOSEWAIT))
+ if (!so->so_upcallusecount || !(so->so_flags & SOF_UPCALLCLOSEWAIT)) {
return;
+ }
so->so_rcv.sb_flags &= ~SB_UPCALL;
so->so_snd.sb_flags &= ~SB_UPCALL;
so->so_flags |= SOF_CLOSEWAIT;
sflt_notify(so, sock_evt_closing, NULL);
- if (so->so_upcallusecount)
+ if (so->so_upcallusecount) {
soclose_wait_locked(so);
+ }
#if CONTENT_FILTER
/*
* otherwise, remove the incomp socket from the queue
* and let soabort trigger the appropriate cleanup.
*/
- if (sp->so_flags & SOF_OVERFLOW)
+ if (sp->so_flags & SOF_OVERFLOW) {
continue;
+ }
- if (persocklock != 0)
+ if (persocklock != 0) {
socket_lock(sp, 1);
+ }
/*
* Radar 27945981
__func__, sp);
}
- if (persocklock != 0)
+ if (persocklock != 0) {
socket_unlock(sp, 1);
+ }
}
TAILQ_FOREACH_SAFE(sp, &so->so_comp, so_list, sonext) {
/* Dequeue from so_comp since sofree() won't do it */
- if (persocklock != 0)
+ if (persocklock != 0) {
socket_lock(sp, 1);
+ }
if (sp->so_state & SS_COMP) {
sp->so_state &= ~SS_COMP;
__func__, sp);
}
- if (persocklock)
+ if (persocklock) {
socket_unlock(sp, 1);
}
+ }
if (incomp_overflow_only == 0 && !TAILQ_EMPTY(&so->so_incomp)) {
-#if (DEBUG|DEVELOPMENT)
+#if (DEBUG | DEVELOPMENT)
panic("%s head %p so_comp not empty\n", __func__, so);
#endif /* (DEVELOPMENT || DEBUG) */
}
if (!TAILQ_EMPTY(&so->so_comp)) {
-#if (DEBUG|DEVELOPMENT)
+#if (DEBUG | DEVELOPMENT)
panic("%s head %p so_comp not empty\n", __func__, so);
#endif /* (DEVELOPMENT || DEBUG) */
if (so->so_state & SS_ISCONNECTED) {
if ((so->so_state & SS_ISDISCONNECTING) == 0) {
error = sodisconnectlocked(so);
- if (error)
+ if (error) {
goto drop;
+ }
}
if (so->so_options & SO_LINGER) {
lck_mtx_t *mutex_held;
if ((so->so_state & SS_ISDISCONNECTING) &&
- (so->so_state & SS_NBIO))
+ (so->so_state & SS_NBIO)) {
goto drop;
- if (so->so_proto->pr_getlock != NULL)
+ }
+ if (so->so_proto->pr_getlock != NULL) {
mutex_held = (*so->so_proto->pr_getlock)(so, PR_F_WILLUNLOCK);
- else
+ } else {
mutex_held = so->so_proto->pr_domain->dom_mtx;
+ }
while (so->so_state & SS_ISCONNECTED) {
- ts.tv_sec = (so->so_linger/100);
+ ts.tv_sec = (so->so_linger / 100);
ts.tv_nsec = (so->so_linger % 100) *
NSEC_PER_USEC * 1000 * 10;
error = msleep((caddr_t)&so->so_timeo,
* It's OK when the time fires,
* don't report an error
*/
- if (error == EWOULDBLOCK)
+ if (error == EWOULDBLOCK) {
error = 0;
+ }
break;
}
}
}
if (so->so_pcb != NULL && !(so->so_flags & SOF_PCBCLEARING)) {
int error2 = (*so->so_proto->pr_usrreqs->pru_detach)(so);
- if (error == 0)
+ if (error == 0) {
error = error2;
+ }
}
if (so->so_usecount <= 0) {
panic("soclose: usecount is zero so=%p\n", so);
}
so->so_state |= SS_NOFDREF;
- if ((so->so_flags & SOF_KNOTE) != 0)
+ if ((so->so_flags & SOF_KNOTE) != 0) {
KNOTE(&so->so_klist, SO_FILT_HINT_LOCKED);
+ }
atomic_add_32(&so->so_proto->pr_domain->dom_refs, -1);
evsofree(so);
VERIFY(so->so_usecount > 0);
so->so_usecount--;
sofree(so);
- return (error);
+ return error;
}
int
* retained in kernel remove its reference
*/
so->so_usecount--;
- if (so->so_usecount < 2)
+ if (so->so_usecount < 2) {
panic("soclose: retaincnt non null and so=%p "
"usecount=%d\n", so, so->so_usecount);
+ }
}
socket_unlock(so, 1);
- return (error);
+ return error;
}
/*
#ifdef MORE_LOCKING_DEBUG
lck_mtx_t *mutex_held;
- if (so->so_proto->pr_getlock != NULL)
+ if (so->so_proto->pr_getlock != NULL) {
mutex_held = (*so->so_proto->pr_getlock)(so, 0);
- else
+ } else {
mutex_held = so->so_proto->pr_domain->dom_mtx;
+ }
LCK_MTX_ASSERT(mutex_held, LCK_MTX_ASSERT_OWNED);
#endif
error = (*so->so_proto->pr_usrreqs->pru_abort)(so);
if (error) {
sofree(so);
- return (error);
+ return error;
}
}
- return (0);
+ return 0;
}
int
{
int error;
- if (dolock)
+ if (dolock) {
socket_lock(so, 1);
+ }
so_update_last_owner_locked(so, PROC_NULL);
so_update_policy(so);
so_update_necp_policy(so, NULL, NULL);
#endif /* NECP */
- if ((so->so_state & SS_NOFDREF) == 0)
+ if ((so->so_state & SS_NOFDREF) == 0) {
panic("soaccept: !NOFDREF");
+ }
so->so_state &= ~SS_NOFDREF;
error = (*so->so_proto->pr_usrreqs->pru_accept)(so, nam);
- if (dolock)
+ if (dolock) {
socket_unlock(so, 1);
- return (error);
+ }
+ return error;
}
int
soaccept(struct socket *so, struct sockaddr **nam)
{
- return (soacceptlock(so, nam, 1));
+ return soacceptlock(so, nam, 1);
}
int
/* Callee checks for NULL pointer */
sock_freeaddr(remote);
sock_freeaddr(local);
- return (error);
+ return error;
}
/*
int error;
struct proc *p = current_proc();
- if (dolock)
+ if (dolock) {
socket_lock(so, 1);
+ }
so_update_last_owner_locked(so, p);
so_update_policy(so);
(uint64_t)DEBUG_KERNEL_ADDRPERM(so),
SOCK_DOM(so), SOCK_TYPE(so), error);
}
- if (dolock)
+ if (dolock) {
socket_unlock(so, 1);
- return (error);
+ }
+ return error;
}
if ((so->so_restrictions & SO_RESTRICT_DENY_OUT) != 0) {
- if (dolock)
+ if (dolock) {
socket_unlock(so, 1);
- return (EPERM);
+ }
+ return EPERM;
}
/*
* This allows user to disconnect by connecting to, e.g.,
* a null address.
*/
- if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
+ if (so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING) &&
((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
(error = sodisconnectlocked(so)))) {
error = EISCONN;
*/
error = sflt_connectout(so, nam);
if (error != 0) {
- if (error == EJUSTRETURN)
+ if (error == EJUSTRETURN) {
error = 0;
+ }
} else {
error = (*so->so_proto->pr_usrreqs->pru_connect)
(so, nam, p);
}
}
- if (dolock)
+ if (dolock) {
socket_unlock(so, 1);
- return (error);
+ }
+ return error;
}
int
soconnect(struct socket *so, struct sockaddr *nam)
{
- return (soconnectlock(so, nam, 1));
+ return soconnectlock(so, nam, 1);
}
/*
int error;
socket_lock(so1, 1);
- if (so2->so_proto->pr_lock)
+ if (so2->so_proto->pr_lock) {
socket_lock(so2, 1);
+ }
error = (*so1->so_proto->pr_usrreqs->pru_connect2)(so1, so2);
socket_unlock(so1, 1);
- if (so2->so_proto->pr_lock)
+ if (so2->so_proto->pr_lock) {
socket_unlock(so2, 1);
- return (error);
+ }
+ return error;
}
int
(uint64_t)DEBUG_KERNEL_ADDRPERM(so),
SOCK_DOM(so), SOCK_TYPE(so), error);
}
- return (error);
+ return error;
}
- if ((so->so_restrictions & SO_RESTRICT_DENY_OUT) != 0)
- return (EPERM);
+ if ((so->so_restrictions & SO_RESTRICT_DENY_OUT) != 0) {
+ return EPERM;
+ }
/*
* If protocol is connection-based, can only connect once
* try to disconnect first. This allows user to disconnect
* by connecting to, e.g., a null address.
*/
- if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) &&
+ if ((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING)) &&
!(so->so_proto->pr_flags & PR_MULTICONN) &&
((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
(error = sodisconnectlocked(so)) != 0)) {
if (error != 0) {
/* Disable PRECONNECT_DATA, as we don't need to send a SYN anymore. */
so->so_flags1 &= ~SOF1_PRECONNECT_DATA;
- if (error == EJUSTRETURN)
+ if (error == EJUSTRETURN) {
error = 0;
+ }
} else {
error = (*so->so_proto->pr_usrreqs->pru_connectx)
(so, src, dst, p, ifscope, aid, pcid,
}
}
- return (error);
+ return error;
}
int
}
error = (*so->so_proto->pr_usrreqs->pru_disconnect)(so);
- if (error == 0)
+ if (error == 0) {
sflt_notify(so, sock_evt_disconnected, NULL);
+ }
bad:
- return (error);
+ return error;
}
/* Locking version */
socket_lock(so, 1);
error = sodisconnectlocked(so);
socket_unlock(so, 1);
- return (error);
+ return error;
}
int
* The event applies only for the session, not for
* the disconnection of individual subflows.
*/
- if (so->so_state & (SS_ISDISCONNECTING|SS_ISDISCONNECTED))
+ if (so->so_state & (SS_ISDISCONNECTING | SS_ISDISCONNECTED)) {
sflt_notify(so, sock_evt_disconnected, NULL);
+ }
}
- return (error);
+ return error;
}
int
socket_lock(so, 1);
error = sodisconnectxlocked(so, aid, cid);
socket_unlock(so, 1);
- return (error);
+ return error;
}
-#define SBLOCKWAIT(f) (((f) & MSG_DONTWAIT) ? 0 : SBL_WAIT)
+#define SBLOCKWAIT(f) (((f) & MSG_DONTWAIT) ? 0 : SBL_WAIT)
/*
* sosendcheck will lock the socket buffer if it isn't locked and
int32_t clen, int32_t atomic, int flags, int *sblocked,
struct mbuf *control)
{
- int error = 0;
+ int error = 0;
int32_t space;
- int assumelock = 0;
+ int assumelock = 0;
restart:
if (*sblocked == 0) {
} else {
error = sblock(&so->so_snd, SBLOCKWAIT(flags));
if (error) {
- if (so->so_flags & SOF_DEFUNCT)
+ if (so->so_flags & SOF_DEFUNCT) {
goto defunct;
- return (error);
+ }
+ return error;
}
*sblocked = 1;
}
__func__, proc_selfpid(), proc_best_name(current_proc()),
(uint64_t)DEBUG_KERNEL_ADDRPERM(so),
SOCK_DOM(so), SOCK_TYPE(so), error);
- return (error);
+ return error;
}
if (so->so_state & SS_CANTSENDMORE) {
* Can re-inject data of half closed connections
*/
if ((so->so_state & SS_ISDISCONNECTED) == 0 &&
- so->so_snd.sb_cfil_thread == current_thread() &&
- cfil_sock_data_pending(&so->so_snd) != 0)
+ so->so_snd.sb_cfil_thread == current_thread() &&
+ cfil_sock_data_pending(&so->so_snd) != 0) {
CFIL_LOG(LOG_INFO,
- "so %llx ignore SS_CANTSENDMORE",
- (uint64_t)DEBUG_KERNEL_ADDRPERM(so));
- else
+ "so %llx ignore SS_CANTSENDMORE",
+ (uint64_t)DEBUG_KERNEL_ADDRPERM(so));
+ } else
#endif /* CONTENT_FILTER */
- return (EPIPE);
+ return EPIPE;
}
if (so->so_error) {
error = so->so_error;
so->so_error = 0;
- return (error);
+ return error;
}
if ((so->so_state & SS_ISCONNECTED) == 0) {
if ((so->so_proto->pr_flags & PR_CONNREQUIRED) != 0) {
if (((so->so_state & SS_ISCONFIRMING) == 0) &&
(resid != 0 || clen == 0) &&
- !(so->so_flags1 & SOF1_PRECONNECT_DATA))
- return (ENOTCONN);
-
- } else if (addr == 0 && !(flags&MSG_HOLD)) {
- return ((so->so_proto->pr_flags & PR_CONNREQUIRED) ?
- ENOTCONN : EDESTADDRREQ);
+ !(so->so_flags1 & SOF1_PRECONNECT_DATA)) {
+ return ENOTCONN;
+ }
+ } else if (addr == 0 && !(flags & MSG_HOLD)) {
+ return (so->so_proto->pr_flags & PR_CONNREQUIRED) ?
+ ENOTCONN : EDESTADDRREQ;
}
}
- if (so->so_flags & SOF_ENABLE_MSGS)
+ if (so->so_flags & SOF_ENABLE_MSGS) {
space = msgq_sbspace(so, control);
- else
+ } else {
space = sbspace(&so->so_snd);
+ }
- if (flags & MSG_OOB)
+ if (flags & MSG_OOB) {
space += 1024;
+ }
if ((atomic && resid > so->so_snd.sb_hiwat) ||
- clen > so->so_snd.sb_hiwat)
- return (EMSGSIZE);
+ clen > so->so_snd.sb_hiwat) {
+ return EMSGSIZE;
+ }
if ((space < resid + clen &&
(atomic || (space < (int32_t)so->so_snd.sb_lowat) ||
*/
if (so->so_flags1 & SOF1_PRECONNECT_DATA) {
if (space == 0) {
- return (EWOULDBLOCK);
+ return EWOULDBLOCK;
}
if (space < (int32_t)so->so_snd.sb_lowat) {
- return (0);
+ return 0;
}
}
if ((so->so_state & SS_NBIO) || (flags & MSG_NBIO) ||
assumelock) {
- return (EWOULDBLOCK);
+ return EWOULDBLOCK;
}
- sbunlock(&so->so_snd, TRUE); /* keep socket locked */
+ sbunlock(&so->so_snd, TRUE); /* keep socket locked */
*sblocked = 0;
error = sbwait(&so->so_snd);
if (error) {
- if (so->so_flags & SOF_DEFUNCT)
+ if (so->so_flags & SOF_DEFUNCT) {
goto defunct;
- return (error);
+ }
+ return error;
}
goto restart;
}
- return (0);
+ return 0;
}
/*
uint16_t headroom = 0;
boolean_t en_tracing = FALSE;
- if (uio != NULL)
+ if (uio != NULL) {
resid = uio_resid(uio);
- else
+ } else {
resid = top->m_pkthdr.len;
+ }
KERNEL_DEBUG((DBG_FNC_SOSEND | DBG_FUNC_START), so, resid,
so->so_snd.sb_cc, so->so_snd.sb_lowat, so->so_snd.sb_hiwat);
(so->so_proto->pr_flags & PR_ATOMIC);
OSIncrementAtomicLong(&p->p_stats->p_ru.ru_msgsnd);
- if (control != NULL)
+ if (control != NULL) {
clen = control->m_len;
+ }
- if (soreserveheadroom != 0)
+ if (soreserveheadroom != 0) {
headroom = so->so_pktheadroom;
+ }
do {
error = sosendcheck(so, addr, resid, clen, atomic, flags,
&sblocked, control);
- if (error)
+ if (error) {
goto out_locked;
+ }
mp = ⊤
- if (so->so_flags & SOF_ENABLE_MSGS)
+ if (so->so_flags & SOF_ENABLE_MSGS) {
space = msgq_sbspace(so, control);
- else
+ } else {
space = sbspace(&so->so_snd) - clen;
+ }
space += ((flags & MSG_OOB) ? 1024 : 0);
do {
* Data is prepackaged in "top".
*/
resid = 0;
- if (flags & MSG_EOR)
+ if (flags & MSG_EOR) {
top->m_flags |= M_EOR;
+ }
} else {
int chainlength;
int bytes_to_copy;
bytes_to_copy = imin(resid, space);
bytes_to_alloc = bytes_to_copy;
- if (top == NULL)
+ if (top == NULL) {
bytes_to_alloc += headroom;
+ }
- if (sosendminchain > 0)
+ if (sosendminchain > 0) {
chainlength = 0;
- else
+ } else {
chainlength = sosendmaxchain;
+ }
/*
* Use big 4 KB cluster when the outgoing interface
if ((bytes_to_alloc -
(num_needed * M16KCLBYTES))
- >= MINCLSIZE)
+ >= MINCLSIZE) {
num_needed++;
+ }
freelist =
m_getpackets_internal(
- (unsigned int *)&num_needed,
- hdrs_needed, M_WAIT, 0,
- M16KCLBYTES);
+ (unsigned int *)&num_needed,
+ hdrs_needed, M_WAIT, 0,
+ M16KCLBYTES);
/*
* Fall back to 4K cluster size
* if allocation failed
if ((bytes_to_alloc -
(num_needed * MBIGCLBYTES)) >=
- MINCLSIZE)
+ MINCLSIZE) {
num_needed++;
+ }
freelist =
m_getpackets_internal(
- (unsigned int *)&num_needed,
- hdrs_needed, M_WAIT, 0,
- MBIGCLBYTES);
+ (unsigned int *)&num_needed,
+ hdrs_needed, M_WAIT, 0,
+ MBIGCLBYTES);
/*
* Fall back to cluster size
* if allocation failed
MCLBYTES;
freelist =
m_getpackets_internal(
- (unsigned int *)&num_needed,
- hdrs_needed, M_WAIT, 0,
- MCLBYTES);
+ (unsigned int *)&num_needed,
+ hdrs_needed, M_WAIT, 0,
+ MCLBYTES);
/*
* Fall back to a single mbuf
* if allocation failed
if ((bytes_to_alloc -
(num_needed * MCLBYTES)) >=
- MINCLSIZE)
+ MINCLSIZE) {
num_needed++;
+ }
freelist =
m_getpackets_internal(
- (unsigned int *)&num_needed,
- hdrs_needed, M_WAIT, 0,
- MCLBYTES);
+ (unsigned int *)&num_needed,
+ hdrs_needed, M_WAIT, 0,
+ MCLBYTES);
/*
* Fall back to a single mbuf
* if allocation failed
* reserving the socket headroom
*/
if (freelist == NULL) {
- if (top == NULL)
+ if (top == NULL) {
MGETHDR(freelist,
M_WAIT, MT_DATA);
- else
+ } else {
MGET(freelist,
M_WAIT, MT_DATA);
+ }
if (freelist == NULL) {
error = ENOBUFS;
freelist = m->m_next;
m->m_next = NULL;
- if ((m->m_flags & M_EXT))
+ if ((m->m_flags & M_EXT)) {
mlen = m->m_ext.ext_size -
M_LEADINGSPACE(m);
- else if ((m->m_flags & M_PKTHDR))
+ } else if ((m->m_flags & M_PKTHDR)) {
mlen =
MHLEN - M_LEADINGSPACE(m);
- else
+ } else {
mlen = MLEN - M_LEADINGSPACE(m);
+ }
len = imin(mlen, bytes_to_copy);
chainlength += len;
m->m_len = len;
*mp = m;
top->m_pkthdr.len += len;
- if (error)
+ if (error) {
break;
+ }
mp = &m->m_next;
if (resid <= 0) {
- if (flags & MSG_EOR)
+ if (flags & MSG_EOR) {
top->m_flags |= M_EOR;
+ }
break;
}
bytes_to_copy = min(resid, space);
-
} while (space > 0 &&
(chainlength < sosendmaxchain || atomic ||
resid < MINCLSIZE));
socket_lock(so, 0);
- if (error)
+ if (error) {
goto out_locked;
+ }
}
- if (flags & (MSG_HOLD|MSG_SEND)) {
+ if (flags & (MSG_HOLD | MSG_SEND)) {
/* Enqueue for later, go away if HOLD */
struct mbuf *mb1;
if (so->so_temp && (flags & MSG_FLUSH)) {
m_freem(so->so_temp);
so->so_temp = NULL;
}
- if (so->so_temp)
+ if (so->so_temp) {
so->so_tail->m_next = top;
- else
+ } else {
so->so_temp = top;
+ }
mb1 = top;
- while (mb1->m_next)
+ while (mb1->m_next) {
mb1 = mb1->m_next;
+ }
so->so_tail = mb1;
if (flags & MSG_HOLD) {
top = NULL;
}
top = so->so_temp;
}
- if (dontroute)
+ if (dontroute) {
so->so_options |= SO_DONTROUTE;
+ }
/*
* Compute flags here, for pru_send and NKEs
clen = 0;
control = NULL;
top = NULL;
- }
+ }
goto out_locked;
}
#endif /* CONTENT_FILTER */
error = (*so->so_proto->pr_usrreqs->pru_send)
(so, sendflags, top, addr, control, p);
- if (flags & MSG_SEND)
+ if (flags & MSG_SEND) {
so->so_temp = NULL;
+ }
- if (dontroute)
+ if (dontroute) {
so->so_options &= ~SO_DONTROUTE;
+ }
clen = 0;
control = control_copy;
control_copy = NULL;
top = NULL;
mp = ⊤
- if (error)
+ if (error) {
goto out_locked;
+ }
} while (resid && space > 0);
} while (resid);
out_locked:
- if (sblocked)
- sbunlock(&so->so_snd, FALSE); /* will unlock socket */
- else
+ if (sblocked) {
+ sbunlock(&so->so_snd, FALSE); /* will unlock socket */
+ } else {
socket_unlock(so, 1);
- if (top != NULL)
+ }
+ if (top != NULL) {
m_freem(top);
- if (control != NULL)
+ }
+ if (control != NULL) {
m_freem(control);
- if (freelist != NULL)
+ }
+ if (freelist != NULL) {
m_freem_list(freelist);
- if (control_copy != NULL)
+ }
+ if (control_copy != NULL) {
m_freem(control_copy);
+ }
soclearfastopen(so);
KERNEL_DEBUG(DBG_FNC_SOSEND | DBG_FUNC_END, so, resid,
so->so_snd.sb_cc, space, error);
- return (error);
+ return error;
}
int
* If control is not NULL, top must be packet header
*/
VERIFY(top != NULL &&
- (control == NULL || top->m_flags & M_PKTHDR));
+ (control == NULL || top->m_flags & M_PKTHDR));
/*
* If control is not passed in, see if we can get it
}
}
}
- if (control_end != NULL)
+ if (control_end != NULL) {
control_end->m_next = NULL;
+ }
}
int error = (*so->so_proto->pr_usrreqs->pru_send)
- (so, sendflags, top, addr, control, current_proc());
+ (so, sendflags, top, addr, control, current_proc());
return error;
}
error = sosendcheck(so, NULL, resid, 0, atomic, flags,
&sblocked, NULL);
- if (error)
+ if (error) {
goto release;
+ }
/*
* Use big 4 KB clusters when the outgoing interface does not prefer
*/
bigcl = !(so->so_flags1 & SOF1_IF_2KCL) || sosendbigcl_ignore_capab;
- if (soreserveheadroom != 0)
+ if (soreserveheadroom != 0) {
headroom = so->so_pktheadroom;
+ }
do {
int i;
size_t maxpktlen = 0;
int bytes_to_alloc;
- if (sosendminchain > 0)
+ if (sosendminchain > 0) {
chainlength = 0;
- else
+ } else {
chainlength = sosendmaxchain;
+ }
socket_unlock(so, 0);
len = uio_resid(auio);
/* Do nothing for empty messages */
- if (len == 0)
+ if (len == 0) {
continue;
+ }
num_needed += 1;
uiolast += 1;
- if (len > maxpktlen)
+ if (len > maxpktlen) {
maxpktlen = len;
+ }
chainlength += len;
- if (chainlength > sosendmaxchain)
+ if (chainlength > sosendmaxchain) {
break;
+ }
}
/*
* Nothing left to send
if (bytes_to_alloc > MCLBYTES &&
bytes_to_alloc <= MBIGCLBYTES && bigcl) {
freelist = m_getpackets_internal(
- (unsigned int *)&num_needed,
- num_needed, M_WAIT, 1,
- MBIGCLBYTES);
+ (unsigned int *)&num_needed,
+ num_needed, M_WAIT, 1,
+ MBIGCLBYTES);
} else if (bytes_to_alloc > _MHLEN &&
bytes_to_alloc <= MCLBYTES) {
freelist = m_getpackets_internal(
- (unsigned int *)&num_needed,
- num_needed, M_WAIT, 1,
- MCLBYTES);
+ (unsigned int *)&num_needed,
+ num_needed, M_WAIT, 1,
+ MCLBYTES);
} else {
freelist = m_allocpacket_internal(
- (unsigned int *)&num_needed,
- bytes_to_alloc, NULL, M_WAIT, 1, 0);
+ (unsigned int *)&num_needed,
+ bytes_to_alloc, NULL, M_WAIT, 1, 0);
}
if (freelist == NULL) {
bytes_to_copy = uio_resid(auio);
/* Do nothing for empty messages */
- if (bytes_to_copy == 0)
+ if (bytes_to_copy == 0) {
continue;
+ }
/*
* Leave headroom for protocol headers
* in the first mbuf of the chain
m->m_data += headroom;
for (n = m; n != NULL; n = n->m_next) {
- if ((m->m_flags & M_EXT))
+ if ((m->m_flags & M_EXT)) {
mlen = m->m_ext.ext_size -
M_LEADINGSPACE(m);
- else if ((m->m_flags & M_PKTHDR))
+ } else if ((m->m_flags & M_PKTHDR)) {
mlen =
MHLEN - M_LEADINGSPACE(m);
- else
+ } else {
mlen = MLEN - M_LEADINGSPACE(m);
+ }
len = imin(mlen, bytes_to_copy);
/*
*/
error = uiomove(mtod(n, caddr_t),
len, auio);
- if (error != 0)
+ if (error != 0) {
break;
+ }
n->m_len = len;
m->m_pkthdr.len += len;
}
if (m->m_pkthdr.len == 0) {
printf(
- "%s:%d so %llx pkt %llx type %u len null\n",
- __func__, __LINE__,
- (uint64_t)DEBUG_KERNEL_ADDRPERM(so),
- (uint64_t)DEBUG_KERNEL_ADDRPERM(m),
- m->m_type);
+ "%s:%d so %llx pkt %llx type %u len null\n",
+ __func__, __LINE__,
+ (uint64_t)DEBUG_KERNEL_ADDRPERM(so),
+ (uint64_t)DEBUG_KERNEL_ADDRPERM(m),
+ m->m_type);
}
- if (error != 0)
+ if (error != 0) {
break;
+ }
m = m->m_nextpkt;
}
socket_lock(so, 0);
- if (error)
+ if (error) {
goto release;
+ }
top = freelist;
freelist = NULL;
- if (dontroute)
+ if (dontroute) {
so->so_options |= SO_DONTROUTE;
+ }
if ((flags & MSG_SKIPCFIL) == 0) {
struct mbuf **prevnextp = NULL;
*/
error = sflt_data_out(so, NULL, &m,
NULL, 0);
- if (error != 0 && error != EJUSTRETURN)
+ if (error != 0 && error != EJUSTRETURN) {
goto release;
+ }
#if CONTENT_FILTER
if (error == 0) {
*/
error = cfil_sock_data_out(so, NULL, m,
NULL, 0);
- if (error != 0 && error != EJUSTRETURN)
+ if (error != 0 && error != EJUSTRETURN) {
goto release;
+ }
}
#endif /* CONTENT_FILTER */
/*
*/
if (error == EJUSTRETURN) {
error = 0;
- if (prevnextp != NULL)
+ if (prevnextp != NULL) {
*prevnextp = nextpkt;
- else
+ } else {
top = nextpkt;
+ }
}
m = nextpkt;
- if (m != NULL)
+ if (m != NULL) {
prevnextp = &m->m_nextpkt;
+ }
}
}
- if (top != NULL)
+ if (top != NULL) {
error = (*so->so_proto->pr_usrreqs->pru_send_list)
(so, 0, top, NULL, NULL, p);
+ }
- if (dontroute)
+ if (dontroute) {
so->so_options &= ~SO_DONTROUTE;
+ }
top = NULL;
uiofirst = uiolast;
} while (resid > 0 && error == 0);
release:
- if (sblocked)
- sbunlock(&so->so_snd, FALSE); /* will unlock socket */
- else
+ if (sblocked) {
+ sbunlock(&so->so_snd, FALSE); /* will unlock socket */
+ } else {
socket_unlock(so, 1);
+ }
out:
- if (top != NULL)
+ if (top != NULL) {
m_freem(top);
- if (freelist != NULL)
+ }
+ if (freelist != NULL) {
m_freem_list(freelist);
+ }
KERNEL_DEBUG(DBG_FNC_SOSEND_LIST | DBG_FUNC_END, so, resid,
so->so_snd.sb_cc, 0, error);
- return (error);
+ return error;
}
/*
* the record in front of any packets which may have
* been appended while we dropped the lock.
*/
- for (m = m0; m->m_next != NULL; m = m->m_next)
+ for (m = m0; m->m_next != NULL; m = m->m_next) {
sballoc(&so->so_rcv, m);
+ }
sballoc(&so->so_rcv, m);
if (so->so_rcv.sb_mb == NULL) {
so->so_rcv.sb_lastrecord = m0;
*mp = m;
*nextrecordp = nextrecord;
- return (error);
+ return error;
}
/*
sb_rcv->sb_mb = nextrecord;
SB_EMPTY_FIXUP(sb_rcv);
}
- if (nextrecord == NULL)
+ if (nextrecord == NULL) {
sb_rcv->sb_lastrecord = m;
+ }
}
SBLASTRECORDCHK(&so->so_rcv, "soreceive ctl");
* records when the socket was unlocked above for
* externalizing SCM_RIGHTS.
*/
- if (m != NULL)
+ if (m != NULL) {
nextrecord = sb_rcv->sb_mb->m_nextpkt;
- else
+ } else {
nextrecord = sb_rcv->sb_mb;
+ }
done:
*mp = m;
*nextrecordp = nextrecord;
- return (error);
+ return error;
}
/*
* Sanity check on the length passed by caller as we are making 'int'
* comparisons
*/
- if (orig_resid < 0 || orig_resid > INT_MAX)
- return (EINVAL);
+ if (orig_resid < 0 || orig_resid > INT_MAX) {
+ return EINVAL;
+ }
KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_START, so,
uio_resid(uio), so->so_rcv.sb_cc, so->so_rcv.sb_lowat,
}
#endif
mp = mp0;
- if (psa != NULL)
+ if (psa != NULL) {
*psa = NULL;
- if (controlp != NULL)
+ }
+ if (controlp != NULL) {
*controlp = NULL;
- if (flagsp != NULL)
- flags = *flagsp &~ MSG_EOR;
- else
+ }
+ if (flagsp != NULL) {
+ flags = *flagsp & ~MSG_EOR;
+ } else {
flags = 0;
+ }
/*
* If a recv attempt is made on a previously-accepted socket
* prior to being returned from sodefunct(); there should
* be no data on its receive list, so panic otherwise.
*/
- if (so->so_state & SS_DEFUNCT)
+ if (so->so_state & SS_DEFUNCT) {
sb_empty_assert(sb, __func__);
+ }
socket_unlock(so, 1);
- return (error);
+ return error;
}
if ((so->so_flags1 & SOF1_PRECONNECT_DATA) &&
if (error) {
socket_unlock(so, 1);
- return (error);
+ return error;
}
}
socket_unlock(so, 1);
KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_END,
ENOBUFS, 0, 0, 0, 0);
- return (ENOBUFS);
+ return ENOBUFS;
}
error = (*pr->pr_usrreqs->pru_rcvoob)(so, m, flags & MSG_PEEK);
- if (error)
+ if (error) {
goto bad;
+ }
socket_unlock(so, 0);
do {
error = uiomove(mtod(m, caddr_t),
} while (uio_resid(uio) && error == 0 && m != NULL);
socket_lock(so, 0);
bad:
- if (m != NULL)
+ if (m != NULL) {
m_freem(m);
+ }
if ((so->so_options & SO_WANTOOBFLAG) != 0) {
if (error == EWOULDBLOCK || error == EINVAL) {
KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_END, error,
0, 0, 0, 0);
- return (error);
+ return error;
}
nooob:
- if (mp != NULL)
+ if (mp != NULL) {
*mp = NULL;
+ }
if (so->so_state & SS_ISCONFIRMING && uio_resid(uio)) {
(*pr->pr_usrreqs->pru_rcvd)(so, 0);
delayed_copy_len = 0;
restart:
#ifdef MORE_LOCKING_DEBUG
- if (so->so_usecount <= 1)
+ if (so->so_usecount <= 1) {
printf("soreceive: sblock so=0x%llx ref=%d on socket\n",
(uint64_t)DEBUG_KERNEL_ADDRPERM(so), so->so_usecount);
+ }
#endif
/*
* See if the socket has been closed (SS_NOFDREF|SS_CANTRCVMORE)
if ((so->so_state & (SS_NOFDREF | SS_CANTRCVMORE)) ==
(SS_NOFDREF | SS_CANTRCVMORE) && !(so->so_flags & SOF_MP_SUBFLOW)) {
socket_unlock(so, 1);
- return (0);
+ return 0;
}
error = sblock(&so->so_rcv, SBLOCKWAIT(flags));
VM_KERNEL_ADDRPERM(so), 0,
(int64_t)(orig_resid - uio_resid(uio)));
}
- return (error);
+ return error;
}
m = so->so_rcv.sb_mb;
SB_MB_CHECK(&so->so_rcv);
if (so->so_error) {
- if (m != NULL)
+ if (m != NULL) {
goto dontblock;
+ }
error = so->so_error;
- if ((flags & MSG_PEEK) == 0)
+ if ((flags & MSG_PEEK) == 0) {
so->so_error = 0;
+ }
goto release;
}
if (so->so_state & SS_CANTRCVMORE) {
* Deal with half closed connections
*/
if ((so->so_state & SS_ISDISCONNECTED) == 0 &&
- cfil_sock_data_pending(&so->so_rcv) != 0)
+ cfil_sock_data_pending(&so->so_rcv) != 0) {
CFIL_LOG(LOG_INFO,
- "so %llx ignore SS_CANTRCVMORE",
- (uint64_t)DEBUG_KERNEL_ADDRPERM(so));
- else
+ "so %llx ignore SS_CANTRCVMORE",
+ (uint64_t)DEBUG_KERNEL_ADDRPERM(so));
+ } else
#endif /* CONTENT_FILTER */
- if (m != NULL)
+ if (m != NULL) {
goto dontblock;
- else
+ } else {
goto release;
+ }
}
- for (; m != NULL; m = m->m_next)
+ for (; m != NULL; m = m->m_next) {
if (m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)) {
m = so->so_rcv.sb_mb;
goto dontblock;
}
- if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
+ }
+ if ((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING)) == 0 &&
(so->so_proto->pr_flags & PR_CONNREQUIRED)) {
error = ENOTCONN;
goto release;
}
- if (uio_resid(uio) == 0)
+ if (uio_resid(uio) == 0) {
goto release;
+ }
if ((so->so_state & SS_NBIO) ||
- (flags & (MSG_DONTWAIT|MSG_NBIO))) {
+ (flags & (MSG_DONTWAIT | MSG_NBIO))) {
error = EWOULDBLOCK;
goto release;
}
SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 1");
SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 1");
- sbunlock(&so->so_rcv, TRUE); /* keep socket locked */
+ sbunlock(&so->so_rcv, TRUE); /* keep socket locked */
#if EVEN_MORE_LOCKING_DEBUG
- if (socket_debug)
+ if (socket_debug) {
printf("Waiting for socket data\n");
+ }
#endif
error = sbwait(&so->so_rcv);
#if EVEN_MORE_LOCKING_DEBUG
- if (socket_debug)
+ if (socket_debug) {
printf("SORECEIVE - sbwait returned %d\n", error);
+ }
#endif
if (so->so_usecount < 1) {
panic("%s: after 2nd sblock so=%p ref=%d on socket\n",
VM_KERNEL_ADDRPERM(so), 0,
(int64_t)(orig_resid - uio_resid(uio)));
}
- return (error);
+ return error;
}
goto restart;
}
if ((pr->pr_flags & PR_ADDR) && m->m_type == MT_SONAME) {
error = soreceive_addr(p, so, psa, flags, &m, &nextrecord,
mp0 == NULL);
- if (error == ERESTART)
+ if (error == ERESTART) {
goto restart;
- else if (error != 0)
+ } else if (error != 0) {
goto release;
+ }
orig_resid = 0;
}
*/
if (m != NULL && m->m_type == MT_CONTROL) {
error = soreceive_ctl(so, controlp, flags, &m, &nextrecord);
- if (error != 0)
+ if (error != 0) {
goto release;
+ }
orig_resid = 0;
}
struct mbuf *seq_cm;
seq_cm = sbcreatecontrol((caddr_t)&m->m_pkthdr.msg_seq,
- sizeof (uint32_t), SCM_SEQNUM, SOL_SOCKET);
+ sizeof(uint32_t), SCM_SEQNUM, SOL_SOCKET);
if (seq_cm == NULL) {
/* unable to allocate a control mbuf */
error = ENOBUFS;
nextrecord);
/* NOTREACHED */
}
- if (nextrecord == NULL)
+ if (nextrecord == NULL) {
so->so_rcv.sb_lastrecord = m;
+ }
}
type = m->m_type;
- if (type == MT_OOBDATA)
+ if (type == MT_OOBDATA) {
flags |= MSG_OOB;
+ }
} else {
if (!(flags & MSG_PEEK)) {
SB_EMPTY_FIXUP(&so->so_rcv);
moff = 0;
offset = 0;
- if (!(flags & MSG_PEEK) && uio_resid(uio) > sorecvmincopy)
+ if (!(flags & MSG_PEEK) && uio_resid(uio) > sorecvmincopy) {
can_delay = 1;
- else
+ } else {
can_delay = 0;
+ }
need_event = 0;
while (m != NULL &&
(uio_resid(uio) - delayed_copy_len) > 0 && error == 0) {
if (m->m_type == MT_OOBDATA) {
- if (type != MT_OOBDATA)
+ if (type != MT_OOBDATA) {
break;
+ }
} else if (type == MT_OOBDATA) {
break;
}
}
so->so_state &= ~SS_RCVATMARK;
len = uio_resid(uio) - delayed_copy_len;
- if (so->so_oobmark && len > so->so_oobmark - offset)
+ if (so->so_oobmark && len > so->so_oobmark - offset) {
len = so->so_oobmark - offset;
- if (len > m->m_len - moff)
+ }
+ if (len > m->m_len - moff) {
len = m->m_len - moff;
+ }
/*
* If mp is set, just pass back the mbufs.
* Otherwise copy them out via the uio, then free.
(int)len, uio);
socket_lock(so, 0);
- if (error)
+ if (error) {
goto release;
+ }
}
} else {
uio_setresid(uio, (uio_resid(uio) - len));
}
if (len == m->m_len - moff) {
- if (m->m_flags & M_EOR)
+ if (m->m_flags & M_EOR) {
flags |= MSG_EOR;
+ }
if (flags & MSG_PEEK) {
m = m->m_next;
moff = 0;
if (so->so_msg_state->msg_uno_bytes >
m->m_len) {
so->so_msg_state->
- msg_uno_bytes -= m->m_len;
+ msg_uno_bytes -= m->m_len;
} else {
so->so_msg_state->
- msg_uno_bytes = 0;
+ msg_uno_bytes = 0;
}
m->m_flags &= ~M_UNORDERED_DATA;
}
so->so_rcv.sb_mb = m = m->m_next;
*mp = NULL;
} else {
- if (free_list == NULL)
+ if (free_list == NULL) {
free_list = m;
- else
+ } else {
ml->m_next = m;
+ }
ml = m;
so->so_rcv.sb_mb = m = m->m_next;
ml->m_next = NULL;
}
if (m != NULL) {
m->m_nextpkt = nextrecord;
- if (nextrecord == NULL)
+ if (nextrecord == NULL) {
so->so_rcv.sb_lastrecord = m;
+ }
} else {
so->so_rcv.sb_mb = nextrecord;
SB_EMPTY_FIXUP(&so->so_rcv);
if (mp != NULL) {
int copy_flag;
- if (flags & MSG_DONTWAIT)
+ if (flags & MSG_DONTWAIT) {
copy_flag = M_DONTWAIT;
- else
+ } else {
copy_flag = M_WAIT;
+ }
*mp = m_copym(m, 0, len, copy_flag);
/*
* Failed to allocate an mbuf?
}
} else {
offset += len;
- if (offset == so->so_oobmark)
+ if (offset == so->so_oobmark) {
break;
+ }
}
}
- if (flags & MSG_EOR)
+ if (flags & MSG_EOR) {
break;
+ }
/*
* If the MSG_WAITALL or MSG_WAITSTREAM flag is set
* (for non-atomic socket), we must not quit until
* count but without error. Keep sockbuf locked
* against other readers.
*/
- while (flags & (MSG_WAITALL|MSG_WAITSTREAM) && m == NULL &&
+ while (flags & (MSG_WAITALL | MSG_WAITSTREAM) && m == NULL &&
(uio_resid(uio) - delayed_copy_len) > 0 &&
!sosendallatonce(so) && !nextrecord) {
if (so->so_error || ((so->so_state & SS_CANTRCVMORE)
#if CONTENT_FILTER
&& cfil_sock_data_pending(&so->so_rcv) == 0
#endif /* CONTENT_FILTER */
- ))
+ )) {
goto release;
+ }
/*
* Depending on the protocol (e.g. TCP), the following
*/
if (pr->pr_flags & PR_WANTRCVD && so->so_pcb &&
(((struct inpcb *)so->so_pcb)->inp_state !=
- INPCB_STATE_DEAD))
+ INPCB_STATE_DEAD)) {
(*pr->pr_usrreqs->pru_rcvd)(so, flags);
+ }
SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 2");
SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 2");
error = sodelayed_copy(so, uio,
&free_list, &delayed_copy_len);
- if (error)
+ if (error) {
goto release;
+ }
}
m = so->so_rcv.sb_mb;
if (m != NULL) {
flags |= MSG_RCVMORE;
} else {
flags |= MSG_TRUNC;
- if ((flags & MSG_PEEK) == 0)
+ if ((flags & MSG_PEEK) == 0) {
(void) sbdroprecord(&so->so_rcv);
+ }
}
}
* is set), and so we set the flag now based on what we know
* prior to calling pru_rcvd.
*/
- if ((so->so_options & SO_WANTMORE) && so->so_rcv.sb_cc > 0)
+ if ((so->so_options & SO_WANTMORE) && so->so_rcv.sb_cc > 0) {
flags |= MSG_HAVEMORE;
+ }
if ((flags & MSG_PEEK) == 0) {
if (m == NULL) {
}
SBLASTRECORDCHK(&so->so_rcv, "soreceive 4");
SBLASTMBUFCHK(&so->so_rcv, "soreceive 4");
- if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
+ if (pr->pr_flags & PR_WANTRCVD && so->so_pcb) {
(*pr->pr_usrreqs->pru_rcvd)(so, flags);
+ }
}
if (delayed_copy_len) {
error = sodelayed_copy(so, uio, &free_list, &delayed_copy_len);
- if (error)
+ if (error) {
goto release;
+ }
}
if (free_list != NULL) {
m_freem_list(free_list);
free_list = NULL;
}
- if (need_event)
+ if (need_event) {
postevent(so, 0, EV_OOB);
+ }
if (orig_resid == uio_resid(uio) && orig_resid &&
(flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
- sbunlock(&so->so_rcv, TRUE); /* keep socket locked */
+ sbunlock(&so->so_rcv, TRUE); /* keep socket locked */
goto restart;
}
- if (flagsp != NULL)
+ if (flagsp != NULL) {
*flagsp |= flags;
+ }
release:
#ifdef MORE_LOCKING_DEBUG
if (so->so_usecount <= 1) {
/* NOTREACHED */
}
#endif
- if (delayed_copy_len)
+ if (delayed_copy_len) {
error = sodelayed_copy(so, uio, &free_list, &delayed_copy_len);
+ }
- if (free_list != NULL)
+ if (free_list != NULL) {
m_freem_list(free_list);
+ }
- sbunlock(&so->so_rcv, FALSE); /* will unlock socket */
+ sbunlock(&so->so_rcv, FALSE); /* will unlock socket */
if (en_tracing) {
KERNEL_ENERGYTRACE(kEnTrActKernSockRead, DBG_FUNC_END,
KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_END, so, uio_resid(uio),
so->so_rcv.sb_cc, 0, error);
- return (error);
+ return error;
}
/*
socket_lock(so, 0);
- return (error);
+ return error;
}
static int
auio = msgarray[i].uio;
for (m = ml; m != NULL; m = m->m_next) {
error = uiomove(mtod(m, caddr_t), m->m_len, auio);
- if (error != 0)
+ if (error != 0) {
goto out;
+ }
}
}
out:
*free_list = NULL;
*resid = 0;
- return (error);
+ return error;
}
int
* - Protocol must support packet chains
* - The uio array is NULL (should we panic?)
*/
- if (flagsp != NULL)
+ if (flagsp != NULL) {
flags = *flagsp;
- else
+ } else {
flags = 0;
+ }
if (flags & ~(MSG_PEEK | MSG_WAITALL | MSG_DONTWAIT | MSG_NEEDSA |
MSG_NBIO)) {
printf("%s invalid flags 0x%x\n", __func__, flags);
goto out;
}
- if (!(flags & MSG_PEEK) && sorecvmincopy > 0)
+ if (!(flags & MSG_PEEK) && sorecvmincopy > 0) {
can_delay = 1;
- else
+ } else {
can_delay = 0;
+ }
socket_lock(so, 1);
so_update_last_owner_locked(so, p);
* prior to being returned from sodefunct(); there should
* be no data on its receive list, so panic otherwise.
*/
- if (so->so_state & SS_DEFUNCT)
+ if (so->so_state & SS_DEFUNCT) {
sb_empty_assert(sb, __func__);
+ }
goto release;
}
if (so->so_error) {
error = so->so_error;
- if ((flags & MSG_PEEK) == 0)
+ if ((flags & MSG_PEEK) == 0) {
so->so_error = 0;
+ }
goto release;
}
if (so->so_state & SS_CANTRCVMORE) {
goto release;
}
- if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
+ if ((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING)) == 0 &&
(so->so_proto->pr_flags & PR_CONNREQUIRED)) {
error = ENOTCONN;
goto release;
}
if ((so->so_state & SS_NBIO) ||
- (flags & (MSG_DONTWAIT|MSG_NBIO))) {
+ (flags & (MSG_DONTWAIT | MSG_NBIO))) {
error = EWOULDBLOCK;
goto release;
}
SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 1");
SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 1");
- sbunlock(&so->so_rcv, TRUE); /* keep socket locked */
+ sbunlock(&so->so_rcv, TRUE); /* keep socket locked */
sblocked = 0;
error = sbwait(&so->so_rcv);
if ((pr->pr_flags & PR_ADDR) && m->m_type == MT_SONAME) {
error = soreceive_addr(p, so, psa, flags, &m, &nextrecord, 1);
- if (error == ERESTART)
+ if (error == ERESTART) {
goto restart;
- else if (error != 0)
+ } else if (error != 0) {
goto release;
+ }
}
if (m != NULL && m->m_type == MT_CONTROL) {
error = soreceive_ctl(so, controlp, flags, &m, &nextrecord);
- if (error != 0)
+ if (error != 0) {
goto release;
+ }
}
if (m->m_pkthdr.len == 0) {
ml = NULL;
pktlen = 0;
while (m != NULL && (len = resid - pktlen) >= 0 && error == 0) {
- if (m->m_len == 0)
+ if (m->m_len == 0) {
panic("%p m_len zero", m);
- if (m->m_type == 0)
+ }
+ if (m->m_type == 0) {
panic("%p m_type zero", m);
+ }
/*
* Clip to the residual length
*/
- if (len > m->m_len)
+ if (len > m->m_len) {
len = m->m_len;
+ }
pktlen += len;
/*
* Copy the mbufs via the uio or delay the copy
socket_unlock(so, 0);
error = uiomove(mtod(m, caddr_t), (int)len, auio);
socket_lock(so, 0);
- if (error)
+ if (error) {
goto release;
+ }
} else {
delayed_copy_len += len;
}
/*
* Set the first packet to the head of the free list
*/
- if (free_list == NULL)
+ if (free_list == NULL) {
free_list = m;
+ }
/*
* Link current packet to tail of free list
*/
if (ml == NULL) {
- if (free_tail != NULL)
+ if (free_tail != NULL) {
free_tail->m_nextpkt = m;
+ }
free_tail = m;
}
/*
* Link current mbuf to last mbuf of current packet
*/
- if (ml != NULL)
+ if (ml != NULL) {
ml->m_next = m;
+ }
ml = m;
/*
if (m != NULL) {
m->m_nextpkt = nextrecord;
- if (nextrecord == NULL)
+ if (nextrecord == NULL) {
so->so_rcv.sb_lastrecord = m;
+ }
} else {
so->so_rcv.sb_mb = nextrecord;
SB_EMPTY_FIXUP(&so->so_rcv);
* Copyout first the freelist then the partial mbuf
*/
socket_unlock(so, 0);
- if (delayed_copy_len)
+ if (delayed_copy_len) {
error = sodelayed_copy_list(so, msgarray,
uiocnt, &free_list, &delayed_copy_len);
+ }
if (error == 0) {
error = uiomove(mtod(m, caddr_t), (int)len,
auio);
}
socket_lock(so, 0);
- if (error)
+ if (error) {
goto release;
+ }
m->m_data += len;
m->m_len -= len;
if (npkts < uiocnt && error == 0 &&
(flags & (MSG_RCVMORE | MSG_TRUNC)) == 0 &&
(so->so_state & SS_CANTRCVMORE) == 0) {
- sbunlock(&so->so_rcv, TRUE); /* keep socket locked */
+ sbunlock(&so->so_rcv, TRUE); /* keep socket locked */
sblocked = 0;
goto next;
}
- if (flagsp != NULL)
+ if (flagsp != NULL) {
*flagsp |= flags;
+ }
release:
/*
* That way the caller won't be surprised if it receives less data
* than requested.
*/
- if ((so->so_options & SO_WANTMORE) && so->so_rcv.sb_cc > 0)
+ if ((so->so_options & SO_WANTMORE) && so->so_rcv.sb_cc > 0) {
flags |= MSG_HAVEMORE;
+ }
- if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
+ if (pr->pr_flags & PR_WANTRCVD && so->so_pcb) {
(*pr->pr_usrreqs->pru_rcvd)(so, flags);
+ }
- if (sblocked)
- sbunlock(&so->so_rcv, FALSE); /* will unlock socket */
- else
+ if (sblocked) {
+ sbunlock(&so->so_rcv, FALSE); /* will unlock socket */
+ } else {
socket_unlock(so, 1);
+ }
- if (delayed_copy_len)
+ if (delayed_copy_len) {
error = sodelayed_copy_list(so, msgarray, uiocnt,
&free_list, &delayed_copy_len);
+ }
out:
/*
* Amortize the cost of freeing the mbufs
*/
- if (free_list != NULL)
+ if (free_list != NULL) {
m_freem_list(free_list);
- if (free_others != NULL)
+ }
+ if (free_others != NULL) {
m_freem_list(free_others);
+ }
KERNEL_DEBUG(DBG_FNC_SORECEIVE_LIST | DBG_FUNC_END, error,
0, 0, 0, 0);
- return (error);
+ return error;
}
/*
case SHUT_RDWR:
socket_lock(so, 1);
if ((so->so_state &
- (SS_ISCONNECTED|SS_ISCONNECTING|SS_ISDISCONNECTING)) == 0) {
+ (SS_ISCONNECTED | SS_ISCONNECTING | SS_ISDISCONNECTING)) == 0) {
error = ENOTCONN;
} else {
error = soshutdownlock(so, how);
KERNEL_DEBUG(DBG_FNC_SOSHUTDOWN | DBG_FUNC_END, how, error, 0, 0, 0);
- return (error);
+ return error;
}
int
}
done:
KERNEL_DEBUG(DBG_FNC_SOSHUTDOWN, how, 1, 0, 0, 0);
- return (error);
+ return error;
}
int
error = soshutdownlock_final(so, how);
done:
- return (error);
+ return error;
}
void
(void) sblock(sb, SBL_WAIT | SBL_NOINTR | SBL_IGNDEFUNCT);
VERIFY(sb->sb_flags & SB_LOCK);
- sb->sb_flags &= ~(SB_SEL|SB_UPCALL);
- sb->sb_flags |= SB_DROP;
- sb->sb_upcall = NULL;
- sb->sb_upcallarg = NULL;
+ sb->sb_flags &= ~(SB_SEL | SB_UPCALL);
+ sb->sb_flags |= SB_DROP;
+ sb->sb_upcall = NULL;
+ sb->sb_upcallarg = NULL;
- sbunlock(sb, TRUE); /* keep socket locked */
+ sbunlock(sb, TRUE); /* keep socket locked */
selthreadclear(&sb->sb_sel);
sbrelease(sb);
* as part of sofreelastref(), and at that time, pr_getlock() may no
* longer be able to return us the lock; this will be fixed in future.
*/
- if (so->so_proto->pr_getlock != NULL)
+ if (so->so_proto->pr_getlock != NULL) {
mutex_held = (*so->so_proto->pr_getlock)(so, 0);
- else
+ } else {
mutex_held = so->so_proto->pr_domain->dom_mtx;
+ }
LCK_MTX_ASSERT(mutex_held, LCK_MTX_ASSERT_OWNED);
#endif /* notyet */
* Make sure to not carry over SB_LOCK in "asb", as we need
* to acquire it later as part of sbrelease().
*/
- bzero(&asb, sizeof (asb));
- asb.sb_cc = sb->sb_cc;
- asb.sb_hiwat = sb->sb_hiwat;
- asb.sb_mbcnt = sb->sb_mbcnt;
- asb.sb_mbmax = sb->sb_mbmax;
- asb.sb_ctl = sb->sb_ctl;
- asb.sb_lowat = sb->sb_lowat;
- asb.sb_mb = sb->sb_mb;
- asb.sb_mbtail = sb->sb_mbtail;
- asb.sb_lastrecord = sb->sb_lastrecord;
- asb.sb_so = sb->sb_so;
- asb.sb_flags = sb->sb_flags;
- asb.sb_flags &= ~(SB_LOCK|SB_SEL|SB_KNOTE|SB_UPCALL);
- asb.sb_flags |= SB_DROP;
+ bzero(&asb, sizeof(asb));
+ asb.sb_cc = sb->sb_cc;
+ asb.sb_hiwat = sb->sb_hiwat;
+ asb.sb_mbcnt = sb->sb_mbcnt;
+ asb.sb_mbmax = sb->sb_mbmax;
+ asb.sb_ctl = sb->sb_ctl;
+ asb.sb_lowat = sb->sb_lowat;
+ asb.sb_mb = sb->sb_mb;
+ asb.sb_mbtail = sb->sb_mbtail;
+ asb.sb_lastrecord = sb->sb_lastrecord;
+ asb.sb_so = sb->sb_so;
+ asb.sb_flags = sb->sb_flags;
+ asb.sb_flags &= ~(SB_LOCK | SB_SEL | SB_KNOTE | SB_UPCALL);
+ asb.sb_flags |= SB_DROP;
/*
* Ideally we'd bzero() these and preserve the ones we need;
* Setting SB_DROP acts as a barrier to prevent further appends.
* Clearing SB_SEL is done for selthreadclear() below.
*/
- sb->sb_cc = 0;
- sb->sb_hiwat = 0;
- sb->sb_mbcnt = 0;
- sb->sb_mbmax = 0;
- sb->sb_ctl = 0;
- sb->sb_lowat = 0;
- sb->sb_mb = NULL;
- sb->sb_mbtail = NULL;
- sb->sb_lastrecord = NULL;
- sb->sb_timeo.tv_sec = 0;
- sb->sb_timeo.tv_usec = 0;
- sb->sb_upcall = NULL;
- sb->sb_upcallarg = NULL;
- sb->sb_flags &= ~(SB_SEL|SB_UPCALL);
- sb->sb_flags |= SB_DROP;
-
- sbunlock(sb, TRUE); /* keep socket locked */
+ sb->sb_cc = 0;
+ sb->sb_hiwat = 0;
+ sb->sb_mbcnt = 0;
+ sb->sb_mbmax = 0;
+ sb->sb_ctl = 0;
+ sb->sb_lowat = 0;
+ sb->sb_mb = NULL;
+ sb->sb_mbtail = NULL;
+ sb->sb_lastrecord = NULL;
+ sb->sb_timeo.tv_sec = 0;
+ sb->sb_timeo.tv_usec = 0;
+ sb->sb_upcall = NULL;
+ sb->sb_upcallarg = NULL;
+ sb->sb_flags &= ~(SB_SEL | SB_UPCALL);
+ sb->sb_flags |= SB_DROP;
+
+ sbunlock(sb, TRUE); /* keep socket locked */
/*
* Note that selthreadclear() is called on the original "sb" and
*/
selthreadclear(&sb->sb_sel);
- if ((pr->pr_flags & PR_RIGHTS) && pr->pr_domain->dom_dispose)
+ if ((pr->pr_flags & PR_RIGHTS) && pr->pr_domain->dom_dispose) {
(*pr->pr_domain->dom_dispose)(asb.sb_mb);
+ }
sbrelease(&asb);
}
int
sooptcopyin(struct sockopt *sopt, void *buf, size_t len, size_t minlen)
{
- size_t valsize;
+ size_t valsize;
/*
* If the user gives us more than we wanted, we ignore it,
* wants, we return EINVAL. On success, sopt->sopt_valsize
* is set to however much we actually retrieved.
*/
- if ((valsize = sopt->sopt_valsize) < minlen)
- return (EINVAL);
- if (valsize > len)
+ if ((valsize = sopt->sopt_valsize) < minlen) {
+ return EINVAL;
+ }
+ if (valsize > len) {
sopt->sopt_valsize = valsize = len;
+ }
- if (sopt->sopt_p != kernproc)
- return (copyin(sopt->sopt_val, buf, valsize));
+ if (sopt->sopt_p != kernproc) {
+ return copyin(sopt->sopt_val, buf, valsize);
+ }
bcopy(CAST_DOWN(caddr_t, sopt->sopt_val), buf, valsize);
- return (0);
+ return 0;
}
/*
static int
sooptcopyin_timeval(struct sockopt *sopt, struct timeval *tv_p)
{
- int error;
+ int error;
if (proc_is64bit(sopt->sopt_p)) {
- struct user64_timeval tv64;
+ struct user64_timeval tv64;
- if (sopt->sopt_valsize < sizeof (tv64))
- return (EINVAL);
+ if (sopt->sopt_valsize < sizeof(tv64)) {
+ return EINVAL;
+ }
- sopt->sopt_valsize = sizeof (tv64);
+ sopt->sopt_valsize = sizeof(tv64);
if (sopt->sopt_p != kernproc) {
- error = copyin(sopt->sopt_val, &tv64, sizeof (tv64));
- if (error != 0)
- return (error);
+ error = copyin(sopt->sopt_val, &tv64, sizeof(tv64));
+ if (error != 0) {
+ return error;
+ }
} else {
bcopy(CAST_DOWN(caddr_t, sopt->sopt_val), &tv64,
- sizeof (tv64));
+ sizeof(tv64));
}
if (tv64.tv_sec < 0 || tv64.tv_sec > LONG_MAX ||
- tv64.tv_usec < 0 || tv64.tv_usec >= 1000000)
- return (EDOM);
+ tv64.tv_usec < 0 || tv64.tv_usec >= 1000000) {
+ return EDOM;
+ }
tv_p->tv_sec = tv64.tv_sec;
tv_p->tv_usec = tv64.tv_usec;
} else {
- struct user32_timeval tv32;
+ struct user32_timeval tv32;
- if (sopt->sopt_valsize < sizeof (tv32))
- return (EINVAL);
+ if (sopt->sopt_valsize < sizeof(tv32)) {
+ return EINVAL;
+ }
- sopt->sopt_valsize = sizeof (tv32);
+ sopt->sopt_valsize = sizeof(tv32);
if (sopt->sopt_p != kernproc) {
- error = copyin(sopt->sopt_val, &tv32, sizeof (tv32));
+ error = copyin(sopt->sopt_val, &tv32, sizeof(tv32));
if (error != 0) {
- return (error);
+ return error;
}
} else {
bcopy(CAST_DOWN(caddr_t, sopt->sopt_val), &tv32,
- sizeof (tv32));
+ sizeof(tv32));
}
#ifndef __LP64__
/*
* limited range of data type"
*/
if (tv32.tv_sec < 0 || tv32.tv_sec > LONG_MAX ||
- tv32.tv_usec < 0 || tv32.tv_usec >= 1000000)
- return (EDOM);
+ tv32.tv_usec < 0 || tv32.tv_usec >= 1000000) {
+ return EDOM;
+ }
#endif
tv_p->tv_sec = tv32.tv_sec;
tv_p->tv_usec = tv32.tv_usec;
}
- return (0);
+ return 0;
}
int
if (so->so_flags & SOF_DELEGATED) {
ep = proc_find(so->e_pid);
- if (ep)
+ if (ep) {
cred = kauth_cred_proc_ref(ep);
+ }
}
uid = kauth_cred_getuid(cred ? cred : so->so_cred);
/* uid is 0 for root */
- if (uid != 0 || !allow_root)
+ if (uid != 0 || !allow_root) {
error = priv_check_cred(cred ? cred : so->so_cred, priv, 0);
- if (cred)
+ }
+ if (cred) {
kauth_cred_unref(&cred);
- if (ep != PROC_NULL)
+ }
+ if (ep != PROC_NULL) {
proc_rele(ep);
+ }
- return (error);
+ return error;
}
/*
int
sosetoptlock(struct socket *so, struct sockopt *sopt, int dolock)
{
- int error, optval;
- struct linger l;
- struct timeval tv;
+ int error, optval;
+ struct linger l;
+ struct timeval tv;
#if CONFIG_MACF_SOCKET
struct mac extmac;
#endif /* MAC_SOCKET */
- if (sopt->sopt_dir != SOPT_SET)
+ if (sopt->sopt_dir != SOPT_SET) {
sopt->sopt_dir = SOPT_SET;
+ }
- if (dolock)
+ if (dolock) {
socket_lock(so, 1);
+ }
if ((so->so_state & (SS_CANTRCVMORE | SS_CANTSENDMORE)) ==
(SS_CANTRCVMORE | SS_CANTSENDMORE) &&
error = sflt_setsockopt(so, sopt);
if (error != 0) {
- if (error == EJUSTRETURN)
+ if (error == EJUSTRETURN) {
error = 0;
+ }
goto out;
}
* return value indicates that the option is unsupported.
*/
if (so->so_proto != NULL && (error = so->so_proto->pr_usrreqs->
- pru_socheckopt(so, sopt)) != 0)
+ pru_socheckopt(so, sopt)) != 0) {
goto out;
+ }
error = 0;
switch (sopt->sopt_name) {
case SO_LINGER:
case SO_LINGER_SEC:
- error = sooptcopyin(sopt, &l, sizeof (l), sizeof (l));
- if (error != 0)
+ error = sooptcopyin(sopt, &l, sizeof(l), sizeof(l));
+ if (error != 0) {
goto out;
+ }
so->so_linger = (sopt->sopt_name == SO_LINGER) ?
l.l_linger : l.l_linger * hz;
- if (l.l_onoff != 0)
+ if (l.l_onoff != 0) {
so->so_options |= SO_LINGER;
- else
+ } else {
so->so_options &= ~SO_LINGER;
+ }
break;
case SO_DEBUG:
case SO_WANTOOBFLAG:
case SO_NOWAKEFROMSLEEP:
case SO_NOAPNFALLBK:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
- if (optval)
+ }
+ if (optval) {
so->so_options |= sopt->sopt_name;
- else
+ } else {
so->so_options &= ~sopt->sopt_name;
+ }
break;
case SO_SNDBUF:
case SO_RCVBUF:
case SO_SNDLOWAT:
case SO_RCVLOWAT:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
+ }
/*
* Values < 1 make no sense for any of these
so->so_rcv.sb_hiwat : optval;
data_len = so->so_rcv.sb_cc
- so->so_rcv.sb_ctl;
- if (data_len >= so->so_rcv.sb_lowat)
- sorwakeup(so);
+ if (data_len >= so->so_rcv.sb_lowat) {
+ sorwakeup(so);
+ }
break;
}
}
case SO_SNDTIMEO:
case SO_RCVTIMEO:
error = sooptcopyin_timeval(sopt, &tv);
- if (error != 0)
+ if (error != 0) {
goto out;
+ }
switch (sopt->sopt_name) {
case SO_SNDTIMEO:
case SO_NKE: {
struct so_nke nke;
- error = sooptcopyin(sopt, &nke, sizeof (nke),
- sizeof (nke));
- if (error != 0)
+ error = sooptcopyin(sopt, &nke, sizeof(nke),
+ sizeof(nke));
+ if (error != 0) {
goto out;
+ }
error = sflt_attach_internal(so, nke.nke_handle);
break;
}
case SO_NOSIGPIPE:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
- if (optval != 0)
+ }
+ if (optval != 0) {
so->so_flags |= SOF_NOSIGPIPE;
- else
+ } else {
so->so_flags &= ~SOF_NOSIGPIPE;
+ }
break;
case SO_NOADDRERR:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
- if (optval != 0)
+ }
+ if (optval != 0) {
so->so_flags |= SOF_NOADDRAVAIL;
- else
+ } else {
so->so_flags &= ~SOF_NOADDRAVAIL;
+ }
break;
case SO_REUSESHAREUID:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
- if (optval != 0)
+ }
+ if (optval != 0) {
so->so_flags |= SOF_REUSESHAREUID;
- else
+ } else {
so->so_flags &= ~SOF_REUSESHAREUID;
+ }
break;
case SO_NOTIFYCONFLICT:
error = EPERM;
goto out;
}
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
- if (optval != 0)
+ }
+ if (optval != 0) {
so->so_flags |= SOF_NOTIFYCONFLICT;
- else
+ } else {
so->so_flags &= ~SOF_NOTIFYCONFLICT;
+ }
break;
case SO_RESTRICTIONS:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
+ }
error = so_set_restrictions(so, optval);
break;
}
error = sooptcopyin(sopt, &optval, sizeof(optval),
sizeof(optval));
- if (error != 0)
+ if (error != 0) {
goto out;
+ }
if (optval != 0) {
error = soopt_cred_check(so,
PRIV_NET_RESTRICTED_AWDL, false);
- if (error == 0)
+ if (error == 0) {
inp_set_awdl_unrestricted(
- sotoinpcb(so));
- } else
+ sotoinpcb(so));
+ }
+ } else {
inp_clear_awdl_unrestricted(sotoinpcb(so));
+ }
break;
case SO_INTCOPROC_ALLOW:
if (SOCK_DOM(so) != PF_INET6) {
}
error = sooptcopyin(sopt, &optval, sizeof(optval),
sizeof(optval));
- if (error != 0)
+ if (error != 0) {
goto out;
+ }
if (optval != 0 &&
- inp_get_intcoproc_allowed(sotoinpcb(so)) == FALSE) {
+ inp_get_intcoproc_allowed(sotoinpcb(so)) == FALSE) {
error = soopt_cred_check(so,
PRIV_NET_RESTRICTED_INTCOPROC, false);
- if (error == 0)
+ if (error == 0) {
inp_set_intcoproc_allowed(
- sotoinpcb(so));
- } else if (optval == 0)
+ sotoinpcb(so));
+ }
+ } else if (optval == 0) {
inp_clear_intcoproc_allowed(sotoinpcb(so));
+ }
break;
case SO_LABEL:
#if CONFIG_MACF_SOCKET
- if ((error = sooptcopyin(sopt, &extmac, sizeof (extmac),
- sizeof (extmac))) != 0)
+ if ((error = sooptcopyin(sopt, &extmac, sizeof(extmac),
+ sizeof(extmac))) != 0) {
goto out;
+ }
error = mac_setsockopt_label(proc_ucred(sopt->sopt_p),
so, &extmac);
break;
case SO_UPCALLCLOSEWAIT:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
- if (optval != 0)
+ }
+ if (optval != 0) {
so->so_flags |= SOF_UPCALLCLOSEWAIT;
- else
+ } else {
so->so_flags &= ~SOF_UPCALLCLOSEWAIT;
+ }
break;
case SO_RANDOMPORT:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
- if (optval != 0)
+ }
+ if (optval != 0) {
so->so_flags |= SOF_BINDRANDOMPORT;
- else
+ } else {
so->so_flags &= ~SOF_BINDRANDOMPORT;
+ }
break;
case SO_NP_EXTENSIONS: {
struct so_np_extensions sonpx;
- error = sooptcopyin(sopt, &sonpx, sizeof (sonpx),
- sizeof (sonpx));
- if (error != 0)
+ error = sooptcopyin(sopt, &sonpx, sizeof(sonpx),
+ sizeof(sonpx));
+ if (error != 0) {
goto out;
+ }
if (sonpx.npx_mask & ~SONPX_MASK_VALID) {
error = EINVAL;
goto out;
* Only one bit defined for now
*/
if ((sonpx.npx_mask & SONPX_SETOPTSHUT)) {
- if ((sonpx.npx_flags & SONPX_SETOPTSHUT))
+ if ((sonpx.npx_flags & SONPX_SETOPTSHUT)) {
so->so_flags |= SOF_NPX_SETOPTSHUT;
- else
+ } else {
so->so_flags &= ~SOF_NPX_SETOPTSHUT;
+ }
}
break;
}
case SO_TRAFFIC_CLASS: {
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
+ }
if (optval >= SO_TC_NET_SERVICE_OFFSET) {
int netsvc = optval - SO_TC_NET_SERVICE_OFFSET;
error = so_set_net_service_type(so, netsvc);
goto out;
}
error = so_set_traffic_class(so, optval);
- if (error != 0)
+ if (error != 0) {
goto out;
+ }
so->so_flags1 &= ~SOF1_TC_NET_SERV_TYPE;
so->so_netsvctype = _NET_SERVICE_TYPE_UNSPEC;
break;
}
case SO_RECV_TRAFFIC_CLASS: {
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
- if (optval == 0)
+ }
+ if (optval == 0) {
so->so_flags &= ~SOF_RECV_TRAFFIC_CLASS;
- else
+ } else {
so->so_flags |= SOF_RECV_TRAFFIC_CLASS;
+ }
break;
}
struct so_tcdbg so_tcdbg;
error = sooptcopyin(sopt, &so_tcdbg,
- sizeof (struct so_tcdbg), sizeof (struct so_tcdbg));
- if (error != 0)
+ sizeof(struct so_tcdbg), sizeof(struct so_tcdbg));
+ if (error != 0) {
goto out;
+ }
error = so_set_tcdbg(so, &so_tcdbg);
- if (error != 0)
+ if (error != 0) {
goto out;
+ }
break;
}
#endif /* (DEVELOPMENT || DEBUG) */
case SO_PRIVILEGED_TRAFFIC_CLASS:
error = priv_check_cred(kauth_cred_get(),
PRIV_NET_PRIVILEGED_TRAFFIC_CLASS, 0);
- if (error != 0)
+ if (error != 0) {
goto out;
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error != 0)
+ }
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error != 0) {
goto out;
- if (optval == 0)
+ }
+ if (optval == 0) {
so->so_flags &= ~SOF_PRIVILEGED_TRAFFIC_CLASS;
- else
+ } else {
so->so_flags |= SOF_PRIVILEGED_TRAFFIC_CLASS;
+ }
break;
#if (DEVELOPMENT || DEBUG)
case SO_DEFUNCTIT:
error = sosetdefunct(current_proc(), so, 0, FALSE);
- if (error == 0)
+ if (error == 0) {
error = sodefunct(current_proc(), so, 0);
+ }
break;
#endif /* (DEVELOPMENT || DEBUG) */
case SO_DEFUNCTOK:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
if (error != 0 || (so->so_flags & SOF_DEFUNCT)) {
- if (error == 0)
+ if (error == 0) {
error = EBADF;
+ }
goto out;
}
/*
error = EPERM;
goto out;
}
- if (optval)
+ if (optval) {
so->so_flags &= ~SOF_NODEFUNCT;
- else
+ } else {
so->so_flags |= SOF_NODEFUNCT;
+ }
if (SOCK_DOM(so) == PF_INET ||
SOCK_DOM(so) == PF_INET6) {
"TCP" : "UDP", inet_ntop(SOCK_DOM(so),
((SOCK_DOM(so) == PF_INET) ?
(void *)&inp->inp_laddr.s_addr :
- (void *)&inp->in6p_laddr), s, sizeof (s)),
+ (void *)&inp->in6p_laddr), s, sizeof(s)),
ntohs(inp->in6p_lport),
inet_ntop(SOCK_DOM(so),
(SOCK_DOM(so) == PF_INET) ?
(void *)&inp->inp_faddr.s_addr :
- (void *)&inp->in6p_faddr, d, sizeof (d)),
+ (void *)&inp->in6p_faddr, d, sizeof(d)),
ntohs(inp->in6p_fport),
(so->so_flags & SOF_NODEFUNCT) ?
"not " : "");
break;
case SO_OPPORTUNISTIC:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error == 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error == 0) {
error = so_set_opportunistic(so, optval);
+ }
break;
case SO_FLUSH:
break;
case SO_RECV_ANYIF:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error == 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error == 0) {
error = so_set_recv_anyif(so, optval);
+ }
break;
case SO_TRAFFIC_MGT_BACKGROUND: {
case SO_FLOW_DIVERT_TOKEN:
error = flow_divert_token_set(so, sopt);
break;
-#endif /* FLOW_DIVERT */
+#endif /* FLOW_DIVERT */
case SO_DELEGATED:
- if ((error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval))) != 0)
+ if ((error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval))) != 0) {
break;
+ }
error = so_set_effective_pid(so, optval, sopt->sopt_p);
break;
case SO_DELEGATED_UUID: {
uuid_t euuid;
- if ((error = sooptcopyin(sopt, &euuid, sizeof (euuid),
- sizeof (euuid))) != 0)
+ if ((error = sooptcopyin(sopt, &euuid, sizeof(euuid),
+ sizeof(euuid))) != 0) {
break;
+ }
error = so_set_effective_uuid(so, euuid, sopt->sopt_p);
break;
}
error = sooptcopyin(sopt, &inp->necp_client_uuid,
- sizeof(uuid_t), sizeof(uuid_t));
+ sizeof(uuid_t), sizeof(uuid_t));
if (error != 0) {
goto out;
}
#endif /* NECP */
case SO_EXTENDED_BK_IDLE:
- error = sooptcopyin(sopt, &optval, sizeof (optval),
- sizeof (optval));
- if (error == 0)
+ error = sooptcopyin(sopt, &optval, sizeof(optval),
+ sizeof(optval));
+ if (error == 0) {
error = so_set_extended_bk_idle(so, optval);
+ }
break;
case SO_MARK_CELLFALLBACK:
error = sooptcopyin(sopt, &optval, sizeof(optval),
sizeof(optval));
- if (error != 0)
+ if (error != 0) {
goto out;
+ }
if (optval < 0) {
error = EINVAL;
goto out;
}
- if (optval == 0)
+ if (optval == 0) {
so->so_flags1 &= ~SOF1_CELLFALLBACK;
- else
+ } else {
so->so_flags1 |= SOF1_CELLFALLBACK;
+ }
break;
case SO_NET_SERVICE_TYPE: {
error = sooptcopyin(sopt, &optval, sizeof(optval),
sizeof(optval));
- if (error != 0)
+ if (error != 0) {
goto out;
+ }
error = so_set_net_service_type(so, optval);
break;
}
case SO_QOSMARKING_POLICY_OVERRIDE:
error = priv_check_cred(kauth_cred_get(),
PRIV_NET_QOSMARKING_POLICY_OVERRIDE, 0);
- if (error != 0)
+ if (error != 0) {
goto out;
+ }
error = sooptcopyin(sopt, &optval, sizeof(optval),
sizeof(optval));
- if (error != 0)
+ if (error != 0) {
goto out;
- if (optval == 0)
+ }
+ if (optval == 0) {
so->so_flags1 &= ~SOF1_QOSMARKING_POLICY_OVERRIDE;
- else
+ } else {
so->so_flags1 |= SOF1_QOSMARKING_POLICY_OVERRIDE;
+ }
break;
default:
}
}
out:
- if (dolock)
+ if (dolock) {
socket_unlock(so, 1);
- return (error);
+ }
+ return error;
}
/* Helper routines for getsockopt */
int
sooptcopyout(struct sockopt *sopt, void *buf, size_t len)
{
- int error;
- size_t valsize;
+ int error;
+ size_t valsize;
error = 0;
valsize = min(len, sopt->sopt_valsize);
sopt->sopt_valsize = valsize;
if (sopt->sopt_val != USER_ADDR_NULL) {
- if (sopt->sopt_p != kernproc)
+ if (sopt->sopt_p != kernproc) {
error = copyout(buf, sopt->sopt_val, valsize);
- else
+ } else {
bcopy(buf, CAST_DOWN(caddr_t, sopt->sopt_val), valsize);
+ }
}
- return (error);
+ return error;
}
static int
sooptcopyout_timeval(struct sockopt *sopt, const struct timeval *tv_p)
{
- int error;
- size_t len;
- struct user64_timeval tv64 = {};
- struct user32_timeval tv32 = {};
- const void * val;
- size_t valsize;
+ int error;
+ size_t len;
+ struct user64_timeval tv64 = {};
+ struct user32_timeval tv32 = {};
+ const void * val;
+ size_t valsize;
error = 0;
if (proc_is64bit(sopt->sopt_p)) {
- len = sizeof (tv64);
+ len = sizeof(tv64);
tv64.tv_sec = tv_p->tv_sec;
tv64.tv_usec = tv_p->tv_usec;
val = &tv64;
} else {
- len = sizeof (tv32);
+ len = sizeof(tv32);
tv32.tv_sec = tv_p->tv_sec;
tv32.tv_usec = tv_p->tv_usec;
val = &tv32;
valsize = min(len, sopt->sopt_valsize);
sopt->sopt_valsize = valsize;
if (sopt->sopt_val != USER_ADDR_NULL) {
- if (sopt->sopt_p != kernproc)
+ if (sopt->sopt_p != kernproc) {
error = copyout(val, sopt->sopt_val, valsize);
- else
+ } else {
bcopy(val, CAST_DOWN(caddr_t, sopt->sopt_val), valsize);
+ }
}
- return (error);
+ return error;
}
/*
int
sogetoptlock(struct socket *so, struct sockopt *sopt, int dolock)
{
- int error, optval;
- struct linger l;
- struct timeval tv;
+ int error, optval;
+ struct linger l;
+ struct timeval tv;
#if CONFIG_MACF_SOCKET
struct mac extmac;
#endif /* MAC_SOCKET */
- if (sopt->sopt_dir != SOPT_GET)
+ if (sopt->sopt_dir != SOPT_GET) {
sopt->sopt_dir = SOPT_GET;
+ }
- if (dolock)
+ if (dolock) {
socket_lock(so, 1);
+ }
error = sflt_getsockopt(so, sopt);
if (error != 0) {
- if (error == EJUSTRETURN)
+ if (error == EJUSTRETURN) {
error = 0;
+ }
goto out;
}
* return value indicates that the option is unsupported.
*/
if (so->so_proto != NULL && (error = so->so_proto->pr_usrreqs->
- pru_socheckopt(so, sopt)) != 0)
+ pru_socheckopt(so, sopt)) != 0) {
goto out;
+ }
error = 0;
switch (sopt->sopt_name) {
l.l_onoff = ((so->so_options & SO_LINGER) ? 1 : 0);
l.l_linger = (sopt->sopt_name == SO_LINGER) ?
so->so_linger : so->so_linger / hz;
- error = sooptcopyout(sopt, &l, sizeof (l));
+ error = sooptcopyout(sopt, &l, sizeof(l));
break;
case SO_USELOOPBACK:
case SO_NOAPNFALLBK:
optval = so->so_options & sopt->sopt_name;
integer:
- error = sooptcopyout(sopt, &optval, sizeof (optval));
+ error = sooptcopyout(sopt, &optval, sizeof(optval));
break;
case SO_TYPE:
while (m1 != NULL) {
if (m1->m_type == MT_DATA ||
m1->m_type == MT_HEADER ||
- m1->m_type == MT_OOBDATA)
+ m1->m_type == MT_OOBDATA) {
pkt_total += m1->m_len;
+ }
m1 = m1->m_next;
}
optval = pkt_total;
while (m1 != NULL) {
if (m1->m_type == MT_DATA ||
m1->m_type == MT_HEADER ||
- m1->m_type == MT_OOBDATA)
+ m1->m_type == MT_OOBDATA) {
cnt += 1;
+ }
m1 = m1->m_nextpkt;
}
optval = cnt;
if (SOCK_DOM(so) == PF_INET ||
SOCK_DOM(so) == PF_INET6) {
optval = inp_get_awdl_unrestricted(
- sotoinpcb(so));
+ sotoinpcb(so));
goto integer;
- } else
+ } else {
error = EOPNOTSUPP;
+ }
break;
case SO_INTCOPROC_ALLOW:
if (SOCK_DOM(so) == PF_INET6) {
optval = inp_get_intcoproc_allowed(
- sotoinpcb(so));
+ sotoinpcb(so));
goto integer;
- } else
+ } else {
error = EOPNOTSUPP;
+ }
break;
case SO_LABEL:
#if CONFIG_MACF_SOCKET
- if ((error = sooptcopyin(sopt, &extmac, sizeof (extmac),
- sizeof (extmac))) != 0 ||
+ if ((error = sooptcopyin(sopt, &extmac, sizeof(extmac),
+ sizeof(extmac))) != 0 ||
(error = mac_socket_label_get(proc_ucred(
- sopt->sopt_p), so, &extmac)) != 0)
+ sopt->sopt_p), so, &extmac)) != 0) {
break;
+ }
- error = sooptcopyout(sopt, &extmac, sizeof (extmac));
+ error = sooptcopyout(sopt, &extmac, sizeof(extmac));
#else
error = EOPNOTSUPP;
#endif /* MAC_SOCKET */
case SO_PEERLABEL:
#if CONFIG_MACF_SOCKET
- if ((error = sooptcopyin(sopt, &extmac, sizeof (extmac),
- sizeof (extmac))) != 0 ||
+ if ((error = sooptcopyin(sopt, &extmac, sizeof(extmac),
+ sizeof(extmac))) != 0 ||
(error = mac_socketpeer_label_get(proc_ucred(
- sopt->sopt_p), so, &extmac)) != 0)
+ sopt->sopt_p), so, &extmac)) != 0) {
break;
+ }
- error = sooptcopyout(sopt, &extmac, sizeof (extmac));
+ error = sooptcopyout(sopt, &extmac, sizeof(extmac));
#else
error = EOPNOTSUPP;
#endif /* MAC_SOCKET */
sonpx.npx_mask = SONPX_MASK_VALID;
error = sooptcopyout(sopt, &sonpx,
- sizeof (struct so_np_extensions));
+ sizeof(struct so_np_extensions));
break;
}
case SO_TRAFFIC_CLASS_STATS:
error = sooptcopyout(sopt, &so->so_tc_stats,
- sizeof (so->so_tc_stats));
+ sizeof(so->so_tc_stats));
break;
#if (DEVELOPMENT || DEBUG)
case SO_FLOW_DIVERT_TOKEN:
error = flow_divert_token_get(so, sopt);
break;
-#endif /* FLOW_DIVERT */
+#endif /* FLOW_DIVERT */
#if NECP
case SO_NECP_ATTRIBUTES:
sock_id = cfil_sock_id_from_socket(so);
error = sooptcopyout(sopt, &sock_id,
- sizeof(cfil_sock_id_t));
+ sizeof(cfil_sock_id_t));
break;
}
-#endif /* CONTENT_FILTER */
+#endif /* CONTENT_FILTER */
case SO_EXTENDED_BK_IDLE:
optval = (so->so_flags1 & SOF1_EXTEND_BK_IDLE_WANTED);
? 1 : 0;
goto integer;
case SO_NET_SERVICE_TYPE: {
- if ((so->so_flags1 & SOF1_TC_NET_SERV_TYPE))
+ if ((so->so_flags1 & SOF1_TC_NET_SERV_TYPE)) {
optval = so->so_netsvctype;
- else
+ } else {
optval = NET_SERVICE_TYPE_BE;
+ }
goto integer;
}
case SO_NETSVC_MARKING_LEVEL:
}
}
out:
- if (dolock)
+ if (dolock) {
socket_unlock(so, 1);
- return (error);
+ }
+ return error;
}
/*
int sopt_size = sopt->sopt_valsize;
int how;
- if (sopt_size <= 0 || sopt_size > MCLBYTES)
- return (EMSGSIZE);
+ if (sopt_size <= 0 || sopt_size > MCLBYTES) {
+ return EMSGSIZE;
+ }
how = sopt->sopt_p != kernproc ? M_WAIT : M_DONTWAIT;
MGET(m, how, MT_DATA);
- if (m == NULL)
- return (ENOBUFS);
+ if (m == NULL) {
+ return ENOBUFS;
+ }
if (sopt_size > MLEN) {
MCLGET(m, how);
if ((m->m_flags & M_EXT) == 0) {
m_free(m);
- return (ENOBUFS);
+ return ENOBUFS;
}
m->m_len = min(MCLBYTES, sopt_size);
} else {
MGET(m, how, MT_DATA);
if (m == NULL) {
m_freem(*mp);
- return (ENOBUFS);
+ return ENOBUFS;
}
if (sopt_size > MLEN) {
MCLGET(m, how);
if ((m->m_flags & M_EXT) == 0) {
m_freem(*mp);
m_freem(m);
- return (ENOBUFS);
+ return ENOBUFS;
}
m->m_len = min(MCLBYTES, sopt_size);
} else {
m_prev->m_next = m;
m_prev = m;
}
- return (0);
+ return 0;
}
/* copyin sopt data into mbuf chain */
{
struct mbuf *m0 = m;
- if (sopt->sopt_val == USER_ADDR_NULL)
- return (0);
+ if (sopt->sopt_val == USER_ADDR_NULL) {
+ return 0;
+ }
while (m != NULL && sopt->sopt_valsize >= m->m_len) {
if (sopt->sopt_p != kernproc) {
int error;
m->m_len);
if (error != 0) {
m_freem(m0);
- return (error);
+ return error;
}
} else {
bcopy(CAST_DOWN(caddr_t, sopt->sopt_val),
panic("soopt_mcopyin");
/* NOTREACHED */
}
- return (0);
+ return 0;
}
/* copyout mbuf chain data into soopt */
struct mbuf *m0 = m;
size_t valsize = 0;
- if (sopt->sopt_val == USER_ADDR_NULL)
- return (0);
+ if (sopt->sopt_val == USER_ADDR_NULL) {
+ return 0;
+ }
while (m != NULL && sopt->sopt_valsize >= m->m_len) {
if (sopt->sopt_p != kernproc) {
int error;
m->m_len);
if (error != 0) {
m_freem(m0);
- return (error);
+ return error;
}
} else {
bcopy(mtod(m, char *),
if (m != NULL) {
/* enough soopt buffer should be given from user-land */
m_freem(m0);
- return (EINVAL);
+ return EINVAL;
}
sopt->sopt_valsize = valsize;
- return (0);
+ return 0;
}
void
sohasoutofband(struct socket *so)
{
- if (so->so_pgid < 0)
+ if (so->so_pgid < 0) {
gsignal(-so->so_pgid, SIGURG);
- else if (so->so_pgid > 0)
+ } else if (so->so_pgid > 0) {
proc_signal(so->so_pgid, SIGURG);
+ }
selwakeup(&so->so_rcv.sb_sel);
if (so->so_rcv.sb_flags & SB_KNOTE) {
KNOTE(&so->so_rcv.sb_sel.si_note,
so_update_last_owner_locked(so, PROC_NULL);
so_update_policy(so);
- if (events & (POLLIN | POLLRDNORM))
- if (soreadable(so))
+ if (events & (POLLIN | POLLRDNORM)) {
+ if (soreadable(so)) {
revents |= events & (POLLIN | POLLRDNORM);
+ }
+ }
- if (events & (POLLOUT | POLLWRNORM))
- if (sowriteable(so))
+ if (events & (POLLOUT | POLLWRNORM)) {
+ if (sowriteable(so)) {
revents |= events & (POLLOUT | POLLWRNORM);
+ }
+ }
- if (events & (POLLPRI | POLLRDBAND))
- if (so->so_oobmark || (so->so_state & SS_RCVATMARK))
+ if (events & (POLLPRI | POLLRDBAND)) {
+ if (so->so_oobmark || (so->so_state & SS_RCVATMARK)) {
revents |= events & (POLLPRI | POLLRDBAND);
+ }
+ }
if (revents == 0) {
if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
}
socket_unlock(so, 1);
- return (revents);
+ return revents;
}
int
soo_kqfilter(struct fileproc *fp, struct knote *kn,
- struct kevent_internal_s *kev, vfs_context_t ctx)
+ struct kevent_internal_s *kev, vfs_context_t ctx)
{
#pragma unused(fp)
#if !CONFIG_MACF_SOCKET
*/
kn->kn_data = so->so_qlen;
- is_not_empty = ! TAILQ_EMPTY(&so->so_comp);
+ is_not_empty = !TAILQ_EMPTY(&so->so_comp);
- return (is_not_empty);
+ return is_not_empty;
}
/* socket isn't a listener */
if (so->so_oobmark || (so->so_state & SS_RCVATMARK)) {
kn->kn_fflags |= NOTE_OOB;
kn->kn_data -= so->so_oobmark;
- return (1);
+ return 1;
}
}
#if CONTENT_FILTER
&& cfil_sock_data_pending(&so->so_rcv) == 0
#endif /* CONTENT_FILTER */
- ) {
+ ) {
kn->kn_flags |= EV_EOF;
kn->kn_fflags = so->so_error;
- return (1);
+ return 1;
}
- if (so->so_error) { /* temporary udp error */
- return (1);
+ if (so->so_error) { /* temporary udp error */
+ return 1;
}
- int64_t lowwat = so->so_rcv.sb_lowat;
+ int64_t lowwat = so->so_rcv.sb_lowat;
/*
* Ensure that when NOTE_LOWAT is used, the derived
* low water mark is bounded by socket's rcv buf's
* high and low water mark values.
*/
if (kn->kn_sfflags & NOTE_LOWAT) {
- if (kn->kn_sdata > so->so_rcv.sb_hiwat)
+ if (kn->kn_sdata > so->so_rcv.sb_hiwat) {
lowwat = so->so_rcv.sb_hiwat;
- else if (kn->kn_sdata > lowwat)
+ } else if (kn->kn_sdata > lowwat) {
lowwat = kn->kn_sdata;
+ }
}
/*
* overrides sb_lowat, check for NOTE_LOWAT case
* first.
*/
- if (kn->kn_sfflags & NOTE_LOWAT)
- return (kn->kn_data >= lowwat);
+ if (kn->kn_sfflags & NOTE_LOWAT) {
+ return kn->kn_data >= lowwat;
+ }
- return (so->so_rcv.sb_cc >= lowwat);
+ return so->so_rcv.sb_cc >= lowwat;
}
static int
} else {
kn->kn_hookid = 0;
}
- if (KNOTE_ATTACH(&so->so_rcv.sb_sel.si_note, kn))
+ if (KNOTE_ATTACH(&so->so_rcv.sb_sel.si_note, kn)) {
so->so_rcv.sb_flags |= SB_KNOTE;
+ }
/* indicate if event is already fired */
return filt_soread_common(kn, so);
struct socket *so = (struct socket *)kn->kn_fp->f_fglob->fg_data;
socket_lock(so, 1);
- if (so->so_rcv.sb_flags & SB_KNOTE)
- if (KNOTE_DETACH(&so->so_rcv.sb_sel.si_note, kn))
+ if (so->so_rcv.sb_flags & SB_KNOTE) {
+ if (KNOTE_DETACH(&so->so_rcv.sb_sel.si_note, kn)) {
so->so_rcv.sb_flags &= ~SB_KNOTE;
+ }
+ }
socket_unlock(so, 1);
}
struct socket *so = (struct socket *)kn->kn_fp->f_fglob->fg_data;
int retval;
- if ((hint & SO_FILT_HINT_LOCKED) == 0)
+ if ((hint & SO_FILT_HINT_LOCKED) == 0) {
socket_lock(so, 1);
+ }
retval = filt_soread_common(kn, so);
- if ((hint & SO_FILT_HINT_LOCKED) == 0)
+ if ((hint & SO_FILT_HINT_LOCKED) == 0) {
socket_unlock(so, 1);
+ }
return retval;
}
if ((SOCK_DOM(so) == PF_INET || SOCK_DOM(so) == PF_INET6) &&
(so->so_state & SS_ISCONNECTED)) {
struct inpcb *inp = sotoinpcb(so);
- if (INP_WAIT_FOR_IF_FEEDBACK(inp))
- return (1);
+ if (INP_WAIT_FOR_IF_FEEDBACK(inp)) {
+ return 1;
+ }
}
- return (0);
+ return 0;
}
static int
kn->kn_fflags = so->so_error;
return 1;
}
- if (so->so_error) { /* temporary udp error */
+ if (so->so_error) { /* temporary udp error */
return 1;
}
if (!socanwrite(so)) {
if (so->so_flags1 & SOF1_PRECONNECT_DATA) {
return 1;
}
- int64_t lowwat = so->so_snd.sb_lowat;
+ int64_t lowwat = so->so_snd.sb_lowat;
if (kn->kn_sfflags & NOTE_LOWAT) {
- if (kn->kn_sdata > so->so_snd.sb_hiwat)
+ if (kn->kn_sdata > so->so_snd.sb_hiwat) {
lowwat = so->so_snd.sb_hiwat;
- else if (kn->kn_sdata > lowwat)
+ } else if (kn->kn_sdata > lowwat) {
lowwat = kn->kn_sdata;
+ }
}
if (kn->kn_data >= lowwat) {
if ((so->so_flags & SOF_NOTSENT_LOWAT)
ret = 1;
}
}
- if (so_wait_for_if_feedback(so))
+ if (so_wait_for_if_feedback(so)) {
ret = 0;
- return (ret);
+ }
+ return ret;
}
static int
struct socket *so = (struct socket *)kn->kn_fp->f_fglob->fg_data;
/* socket locked */
- if (KNOTE_ATTACH(&so->so_snd.sb_sel.si_note, kn))
+ if (KNOTE_ATTACH(&so->so_snd.sb_sel.si_note, kn)) {
so->so_snd.sb_flags |= SB_KNOTE;
+ }
/* determine if its already fired */
return filt_sowrite_common(kn, so);
struct socket *so = (struct socket *)kn->kn_fp->f_fglob->fg_data;
socket_lock(so, 1);
- if (so->so_snd.sb_flags & SB_KNOTE)
- if (KNOTE_DETACH(&so->so_snd.sb_sel.si_note, kn))
+ if (so->so_snd.sb_flags & SB_KNOTE) {
+ if (KNOTE_DETACH(&so->so_snd.sb_sel.si_note, kn)) {
so->so_snd.sb_flags &= ~SB_KNOTE;
+ }
+ }
socket_unlock(so, 1);
}
struct socket *so = (struct socket *)kn->kn_fp->f_fglob->fg_data;
int ret;
- if ((hint & SO_FILT_HINT_LOCKED) == 0)
+ if ((hint & SO_FILT_HINT_LOCKED) == 0) {
socket_lock(so, 1);
+ }
ret = filt_sowrite_common(kn, so);
- if ((hint & SO_FILT_HINT_LOCKED) == 0)
+ if ((hint & SO_FILT_HINT_LOCKED) == 0) {
socket_unlock(so, 1);
+ }
return ret;
}
}
if (ev_hint & SO_FILT_HINT_CONNINFO_UPDATED) {
if (so->so_proto != NULL &&
- (so->so_proto->pr_flags & PR_EVCONNINFO))
+ (so->so_proto->pr_flags & PR_EVCONNINFO)) {
kn->kn_fflags |= NOTE_CONNINFO_UPDATED;
+ }
}
if ((ev_hint & SO_FILT_HINT_NOTIFY_ACK) ||
level_trigger &= EVFILT_SOCK_LEVEL_TRIGGER_MASK;
/* Do not deliver level triggerred events more than once */
- if ((kn->kn_fflags & ~level_trigger) != 0)
+ if ((kn->kn_fflags & ~level_trigger) != 0) {
ret = 1;
+ }
- return (ret);
+ return ret;
}
static int
/* socket locked */
kn->kn_hookid = 0;
- if (KNOTE_ATTACH(&so->so_klist, kn))
+ if (KNOTE_ATTACH(&so->so_klist, kn)) {
so->so_flags |= SOF_KNOTE;
+ }
/* determine if event already fired */
return filt_sockev_common(kn, so, 0);
struct socket *so = (struct socket *)kn->kn_fp->f_fglob->fg_data;
socket_lock(so, 1);
- if ((so->so_flags & SOF_KNOTE) != 0)
- if (KNOTE_DETACH(&so->so_klist, kn))
+ if ((so->so_flags & SOF_KNOTE) != 0) {
+ if (KNOTE_DETACH(&so->so_klist, kn)) {
so->so_flags &= ~SOF_KNOTE;
+ }
+ }
socket_unlock(so, 1);
}
ret = filt_sockev_common(kn, so, ev_hint);
- if (locked)
+ if (locked) {
socket_unlock(so, 1);
+ }
return ret;
}
* ateast once and still avoid waking up the application
* multiple times as long as the event is active.
*/
- if (kn->kn_fflags != 0)
+ if (kn->kn_fflags != 0) {
kn->kn_hookid |= (kn->kn_fflags &
- EVFILT_SOCK_LEVEL_TRIGGER_MASK);
+ EVFILT_SOCK_LEVEL_TRIGGER_MASK);
+ }
/*
* NOTE_RESUME and NOTE_SUSPEND are an exception, deliver
* only one of them and remember the last one that was
* delivered last
*/
- if (kn->kn_fflags & NOTE_SUSPEND)
+ if (kn->kn_fflags & NOTE_SUSPEND) {
kn->kn_hookid &= ~NOTE_RESUME;
- if (kn->kn_fflags & NOTE_RESUME)
+ }
+ if (kn->kn_fflags & NOTE_RESUME) {
kn->kn_hookid &= ~NOTE_SUSPEND;
+ }
if (kn->kn_flags & EV_CLEAR) {
kn->kn_data = 0;
* If the state variable is already used by a previous event,
* reset it.
*/
- if (state != 0)
+ if (state != 0) {
return;
+ }
- if (so->so_state & SS_ISCONNECTED)
+ if (so->so_state & SS_ISCONNECTED) {
state |= SOCKEV_CONNECTED;
- else
+ } else {
state &= ~(SOCKEV_CONNECTED);
+ }
state |= ((so->so_state & SS_ISDISCONNECTED) ? SOCKEV_DISCONNECTED : 0);
*(statep) = state;
}
-#define SO_LOCK_HISTORY_STR_LEN \
+#define SO_LOCK_HISTORY_STR_LEN \
(2 * SO_LCKDBG_MAX * (2 + (2 * sizeof (void *)) + 1) + 1)
__private_extern__ const char *
int i;
static char lock_history_str[SO_LOCK_HISTORY_STR_LEN];
- bzero(lock_history_str, sizeof (lock_history_str));
+ bzero(lock_history_str, sizeof(lock_history_str));
for (i = SO_LCKDBG_MAX - 1; i >= 0; i--) {
n += snprintf(lock_history_str + n,
SO_LOCK_HISTORY_STR_LEN - n, "%p:%p ",
so->lock_lr[(so->next_lock_lr + i) % SO_LCKDBG_MAX],
so->unlock_lr[(so->next_unlock_lr + i) % SO_LCKDBG_MAX]);
}
- return (lock_history_str);
+ return lock_history_str;
}
void
LCK_MTX_ASSERT_NOTOWNED);
#endif
lck_mtx_lock(so->so_proto->pr_domain->dom_mtx);
- if (refcount)
+ if (refcount) {
so->so_usecount++;
+ }
so->lock_lr[so->next_lock_lr] = lr_saved;
- so->next_lock_lr = (so->next_lock_lr+1) % SO_LCKDBG_MAX;
+ so->next_lock_lr = (so->next_lock_lr + 1) % SO_LCKDBG_MAX;
}
}
{
lck_mtx_t *mutex_held;
- if (so->so_proto->pr_getlock != NULL)
+ if (so->so_proto->pr_getlock != NULL) {
mutex_held = (*so->so_proto->pr_getlock)(so, 0);
- else
+ } else {
mutex_held = so->so_proto->pr_domain->dom_mtx;
+ }
LCK_MTX_ASSERT(mutex_held, LCK_MTX_ASSERT_OWNED);
}
{
lck_mtx_t *mtx;
- if (so->so_proto->pr_getlock != NULL)
+ if (so->so_proto->pr_getlock != NULL) {
mtx = (*so->so_proto->pr_getlock)(so, 0);
- else
+ } else {
mtx = so->so_proto->pr_domain->dom_mtx;
+ }
- return (lck_mtx_try_lock(mtx));
+ return lck_mtx_try_lock(mtx);
}
void
LCK_MTX_ASSERT(mutex_held, LCK_MTX_ASSERT_OWNED);
#endif
so->unlock_lr[so->next_unlock_lr] = lr_saved;
- so->next_unlock_lr = (so->next_unlock_lr+1) % SO_LCKDBG_MAX;
+ so->next_unlock_lr = (so->next_unlock_lr + 1) % SO_LCKDBG_MAX;
if (refcount) {
if (so->so_usecount <= 0) {
}
so->so_usecount--;
- if (so->so_usecount == 0)
+ if (so->so_usecount == 0) {
sofreelastref(so, 1);
+ }
}
lck_mtx_unlock(mutex_held);
}
{
lck_mtx_t *mutex_held;
- if (so->so_proto->pr_getlock != NULL)
+ if (so->so_proto->pr_getlock != NULL) {
mutex_held = (*so->so_proto->pr_getlock)(so, 0);
- else
+ } else {
mutex_held = so->so_proto->pr_domain->dom_mtx;
+ }
LCK_MTX_ASSERT(mutex_held, LCK_MTX_ASSERT_OWNED);
sofreelastref(so, 0);
void
soreference(struct socket *so)
{
- socket_lock(so, 1); /* locks & take one reference on socket */
- socket_unlock(so, 0); /* unlock only */
+ socket_lock(so, 1); /* locks & take one reference on socket */
+ socket_unlock(so, 0); /* unlock only */
}
void
void
somultipages(struct socket *so, boolean_t set)
{
- if (set)
+ if (set) {
so->so_flags |= SOF_MULTIPAGES;
- else
+ } else {
so->so_flags &= ~SOF_MULTIPAGES;
+ }
}
void
soif2kcl(struct socket *so, boolean_t set)
{
- if (set)
+ if (set) {
so->so_flags1 |= SOF1_IF_2KCL;
- else
+ } else {
so->so_flags1 &= ~SOF1_IF_2KCL;
+ }
}
int
-so_isdstlocal(struct socket *so) {
-
+so_isdstlocal(struct socket *so)
+{
struct inpcb *inp = (struct inpcb *)so->so_pcb;
- if (SOCK_DOM(so) == PF_INET)
- return (inaddr_local(inp->inp_faddr));
- else if (SOCK_DOM(so) == PF_INET6)
- return (in6addr_local(&inp->in6p_faddr));
+ if (SOCK_DOM(so) == PF_INET) {
+ return inaddr_local(inp->inp_faddr);
+ } else if (SOCK_DOM(so) == PF_INET6) {
+ return in6addr_local(&inp->in6p_faddr);
+ }
- return (0);
+ return 0;
}
int
(uint64_t)DEBUG_KERNEL_ADDRPERM(so),
SOCK_DOM(so), SOCK_TYPE(so), err);
}
- return (err);
+ return err;
}
so->so_flags &= ~SOF_NODEFUNCT;
if (p != PROC_NULL) {
proc_best_name(p), level,
(uint64_t)DEBUG_KERNEL_ADDRPERM(so),
SOCK_DOM(so), SOCK_TYPE(so), err);
- return (err);
+ return err;
} else {
OSIncrementAtomic(&soextbkidlestat.so_xbkidle_forced);
}
(so->so_flags1 & SOF1_EXTEND_BK_IDLE_WANTED) ?
" extbkidle" : "");
}
- return (err);
+ return err;
}
int
panic("%s improperly called", __func__);
/* NOTREACHED */
}
- if (so->so_state & SS_DEFUNCT)
+ if (so->so_state & SS_DEFUNCT) {
goto done;
+ }
rcv = &so->so_rcv;
snd = &so->so_snd;
if (p != PROC_NULL) {
SODEFUNCTLOG(
- "%s[%d, %s]: (target pid %d name %s level %d) "
- "so 0x%llx [%s %s:%d -> %s:%d] is now defunct "
- "[rcv_si 0x%x, snd_si 0x%x, rcv_fl 0x%x, "
- " snd_fl 0x%x]\n", __func__,
- proc_selfpid(), proc_best_name(current_proc()),
- proc_pid(p), proc_best_name(p), level,
- (uint64_t)DEBUG_KERNEL_ADDRPERM(so),
- (SOCK_TYPE(so) == SOCK_STREAM) ? "TCP" : "UDP",
- inet_ntop(SOCK_DOM(so), ((SOCK_DOM(so) == PF_INET) ?
- (void *)&inp->inp_laddr.s_addr :
- (void *)&inp->in6p_laddr),
- s, sizeof (s)), ntohs(inp->in6p_lport),
- inet_ntop(SOCK_DOM(so), (SOCK_DOM(so) == PF_INET) ?
- (void *)&inp->inp_faddr.s_addr :
- (void *)&inp->in6p_faddr,
- d, sizeof (d)), ntohs(inp->in6p_fport),
- (uint32_t)rcv->sb_sel.si_flags,
- (uint32_t)snd->sb_sel.si_flags,
- rcv->sb_flags, snd->sb_flags);
- }
- } else if (p != PROC_NULL) {
+ "%s[%d, %s]: (target pid %d name %s level %d) "
+ "so 0x%llx [%s %s:%d -> %s:%d] is now defunct "
+ "[rcv_si 0x%x, snd_si 0x%x, rcv_fl 0x%x, "
+ " snd_fl 0x%x]\n", __func__,
+ proc_selfpid(), proc_best_name(current_proc()),
+ proc_pid(p), proc_best_name(p), level,
+ (uint64_t)DEBUG_KERNEL_ADDRPERM(so),
+ (SOCK_TYPE(so) == SOCK_STREAM) ? "TCP" : "UDP",
+ inet_ntop(SOCK_DOM(so), ((SOCK_DOM(so) == PF_INET) ?
+ (void *)&inp->inp_laddr.s_addr :
+ (void *)&inp->in6p_laddr),
+ s, sizeof(s)), ntohs(inp->in6p_lport),
+ inet_ntop(SOCK_DOM(so), (SOCK_DOM(so) == PF_INET) ?
+ (void *)&inp->inp_faddr.s_addr :
+ (void *)&inp->in6p_faddr,
+ d, sizeof(d)), ntohs(inp->in6p_fport),
+ (uint32_t)rcv->sb_sel.si_flags,
+ (uint32_t)snd->sb_sel.si_flags,
+ rcv->sb_flags, snd->sb_flags);
+ }
+ } else if (p != PROC_NULL) {
SODEFUNCTLOG("%s[%d, %s]: (target pid %d name %s level %d) "
"so 0x%llx [%d,%d] is now defunct [rcv_si 0x%x, "
"snd_si 0x%x, rcv_fl 0x%x, snd_fl 0x%x]\n", __func__,
sbwakeup(snd);
so->so_flags1 |= SOF1_DEFUNCTINPROG;
- if (rcv->sb_flags & SB_LOCK)
- sbunlock(rcv, TRUE); /* keep socket locked */
- if (snd->sb_flags & SB_LOCK)
- sbunlock(snd, TRUE); /* keep socket locked */
-
+ if (rcv->sb_flags & SB_LOCK) {
+ sbunlock(rcv, TRUE); /* keep socket locked */
+ }
+ if (snd->sb_flags & SB_LOCK) {
+ sbunlock(snd, TRUE); /* keep socket locked */
+ }
/*
* Flush the buffers and disconnect. We explicitly call shutdown
* on both data directions to ensure that SS_CANT{RCV,SEND}MORE
* Explicitly handle connectionless-protocol disconnection
* and release any remaining data in the socket buffers.
*/
- if (!(so->so_state & SS_ISDISCONNECTED))
+ if (!(so->so_state & SS_ISDISCONNECTED)) {
(void) soisdisconnected(so);
+ }
- if (so->so_error == 0)
+ if (so->so_error == 0) {
so->so_error = EBADF;
+ }
if (rcv->sb_cc != 0) {
rcv->sb_flags &= ~SB_SEL;
OSIncrementAtomicLong((volatile long *)&sodefunct_calls);
done:
- return (0);
+ return 0;
}
int
soresume(struct proc *p, struct socket *so, int locked)
{
- if (locked == 0)
+ if (locked == 0) {
socket_lock(so, 1);
+ }
if (so->so_flags1 & SOF1_EXTEND_BK_IDLE_INPROG) {
SODEFUNCTLOG("%s[%d, %s]: (target pid %d name %s) so 0x%llx "
OSDecrementAtomic(&soextbkidlestat.so_xbkidle_active);
VERIFY(soextbkidlestat.so_xbkidle_active >= 0);
}
- if (locked == 0)
+ if (locked == 0) {
socket_unlock(so, 1);
+ }
- return (0);
+ return 0;
}
/*
/*
* Unlock socket to avoid lock ordering issue with
* the proc fd table lock
- */
+ */
socket_unlock(so, 0);
proc_fdlock(p);
if (fp == NULL ||
(fdp->fd_ofileflags[i] & UF_RESERVED) != 0 ||
- FILEGLOB_DTYPE(fp->f_fglob) != DTYPE_SOCKET)
+ FILEGLOB_DTYPE(fp->f_fglob) != DTYPE_SOCKET) {
continue;
+ }
so2 = (struct socket *)fp->f_fglob->fg_data;
if (so != so2 &&
- so2->so_flags1 & SOF1_EXTEND_BK_IDLE_WANTED)
+ so2->so_flags1 & SOF1_EXTEND_BK_IDLE_WANTED) {
count++;
- if (count >= soextbkidlestat.so_xbkidle_maxperproc)
+ }
+ if (count >= soextbkidlestat.so_xbkidle_maxperproc) {
break;
+ }
}
proc_fdunlock(p);
"is" : "not");
}
- return (error);
+ return error;
}
static void
}
}
- return (ret);
+ return ret;
}
void
resume_proc_sockets(proc_t p)
{
if (p->p_ladvflag & P_LXBKIDLEINPROG) {
- struct filedesc *fdp;
+ struct filedesc *fdp;
int i;
proc_fdlock(p);
fdp = p->p_fd;
for (i = 0; i < fdp->fd_nfiles; i++) {
- struct fileproc *fp;
+ struct fileproc *fp;
struct socket *so;
fp = fdp->fd_ofiles[i];
if (fp == NULL ||
(fdp->fd_ofileflags[i] & UF_RESERVED) != 0 ||
- FILEGLOB_DTYPE(fp->f_fglob) != DTYPE_SOCKET)
+ FILEGLOB_DTYPE(fp->f_fglob) != DTYPE_SOCKET) {
continue;
+ }
so = (struct socket *)fp->f_fglob->fg_data;
(void) soresume(p, so, 0);
#else
if (SOCK_DOM(so) == PF_INET) {
#endif /* !INET6 */
- if (optval)
+ if (optval) {
sotoinpcb(so)->inp_flags |= INP_RECV_ANYIF;
- else
+ } else {
sotoinpcb(so)->inp_flags &= ~INP_RECV_ANYIF;
+ }
}
- return (ret);
+ return ret;
}
__private_extern__ int
ret = (sotoinpcb(so)->inp_flags & INP_RECV_ANYIF) ? 1 : 0;
}
- return (ret);
+ return ret;
}
int
/* we can only set, not clear restrictions */
if ((nocell_new - nocell_old) == 0 &&
- (noexpensive_new - noexpensive_old) == 0)
- return (0);
+ (noexpensive_new - noexpensive_old) == 0) {
+ return 0;
+ }
#if INET6
if (SOCK_DOM(so) == PF_INET || SOCK_DOM(so) == PF_INET6) {
#else
}
}
- if (SOCK_DOM(so) == PF_MULTIPATH)
+ if (SOCK_DOM(so) == PF_MULTIPATH) {
mptcp_set_restrictions(so);
+ }
- return (0);
+ return 0;
}
uint32_t
so_get_restrictions(struct socket *so)
{
- return (so->so_restrictions & (SO_RESTRICT_DENY_IN |
- SO_RESTRICT_DENY_OUT |
- SO_RESTRICT_DENY_CELLULAR | SO_RESTRICT_DENY_EXPENSIVE));
+ return so->so_restrictions & (SO_RESTRICT_DENY_IN |
+ SO_RESTRICT_DENY_OUT |
+ SO_RESTRICT_DENY_CELLULAR | SO_RESTRICT_DENY_EXPENSIVE);
}
int
so->so_flags |= SOF_DELEGATED;
so->e_upid = proc_uniqueid(ep);
so->e_pid = proc_pid(ep);
- proc_getexecutableuuid(ep, so->e_uuid, sizeof (so->e_uuid));
+ proc_getexecutableuuid(ep, so->e_uuid, sizeof(so->e_uuid));
}
done:
if (error == 0 && net_io_policy_log) {
#endif /* NECP */
}
- if (ep != PROC_NULL)
+ if (ep != PROC_NULL) {
proc_rele(ep);
+ }
- return (error);
+ return error;
}
int
}
/* Get the UUID of the issuing process */
- proc_getexecutableuuid(p, uuid, sizeof (uuid));
+ proc_getexecutableuuid(p, uuid, sizeof(uuid));
/*
* If this is issued by a process that's recorded as the
#endif /* NECP */
}
- return (error);
+ return error;
}
void
* structure, but the caller can provide for a longer event
* structure to post, depending on the event code.
*/
- VERIFY(ev_data != NULL && ev_datalen >= sizeof (*ev_data));
+ VERIFY(ev_data != NULL && ev_datalen >= sizeof(*ev_data));
- bzero(&ev_msg, sizeof (ev_msg));
- ev_msg.vendor_code = KEV_VENDOR_APPLE;
- ev_msg.kev_class = KEV_NETWORK_CLASS;
- ev_msg.kev_subclass = KEV_NETPOLICY_SUBCLASS;
- ev_msg.event_code = ev_code;
+ bzero(&ev_msg, sizeof(ev_msg));
+ ev_msg.vendor_code = KEV_VENDOR_APPLE;
+ ev_msg.kev_class = KEV_NETWORK_CLASS;
+ ev_msg.kev_subclass = KEV_NETPOLICY_SUBCLASS;
+ ev_msg.event_code = ev_code;
- ev_msg.dv[0].data_ptr = ev_data;
+ ev_msg.dv[0].data_ptr = ev_data;
ev_msg.dv[0].data_length = ev_datalen;
kev_post_msg(&ev_msg);
ev_msg.event_code = ev_code;
ev_msg.dv[0].data_ptr = ev_data;
- ev_msg.dv[0]. data_length = ev_datalen;
+ ev_msg.dv[0].data_length = ev_datalen;
kev_post_msg(&ev_msg);
}
if (err == 0) {
memcpy(&ev.ev_data.kev_sockname, socksa,
min(socksa->sa_len,
- sizeof (ev.ev_data.kev_sockname)));
+ sizeof(ev.ev_data.kev_sockname)));
memcpy(&ev.ev_data.kev_peername, peersa,
min(peersa->sa_len,
- sizeof (ev.ev_data.kev_peername)));
+ sizeof(ev.ev_data.kev_peername)));
socket_post_kev_msg(KEV_SOCKET_CLOSED,
- &ev.ev_data, sizeof (ev));
+ &ev.ev_data, sizeof(ev));
}
}
- if (socksa != NULL)
+ if (socksa != NULL) {
FREE(socksa, M_SONAME);
- if (peersa != NULL)
+ }
+ if (peersa != NULL) {
FREE(peersa, M_SONAME);
+ }
}
projects / apple / xnu.git / blobdiff