tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 1 | /*- |
| 2 | * Copyright (c) 1982, 1986, 1988, 1990, 1993 |
| 3 | * The Regents of the University of California. |
| 4 | * Copyright (c) 2004 The FreeBSD Foundation |
| 5 | * Copyright (c) 2004-2008 Robert N. M. Watson |
tuexen | 829d1a7 | 2012-05-23 09:39:05 +0000 | [diff] [blame] | 6 | * Copyright (c) 2009-2010 Brad Penoff |
| 7 | * Copyright (c) 2009-2010 Humaira Kamal |
| 8 | * Copyright (c) 2011-2012 Irene Ruengeler |
| 9 | * Copyright (c) 2011-2012 Michael Tuexen |
tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 10 | * All rights reserved. |
| 11 | * |
| 12 | * Redistribution and use in source and binary forms, with or without |
| 13 | * modification, are permitted provided that the following conditions |
| 14 | * are met: |
| 15 | * 1. Redistributions of source code must retain the above copyright |
| 16 | * notice, this list of conditions and the following disclaimer. |
| 17 | * 2. Redistributions in binary form must reproduce the above copyright |
| 18 | * notice, this list of conditions and the following disclaimer in the |
| 19 | * documentation and/or other materials provided with the distribution. |
| 20 | * |
| 21 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
| 22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
| 25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 31 | * SUCH DAMAGE. |
| 32 | * |
| 33 | */ |
| 34 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 35 | #include <netinet/sctp_os.h> |
| 36 | #include <netinet/sctp_pcb.h> |
| 37 | #include <netinet/sctputil.h> |
tuexen | 8ce022e | 2012-01-19 22:47:44 +0000 | [diff] [blame] | 38 | #include <netinet/sctp_var.h> |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 39 | #include <netinet/sctp_sysctl.h> |
tuexen | bbdbb60 | 2012-07-07 20:54:13 +0000 | [diff] [blame] | 40 | #include <netinet/sctp_input.h> |
t00fcxen | 56c7d1c | 2012-11-25 14:36:23 +0000 | [diff] [blame] | 41 | #include <netinet/sctp_peeloff.h> |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 42 | #ifdef INET6 |
| 43 | #include <netinet6/sctp6_var.h> |
| 44 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 45 | #if defined(__Userspace_os_Linux) |
| 46 | #define __FAVOR_BSD /* (on Ubuntu at least) enables UDP header field names like BSD in RFC 768 */ |
| 47 | #endif |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 48 | #if !defined (__Userspace_os_Windows) |
t00fcxen | 6c632b3 | 2014-06-30 20:55:44 +0000 | [diff] [blame] | 49 | #if defined INET || defined INET6 |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 50 | #include <netinet/udp.h> |
t00fcxen | 6c632b3 | 2014-06-30 20:55:44 +0000 | [diff] [blame] | 51 | #endif |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 52 | #include <arpa/inet.h> |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 53 | #else |
| 54 | #include <user_socketvar.h> |
t00fcxen | 6afa8ee | 2013-11-30 09:04:47 +0000 | [diff] [blame] | 55 | #endif |
iruengeler | a4442f3 | 2012-09-12 14:19:25 +0000 | [diff] [blame] | 56 | userland_mutex_t accept_mtx; |
| 57 | userland_cond_t accept_cond; |
t00fcxen | 47948bc | 2012-12-26 19:39:07 +0000 | [diff] [blame] | 58 | #ifdef _WIN32 |
t00fcxen | 95eb2c4 | 2012-12-26 20:22:53 +0000 | [diff] [blame] | 59 | #include <time.h> |
t00fcxen | 47948bc | 2012-12-26 19:39:07 +0000 | [diff] [blame] | 60 | #include <sys/timeb.h> |
| 61 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 62 | |
tuexen | f785039 | 2011-11-03 08:46:42 +0000 | [diff] [blame] | 63 | MALLOC_DEFINE(M_PCB, "sctp_pcb", "sctp pcb"); |
| 64 | MALLOC_DEFINE(M_SONAME, "sctp_soname", "sctp soname"); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 65 | #define MAXLEN_MBUF_CHAIN 32 |
tuexen | f785039 | 2011-11-03 08:46:42 +0000 | [diff] [blame] | 66 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 67 | /* Prototypes */ |
| 68 | extern int sctp_sosend(struct socket *so, struct sockaddr *addr, struct uio *uio, |
| 69 | struct mbuf *top, struct mbuf *control, int flags, |
| 70 | /* proc is a dummy in __Userspace__ and will not be passed to sctp_lower_sosend */ struct proc *p); |
| 71 | |
| 72 | extern int sctp_attach(struct socket *so, int proto, uint32_t vrf_id); |
tuexen | bbdbb60 | 2012-07-07 20:54:13 +0000 | [diff] [blame] | 73 | extern int sctpconn_attach(struct socket *so, int proto, uint32_t vrf_id); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 74 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 75 | void |
tuexen | de2407b | 2012-07-06 20:00:32 +0000 | [diff] [blame] | 76 | usrsctp_init(uint16_t port, |
t00fcxen | e6b8257 | 2013-01-19 17:56:54 +0000 | [diff] [blame] | 77 | int (*conn_output)(void *addr, void *buffer, size_t length, uint8_t tos, uint8_t set_df), |
| 78 | void (*debug_printf)(const char *format, ...)) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 79 | { |
t00fcxen | e6b8257 | 2013-01-19 17:56:54 +0000 | [diff] [blame] | 80 | sctp_init(port, conn_output, debug_printf); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 81 | } |
| 82 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 83 | |
| 84 | /* Taken from usr/src/sys/kern/uipc_sockbuf.c and modified for __Userspace__*/ |
| 85 | /* |
| 86 | * Socantsendmore indicates that no more data will be sent on the socket; it |
| 87 | * would normally be applied to a socket when the user informs the system |
| 88 | * that no more data is to be sent, by the protocol code (in case |
| 89 | * PRU_SHUTDOWN). Socantrcvmore indicates that no more data will be |
| 90 | * received, and will normally be applied to the socket by a protocol when it |
| 91 | * detects that the peer will send no more data. Data queued for reading in |
| 92 | * the socket may yet be read. |
| 93 | */ |
| 94 | |
| 95 | void socantrcvmore_locked(struct socket *so) |
| 96 | { |
| 97 | SOCKBUF_LOCK_ASSERT(&so->so_rcv); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 98 | so->so_rcv.sb_state |= SBS_CANTRCVMORE; |
| 99 | sorwakeup_locked(so); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | void socantrcvmore(struct socket *so) |
| 103 | { |
| 104 | SOCKBUF_LOCK(&so->so_rcv); |
| 105 | socantrcvmore_locked(so); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 106 | } |
| 107 | |
| 108 | void |
| 109 | socantsendmore_locked(struct socket *so) |
| 110 | { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 111 | SOCKBUF_LOCK_ASSERT(&so->so_snd); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 112 | so->so_snd.sb_state |= SBS_CANTSENDMORE; |
| 113 | sowwakeup_locked(so); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | void |
| 117 | socantsendmore(struct socket *so) |
| 118 | { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 119 | SOCKBUF_LOCK(&so->so_snd); |
| 120 | socantsendmore_locked(so); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 121 | } |
| 122 | |
| 123 | |
| 124 | |
tuexen | 45c7f50 | 2011-11-18 09:04:46 +0000 | [diff] [blame] | 125 | /* Taken from usr/src/sys/kern/uipc_sockbuf.c and called within sctp_lower_sosend. |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 126 | */ |
| 127 | int |
| 128 | sbwait(struct sockbuf *sb) |
| 129 | { |
| 130 | #if defined(__Userspace__) /* __Userspace__ */ |
| 131 | |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 132 | SOCKBUF_LOCK_ASSERT(sb); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 133 | |
| 134 | sb->sb_flags |= SB_WAIT; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 135 | #if defined (__Userspace_os_Windows) |
| 136 | if (SleepConditionVariableCS(&(sb->sb_cond), &(sb->sb_mtx), INFINITE)) |
| 137 | return 0; |
| 138 | else |
| 139 | return -1; |
| 140 | #else |
| 141 | return (pthread_cond_wait(&(sb->sb_cond), &(sb->sb_mtx))); |
| 142 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 143 | |
| 144 | #else |
| 145 | SOCKBUF_LOCK_ASSERT(sb); |
| 146 | |
| 147 | sb->sb_flags |= SB_WAIT; |
| 148 | return (msleep(&sb->sb_cc, &sb->sb_mtx, |
| 149 | (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, "sbwait", |
| 150 | sb->sb_timeo)); |
| 151 | #endif |
| 152 | } |
| 153 | |
| 154 | |
| 155 | |
| 156 | |
| 157 | /* Taken from /src/sys/kern/uipc_socket.c |
| 158 | * and modified for __Userspace__ |
| 159 | */ |
| 160 | static struct socket * |
| 161 | soalloc(void) |
| 162 | { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 163 | struct socket *so; |
| 164 | |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 165 | /* |
| 166 | * soalloc() sets of socket layer state for a socket, |
| 167 | * called only by socreate() and sonewconn(). |
| 168 | * |
| 169 | * sodealloc() tears down socket layer state for a socket, |
| 170 | * called only by sofree() and sonewconn(). |
| 171 | * __Userspace__ TODO : Make sure so is properly deallocated |
| 172 | * when tearing down the connection. |
| 173 | */ |
| 174 | |
| 175 | so = (struct socket *)malloc(sizeof(struct socket)); |
| 176 | |
t00fcxen | 1584d52 | 2013-11-03 01:03:41 +0000 | [diff] [blame] | 177 | if (so == NULL) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 178 | return (NULL); |
t00fcxen | 1584d52 | 2013-11-03 01:03:41 +0000 | [diff] [blame] | 179 | } |
| 180 | memset(so, 0, sizeof(struct socket)); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 181 | |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 182 | /* __Userspace__ Initializing the socket locks here */ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 183 | SOCKBUF_LOCK_INIT(&so->so_snd, "so_snd"); |
| 184 | SOCKBUF_LOCK_INIT(&so->so_rcv, "so_rcv"); |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 185 | SOCKBUF_COND_INIT(&so->so_snd); |
| 186 | SOCKBUF_COND_INIT(&so->so_rcv); |
| 187 | SOCK_COND_INIT(so); /* timeo_cond */ |
| 188 | |
| 189 | /* __Userspace__ Any ref counting required here? Will we have any use for aiojobq? |
| 190 | What about gencnt and numopensockets?*/ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 191 | TAILQ_INIT(&so->so_aiojobq); |
| 192 | return (so); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 193 | } |
| 194 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 195 | static void |
| 196 | sodealloc(struct socket *so) |
| 197 | { |
| 198 | |
tuexen | c710843 | 2012-05-21 18:53:50 +0000 | [diff] [blame] | 199 | KASSERT(so->so_count == 0, ("sodealloc(): so_count %d", so->so_count)); |
| 200 | KASSERT(so->so_pcb == NULL, ("sodealloc(): so_pcb != NULL")); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 201 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 202 | SOCKBUF_COND_DESTROY(&so->so_snd); |
| 203 | SOCKBUF_COND_DESTROY(&so->so_rcv); |
| 204 | |
t00fcxen | 1584d52 | 2013-11-03 01:03:41 +0000 | [diff] [blame] | 205 | SOCK_COND_DESTROY(so); |
| 206 | |
| 207 | SOCKBUF_LOCK_DESTROY(&so->so_snd); |
| 208 | SOCKBUF_LOCK_DESTROY(&so->so_rcv); |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 209 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 210 | free(so); |
| 211 | } |
| 212 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 213 | /* Taken from /src/sys/kern/uipc_socket.c |
| 214 | * and modified for __Userspace__ |
| 215 | */ |
| 216 | void |
| 217 | sofree(struct socket *so) |
| 218 | { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 219 | struct socket *head; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 220 | |
| 221 | ACCEPT_LOCK_ASSERT(); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 222 | SOCK_LOCK_ASSERT(so); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 223 | /* SS_NOFDREF unset in accept call. this condition seems irrelevent |
| 224 | * for __Userspace__... |
| 225 | */ |
| 226 | if (so->so_count != 0 || |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 227 | (so->so_state & SS_PROTOREF) || (so->so_qstate & SQ_COMP)) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 228 | SOCK_UNLOCK(so); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 229 | ACCEPT_UNLOCK(); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 230 | return; |
| 231 | } |
| 232 | head = so->so_head; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 233 | if (head != NULL) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 234 | KASSERT((so->so_qstate & SQ_COMP) != 0 || |
| 235 | (so->so_qstate & SQ_INCOMP) != 0, |
| 236 | ("sofree: so_head != NULL, but neither SQ_COMP nor " |
| 237 | "SQ_INCOMP")); |
| 238 | KASSERT((so->so_qstate & SQ_COMP) == 0 || |
| 239 | (so->so_qstate & SQ_INCOMP) == 0, |
| 240 | ("sofree: so->so_qstate is SQ_COMP and also SQ_INCOMP")); |
| 241 | TAILQ_REMOVE(&head->so_incomp, so, so_list); |
| 242 | head->so_incqlen--; |
| 243 | so->so_qstate &= ~SQ_INCOMP; |
| 244 | so->so_head = NULL; |
| 245 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 246 | KASSERT((so->so_qstate & SQ_COMP) == 0 && |
| 247 | (so->so_qstate & SQ_INCOMP) == 0, |
| 248 | ("sofree: so_head == NULL, but still SQ_COMP(%d) or SQ_INCOMP(%d)", |
| 249 | so->so_qstate & SQ_COMP, so->so_qstate & SQ_INCOMP)); |
t00fcxen | 907b9e7 | 2012-09-03 16:20:51 +0000 | [diff] [blame] | 250 | if (so->so_options & SCTP_SO_ACCEPTCONN) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 251 | KASSERT((TAILQ_EMPTY(&so->so_comp)), ("sofree: so_comp populated")); |
| 252 | KASSERT((TAILQ_EMPTY(&so->so_incomp)), ("sofree: so_comp populated")); |
| 253 | } |
| 254 | SOCK_UNLOCK(so); |
| 255 | ACCEPT_UNLOCK(); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 256 | sctp_close(so); /* was... sctp_detach(so); */ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 257 | /* |
| 258 | * From this point on, we assume that no other references to this |
| 259 | * socket exist anywhere else in the stack. Therefore, no locks need |
| 260 | * to be acquired or held. |
| 261 | * |
| 262 | * We used to do a lot of socket buffer and socket locking here, as |
| 263 | * well as invoke sorflush() and perform wakeups. The direct call to |
| 264 | * dom_dispose() and sbrelease_internal() are an inlining of what was |
| 265 | * necessary from sorflush(). |
| 266 | * |
| 267 | * Notice that the socket buffer and kqueue state are torn down |
| 268 | * before calling pru_detach. This means that protocols shold not |
| 269 | * assume they can perform socket wakeups, etc, in their detach code. |
| 270 | */ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 271 | sodealloc(so); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 272 | } |
| 273 | |
| 274 | |
| 275 | |
| 276 | /* Taken from /src/sys/kern/uipc_socket.c */ |
| 277 | int |
| 278 | soabort(so) |
| 279 | struct socket *so; |
| 280 | { |
| 281 | int error; |
t00fcxen | 5d7df6a | 2013-10-31 13:22:14 +0000 | [diff] [blame] | 282 | #if defined(INET6) |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 283 | struct sctp_inpcb *inp; |
t00fcxen | 5d7df6a | 2013-10-31 13:22:14 +0000 | [diff] [blame] | 284 | #endif |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 285 | |
| 286 | #if defined(INET6) |
t00fcxen | 5d7df6a | 2013-10-31 13:22:14 +0000 | [diff] [blame] | 287 | inp = (struct sctp_inpcb *)so->so_pcb; |
| 288 | if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) { |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 289 | error = sctp6_abort(so); |
t00fcxen | 5d7df6a | 2013-10-31 13:22:14 +0000 | [diff] [blame] | 290 | } else { |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 291 | #if defined(INET) |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 292 | error = sctp_abort(so); |
t00fcxen | 5d7df6a | 2013-10-31 13:22:14 +0000 | [diff] [blame] | 293 | #else |
| 294 | error = EAFNOSUPPORT; |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 295 | #endif |
t00fcxen | 478069f | 2013-10-31 14:10:07 +0000 | [diff] [blame] | 296 | } |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 297 | #elif defined(INET) |
| 298 | error = sctp_abort(so); |
| 299 | #else |
| 300 | error = EAFNOSUPPORT; |
| 301 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 302 | if (error) { |
| 303 | sofree(so); |
| 304 | return error; |
| 305 | } |
| 306 | return (0); |
| 307 | } |
| 308 | |
| 309 | |
| 310 | /* Taken from usr/src/sys/kern/uipc_socket.c and called within sctp_connect (sctp_usrreq.c). |
| 311 | * We use sctp_connect for send_one_init_real in ms1. |
| 312 | */ |
| 313 | void |
| 314 | soisconnecting(struct socket *so) |
| 315 | { |
| 316 | |
| 317 | SOCK_LOCK(so); |
| 318 | so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING); |
| 319 | so->so_state |= SS_ISCONNECTING; |
| 320 | SOCK_UNLOCK(so); |
| 321 | } |
| 322 | |
| 323 | /* Taken from usr/src/sys/kern/uipc_socket.c and called within sctp_disconnect (sctp_usrreq.c). |
| 324 | * TODO Do we use sctp_disconnect? |
| 325 | */ |
| 326 | void |
| 327 | soisdisconnecting(struct socket *so) |
| 328 | { |
| 329 | |
| 330 | /* |
| 331 | * Note: This code assumes that SOCK_LOCK(so) and |
| 332 | * SOCKBUF_LOCK(&so->so_rcv) are the same. |
| 333 | */ |
| 334 | SOCKBUF_LOCK(&so->so_rcv); |
| 335 | so->so_state &= ~SS_ISCONNECTING; |
| 336 | so->so_state |= SS_ISDISCONNECTING; |
| 337 | so->so_rcv.sb_state |= SBS_CANTRCVMORE; |
| 338 | sorwakeup_locked(so); |
| 339 | SOCKBUF_LOCK(&so->so_snd); |
| 340 | so->so_snd.sb_state |= SBS_CANTSENDMORE; |
| 341 | sowwakeup_locked(so); |
| 342 | wakeup("dummy",so); |
tuexen | 2418516 | 2012-08-16 07:32:27 +0000 | [diff] [blame] | 343 | /* requires 2 args but this was in orig */ |
| 344 | /* wakeup(&so->so_timeo); */ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 345 | } |
| 346 | |
| 347 | |
| 348 | /* Taken from sys/kern/kern_synch.c and |
| 349 | modified for __Userspace__ |
| 350 | */ |
| 351 | |
| 352 | /* |
| 353 | * Make all threads sleeping on the specified identifier runnable. |
| 354 | * Associating wakeup with so_timeo identifier and timeo_cond |
| 355 | * condition variable. TODO. If we use iterator thread then we need to |
| 356 | * modify wakeup so it can distinguish between iterator identifier and |
| 357 | * timeo identifier. |
| 358 | */ |
| 359 | void |
| 360 | wakeup(ident, so) |
| 361 | void *ident; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 362 | struct socket *so; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 363 | { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 364 | SOCK_LOCK(so); |
| 365 | #if defined (__Userspace_os_Windows) |
| 366 | WakeAllConditionVariable(&(so)->timeo_cond); |
| 367 | #else |
| 368 | pthread_cond_broadcast(&(so)->timeo_cond); |
| 369 | #endif |
| 370 | SOCK_UNLOCK(so); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 371 | } |
| 372 | |
| 373 | |
| 374 | /* |
| 375 | * Make a thread sleeping on the specified identifier runnable. |
| 376 | * May wake more than one thread if a target thread is currently |
| 377 | * swapped out. |
| 378 | */ |
| 379 | void |
| 380 | wakeup_one(ident) |
| 381 | void *ident; |
| 382 | { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 383 | /* __Userspace__ Check: We are using accept_cond for wakeup_one. |
| 384 | It seems that wakeup_one is only called within |
| 385 | soisconnected() and sonewconn() with ident &head->so_timeo |
| 386 | head is so->so_head, which is back pointer to listen socket |
| 387 | This seems to indicate that the use of accept_cond is correct |
| 388 | since socket where accepts occur is so_head in all |
| 389 | subsidiary sockets. |
| 390 | */ |
| 391 | ACCEPT_LOCK(); |
| 392 | #if defined (__Userspace_os_Windows) |
ruengeler | ec3534f | 2012-05-23 12:58:55 +0000 | [diff] [blame] | 393 | WakeAllConditionVariable(&accept_cond); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 394 | #else |
ruengeler | ec3534f | 2012-05-23 12:58:55 +0000 | [diff] [blame] | 395 | pthread_cond_broadcast(&accept_cond); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 396 | #endif |
| 397 | ACCEPT_UNLOCK(); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 398 | } |
| 399 | |
| 400 | |
| 401 | /* Called within sctp_process_cookie_[existing/new] */ |
| 402 | void |
| 403 | soisconnected(struct socket *so) |
| 404 | { |
| 405 | struct socket *head; |
| 406 | |
| 407 | ACCEPT_LOCK(); |
| 408 | SOCK_LOCK(so); |
| 409 | so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING); |
| 410 | so->so_state |= SS_ISCONNECTED; |
| 411 | head = so->so_head; |
| 412 | if (head != NULL && (so->so_qstate & SQ_INCOMP)) { |
t00fcxen | cd09288 | 2012-09-03 15:36:46 +0000 | [diff] [blame] | 413 | SOCK_UNLOCK(so); |
| 414 | TAILQ_REMOVE(&head->so_incomp, so, so_list); |
| 415 | head->so_incqlen--; |
| 416 | so->so_qstate &= ~SQ_INCOMP; |
| 417 | TAILQ_INSERT_TAIL(&head->so_comp, so, so_list); |
| 418 | head->so_qlen++; |
| 419 | so->so_qstate |= SQ_COMP; |
| 420 | ACCEPT_UNLOCK(); |
| 421 | sorwakeup(head); |
| 422 | wakeup_one(&head->so_timeo); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 423 | return; |
| 424 | } |
| 425 | SOCK_UNLOCK(so); |
| 426 | ACCEPT_UNLOCK(); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 427 | wakeup(&so->so_timeo, so); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 428 | sorwakeup(so); |
| 429 | sowwakeup(so); |
| 430 | |
| 431 | } |
| 432 | |
| 433 | /* called within sctp_handle_cookie_echo */ |
| 434 | |
| 435 | struct socket * |
| 436 | sonewconn(struct socket *head, int connstatus) |
| 437 | { |
| 438 | struct socket *so; |
| 439 | int over; |
| 440 | |
| 441 | ACCEPT_LOCK(); |
| 442 | over = (head->so_qlen > 3 * head->so_qlimit / 2); |
| 443 | ACCEPT_UNLOCK(); |
| 444 | #ifdef REGRESSION |
| 445 | if (regression_sonewconn_earlytest && over) |
| 446 | #else |
| 447 | if (over) |
| 448 | #endif |
| 449 | return (NULL); |
| 450 | so = soalloc(); |
| 451 | if (so == NULL) |
| 452 | return (NULL); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 453 | so->so_head = head; |
| 454 | so->so_type = head->so_type; |
t00fcxen | 907b9e7 | 2012-09-03 16:20:51 +0000 | [diff] [blame] | 455 | so->so_options = head->so_options &~ SCTP_SO_ACCEPTCONN; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 456 | so->so_linger = head->so_linger; |
| 457 | so->so_state = head->so_state | SS_NOFDREF; |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 458 | so->so_dom = head->so_dom; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 459 | #ifdef MAC |
| 460 | SOCK_LOCK(head); |
| 461 | mac_create_socket_from_socket(head, so); |
| 462 | SOCK_UNLOCK(head); |
| 463 | #endif |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 464 | if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat)) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 465 | sodealloc(so); |
| 466 | return (NULL); |
| 467 | } |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 468 | switch (head->so_dom) { |
| 469 | #ifdef INET |
| 470 | case AF_INET: |
| 471 | if (sctp_attach(so, IPPROTO_SCTP, SCTP_DEFAULT_VRFID)) { |
| 472 | sodealloc(so); |
| 473 | return (NULL); |
| 474 | } |
| 475 | break; |
| 476 | #endif |
| 477 | #ifdef INET6 |
| 478 | case AF_INET6: |
| 479 | if (sctp6_attach(so, IPPROTO_SCTP, SCTP_DEFAULT_VRFID)) { |
| 480 | sodealloc(so); |
| 481 | return (NULL); |
| 482 | } |
| 483 | break; |
| 484 | #endif |
| 485 | case AF_CONN: |
| 486 | if (sctpconn_attach(so, IPPROTO_SCTP, SCTP_DEFAULT_VRFID)) { |
| 487 | sodealloc(so); |
| 488 | return (NULL); |
| 489 | } |
| 490 | break; |
| 491 | default: |
| 492 | sodealloc(so); |
| 493 | return (NULL); |
| 494 | break; |
| 495 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 496 | so->so_rcv.sb_lowat = head->so_rcv.sb_lowat; |
| 497 | so->so_snd.sb_lowat = head->so_snd.sb_lowat; |
| 498 | so->so_rcv.sb_timeo = head->so_rcv.sb_timeo; |
| 499 | so->so_snd.sb_timeo = head->so_snd.sb_timeo; |
| 500 | so->so_rcv.sb_flags |= head->so_rcv.sb_flags & SB_AUTOSIZE; |
| 501 | so->so_snd.sb_flags |= head->so_snd.sb_flags & SB_AUTOSIZE; |
| 502 | so->so_state |= connstatus; |
| 503 | ACCEPT_LOCK(); |
| 504 | if (connstatus) { |
| 505 | TAILQ_INSERT_TAIL(&head->so_comp, so, so_list); |
| 506 | so->so_qstate |= SQ_COMP; |
| 507 | head->so_qlen++; |
| 508 | } else { |
| 509 | /* |
| 510 | * Keep removing sockets from the head until there's room for |
| 511 | * us to insert on the tail. In pre-locking revisions, this |
| 512 | * was a simple if(), but as we could be racing with other |
| 513 | * threads and soabort() requires dropping locks, we must |
| 514 | * loop waiting for the condition to be true. |
| 515 | */ |
| 516 | while (head->so_incqlen > head->so_qlimit) { |
| 517 | struct socket *sp; |
| 518 | sp = TAILQ_FIRST(&head->so_incomp); |
| 519 | TAILQ_REMOVE(&head->so_incomp, sp, so_list); |
| 520 | head->so_incqlen--; |
| 521 | sp->so_qstate &= ~SQ_INCOMP; |
| 522 | sp->so_head = NULL; |
| 523 | ACCEPT_UNLOCK(); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 524 | soabort(sp); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 525 | ACCEPT_LOCK(); |
| 526 | } |
| 527 | TAILQ_INSERT_TAIL(&head->so_incomp, so, so_list); |
| 528 | so->so_qstate |= SQ_INCOMP; |
| 529 | head->so_incqlen++; |
| 530 | } |
| 531 | ACCEPT_UNLOCK(); |
| 532 | if (connstatus) { |
| 533 | sorwakeup(head); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 534 | wakeup_one(&head->so_timeo); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 535 | } |
| 536 | return (so); |
| 537 | |
| 538 | } |
| 539 | |
| 540 | /* From /src/sys/sys/sysproto.h */ |
| 541 | struct sctp_generic_sendmsg_args { |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 542 | int sd; |
| 543 | caddr_t msg; |
| 544 | int mlen; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 545 | caddr_t to; |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 546 | socklen_t tolen; /* was __socklen_t */ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 547 | struct sctp_sndrcvinfo * sinfo; |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 548 | int flags; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 549 | }; |
| 550 | |
| 551 | struct sctp_generic_recvmsg_args { |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 552 | int sd; |
| 553 | struct iovec *iov; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 554 | int iovlen; |
| 555 | struct sockaddr *from; |
| 556 | socklen_t *fromlenaddr; /* was __socklen_t */ |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 557 | struct sctp_sndrcvinfo *sinfo; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 558 | int *msg_flags; |
| 559 | }; |
| 560 | |
| 561 | |
| 562 | /* |
| 563 | Source: /src/sys/gnu/fs/xfs/FreeBSD/xfs_ioctl.c |
| 564 | */ |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 565 | static __inline__ int |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 566 | copy_to_user(void *dst, void *src, int len) { |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 567 | memcpy(dst, src, len); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 568 | return 0; |
| 569 | } |
| 570 | |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 571 | static __inline__ int |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 572 | copy_from_user(void *dst, void *src, int len) { |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 573 | memcpy(dst, src, len); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 574 | return 0; |
| 575 | } |
| 576 | |
| 577 | /* |
| 578 | References: |
| 579 | src/sys/dev/lmc/if_lmc.h: |
| 580 | src/sys/powerpc/powerpc/copyinout.c |
| 581 | src/sys/sys/systm.h |
| 582 | */ |
| 583 | # define copyin(u, k, len) copy_from_user(k, u, len) |
| 584 | |
| 585 | /* References: |
| 586 | src/sys/powerpc/powerpc/copyinout.c |
| 587 | src/sys/sys/systm.h |
| 588 | */ |
| 589 | # define copyout(k, u, len) copy_to_user(u, k, len) |
| 590 | |
| 591 | |
| 592 | /* copyiniov definition copied/modified from src/sys/kern/kern_subr.c */ |
| 593 | int |
| 594 | copyiniov(struct iovec *iovp, u_int iovcnt, struct iovec **iov, int error) |
| 595 | { |
| 596 | u_int iovlen; |
| 597 | |
| 598 | *iov = NULL; |
| 599 | if (iovcnt > UIO_MAXIOV) |
| 600 | return (error); |
| 601 | iovlen = iovcnt * sizeof (struct iovec); |
| 602 | *iov = malloc(iovlen); /*, M_IOV, M_WAITOK); */ |
| 603 | error = copyin(iovp, *iov, iovlen); |
| 604 | if (error) { |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 605 | free(*iov); /*, M_IOV); */ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 606 | *iov = NULL; |
| 607 | } |
| 608 | return (error); |
| 609 | } |
| 610 | |
| 611 | /* (__Userspace__) version of uiomove */ |
| 612 | int |
| 613 | uiomove(void *cp, int n, struct uio *uio) |
| 614 | { |
| 615 | struct iovec *iov; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 616 | int cnt; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 617 | int error = 0; |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 618 | |
tuexen | c710843 | 2012-05-21 18:53:50 +0000 | [diff] [blame] | 619 | if ((uio->uio_rw != UIO_READ) && |
| 620 | (uio->uio_rw != UIO_WRITE)) { |
| 621 | return (EINVAL); |
| 622 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 623 | |
| 624 | while (n > 0 && uio->uio_resid) { |
| 625 | iov = uio->uio_iov; |
| 626 | cnt = iov->iov_len; |
| 627 | if (cnt == 0) { |
| 628 | uio->uio_iov++; |
| 629 | uio->uio_iovcnt--; |
| 630 | continue; |
| 631 | } |
| 632 | if (cnt > n) |
| 633 | cnt = n; |
| 634 | |
| 635 | switch (uio->uio_segflg) { |
| 636 | |
| 637 | case UIO_USERSPACE: |
| 638 | if (uio->uio_rw == UIO_READ) |
| 639 | error = copyout(cp, iov->iov_base, cnt); |
| 640 | else |
| 641 | error = copyin(iov->iov_base, cp, cnt); |
| 642 | if (error) |
| 643 | goto out; |
| 644 | break; |
| 645 | |
| 646 | case UIO_SYSSPACE: |
| 647 | if (uio->uio_rw == UIO_READ) |
| 648 | bcopy(cp, iov->iov_base, cnt); |
| 649 | else |
| 650 | bcopy(iov->iov_base, cp, cnt); |
| 651 | break; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 652 | } |
| 653 | iov->iov_base = (char *)iov->iov_base + cnt; |
| 654 | iov->iov_len -= cnt; |
| 655 | uio->uio_resid -= cnt; |
| 656 | uio->uio_offset += cnt; |
| 657 | cp = (char *)cp + cnt; |
| 658 | n -= cnt; |
| 659 | } |
| 660 | out: |
| 661 | return (error); |
| 662 | } |
| 663 | |
| 664 | |
| 665 | /* Source: src/sys/kern/uipc_syscalls.c */ |
| 666 | int |
| 667 | getsockaddr(namp, uaddr, len) |
| 668 | struct sockaddr **namp; |
| 669 | caddr_t uaddr; |
| 670 | size_t len; |
| 671 | { |
| 672 | struct sockaddr *sa; |
| 673 | int error; |
| 674 | |
| 675 | if (len > SOCK_MAXADDRLEN) |
| 676 | return (ENAMETOOLONG); |
t00fcxen | f4dcfd5 | 2012-09-15 07:33:55 +0000 | [diff] [blame] | 677 | if (len < offsetof(struct sockaddr, sa_data)) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 678 | return (EINVAL); |
| 679 | MALLOC(sa, struct sockaddr *, len, M_SONAME, M_WAITOK); |
| 680 | error = copyin(uaddr, sa, len); |
| 681 | if (error) { |
| 682 | FREE(sa, M_SONAME); |
| 683 | } else { |
t00fcxen | f48c939 | 2012-09-12 19:24:54 +0000 | [diff] [blame] | 684 | #ifdef HAVE_SA_LEN |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 685 | sa->sa_len = len; |
| 686 | #endif |
| 687 | *namp = sa; |
| 688 | } |
| 689 | return (error); |
| 690 | } |
| 691 | |
| 692 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 693 | /* Taken from /src/lib/libc/net/sctp_sys_calls.c |
| 694 | * and modified for __Userspace__ |
| 695 | * calling sctp_generic_sendmsg from this function |
| 696 | */ |
| 697 | ssize_t |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 698 | userspace_sctp_sendmsg(struct socket *so, |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 699 | const void *data, |
| 700 | size_t len, |
| 701 | struct sockaddr *to, |
| 702 | socklen_t tolen, |
| 703 | u_int32_t ppid, |
| 704 | u_int32_t flags, |
| 705 | u_int16_t stream_no, |
| 706 | u_int32_t timetolive, |
| 707 | u_int32_t context) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 708 | { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 709 | struct sctp_sndrcvinfo sndrcvinfo, *sinfo = &sndrcvinfo; |
| 710 | struct uio auio; |
| 711 | struct iovec iov[1]; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 712 | |
t00fcxen | fb3816e | 2014-08-12 12:51:45 +0000 | [diff] [blame] | 713 | memset(sinfo, 0, sizeof(struct sctp_sndrcvinfo)); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 714 | sinfo->sinfo_ppid = ppid; |
| 715 | sinfo->sinfo_flags = flags; |
| 716 | sinfo->sinfo_stream = stream_no; |
| 717 | sinfo->sinfo_timetolive = timetolive; |
| 718 | sinfo->sinfo_context = context; |
| 719 | sinfo->sinfo_assoc_id = 0; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 720 | |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 721 | |
| 722 | /* Perform error checks on destination (to) */ |
| 723 | if (tolen > SOCK_MAXADDRLEN){ |
tuexen | 57fa8d6 | 2012-07-14 17:14:01 +0000 | [diff] [blame] | 724 | errno = ENAMETOOLONG; |
| 725 | return (-1); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 726 | } |
tuexen | 3ad9597 | 2012-01-18 21:00:02 +0000 | [diff] [blame] | 727 | if ((tolen > 0) && |
t00fcxen | 8c88a9b | 2014-02-20 10:44:26 +0000 | [diff] [blame] | 728 | ((to == NULL) || (tolen < (socklen_t)sizeof(struct sockaddr)))) { |
tuexen | 3ad9597 | 2012-01-18 21:00:02 +0000 | [diff] [blame] | 729 | errno = EINVAL; |
tuexen | 57fa8d6 | 2012-07-14 17:14:01 +0000 | [diff] [blame] | 730 | return (-1); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 731 | } |
| 732 | /* Adding the following as part of defensive programming, in case the application |
| 733 | does not do it when preparing the destination address.*/ |
t00fcxen | f48c939 | 2012-09-12 19:24:54 +0000 | [diff] [blame] | 734 | #ifdef HAVE_SA_LEN |
tuexen | 3ad9597 | 2012-01-18 21:00:02 +0000 | [diff] [blame] | 735 | if (to != NULL) { |
| 736 | to->sa_len = tolen; |
| 737 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 738 | #endif |
| 739 | |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 740 | iov[0].iov_base = (caddr_t)data; |
| 741 | iov[0].iov_len = len; |
| 742 | |
| 743 | auio.uio_iov = iov; |
| 744 | auio.uio_iovcnt = 1; |
| 745 | auio.uio_segflg = UIO_USERSPACE; |
| 746 | auio.uio_rw = UIO_WRITE; |
| 747 | auio.uio_offset = 0; /* XXX */ |
| 748 | auio.uio_resid = len; |
tuexen | 57fa8d6 | 2012-07-14 17:14:01 +0000 | [diff] [blame] | 749 | errno = sctp_lower_sosend(so, to, &auio, NULL, NULL, 0, sinfo); |
| 750 | if (errno == 0) { |
| 751 | return (len - auio.uio_resid); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 752 | } else { |
tuexen | 57fa8d6 | 2012-07-14 17:14:01 +0000 | [diff] [blame] | 753 | return (-1); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 754 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 755 | } |
| 756 | |
| 757 | |
| 758 | ssize_t |
| 759 | usrsctp_sendv(struct socket *so, |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 760 | const void *data, |
| 761 | size_t len, |
| 762 | struct sockaddr *to, |
| 763 | int addrcnt, |
| 764 | void *info, |
| 765 | socklen_t infolen, |
| 766 | unsigned int infotype, |
| 767 | int flags) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 768 | { |
| 769 | struct sctp_sndrcvinfo sinfo; |
| 770 | struct uio auio; |
| 771 | struct iovec iov[1]; |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 772 | int use_sinfo; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 773 | |
tuexen | 2831695 | 2012-07-14 09:41:02 +0000 | [diff] [blame] | 774 | if (so == NULL) { |
| 775 | errno = EBADF; |
| 776 | return (-1); |
| 777 | } |
ruengeler | dae9040 | 2012-05-25 12:25:58 +0000 | [diff] [blame] | 778 | memset(&sinfo, 0, sizeof(struct sctp_sndrcvinfo)); |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 779 | use_sinfo = 0; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 780 | switch (infotype) { |
| 781 | case SCTP_SENDV_NOINFO: |
| 782 | if ((infolen != 0) || (info != NULL)) { |
| 783 | errno = EINVAL; |
| 784 | return (-1); |
| 785 | } |
| 786 | break; |
| 787 | case SCTP_SENDV_SNDINFO: |
| 788 | if ((info == NULL) || (infolen != sizeof(struct sctp_sndinfo))) { |
| 789 | errno = EINVAL; |
| 790 | return (-1); |
| 791 | } |
| 792 | sinfo.sinfo_stream = ((struct sctp_sndinfo *)info)->snd_sid; |
| 793 | sinfo.sinfo_flags = ((struct sctp_sndinfo *)info)->snd_flags; |
| 794 | sinfo.sinfo_ppid = ((struct sctp_sndinfo *)info)->snd_ppid; |
| 795 | sinfo.sinfo_context = ((struct sctp_sndinfo *)info)->snd_context; |
| 796 | sinfo.sinfo_assoc_id = ((struct sctp_sndinfo *)info)->snd_assoc_id; |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 797 | use_sinfo = 1; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 798 | break; |
| 799 | case SCTP_SENDV_PRINFO: |
| 800 | if ((info == NULL) || (infolen != sizeof(struct sctp_prinfo))) { |
| 801 | errno = EINVAL; |
| 802 | return (-1); |
| 803 | } |
| 804 | sinfo.sinfo_stream = 0; |
| 805 | sinfo.sinfo_flags = PR_SCTP_POLICY(((struct sctp_prinfo *)info)->pr_policy); |
| 806 | sinfo.sinfo_timetolive = ((struct sctp_prinfo *)info)->pr_value; |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 807 | use_sinfo = 1; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 808 | break; |
| 809 | case SCTP_SENDV_AUTHINFO: |
| 810 | errno = EINVAL; |
| 811 | return (-1); |
| 812 | case SCTP_SENDV_SPA: |
| 813 | if ((info == NULL) || (infolen != sizeof(struct sctp_sendv_spa))) { |
| 814 | errno = EINVAL; |
| 815 | return (-1); |
| 816 | } |
| 817 | if (((struct sctp_sendv_spa *)info)->sendv_flags & SCTP_SEND_SNDINFO_VALID) { |
| 818 | sinfo.sinfo_stream = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_sid; |
| 819 | sinfo.sinfo_flags = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_flags; |
| 820 | sinfo.sinfo_ppid = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_ppid; |
| 821 | sinfo.sinfo_context = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_context; |
| 822 | sinfo.sinfo_assoc_id = ((struct sctp_sendv_spa *)info)->sendv_sndinfo.snd_assoc_id; |
| 823 | } else { |
| 824 | sinfo.sinfo_flags = 0; |
| 825 | sinfo.sinfo_stream = 0; |
| 826 | } |
| 827 | if (((struct sctp_sendv_spa *)info)->sendv_flags & SCTP_SEND_PRINFO_VALID) { |
| 828 | sinfo.sinfo_flags |= PR_SCTP_POLICY(((struct sctp_sendv_spa *)info)->sendv_prinfo.pr_policy); |
| 829 | sinfo.sinfo_timetolive = ((struct sctp_sendv_spa *)info)->sendv_prinfo.pr_value; |
| 830 | } |
| 831 | if (((struct sctp_sendv_spa *)info)->sendv_flags & SCTP_SEND_AUTHINFO_VALID) { |
| 832 | errno = EINVAL; |
| 833 | return (-1); |
| 834 | } |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 835 | use_sinfo = 1; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 836 | break; |
| 837 | default: |
| 838 | errno = EINVAL; |
| 839 | return (-1); |
| 840 | } |
| 841 | |
| 842 | /* Perform error checks on destination (to) */ |
| 843 | if (addrcnt > 1) { |
| 844 | errno = EINVAL; |
tuexen | 57fa8d6 | 2012-07-14 17:14:01 +0000 | [diff] [blame] | 845 | return (-1); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 846 | } |
| 847 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 848 | iov[0].iov_base = (caddr_t)data; |
| 849 | iov[0].iov_len = len; |
| 850 | |
| 851 | auio.uio_iov = iov; |
| 852 | auio.uio_iovcnt = 1; |
| 853 | auio.uio_segflg = UIO_USERSPACE; |
| 854 | auio.uio_rw = UIO_WRITE; |
| 855 | auio.uio_offset = 0; /* XXX */ |
| 856 | auio.uio_resid = len; |
tuexen | 57fa8d6 | 2012-07-14 17:14:01 +0000 | [diff] [blame] | 857 | errno = sctp_lower_sosend(so, to, &auio, NULL, NULL, flags, use_sinfo ? &sinfo : NULL); |
| 858 | if (errno == 0) { |
| 859 | return (len - auio.uio_resid); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 860 | } else { |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 861 | return (-1); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 862 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 863 | } |
| 864 | |
| 865 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 866 | ssize_t |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 867 | userspace_sctp_sendmbuf(struct socket *so, |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 868 | struct mbuf* mbufdata, |
| 869 | size_t len, |
| 870 | struct sockaddr *to, |
| 871 | socklen_t tolen, |
| 872 | u_int32_t ppid, |
| 873 | u_int32_t flags, |
| 874 | u_int16_t stream_no, |
| 875 | u_int32_t timetolive, |
| 876 | u_int32_t context) |
| 877 | { |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 878 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 879 | struct sctp_sndrcvinfo sndrcvinfo, *sinfo = &sndrcvinfo; |
| 880 | /* struct uio auio; |
| 881 | struct iovec iov[1]; */ |
| 882 | int error = 0; |
| 883 | int uflags = 0; |
| 884 | int retvalsendmsg; |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 885 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 886 | sinfo->sinfo_ppid = ppid; |
| 887 | sinfo->sinfo_flags = flags; |
| 888 | sinfo->sinfo_stream = stream_no; |
| 889 | sinfo->sinfo_timetolive = timetolive; |
| 890 | sinfo->sinfo_context = context; |
| 891 | sinfo->sinfo_assoc_id = 0; |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 892 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 893 | /* Perform error checks on destination (to) */ |
| 894 | if (tolen > SOCK_MAXADDRLEN){ |
| 895 | error = (ENAMETOOLONG); |
| 896 | goto sendmsg_return; |
| 897 | } |
t00fcxen | 8c88a9b | 2014-02-20 10:44:26 +0000 | [diff] [blame] | 898 | if (tolen < (socklen_t)offsetof(struct sockaddr, sa_data)){ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 899 | error = (EINVAL); |
| 900 | goto sendmsg_return; |
| 901 | } |
| 902 | /* Adding the following as part of defensive programming, in case the application |
| 903 | does not do it when preparing the destination address.*/ |
t00fcxen | f48c939 | 2012-09-12 19:24:54 +0000 | [diff] [blame] | 904 | #ifdef HAVE_SA_LEN |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 905 | to->sa_len = tolen; |
| 906 | #endif |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 907 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 908 | error = sctp_lower_sosend(so, to, NULL/*uio*/, |
| 909 | (struct mbuf *)mbufdata, (struct mbuf *)NULL, |
| 910 | uflags, sinfo); |
| 911 | sendmsg_return: |
| 912 | /* TODO: Needs a condition for non-blocking when error is EWOULDBLOCK */ |
| 913 | if (0 == error) |
| 914 | retvalsendmsg = len; |
| 915 | else if(error == EWOULDBLOCK) { |
| 916 | errno = EWOULDBLOCK; |
| 917 | retvalsendmsg = (-1); |
| 918 | } else { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 919 | SCTP_PRINTF("%s: error = %d\n", __func__, error); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 920 | errno = error; |
| 921 | retvalsendmsg = (-1); |
| 922 | } |
| 923 | return retvalsendmsg; |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 924 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 925 | } |
| 926 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 927 | |
| 928 | /* taken from usr.lib/sctp_sys_calls.c and needed here */ |
| 929 | #define SCTP_SMALL_IOVEC_SIZE 2 |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 930 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 931 | /* Taken from /src/lib/libc/net/sctp_sys_calls.c |
| 932 | * and modified for __Userspace__ |
| 933 | * calling sctp_generic_recvmsg from this function |
| 934 | */ |
| 935 | ssize_t |
| 936 | userspace_sctp_recvmsg(struct socket *so, |
| 937 | void *dbuf, |
| 938 | size_t len, |
| 939 | struct sockaddr *from, |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 940 | socklen_t *fromlenp, |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 941 | struct sctp_sndrcvinfo *sinfo, |
| 942 | int *msg_flags) |
| 943 | { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 944 | struct uio auio; |
| 945 | struct iovec iov[SCTP_SMALL_IOVEC_SIZE]; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 946 | struct iovec *tiov; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 947 | int iovlen = 1; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 948 | int error = 0; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 949 | int ulen, i, retval; |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 950 | socklen_t fromlen; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 951 | |
| 952 | iov[0].iov_base = dbuf; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 953 | iov[0].iov_len = len; |
| 954 | |
| 955 | auio.uio_iov = iov; |
| 956 | auio.uio_iovcnt = iovlen; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 957 | auio.uio_segflg = UIO_USERSPACE; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 958 | auio.uio_rw = UIO_READ; |
| 959 | auio.uio_offset = 0; /* XXX */ |
| 960 | auio.uio_resid = 0; |
| 961 | tiov = iov; |
| 962 | for (i = 0; i <iovlen; i++, tiov++) { |
| 963 | if ((auio.uio_resid += tiov->iov_len) < 0) { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 964 | error = EINVAL; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 965 | SCTP_PRINTF("%s: error = %d\n", __func__, error); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 966 | return (-1); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 967 | } |
| 968 | } |
| 969 | ulen = auio.uio_resid; |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 970 | if (fromlenp != NULL) { |
| 971 | fromlen = *fromlenp; |
| 972 | } else { |
| 973 | fromlen = 0; |
| 974 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 975 | error = sctp_sorecvmsg(so, &auio, (struct mbuf **)NULL, |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 976 | from, fromlen, msg_flags, |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 977 | (struct sctp_sndrcvinfo *)sinfo, 1); |
| 978 | |
| 979 | if (error) { |
t00fcxen | 22a33a1 | 2013-12-27 19:21:25 +0000 | [diff] [blame] | 980 | if (auio.uio_resid != (int)ulen && |
| 981 | (error == EINTR || |
| 982 | #if !defined(__Userspace_os_NetBSD) |
| 983 | error == ERESTART || |
| 984 | #endif |
| 985 | error == EWOULDBLOCK)) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 986 | error = 0; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 987 | } |
t00fcxen | 22a33a1 | 2013-12-27 19:21:25 +0000 | [diff] [blame] | 988 | } |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 989 | if ((fromlenp != NULL) && (fromlen > 0) && (from != NULL)) { |
| 990 | switch (from->sa_family) { |
| 991 | #if defined(INET) |
| 992 | case AF_INET: |
| 993 | *fromlenp = sizeof(struct sockaddr_in); |
| 994 | break; |
| 995 | #endif |
| 996 | #if defined(INET6) |
| 997 | case AF_INET6: |
| 998 | *fromlenp = sizeof(struct sockaddr_in6); |
| 999 | break; |
| 1000 | #endif |
| 1001 | case AF_CONN: |
| 1002 | *fromlenp = sizeof(struct sockaddr_conn); |
| 1003 | break; |
| 1004 | default: |
| 1005 | *fromlenp = 0; |
| 1006 | break; |
| 1007 | } |
| 1008 | if (*fromlenp > fromlen) { |
| 1009 | *fromlenp = fromlen; |
| 1010 | } |
| 1011 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1012 | if (error == 0){ |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1013 | /* ready return value */ |
| 1014 | retval = (int)ulen - auio.uio_resid; |
| 1015 | return (retval); |
| 1016 | } else { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1017 | SCTP_PRINTF("%s: error = %d\n", __func__, error); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1018 | return (-1); |
| 1019 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1020 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1021 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1022 | ssize_t |
| 1023 | usrsctp_recvv(struct socket *so, |
| 1024 | void *dbuf, |
| 1025 | size_t len, |
| 1026 | struct sockaddr *from, |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 1027 | socklen_t *fromlenp, |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1028 | void *info, |
| 1029 | socklen_t *infolen, |
| 1030 | unsigned int *infotype, |
| 1031 | int *msg_flags) |
| 1032 | { |
| 1033 | struct uio auio; |
| 1034 | struct iovec iov[SCTP_SMALL_IOVEC_SIZE]; |
| 1035 | struct iovec *tiov; |
| 1036 | int iovlen = 1; |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 1037 | int ulen, i; |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 1038 | socklen_t fromlen; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1039 | struct sctp_rcvinfo *rcv; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1040 | struct sctp_recvv_rn *rn; |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 1041 | struct sctp_extrcvinfo seinfo; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1042 | |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 1043 | if (so == NULL) { |
| 1044 | errno = EBADF; |
| 1045 | return (-1); |
| 1046 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1047 | iov[0].iov_base = dbuf; |
| 1048 | iov[0].iov_len = len; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1049 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1050 | auio.uio_iov = iov; |
| 1051 | auio.uio_iovcnt = iovlen; |
| 1052 | auio.uio_segflg = UIO_USERSPACE; |
| 1053 | auio.uio_rw = UIO_READ; |
| 1054 | auio.uio_offset = 0; /* XXX */ |
| 1055 | auio.uio_resid = 0; |
| 1056 | tiov = iov; |
| 1057 | for (i = 0; i <iovlen; i++, tiov++) { |
| 1058 | if ((auio.uio_resid += tiov->iov_len) < 0) { |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 1059 | errno = EINVAL; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1060 | return (-1); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1061 | } |
| 1062 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1063 | ulen = auio.uio_resid; |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 1064 | if (fromlenp != NULL) { |
| 1065 | fromlen = *fromlenp; |
| 1066 | } else { |
| 1067 | fromlen = 0; |
| 1068 | } |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 1069 | errno = sctp_sorecvmsg(so, &auio, (struct mbuf **)NULL, |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 1070 | from, fromlen, msg_flags, |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 1071 | (struct sctp_sndrcvinfo *)&seinfo, 1); |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 1072 | if (errno) { |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 1073 | if (auio.uio_resid != (int)ulen && |
t00fcxen | 22a33a1 | 2013-12-27 19:21:25 +0000 | [diff] [blame] | 1074 | (errno == EINTR || |
| 1075 | #if !defined(__Userspace_os_NetBSD) |
| 1076 | errno == ERESTART || |
| 1077 | #endif |
| 1078 | errno == EWOULDBLOCK)) { |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 1079 | errno = 0; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1080 | } |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 1081 | } |
| 1082 | if ((*msg_flags & MSG_NOTIFICATION) == 0) { |
| 1083 | struct sctp_inpcb *inp; |
| 1084 | |
| 1085 | inp = (struct sctp_inpcb *)so->so_pcb; |
| 1086 | if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVNXTINFO) && |
| 1087 | sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVRCVINFO) && |
t00fcxen | 8c88a9b | 2014-02-20 10:44:26 +0000 | [diff] [blame] | 1088 | *infolen >= (socklen_t)sizeof(struct sctp_recvv_rn) && |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 1089 | seinfo.sreinfo_next_flags & SCTP_NEXT_MSG_AVAIL) { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1090 | rn = (struct sctp_recvv_rn *)info; |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 1091 | rn->recvv_rcvinfo.rcv_sid = seinfo.sinfo_stream; |
| 1092 | rn->recvv_rcvinfo.rcv_ssn = seinfo.sinfo_ssn; |
| 1093 | rn->recvv_rcvinfo.rcv_flags = seinfo.sinfo_flags; |
| 1094 | rn->recvv_rcvinfo.rcv_ppid = seinfo.sinfo_ppid; |
| 1095 | rn->recvv_rcvinfo.rcv_context = seinfo.sinfo_context; |
| 1096 | rn->recvv_rcvinfo.rcv_tsn = seinfo.sinfo_tsn; |
| 1097 | rn->recvv_rcvinfo.rcv_cumtsn = seinfo.sinfo_cumtsn; |
| 1098 | rn->recvv_rcvinfo.rcv_assoc_id = seinfo.sinfo_assoc_id; |
| 1099 | rn->recvv_nxtinfo.nxt_sid = seinfo.sreinfo_next_stream; |
| 1100 | rn->recvv_nxtinfo.nxt_flags = 0; |
| 1101 | if (seinfo.sreinfo_next_flags & SCTP_NEXT_MSG_IS_UNORDERED) { |
| 1102 | rn->recvv_nxtinfo.nxt_flags |= SCTP_UNORDERED; |
| 1103 | } |
| 1104 | if (seinfo.sreinfo_next_flags & SCTP_NEXT_MSG_IS_NOTIFICATION) { |
| 1105 | rn->recvv_nxtinfo.nxt_flags |= SCTP_NOTIFICATION; |
| 1106 | } |
| 1107 | if (seinfo.sreinfo_next_flags & SCTP_NEXT_MSG_ISCOMPLETE) { |
| 1108 | rn->recvv_nxtinfo.nxt_flags |= SCTP_COMPLETE; |
| 1109 | } |
| 1110 | rn->recvv_nxtinfo.nxt_ppid = seinfo.sreinfo_next_ppid; |
| 1111 | rn->recvv_nxtinfo.nxt_length = seinfo.sreinfo_next_length; |
| 1112 | rn->recvv_nxtinfo.nxt_assoc_id = seinfo.sreinfo_next_aid; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1113 | *infolen = (socklen_t)sizeof(struct sctp_recvv_rn); |
| 1114 | *infotype = SCTP_RECVV_RN; |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 1115 | } else if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVRCVINFO) && |
t00fcxen | 8c88a9b | 2014-02-20 10:44:26 +0000 | [diff] [blame] | 1116 | *infolen >= (socklen_t)sizeof(struct sctp_rcvinfo)) { |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 1117 | rcv = (struct sctp_rcvinfo *)info; |
| 1118 | rcv->rcv_sid = seinfo.sinfo_stream; |
| 1119 | rcv->rcv_ssn = seinfo.sinfo_ssn; |
| 1120 | rcv->rcv_flags = seinfo.sinfo_flags; |
| 1121 | rcv->rcv_ppid = seinfo.sinfo_ppid; |
| 1122 | rcv->rcv_context = seinfo.sinfo_context; |
| 1123 | rcv->rcv_tsn = seinfo.sinfo_tsn; |
| 1124 | rcv->rcv_cumtsn = seinfo.sinfo_cumtsn; |
| 1125 | rcv->rcv_assoc_id = seinfo.sinfo_assoc_id; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1126 | *infolen = (socklen_t)sizeof(struct sctp_rcvinfo); |
tuexen | 23e5769 | 2012-05-25 19:06:57 +0000 | [diff] [blame] | 1127 | *infotype = SCTP_RECVV_RCVINFO; |
| 1128 | } else { |
| 1129 | *infotype = SCTP_RECVV_NOINFO; |
| 1130 | *infolen = 0; |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1131 | } |
| 1132 | } |
t00fcxen | 07137be | 2013-02-20 09:49:35 +0000 | [diff] [blame] | 1133 | if ((fromlenp != NULL) && (fromlen > 0) && (from != NULL)) { |
| 1134 | switch (from->sa_family) { |
| 1135 | #if defined(INET) |
| 1136 | case AF_INET: |
| 1137 | *fromlenp = sizeof(struct sockaddr_in); |
| 1138 | break; |
| 1139 | #endif |
| 1140 | #if defined(INET6) |
| 1141 | case AF_INET6: |
| 1142 | *fromlenp = sizeof(struct sockaddr_in6); |
| 1143 | break; |
| 1144 | #endif |
| 1145 | case AF_CONN: |
| 1146 | *fromlenp = sizeof(struct sockaddr_conn); |
| 1147 | break; |
| 1148 | default: |
| 1149 | *fromlenp = 0; |
| 1150 | break; |
| 1151 | } |
| 1152 | if (*fromlenp > fromlen) { |
| 1153 | *fromlenp = fromlen; |
| 1154 | } |
| 1155 | } |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 1156 | if (errno == 0) { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1157 | /* ready return value */ |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 1158 | return ((int)ulen - auio.uio_resid); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1159 | } else { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1160 | return (-1); |
| 1161 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1162 | } |
| 1163 | |
| 1164 | |
| 1165 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1166 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1167 | #if defined(__Userspace__) |
| 1168 | /* Taken from /src/sys/kern/uipc_socket.c |
| 1169 | * and modified for __Userspace__ |
| 1170 | * socreate returns a socket. The socket should be |
| 1171 | * closed with soclose(). |
| 1172 | */ |
| 1173 | int |
| 1174 | socreate(int dom, struct socket **aso, int type, int proto) |
| 1175 | { |
| 1176 | struct socket *so; |
| 1177 | int error; |
| 1178 | |
tuexen | bbdbb60 | 2012-07-07 20:54:13 +0000 | [diff] [blame] | 1179 | if ((dom != AF_CONN) && (dom != AF_INET) && (dom != AF_INET6)) { |
tuexen | c710843 | 2012-05-21 18:53:50 +0000 | [diff] [blame] | 1180 | return (EINVAL); |
| 1181 | } |
| 1182 | if ((type != SOCK_STREAM) && (type != SOCK_SEQPACKET)) { |
| 1183 | return (EINVAL); |
| 1184 | } |
| 1185 | if (proto != IPPROTO_SCTP) { |
| 1186 | return (EINVAL); |
| 1187 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1188 | |
| 1189 | so = soalloc(); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1190 | if (so == NULL) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1191 | return (ENOBUFS); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1192 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1193 | |
tuexen | bbdbb60 | 2012-07-07 20:54:13 +0000 | [diff] [blame] | 1194 | /* |
| 1195 | * so_incomp represents a queue of connections that |
| 1196 | * must be completed at protocol level before being |
| 1197 | * returned. so_comp field heads a list of sockets |
| 1198 | * that are ready to be returned to the listening process |
| 1199 | *__Userspace__ These queues are being used at a number of places like accept etc. |
| 1200 | */ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1201 | TAILQ_INIT(&so->so_incomp); |
| 1202 | TAILQ_INIT(&so->so_comp); |
| 1203 | so->so_type = type; |
| 1204 | so->so_count = 1; |
tuexen | 0d570ca | 2012-07-15 18:45:28 +0000 | [diff] [blame] | 1205 | so->so_dom = dom; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1206 | /* |
| 1207 | * Auto-sizing of socket buffers is managed by the protocols and |
| 1208 | * the appropriate flags must be set in the pru_attach function. |
tuexen | bbdbb60 | 2012-07-07 20:54:13 +0000 | [diff] [blame] | 1209 | * For __Userspace__ The pru_attach function in this case is sctp_attach. |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1210 | */ |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1211 | switch (dom) { |
| 1212 | #if defined(INET) |
| 1213 | case AF_INET: |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 1214 | error = sctp_attach(so, proto, SCTP_DEFAULT_VRFID); |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1215 | break; |
| 1216 | #endif |
| 1217 | #if defined(INET6) |
| 1218 | case AF_INET6: |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 1219 | error = sctp6_attach(so, proto, SCTP_DEFAULT_VRFID); |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1220 | break; |
| 1221 | #endif |
tuexen | bbdbb60 | 2012-07-07 20:54:13 +0000 | [diff] [blame] | 1222 | case AF_CONN: |
| 1223 | error = sctpconn_attach(so, proto, SCTP_DEFAULT_VRFID); |
| 1224 | break; |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1225 | default: |
| 1226 | error = EAFNOSUPPORT; |
tuexen | bbdbb60 | 2012-07-07 20:54:13 +0000 | [diff] [blame] | 1227 | break; |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1228 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1229 | if (error) { |
tuexen | c710843 | 2012-05-21 18:53:50 +0000 | [diff] [blame] | 1230 | KASSERT(so->so_count == 1, ("socreate: so_count %d", so->so_count)); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1231 | so->so_count = 0; |
| 1232 | sodealloc(so); |
| 1233 | return (error); |
| 1234 | } |
| 1235 | *aso = so; |
| 1236 | return (0); |
| 1237 | } |
| 1238 | #else |
| 1239 | /* The kernel version for reference is below. The #else |
| 1240 | should be removed once the __Userspace__ |
| 1241 | version is tested. |
| 1242 | * socreate returns a socket with a ref count of 1. The socket should be |
| 1243 | * closed with soclose(). |
| 1244 | */ |
| 1245 | int |
| 1246 | socreate(int dom, struct socket **aso, int type, int proto, |
| 1247 | struct ucred *cred, struct thread *td) |
| 1248 | { |
| 1249 | struct protosw *prp; |
| 1250 | struct socket *so; |
| 1251 | int error; |
| 1252 | |
| 1253 | if (proto) |
| 1254 | prp = pffindproto(dom, proto, type); |
| 1255 | else |
| 1256 | prp = pffindtype(dom, type); |
| 1257 | |
| 1258 | if (prp == NULL || prp->pr_usrreqs->pru_attach == NULL || |
| 1259 | prp->pr_usrreqs->pru_attach == pru_attach_notsupp) |
| 1260 | return (EPROTONOSUPPORT); |
| 1261 | |
| 1262 | if (jailed(cred) && jail_socket_unixiproute_only && |
| 1263 | prp->pr_domain->dom_family != PF_LOCAL && |
| 1264 | prp->pr_domain->dom_family != PF_INET && |
| 1265 | prp->pr_domain->dom_family != PF_ROUTE) { |
| 1266 | return (EPROTONOSUPPORT); |
| 1267 | } |
| 1268 | |
| 1269 | if (prp->pr_type != type) |
| 1270 | return (EPROTOTYPE); |
| 1271 | so = soalloc(); |
| 1272 | if (so == NULL) |
| 1273 | return (ENOBUFS); |
| 1274 | |
| 1275 | TAILQ_INIT(&so->so_incomp); |
| 1276 | TAILQ_INIT(&so->so_comp); |
| 1277 | so->so_type = type; |
| 1278 | so->so_cred = crhold(cred); |
| 1279 | so->so_proto = prp; |
| 1280 | #ifdef MAC |
| 1281 | mac_create_socket(cred, so); |
| 1282 | #endif |
| 1283 | knlist_init(&so->so_rcv.sb_sel.si_note, SOCKBUF_MTX(&so->so_rcv), |
| 1284 | NULL, NULL, NULL); |
| 1285 | knlist_init(&so->so_snd.sb_sel.si_note, SOCKBUF_MTX(&so->so_snd), |
| 1286 | NULL, NULL, NULL); |
| 1287 | so->so_count = 1; |
| 1288 | /* |
| 1289 | * Auto-sizing of socket buffers is managed by the protocols and |
| 1290 | * the appropriate flags must be set in the pru_attach function. |
| 1291 | */ |
| 1292 | error = (*prp->pr_usrreqs->pru_attach)(so, proto, td); |
| 1293 | if (error) { |
| 1294 | KASSERT(so->so_count == 1, ("socreate: so_count %d", |
| 1295 | so->so_count)); |
| 1296 | so->so_count = 0; |
| 1297 | sodealloc(so); |
| 1298 | return (error); |
| 1299 | } |
| 1300 | *aso = so; |
| 1301 | return (0); |
| 1302 | } |
| 1303 | #endif |
| 1304 | |
| 1305 | |
| 1306 | |
| 1307 | |
| 1308 | /* Taken from /src/sys/kern/uipc_syscalls.c |
| 1309 | * and modified for __Userspace__ |
| 1310 | * Removing struct thread td. |
| 1311 | */ |
| 1312 | struct socket * |
| 1313 | userspace_socket(int domain, int type, int protocol) |
| 1314 | { |
| 1315 | struct socket *so = NULL; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1316 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1317 | errno = socreate(domain, &so, type, protocol); |
| 1318 | if (errno) { |
tuexen | a0e4aa0 | 2012-05-20 09:07:07 +0000 | [diff] [blame] | 1319 | return (NULL); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1320 | } |
| 1321 | /* |
tuexen | 05f7281 | 2012-04-18 11:29:38 +0000 | [diff] [blame] | 1322 | * The original socket call returns the file descriptor fd. |
| 1323 | * td->td_retval[0] = fd. |
| 1324 | * We are returning struct socket *so. |
| 1325 | */ |
| 1326 | return (so); |
| 1327 | } |
| 1328 | |
| 1329 | struct socket * |
| 1330 | usrsctp_socket(int domain, int type, int protocol, |
tuexen | d47a447 | 2012-05-27 11:10:08 +0000 | [diff] [blame] | 1331 | int (*receive_cb)(struct socket *sock, union sctp_sockstore addr, void *data, |
| 1332 | size_t datalen, struct sctp_rcvinfo, int flags, void *ulp_info), |
| 1333 | int (*send_cb)(struct socket *sock, uint32_t sb_free), |
| 1334 | uint32_t sb_threshold, |
| 1335 | void *ulp_info) |
tuexen | 05f7281 | 2012-04-18 11:29:38 +0000 | [diff] [blame] | 1336 | { |
tuexen | d47a447 | 2012-05-27 11:10:08 +0000 | [diff] [blame] | 1337 | struct socket *so; |
tuexen | 05f7281 | 2012-04-18 11:29:38 +0000 | [diff] [blame] | 1338 | |
tuexen | 2831695 | 2012-07-14 09:41:02 +0000 | [diff] [blame] | 1339 | if ((protocol = IPPROTO_SCTP) && (SCTP_BASE_VAR(sctp_pcb_initialized) == 0)) { |
| 1340 | errno = EPROTONOSUPPORT; |
| 1341 | return (NULL); |
| 1342 | } |
tuexen | d47a447 | 2012-05-27 11:10:08 +0000 | [diff] [blame] | 1343 | if ((receive_cb == NULL) && |
tuexen | 2831695 | 2012-07-14 09:41:02 +0000 | [diff] [blame] | 1344 | ((send_cb != NULL) || (sb_threshold != 0) || (ulp_info != NULL))) { |
tuexen | 05f7281 | 2012-04-18 11:29:38 +0000 | [diff] [blame] | 1345 | errno = EINVAL; |
| 1346 | return (NULL); |
| 1347 | } |
tuexen | 2831695 | 2012-07-14 09:41:02 +0000 | [diff] [blame] | 1348 | if ((domain == AF_CONN) && (SCTP_BASE_VAR(conn_output) == NULL)) { |
| 1349 | errno = EAFNOSUPPORT; |
| 1350 | return (NULL); |
| 1351 | } |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1352 | errno = socreate(domain, &so, type, protocol); |
| 1353 | if (errno) { |
tuexen | 05f7281 | 2012-04-18 11:29:38 +0000 | [diff] [blame] | 1354 | return (NULL); |
| 1355 | } |
| 1356 | /* |
| 1357 | * The original socket call returns the file descriptor fd. |
| 1358 | * td->td_retval[0] = fd. |
| 1359 | * We are returning struct socket *so. |
| 1360 | */ |
| 1361 | register_recv_cb(so, receive_cb); |
| 1362 | register_send_cb(so, sb_threshold, send_cb); |
tuexen | d47a447 | 2012-05-27 11:10:08 +0000 | [diff] [blame] | 1363 | register_ulp_info(so, ulp_info); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1364 | return (so); |
| 1365 | } |
| 1366 | |
| 1367 | |
| 1368 | u_long sb_max = SB_MAX; |
| 1369 | u_long sb_max_adj = |
| 1370 | SB_MAX * MCLBYTES / (MSIZE + MCLBYTES); /* adjusted sb_max */ |
| 1371 | |
| 1372 | static u_long sb_efficiency = 8; /* parameter for sbreserve() */ |
| 1373 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1374 | /* |
| 1375 | * Allot mbufs to a sockbuf. Attempt to scale mbmax so that mbcnt doesn't |
| 1376 | * become limiting if buffering efficiency is near the normal case. |
| 1377 | */ |
| 1378 | int |
| 1379 | sbreserve_locked(struct sockbuf *sb, u_long cc, struct socket *so) |
| 1380 | { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1381 | SOCKBUF_LOCK_ASSERT(sb); |
| 1382 | sb->sb_mbmax = (u_int)min(cc * sb_efficiency, sb_max); |
t00fcxen | d433587 | 2013-09-06 19:19:17 +0000 | [diff] [blame] | 1383 | sb->sb_hiwat = cc; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1384 | if (sb->sb_lowat > (int)sb->sb_hiwat) |
| 1385 | sb->sb_lowat = (int)sb->sb_hiwat; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1386 | return (1); |
| 1387 | } |
t00fcxen | d433587 | 2013-09-06 19:19:17 +0000 | [diff] [blame] | 1388 | |
| 1389 | static int |
| 1390 | sbreserve(struct sockbuf *sb, u_long cc, struct socket *so) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1391 | { |
t00fcxen | d433587 | 2013-09-06 19:19:17 +0000 | [diff] [blame] | 1392 | int error; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1393 | |
t00fcxen | d433587 | 2013-09-06 19:19:17 +0000 | [diff] [blame] | 1394 | SOCKBUF_LOCK(sb); |
| 1395 | error = sbreserve_locked(sb, cc, so); |
| 1396 | SOCKBUF_UNLOCK(sb); |
| 1397 | return (error); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1398 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1399 | |
| 1400 | #if defined(__Userspace__) |
| 1401 | int |
| 1402 | soreserve(struct socket *so, u_long sndcc, u_long rcvcc) |
| 1403 | { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1404 | SOCKBUF_LOCK(&so->so_snd); |
| 1405 | SOCKBUF_LOCK(&so->so_rcv); |
| 1406 | so->so_snd.sb_hiwat = (uint32_t)sndcc; |
| 1407 | so->so_rcv.sb_hiwat = (uint32_t)rcvcc; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1408 | |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1409 | if (sbreserve_locked(&so->so_snd, sndcc, so) == 0) { |
| 1410 | goto bad; |
| 1411 | } |
| 1412 | if (sbreserve_locked(&so->so_rcv, rcvcc, so) == 0) { |
| 1413 | goto bad; |
| 1414 | } |
| 1415 | if (so->so_rcv.sb_lowat == 0) |
| 1416 | so->so_rcv.sb_lowat = 1; |
| 1417 | if (so->so_snd.sb_lowat == 0) |
| 1418 | so->so_snd.sb_lowat = MCLBYTES; |
t00fcxen | d6d6990 | 2013-04-08 23:07:02 +0000 | [diff] [blame] | 1419 | if (so->so_snd.sb_lowat > (int)so->so_snd.sb_hiwat) |
| 1420 | so->so_snd.sb_lowat = (int)so->so_snd.sb_hiwat; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1421 | SOCKBUF_UNLOCK(&so->so_rcv); |
| 1422 | SOCKBUF_UNLOCK(&so->so_snd); |
| 1423 | return (0); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1424 | |
| 1425 | bad: |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1426 | SOCKBUF_UNLOCK(&so->so_rcv); |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 1427 | SOCKBUF_UNLOCK(&so->so_snd); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1428 | return (ENOBUFS); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1429 | } |
| 1430 | #else /* kernel version for reference */ |
| 1431 | int |
| 1432 | soreserve(struct socket *so, u_long sndcc, u_long rcvcc) |
| 1433 | { |
| 1434 | struct thread *td = curthread; |
| 1435 | |
| 1436 | SOCKBUF_LOCK(&so->so_snd); |
| 1437 | SOCKBUF_LOCK(&so->so_rcv); |
| 1438 | if (sbreserve_locked(&so->so_snd, sndcc, so, td) == 0) |
| 1439 | goto bad; |
| 1440 | if (sbreserve_locked(&so->so_rcv, rcvcc, so, td) == 0) |
| 1441 | goto bad2; |
| 1442 | if (so->so_rcv.sb_lowat == 0) |
| 1443 | so->so_rcv.sb_lowat = 1; |
| 1444 | if (so->so_snd.sb_lowat == 0) |
| 1445 | so->so_snd.sb_lowat = MCLBYTES; |
| 1446 | if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat) |
| 1447 | so->so_snd.sb_lowat = so->so_snd.sb_hiwat; |
| 1448 | SOCKBUF_UNLOCK(&so->so_rcv); |
| 1449 | SOCKBUF_UNLOCK(&so->so_snd); |
| 1450 | return (0); |
| 1451 | bad2: |
| 1452 | sbrelease_locked(&so->so_snd, so); |
| 1453 | bad: |
| 1454 | SOCKBUF_UNLOCK(&so->so_rcv); |
| 1455 | SOCKBUF_UNLOCK(&so->so_snd); |
| 1456 | return (ENOBUFS); |
| 1457 | } |
| 1458 | #endif |
| 1459 | |
| 1460 | |
| 1461 | |
| 1462 | |
| 1463 | |
| 1464 | /* Taken from /src/sys/kern/uipc_sockbuf.c |
| 1465 | * and modified for __Userspace__ |
| 1466 | */ |
| 1467 | |
| 1468 | #if defined(__Userspace__) |
| 1469 | void |
| 1470 | sowakeup(struct socket *so, struct sockbuf *sb) |
| 1471 | { |
| 1472 | |
| 1473 | SOCKBUF_LOCK_ASSERT(sb); |
| 1474 | |
| 1475 | sb->sb_flags &= ~SB_SEL; |
| 1476 | if (sb->sb_flags & SB_WAIT) { |
| 1477 | sb->sb_flags &= ~SB_WAIT; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1478 | #if defined (__Userspace_os_Windows) |
ruengeler | ec3534f | 2012-05-23 12:58:55 +0000 | [diff] [blame] | 1479 | WakeAllConditionVariable(&(sb)->sb_cond); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1480 | #else |
ruengeler | ec3534f | 2012-05-23 12:58:55 +0000 | [diff] [blame] | 1481 | pthread_cond_broadcast(&(sb)->sb_cond); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1482 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1483 | } |
| 1484 | SOCKBUF_UNLOCK(sb); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1485 | /*__Userspace__ what todo about so_upcall?*/ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1486 | |
| 1487 | } |
| 1488 | #else /* kernel version for reference */ |
| 1489 | /* |
| 1490 | * Wakeup processes waiting on a socket buffer. Do asynchronous notification |
| 1491 | * via SIGIO if the socket has the SS_ASYNC flag set. |
| 1492 | * |
| 1493 | * Called with the socket buffer lock held; will release the lock by the end |
| 1494 | * of the function. This allows the caller to acquire the socket buffer lock |
| 1495 | * while testing for the need for various sorts of wakeup and hold it through |
| 1496 | * to the point where it's no longer required. We currently hold the lock |
| 1497 | * through calls out to other subsystems (with the exception of kqueue), and |
| 1498 | * then release it to avoid lock order issues. It's not clear that's |
| 1499 | * correct. |
| 1500 | */ |
| 1501 | void |
| 1502 | sowakeup(struct socket *so, struct sockbuf *sb) |
| 1503 | { |
| 1504 | |
| 1505 | SOCKBUF_LOCK_ASSERT(sb); |
| 1506 | |
| 1507 | selwakeuppri(&sb->sb_sel, PSOCK); |
| 1508 | sb->sb_flags &= ~SB_SEL; |
| 1509 | if (sb->sb_flags & SB_WAIT) { |
| 1510 | sb->sb_flags &= ~SB_WAIT; |
| 1511 | wakeup(&sb->sb_cc); |
| 1512 | } |
| 1513 | KNOTE_LOCKED(&sb->sb_sel.si_note, 0); |
| 1514 | SOCKBUF_UNLOCK(sb); |
| 1515 | if ((so->so_state & SS_ASYNC) && so->so_sigio != NULL) |
| 1516 | pgsigio(&so->so_sigio, SIGIO, 0); |
| 1517 | if (sb->sb_flags & SB_UPCALL) |
t00fcxen | 218d5d0 | 2012-12-10 20:28:19 +0000 | [diff] [blame] | 1518 | (*so->so_upcall)(so, so->so_upcallarg, M_NOWAIT); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1519 | if (sb->sb_flags & SB_AIO) |
| 1520 | aio_swake(so, sb); |
| 1521 | mtx_assert(SOCKBUF_MTX(sb), MA_NOTOWNED); |
| 1522 | } |
| 1523 | #endif |
| 1524 | |
| 1525 | |
| 1526 | |
| 1527 | /* Taken from /src/sys/kern/uipc_socket.c |
| 1528 | * and modified for __Userspace__ |
| 1529 | */ |
| 1530 | |
| 1531 | int |
| 1532 | sobind(struct socket *so, struct sockaddr *nam) |
| 1533 | { |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1534 | switch (nam->sa_family) { |
| 1535 | #if defined(INET) |
| 1536 | case AF_INET: |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 1537 | return (sctp_bind(so, nam)); |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1538 | #endif |
| 1539 | #if defined(INET6) |
| 1540 | case AF_INET6: |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 1541 | return (sctp6_bind(so, nam, NULL)); |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1542 | #endif |
tuexen | c5f8040 | 2012-07-08 18:36:51 +0000 | [diff] [blame] | 1543 | case AF_CONN: |
| 1544 | return (sctpconn_bind(so, nam)); |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1545 | default: |
| 1546 | return EAFNOSUPPORT; |
| 1547 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1548 | } |
| 1549 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1550 | /* Taken from /src/sys/kern/uipc_syscalls.c |
| 1551 | * and modified for __Userspace__ |
| 1552 | */ |
| 1553 | |
| 1554 | int |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1555 | usrsctp_bind(struct socket *so, struct sockaddr *name, int namelen) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1556 | { |
| 1557 | struct sockaddr *sa; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1558 | |
tuexen | 2831695 | 2012-07-14 09:41:02 +0000 | [diff] [blame] | 1559 | if (so == NULL) { |
| 1560 | errno = EBADF; |
| 1561 | return (-1); |
| 1562 | } |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1563 | if ((errno = getsockaddr(&sa, (caddr_t)name, namelen)) != 0) |
| 1564 | return (-1); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1565 | |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 1566 | errno = sobind(so, sa); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1567 | FREE(sa, M_SONAME); |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1568 | if (errno) { |
| 1569 | return (-1); |
| 1570 | } else { |
| 1571 | return (0); |
| 1572 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1573 | } |
| 1574 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1575 | int |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1576 | userspace_bind(struct socket *so, struct sockaddr *name, int namelen) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1577 | { |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 1578 | return (usrsctp_bind(so, name, namelen)); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1579 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1580 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1581 | /* Taken from /src/sys/kern/uipc_socket.c |
| 1582 | * and modified for __Userspace__ |
| 1583 | */ |
| 1584 | |
| 1585 | int |
| 1586 | solisten(struct socket *so, int backlog) |
| 1587 | { |
tuexen | 5399719 | 2012-07-06 20:27:20 +0000 | [diff] [blame] | 1588 | if (so == NULL) { |
| 1589 | return (EBADF); |
| 1590 | } else { |
| 1591 | return (sctp_listen(so, backlog, NULL)); |
| 1592 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1593 | } |
| 1594 | |
| 1595 | |
| 1596 | int |
| 1597 | solisten_proto_check(struct socket *so) |
| 1598 | { |
| 1599 | |
| 1600 | SOCK_LOCK_ASSERT(so); |
| 1601 | |
| 1602 | if (so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING | |
| 1603 | SS_ISDISCONNECTING)) |
| 1604 | return (EINVAL); |
| 1605 | return (0); |
| 1606 | } |
| 1607 | |
| 1608 | static int somaxconn = SOMAXCONN; |
| 1609 | |
| 1610 | void |
| 1611 | solisten_proto(struct socket *so, int backlog) |
| 1612 | { |
| 1613 | |
| 1614 | SOCK_LOCK_ASSERT(so); |
| 1615 | |
| 1616 | if (backlog < 0 || backlog > somaxconn) |
| 1617 | backlog = somaxconn; |
| 1618 | so->so_qlimit = backlog; |
t00fcxen | 907b9e7 | 2012-09-03 16:20:51 +0000 | [diff] [blame] | 1619 | so->so_options |= SCTP_SO_ACCEPTCONN; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1620 | } |
| 1621 | |
| 1622 | |
| 1623 | |
| 1624 | |
| 1625 | /* Taken from /src/sys/kern/uipc_syscalls.c |
| 1626 | * and modified for __Userspace__ |
| 1627 | */ |
| 1628 | |
| 1629 | int |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1630 | usrsctp_listen(struct socket *so, int backlog) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1631 | { |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 1632 | errno = solisten(so, backlog); |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1633 | if (errno) { |
| 1634 | return (-1); |
| 1635 | } else { |
| 1636 | return (0); |
| 1637 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1638 | } |
| 1639 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1640 | int |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1641 | userspace_listen(struct socket *so, int backlog) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1642 | { |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 1643 | return (usrsctp_listen(so, backlog)); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1644 | } |
| 1645 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1646 | /* Taken from /src/sys/kern/uipc_socket.c |
| 1647 | * and modified for __Userspace__ |
| 1648 | */ |
| 1649 | |
| 1650 | int |
| 1651 | soaccept(struct socket *so, struct sockaddr **nam) |
| 1652 | { |
| 1653 | int error; |
| 1654 | |
| 1655 | SOCK_LOCK(so); |
| 1656 | KASSERT((so->so_state & SS_NOFDREF) != 0, ("soaccept: !NOFDREF")); |
| 1657 | so->so_state &= ~SS_NOFDREF; |
| 1658 | SOCK_UNLOCK(so); |
| 1659 | error = sctp_accept(so, nam); |
| 1660 | return (error); |
| 1661 | } |
| 1662 | |
| 1663 | |
| 1664 | |
| 1665 | /* Taken from /src/sys/kern/uipc_syscalls.c |
| 1666 | * kern_accept modified for __Userspace__ |
| 1667 | */ |
| 1668 | int |
t00fcxen | b7cb967 | 2012-11-23 08:22:47 +0000 | [diff] [blame] | 1669 | user_accept(struct socket *head, struct sockaddr **name, socklen_t *namelen, struct socket **ptr_accept_ret_sock) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1670 | { |
| 1671 | struct sockaddr *sa = NULL; |
| 1672 | int error; |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 1673 | struct socket *so = NULL; |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 1674 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1675 | |
| 1676 | if (name) { |
| 1677 | *name = NULL; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1678 | } |
| 1679 | |
t00fcxen | 907b9e7 | 2012-09-03 16:20:51 +0000 | [diff] [blame] | 1680 | if ((head->so_options & SCTP_SO_ACCEPTCONN) == 0) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1681 | error = EINVAL; |
| 1682 | goto done; |
| 1683 | } |
| 1684 | |
| 1685 | ACCEPT_LOCK(); |
| 1686 | if ((head->so_state & SS_NBIO) && TAILQ_EMPTY(&head->so_comp)) { |
| 1687 | ACCEPT_UNLOCK(); |
| 1688 | error = EWOULDBLOCK; |
| 1689 | goto noconnection; |
| 1690 | } |
| 1691 | while (TAILQ_EMPTY(&head->so_comp) && head->so_error == 0) { |
| 1692 | if (head->so_rcv.sb_state & SBS_CANTRCVMORE) { |
| 1693 | head->so_error = ECONNABORTED; |
| 1694 | break; |
| 1695 | } |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1696 | #if defined (__Userspace_os_Windows) |
| 1697 | if (SleepConditionVariableCS(&accept_cond, &accept_mtx, INFINITE)) |
| 1698 | error = 0; |
| 1699 | else |
| 1700 | error = GetLastError(); |
| 1701 | #else |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1702 | error = pthread_cond_wait(&accept_cond, &accept_mtx); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1703 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1704 | if (error) { |
| 1705 | ACCEPT_UNLOCK(); |
| 1706 | goto noconnection; |
| 1707 | } |
| 1708 | } |
| 1709 | if (head->so_error) { |
| 1710 | error = head->so_error; |
| 1711 | head->so_error = 0; |
| 1712 | ACCEPT_UNLOCK(); |
| 1713 | goto noconnection; |
| 1714 | } |
| 1715 | so = TAILQ_FIRST(&head->so_comp); |
| 1716 | KASSERT(!(so->so_qstate & SQ_INCOMP), ("accept1: so SQ_INCOMP")); |
| 1717 | KASSERT(so->so_qstate & SQ_COMP, ("accept1: so not SQ_COMP")); |
| 1718 | |
| 1719 | /* |
| 1720 | * Before changing the flags on the socket, we have to bump the |
| 1721 | * reference count. Otherwise, if the protocol calls sofree(), |
| 1722 | * the socket will be released due to a zero refcount. |
| 1723 | */ |
| 1724 | SOCK_LOCK(so); /* soref() and so_state update */ |
| 1725 | soref(so); /* file descriptor reference */ |
| 1726 | |
| 1727 | TAILQ_REMOVE(&head->so_comp, so, so_list); |
| 1728 | head->so_qlen--; |
| 1729 | so->so_state |= (head->so_state & SS_NBIO); |
| 1730 | so->so_qstate &= ~SQ_COMP; |
| 1731 | so->so_head = NULL; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1732 | SOCK_UNLOCK(so); |
| 1733 | ACCEPT_UNLOCK(); |
| 1734 | |
| 1735 | |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 1736 | /* |
| 1737 | * The original accept returns fd value via td->td_retval[0] = fd; |
| 1738 | * we will return the socket for accepted connection. |
| 1739 | */ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1740 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1741 | error = soaccept(so, &sa); |
| 1742 | if (error) { |
| 1743 | /* |
| 1744 | * return a namelen of zero for older code which might |
| 1745 | * ignore the return value from accept. |
| 1746 | */ |
| 1747 | if (name) |
| 1748 | *namelen = 0; |
| 1749 | goto noconnection; |
| 1750 | } |
| 1751 | if (sa == NULL) { |
| 1752 | if (name) |
| 1753 | *namelen = 0; |
| 1754 | goto done; |
| 1755 | } |
| 1756 | if (name) { |
t00fcxen | f48c939 | 2012-09-12 19:24:54 +0000 | [diff] [blame] | 1757 | #ifdef HAVE_SA_LEN |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1758 | /* check sa_len before it is destroyed */ |
t00fcxen | ddb7d0f | 2013-11-29 19:15:01 +0000 | [diff] [blame] | 1759 | if (*namelen > sa->sa_len) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1760 | *namelen = sa->sa_len; |
t00fcxen | ddb7d0f | 2013-11-29 19:15:01 +0000 | [diff] [blame] | 1761 | } |
| 1762 | #else |
| 1763 | socklen_t sa_len; |
| 1764 | |
| 1765 | switch (sa->sa_family) { |
| 1766 | #ifdef INET |
| 1767 | case AF_INET: |
| 1768 | sa_len = sizeof(struct sockaddr_in); |
| 1769 | break; |
| 1770 | #endif |
| 1771 | #ifdef INET6 |
| 1772 | case AF_INET6: |
| 1773 | sa_len = sizeof(struct sockaddr_in6); |
| 1774 | break; |
| 1775 | #endif |
| 1776 | case AF_CONN: |
| 1777 | sa_len = sizeof(struct sockaddr_conn); |
| 1778 | break; |
| 1779 | default: |
| 1780 | sa_len = 0; |
| 1781 | break; |
| 1782 | } |
| 1783 | if (*namelen > sa_len) { |
| 1784 | *namelen = sa_len; |
| 1785 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1786 | #endif |
| 1787 | *name = sa; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1788 | sa = NULL; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1789 | } |
| 1790 | noconnection: |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1791 | if (sa) { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1792 | FREE(sa, M_SONAME); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1793 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1794 | |
| 1795 | done: |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 1796 | *ptr_accept_ret_sock = so; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1797 | return (error); |
| 1798 | } |
| 1799 | |
| 1800 | |
| 1801 | |
| 1802 | /* Taken from /src/sys/kern/uipc_syscalls.c |
| 1803 | * and modified for __Userspace__ |
| 1804 | */ |
| 1805 | /* |
| 1806 | * accept1() |
| 1807 | */ |
| 1808 | static int |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1809 | accept1(struct socket *so, struct sockaddr *aname, socklen_t *anamelen, struct socket **ptr_accept_ret_sock) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1810 | { |
| 1811 | struct sockaddr *name; |
| 1812 | socklen_t namelen; |
| 1813 | int error; |
| 1814 | |
tuexen | 5399719 | 2012-07-06 20:27:20 +0000 | [diff] [blame] | 1815 | if (so == NULL) { |
| 1816 | return (EBADF); |
| 1817 | } |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1818 | if (aname == NULL) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1819 | return (user_accept(so, NULL, NULL, ptr_accept_ret_sock)); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1820 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1821 | |
| 1822 | error = copyin(anamelen, &namelen, sizeof (namelen)); |
| 1823 | if (error) |
| 1824 | return (error); |
| 1825 | |
| 1826 | error = user_accept(so, &name, &namelen, ptr_accept_ret_sock); |
| 1827 | |
| 1828 | /* |
| 1829 | * return a namelen of zero for older code which might |
| 1830 | * ignore the return value from accept. |
| 1831 | */ |
| 1832 | if (error) { |
| 1833 | (void) copyout(&namelen, |
| 1834 | anamelen, sizeof(*anamelen)); |
| 1835 | return (error); |
| 1836 | } |
| 1837 | |
| 1838 | if (error == 0 && name != NULL) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1839 | error = copyout(name, aname, namelen); |
| 1840 | } |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1841 | if (error == 0) { |
| 1842 | error = copyout(&namelen, anamelen, sizeof(namelen)); |
| 1843 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1844 | |
tuexen | 5399719 | 2012-07-06 20:27:20 +0000 | [diff] [blame] | 1845 | if (name) { |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 1846 | FREE(name, M_SONAME); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 1847 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1848 | return (error); |
| 1849 | } |
| 1850 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1851 | struct socket * |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1852 | usrsctp_accept(struct socket *so, struct sockaddr *aname, socklen_t *anamelen) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1853 | { |
tuexen | 0187b6e | 2012-01-19 07:38:26 +0000 | [diff] [blame] | 1854 | struct socket *accept_return_sock; |
| 1855 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1856 | errno = accept1(so, aname, anamelen, &accept_return_sock); |
| 1857 | if (errno) { |
tuexen | 8ce022e | 2012-01-19 22:47:44 +0000 | [diff] [blame] | 1858 | return (NULL); |
| 1859 | } else { |
| 1860 | return (accept_return_sock); |
| 1861 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1862 | } |
| 1863 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1864 | struct socket * |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1865 | userspace_accept(struct socket *so, struct sockaddr *aname, socklen_t *anamelen) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1866 | { |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1867 | return (usrsctp_accept(so, aname, anamelen)); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 1868 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1869 | |
t00fcxen | 56c7d1c | 2012-11-25 14:36:23 +0000 | [diff] [blame] | 1870 | struct socket * |
| 1871 | usrsctp_peeloff(struct socket *head, sctp_assoc_t id) |
| 1872 | { |
| 1873 | struct socket *so; |
| 1874 | |
| 1875 | if ((errno = sctp_can_peel_off(head, id)) != 0) { |
| 1876 | return (NULL); |
| 1877 | } |
| 1878 | if ((so = sonewconn(head, SS_ISCONNECTED)) == NULL) { |
| 1879 | return (NULL); |
| 1880 | } |
| 1881 | ACCEPT_LOCK(); |
| 1882 | SOCK_LOCK(so); |
| 1883 | soref(so); |
| 1884 | TAILQ_REMOVE(&head->so_comp, so, so_list); |
| 1885 | head->so_qlen--; |
| 1886 | so->so_state |= (head->so_state & SS_NBIO); |
| 1887 | so->so_qstate &= ~SQ_COMP; |
| 1888 | so->so_head = NULL; |
| 1889 | SOCK_UNLOCK(so); |
| 1890 | ACCEPT_UNLOCK(); |
| 1891 | if ((errno = sctp_do_peeloff(head, so, id)) != 0) { |
| 1892 | so->so_count = 0; |
| 1893 | sodealloc(so); |
| 1894 | return (NULL); |
| 1895 | } |
| 1896 | return (so); |
| 1897 | } |
| 1898 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1899 | int |
| 1900 | sodisconnect(struct socket *so) |
| 1901 | { |
| 1902 | int error; |
| 1903 | |
| 1904 | if ((so->so_state & SS_ISCONNECTED) == 0) |
| 1905 | return (ENOTCONN); |
| 1906 | if (so->so_state & SS_ISDISCONNECTING) |
| 1907 | return (EALREADY); |
| 1908 | error = sctp_disconnect(so); |
| 1909 | return (error); |
| 1910 | } |
| 1911 | |
tuexen | b053ad5 | 2012-07-13 20:44:13 +0000 | [diff] [blame] | 1912 | int |
tuexen | 131dc2e | 2012-07-14 15:35:13 +0000 | [diff] [blame] | 1913 | usrsctp_set_non_blocking(struct socket *so, int onoff) |
| 1914 | { |
tuexen | b053ad5 | 2012-07-13 20:44:13 +0000 | [diff] [blame] | 1915 | if (so == NULL) { |
| 1916 | errno = EBADF; |
| 1917 | return (-1); |
| 1918 | } |
| 1919 | SOCK_LOCK(so); |
| 1920 | if (onoff != 0) { |
| 1921 | so->so_state |= SS_NBIO; |
| 1922 | } else { |
| 1923 | so->so_state &= ~SS_NBIO; |
| 1924 | } |
| 1925 | SOCK_UNLOCK(so); |
| 1926 | return (0); |
| 1927 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1928 | |
| 1929 | int |
tuexen | 131dc2e | 2012-07-14 15:35:13 +0000 | [diff] [blame] | 1930 | usrsctp_get_non_blocking(struct socket *so) |
| 1931 | { |
| 1932 | int result; |
| 1933 | |
| 1934 | if (so == NULL) { |
| 1935 | errno = EBADF; |
| 1936 | return (-1); |
| 1937 | } |
| 1938 | SOCK_LOCK(so); |
| 1939 | if (so->so_state | SS_NBIO) { |
| 1940 | result = 1; |
| 1941 | } else { |
| 1942 | result = 0; |
| 1943 | } |
| 1944 | SOCK_UNLOCK(so); |
| 1945 | return (result); |
| 1946 | } |
| 1947 | |
| 1948 | int |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1949 | soconnect(struct socket *so, struct sockaddr *nam) |
| 1950 | { |
| 1951 | int error; |
| 1952 | |
t00fcxen | 907b9e7 | 2012-09-03 16:20:51 +0000 | [diff] [blame] | 1953 | if (so->so_options & SCTP_SO_ACCEPTCONN) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1954 | return (EOPNOTSUPP); |
| 1955 | /* |
| 1956 | * If protocol is connection-based, can only connect once. |
| 1957 | * Otherwise, if connected, try to disconnect first. This allows |
| 1958 | * user to disconnect by connecting to, e.g., a null address. |
| 1959 | */ |
tuexen | c5f8040 | 2012-07-08 18:36:51 +0000 | [diff] [blame] | 1960 | if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) && (error = sodisconnect(so))) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1961 | error = EISCONN; |
| 1962 | } else { |
| 1963 | /* |
| 1964 | * Prevent accumulated error from previous connection from |
| 1965 | * biting us. |
| 1966 | */ |
| 1967 | so->so_error = 0; |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1968 | switch (nam->sa_family) { |
| 1969 | #if defined(INET) |
| 1970 | case AF_INET: |
| 1971 | error = sctp_connect(so, nam); |
| 1972 | break; |
| 1973 | #endif |
| 1974 | #if defined(INET6) |
| 1975 | case AF_INET6: |
| 1976 | error = sctp6_connect(so, nam); |
| 1977 | break; |
| 1978 | #endif |
tuexen | c5f8040 | 2012-07-08 18:36:51 +0000 | [diff] [blame] | 1979 | case AF_CONN: |
| 1980 | error = sctpconn_connect(so, nam); |
| 1981 | break; |
tuexen | d4985d8 | 2012-01-05 16:38:21 +0000 | [diff] [blame] | 1982 | default: |
| 1983 | error = EAFNOSUPPORT; |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 1984 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1985 | } |
| 1986 | |
| 1987 | return (error); |
| 1988 | } |
| 1989 | |
| 1990 | |
| 1991 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 1992 | int user_connect(struct socket *so, struct sockaddr *sa) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 1993 | { |
| 1994 | int error; |
| 1995 | int interrupted = 0; |
| 1996 | |
tuexen | 5399719 | 2012-07-06 20:27:20 +0000 | [diff] [blame] | 1997 | if (so == NULL) { |
| 1998 | error = EBADF; |
| 1999 | goto done1; |
| 2000 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2001 | if (so->so_state & SS_ISCONNECTING) { |
| 2002 | error = EALREADY; |
| 2003 | goto done1; |
| 2004 | } |
| 2005 | |
| 2006 | error = soconnect(so, sa); |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2007 | if (error) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2008 | goto bad; |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2009 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2010 | if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) { |
| 2011 | error = EINPROGRESS; |
| 2012 | goto done1; |
| 2013 | } |
| 2014 | |
| 2015 | SOCK_LOCK(so); |
| 2016 | while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2017 | #if defined (__Userspace_os_Windows) |
| 2018 | if (SleepConditionVariableCS(SOCK_COND(so), SOCK_MTX(so), INFINITE)) |
| 2019 | error = 0; |
| 2020 | else |
| 2021 | error = -1; |
| 2022 | #else |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2023 | error = pthread_cond_wait(SOCK_COND(so), SOCK_MTX(so)); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2024 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2025 | if (error) { |
t00fcxen | 22a33a1 | 2013-12-27 19:21:25 +0000 | [diff] [blame] | 2026 | #if defined(__Userspace_os_NetBSD) |
| 2027 | if (error == EINTR) { |
| 2028 | #else |
| 2029 | if (error == EINTR || error == ERESTART) { |
| 2030 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2031 | interrupted = 1; |
t00fcxen | 22a33a1 | 2013-12-27 19:21:25 +0000 | [diff] [blame] | 2032 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2033 | break; |
| 2034 | } |
| 2035 | } |
| 2036 | if (error == 0) { |
| 2037 | error = so->so_error; |
| 2038 | so->so_error = 0; |
| 2039 | } |
| 2040 | SOCK_UNLOCK(so); |
| 2041 | |
| 2042 | bad: |
t00fcxen | 22a33a1 | 2013-12-27 19:21:25 +0000 | [diff] [blame] | 2043 | if (!interrupted) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2044 | so->so_state &= ~SS_ISCONNECTING; |
t00fcxen | 22a33a1 | 2013-12-27 19:21:25 +0000 | [diff] [blame] | 2045 | } |
| 2046 | #if !defined(__Userspace_os_NetBSD) |
| 2047 | if (error == ERESTART) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2048 | error = EINTR; |
t00fcxen | 22a33a1 | 2013-12-27 19:21:25 +0000 | [diff] [blame] | 2049 | } |
| 2050 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2051 | done1: |
| 2052 | return (error); |
| 2053 | } |
| 2054 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2055 | int usrsctp_connect(struct socket *so, struct sockaddr *name, int namelen) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2056 | { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2057 | struct sockaddr *sa; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2058 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2059 | errno = getsockaddr(&sa, (caddr_t)name, namelen); |
| 2060 | if (errno) |
| 2061 | return (-1); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2062 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2063 | errno = user_connect(so, sa); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2064 | FREE(sa, M_SONAME); |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2065 | if (errno) { |
| 2066 | return (-1); |
| 2067 | } else { |
| 2068 | return (0); |
| 2069 | } |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2070 | } |
| 2071 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2072 | int userspace_connect(struct socket *so, struct sockaddr *name, int namelen) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2073 | { |
t00fcxen | cce4fa0 | 2012-09-08 15:41:49 +0000 | [diff] [blame] | 2074 | return (usrsctp_connect(so, name, namelen)); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2075 | } |
| 2076 | |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2077 | #define SCTP_STACK_BUF_SIZE 2048 |
| 2078 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2079 | void |
| 2080 | usrsctp_close(struct socket *so) { |
tuexen | 5399719 | 2012-07-06 20:27:20 +0000 | [diff] [blame] | 2081 | if (so != NULL) { |
t00fcxen | 907b9e7 | 2012-09-03 16:20:51 +0000 | [diff] [blame] | 2082 | if (so->so_options & SCTP_SO_ACCEPTCONN) { |
tuexen | 81680b2 | 2012-07-24 10:37:37 +0000 | [diff] [blame] | 2083 | struct socket *sp; |
| 2084 | |
| 2085 | ACCEPT_LOCK(); |
| 2086 | while ((sp = TAILQ_FIRST(&so->so_comp)) != NULL) { |
| 2087 | TAILQ_REMOVE(&so->so_comp, sp, so_list); |
| 2088 | so->so_qlen--; |
| 2089 | sp->so_qstate &= ~SQ_COMP; |
| 2090 | sp->so_head = NULL; |
| 2091 | ACCEPT_UNLOCK(); |
| 2092 | soabort(sp); |
| 2093 | ACCEPT_LOCK(); |
| 2094 | } |
| 2095 | ACCEPT_UNLOCK(); |
| 2096 | } |
tuexen | 5399719 | 2012-07-06 20:27:20 +0000 | [diff] [blame] | 2097 | ACCEPT_LOCK(); |
| 2098 | SOCK_LOCK(so); |
| 2099 | sorele(so); |
| 2100 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2101 | } |
| 2102 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2103 | void |
| 2104 | userspace_close(struct socket *so) |
tuexen | 8ce022e | 2012-01-19 22:47:44 +0000 | [diff] [blame] | 2105 | { |
tuexen | b63afcd | 2012-07-11 22:44:32 +0000 | [diff] [blame] | 2106 | usrsctp_close(so); |
tuexen | 8ce022e | 2012-01-19 22:47:44 +0000 | [diff] [blame] | 2107 | } |
| 2108 | |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 2109 | int |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2110 | usrsctp_shutdown(struct socket *so, int how) |
| 2111 | { |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2112 | if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR)) { |
| 2113 | errno = EINVAL; |
| 2114 | return (-1); |
| 2115 | } |
tuexen | 5399719 | 2012-07-06 20:27:20 +0000 | [diff] [blame] | 2116 | if (so == NULL) { |
| 2117 | errno = EBADF; |
| 2118 | return (-1); |
| 2119 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2120 | sctp_flush(so, how); |
| 2121 | if (how != SHUT_WR) |
| 2122 | socantrcvmore(so); |
| 2123 | if (how != SHUT_RD) { |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2124 | errno = sctp_shutdown(so); |
| 2125 | if (errno) { |
| 2126 | return (-1); |
| 2127 | } else { |
| 2128 | return (0); |
| 2129 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2130 | } |
| 2131 | return (0); |
| 2132 | } |
| 2133 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2134 | int |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2135 | userspace_shutdown(struct socket *so, int how) |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 2136 | { |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2137 | return (usrsctp_shutdown(so, how)); |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 2138 | } |
tuexen | 8ce022e | 2012-01-19 22:47:44 +0000 | [diff] [blame] | 2139 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2140 | int |
| 2141 | usrsctp_finish(void) |
| 2142 | { |
tuexen | 2831695 | 2012-07-14 09:41:02 +0000 | [diff] [blame] | 2143 | if (SCTP_BASE_VAR(sctp_pcb_initialized) == 0) { |
| 2144 | return (0); |
| 2145 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2146 | if (SCTP_INP_INFO_TRYLOCK()) { |
| 2147 | if (!LIST_EMPTY(&SCTP_BASE_INFO(listhead))) { |
| 2148 | SCTP_INP_INFO_RUNLOCK(); |
| 2149 | return (-1); |
| 2150 | } |
t00fcxen | 1584d52 | 2013-11-03 01:03:41 +0000 | [diff] [blame] | 2151 | SCTP_INP_INFO_RUNLOCK(); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2152 | } else { |
| 2153 | return (-1); |
| 2154 | } |
| 2155 | sctp_finish(); |
| 2156 | return (0); |
| 2157 | } |
| 2158 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2159 | int |
| 2160 | userspace_finish(void) |
| 2161 | { |
| 2162 | return (usrsctp_finish()); |
| 2163 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2164 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2165 | /* needed from sctp_usrreq.c */ |
| 2166 | int |
| 2167 | sctp_setopt(struct socket *so, int optname, void *optval, size_t optsize, void *p); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2168 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2169 | int |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2170 | usrsctp_setsockopt(struct socket *so, int level, int option_name, |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 2171 | const void *option_value, socklen_t option_len) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2172 | { |
tuexen | 5399719 | 2012-07-06 20:27:20 +0000 | [diff] [blame] | 2173 | if (so == NULL) { |
| 2174 | errno = EBADF; |
| 2175 | return (-1); |
| 2176 | } |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2177 | switch (level) { |
| 2178 | case SOL_SOCKET: |
| 2179 | { |
| 2180 | switch (option_name) { |
t00fcxen | d433587 | 2013-09-06 19:19:17 +0000 | [diff] [blame] | 2181 | case SO_RCVBUF: |
| 2182 | if (option_len < (socklen_t)sizeof(int)) { |
| 2183 | errno = EINVAL; |
| 2184 | return (-1); |
| 2185 | } else { |
| 2186 | int *buf_size; |
| 2187 | |
| 2188 | buf_size = (int *)option_value; |
| 2189 | if (*buf_size < 1) { |
| 2190 | errno = EINVAL; |
| 2191 | return (-1); |
| 2192 | } |
| 2193 | sbreserve(&so->so_rcv, (u_long)*buf_size, so); |
| 2194 | return (0); |
| 2195 | } |
| 2196 | break; |
| 2197 | case SO_SNDBUF: |
| 2198 | if (option_len < (socklen_t)sizeof(int)) { |
| 2199 | errno = EINVAL; |
| 2200 | return (-1); |
| 2201 | } else { |
| 2202 | int *buf_size; |
| 2203 | |
| 2204 | buf_size = (int *)option_value; |
| 2205 | if (*buf_size < 1) { |
| 2206 | errno = EINVAL; |
| 2207 | return (-1); |
| 2208 | } |
| 2209 | sbreserve(&so->so_snd, (u_long)*buf_size, so); |
| 2210 | return (0); |
| 2211 | } |
| 2212 | break; |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2213 | case SO_LINGER: |
t00fcxen | 145a866 | 2012-09-19 07:03:53 +0000 | [diff] [blame] | 2214 | if (option_len < (socklen_t)sizeof(struct linger)) { |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2215 | errno = EINVAL; |
| 2216 | return (-1); |
| 2217 | } else { |
| 2218 | struct linger *l; |
| 2219 | |
| 2220 | l = (struct linger *)option_value; |
| 2221 | so->so_linger = l->l_linger; |
| 2222 | if (l->l_onoff) { |
t00fcxen | 907b9e7 | 2012-09-03 16:20:51 +0000 | [diff] [blame] | 2223 | so->so_options |= SCTP_SO_LINGER; |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2224 | } else { |
t00fcxen | 907b9e7 | 2012-09-03 16:20:51 +0000 | [diff] [blame] | 2225 | so->so_options &= ~SCTP_SO_LINGER; |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2226 | } |
| 2227 | return (0); |
| 2228 | } |
| 2229 | default: |
| 2230 | errno = EINVAL; |
| 2231 | return (-1); |
| 2232 | } |
| 2233 | } |
| 2234 | case IPPROTO_SCTP: |
t00fcxen | 145a866 | 2012-09-19 07:03:53 +0000 | [diff] [blame] | 2235 | errno = sctp_setopt(so, option_name, (void *) option_value, (size_t)option_len, NULL); |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2236 | if (errno) { |
| 2237 | return (-1); |
| 2238 | } else { |
| 2239 | return (0); |
| 2240 | } |
| 2241 | default: |
| 2242 | errno = ENOPROTOOPT; |
tuexen | 18d788f | 2012-05-27 12:55:14 +0000 | [diff] [blame] | 2243 | return (-1); |
tuexen | 18d788f | 2012-05-27 12:55:14 +0000 | [diff] [blame] | 2244 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2245 | } |
| 2246 | |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2247 | int |
| 2248 | userspace_setsockopt(struct socket *so, int level, int option_name, |
| 2249 | const void *option_value, socklen_t option_len) |
| 2250 | { |
| 2251 | return (usrsctp_setsockopt(so, level, option_name, option_value, option_len)); |
| 2252 | } |
| 2253 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2254 | /* needed from sctp_usrreq.c */ |
| 2255 | int |
| 2256 | sctp_getopt(struct socket *so, int optname, void *optval, size_t *optsize, |
| 2257 | void *p); |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2258 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2259 | int |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2260 | usrsctp_getsockopt(struct socket *so, int level, int option_name, |
t00fcxen | eded5de | 2012-09-20 16:25:20 +0000 | [diff] [blame] | 2261 | void *option_value, socklen_t *option_len) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2262 | { |
tuexen | 5399719 | 2012-07-06 20:27:20 +0000 | [diff] [blame] | 2263 | if (so == NULL) { |
| 2264 | errno = EBADF; |
| 2265 | return (-1); |
| 2266 | } |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2267 | if (option_len == NULL) { |
| 2268 | errno = EFAULT; |
tuexen | 18d788f | 2012-05-27 12:55:14 +0000 | [diff] [blame] | 2269 | return (-1); |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2270 | } |
| 2271 | switch (level) { |
| 2272 | case SOL_SOCKET: |
| 2273 | switch (option_name) { |
t00fcxen | d433587 | 2013-09-06 19:19:17 +0000 | [diff] [blame] | 2274 | case SO_RCVBUF: |
| 2275 | if (*option_len < (socklen_t)sizeof(int)) { |
| 2276 | errno = EINVAL; |
| 2277 | return (-1); |
| 2278 | } else { |
| 2279 | int *buf_size; |
| 2280 | |
| 2281 | buf_size = (int *)option_value; |
| 2282 | *buf_size = so->so_rcv.sb_hiwat;; |
| 2283 | *option_len = (socklen_t)sizeof(int); |
| 2284 | return (0); |
| 2285 | } |
| 2286 | break; |
| 2287 | case SO_SNDBUF: |
| 2288 | if (*option_len < (socklen_t)sizeof(int)) { |
| 2289 | errno = EINVAL; |
| 2290 | return (-1); |
| 2291 | } else { |
| 2292 | int *buf_size; |
| 2293 | |
| 2294 | buf_size = (int *)option_value; |
| 2295 | *buf_size = so->so_snd.sb_hiwat; |
| 2296 | *option_len = (socklen_t)sizeof(int); |
| 2297 | return (0); |
| 2298 | } |
| 2299 | break; |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2300 | case SO_LINGER: |
t00fcxen | ce05298 | 2012-09-18 22:16:24 +0000 | [diff] [blame] | 2301 | if (*option_len < (socklen_t)sizeof(struct linger)) { |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2302 | errno = EINVAL; |
| 2303 | return (-1); |
| 2304 | } else { |
| 2305 | struct linger *l; |
| 2306 | |
| 2307 | l = (struct linger *)option_value; |
| 2308 | l->l_linger = so->so_linger; |
t00fcxen | 907b9e7 | 2012-09-03 16:20:51 +0000 | [diff] [blame] | 2309 | if (so->so_options & SCTP_SO_LINGER) { |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2310 | l->l_onoff = 1; |
| 2311 | } else { |
| 2312 | l->l_onoff = 0; |
| 2313 | } |
t00fcxen | ce05298 | 2012-09-18 22:16:24 +0000 | [diff] [blame] | 2314 | *option_len = (socklen_t)sizeof(struct linger); |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2315 | return (0); |
| 2316 | } |
| 2317 | default: |
| 2318 | errno = EINVAL; |
| 2319 | return (-1); |
| 2320 | } |
| 2321 | case IPPROTO_SCTP: |
t00fcxen | ce05298 | 2012-09-18 22:16:24 +0000 | [diff] [blame] | 2322 | { |
| 2323 | size_t len; |
| 2324 | |
| 2325 | len = (size_t)*option_len; |
| 2326 | errno = sctp_getopt(so, option_name, option_value, &len, NULL); |
| 2327 | *option_len = (socklen_t)len; |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2328 | if (errno) { |
| 2329 | return (-1); |
| 2330 | } else { |
| 2331 | return (0); |
| 2332 | } |
t00fcxen | ce05298 | 2012-09-18 22:16:24 +0000 | [diff] [blame] | 2333 | } |
tuexen | a21f0f5 | 2012-08-05 20:32:31 +0000 | [diff] [blame] | 2334 | default: |
| 2335 | errno = ENOPROTOOPT; |
| 2336 | return (-1); |
tuexen | 18d788f | 2012-05-27 12:55:14 +0000 | [diff] [blame] | 2337 | } |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2338 | } |
| 2339 | |
| 2340 | int |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2341 | userspace_getsockopt(struct socket *so, int level, int option_name, |
| 2342 | void *option_value, socklen_t *option_len) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2343 | { |
tuexen | 970e390 | 2012-05-27 14:17:00 +0000 | [diff] [blame] | 2344 | return (usrsctp_getsockopt(so, level, option_name, option_value, option_len)); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2345 | } |
| 2346 | |
t00fcxen | 112778d | 2012-11-18 17:40:06 +0000 | [diff] [blame] | 2347 | int |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2348 | usrsctp_bindx(struct socket *so, struct sockaddr *addrs, int addrcnt, int flags) |
| 2349 | { |
| 2350 | struct sctp_getaddresses *gaddrs; |
| 2351 | struct sockaddr *sa; |
t00fcxen | 0244dd5 | 2014-02-26 20:34:23 +0000 | [diff] [blame] | 2352 | #ifdef INET |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2353 | struct sockaddr_in *sin; |
t00fcxen | 0244dd5 | 2014-02-26 20:34:23 +0000 | [diff] [blame] | 2354 | #endif |
iruengeler | e6d3ea9 | 2012-11-26 09:05:29 +0000 | [diff] [blame] | 2355 | #ifdef INET6 |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2356 | struct sockaddr_in6 *sin6; |
iruengeler | e6d3ea9 | 2012-11-26 09:05:29 +0000 | [diff] [blame] | 2357 | #endif |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2358 | int i; |
| 2359 | size_t argsz; |
t00fcxen | 0244dd5 | 2014-02-26 20:34:23 +0000 | [diff] [blame] | 2360 | #if defined(INET) || defined(INET6) |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2361 | uint16_t sport = 0; |
t00fcxen | 0244dd5 | 2014-02-26 20:34:23 +0000 | [diff] [blame] | 2362 | #endif |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2363 | |
| 2364 | /* validate the flags */ |
| 2365 | if ((flags != SCTP_BINDX_ADD_ADDR) && |
| 2366 | (flags != SCTP_BINDX_REM_ADDR)) { |
| 2367 | errno = EFAULT; |
| 2368 | return (-1); |
| 2369 | } |
| 2370 | /* validate the address count and list */ |
| 2371 | if ((addrcnt <= 0) || (addrs == NULL)) { |
| 2372 | errno = EINVAL; |
| 2373 | return (-1); |
| 2374 | } |
| 2375 | /* First pre-screen the addresses */ |
| 2376 | sa = addrs; |
| 2377 | for (i = 0; i < addrcnt; i++) { |
| 2378 | switch (sa->sa_family) { |
| 2379 | #ifdef INET |
| 2380 | case AF_INET: |
| 2381 | #ifdef HAVE_SA_LEN |
| 2382 | if (sa->sa_len != sizeof(struct sockaddr_in)) { |
| 2383 | errno = EINVAL; |
| 2384 | return (-1); |
| 2385 | } |
| 2386 | #endif |
| 2387 | sin = (struct sockaddr_in *)sa; |
| 2388 | if (sin->sin_port) { |
| 2389 | /* non-zero port, check or save */ |
| 2390 | if (sport) { |
| 2391 | /* Check against our port */ |
| 2392 | if (sport != sin->sin_port) { |
| 2393 | errno = EINVAL; |
| 2394 | return (-1); |
| 2395 | } |
| 2396 | } else { |
| 2397 | /* save off the port */ |
| 2398 | sport = sin->sin_port; |
| 2399 | } |
| 2400 | } |
| 2401 | #ifndef HAVE_SA_LEN |
t00fcxen | 23069ba | 2014-01-04 12:26:30 +0000 | [diff] [blame] | 2402 | sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in)); |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2403 | #endif |
| 2404 | break; |
| 2405 | #endif |
| 2406 | #ifdef INET6 |
| 2407 | case AF_INET6: |
| 2408 | #ifdef HAVE_SA_LEN |
| 2409 | if (sa->sa_len != sizeof(struct sockaddr_in6)) { |
| 2410 | errno = EINVAL; |
| 2411 | return (-1); |
| 2412 | } |
| 2413 | #endif |
| 2414 | sin6 = (struct sockaddr_in6 *)sa; |
| 2415 | if (sin6->sin6_port) { |
| 2416 | /* non-zero port, check or save */ |
| 2417 | if (sport) { |
| 2418 | /* Check against our port */ |
| 2419 | if (sport != sin6->sin6_port) { |
| 2420 | errno = EINVAL; |
| 2421 | return (-1); |
| 2422 | } |
| 2423 | } else { |
| 2424 | /* save off the port */ |
| 2425 | sport = sin6->sin6_port; |
| 2426 | } |
| 2427 | } |
| 2428 | #ifndef HAVE_SA_LEN |
t00fcxen | 23069ba | 2014-01-04 12:26:30 +0000 | [diff] [blame] | 2429 | sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6)); |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2430 | #endif |
| 2431 | break; |
| 2432 | #endif |
| 2433 | default: |
| 2434 | /* Invalid address family specified. */ |
t00fcxen | 23069ba | 2014-01-04 12:26:30 +0000 | [diff] [blame] | 2435 | errno = EAFNOSUPPORT; |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2436 | return (-1); |
| 2437 | } |
| 2438 | #ifdef HAVE_SA_LEN |
| 2439 | sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len); |
| 2440 | #endif |
| 2441 | } |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2442 | argsz = sizeof(struct sctp_getaddresses) + |
| 2443 | sizeof(struct sockaddr_storage); |
| 2444 | if ((gaddrs = (struct sctp_getaddresses *)malloc(argsz)) == NULL) { |
| 2445 | errno = ENOMEM; |
| 2446 | return (-1); |
| 2447 | } |
| 2448 | sa = addrs; |
| 2449 | for (i = 0; i < addrcnt; i++) { |
| 2450 | #ifndef HAVE_SA_LEN |
| 2451 | size_t sa_len; |
| 2452 | #endif |
| 2453 | memset(gaddrs, 0, argsz); |
| 2454 | gaddrs->sget_assoc_id = 0; |
| 2455 | #ifdef HAVE_SA_LEN |
| 2456 | memcpy(gaddrs->addr, sa, sa->sa_len); |
| 2457 | if (usrsctp_setsockopt(so, IPPROTO_SCTP, flags, gaddrs, (socklen_t)argsz) != 0) { |
| 2458 | free(gaddrs); |
| 2459 | return (-1); |
| 2460 | } |
| 2461 | sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len); |
| 2462 | #else |
| 2463 | switch (sa->sa_family) { |
| 2464 | #ifdef INET |
| 2465 | case AF_INET: |
| 2466 | sa_len = sizeof(struct sockaddr_in); |
| 2467 | break; |
| 2468 | #endif |
| 2469 | #ifdef INET6 |
| 2470 | case AF_INET6: |
| 2471 | sa_len = sizeof(struct sockaddr_in6); |
| 2472 | break; |
| 2473 | #endif |
| 2474 | default: |
| 2475 | sa_len = 0; |
| 2476 | break; |
| 2477 | } |
| 2478 | memcpy(gaddrs->addr, sa, sa_len); |
t00fcxen | 23069ba | 2014-01-04 12:26:30 +0000 | [diff] [blame] | 2479 | /* |
| 2480 | * Now, if there was a port mentioned, assure that the |
| 2481 | * first address has that port to make sure it fails or |
| 2482 | * succeeds correctly. |
| 2483 | */ |
t00fcxen | b374a4f | 2014-03-18 22:34:21 +0000 | [diff] [blame] | 2484 | #if defined(INET) || defined(INET6) |
t00fcxen | 23069ba | 2014-01-04 12:26:30 +0000 | [diff] [blame] | 2485 | if ((i == 0) && (sport != 0)) { |
| 2486 | switch (gaddrs->addr->sa_family) { |
t00fcxen | f413b2d | 2014-02-26 20:28:52 +0000 | [diff] [blame] | 2487 | #ifdef INET |
t00fcxen | 23069ba | 2014-01-04 12:26:30 +0000 | [diff] [blame] | 2488 | case AF_INET: |
| 2489 | sin = (struct sockaddr_in *)gaddrs->addr; |
| 2490 | sin->sin_port = sport; |
| 2491 | break; |
t00fcxen | f413b2d | 2014-02-26 20:28:52 +0000 | [diff] [blame] | 2492 | #endif |
| 2493 | #ifdef INET6 |
t00fcxen | 23069ba | 2014-01-04 12:26:30 +0000 | [diff] [blame] | 2494 | case AF_INET6: |
| 2495 | sin6 = (struct sockaddr_in6 *)gaddrs->addr; |
| 2496 | sin6->sin6_port = sport; |
| 2497 | break; |
t00fcxen | f413b2d | 2014-02-26 20:28:52 +0000 | [diff] [blame] | 2498 | #endif |
t00fcxen | 23069ba | 2014-01-04 12:26:30 +0000 | [diff] [blame] | 2499 | } |
| 2500 | } |
t00fcxen | b374a4f | 2014-03-18 22:34:21 +0000 | [diff] [blame] | 2501 | #endif |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2502 | if (usrsctp_setsockopt(so, IPPROTO_SCTP, flags, gaddrs, (socklen_t)argsz) != 0) { |
| 2503 | free(gaddrs); |
| 2504 | return (-1); |
| 2505 | } |
| 2506 | sa = (struct sockaddr *)((caddr_t)sa + sa_len); |
| 2507 | #endif |
| 2508 | } |
| 2509 | free(gaddrs); |
| 2510 | return (0); |
| 2511 | } |
| 2512 | |
| 2513 | int |
| 2514 | usrsctp_connectx(struct socket *so, |
| 2515 | const struct sockaddr *addrs, int addrcnt, |
| 2516 | sctp_assoc_t *id) |
| 2517 | { |
t00fcxen | 5d7df6a | 2013-10-31 13:22:14 +0000 | [diff] [blame] | 2518 | #if defined(INET) || defined(INET6) |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2519 | char buf[SCTP_STACK_BUF_SIZE]; |
| 2520 | int i, ret, cnt, *aa; |
| 2521 | char *cpto; |
| 2522 | const struct sockaddr *at; |
| 2523 | sctp_assoc_t *p_id; |
| 2524 | size_t len = sizeof(int); |
| 2525 | |
| 2526 | /* validate the address count and list */ |
| 2527 | if ((addrs == NULL) || (addrcnt <= 0)) { |
| 2528 | errno = EINVAL; |
| 2529 | return (-1); |
| 2530 | } |
| 2531 | at = addrs; |
| 2532 | cnt = 0; |
| 2533 | cpto = ((caddr_t)buf + sizeof(int)); |
| 2534 | /* validate all the addresses and get the size */ |
| 2535 | for (i = 0; i < addrcnt; i++) { |
| 2536 | switch (at->sa_family) { |
| 2537 | #ifdef INET |
| 2538 | case AF_INET: |
| 2539 | #ifdef HAVE_SA_LEN |
| 2540 | if (at->sa_len != sizeof(struct sockaddr_in)) { |
| 2541 | errno = EINVAL; |
| 2542 | return (-1); |
| 2543 | } |
| 2544 | #endif |
| 2545 | memcpy(cpto, at, sizeof(struct sockaddr_in)); |
| 2546 | cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in)); |
| 2547 | len += sizeof(struct sockaddr_in); |
| 2548 | at = (struct sockaddr *)((caddr_t)at + sizeof(struct sockaddr_in)); |
| 2549 | break; |
| 2550 | #endif |
| 2551 | #ifdef INET6 |
| 2552 | case AF_INET6: |
| 2553 | #ifdef HAVE_SA_LEN |
| 2554 | if (at->sa_len != sizeof(struct sockaddr_in6)) { |
| 2555 | errno = EINVAL; |
| 2556 | return (-1); |
| 2557 | } |
| 2558 | #endif |
| 2559 | if (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)at)->sin6_addr)) { |
| 2560 | in6_sin6_2_sin((struct sockaddr_in *)cpto, (struct sockaddr_in6 *)at); |
| 2561 | cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in)); |
| 2562 | len += sizeof(struct sockaddr_in); |
| 2563 | } else { |
| 2564 | memcpy(cpto, at, sizeof(struct sockaddr_in6)); |
| 2565 | cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in6)); |
| 2566 | len += sizeof(struct sockaddr_in6); |
| 2567 | } |
| 2568 | at = (struct sockaddr *)((caddr_t)at + sizeof(struct sockaddr_in6)); |
| 2569 | break; |
| 2570 | #endif |
| 2571 | default: |
| 2572 | errno = EINVAL; |
| 2573 | return (-1); |
| 2574 | } |
| 2575 | if (len > (sizeof(buf) - sizeof(int))) { |
| 2576 | /* Never enough memory */ |
| 2577 | errno = E2BIG; |
| 2578 | return (-1); |
| 2579 | } |
| 2580 | cnt++; |
| 2581 | } |
| 2582 | /* do we have any? */ |
| 2583 | if (cnt == 0) { |
| 2584 | errno = EINVAL; |
| 2585 | return (-1); |
| 2586 | } |
| 2587 | aa = (int *)buf; |
| 2588 | *aa = cnt; |
| 2589 | ret = usrsctp_setsockopt(so, IPPROTO_SCTP, SCTP_CONNECT_X, (void *)buf, (socklen_t)len); |
| 2590 | if ((ret == 0) && id) { |
| 2591 | p_id = (sctp_assoc_t *)buf; |
| 2592 | *id = *p_id; |
| 2593 | } |
| 2594 | return (ret); |
t00fcxen | 5d7df6a | 2013-10-31 13:22:14 +0000 | [diff] [blame] | 2595 | #else |
| 2596 | errno = EINVAL; |
| 2597 | return (-1); |
| 2598 | #endif |
t00fcxen | 72939a6 | 2012-11-19 10:53:00 +0000 | [diff] [blame] | 2599 | } |
| 2600 | |
| 2601 | int |
t00fcxen | 112778d | 2012-11-18 17:40:06 +0000 | [diff] [blame] | 2602 | usrsctp_getpaddrs(struct socket *so, sctp_assoc_t id, struct sockaddr **raddrs) |
| 2603 | { |
| 2604 | struct sctp_getaddresses *addrs; |
| 2605 | struct sockaddr *sa; |
| 2606 | sctp_assoc_t asoc; |
| 2607 | caddr_t lim; |
| 2608 | socklen_t opt_len; |
| 2609 | int cnt; |
| 2610 | |
| 2611 | if (raddrs == NULL) { |
| 2612 | errno = EFAULT; |
| 2613 | return (-1); |
| 2614 | } |
| 2615 | asoc = id; |
| 2616 | opt_len = (socklen_t)sizeof(sctp_assoc_t); |
| 2617 | if (usrsctp_getsockopt(so, IPPROTO_SCTP, SCTP_GET_REMOTE_ADDR_SIZE, &asoc, &opt_len) != 0) { |
| 2618 | return (-1); |
| 2619 | } |
| 2620 | /* size required is returned in 'asoc' */ |
| 2621 | opt_len = (socklen_t)((size_t)asoc + sizeof(struct sctp_getaddresses)); |
| 2622 | addrs = calloc(1, (size_t)opt_len); |
| 2623 | if (addrs == NULL) { |
| 2624 | errno = ENOMEM; |
| 2625 | return (-1); |
| 2626 | } |
| 2627 | addrs->sget_assoc_id = id; |
| 2628 | /* Now lets get the array of addresses */ |
| 2629 | if (usrsctp_getsockopt(so, IPPROTO_SCTP, SCTP_GET_PEER_ADDRESSES, addrs, &opt_len) != 0) { |
| 2630 | free(addrs); |
| 2631 | return (-1); |
| 2632 | } |
| 2633 | *raddrs = (struct sockaddr *)&addrs->addr[0]; |
| 2634 | cnt = 0; |
| 2635 | sa = (struct sockaddr *)&addrs->addr[0]; |
| 2636 | lim = (caddr_t)addrs + opt_len; |
| 2637 | #ifdef HAVE_SA_LEN |
| 2638 | while (((caddr_t)sa < lim) && (sa->sa_len > 0)) { |
| 2639 | sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len); |
| 2640 | #else |
| 2641 | while ((caddr_t)sa < lim) { |
| 2642 | switch (sa->sa_family) { |
| 2643 | #ifdef INET |
| 2644 | case AF_INET: |
| 2645 | sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in)); |
| 2646 | break; |
| 2647 | #endif |
| 2648 | #ifdef INET6 |
| 2649 | case AF_INET6: |
| 2650 | sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6)); |
| 2651 | break; |
| 2652 | #endif |
| 2653 | case AF_CONN: |
| 2654 | sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_conn)); |
| 2655 | break; |
| 2656 | default: |
| 2657 | return (cnt); |
| 2658 | break; |
| 2659 | } |
| 2660 | #endif |
| 2661 | cnt++; |
| 2662 | } |
| 2663 | return (cnt); |
| 2664 | } |
| 2665 | |
| 2666 | void |
| 2667 | usrsctp_freepaddrs(struct sockaddr *addrs) |
| 2668 | { |
| 2669 | /* Take away the hidden association id */ |
| 2670 | void *fr_addr; |
| 2671 | |
| 2672 | fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t)); |
| 2673 | /* Now free it */ |
| 2674 | free(fr_addr); |
| 2675 | } |
| 2676 | |
| 2677 | int |
| 2678 | usrsctp_getladdrs(struct socket *so, sctp_assoc_t id, struct sockaddr **raddrs) |
| 2679 | { |
| 2680 | struct sctp_getaddresses *addrs; |
| 2681 | caddr_t lim; |
| 2682 | struct sockaddr *sa; |
| 2683 | size_t size_of_addresses; |
| 2684 | socklen_t opt_len; |
| 2685 | int cnt; |
| 2686 | |
| 2687 | if (raddrs == NULL) { |
| 2688 | errno = EFAULT; |
| 2689 | return (-1); |
| 2690 | } |
| 2691 | size_of_addresses = 0; |
| 2692 | opt_len = (socklen_t)sizeof(int); |
| 2693 | if (usrsctp_getsockopt(so, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDR_SIZE, &size_of_addresses, &opt_len) != 0) { |
| 2694 | errno = ENOMEM; |
| 2695 | return (-1); |
| 2696 | } |
| 2697 | if (size_of_addresses == 0) { |
| 2698 | errno = ENOTCONN; |
| 2699 | return (-1); |
| 2700 | } |
| 2701 | opt_len = (socklen_t)(size_of_addresses + |
| 2702 | sizeof(struct sockaddr_storage) + |
| 2703 | sizeof(struct sctp_getaddresses)); |
| 2704 | addrs = calloc(1, (size_t)opt_len); |
| 2705 | if (addrs == NULL) { |
| 2706 | errno = ENOMEM; |
| 2707 | return (-1); |
| 2708 | } |
| 2709 | addrs->sget_assoc_id = id; |
| 2710 | /* Now lets get the array of addresses */ |
| 2711 | if (usrsctp_getsockopt(so, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDRESSES, addrs, &opt_len) != 0) { |
| 2712 | free(addrs); |
| 2713 | errno = ENOMEM; |
| 2714 | return (-1); |
| 2715 | } |
| 2716 | *raddrs = (struct sockaddr *)&addrs->addr[0]; |
| 2717 | cnt = 0; |
| 2718 | sa = (struct sockaddr *)&addrs->addr[0]; |
| 2719 | lim = (caddr_t)addrs + opt_len; |
| 2720 | #ifdef HAVE_SA_LEN |
| 2721 | while (((caddr_t)sa < lim) && (sa->sa_len > 0)) { |
| 2722 | sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len); |
| 2723 | #else |
| 2724 | while ((caddr_t)sa < lim) { |
| 2725 | switch (sa->sa_family) { |
| 2726 | #ifdef INET |
| 2727 | case AF_INET: |
| 2728 | sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in)); |
| 2729 | break; |
| 2730 | #endif |
| 2731 | #ifdef INET6 |
| 2732 | case AF_INET6: |
| 2733 | sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_in6)); |
| 2734 | break; |
| 2735 | #endif |
| 2736 | case AF_CONN: |
| 2737 | sa = (struct sockaddr *)((caddr_t)sa + sizeof(struct sockaddr_conn)); |
| 2738 | break; |
| 2739 | default: |
| 2740 | return (cnt); |
| 2741 | break; |
| 2742 | } |
| 2743 | #endif |
| 2744 | cnt++; |
| 2745 | } |
| 2746 | return (cnt); |
| 2747 | } |
| 2748 | |
| 2749 | void |
| 2750 | usrsctp_freeladdrs(struct sockaddr *addrs) |
| 2751 | { |
| 2752 | /* Take away the hidden association id */ |
| 2753 | void *fr_addr; |
| 2754 | |
| 2755 | fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t)); |
| 2756 | /* Now free it */ |
| 2757 | free(fr_addr); |
| 2758 | } |
| 2759 | |
tuexen | 656fe4c | 2012-06-28 16:54:10 +0000 | [diff] [blame] | 2760 | #ifdef INET |
tuexen | 89310d4 | 2011-12-15 21:53:09 +0000 | [diff] [blame] | 2761 | void |
| 2762 | sctp_userspace_ip_output(int *result, struct mbuf *o_pak, |
t00fcxen | e4ac8c0 | 2012-09-14 13:15:24 +0000 | [diff] [blame] | 2763 | sctp_route_t *ro, void *stcb, |
tuexen | 89310d4 | 2011-12-15 21:53:09 +0000 | [diff] [blame] | 2764 | uint32_t vrf_id) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2765 | { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2766 | struct mbuf *m; |
| 2767 | struct mbuf *m_orig; |
| 2768 | int iovcnt; |
| 2769 | int send_len; |
| 2770 | int len; |
| 2771 | int send_count; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2772 | struct ip *ip; |
| 2773 | struct udphdr *udp; |
tuexen | b63afcd | 2012-07-11 22:44:32 +0000 | [diff] [blame] | 2774 | #if !defined (__Userspace_os_Windows) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2775 | int res; |
tuexen | b63afcd | 2012-07-11 22:44:32 +0000 | [diff] [blame] | 2776 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2777 | struct sockaddr_in dst; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2778 | #if defined (__Userspace_os_Windows) |
| 2779 | WSAMSG win_msg_hdr; |
| 2780 | int win_sent_len; |
| 2781 | WSABUF send_iovec[MAXLEN_MBUF_CHAIN]; |
| 2782 | WSABUF winbuf; |
| 2783 | #else |
| 2784 | struct iovec send_iovec[MAXLEN_MBUF_CHAIN]; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2785 | struct msghdr msg_hdr; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2786 | #endif |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2787 | int use_udp_tunneling; |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 2788 | |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2789 | *result = 0; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2790 | |
| 2791 | m = SCTP_HEADER_TO_CHAIN(o_pak); |
| 2792 | m_orig = m; |
| 2793 | |
| 2794 | len = sizeof(struct ip); |
| 2795 | if (SCTP_BUF_LEN(m) < len) { |
| 2796 | if ((m = m_pullup(m, len)) == 0) { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2797 | SCTP_PRINTF("Can not get the IP header in the first mbuf.\n"); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2798 | return; |
| 2799 | } |
| 2800 | } |
| 2801 | ip = mtod(m, struct ip *); |
| 2802 | use_udp_tunneling = (ip->ip_p == IPPROTO_UDP); |
| 2803 | |
| 2804 | if (use_udp_tunneling) { |
| 2805 | len = sizeof(struct ip) + sizeof(struct udphdr); |
| 2806 | if (SCTP_BUF_LEN(m) < len) { |
| 2807 | if ((m = m_pullup(m, len)) == 0) { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2808 | SCTP_PRINTF("Can not get the UDP/IP header in the first mbuf.\n"); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2809 | return; |
| 2810 | } |
| 2811 | ip = mtod(m, struct ip *); |
| 2812 | } |
| 2813 | udp = (struct udphdr *)(ip + 1); |
t00fcxen | b574145 | 2013-12-27 09:49:11 +0000 | [diff] [blame] | 2814 | } else { |
| 2815 | udp = NULL; |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2816 | } |
| 2817 | |
| 2818 | if (!use_udp_tunneling) { |
| 2819 | if (ip->ip_src.s_addr == INADDR_ANY) { |
| 2820 | /* TODO get addr of outgoing interface */ |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2821 | SCTP_PRINTF("Why did the SCTP implementation did not choose a source address?\n"); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2822 | } |
| 2823 | /* TODO need to worry about ro->ro_dst as in ip_output? */ |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2824 | #if defined(__Userspace_os_Linux) || defined (__Userspace_os_Windows) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2825 | /* need to put certain fields into network order for Linux */ |
| 2826 | ip->ip_len = htons(ip->ip_len); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2827 | ip->ip_off = 0; |
| 2828 | #endif |
| 2829 | } |
| 2830 | |
| 2831 | memset((void *)&dst, 0, sizeof(struct sockaddr_in)); |
| 2832 | dst.sin_family = AF_INET; |
| 2833 | dst.sin_addr.s_addr = ip->ip_dst.s_addr; |
t00fcxen | 7b0ab5c | 2012-09-04 16:41:39 +0000 | [diff] [blame] | 2834 | #ifdef HAVE_SIN_LEN |
tuexen | 4e69eed | 2011-11-14 16:31:35 +0000 | [diff] [blame] | 2835 | dst.sin_len = sizeof(struct sockaddr_in); |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2836 | #endif |
| 2837 | if (use_udp_tunneling) { |
| 2838 | dst.sin_port = udp->uh_dport; |
| 2839 | } else { |
| 2840 | dst.sin_port = 0; |
| 2841 | } |
| 2842 | |
tuexen | 4e69eed | 2011-11-14 16:31:35 +0000 | [diff] [blame] | 2843 | /* tweak the mbuf chain */ |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2844 | if (use_udp_tunneling) { |
| 2845 | m_adj(m, sizeof(struct ip) + sizeof(struct udphdr)); |
| 2846 | } |
| 2847 | |
| 2848 | send_len = SCTP_HEADER_LEN(m); /* length of entire packet */ |
| 2849 | send_count = 0; |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2850 | for (iovcnt = 0; m != NULL && iovcnt < MAXLEN_MBUF_CHAIN; m = m->m_next, iovcnt++) { |
| 2851 | #if !defined (__Userspace_os_Windows) |
| 2852 | send_iovec[iovcnt].iov_base = (caddr_t)m->m_data; |
| 2853 | send_iovec[iovcnt].iov_len = SCTP_BUF_LEN(m); |
| 2854 | send_count += send_iovec[iovcnt].iov_len; |
| 2855 | #else |
| 2856 | send_iovec[iovcnt].buf = (caddr_t)m->m_data; |
| 2857 | send_iovec[iovcnt].len = SCTP_BUF_LEN(m); |
| 2858 | send_count += send_iovec[iovcnt].len; |
| 2859 | #endif |
| 2860 | } |
| 2861 | |
| 2862 | if (m != NULL) { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2863 | SCTP_PRINTF("mbuf chain couldn't be copied completely\n"); |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2864 | goto free_mbuf; |
| 2865 | } |
| 2866 | |
| 2867 | #if !defined (__Userspace_os_Windows) |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2868 | msg_hdr.msg_name = (struct sockaddr *) &dst; |
| 2869 | msg_hdr.msg_namelen = sizeof(struct sockaddr_in); |
| 2870 | msg_hdr.msg_iov = send_iovec; |
| 2871 | msg_hdr.msg_iovlen = iovcnt; |
| 2872 | msg_hdr.msg_control = NULL; |
| 2873 | msg_hdr.msg_controllen = 0; |
| 2874 | msg_hdr.msg_flags = 0; |
| 2875 | |
tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 2876 | if ((!use_udp_tunneling) && (SCTP_BASE_VAR(userspace_rawsctp) > -1)) { |
| 2877 | if ((res = sendmsg(SCTP_BASE_VAR(userspace_rawsctp), &msg_hdr, MSG_DONTWAIT)) != send_len) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2878 | *result = errno; |
| 2879 | } |
| 2880 | } |
tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 2881 | if ((use_udp_tunneling) && (SCTP_BASE_VAR(userspace_udpsctp) > -1)) { |
| 2882 | if ((res = sendmsg(SCTP_BASE_VAR(userspace_udpsctp), &msg_hdr, MSG_DONTWAIT)) != send_len) { |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2883 | *result = errno; |
| 2884 | } |
| 2885 | } |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2886 | #else |
| 2887 | win_msg_hdr.name = (struct sockaddr *) &dst; |
| 2888 | win_msg_hdr.namelen = sizeof(struct sockaddr_in); |
| 2889 | win_msg_hdr.lpBuffers = (LPWSABUF)send_iovec; |
| 2890 | win_msg_hdr.dwBufferCount = iovcnt; |
| 2891 | winbuf.len = 0; |
| 2892 | winbuf.buf = NULL; |
| 2893 | win_msg_hdr.Control = winbuf; |
| 2894 | win_msg_hdr.dwFlags = 0; |
| 2895 | |
tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 2896 | if ((!use_udp_tunneling) && (SCTP_BASE_VAR(userspace_rawsctp) > -1)) { |
ruengeler | 4f97bd6 | 2012-07-05 09:19:02 +0000 | [diff] [blame] | 2897 | if (WSASendTo(SCTP_BASE_VAR(userspace_rawsctp), (LPWSABUF) send_iovec, iovcnt, &win_sent_len, win_msg_hdr.dwFlags, win_msg_hdr.name, (int) win_msg_hdr.namelen, NULL, NULL) != 0) { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2898 | *result = WSAGetLastError(); |
| 2899 | } else if (win_sent_len != send_len) { |
| 2900 | *result = WSAGetLastError(); |
| 2901 | } |
| 2902 | } |
tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 2903 | if ((use_udp_tunneling) && (SCTP_BASE_VAR(userspace_udpsctp) > -1)) { |
ruengeler | 4f97bd6 | 2012-07-05 09:19:02 +0000 | [diff] [blame] | 2904 | if (WSASendTo(SCTP_BASE_VAR(userspace_udpsctp), (LPWSABUF) send_iovec, iovcnt, &win_sent_len, win_msg_hdr.dwFlags, win_msg_hdr.name, (int) win_msg_hdr.namelen, NULL, NULL) != 0) { |
tuexen | 9c5fce7 | 2011-12-15 17:47:17 +0000 | [diff] [blame] | 2905 | *result = WSAGetLastError(); |
| 2906 | } else if (win_sent_len != send_len) { |
| 2907 | *result = WSAGetLastError(); |
| 2908 | } |
| 2909 | } |
| 2910 | #endif |
| 2911 | free_mbuf: |
tuexen | bca1dae | 2011-11-01 23:02:02 +0000 | [diff] [blame] | 2912 | sctp_m_freem(m_orig); |
| 2913 | } |
tuexen | 656fe4c | 2012-06-28 16:54:10 +0000 | [diff] [blame] | 2914 | #endif |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2915 | |
| 2916 | #if defined (INET6) |
| 2917 | void sctp_userspace_ip6_output(int *result, struct mbuf *o_pak, |
| 2918 | struct route_in6 *ro, void *stcb, |
| 2919 | uint32_t vrf_id) |
| 2920 | { |
| 2921 | struct mbuf *m; |
| 2922 | struct mbuf *m_orig; |
| 2923 | int iovcnt; |
| 2924 | int send_len; |
| 2925 | int len; |
| 2926 | int send_count; |
| 2927 | struct ip6_hdr *ip6; |
| 2928 | struct udphdr *udp; |
tuexen | b63afcd | 2012-07-11 22:44:32 +0000 | [diff] [blame] | 2929 | #if !defined (__Userspace_os_Windows) |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2930 | int res; |
tuexen | b63afcd | 2012-07-11 22:44:32 +0000 | [diff] [blame] | 2931 | #endif |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2932 | struct sockaddr_in6 dst; |
| 2933 | #if defined (__Userspace_os_Windows) |
| 2934 | WSAMSG win_msg_hdr; |
| 2935 | int win_sent_len; |
| 2936 | WSABUF send_iovec[MAXLEN_MBUF_CHAIN]; |
| 2937 | WSABUF winbuf; |
| 2938 | #else |
| 2939 | struct iovec send_iovec[MAXLEN_MBUF_CHAIN]; |
| 2940 | struct msghdr msg_hdr; |
| 2941 | #endif |
| 2942 | int use_udp_tunneling; |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 2943 | |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2944 | *result = 0; |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2945 | |
| 2946 | m = SCTP_HEADER_TO_CHAIN(o_pak); |
| 2947 | m_orig = m; |
| 2948 | |
| 2949 | len = sizeof(struct ip6_hdr); |
| 2950 | |
| 2951 | if (SCTP_BUF_LEN(m) < len) { |
| 2952 | if ((m = m_pullup(m, len)) == 0) { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2953 | SCTP_PRINTF("Can not get the IP header in the first mbuf.\n"); |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2954 | return; |
| 2955 | } |
| 2956 | } |
| 2957 | |
| 2958 | ip6 = mtod(m, struct ip6_hdr *); |
| 2959 | use_udp_tunneling = (ip6->ip6_nxt == IPPROTO_UDP); |
| 2960 | |
| 2961 | if (use_udp_tunneling) { |
| 2962 | len = sizeof(struct ip6_hdr) + sizeof(struct udphdr); |
| 2963 | if (SCTP_BUF_LEN(m) < len) { |
| 2964 | if ((m = m_pullup(m, len)) == 0) { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2965 | SCTP_PRINTF("Can not get the UDP/IP header in the first mbuf.\n"); |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2966 | return; |
| 2967 | } |
| 2968 | ip6 = mtod(m, struct ip6_hdr *); |
| 2969 | } |
| 2970 | udp = (struct udphdr *)(ip6 + 1); |
t00fcxen | b574145 | 2013-12-27 09:49:11 +0000 | [diff] [blame] | 2971 | } else { |
| 2972 | udp = NULL; |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2973 | } |
| 2974 | |
| 2975 | if (!use_udp_tunneling) { |
| 2976 | if (ip6->ip6_src.s6_addr == in6addr_any.s6_addr) { |
| 2977 | /* TODO get addr of outgoing interface */ |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 2978 | SCTP_PRINTF("Why did the SCTP implementation did not choose a source address?\n"); |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2979 | } |
| 2980 | /* TODO need to worry about ro->ro_dst as in ip_output? */ |
| 2981 | #if defined(__Userspace_os_Linux) || defined (__Userspace_os_Windows) |
| 2982 | /* need to put certain fields into network order for Linux */ |
| 2983 | ip6->ip6_plen = htons(ip6->ip6_plen); |
| 2984 | #endif |
| 2985 | } |
| 2986 | |
| 2987 | memset((void *)&dst, 0, sizeof(struct sockaddr_in6)); |
| 2988 | dst.sin6_family = AF_INET6; |
| 2989 | dst.sin6_addr = ip6->ip6_dst; |
t00fcxen | 7b0ab5c | 2012-09-04 16:41:39 +0000 | [diff] [blame] | 2990 | #ifdef HAVE_SIN6_LEN |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 2991 | dst.sin6_len = sizeof(struct sockaddr_in6); |
| 2992 | #endif |
| 2993 | |
| 2994 | if (use_udp_tunneling) { |
| 2995 | dst.sin6_port = udp->uh_dport; |
| 2996 | } else { |
| 2997 | dst.sin6_port = 0; |
| 2998 | } |
| 2999 | |
| 3000 | /* tweak the mbuf chain */ |
| 3001 | if (use_udp_tunneling) { |
| 3002 | m_adj(m, sizeof(struct ip6_hdr) + sizeof(struct udphdr)); |
| 3003 | } else { |
| 3004 | m_adj(m, sizeof(struct ip6_hdr)); |
| 3005 | } |
| 3006 | |
| 3007 | send_len = SCTP_HEADER_LEN(m); /* length of entire packet */ |
| 3008 | send_count = 0; |
| 3009 | for (iovcnt = 0; m != NULL && iovcnt < MAXLEN_MBUF_CHAIN; m = m->m_next, iovcnt++) { |
| 3010 | #if !defined (__Userspace_os_Windows) |
| 3011 | send_iovec[iovcnt].iov_base = (caddr_t)m->m_data; |
| 3012 | send_iovec[iovcnt].iov_len = SCTP_BUF_LEN(m); |
| 3013 | send_count += send_iovec[iovcnt].iov_len; |
| 3014 | #else |
| 3015 | send_iovec[iovcnt].buf = (caddr_t)m->m_data; |
| 3016 | send_iovec[iovcnt].len = SCTP_BUF_LEN(m); |
| 3017 | send_count += send_iovec[iovcnt].len; |
| 3018 | #endif |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 3019 | } |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 3020 | if (m != NULL) { |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3021 | SCTP_PRINTF("mbuf chain couldn't be copied completely\n"); |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 3022 | goto free_mbuf; |
tuexen | f3d0e4f | 2012-04-16 15:12:45 +0000 | [diff] [blame] | 3023 | } |
| 3024 | |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 3025 | #if !defined (__Userspace_os_Windows) |
| 3026 | msg_hdr.msg_name = (struct sockaddr *) &dst; |
| 3027 | msg_hdr.msg_namelen = sizeof(struct sockaddr_in6); |
| 3028 | msg_hdr.msg_iov = send_iovec; |
| 3029 | msg_hdr.msg_iovlen = iovcnt; |
| 3030 | msg_hdr.msg_control = NULL; |
| 3031 | msg_hdr.msg_controllen = 0; |
| 3032 | msg_hdr.msg_flags = 0; |
| 3033 | |
tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 3034 | if ((!use_udp_tunneling) && (SCTP_BASE_VAR(userspace_rawsctp6) > -1)) { |
| 3035 | if ((res = sendmsg(SCTP_BASE_VAR(userspace_rawsctp6), &msg_hdr, MSG_DONTWAIT)) != send_len) { |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 3036 | *result = errno; |
| 3037 | } |
| 3038 | } |
tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 3039 | if ((use_udp_tunneling) && (SCTP_BASE_VAR(userspace_udpsctp6) > -1)) { |
| 3040 | if ((res = sendmsg(SCTP_BASE_VAR(userspace_udpsctp6), &msg_hdr, MSG_DONTWAIT)) != send_len) { |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 3041 | *result = errno; |
| 3042 | } |
| 3043 | } |
| 3044 | #else |
| 3045 | win_msg_hdr.name = (struct sockaddr *) &dst; |
| 3046 | win_msg_hdr.namelen = sizeof(struct sockaddr_in6); |
| 3047 | win_msg_hdr.lpBuffers = (LPWSABUF)send_iovec; |
| 3048 | win_msg_hdr.dwBufferCount = iovcnt; |
| 3049 | winbuf.len = 0; |
| 3050 | winbuf.buf = NULL; |
| 3051 | win_msg_hdr.Control = winbuf; |
| 3052 | win_msg_hdr.dwFlags = 0; |
| 3053 | |
tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 3054 | if ((!use_udp_tunneling) && (SCTP_BASE_VAR(userspace_rawsctp6) > -1)) { |
ruengeler | 4f97bd6 | 2012-07-05 09:19:02 +0000 | [diff] [blame] | 3055 | if (WSASendTo(SCTP_BASE_VAR(userspace_rawsctp6), (LPWSABUF) send_iovec, iovcnt, &win_sent_len, win_msg_hdr.dwFlags, win_msg_hdr.name, (int) win_msg_hdr.namelen, NULL, NULL) != 0) { |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 3056 | *result = WSAGetLastError(); |
| 3057 | } else if (win_sent_len != send_len) { |
| 3058 | *result = WSAGetLastError(); |
| 3059 | } |
| 3060 | } |
tuexen | b735c0f | 2012-04-28 16:43:56 +0000 | [diff] [blame] | 3061 | if ((use_udp_tunneling) && (SCTP_BASE_VAR(userspace_udpsctp6) > -1)) { |
ruengeler | 4f97bd6 | 2012-07-05 09:19:02 +0000 | [diff] [blame] | 3062 | if (WSASendTo(SCTP_BASE_VAR(userspace_udpsctp6), (LPWSABUF) send_iovec, iovcnt, &win_sent_len, win_msg_hdr.dwFlags, win_msg_hdr.name, (int) win_msg_hdr.namelen, NULL, NULL) != 0) { |
tuexen | 07961c4 | 2011-12-23 15:39:36 +0000 | [diff] [blame] | 3063 | *result = WSAGetLastError(); |
| 3064 | } else if (win_sent_len != send_len) { |
| 3065 | *result = WSAGetLastError(); |
| 3066 | } |
| 3067 | } |
| 3068 | #endif |
| 3069 | free_mbuf: |
| 3070 | sctp_m_freem(m_orig); |
| 3071 | } |
| 3072 | #endif |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3073 | |
t00fcxen | 20307bc | 2012-12-28 17:47:22 +0000 | [diff] [blame] | 3074 | void |
| 3075 | usrsctp_register_address(void *addr) |
| 3076 | { |
| 3077 | struct sockaddr_conn sconn; |
| 3078 | |
| 3079 | memset(&sconn, 0, sizeof(struct sockaddr_conn)); |
| 3080 | sconn.sconn_family = AF_CONN; |
| 3081 | #ifdef HAVE_SCONN_LEN |
| 3082 | sconn.sconn_len = sizeof(struct sockaddr_conn); |
| 3083 | #endif |
| 3084 | sconn.sconn_port = 0; |
| 3085 | sconn.sconn_addr = addr; |
| 3086 | sctp_add_addr_to_vrf(SCTP_DEFAULT_VRFID, |
| 3087 | NULL, |
| 3088 | 0xffffffff, |
| 3089 | 0, |
| 3090 | "conn", |
| 3091 | NULL, |
| 3092 | (struct sockaddr *)&sconn, |
| 3093 | 0, |
| 3094 | 0); |
| 3095 | } |
| 3096 | |
| 3097 | void |
| 3098 | usrsctp_deregister_address(void *addr) |
| 3099 | { |
| 3100 | struct sockaddr_conn sconn; |
| 3101 | |
| 3102 | memset(&sconn, 0, sizeof(struct sockaddr_conn)); |
| 3103 | sconn.sconn_family = AF_CONN; |
| 3104 | #ifdef HAVE_SCONN_LEN |
| 3105 | sconn.sconn_len = sizeof(struct sockaddr_conn); |
| 3106 | #endif |
| 3107 | sconn.sconn_port = 0; |
| 3108 | sconn.sconn_addr = addr; |
| 3109 | sctp_del_addr_from_vrf(SCTP_DEFAULT_VRFID, |
| 3110 | (struct sockaddr *)&sconn, |
| 3111 | 0xffffffff, |
| 3112 | "conn"); |
| 3113 | } |
| 3114 | |
t00fcxen | 324854c | 2013-02-10 20:13:22 +0000 | [diff] [blame] | 3115 | #define PREAMBLE_FORMAT "\n%c %02d:%02d:%02d.%06ld " |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3116 | #define PREAMBLE_LENGTH 19 |
| 3117 | #define HEADER "0000 " |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3118 | #define TRAILER "# SCTP_PACKET\n" |
| 3119 | |
t00fcxen | 56c7d1c | 2012-11-25 14:36:23 +0000 | [diff] [blame] | 3120 | char * |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3121 | usrsctp_dumppacket(void *buf, size_t len, int outbound) |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3122 | { |
| 3123 | size_t i, pos; |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3124 | char *dump_buf, *packet; |
t00fcxen | 95eb2c4 | 2012-12-26 20:22:53 +0000 | [diff] [blame] | 3125 | #ifdef _WIN32 |
| 3126 | struct timeb tb; |
| 3127 | struct tm t; |
| 3128 | #else |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3129 | struct timeval tv; |
| 3130 | struct tm *t; |
t00fcxen | 9eca21f | 2013-02-27 13:06:51 +0000 | [diff] [blame] | 3131 | time_t sec; |
t00fcxen | 95eb2c4 | 2012-12-26 20:22:53 +0000 | [diff] [blame] | 3132 | #endif |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3133 | |
t00fcxen | 95eb2c4 | 2012-12-26 20:22:53 +0000 | [diff] [blame] | 3134 | if ((len == 0) || (buf == NULL)) { |
t00fcxen | 56c7d1c | 2012-11-25 14:36:23 +0000 | [diff] [blame] | 3135 | return (NULL); |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3136 | } |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3137 | if ((dump_buf = malloc(PREAMBLE_LENGTH + strlen(HEADER) + 3 * len + strlen(TRAILER) + 1)) == NULL) { |
| 3138 | return (NULL); |
| 3139 | } |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3140 | pos = 0; |
t00fcxen | 95eb2c4 | 2012-12-26 20:22:53 +0000 | [diff] [blame] | 3141 | #ifdef _WIN32 |
| 3142 | ftime(&tb); |
| 3143 | localtime_s(&t, &tb.time); |
| 3144 | _snprintf_s(dump_buf, PREAMBLE_LENGTH + 1, PREAMBLE_LENGTH, PREAMBLE_FORMAT, |
t00fcxen | 32f19d4 | 2012-12-27 00:04:59 +0000 | [diff] [blame] | 3145 | outbound ? 'O' : 'I', |
t00fcxen | 8e7c10c | 2013-02-10 20:17:56 +0000 | [diff] [blame] | 3146 | t.tm_hour, t.tm_min, t.tm_sec, (long)(1000 * tb.millitm)); |
t00fcxen | 95eb2c4 | 2012-12-26 20:22:53 +0000 | [diff] [blame] | 3147 | #else |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3148 | gettimeofday(&tv, NULL); |
t00fcxen | 9eca21f | 2013-02-27 13:06:51 +0000 | [diff] [blame] | 3149 | sec = (time_t)tv.tv_sec; |
| 3150 | t = localtime((const time_t *)&sec); |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3151 | snprintf(dump_buf, PREAMBLE_LENGTH + 1, PREAMBLE_FORMAT, |
| 3152 | outbound ? 'O' : 'I', |
t00fcxen | 8e7c10c | 2013-02-10 20:17:56 +0000 | [diff] [blame] | 3153 | t->tm_hour, t->tm_min, t->tm_sec, (long)tv.tv_usec); |
t00fcxen | 95eb2c4 | 2012-12-26 20:22:53 +0000 | [diff] [blame] | 3154 | #endif |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3155 | pos += PREAMBLE_LENGTH; |
t00fcxen | 32f19d4 | 2012-12-27 00:04:59 +0000 | [diff] [blame] | 3156 | #ifdef _WIN32 |
t00fcxen | ce77eb0 | 2012-12-27 00:22:15 +0000 | [diff] [blame] | 3157 | strncpy_s(dump_buf + pos, strlen(HEADER) + 1, HEADER, strlen(HEADER)); |
t00fcxen | 32f19d4 | 2012-12-27 00:04:59 +0000 | [diff] [blame] | 3158 | #else |
t00fcxen | 95eb2c4 | 2012-12-26 20:22:53 +0000 | [diff] [blame] | 3159 | strcpy(dump_buf + pos, HEADER); |
t00fcxen | 32f19d4 | 2012-12-27 00:04:59 +0000 | [diff] [blame] | 3160 | #endif |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3161 | pos += strlen(HEADER); |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3162 | packet = (char *)buf; |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3163 | for (i = 0; i < len; i++) { |
| 3164 | uint8_t byte, low, high; |
| 3165 | |
| 3166 | byte = (uint8_t)packet[i]; |
| 3167 | high = byte / 16; |
| 3168 | low = byte % 16; |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3169 | dump_buf[pos++] = high < 10 ? '0' + high : 'a' + (high - 10); |
| 3170 | dump_buf[pos++] = low < 10 ? '0' + low : 'a' + (low - 10); |
| 3171 | dump_buf[pos++] = ' '; |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3172 | } |
t00fcxen | 32f19d4 | 2012-12-27 00:04:59 +0000 | [diff] [blame] | 3173 | #ifdef _WIN32 |
t00fcxen | ce77eb0 | 2012-12-27 00:22:15 +0000 | [diff] [blame] | 3174 | strncpy_s(dump_buf + pos, strlen(TRAILER) + 1, TRAILER, strlen(TRAILER)); |
t00fcxen | 32f19d4 | 2012-12-27 00:04:59 +0000 | [diff] [blame] | 3175 | #else |
t00fcxen | 95eb2c4 | 2012-12-26 20:22:53 +0000 | [diff] [blame] | 3176 | strcpy(dump_buf + pos, TRAILER); |
t00fcxen | 32f19d4 | 2012-12-27 00:04:59 +0000 | [diff] [blame] | 3177 | #endif |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3178 | pos += strlen(TRAILER); |
t00fcxen | c9b21eb | 2012-12-26 19:33:38 +0000 | [diff] [blame] | 3179 | dump_buf[pos++] = '\0'; |
| 3180 | return (dump_buf); |
t00fcxen | 56c7d1c | 2012-11-25 14:36:23 +0000 | [diff] [blame] | 3181 | } |
| 3182 | |
| 3183 | void |
| 3184 | usrsctp_freedumpbuffer(char *buf) |
| 3185 | { |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3186 | free(buf); |
| 3187 | } |
t00fcxen | 5716b09 | 2012-11-20 16:00:31 +0000 | [diff] [blame] | 3188 | |
tuexen | de2407b | 2012-07-06 20:00:32 +0000 | [diff] [blame] | 3189 | void |
t00fcxen | 9d961e5 | 2012-09-04 17:25:39 +0000 | [diff] [blame] | 3190 | usrsctp_conninput(void *addr, const void *buffer, size_t length, uint8_t ecn_bits) |
tuexen | de2407b | 2012-07-06 20:00:32 +0000 | [diff] [blame] | 3191 | { |
| 3192 | struct sockaddr_conn src, dst; |
| 3193 | struct mbuf *m; |
| 3194 | struct sctphdr *sh; |
| 3195 | struct sctp_chunkhdr *ch; |
t00fcxen | 56c7d1c | 2012-11-25 14:36:23 +0000 | [diff] [blame] | 3196 | |
t00fcxen | 6b5474d | 2013-08-03 13:14:37 +0000 | [diff] [blame] | 3197 | SCTP_STAT_INCR(sctps_recvpackets); |
| 3198 | SCTP_STAT_INCR_COUNTER64(sctps_inpackets); |
tuexen | de2407b | 2012-07-06 20:00:32 +0000 | [diff] [blame] | 3199 | memset(&src, 0, sizeof(struct sockaddr_conn)); |
| 3200 | src.sconn_family = AF_CONN; |
t00fcxen | 7b0ab5c | 2012-09-04 16:41:39 +0000 | [diff] [blame] | 3201 | #ifdef HAVE_SCONN_LEN |
tuexen | de2407b | 2012-07-06 20:00:32 +0000 | [diff] [blame] | 3202 | src.sconn_len = sizeof(struct sockaddr_conn); |
tuexen | de8908a | 2012-07-11 22:12:57 +0000 | [diff] [blame] | 3203 | #endif |
tuexen | de2407b | 2012-07-06 20:00:32 +0000 | [diff] [blame] | 3204 | src.sconn_addr = addr; |
| 3205 | memset(&dst, 0, sizeof(struct sockaddr_conn)); |
tuexen | 9375131 | 2012-07-06 21:51:39 +0000 | [diff] [blame] | 3206 | dst.sconn_family = AF_CONN; |
t00fcxen | 7b0ab5c | 2012-09-04 16:41:39 +0000 | [diff] [blame] | 3207 | #ifdef HAVE_SCONN_LEN |
tuexen | 9375131 | 2012-07-06 21:51:39 +0000 | [diff] [blame] | 3208 | dst.sconn_len = sizeof(struct sockaddr_conn); |
tuexen | de8908a | 2012-07-11 22:12:57 +0000 | [diff] [blame] | 3209 | #endif |
tuexen | 9375131 | 2012-07-06 21:51:39 +0000 | [diff] [blame] | 3210 | dst.sconn_addr = addr; |
t00fcxen | 218d5d0 | 2012-12-10 20:28:19 +0000 | [diff] [blame] | 3211 | if ((m = sctp_get_mbuf_for_msg(length, 1, M_NOWAIT, 0, MT_DATA)) == NULL) { |
tuexen | de2407b | 2012-07-06 20:00:32 +0000 | [diff] [blame] | 3212 | return; |
| 3213 | } |
t00fcxen | e3a4fdd | 2012-09-04 20:39:39 +0000 | [diff] [blame] | 3214 | m_copyback(m, 0, length, (caddr_t)buffer); |
t00fcxen | d6d6990 | 2013-04-08 23:07:02 +0000 | [diff] [blame] | 3215 | if (SCTP_BUF_LEN(m) < (int)(sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr))) { |
tuexen | de2407b | 2012-07-06 20:00:32 +0000 | [diff] [blame] | 3216 | if ((m = m_pullup(m, sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr))) == NULL) { |
| 3217 | SCTP_STAT_INCR(sctps_hdrops); |
| 3218 | return; |
| 3219 | } |
| 3220 | } |
| 3221 | sh = mtod(m, struct sctphdr *);; |
| 3222 | ch = (struct sctp_chunkhdr *)((caddr_t)sh + sizeof(struct sctphdr)); |
| 3223 | src.sconn_port = sh->src_port; |
| 3224 | dst.sconn_port = sh->dest_port; |
| 3225 | sctp_common_input_processing(&m, 0, sizeof(struct sctphdr), length, |
| 3226 | (struct sockaddr *)&src, |
| 3227 | (struct sockaddr *)&dst, |
| 3228 | sh, ch, |
| 3229 | #if !defined(SCTP_WITH_NO_CSUM) |
| 3230 | 1, |
| 3231 | #endif |
| 3232 | ecn_bits, |
| 3233 | SCTP_DEFAULT_VRFID, 0); |
t00fcxen | 7fdfb5e | 2013-11-14 14:13:31 +0000 | [diff] [blame] | 3234 | if (m) { |
| 3235 | sctp_m_freem(m); |
| 3236 | } |
tuexen | de2407b | 2012-07-06 20:00:32 +0000 | [diff] [blame] | 3237 | return; |
| 3238 | } |
| 3239 | |
| 3240 | |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3241 | #define USRSCTP_SYSCTL_SET_DEF(__field) \ |
| 3242 | void usrsctp_sysctl_set_ ## __field(uint32_t value) { \ |
| 3243 | SCTP_BASE_SYSCTL(__field) = value; \ |
| 3244 | } |
| 3245 | |
| 3246 | USRSCTP_SYSCTL_SET_DEF(sctp_sendspace) |
| 3247 | USRSCTP_SYSCTL_SET_DEF(sctp_recvspace) |
| 3248 | USRSCTP_SYSCTL_SET_DEF(sctp_auto_asconf) |
| 3249 | USRSCTP_SYSCTL_SET_DEF(sctp_multiple_asconfs) |
| 3250 | USRSCTP_SYSCTL_SET_DEF(sctp_ecn_enable) |
t00fcxen | a8657c4 | 2014-08-02 22:05:33 +0000 | [diff] [blame] | 3251 | USRSCTP_SYSCTL_SET_DEF(sctp_pr_enable) |
t00fcxen | 0602fd0 | 2014-08-12 13:19:21 +0000 | [diff] [blame] | 3252 | USRSCTP_SYSCTL_SET_DEF(sctp_auth_enable) |
t00fcxen | fb3816e | 2014-08-12 12:51:45 +0000 | [diff] [blame] | 3253 | USRSCTP_SYSCTL_SET_DEF(sctp_asconf_enable) |
t00fcxen | 2344bfc | 2014-08-04 20:41:36 +0000 | [diff] [blame] | 3254 | USRSCTP_SYSCTL_SET_DEF(sctp_reconfig_enable) |
t00fcxen | 44318e9 | 2014-08-03 15:25:02 +0000 | [diff] [blame] | 3255 | USRSCTP_SYSCTL_SET_DEF(sctp_nrsack_enable) |
t00fcxen | 669cffc | 2014-08-03 20:32:08 +0000 | [diff] [blame] | 3256 | USRSCTP_SYSCTL_SET_DEF(sctp_pktdrop_enable) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3257 | USRSCTP_SYSCTL_SET_DEF(sctp_strict_sacks) |
t00fcxen | a84e47f | 2013-10-29 21:06:25 +0000 | [diff] [blame] | 3258 | #if !defined(SCTP_WITH_NO_CSUM) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3259 | USRSCTP_SYSCTL_SET_DEF(sctp_no_csum_on_loopback) |
t00fcxen | a84e47f | 2013-10-29 21:06:25 +0000 | [diff] [blame] | 3260 | #endif |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3261 | USRSCTP_SYSCTL_SET_DEF(sctp_peer_chunk_oh) |
| 3262 | USRSCTP_SYSCTL_SET_DEF(sctp_max_burst_default) |
| 3263 | USRSCTP_SYSCTL_SET_DEF(sctp_max_chunks_on_queue) |
| 3264 | USRSCTP_SYSCTL_SET_DEF(sctp_hashtblsize) |
| 3265 | USRSCTP_SYSCTL_SET_DEF(sctp_pcbtblsize) |
| 3266 | USRSCTP_SYSCTL_SET_DEF(sctp_min_split_point) |
| 3267 | USRSCTP_SYSCTL_SET_DEF(sctp_chunkscale) |
| 3268 | USRSCTP_SYSCTL_SET_DEF(sctp_delayed_sack_time_default) |
| 3269 | USRSCTP_SYSCTL_SET_DEF(sctp_sack_freq_default) |
| 3270 | USRSCTP_SYSCTL_SET_DEF(sctp_system_free_resc_limit) |
| 3271 | USRSCTP_SYSCTL_SET_DEF(sctp_asoc_free_resc_limit) |
| 3272 | USRSCTP_SYSCTL_SET_DEF(sctp_heartbeat_interval_default) |
| 3273 | USRSCTP_SYSCTL_SET_DEF(sctp_pmtu_raise_time_default) |
| 3274 | USRSCTP_SYSCTL_SET_DEF(sctp_shutdown_guard_time_default) |
| 3275 | USRSCTP_SYSCTL_SET_DEF(sctp_secret_lifetime_default) |
| 3276 | USRSCTP_SYSCTL_SET_DEF(sctp_rto_max_default) |
| 3277 | USRSCTP_SYSCTL_SET_DEF(sctp_rto_min_default) |
| 3278 | USRSCTP_SYSCTL_SET_DEF(sctp_rto_initial_default) |
| 3279 | USRSCTP_SYSCTL_SET_DEF(sctp_init_rto_max_default) |
| 3280 | USRSCTP_SYSCTL_SET_DEF(sctp_valid_cookie_life_default) |
| 3281 | USRSCTP_SYSCTL_SET_DEF(sctp_init_rtx_max_default) |
| 3282 | USRSCTP_SYSCTL_SET_DEF(sctp_assoc_rtx_max_default) |
| 3283 | USRSCTP_SYSCTL_SET_DEF(sctp_path_rtx_max_default) |
| 3284 | USRSCTP_SYSCTL_SET_DEF(sctp_add_more_threshold) |
| 3285 | USRSCTP_SYSCTL_SET_DEF(sctp_nr_outgoing_streams_default) |
| 3286 | USRSCTP_SYSCTL_SET_DEF(sctp_cmt_on_off) |
| 3287 | USRSCTP_SYSCTL_SET_DEF(sctp_cmt_use_dac) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3288 | USRSCTP_SYSCTL_SET_DEF(sctp_use_cwnd_based_maxburst) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3289 | USRSCTP_SYSCTL_SET_DEF(sctp_nat_friendly) |
| 3290 | USRSCTP_SYSCTL_SET_DEF(sctp_L2_abc_variable) |
| 3291 | USRSCTP_SYSCTL_SET_DEF(sctp_mbuf_threshold_count) |
| 3292 | USRSCTP_SYSCTL_SET_DEF(sctp_do_drain) |
| 3293 | USRSCTP_SYSCTL_SET_DEF(sctp_hb_maxburst) |
| 3294 | USRSCTP_SYSCTL_SET_DEF(sctp_abort_if_one_2_one_hits_limit) |
| 3295 | USRSCTP_SYSCTL_SET_DEF(sctp_strict_data_order) |
| 3296 | USRSCTP_SYSCTL_SET_DEF(sctp_min_residual) |
| 3297 | USRSCTP_SYSCTL_SET_DEF(sctp_max_retran_chunk) |
| 3298 | USRSCTP_SYSCTL_SET_DEF(sctp_logging_level) |
| 3299 | USRSCTP_SYSCTL_SET_DEF(sctp_default_cc_module) |
| 3300 | USRSCTP_SYSCTL_SET_DEF(sctp_default_frag_interleave) |
| 3301 | USRSCTP_SYSCTL_SET_DEF(sctp_mobility_base) |
| 3302 | USRSCTP_SYSCTL_SET_DEF(sctp_mobility_fasthandoff) |
| 3303 | USRSCTP_SYSCTL_SET_DEF(sctp_inits_include_nat_friendly) |
| 3304 | USRSCTP_SYSCTL_SET_DEF(sctp_udp_tunneling_port) |
| 3305 | USRSCTP_SYSCTL_SET_DEF(sctp_enable_sack_immediately) |
| 3306 | USRSCTP_SYSCTL_SET_DEF(sctp_vtag_time_wait) |
| 3307 | USRSCTP_SYSCTL_SET_DEF(sctp_blackhole) |
t00fcxen | 8f9e45f | 2014-03-16 13:38:54 +0000 | [diff] [blame] | 3308 | USRSCTP_SYSCTL_SET_DEF(sctp_diag_info_code) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3309 | USRSCTP_SYSCTL_SET_DEF(sctp_fr_max_burst_default) |
| 3310 | USRSCTP_SYSCTL_SET_DEF(sctp_path_pf_threshold) |
| 3311 | USRSCTP_SYSCTL_SET_DEF(sctp_default_ss_module) |
| 3312 | USRSCTP_SYSCTL_SET_DEF(sctp_rttvar_bw) |
| 3313 | USRSCTP_SYSCTL_SET_DEF(sctp_rttvar_rtt) |
| 3314 | USRSCTP_SYSCTL_SET_DEF(sctp_rttvar_eqret) |
| 3315 | USRSCTP_SYSCTL_SET_DEF(sctp_steady_step) |
| 3316 | USRSCTP_SYSCTL_SET_DEF(sctp_use_dccc_ecn) |
| 3317 | USRSCTP_SYSCTL_SET_DEF(sctp_buffer_splitting) |
| 3318 | USRSCTP_SYSCTL_SET_DEF(sctp_initial_cwnd) |
| 3319 | #ifdef SCTP_DEBUG |
| 3320 | USRSCTP_SYSCTL_SET_DEF(sctp_debug_on) |
| 3321 | #endif |
| 3322 | |
| 3323 | #define USRSCTP_SYSCTL_GET_DEF(__field) \ |
| 3324 | uint32_t usrsctp_sysctl_get_ ## __field(void) { \ |
| 3325 | return SCTP_BASE_SYSCTL(__field); \ |
| 3326 | } |
| 3327 | |
| 3328 | USRSCTP_SYSCTL_GET_DEF(sctp_sendspace) |
| 3329 | USRSCTP_SYSCTL_GET_DEF(sctp_recvspace) |
| 3330 | USRSCTP_SYSCTL_GET_DEF(sctp_auto_asconf) |
| 3331 | USRSCTP_SYSCTL_GET_DEF(sctp_multiple_asconfs) |
| 3332 | USRSCTP_SYSCTL_GET_DEF(sctp_ecn_enable) |
t00fcxen | a8657c4 | 2014-08-02 22:05:33 +0000 | [diff] [blame] | 3333 | USRSCTP_SYSCTL_GET_DEF(sctp_pr_enable) |
t00fcxen | 0602fd0 | 2014-08-12 13:19:21 +0000 | [diff] [blame] | 3334 | USRSCTP_SYSCTL_GET_DEF(sctp_auth_enable) |
t00fcxen | fb3816e | 2014-08-12 12:51:45 +0000 | [diff] [blame] | 3335 | USRSCTP_SYSCTL_GET_DEF(sctp_asconf_enable) |
t00fcxen | 2344bfc | 2014-08-04 20:41:36 +0000 | [diff] [blame] | 3336 | USRSCTP_SYSCTL_GET_DEF(sctp_reconfig_enable) |
t00fcxen | 44318e9 | 2014-08-03 15:25:02 +0000 | [diff] [blame] | 3337 | USRSCTP_SYSCTL_GET_DEF(sctp_nrsack_enable) |
t00fcxen | 669cffc | 2014-08-03 20:32:08 +0000 | [diff] [blame] | 3338 | USRSCTP_SYSCTL_GET_DEF(sctp_pktdrop_enable) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3339 | USRSCTP_SYSCTL_GET_DEF(sctp_strict_sacks) |
t00fcxen | a84e47f | 2013-10-29 21:06:25 +0000 | [diff] [blame] | 3340 | #if !defined(SCTP_WITH_NO_CSUM) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3341 | USRSCTP_SYSCTL_GET_DEF(sctp_no_csum_on_loopback) |
t00fcxen | a84e47f | 2013-10-29 21:06:25 +0000 | [diff] [blame] | 3342 | #endif |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3343 | USRSCTP_SYSCTL_GET_DEF(sctp_peer_chunk_oh) |
| 3344 | USRSCTP_SYSCTL_GET_DEF(sctp_max_burst_default) |
| 3345 | USRSCTP_SYSCTL_GET_DEF(sctp_max_chunks_on_queue) |
| 3346 | USRSCTP_SYSCTL_GET_DEF(sctp_hashtblsize) |
| 3347 | USRSCTP_SYSCTL_GET_DEF(sctp_pcbtblsize) |
| 3348 | USRSCTP_SYSCTL_GET_DEF(sctp_min_split_point) |
| 3349 | USRSCTP_SYSCTL_GET_DEF(sctp_chunkscale) |
| 3350 | USRSCTP_SYSCTL_GET_DEF(sctp_delayed_sack_time_default) |
| 3351 | USRSCTP_SYSCTL_GET_DEF(sctp_sack_freq_default) |
| 3352 | USRSCTP_SYSCTL_GET_DEF(sctp_system_free_resc_limit) |
| 3353 | USRSCTP_SYSCTL_GET_DEF(sctp_asoc_free_resc_limit) |
| 3354 | USRSCTP_SYSCTL_GET_DEF(sctp_heartbeat_interval_default) |
| 3355 | USRSCTP_SYSCTL_GET_DEF(sctp_pmtu_raise_time_default) |
| 3356 | USRSCTP_SYSCTL_GET_DEF(sctp_shutdown_guard_time_default) |
| 3357 | USRSCTP_SYSCTL_GET_DEF(sctp_secret_lifetime_default) |
| 3358 | USRSCTP_SYSCTL_GET_DEF(sctp_rto_max_default) |
| 3359 | USRSCTP_SYSCTL_GET_DEF(sctp_rto_min_default) |
| 3360 | USRSCTP_SYSCTL_GET_DEF(sctp_rto_initial_default) |
| 3361 | USRSCTP_SYSCTL_GET_DEF(sctp_init_rto_max_default) |
| 3362 | USRSCTP_SYSCTL_GET_DEF(sctp_valid_cookie_life_default) |
| 3363 | USRSCTP_SYSCTL_GET_DEF(sctp_init_rtx_max_default) |
| 3364 | USRSCTP_SYSCTL_GET_DEF(sctp_assoc_rtx_max_default) |
| 3365 | USRSCTP_SYSCTL_GET_DEF(sctp_path_rtx_max_default) |
| 3366 | USRSCTP_SYSCTL_GET_DEF(sctp_add_more_threshold) |
| 3367 | USRSCTP_SYSCTL_GET_DEF(sctp_nr_outgoing_streams_default) |
| 3368 | USRSCTP_SYSCTL_GET_DEF(sctp_cmt_on_off) |
| 3369 | USRSCTP_SYSCTL_GET_DEF(sctp_cmt_use_dac) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3370 | USRSCTP_SYSCTL_GET_DEF(sctp_use_cwnd_based_maxburst) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3371 | USRSCTP_SYSCTL_GET_DEF(sctp_nat_friendly) |
| 3372 | USRSCTP_SYSCTL_GET_DEF(sctp_L2_abc_variable) |
| 3373 | USRSCTP_SYSCTL_GET_DEF(sctp_mbuf_threshold_count) |
| 3374 | USRSCTP_SYSCTL_GET_DEF(sctp_do_drain) |
| 3375 | USRSCTP_SYSCTL_GET_DEF(sctp_hb_maxburst) |
| 3376 | USRSCTP_SYSCTL_GET_DEF(sctp_abort_if_one_2_one_hits_limit) |
| 3377 | USRSCTP_SYSCTL_GET_DEF(sctp_strict_data_order) |
| 3378 | USRSCTP_SYSCTL_GET_DEF(sctp_min_residual) |
| 3379 | USRSCTP_SYSCTL_GET_DEF(sctp_max_retran_chunk) |
| 3380 | USRSCTP_SYSCTL_GET_DEF(sctp_logging_level) |
| 3381 | USRSCTP_SYSCTL_GET_DEF(sctp_default_cc_module) |
| 3382 | USRSCTP_SYSCTL_GET_DEF(sctp_default_frag_interleave) |
| 3383 | USRSCTP_SYSCTL_GET_DEF(sctp_mobility_base) |
| 3384 | USRSCTP_SYSCTL_GET_DEF(sctp_mobility_fasthandoff) |
| 3385 | USRSCTP_SYSCTL_GET_DEF(sctp_inits_include_nat_friendly) |
| 3386 | USRSCTP_SYSCTL_GET_DEF(sctp_udp_tunneling_port) |
| 3387 | USRSCTP_SYSCTL_GET_DEF(sctp_enable_sack_immediately) |
| 3388 | USRSCTP_SYSCTL_GET_DEF(sctp_vtag_time_wait) |
| 3389 | USRSCTP_SYSCTL_GET_DEF(sctp_blackhole) |
t00fcxen | 8f9e45f | 2014-03-16 13:38:54 +0000 | [diff] [blame] | 3390 | USRSCTP_SYSCTL_GET_DEF(sctp_diag_info_code) |
tuexen | a25381b | 2012-05-19 11:36:20 +0000 | [diff] [blame] | 3391 | USRSCTP_SYSCTL_GET_DEF(sctp_fr_max_burst_default) |
| 3392 | USRSCTP_SYSCTL_GET_DEF(sctp_path_pf_threshold) |
| 3393 | USRSCTP_SYSCTL_GET_DEF(sctp_default_ss_module) |
| 3394 | USRSCTP_SYSCTL_GET_DEF(sctp_rttvar_bw) |
| 3395 | USRSCTP_SYSCTL_GET_DEF(sctp_rttvar_rtt) |
| 3396 | USRSCTP_SYSCTL_GET_DEF(sctp_rttvar_eqret) |
| 3397 | USRSCTP_SYSCTL_GET_DEF(sctp_steady_step) |
| 3398 | USRSCTP_SYSCTL_GET_DEF(sctp_use_dccc_ecn) |
| 3399 | USRSCTP_SYSCTL_GET_DEF(sctp_buffer_splitting) |
| 3400 | USRSCTP_SYSCTL_GET_DEF(sctp_initial_cwnd) |
| 3401 | #ifdef SCTP_DEBUG |
| 3402 | USRSCTP_SYSCTL_GET_DEF(sctp_debug_on) |
| 3403 | #endif |
| 3404 | |
t00fcxen | 6b5474d | 2013-08-03 13:14:37 +0000 | [diff] [blame] | 3405 | void usrsctp_get_stat(struct sctpstat *stat) |
| 3406 | { |
| 3407 | *stat = SCTP_BASE_STATS; |
| 3408 | } |